目录
1、孤岛的总面积
题目描述
给定一个由 1（陆地）和 0（水）组成的矩阵，岛屿指的是由水平或垂直方向上相邻的陆地单元格组成的区域，且完全被水域单元格包围。孤岛是那些位于矩阵内部、所有单元格都不接触边缘的岛屿。
现在你需要计算所有孤岛的总面积，岛屿面积的计算方式为组成岛屿的陆地的总数。
输入描述
第一行包含两个整数 N, M，表示矩阵的行数和列数。之后 N 行，每行包含 M 个数字，数字为 1 或者 0。
输出描述
输出一个整数，表示所有孤岛的总面积，如果不存在孤岛，则输出 0。
输入示例
4 5 1 1 0 0 0 1 1 0 0 0 0 0 1 0 0 0 0 0 1 1
输出示例
1
提示信息
在矩阵中心部分的岛屿，因为没有任何一个单元格接触到矩阵边缘，所以该岛屿属于孤岛，总面积为 1。
数据范围：
1 <= M, N <= 50。
思路：这里所求的孤岛是指不和四周边界有关系的岛屿，所以这里可以采用深搜或者广搜来将和四周边界相关的岛屿置为0，也就是变为水域，这样再进行深搜或者广搜，记录孤岛总面积即可。
1.1 深度优先
#include<iostream>
#include<vector>
using namespace std;
int count = 0;
int dir[4][2] = {1, 0, 0, 1, -1, 0, 0, -1};
void dfs(vector<vector<int>>& grid, vector<vector<bool>>& visited, int x, int y){
if(visited[x][y] || grid[x][y] == 0) return;
visited[x][y] = true;
grid[x][y] = 0;//这里尝试将矩阵中非孤岛的地方置为0，方便后续计算孤岛
count ++;
for(int i = 0; i < 4; i ++){
int nextx = x + dir[i][0];
int nexty = y + dir[i][1];
if(nextx < 0 || nextx >= grid.size() || nexty < 0 || nexty >= grid[0].size()) continue;
dfs(grid, visited, nextx, nexty);
}
}
int main(){
int n , m;
cin >> n >> m;
vector<vector<int>> grid(n, vector<int>(m, 0));
vector<vector<bool>> visited(n, vector<bool>(m, false));
for(int i = 0; i < n; i ++){
for(int j = 0; j < m; j ++){
cin >> grid[i][j];
}
}
//开始从矩阵的左右两边进行陆地转海洋
for(int i = 0; i < n; i ++){
if(grid[i][0] == 1) dfs(grid, visited, i, 0);
if(grid[i][m - 1] == 1) dfs(grid, visited, i, m - 1);
}
//开始从矩阵的上下两边进行陆地转海洋
for(int j = 0; j < m; j ++){
if(grid[0][j] == 1) dfs(grid, visited, 0, j);
if(grid[n - 1][j] == 1) dfs(grid, visited, n - 1, j);
}
int result = 0;//统计孤岛面积总数
for(int i = 0; i < n; i ++){
for(int j = 0; j < m; j ++){
if(!visited[i][j] && grid[i][j] == 1){
count = 0;
dfs(grid, visited, i, j);
result += count;
}
}
}
cout << result << endl;
}1.2 广度优先
#include<iostream>
#include<vector>
#include<queue>
using namespace std;
int count = 0;
int dir[4][2] = {1, 0, 0, 1, -1, 0, 0, -1};
void bfs(vector<vector<int>>& grid, vector<vector<bool>>& visited, int x, int y){
queue<int> que;
que.push(x);
que.push(y);
visited[x][y] = 1;
grid[x][y] = 0;
count ++;
while(!que.empty()){
int curx = que.front(); que.pop();
int cury = que.front(); que.pop();
for(int i = 0; i < 4; i ++){
int nextx = curx + dir[i][0];
int nexty = cury + dir[i][1];
if(nextx < 0 || nextx >= grid.size() || nexty < 0 || nexty >= grid[0].size()) continue;
if(!visited[nextx][nexty] && grid[nextx][nexty] == 1){
que.push(nextx);
que.push(nexty);
visited[nextx][nexty] = 1;
grid[nextx][nexty] = 0;
count ++;
}
}
}
}
int main(){
int n , m;
cin >> n >> m;
vector<vector<int>> grid(n, vector<int>(m, 0));
vector<vector<bool>> visited(n, vector<bool>(m, false));
for(int i = 0; i < n; i ++){
for(int j = 0; j < m; j ++){
cin >> grid[i][j];
}
}
//开始从矩阵的左右两边进行陆地转海洋
for(int i = 0; i < n; i ++){
if(grid[i][0] == 1) bfs(grid, visited, i, 0);
if(grid[i][m - 1] == 1) bfs(grid, visited, i, m - 1);
}
//开始从矩阵的上下两边进行陆地转海洋
for(int j = 0; j < m; j ++){
if(grid[0][j] == 1) bfs(grid, visited, 0, j);
if(grid[n - 1][j] == 1) bfs(grid, visited, n - 1, j);
}
int result = 0;//统计孤岛面积总数
for(int i = 0; i < n; i ++){
for(int j = 0; j < m; j ++){
if(!visited[i][j] && grid[i][j] == 1){
count = 0;
bfs(grid, visited, i, j);
result += count;
}
}
}
cout << result << endl;
}2、沉没孤岛
题目描述
给定一个由 1（陆地）和 0（水）组成的矩阵，岛屿指的是由水平或垂直方向上相邻的陆地单元格组成的区域，且完全被水域单元格包围。孤岛是那些位于矩阵内部、所有单元格都不接触边缘的岛屿。
现在你需要将所有孤岛“沉没”，即将孤岛中的所有陆地单元格（1）转变为水域单元格（0）。
输入描述
第一行包含两个整数 N, M，表示矩阵的行数和列数。
之后 N 行，每行包含 M 个数字，数字为 1 或者 0，表示岛屿的单元格。
输出描述
输出将孤岛“沉没”之后的岛屿矩阵。 注意：每个元素后面都有一个空格
输入示例
4 5 1 1 0 0 0 1 1 0 0 0 0 0 1 0 0 0 0 0 1 1
输出示例
1 1 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 1 1
提示信息
将孤岛沉没。
数据范围：
1 <= M, N <= 50。
思路：这里和第1题孤岛总面积的思路是相似的，将和四周边界相关的岛屿置为2或者其他数字，然循环遍历，将孤岛置为0，将之前变为2或者其他数字的岛屿重新置为1，最后打印输出即可。
#include<iostream>
#include<vector>
using namespace std;
int dir[4][2] = {1, 0, 0, 1, -1, 0, 0, -1};
void dfs(vector<vector<int>>& grid, int x, int y){
grid[x][y] = 2;
for(int i = 0; i < 4; i ++){
int nextx = x + dir[i][0];
int nexty = y + dir[i][1];
if(nextx < 0 || nextx >= grid.size() || nexty < 0 || nexty >= grid[0].size()) continue;
if(grid[nextx][nexty] == 0 || grid[nextx][nexty] == 2) continue;
dfs(grid, nextx, nexty);
}
}
int main(){
int n, m;
cin >> n >> m;
vector<vector<int>> grid(n, vector<int>(m, 0));
for(int i = 0; i < n; i ++){
for(int j = 0; j < m; j ++){
cin >> grid[i][j];
}
}
for(int i = 0; i < n; i ++){
if(grid[i][0] == 1) dfs(grid, i, 0);
if(grid[i][m - 1] == 1) dfs(grid, i, m - 1);
}
for(int j = 0; j < m; j ++){
if(grid[0][j] == 1) dfs(grid, 0, j);
if(grid[n - 1][j] == 1) dfs(grid, n - 1, j);
}
for(int i = 0; i < n; i ++){
for(int j = 0; j < m; j ++){
if(grid[i][j] == 1) grid[i][j] = 0;
if(grid[i][j] == 2) grid[i][j] = 1;
}
}
for(int i = 0; i < n; i ++){
for(int j = 0; j < m; j ++){
cout << grid[i][j] << " ";
}
cout << endl;
}
}3、水流问题
题目描述
现有一个 N × M 的矩阵，每个单元格包含一个数值，这个数值代表该位置的相对高度。矩阵的左边界和上边界被认为是第一组边界，而矩阵的右边界和下边界被视为第二组边界。
矩阵模拟了一个地形，当雨水落在上面时，水会根据地形的倾斜向低处流动，但只能从较高或等高的地点流向较低或等高并且相邻（上下左右方向）的地点。我们的目标是确定那些单元格，从这些单元格出发的水可以达到第一组边界和第二组边界。
输入描述
第一行包含两个整数 N 和 M，分别表示矩阵的行数和列数。
后续 N 行，每行包含 M 个整数，表示矩阵中的每个单元格的高度。
输出描述
输出共有多行，每行输出两个整数，用一个空格隔开，表示可达第一组边界和第二组边界的单元格的坐标，输出顺序任意。
输入示例
5 5 1 3 1 2 4 1 2 1 3 2 2 4 7 2 1 4 5 6 1 1 1 4 1 2 1
输出示例
0 4 1 3 2 2 3 0 3 1 3 2 4 0 4 1
提示信息
图中的蓝色方块上的雨水既能流向第一组边界，也能流向第二组边界。所以最终答案为所有蓝色方块的坐标。
数据范围：
1 <= M, N <= 100。
思路：这里采用了逆向思维，从上下左右的第一、二组边界出发，向上去找高的地方，同时对于第一、二组边界各设置一个visited数组，当所有循环遍历结束后，取两个visited数组的交集即为最终的结果。
#include<iostream>
#include<vector>
using namespace std;
int dir[4][2] = {1, 0, 0, 1, -1, 0, 0, -1};
void dfs(vector<vector<int>>& grid, vector<vector<bool>>& visited, int x, int y){
if(visited[x][y] == true) return;
visited[x][y] = true;
for(int i = 0; i < 4; i ++){
int nextx = x + dir[i][0];
int nexty = y + dir[i][1];
if(nextx < 0 || nextx >= grid.size() || nexty < 0 || nexty >= grid[0].size()) continue;
if(grid[nextx][nexty] < grid[x][y]) continue;
dfs(grid, visited, nextx, nexty);
}
}
int main(){
int n, m;
cin >> n >> m;
vector<vector<int>> grid(n, vector<int>(m, 0));
for(int i = 0; i < n; i ++){
for(int j = 0; j < m; j ++){
cin >> grid[i][j];
}
}
vector<vector<bool>> first(n, vector<bool>(m, false));
vector<vector<bool>> second(n, vector<bool>(m, false));
for(int i = 0; i < n; i ++){
dfs(grid, first, i, 0);
dfs(grid, second, i, m - 1);
}
for(int j = 0; j < m; j ++){
dfs(grid, first, 0, j);
dfs(grid, second, n - 1, j);
}
for(int i = 0; i < n; i ++){
for(int j = 0; j < m; j ++){
if(first[i][j] && second[i][j]) cout << i << " " << j << endl;
}
}
}4、建造最大岛屿
题目描述
给定一个由 1（陆地）和 0（水）组成的矩阵，你最多可以将矩阵中的一格水变为一块陆地，在执行了此操作之后，矩阵中最大的岛屿面积是多少。
岛屿面积的计算方式为组成岛屿的陆地的总数。岛屿是被水包围，并且通过水平方向或垂直方向上相邻的陆地连接而成的。你可以假设矩阵外均被水包围。
输入描述
第一行包含两个整数 N, M，表示矩阵的行数和列数。之后 N 行，每行包含 M 个数字，数字为 1 或者 0，表示岛屿的单元格。
输出描述
输出一个整数，表示最大的岛屿面积。
输入示例
4 5 1 1 0 0 0 1 1 0 0 0 0 0 1 0 0 0 0 0 1 1
输出示例
6
提示信息
对于上面的案例，有两个位置可将 0 变成 1，使得岛屿的面积最大，即 6。
数据范围：
1 <= M, N <= 50。
思路：这道题相较于前面的题目来说稍微有一点复杂了。
如果采用暴力求解的方法，那么就是每次遇到一个水域，将其变为1后，开始计算岛屿数量，最后得出最大的结果即可。但是这样的时间复杂度太大了，不是很可取。
所以我们这里尝试将本来的岛屿标上号码，并且记录好每块区域的大小，这样当遍历到水域时，查看它四周的方向，取四个方向上能构成岛屿最大的即可，不断更新最终结果，最后返回。
#include<iostream>
#include<vector>
#include<unordered_map>
#include<unordered_set>
using namespace std;
int mark;
int count;
int dir[4][2] = {1, 0, 0, 1, -1, 0, 0, -1};
void dfs(vector<vector<int>>& grid, vector<vector<bool>>& visited, int x, int y){
visited[x][y] = true;
grid[x][y] = mark;
count ++;
for(int i = 0; i < 4; i ++){
int nextx = x + dir[i][0];
int nexty = y + dir[i][1];
if(nextx < 0 || nextx >= grid.size() || nexty < 0 || nexty >= grid[0].size()) continue;
if(!visited[nextx][nexty] && grid[nextx][nexty] == 1){
visited[nextx][nexty] = true;
grid[nextx][nexty] = mark;
dfs(grid, visited, nextx, nexty);
}
}
}
int main(){
int n, m;
cin >> n >> m;
vector<vector<int>> grid(n, vector<int>(m, 0));
for(int i = 0; i < n; i ++){
for(int j = 0; j < m; j ++){
cin >> grid[i][j];
}
}
vector<vector<bool>> visited(n, vector<bool>(m, false));
mark = 2;
bool isAllGrid = true;
unordered_map<int, int> mp;
for(int i = 0; i < n; i ++){
for(int j = 0; j < m; j ++){
if(grid[i][j] == 0) isAllGrid = false;
if(!visited[i][j] && grid[i][j] == 1){
count = 0;
dfs(grid, visited, i, j);
mp[mark] = count;
mark ++;
}
}
}
if(isAllGrid){
cout << n * m << endl;
return 0;
}
int result = 0;
unordered_set<int> set;
for(int i = 0; i < n; i ++){
for(int j = 0; j < m; j ++){
count = 1;
set.clear();
if(grid[i][j] == 0){
for(int k = 0; k < 4; k ++){
int nearx = i + dir[k][0];
int neary = j + dir[k][1];
if(nearx < 0 || nearx >= grid.size() || neary < 0 || neary >= grid[0].size()) continue;
if(set.find(grid[nearx][neary]) != set.end()) continue;
count += mp[grid[nearx][neary]];
set.insert(grid[nearx][neary]);
}
}
result = max(result, count);
}
}感谢你的阅读，希望我的文章能够给你帮助，如果有帮助，麻烦点赞加收藏，或者点点关注，非常感谢。
如果有什么问题欢迎评论区讨论！
扫一扫
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
