连通图的割点割边桥块缩点有向图的强连通分量文档格式.docx
《连通图的割点割边桥块缩点有向图的强连通分量文档格式.docx》由会员分享，可在线阅读，更多相关《连通图的割点割边桥块缩点有向图的强连通分量文档格式.docx（11页珍藏版）》请在冰豆网上搜索。
=dfn[v],说明v的儿子u不能通过其他边到达v的祖先，此时如果拿掉v,则必定把v的祖先和v的儿子u，及它的子孙分开，于是v便是一个割点，v和它的子孙形成一个块。
dfn[v]时，则说明u不仅不能到达v的祖先，连v也不能通过另外一条边直接到达，从而它们之间的边w（v,u）便是割边，求割边的时候有一个重边的问题要视情况处理，如果v,u之间有两条无向边，需要仍视为割边的话，则在DFS的时候加一个变量记录它的父亲,下一步遇到父结点时不扩展回去，从而第二条无向重边不会被遍历而导致low[u]==dfn[v],而在另外一些问题中，比如电线连接两台设备A,B如果它们之间有两根电线，则应该视为是双连通的，因为任何一条电线出问题都不会破坏A和B之间的连通性，这个时候，我们可以用一个used[]数组标记边的id,DFS时会把一条无向边拆成两条有向边进行遍历,但我们给它们俩同一个id号，在开始遍历v->
u前检查它的id是否在上一次u->
v时被标记，这样如果两点之间有多条边时，每次遍历都只标记其中一条，还可以通过其他边回去，形成第二条新的路
求割点的时候，维护一个栈st每遍历到一个顶点v则把它放进去，对它的子孙u如果dfn[u]为0，则表示还没有遍历到则先DFS（u）,之后再判断low[u]和dfn[v]，如果low[u]>
=dfn[v],则把栈中从栈顶到v这一系列元素弹出，这些点与v形成一个块，如果u的子孙x也是一个割点，这样做会不会错把它们和v，u放在一起形成一个块呢，这种情况是不会发生的，如果发现x是一个割点，则DFS到x那一步后栈早就把属于x的子孙弹出来了，而只剩下v,u的子孙，它们之间不存在割点，否则在回溯到v之前也早就提前出栈了！
画一个图照着代码模拟一下可以方便理解。
求割边也是一样的。
有向图强连通分量的算法有两个，一个是Kosaraju,另一个是Tarjan，前者需要两次DFS，代码量偏大但容易理解，后者只需要一次DFS和维护一个栈便可以，实现简单，详见这里>
>
强连通分量KosarajuPKTarjan
2010-04-2216:
23
Kosaraju算法
对每个不在树中的点开始DFS一次，并记录离开各点的时间，这里是离开的时间，而不是到达时的，比如有图1->
22->
3则1,2,3分别对应的时间是321,因为3没有出边，所以最先离开，其次是2,最后是1,
DFS后，在同一棵树中的点，如果dfn[v]>
dfn[u]则说明点从v有可能到达u,而这棵树中的dfn[]最大的点，肯定可以到达每个点，从而在原图的逆图中，每次都选没有访问过的最大的dfn值开始DFS,如果可达点x则说明它们是强连通的
voidDFS_T（intu）
{
inti,v;
if（used[u]）return;
used[u]=1;
id[u]=scc;
for（i=q[u];
i!
=-1;
i=Tedge[i].pre）
{
v=Tedge[i].d;
if（!
used[v]）DFS_T（v）;
}
}
voidDFS（intv）{
inti,u;
if（used[v]）return;
used[v]=1;
for（i=p[v];
i=edge[i].pre）
u=edge[i].d;
used[u]）DFS（u）;
order[++num]=v;
intKosaraju（）
inti,j,k,v,u;
memset（used,0,sizeof（used））;
num=0;
for（i=1;
i<
=n;
++i）if（!
used[i]）DFS（i）;
memset（id,0,sizeof（id））;
scc=0;
for（i=num;
i>
=1;
--i）if（!
used[order[i]]）scc++,DFS_T（order[i]）;
Tarjan算法
dfn[v]记录到达点v的时间，跟上面的离开不同，low[v]表示通过它的子结点可以到达的所有点中时间最小值，即low[i]=min（low[i],low[u]）,u为v的了孙，初始化时low[v]=dfn[u]。
如果low[v]比dfn[v]小，说明v可以通过它的子结点u,u1,u2...到达它的祖先v'
则存在环，这个环上所有的点组成的子图便是一个强连通分量。
换一个角度看，如果当low[v]==dfn[v]时，则它的子树中所有low[u]==dfn[v]的点都与v构成一个环，维护一个栈，DFS过程中，每遍历一个点则把它放入栈中，当发现low[v]==dfn[v]则依次把栈里的元素都弹出来，当栈顶元素为v时结束，这些点便构成一个以v为树根的强连通分量。
仍以上图为例，首先遍历点1,并dfn[1]=low[1]=++num,num表示按先后访问时间编号,同时1入栈
a.从3深入dfn[3]=low[3]=2;
3入栈
b.从3到5dfn[5]=low[5]=3;
5入栈
c.从5到6dfn[6]=low[6]=4;
6入栈
d.发现6没有子结点可走，这时判断dfn[6]==low[6],于是开始弹栈，当遇到6时则break,即共弹出一个元素，于是6便是一个强连通分量
e.回溯至5,同样判断和弹栈，发现5也是一个强连通分量
f.再回溯至3,发现有边3->
4，dfn[4]=low[4]=5,4入栈
g.4有边到1,由于1已经在栈里面，所以用dfn[1]更新low[4]即low[4]=min（low[4],dfn[1]）=1
h.回溯更新4的父亲3的low值low[3]=min（low[3],low[4]）=1
i.再回溯至1,发现有边1->
2继续深度遍历，2入栈,发现它的子结点4已经在栈中，直接更新low[2]=min（low[2],dfn[4]）;
j.回溯至1,从而1所有出发的边都走了一遍，这时再比较low[1]与dfn[1]，发现相等，于是开始弹栈，找到2,4,3,1这四个元素，构成一个连通分量。
voidTarjan（intv）{
dfn[v]=low[v]=++num;
st[++numSt]=v;
for（inti=p[v];
i=edge[i].pre）{
intu（edge[i].d）;
dfn[u]）//还没有标号的点
Tarjan（u）;
//先遍历它的子结点
GetMin（low[v],low[u]）;
//用子结点更新当前点的low值
elseif（used[u]&
&
GetMin（low[v],dfn[u]））;
if（dfn[v]==low[v]）{
scc++;
while
（1）{
intu（st[numSt--]）;
id[u]=scc;
used[u]=0;
if（v==u）break;
intmain（）{
for（inti=1;
dfn[i]）Tarjan（i）;
这里有一个疑问，为什么当发现一个点v的子结点u已经在栈中时用dfn[u]来更新low[v],而不是用low[u],感觉好象两个都可以用，因为只要保证low[v]尽可能变小就行了，
三、代码实现
割点和块
求割点的时候由于不知道最开始选的树根是不是只有一个儿子，这样在DFS过来中不会满足low[u]>
=dfn[v]而判为割点，但有两个或两个以上儿子的根肯定也是一个割点，所以要特判！
voidCutBlock（intv）{
dfn[v]=low[v]=++cnt;
st[++top]=v;
if（dfn[u]==0）{
CutBlock（u）;
if（low[u]>
=dfn[v]）{//V是一个割点
block[0]=0;
while（true）{
block[++block[0]]=st[top];
if（st[top--]==u）//只能弹到u为止，v还可以在其他块中
break;
block[++block[0]]=v;
//割点属于多个块，一定要补进去
Count（block）;
elseGetMin（low[v],dfn[u]）;
割边和缩点
voidCutEdge（intv,intfa）{
if（u==fa）continue;
dfn[u]）{
CutEdge（u,v）;
dfn[v]）{//边v->
u为一条割边
cutE[++numE]=E（v,u）;
//将u及与它形成的连通分量的所有点存起来
++numB;
while
（1）{
id[st[top]]=numB;
if（st[top--]==u）break;
有向图强连通分量
这里需要注意一个地方，上面标记为紫色的那行代码，相比上面两个代码，这里加了一个used[]判断点是否在栈中，为什么前面的不要，而这里需要呢，举个例子
根据dfn可以看出搜索的顺序是1->
2->
5->
6形成一个强连通分量（2,5,6），于是开始退栈,回溯到1从3出发到达4,此时如果直接用dfn[2]更新low[4]的话，会得到low[4]=2,变小后而与dfn[4]不再相等，不能退栈，这与最后的4形成一个单独强连通分量是不符合的，所以，不在栈中的点，不能用来更新当前点的low[]值，为什么无向图不用标记呢，那时因为，边是无向的，有边从4->
2同时也必有边2->
4由于2之前被标记过，而遍历到当前结点4又不是通过w（2,4）这条边过来的，则必还存在另一条路径可以使2和4是相通的，（即图中的4-3-1-2）,从而2,4是双连通的。
其实以上三个算法都源于Tarjan，只是根据dfn[]和low[]判断条件不同而得到不同的结果，无限OrzTrajan！
！
于是，顺便总结一下LCA的离线算法
离线是指把所有的问题都存起来，类似邻接表的形式，能根据点v找到它关的点u,处理完后一次性回答所有的答案。
DFS到v时，用used[]标记为已访问，下面分两部分完成
1、在Q个查询中对所有与v相关连的ui,uj,uk,如果检查发现used[]为真，则说明它们的最近公共祖先为ui当前能往上最大程度找到的祖先，这个可借助并查集实现，记录结果用以后面输出。
2、对v所有子结点u（不同于上面的u）,进行DFS（），DFS结束后，设置u的父亲为v，即fa[u]=v；
时间复杂度为O（m+Q），Q为查询的总数，dist[]记录根到当前点的距离，如果最后要求任意两点v和u之间的距离，则为dist[v]+dist[u]-2*dist[lca（v,u）]
voidLcaTarjan（intv）{
fa[v]=v;
for（inti=q[v];
i=e[i].pre）{//对跟v相关每个问题，尝试进行回答
intu（e[i].d）,id（e[i].id）;
if（used[u]）ans[id]=Find（u）;
intu（edge[i].d）,w（edge[i].w）;
used[u]）{
dist[u]=dist[v]+w;
LcaTarjan（u）;
fa[u]=v;
四、例题
pku1523>
先求割点，第二问其实就是求块，一个割点存在k个块中，删掉后，便形成k个子图
pku2942>
求块后，对每块有：
如果存在奇圈，则可以分开开会，否则全T掉，判断奇圈可以用DFS二分染色的方法，当前点染为白色，它所有相邻点染为黑色，如果最后发现某条边两个端点同色，则存在奇圈。
pku3694>
求割边后，并标记，这时新图形成一棵树，但并不需要缩点，否则反而不好处理，每加一条边w（v,u）进去，必会形成一个圈，剩下的问题但是如何找圈，事先求出v,u的最小公共祖先，加入边w（v,u）后，则这个圈的一部分便是从v到lca（v,u）之间的树边，另一部分是u到lca（v,u）之间的树边，由于一个图中割边的总条数不会超过n，所以可用割边关联的两个顶点中的一个来记录它的位置，这样在沿v或u向lca（v,u）往上找时，快速判断它与它父亲之间相连的边是否为割边，是的话ans--并标记为非，因为w（v,u）的加入形成了环，环中原来所有的割边都会变成非割边。
用fa[v]表示v的父亲，set[v]表示v的祖先，虽然初始都表示v的父亲，但在LCA时要区分使用，一个只记录它的直接父亲，另一个并查集时压缩路径会改变。
pku3352>
pku3177>
求割边，缩点后，形成一棵树，统计度为1的点个数t，需要连的边数则为（t+1）/2,pku3177只是多了重边处理，方法见上。
hdu3394>
求块，如果一个块的顶点数等于边数，则这个块只有一个环，如果边数大于点数，则必有多个环，容易知道在一个K环的块中，每条边也必属于K个环,这样可以计算出在一个环和多个环里的边总数，剩下的便是不在环中的边。
hdu3394Railway无向图求块
2010-06-0222:
07
hdu3394>
求在0个环、1个环、多个环里的边的条数
问题转化为无向图求块，即缩块。
块是不存在割点的连通子图，如果一个块的顶点数等于边数，则这个块只有一个环，如果边数大于点数，则必有多个环，容易知道在一个K环的块中，每条边也必属于K个环,这样可以计算出在一个环和多个环里的边总数，剩下的便是不在环中的边。
#definearr
10010
#definebrr
500010
structEdge{
intd,pre;
Edge（）{}
Edge（intd1,intpre1）:
d（d1）,pre（pre1）{}
}edge[brr];
intp[arr];
intpn;
intdfn[arr];
intlow[arr];
boolused[arr];
intcnt;
intblock[arr];
intn,m;
intnone,one,two;
intst[arr];
inttop;
intfa[arr];
voidInsert（intv,intu）{
edge[++pn]=Edge（u,p[v]）;
p[v]=pn;
edge[++pn]=Edge（v,p[u]）;
p[u]=pn;
voidCount（int*block）{
FF（i,block[0]）used[block[i]]=1;
intsum（0）;
FF（i,block[0]）{
intv（block[i]）;
for（intj=p[v];
j!
j=edge[j].pre）{
intu（edge[j].d）;
if（used[u]）sum++;
}
sum/=2;
if（sum==block[0]）//点和边总数一样多，刚好一个环
one+=sum;
elseif（sum>
block[0]）//边比点多，存在多个环
two+=sum;
elsenone+=sum;
FF（i,block[0]）used[block[i]]=0;
st[top++]=v;
DFS（u）;
=dfn[v]）{
block[++block[0]]=st[top-1];
if（st[--top]==u）
elseif（u!
=fa[v]）GetMin（low[v],dfn[u]）;
voidWork（）{
clr（dfn,0）;
clr（low,0）;
clr（used,0）;
cnt=none=one=two=top=0;
FF（i,n）{
if（dfn[i]==0）DFS（i）;
printf（"
%d%d\n"
none,two）;
intmain（）{
while（scanf（"
%d%d"
&
n,&
m）!
=EOF）{
if（n+m==0）break;
clr（p,-1）;
pn=0;
FF（i,m）{
intv,u;
scanf（"
v,&
u）;
升级会员 