力扣(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重複1、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;
    }
}