目录
⑦力扣LCR 130. 衣橱整理(原剑指Offer13机器人的运动范围)
①力扣733. 图像渲染
难度 简单
有一幅以 m x n
的二维整数数组表示的图画 image
,其中 image[i][j]
表示该图画的像素值大小。
你也被给予三个整数 sr
, sc
和 newColor
。你应该从像素 image[sr][sc]
开始对图像进行 上色填充 。
为了完成 上色工作 ,从初始像素开始,记录初始坐标的 上下左右四个方向上 像素值与初始坐标相同的相连像素点,接着再记录这四个方向上符合条件的像素点与他们对应 四个方向上 像素值与初始坐标相同的相连像素点,……,重复该过程。将所有有记录的像素点的颜色值改为 newColor
。
最后返回 经过上色渲染后的图像 。
示例 1:
输入: image = [[1,1,1],[1,1,0],[1,0,1]],sr = 1, sc = 1, newColor = 2 输出: [[2,2,2],[2,2,0],[2,0,1]] 解析: 在图像的正中间,(坐标(sr,sc)=(1,1)),在路径上所有符合条件的像素点的颜色都被更改成2。 注意,右下角的像素没有更改为2,因为它不是在上下左右四个方向上与初始点相连的像素点。
示例 2:
输入: image = [[0,0,0],[0,0,0]], sr = 0, sc = 0, newColor = 2 输出: [[2,2,2],[2,2,2]]
提示:
m == image.length
n == image[i].length
1 <= m, n <= 50
0 <= image[i][j], newColor < 2^16
0 <= sr < m
0 <= sc < n
class Solution {
public:
vector<vector<int>> floodFill(vector<vector<int>>& image, int sr, int sc, int color) {
}
};
解析代码
算法思路:利用深搜DFS或者宽搜BFS,遍历到与该点相连的所有像素相同的点,然后将其修改成指定的像素即可。宽搜BFS之前写过了,现在用深搜DFS写一遍:
class Solution {
int dx[4] = {0, 0, -1, 1};
int dy[4] = {1, -1, 0, 0};
int m, n;
int prev;
public:
vector<vector<int>> floodFill(vector<vector<int>>& image, int sr, int sc, int color) {
prev = image[sr][sc];
if(prev == color)
return image;
m = image.size(), n = image[0].size();
dfs(image, sr, sc, color);
return image;
}
void dfs(vector<vector<int>>& image, int sr, int sc, int color)
{
image[sr][sc] = color;
for(int i = 0; i < 4; ++i)
{
int x = sr + dx[i], y = sc + dy[i];
if(x >= 0 && x < m && y >= 0 && y < n && image[x][y] == prev)
{
dfs(image, x, y, color);
}
}
}
};
②力扣200. 岛屿数量
难度 中等
给你一个由 '1'
(陆地)和 '0'
(水)组成的的二维网格,请你计算网格中岛屿的数量。
岛屿总是被水包围,并且每座岛屿只能由水平方向和/或竖直方向上相邻的陆地连接形成。
此外,你可以假设该网格的四条边均被水包围。
示例 1:
输入:grid = [ ["1","1","1","1","0"], ["1","1","0","1","0"], ["1","1","0","0","0"], ["0","0","0","0","0"] ] 输出:1
示例 2:
输入:grid = [ ["1","1","0","0","0"], ["1","1","0","0","0"], ["0","0","1","0","0"], ["0","0","0","1","1"] ] 输出:3
提示:
m == grid.length
n == grid[i].length
1 <= m, n <= 300
grid[i][j]
的值为'0'
或'1'
class Solution {
public:
int numIslands(vector<vector<char>>& grid) {
}
};
解析代码
遍历整个矩阵,每次找到一块陆地的时候:说明找到一个岛屿,记录到最终结果 ret 里面。
并且将这个陆地相连的所有陆地,也就是这块岛屿,全部变成海洋。这样的话,下次遍历到这块岛屿的时候,它已经是海洋了,不会影响最终结果。
其中变成海洋的操作,可以利用深搜或宽搜解决,其实就是力扣733. 图像渲染这道题。这样,遍历完全部的矩阵的时候, ret 存的就是最终结果,之前用宽搜写过现在用深搜写。
(这里用全局bool数组来判断陆地是否被遍历过,也可以直接修改数组,面试的时候可以问面试官是否可以直接修改数组,现在就建议不修改原数组)
class Solution {
int dx[4] = {0, 0 , -1, 1}; // i点加dx,dy就是i点的上下左右下标
int dy[4] = {1, -1 , 0, 0};
bool vis[301][301] = {false}; // 开题目范围大小
int m, n, ret;
public:
int numIslands(vector<vector<char>>& grid) {
m = grid.size(), n = grid[0].size();
for(int i = 0; i < m; ++i)
{
for(int j = 0; j < n; ++j)
{
if(grid[i][j] == '1' && !vis[i][j])
{
++ret;
dfs(grid, i, j); // 标记周围的1
}
}
}
return ret;
}
void dfs(vector<vector<char>>& grid, int sr, int sc)
{
vis[sr][sc] = true;
for(int i = 0; i < 4; ++i)
{
int x = sr + dx[i], y = sc + dy[i];
if(x >= 0 && x < m && y >= 0 && y < n && !vis[x][y] && grid[x][y] == '1')
{
dfs(grid, x, y);
}
}
}
};
③力扣695. 岛屿的最大面积
难度 中等
给你一个大小为 m x n
的二进制矩阵 grid
。
岛屿 是由一些相邻的 1
(代表土地) 构成的组合,这里的「相邻」要求两个 1
必须在 水平或者竖直的四个方向上 相邻。你可以假设 grid
的四个边缘都被 0
(代表水)包围着。
岛屿的面积是岛上值为 1
的单元格的数目。
计算并返回 grid
中最大的岛屿面积。如果没有岛屿,则返回面积为 0
。
示例 1:
输入:grid = [[0,0,1,0,0,0,0,1,0,0,0,0,0],[0,0,0,0,0,0,0,1,1,1,0,0,0],[0,1,1,0,1,0,0,0,0,0,0,0,0],[0,1,0,0,1,1,0,0,1,0,1,0,0],[0,1,0,0,1,1,0,0,1,1,1,0,0],[0,0,0,0,0,0,0,0,0,0,1,0,0],[0,0,0,0,0,0,0,1,1,1,0,0,0],[0,0,0,0,0,0,0,1,1,0,0,0,0]] 输出:6 解释:答案不应该是 11 ,因为岛屿只能包含水平或垂直这四个方向上的 1 。
示例 2:
输入:grid = [[0,0,0,0,0,0,0,0]] 输出:0
提示:
m == grid.length
n == grid[i].length
1 <= m, n <= 50
grid[i][j]
为0
或1
class Solution {
public:
int maxAreaOfIsland(vector<vector<int>>& grid) {
}
};
解析代码
遍历整个矩阵,每当遇到一块土地的时候,就用深搜或者宽搜将与这块土地相连的整个岛屿的面积计算出来。然后在搜索得到的所有的岛屿面积求一个最大值即可。
在搜索过程中,为了防止搜到重复的土地,可以开一个同等规模的bool数组,标记一下这个位置是否已经被访问过,也可以将原始矩阵的 1 修改成 0 ,但是这样操作会修改原始矩阵。
class Solution {
int dx[4] = {0, 0 , -1, 1}; // i点加dx,dy就是i点的上下左右下标
int dy[4] = {1, -1 , 0, 0};
bool vis[51][51] = {false};
int m = 0, n = 0, cnt = 0;
public:
int maxAreaOfIsland(vector<vector<int>>& grid) {
m = grid.size(), n = grid[0].size();
int ret = 0;
for(int i = 0; i < m; ++i)
{
for(int j = 0; j < n; ++j)
{
if(grid[i][j] == 1 && !vis[i][j])
{
cnt = 1;
ret = max(ret, dfs(grid, i, j)); // 碰到1就算周围的1并标记
}
}
}
return ret;
}
int dfs(vector<vector<int>>& grid, int sr, int sc)
{
vis[sr][sc] = true;
for(int i = 0; i < 4; ++i)
{
int x = sr + dx[i], y = sc + dy[i];
if(x >= 0 && x < m && y >= 0 && y < n && grid[x][y] == 1 && !vis[x][y])
{
++cnt;
dfs(grid, x, y);
}
}
return cnt;
}
};
④力扣130. 被围绕的区域
难度 中等
给你一个 m x n
的矩阵 board
,由若干字符 'X'
和 'O'
,找到所有被 'X'
围绕的区域,并将这些区域里所有的 'O'
用 'X'
填充。
示例 1:
输入:board = [["X","X","X","X"],["X","O","O","X"],["X","X","O","X"],["X","O","X","X"]] 输出:[["X","X","X","X"],["X","X","X","X"],["X","X","X","X"],["X","O","X","X"]] 解释:被围绕的区间不会存在于边界上,换句话说,任何边界上的 'O' 都不会被填充为 'X'。 任何不在边界上,或不与边界上的 'O' 相连的 'O' 最终都会被填充为 'X'。如果两个元素在水平或垂直方向相邻,则称它们是“相连”的。
示例 2:
输入:board = [["X"]] 输出:[["X"]]
提示:
m == board.length
n == board[i].length
1 <= m, n <= 200
board[i][j]
为'X'
或'O'
class Solution {
public:
void solve(vector<vector<char>>& board) {
}
};
解析代码
正难则反。 可以先利用 bfs 将与边缘相连的 'O' 区域修改成无关字符,然后重新遍历矩阵,将没有标记过的 'O' 全修改成 'X' 即可,再把无关字符全还原成'O'。
class Solution {
int dx[4] = {0, 0, -1, 1};
int dy[4] = {1, -1, 0, 0};
int m = 0, n = 0;
public:
void solve(vector<vector<char>>& board) {
m = board.size(), n = board[0].size();
for(int i = 0; i < n; ++i) // 修改边界的O成无关字符R
{
if(board[0][i] == 'O')
dfs(board, 0, i);
if(board[m - 1][i] == 'O')
dfs(board, m - 1, i);
}
for(int i = 0; i < m; ++i)
{
if(board[i][0] == 'O')
dfs(board, i, 0);
if(board[i][n - 1] == 'O')
dfs(board, i, n - 1);
}
for(int i = 0; i < m; ++i) // 把剩下的O全修改成X,R全修改成O
{
for(int j = 0; j < n; ++j)
{
if(board[i][j] == 'O')
board[i][j] = 'X';
else if(board[i][j] == 'R')
board[i][j] = 'O';
}
}
}
void dfs(vector<vector<char>>& board, int sr, int sc) // 修改边界的O成无关字符R
{
board[sr][sc] = 'R';
for(int i = 0; i < 4; ++i)
{
int x = sr + dx[i], y = sc + dy[i];
if(x >= 0 && x < m && y >= 0 && y < n && board[x][y] == 'O')
{
dfs(board, x, y);
}
}
}
};
⑤力扣417. 太平洋大西洋水流问题
难度 中等
有一个 m × n
的矩形岛屿,与 太平洋 和 大西洋 相邻。 “太平洋” 处于大陆的左边界和上边界,而 “大西洋” 处于大陆的右边界和下边界。
这个岛被分割成一个由若干方形单元格组成的网格。给定一个 m x n
的整数矩阵 heights
, heights[r][c]
表示坐标 (r, c)
上单元格 高于海平面的高度 。
岛上雨水较多,如果相邻单元格的高度 小于或等于 当前单元格的高度,雨水可以直接向北、南、东、西流向相邻单元格。水可以从海洋附近的任何单元格流入海洋。
返回网格坐标 result
的 2D 列表 ,其中 result[i] = [ri, ci]
表示雨水从单元格 (ri, ci)
流动 既可流向太平洋也可流向大西洋 。
示例 1:
输入: heights = [[1,2,2,3,5],[3,2,3,4,4],[2,4,5,3,1],[6,7,1,4,5],[5,1,1,2,4]] 输出: [[0,4],[1,3],[1,4],[2,2],[3,0],[3,1],[4,0]]
示例 2:
输入: heights = [[2,1],[1,2]] 输出: [[0,0],[0,1],[1,0],[1,1]]
提示:
m == heights.length
n == heights[r].length
1 <= m, n <= 200
0 <= heights[r][c] <= 10^5
class Solution {
public:
vector<vector<int>> pacificAtlantic(vector<vector<int>>& heights) {
}
};
解析代码
算法思路:正难则反。
如果直接去判断某一个位置是否既能到大西洋也能到太平洋,会重复遍历很多路径。我们反着来,从大西洋沿岸开始反向 dfs ,这样就能找出那些点可以流向大西洋。同理,从太平洋沿岸也反向 dfs ,这样就能找出那些点可以流向太平洋。那么被标记两次的点,就是要找的结果。
class Solution {
int dx[4] = {0, 0, -1, 1};
int dy[4] = {1, -1, 0, 0};
int m = 0, n = 0;
public:
vector<vector<int>> pacificAtlantic(vector<vector<int>>& heights) {
m = heights.size(), n = heights[0].size();
vector<vector<bool>> vis1(m, vector<bool>(n, false));
vector<vector<bool>> vis2(m, vector<bool>(n, false));
for(int i = 0; i < n; ++i) // 遍历周围
{
dfs(heights, 0, i, vis1); // 太平洋
dfs(heights, m - 1, i, vis2); // 大西洋
}
for(int i = 0; i < m; ++i)
{
dfs(heights, i, 0, vis1); // 太平洋
dfs(heights, i, n - 1, vis2); // 大西洋
}
vector<vector<int>> ret;
for(int i = 0; i < m; i++)
{
for(int j = 0; j < n; j++)
{
if(vis1[i][j] && vis2[i][j])
ret.push_back({i, j});
}
}
return ret;
}
void dfs(vector<vector<int>>& heights, int sr, int sc, vector<vector<bool>>& vis)
{
vis[sr][sc] = true;
for(int i = 0; i < 4; ++i)
{
int x = sr + dx[i], y = sc + dy[i];
if(x >= 0 && x < m && y >= 0 && y < n && !vis[x][y] && heights[x][y] >= heights[sr][sc])
{
dfs(heights, x, y, vis);
}
}
}
};
⑥力扣529. 扫雷游戏
难度 中等
让我们一起来玩扫雷游戏!
给你一个大小为 m x n
二维字符矩阵 board
,表示扫雷游戏的盘面,其中:
'M'
代表一个 未挖出的 地雷,'E'
代表一个 未挖出的 空方块,'B'
代表没有相邻(上,下,左,右,和所有4个对角线)地雷的 已挖出的 空白方块,- 数字(
'1'
到'8'
)表示有多少地雷与这块 已挖出的 方块相邻, 'X'
则表示一个 已挖出的 地雷。
给你一个整数数组 click
,其中 click = [clickr, clickc]
表示在所有 未挖出的 方块('M'
或者 'E'
)中的下一个点击位置(clickr
是行下标,clickc
是列下标)。
根据以下规则,返回相应位置被点击后对应的盘面:
- 如果一个地雷(
'M'
)被挖出,游戏就结束了- 把它改为'X'
。 - 如果一个 没有相邻地雷 的空方块(
'E'
)被挖出,修改它为('B'
),并且所有和其相邻的 未挖出 方块都应该被递归地揭露。 - 如果一个 至少与一个地雷相邻 的空方块(
'E'
)被挖出,修改它为数字('1'
到'8'
),表示相邻地雷的数量。 - 如果在此次点击中,若无更多方块可被揭露,则返回盘面。
示例 1:
输入:board = [["E","E","E","E","E"],["E","E","M","E","E"],["E","E","E","E","E"],["E","E","E","E","E"]], click = [3,0] 输出:[["B","1","E","1","B"],["B","1","M","1","B"],["B","1","1","1","B"],["B","B","B","B","B"]]
示例 2:
输入:board = [["B","1","E","1","B"],["B","1","M","1","B"],["B","1","1","1","B"],["B","B","B","B","B"]], click = [1,2] 输出:[["B","1","E","1","B"],["B","1","X","1","B"],["B","1","1","1","B"],["B","B","B","B","B"]]
提示:
m == board.length
n == board[i].length
1 <= m, n <= 50
board[i][j]
为'M'
、'E'
、'B'
或数字'1'
到'8'
中的一个click.length == 2
0 <= clickr < m
0 <= clickc < n
board[clickr][clickc]
为'M'
或'E'
class Solution {
public:
vector<vector<char>> updateBoard(vector<vector<char>>& board, vector<int>& click) {
}
};
解析代码
模拟类型的 dfs 题目。首先要搞懂题目要求,也就是游戏规则。从题目所给的点击位置开始,根据游戏规则,来一次 dfs 即可。
dfs大步骤就是统计一下周围的地雷个数,有地雷就在当前位置放上周围地雷的个数,然后返回,没有地雷就改当前位置为没有地雷的空白块B,然后dfs周围的未挖出的空方块E。
class Solution {
int dx[8] = {0, 0, 1, -1, 1, 1, -1, -1};
int dy[8] = {1, -1, 0, 0, 1, -1, 1, -1};
int m, n;
public:
vector<vector<char>> updateBoard(vector<vector<char>>& board, vector<int>& click) {
m = board.size(), n = board[0].size();
int x = click[0], y = click[1];
if(board[x][y] == 'M')
{
board[x][y] = 'X';
return board;
}
dfs(board, x, y);
return board;
}
void dfs(vector<vector<char>>& board, int sr, int sc)
{
int cnt = 0;
for(int i = 0; i < 8; ++i)
{
int x = sr + dx[i], y = sc + dy[i];
if(x >= 0 && x < m && y >= 0 && y < n && board[x][y] == 'M')
++cnt;
}
if(cnt != 0)
{
board[sr][sc] = cnt + '0';
return;
}
else // 周围没地雷
{
board[sr][sc] = 'B';
for(int i = 0; i < 8; ++i)
{
int x = sr + dx[i], y = sc + dy[i];
if(x >= 0 && x < m && y >= 0 && y < n && board[x][y] == 'E')
dfs(board, x, y); // 再探索周围的空白块
}
}
}
};
⑦力扣LCR 130. 衣橱整理(原剑指Offer13机器人的运动范围)
难度 中等
家居整理师将待整理衣橱划分为 m x n
的二维矩阵 grid
,其中 grid[i][j]
代表一个需要整理的格子。整理师自 grid[0][0]
开始 逐行逐列 地整理每个格子。
整理规则为:在整理过程中,可以选择 向右移动一格 或 向下移动一格,但不能移动到衣柜之外。同时,不需要整理 digit(i) + digit(j) > cnt
的格子,其中 digit(x)
表示数字 x
的各数位之和。
请返回整理师 总共需要整理多少个格子。
示例 1:
输入:m = 4, n = 7, cnt = 5 输出:18
提示:
1 <= n, m <= 100
0 <= cnt <= 20
class Solution {
public:
int wardrobeFinishing(int m, int n, int cnt) {
}
};
解析代码
一道非常典型的搜索类问题。 可以通过深搜或者宽搜,从 [0, 0] 点出发,按照题目的规则一直往 [m - 1, n - 1] 位置走。 同时设置一个全局变量。每次走到一个合法位置,就将全局变量加一。当我们把所有能走到的路都走完之后,全局变量里面存的就是最终答案。下面是深搜的代码:
class Solution {
int ret, _m, _n, _cnt;
bool vis[101][101];
int dx[4] = {0, 0, -1, 1};
int dy[4] = {1, -1, 0, 0};
public:
int wardrobeFinishing(int m, int n, int cnt) {
_m = m, _n = n, _cnt = cnt;
dfs(0, 0);
return ret;
}
void dfs(int sr, int sc)
{
++ret;
vis[sr][sc] = true;
for(int i = 0; i < 4; ++i)
{
int x = sr + dx[i], y = sc + dy[i];
if(x >= 0 && x < _m && y >= 0 && y < _n && !vis[x][y] && chick(x, y))
dfs(x, y);
}
}
bool chick(int x, int y)
{
int sum = 0;
while(x)
{
sum += (x % 10);
x /= 10;
}
while(y)
{
sum += (y % 10);
y /= 10;
}
return sum <= _cnt;
}
};
本篇完。
下一篇是贪心算法的第三部分。
下下篇是记忆化搜索类型的OJ。