leetcode207

拓扑排序问题。

class Solution {
public:
    bool canFinish(int numCourses, vector<pair<int, int>>& prerequisites) {
        int Hash[10010];//每个节点的入度
        vector<vector<int>> v(numCourses);//用于存储每个节点相邻的边
        stack<int> s;//存放入度为0的节点
    memset(Hash, 0, sizeof(Hash));
    for(int i =0 ; i < prerequisites.size();i++){
        pair<int, int>p = prerequisites[i];
        int x = p.first;
        int y = p.second;
        cout<<"x = "<<x <<"y = "<<y<<endl;
        v[x].push_back(y);
        ++Hash[y];
    }
    for(int i = 0; i < numCourses; i++){
        if(Hash[i] == 0){
            s.push(i);
        }
    }
    while (!s.empty()) {
        int cur = s.top();//找到入度为0的点
        s.pop();
        for(int i = 0; i < prerequisites.size(); i++){
            pair<int, int>p = prerequisites[i];
            int x = p.first;
            int y = p.second;
            if(cur == x){
                for(int j = 0; j < v[cur].size(); j++){
                    --Hash[v[cur][j]];//删除以该点为起点的所有有向边
                    if(Hash[v[cur][j]] == 0)
                        s.push(v[cur][j]);
                }
                break;
            }
        }
    }
    for(int i = 0; i < numCourses; i++){
        if(Hash[i] != 0)
            return false;
    }
    return true;
    }
};

补充一个python的实现：

class Solution:
    #返回True表示有环，返回False表示无环
    def dfs(self,visited,memo,dic,i):
        if visited[i]:
            return True
        if memo[i] == 0:
            return False
        elif memo[i] == 1:
            return True
        for cs in dic[i]:
            visited[i] = True
            bl = self.dfs(visited,memo,dic,cs)
            visited[i] = False
            if bl:
                #当前线路中出现了环，则标记当前课程为1，返回True
                memo[i] = 1
                return True
        ##当前线路，已经找到最早的前置课程，没有出现"环"，则标记为0，表示课程i是可以学习的
        memo[i] = 0
        return False#返回False表示无环，当前课程i，可以完成学习

    def canFinish(self, numCourses: 'int', prerequisites: 'List[List[int]]') -> 'bool':
        dic = {}
        n = len(prerequisites)
        for i in range(numCourses):
            dic[i] = []
        for i in range(n):
            cs = prerequisites[i][0]#当前课程
            pre = prerequisites[i][1]#前置课程
            dic[cs].append(pre)
        visited = [False for _ in range(numCourses)]
        memo = [-1 for _ in range(numCourses)]
        for i in range(numCourses):
            #只要出现过一个有环的线路，则不能符合题目"所有课程都完成"的目标
            if self.dfs(visited,memo,dic,i):
                return False
        return True

算法思路：深度优先遍历，判断图中是否有环。

使用两个标记数组：

visited=True表示当前“线路”上的节点已经被锁定，如果在线路遍历的过程中遇到已经被锁定的节点，那说明遇到了环。

memo表示备忘录(缓存)，默认状态为-1，标记为0表示本节点不存在环，标记为1表示本节点有环，使用备忘录可加速得到查询结果。