割點是無向圖中去掉後能把圖割開的點。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。還是想諮詢大牛，這個細微的差別到底為什麼，到現在還是不懂？看來圖論這一塊還是沒吃透，吃不透，程式碼就得背，背程式碼沒意思，理解了，怎麼寫都可以。求神人給出解釋哈，謝謝！

程式碼

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