[图论] 有向图强连通分量 （kosaraju算法，Tarjan算法)

记录自己的想法：在有向图中，如果一些顶点中任意两个顶点都能互相到达（间接或直接）,那么这些顶点就构成了一个强连通分量，如果一个顶点没有出度，即它不能到达其他任何顶点，那么该顶点自己就是一个强连通分量。在用kosaraju算法和Tarjan算法求强连通分量的时候，就是给所有的顶点分组染色，同一种颜色的顶点在同一个强连通分量中，记录有多少种颜色（有多少个强联通分量），每个顶点属于哪种颜色（每个顶点在哪个强连通分量重）。在同一个强连通分量中的所有顶点可以缩为一个顶点，然后根据缩点构造DAG（有向无环图），记录每个顶点的入度和出度。

下面两种算法的模板都是根据POJ 1236经典题目的

一.kosaraju算法比较好的资料：

http://blog.sina.com.cn/s/blog_4dff87120100r58c.html

http://blog.csdn.net/michealtx/article/details/8233814

http://blog.csdn.net/acceptedxukai/article/details/6961171

http://www.cnblogs.com/Fatedayt/archive/2011/09/16/2178890.html      POJ 2186

http://www.xuebuyuan.com/562460.html

http://www.cnblogs.com/luweiseu/archive/2012/07/14/2591370.html

http://blog.csdn.net/dm_vincent/article/details/8554244

模板：

maxn记录最大顶点数，顶点编号1~n,color记录有多少个强连通分量，代码中算出来的color值比实际的强连通分量数大1，所以实际强连通分量的个数为color-1，belong[i]，代表第i个顶点属于第几个强连通分量中，ans[i]代表第i个强连通分量包含的点数.

#include <iostream>
#include <algorithm>
#include <stdio.h>
#include <string.h>
#include <vector>
using namespace std;
const int maxn=102;
vector<int>g[maxn],gre[maxn];//存储正向图和逆图
int ord[maxn];//正向搜索，顶点的编号
bool vis[maxn];
int out[maxn];//转化为DAG以后的每个缩点的出度
int in[maxn];//转化为DAG以后的每个缩点的入度
int belong[maxn];//当前顶点属于哪个集合，相当于染色，当前顶点被染成了什么颜色
int ans[maxn];//每种颜色包括多少顶点,也就是每个强连通分量包含的定点数
int color;//代表不同的颜色,有多少个强连通分量
int no;//正向搜索排序的编号
int n;//顶点数

void dfs1(int u)//从当前u顶点开始DFS
{
    vis[u]=1;
    for(int i=0;i<g[u].size();i++)
    {
        int v=g[u][i];
        if(!vis[v])
            dfs1(v);
    }
    ord[no++]=u;//为每个顶点编号
}

void dfs2(int u)
{
    vis[u]=1;
    belong[u]=color;//当前顶点u被染成了color
    for(int i=0;i<gre[u].size();i++)
    {
        int v=gre[u][i];
        if(!vis[v])
        {
            dfs2(v);
        }
    }
}

void kosaraju()
{
    color=1,no=1;
    memset(in,0,sizeof(vis));
    memset(out,0,sizeof(out));
    memset(vis,0,sizeof(vis));
    for(int i=1;i<=n;i++)
        if(!vis[i])
        dfs1(i);
    memset(vis,0,sizeof(vis));
    for(int i=no-1;i>=1;i--)//编好号以后，从排号最大的开始搜索
    {
        int v=ord[i];
        if(!vis[v])
        {
            dfs2(v);
            color++;
        }
    }

    //构造DAG
    for(int i=1;i<=n;i++)
    {
        for(int j=0;j<g[i].size();j++)
        {
            if(belong[i]==belong[g[i][j]])
                continue;
            out[belong[i]]++;
            in[belong[g[i][j]]]++;
        }
    }

    int  inzero=0,outzero=0;
    for(int i=1;i<color;i++)
    {
        if(!in[i])
            inzero++;
        if(!out[i])
            outzero++;
    }
    if(color==2)
        printf("1\n0\n");
    else
        printf("%d\n%d\n",inzero,max(inzero,outzero));
}

int main()
{
    scanf("%d",&n);
    int to;
    for(int i=1;i<=n;i++)
    {
        while(scanf("%d",&to)&&to)
        {
            g[i].push_back(to);
            gre[to].push_back(i);
        }
    }
    kosaraju();
    return 0;
}

二.Tarjan比较好的资料

https://www.byvoid.com/blog/scc-tarjan/

模板：

顶点编号1~n,强连通分量的个数用scc表示，,belong[i],表示第i个顶点属于第几个强连通分量，num[i]表示第i个强连通分量所包含的顶点个数，num数组的下标为为1~scc

#include <iostream>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <algorithm>
#include <vector>
#include <queue>
#include <stack>
#include <map>
#include <set>
#include <cmath>
#include <time.h>
#include <iomanip>
#include <cctype>
#define ll long long
using namespace std;

/*Tarjan 算法
复杂度O（n+m)*/

const int maxn=110;///点数
const int maxm=100010;///边数

struct Edge
{
    int to,next;
}edge[maxm];///每条边看做一个结构体

int head[maxn],tot;
int low[maxn],dfn[maxn],Stack[maxn],belong[maxn];
///dfn[i]表示搜索时第i个顶点的访问时间，low[i]表示第i个顶点或者其子树中节点的最小访问时间
///Belong[i]表示第i个顶点属于哪一个强连通分量中，数组的值为1~scc，共有scc个强连通分量
int index,top;///index用来搜索时添加顶点访问时间，top栈顶
int scc;///强连通分量的个数
bool instack[maxn];///判断顶点i是否在栈中
int num[maxn];///各个强连通分量包含点的个数，数组编号1~scc
int in[maxn];///转化为DAG以后每个缩点的入度
int out[maxn];///转化为DAG以后每个缩点的出度

void addedge(int u,int v)///增加一条边,由u指向v，邻接表的实现采用头插法
{
    edge[tot].to=v;
    edge[tot].next=head[u];
    head[u]=tot++;
}

void Tarjan(int u)
{
    int v;
    low[u]=dfn[u]=++index;///一开始访问时间等于最小时间
    Stack[top++]=u;///入栈
    instack[u]=true;
    for(int i=head[u];i!=-1;i=edge[i].next)///与u相邻的顶点v，由u指向v
    {
        v=edge[i].to;
        if(!dfn[v])
        {
            Tarjan(v);
            if(low[u]>low[v])
                low[u]=low[v];
        }
        else if(instack[v]&&low[u]>dfn[v])
            low[u]=dfn[v];
    }
    if(low[u]==dfn[u])
    {
        scc++;
        do
        {
            v=Stack[--top];
            instack[v]=false;
            belong[v]=scc;
            num[scc]++;
        }while(v!=u);
    }
}

void init()
{
    tot=0;
    memset(head,-1,sizeof(head));
}

void solve(int n)
{
    memset(dfn,0,sizeof(dfn));
    memset(instack,false,sizeof(instack));
    memset(num,0,sizeof(num));
    index=scc=top=0;
    for(int i=1;i<=n;i++)
        if(!dfn[i])
        Tarjan(i);
}
int n,m;
int main()
{
    scanf("%d",&n);
    init();
    int to;
    for(int i=1;i<=n;i++)
    {
        while(scanf("%d",&to)&&to)
        {
            addedge(i,to);
        }
    }
    solve(n);
    memset(in,0,sizeof(in));
    memset(in,0,sizeof(out));
    ///构造DAG
    for(int i=1;i<=n;i++)
    {
        for(int j=head[i];j!=-1;j=edge[j].next)
        {
            int v=edge[j].to;
            if(belong[i]==belong[v])
                continue;
            out[belong[i]]++;
            in[belong[v]]++;
        }
    }
    int inzero=0,outzero=0;
    for(int i=1;i<=scc;i++)
    {
        if(!in[i])
            inzero++;
        if(!out[i])
            outzero++;
    }
    if(scc==1)
        printf("1\n0\n");
    else
        printf("%d\n%d\n",inzero,max(inzero,outzero));
    return 0;
}