101.孤岛的总面积
以此从上下左右四条边遍历节点，搜索岛屿，把搜索到的块置为0，搜索完之后，剩下的陆地就是孤岛，再遍历一遍图，计数即可。
注意，此题由于会把非孤岛的陆地块置为0，所以不需要visited数组，因为仅通过陆地是否为1就能避免重复访问节点了（会把访问过的非孤岛陆地块置为0）。
cpp
#include<iostream>
using namespace std;
#include<vector>
#include<queue>
int dir[4][2] = {0,1,1,0,0,-1,-1,0};
void bfs(vector<vector<int>>& grid, int x, int y){
queue<pair<int,int>> qe;
qe.push({x,y});
grid[x][y]=0;
while(!qe.empty()){
pair<int,int> pr = qe.front(); qe.pop();
for(int i=0;i<4;i++){
int nextx = pr.first+dir[i][0];
int nexty = pr.second+dir[i][1];
if(nextx<0 || nextx>=grid.size() || nexty<0 || nexty>=grid[0].size()) continue;
if(grid[nextx][nexty]==1){
qe.push({nextx,nexty});
grid[nextx][nexty]=0;
}
}
}
}
int main(){
int n,m;
cin>>n>>m;
vector<vector<int>> grid(n,vector<int>(m));
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,i,0);
if(grid[i][m-1]==1) bfs(grid,i,m-1);
}
for(int i=0;i<m;i++){
if(grid[0][i]==1) bfs(grid,0,i);
if(grid[n-1][i]==1) bfs(grid,n-1,i);
}
int result=0;
for(int i=0;i<n;i++){
for(int j=0;j<m;j++){
if(grid[i][j]==1) result++;
}
}
cout<<result<<endl;
return 0;
}102.沉没孤岛
名字听起来很有诗意。
这题自己想的思路，和上题很类似。依旧是从四条边开始搜索岛屿，搜索到的地方置为2，这样图上就分为2（非孤岛）、1（孤岛）、0（海洋）。
然后遍历图，把大于0的部分-1，这样就实现了沉没孤岛的效果。
cpp
#include<iostream>
using namespace std;
#include<vector>
#include<queue>
int dir[4][2] = {0,1,1,0,0,-1,-1,0};
void bfs(vector<vector<int>>& grid, int x, int y){
queue<pair<int,int>> qe;
qe.push({x,y});
grid[x][y]=2;
while(!qe.empty()){
pair<int,int> pr = qe.front(); qe.pop();
for(int i=0;i<4;i++){
int nextx = pr.first+dir[i][0];
int nexty = pr.second+dir[i][1];
if(nextx<0 || nextx>=grid.size() || nexty<0 || nexty>=grid[0].size()) continue;
if(grid[nextx][nexty]==1){
qe.push({nextx,nexty});
grid[nextx][nexty]=2;
}
}
}
}
int main(){
int n,m;
cin>>n>>m;
vector<vector<int>> grid(n,vector<int>(m));
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,i,0);
if(grid[i][m-1]==1) bfs(grid,i,m-1);
}
for(int i=0;i<m;i++){
if(grid[0][i]==1) bfs(grid,0,i);
if(grid[n-1][i]==1) bfs(grid,n-1,i);
}
for(int i=0;i<n;i++){
for(int j=0;j<m;j++){
if(grid[i][j]>0) grid[i][j]--;
}
}
for(int i=0;i<n;i++){
for(int j=0;j<m;j++){
if(j<m-1) cout<<grid[i][j]<<" ";
else cout<<grid[i][j];
}
cout<<endl;
}
return 0;
}103.水流问题
本题使用优化思路：从边界反向搜高点。
本题分为第一边界（左上）和第二边界（右下），所以可以定义两个队列q1、q2，两个visited数组v1、v2。
分别把q1q2传入搜索函数，搜索函数的逻辑是：从队列（队列里是第一或第二边界上的所有节点）节点出发，只要上下左右节点有高于自己的，就可以往高处的方向搜索，把搜索到的节点标记为访问过（v1访问过 / v2访问过）。
结果就是，从标记为访问过的节点都是可以流到第一或者第二边界的节点，所以v1、v2都访问过的节点，就是满足条件的节点，遍历图节点，把v1、v2都访问过的节点加入result当中。
cpp
#include<iostream>
using namespace std;
#include<vector>
#include<queue>
int dir[4][2] = {0,1,1,0,0,-1,-1,0};
void bfs(vector<vector<int>>& grid, vector<vector<bool>>& visited ,queue<pair<int, int>>& qe){
while(!qe.empty()){
pair<int,int> cur = qe.front(); qe.pop();
int curx = cur.first;
int cury = cur.second;
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]) continue;
if(grid[nextx][nexty]>=grid[curx][cury]){
qe.push({nextx,nexty});
visited[nextx][nexty]=true;
}
}
}
}
int main(){
int n,m;
cin>>n>>m;
vector<vector<int>> grid(n,vector<int>(m));
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));
queue<pair<int, int>> q1;
queue<pair<int, int>> q2;
for (int j = 0; j < m; j++) {
first[0][j] = true;
q1.push({0, j});
}
for (int i = 0; i < n; i++) {
first[i][0] = true;
q1.push({i, 0});
}
for (int j = 0; j < m; j++) {
second[n - 1][j] = true;
q2.push({n - 1, j});
}
for (int i = 0; i < n; i++) {
second[i][m - 1] = true;
q2.push({i, m - 1});
}
bfs(grid, first, q1);
bfs(grid, second, q2);
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;
}
}
}
}104.建造最大岛屿
思路见注释：
cpp
#include<iostream>
using namespace std;
#include<vector>
#include<unordered_map>
#include<unordered_set>
int dir[4][2]={0,1,1,0,0,-1,-1,0};
int count;
//深搜-用来给每块岛屿做标记并统计面积
void dfs(vector<vector<int>>& grid, vector<vector<bool>>& visited, int x, int y, int& mark){
if(grid[x][y]==0 || visited[x][y]==true) return;
visited[x][y]=true;
count++;//岛屿面积++
grid[x][y]=mark;//把该陆地的值改为岛屿编号
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,mark);
}
}
int main(){
int n,m;
cin>>n>>m;
vector<vector<int>> grid(n,vector<int>(m));
vector<vector<bool>> visited(n,vector<bool>(m,false));
//构造图，判断是否全部为陆地
bool isAllGrid = true;
for(int i=0;i<n;i++){
for(int j=0;j<m;j++){
cin>>grid[i][j];
if(grid[i][j]==0) isAllGrid = false;
}
}
//如果全部为陆地直接返回面积并退出函数
if(isAllGrid){
cout<<n*m<<endl;
return 0;
}
//定义第一个岛屿的编号为2
int mark=2;
//定义"岛屿编号"到"岛屿面积"的映射
unordered_map<int,int> gridnum;
//遍历图，搜索出所有岛屿并为其编号和统计面积并把信息加入映射
for(int i=0;i<n;i++){
for(int j=0;j<m;j++){
if(grid[i][j]==1 && visited[i][j]==false){
count=0;
dfs(grid,visited,i,j,mark);
gridnum[mark] = count;
mark++;
}
}
}
//遍历每块海洋，计算和其连通的周边岛屿面积之和（再加上本身的1），寻找最大值
unordered_set<int> norepeat;//防止四个方向搜索当中会遍历到同一片岛屿，导致岛屿面积重复累加
int scount;//定义新计数变量
int result=0;//定义最大面积变量
for(int i=0;i<n;i++){
for(int j=0;j<m;j++){
//只处理海洋块
if(grid[i][j]==0){
scount = 1;//本身会变成陆地，面积初始为1
norepeat.clear();//该集合防止的是同一个海洋在搜索中会搜索到同一个岛屿，但是不会防止不同的海洋搜索到同一个岛屿，所以每遍历一个海洋就要清空
for(int k=0;k<4;k++){
int neari = i+dir[k][0];
int nearj = j+dir[k][1];
if(neari<0 || neari>=n || nearj<0 || nearj>=m) continue;
//如果这个块是其他方向遍历过的岛屿块就换个方向
if(norepeat.count(grid[neari][nearj])) continue;
scount+=gridnum[grid[neari][nearj]];//获取岛屿面积并相加
norepeat.insert(grid[neari][nearj]);//把这块岛屿的编号加入集合，防止再累加面积
}
}
result = max(result,scount);
}
}
cout<<result<<endl;
}