记录自己的想法:在有向图中,如果一些顶点中任意两个顶点都能互相到达(间接或直接),那么这些顶点就构成了一个强连通分量,如果一个顶点没有出度,即它不能到达其他任何顶点,那么该顶点自己就是一个强连通分量。在用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;
}