目录
图的逻辑结构和具体实现
一幅图是由节点和边构成的，逻辑结构如下
/* 图节点的逻辑结构 */
class Vertex {
int id;
Vertex[] neighbors;
}实际上面这个很少用，引出了下面两种存储图的方式
邻接表和邻接矩阵
邻接表，好处是占用的空间少，但无法快速判断两个节点是否相邻；连接矩阵，好处是快速判断两个节点是否相邻，但占用的空间多，浪费多。
如果用代码的形式来表现，邻接表和邻接矩阵大概长这样：
无权图
// 邻接表
// graph[x] 存储 x 的所有邻居节点
List<Integer>[] graph;
// 邻接矩阵
// matrix[x][y] 记录 x 是否有一条指向 y 的边
boolean[][] matrix; //true 为有加权图
// 邻接表
// graph[x] 存储 x 的所有邻居节点以及对应的权重
List<int[]>[] graph;
// 邻接矩阵
// matrix[x][y] 记录 x 指向 y 的边的权重，0 表示不相邻
int[][] matrix;例如
List<List<Integer>> allPathsSourceTarget(int[][] graph);输入的这个 graph 其实就是「邻接表」表示的一幅图，graph[i] 存储这节点 i 的所有邻居节点。
比如输入 graph = [[1,2],[3],[3],[]]，就代表下面这幅图：
图的遍历
// 记录所有路径
List<List<Integer>> res = new LinkedList<>();
public List<List<Integer>> allPathsSourceTarget(int[][] graph) {
// 维护递归过程中经过的路径
LinkedList<Integer> path = new LinkedList<>();
traverse(graph, 0, path);
return res;
}
/* 图的遍历框架 */
void traverse(int[][] graph, int s, LinkedList<Integer> path) {
// 添加节点 s 到路径
path.addLast(s);
int n = graph.length;
if (s == n - 1) {
// 到达终点
res.add(new LinkedList<>(path));
// 可以在这直接 return，但要 removeLast 正确维护 path
// path.removeLast();
// return;
// 不 return 也可以，因为图中不包含环，不会出现无限递归
}
// 递归每个相邻节点
for (int v : graph[s]) {
traverse(graph, v, path);
}
// 从路径移出节点 s
path.removeLast();
}力扣第 797 题 力扣
环检测及拓扑排序算法
这两个算法既可以用 DFS 思路解决，也可以用 BFS 思路解决，相对而言 BFS 解法从代码实现上看更简洁一些，但 DFS 解法有助于你进一步理解递归遍历数据结构的奥义，只介绍DFS。
环检测-1
背景：力扣第 207 题 力扣
建图函数
List<Integer>[] buildGraph(int numCourses, int[][] prerequisites) {
// 图中共有 numCourses 个节点
List<Integer>[] graph = new LinkedList[numCourses];
for (int i = 0; i < numCourses; i++) {
graph[i] = new LinkedList<>();
}
for (int[] edge : prerequisites) {
int from = edge[1], to = edge[0];
// 添加一条从 from 指向 to 的有向边
// 边的方向是「被依赖」关系，即修完课程 from 才能修课程 to
graph[from].add(to);
}
return graph;
}判断图中是否存在环
// 防止重复遍历同一个节点
boolean[] visited;
// 从节点 s 开始 DFS 遍历，将遍历过的节点标记为 true
void traverse(List<Integer>[] graph, int s) {
if (visited[s]) {
return;
}
/* 前序遍历代码位置 */
// 将当前节点标记为已遍历
visited[s] = true;
for (int t : graph[s]) {
traverse(graph, t);
}
/* 后序遍历代码位置 */
}模板代码
/ 防止重复遍历同一个节点
boolean[] visited;
boolean canFinish(int numCourses, int[][] prerequisites) {
List<Integer>[] graph = buildGraph(numCourses, prerequisites);
visited = new boolean[numCourses];
for (int i = 0; i < numCourses; i++) {
traverse(graph, i);
}
}
void traverse(List<Integer>[] graph, int s) {
// 代码见上文
}注意图中并不是所有节点都相连，所以要用一个 for 循环将所有节点都作为起点调用一次 DFS 搜索算法。这样，就能遍历这幅图中的所有节点了，你打印一下 visited 数组，应该全是 true。
环检测-2
添加一个布尔数组 onPath 记录当前 traverse 经过的路径
// 记录一次递归堆栈中的节点
boolean[] onPath;
// 记录遍历过的节点，防止走回头路
boolean[] visited;
// 记录图中是否有环
boolean hasCycle = false;
boolean canFinish(int numCourses, int[][] prerequisites) {
List<Integer>[] graph = buildGraph(numCourses, prerequisites);
visited = new boolean[numCourses];
onPath = new boolean[numCourses];
for (int i = 0; i < numCourses; i++) {
// 遍历图中的所有节点
traverse(graph, i);
}
// 只要没有循环依赖可以完成所有课程
return !hasCycle;
}
void traverse(List<Integer>[] graph, int s) {
if (onPath[s]) {
// 出现环
hasCycle = true;
}
if (visited[s] || hasCycle) {
// 如果已经找到了环，也不用再遍历了
return;
}
// 前序代码位置
visited[s] = true;
onPath[s] = true;
for (int t : graph[s]) {
traverse(graph, t);
}
// 后序代码位置
onPath[s] = false;
}
List<Integer>[] buildGraph(int numCourses, int[][] prerequisites) {
// 代码见前文
}结果
不过如果出题人继续恶心你，让你不仅要判断是否存在环，还要返回这个环具体有哪些节点，怎么办？
拓扑排序
背景：扣第 210 题「 课程表 II」
// 方法 1 最简单的 BFS
public int[] findOrder(int numCourses, int[][] prerequisites) {
if (numCourses == 0) return new int[0];
int[] inDegrees = new int[numCourses];
// 建立入度表
for (int[] p : prerequisites) { // 对于有先修课的课程，计算有几门先修课
inDegrees[p[0]]++;
}
// 入度为0的节点队列
Queue<Integer> queue = new LinkedList<>();
for (int i = 0; i < inDegrees.length; i++) {
if (inDegrees[i] == 0) queue.offer(i);
}
int count = 0; // 记录可以学完的课程数量
int[] res = new int[numCourses]; // 可以学完的课程
// 根据提供的先修课列表，删除入度为 0 的节点
while (!queue.isEmpty()){
int curr = queue.poll();
res[count++] = curr; // 将可以学完的课程加入结果当中
for (int[] p : prerequisites) {
if (p[1] == curr){
inDegrees[p[0]]--;
if (inDegrees[p[0]] == 0) queue.offer(p[0]);
}
}
}
if (count == numCourses) return res;
return new int[0];
}二分图
二分图定义
二分图的顶点集可分割为两个互不相交的子集，图中每条边依附的两个顶点都分属于这两个子集，且两个子集内的顶点不相邻。
双色问题
给你一幅「图」，请你用两种颜色将图中的所有顶点着色，且使得任意一条边的两个端点的颜色都不相同，你能做到吗？
二分图判定思路
说白了就是遍历一遍图，一边遍历一边染色，看看能不能用两种颜色给所有节点染色，且相邻节点的颜色都不相同。
题目
力扣第 785 题「 判断二分图」
广度优先
class Solution {
public boolean isBipartite(int[][] graph) {
// 定义 visited 数组，初始值为 0 表示未被访问，赋值为 1 或者 -1 表示两种不同的颜色。
int[] visited = new int[graph.length];
Queue<Integer> queue = new LinkedList<>();
// 因为图中可能含有多个连通域，所以我们需要判断是否存在顶点未被访问，若存在则从它开始再进行一轮 bfs 染色。
for (int i = 0; i < graph.length; i++) {
if (visited[i] != 0) {
continue;
}
// 每出队一个顶点，将其所有邻接点染成相反的颜色并入队。
queue.offer(i);
visited[i] = 1;
while (!queue.isEmpty()) {
int v = queue.poll();
for (int w: graph[v]) {
// 如果当前顶点的某个邻接点已经被染过色了，且颜色和当前顶点相同，说明此无向图无法被正确染色，返回 false。
if (visited[w] == visited[v]) {
return false;
}
if (visited[w] == 0) {
visited[w] = -visited[v];
queue.offer(w);
}
}
}
}
return true;
}
}
并查集（UNION-FIND）
主要是解决图论中「动态连通性」问题的，有四个基本操作。
1、初始化
2.查询和合并
3.路径压缩
首先，让我们来回忆一下find执行的操作：从一个节点，不停的通过parent数组向上去寻找他的根节点，在这个过程中，我们相当于把从这个节点到根节点的这条路径上的所有的节点都给遍历了一遍，那么，让我们想一想，在find的同时，是否可以顺便加上一些其它的操作使得树的层数尽量变得更少呢？答案是可以的。
理解
题目
力扣第 323 题「 无向图中连通分量的数目」
Leetcode 323.无向连通图中的连通分量个数_DrCrypto的博客-CSDN博客_给定一个无向边列表
public int countComponents(int n, int[][] edges) {
UF uf = new UF(n);
// 将每个节点进行连通
for (int[] e : edges) {
uf.union(e[0], e[1]);
}
// 返回连通分量的个数
return uf.count();
}
class UF {
// 见下文
}class UF {
// 连通分量个数
private int count;
// 存储每个节点的父节点
private int[] parent;
// n 为图中节点的个数
public UF(int n) {
this.count = n;
parent = new int[n];
for (int i = 0; i < n; i++) {
parent[i] = i;
}
}
// 将节点 p 和节点 q 连通
public void union(int p, int q) {
int rootP = find(p);
int rootQ = find(q);
if (rootP == rootQ)
return;
parent[rootQ] = rootP;
// 两个连通分量合并成一个连通分量
count--;
}
// 判断节点 p 和节点 q 是否连通
public boolean connected(int p, int q) {
int rootP = find(p);
int rootQ = find(q);
return rootP == rootQ;
}
public int find(int x) {
if (parent[x] != x) {
parent[x] = find(parent[x]);
}
return parent[x];
}
// 返回图中的连通分量个数
public int count() {
return count;
}
}
最小生成树算法
Prim 算法（普里姆算法）
Kruskal 算法（克鲁斯卡尔算法）
int minimumCost(int n, int[][] edges) {
// 编号为 0...n
UF uf = new UF(n + 1);
// 对所有边按照权重从小到大排序
Arrays.sort(edges, (a, b) -> (a[2] - b[2]));
// 记录最小生成树的权重之和
int mst = 0;
for (int[] edge : edges) {
int u = edge[0];
int v = edge[1];
int weight = edge[2];
// 若这条边会产生环，则不能加入 mst
if (uf.connected(u, v)) {
continue;
}
// 若这条边不会产生环，则属于最小生成树
mst += weight;
uf.union(u, v);
}
// 保证所有节点都被连通
// uf.count() == 1 说明所有节点被连通
return uf.count() == 1 ? mst : -1;
}
class UF {
// 见 并查集总结 的实现
}最路径算法
图的最短路算法有很多，在此记录一下非常常用的三个算法
- 单源最短路
不带负权边：Dijkstra
带负权边：Bellman-Ford、SPFA
- 多源最短路
FloydFloyd
题目：
Dijkstra
class Solution {
public int networkDelayTime(int[][] times, int N, int K) {
// 构建邻接表，用于存放各个点到各个点的距离
int[][] graph = new int[N + 1][N + 1];
for (int i = 1; i <= N; i++) {
for (int j = 1; j <= N; j++) {
graph[i][j] = -1;
}
}
// 遍历times填充邻接表
for (int[] time : times) {
graph[time[0]][time[1]] = time[2];
}
// 存放 K 到各个点的最短路径，最大的那个最短路径即为结果
int[] distance = new int[N + 1];
Arrays.fill(distance, -1);
// 初始化 distance 为 K 到各个节点的距离
for (int i = 1; i <= N; i++) {
distance[i] = graph[K][i];
}
// K到达K本身的节点初始化为 0
distance[K] = 0;
// 判断是否找到K到达该点最短路径
boolean[] visited = new boolean[N + 1];
visited[K] = true;
// 遍历除K本身节点之外的所有N-1个节点
for (int i = 1; i <= N - 1; i++) {
int minDistance = Integer.MAX_VALUE;
int minIndex = 1;
// 遍历所有节点，找到离K最近的节点
for (int j = 1; j <= N; j++) {
if (!visited[j] && distance[j] != -1 && distance[j] < minDistance) {
minDistance = distance[j];
minIndex = j;
}
}
// 标记最近距离节点找到
visited[minIndex] = true;
// 根据刚刚找到的最短距离节点，通过该节点更新K节点与其他的节点的距离
for (int j = 1; j <= N; j++) {
// 如果已更新的最短节点可以到达当前节点
if (graph[minIndex][j] != -1) {
if (distance[j] != -1) {
// 取之前路径与当前更新路径的最小值
distance[j] = Math.min(distance[j], distance[minIndex] + graph[minIndex][j]);
} else {
// 该节点是第一次访问，直接更新
distance[j] = distance[minIndex] + graph[minIndex][j];
}
}
}
}
int maxDistance = 0;
// 遍历最大值，如果有节点未被访问，返回 -1，否则返回最大最短路径
for (int i = 1; i <= N; i++) {
if (distance[i] == -1) {
return -1;
}
maxDistance = Math.max(distance[i], maxDistance);
}
return maxDistance;
}
}
FloydFloyd
参考
365
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
