广度优先搜索

广度优先搜索其实是一个队列问题。

 

它是一层一层的遍历 与深度优先搜索的先把一条路径遍历完有所不同

bfs(广度)：v0 (0)- v2 v1 v3 (1) - v4 v5 -v6 （2第2层）

bfs是专门针对图来说的

过程：首先创建一个队列 v0进队 v0出队 然后它的下一层v2 v1 v3进队-然后v2出队--v4进队--然后v1出队-v3进队-后面也是如此

总之一句话 就是每一个顶点出队的时候 相对应的下面一层的顶点就要进队。如此便可以bfs

 

难点：1.什么时候bfs遍历结束 你需要找一个条件当不满足while时 ，便结束遍历 这里是队列为空的时候，

           2.在遍历时候 怎么从每一顶点过渡到它的下一层

我们结合一道题目一起看：

 代码：

#include
using namespace std;
string a[1001];
int b[10001][2];
int vis [1001][1001];
int d[4][2]= {{0,1},{1,0},{0,-1},{-1,0}};
int m,n;
int max1=1;
typedef struct {
    int front;
    int rear;
    int a[1000][3];
}queue1;
queue1 *init_queue(queue1 *p) {
    p = new queue1;
    p->front=0;
    p->rear=0;
    return p; 
}
int empty(queue1 *p) {
    if(p->front==p->rear)
        return 1;
    else
        return 0;
}

int  dequeue(queue1 *p) {
    p->front=(p->front+1)%1000;
    return 0;
}

void enqueue(queue1 *p,int data,int x,int y)
{
    p->a[p->rear][0]=data;
    p->a[p->rear][1]=x;
    p->a[p->rear][2]=y;
    p->rear = (p->rear+1)%1000;
    return;
}

void bfs(int x,int y)
{
    queue1 *p1;
    p1 = init_queue(p1);
    enqueue(p1,a[x][y],x,y);
    vis[x][y]=1;
    while(!empty(p1)) 难点1
    {
        x=p1->a[p1->front][1];//
        y=p1->a[p1->front][2];//难点2 顶点和他的下面一层联系在一起
        dequeue(p1);
        for(int i=0;i<4;i++)
        {
            if(d[i][1]+y>=0&&d[i][1]+y=0&&d[i][0]+x             if(vis[x+d[i][0]][y+d[i][1]]==0&&a[d[i][0]+x][d[i][1]+y]!=a[x][y])//难点2 顶点和他的下面一层联系在一起
            {
                    enqueue(p1,a[x+d[i][0]][y+d[i][1]],x+d[i][0],y+d[i][1]);
                    max1++;
                    vis[x+d[i][0]][y+d[i][1]]=1;
            }
        }
    }
    
}
int main()
{
    int i,j,k;
    cin >> n >> m;
    for(i=0;i     cin >> a[i];
    for(i=0;i     for(j=0;j<2;j++) 
    cin >> b[i][j];
    for(i=0;i     {
        vis[b[i][0]-1][b[i][1]-1] = 1;
        bfs(b[i][0]-1,b[i][1]-1);
        memset(vis,0,sizeof(vis));
        cout << max1 <         max1 = 1;
    }
    return 0; 
 }