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?

For example:

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

2, [[1,0],[0,1]]
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.

这道题考察的就是拓扑排序，关键是图是怎么存储，怎么判断前驱节点，我在网上看到了一个很不错的做法，可以参考一下。

建议和leetcode 210. Course Schedule II 拓扑排序 + HashSet和leetcode 630. Course Schedule III 课程调度 + 贪心算法 一起学习

需要注意的是，由于这道题更新了测试用例所以原先的代码可能出现问题，情况是这样的，记录后继结点要使用vector，不要使用set，因为假如存在(1,9)和(1,9)多次出现，这样就会出现问题，所以要使用vector

代码如下：

import java.util.ArrayList;
import java.util.Arrays;
import java.util.HashSet;
import java.util.Iterator;
import java.util.LinkedList;
import java.util.List;
import java.util.Queue;
import java.util.Set;

/*
 * 本质就是判断图中是否有环，拓扑排序的应用
 * http://blog.csdn.net/ljiabin/article/details/45846837
 * */
public class Solution 
{
    public boolean canFinish(int numCourses, int[][] prerequisites) 
    {
        if(numCourses<=1 || prerequisites.length<=1)
            return true;

        int []preCount=new int[numCourses];
        List<Set<Integer>> list=new ArrayList<Set<Integer>>();
        Arrays.fill(preCount, 0);
        for(int i=0;i<numCourses;i++)
            list.add(new HashSet<>());

        /*
         * list保存的是出度边，也即后继结点
         * 这里使用是为了避免重复的边
         * perCount保存的说前驱节点的数量
         * */
        for(int i=0;i<prerequisites.length;i++)
        {
            int to=prerequisites[i][0];
            int from=prerequisites[i][1];
            list.get(from).add(to);
            preCount[to]++;
        }

        //使用队列来拓扑排序
        Queue<Integer> queue=new LinkedList<Integer>();
        for(int i=0;i<numCourses;i++)
        {
            if(preCount[i]==0)
                queue.add(i);
        }

        int res=numCourses;
        while(queue.isEmpty()==false)
        {
            int from=queue.poll();
            res--;

            Set<Integer> one=list.get(from);
            Iterator<Integer> iter =one.iterator();
            while(iter.hasNext())
            {
                int to=iter.next();
                preCount[to]--;
                if(preCount[to]==0)
                    queue.add(to);
            }
        }
        //这里通过res来判断是否所有的课程都可以满足
        return res==0?true:false;
    }
}

下面是C++的做法，这是一道十分典型的拓扑排序的问题，看过答案就会发现本题十分的简单

代码如下：

#include <iostream>
#include <vector>
#include <map>
#include <unordered_map>
#include <set>
#include <unordered_set>
#include <queue>
#include <stack>
#include <string>
#include <climits>
#include <algorithm>
#include <sstream>
#include <functional>
#include <bitset>
#include <numeric>
#include <cmath>
#include <regex>

using namespace std;



class Solution
{
public:
    bool canFinish(int numCourses, vector<pair<int, int>>& reque)
    {
        vector<int> preCount(numCourses, 0);
        vector<vector<int>> next(numCourses, vector<int>());
        for (pair<int, int> key : reque)
        {
            int from = key.second;
            int to = key.first;
            next[from].push_back(to);
            preCount[to]++;
        }

        queue<int> que;
        for (int i = 0; i < preCount.size(); i++)
        {
            if (preCount[i] == 0)
                que.push(i);
        }

        int count = numCourses;
        while (que.empty() == false)
        {
            int from = que.front();
            que.pop();
            count--;
            for (int i: next[from])
            {
                preCount[i]--;
                if (preCount[i] == 0)
                    que.push(i);
            }
        }

        return count == 0 ? true : false;
    }
};