目录
[1. 矩阵](#1. 矩阵)
介绍
最短路径问题有单源最短路径、多源最短路径、边权为 1 的最短路径、带负环的最短路等等。
目前我们学了，边权为 1 的最短路径。
单源最短路径
- 前面一个专题用BFS 解决 边权为 1 的最短路径问题，都是单源最短路径问题。
一个起点一个终点 求最短路径
多源最短路径
- 多个起点一个终点 求从多个起点出发到终点的最短路径问题。
多源 BFS
- 用 BFS 解决边权为 1 的多源最短路径问题。
- 不管是单源还是多源只要用 BFS 解决边权都是为1的。
- 边权是其他的是不能用BFS解决。
- 也就是只要是用BFS解决最短路径问题，必须都是边权为1 ！
如何解决?
解法一：暴力，把多源最短路径问题转化成若干个单源最短路径问题。
- 也就是说给我若干个起点，用BFS暴力枚举出所有起点到终点的最短路径
- 然后取其中最短的路径。大概率是会超时的。
解法二：把所有的源点当成一个 超级源点 ，问题就变成了单一的单源最短路径问题
- 意思就是给我很多起点，我想办法把这些起点当成一个起点，问题就变长了从这一个超级起点开始到终点的最短路径了。
- 仅需从这个超级起点出发来一次BFS就可以了。
这里可能会有疑惑，把所有起点当成一个超级起点出发最终得到的路径是正确答案吗？
- 这里我们感性的理解一下，所有起点的小人同时向外走一步。
- 它们同时向外走一步，我们是可以舍去很多点的。
- 比如有的起点小人向外走一步但是这一步已经被其他小人走过了，所以说从这个点向外走一步肯定没有其他点向外走一步更好，因此就可以舍去这个点。
- 然后就相当于从超级起点出发向外走一步。
- 把不好的都舍去 只把好的保留，这就是超级源点干的事情。
- 因为只保留好的，所以到达某一点绝对是最短的。
如何写代码呢？
这里的重点就是如何把所有起点搞成一个超级起点呢？
特别简单，我们回忆一下 边权为1 单源最短路径问题 用 BFS 怎么解决，分为两步：
- 把起点加入到队列
- 一层一层往外扩
如何把所有起点搞成一个超级起点呢？
- 把所有起点加入到队列
- 一层一层往外扩
1. 矩阵
题目链接： 542. 01 矩阵
给定一个由 0 和 1 组成的矩阵 mat ，请输出一个大小相同的矩阵，其中每一个格子是 mat 中对应位置元素到最近的 0 的距离。
两个相邻元素间的距离为 1 。
题解
给一个m*n的矩阵mat
- 返回一个同等大小的矩阵
- 并且矩阵中每个格子都是到达0的最短距离。
解法一：一个位置一个位置求
- 遍历一下矩阵，一个一个位置BFS求到0的最短距离，但是会超时。
解法二：多源BFS + 正难则反
我们可以把所有的1当成一个超级起点，然后从这个起点做一次BFS
- 但是如果把1作为起点有一个致命问题，你更新不出来结果，把1当成超级起点从1找到0之后那是那个1到达的0？
- 并且又如何回到开始位置去更新1到0的最短距离呢？
正着来起点到终点最短距离，那反着来终点到起点最短距离也是没问题的。
所以，把所有的 0 当成起点，1 当成终点，当扩展到1的时候直接把距离更新到对应1的位置就行了。
- 把所有的 0 位置加入到队列中
- 一层一层的向外扩即可
刚开始遍历一下把所有0加入到队列中同时也把dist中对应位置更新成0，然后一层一层往外扩
- 我们是把队列中元素拿出来 上下左右 四个方向像外扩。
- 当层序遍历结束之后这个dist也就填完了。把dist返回就可以了。
这里有一些细节问题：
回忆求边权为 1 的单源最短路径
- 我们写代码时是需要一个bool类型vis二维数组标记当前位置是否被搜索过
- 并且层序遍历中还需要step记录当前扩展到那一层，sz记录当前队列中的元素是把队列中所有元素都往外扩一层，结合step知道当前扩展到这一层的步数是多少。
这道题我们仅需一个dist二维数组就行了，不需要上面三个东西。
- 先看这个bool数组，其实我们可以把dist数组里面的值全部都初始化-1来标记当前位置没有被搜索过。
- step和sz也不用要，我们直接从dist数组中就可以更新下一个位置中dist的值，之前是从[a，b] 上下左右扩展 [x，y]，这次从[a，b] 扩展到 [x，y] dist中已经记录[a，b]位置的值了，仅需dist[x][y] = dist[a][b] + 1 即可。
而且也不用搞一个sz一层一层往外扩，我们可以一个元素一个元素往下扩，原因就是dist已经标记当前元素是处于那一层的。
class Solution {
public:
typedef pair<int,int> PII;
int dx[4]={0,0,1,-1};
int dy[4]={1,-1,0,0};
vector<vector<int>> updateMatrix(vector<vector<int>>& mat)
{
queue<PII> q;
int m=mat.size();
int n=mat[0].size();
vector<vector<int>> dist(m,vector<int>(n,-1));
for(int i=0;i<m;i++)
{
for(int j=0;j<n;j++)
{
if(mat[i][j]==0)
{
q.push({i,j});
dist[i][j]=0;
}
}
}
while(q.size())
{
auto [a,b]=q.front();
q.pop();
for(int i=0;i<4;i++)
{
int x=a+dx[i],y=b+dy[i];
if(x>=0 && x<m && y>=0 && y<n
&& dist[x][y]==-1)
{
q.push({x,y});
dist[x][y]=dist[a][b]+1;
}
}
}
return dist;
}
};2.飞地的数量
链接： 1020. 飞地的数量
给你一个大小为 m x n 的二进制矩阵 grid ，其中 0 表示一个海洋单元格、1 表示一个陆地单元格。
一次 移动 是指从一个陆地单元格走到另一个相邻（上、下、左、右 ）的陆地单元格或跨过 grid 的边界。
返回网格中无法在任意次数的移动中离开网格边界的陆地单元格的数量。
题解
返回矩阵中无法通过边界离开网格的陆地的数量。
解法一：一个一个去判断
遍历矩阵当遇到一个1的时候就去判断能不能走出去。时间复杂度很恐怖。
- 但是可以一个一个去判断做一些优化，当遇到一个1的时候先做一次BFS看与这个1相连的连通块能不能到边界
- 如果能的话，然后再来一次BFS统计1的个数并且标记一下该位置已经被搜索过，如果不能的话把这块地方标记为0。
- 需要写两份不同的BFS代码。
解法二：多源BFS + 正难则反
-
我不判断1这个位置能不能走到边界，而是 判断边界上的1能不能走到你。
-
把所有边界1当作一个超级起点向内搜索，把搜索到的1都标记一下表明这些位置都是能走出去的。
-
最后再搜索一下看看哪些 1 是没被标记过的统计一下就是答案。
class Solution {
public:
typedef pair<int,int> PII;
int dx[4]={0,0,1,-1};
int dy[4]={1,-1,0,0};int numEnclaves(vector<vector<int>>& grid) { int m=grid.size(); int n=grid[0].size(); queue<PII> q; int count=0; for(int i=0;i<m;i++) { for(int j=0;j<n;j++) { if((i==0 || i==m-1 || j==0 || j==n-1) && (grid[i][j]==1)) { grid[i][j]=2; q.push({i,j}); } } } while(q.size()) { auto [a,b]=q.front(); q.pop(); for(int i=0;i<4;i++) { int x=a+dx[i],y=b+dy[i]; if(x>=0 && x<m && y>=0 && y<n && grid[x][y]==1) { q.push({x,y}); grid[x][y]=2; } } } for(int i=0;i<m;i++) { for(int j=0;j<n;j++) { if(grid[i][j]==1) count++; } } return count; }};
3.地图中的最高点
题目链接： 1765. 地图中的最高点
给你一个大小为 m x n 的整数矩阵 isWater ，它代表了一个由 陆地 和 水域 单元格组成的地图。
- 如果
isWater[i][j] == 0，格子(i, j)是一个 陆地 格子。 - 如果
isWater[i][j] == 1，格子(i, j)是一个 水域 格子。
你需要按照如下规则给每个单元格安排高度：
- 每个格子的高度都必须是非负的。
- 如果一个格子是 水域 ，那么它的高度必须为
0。 - 任意相邻的格子高度差 至多 为
1。当两个格子在正东、南、西、北方向上相互紧挨着，就称它们为相邻的格子。（也就是说它们有一条公共边）
找到一种安排高度的方案，使得矩阵中的最高高度值 最大 。
请你返回一个大小为 m x n 的整数矩阵 height ，其中 height[i][j] 是格子 (i, j) 的高度。如果有多种解法，请返回 任意一个 。
题解
给一个m*n的矩阵，格子里面0代表陆地，1代表水域。
按照下面要去给每个格子安排高度：
- 每个格子的高度都必须是非负的。
- 如果一个格子是 水域 ，那么它的高度必须为 0 。
任意相邻的格子高度差 至多 为 1 。当两个格子在正东、南、西、北方向上相互紧挨着，就称它们为相邻的格子。（也就是说它们有一条公共边）
- 找到一种安排高度的方案，使得矩阵中的最高高度值 最大 。
解法：多源 bfs
按照上面的要求，我们可以先安排水域，如果你安排其他地方，它要受它上下左右的控制才行不能随意给一个数。
将所有水域变成0然后按照多源BFS走一次就行了。
-
因为要求高度值最大，因此每个临近位置都+1往外扩。
-
这里和前面一道题几乎一模一样
class Solution {
public:
typedef pair<int,int> PII;
int dx[4]={0,0,1,-1};
int dy[4]={1,-1,0,0};vector<vector<int>> highestPeak(vector<vector<int>>& isWater) { //先找到 水域=0 int m=isWater.size(); int n=isWater[0].size(); vector<vector<int>> dist(m,vector<int>(n,-1)); queue<PII> q; for(int i=0;i<m;i++) { for(int j=0;j<n;j++) { if(isWater[i][j]==1) { q.push({i,j}); dist[i][j]=0; } } } while(q.size()) { auto [a,b]=q.front(); q.pop(); for(int i=0;i<4;i++) { int x=a+dx[i],y=b+dy[i]; if(x>=0 && x<m && y>=0 && y<n && dist[x][y]==-1) { q.push({x,y}); dist[x][y]=dist[a][b]+1; } } } return dist; }};
4.地图分析
链接： 1162. 地图分析
你现在手里有一份大小为 n x n 的 网格 grid，上面的每个 单元格 都用 0 和 1 标记好了。其中 0 代表海洋，1 代表陆地。
请你找出一个海洋单元格，这个海洋单元格到离它最近的陆地单元格的距离是最大的，并返回该距离。如果网格上只有陆地或者海洋，请返回 -1。
我们这里说的距离是「曼哈顿距离」（ Manhattan Distance）：(x0, y0) 和 (x1, y1) 这两个单元格之间的距离是 |x0 - x1| + |y0 - y1| 。
给一个 n x n 的 网格 grid，上面的每个 单元格 都用 0 和 1 标记好了。
- 其中 0 代表海洋，1 代表陆地。
- 找出一个 0 海洋单元格，这个 0 海洋单元格到离它最近的 1 陆地单元格，距离是最大的，并返回该距离。
- 如果网格上只有陆地或者海洋，请返回 -1。
「曼哈顿距离」（ Manhattan Distance）：
- (x0, y0) 和 (x1, y1) 这两个单元格之间的距离是 |x0 - x1| + |y0 - y1| 。
- 其实就是最短路径
解法： 多源BFS + 正难则反
从 0 海洋找 1 陆地不好找路径，反过来从陆地 1 到 0 海洋。
陆地 dist 初始为0。
class Solution {
public:
typedef pair<int,int> PII;
int dx[4]={0,0,1,-1};
int dy[4]={1,-1,0,0};
int maxDistance(vector<vector<int>>& grid)
{
int n=grid.size();
vector<vector<int>> dist(n,vector<int>(n,-1));
queue<PII> q;
for(int i=0;i<n;i++)
{
for(int j=0;j<n;j++)
{
if(grid[i][j]==1)
{
dist[i][j]=0;
q.push({i,j});
}
}
}
int ret=-1;
while(q.size())
{
auto [a,b]=q.front();
q.pop();
for(int i=0;i<4;i++)
{
int x=a+dx[i],y=b+dy[i];
if(x>=0 && x<n && y>=0 && y<n
&& dist[x][y]==-1)
{
q.push({x,y});
dist[x][y]=dist[a][b]+1;
ret=max(ret,dist[x][y]);
}
}
}
return ret;
}
};