码迷,mamicode.com
首页 > 其他好文 > 详细

连通分量模板:tarjan: 求割点 && 桥 && 缩点 && 强连通分量 && 双连通分量 && LCA(最近公共祖先)

时间:2014-08-26 21:30:06      阅读:612      评论:0      收藏:0      [点我收藏+]

标签:style   blog   http   color   os   io   strong   for   ar   

PS:摘自一不知名的来自大神。

1.割点:若删掉某点后,原连通图分裂为多个子图,则称该点为割点

2.割点集合:在一个无向连通图中,如果有一个顶点集合,删除这个顶点集合,以及这个集合中所有顶点相关联的边以后,原图变成多个连通块,就称这个点集为割点集合

3.点连通度:最小割点集合中的顶点数。

4.割边():删掉它之后,图必然会分裂为两个或两个以上的子图。

5.割边集合:如果有一个边集合,删除这个边集合以后,原图变成多个连通块,就称这个点集为割边集合

6.边连通度:一个图的边连通度的定义为,最小割边集合中的边数。

7.缩点:把没有割边的连通子图缩为一个点,此时满足任意两点之间都有两条路径可达。

注:求块<>求缩点。缩点后变成一棵k个点k-1条割边连接成的树。而割点可以存在于多个块中。

8.双连通分量:分为点双连通和边双连通。它的标准定义为:点连通度大于1的图称为点双连通图,边连通度大于1的图称为边双连通图。通俗地讲,满足任意两点之间,能通过两条或两条以上没有任何重复边的路到达的图称为双连通图。无向图G的极大双连通子图称为双连通分量


Tarjan算法的应用论述:


1.求强连通分量、割点、桥、缩点:

对于Tarjan算法中,我们得到了dfnlow两个数组,

low[u]:=min(low[u],dfn[v])——(u,v)为后向边,v不是u的子树;

low[u]:=min(low[u],low[v])——(u,v)为树枝边,vu的子树;

下边对其进行讨论:

low[v]>=dfn[u],u为割点,节点v的子孙和节点u形成一个块。因为这说明v的子孙不能够通过其他边到达u的祖先,这样去掉u之后,图必然分裂为两个子图。这样我们处理点u时,首先递归u的子节点v,然后从v回溯至u后,如果发现上述不等式成立,则找到了一个割点u,并且u和v的子树构成一个块。


void tarjan(int x)
{
 v[x]=1,dfn[x]=low[x]=++num;
 for(int i=head[x];i;i=next[i])
  if(!v[ver[i]])
  {
   tarjan(ver[i]);
   low[x]=min(low[x],low[ver[i]]);
   if(dfn[x]<=low[ver[i]]) v[x]++;
  }
  else low[x]=min(low[x],dfn[ver[i]]);
 if((x==1&&v[x]>2)||(x>1&&v[x]>1)) v[x]=2; else v[x]=1;//v[x]=2表示该点为割点,注意其中第一个点要特判
}

low[v]>dfn[u],(u,v)为割边。但是实际处理时我们并不这样判断,因为有的图上可能有重边,这样不好处理。我们记录每条边的标号(一条无向边拆成的两条有向边标号相同),记录每个点的父亲到它的边的标号,如果边(u,v)是v的父亲边,就不能用dfn[u]更新low[v]。这样如果遍历完v的所有子节点后,发现low[v]=dfn[v],说明u的父亲边(u,v)为割边。


void tarjan(int x)
{
 vis[x]=1;
 dfn[x]=low[x]=++num;
 for(int i=head[x];i;i=next[i])
  if(!vis[ver[i]])
  {
   p[ver[i]]=edge[i];//记录父亲边
   tarjan(ver[i]);
   low[x]=min(low[x],low[ver[i]]);
  }
  else if(p[x]!=edge[i])//不是父亲边才更新
   low[x]=min(low[x],dfn[ver[i]]);
 if(p[x]&&low[x]==dfn[x]) f[p[x]]=1;//是割边
}


2.求双连通分量以及构造双连通分量:

对于点双连通分支,实际上在求割点的过程中就能顺便把每个点双连通分支求出。建立一个栈,存储当前双连通分支,在搜索图时,每找到一条树枝边或后向边(非横叉边),就把这条边加入栈中。如果遇到某时满足DFS(u)<=Low(v),说明u是一个割点,同时把边从栈顶一个个取出,直到遇到了边(u,v),取出的这些边与其关联的点,组成一个点双连通分支。割点可以属于多个点双连通分支,其余点和每条边只属于且属于一个点双连通分支。

对于边双连通分支,求法更为简单。只需在求出所有的桥以后,把桥边删除,原图变成了多个连通块,则每个连通块就是一个边双连通分支。桥不属于任何一个边双连通分支,其余的边和每个顶点都属于且只属于一个边双连通分支。

一个有桥的连通图,如何把它通过加边变成边双连通图?方法为首先求出所有的桥,然后删除这些桥边,剩下的每个连通块都是一个双连通子图。把每个双连通子图收缩为一个顶点,再把桥边加回来,最后的这个图一定是一棵树,边连通度为1。

统计出树中度为1的节点的个数,即为叶节点的个数,记为leaf。则至少在树上添加(leaf+1)/2条边,就能使树达到边二连通,所以至少添加的边数就是(leaf+1)/2。具体方法为,首先把两个最近公共祖先最远的两个叶节点之间连接一条边,这样可以把这两个点到祖先的路径上所有点收缩到一起,因为一个形成的环一定是双连通的。然后再找两个最近公共祖先最远的两个叶节点,这样一对一对找完,恰好是(leaf+1)/2次,把所有点收缩到了一起。

3.求最近公共祖先(LCA)

在遍历到u时,先tarjan遍历完u的子树,则u和u的子树中的节点的最近公共祖先就是u,并且u和【u的兄弟节点及其子树】的最近公共祖先就是u的父亲。注意到由于我们是按照DFS顺序遍历的,我们可用一个color数组标记,正在访问的染色为1,未访问的标记为0,已经访问到即在【u的子树中的】及【u的已访问的兄弟节点及其子树中的】染色标记为2,这样我们可以通过并查集的不断合并更新,通过find实现以上目标。

注:用链表存储边和问题,可以使得该算法的时间复杂度降低为O(n+m+q),其中n、m、q分别为点、边、问题数目。本文中为了书写简便,采用的是矩阵的存储方式。

 function find(x:longint):longint;
  begin
    if f[x]<>x then f[x]:=find(f[x]);
    find:=f[x];
  end;
procedure tarjan(u:longint);
  begin
     f[u]:=u; color[u]:=1;
     for i:=1 to n do
     if (g[u,i])and(color[i]=0) then//g[u,i]表示u连着i
        begin
          tarjan(i); f[i]:=u;
        end;
     for i:=1 to n do
     if ((ask[u,i])or(ask[i,u]))and(color[i]=2) then//ask[u,i]表示询问了u,i
       begin
         lca[u,i]:=find(i); lca[i,u]:=lca[u,i];
       end;
     color[u]:=2;
  end;

下面是鹏哥的模板:链接

点双连通分量:

在无向连通图中,如果删除该图的任何一个结点都不能改变该图的连通性,则该图为双连通的无向图。一个连通的无向图是双连通的,当且仅当它没有关键点.

强连通分量:

在有向图G中,如果两个顶点vi,vj间(vi<>vj)有一条从vi到vj的有向路径,同时还有一条从vj到vi的有向路径,则称两个顶点强连通。如果有向图G的每两个顶点都强连通,称G是一个强连通图。非强连通图有向图的极大强连通子图,称为强连通分量。

tarjan算法:

tarjan(u)
{
    DFN[u]=Low[u]=++Index                      // 为节点u设定次序编号和Low初值
    Stack.push(u)                              // 将节点u压入栈中
    for each (u, v) in E                       // 枚举每一条边
        if (v is not visted)               // 如果节点v未被访问过
            tarjan(v)                  // 继续向下找
            Low[u] = min(Low[u], Low[v])
        else if (v in S)                   // 如果节点v还在栈内
            Low[u] = min(Low[u], DFN[v])
    if (DFN[u] == Low[u])                      // 如果节点u是强连通分量的根
        repeat
            v = S.pop                  // 将v退栈,为该强连通分量中一个顶点
            print v
        until (u== v)
}

tarjan算法的本质:

对所有的节点进行dfs,并且在遍历的时候记录搜到这个点的时间,用dfn存储。当y搜索到的某个节点x之前搜索到了,那么

说明从节点x到节点y这一段路程组成一个强连通分量。具体代码实现就是每搜过一个点就把这个点放进栈里,low数组记录这个节

点以及这个节点所在的连通分量中的最小dfn,当low[x]=dfn[x]的时候,说明已经形成了一个连通分量,那么把栈里的节点出栈到x。

tarjan无向图求点双联通:


void tarjan(int x)
{
    int i;
    low[x]=dnf[x]=times++;
    for(i=head[x];i!=-1;i=edge[i].next)
    {
        if(vis[i])continue;
        vis[i]=vis[i^1]=1;
        int y=edge[i].e;
        if(!dnf[y])
        {
            st.push(i);
            tarjan(y);
            low[x]=min(low[x],low[y]);
            if(low[y]>=dnf[x])//这个时候,栈里的点构成一个双连通分量
            {
                while(1)
                {
                    yw=st.top();
                    st.pop();
                    if(edge[yw].u==x)break;
                }
            }
        }
        else if(dnf[y]<dnf[x])
        {
            st.push(i);
            low[x]=min(low[x],dnf[y]);
        }
    }
}

tarjan有向图求强联通分量:


void tarjan(int x)
{
    dnf[x]=low[x]=times++;
    instack[x]=1;
    qq.push(x);
    for(int i=head[x];i!=-1;i=edge[i].next)
    {
        int y=edge[i].v;
        if(!dnf[y])
        {
            tarjan(y);
            low[x]=min(low[x],low[y]);
        }
        else if(instack[y])
        {
            low[x]=min(low[x],dnf[y]);
        }
    }
    if(low[x]==dnf[x])
    {
        int y=-1;
        while(x!=y)
        {
            y=qq.top();
            qq.pop();
            instack[y]=0;
        }
        nums++;
    }
}

tarjan算法求完缩点之后,对于有向图:

如果入度为0的点的个数为a,出度为0的点的个数为b;

那么:最少需要加max(a,b)条边使得原图变成强联通图。




连通分量模板:tarjan: 求割点 && 桥 && 缩点 && 强连通分量 && 双连通分量 && LCA(最近公共祖先)

标签:style   blog   http   color   os   io   strong   for   ar   

原文地址:http://blog.csdn.net/wjw0130/article/details/38853049

(0)
(0)
   
举报
评论 一句话评论(0
登录后才能评论!
© 2014 mamicode.com 版权所有  联系我们:gaon5@hotmail.com
迷上了代码!