bfs

广度优先搜索

首先选择一个点作为起始结点，并将其标注为已知点

构造一个队列

将起始结点放入队列中

从队列首部选出一个点，并找出所有与之邻接的结点

将找到的邻接结点放入队列尾部，对已访问过的点进行标记

如果结点的已经标记，表示已经发现并且放入了队列，如果节点没有标记，表示还没有发现

每一次拓展完要进行出队

按照同样的方法处理队列中的下一个结点

当队列元素为空的时候结束

构造队列可以选择利用 stl 中的queue，也可以选择手打队列

两种方式都要构造一个结构体

结构体一般有横纵坐标和走过的步数

 

struct node
{
    int x;
    int y;
    int step;
};

 

1 . 利用stl

queue 头文件 #include<queue>

申请队列

//随机选择一个参数

queue <node> r

入队

r.push()

出队

r.pop

队首元素

r.front()

 

#include<stdio.h>
#include<queue>
using namespace std;
int mp[100][100],v[100][100];
int dx[4]={0,1,0,-1},dy[4]={1,0,-1,0};//方向数组
struct point
{
    int x,y,step;
};
queue<point> r;//申请队列 
int main()
{
    //输入
    int n,m,sx,sy,p,q;
    scanf("%d%d",&n,&m);
    for(int i=1;i<=n;i++)
    for(int j=1;j<=m;j++)
        scanf("%d",&mp[i][j]);
     scanf("%d%d%d%d",&sx,&sy,&p,&q);
     //bfs
    point start;
    start.x =sx;
    start.y =sy;
    start.step =0;
    r.push(start);//将起点入队 
    v[sx][sy]=1;
    int flag=0;
    while(!r.empty())//队列不为空循环
    {
        int x=r.front().x,y=r.front().y;
        if(x==p&&y==q)
        {
            
            flag=1;//表示有解 
            printf("%d",r.front().step);
            break;
        }
        for(int k=0;k<=3;k++)
        {
            int tx,ty;
            tx=x+dx[k];
            ty=y+dy[k];
            if(mp[tx][ty]==1&&v[tx][ty]==0)
            {
                //入队
                point temp;
                temp.x =tx;
                temp.y =ty;
                temp.step =r.front().step+1;
                r.push(temp);
                v[tx][ty]=1; 
            }
        }
        r.pop();//拓展完，要将队首元素出队 
    }
    if(flag==0)
    printf("no answer");
    return 0;
}

 

2 . 手打队列

申请队列 struct node que[];

申请一个头一个尾

head；

tail；

然后入队

que.[tail];

 

#include<stdio.h>
struct note {
        int x;
        int y;
        int s;
    };
int main() {
    struct note que[2501];
    int map[51][51]= {0},book[51][51]= {0};
    int next[4][2]= {{0,1},{1,0},{0,-1},{-1,0}};//方向数组 
    int head,tail;
    int i,j,k,n,m,sx,sy,fx,fy,tx,ty,flag;
    scanf("%d %d",&n,&m);
    for(i=1; i<=n; i++)
        for(j=1; j<=m; j++)
            scanf("%d",&map[i][j]);
    scanf("%d %d %d %d",&sx,&sy,&fx,&fy);
    //初始化队列 
    head=1;
    tail=1;
    //起点入队 
    que[tail].x=sx;
    que[tail].y=sy;
    que[tail].s=0;
    tail++;
    book[sx][sy]=1;
    flag=0;
    //队列为空结束循环 
    while(head<tail) {
        for(k=0; k<4; k++) {
            tx=que[head].x+next[k][0];
            ty=que[head].y+next[k][1];
            if(tx<1||tx>n||ty<1||tx>m)
                continue;
            if(map[tx][ty]==0&&book[tx][ty]==0) {
                book[tx][ty]=1;
                que[tail].x=tx;
                que[tail].y=ty;
                que[tail].s=que[head].s+1;
                tail++;
            }
            if(tx==fx&&ty==fy) {
                flag=1;
                break;
            }
        }
        if(flag==1)
            break;
        head++;
    }
    printf("%d",que[tail-1].s);//tail是指向队尾的下一个位置，所以要减一 
    return 0;
}