原

简单迷宫的问题求解

2018年04月17日 14:22:26 阅读数：44
个人分类： 数据结构
  • 回溯法：对一个包括有很多个结点，每个结点有若干个搜索分支的问题，把原问题分解为若干个子问题求解的算法；当搜索到某个结点发现无法再继续搜索下去时，就让搜索过程回溯(回退)到该节点的前一个结点，继续搜索该节点外的其他尚未搜索的分支；如果发现该结点无法再搜索下去，就让搜索过程回溯到这个结点的前一结点继续这样的搜索过程；这样的搜索过程一直进行到搜索到问题的解或者搜索完了全部可搜索分支没有解存在为止。
  • 首先我们先来定义一张简单的迷宫地图：

                      

图中0表示墙，即无法落脚；1表示可以落脚；之后我们会用2来标记走过的路。

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

要解决这个问题，我们还是要基于栈的基本操作，依赖栈结构来辅助完成回溯法。而这里的栈可以是内存地址空间中的栈，也可以我们自己手动创建一个栈来实现。这两种方法我们在下面的代码中都会有所实现。

第一种方法：基于地址空间中的栈辅助完成回溯（递归式）

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

#define MAX_ROW 6
#define MAX_COL 6
   
typedef struct Maze{
    int map[MAX_ROW][MAX_COL];
}Maze;

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

typedef Point SeqStackType;

typedef struct SeqStack{
    SeqStackType *data;
    size_t size;
    size_t capacity;
}SeqStack;

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,0},
    {0,1,1,0,0,0},
    {0,0,1,0,0,0},
    {0,0,1,0,0,0}
};

void MazeInit(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 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 CanStay(Maze* maze,Point pt){
    if(pt.row < 0 || pt.row >= MAX_ROW || pt.col < 0 || pt.col >= MAX_COL){
        return 0;
    }
    int value = maze->map[pt.row][pt.col];
    if(value == 1){
        return 1;
    }
    return 0;
}

void Mark(Maze* maze,Point cur){
    maze->map[cur.row][cur.col] = 2;
}

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 _GetPath(Maze* maze,Point cur,Point entry){
    printf("cur:(%d,%d)\n",cur.row,cur.col);
    //1.判断当前点能否落脚
    if(!CanStay(maze,cur)){
        return;
    }
    //2.若能落脚，给当前位置做一个标记
    Mark(maze,cur);
    //3.若当前点为出口，说明找到了一条出口，探测结束
    if(IsExit(maze,cur,entry)){
        printf("找到了一条出路\n");
        return;
    }
    //4.若当前点不是出口，则按顺时针方向探测四个相邻的点，递归式调用函数自身，递归式更新cur节点
    //（每次递归时，cur都是下一次要走的点，这个点能否落脚，交给递归函数作判断）
    Point up = cur;
    up.row -= 1;
    _GetPath(maze,up,entry);

    Point right = cur;
    right.col += 1;
    _GetPath(maze,right,entry);

    Point down = cur;
    down.row += 1;
    _GetPath(maze,down,entry);

    Point left = cur;
    left.col -= 1;
    _GetPath(maze,left,entry);
}

void GetPath(Maze* maze,Point entry){
    if(maze == NULL){
        return;
    }
    _GetPath(maze,entry,entry);
}

test.c：
#include "maze.h"
#define PRINT_HEADER printf("\n============%s============\n",__FUNCTION__)

void Test1(){
    PRINT_HEADER;
    Maze maze;
    MazeInit(&maze);
    Point entry = {0,1};
    GetPath(&maze,entry);
    MazePrint(&maze);
}

int main(){
    Test1();
    return 0;
}

结果演示：

               

第二种方法：自己手动创建一个栈，然后基于自己创建的栈实现回溯（非递归式）

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

#define MAX_ROW 6
#define MAX_COL 6
   
typedef struct Maze{
    int map[MAX_ROW][MAX_COL];
}Maze;

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

typedef Point SeqStackType;

typedef struct SeqStack{
    SeqStackType *data;
    size_t size;
    size_t capacity;
}SeqStack;
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,0},
    {0,1,1,0,0,0},
    {0,0,1,0,0,0},
    {0,0,1,0,0,0}
};

void MazeInit(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 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 CanStay(Maze* maze,Point pt){//判断当前点是否能落脚
    if(pt.row < 0 || pt.row >= MAX_ROW || pt.col < 0 || pt.col >= MAX_COL){
        return 0;
    }
    int value = maze->map[pt.row][pt.col];
    if(value == 1){
        return 1;
    }
    return 0;
}

void Mark(Maze* maze,Point cur){//标记走过的路径
    maze->map[cur.row][cur.col] = 2;
}

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 GetPathByLoop(Maze* maze,Point entry){
    if(maze == NULL)
        return;
    //1.创建一个栈，并且初始化，这个栈保存着走过的路径
    SeqStack stack;
    SeqStackInit(&stack);
    //2.判定入口点能否落脚，若不能，说明参数非法,则直接返回
    if(!CanStay(maze,entry)){
        return;
    }    
    //3.标记入口点，并将入口点入栈
    Mark(maze,entry);
    SeqStackPush(&stack,entry);
    //4.进入循环，获取到当前栈的栈顶元素
    Point cur;
    while(GetTop(&stack,&cur)){
    //5.判定这个点是否为出口，若为出口，直接函数返回
        if(IsExit(maze,cur,entry)){
            printf("找到了一条路径\n");
            return;
        }
    //6.按照顺时针方向取相邻点，判断相邻点能否落脚，若能落脚，就标记并入栈，立即进入下一轮循环
    Point up = cur;
    up.row -= 1;
    if(CanStay(maze,up)){
        Mark(maze,up);
        SeqStackPush(&stack,up);
        continue;
    }

    Point right = cur;
    right.col += 1;
    if(CanStay(maze,right)){
        Mark(maze,right);
        SeqStackPush(&stack,right);
        continue;
    }

    Point down = cur;
    down.row += 1;
    if(CanStay(maze,down)){
        Mark(maze,down);
        SeqStackPush(&stack,down);
        continue;
    }

    Point left = cur;
    left.col -= 1;
    if(CanStay(maze,left)){
        Mark(maze,left);
        SeqStackPush(&stack,left);
        continue;
    }
    //7.若四个相邻点均不能落脚，就出栈当前点，相当于进行回溯
    SeqStackPop(&stack);
    }
    return;
}
test.c：
#include "maze.h"
#define PRINT_HEADER printf("\n============%s============\n",__FUNCTION__)

void Test2(){
    PRINT_HEADER;
    Maze maze;
    MazeInit(&maze);
    Point entry = {0,1};
    GetPathByLoop(&maze,entry);
    MazePrint(&maze);
}
int main(){
    Test2();
    return 0;
}

结果演示：

        


至此，我们求解简单迷宫是否存在路径的问题就解决了。




阅读更多
想对作者说点什么？ 我来说一句

小型迷宫实现---迷宫算法（递归回溯法）

fern_girl fern_girl

04-24 1370

首先我们来了解迷宫包含的算法—-回溯法 回溯法的基本思想： 对一个包括有很多个结点，每个结点有若干个搜索分支的问题，把原问题分解为若干个子问题求解的算法；当搜索到某个结点发现无法再继续搜索下去时，...

数据结构：各类迷宫问题详解(c语言版)

Ferlan Ferlan

04-01 628

第一类 简单迷宫（不含多条出路，不带环）（0代表墙，1代表通路） 思路分析： 1.以入口为起点，寻找出口（除了起点以外的边缘上的点） 2.判定当前点坐标是否可以走。（坐标合法且不为0...

C语言简单迷宫问题，深搜，通俗易懂。

mutao1127877836 mutao1127877836

12-01 2280

简单迷宫深搜-C表示新人，大神勿喷，欢迎给出建议。在网上搜了一些深搜，发现看不懂，就把自己写的贴出来，还是比较好理解。自己出的小迷宫题：给出迷宫，求出共多少方法，和最小最大路程。0表示可走，1表示墙，...

迷宫最短路求解

sb_Ihateyou sb_Ihateyou

04-15 2666

任务： 可以输入一个任意大小的迷宫数据，用非递归的方法求出一条走出迷宫的路径，并将路径输出。 要求：写明存储结构、迷宫求解的算法（可以使用程序流程图）、源程序、测试数据和结果、算法的时间复杂度、另...

【数据结构】迷宫问题求解（链栈，DFS）

Chen_yuazzy Chen_yuazzy

06-21 1362

1.问题描述： 以一个m*n的长方阵表示迷宫，0和1分别表示迷宫中的通路和障碍。设计一个程序，对任意设定的迷宫，求出一条从入口到出口的通路，或得出没有通路的结论。 2.基本要求： （1）首先实现一个以...

简单迷宫问题的求解

qq_33951180 qq_33951180

09-11 2432

回溯法解决迷宫问题

关于迷宫求解及其最优解的问题

lvyibin890 lvyibin890

10-08 433

关于迷宫问题，求解它的最优解的问题可以使用栈的概念来实现。简单的迷宫如下图 其中0表示可以走，1表示不能走，显然可见，若是以（3,1）点为入口，则有两个出口分别是（10，3）和（10, 8）。而...

运用栈求解迷宫问题C/C++

g15827636417 g15827636417

10-07 8952

用栈解决基本的迷宫问题C/C++ 1、问题描述：设置迷宫为m*n的二维数组，起点坐标为（1，1），中点坐标为（m，n），0为通路，1为死路，为防止数组越界将四周设置边界1，即数组变为（m+2）*（n...

迷宫问题—简单深度搜索

qq_38807738 qq_38807738

05-24 176

迷宫问题 时间限制(普通/Java):1000MS/3000MS 运行内存限制:65536KByte 总提交:196 测试通过:137 描述 求迷宫中从入口到出口的所有路径是一个经...

迷宫问题求解

sandmm112 sandmm112

04-21 428

问题一：在迷宫中找到出口（只需找到一个即可）        给定一张迷宫地图和一个迷宫入口，然后进入迷宫探索找到一个出口。问题分析：1. 首先要有一张迷宫地图，地图由两部分组成：    （1）一是迷宫...

相关热词
for简单 as简单 md5简单 ctcp简单 julia简单

没有更多推荐了，返回首页

注册