文章目录
- 拓扑排序介绍
- 如何构造拓扑排序(⭐重要!)
- 例题:848. 有向图的拓扑序列
- BFS 写法构造拓扑排序
- 相关题目练习
- 207. 课程表(判断是否存在拓扑序列)
- bfs 写法
- dfs 写法
- 210. 课程表 II(找到一个拓扑序列)
- 1136. 并行课程(找拓扑序列过程中记录最少学期数)
- 2050. 并行课程 III(边带值的拓扑序列,好题!🐂)
- 444. 序列重建(将问题转换成拓扑排序)
- 269. 火星词典(需要考虑情况比较多的题目,需要细心)
- 相关资料
拓扑排序介绍
https://oi-wiki.org/graph/topo/
本文主要学习拓扑排序相关知识。
拓扑排序的英文名是 Topological sorting。
拓扑排序要解决的问题是给一个 有向无环图 的所有节点排序。
我们可以拿大学每学期排课的例子来描述这个过程,比如学习大学课程中有:程序设计,算法语言,高等数学,离散数学,编译技术,普通物理,数据结构,数据库系统等。按照例子中的排课,当我们想要学习 数据结构 的时候,就必须先学会 离散数学 和 编译技术。当然还有一个更加前的课程 算法语言。这些课程就相当于几个顶点 u, 顶点之间的有向边 (u,v) 就相当于学习课程的顺序。教务处安排这些课程,使得在逻辑关系符合的情况下排出课表,就是拓扑排序的过程。
但是如果某一天排课的老师打瞌睡了,说想要学习 数据结构,还得先学 操作系统,而 操作系统 的前置课程又是 数据结构,那么到底应该先学哪一个(不考虑同时学习的情况)?在这里,数据结构 和 操作系统 间就出现了一个环,显然你现在没办法弄清楚你需要学什么了,于是你也没办法进行拓扑排序了。因为如果有向图中存在环路,那么我们就没办法进行 拓扑排序。
因此我们可以说 在一个 DAG(有向无环图) 中,我们将图中的顶点以线性方式进行排序,使得对于任何的顶点 u 到 v 的有向边 (u,v), 都可以有 u 在 v 的前面。
还有给定一个 DAG,如果从 i 到 j 有边,则认为 j 依赖于 i。如果 i 到 j 有路径(i 可达 j),则称 j 间接依赖于 i。
拓扑排序的目标是将所有节点排序,使得排在前面的节点不能依赖于排在后面的节点。
由于有环的图没有拓扑序列,因此拓扑排序还可以判断图中是否有环。
如何构造拓扑排序(⭐重要!)
- 从图中选择一个入度为零的点。
- 输出该顶点,从图中删除此顶点及其所有的出边。
重复上面两步,直到所有顶点都输出,拓扑排序完成,或者图中不存在入度为零的点,此时说明图是有环图,拓扑排序无法完成,陷入死锁。
例题:848. 有向图的拓扑序列
BFS 写法构造拓扑排序
思路按照:
- 从图中选择一个入度为零的点。
- 输出该顶点,从图中删除此顶点及其所有的出边。
重复上面两步,直到所有顶点都输出,拓扑排序完成,或者图中不存在入度为零的点,此时说明图是有环图,拓扑排序无法完成,陷入死锁。
import java.util.*;public class Main {static List<Integer>[] g; // 用来建图static int[] in; // 存储各个节点的入度static int n, m;public static void main(String[] args){Scanner scanner = new Scanner(System.in);n = scanner.nextInt();m = scanner.nextInt();g = new ArrayList[n + 1];in = new int[n + 1];Arrays.setAll(g, e -> new ArrayList<Integer>());for (int i = 0; i < m; ++i) {int a = scanner.nextInt(), b = scanner.nextInt();g[a].add(b);in[b]++; // b 的入度 + 1}bfs();}static void bfs() {Queue<Integer> q = new LinkedList<>();boolean[] st = new boolean[n + 1];// 将所有初始入度 = 0 的节点放入队列for (int i = 1; i <= n; ++i) {if (in[i] == 0) {q.offer(i);st[i] = true;}}List<Integer> res = new ArrayList<>();while (!q.isEmpty()) {int x = q.poll();res.add(x);for (int y: g[x]) { // 将 x 的子节点 y 的入度 - 1in[y]--;if (!st[y] && in[y] == 0) {st[y] = true;q.offer(y);}}}if (res.size() == n) { // 如果都放进序列了,说明存在拓扑序列for (int v: res) System.out.print(v + " ");} else System.out.println("-1");;}
}
这道题是有向无环图,因此是可以不使用 st 数组存储节点是否已经被访问过。修改后的代码如下:
import java.util.*;public class Main {static List<Integer>[] g; // 用来建图static int[] in; // 存储各个节点的入度static int n, m;public static void main(String[] args){Scanner scanner = new Scanner(System.in);n = scanner.nextInt();m = scanner.nextInt();g = new ArrayList[n + 1];in = new int[n + 1];Arrays.setAll(g, e -> new ArrayList<Integer>());for (int i = 0; i < m; ++i) {int a = scanner.nextInt(), b = scanner.nextInt();g[a].add(b);in[b]++; // b 的入度 + 1}bfs();}static void bfs() {Queue<Integer> q = new LinkedList<>();// 将所有初始入度 = 0 的节点放入队列for (int i = 1; i <= n; ++i) {if (in[i] == 0) q.offer(i);}List<Integer> res = new ArrayList<>();while (!q.isEmpty()) {int x = q.poll();res.add(x);for (int y: g[x]) { // 将 x 的子节点 y 的入度 - 1if (--in[y] == 0) q.offer(y);}}if (res.size() == n) { // 如果都放进序列了,说明存在拓扑序列for (int v: res) System.out.print(v + " ");} else System.out.println("-1");;}
}
相关题目练习
207. 课程表(判断是否存在拓扑序列)
https://leetcode.cn/problems/course-schedule/
bfs 写法
class Solution {List<Integer>[] g;int[] in;public boolean canFinish(int numCourses, int[][] prerequisites) {g = new ArrayList[numCourses];Arrays.setAll(g, e -> new ArrayList<Integer>());in = new int[numCourses];for (int[] prerequisity: prerequisites) {g[prerequisity[0]].add(prerequisity[1]);in[prerequisity[1]]++;}int sum = 0;Queue<Integer> q = new LinkedList<Integer>();for (int i = 0; i < numCourses; ++i) {if (in[i] == 0) {q.offer(i);sum++;}}while (!q.isEmpty()) {int x = q.poll();for (int y: g[x]) {if (--in[y] == 0) {sum++;q.offer(y);}} }return sum == numCourses;}
}
dfs 写法
相比于 bfs 写法, dfs 写法多开了一个 st 数组用来存储各个节点是否已经被访问过了。
class Solution {List<Integer>[] g;boolean[] st;int[] in;int sum = 0;public boolean canFinish(int numCourses, int[][] prerequisites) {g = new ArrayList[numCourses];Arrays.setAll(g, e -> new ArrayList<Integer>());in = new int[numCourses];st = new boolean[numCourses];for (int[] prerequisity: prerequisites) {g[prerequisity[0]].add(prerequisity[1]);in[prerequisity[1]]++;}for (int i = 0; i < numCourses; ++i) {if (in[i] == 0) {dfs(i);}}return sum == numCourses;}public void dfs(int x) {if (st[x]) return;++sum;st[x] = true;for (int y: g[x]) {if (--in[y] == 0) {dfs(y);}}}
}
210. 课程表 II(找到一个拓扑序列)
https://leetcode.cn/problems/course-schedule-ii/description/
对上一题的代码进行简单修改即可,把找到的拓扑序列存下来。
class Solution {List<Integer>[] g;List<Integer> ans = new ArrayList();int[] in;public int[] findOrder(int numCourses, int[][] prerequisites) {g = new ArrayList[numCourses];Arrays.setAll(g, e -> new ArrayList<Integer>());in = new int[numCourses];for (int[] prerequisity: prerequisites) {g[prerequisity[1]].add(prerequisity[0]);in[prerequisity[0]]++;}Queue<Integer> q = new LinkedList<Integer>();for (int i = 0; i < numCourses; ++i) {if (in[i] == 0) {q.offer(i);ans.add(i);}}while (!q.isEmpty()) {int x = q.poll();for (int y: g[x]) {if (--in[y] == 0) {ans.add(y);q.offer(y);}} }if (ans.size() == numCourses) return ans.stream().mapToInt(Integer::intValue).toArray();else return new int[]{};}
}
上一题是用 sum 记录可以学的课程数目,这一题是把可学的课程都放进 ans 列表中。
另外还有一道题:630. 课程表 III,但是和 拓扑排序 没什么关系。
1136. 并行课程(找拓扑序列过程中记录最少学期数)
https://leetcode.cn/problems/parallel-courses/
在 bfs 的过程中记录走了几步即可。
class Solution {List<Integer>[] g;int[] in;public int minimumSemesters(int n, int[][] relations) {in = new int[n + 1];g = new ArrayList[n + 1];Arrays.setAll(g, e -> new ArrayList());for (int[] r: relations) {g[r[0]].add(r[1]);in[r[1]]++;}int ans = 0, sum = 0; // ans记录答案,sum记录学了几个课程Queue<Integer> q = new LinkedList();for (int i = 1; i <= n; ++i) {if (in[i] == 0) {q.offer(i);sum++;}}while (!q.isEmpty()) {int sz = q.size();for (int i = 0; i < sz; ++i) {int x = q.poll();for (int y: g[x]) {if (--in[y] == 0) {++sum;q.offer(y);}}}++ans;}return sum == n? ans: -1;}
}
还有一道题目1494. 并行课程 II 可见:从集合论到位运算——常见位运算技巧及相关习题 & 状态压缩DP
2050. 并行课程 III(边带值的拓扑序列,好题!🐂)
https://leetcode.cn/problems/parallel-courses-iii/
是 https://leetcode.cn/problems/parallel-courses/ 的进阶版,学完每门课程的需要花费的时间是不一样的。
借助优先队列,每次取出队列中最先完成的课程,检查完成这个课程后是否有新的课程可以开始学习即可。
最终的答案就是完成最后一门课程时的时间。
class Solution {List<Integer>[] g;int[] in;public int minimumTime(int n, int[][] relations, int[] time) {in = new int[n + 1];g = new ArrayList[n + 1];Arrays.setAll(g, e -> new ArrayList());for (int[] r: relations) {g[r[0]].add(r[1]);in[r[1]]++;}int ans = 0; // ans记录答案// 按照完成时间升序排序的优先队列PriorityQueue<int[]> pq = new PriorityQueue<int[]>((a, b) -> a[1] - b[1]);for (int i = 1; i <= n; ++i) {if (in[i] == 0) {pq.offer(new int[]{i, time[i - 1]});}}while (!pq.isEmpty()) {int[] cur = pq.poll();ans = cur[1];for (int y: g[cur[0]]) {if (--in[y] == 0) {pq.offer(new int[]{y, ans + time[y - 1]});}}}return ans;}
}
444. 序列重建(将问题转换成拓扑排序)
https://leetcode.cn/problems/sequence-reconstruction/
题目数据保证了所有 sequences[i] 都是 nums 的子序列,因此 nums 一定是一个超序列,如果序列有唯一一个超序列,那么这一唯一的超序列一定是 nums 。
在构造拓扑序列的过程中,如果每次只有一个节点的入度是 0 ,那么构造的拓扑序列就是唯一的,则答案返回 true,否则中间过程一旦检查到同时有两个节点的入度变成了 0,那么就返回 false。
class Solution {public boolean sequenceReconstruction(int[] nums, List<List<Integer>> sequences) {int n = nums.length;List<Integer>[] g = new ArrayList[n + 1];int[] in = new int[n + 1];Arrays.setAll(g, e -> new ArrayList<Integer>()); for (List<Integer> s: sequences) {for (int i = 0; i < s.size() - 1; i++) {g[s.get(i)].add(s.get(i + 1));in[s.get(i + 1)]++;}}Queue<Integer> q = new LinkedList<Integer>();boolean f = false;int sum = 0;for (int i = 1; i <= n; ++i) {if (in[i] == 0) {++sum;if (f) return false;f = true;q.offer(i);}}while (!q.isEmpty()) {if (q.size() > 1) return false;int x = q.poll();for (int y: g[x]) {if (--in[y] == 0) {q.offer(y);sum++;}}}return sum == n;}
}
269. 火星词典(需要考虑情况比较多的题目,需要细心)
https://leetcode.cn/problems/alien-dictionary/
提示:
1 <= words.length <= 100
1 <= words[i].length <= 100
words[i] 仅由小写英文字母组成
这题比较麻烦,有多个情况需要考虑。
class Solution {public String alienOrder(String[] words) {Set<Character>[] g = new HashSet[128];Arrays.setAll(g, e -> new HashSet<Character>());int n = words.length;int[] in = new int[128];Set<Character> letters = new HashSet();// 记录所有出现的字符for (String word: words) {for (char ch: word.toCharArray()) letters.add(ch);}// 构造字符之间的顺序关系for (int i = 0; i < n; ++i) {for (int j = i + 1; j < n; ++j) {String a = words[i], b = words[j];for (int k = 0; k < a.length(); ++k) {if (k >= b.length()) return ""; // 前面的字符都一样但长的排在前面了不合理char x = a.charAt(k), y = b.charAt(k);if (x != y) { if (g[y].contains(x)) return ""; // 和之前的顺序冲突了if (!g[x].contains(y)) {g[x].add(y);in[y]++;}break;}}}}// bfs 寻找拓扑序列StringBuilder ans = new StringBuilder();Queue<Character> q = new LinkedList<Character>();for (char letter: letters) {if (in[letter] == 0) {q.offer(letter);ans.append(letter);}}while (!q.isEmpty()) {char x = q.poll();for (char y: g[x]) {if (--in[y] == 0) {q.offer(y);ans.append(y);}}}return ans.toString();}
}
相关资料
https://oi-wiki.org/graph/topo/
更多关于拓扑排序的题目可见:https://leetcode.cn/tag/topological-sort/problemset/