求带环的多出口迷宫的最短路径

原创 2018年04月17日 16:28:58

在前面的博客中,我们已经解决了简单迷宫的求解问题以及多出口(不带环)迷宫求最短路径的问题。求带环的多出口迷宫的最短路径,需要我们在之前解决问题的思想上做出调整和改进。

  • 首先,我们先来定义一个带环的多出口迷宫:

                  

图中黄色标记为一个环,0表示墙,即无法落脚;1表示可以落脚;之后我们会用2来标记走过的路。

我们默认出口为四个边界上的点。若入口也为边界点,则出口与入口不能重合。

  • 解题思路的改进:

(1)CanStay函数。在之前的代码中,我们判断当前点是否能落脚,实现判断当前点是否在边界外,若在边界外则不能落脚;若在边界内且当前点的值为1,则可以落脚。但在求带环的多出口迷宫的最短路径时,我们还需要判断cur_value是否大于pre_value+1,若满足则应该落脚,若不满足则不应该落脚。

(2)Mark函数。在之前的代码中,我们将走过的路径点的值全部改为2,表示这个点已经走过。但在求带环的多出口迷宫的最短路径的问题时,我们不能简单的将走过的路径的点全部标记为一个特定的值。

                          

如上图所示,根据我们定义的按顺时针方向探测相邻点,那么该迷宫找到的第一条路径应该如图中蓝色数字标示所示。当找到一条路径后,进行出栈回溯,继续寻找下一条路径。

                        

此时就又新找到了一条路径。然后进行出栈回溯,继续新一轮的探测:

                        

当按顺时针方向进行探测时,走到图中红色圈出来的点后,就会发现,此时周围相邻的四个点要么无法落脚,要么已经走过,所以进行出栈回溯操作,继续寻找下一条路径。

                        

当回溯到上一个点后,按照顺时针探测的规则,下一个要走的点即为图中圈出来的点,当走到下一个点时,就相当于又找到了一条路径。相同地,进行出栈回溯,寻找下一条路径。此时会回溯到入口点,然后进行新一轮的探测。

                        

当回到入口点下面这个点时,向下进行探测时,发现下一个点已经被标记过,而右边的点不能落脚,所以探测就结束了。然而图中我们圈出来的这条路径,却没有被找到!

这就说明,在求带环的多出口迷宫的最短路径上,我们不能单纯地将已经走过的点标记为同一个特定值,而是应该采用新的方法:我们规定,将能落脚的入口点标记为2,之后的每个点都为上一个点的值+1,这样我们就得到了第一条路径的标记图:

                        

然后出栈回溯,寻找第二条路径:

                        

此时就找到了第二条路径。出栈回溯,继续寻找下一条路径:                        

                        

当走到图中标记为10的位置时,探测发现周围四个相邻点的值。探测上边的点时,发现3>10+1这个条件不满足,所以不应该落脚;探测右边和左边的点值为0,不能落脚,所以回溯到标记点为9的位置,继续新一轮的探测,发现当前位置左边的点满足标记条件,则直接落脚,并且此时又找到了一条路径。

                        

然后进行出栈回溯,回到标记为3的位置,按照顺时针方向,向下探测,发现10>3+1,所以可以落脚,并且将值改为4,之后的步骤同理:

                        

当走到图中圈出来的点时,向上探测,发现值为0不能落脚;向左探测发现7>6+1不成立,所以不能落脚;向下探测发现9>6+1成立,所以往下走,并修改标记值:

                        

这是就又找到了一条新的路径。以此方法类推,便能找到所有的路径。

(3)就如求解多出口迷宫(不带环)问题一样,由于多出口迷宫存在着多条路径,所以我们需要定义两个栈,一个栈中存放着当前走过的路径的数据,另一个栈中存放着最短路径的数据。每找到一条路径,就将当前路径的长度与最短路径的长度作比较,若存放最短路径的栈为空栈,或者当前路径的长度小于最短路径的长度,就用存放着当前路径的栈中的数据替代存放最短路径的栈中的数据。当所有路径都找到以后,此时存放最短路径的栈中的数据即可表示该迷宫的最短路径。

maze.h:
#pragma once
#include <stdio.h> 
#include<stdlib.h>
#include<stddef.h>

#define MAX_ROW 6
#define MAX_COL 6

typedef struct Point{
    int row;
    int col;
}Point;
typedef Point SeqStackType;

typedef struct SeqStack{
    SeqStackType *data;
    size_t size;
    size_t capacity;
}SeqStack;
typedef struct Maze{
    int map[MAX_ROW][MAX_COL];
}Maze;
maze.c:
#include "maze.h"
 
int map[MAX_ROW][MAX_COL]={
    {0,1,0,0,0,0},
    {0,1,1,1,0,0},
    {0,1,0,1,1,1},
    {1,1,1,1,0,0},
    {0,0,1,0,0,0},
    {0,0,1,0,0,0}
};

void MazeInitShortPathWithCycle(Maze* maze){
    if(maze == NULL)
        return;
    size_t i = 0;
    for(;i < MAX_ROW;i++){
        size_t j = 0;
        for(;j < MAX_COL;j++){
            maze->map[i][j] = map[i][j];
        }
    }
    return;
}

void SeqStackDebugPrint(SeqStack* stack,const char* msg){
    printf("%s\n",msg);
    if(stack == NULL)
        return;
    size_t i = 0;
    for(;i < stack->size;i++){
        printf("(%d,%d)\n",stack->data[i].row,stack->data[i].col);
    }
        printf("\n");
        return;
}

void MazePrint(Maze* maze){
    if(maze == NULL)
        return;
    size_t i = 0;
    for(;i < MAX_ROW;i++){
        size_t j = 0;
        for(;j < MAX_COL;j++)
            printf("%2d ",maze->map[i][j]);
        printf("\n");
    }
    return;
}
    
int CanStayWithCycle(Maze* maze,Point cur,Point pre){
    if(maze == 0)
        return 0;
    //判断当前点是否在地图上
    if(cur.row < 0 || cur.row >= MAX_ROW || cur.col < 0 || cur.col >= MAX_COL){
        return 0;
    }
    //判断是否为墙
    int cur_value = maze->map[cur.row][cur.col];
    int pre_value = maze->map[pre.row][pre.col];
    if(cur_value == 0){
        return 0;
    }
    //若当前点是1,可直接落脚
    if(cur_value == 1)
    return 1;
    //若当前点已走过,比较cur_value和pre_value的大小关系
    //若cur_value > pre_value+1,则应该落脚;否则不应该落脚
    if(cur_value > pre_value+1)
        return 1;
    return 0;
}

void MarkWithCycle(Maze* maze,Point cur,Point pre){
    if(pre.row == -1 && pre.col == -1){
        //单独考虑非法点的情况
        maze->map[cur.row][cur.col] = 2;
        return;
    }
    int pre_value = maze->map[pre.row][pre.col];
    maze->map[cur.row][cur.col] = pre_value + 1;
}

int IsExit(Maze* maze,Point cur,Point entry){
    (void)maze;
    //1.判断当前点是不是入口,若为入口,则不是出口
    if(cur.row == entry.row && cur.col == entry.col){
        return 0;
    }
    //2.如果当前点在地图边界上,说明是出口
    if(cur.row == 0 || cur.row == MAX_ROW-1 || cur.col == 0 || cur.col == MAX_COL-1){
        return 1;
    }
    return 0;
}

void SeqStackAssgin(SeqStack* from,SeqStack* to){
    //释放to中的原有内存
    SeqStackDestroy(to);
    //根据from中的元素个数确定内存申请的大小,给to重新申请一个足够的内存
    to->size = from->size;
    to->capacity = from->capacity;
    to->data = (SeqStackType*)malloc(to->capacity * sizeof(SeqStackType));
    //再进行数据拷贝
    size_t i = 0;
    for(;i < from->size;i++){
        to->data[i] = from->data[i];
    }
}

void _GetShortPathWithCycle(Maze* maze,Point cur,Point pre,Point entry,SeqStack* cur_path,SeqStack* short_path){
    printf("cur:(%d,%d)\n",cur.row,cur.col);
    //1.判断当前点能否落脚
    if(!CanStayWithCycle(maze,cur,pre)){
        return;
    }
    //2.若能落脚,给当前位置做一个标记
    //同时将当前点插入到cur_path
    MarkWithCycle(maze,cur,pre);
    SeqStackPush(cur_path,cur);
    //3.若当前点为出口,说明找到了一条出口
    if(IsExit(maze,cur,entry)){
        printf("找到了一条路径\n");
        if(cur_path->size < short_path->size || short_path->size == 0){
            //将当前路径与short_path中的路径对比,若当前路径比short_path短或short_path本身为空栈,则用当前路径替换short_path
            SeqStackAssgin(cur_path,short_path);
            printf("找到了一条相对较短的路径\n");
        }
        //若当前路径没有比short_path短,就尝试找其他路径
        SeqStackPop(cur_path);
        return;
    }
    //4.若当前点不是出口,则按顺时针方向探测四个相邻的点,递归式调用函数自身,递归式更新cur节点
    //(每次递归时,cur都是下一次要走的点,这个点能否落脚,交给递归函数作判断)
    Point up = cur;
    up.row -= 1;
    _GetShortPathWithCycle(maze,up,cur,entry,cur_path,short_path);

    Point right = cur;
    right.col += 1;
    _GetShortPathWithCycle(maze,right,cur,entry,cur_path,short_path);

    Point down = cur;
    down.row += 1;
    _GetShortPathWithCycle(maze,down,cur,entry,cur_path,short_path);

    Point left = cur;
    left.col -= 1;
    _GetShortPathWithCycle(maze,left,cur,entry,cur_path,short_path);
    
    //若四个方向都递归的探测过了,则可进行出栈,同时回溯到上一个点
    SeqStackPop(cur_path);
    return;
}

void GetShortPathWithCycle(Maze* maze,Point entry){
    SeqStack cur_path;
    SeqStack short_path;
    SeqStackInit(&cur_path);
    SeqStackInit(&short_path);
    Point pre = {-1,-1};
    _GetShortPathWithCycle(maze,entry,pre,entry,&cur_path,&short_path);
    SeqStackDebugPrint(&short_path,"最短路径为");
    return;
}
test.c:
#include "maze.h"
#define PRINT_HEADER printf("\n============%s============\n",__FUNCTION__);

void Test(){
    PRINT_HEADER;
    Maze maze;
    SeqStack stack;
    MazeInitShortPathWithCycle(&maze);
    Point entry = {0,1};
    GetShortPathWithCycle(&maze,entry);
    MazePrint(&maze);
}
int main(){
    Test();
    return 0;
}

结果演示:

                    




机器学习-Q-Learning-沙鼠走迷宫

-
  • 1970年01月01日 08:00

【数据结构】求多出口带环迷宫的最短路径(递归版本)

Maze.h #pragma once #include typedef struct Pos{ int _Row; int _COL; }Pos; typedef struct Maz...
  • Qregi
  • Qregi
  • 2018-02-03 22:17:49
  • 66

【数据结构】求多出口迷宫的最短路径

代码如下: Maze.h #pragma once #include typedef struct Pos{ int _Row; int _COL; }Pos; Maze.c ...
  • Qregi
  • Qregi
  • 2018-02-01 18:02:46
  • 99

求迷宫的最短路径:现要求设计一个算法找一条从迷宫入口到出口的最短路径。

  • 2009年11月25日 23:06
  • 6KB
  • 下载

迷宫出口以及迷宫最短路径的求解

整理出来方便大家复习//完成迷宫 #pragma warning (disable:4996) #include #include #include using namespace std; #inc...
  • lizhidefengzi
  • lizhidefengzi
  • 2017-04-20 15:36:57
  • 317

erl_stack_queue-队列求迷宫最短路径

求迷宫的最短路径: 现要求设计一个算法找一条从迷宫入口到出口的最短路径。本算法要求找一条迷宫的最短路径,算法的基本思想为:从迷宫入口点(2,2)出发,向四周搜索,记下所有一步能到达的坐标点;然后依次...
  • u011518176
  • u011518176
  • 2015-09-14 11:31:11
  • 289

[数据结构]求解迷宫最短路径问题

一、问题概述        之前,我们了解了如何实现迷宫问题(对于迷宫只有一个出口可以通的情况),事实上我们的迷宫有多个出口,对于每条路径来说,有长有短,所以在这里,我们讨论一下迷宫的最短路径,...
  • xxpresent
  • xxpresent
  • 2016-12-08 16:23:59
  • 1693

一个求迷宫入口到出口最近距离的程序

本文给出一个c/c++语言版的求迷宫入口到出口的最短路径的程序。程序的大部分使用标准c语言编写,包括 输入和输出。唯一用到C++库的地方是使用STL了中的deque。迷宫的宽和高,迷宫矩阵,迷宫的入...
  • liangbch
  • liangbch
  • 2012-05-23 16:28:21
  • 3526

迷宫最短路径问题(ShortestPath)的求解——利用链式队列

迷宫最短路径问题(ShortestPath)的求解——利用链式队列 注:借助于栈求解迷宫问题时,并不能保证找到一条从迷宫入口到迷宫出口的最短路径。而借助于队列,可以找到从迷宫入口到迷宫出口的最短路径...
  • cainv89
  • cainv89
  • 2016-06-05 12:09:15
  • 2629

【数据结构】求多出口带环迷宫的最短路径

代码如下: Maze.h #pragma once #include typedef struct Pos{ int _Row; int _COL; }Pos; typedef st...
  • Qregi
  • Qregi
  • 2018-02-01 21:03:40
  • 31
收藏助手
不良信息举报
您举报文章:求带环的多出口迷宫的最短路径
举报原因:
原因补充:

(最多只允许输入30个字)