BFS广度优先搜素

目录

BFS与DFS区别：

练习：全球变暖

解题思路：

---

图的遍历BFS广度优先搜索 - 数据结构教程 - C语言网 (dotcpp.com)https://www.dotcpp.com/course/149

BFS与DFS区别：

DFS利用栈，根据树的深度优先搜索，一路走到底，再通过回溯搜索最优解或全局解；

而BFS利用队，类似树的层级遍历，通过队的先入先出特点，标记每一步的下一步状态，通过入队出队模拟执行搜索过程（通常开辟一个Memory数组记录每个位置是否被搜索过)。DFS深度优先搜索与回溯算法_dfs算法怎么回溯-CSDN博客https://blog.csdn.net/qq_43855258/article/details/136070858

二叉树的遍历-CSDN博客https://blog.csdn.net/qq_43855258/article/details/135624865 

练习：全球变暖

解题思路：

step1.在海域中寻找未标记的连通岛屿for(for),遍历至未标记岛屿的起点[start_i,start_j]；

step.2.岛屿数totoal_num++；

step3.BFS搜素，分别从上下左右4个方向vector<pair<int,int>> move={(-1.0)，(+1,0),(0,-1),(0,+1)}搜索当前岛屿的连通状态，由queue<pair<int,int>> que的入队、出队模拟执行搜索过程，vector<vector<int>> memory 记录搜索状态，num记录位置(x,y)四周'#‘岛屿数，num=4则is_last=true当前岛屿没有完全覆盖-->存活岛屿数last_num++;

step4..重复step1.直至搜索结束。

# include <iostream>
# include <vector>
# include <queue>
using namespace std;

void debug_input(vector<vector<char>>& input, int& input_size){
    for(int i=0; i<input_size; i++){
        for(int j=0; j<input_size; j++){
            cout<<input[i][j];
        }
        cout<<endl;
    }
    cout<<endl;
}

class solution
{
private:
    vector<pair<int,int>> move;
    vector<vector<int>> memory; // 是否访问
    bool  BFS(vector<vector<char>>& input, int start_i, int start_j){
        bool is_last = false;
        queue<pair<int,int>> que;
        que.push(make_pair(start_i, start_j));
        memory[start_i][start_j] = 1;
        while(!que.empty()){
            int que_size = que.size();
            while(que_size--){
                auto cur_pos = que.front();
                que.pop();
                // 搜素current'#'四周(上下左右4点)
                int num = 0;
                for(int i=0; i<4; i++){
                    int x = cur_pos.first + move[i].first;
                    int y = cur_pos.second + move[i].second;
                    if(input[x][y] == '#'){
                        num++;
                        if(!memory[x][y]){
                            que.push(make_pair(x, y));
                            memory[x][y] = 1;   // 标记已搜查状态
                        } 
                    }
                }
                // current'#'四周均为'#'，不会淹没
                if(num == 4) is_last = true;
            }
        }
        return is_last;
    }
    
public:
    solution(int& input_size){
        move.push_back(make_pair(-1,0));
        move.push_back(make_pair(1,0));
        move.push_back(make_pair(0,-1));
        move.push_back(make_pair(0,1));
        
        vector<int> vec(input_size, 0);
        memory.resize(input_size, vec);
    }
    
    int myslove(vector<vector<char>>& input, int& input_size){
        int total_num = 0, last_num = 0;
        // 找连通岛屿
        for(int i=0; i<input_size; i++){
            for(int j=0; j<input_size; j++){
                if(input[i][j] == '#' && !memory[i][j]){
                    total_num++;
                    // BFS搜素连通岛屿
                    if(BFS(input, i, j)) last_num++;
                }
            }
        }
        return total_num - last_num;
     }
};

int main()
{
    //input
    int input_size;
    char input;
    cin >> input_size;
    vector<vector<char>> vec;
    for(int i=0; i<input_size; i++){
        vector<char> tmp;
        for(int j=0; j<input_size; j++){
            cin>>input;
            tmp.push_back(input);
        }
        vec.push_back(tmp);
    }
    // // debug input
    // debug_input(vec, input_size);
    // solve
    solution res(input_size);
    cout<<res.myslove(vec, input_size)<<endl;
    
    return 0;
}