题目
现在你总共有 n 门课需要选，记为 0 到 n-1。
在选修某些课程之前需要一些先修课程。 例如，想要学习课程 0 ，你需要先完成课程 1 ，我们用一个匹配来表示他们: [0,1]
给定课程总量以及它们的先决条件，判断是否可能完成所有课程的学习？
示例 1:
输入: 2, [[1,0]]
输出: true
解释: 总共有 2 门课程。学习课程 1 之前，你需要完成课程 0。所以这是可能的。
示例 2:
输入: 2, [[1,0],[0,1]]
输出: false
解释: 总共有 2 门课程。学习课程 1 之前，你需要先完成课程 0；
并且学习课程 0 之前，你还应先完成课程 1。这是不可能的。
说明:
输入的先决条件是由边缘列表表示的图形，而不是邻接矩阵。详情请参见图的表示法。
你可以假定输入的先决条件中没有重复的边。
提示:
这个问题相当于查找一个循环是否存在于有向图中。如果存在循环，则不存在拓扑排序，因此不可能选取所有课程进行学习。
通过 DFS 进行拓扑排序 - 一个关于Coursera的精彩视频教程（21分钟），介绍拓扑排序的基本概念。
拓扑排序也可以通过 BFS 完成。
代码(java)
方法一：入度表（广度优先遍历）
class Solution {
public boolean canFinish(int numCourses, int prerequisites) {
int[] indegrees = new int[numCourses];
for(int[] cp : prerequisites) indegrees[cp[0]]++;//入度增加
LinkedList<Integer> queue = new LinkedList<>();
for(int i = 0; i < numCourses; i++){
if(indegrees[i] == 0) queue.addLast(i);
}
while(!queue.isEmpty()) {
Integer pre = queue.removeFirst();
numCourses--;
for(int[] req : prerequisites) {//循环二维数组
if(req[1] != pre) continue;//判断是不是依赖这一门课，如果不是，就跳过
//如果是这门课,入席数组减减
if(--indegrees[req[0]] == 0) queue.add(req[0]);
}
}
return numCourses == 0;
}
}
方法二：深度优先遍历
第 1 步：构建逆邻接表；
第 2 步：递归处理每一个还没有被访问的结点，具体做法很简单：对于一个结点来说，先输出指向它的所有顶点，再输出自己。
第 3 步：如果这个顶点还没有被遍历过，就递归遍历它，把所有指向它的结点都输出了，再输出自己。注意：当访问一个结点的时候，应当先递归访问它的前驱结点，直至前驱结点没有前驱结点为止。
import java.util.HashSet;
public class Solution6 {
public boolean canFinish(int numCourses, int[][] prerequisites) {
if (numCourses <= 0) {
return false;
}
int plen = prerequisites.length;
if (plen == 0) {
return true;
}
int[] marked = new int[numCourses];
// 初始化有向图 begin
HashSet<Integer>[] graph = new HashSet[numCourses];
for (int i = 0; i < numCourses; i++) {
graph[i] = new HashSet<>();
}
// 初始化有向图 end
// 有向图的 key 是前驱结点，value 是后继结点的集合
for (int[] p : prerequisites) {
graph[p[1]].add(p[0]);
}
for (int i = 0; i < numCourses; i++) {
if (dfs(i, graph, marked)) {
// 注意方法的语义，如果图中存在环，表示课程任务不能完成，应该返回 false
return false;
}
}
// 在遍历的过程中，一直 dfs 都没有遇到已经重复访问的结点，就表示有向图中没有环
// 所有课程任务可以完成，应该返回 true
return true;
}
/**
* 注意这个 dfs 方法的语义
* @param i 当前访问的课程结点
* @param graph
* @param marked 如果 == 1 表示正在访问中，如果 == 2 表示已经访问完了
* @return true 表示图中存在环，false 表示访问过了，不用再访问了
*/
private boolean dfs(int i,
HashSet<Integer>[] graph,
int[] marked) {
// 如果访问过了，就不用再访问了
if (marked[i] == 1) {
// 从正在访问中，到正在访问中，表示遇到了环
return true;
}
if (marked[i] == 2) {
// 表示在访问的过程中没有遇到环，这个节点访问过了
return false;
}
// 走到这里，是因为初始化呢，此时 marked[i] == 0
// 表示正在访问中
marked[i] = 1;
// 后继结点的集合
HashSet<Integer> successorNodes = graph[i];
for (Integer successor : successorNodes) {
if (dfs(successor, graph, marked)) {
// 层层递归返回 true ，表示图中存在环
return true;
}
}
// i 的所有后继结点都访问完了，都没有存在环，则这个结点就可以被标记为已经访问结束
// 状态设置为 2
marked[i] = 2;
// false 表示图中不存在环
return false;
}
}
有向图
前驱与直接前驱结点的区别
对于某个有向图,它拥有A->B->C 前驱:对于C来说,其前驱为A、B 直接前驱:对于C来说,其直接前驱为B。
代码(cpp)
方法一:广度优先(cpp)
#include <stdio.h>
#include <vector>
#include <queue>
struct GraphNode{
int label;
std::vector<GraphNode *> neighbors;
GraphNode(int x) : label(x) {};
};
class Solution {
public:
bool canFinish(int numCourses,
std::vector<std::pair<int, int> >& prerequisites) {
std::vector<GraphNode*> graph;
std::vector<int> degree;
for (int i = 0; i < numCourses; i++){
degree.push_back(0);
graph.push_back(new GraphNode(i));
}
for (int i = 0; i < prerequisites.size(); i++){
GraphNode *begin = graph[prerequisites[i].second];
GraphNode *end = graph[prerequisites[i].first];
begin->neighbors.push_back(end);
degree[prerequisites[i].first]++;
}
std::queue<GraphNode *> Q;
for (int i = 0; i < numCourses; i++){
if (degree[i] == 0){
Q.push(graph[i]);
}
}
while(!Q.empty()){
GraphNode *node = Q.front();
Q.pop();
for (int i = 0; i < node->neighbors.size(); i++){
degree[node->neighbors[i]->label]--;
if (degree[node->neighbors[i]->label] == 0){
Q.push(node->neighbors[i]);
}
}
}
for (int i = 0; i < graph.size(); i++){
delete graph[i];
}
for (int i = 0; i < degree.size(); i++){
if (degree[i]){
return false;
}
}
return true;
}
};
int main(){
std::vector<std::pair<int, int> > prerequisites;
prerequisites.push_back(std::make_pair(1, 0));
prerequisites.push_back(std::make_pair(2, 0));
prerequisites.push_back(std::make_pair(3, 1));
prerequisites.push_back(std::make_pair(3, 2));
Solution solve;
printf("%d\n", solve.canFinish(4, prerequisites));
return 0;
}
方法二:深度优先(cpp)
#include <stdio.h>
#include <vector>
struct GraphNode{
int label;
std::vector<GraphNode *> neighbors;
GraphNode(int x) : label(x) {};
};
//节点状态,-1没有访问过，0代表正在访问，1代表已完成访问
bool DFS_graph(GraphNode *node, std::vector<int> &visit){
visit[node->label] = 0;
for (int i = 0; i < node->neighbors.size(); i++){
if (visit[node->neighbors[i]->label] == -1){
if (DFS_graph(node->neighbors[i], visit) == 0){
return false;
}
}
else if (visit[node->neighbors[i]->label] == 0){
return false;
}
}
visit[node->label] = 1;
return true;
}
class Solution {
public:
bool canFinish(int numCourses,
std::vector<std::pair<int, int> >& prerequisites) {
std::vector<GraphNode*> graph;
std::vector<int> visit;
for (int i = 0; i < numCourses; i++){
graph.push_back(new GraphNode(i));
visit.push_back(-1);
}
//创建图，连接图的顶点
for (int i = 0; i < prerequisites.size(); i++){
GraphNode *begin = graph[prerequisites[i].second];
GraphNode *end = graph[prerequisites[i].first];
begin->neighbors.push_back(end);
}
for (int i = 0; i < graph.size(); i++){
//如果节点没有访问过,进行DFS，如果DFS遇到环,返回无法完成课程。
if (visit[i] == -1 && !DFS_graph(graph[i], visit)){
return false;
}
}
for (int i = 0; i < numCourses; i++){
delete graph[i];
}
return true;//返回可以完成
}
};
int main(){
std::vector<std::pair<int, int> > prerequisites;
prerequisites.push_back(std::make_pair(1, 0));
prerequisites.push_back(std::make_pair(2, 0));
prerequisites.push_back(std::make_pair(3, 1));
prerequisites.push_back(std::make_pair(3, 2));
Solution solve;
printf("%d\n", solve.canFinish(4, prerequisites));
return 0;
}
参考资料
