什么是强连通分量(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;
}
缩点很神奇啊