leetcode Course Schedule

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:

1. The input prerequisites is a graph represented by a list of edges, not adjacency matrices. Read more about how a graph is represented.
2. You may assume that there are no duplicate edges in the input prerequisites.

解题方法一：

  BFS：第一步构造图，第二步计算入度，第三步寻找入度为0的点，如果没有入度为0的节点，则存在环，否则删除与入度为0的点相关连的边也删除这个入度为0的点，实现方法：此节点的入度赋值为-1，此节点指向的节点的入度-1.接着重复第三步。直到重复寻找了节点个数次。

代码详情一：

class Solution {
  public:
  bool canFinish(int numCourses, vector<pair<int, int> >& prerequisites) {
  vector<vector<int> > graph(numCourses);
  for (int i = 0; i < prerequisites.size(); i++) {
  graph[prerequisites[i].second].push_back(prerequisites[i].first);
}
vector<int> in(numCourses, 0);
for (int i = 0; i < numCourses; i++) {
for (int j = 0; j < graph[i].size(); j++) {
in[graph[i][j]]++;
}
}
for (int i = 0; i < numCourses; i++) {
int j;
for (j = 0; j < numCourses; j++) {
if (in[j] == 0) {
break;
}
}
if (j == numCourses) {
return false;
}
in[j] = -1;
for (int k = 0; k < graph[j].size(); k++) {
in[graph[j][k]]--;
}
}
return true;
  }
 
 }; 

解题方法二：

DFS：第一步构造图，第二步完成DFS函数。DFS函数判断有无环：如果节点被访问过，则返回false。否则onpath[node] = visited[node] = true，便利该节点指向的节点，如果该节点没有指向的节点，则onpath[node] = false，返回true；如果该节点有指向的节点，如果其指向的节点onpath[node]=true，即该节点和其指向的节点存在环或DFS其指向的节点为true，即其指向的节点存在环。返回true。第三步，对于每个节点如果没被访问过，且DFS函数为true，则返回false，如果不存在这样的节点，则返回true。

代码详情：

class Solution {
public:
    bool canFinish(int numCourses, vector<pair<int, int> >& prerequisites) {
        vector<vector<int> > graph = make_graph(numCourses, prerequisites);
        vector<bool> onpath(numCourses, false), visited(numCourses, false);
        for (int i = 0; i < numCourses; i++)
            if (!visited[i] && dfs_cycle(graph, i, onpath, visited))
                return false;
        return true;
    }
private:
    vector<vector<int>> make_graph(int numCourses, vector<pair<int, int>>& prerequisites) {
        vector<vector<int> > graph(numCourses);
        for (auto pre : prerequisites)
            graph[pre.second].push_back(pre.first);
        return graph;
    } 
    bool dfs_cycle(vector<vector<int> >& graph, int node, vector<bool>& onpath, vector<bool>& visited) {
        if (visited[node]) return false;
        onpath[node] = visited[node] = true; 
        for (int neigh : graph[node])
            if (onpath[neigh] || dfs_cycle(graph, neigh, onpath, visited))
                return true;
        return onpath[node] = false;
    }
};