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.

Note:

The input prerequisites is a graph represented by a list of edges, not adjacency matrices. Read more about how a graph is represented.

题目非常明确的提出了先后拓扑顺序，所以采用拓扑排序来实现。在实现拓扑排序时，需要注意几点：结束的条件是没有包含入度为0的节点了；其次是出现环的时候，如(1, 0)，(0, 1)的时候该及时停止并返回false。小细节注意之后应该就很好实现了。

void GetInOutDegree(vector<pair<int, int>> &edges, vector<int> &Indegree, map<int, set<int>> &outMap, 
        set<int> &zeroIn)
    {
        unsigned len = edges.size();
        pair<int, int> tmpPair;
        for(unsigned i = 0; i < len; ++i)
        {
            tmpPair = edges[i];
            if(outMap[tmpPair.first].count(tmpPair.second))
                continue;
            ++Indegree[tmpPair.second];
            zeroIn.erase(tmpPair.second);
            outMap[tmpPair.first].insert(tmpPair.second);
        }
    }
    
    bool TopSort(int n, vector<int> &Indegree, map<int, set<int>> &outMap, set<int> &zeroIn, 
        set<int> &dealSet)
    {
        typedef set<int>::iterator siterator;
        if(zeroIn.size() == 0)
        {
            if(dealSet.size() == n)  //满足拓扑排序要求
                return true;
            else                      //还有结点没有处理，带有环的情况
                return false;
        }
        
        int tmp = *(zeroIn.begin());
        zeroIn.erase(tmp);
        dealSet.insert(tmp);
        
        set<int> tmpSet = outMap[tmp];
        siterator end = tmpSet.end();
        for(siterator ite = tmpSet.begin(); ite != end; ++ite)
        {
            if(dealSet.count(*ite))  //出现环时
                return false;
            else
            {
                --Indegree[*ite];
                if(Indegree[*ite] < 1)
                    zeroIn.insert(*ite);
            }
        }
        
        return TopSort(n, Indegree, outMap, zeroIn, dealSet);
        
    }
    
    bool canFinish(int numCourses, vector<pair<int, int>>& prerequisites) {
        
        int len = prerequisites.size();
        if(len < 1)
            return true;
        
        if(numCourses < 2)
            return true;
        vector<int> Indegree(numCourses + 5, 0);
        map<int, set<int>> outMap;
        set<int> zeroIn;
        for(int i = 0; i < numCourses; ++i)
            zeroIn.insert(i);
        GetInOutDegree(prerequisites, Indegree, outMap, zeroIn);
        if(zeroIn.size() < 1)
            return false;
        
         set<int> dealSet;
         return TopSort(numCourses, Indegree, outMap, zeroIn, dealSet);
    }