이름
지금 당신은 과정을 표시 N의 총 선택할 필요 0로를 n-1.
선택 과목 특정 전에 어떤 AP 과목이 필요합니다. 예를 들어, 연구 과정 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를 통해 수행 할 수 있습니다.
코드 (자바)
방법 A : 정도 테이블 (폭 우선 탐색)
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 단계 : 각 노드 순환 프로세스가 액세스되지 않은 특정 방법은 매우 간단하다 : 노드에 대한 상기의 모든 정점에 제 1 출력 가리키고 출력 자체.
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)
방법 1 : 폭 우선 (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;
}
참고 자료
