【BFS】层层递进—广度优先搜索

【BFS】层层递进—广度优先搜索 Breadth First Search

啊哈算法 迷宫中寻找小哈
 

#include <iostream>
#include <stdio.h>
#include <stdlib.h>
using namespace std;
struct node{//结构体
    int x;//横坐标
    int y;//纵坐标
    int f;// 用来储存他的·Father 父亲的head
    int s;//他的步数
};
/*BFS算法 广度优先算法 Breadth First Search
是一层层的查找
先找到第一步能到哪里，再在第一步的基础上找到第二步能到的新地方
这样就能找到最短的路线了
*/
int main(){
    struct node que[2501];//最多将数组50*50全部走一次，队列中最多2500个元素
    int a[51][51]={0},book[51][51]={0};//a[]储存环境，book[]储存是否走过
    int next[4][2]={{0,1},//方向数组 向右 Y+1 向下 X+1 向左 Y-1 向上 X-1
                    {1,0},
                    {0,-1},
                    {-1,0}};
    int head,tail;//队列的头和尾 startx starty初始横纵坐标，tx,ty下一步横纵坐标
    int i,j,k,n,m,startx,starty,tx,ty,p,q,flag;//flag==1表明找到了 p,q目标坐标
    scanf("%d %d",&n,&m);
    for(i=1;i<=n;i++){
        for(j=1;j<=m;j++){
            scanf("%d",&a[i][j]);
        }
    }
    scanf("%d %d %d %d",&startx,&starty,&p,&q);
    head=1; tail=1;
    que[tail].x=startx; que[tail].y=starty;
    que[tail].f=0; que[tail].s=0;
    tail++;
    book[startx][starty]=1;
    flag=0;
    while(head<tail){
        for(k=0;k<=3;k++){
            tx=que[head].x+next[k][0];
            ty=que[head].y+next[k][1];
            if(tx<1 || tx>n || ty<1 || ty>m){//判断是否出了地图
                continue;
            }
            if(a[tx][ty]==0 && book[tx][ty]==0){//判断是否走过和有无障碍物
                book[tx][ty]==1;//下一步可以走 标记走过
                que[tail].x=tx; que[tail].y=ty;
                que[tail].f=head;//记录他的父亲坐标对应队中位置
                que[tail].s=que[head].s+1;//下一步 是父亲步数+1
                tail++;//入队延长队列
            }
            if(tx==p && ty==q){
                flag=1;
                break;
            }
        }
        if(flag==1){
            break;
        }
        head++;
    }
    printf("%d",que[tail-1].s);//找到后，tail++了，减 1 才是目标的队列位置
    system("pause");
    return 0;
}