210. Course Schedule II 【Medium】 拓扑排序

思路：若此图无环，则任意方式DFS这个图，把所有节点以post值从大到小顺序排列，必定得到一个拓扑序列。

证明：首先，有环的图肯定不存在拓扑序列。排除有环的情况。无环即无back edge。

           然后，从书上的定义可知，对于任意的图，只有back edge (u->v) 存在post(u) < post(v) ，

           那么对于这个无环图所有的edge (u->v)， 应该都有post(u) > post(v)。

           那么把所有节点以post值从大到小顺序排列的话，这些节点之间的edge都是从左到右的，那么这个序列必然是一个拓扑排序。

判断无环直接使用 207. Course Schedule 的代码，然后就按照上述思路编程即可。没有难度，一会就打完了。

class Solution {
public:
	typedef struct node {
		int v;
		node* next;
		node(int vv, node* nn = 0) {
			v = vv;
			next = nn;
		} 
	} node;
	node* map[4001] = {0};
	node* tail[4001] = {0};
    int visited[4001][2] = {{0}};
    int clock;
    int n;
    
    void ch(int &a, int &b) {
    	int temp;
    	temp = b;
    	b = a;
    	a = temp;
	}
    
    void explore(int start) {
        visited[start][0] = ++clock;
        for (int i = 0; i < n; ++i) {
            if (start == i) continue;
            if (if_path(start, i) && visited[i][0] == 0) explore(i); 
        }
        visited[start][1] = ++clock;
    }
    
    bool if_path(int x, int y) {
    	node* temp = map[x];
    	while (temp) {
    		if (y == temp->v) return true;
    		temp = temp->next;
		}
		return false;
	}

    bool canFinish(int numCourses, std::vector<pair<int, int> >& prerequisites) {
        // initialize and build map
        n = numCourses;
        clock = 0;
        int fir, sec;
        for (int i = 0; i < prerequisites.size(); ++i) {
        	fir = prerequisites[i].second;
        	sec = prerequisites[i].first;
        	node* temp = new node(sec, 0);
        	
            if (tail[fir]) tail[fir]->next = temp;
            else map[fir] = temp;
            tail[fir] = temp;
        }

        // dfs
        for (int i = 0; i < numCourses; ++i) {
            if (visited[i][0] == 0) explore(i);
        }

        // find if back edge exists
        for (int i = 0; i < numCourses; ++i)
            for (int j = 0; j < numCourses; ++j)
                if (if_path(i, j) && visited[i][0] > visited[j][0] && visited[i][1] < visited[j][1])
                    return false;

        return true;
    }
    
    vector<int> findOrder(int numCourses, vector<pair<int, int> >& prerequisites) {
        if (!canFinish(numCourses, prerequisites)) return vector<int>();
        
    	vector<int> v(numCourses);
        for (int i = 0; i < numCourses; ++i) v[i] = i;
        
        for (int i = 0; i < numCourses - 1; ++i) {
        	for (int j = numCourses - 1; j > i; --j) {
        		if (visited[j][1] > visited[j - 1][1]) {
        			ch(visited[j][1], visited[j - 1][1]);
        			ch(v[j], v[j - 1]);
				}
			}
		}
		return v;
    }
};