版权声明：本博客主要用于记录思考过程，方便复习，欢迎留言交流讨论~ https://blog.csdn.net/Floraqiu/article/details/82023985
强连通分量
1
无向图 双联通分量
1
关于tarjan算法，一直有一个很大的争议，就是low[u]=min(low[u],dfn[v]);
这句话，如果改成low[u]=min(low[u],low[v])就会wa掉，但是在求强连通分量时却没有问题
根据许多大佬的观点，我想提出自己的一点看法，在求强连通分量时，如果v已经在栈中，那么说明u，v一定在同一个强连通分量中，所以到最后low[u]=low[v]是必然的，提前更新也不会有问题，但是在求割点时，low的定义有了小小的变化，不再是最早能追溯到的祖先，（因为是个无向图）没有意义，应该是最早能绕到的割点，为什么用绕到，是因为是无向边，所以有另一条路可以走，如果把dfn[v]改掉就会上翻过头，可能翻进另一个环中，所以wa掉，仅是本人的一些个人看法，不知道讲的对不对，请各位指教
做了的例题
POJ 1523
luogu P3388 【模板】割点（割顶）
POJ 3694（就是WA？？？先放着）
无向图 割顶 桥
#include <iostream>
#include <stdio.h>
#include <string.h>
#include <algorithm>
#include <math.h>
#include <vector>
#include <queue>
#include <set>
#include <map>
#include <list>
#define clr(x, y) memset(x, y, sizeof(x))
#define MOD 1000000000+7
#define INF 0x3f3f3f3f
using namespace std;
const int maxn = 1000;
int n, m;
vector<int> G[maxn];
int pre[maxn], low[maxn];//pre是dfs时间序列, low是该节点及其子孙能够连回最早的祖先的dfs值
int dfs_clock; //时间戳
int iscut[maxn];//标记是否为割顶
int dfs(int u, int fa)//u在dfs树中的父节点是fa
{
int lowu = pre[u] = ++dfs_clock;
int child = 0;//子节点数目
for(int i = 0; i < G[u].size(); ++i)
{
int v = G[u][i];
if(!pre[v]) // 没有访问过v
{
++child;
int lowv = dfs(v, u);
lowu = min(lowu, lowv);
if(lowv >= pre[u]) iscut[u] = 1; // u是割顶
if(lowv > pre[u]) cout << "桥 ： " << u << " -> " << v << endl; // u -> v是桥
}
else if(pre[v] < pre[u] && v != fa)//用反向边更新u的low函数
lowu = min(lowu, pre[v]);
}
if(fa < 0 && child == 1) iscut[u] = 0;//对根节点的处理
low[u] = lowu;
return lowu;
}
int main()
{
while(~scanf("%d%d", &n, &m))
{
clr(pre, 0);
clr(cut, 0);
for(int i = 1; i <= n; ++i)
G[i].clear();
int u, v;
for(int i = 1; i <= m; ++i)
{
scanf("%d%d", &u, &v);
G[u].push_back(v);
G[v].push_back(u);
}
dfs(1, -1);//对于根节点的fa，要初始化为-1
for(int i = 1; i <= n; ++i)//打印割顶
if(iscut[i]) cout<<i<<endl;
}
return 0;
}
点双联通分量
#include <iostream>
#include <stdio.h>
#include <string.h>
#include <algorithm>
#include <math.h>
#include <vector>
#include <queue>
#include <set>
#include <stack>
#include <map>
#include <list>
#define clr(x, y) memset(x, y, sizeof(x))
#define MOD 1000000000+7
#define INF 0x3f3f3f3f
using namespace std;
const int maxn = 1000;
int pre[maxn], bccno[maxn], dfs_clock, bcc_cnt;
bool iscut[maxn];
vector<int> G[maxn], bcc[maxn];
struct Edge
{
int u, v;
Edge(int uu, int vv): u(uu), v(vv) {};
};
stack<Edge> S;
int dfs(int u, int fa)
{
int lowu = pre[u] = ++dfs_clock;
int child = 0;
for(int i = 0; i < G[u].size(); ++i)
{
int v = G[u][i];
if(!pre[v])
{
++child;
S.push(Edge(u, v));
int lowv = dfs(v, u);
lowu = min(lowu, lowv);
if(lowv >= pre[u])//割顶，有BCC
{
iscut[u] = true;
++bcc_cnt;
bcc[bcc_cnt].clear();
for( ; ; )
{
Edge x = S.top();
S.pop();
if(bccno[x.u] != bcc_cnt)
{
bcc[bcc_cnt].push_back(x.u);
bccno[x.u] = bcc_cnt;
}
if(bccno[x.v] != bcc_cnt)
{
bcc[bcc_cnt].push_back(x.v);
bccno[x.v] = bcc_cnt;
}
}
}
}
else if(pre[v] < pre[u] && v != fa)
{
S.push(Edge(u, v));
lowu = min(lowu, pre[v]);
}
}
if(fa < 0 && child == 1)
iscut[u] = false;
return lowu;
}
void find_bcc(int n)
{
clr(pre, 0);
clr(iscut, false);
clr(bccno, 0);
dfs_clock = bcc_cnt = 0;
for(int i = 1; i <= n; ++i)
if(!pre[i]) dfs(i, -1);
}
void print_bcc()
{
for(int i = 1; i <= bcc_cnt; ++i)
{
for(int j = 0; j < bcc[i].size(); ++j)
printf("%d ", bcc[i][j]);
printf("\n");
}
}边双联通分量
#include <iostream>
#include <stdio.h>
#include <string.h>
#include <algorithm>
#include <math.h>
#include <vector>
#include <queue>
#include <set>
#include <stack>
#include <map>
#include <list>
#define clr(x, y) memset(x, y, sizeof(x))
#define MOD 1000000000+7
#define INF 0x3f3f3f3f
using namespace std;
const int maxn = 1000;
int pre[maxn], bccno[maxn], head[maxn];
int dfs_clock, ebc_cnt, tot;
bool isbridge[maxn];//标记编号为i的边是否为桥
vector<int> ebc[maxn];
struct Edge
{
int no, v, next;
}edge[maxn];
void init()
{
clr(head, -1);
tot = 0;
}
void addEdge(int no, int u, int v)
{
edge[tot].no = no;//记录边的编号，和tot不一样
edge[tot].v = v;
edge[tot].next = head[u];
head[u] = tot++;
}
void dfs_bridge(int u, int fa)//找出所有桥
{
int lowu = pre[u] = ++dfs_clock;
for(int i = head[u]; i != -1; i = edge[i].next)
{
int v = edge[i].v;
if(!pre[v])
{
int lowv = dfs_bridge(v, u);
lowu = min(lowu, lowv);
if(lowv > pre[u])
isbridge[edge[i].no] = true;
}
else if(pre[v] < pre[u] && v != fa)
lowu = min(lowu, pre[v]);
}
return lowu;
}
void dfs_countbridge(int u, int fa)
{
ebc[ebc_cnt].push_back(u);
pre[u] = ++dfs_clock;
for(int i = head[u]; i != -1; i = edge[i].next)
{
int v = edge[i].v;
if(!isbridge[edge[i].no] && !pre[v])//除去桥和已经访问过的点
dfs_countbridge(v, u);
}
}
void find_ebc()
{
clr(pre, 0);
clr(isbridge, false);
dfs_clock = ebc_cnt = 0;
for(int i = 1; i <= n; ++i)
if(!pre[i]) dfs_bridge(i, -1);
clr(pre, 0);
dfs_clock = 0;
for(int i = 1; i <= n; ++i)
{
if(!pre[i])
{
++ebc_cnt;
ebc[ebc_cnt].clear();
dfs_countbridge(i, -1);
}
}
}
void print_ebc()
{
for(int i = 1; i <= ebc_cnt; ++i)
{
for(int j = 0; j < ebc[i].size(); ++j)
printf("%d ", ebc[i][j]);
printf("\n");
}
}
int main()
{
for(int i = 1; i <= m; ++i)
{
scanf("%d%d", &u, &v);
addEdge(i, u, v);
addEdge(i, v, u);
}
}