BFS(广度优先搜索)

1. BFS与DFS的区别

1.1 DFS是按枝搜索，BFS是按层搜素.

1.2 DFS使用栈（是隐式的栈，先进后出），BFS使用队列（先进先出，后进后出）.

1.3 通常DFS可以找到所有的路径，BFS可以找到最短路径。

2. BFS与DFS的共同点

2.1 重点考虑父亲和孩子的关系，即知父亲就能找到所有的孩子.

2.2 重点要考虑孩子的合法性判断，即他的重复性和符合约束条件.

2.3 DFS使用必要的变量有vis[],ans[],BFS用的变量有vis[],father[].

3. BFS两种实现方式

3.1 普通数组实现队列

#include<bits/stdc++.h>
using namespace std;
void BFS(int start);
int main()
{
    BFS(start);
    return 0;
}
void BFS(int start)
{
    //1初始化队列
    int q[N];//定义队列 
    int vis[N];//定义标记变量
    int father[N];//记录父亲
    int head=0, tail=1;//初始化头指针和尾指针 
    memset(q,0,sizeof(q)); 
    memset(vis,0,sizeof(vis));//将标记变量初始化为0
    memset(father,0,sizeof(father));//初始化父亲 
    //2根节点入队(起点）
    q[tail]=start;
    vis[start]=1;//标记根节点入队 
    //3进队出队 
    while(head<tail)
    {
        //3.1父亲出队
        head++;//出队头指针增1 
        int p=q[head];
        //3.2判父亲是否为答案
        if()
        {
            //输出答案 
        }
        //3.3孩子入队 
        for(int i=1;i<=n;i++)//n表示孩子数 
        {
            //生成孩子
            //判孩子合法性 
            if()
            {
                tail++;//入队尾指针增一 
                q[tail]=/*孩子*/;
                //标记孩子已经入队 
                vis(/*孩子*/)=1;
                //记录父亲
                father(/*孩子*/)=p;
            }
        }
    }
}

3.2 STL实现队列（推荐使用）

#include<bits/stdc++.h>
using namespace std;
void BFS(int start);
int main()
{
    BFS(start);
    return 0;
}
void BFS(int start)
{
    //1初始化队列
    queue <T> q;
    int vis[N];//定义标记变量
    int father[N];//记录父亲 
    memset(vis,0,sizeof(vis));//将标记变量初始化为0
    memset(father,0,sizeof(father));//初始化父亲 
    //2根节点入队(起点）
    q.push(start);
    vis[start]=1;//标记根节点入队 
    //3进队出队 
    while(!q.empty())
    {
        //3.1父亲出队
        int p=q.front();
        q.pop();
        //3.2判父亲是否为答案
        if()
        {
            //输出答案 
        }
        //3.3孩子入队 
        for(int i=1;i<=n;i++)//n表示孩子数 
        {
            //生成孩子
            //判孩子合法性 
            if()
            {
                q.push(/*孩子*/);
                //标记孩子已经入队 
                vis(/*孩子*/)=1;
                //记录父亲
                father(/*孩子*/)=p;
            }
        }
    }
}

4. 实例：（一本通1802细胞计数问题）

#include<bits/stdc++.h>
using namespace std;
#define N 100
int di[4]= {-1,1,0,0};
int dj[4]= {0,0,-1,1};
int cnt;
int n, m;//定义行列
int vis[N][N];//定义标记变量
struct point
{
    int h, c;//定义行和列
};
void BFS(int h, int c);

int main()
{
    cin>>n>>m;
    for(int i=0; i<n; i++)
    {
        string s;
        cin>>s;
        for(int j=0; j<m; j++)
        {
            if(s[j]=='0')
            {
                vis[i][j]=0;
            }
            else
            {
                vis[i][j]=1;
            }
        }
    }
    for(int i=0; i<n; i++)
    {
        for(int j=0; j<m; j++)
        {
            if(vis[i][j]==1)
            {
                BFS(i,j);
            }
        }
    }
    cout<<cnt;
    return 0;
}

void BFS(int h, int c)
{
    cnt++;//细胞数增一
    //1初始化队列
    queue<point> q;
    //2根节点入队(起点）
    point t= {h,c};
    q.push(t);
    vis[h][c]=0;//标记根节点入队 ,初始化时全是1，入队时为0
    //3进队出队
    while(!q.empty())
    {
        //3.1父亲出队
        point p=q.front();
        q.pop();

        //3.3孩子入队
        for(int i=0; i<4; i++) //n表示孩子数
        {
            //生成孩子
            int ni=p.h+di[i];
            int nj=p.c+dj[i];
            //判孩子合法性
            if(vis[ni][nj]==1 && ni>=0 && ni<n && nj>=0 && nj<m)//不重复不越界
            {
                point t= {ni,nj};
                q.push(t);
                //标记孩子已经入队
                vis[ni][nj]=0;
            }
        }
    }
}