标签：uva
时间戳 dfs_clock ：说白了就是记录下访问每个结点的次序。假设我们用 pre 保存，那么如果 pre[u] > pre[v]， 那么就可以知道先访问的 v ，后访问的 u 。
现在给定一条边， (u, v)， 且 u 的祖先为 fa, 如果有 pre[v] < pre[u] && v != fa, 那么 (u, v) 为一条反向边。
1 求连通分量：
相互可达的节点称为一个连通分量；
#include <iostream>
#include <cstdlib>
#include <cstdio>
#include <algorithm>
#include <cstring>
#include <stack>
#include <vector>
#include <queue>
#include <map>
using namespace std;
const int maxn = 1000;
vector<int> G[maxn];
int n;
void init(){
for(int i=0; i<n; i++) G[i].clear();
}
int current_cc;///连通分量的编号
void dfs(int u){
vis[u] = 1;
cc[u] = current_cc;
for(int i = 0; i < G[u].size(); i++){
int v = G[u][i];
if(!vis[v]) dfs(v);
}
}
void find_cc(){
current_cc = 0;
memset(vis,0,sizeof(vis));
for(int u = 0; u < n; u++){
if(!vis[u]){
current_cc ++;
dfs(u);
}
}
}
int main(){
int m, u, v;
scanf("%d%d", &n, &m);
init();
for(int i=0; i<m; i++){
cin>>u>>v;
G[u].push_back(v);
G[v].push_back(u);
}
find_cc();
for(int i = 0; i < n; i++){ ///假设结点是从0开始编号的
printf("结点 %d 属于连通分量 %d\n",i,cc[i]);
}
return 0;
}
#include <iostream>
#include <cstdlib>
#include <cstdio>
#include <algorithm>
#include <cstring>
#include <stack>
#include <vector>
#include <queue>
#include <map>
using namespace std;
const int maxn = 1000;
vector<int> G[maxn];///G用来存图
int pre[maxn], dfs_clock, low[maxn], n;
///dfs_clock是时间戳,pre[]用来保存时间戳，即结点的访问次序
///low[u]表示u及其后代所能连回的最早的祖先的pre[]值
///n是结点的个数
bool iscut[maxn];///判断第i个节点是不是割点
vector< pair<int,int> > bridge;///用来保存桥
void init(){
for(int i=0; i<=n; i++) G[i].clear();
memset(iscut, false, sizeof(iscut));
memset(pre, 0, sizeof(pre));
dfs_clock = 0;
bridge.clear();
}
///时间戳初始化为0
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, 没有必要用vis标记了
child++;
int lowv = dfs(v, u);
lowu = min(lowu, lowv); ///用后代的 low 函数更新 u 的 low 函数
if(lowv >= pre[u]){
iscut[u] = true;
if(lowv > pre[u]){
bridge.push_back(make_pair(u,v));
}
}///割点的性质
}
else if(pre[v] < pre[u] && v != fa){ ///(u,v)为反向边
lowu = min(lowu, pre[v]); ///用反向边更新 u 的 low 函数
}
if(fa < 0 && child == 1) iscut[u] = false;
}
low[u] = lowu;
return lowu;
}
int main(){
int m, u, v;
scanf("%d%d", &n, &m);
init();
for(int i=0; i<m; i++){
cin>>u>>v;
G[u].push_back(v);
G[v].push_back(u);
}
for(int i=0; i<n; i++)if(!pre[i]){
dfs(i, -1);
}
///割点的信息就存在了iscut[]数组中
for(int i=0; i<n; i++){ ///将割点输出
if(iscut[i]) printf("%d ", i);
}
putchar('\n');
for(int i = 0; i < bridge.size(); i++){///将桥输出
printf("%d %d\n",bridge[i].first,bridge[i].second);
}
return 0;
}
样例：
12 12
0 1
0 4
4 8
8 9
4 9
2 3
2 7
2 6
6 7
3 7
10 7
7 11
割顶的bccno无意义：割点的bccno会被多次赋值，所以它的值无意义。
调用结束后， S保证为空：
#include <iostream>
#include <cstdlib>
#include <cstdio>
#include <algorithm>
#include <cstring>
#include <stack>
#include <vector>
#include <queue>
#include <map>
using namespace std;
const int maxn = 1000+10;
int pre[maxn], iscut[maxn], bccno[maxn], dfs_clock, bcc_cnt;
///bccno 是每个节点所属的双连通分量的编号
///bcc_cnt是双连通分量的个数
vector<int> G[maxn], bcc[maxn];
///bcc[]数组记录了每一支双连通分量
struct Edge{
int u, v;
};
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];
Edge e = (Edge){u, v};
if(!pre[v]){
S.push(e);
child++;
int lowv = dfs(v, u);
lowu = min(lowu, lowv);
if(lowv >= pre[u]){
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;
}
if(x.u == u && x.v == v) break;
}
}
}
else if(pre[v] < pre[u] && v != fa){
S.push(e);
lowu = min(lowu, pre[v]);
}
}
if(fa < 0 && child == 1) iscut[u] = 0;
return lowu;
}
void find_bcc(int n){
memset(pre, 0, sizeof(pre));
memset(iscut, 0, sizeof(iscut));
memset(bccno, 0, sizeof(bccno));
dfs_clock = bcc_cnt = 0;
for(int i=0; i<n; i++){
if(!pre[i]) dfs(i, -1);
}
}
int main(){
int m, u, v, n;
scanf("%d%d", &n, &m);
for(int i=0; i<m; i++){
cin>>u>>v;
G[u].push_back(v);
G[v].push_back(u);
}
find_bcc(n);
printf("%d\n", bcc_cnt); ///双连通分量的个数
for(int i=1; i<=bcc_cnt; i++){ ///输出每个双连通分量
for(int j=0; j<bcc[i].size(); j++){
printf("%d ", bcc[i][j]);
}
putchar('\n');
}
return 0;
}
样例：
5 6
0 1
0 2
1 2
2 3
2 4
3 4
#include <iostream>
#include <cstdio>
#include <cstring>
#include <vector>
#include <stack>
using namespace std;
const int maxn = 2000;
int pre[maxn], lowlink[maxn], sccno[maxn], dfs_clock, scc_cnt;
///lowlink[]数组就相当于以往的low[]数组，其他变量类似
vector<int> G[maxn];
stack<int> S;
void dfs(int u){
pre[u] = lowlink[u] = ++dfs_clock;
S.push(u);
for(int i=0; i<G[u].size(); i++){
int v = G[u][i];
if(!pre[v]){
dfs(v);
lowlink[u] = min(lowlink[u], lowlink[v]);
}
else if(!sccno[v]){
lowlink[u] = min(lowlink[u], pre[v]);
}
}
if(lowlink[u] == pre[u]){
scc_cnt++;
for(;;){
int x = S.top(); S.pop();
sccno[x] = scc_cnt;
if(x == u) break;
}
}
}
void find_scc(int n){
///栈始终为空，不用初始化
dfs_clock = scc_cnt = 0;
memset(sccno, 0, sizeof(sccno));
memset(pre, 0, sizeof(pre));
for(int i=0; i<n; i++){
if(!pre[i]) dfs(i);
}
}
int main(){
int n, m, u, v;
scanf("%d%d", &n, &m);
for(int i=0; i<n; i++) G[i].clear();
for(int i=0; i<m; i++){
scanf("%d%d", &u, &v);
G[u].push_back(v);
}
find_scc(n);
///输出所有的强连通分量
for(int i=1; i<=scc_cnt; i++){
for(int j=0; j<n; j++) if(sccno[j] == i) printf("%d ", j);
putchar('\n');
}
return 0;
}
样例：
12 17
连通分量 无向图的割顶和桥 无向图的双连通分量 有向图的强连通分量
标签：uva
原文地址：http://blog.csdn.net/u013382399/article/details/44259341
