[学习笔记]tarjan原理，割点，桥

tarjan原理

tarjan是图论中常用的算法，用于求图中的强连通分量，割点等

这里先讲强连通分量的做法

强连通分量的定义：

在一个有向图的子图中，任意两个点相互可达，也就是存在互通的路径，那么这个子图就是强连通分量（或者称为强连通分支）。如果一个有向图的任意两个点相互可达，那么这个图就称为强连通图。

tarjan基于dfs。而且每个强连通分量恰好是深搜树的一颗子树。

如果u是某个强连通分量的根，那么：

（1）u不存在路径可以返回到它的祖先

（2）u的子树也不存在路径可以返回到u的祖先。

DFN[i]标记i这个点被访问到的时间

low[i]表示i这个点直接或者间接可以到达的点里面最早被访问到的点的时间(实际上就是同一个强连通分量里的根)

步骤：

从第1个点(u)开始搜索，刚开始要把DFN[u]和low[u]赋值为被访问到的时间， 每次都去遍历这个点关联的边<u,v>：

如果v不在栈里面，继续去递归搜索v，等到回溯以后，就要对low[u]判断，如果u的子树能到达更早的点，那么就把low[u]赋值为low[v[i]]。

如果v已经在栈里面了，此时形成一个环，那么此时对于low[u]的修改就是：

这样很明显，只有强连通分量的根的DFN值和low值是相等的，其他的点都进行过修改，所以如果DFN[i]==low[i],说明我们找到了一个强连通分量的根，要得到这个强连通分量，只要把相应元素出栈就行了。

由于每个点只访问1次，每条边也是1次，所以tarjan算法的时间复杂度是O(n+m)。

代码：

#include<stdio>  
#include<cstring>  
  
const int maxn=10005;  
int DFN[maxn];//记录每个点被访问到的时间  
int low[maxn];//记录点可以直接或间接到达的最早被访问到的点（也就是那个强连通分量的根）  
int stack[maxn];  
int sccnum[maxn];//标记每个点属于第几个强连通分量  
bool instack[maxn];  
int sccNum;//强连通分量的数目  
int top;  
int index;  
int n;  
  
struct node  
{  
    int to;  
    int next;  
}edge[10*maxn];  
int head[maxn];  
int tot;  
  
void addedge(int from,int to)  
{
    edge[tot].to=to;  
    edge[tot].next=head[from];  
    head[from]=tot++;  
}  
 
void tarjan(int i)  
{  
    DFN[i]=low[i]=++index;//刚刚搜到这个点，DFN和low都赋值为被访问到的时间  
    stack[top++]=i;//入栈  
    instack[i]=1;  
    for(int j=head[i];j!=-1;j=edge[j].next)  
    {  
        if(!DFN[edge[j].to])//如果没有被访问过  
        {  
            tarjan(edge[j].to);
            //这个时候low可能要修改,值为i或者i的子树可以到达的最早被访问到的点的时间  
            if(low[i]>low[edge[j].to])  
                low[i]=low[edge[j].to];  
        }  
        else if(instack[edge[j].to])//已经在栈  
        {  
            if(low[i]>DFN[edge[j].to])  
                low[i]=DFN[edge[j].to];  
        }  
    }  
    if(DFN[i]==low[i])//找到根  
    {  
        sccNum++;  
        int v;  
        do  
       {  
            v=stack[--top];  
            sccnum[v]=sccNum;  
            instack[v]=0;//标记出栈  
        }while(v!=i);  
    }  
}  
  
void solve()  
{  
    memset(DFN,0,sizeof(DFN));  
    memset(instack,0,sizeof(instack));  
    index=0;  
    sccNum=0;  
    top=0;  
    for(int i=1;i<=n;i++)  
        if(!DFN[i])  
            tarjan(i);  
}  
  
int main()  
{  
    int m,a,b;  
    while(~scanf("%d%d",&n,&m))  
    {  
        if(n==0 && m==0)  
            break;  
        memset(head,-1,sizeof(head));  
        tot=0;  
        for(int i=0;i<m;i++)  
        {  
            scanf("%d%d",&a,&b);  
            addedge(a,b);  
        }  
        solve();  
        if(sccNum==1)  
            printf("Yes\n");  
        else  
            printf("No\n");  
    }  
    return 0;  
}

基于强联通分量，还可以扩展出一些其他的算法：

1. 割点：

定义：在一张无向图中，如果去掉某个顶点以及和这个顶点相关联的边，使得整个图的连通分支数增  加，那么这个点就是一个割点.

tarjan求割点：

若一个节点为割点，一定满足以下两个条件之一：

    1).u是dfs搜索树的根，并且u含2棵及2棵以上的子树，即不同子树的节点要想联通必须经过u，那么把u删去图中的连通分支一定增加。

    2).u不是dfs搜索树的根，并且有不等式 low[v]>=DFN[u],其中(u,v)是树枝边(即v通过u延伸开去)，因为v一定不会到达时间比u小的点，否则low[v]一定会小于dfn[u]，所以v要达到祖先一定要经过u。

代码：

割点.md

2.桥：

    定义:

     在一张无向图中，如果去掉边(u,v)使得图的连通分支数增加，那么边(u,v)便称为桥.

     类似于割点，只不过是把点变为一条边而已。边(u,v)是无向图的桥当且仅当(u,v)满足 low[v]>DFN[u]，另外要对于u,v间有重边进行特判。

代码：

void tarjan(int u,int root,int fa)    
{    
    DFN[u]=low[u]=++index;    
    instack[u]=1;    
    int cnt=0;    
    for(int i=head[u];i!=-1;i=edge[i].next)    
    {    
        int v=edge[i].to;    
        if(!instack[v])    
        {    
            tarjan(v,root,u);    
            cnt++;    
            if(low[u]>low[v])    
                low[u]=low[v];    
            if(u==root && cnt>1)    
                cut_point[u]=1;    
            else if(u!=root && low[v]>=DFN[u])    
                cut_point[u]=1;    
        }    
        else if(v!=fa && low[u] > DFN[v])    
            low[u]=DFN[v];    
    }

3.双联通分量：

在无向连通图中，如果删除该图的任何一个结点都不能改变该图的连通性，则该图为双连通的无向图。一个连通的无向图是双连通的，当且仅当它没有关键点。换言之，双连通分量里任何2个顶点之间都至少有2条不相交的路径

求法类似于求强联通分量，只不过是在无向图中。

代码：

void tarjan(int u,int fa)  
{  
    instack[u]=1;  
    DFN[u]=low[u]=++index;  
    for(int i=head[u];i!=-1;i=edge[i].next)  
    {  
        int v=edge[i].to;  
        if(fa==edge[i].id)  
            continue;  
        if(!instack[v])  
        {  
            tarjan(v,edge[i].id);  
            low[u]=min(low[u],low[v]);  
        }  
        else  
            low[u]=min(DFN[v],low[u]);  
    }  
}