强连通分量之Korasju 与tarjan两小模版题

Korasaju算法求有向图强连通分支
procedure Strongly_Connected_Components(G);
begin
1.深度优先遍历G，算出每个结点u的结束时间f[u],起点如何选择无所谓。
2.深度优先遍历G的转置图GT， 选择遍历的起点时，按照结点的结束时间从大到小进行。遍历的过程中，一边遍历， 一边给结点做分类标记，每找到一个新的起点，分类标记值就加1。
3. 第2步中产生的标记值相同的结点构成深度优先森林中的一棵树，也即一个强连通分量。
end.

poj2186.
题意比较简单就不写了。
解题思路：
1. 求出所有强连通分量
2. 每个强连通分量缩成一点，则形成一个有向无环图DAG。
3. DAG上面如果有唯一的出度为0的点,则该点能被所有的点可达。那么该点所代表的连通分量上的所有的原图中的点，都能被原图中的所有点可达，则该连通分量的点数，就是答案。
4. DAG上面如果有不止一个出度为0的点，则这些点互相不可达，原问题无解，答案为0。
缩点的时候不一定要构造新图，只要把不同强连通分量的点染不同颜色，然后考察各种颜色的点有没有连到别的颜色的边即可(即其对应的缩点后的DAG图上的点是否有出边）。
ps:
有向无环图中唯一出度为0的点，一定可以由任何点出发均可达.
(由于无环，所以从任何点出发往前走，必然终止于一个出度为0的点)
AC代码：

#include<iostream>
#include<vector>
#include<algorithm>
#include<queue>
#include<stdio.h>
#include<string.h>
using namespace std;
vector<int>G[10001];
vector<int>rG[10002];
vector<int >vs;
bool used[10001];
int cmp[10001],a,b;
int n,m;
void dfs(int v)
{
    used[v]=true;
    for(int i=0; i<G[v].size(); i++)
        if(!used[G[v][i]])
            dfs(G[v][i]);
    vs.push_back(v);
}
void rdfs(int v,int k)
{
    used[v]=true;
    cmp[v]=k;
    for(int i=0; i<rG[v].size(); i++)
        if(!used[rG[v][i]])rdfs(rG[v][i],k);

}
int scc()
{
    memset(used,0,sizeof(used));
    vs.clear();
    for(int i=0; i<n; i++)
        if(!used[i])
            dfs(i);
    memset(used,0,sizeof(used));
    int k=0;
    for(int i=vs.size()-1; i>=0; i--)
        if(!used[vs[i]])
            rdfs(vs[i],k++);
    return k;
}

int  sloved()
{
    int nn=scc();
    int num=0;
    int u;
    for(int i=0; i<n; i++)
        if(cmp[i]==nn-1)
        {
              u=i;
            num++;
        }
        memset(used,0,sizeof(used));
        rdfs(u,0);
        for(int i=0;i<n;i++)
        {
            if(!used[i])
            {
                num=0;
                break;
            }
        }
    return num;
}

int main()
{

    scanf("%d%d",&n,&m);
    for(int i=0; i<m; i++)
    {
        scanf("%d%d",&a,&b);
        G[a-1].push_back(b-1);
        rG[b-1].push_back(a-1);
    }
    printf("%d\n",sloved());

    return 0;
}

poj1236
题目大意:N个学校之间有单向的网络，每个学校得到一套软件后，可以通过单向网络向周边的学校传输，问题1：初始至少需要向多少个学校发放软件，使得网络内所有的学校最终都能得到软件。 2，至少需要添加几条传输线路(边)，使任意向一个学校发放软件后，经过若干次传送，网络内所有的学校最终都能得到软件。
问题可以转化成给定一个有向图，求：
1) 至少要选几个顶点，才能做到从这些顶点出发，可以到达全部顶点
2) 至少要加多少条边，才能使得从任何一个顶点出发，都能到达全部顶点
ps：
有向无环图中所有入度不为0的点，一定可以由某个入度为0的点出发可达。
(由于无环，所以从任何入度不为0的点往回走，必然终止于一个入度为0的点)
AC代码：

#include<iostream>
#include<vector>
#include<algorithm>
#include<queue>
#include<stdio.h>
#include<string.h>
#include<stack>
using namespace std;
vector< vector<int> >G;
stack<int>S;
int low[102],dfn[102],fla[102],inde[102],outde[102],cmp[102];
int in,out,cnt,a,b,time,n;
void tarjan(int s)
{
    dfn[s]=cnt++;
    low[s]=dfn[s];
    fla[s]=1;//栈内标记
    S.push(s);
    for(int i=0; i<G[s].size(); i++)
    {
        int k=G[s][i];
        if(!dfn[k])
        {
            tarjan(k);
            low[s]=min(low[s],low[k]);
        }
        else if(fla[k]&&low[s]>dfn[k])
            low[s]=dfn[k];
    }
    if(low[s]==dfn[s])
    {
        time++;
        int e;
        for(e=S.top(),S.pop(); e!=s; e=S.top(),S.pop())
        {
            cmp[e]=time;
            fla[e]=0;
        }
        cmp[e]=time;
        fla[e]=0;
    }
}
int sloved()
{
    if(time==1)
    {
        in=1;
        return 0;
    }
    for(int i=0; i<=n; i++)
        for(int j=0; j<G[i].size(); j++)
        {
            int   k=G[i][j];
            if(cmp[i]!=cmp[k])
            {
                outde[cmp[i]]++;
                inde[cmp[k]]++;
            }
        }
    for(int i=1; i<=time; i++)
    {
        if(inde[i]==0)
            in++;
        if(outde[i]==0)
            out++;
    }
    return max(in,out);
}
int main()
{

    while(scanf("%d",&n)==1)
    {
        G.clear();
        G.resize(n+1);
        for(int i=1; i<=n; i++)
            while(scanf("%d",&a)&&a)
                if(a!=i)
                    G[i].push_back(a);
        memset(low,0,sizeof(low));
        memset(dfn,0,sizeof(dfn));
        memset(fla,0,sizeof(fla));
        memset(inde,0,sizeof(inde));
        memset(outde,0,sizeof(outde));
        memset(cmp,0,sizeof(cmp));
        cnt=1,time=0,in=0,out=0;
        for(int i=1; i<=n; i++)
            if(!dfn[i])
                tarjan(i);
        int  k=sloved();
        printf("%d\n%d\n",in,k);

    }
    return 0;
}

Korasju 和tarjan复杂度都是O(v+e），但是tarjan更常用一点。