简单迷宫的问题求解

最新推荐文章于 2018-06-02 16:47:08 发布
最新推荐文章于 2018-06-02 16:47:08 发布
阅读量313 收藏 1
点赞数
分类专栏： 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Cecilia3333/article/details/79973243
版权
  • 回溯法：对一个包括有很多个结点，每个结点有若干个搜索分支的问题，把原问题分解为若干个子问题求解的算法；当搜索到某个结点发现无法再继续搜索下去时，就让搜索过程回溯(回退)到该节点的前一个结点，继续搜索该节点外的其他尚未搜索的分支；如果发现该结点无法再搜索下去，就让搜索过程回溯到这个结点的前一结点继续这样的搜索过程；这样的搜索过程一直进行到搜索到问题的解或者搜索完了全部可搜索分支没有解存在为止。
  • 首先我们先来定义一张简单的迷宫地图：

                      

图中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;
}

结果演示：

        


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




Cecilia3333
关注
专栏目录
c++ 迷宫思路_迷宫问题求解——C++
weixin_42517137的博客
01-17 1523
迷宫问题思路根据昨天的博客，有如下几种解决方案克鲁斯卡尔 ，为避免死循环，需要设定优化路径的次数。Prim，为避免死循环，需要设定优化路径的次数，暂定200次。BFS ， 实现简单，无死循环。DFS , 实现简单，无死循环，复杂度较低。动态规划，实时根据权重调整方向，目前看来最合适的解决方案。需要以数据证明。综上，本次优先选择BFS，首先不存在死循环的风险，其次算法复杂度较低，容易理解且实现。...
迷宫问题的递归回溯算法c语言,c语言迷宫问题求解——递归、栈回溯
weixin_36345268的博客
05-23 1873
第一次写，见谅以下是求迷宫的实现为什么下面会出现标签啊，有什么简便的方法去掉吗？求告知最后是关于求所有通路，个人愚笨只想到改变搜索方向顺序这种笨方法，总共有16种不同顺序，有兴趣的小伙伴可以试一下/*第一部分使用递归求解为了数据的简单化，不对路口进行数据结构化，将用一个简单的int类型数组来表示迷宫因为每一个路口的四个方向相对于当前路口的位移都是一样的，这样可以用一个int类型二位数据表示四个方向...
迷宫问题求解
12-20
完美的迷宫问题求解代码，适合学习数据结构的人参考。
简单迷宫求解
Xucc_x的博客
04-23 1737
问题引出 迷宫求解是栈的典型例子，今天我们来讨论的是简单的迷宫求解问题，即 迷宫只有一个出口，迷宫内的路径不带环，不相交 例如： 回溯法 在正式求解之前，我们要知道一个很重要的概念 回溯法：对一个包括有很多个结点，每个结点有若干个搜索分支的问题，把原问题分解为若干个子问题求解的算法；当搜索到某个结点发现无法再继续搜索下去时，就让搜索过程回溯(回退)到该节点的前一个结点，继...
简单迷宫问题的求解-BFS
lrf2454224026的博客
06-02 563
描述定义一个二维数组：int maze[5][5] = {                                    0, 1, 0, 0, 0,                                    0, 1, 0, 1, 0,                                    0, 0, 0, 0, 0,                     ...
迷宫问题—简单深度搜索
qq_38807738的博客
05-24 535
迷宫问题 时间限制(普通/Java):1000MS/3000MS 运行内存限制:65536KByte 总提交:196 测试通过:137 描述 求迷宫中从入口到出口的所有路径是一个经典的程序设计问题。由于计算机解迷宫时，通常用的是“穷举求解”的方法，即从入口出发，顺着某一个方向向前探索，若能走通，则继续往前走；否则沿着原路退回，换一个方向再继续探索，直至所有可能的通路都探索到为止
穷举法迷宫求解简单实现（C）
mmdev
08-13 209
穷举法迷宫求解简单实现，主要是锻炼队列及链表的使用，直接上代码： // // main.c // migong // // Created by mac on 12-8-13. // Copyright 2012年 __MyCompanyName__. All rights reserved. // #include &lt;stdio.h&gt; #include ...
老鼠走迷宫（迷宫问题求解）
04-25
简单的老鼠走迷宫问题的求解！望提供一点分享 ！
迷宫求解课程设计报告完整版
05-20
【迷宫求解课程设计】是计算机科学领域中常见的一个问题，通常用于教授基本的图论概念和搜索算法。在这个课程设计中，目标是设计一个C++程序，解决一个8x8的迷宫问题，从入口(1,1)找到所有可能路径及最短路径至出口...
迷宫求解问题
07-05
《迷宫求解问题——C语言实现解析》 在计算机科学领域，迷宫求解问题是一个经典的图论问题，它涉及到路径寻找、搜索算法等多种概念。在这个问题中，我们通常将迷宫视为一个二维矩阵，其中每个节点代表一个位置，而...
迷宫问题的求解（八个方向的）
10-28
这是一个迷宫问题的求解，有八个方向。下了就知道
c语言迷宫问题求解
11-28
两百行左右的代码，可以根据自己的需求进行修改，给对迷宫有疑惑的朋友一个参考。
迷宫问题的解决
03-16
问题分析：迷宫中设置了很多墙壁，对前进方向形成了多处障碍。迷宫只有唯一的出口，如果从迷宫的入口到出口，途中不出现行进方向错误，则得到一条最佳路线。<br>总体设计：利用递归方法获得迷宫从入口到出口的最佳路线。<br>用一个二维数组Maze[m+2][p+1]来表示迷宫，当数组元素Maze[i][j]=1时，表示该位置是墙壁，不能通行；当Maze[i][j]=0时，表示该位置是通路（其中0<i<m+1,0<j<p.），数组的第0行、第m+1行，以及第0列和第p+1列是迷宫的墙。在求解迷宫问题的过程中，当沿某一条路径一步步走向出口但发现进入死胡同时，就回溯一步或多步，寻求其它可走路经。在迷宫中任意时刻的位置可用数组行下标 i和列下标j表示。从Maze[i][j]出发，可能的前进方向有4个，分别代表4个前进位置。如果某一方向是0值，表示该方向有路可通，否则表示该方向已堵死，为了有效地选择下一位置，可将从位置出发可能的前进方向预先定义，该定义给出个方向的偏移量。<br>
最简单的迷宫求解
superficial
03-16 1440
使用栈对迷宫进行求解，并且使用了探测法和回溯法。
VC环境下迷宫问题求解与编程实践
实验5：求解迷宫问题 本次实验的主要目标是通过编程实践来理解和掌握求解迷宫问题的方法，以及应用蛮力法解决这类问题。实验环境包括使用Microsoft Visual C++ 6.0或Visual Studio 2008开发环境。实验内容主要包括...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值