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

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

[图论] 有向图强连通分量 (kosaraju算法,Tarjan算法)_第1张图片


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

[图论] 有向图强连通分量 (kosaraju算法,Tarjan算法)_第2张图片


[图论] 有向图强连通分量 (kosaraju算法,Tarjan算法)_第3张图片



[图论] 有向图强连通分量 (kosaraju算法,Tarjan算法)_第4张图片

[图论] 有向图强连通分量 (kosaraju算法,Tarjan算法)_第5张图片



一.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;
}





你可能感兴趣的:(强连通分量)