Course Schedule/Course Schedule II

题目分析

1. 这两题的问题很相似，于是放在一起做。

2. 第一题可以发现是要判断有向图中是否存在有环。一开始我的思路是用BFS遍历图，然后如果一个点入队两次就说明有环，根据这个思路写了一遍运行之后很快就发现是有问题的，这种做法只可以对无向图找环，但是对于有向图来说是不成立的。一个显然的反例是

 0

 |   \

1 ->2

于是我上网找了一下有向图找环的思路。

3. 一个比较通用的思路是设置一个入度列表，记录每个点的入度，每次某个点入队都把这个点的入度减1。当某个点的入度为0的时候把这个点加入到队列中。这个思路非常类似拓扑排序的做法，只要最后存在某个点的入度不为0说明存在环，很简单又通用。因此直接利用这个做法来进行。

4. 一个问题是这个列表是用边的列表存的，如果用输入的vector<pair<int, int>>检索的效率非常低，因此先转换到unordered_multimap结构中去，就可以直接用range在O(1)的时间复杂度下找到符合的出边。

5. 用3的思路和4的数据结构可以完成题目。

6. Course Schedule II也不复杂，基本上是用了类似Course Schedule I中标记方法完成的拓扑排序，只要记录一下序列就可以了。

	bool canFinish(int numCourses, vector<pair<int, int>>& prerequisites) {
		if (prerequisites.size() == 0) return true;
		unordered_multimap<int, int> pre_map(prerequisites.begin(), prerequisites.end());
		vector<int> found(numCourses, 0);
		for (int i = 0; i < prerequisites.size(); i++)
			found[prerequisites[i].second]++;
		queue<int> workingQueue;
		for (int i = 0; i < found.size(); i++)
			if (found[i] == 0) workingQueue.push(i);
		while (!workingQueue.empty()) {
			int current = workingQueue.front();
			workingQueue.pop();
			auto range = pre_map.equal_range(current);
			for (auto x = range.first; x != range.second; x++) {
				found[x->second]--;
				if (!found[x->second]) workingQueue.push(x->second);
			}
		}
		if (count(found.begin(), found.end(), 0) != numCourses) return false;
		else return true;
	}

class Solution {
public:
    vector<int> findOrder(int numCourses, vector<pair<int, int>>& prerequisites) {
        vector<int> order;
        vector<int> in(numCourses, 0);
        vector<bool> zero(numCourses, false);
        unordered_map<int, vector<int> > map;
        for(int i = 0; i < prerequisites.size(); i ++)
        {
            in[prerequisites[i].first] ++;
            map[prerequisites[i].second].push_back(prerequisites[i].first);
        }
        int count = 0;
        while(count < numCourses)
        {
            int i;
            for(i = 0; i < numCourses; i ++)
            {
                if(in[i] == 0 && zero[i] == false)
                    break;
            }
            if(i < numCourses)
            {
                zero[i] = true;
                order.push_back(i);
                for(int j = 0; j < map[i].size(); j ++)
                {
                    in[map[i][j]] --;
                }
                count ++;
            }
            else
            {
                vector<int> noorder;
                return noorder;
            }
        }
        return order;
    }
};