岛屿个数 （当行不通的时候换个思路bfs）

 （第十四届蓝桥杯真题）岛屿个数

题目描述

小蓝得到了一副大小为 M × N 的格子地图，可以将其视作一个只包含字符‘0’（代表海水）和 ‘1’（代表陆地）的二维数组，地图之外可以视作全部是海水，每个岛屿由在上/下/左/右四个方向上相邻的 ‘1’ 相连接而形成。 在岛屿 A 所占据的格子中，如果可以从中选出 k 个不同的格子，使得他们的坐标能够组成一个这样的排列：(x0, y0),(x1, y1), . . . ,(xk−1, yk−1)，其中(x(i+1)%k , y(i+1)%k) 是由 (xi , yi) 通过上/下/左/右移动一次得来的 (0 ≤ i ≤ k − 1)， 此时这 k 个格子就构成了一个 “环”。如果另一个岛屿 B 所占据的格子全部位于这个 “环” 内部，此时我们将岛屿 B 视作是岛屿 A 的子岛屿。若 B 是 A 的子岛屿，C 又是 B 的子岛屿，那 C 也是 A 的子岛屿。 请问这个地图上共有多少个岛屿？在进行统计时不需要统计子岛屿的数目。

输入格式

第一行一个整数 T，表示有 T 组测试数据。 接下来输入 T 组数据。对于每组数据，第一行包含两个用空格分隔的整数M、N 表示地图大小；接下来输入 M 行，每行包含 N 个字符，字符只可能是‘0’ 或 ‘1’。

输出格式

对于每组数据，输出一行，包含一个整数表示答案。

解题思路

        这题原来的思路是用dfs把环的范围求出来，但是对于环的操作太过麻烦，而bfs也是如此，此时换个思路，bfs本质上是搜索，有以下几种情况

        1.搜索相同状态的集合，寻找不同集合之间的关系。

        2.寻找最短路，例如 曼哈短距离， 这也就是层次关系，最基本的应用。

        3.双重bfs， 也就是捆绑问题，此类问题满足某些单调关系，n元组

        4.双向bfs， 从初始状态和目标状态出发，例如 男女朋友相遇的最短时间

        5.广搜变形

                1） 双端队列， 也就是从队头和队尾两端操作，此类问题需要抽象出具体问题，且具有局限性，必须是从队头插入时，必须为0

                2）优先队列， 双端队列的普遍性，有两种方法，一种是利用极限的方法，而另一种后文再说。

        6.A* 具有估值函数的bfs，具体例子后续更新

我们这里显然是利用了第一个性质，寻找岛屿和湖泊之间的关系。

岛屿有两种情况，第一种是附属岛屿，那么它周围的湖泊都是-1，找不到边界的湖泊

另一种是父岛屿，必有连着一条湖泊通向大海。

这里有个细节，判断湖泊通向边界是包括8个方向。

代码如下，谢谢点赞与关注

#include <iostream>
#include <vector>
#include <cstring>
#include <string>
#include <cstdio>
#include <queue>

using namespace std;

const int N = 110;
char g[N][N];
typedef pair<int, int> PII;
int xx[8] = {-1, 1, 0, 0, -1, 1, -1, 1};
int yy[8] = {0, 0, -1, 1, 1, -1, -1, 1};
int n, m;
int st[N][N];

void bfs(int u, int x){
    queue<PII> q;
    queue<PII> tmp;
    tmp.push({u, x});
    q.push({u, x});
    st[u][x] = 2;
    int f = -1;
    while(q.size()){
        auto t = q.front();
        int y = t.first, x = t.second;
        for(int i = 0; i < 8; i ++){
            int a = y + yy[i], b = x + xx[i];
            if(a >= 0 && a < n && b >= 0 && b < m ){
                if( !st[a][b] && g[a][b] == '0'){
                    st[a][b] = 1;
                    q.push({a, b});
                    tmp.push({a, b});
                }
            }else f = 1;
        }
        q.pop();
    }
    while(tmp.size()){
        auto t = tmp.front();
        st[t.first][t.second] = f;
        tmp.pop();
    }
}

bool bfs2(int u, int x){
    queue<PII> q;
    q.push({u, x});
    st[u][x] = 3;
    bool f = false; // 假设认为是附属岛屿
    while(q.size()){
        auto t = q.front();
        int y = t.first, x = t.second;
        for(int i = 0; i < 4; i ++){
            int a = y + yy[i], b = x + xx[i];
            if(a >= 0 && a < n && b >= 0 && b < m ){
                if(st[a][b] == 1) {
                    // 找到一个岛屿 连通外海说明不是附属岛屿
                    f = true;
                    continue;
                }
                if(g[a][b] == '1' && !st[a][b]){ // 是一个没有被搜索过的岛屿
                    st[a][b] = 3;
                    q.push({a, b});
                }
            }
        }
        q.pop();
    }
    return f;
}

int main(){
    int T;
    cin >> T;
    getchar();
    while(T --){
        cin >> n >> m;
        getchar();
        memset(st, 0, sizeof(st));
        for(int i = 0; i < n; i ++)
            fgets(g[i], 100, stdin);

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

        int cnt = 0;
        for(int i = 0; i < n; i ++){
            for(int j = 0; j < m; j ++)
                if(!st[i][j]){
                    if(bfs2(i, j))
                        cnt ++;
                }
        }
        cout << cnt << endl;
    }
    return 0;
}