【重点】【拓扑排序】207.课程表|210.课程表II

207.课程表

其实就是『有向图里找环』。
题目
参考链接

Python

207
入度+邻接矩阵！！！

class Solution:
    def canFinish(self, numCourses: int, prerequisites: List[List[int]]) -> bool:
        indegree = [0] * numCourses
        adjacency = [[] for _ in range(numCourses)]
        for tmp in prerequisites:
            indegree[tmp[0]] += 1
            adjacency[tmp[1]].append(tmp[0])

        queue = collections.deque()
        for i in range(numCourses):
            if indegree[i] == 0:
                queue.append(i)
        visited = 0
        while queue:
            curNode = queue.popleft()
            visited += 1
            for endNode in adjacency[curNode]:
                indegree[endNode] -= 1
                if indegree[endNode] == 0:
                    queue.append(endNode)
        
        return visited == numCourses

210
题目

class Solution:
    def findOrder(self, numCourses: int, prerequisites: List[List[int]]) -> List[int]:
        res = list()
        q = collections.deque()
        indegrees = [0] * numCourses
        adajcency = [[] for _ in range(numCourses)]
        for tmp_array in prerequisites:
            indegrees[tmp_array[0]] += 1
            adajcency[tmp_array[1]].append(tmp_array[0])
        
        for i in range(numCourses):
            if indegrees[i] == 0:
                q.append(i)

        while q:
            top = q.popleft()
            res.append(top)
            for tmp in adajcency[top]:
                indegrees[tmp] -= 1
                if indegrees[tmp] == 0:
                    q.append(tmp)
        
        return res if len(res) == numCourses else []

Java

法1：DFS

很容易理解的方法！

class Solution {
    public boolean canFinish(int numCourses, int[][] prerequisites) {
        int[] flags = new int[numCourses];
        List<List<Integer>> adjacency = new ArrayList<>();
        for (int i = 0; i < numCourses; ++i) {
            adjacency.add(new ArrayList<>());
        }
        for (int[] array : prerequisites) {
            adjacency.get(array[1]).add(array[0]);
        }
        for (int i = 0; i < numCourses; ++i) {
            if (!dfs(adjacency, flags, i)) {
                return false;
            }
        }

        return true;
    }
 
    // 无环图 => true; 有环图 => false
    public boolean dfs(List<List<Integer>> adjacency, int[] flags, int index) {
        if (flags[index] == 1) {
            return false;
        } else if (flags[index] == -1) {
            return true;
        }
        flags[index] = 1;
        for (int nextInx : adjacency.get(index)) {
            if (!dfs(adjacency, flags, nextInx)) {
                return false;
            }
        }
        flags[index] = -1;

        return true;
    }
}

法2：入度表（BFS）

复习入度和出度的概念！

class Solution {
    public boolean canFinish(int numCourses, int[][] prerequisites) {
        int visited = 0;
        int[] indegrees = new int[numCourses];
        Queue<Integer> queue = new LinkedList<>();
        List<List<Integer>> adjacency = new ArrayList<>();
        for (int i = 0; i < numCourses; ++i) {
            adjacency.add(new ArrayList<>());
        }
        for (int[] array : prerequisites) {
            ++indegrees[array[0]];
            adjacency.get(array[1]).add(array[0]);
        }
        for (int i = 0; i < numCourses; ++i) {
            if (indegrees[i] == 0) {
                queue.offer(i);
            }
        }
        while (!queue.isEmpty()) {
            int topInx = queue.poll();
            ++visited;
            for (int k : adjacency.get(topInx)) {
                --indegrees[k];
                if (indegrees[k] == 0) {
                    queue.offer(k);
                }
            }
        }

        return visited == numCourses;
    }
}

210.课程表II

题目

法1：入度表（BFS）

BFS更简单实现！！！

class Solution {
    public int[] findOrder(int numCourses, int[][] prerequisites) {
        List<Integer> res = new ArrayList<>();
        Queue<Integer> queue = new LinkedList<>();
        int[] indegrees = new int[numCourses];
        List<List<Integer>> adjacency = new ArrayList<>();
        for (int i = 0; i < numCourses; ++i) {
            adjacency.add(new ArrayList<>());
        }
        for (int[] arr : prerequisites) {
            ++indegrees[arr[0]];
            adjacency.get(arr[1]).add(arr[0]);
        }
        for (int i = 0; i < numCourses; ++i) {
            if (indegrees[i] == 0) {
                queue.offer(i);
            }
        }

        while (!queue.isEmpty()) {
            int topInx = queue.poll();
            res.add(topInx);
            for (int k : adjacency.get(topInx)) {
                --indegrees[k];
                if (indegrees[k] == 0) {
                    queue.offer(k);
                }
            }
        }
        
        if (res.size() == numCourses) {
            int[] resArray = new int[numCourses];
            for (int i = 0; i < res.size(); ++i) {
                resArray[i] = res.get(i);
            }

            return resArray;
        }

        return new int[0];
    }
}