tarjan算法-无向图割边

无向图中，u是v的父节点

low(v)的值表示v通过u以为可以访问的最大祖先节点的时间戳

low(v)>=dfn(u) 表示:v访问祖先节点必须通过v-u（不包括u），不存在其他路。(割点)

low(v)>dfn(u)表示:v访问祖先节点必须通过v-u（包括u）。（割边）

low(v)==dfn(u)表示:v可以不通过u回到u,即不从v-u这条边走到u，但必须从u访问祖先节点。

low(v)<dfn(u)表示:v可以不通过u访问祖先节点（包括u）。

 因为是无向图。若连通，跑一次即可。若非连通，需要多次跑

const int N=1e5+10;
struct ac{
    int u,v;
}edge[N];
int tot,now;
int dfn[N],low[N];
vector<int> g[N];
void tarjan(int u,int fa){
    dfn[u]=low[u]=++now;
    for(int i=0;i<g[u].size();i++){
        int v=g[u][i];
        if(dfn[v]!=0&&v!=fa){
            low[u]=min(low[u],dfn[v]);    
        }
        else if(dfn[v]==0){
            tarjan(v,u);
            low[u]=min(low[u],low[v]);
            if(dfn[u]<low[v]){
                if(u<v){
                    edge[tot].u=u;
                    edge[tot++].v=v;
                }
                else {
                    edge[tot].u=v;
                    edge[tot++].v=u;
                }
            }
        }
    }
}

struct ac{
    int u,v;
    ac(int _u,int _v){
        u=_u,v=_v;
    }
};
vector<ac> edges;
int tot,now;
int dfn[N],low[N];
vector<int> g[N];
void tarjan(int u,int fa){
    dfn[u]=low[u]=++now;
    for(int i=0;i<g[u].size();i++){
        int v=g[u][i];
        if(dfn[v]!=0&&v!=fa){
            low[u]=min(low[u],dfn[v]);    
        }
        else if(dfn[v]==0){
            tarjan(v,u);
            low[u]=min(low[u],low[v]);
            if(dfn[u]<low[v]){
                if(u<v){
                    edges.push_back(ac(u,v));
                }
                else {
                    edges.push_back(ac(v,u));
                }
            
            }
        }
    }
}

例题

Sample Input

8

0 (1) 1

1 (3) 2 0 3

2 (2) 1 3

3 (3) 1 2 4

4 (1) 3

7 (1) 6

6 (1) 7

5 (0)

0

Sample Output

3 critical links

0 - 1

3 - 4

6 - 7

0 critical links

　　　　

q求割边个数

#include<iostream>
#include<stdio.h>
#include<string.h>
#include<vector>
#include<algorithm>
using namespace std;
const int N=1e5+10;
struct ac{
    int u,v;
}edge[N];
int tot,now;
int dfn[N],low[N];
vector<int> g[N];
void tarjan(int u,int fa){
    dfn[u]=low[u]=++now;
    for(int i=0;i<g[u].size();i++){
        int v=g[u][i];
        if(dfn[v]!=0&&v!=fa){
            low[u]=min(low[u],dfn[v]);    
        }
        else if(dfn[v]==0){
            tarjan(v,u);
            low[u]=min(low[u],low[v]);
            if(dfn[u]<low[v]){
                if(u<v){
                    edge[tot].u=u;
                    edge[tot++].v=v;
                }
                else {
                    edge[tot].u=v;
                    edge[tot++].v=u;
                }
            }
        }
    }
}
void init(){
    memset(dfn,0,sizeof(dfn));
    memset(low,0,sizeof(low));
    tot=now=0;
    for(int i=0;i<N;i++){
        edge[i].u=edge[i].v=0;
        g[i].clear();
    }
}
bool cmp(ac a1,ac a2){
    if(a1.u==a2.u) return a1.v<a2.v;
    else return a1.u<a2.u;
}
int main(){
    int n,m,mn,t;
    while(scanf("%d",&n)!=EOF){
        init();
        for(int i=0;i<n;i++){
            scanf("%d (%d)",&m,&mn);
            for(int j=0;j<mn;j++){
                scanf("%d",&t);
                g[m].push_back(t);
            }
        }
        for(int i=0;i<n;i++) 
            if(dfn[i]==0)
                tarjan(i,-1);
        sort(edge,edge+tot,cmp);
        printf("%d critical links\n",tot);
        for(int i=0;i<tot;i++){
            printf("%d - %d\n",edge[i].u,edge[i].v);
        }
        cout<<endl;
    }
}

 

 

 

转载于:https://www.cnblogs.com/jjl0229/p/11310554.html