拓扑排序

给定一个包含 n 个节点的有向图 G，我们给出它的节点编号的一种排列，如果满足：对于图 G 中的任意一条有向边 (u, v)(u,v)，u 在排列中都出现在 v 的前面。那么称该排列是图G的拓扑排序。

因此求拓扑排序就涉及到图的遍历问题，我们一般采用深度优先搜索的策略，具体的思路如下：
对于图中的每一个结点，我们假设在搜索的过程中又三种状态，即：

1. 未搜索：还没有搜索到这个结点。

2. 搜索中：我们搜索过这个结点，但是还没有回溯到该结点，集该结点还有相邻的结点没有搜索完成。

3. 已完成：我们搜索过这个结点并且回溯过这个结点，所以该结点已经入栈。

通过上述的三种状态，我们就可以给出使用深度优先搜索得到拓扑排序的算法流程，在每一轮的搜索搜索开始时，我们任取一个「未搜索」的节点开始进行深度优先搜索。

我们将当前搜索的节点 u标记为「搜索中」，遍历该节点的每一个相邻节点 v：

1. 如果 v 为「未搜索」，那么我们开始搜索 v，待搜索完成回溯到 u；

2. 如果 v 为「搜索中」，那么我们就找到了图中的一个环，因此是不存在拓扑排序的；

3. 如果 v 为「已完成」，那么说明 v 已经在栈中了，而 u 还不在栈中，因此 u 无论何时入栈都不会影响到 (u, v)(u,v) 之前的拓扑关系，以及不用进行任何操作。

当 u 的所有相邻节点都为「已完成」时，我们将 u 放入栈中，并将其标记为「已完成」。
整个深度优先搜索的过程结束后，如果我们没有找到图中的环，那么栈中存储这所有的 n 个节点，从栈顶到栈底的顺序即为一种拓扑排序。

具体代码如下所示：

class Solution {
    List<List<Integer>> edges;
    int[] visited;
    boolean valid = true;

    public boolean canFinish(int numCourses, int[][] prerequisites) {
        edges = new ArrayList<List<Integer>>();
        for (int i = 0; i < numCourses; ++i) {
            edges.add(new ArrayList<Integer>());
        }
        visited = new int[numCourses];
        for (int[] info : prerequisites) {
            edges.get(info[1]).add(info[0]);
        }
        for (int i = 0; i < numCourses && valid; ++i) {
            if (visited[i] == 0) {
                dfs(i);
            }
        }
        return valid;
    }

    public void dfs(int u) {
        visited[u] = 1;
        for (int v: edges.get(u)) {
            if (visited[v] == 0) {
                dfs(v);
                if (!valid) {
                    return;
                }
            } else if (visited[v] == 1) {
                valid = false;
                return;
            }
        }
        visited[u] = 2;
    }
}