[LeetCode]Course Schedule ||

Course Schedule II : ****

Cited From Yu's Coding Garden

"

Analysis:

This is a classic Graph topology sorting problem, but an easy version. We don't have to store the sort, in other words, we only need to detect if exists cycle in a directed graph.

Both DFS and BFS can be used to solve this problem.

First of all, we need to get a representation of the graph, either adjacency matrix or adjacency list is OK. In my code, you can see both ways. But note that, when the number of vertex is large, adjacency matrix usually is NOT a good option.

In DFS, the general idea, is to search each vertex in the graph recursively, if the current vertex has been visited in this search, then there must be a cycle. Be careful with the status of each vertex, here in my code, it has three states:  unvisited (=0), visited(=1), searching(=-1). The third states is to detect the existence of cycle, while the 2nd state indicate that the vertex is already checked and there is no cycle.

In BFS, the idea is much easier.  We store the indegree of each vertex, push the vertices with 0 indegree in stack (remember general BFS framwork?).  Every time, pop the stack and set indegree of connected vertices -1. In the end, if the number of popped out vertices is less than the total number of vertices in the original graph, there is cycle.

"

--- 出处博客链接

//原始版本。
//adjacent list换成map更方便
//degree方式 bfs推进，不需要查环，回环 永远是避开的不扫的（只有你 degree为0才入stack ）。最后count数就会小于总数。

public class Solution {
    public int[] findOrder(int numCourses, int[][] prerequisites) {
        int[] Res = new int[numCourses];
        //ind records indegree for each course
        int[] ind = new int[numCourses];
        //al is the adjacent list
        List
  
   
    > al = new ArrayList
    
     
      >();
        for(int i=0; i
      
        temp = new ArrayList
       
        (); al.add(temp); } //构建图的adjacent list for(int i=0; i< prerequisites.length; i++){ int[] item = prerequisites[i]; if(al.get(item[1]).isEmpty()){ al.get(item[1]).add(item[0]); ind[item[0]] += 1; }else{ if(!al.get(item[1]).contains(item[0])){ al.get(item[1]).add(item[0]); ind[item[0]] += 1; } } } //向queue内推入indegree ＝ 0 的course作为搜索起点（代表可以直接上的课） LinkedList
        
          queue = new LinkedList
         
          (); for(int i=0; i
          
           > map = new HashMap
           
            >(); for(int i=0; i
            
             ()); } for(int[] p : pre){ map.get(p[1]).add(p[0]); } return topSort(map,numC); } public static int[] topSort(HashMap
             
              > map, int numC){ List
              
                res = new ArrayList
               
                (); HashSet
                
                  visited = new HashSet
                 
                  (); HashSet
                  
                    records = new HashSet
                   
                    (); for(int key:map.keySet()){ if(!dfs(key,map, visited,records, res)) return new int[0]; } int[] ans = new int[numC]; for(int i=0; i
                    
                     > map, HashSet
                     
                       visited, HashSet
                      
                        records, List
                       
                         res ){ if(records.contains(node)) return false; if(visited.contains(node)) return true; records.add(node); if(map.containsKey(node)){ for(int key : map.get(node)){ if(!dfs(key, map, visited, records, res)) return false; } } records.remove(Integer.valueOf(node)); visited.add(node); res.add(0,node); return true; } }