LeetCode 207. Course Schedule

图和dfs

LeetCode第207题CourseSchedule 难度Medium

题目描述：

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.

You may assume that there are no duplicate edges in the input prerequisites.

这题的相当于给定一个有向图，课程是有向图的顶点，课程之间的依赖关系相当于有向图的边。修完所有课程的顺序相当于对图进行一次拓扑排序。而问题问的是能否修完课程，即能否进行拓扑排序。若不能进行拓扑排序，说明有向图中有环，也就是存在回边(back edge)。

因此先由输入数据构建起有向图（邻接表形式），找出图中所有的源。

1. 若没有源，则图中只有环，返回false。

2. 若存在源，分别从每个源开始进行dfs。在dfs的过程中，访问顶点n时将pre
标志为true，离开时将post
标志为true。倘若将要访问的下一个顶点m的pre[m]为true而post[m]为false，则说明在dfs过程构建的树中，n是m的子树中的节点，故n->m的边是回边，以此可以判断图中有环，返回false。从所有源开始遍历完后，要检查是否顶点全部被遍历过，以排除有些环无源未被遍历的情况。

具体代码如下：

struct Node {
int value;
Node* next;
Node(int v): value(v), next(NULL) {}
};

class Solution {
public:
bool canFinish(int numCourses, vector<pair<int, int>>& prerequisites) {
constructGraph(numCourses, prerequisites);

int s, i;

for (i = 0; i < numCourses; i++) {
pre.push_back(false);
post.push_back(false);
}

// dfs每个源
for (s = 0; s < numCourses; s++) {
if (source[s]) {
if (dfs(s) == false)
return false;
}
}

// 判断是否所有顶点都被访问过
for (i = 0; i < numCourses; i++) {
if (pre[i] == false) break;
}

destructGraph(numCourses);
if (i == numCourses) return true;
else return false;
}

private:
bool constructGraph(int numCourses, vector<pair<int, int>>& prerequisites) {
for (int i = 0; i < numCourses; i++) {
adjList.push_back(NULL);
source.push_back(true);
}
for (int i = 0; i < prerequisites.size(); i++) {
Node* p = adjList[prerequisites[i].first];
// 有入边的顶点不是源
source[prerequisites[i].second] = false;
if (p == NULL) {
adjList[prerequisites[i].first] = new Node(prerequisites[i].second);
} else {
while (p->next != NULL) {
p = p->next;
}
p->next = new Node(prerequisites[i].second);
}
}
return true;
}

bool destructGraph(int numCourses) {
for (int i = 0; i < numCourses; i++) {
if (adjList[i] != NULL) {
Node* del = adjList[i];
Node* p = del->next;
while (p != NULL) {
delete del;
del = p;
p = del->next;
}
delete del;
}
}
return true;
}

bool dfs(int n) {
pre
= true;
Node* p = adjList
;
// 判断这条边是否是回边
if (pre[p->value] == true && post[p->value] == false)
return false;
if (pre[p->value] == false) {
if (dfs(p->value) == false) return false;
}
p = p->next;
}
post
= true;
return true;
}

private:
//邻接表
vector<Node*> adjList;

//储存pre和post标志
vector<bool> pre;
vector<bool> post;

//储存源
vector<bool> source;
};

结果：

37 / 37 test cases passed.

Status: Accepted

Runtime: 12 ms

Your runtime beats 86.48 % of cpp submissions.

是图和dfs很基础的应用的题目~