leetcode207

拓扑排序问题。

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

补充一个python的实现：

 class Solution:
     #返回True表示有环，返回False表示无环
     def dfs(self,visited,memo,dic,i):
         if visited[i]:
             return True
         if memo[i] == :
             return False
         elif memo[i] == :
             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] =
                 return True
         ##当前线路，已经找到最早的前置课程，没有出现"环"，则标记为0，表示课程i是可以学习的
         memo[i] =
         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][]#当前课程
             pre = prerequisites[i][]#前置课程
             dic[cs].append(pre)
         visited = [False for _ in range(numCourses)]
         memo = [- 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表示本节点有环，使用备忘录可加速得到查询结果。