POJ_3895 - 图论找最大环

//此题是未使用tarjan算法的递归实现，主要原因为，当某一条边属于两个环时，普通tarjan算法结果不对。
 // 当然此题已有限制，边最多只属于一个环。

import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.util.Arrays;
import java.util.StringTokenizer;

import static java.lang.Integer.parseInt;

//A - 图论找最大环
//POJ 3895
public class A {

    static StringTokenizer st;
    static int N, M, u, v, cnt, ans;
    static Edge[] edges;
    static int[] head, dp;
    static boolean[] visited;

    public static void main(String[] args) throws Exception {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        int T = parseInt(br.readLine());
        for (int i = 0; i < T; i++) {
            st = new StringTokenizer(br.readLine());
            N = parseInt(st.nextToken());
            M = parseInt(st.nextToken());
            initD();

            for (int j = 0; j < M; j++) {
                st = new StringTokenizer(br.readLine());
                u = parseInt(st.nextToken());
                v = parseInt(st.nextToken());
                addEdge(u, v);
                addEdge(v, u);
            }
            for (int k = 1; k <= N; k++) {
                if (!visited[k]) {
                    dfs(k, 1);
                }
            }
            if (ans <= 2) {
                System.out.println(0);
            } else {
                System.out.println(ans);
            }
        }
    }

    private static void initD() {
        edges = new Edge[5000 << 1];
        for (int i = 0; i < edges.length; i++) {
            edges[i] = new Edge();
        }
        head = new int[5000];
        Arrays.fill(head, -1);
        dp = new int[5000];
        cnt = 1;
        ans = 0;
        visited = new boolean[5000];
    }

    private static void dfs(int k, int len) {
        visited[k] = true;
        dp[k] = len;
        for (int i = head[k]; i != -1; i = edges[i].next) {
            int v = edges[i].to;
            if (!visited[v]) {
                dfs(v, len + 1);
            } else {
                ans = Math.max(ans, dp[k] - dp[v] + 1);
            }
        }
    }


    private static void addEdge(int from, int to) {
        edges[cnt] = new Edge(to, head[from]);
        head[from] = cnt++;
    }

    static class Edge {
        int to;
        int next;

        public Edge() {
        }

        public Edge(int to, int next) {
            this.to = to;
            this.next = next;
        }
    }
}