有向无环图判断问题（207. 课程表 C语言）

1.Kahn

       算法Kahn 算法实际上用的是贪心算法思想，思路非常简单、好懂。定义数据结构的时候，如果 s 需要先于 t 执行，那就添加一条 s 指向 t 的边。所以，如果某个顶点入度为 0， 也就表示，没有任何顶点必须先于这个顶点执行，那么这个顶点就可以执行了。

        我们先从图中，找出一个入度为 0 的顶点，将其输出到拓扑排序的结果序列中（对应代码中就是把它打印出来），并且把这个顶点从图中删除（也就是把这个顶点可达的顶点的入度都减 1）。我们循环执行上面的过程，直到所有的顶点都被输出。最后输出的序列，就是满足局部依赖关系的拓扑排序。

       我把 Kahn 算法用代码实现了一下，你可以结合着文字描述一块看下。不过，你应该能发现，这段代码实现更有技巧一些，并没有真正删除顶点的操作。代码中有详细的注释，你自己来看，我就不多解释了。

public void topoSortByKahn() {
  int[] inDegree = new int[v]; // 统计每个顶点的入度
  for (int i = 0; i < v; ++i) {
    for (int j = 0; j < adj[i].size(); ++j) {
      int w = adj[i].get(j); // i->w
      inDegree[w]++;
    }
  }
  LinkedList<Integer> queue = new LinkedList<>();
  for (int i = 0; i < v; ++i) {
    if (inDegree[i] == 0) queue.add(i);
  }
  while (!queue.isEmpty()) {
    int i = queue.remove();
    System.out.print("->" + i);
    for (int j = 0; j < adj[i].size(); ++j) {
      int k = adj[i].get(j);
      inDegree[k]--;
      if (inDegree[k] == 0) queue.add(k);
    }
  }
}

2.DFS

       图上的深度优先搜索我们前面已经讲过了，实际上，拓扑排序也可以用深度优先搜索来实现。不过这里的名字要稍微改下，更加确切的说法应该是深度优先遍历，遍历图中的所有顶点，而非只是搜索一个顶点到另一个顶点的路径。关于这个算法的实现原理，我先把代码贴在下面，下面给你具体解释。

public void topoSortByDFS() {
  // 先构建逆邻接表，边s->t表示，s依赖于t，t先于s
  LinkedList<Integer> inverseAdj[] = new LinkedList[v];
  for (int i = 0; i < v; ++i) { // 申请空间
    inverseAdj[i] = new LinkedList<>();
  }
  for (int i = 0; i < v; ++i) { // 通过邻接表生成逆邻接表
    for (int j = 0; j < adj[i].size(); ++j) {
      int w = adj[i].get(j); // i->w
      inverseAdj[w].add(i); // w->i
    }
  }
  boolean[] visited = new boolean[v];
  for (int i = 0; i < v; ++i) { // 深度优先遍历图
    if (visited[i] == false) {
      visited[i] = true;
      dfs(i, inverseAdj, visited);
    }
  }
}

private void dfs(
    int vertex, LinkedList<Integer> inverseAdj[], boolean[] visited) {
  for (int i = 0; i < inverseAdj[vertex].size(); ++i) {
    int w = inverseAdj[vertex].get(i);
    if (visited[w] == true) continue;
    visited[w] = true;
    dfs(w, inverseAdj, visited);
  } // 先把vertex这个顶点可达的所有顶点都打印出来之后，再打印它自己
  System.out.print("->" + vertex);
}

207. 课程表 

1.Kahn 算法实现

有向图可以描述一种依赖关系

该算法将有向图中指向一个点的边，转变成该点的入度，用indgree数组存储。

入度为0的点，是起始点，也就是有向图入口，没有其他点指向它，没有任何点先于这个点执行。

        for(int i=0;i<n;i++){
                if(!indegree[i])queue[rear++]=i;     //入度为0，全部要加进队列中
        }

从入度为0的点进入图，删除从它出发的边，也就是入度值减一

if(prerequisites[i][1]==t){
                int tmp=prerequisites[i][0];
                indegree[tmp]--;

 

题目要求：想要学习课程 0 ，你需要先完成课程 1 ，我们用一个匹配来表示他们：[0,1]。 也就是prerequisited[i][1]先于prerequisited[i][0]执行。

bool canFinish(int numCourses, int** prerequisites, int prerequisitesSize, int* prerequisitesColSize){
    int n=numCourses;
    int count=numCourses;
    int *indegree=malloc(sizeof(int)*n);
    memset(indegree,0,sizeof(int)*n);
    for(int i=0;i<prerequisitesSize;i++){
        int tmp=prerequisites[i][0];
        indegree[tmp]++;
    }
    int *queue=malloc(sizeof(int)*(n+2));
    int rear=0,front=0;
    for(int i=0;i<n;i++){
        if(!indegree[i])queue[rear++]=i;     //入度为0，全部要加进队列中
    }

    while(rear!=front){
        int t=queue[front++];
        count--;
        for(int i=0;i<prerequisitesSize;i++){
            if(prerequisites[i][1]==t){
                int tmp=prerequisites[i][0];
                indegree[tmp]--;
                if(indegree[tmp]==0)queue[rear++]=tmp;  //新出现入度为零的点，也加进队列中
            }
        }
    }
		//判断有没有入度不为0的点，证明有环
    // for(int i=0;i<n;i++){
    //     if(indegree[i])return false;
    // }
    //return true;
    return count==0;

方法二：深度优先遍历 DFS 

原理是通过 DFS 判断图中是否有环。

算法流程：
借助一个标志列表 flags，用于判断每个节点 i （课程）的状态：
未被 DFS 访问：i == 0；
已被其他节点启动的 DFS 访问：i == -1；
已被当前节点启动的 DFS 访问：i == 1。
对 numCourses 个节点依次执行 DFS，判断每个节点起步 DFS 是否存在环，若存在环直接返回 FalseFalse。DFS 流程；
终止条件：
当 flag[i] == -1，说明当前访问节点已被其他节点启动的 DFS 访问，无需再重复搜索，直接返回 TrueTrue。
当 flag[i] == 1，说明在本轮 DFS 搜索中节点 i 被第 22 次访问，即 课程安排图有环 ，直接返回 FalseFalse。
将当前访问节点 i 对应 flag[i] 置 11，即标记其被本轮 DFS 访问过；
递归访问当前节点 i 的所有邻接节点 j，当发现环直接返回 FalseFalse；
当前节点所有邻接节点已被遍历，并没有发现环，则将当前节点 flag 置为 -1−1 并返回 TrueTrue。
若整个图 DFS 结束并未发现环，返回 TrueTrue。
复杂度分析：
时间复杂度 O(N + M)O(N+M)： 遍历一个图需要访问所有节点和所有临边，NN 和 MM 分别为节点数量和临边数量；
空间复杂度 O(N + M)O(N+M)： 为建立邻接表所需额外空间，adjacency 长度为 NN ，并存储 MM 条临边的数据。

作者：jyd
链接：https://leetcode-cn.com/problems/course-schedule/solution/course-schedule-tuo-bu-pai-xu-bfsdfsliang-chong-fa/
 

struct adj {
	int val;
	struct adj* next;
};
struct adj** createGraph(int numCourses, int** prerequisites, int prerequisitesSize) {
	struct adj** adjs = (struct adj**)malloc(sizeof(struct adj*) * numCourses);
	for (int i = 0; i < numCourses; i++) {
		adjs[i] = NULL;
	}
	for (int i = 0; i < prerequisitesSize; i++) {
		int id = prerequisites[i][1];
		struct adj*node= (struct adj*)malloc(sizeof(struct adj));
		node->val= prerequisites[i][0];
		node->next=adjs[id];
		adjs[id] = node;
	}
	return adjs;
}
void freeGraph(int numCourses, struct adj** adjs) {
	struct adj* p;
	struct adj* c;
	for (int i = 0; i < numCourses; i++) {
		p = adjs[i];
		while (p) {
			c = p->next;
			free(p);
			p = c;
		}
	}
	free(adjs);
	free(p);
	free(c);
}
bool dfs(int numCourses, struct adj** adjs, int* visited, int i) {
	if (visited[i] == 1)return false;
	if(visited[i] == -1) return true;
	visited[i] = 1;
	struct adj* p = adjs[i];
	while(p!=NULL){		
		if(!dfs(numCourses, adjs, visited, p->val)){
			return false;
		}
		p = p->next;
	}
	visited[i] = -1;
	return true;
}
bool canFinish(int numCourses, int** prerequisites, int prerequisitesSize, int* prerequisitesColSize)
{
	struct adj**adjs=createGraph(numCourses, prerequisites, prerequisitesSize);
	int* visited = (int*)malloc(sizeof(int) * numCourses);
	memset(visited, 0, sizeof(int) * numCourses);
	for(int i=0;i<numCourses;i++){
		if (!dfs(numCourses, adjs, visited, i)) {
			freeGraph(numCourses, adjs);
			free(visited);
			return false;
		}	
	}
	freeGraph(numCourses, adjs);
	free(visited);
	return true;
}