目录
一、463. 岛屿的周长
给定一个 row x col 的二维网格地图 grid ，其中：grid[i][j] = 1 表示陆地， grid[i][j] = 0 表示水域。
网格中的格子 水平和垂直 方向相连（对角线方向不相连）。整个网格被水完全包围，但其中恰好有一个岛屿（或者说，一个或多个表示陆地的格子相连组成的岛屿）。
岛屿中没有“湖”（“湖” 指水域在岛屿内部且不和岛屿周围的水相连）。格子是边长为 1 的正方形。网格为长方形，且宽度和高度均不超过 100 。计算这个岛屿的周长。
示例 1：
输入：grid = [[0,1,0,0],[1,1,1,0],[0,1,0,0],[1,1,0,0]]
输出：16
解释：它的周长是上面图片中的 16 个黄色的边
【解法一】
//随便找到第一个1的位置判断它的四面环绕情况
// 从这个位置出发上下左右遍历每一块陆地
// 遇到新的陆地并且没有走过就DFS
int nextP[4][2] = {{0,1},{0,-1},{1,0},{-1,0}};
class Solution {
public:
int dfs(vector<vector<int>>& grid, int curX, int curY, vector<vector<bool>>& book, int row, int col)
{
int line = 0;
// 如果左边是边界或者为海line++
if(curY==0 || grid[curX][curY-1]==0)
line++;
if(curY==col-1 || grid[curX][curY+1]==0)
line++;
if(curX==0 || grid[curX-1][curY]==0)
line++;
if(curX==row-1 || grid[curX+1][curY]==0)
line++;
book[curX][curY] = true;
for(int i = 0; i < 4; i++)
{
int newX = curX + nextP[i][0];
int newY = curY + nextP[i][1];
if(newX<0||newX>=row||newY<0||newY>=col)
continue;//越界
if(book[newX][newY]==false && grid[newX][newY]==1)// 新的陆地并没有走过
line += dfs(grid, newX, newY, book, row, col);
}
return line;
}
int islandPerimeter(vector<vector<int>>& grid) {
//随便找到第一个1的位置判断它的四面环绕情况
// 从这个位置出发上下左右遍历每一块陆地
// 遇到新的陆地并且没有走过就DFS
int curX = 0;
int curY = 0;
int row = grid.size();
int col = grid[0].size();
for(int i = 0; i < row; i++)
{
int flag = 0;
for(int j = 0; j < col; j++)
{
if(grid[i][j]==1)
{
curX = i;
curY = j;
flag = 1;
break;
}
}
if(flag==1)break;
}
vector<vector<bool>> book(row,vector<bool> (col, false));
return dfs(grid, curX, curY, book, row, col);
}
};【解法二】数学思维
每块陆地有四条边，如果俩块陆地接壤就会少俩条边
依次从左到右从上到下遍历grid，如果遇到陆地land++，如果该陆地下或者右为陆地那么接壤+=2
class Solution {
public:
int islandPerimeter(vector<vector<int>>& grid) {
int row = grid.size();
int col = grid[0].size();
int land = 0;
int boder = 0;
for(int i = 0; i < row; i++)
{
for(int j = 0; j < col; j++)
{
if(grid[i][j]==1)
{
land++;
if(i+1<row &&grid[i+1][j]==1)
boder++;
if(j+1<col &&grid[i][j+1]==1)
boder++;
}
}
}
return 4*land-2*boder;
}
};二、 130. 被围绕的区域
给你一个 m x n 的矩阵 board ，由若干字符 'X' 和 'O' ，找到所有被 'X' 围绕的区域，并将这些区域里所有的 'O' 用 'X' 填充。
输入：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'。如果两个元素在水平或垂直方向相邻，则称它们是“相连”的。
第一个思路是for循环从（1,1）下标开始遍历，并判断是否被围绕（想想都复杂果断抛弃）
直接去在边界上找可以连通的把不被围绕的找出来重新赋值
for(int i = 0; i < row; i++)
{
for(int j= 0; j < col; j++)
{
if(board[i][j]=='Z')
board[i][j] = 'O';// if(board[i][j]=='O') 错误！！！
else if(board[i][j]=='O')
board[i][j] = 'X';
} 又犯这个小错误，if与if进行二次判断，在第一次的结果上进行修改结果错误
} 双if相同判断会进行数据二次修改，尽量使用else if
int nextP[4][2] = {{0,1},{0,-1},{1,0},{-1,0}};
class Solution {
public:
void dfs(vector<vector<char>>& board, int curX, int curY, vector<vector<bool>>&book, int row, int col)
{
// 进行赋值为Z
board[curX][curY] = 'Z';
book[curX][curY] = true;
// 进行上下左右搜索
for(int i = 0; i < 4; i++)
{
int newX = curX + nextP[i][0];
int newY = curY + nextP[i][1];
// 越界检测
if(newX<0||newX>=row
|| newY<0||newY>=col)
continue;
// book标志位可以不用加入
//if(book[newX][newY]==false && board[newX][newY]=='O')
if(board[newX][newY]=='O')
dfs(board, newX, newY, book, row, col);
}
}
void solve(vector<vector<char>>& board) {
if(board.empty())return;
int row = board.size();
int col = board[0].size();
vector<vector<bool>> book(row, vector<bool>(col, false));
for(int i = 0; i < row; i++)
{
if(board[i][0]=='O' && book[i][0]==false)
dfs(board, i, 0, book,row,col);
if(board[i][col-1]=='O'&&book[i][col-1]==false)
dfs(board,i, col-1, book,row,col);
}
for(int j = 1; j < col; j++)
{
if(board[0][j]=='O'&&book[0][j]==false)
dfs(board, 0, j, book,row,col);
if(board[row-1][j]=='O'&&book[row-1][j]==false)
dfs(board, row-1, j, book,row,col);
}
for(int i = 0; i < row; i++)
{
for(int j= 0; j < col; j++)
{
if(board[i][j]=='Z')
board[i][j] = 'O';
else if(board[i][j]=='O') // 又犯这个小错误，if与if进行二次判断，在第一次的结果上进行修改结果错误
board[i][j] = 'X';
}
}
}
};book标志位可以进行去掉，因为之前已经将走过的赋值为“Z”了，如果是重复的比如之前的题中走过了防止再重复走就使用book向量进行判断
// book标志位可以不用加入
//if(book[newX][newY]==false && board[newX][newY]=='O')
if(board[newX][newY]=='O')
dfs(board, newX, newY, book, row, col);
修改后：
int nextP[4][2] = {{0,1},{0,-1},{1,0},{-1,0}};
class Solution {
public:
void dfs(vector<vector<char>>& board, int curX, int curY, int row, int col)
{
// 进行赋值为Z
board[curX][curY] = 'Z';
// 进行上下左右搜索
for(int i = 0; i < 4; i++)
{
int newX = curX + nextP[i][0];
int newY = curY + nextP[i][1];
// 越界检测
if(newX<0||newX>=row
|| newY<0||newY>=col)
continue;
if(board[newX][newY]=='O')
dfs(board, newX, newY, row, col);
}
}
void solve(vector<vector<char>>& board) {
if(board.empty())return;
int row = board.size();
int col = board[0].size();
for(int i = 0; i < row; i++)
{
if(board[i][0]=='O')
dfs(board, i, 0,row,col);
if(board[i][col-1]=='O')
dfs(board,i, col-1,row,col);
}
for(int j = 1; j < col; j++)
{
if(board[0][j]=='O')
dfs(board, 0, j,row,col);
if(board[row-1][j]=='O')
dfs(board, row-1, j,row,col);
}
for(int i = 0; i < row; i++)
{
for(int j= 0; j < col; j++)
{
if(board[i][j]=='Z')
board[i][j] = 'O';
else if(board[i][j]=='O') // 又犯这个小错误，if与if进行二次判断，在第一次的结果上进行修改结果错误
board[i][j] = 'X';
}
}
}
};三、 200. 岛屿数量
给你一个由 '1'（陆地）和 '0'（水）组成的的二维网格，请你计算网格中岛屿的数量。
岛屿总是被水包围，并且每座岛屿只能由水平方向和/或竖直方向上相邻的陆地连接形成。
此外，你可以假设该网格的四条边均被水包围。
思路：遍历二维数组，遇到‘1’就进行dfs将一块岛上所有数都置为0，然后继续遍历
每次碰到1就进行计数，然后进入dfs
int nextP[4][2] = {{0,1},{0,-1},{-1,0},{1,0}};
class Solution {
public:
void dfs(vector<vector<char>>& grid, int curX, int curY, int row, int col)
{
//进行替换 1->0
grid[curX][curY] = '0';
// 上下左右遍历
for(int i = 0; i < 4; i++)
{
int newX = curX + nextP[i][0];
int newY = curY + nextP[i][1];
// 检测是否越界
if(newX<0||newX>=row
|| newY<0||newY>=col)
continue;
// 检测是否是‘1’
if(grid[newX][newY]=='1')
dfs(grid, newX, newY, row, col);
}
}
int numIslands(vector<vector<char>>& grid) {
int row = grid.size();
int col = grid[0].size();
int count = 0;
for(int i = 0; i < row; i++)
{
for(int j = 0; j < col; j++)
{
if(grid[i][j]=='1')
{
++count;
dfs(grid, i, j, row, col);
}
}
}
return count;
}
};四、695. 岛屿的最大面积
给你一个大小为 m x n 的二进制矩阵 grid 。
岛屿 是由一些相邻的 1 (代表土地) 构成的组合，这里的「相邻」要求两个 1 必须在 水平或者竖直的四个方向上 相邻。你可以假设 grid 的四个边缘都被 0（代表水）包围着。
岛屿的面积是岛上值为 1 的单元格的数目。
计算并返回 grid 中最大的岛屿面积。如果没有岛屿，则返回面积为 0 。
输入：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 。
在上一个题的基础上加一个int类型的返回值以及对于maxS的判断即可。
int nextP[4][2] = {{1,0},{-1,0},{0,1},{0,-1}};
class Solution {
public:
int dfs(vector<vector<int>>& grid, int curX, int curY, int row, int col)
{
int num = 0;
num++;
grid[curX][curY]=0;
for(int i = 0; i < 4; i++)
{
int newX = curX + nextP[i][0];
int newY = curY + nextP[i][1];
if(newX<0||newX>=row
|| newY<0||newY>=col)
continue;
if(grid[newX][newY]==1)
num += dfs(grid, newX, newY, row, col);
}
return num;
}
int maxAreaOfIsland(vector<vector<int>>& grid) {
int row = grid.size();
int col = grid[0].size();
int maxS = 0;
for(int i = 0; i < row; i++)
{
for(int j = 0; j < col; j++)
{
if(grid[i][j]==1)
{
int temp = dfs(grid, i, j, row, col);
maxS = maxS>temp?maxS:temp;
}
}
}
return maxS;
}
};
974
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
