第九届蓝桥杯C++B组：全球变暖( 三种方法解决)-CFANZ编程社区

你有一张某海域NxN像素的照片，"."表示海洋、"#"表示陆地，如下所示：

.......

.##....

....##.

..####.

...###.

.......

其中"上下左右"四个方向上连在一起的一片陆地组成一座岛屿。例如上图就有2座岛屿。

由于全球变暖导致了海面上升，科学家预测未来几十年，岛屿边缘一个像素的范围会被海水淹没。具体来说如果一块陆地像素与海洋相邻(上下左右四个相邻像素中有海洋)，它就会被淹没。

例如上图中的海域未来会变成如下样子：

.......

....#..

.......

请你计算：依照科学家的预测，照片中有多少岛屿会被完全淹没。

【输入格式】

第一行包含一个整数N。 (1 <= N <= 1000)

以下N行N列代表一张海域照片。

照片保证第1行、第1列、第N行、第N列的像素都是海洋。

【输出格式】

一个整数表示答案。

【输入样例】

.......

.##....

....##.

..####.

...###.

.......

【输出样例】

资源约定：

峰值内存消耗（含虚拟机） < 256M

CPU消耗 < 1000ms

请严格按要求输出，不要画蛇添足地打印类似：“请您输入...” 的多余内容。

注意：

main函数需要返回0;

只使用ANSI C/ANSI C++ 标准;

不要调用依赖于编译环境或操作系统的特殊函数。

所有依赖的函数必须明确地在源文件中 #include <xxx>

不能通过工程设置而省略常用头文件。

提交程序时，注意选择所期望的语言类型和编译器类型。

附带额外的测试数据：

输入：

5
.....
.#...
...#.
.#...
.....

输出：

输入：

10
..........
.##.......
.##.......
....##.#..
..#######.
...###.#..
..........
..#....#..
......###.
..........

输出：

输入：

10
..........
..........
..........
....##.#..
..#######.
...###.#..
..........
..........
..........
..........

输出：

思路：

理解题意：如果一个岛屿（#）的它的上下左右都是#，那么与它相连的岛屿就不会被淹没，否则就会被淹没。（使用此方法可以杜绝，淹没后又产生新岛屿的情况）

代码思路：使用bfs遍历二维数组（地图）：把当前元素入队，获取其x和y的坐标，然后把它出队，如果它没有被遍历过且它是岛屿，则判断它的上下左右是否都是#（标记为已遍历过），如果是，则标记这块岛屿不会被淹没，把位移后与它相邻的且没有遍历过的岛屿，入队列，继续遍历。当队列为空时，返回；

如果这块岛屿不会被淹没，则不会被淹没的岛屿数加1。

参考代码：

#include<cstdio>
#include<queue>
#include<cstring>
using namespace std;

const  int maxn = 1005;
char a[maxn][maxn];//存储地图
int n;//矩阵的行列数
int vis[maxn][maxn];// 判断该陆地是否被遍历过
int dir[4][2]={{-1,0},{0,-1},{0,1},{1,0}};//规定向左，下，右，上移动

struct point
{
    int x,y;
    point(int _a,int _b)//初始化结构体变量
    {
        x = _a;
        y = _b;
    }
};

int bfs(int x,int y)
{
    queue<point> q;//定义队列结构体
    q.push(point(x,y));//把(x,y)入队列
    int left = 0;
    while(!q.empty())//如果队列不非空，执行循环（q.empty()==flase）
    {
        point p = q.front();//获取队首元素
        q.pop();//令队首元素出队
        int cnt = 0;//对每一个新来的陆地元素，令其周边的陆地元素累计个数清0（以防收到上一个陆地元素影响）
        for(int i = 0;i<4;i++)
        {
            int dx = p.x+dir[i][0],dy = p.y+dir[i][1];//原坐标加上位移方向
            if(dx < 0||dx >= n||dy < 0||dy >= n)//如果超出标界，则进行下一次循环
                continue;
            if(a[dx][dy] == '#')//如果周围有一个是陆地
            {
                cnt++;//陆地数目加1
                if(!vis[dx][dy])//如果位移后的该陆地之前没有被遍历过
                {
                    vis[dx][dy]=1;//标记为已遍历过
                    q.push(point(dx,dy));//把该陆地入队
                }
            }
        }
        if(cnt == 4)//如果四周都是陆地
            left++;
    }
    return left;
}

int main()
{
    int ans = 0;
    scanf("%d", &n);
    getchar();//吸收换行符
    for(int i = 0;i < n;i++)//存储地图
    {
            scanf("%s", a[i]);
    }

    memset(vis, 0, sizeof(vis));//初始化全部的陆地均为未遍历过

    for(int i = 0; i < n; i++)//遍历地图
    {
        for(int j = 0; j < n; j++)
        {
            if(a[i][j] == '#' && !vis[i][j])//如果是陆地且没有被遍历过
            {
                vis[i][j]=1;//标记为已遍历过
                if(!bfs(i,j))//如果能被淹没，则淹没岛屿+1
                    ans++;
            }
        }
    }
    printf("%d\n", ans);
    return 0;
}

参考代码2:(递归)

#include<cstdio>
#include<cstring>

const int maxn = 1005;
int n, len = 0, cnt = 0;
int vis[maxn][maxn], ans[maxn];
char arr[maxn][maxn];

void dfs(int a, int b, int k){
    if(arr[a][b] == '.')return;//如果当前位置是海水，则返回
    if(vis[a][b])return;//如果遍历过则返回
    //如果该陆地的上下左右，均是陆地，则则岛屿不会被淹没，并记录在ans中
    if(arr[a+1][b] == '#' && arr[a-1][b] == '#' && arr[a][b+1] == '#' && arr[a][b-1] == '#') ans[k]++;
    vis[a][b] = 1;//把遍历过的位置标注为1
    dfs(a + 1, b, k);//地图向下走
    dfs(a - 1, b, k);//地图向上走
    dfs(a, b + 1, k);//地图向右走
    dfs(a, b - 1, k);//地图向左走
}

int main(){
    //处理输入
    scanf("%d", &n);
    memset(vis, 0, sizeof(vis));
    getchar();    //读入第一行的换行符
    for(int i = 0; i < n; i++){//录入地图
        scanf("%s",arr[i]);//读入地图的每一行
    }

    for(int i = 0; i < n; i++){//依次遍历地图的每一个位置
        for(int j = 0; j < n; j++){
            if(arr[i][j] == '#' && !vis[i][j]){//如果该位置是陆地且未被遍历过
                dfs(i, j, len);//遍历该岛屿
                len++;//统计遍历的陆地个数
            }
        }
    }
    
    for(int i = 0; i < len; i++){
        if(ans[i] == 0) cnt++;//如果该岛屿没有被标记为不会被淹没，则会被淹没的个数+1
    }
    
    printf("%d", cnt);
    return 0;
}

参考代码3（模拟）:

// 正确
#include <map>
#include <iostream>
#include <cstdio>
#include <vector>
using namespace std;
#define mem(a,b) memset(a,b,sizeof(a))
#define mod 1000000007
using namespace std;
typedef long long ll;
const int maxn = 1e6+5;
const double esp = 1e-7;
const int ff = 0x3f3f3f3f;
map<int,int>::iterator it;

struct node
{
    int x,y;
    node(int x = 0,int y = 0):x(x),y(y){}
};

int n;
int cnt;
char mp[1005][1005];
int vis[1005][1005];
vector<node> d[maxn];
int ne[4][2] = {1,0,-1,0,0,1,0,-1};

void find(int x,int y)//寻找相连点
{
    d[cnt].push_back(node(x,y));
    vis[x][y] = 1;
    for(int i = 0;i< 4;i++)
    {
        int tx = x+ne[i][0];
        int ty = y+ne[i][1];

        if(tx< 0||tx>= n||ty< 0||ty>= n||vis[tx][ty]||mp[tx][ty] == '.')
            continue;
        find(tx,ty);
    }

    return ;
}

void Preprocess()//预处理岛屿
{
    for(int i = 0;i< n;i++)
        for(int j = 0;j< n;j++)
            if(mp[i][j] == '#'&&!vis[i][j])
            {
                cnt++;
                find(i,j);
            }
    return ;
}

void dfs(int x,int y)//侵蚀
{
    vis[x][y] = 1;

    for(int i = 0;i< 4;i++)
    {
        int tx = x+ne[i][0];
        int ty = y+ne[i][1];

        if(tx< 0||tx>= n||ty< 0||ty>= n||vis[tx][ty])
            continue;

        if(mp[tx][ty] == '#')
            vis[tx][ty] = 1;
        else
            dfs(tx,ty);
    }

    return ;
}

void solve()//开始侵蚀
{
    mem(vis,0);
    for(int i = 0;i< n;i++)
        for(int j = 0;j< n;j++)
            if(mp[i][j] == '.'&&!vis[i][j])
                dfs(i,j);
    return ;
}

int main()
{
    cin>>n;
    for(int i = 0;i< n;i++)
        scanf(" %s",mp[i]);

    Preprocess();
    solve();

    int ans = 0;
    for(int i = 1;i<= cnt;i++)//判断组成岛屿的点还在不在
    {
        int j,k = d[i].size();
        for(j = 0;j< k;j++)
            if(vis[d[i][j].x][d[i][j].y] == 0)
                break;

        if(j == k)
            ans++;
    }

    cout<<ans<<endl;

    return 0;
}