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

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

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

2.割点集合：在一个无向连通图中，假设有一个顶点集合，删除这个顶点集合，以及这个集合中全部顶点相关联的边以后。原图变成多个连通块。就称这个点集为割点集合。

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

4.割边(桥)：删掉它之后，图必定会分裂为两个或两个以上的子图。

5.割边集合：假设有一个边集合。删除这个边集合以后，原图变成多个连通块。就称这个点集为割边集合。

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

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

注：求块<>求缩点。

缩点后变成一棵k个点k-1条割边连接成的树。而割点能够存在于多个块中。

8.双连通分量：分为点双连通和边双连通。它的标准定义为：点连通度大于1的图称为点双连通图，边连通度大于1的图称为边双连通图。

通俗地讲，满足随意两点之间，能通过两条或两条以上没有不论什么反复边的路到达的图称为双连通图。无向图G的极大双连通子图称为双连通分量。

Tarjan算法的应用论述：

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

对于Tarjan算法中，我们得到了dfn和low两个数组。

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

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

下边对其进行讨论：

若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)条边使得原图变成强联通图。