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)
{
if (image[sr][sc] == color) return image;
m = image.size(), n = image[0].size();
prev = image[sr][sc];
dfs(image, sr, sc, color);
return image;
}
void dfs(vector<vector<int>>& image, int i, int j, int color)
{
image[i][j] = color;
for (int k = 0; k < 4; k++)
{
int x = i + dx[k], y = j + dy[k];
if (x >= 0 && x < m && y >=0 && y < n && image[x][y] == prev)
{
dfs(image, x, y, color);
}
}
}
};
class Solution
{
vector<vector<bool>> vis;
int m, n;
public:
int numIslands(vector<vector<char>>& grid)
{
m = grid.size(), n = grid[0].size();
vis = vector<vector<bool>>(m, vector<bool>(n));
int ret = 0;
for (int i = 0; i < m; i++)
for (int j = 0; j < n; j++)
{
if (!vis[i][j] && grid[i][j] == '1')
{
ret++;
dfs(grid, i, j);
}
}
return ret;
}
int dx[4] = {0, 0, 1, -1};
int dy[4] = {1, -1, 0, 0};
void dfs(vector<vector<char>>& grid, int i, int j)
{
vis[i][j] = true;
for (int k = 0; k < 4; k++)
{
int x = i + dx[k], y = j + dy[k];
if (x >= 0 && x < m && y >= 0 && y < n && grid[x][y] == '1' && !vis[x][y])
{
dfs(grid, x, y);
}
}
}
};
a. 遍历整个数组，发现⼀块没有遍历到的土地之后，就用 dfs ，将与这块土地相连的岛屿的面积求出来；
b. 然后将面积更新到最终结果 ret 中。
深搜函数 dfs 中：
a. 能够进到 dfs 函数中，说明是一个没遍历到的位置；
b. 标记一下已经遍历过，设置一个变量 S = 1 （当前这个位置的面积为 1 ），记录最终的面积；
c. 上下左右遍历四个位置：
如果找到⼀块没有遍历到的土地，就将与这块土地相连的岛屿面积累加到 S 上；
d. 循环结束后， S 中存的就是整块岛屿的面积，返回即可。
🌴算法代码：
cpp复制代码
class Solution
{
vector<vector<bool>> vis;
int m, n;
int dx[4] = {0, 0, 1, -1};
int dy[4] = {1, -1, 0, 0};
int count;
public:
int maxAreaOfIsland(vector<vector<int>>& grid)
{
m = grid.size(), n = grid[0].size();
vis = vector<vector<bool>>(m, vector<bool>(n));
int ret = 0;
for (int i = 0; i < m; i++)
for (int j = 0; j < n; j++)
{
if (!vis[i][j] && grid[i][j] == 1)
{
count = 0;
dfs (grid, i, j);
ret = max(ret, count);
}
}
return ret;
}
void dfs (vector<vector<int>>& grid, int i, int j)
{
count++;
vis[i][j] = true;
for (int k = 0; k < 4; k++)
{
int x = i + dx[k], y = j + dy[k];
if (x >= 0 && x < m && y >= 0 && y < n && !vis[x][y] && grid[x][y] == 1)
{
dfs (grid, x, y);
}
}
}
};
class Solution
{
int dx[4] = {0, 0, 1, -1};
int dy[4] = {1, -1, 0, 0};
int m, n;
public:
void solve(vector<vector<char>>& board)
{
m = board.size(), n = board[0].size();
// 1.把与边界相连的连通块 'O' 修改成 '.'
for (int j = 0; j < n; j++)
{
if (board[0][j] == 'O') dfs(board, 0, j);
if (board[m - 1][j] == 'O') dfs(board, m - 1, j);
}
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);
}
// 2.还原
for (int i = 0; i < m; i++)
for (int j = 0; j < n; j++)
{
if (board[i][j] == '.') board[i][j] = 'O';
else if (board[i][j] == 'O') board[i][j] = 'X';
}
}
void dfs(vector<vector<char>>& board, int i, int j)
{
board[i][j] = '.';
for (int k = 0; k < 4; k++)
{
int x = i + dx[k], y = j + dy[k];
if (x >= 0 && x < m && y >= 0 && y < n && board[x][y] == 'O')
{
dfs(board, x, y);
}
}
}
};
