タイトル
今、あなたは当然に示される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によるトポロジカルソート-コーセラさん（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;
}
}
方法2：深さ優先探索
ステップ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;
}
方法2：深さ優先（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;
}
参考資料
