POJ 1094 拓扑排序-java实现

本身以为是一个简单的拓扑排序，没想到做了挺长时间。题目要求没有明确，所以输出优先级上，需要注意一下。
(不喜欢这道题目，不想去做这道题目)
对于每一次输入后，需要进行判断。输出优先级顺序为：
1.环。如果有环，直接输出有矛盾。
2.不能确定顺序。环的优先级要高于顺序。
3.输出正确结果。

以下是AC的java代码：

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

public class Main {
    static int[] inDegrees;
    static int[] outDegrees;
    static LinkedList<Integer>[] adj;
    static StringBuilder order;
    static boolean hasResult;
    static int n;
    static boolean[] isDescribe;

    public static void main(String[] args) throws Exception {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        StringTokenizer st;
        while (br.ready()) {
            st = new StringTokenizer(br.readLine());
            n = Integer.parseInt(st.nextToken());
            int m = Integer.parseInt(st.nextToken());
            if (n == 0 && m == 0) {
                return;
            }
            inDegrees = new int[n];
            outDegrees = new int[n];
            isDescribe = new boolean[n];
            char[] input;
            adj = new LinkedList[n];
            for (int i = 0; i < n; i++) {
                adj[i] = new LinkedList<Integer>();
            }
            int result = 0;
            hasResult = false;
            for (int i = 1; i <= m; i++) {
                input = br.readLine().toCharArray();
                if (hasResult) {
                    continue;
                }
                outDegrees[input[0] - 'A']++;
                isDescribe[input[0] - 'A'] = true;
                for (int j = 2; j < input.length; j++) {
                    inDegrees[input[j] - 'A']++;
                    isDescribe[input[j] - 'A'] = true;
                    adj[input[0] - 'A'].add(input[j] - 'A');
                }
                result = topoSort();
                if (result == 1) {
                    hasResult = true;
                    System.out.println("Inconsistency found after " + i + " relations.");
                }
                if (result == 3) {
                    hasResult = true;
                    System.out.println("Sorted sequence determined after " + i + " relations: " + order.toString() + ".");
                }
            }
            if (result == 2) {
                System.out.println("Sorted sequence cannot be determined.");
            }
        }

    }

    //return 1 没有入度为0的点,说明有环
    //return 2 入度为0的点有多个,不能确定顺序
    //return 3 可以确定出明确顺序
    private static int topoSort() {

        PriorityQueue<Integer> pq = new PriorityQueue<Integer>();
        for (int i = 0; i < inDegrees.length; i++) {
            if (inDegrees[i] == 0) {
                pq.add(i);
            }
        }
        int current;
        order = new StringBuilder();
        int[] copyDegrees = Arrays.copyOf(inDegrees, inDegrees.length);
        int tempResult = -1;
        while (!pq.isEmpty()) {
            current = pq.poll();
            if (copyDegrees[current] != 0) {
                break;
            }
            if (!pq.isEmpty()) {
                if (copyDegrees[current] == copyDegrees[pq.peek()]) {
                    tempResult = 2;
                }
            }
            order.append((char) (current + 'A'));
            for (int next : adj[current]) {
                copyDegrees[next]--;
                if (copyDegrees[next] == 0) {
                    pq.add(next);
                }
            }
        }

        if (!pq.isEmpty() || order.length() != n) {
            return 1;
        }
        if(tempResult == 2){
            return 2;
        }
        return 3;
    }
}