数据结构之图-割点与桥

割点是无向图中去掉后能把图割开的点。dfs时用dfn（u）记录u的访问时间，用low（u）数组记录u和u的子孙能追溯到的最早的节点（dfn值最小）。由于无向图的dfs只有回边和树边，且以第一次dfs时的方向作为边的方向，故有：
low=min{
dfn（u），
dfn（v），若（u，v）为回边（非树边的逆边）
low（v），若（u，v）为树边
}

顶点u是割点当且仅当其满足（1）或者（2）：
（1） 若u是树根，且u的孩子数sons>1。因为没有u后，以这些孩子为根的子树间互相就不连通了，所以去掉u后得到sons个分支。
（2） 若u不是树根，且存在树边（u，v）使 low（v）>=dfn（u）。low值说明以v为根的子树不能到达u的祖先也就是去掉u后不能和原图联通，所以得到{这样的v的个数+1}个分支。

这个题是求无向图（不一定联通）中，去掉一个顶点可以形成的最多的分支数，对所有分支tarjan一下就知道了去掉哪个多了，注意孤立点的情况。求low时其实不用判断树边的逆边的情况，仔细琢磨一下，对结果没有影响，又能省很多代码。

-----------------------------------------------------

何为割点？也就是题目中的关键点。在一个无向图中，去掉一个点，这个无向图会变成多个子图，那么这个点就叫做割点

同理，割边也是如此，如果去掉一条边，能让无向图变成多个子图，那么这条边叫做割边，所谓的桥。

 

那么tarjan是如何求的割点的呢？

如果u为割点，当且仅当满足下面的1/2

1、如果u为树根，那么u必须有多于1棵子树

2、如果u不为树根，那么（u,v）为树枝边，当Low[v]>=DFN[u]时。

 

割点的求法倒是看明白了，条件1的意思是若为根，下面如果只有一颗子树，也就是整个图是强连通，那么去掉根节点，肯定不会变成多个子图，因此也不会成为割点。只有大于一颗子树，去掉根节点，才会有两个或者2个以上的子图，从而才能成为割点

 

条件2也比较好理解，u不为树根，那么u肯定有祖先，如果存在Low【v】>=DFN【u】时，表示u的子孙只能通过u才能访问u的祖先，这也就是说，不通过u，u的子孙无法访问u的祖先，那么如果去掉u这个节点，就会至少分为两个子图，一个是u祖先，一个是u子孙的。

 

但是还是不明白tarjan为何在求Low数组时一个是Min(Low[u], Low[i]); 一个是Min(Low[u], DFN[i]);在上一篇求强连通分量时，如果将Min(Low[u], DFN[i]);也改为Min(Low[u], Low[i]);照样能求出强连通分量，但是如果在求割点的时候改，就会WA。还是想咨询大牛，这个细微的差别到底为什么，到现在还是不懂？看来图论这一块还是没吃透，吃不透，代码就得背，背代码没意思，理解了，怎么写都可以。求神人给出解释哈，谢谢！

 

代码

[cpp]  view plain copy

1. #include <stdio.h>  
2. #include <stdlib.h>  
3. #include <string.h>  
4.   
5. #define nMax 110  
6. #define Min(a,b) (a<b?a:b)  
7. #define Max(a,b) (a>b?a:b)  
8. int map[nMax][nMax];  
9. int DFN[nMax],Low[nMax];  
10. bool isVisted[nMax];  
11. int gPoint[nMax];  
12. int index, root;  
13. int n,ans;  
14. void tarjan(int u)  
15. {  
16.     DFN[u] = Low[u] = ++index;  
17.     isVisted[u] = true;  
18.     for (int i = 1; i <= n; ++ i)  
19.     {  
20.         if (map[u][i])  
21.         {  
22.             if (!isVisted[i])  
23.             {  
24.                 tarjan(i);  
25.                 Low[u] = Min(Low[u], Low[i]);  
26.                 if (Low[i] >= DFN[u] && u != 1)//if it is not root  
27.                 {  
28.                     gPoint[u] ++;  
29.                 }  
30.                 else if (u == 1)//if it is root  
31.                 {  
32.                     root ++;  
33.                 }  
34.             }  
35.             else  
36.             {  
37.                 Low[u] = Min(Low[u], DFN[i]);  
38.             }  
39.         }  
40.     }  
41. }  
42. int main()  
43. {  
44.     while (scanf("%d", &n) && n)  
45.     {  
46.         int u, v;  
47.         memset(map, 0, sizeof(map));  
48.         memset(isVisted, false, sizeof(isVisted));  
49.         memset(gPoint, 0, sizeof(gPoint));  
50.         ans = root = index = 0;  
51.         while (scanf("%d", &u) && u)  
52.         {  
53.             while (getchar() != '\n')  
54.             {  
55.                 scanf("%d", &v);  
56.                 map[u][v] = 1;  
57.                 map[v][u] = 1;  
58.             }  
59.         }  
60.         tarjan(1);  
61.         if (root > 1)  
62.         {  
63.             ans ++;  
64.         }  
65.         for (int i = 2; i <= n; ++ i)  
66.         {  
67.             if (gPoint[i])  
68.             {  
69.                 ans ++;  
70.             }  
71.         }  
72.         printf("%d\n", ans);  
73.     }  
74.     return 0;  
75. }