回溯法实现迷宫

最新推荐文章于 2019-09-28 21:13:51 发布
最新推荐文章于 2019-09-28 21:13:51 发布
阅读量1.7k 收藏 15
点赞数 2
文章标签： 迷宫 回溯法 递归 带环 多通路
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Lsxlsxls/article/details/82081909
版权

回溯法的整体思想是：
当搜索到某个结点发现无法再继续搜索下去时，就让搜索过程回溯(回退)到该节点的前一个结点，继续搜索该节点外的其他尚未搜索的分支；如果发现该结点 无法再搜索下去，就让搜索过程回溯到这个结点的前一结点，继续这样的搜索过程；这样的搜索过程一直进行到搜索到问题的解或者搜索完了全部可搜索分支没有解存在为止。

我们这里写的迷宫就是利用以上思想，按照左上右下的方向进行搜索，当四面都没有通路的时候，就回溯到上一个结点，搜索其他尚未搜索的方向，如果还是没有通路，就继续回溯。直到回到起点或者找到通路的时候方可停止。这里我们是通过栈来实现回溯的，利用了栈的特点，先进后出，当我们发现一个位置四面八方都没有通路的时候，出栈，回到上一个位置。

接下来让我们来实现迷宫：

一、创建一个迷宫

这里我们实现一个有多通路且内部带环的迷宫。（为了方便呢，我用的大都是全局变量）

用一个二维数组来创建一个迷宫，这里我用0表示墙，1表示通路，2表示走过的路，但是在打印迷宫的时候可以选用自己喜欢的字符。


在打印的时候我用"█ "表示墙，" "表示通路，"☺ "表示走过的路。
以下是在走迷宫的过程中打印的一个迷宫：


代码如下：

//打印迷宫
void PrintMaze(){
    for(int i=0; i<ROWS; i++){
        for(int j=0; j<COLS; j++){
            if(Maze[i][j] == 0){
                printf("█ ");
            }
            if(Maze[i][j] == 1){
                printf("  ");
            }
            if(Maze[i][j] == 2){
                printf("☺ ");
            }
        }
        printf("\n");
    }
    printf("\n\n");
}

顺便我们可以把迷宫的入口和出口也设定一下：
首先需要一个结构体来保存走迷宫的位置，也就是横纵坐标： 


typedef struct Position{
    int x;
    int y;
} Position;

我们把迷宫入口设置为：

//起始位置
Position start = {5, 2};

出口设成多个，最后一列都为出口：

//判断是否走出迷宫
int IsExit(Position pos){
    if(pos.y == COLS-1){
        return 1;
    }
    else{
        return 0;
    }
}

二、用栈来保存走过的位置

栈的特点是先进后出，十分适合我们的迷宫的回溯，当找到一条通路的时候，进栈，直到四面八方都没有通路的时候，出栈，回到上一个位置并把这个位置还原回去，继续搜索没有搜索过的方向。直到找到出口或者回到原点。

这里我们自己写一个栈，实现栈的声明、初始化、销毁、进栈、出栈、查看栈顶元素、栈中元素的个数、判断栈是否空/满。因为后面走迷宫的时候想要找到一个最短路径，所以我们需要拿一个栈来保存最短路径，这里需要用到栈的拷贝，当最小栈为空或者现在的栈中元素小与最小栈的时候，就把现在的栈拷贝到最小栈，所以一并在这里实现。最后写一个打印栈，可以看看是怎么走出迷宫的。

typedef Position DataType;
#define MAX_SIZE (100)

//栈的声明
typedef struct Stack{
    DataType array[MAX_SIZE];
    int top;
} Stack;
//初始化
void StackInit(Stack *p){
    assert(p);
    p->top = 0;
}
//销毁
void StackDestroy(Stack *p){
    p->top = 0;
}
//进栈
void StackPush(Stack *p, DataType data){
    assert(p->top < MAX_SIZE);
    p->array[p->top++] = data;
}
//出栈
void StackPop(Stack *p){
    assert(p->top > 0);
    p->top--;
}
//查看栈顶元素
DataType StackTop(Stack *p){
    return p->array[p->top-1];
}
//返回栈中元素的个数
int StackSize(Stack *p){
    return p->top;
}
//判断栈是否为空
int StackIsEmpty(Stack *p){
    return p->top <= 0;
}
//判断栈是否满
int StackIsFull(Stack *p){
    return p->top >= MAX_SIZE;
}
//拷贝栈
void CopyStack(Stack *dest, Stack *src){
    for(int i=0; i<src->top; i++){
        dest->array[i] = src->array[i];
    }
    dest->top = src->top;
}
//打印栈
void PrintStack(Stack *p){
    for (int i = 0; i < p->top; i++) {
        printf("x = %d, y = %d\n", p->array[i].x, p->array[i].y);
    }
}

三、走迷宫

这里我们分装出一个函数判断走到某个位置时是否能通过：

//判断是否能通过
int CanPass(Position pos){
    if(Maze[pos.x][pos.y] == 1){
        return 1;
    }
    return 0;
}

走迷宫的主体函数：
利用递归+栈实现回溯，代码很好懂

Stack stack;
Stack min;

void GoMazes(Position pos){
    Position now = pos;//记录当前位置
    Position next;//记录下一步的位置

    StackPush(&stack, now);//当前位置进栈
    Maze[now.x][now.y] = 2;//将当前位置改为走过
    PrintMaze();//打印迷宫

    if(IsExit(now)){
        Maze[now.x][now.y] = 1;

        if(StackIsEmpty(&min) || StackSize(&stack) < StackSize(&min)){
            CopyStack(&min, &stack);
        }
        printf("成功走出迷宫!\n走了%d步\n",StackSize(&stack));
        PrintStack(&stack);
        StackPop(&stack);
        return;
    }

    //我是按照 左 上 右 下 的顺序
    next.x = now.x;
    next.y = now.y-1;
    if(CanPass(next)){
        PrintMaze();

        GoMazes(next); 
    }

    next.x = now.x-1;
    next.y = now.y;
    if(CanPass(next)){
        PrintMaze();

        GoMazes(next);
    }

    next.x = now.x;
    next.y = now.y+1;
    if(CanPass(next)){
        PrintMaze();

        GoMazes(next);
    }

    next.x = now.x+1;
    next.y = now.y;
    if(CanPass(next)){
        PrintMaze();

        GoMazes(next);
    }

    //走到这里的时候四面八方都没有路，只能退回到上一个位置，并将其还原为通路
    StackPop(&stack);
    Maze[now.x][now.y] = 1;
    return;
}

最后献上整体代码：
也就是把上面的板块拼凑在一起

#include <stdio.h>
#include <assert.h>

#define ROWS (6)
#define COLS (6)

typedef struct Position{
    int x;
    int y;
} Position;
int Maze[ROWS][COLS] = {
    { 0, 0, 0, 0, 0, 0 },
    { 0, 0, 1, 1, 1, 1 },
    { 0, 0, 1, 0, 1, 0 },
    { 0, 0, 1, 0, 1, 0 },
    { 0, 0, 1, 1, 1, 1 },
    { 0, 0, 1, 0, 0, 0 }
};

typedef Position DataType;
#define MAX_SIZE (100)

typedef struct Stack{
    DataType array[MAX_SIZE];
    int top;
} Stack;
void StackInit(Stack *p){
    assert(p);
    p->top = 0;
}
void StackDestroy(Stack *p){
    p->top = 0;
}
void StackPush(Stack *p, DataType data){
    assert(p->top < MAX_SIZE);
    p->array[p->top++] = data;
}
void StackPop(Stack *p){
    assert(p->top > 0);
    p->top--;
}
DataType StackTop(Stack *p){
    return p->array[p->top-1];
}
int StackSize(Stack *p){
    return p->top;
}
int StackIsEmpty(Stack *p){
    return p->top <= 0;
}
int StackIsFull(Stack *p){
    return p->top >= MAX_SIZE;
}
void CopyStack(Stack *dest, Stack *src){
    for(int i=0; i<src->top; i++){
        dest->array[i] = src->array[i];
    }
    dest->top = src->top;
}
//打印栈
void PrintStack(Stack *p){
    for (int i = 0; i < p->top; i++) {
        printf("x = %d, y = %d\n", p->array[i].x, p->array[i].y);
    }
}
//打印迷宫
void PrintMaze(){
    for(int i=0; i<ROWS; i++){
        for(int j=0; j<COLS; j++){
            if(Maze[i][j] == 0){
                printf("█ ");
            }
            if(Maze[i][j] == 1){
                printf("  ");
            }
            if(Maze[i][j] == 2){
                printf("☺ ");
            }
        }
        printf("\n");
    }
    printf("\n\n");
}
//起始位置
Position start = {5, 2};
//判断是否走出迷宫
int IsExit(Position pos){
    if(pos.y == COLS-1){
        return 1;
    }
    else{
        return 0;
    }
}
//判断是否能通过
int CanPass(Position pos){
    if(Maze[pos.x][pos.y] == 1){
        return 1;
    }
    return 0;
}
Stack stack;
Stack min;

void GoMazes(Position pos){
    Position now = pos;//记录当前位置
    Position next;//记录下一步的位置

    StackPush(&stack, now);
    Maze[now.x][now.y] = 2;
    PrintMaze();
    if(IsExit(now)){
        Maze[now.x][now.y] = 1;

        if(StackIsEmpty(&min) || StackSize(&stack) < StackSize(&min)){
            CopyStack(&min, &stack);
        }
        printf("成功走出迷宫!\n走了%d步\n",StackSize(&stack));
        PrintStack(&stack);
        StackPop(&stack);
        return;
    }

    //按照 左 上 右 下 的顺序
    next.x = now.x;
    next.y = now.y-1;
    if(CanPass(next)){
        PrintMaze();

        GoMazes(next);

    }

    next.x = now.x-1;
    next.y = now.y;
    if(CanPass(next)){
        PrintMaze();

        GoMazes(next);
    }

    next.x = now.x;
    next.y = now.y+1;
    if(CanPass(next)){
        PrintMaze();

        GoMazes(next);
    }

    next.x = now.x+1;
    next.y = now.y;
    if(CanPass(next)){
        PrintMaze();

        GoMazes(next);
    }
    StackPop(&stack);
    Maze[now.x][now.y] = 1;
    return;
}
int main(int argc, const char * argv[]) {

    PrintMaze();
    StackInit(&stack);
    StackInit(&min);

    GoMazes(start);

    printf("最短路径为：%d\n",StackSize(&min));
    PrintStack(&min);
    return 0;

}

我为了检查过程，用了很多打印函数，这里就看最后走完迷宫的过程：


这里写图片描述

END

Lsxlsxls
关注
用回溯法走迷宫，较简易代码
吃苦胆的野狼
03-03 1631
这应该算是第一份回溯写迷宫的代码，寒假写的时候出了点小毛病一直显示找不到路径，连续几天都没有思绪，后面来学校在学霸的帮助下发现了原因 在main函数里定义了offset数组，在外面又同时定义了一个数组，结果在seekpath函数里面调用的是外面定义的那个，外面定义的没赋值。。结果就一直。。#include #include using namespace std ; const int m =
回溯法求解迷宫问题
最新发布
zuojiejie的博客
11-20 1246
也就是说在起始位置先对左边的下一个位置能否通行进行判断，如果可以，机器人向前走一步并将小机器人当前的信息存放在栈中，再对下一个位置的前进方向进行试探。所以从[5,10]位置开始向后回溯，[5,10]位置四个方向均试探完毕都不通，对此位置记上不通的标记（用数字2表示）然后退回[4,10]位置，将[4,10]位置时小机器人存放在栈中的信息提取出来，继续下一个方向的试探。从入口[1,1]位置开始，先对1号方向进行试探。1号方向为墙，则对2号方向进行试探，2号方向也为墙，再对3号方向进行试探，3号方向可通行。
回溯法求解走迷宫问题（八个方向）
06-11
迷宫问题。迷宫问题的求解是实验心理学中的一个经典问题，心理学家把一只老鼠从一个无顶盖的大盒子的入口处赶进迷宫，迷宫中设置很多隔壁，对前进方向形成了多处障碍，心理学家在迷宫的唯一出口放了一块奶酪，吸引老鼠在迷宫中寻找出路来找到出口。设计回溯算法实现如图所示的迷宫的求解。
C++回溯法走迷宫
weixin_34378922的博客
12-18 239
1 #include <iostream> 2 #include <iomanip> 3 #include <cstdlib> 4 using namespace std; 5 6 #define MaxSize 100 7 int maze[10][10] = //定义一个迷宫，...
迷宫回溯
用心改变世界
09-28 536
迷宫回溯什么是递归递归要遵守的规则迷宫寻路问题解决 什么是递归 递归简单的说就是自己调用自己。 //求10的阶乘 public static int recursive(int n){ if(n==1){ return 1; }else { return n * recursive(n-1); ...
回溯法实现
Make Progress Everyday!
03-20 1686
一、回溯法：回溯法是一个既带有系统性又带有跳跃性的的搜索算法。它在包含问题的所有解的解空间树中，按照深度优先的策略，从根结点出发搜索解空间树。算法搜索至解空间树的任一结点时，总是先判断该结点是否肯定不包含问题的解。如果肯定不包含，则跳过对以该结点为根的子树的系统搜索，逐层向其祖先结点回溯。否则，进入该子树，继续按深度优先的策略进行搜索。回溯法在用来求问题的所有解时，要回溯到根，且根结点的所有子树都
回溯法解迷宫问题
09-22
在本案例中，"回溯法解迷宫问题"是利用这种算法解决经典的迷宫寻路问题。 迷宫问题通常表现为一个二维矩阵，其中1表示墙壁，0表示可以通过的路径。目标是从起点（通常是迷宫的一个角落）到达终点，同时避开障碍物。...
PHP实现基于回溯法求解迷宫问题的方法详解
10-19
PHP的数组操作技巧在实现迷宫问题的回溯算法中非常关键，包括数组的合并、添加元素等。通过这些操作可以方便地记录和更新路径信息。 在解决实际问题时，除了回溯法，PHP程序设计者还应熟悉其他算法和数据结构，比如...
回溯法解迷宫问题.
01-28
通过本文的学习，我们不仅了解了如何使用回溯法解决迷宫问题的基本原理，还深入分析了具体的实现细节。这种方法不仅可以帮助我们在计算机编程领域解决问题，同时也能够提升我们解决问题的思维能力。
迷宫问题（回溯法）
weixin_42325110的博客
08-06 1414
问题： 给定一个入口，一个出口，找出从入口到出口的所有路径。 图例： 其中： // 代表墙 入口：（1,1） 出口：（7,8） 分析： 1. 中间格子有4种走法：东、南、西、北 2. 但对于两边的格子，只有两种走法，为了普遍性，给其上下左右各加一行格子，作为墙。如图：红色区域。 3. 走过的路需要标记，要不然会出现死循环，前一个格子走到下一个格子，而下一个格子其余三边都是墙...
迷宫回溯算法
08-02
迷宫算法 按钮代表格子 回溯算法
回溯算法求解迷宫问题
12-26
迷宫的存储结构以二维数组来存储，用0，1表示通或不通。表面上似乎迷宫问题是一种特殊问题的解决方法，其实迷宫问题是一种特殊形式图的问题，因此，迷宫总量可转化为图的问题来解决。设计一个计算机程序对任意设定的迷宫,求出一条从入口到出口的通路,或得出没有通路的结论.本文采用回溯法求解迷宫路径，算法用到数据结构中的栈。
迷宫——回溯，递归
03-21
NULL 博文链接：https://13485712774-139-com.iteye.com/blog/944874
迷宫（回溯，递归）
冷月
08-23 670
回溯法 递归法
实现回溯法求走迷宫
justin_bkdrong的专栏
06-15 2126
题目是这样： 有一个入口比如坐标（0，0） 迷宫是 8x8 的矩阵，出口是 (7,7)，0 为通过，1 为不通 函数为： find_path_in_maze 思路如下： 每个节点（路径坐标点）都有两个元素 坐标和阻塞的坐标数组 使用栈的思想，将入口入栈，在栈顶循环操作，查找下一个可以走的路径 next_path（四个方向坐标查找，去掉阻塞点，已经走过的节点也为阻塞点），如果不通则将栈
回溯法题型1 迷宫找路
Sky丨Star的博客
12-16 494
Tom is addicted to a game recently, but he often comes across all kinds of mazes in playing the game, among which there are both passable mazes and unpassable mazes.  Tom is too lazy. He wants you to...
回溯走迷宫
TaoXiaoT的博客
11-06 280
#include #include   using namespace std; int tap[100] = {0}, n; int map[10][10] = { { 1,1,1,1,1,1,1,1,1,1 }, { 1,0,0,0,0,0,0,0,0,1 }, { 1,0,1,1,1,0,1,1,0,1 }, { 1,0,0,0,1,0,1,1,0,1 }, { 1,0,1
走迷宫 回溯法
yellowOri的专栏
06-14 845
<br />#include <iostream><br />#include <windows.h><br />using namespace std;<br />#define FINISH_X 4<br />#define FINISH_Y 11<br />#define M 1000<br />char a[12][12] = {{'#','#','#','#','#','#','#','#','#','#','#','#'},<br />                  {'#',' ',' '
回溯法解决迷宫路径：从入口到出口的算法实现
在这个特定的迷宫求解过程中，采用了回溯法结合数据结构中的栈来实现。 回溯法的基本思想是深度优先搜索（DFS），它沿着一条路径尽可能深地探索，直到遇到无法继续前进的情况（即“回溯点”）。当遇到死胡同或者...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值