DFS/BFS(Flood Fill)-第九届蓝桥杯省赛C++A/B组-全球变暖

本文链接：https://blog.csdn.net/njuptACMcxk/article/details/104564891

DFS/BFS(Flood Fill)-第九届蓝桥杯省赛C++A/B组-全球变暖

题目：

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

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

由于全球变暖导致了海面上升，科学家预测未来几十年，岛屿边缘一个像素的范围会被海水淹没。

具体来说如果一块陆地像素与海洋相邻(上下左右四个相邻像素中有海洋)，它就会被淹没。

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

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

输入格式
第一行包含一个整数N。

以下 N 行 N 列，包含一个由字符”#”和”.”构成的 N×N 字符矩阵，代表一张海域照片，”#”表示陆地，”.”表示海洋。

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

输出格式
一个整数表示答案。

数据范围
1≤N≤1000
输入样例1：
7........##.....##........##...####....###........
输出样例1：
1
输入样例2：
9..........##.##....#####....##.##.............##.#.....#.###....#..#.............
输出样例2：
1

题意：

$'\#'被淹没的条件是上下左右都是'.'。求图中每一个'\#'连通块中，所有'\#'都被淹没的连通块的数量。$

题解：

$搜索连通块可以使用 B F S ，也可以使用 D F S 。$

$对淹没的连通块数量的统计，有两种方式：$

$①、先统计所有连通块的数量，再统计不完全被淹没的连通块的数量，二者作差。不被完全淹没的连通块这样统计:\\若'\#'的上下左右都是'\#'，那么这个'\#'所在的连通块就不会完全被淹没,从这个点进入搜索这个连通块。$

$②、被完全淹没的连通块这样统计：统计连通块所有'\#'数量x，再统计连通块中会被淹没的所有'\#'的数量y，\\若x=y，说明整个连通块会被完全淹没。\\ \ \\BFS学习使用pair模拟队列。$

方案一(用DFS写)：

#include<iostream>
#include<cstdio>
#include<cstring>
#include<algorithm>
#include<cmath>
#include<queue>
#define P pair<int,int>
#define x first
#define y second
#define ll long long
#define inf 0x7fffffff
using namespace std;
const int N=1010;
int n;
char mp[N][N];
bool vis[N][N];
int dir[4][2]={{1,0},{-1,0},{0,1},{0,-1}};
int cnt;

bool check(int x,int y)  ///判断是否会被淹没
{
    for(int i=0;i<4;i++)
    {
        int x1=x+dir[i][0];
        int y1=y+dir[i][1];
        if(mp[x1][y1]=='.')
            return false;
    }
    return true;
}

void dfs(int x,int y)
{
    if(vis[x][y]) return ;
    vis[x][y]=true;
    for(int i=0;i<4;i++)
    {
        int x1=x+dir[i][0];
        int y1=y+dir[i][1];
        if(x1<0||y1<0||x1>=n||y1>=n||vis[x1][y1]||mp[x1][y1]=='.') continue;
        dfs(x1,y1);
    }
}

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

    for(int i=0;i<n;i++)
        for(int j=0;j<n;j++)
            if(mp[i][j]=='#'&&!vis[i][j])  ///统计连通块的数量
            {
                dfs(i,j);
                cnt++;
            }

    memset(vis,false,sizeof(vis));
    for(int i=0;i<n;i++)
        for(int j=0;j<n;j++)
            if(mp[i][j]=='#'&&check(i,j)&&!vis[i][j])  ///搜索看是否存在不会被淹没的#，有就减掉
            {
                dfs(i,j);
                cnt--;
            }

    cout<<cnt<<endl;

    return 0;
}

方案二(用BFS写)：

#include <cstdio>
#include <cstring>
#include <iostream>
#include <algorithm>

#define x first
#define y second

using namespace std;

typedef pair<int, int> PII;

const int N = 1010;

int n;
char g[N][N];
bool st[N][N];
PII q[N * N];  ///pair模拟队列
int dx[4] = {-1, 0, 1, 0};
int dy[4] = {0, 1, 0, -1};

void bfs(int sx, int sy, int &total, int &bound)  ///total：连通块#总数，bound：连通块中会被淹没的#数量
{
    int hh = 0, tt = 0;
    q[0] = {sx, sy};
    st[sx][sy] = true;

    while (hh <= tt)  ///两个下标模拟队列
    {
        PII t = q[hh ++ ];

        total ++ ;
        bool is_bound = false;
        for (int i = 0; i < 4; i ++ )
        {
            int x = t.x + dx[i], y = t.y + dy[i];
            if (x < 0 || x >= n || y < 0 || y >= n) continue;  // 出界
            if (st[x][y]) continue;
            if (g[x][y] == '.')
            {
                is_bound = true;   ///会被淹没
                continue;
            }

            q[ ++ tt] = {x, y};
            st[x][y] = true;
        }

        if (is_bound) bound ++ ;
    }
}

int main()
{
    scanf("%d", &n);

    for (int i = 0; i < n; i ++ ) scanf("%s", g[i]);

    int cnt = 0;
    for (int i = 0; i < n; i ++ )
        for (int j = 0; j < n; j ++ )
            if (!st[i][j] && g[i][j] == '#')
            {
                int total = 0, bound = 0;
                bfs(i, j, total, bound);
                if (total == bound) cnt ++ ;
            }

    printf("%d\n", cnt);

    return 0;
}