力扣(LeetCode)207

題目地址：
https://leetcode-cn.com/probl...
題目描述：
如今你總共有 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。這是不可能的。

解答：
利用圖的拓撲排序。
拓撲排序是來檢測圖中有無環的算法。具體步驟：
1找到一個入度爲0的點，若沒有，則返回圖中有環。
2刪除1中找到的點及以它爲起點的邊。
3重複一、2直到圖中全部點都被刪除，此時返回圖中無環。

下面的一種思路是創建相似鄰接表的圖，這裏的鄰接表保存的不是邊，而是指向該點的
其餘點，這種算法很好理解，可是時間複雜度過大。
思想是，每一次都找到一個點，這個點沒有任何點指向它。而後把它刪除。
再遍歷圖，把這個點做爲起點的邊(其餘點鄰接表的元素)刪除，直到圖爲空返回true
或者找不到這個點，返回false。
java ac代碼：

class Solution {
    public boolean canFinish(int numCourses, int[][] prerequisites) {
        
        //鄰接表，存放的是指向該節點的其餘節點編號，而不是邊
        //若是某個點沒有其餘點指向它，那麼對應的list爲空。
        HashMap<Integer,List<Integer>> map = new HashMap(numCourses);
        
        for(int i = 0;i < numCourses;i++)
            map.put(i,new ArrayList());
        
        for(int i = 0;i < prerequisites.length;i++)
        {
             int previous = prerequisites[i][1];
             int latter = prerequisites[i][0];
          
             List<Integer>list = map.get(latter);
             list.add(previous);
        }
        while(map.size() > 0)
        {
            //判斷是否能找到一個沒有任何節點指向的節點
            boolean flag = false;
            int num = 0;
            for(Map.Entry<Integer,List<Integer>> entry:map.entrySet())
            if(entry.getValue().size() == 0)
            {
                flag = true;
                num = entry.getKey();
                break;
            }

            if(!flag)return false;
            
            map.remove(num);
            Iterator<List<Integer>> it = map.values().iterator();
            while(it.hasNext())
                it.next().remove(new Integer(num));
            
        }
        
        return true;
    }
}

下面這種是利用一個隊列暫存入度爲0的點的快速拓撲排序方法。
由於它沒必要每次都從頭查找入度爲0的點，所以時間效率獲得了提示。
java ac代碼：

class Solution {
    public boolean canFinish(int numCourses, int[][] prerequisites) {
        
        //鄰接表,表示法
        HashMap<Integer,List<Integer>> map = new HashMap(numCourses);
        
        //存放每一個點的入度，初始爲0
        HashMap<Integer,Integer>map2 = new HashMap(numCourses);
        
        for(int i = 0;i < numCourses;i++){
            map.put(i,new ArrayList());
            map2.put(i,0);   
        }
        
        //構造鄰接表，並求出每一個點的初始入度。
        for(int i = 0;i < prerequisites.length;i++)
        {
             int previous = prerequisites[i][1];
             int latter = prerequisites[i][0];
          
             List<Integer>list = map.get(previous);
             list.add(latter);
             map.put(previous,list);
             map2.put(latter,map2.get(latter)+1);
        }
        
        //暫存入度爲0的節點。
        ArrayDeque<Integer>queue = new ArrayDeque();
        for(int i = 0;i < numCourses;i++)
            if(map2.get(i) == 0)
                queue.offer(i);
        
        //統計最終能有多少個入度爲0的點，若該數量小於numCourses則表明有環
        int count = 0;
        while(!queue.isEmpty())
        {
         int node = queue.poll();   
         for(int i:map.get(node))
         {
             int ii = map2.get(i);
             ii -= 1;
             if(ii != 0)
                map2.put(i,ii);
             //這個點的入度變爲了0，能夠加入隊列中
             else
             queue.offer(i);
         }
          
         count++;
        }
       
        
        return count == numCourses;
    }
}