本文总结了LeetCode中的图论问题解决方案，涉及矩阵更新、腐烂橘子扩散、省份数量计数、岛屿识别、最短路径、所有路径查找、课程表安排、转盘锁解码、单词接龙等，重点讲解了深度优先、广度优先、超级源点等核心算法应用。
Leetcode记录库数据结构篇之五：图
结论
一些很主观的东西，归根到底可能还是自己的实力不够：
图的问题一般有以下几种解决方法：深度优先、广度优先、超级源、计数连通分量
1 542. 01 矩阵
思路描述
- 超级源点
- 将所有的起点抽象为一个超级源点，通过这样的方式计算其他各点到目标点的最小距离。
- 时空复杂度O(r × c), O(r × c)
代码实现
class Solution {
int[] dx = {1, 0, 0, -1}; // 左右移动
int[] dy = {0, 1, -1, 0}; // 上下移动
int r, c;
public int[][] updateMatrix(int[][] mat) {
// 广度优先
r = mat.length;
c = mat[0].length;
if (r == 0 && c == 0) return mat;
int[][] ansmat = new int[r][c];
boolean[][] visited = new boolean[r][c];
Queue<int[]> q = new LinkedList<>();
int i, j, x, y, mx, my;
int[] cell;
for (i = 0; i < r; i++) { // 构建超级源点
for (j = 0; j < c; j++) {
if (mat[i][j] == 0) {
visited[i][j] = true;
q.offer(new int[]{i, j});
}
}
}
// 广度搜索
while (!q.isEmpty()) {
cell = q.poll();
x = cell[0];
y = cell[1];
for (i = 0; i < 4; i++) {
mx = x + dx[i];
my = y + dy[i];
if (mx > -1 && mx < r && my > -1 && my < c && !visited[mx][my]) { // 从
ansmat[mx][my] = ansmat[x][y] + 1;
visited[mx][my] = true;
q.offer(new int[]{mx, my});
}
}
}
return ansmat;
}
}
注意事项
- 注意事项
拓展延伸
- 空
2 994. 腐烂的橘子
思路描述
- 超级源点
- 将所有的起点抽象为一个超级源点，通过这样的方式计算其他各点到目标点的最小距离。
- 将所有的坏橘子作为超级源点，记录下一共进行了几次“广度遍历”，广度遍历的次数就是能够坏掉的所有橘子的最小时间。
- 这个问题有点像传染病，只不过传染病的病源还会移动。
- 时空复杂度O(r × c), O(r × c)
代码实现
class Solution {
int[] dx = new int[]{1, -1, 0, 0};
int[] dy = new int[]{0, 0, 1, -1};
public int orangesRotting(int[][] grid) {
// 超级源点
int m = grid.length, n = grid[0].length;
int mins = 0;
Queue<int[]> rot = new LinkedList<>();
boolean[][] visited = new boolean[m][n];
boolean flag = false;
int i, j;
// 收集超级源点
for (i = 0; i < m; i++) {
for (j = 0; j < n; j++) {
if (grid[i][j] == 2) {
rot.offer(new int[]{i, j});
visited[i][j] = true;
}
if (grid[i][j] == 1) flag = true;
}
}
if (!flag) return 0;
// 更新
int x, y, mx, my, size;
int[] cell;
while (!rot.isEmpty()) {
flag = false;
size = rot.size();
for (j = 0; j < size; j++) {
cell = rot.poll();
x = cell[0];
y = cell[1];
for (i = 0; i < 4; i++) {
mx = x + dx[i];
my = y + dy[i];
if (mx > -1 && mx < m && my > -1 && my < n && grid[mx][my] == 1 && !visited[mx][my]) {
flag = true;
grid[mx][my] = 2;
visited[mx][my] = true;
rot.offer(new int[]{mx, my});
}
}
}
if (flag) {
mins++;
}
}
// 查看是否还有新鲜橘子
for (i = 0; i < m; i++) {
for (j = 0; j < n; j ++) {
if (grid[i][j] == 1) {return -1;}
}
}
return mins;
}
}
注意事项
- 注意事项
拓展延伸
- 空
3 547. 省份数量
思路描述
- 图的问题，数图中的连通分量的个数
- 深度优先，逮住一个点取查询它和其他点的连接情况，把一次能够遍历到的点都标记为已经访问过了，然后连通分量个数++；重复这个过程直到图中所有点都已经访问过了。
- 时空复杂度n2，1
代码实现
class Solution {
int n;
boolean[] visited;
public int findCircleNum(int[][] isConnected) {
n = isConnected.length;
if (n == 1) {return 1;}
int ans = 0;
visited = new boolean[n];
for (int i = 0; i < n; i++) {
if (!visited[i]) {
dfs(isConnected, i);
ans++;
}
}
return ans;
}
private void dfs(int[][] isConnected, int i) {
visited[i] = true;
for (int j = 0; j < n; j++) {
if (!visited[j] && isConnected[i][j] == 1) {
dfs(isConnected, j);
}
}
}
}
注意事项
- 二
拓展延伸
- 同
4 200. 岛屿数量
思路描述
- 图的问题
- 深度遍历和回溯问题
- 递归的方式比较好写，这次写的非递归的
- 好像……广度优先只能使用队列以非递归的形式实现，而深度优先就是适合使用递归实现。
- 时空复杂度O(m * n)和O(m * n)
- 有关空间复杂度，可以通过改变原始数据，每次遇到‘1’后，改变它为’0’，就可以起到visited数组的作用。这样就可以将visited数组的空间节省下来。可是，递归、栈以及队列的空间还是不能省，所以空间复杂度还是O(m * n)
代码实现
// 非递归深度优先
class Solution {
int[] dx = {1, 0, 0, -1};
int[] dy = {0, 1, -1, 0};
boolean[][] visited;
int m, n;
public int numIslands(char[][] grid) {
m = grid.length;
n = grid[0].length;
visited = new boolean[m][n];
Stack<Integer> s = new Stack<Integer>(); // 非递归深度优先，如果写广度优先的话使用队列queue
int ans = 0, x, y;
for (int i = 0; i < m; i++) {
for (int j = 0; j < n; j++) {
if (!visited[i][j] && grid[i][j] == '1') {
ans++;
s.push(i); // 先压x
s.push(j); // 再压y
while (!s.isEmpty()) {
y = (int) s.pop(); // 先出y
x = (int) s.pop(); // 再出x
if (x > - 1 && x < m && y > -1 && y < n && !visited[x][y] && grid[x][y] == '1') {
visited[x][y] = true;
for (int k = 0; k < 4; k++) {
s.push(x + dx[k]); // 先压x
s.push(y + dy[k]); // 再压y
}
}
}
}
}
}
return ans;
}
}
注意事项
- 二
拓展延伸
1.下面是深度优先递归实现和广度优先实现：
// 深度优先递归实现
class Solution {
int[] dx = {1, 0, 0, -1};
int[] dy = {0, 1, -1, 0};
boolean[][] visited;
int m, n;
public int numIslands(char[][] grid) {
m = grid.length;
n = grid[0].length;
int ans = 0;
visited = new boolean[m][n];
for (int i = 0; i < m; i++) {
for (int j = 0; j < n; j++) {
if (grid[i][j] == '1' && !visited[i][j]) {
dfs(grid, i, j);
ans++;
}
}
}
return ans;
}
private void dfs(char[][] grid, int i, int j) {
visited[i][j] = true;
int a = i, b = j;
for (int k = 0; k < 4; k++) {
i = a + dx[k];
j = b + dy[k];
if (i >= 0 && i < m && j >= 0 && j < n && grid[i][j] == '1' && !visited[i][j]) {
dfs(grid, i, j);
}
}
}
}
// 广度优先
class Solution {
int[] dx = {1, 0, 0, -1};
int[] dy = {0, 1, -1, 0};
boolean[][] visited;
int m, n;
public int numIslands(char[][] grid) {
m = grid.length;
n = grid[0].length;
visited = new boolean[m][n];
Queue<Integer> q = new LinkedList<Integer>(); // 非递归深度优先，如果写非递归广度优先的话使用队列queue
int ans = 0, x, y;
for (int i = 0; i < m; i++) {
for (int j = 0; j < n; j++) {
if (!visited[i][j] && grid[i][j] == '1') {
ans++;
q.offer(i); // 先压x
q.offer(j); // 再压y
while (!q.isEmpty()) {
x = (int) q.poll(); // 再出x
y = (int) q.poll(); // 先出y
if (x > - 1 && x < m && y > -1 && y < n && !visited[x][y] && grid[x][y] == '1') {
visited[x][y] = true;
for (int k = 0; k < 4; k++) {
q.offer(x + dx[k]); // 先压x
q.offer(y + dy[k]); // 再压y
}
}
}
}
}
}
return ans;
}
}
5 1091. 二进制矩阵中的最短路径
思路描述
- 图的问题
- 虽然这道题使用深度优先也可以做，但是会超时。所以就使用广度优先比较好。
- 使用广度优先遍历时需要记录什么时候走完了一个轮次，就和树的层次遍历求解树的高度时需要记录什么时候走完了一层一样，需要首先获取一下当前队列的size，作为计数。
- 时空复杂度O(n2)，O(n2)
代码实现
class Solution {
//移动到八个方向的坐标差值
int[] dx = new int[]{1,0,0,-1,1,1,-1,-1};
int[] dy = new int[]{0,1,-1,0,1,-1,1,-1};
public int shortestPathBinaryMatrix(int[][] grid) {
int n = grid.length;
//左上角和右下角为1都不可达, 结束
if (grid[0][0] == 1 || grid[n-1][n-1] == 1){
return -1;
}
//加入起始的左上角节点, 加入的节点要置为非0(这里统一置为1)
Queue<int[]> q = new LinkedList<>();
q.add(new int[]{0,0});
grid[0][0] = 1;
int minPath = 1;
while (!q.isEmpty()){
int size = q.size(); // 获取每层bfs遍历的点数
for (int i = 0; i < size; i++) { // 当循环结束时说明结束了一轮的深度遍历，此时将最短路径++
int[] point = q.poll();
int row = point[0];
int column = point[1];
//遍历到右下点, 结束
if (row == n - 1 && column == n - 1){
return minPath;
}
// 取当前点的八个方向的坐标点判断是否存在为0的坐标点, 存在则进入下一轮bfs处理
for (int j = 0; j < 8; j++) {
int x = row + dx[j];
int y = column + dy[j];
if (x >=0 && x < n && y >= 0 && y < n && grid[x][y] == 0){
// 加入的节点要置为非0(这里统一置为1)
grid[x][y] = 1;
q.add(new int[]{x, y});
}
}
}
minPath++; // 遍历完当一轮的深度遍历（当前一层）, 路径+1
}
// 从左上角开始所有可达的0坐标点都置为1后(不可达的0是不会置为1的), 无法到达右下点, 故没有路径可以到达
return -1;
}
}
注意事项
- 二
拓展延伸
- 什么时候使用深度遍历什么时候使用广度遍历？
答：当问题的目标是求最短的路径，或者问题的逻辑明显是需要从某一个点辐射状的向外扩张时，需要使用广度优先遍历；
如果问题只是要我们要找到一个解，那么深度优先比较好。
很明显本题和 “6 994. 腐烂的橘子”相同，解决问题的逻辑都是从某一个点辐射状向外扩张来求解，所以使用广度优先遍历。 - 当使用广度优先遍进行解体时，需要和层次遍历一样，记录每一趟的队列size，其实图和树是共通的，层次遍历时树是一层一层遍历的，其实图的广度优先和树的层次遍历是一样的也是“一层一层”的只不过树是自上而下的，图是辐射状的，不信可以自己画图看一下。
6 797. 所有可能的路径
思路描述
- 寻找路径，这个最好使用深度优先遍历的方式。
- 找到一条记录下来，然后回溯再找其他路。
- 应为使用的是邻接矩阵，所以不用单独设立visited矩阵来记录点的访问情况。
- 时空复杂度O(n2n)和O(n)，其中 n 为图中点的数量。我们可以找到一种最坏情况，即每一个点都可以去往编号比它大的点。此时路径数为 O(2n)，且每条路径长度为 O(n)，因此总时间复杂度为 O(n2n)。
代码实现
class Solution {
List<List<Integer>> ans = new ArrayList<>();
Stack<Integer> s = new Stack<>();
public List<List<Integer>> allPathsSourceTarget(int[][] graph) {
s.push(0);
dfs(graph, 0, graph.length - 1);
return ans;
}
private void dfs(int[][] graph, int i, int n) {
if (i == n) {
ans.add(new ArrayList<>(s));
return;
}
for (int p : graph[i]) {
s.push(p);
dfs(graph, p, n);
s.pop();
}
return;
}
}
注意事项
- 二
拓展延伸
- 什
7 剑指 Offer 12. 矩阵中的路径
思路描述
- 经典的图的问题，深度遍历就可以解决，记录的原因是在这道题里学到了：如果把方向移动的变量定义为全局变量的话会影响一点执行速度。会差大概1到2ms。
- 时空复杂度O(3KMN)和O(word.length)
代码实现
class Solution {
public boolean exist(char[][] board, String word) {
char[] wordarr = word.toCharArray();
int m = board.length, n = board[0].length, len = wordarr.length;
for(int i = 0; i < m; i++) {
for(int j = 0; j < n; j++) {
if(board[i][j] == wordarr[0] && dfs(i, j, board, m, n, wordarr, len, 0)) return true;
}
}
return false;
}
boolean dfs(int i, int j, char[][] board, int m, int n, char[] word, int len, int k) {
if(i >= m || i < 0 || j >= n || j < 0 || board[i][j] != word[k]) return false;
if(k == len - 1) return true;
board[i][j] += 128;
boolean res = dfs(i - 1, j, board, m, n, word, len, k + 1) ||
dfs(i + 1, j, board, m, n, word, len, k + 1) ||
dfs(i, j - 1, board, m, n, word, len, k + 1) ||
dfs(i, j + 1, board, m, n, word, len, k + 1);
board[i][j] -= 128;
return res;
}
}
注意事项
- 二
拓展延伸
- 什
8 207. 课程表
思路描述
- 图的问题，判断图中是否存在环，深度优先遍历或者广度优先遍历就可以了
代码实现
// 判断有向图中是否存在环
// 首先要构建一个邻接表，记录每一门课程的前置依赖课程
// 如果题目是无向图，当边数大于节点的个数，一定存在环
class Solution {
public boolean canFinish(int numCourses, int[][] prerequisites) {
List<List<Integer>> adjacency = new ArrayList<>(); // 邻接表
for(int i = 0; i < numCourses; i++)
adjacency.add(new ArrayList<>()); // 对于每一门课程，建立一个链表，来存此门课程的前驱课程
for(int[] cp : prerequisites)
adjacency.get(cp[1]).add(cp[0]); // 存储cp[1]是哪些课程的前置依赖课程,构建邻接表
int[] flags = new int[numCourses]; // 每个课程，是否否访问过0没有访问过；-1在其他轮访问过而且顺利访问结束，说明没有环，可以终止访问；1在本轮访问过，说明出现了环
for(int i = 0; i < numCourses; i++) // 遍历每一门课程的前驱课程
if(hasCycle(adjacency, flags, i)) // 如果存在环则不能顺利完成课程
return false; // 返回false
return true;
}
private boolean hasCycle(List<List<Integer>> adjacency, int[] flags, int i) {
if(flags[i] == -1) return false; // 接下来的访问顺序已经在其它轮中走过了，顺利结束，不存在环
if(flags[i] == 1) return true; // 当前这个节点在本轮中已经访问过了，这次又访问到了！存在环
flags[i] = 1; // 先将标志位置为在本轮中访问了
for(Integer j : adjacency.get(i)) // 深度优先访问每一个后续课程
if(hasCycle(adjacency, flags, j)) return true;
flags[i] = -1; // 将标志位置为-1给下一轮使用
return false;
}
}
思路描述
- 图的问题，判断图中是否存在环，深度优先遍历或者广度优先遍历就可以了
代码实现
// 广度优先
// 如果一个课程没有任何的前置课程需要学习，那么我们就先把它学了，
// 然后看看有哪些课程依赖于刚刚学过的课程，可以让那些课程的依赖课程数目也减一，当这些课程的前置依赖课程也减到0时，它们也就可以进行学习了
// 将这些能够学习的课程放到栈中，不断出栈，记录当前学了的课程的数目，然后也不断的将新的可以学习的课程放入到栈中
// 重复上面这个过程，知道没有可以学习的课程了
// 判断我们学习了的课程数目和目标要学的课程数目是否相同，相同：能够学完，不同：不能学完，有环
class Solution {
public boolean canFinish(int numCourses, int[][] prerequisites) {
List<List<Integer>> adj = new ArrayList<List<Integer>>();
for (int i = 0; i < numCourses; i++) {
adj.add(new ArrayList<Integer>()); // 构建邻接表
}
int[] indegree = new int[numCourses];
for (int[] cp : prerequisites) {
indegree[cp[0]]++; // cp0的依赖课程数目++
adj.get(cp[1]).add(cp[0]); // cp1是cp0的前置课程
}
Deque<Integer> s = new LinkedList<>();
for (int i = 0; i < numCourses; i++) {
if (indegree[i] == 0) s.push(i); // 将当前可以学的课程记录到栈中
}
int canLearnCourseNum = 0;
while (!s.isEmpty()) {
canLearnCourseNum++; // 学了的课程数目++
int zeroPre = s.pop();
for (int i : adj.get(zeroPre)) { // 这些课程的前置依赖课程可以减少一个了
indegree[i]--;
if (indegree[i] == 0) s.push(i); // 如果这个课程的前置依赖课程减到了0，说明这个课程也可以进行学习了
}
}
return canLearnCourseNum == numCourses;
}
}
注意事项
- 二
拓展延伸
- 什
9 752. 打开转盘锁
思路描述
代码实现
// bfs
// 广度搜索，可以确保我们的当搜到答案时，这颗搜索树是最矮的（但是可能比较胖），也就是说步数是最少的。
// 如果使用深搜的话，我们需要将所有的可能空间都走一遍，最后在取最小的步数，时间复杂度要大于广搜
// 通过 枚举 当前状态的下一步所有可能状态，我们判断是不是找到了 target
// 没有，把下一步的可能状态放入队列中等待下一步的搜索
// 找了，直接返回当前步数。
class Solution {
public int openLock(String[] deadends, String target) {
if ("0000".equals(target)) { // 特殊情况，如果 target 状态就是初始状态
return 0; // 直接返回，0步就可以变成目标状态
}
Set<String> dead = new HashSet<String>();
for (String deadend : deadends) { // 使用set将所有的死锁状态保存，如果后面在转换状态时遇到了，说明这个状态走不通了
dead.add(deadend);
}
if (dead.contains("0000")) { // 如果死锁状态中包含初始状态
return -1; // 说明初始状态无法变成 target 状态，返回-1
}
int step = 0; // 记录步数
Queue<String> queue = new LinkedList<String>(); // 广度优先暂存队列
queue.offer("0000"); // 初始状态入队
Set<String> seen = new HashSet<String>(); // 用一个 set 保存之前访问过的状态，如果之前访问过这个状态，那么我们就不用重复搜索了
seen.add("0000");
while (!queue.isEmpty()) { // 广度优先，当 queue 不为空时继续循环
++step; // 步数++
int size = queue.size(); // 广度优先
for (int i = 0; i < size; ++i) {
String status = queue.poll(); // 从队列中取出要遍历的状态
for (String nextStatus : get(status)) { // 枚举当前状态的下一个状态
if (!seen.contains(nextStatus) && !dead.contains(nextStatus)) { // 如果没见过这个状态，而且也不是死锁状态
if (nextStatus.equals(target)) {
return step; // 返回第一次遇到目标状态时的步数
}
queue.offer(nextStatus); // 添加新的需要迭代的状态
seen.add(nextStatus); // 将当前状态标志为seen
}
}
}
}
return -1; // 如果一直没遇到
}
// 枚举当前的 status 通过一次旋转能够得到的数字
public List<String> get(String status) {
List<String> ret = new ArrayList<String>();
char[] array = status.toCharArray();
for (int i = 0; i < 4; ++i) {
char num = array[i];
array[i] = numPrev(num); // 将当前这个数字向前拨
ret.add(new String(array)); // 得到一个状态
array[i] = numSucc(num); // 向后拨
ret.add(new String(array)); // 得到一个状态
array[i] = num; // 复原这位数字，相当于不改变这一位数字，我们去改变下一位（回溯）
}
return ret; // 返回下一个状态可能的集合
}
public char numPrev(char x) { // 将当前这个数字向前拨一位
return x == '0' ? '9' : (char) (x - 1);
}
public char numSucc(char x) { // 将当前这个数字向后拨一位
return x == '9' ? '0' : (char) (x + 1);
}
}
注意事项
- 二
拓展延伸
- 什
10 127. 单词接龙
思路描述
- 时空复杂度O() O()
代码实现
// 和转盘锁一样的思路
// 广搜能够得到最矮的从起点到终点的树
class Solution {
public int ladderLength(String beginWord, String endWord, List<String> wordList) {
int wordListLen = wordList.size();
HashSet<String> wordListSet = new HashSet<>();
for (String word : wordList) {
wordListSet.add(word);
}
if (!wordListSet.contains(endWord)) { // 判断endWord有没有存在于wordList中
return 0;
}
Deque<String> q = new LinkedList<>(); // 广度优先暂存队列
HashSet<String> usedWordsSet = new HashSet<>(); // 用过的在wordList中的单词，后面就不用再次使用了
q.offer(beginWord);
int step = 0, qSize;
String curWord;
while (!q.isEmpty()) { // 广度优先
step++;
qSize = q.size();
for (int i = 0; i < qSize; i++) { // 广度优先的一层
curWord = q.poll();
usedWordsSet.add(curWord);
for (String nextWord : getNextChangeWord(curWord)) { // 枚举每一个单词的下一个转换
if (wordListSet.contains(nextWord) && !usedWordsSet.contains(nextWord)) {
if (nextWord.equals(endWord)) {
return step + 1;
}
q.offer(nextWord);
}
}
}
}
return 0;
}
private List<String> getNextChangeWord(String curWord) {
int len = curWord.length();
char[] curWordArr = curWord.toCharArray();
List<String> nextWords = new LinkedList<>();
char curChar;
for (int i = 0; i < len; i++) { // 轮流更换每一位的curWord的字符
curChar = curWordArr[i];
for (char c = 'a'; c <= 'z'; c++) {
if (c != curChar) {
curWordArr[i] = c;
nextWords.add(new String(curWordArr)); // 添加到下一个能变成的单词中
}
}
curWordArr[i] = curChar; // 更换了的字符复原，因为我们要改变下一位字符
}
return nextWords;
}
}
注意事项
- 二
拓展延伸
- 什
扫一扫
1069
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
