Update 207._course_schedule.md

Author: 0xkookoo

docs/Leetcode_Solutions/Python/207._course_schedule.md

@@ -1,93 +1,90 @@
-###207. Course Schedule
+# 207. Course Schedule
 
+**<font color=red>难度: Medium</font>**
 
+## 刷题内容
 
-题目:
-<https://leetcode.com/problems/course-schedule/>
+> 原题连接
 
+* https://leetcode.com/problems/course-schedule/description/
 
-难度:
-Medium
+> 内容描述
 
-思路：
+```
+There are a total of n courses you have to take, labeled from 0 to n-1.
 
-就是考topological sort，用来判断directed graph是否有cycle
+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]
 
-DFS 和 BFS都可以用来拓扑排序。
+Given the total number of courses and a list of prerequisite pairs, is it possible for you to finish all courses?
+
+Example 1:
 
-最简单的想法是每次取出indegree是0的node，然后把它和与之相关的edge都删了。一开始觉得这样的时间复杂度会很高，然后看到了这样写，参照：
+Input: 2, [[1,0]] 
+Output: true
+Explanation: There are a total of 2 courses to take. 
+             To take course 1 you should have finished course 0. So it is possible.
+Example 2:
 
-<http://bookshadow.com/weblog/2015/05/07/leetcode-course-schedule/>
+Input: 2, [[1,0],[0,1]]
+Output: false
+Explanation: 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.
+```
 
-这里做了转成set以及添加removeList这样的操作是因为边list边做iterator这样的操作很危险
+## 解题方案
 
+> 思路 1
+******- 时间复杂度: O(V+E)******- 空间复杂度: O(N)******
+[Topological sorting](https://www.geeksforgeeks.org/topological-sorting/) for Directed Acyclic Graph (DAG) is a linear ordering of vertices such that for every directed edge uv, vertex u comes before v in the ordering. Topological Sorting for a graph is not possible if the graph is not a DAG.
 
+pre-requisite问题，只需要判断最终的topological结果长度与courses数目是否相等即可
 
+DFS 和 BFS都可以用来拓扑排序。
 
-```
+beats 95.38%
+```python
 class Solution(object):
     def canFinish(self, numCourses, prerequisites):
         """
         :type numCourses: int
         :type prerequisites: List[List[int]]
         :rtype: bool
         """
-        degrees = [ 0 for i in range(numCourses)]
-        childs = [[] for i in range(numCourses)]
-        for front, tail in prerequisites:
-        	degrees[front] += 1
-        	childs[tail].append(front)
-
-        courses = set(range(numCourses))
-        flag = True
-
-        while flag and len(courses):
-        	flag = False
-        	removeList = []
-        	for x in courses:
-        		if degrees[x] == 0:
-        			for child in childs[x]:
-        				degrees[child] -= 1
-        			removeList.append(x)
-        			flag = True
-        	for x in removeList:
-        		courses.remove(x)
-        return len(courses) == 0 
-
+        graph = collections.defaultdict(list)
+        indegrees = [0] * numCourses
+        
+        for course, pre in prerequisites:
+            graph[pre].append(course)
+            indegrees[course] += 1
+            
+        return self.topologicalSort(graph, indegrees) == numCourses
+    
+    
+    def topologicalSort(self, graph, indegrees):
+        count = 0
+        queue = []
+        for i in range(len(indegrees)):
+            if indegrees[i] == 0:
+                queue.append(i)
+        while queue:
+            course = queue.pop()
+            count += 1
+            for i in graph[course]:
+                indegrees[i] -= 1
+                if indegrees[i] == 0:
+                    queue.append(i)
+        return count
 ```
 
-因为CLRS里面明确提到涂色法来处理DFS
 
-搞了半天，写了一个涂色法，在超时的边缘。之所以超时边缘是因为每次都要去prerequisites里看，没有删减，不高效.
 
-```
-class Solution(object):
-    def canFinish(self, numCourses, prerequisites):
-        """
-        :type numCourses: int
-        :type prerequisites: List[List[int]]
-        :rtype: bool
-        """
-        def dfs(i, colors, prerequisites):
-        	colors[i] = 'G'
-        	#print i, colors
-        	for front, tail in prerequisites:
-        		if tail == i:
-        			if colors[front] == 'G':
-        				return False
-        			elif colors[front] == 'B':
-        				continue
-        			elif dfs(front, colors, prerequisites) == False:
-        				return False
-        	colors[i] = 'B'
-        	return True
-
-        colors = ['W' for i in range(numCourses)]
-        for i in range(numCourses):
-        	if colors[i] == 'W':
-        		if dfs(i, colors, prerequisites) == False:
-        			return False
-        return True
-```
+
+
+
+
+