题： poj3895
    求组成的最大环的边数
    最大环 - 图1
    =>最大环是 4 （2-6-5-7-2）
    思路： bfs 或者 dfs 都可以解决
    记录每次访问点的个数， 用arr[] 标记当前点是可能组成的环上的第几个点
    当前点 - 字节点放问点 ，得到的最大值就是最大的环值
    maxAnswer = Math.max(maxAnswer, findNode[a[0]]-findNode[arrlist.get(i)]+1); 

    1. package tuLun;
    3. import java.io.BufferedReader;
    4. import java.io.IOException;
    5. import java.io.InputStreamReader;
    6. import java.util.ArrayList;
    7. import java.util.Arrays;
    8. import java.util.Deque;
    9. import java.util.LinkedList;
    10. import java.util.StringTokenizer;
    12. /**
    13.  * poj3895
    14.  * @author XA-GDD
    15.  *
    16.  */
    17. public class 最大环 {
    18.     static int T,N,M;
    19.     static int[] findNode;
    20.     static int maxAnswer;
    21.     static boolean[] vistNode;
    22.     static ArrayList<ArrayList<Integer>> arrayList;
    23.     public static void main(String[] args) throws IOException {
    24.         BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
    25.         StringTokenizer st = new StringTokenizer(br.readLine());
    26.         T = Integer.parseInt(st.nextToken());
    27.         for (int t = 0; t < T; t++) {
    28.             st = new StringTokenizer(br.readLine());
    29.             N = Integer.parseInt(st.nextToken());  //点数
    30.             M = Integer.parseInt(st.nextToken());  //变数
    32.             findNode = new int[N+1];
    33.             vistNode = new boolean[N+1];
    34.             Arrays.fill(vistNode, false);
    36.             arrayList = new ArrayList<ArrayList<Integer>>();
    37.             for (int i = 0; i <= N; i++) {
    38.                 arrayList.add(new ArrayList<Integer>());
    39.             }
    40.             for (int i = 0; i < M; i++) {
    41.                 st = new StringTokenizer(br.readLine());
    42.                 int a = Integer.parseInt(st.nextToken());
    43.                 int b = Integer.parseInt(st.nextToken());
    44.                 arrayList.get(a).add(b);
    45.                 arrayList.get(b).add(a);
    46.             }
    47.             maxAnswer = 0;
    48.             for (int i = 1; i <= N; i++) {
    49.                 if (!vistNode[i]) {
    50. //                    dfs(i,1);
    51.                     bfs(i,1);
    52.                 }
    53.             }
    54.             if (maxAnswer>2) {
    55.                 System.out.println(maxAnswer);
    56.             }else {
    57.                 System.out.println("0");
    58.             }
    59.         }
    60.     }
    61.     private static void bfs(int vist, int vistNodeNum) {
    62.         Deque<int[]> dq = new LinkedList<int[]>();
    63.         dq.offerLast(new int[] {vist,vistNodeNum});
    64.         findNode[vist] = vistNodeNum;
    65.         while (!dq.isEmpty()) {
    66.             int[] a = dq.pollLast();
    67.             vistNode[a[0]] = true;
    68.             ArrayList<Integer> arrlist = arrayList.get(a[0]);
    69.             for (int i = 0; i < arrlist.size(); i++) {
    70.                 if (!vistNode[arrlist.get(i)]) {
    71.                     dq.offer(new int[] {arrlist.get(i),a[1]+1});
    72.                     findNode[arrlist.get(i)] = a[1]+1;
    73.                 }else {
    74.                     maxAnswer = Math.max(maxAnswer, findNode[a[0]]-findNode[arrlist.get(i)]+1);
    75.                 }
    76.             }
    77.         }
    79.     }
    80.     private static void dfs(int vist, int findNodeNum) {
    81.         findNode[vist] = findNodeNum;
    82.         vistNode[vist] = true;
    83.         ArrayList<Integer> tempList = arrayList.get(vist);
    84.         for (int i = 0; i < tempList.size(); i++) {
    85.             if (!vistNode[tempList.get(i)]) {
    86.                 dfs(tempList.get(i), findNodeNum+1);
    87.             }else {
    88.                 maxAnswer = Math.max(maxAnswer, findNode[vist] - findNode[tempList.get(i)]+1);
    89.             }
    90.         }
    91.     }
    92. }