【拓扑排序】LeetCode - Course Schedule I、II - 判断有向图中是否有环

LeetCode - 207. Course Schedule

There are a total of n courses you have to take, labeled from 0 to n-1.
Some courses may have prerequisites, for example to take course 0 you have to first take course 1, which is expressed as a pair: [0,1].
Given the total number of courses and a list of prerequisite pairs, is it possible for you to finish all courses?

Example 1: Input: 2, [[1,0]] Output: true
Explanation: There are a total of 2 courses to take. To take course 1 you should have finished course 0. So it is possible.

Example 2: Input: 2, [[1,0],[0,1]] Output: false
Explanation: There are a total of 2 courses to take. To take course 1 you should have finished course 0, and to take course 0 you should also have finished course 1. So it is impossible.

  这道题其实就是判断这个有向图中有没有环，如果存在环，那就会出现 A needs B，B 又 needs A 的情况，就没有办法进行了。
  第一反应是 DFS，设置一个 visited 数组，0 表示还没有访问过，1 表示之前已经访问过了，可以跳过，-1 表示这次 DFS中 才访问过的，如果访问到了 -1 的节点，那就说明有环了。AC代码如下：

bool dfs(const vector<vector<bool>>& needs, int idx, vector<int>& visited) {
	if (visited[idx] ==  1) return true;
	if (visited[idx] == -1) return false;
	visited[idx] = -1;
	for (int i = 0; i < needs.size(); ++i)
		if (needs[idx][i] && !dfs_207(needs, i, visited))
			return false;
	visited[idx] = 1;
	return true;
}

bool canFinish_dfs(int numCourses, const vector<vector<int>>& prerequisites) {
	if (numCourses <= 1) return true;
	vector<vector<bool>> needs(numCourses, vector<bool>(numCourses, false));
	for(const auto& pre : prerequisites)
		needs[pre[0]][pre[1]] = true;

	// 0: 没有访问过, 1: 之前就访问过, -1: 本次dfs访问到
	vector<int> visited(numCourses, 0);
	for (int i = 0; i < numCourses; ++i)
		if (!dfs(needs, i, visited))
			return false;
	return true;
}

  但是这道题应该是要用拓扑排序的。百度上的解释是：

对一个有向无环图 (Directed Acyclic Graph, 简称 DAG) G 进行拓扑排序，是将 G 中所有顶点排成一个线性序列，使得图中任意一对顶点 u 和 v，若边 (u, v) ∈ E(G)，则 u 在线性序列中出现在 v 之前。通常，这样的线性序列称为满足拓扑次序 (Topological Order) 的序列，简称拓扑序列。
简单的说，由某个集合上的一个偏序得到该集合上的一个全序，这个操作称之为拓扑排序。

  就是说，如果一个学生在上“高等数学”之前，需要上“数学基础”，那么“数学基础”就应该在“高等数学”之前，如果 “穿毛衣” 需要先 “穿秋衣”，那么 “穿秋衣” 就在 “穿毛衣” 之前。
  如果有三把钥匙 A, B, C，拿到 A 需要先拿到 B，拿到 B 需要先拿到 C，拿到 C 需要先拿到 A，不就尴尬了= =。
  拓扑排序的核心思想 就是，用一个队列，每次将所有节点中，入度为 0 的放入队列，每次队列弹出一个节点 i，都将这个节点到达的节点的入度减一，如果有新的入度为0的节点，就将其加入队列中。这样循环知道队列为空，如果所有节点都遍历到了，那么就是一个有向无环图，拓扑排序的结果也就知道了（因为可以在遍历过程中用vector记录）。
  值得注意的是，拓扑排序的结果不一定，就好像你可以选择先穿秋裤，再穿秋衣，也可以反过来一样，只需要保证先穿秋裤，再穿的毛裤，先传秋衣，再穿的毛衣就行，Emmm。
  AC代码如下，没有记录排序结果，因为题目不需要：

bool canFinish(int num, vector<vector<int>>& prerequisites) {
    // pre[i] = { ... } 表示 { ... } 都需要 i 这个条件
    unordered_map<int, vector<int>> pre;
    vector<int> ins(num, 0);
    for(const auto& p : prerequisites) {
        pre[p[1]].push_back(p[0]); // p[0] 需要 p[1]
        ++ins[p[0]];
    }
    queue<int> q;
    // 入度为 0 的节点入队
    for(int i = 0; i < num; ++i)
        if(ins[i] == 0)
            q.push(i);
    int cnt = 0;
    while(!q.empty()) {
        auto tp = q.front();
        q.pop();
        ++cnt;
        for(const int& i : pre[tp])
            if(--ins[i] == 0)
                q.push(i);
    }
    return cnt == num;
}

LeetCode - 210. Course Schedule II

  和上边的题的唯一区别就是如果可以，返回任意一种完成方式。代码就改两三行就行：

vector<int> findOrder(int num, vector<vector<int>>& prerequisites) {
    unordered_map<int, vector<int>> pre;
    vector<int> ins(num, 0);
    for(const auto& p : prerequisites) {
        pre[p[1]].push_back(p[0]); // p[0] 需要 p[1]
        ++ins[p[0]];
    }
    queue<int> q;
    // 入度为 0 的节点入队
    for(int i = 0; i < num; ++i)
        if(ins[i] == 0)
            q.push(i);
    vector<int> res;
    while(!q.empty()) {
        auto tp = q.front();
        q.pop();
        res.push_back(tp);
        for(const int& i : pre[tp])
            if(--ins[i] == 0)
                q.push(i);
    }
    return res.size() == num ? res : vector<int>();
}