精华内容
下载资源
问答
  • 迷宫最短路径

    2017-06-30 22:48:57
    迷宫最短路径
    #include <iostream>
    #include <utility>
    using namespace std;
    const int MAX_N=100,MAX_M=100;
    const int INF = 100000000;
    // 使用pair表示状态时,使用typedef会更加方便一些
    typedef pair<int, int> P;
    // 输入
    char maze[MAX_N][MAX_M + 1]; // 表示迷宫的字符串的数组
    int N, M;
    int sx, sy; // 起点坐标
    int gx, gy; // 终点坐标
    int d[MAX_N][MAX_M]; // 到各个位置的最短距离的数组
    // 4个方向移动的向量
    int dx[4] = {1, 0, -1, 0}, dy[4] = {0, 1, 0, -1};
    // 求从(sx, sy)到(gx, gy)的最短距离
    // 如果无法到达,则是INF
    int bfs() {
        queue<P> que;
    // 把所有的位置都初始化为INF
         for (int i = 0; i < N; i++)
         for (int j = 0; j < M; j++) d[i][j] = INF;
    // 将起点加入队列,并把这一地点的距离设置为0
         que.push(P(sx, sy));
         d[sx][sy] = 0;
    // 不断循环直到队列的长度为0
         while (que.size()) {
    // 从队列的最前端取出元素
         P p = que.front(); que.pop();
    // 如果取出的状态已经是终点,则结束搜索
         if (p.first == gx && p.second == gy) break;
    // 四个方向的循环
         for (int i = 0; i < 4; i++) {
    // 移动之后的位置记为(nx, ny)
         int nx = p.first + dx[i], ny = p.second + dy[i];
    // 判断是否可以移动以及是否已经访问过(d[nx][ny]!=INF即为已经访问过)
              if (0 <= nx && nx < N && 0 <= ny && ny < M && maze[nx][ny] != '#' &&
                   d[nx][ny] == INF) {
    // 可以移动的话,则加入到队列,并且到该位置的距离确定为到p的距离+1
                   que.push(P(nx, ny));
                    d[nx][ny] = d[p.first][p.second] + 1;
    }
    }
    }
    return d[gx][gy];
    }
    
    void solve(){
     int res = bfs();
     cout<<res<<endl;
    }
    int main()
    {
        cin>>N>>M;
        cin>>sx>>xy>>gx>>gy;
        for(int i=1;i<=N;i++)
            for(int j=1;j<=M;j++)
            cin>>maze[i][j];
        solve();
        return 0;
    }
    

    展开全文
  • 迷宫 最短路径

    2013-01-19 20:11:27
    迷宫 最短路径 的C代码 算得上是有图形的
  • 迷宫问题迷宫问题迷宫问题迷宫问题迷宫问题
  • 迷宫最短路径问题 数据结构,详解https://blog.csdn.net/LZJSTUDY/article/details/81143863
  • #include #include #include #define MAX 30//迷宫最大30*30#define ENDS -2//端点位置标记为-2#define ROUT -1//入队的路径标记为-1#define SHORTESTPATH 2//将最终的最短路径标记为2//队列结构,保存进行广度优先...

    #include

    #include

    #include

    #define MAX 30//迷宫最大30*30

    #define ENDS -2//端点位置标记为-2

    #define ROUT -1//入队的路径标记为-1

    #define SHORTESTPATH 2//将最终的最短路径标记为2

    //队列结构,保存进行广度优先搜索时的路径

    typedef struct QueueNode

    {

    int a[2];//记录当前对应的位置

    int source;//记录新节点是由哪个节点探测的

    int self;//记录新节点在队列中的位置

    struct QueueNode *parent,*next;//双亲域

    }Queue;

    Queue *front;//队头指针

    Queue *rear;//队尾指针

    //栈结构,保存已经探测好的路径

    typedef struct Path

    {

    int a[2];

    struct Path *next;

    }PathStack;

    int MapRand(int i,int j,int maze[MAX][MAX])//随机迷宫生成函数,百分之六十是墙,百分之四十是通路

    {

    float scale=0.4;//墙的比例,百分之六十

    int count=0;//计数器,在对迷宫比例进行局部调整的时候使用

    time_t t;//设定时间种子

    srand((unsigned)time(&t));

    int m,n;//控制循环变量

    for(m=0;m

    for(n=0;n

    maze[m][n]=rand()%10;

    for(m=0;m

    for(n=0;n

    if(maze[m][n]<5)

    maze[m][n]=0;

    else

    maze[m][n]=1;

    //控制墙和路的比例

    for(n=0;n

    {

    maze[0][n]=0;

    maze[i-1][n]=0;

    }

    for(m=1;m

    {

    maze[m][0]=0;

    maze[m][j-1]=0;

    }

    //将外围置为墙,防止出界

    for(m=1;m

    for(n=1;n

    if(maze[m][n]==0)

    count++;

    //统计墙的个数

    int total;//墙的总数

    total=(int)(i-2)*(j-2)*scale;

    while(count!=total)

    if(count

    {

    m=rand()%(i-2)+1;

    n=rand()%(j-2)+1;

    if(maze[m][n]==1)

    {

    maze[m][n]=0;

    count++;

    }

    }

    else

    {

    m=rand()%(i-2)+1;

    n=rand()%(j-2)+1;

    if(maze[m][n]==0)

    {

    maze[m][n]=1;

    count--;

    }

    }

    //对迷宫进行局部随机调整,使墙和路的比例合乎规定

    return 0;

    }

    int PrintMap(int i,int j,int maze[MAX][MAX])//打印迷宫

    {

    int m,n;

    printf(" ");

    for(n=0;n

    printf("%d",n%10);

    printf("\n");

    for(m=0;m

    {

    printf("%d",m%10);

    for(n=0;n

    {

    if(maze[m][n]==0)

    printf("%c",219);

    //墙

    if(maze[m][n]==1||maze[m][n]==ROUT)

    printf(" ");

    if(maze[m][n]==SHORTESTPATH)

    printf("*");

    //路径

    if(maze[m][n]==ENDS)

    printf("%c",1);//笑脸

    //开始位置和终点位置

    }

    printf("\n");

    }

    printf("\n");

    return 0;

    }

    int InitQueue(int maze[MAX][MAX])//构造一个队列,并把起始位置加入队列

    {

    int m,n;//起始位置坐标

    printf("Please enter the starting location(i,j):");

    scanf("%d%d",&m,&n);

    getchar();

    while(maze[m][n]==0)

    {

    printf("This seat is unacceptable,please reenter the starting location(i,j):");

    scanf("%d%d",&m,&n);

    getchar();

    }

    maze[m][n]=ENDS;//开始位置

    Queue *q;

    q=(Queue *)malloc(sizeof(Queue));

    if(q==NULL)

    {

    printf("Error1!");

    exit(1);

    }

    q->a[0]=m;

    q->a[1]=n;

    q->parent=q->next=NULL;

    q->source=0;

    q->self=0;

    front=rear=q;

    return 0;

    }

    int EnQueue(int m,int n)//入队函数

    {

    Queue *q;

    q=(Queue *)malloc(sizeof(Queue));

    if(q==NULL)

    {

    printf("Error2!");

    exit(1);

    }

    q->a[0]=m;

    q->a[1]=n;

    q->next=NULL;

    q->self=rear->self+1;

    q->source=front->self;

    rear->next=q;

    q->parent=rear;

    rear=q;

    return 0;

    }

    PathStack *pushstack(PathStack *top,int m,int n)//入栈函数

    {

    PathStack *q;

    q=(PathStack *)malloc(sizeof(PathStack));

    if(q==NULL)

    {

    printf("Error3!");

    exit(1);

    }

    q->a[0]=m;

    q->a[1]=n;

    q->next=top;

    top=q;

    return top;

    }

    int ShortestPath_BFS(int maze[MAX][MAX])//广度优先搜索,寻找最短路径

    {

    int move[4][2]={{0,1},{1,0},{0,-1},{-1,0}};//四个方向,依次是右,下,左,上

    int i;//控制循环变量,实现四个方向的转换

    int m,n;//记录坐标位置,用此位置来探测下一位置

    int end1,end2;//终点坐标位置

    printf("please enter the end position(i,j):");

    scanf("%d%d",&end1,&end2);

    getchar();

    while(maze[end1][end2]==0)

    {

    printf("This seat is unacceptable,please reenter the end position(i,j):");

    scanf("%d%d",&end1,&end2);

    getchar();

    }

    while(front)

    {

    m=front->a[0];

    n=front->a[1];

    for(i=0;i<4;i++)

    {

    int x,y;

    x=m+move[i][0];

    y=n+move[i][1];

    if(maze[x][y]==1)

    {

    maze[x][y]=ROUT;//将入队的位置标记为-1

    EnQueue(x,y);

    if(x==end1&&y==end2)

    return 0;

    }

    }

    front=front->next;

    }

    printf("Sorry,No can reach path!\n");

    return 1;

    }

    PathStack * Shortestpath(PathStack *top,int maze[MAX][MAX])//用栈结构保存路径

    {

    int m,n;//记录指针对应的位置

    int t;//记录该位置的来源,即由哪个节点探测的

    Queue *p=rear;

    m=p->a[0];

    n=p->a[1];

    top=pushstack(top,m,n);

    maze[m][n]=ENDS;

    t=p->source;

    while(1)

    {

    p=p->parent;

    if(p->self==t)

    break;

    }

    while(p->parent)

    {

    m=p->a[0];

    n=p->a[1];

    maze[m][n]=SHORTESTPATH;

    top=pushstack(top,m,n);

    t=p->source;

    while(1)

    {

    p=p->parent;

    if(p->self==t)

    break;

    }

    }

    m=p->a[0];

    n=p->a[1];

    maze[m][n]=ENDS;

    top=pushstack(top,m,n);

    return top;

    }

    int PrintPath(PathStack *top,PathStack *base)//打印路径

    {

    int k=0;//控制输出格式

    int m,n;//迷宫位置

    m=top->a[0];

    n=top->a[1];

    printf("(%d,%d)%c",m,n,26);

    k++;

    top=top->next;

    while(top->next!=base)

    {

    m=top->a[0];

    n=top->a[1];

    printf("(%d,%d)%c",m,n,26);

    k++;

    if(k==5)

    {

    printf("\n");

    k=0;

    }

    top=top->next;

    }

    m=top->a[0];

    n=top->a[1];

    printf("(%d,%d)\n",m,n);

    return 0;

    }

    int main()

    {

    int maze[MAX][MAX];

    int i,j;//i行数,j列数

    PathStack head;

    head.next=NULL;

    PathStack *top;

    top=&head;

    //初始化栈结构

    while(1)

    {

    char c;

    printf("InitMap:I,PrintMap:P,SearchShortestpath:S,Route:R,Quit:Q:");

    scanf("%c",&c);

    getchar();

    if(c=='I'||c=='i')//初始化地图

    {

    printf("Please Enter The Line Number(<=30) And Column Number(<=30):");

    scanf("%d%d",&i,&j);

    getchar();

    while(i>30||j>30)

    {

    printf("Please Enter The Line Number(<=30) And Column Number(<=30):");

    scanf("%d%d",&i,&j);

    getchar();

    }

    MapRand(i,j,maze);

    //以上为创建随机迷宫

    }

    else if(c=='P'||c=='p')//打印地图

    PrintMap(i,j,maze);

    else if(c=='S'||c=='s')

    {

    InitQueue(maze);//初始化队列

    if(ShortestPath_BFS(maze)==1)//如果返回值为1,则说明没有可通路径,退出函数

    continue;

    top=Shortestpath(top,maze);

    }

    else if(c=='R'||c=='r')//打印路径

    PrintPath(top,&head);

    else if(c=='Q'||c=='q')//退出程序

    return 0;

    fflush(stdin);//清空缓冲区

    }

    return 0;

    }

    运行结果:

    0818b9ca8b590ca3270a3433284dd417.png

    展开全文
  • C++迷宫最短路径

    2014-02-21 05:10:26
    Eclipse下C++迷宫最短路径骨干程序,不完整
  • 迷宫最短路径算法

    2011-11-14 18:53:10
    关于迷宫最短路径的新算法,在文档中详细的指出了有关于迷宫中求解最短路径的算法。
  • 迷宫最短路径思路

    千次阅读 多人点赞 2019-06-18 17:01:32
    迷宫最短路径 迷宫的算法很多,但是解释原理的却很少,在这里我利用自己的亲身经历来讲解一下求解迷宫的原理,迷宫求解可以利用栈结构,即深度优先,探索一个位置就标记,通则走,不同则后退寻找下一个位置,可以求...

    迷宫最短路径

    迷宫的算法很多,但是解释原理的却很少,在这里我利用自己的亲身经历来讲解一下求解迷宫的原理,迷宫求解可以利用栈结构,即深度优先,探索一个位置就标记,通则走,不同则后退寻找下一个位置,可以求出通路,简单但是不一定是最短路径,这里求最短路径利用的是广度优先的思想,什么是广度优先,利用队列实现,一个元素出对,然后访问这个元素相邻的所有元素,原理是,一个二维数组,0表示墙,1表示路,这里我利用随机数生成0和1,4个方向,在广度优先算法的思想下,队头元素出队,然后广度依次访问他的4个方向,依次入队,并记下他们的前一个坐标在队列中的位置,重复直到出对的是终点,在找到终点后,利用每一个位置都有前一个坐标在队列中的下标进行回访,访问到起点即走了一遍找到的路径,此时便可正向输出路径即可。

    广度优先访问的过程就是,假设现在队头是5,5出队后,访问5的相邻元素,即将6,8,4,2入队,这里是顺时针方向,一次类推。
    假设这里9个元素全部是路,一开始1入队,然后1出队,访问四周,2,4依次入队,前一个坐标是1,2出队,3,5入队,前一个坐标是2,4出队,7入队,前一个坐标是4,3出队,6入队,前一坐标是3,5出队,8入队,前一坐标是8,6出队,9入队,前一坐标是6,访问了终点9,结束入队,从9开始回访,9->6->3->2->1 即找到最短路径。

    #include
    #include<stdlib.h>
    #include<time.h>
    using namespace std;

    struct Node
    {
    int data;
    int flag;
    };

    struct Path
    {
    int xpath;
    int ypath;
    int pox; //在队列中的下标
    };

    class Maze
    {
    private:
    int n, m; //迷宫的行和列
    Node *maze; //迷宫存放
    Path *que;
    int top = -1;
    int front = -1;
    int rear = -1;
    public:

    	void create()
    	{
    		int i, j;
    		cout<<"输入迷宫的行和列:";
    		cin>>n>>m;
    		maze = new Node[n*m];
    		srand(time(NULL));
    		for(i = 0; i<n; i++)
    		{
    			for(j = 0; j<m; j++)
    			{
    				int temp = rand()%4;
    				if(temp != 1) maze[i*m+j].data = 1;
    				else maze[i*m+j].data = 0;
    				maze[i*m+j].flag = 0;
    			}
    		}
    		maze[0].data = 8;  //设置起点 
    		maze[n*m-1].data = 1;
    		show();
    	} 
    	
    	/*搜索路径*/ 
    	void seek_road()   /*先实现一个路径先*/ 
    	{
    		//path = new Path[n*m];
    		int x1, y1;
    		que = new Path[n*m]; 			     //利用广度优先实现最短路径
    		que[0].xpath = 0;
    		que[0].ypath = 0;
    		que[0].pox = 0;
    		maze[0].flag = 1;
    		rear++;
    		while(front != rear)
    		{
    			int x = que[(++front)%(n*m)].xpath;  //获取队头的坐标,然后将其四周的通路进队,知道操作完队尾元素 
    			int y = que[front%(n*m)].ypath;
    		//	path[++top] = que[front];
    			if(judge_head()) return;
    			if(y+1<m)
    				push_road(x,y+1);
    			if(x+1<n)
    				push_road(x+1,y);
    			if(y-1>=0)
    				push_road(x,y-1);
    			if(x-1>=0)
    				push_road(x-1,y);
    		}	
    		cout<<"没有通路!!"<<endl;
    	}
    			 
    			
    	void show()
    	{
    		for(int i = 0; i<n; i++)
    		{
    			for(int j = 0; j<m; j++)
    			{
    				if(maze[i*m+j].data == 8) cout<<"■ "; 
    				else cout<<maze[i*m+j].data<<"  ";
    			}
    			cout<<endl;
    		}
    	}
    	
    	int judge_head()
    	{
    		int k=1;
    		if(que[front].xpath == n-1 && que[front].ypath == m-1) 
    		{
    			
    			cout<<"找到迷宫的通路!"<<endl;
    			int x = que[front].xpath;
    			int y = que[front].ypath;
    			int t = que[front].pox;    //前一个坐标在队列的下标 
    			while(x != 0 || y != 0)
    			{
    				maze[x*m+y].data = 8;
    				x = que[t].xpath;
    				y = que[t].ypath;
    				t = que[t].pox;
    				k++;
    			}
    			show();
    			cout<<"路径长度为:"<<k<<endl; 
    			return 1;
    		}
    		return 0;
    	}
    	
    	void push_road(int x, int y)
    	{
    		if(maze[x*m+y].data == 1 && maze[x*m+y].flag == 0)
    		{
    			que[(++rear)%(n*m)].xpath = x;
    			que[rear%(n*m)].ypath = y;
    			que[rear%(n*m)].pox = front;   //设置上一个坐标在队列中的位置 
    			maze[x*m+y].flag = 1;
    		}
    	}
    

    };

    int main()
    {
    Maze *ma = new Maze(); /待解决-迷宫最短路径问题/
    ma->create();
    ma->seek_road();
    return 0;
    }
    注:这是个人学习过程中得体会,如果有错误得地方,欢迎留言提醒,定会及时修改,如果觉得有帮助,可以加个关注,后面还会有其他算法得原理分析和代码,也可私聊我哦

    展开全文
  • 深度优先搜索例程:迷宫最短路径
  • 广度优先搜索例程:迷宫最短路径
  • 迷宫最短路径问题

    2011-11-22 22:30:37
    数据结构实验课题之一的,C语言版迷宫最短路径问题的完整代码
  • 用C++语言实现迷宫最短路径搜索图形界面程序
  • 一个迷宫最短路径寻径算法,可显示迷宫,路径。可修改迷宫。
  • python求迷宫最短路径

    2021-05-16 19:04:14
    python求迷宫最短路径算法-bfs # -*- coding: utf-8 -*- """ Created on Tue Apr 27 13:48:14 2021 @author: Administrator """ ###无递归、类求迷宫最短路径算法 #import random pre_route=list() #宽度搜索得到...

    python求迷宫最短路径算法-bfs

    # -*- coding: utf-8 -*-
    """
    Created on Tue Apr 27 13:48:14 2021
    
    @author: Administrator
    """
    
    ###无递归、类求迷宫最短路径算法
    #import random
    pre_route=list()    #宽度搜索得到的节点
    q=list()    #队列结构控制循环次数
    xx=[0,1,0,-1]   #右移、下移、左移、上移
    yy=[1,0,-1,0]
    visited=list()  #记录节点是否已遍历
    father=list()   #每一个pre_route节点的父节点
    route=list()
    def bfs(l,x,y,m,n):
        visited=[[0 for i in range(len(l[0]))]for j in range(len(l))]
        visited[x][y]=1 #入口节点设置为已遍历
        q.append([x,y])
        while q:    #队列为空则结束循环
            now=q[0]
            q.pop(0)    #移除队列头结点
            for i in range(4):
                point=[now[0]+xx[i],now[1]+yy[i]]   #当前节点
                if point[0]<0 or point[1]<0 or point[0]>=len(l) or point[1]>=len(l[0]) or visited[point[0]][point[1]]==1 or l[point[0]][point[1]]=='1':
                    continue
                father.append(now)
                visited[point[0]][point[1]]=1
                q.append(point)
                pre_route.append(point)
                if point[0]==m and point[1]==n:
                    print("success")
                    return 1
        print("false")
        return 0
    
    def get_route(father,pre_route):    #输出最短迷宫路径
        route=[pre_route[-1],father[-1]]
        for i in range(len(pre_route)-1,-1,-1):
            if pre_route[i]==route[-1]:
                route.append(father[i])
        route.reverse()
        print("迷宫最短路径为:\n",route)
        print("步长:",len(route)-1)
        return route
        
    def prn_map(route,l,m,n):   #打印包含路径的迷宫图
        for i in range(len(l)):
            l[i]=list(l[i])
        for i in range(len(route)):
            l[route[i][0]][route[i][1]]='2'
        for i in range(len(l)):
            for j in range(len(l[0])):
                if l[i][j]=='1':
                    print('  ',end='')
                elif l[i][j]=='0':
                    print('██',end='')
                else:
                    print('░░',end='')
                if i==m and j==n:
                    print('☀',end='')
            print()
    
    l=['01010101001011001001010110010110100100001000101010',
       '00001000100000101010010000100000001001100110100101',
       '01111011010010001000001101001011100011000000010000',
       '01000000001010100011010000101000001010101011001011',
       '00011111000000101000010010100010100000101100000000',
       '11001000110101000010101100011010011010101011110111',
       '00011011010101001001001010000001000101001110000000',
       '10100000101000100110101010111110011000010000111010',
       '00111000001010100001100010000001000101001100001001',
       '11000110100001110010001001010101010101010001101000',
       '00010000100100000101001010101110100010101010000101',
       '11100100101001001000010000010101010100100100010100',
       '00000010000000101011001111010001100000101010100011',
       '10101010011100001000011000010110011110110100001000',
       '10101010100001101010100101000010100000111011101001',
       '10000000101100010000101100101101001011100000000100',
       '10101001000000010100100001000100000100011110101001',
       '00101001010101101001010100011010101101110000110101',
       '11001010000100001100000010100101000001000111000010',
       '00001000110000110101101000000100101001001000011101',
       '10100101000101000000001110110010110101101010100001',
       '00101000010000110101010000100010001001000100010101',
       '10100001000110010001000010101001010101011111010010',
       '00000100101000000110010100101001000001000000000010',
       '11010000001001110111001001000011101001011011101000',
       '00000110100010001000100000001000011101000000110011',
       '10101000101000100010001111100010101001010000001000',
       '10000010100101001010110000000100101010001011101000',
       '00111100001000010000000110111000000001000000001011',
       '10000001100111010111010001000110111010101101111000']
    
    if __name__ =='__main__':
        x=0;y=0
        m=25;n=40
        if bfs(l,x,y,m,n)==1:
            route=get_route(father,pre_route)
            prn_map(route,l,m,n)
    

    在这里插入图片描述
    直观效果图

    展开全文
  • 用Java实现迷宫最短路径算法

    千次阅读 2019-01-26 11:24:51
    迷宫最短路径用宽度优先搜索(bfs)相比用深度优先搜索(dfs)的好处在于bfs每次计算都是最短路径不存在重复计算,而dfs每计算出一条可行的路径都要与先前的路径比较,然后储存最短路径。 而bfs的思想是先计算出围绕...
  • flash as3.0 求解迷宫最短路径 深度优先策略 flash as3.0 求解迷宫最短路径 深度优先策略 flash as3.0 求解迷宫最短路径 深度优先策略 flash as3.0 求解迷宫最短路径 深度优先策略 flash as3.0 求解迷宫最短路径 ...
  • 行业分类-物理装置-蜂巢迷宫最短路径计算方法及蜂巢迷宫实训系统.zip
  • 迷宫最短路径.txt

    2013-06-09 16:21:14
    数据结构中的一种方法。介绍如何生成迷宫最短路径。这里是全部代码。
  • 查找迷宫最短路径

    千次阅读 2019-10-04 15:13:19
    迷宫最短路径算法 算法的基本思想 从迷宫入口点(1,1)出发,向四周搜索,记下所有能一步到达的点坐标,然后依次再从这些点出发,然后再记下所有能一步到达的坐标点…依次类推直到能找到迷宫的出口点(m,n)为止,...
  • 迷宫最短路径算法 使用队列
  • C语言 利用队列求迷宫最短路径

    千次阅读 2020-11-24 10:54:22
    C语言 数据结构利用队列求迷宫最短路径 利用队列,求迷宫最短路径,再用栈输出路径 迷宫障碍为#,@为路径,随机产生的是10*10的迷宫。 话不多说,直接上代码 #include<stdio.h> #include<stdlib.h> #...
  • 这是对于邓俊辉老师的《数据结构》一书的4.4.3节的迷宫最短路径算法的自我拓展。在上一篇博客中,我提到本人用DFS算法尝试不出最短路径的解决方法,所以在此篇博客中,本人采用了BFS算法,并结合建图的方式求出了...
  • bfs迷宫最短路径

    2020-03-28 22:56:48
    迷宫最短路径 S:入口 T:出口 *:墙 #include<iostream> #include <cstring> #include <queue> using namespace std; int n,m; string maze[110]; bool vis[110][110]; int dir[4][2]={{-...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 10,287
精华内容 4,114
关键字:

迷宫最短路径