101. 孤岛的总面积
题目链接：101. 孤岛的总面积
题目描述：
给定一个由 1（陆地）和 0（水）组成的矩阵，岛屿指的是由水平或垂直方向上相邻的陆地单元格组成的区域，且完全被水域单元格包围。孤岛是那些位于矩阵内部、所有单元格都不接触边缘的岛屿。
现在你需要计算所有孤岛的总面积，岛屿面积的计算方式为组成岛屿的陆地的总数。
解题思路：
从周边找到陆地，然后通过 dfs或者bfs 将周边靠陆地且相邻的陆地都变成海洋（即将周边1变为0），然后再去重新遍历地图，统计此时还剩下的陆地就可以了。
代码：
cpp
#include<iostream>
#include<vector>
using namespace std;
int count;
int dx[4] = {-1,0,0,1};
int dy[4] = {0,1,-1,0};
void dfs(vector<vector<int>>& matrix,vector<vector<int>>& visited,int r, int c)
{
matrix[r][c] = 0;
visited[r][c] = true;
count++;
for(int i = 0; i < 4; i++)
{
int x = r + dx[i], y = c + dy[i];
if(x < 0 || y < 0 || x >= matrix.size() || y >= matrix[0].size()) continue;
if(matrix[x][y] == 1 && !visited[x][y])
dfs(matrix,visited,x,y);
}
}
int main()
{
int n, m;
cin >> n >> m;
vector<vector<int>> matrix(n+2,vector<int>(m+2));
vector<vector<int>> visited(n+2,vector<int>(m+2));
for(int i = 1; i <= n; i ++)
for(int j = 1; j <= m; j++)
cin >> matrix[i][j];
for(int i = 1; i <= n; i++)
{
for(int j = 1; j <= m; j++)
{
if(i == 1 || i == n || j == 1 || j == m)
if(matrix[i][j] == 1 && visited[i][j] == false)
dfs(matrix,visited,i,j);
}
}
int area = 0;
for(int i = 1; i <= n; i++)
{
for(int j = 1; j <= m; j++)
{
if(matrix[i][j] == 1 && !visited[i][j])
{
count = 0;
dfs(matrix,visited,i,j);
area += count;
}
}
}
cout << area << endl;
return 0;
}102. 沉没孤岛
题目链接：102. 沉没孤岛
题目描述：
给定一个由 1（陆地）和 0（水）组成的矩阵，岛屿指的是由水平或垂直方向上相邻的陆地单元格组成的区域，且完全被水域单元格包围。孤岛是那些位于矩阵内部、所有单元格都不接触边缘的岛屿。
现在你需要将所有孤岛"沉没"，即将孤岛中的所有陆地单元格（1）转变为水域单元格（0）。
解题思路：
1、思路依然是从地图周边出发，将周边空格相邻的陆地都做上标记，然后在遍历一遍地图，遇到陆地且没做过标记的，那么都是地图中间的陆地 ，全部改成水域就行。
2、不用额外定义空间了，标记周边的陆地，可以直接改陆地为其他特殊值作为标记。
步骤一：深搜或者广搜将地图周边的 1 （陆地）全部改成 2 （特殊标记）
步骤二：将水域中间 1 （陆地）全部改成 水域（0）
步骤三：将之前标记的 2 改为 1 （陆地）
代码：
cpp
#include<iostream>
#include<vector>
using namespace std;
int dx[4] = {-1,0,0,1};
int dy[4] = {0,1,-1,0};
void dfs(vector<vector<int>>& matrix,vector<vector<bool>>& visited,int r, int c)
{
visited[r][c] = true;
matrix[r][c] = 2;
for(int i = 0; i < 4; i++)
{
int x = r + dx[i], y = c + dy[i];
if(x < 0 || y < 0 || x >= matrix.size() || y >= matrix[0].size()) continue;
if(matrix[x][y] == 1 && !visited[x][y])
dfs(matrix,visited,x,y);
}
}
int main()
{
int n , m;
cin >> n >> m;
vector<vector<int>> matrix(n+2,vector<int>(m+2));
vector<vector<bool>> visited(n+2,vector<bool>(n+2));
for(int i = 1; i <= n; i++)
for(int j = 1; j <= m; j++)
cin >> matrix[i][j];
for(int i = 1; i <= n; i++)
{
for(int j = 1; j <= m; j++)
{
if(i == 1 || i == n || j == 1 || j == m)
{
if(matrix[i][j] == 1 && !visited[i][j])
dfs(matrix,visited,i,j);
}
}
}
for(int i = 1; i <= n; i++)
for(int j = 1; j <= m; j++)
if(matrix[i][j] == 1) matrix[i][j] = 0;
for(int i = 1; i <= n; i++)
{
for(int j = 1; j <= m; j++)
{
if(matrix[i][j] == 2) matrix[i][j] = 1;
cout << matrix[i][j] << " ";
}
cout << endl;
}
return 0;
}103. 水流问题
题目链接：103. 水流问题
题目描述：
现有一个 N × M 的矩阵，每个单元格包含一个数值，这个数值代表该位置的相对高度。矩阵的左边界和上边界被认为是第一组边界，而矩阵的右边界和下边界被视为第二组边界。
矩阵模拟了一个地形，当雨水落在上面时，水会根据地形的倾斜向低处流动，但只能从较高或等高的地点流向较低或等高并且相邻（上下左右方向）的地点。我们的目标是确定那些单元格，从这些单元格出发的水可以达到第一组边界和第二组边界。
优化思路：
从第一组边界上的节点逆流而上，将遍历过的节点都标记上。
同样从第二组边界的边上节点逆流而上，将遍历过的节点也标记上。
然后两方都标记过的节点就是既可以流太平洋也可以流大西洋的节点。
代码：
cpp
#include<iostream>
#include<vector>
#include<algorithm>
using namespace std;
int dx[4] = {-1,0,0,1};
int dy[4] = {0,1,-1,0};
void dfs(vector<vector<int>>& matrix,vector<vector<bool>>& visited,int r, int c)
{
visited[r][c] = true;
for(int i = 0; i < 4; i++)
{
int x = r + dx[i], y = c + dy[i];
if(x < 0 || y < 0 || x >= matrix.size() || y >= matrix[0].size()) continue;
if(matrix[x][y] >= matrix[r][c] && !visited[x][y])
dfs(matrix,visited,x,y);
}
return;
}
int main()
{
int n,m;
cin >> n >> m;
vector<vector<int>> matrix(n,vector<int>(m));
vector<vector<bool>> firstbound(n,vector<bool>(m,false));
vector<vector<bool>> secondbound(n,vector<bool>(m,false));
for(int i = 0; i < n; i++)
for(int j = 0; j < m; j++)
cin >> matrix[i][j];
for(int i = 0; i < n; i++)
{
dfs(matrix,firstbound,i,0);
dfs(matrix,secondbound,i,m-1);
}
for(int j = 0; j < m; j++)
{
dfs(matrix,firstbound,0,j);
dfs(matrix,secondbound,n-1,j);
}
for(int i = 0; i < n; i++)
for(int j = 0; j < m; j++)
if(firstbound[i][j] && secondbound[i][j])
cout << i << " " << j << endl;
return 0;
}104.建造最大岛屿
题目链接：104. 建造最大岛屿
题目描述：
给定一个由 1（陆地）和 0（水）组成的矩阵，你最多可以将矩阵中的一格水变为一块陆地，在执行了此操作之后，矩阵中最大的岛屿面积是多少。
岛屿面积的计算方式为组成岛屿的陆地的总数。岛屿是被水包围，并且通过水平方向或垂直方向上相邻的陆地连接而成的。你可以假设矩阵外均被水包围。
优化思路：
只要用一次深搜把每个岛屿的面积记录下来就好。
- 一次遍历地图，得出各个岛屿的面积，并做编号记录。可以使用map记录，key为岛屿编号，value为岛屿面积
- 再遍历地图，遍历0的方格（因为要将0变成1），并统计该1（由0变成的1）周边岛屿面积，将其相邻面积相加在一起，遍历所有 0 之后，就可以得出 选一个0变成1 之后的最大面积。
（要考虑全为陆地的情况）
代码：
cpp
#include<iostream>
#include<vector>
#include<unordered_map>
#include<unordered_set>
#include<algorithm>
using namespace std;
int dx[4] = {-1,0,0,1};
int dy[4] = {0,-1,1,0};
int cnt;
void dfs(vector<vector<int>>& grid, int r, int c, int target)
{
cnt ++;
grid[r][c] = target;
for(int i = 0; i < 4; i++)
{
int x = r + dx[i], y = c + dy[i];
if(x < 0 || y < 0 || x >= grid.size() || y >= grid[0].size()) continue;
if(grid[x][y] == 1) dfs(grid,x,y,target);
}
}
int main()
{
int n , m;
cin >> n >> m;
vector<vector<int>> grid(n,vector<int>(m));
unordered_map<int,int> area;
for(int i = 0; i < n; i++)
for(int j = 0; j < m; j++)
cin >> grid[i][j];
int target = 2;
bool isAllGrid = true; // 标记是否整个地图都是陆地
for(int i = 0; i < n; i++)
{
for(int j = 0; j < m; j++)
{
if(grid[i][j] == 0) isAllGrid = false;
if(grid[i][j] == 1)
{
cnt = 0;
dfs(grid,i,j,target);
area[target] = cnt;
target++;
}
}
}
int maxArea = 0;
if(isAllGrid) maxArea = n * m;
else
{
unordered_set<int> visitedGrid;
for(int i = 0; i < n; i++)
{
for(int j = 0; j < m; j++)
{
visitedGrid.clear();
if(grid[i][j] == 0)
{
int sum = 0;
for(int k = 0; k < 4; k++)
{
int x = i + dx[k], y = j + dy[k];
if(x < 0 || y < 0 || x >= n || y >= m) continue;
if(grid[x][y] && !visitedGrid.count(grid[x][y]))
{
sum += area[grid[x][y]];
visitedGrid.insert(grid[x][y]);
}
}
maxArea = max(maxArea,sum + 1);
}
}
}
}
cout << maxArea << endl;
return 0;
}