DFS性质的应用——利用Tarjan算法求割顶、BCC、SCC
整理自《算法竞赛入门经典训练指南》以及网络
DFS (depth first search)深度优先搜索算法
dfs森林：按照dfs的执行顺序，将图的所有边重新梳理，分为四个类别：前向边、反向边、交叉边和树边。在无向图中不存在交叉边，前向边与后向边等价。
low[u]：在DFS过程中，u及其后代能连回的最早祖先的pre值
- 割顶：对于连通图，删除后使图不再连通的点。
- 桥：对于连通图，删除后使图不再连通的边。
计算割顶的方法：在DFS过程中，如果一个点u存在一个子节点v，使得v及其后代都没有反向边连回u的祖先（不包括u），即lowv >= pre[u]，则u是割顶。
计算桥的方法：如果v的后代只能连回v自己（即low(v) > pre(u)）则u-v是桥。
注意：
1.对于已访问点，只处理反向边（条件pre[v] < pre[u]）。
2.对于树根要特判，当只有一个孩子时不是割顶，需手动取消割顶标记。
- 无向图的（点）双连通分量：内部无割顶，即任意两条边都在一个简单环中。
- 无向图的边-双连通分量：所有边都不是桥，即每条边都至少在一个简单环中。
计算BCC的方法：将边入栈，在找到割顶后将这条边以后入栈的边出栈，标记点。
计算edge-BCC的方法：找到桥后再做一次不经过桥的DFS即可。
- 有向图的强连通分量：分量内的点相互可达
计算SCC的方法：将点入栈，DFS过程中记录lowlink，当lowlink(u) == pre(u)时将其中的点出栈标记。
注意：
1.当遇到已访问点时，要忽略已经确定编号的点（条件!sccno[v]）
2.最小值取任意一个都可以（都比树根小)
lowlinku = min(lowlinku, pre[v] OR lowlinkv);
贴上代码
计算BCC
#include <iostream>
#include <stack>
#include <vector>
#include <algorithm>
using namespace std;
const int maxn = 2e4 + 1;
int dfs_clock, pre[maxn], iscut[maxn], bccno[maxn], bcc_count;
struct Edge {
int u, v;
};
vector <int> bcc[maxn], G[maxn];
stack <Edge> S;
void AddE(int u, int v) {
G[u].push_back(v);
}
int tarjan(int u, int fa) {
int lowu = pre[u] = ++dfs_clock, child = 0;
for (auto v: G[u]) {
if (!pre[v]) {
child++;
S.push((Edge) {u, v});
int lowv = tarjan(v, u);
lowu = min(lowu, lowv);
if (lowv >= pre[u]) {
iscut[u] = 1;
++bcc_count;
bcc[bcc_count].clear();
//cout<<dfs_clock<<' '<<u<<'>'<<v<<','<<lowv<<'|'<<bcc_count<<endl;
while (1) {
Edge e = S.top(); S.pop();
if (bccno[e.u] != bcc_count) {
bcc[bcc_count].push_back(e.u);
bccno[e.u] = bcc_count;
}
if (bccno[e.v] != bcc_count) {
bcc[bcc_count].push_back(e.v);
bccno[e.v] = bcc_count;
}
if (e.u == u && e.v == v) break;
}
}
} else if (pre[v] < pre[u] && v != fa) {
S.push((Edge) {u, v});
lowu = min(lowu, pre[v]); //Err
}
}
if (fa == -1 && child == 1) iscut[u] = 0; //Err
return lowu;
}
signed main() {
int n, m, u, v, i;
cin>>n>>m;
while (m--) {
cin>>u>>v;
AddE(u, v);
AddE(v, u);
}
for (i = 1; i <= n; ++i)
if (!pre[i])
tarjan(i, -1);
cout<<count(iscut + 1, iscut + n + 1, 1)<<endl;
for (i = 1; i <= n; ++i)
if (iscut[i])
cout<<i<<' ';
return 0;
}
Tarjan求SCC+缩点+拓扑排序
#include <iostream>
#include <vector>
#include <stack>
using namespace std;
const int maxn = 1e4 + 1;
int n;
int pre[maxn], dfs_clock, sccno[maxn], scc_count;
int c[maxn << 1], topo[maxn << 1], cnt;
vector <int> G[maxn], GA[maxn], scc[maxn];
stack <int> S;
void AddE(int u, int v) {
G[u].push_back(v);
}
void AddED(int u, int v) {
GA[u].push_back(v);
}
int tarjan(int u) {
int lowlinku = pre[u] = ++dfs_clock;
S.push(u);
for (auto x: G[u])
if (!pre[x]) {
int lowlinkv = tarjan(x);
lowlinku = min(lowlinku, lowlinkv);
} else if (!sccno[x])
lowlinku = min(lowlinku, pre[x]);
if (lowlinku == pre[u]) {
++scc_count;
scc[scc_count].clear();
while (1) {
int v = S.top(); S.pop();
scc[scc_count].push_back(v);
sccno[v] = scc_count + n;
if (v == u) break;
}
}
return lowlinku;
}
int dfs(int u) {
static int cnt = n + scc_count;
if (c[u] == -1)
return false;
c[u] = -1;
for (auto v: GA[u])
if (!c[v] && !dfs(v)) return false;
c[u] = 1;
topo[cnt--] = u;
return true;
}
int toposort(int n) {
for (int i = 1; i <= n; ++i)
if (!c[i])
if (!dfs(i))
return false;
return true;
}
void sillys(int n) {
int ans = 0, cnt;
for (int i = n; i > 0; --i)
if (G[topo[i]].empty()) {
ans = topo[i];
cnt++;
}
if (cnt == 0)
cout<<"Fuck"<<endl;
else if (cnt > 1)
cout<<0<<endl;
else if (cnt == 1) {
if (ans <= n)
cout<<1<<endl;
else
cout<<scc[ans - ::n].size()<<endl;
}
return;
}
signed main() {
int m, i, u, v;
cin>>n>>m;
while (m--) {
cin>>u>>v;
AddE(u, v);
}
for (i = 1; i <= n; ++i) {
tarjan(i);
if (sccno[i] == 0)
sccno[i] = i;
}
for (i = 1; i <= n; ++i)
for (int v: G[i])
AddED(sccno[i], sccno[v]);
if (!toposort(n + scc_count))
cout<<"Shit!"<<endl;
sillys(n + scc_count);
return 0;
}
待补充