强连通 Tarjan+Kosaraju （HDU1269+hdu3836）

什么是强连通分量(StronglyConnected Component)(或者，被称为强连通子图，Strongly Connected Subgraph)?

首先需要明白的是，强连通分量只可能存在于有向图中，无向图中是不存在强连通分量的，当然，无向图中也有对应物，被称为连通分量(Connected Component)，求解无向图中的连通分量，根据具体要求，可以选择使用并查集或者DFS。

顺便也介绍一下有关“缩点”的概念：

由于强连通分量的特殊性，在一些实际应用中，会将每个强连通分量看成一个点，然后进行处理。这样做主要是为了降低图的复杂度，特别是在强连通分量规模大、数量多的情况中，利用“缩点”能大幅度降低图的复杂度。

缩点后得到的图，必定是DAG。用反正能够很方便的进行证明：因为若图中含有环路，即意味着至少有两个点彼此可达，那么按照强连通分量的定义，这两个点应该属于一个分量中，因而在缩点发生后，会被一个点所代表。由此推导出矛盾。比如，对上图进行缩点处理，最后的结果就是：

Kosaraju

说一下我的理解把，就是正向dfs，反向dfs（为了反向dfs需要建一个反向图）

说说我的见解把

1.dfs1的时候得到每个点最晚的完成时间（那么根一定是最晚完成的点）

2.为了得到这个逆序数必须先搜索再标记，这样初始点也就是根点一定是数组的最后一个

3从数组的后面开始第二遍dfs如果反向图也可以走通则是一个连通分量（记得标记已经走过的点）

算法流程： 

1、从任意一个点开始深搜，得到图的一个最晚完成时间的排序； 
2、求图的反图； 
3、根据第1步得到的排序，从最晚完成的一个点开始搜索并染色； 
4、第三步每一次深搜完成就是一个强连通分量。

给一个HDU1269的模板把

#include <iostream>
#include<stdio.h>
#include<algorithm>
#include<string.h>
#include<queue>
using namespace std;
const int maxn=10010;
int head1[maxn],head2[maxn];
struct Edge
{
    int to,next;
}edge1[maxn*1000],edge2[maxn*1000];
int cnt1=0,cnt2=0;
int flag=0,ans=0;
bool vis1[maxn],vis2[maxn];
int ord[maxn];

void add(int u,int v)
{
   edge1[cnt1].to=v; edge1[cnt1].next=head1[u]; head1[u]=cnt1++;

   edge2[cnt2].to=u; edge2[cnt2].next=head2[v]; head2[v]=cnt2++;
}



void dfs1(int pos)
{
    vis1[pos]=1;
    for(int i=head1[pos];i!=-1;i=edge1[i].next)
    {
        if(!vis1[edge1[i].to]) dfs1(edge1[i].to);
    }
    ord[flag++]=pos;
}

void dfs2(int pos)
{
    vis2[pos]=1;
    for(int i=head2[pos];i!=-1;i=edge2[i].next)
    {
        if(!vis2[edge2[i].to]) dfs2(edge2[i].to);
    }
}

void init()
{
    ans=0; cnt1=cnt2=0;  flag=0;
    memset(vis1,0,sizeof(vis1));
    memset(vis2,0,sizeof(vis2));
    memset(head1,-1,sizeof(head1));
    memset(head2,-1,sizeof(head2));
}

int main()
{

    int n,m;
    while(scanf("%d%d",&n,&m)!=EOF)
    {
        if(n==0&&m==0) break;
        init();
        for(int i=0;i<m;i++)
        {
            int a,b;
            scanf("%d%d",&a,&b);
            add(a,b);
        }
        for(int i=1;i<=n;i++)
        {
            if(!vis1[i]) dfs1(i);
        }
        for(int i=flag-1;i>=0;i--)
        {
            if(!vis2[ord[i]])
            {
                dfs2(ord[i]);
                ans++;
            }
        }
        if(ans==1)  printf("Yes\n");
        else printf("No\n");
    }
    return 0;
}

Tarjan(u) 

Tarjan算法是基于对图深度优先搜索的算法，每个强连通分量为搜索树中的一棵子树。搜索时，把当前搜索树中未处理的节点加入一个堆栈，回溯时可以判断栈顶到栈中的节点是否为一个强连通分量。

定义DFN(u)为节点u搜索的次序编号(时间戳)，Low(u)为u或u的子树能够追溯到的最早的栈中节点的次序号。由定义可以得出，

当DFN(u)=Low(u)时，以u为根的搜索子树上所有节点是一个强连通分量。

伪代码

<span style="font-family:KaiTi_GB2312;">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)  
}</span>  

/*
hdu3836
做天学了kosaraju ，学姐说写着木乱 ，就又学了这个！
这道题是看着题解慢慢学算法的第一个题所以基本上直接抄了
题意：
    n个城市m条边，问做少加几条边使整个图强连通分量为1
思想:
1.跑一边tarjan，算出有多少个连通分量（进行缩点）
2.跑一边，把缩完的点的出入读算出来
3.计算出入度为零的点个数   a（代表入度为0的点） (代表出度为0的点)
4 答案为max（a,b） 当然要特判断一下是否刚开始图就连通
*/
#include <iostream>
#include<queue>
#include<stdio.h>
#include<algorithm>
#include<string.h>
#include<vector>
#include<stack>
using namespace std;
const int maxn=20100;


vector<int> g[maxn];//边
stack<int>  s;//栈
int dfn[maxn],low[maxn],scc[maxn];
//dfn为该点的时间戳，low为该连通分量最小的时间戳，scc记录每个点的连通分量下标
int d_cnt=0,s_cnt=0;//d_cnt（当前时间戳） s_cnt（当前连通分量标号）
int in[maxn],out[maxn];//出入度

void tarjan(int u)
{
    low[u]=dfn[u]=++d_cnt; //初始化 节点
    s.push(u);//压栈
    for(int i=0;i<g[u].size();i++)
    {
       int v=g[u][i];
       if(!dfn[v]) //如果当前点没有被访问过
       {
           tarjan(v);
           low[u]=min(low[u],low[v]);//low的定义
       }
       else if(!scc[v])
       {
           /*
           如果 之前有点已经拓展过v点，但v点还在栈中
           说明v也在此连通分量中
           因为在拓展v点时已经min了low ，现在只需要再min一次 它的时间戳
           （个人理解）
           */
           low[u]=min(low[u],dfn[v]);
       }
    }
    if(dfn[u]==low[u])
    {
        /*如果当前点的时间戳是该连通分量的最小
        说明这个点是起点，也就是树里面的根
        然后以此弹栈直到将当前点弹出栈，
        因为当前点上面的点一定是拓展出来的点，即同一个连通分量
        */
        s_cnt++;
        while(1)
        {
            int x=s.top(); s.pop();
            scc[x]=s_cnt;
            if(x==u) break;
        }
    }
}

void findscc(int n)
{
    //初始化，跑一边找连通分量
    d_cnt=s_cnt=0;
    memset(dfn,0,sizeof(dfn));
    memset(scc,0,sizeof(scc));
    for(int i=1;i<=n;i++)
    {
        if(!dfn[i]) tarjan(i);
    }
}



int main()
{
    int n,m;
    while(scanf("%d%d",&n,&m)!=EOF)
    {
        for(int i=0;i<=n;i++) g[i].clear();
        while(m--)
        {
            int a,b;
            scanf("%d%d",&a,&b);
            g[a].push_back(b);
        }

        findscc(n);
        for(int i=0;i<=n;i++)
        {
            //初始化出入度
            in[i]=out[i]=0;
        }

        for(int i=1;i<=n;i++)
        {
            for(int j=0;j<g[i].size();j++)
            {
                int x=scc[i],y=scc[g[i][j]];
                if(x!=y)
                {
                    out[x]++;
                    in[y]++;
                }
            }
        }
        int a=0,b=0;
        for(int i=1;i<=s_cnt;i++)
        {
           if(!in[i]) a++;
           if(!out[i]) b++;
        }
        printf("%d\n",s_cnt==1?0:max(a,b));
    }
    return 0;
}

缩点很神奇啊