迷宫（回溯，递归）

最新推荐文章于 2022-04-09 23:56:02 发布
最新推荐文章于 2022-04-09 23:56:02 发布
阅读量662 收藏 2
点赞数 1
分类专栏： 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_35452533/article/details/77511631
版权

回溯法

基本思想：对一个包括有很多个结点，每个结点有若干个搜索分支的问题，把原问题分解为多若干个子问题求解的算法；当搜索到某个结点发现无法再继续搜索下去时，就让搜索过程回溯(回退)到该节点的前一个结点，继续搜索该节点外的其他尚未搜索的分支；如果发现该结点无法再搜索下去，就让搜索过程回溯到这个结点的前一结点继续这样的搜索过程；这样的搜索过程一致进行到搜索到问题的解或者搜索完了全部可搜索分子没有解存在为止。
#include <iostream>
#include <stack>
using namespace std;

#define MAX_ROW 10
#define MAX_COL 10

struct Seat
{
    int x;
    int y;
};

class Maze
{
public:
    Maze(int array[MAX_ROW][MAX_COL])
    {
        for(int i = 0; i < MAX_ROW; i++)
        {
            for(int j = 0; j <MAX_COL; j++)
            {
                map[i][j] = array[i][j];
            }
        }
    }

    bool IsPass(const Seat& s)
    {
        if((s.x >= 0 && s.x < MAX_ROW) &&
            (s.y >= 0 && s.y < MAX_COL))
            return 1 == map[s.x][s.y];
        return 0;
    }

    void PassMaze(stack<Seat>& s, Seat& next)
    {
        s.push(next);
        map[next.x][next.y] = 2;

        while(!s.empty())
        {
            if(s.top().x == 0 || s.top().x == MAX_ROW ||
               s.top().y == 0 || s.top().y == MAX_ROW)
            {
                cout<<"找到出口"<<endl;
                return;
            }

            next = s.top();
            Seat up = {next.x-1, next.y};
            Seat left = {next.x, next.y-1};
            Seat right = {next.x, next.y+1};
            Seat down = {next.x+1, next.y};

            if(IsPass(up))
            {
                s.push(up);
                map[up.x][up.y] = 2;
                continue;
            }

            if(IsPass(left))
            {
                s.push(left);
                map[left.x][left.y] = 2;
                continue;
            }

            if(IsPass(right))
            {
                s.push(right);
                map[right.x][right.y] = 2;
                continue;
            }

            if(IsPass(down))
            {
                s.push(down);
                map[down.x][down.y] = 2;
                continue;
            }

            map[next.x][next.y] = 3;
            s.pop();
            next = s.top();
        }
        cout<<"没有出口"<<endl;
    }

    void PrintMap()
    {
        for(int i = 0; i < MAX_ROW; i++)
        {
            for(int j = 0; j < MAX_COL; j++)
            {
                cout<<map[i][j]<<" ";
            }
            cout<<endl;
        }
    }

private:
    int map[MAX_ROW][MAX_COL];
};


int main()
{
    int mapArr[MAX_ROW][MAX_COL] = 
        { 
            {0, 0, 1, 0, 0, 0, 0, 0, 0, 0}, 
            {0, 0, 1, 1, 1, 0, 0, 0, 0, 0}, 
            {0, 0, 0, 0, 1, 0, 0, 0, 0, 0}, 
            {1, 0, 0, 0, 1, 0, 0, 0, 0, 0}, 
            {0, 0, 1, 0, 1, 0, 0, 0, 0, 0}, 
            {0, 0, 1, 1, 1, 0, 0, 0, 0, 0}, 
            {0, 0, 1, 0, 0, 0, 0, 0, 0, 0}, 
            {0, 0, 1, 1, 0, 0, 0, 0, 0, 0}, 
            {0, 0, 0, 1, 1, 1, 1, 0, 0, 0}, 
            {0, 0, 0, 0, 0, 0, 1, 0, 0, 0} 
        };
    Seat entry = {9, 6};
    stack<Seat> s;
    Maze m(mapArr);
    m.PassMaze(s, entry);
    m.PrintMap();

    return 0;
}

运行结果：（存在缺陷）
这里写图片描述

递归

#include <iostream>
using namespace std;

#define MAX_ROW 10
#define MAX_COL 10

struct Seat
{
    int x;
    int y;
};

class Maze
{
public:
    Maze(int array[MAX_ROW][MAX_COL])
    {
        for(int i = 0; i < MAX_ROW; i++)
        {
            for(int j = 0; j <MAX_COL; j++)
            {
                map[i][j] = array[i][j];
            }
        }
    }

    bool IsPass(const Seat& s)
    {
        if((s.x >= 0 && s.x < MAX_ROW) &&
            (s.y >= 0 && s.y < MAX_COL))
            return 1 == map[s.x][s.y];
        return 0;
    }

    bool PassMaze(const Seat& s)
    {
        if(s.x >= MAX_ROW || s.x < 0 || s.y >= MAX_COL || s.y < 0)
            return true;

        if(IsPass(s))
        {
            map[s.x][s.y] = 2;

            Seat up = {s.x-1, s.y};
            Seat left = {s.x, s.y-1};
            Seat right = {s.x, s.y+1};
            Seat down = {s.x+1, s.y};
            if(PassMaze(up))
            {
                return true;
            }

            else if(PassMaze(left))
            {
                return true;
            }

            else if(PassMaze(right))
            {
                return true;
            }

            else if(PassMaze(down))
            {
                return true;
            }
            else
            {
                map[s.x][s.y] = 3;
            }
        }
        return false;
    }

    void PrintMap()
    {
        for(int i = 0; i < MAX_ROW; i++)
        {
            for(int j = 0; j < MAX_COL; j++)
            {
                cout<<map[i][j]<<" ";
            }
            cout<<endl;
        }
    }

private:
    int map[MAX_ROW][MAX_COL];
};


int main()
{
    int mapArr[MAX_ROW][MAX_COL] = 
        { 
            {0, 0, 1, 0, 0, 0, 0, 0, 0, 0}, 
            {0, 0, 1, 1, 1, 0, 0, 0, 0, 0}, 
            {0, 0, 0, 0, 1, 0, 0, 0, 0, 0}, 
            {1, 0, 0, 0, 1, 0, 0, 0, 0, 0}, 
            {0, 0, 1, 0, 1, 0, 0, 0, 0, 0}, 
            {0, 0, 1, 1, 1, 1, 1, 1, 1, 1}, 
            {0, 0, 1, 0, 0, 0, 0, 0, 0, 0}, 
            {0, 0, 1, 1, 0, 0, 0, 0, 0, 0}, 
            {0, 0, 0, 1, 1, 1, 1, 0, 0, 0}, 
            {0, 0, 0, 0, 0, 0, 1, 0, 0, 0} 
        };
    Seat s = {9, 6};
    Maze m(mapArr);
    m.PassMaze(s);
    m.PrintMap();

    return 0;
}

运行结果：（这种求法和类似于回溯法找出口，根据你代码搜素方式只会找到一条出口，然后就会退出）
这里写图片描述

无返回值的递归求解

#include <iostream>
using namespace std;

#define MAX_ROW 10
#define MAX_COL 10

struct Seat
{
    int x;
    int y;
};

class Maze
{
public:
    Maze(int array[MAX_ROW][MAX_COL])
    {
        for(int i = 0; i < MAX_ROW; i++)
        {
            for(int j = 0; j <MAX_COL; j++)
            {
                map[i][j] = array[i][j];
            }
        }
    }

    bool IsPass(const Seat& s)
    {
        if((s.x >= 0 && s.x < MAX_ROW) &&
            (s.y >= 0 && s.y < MAX_COL))
            return 1 == map[s.x][s.y];
        return 0;
    }

    void PassMaze(const Seat& s)
    {
        if(IsPass(s))
        {
            map[s.x][s.y] = 2;

            Seat up = {s.x-1, s.y};
            Seat left = {s.x, s.y-1};
            Seat right = {s.x, s.y+1};
            Seat down = {s.x+1, s.y};
            if(IsPass(up))
            {
                PassMaze(up);
            }

            if(IsPass(left))
            {
                PassMaze(left);
            }

            if(IsPass(right))
            {
                PassMaze(right);
            }

            if(IsPass(down))
            {
                PassMaze(down);
            }
        }

    }

    void PrintMap()
    {
        for(int i = 0; i < MAX_ROW; i++)
        {
            for(int j = 0; j < MAX_COL; j++)
            {
                cout<<map[i][j]<<" ";
            }
            cout<<endl;
        }
    }

private:
    int map[MAX_ROW][MAX_COL];
};


int main()
{
    int mapArr[MAX_ROW][MAX_COL] = 
        { 
            {0, 0, 1, 0, 0, 0, 0, 0, 0, 0}, 
            {0, 0, 1, 1, 1, 0, 0, 0, 0, 0}, 
            {0, 0, 0, 0, 1, 0, 0, 0, 0, 0}, 
            {1, 0, 0, 0, 1, 0, 0, 0, 0, 0}, 
            {0, 0, 1, 0, 1, 0, 0, 0, 0, 0}, 
            {0, 0, 1, 1, 1, 1, 1, 1, 1, 1}, 
            {0, 0, 1, 0, 0, 0, 0, 0, 0, 0}, 
            {0, 0, 1, 1, 0, 0, 0, 0, 0, 0}, 
            {0, 0, 0, 1, 1, 1, 1, 0, 0, 0}, 
            {0, 0, 0, 0, 0, 0, 1, 0, 0, 0} 
        };
    Seat s = {9, 6};
    Maze m(mapArr);
    m.PassMaze(s);
    m.PrintMap();

    return 0;
}

运行结果：（这种无终止条件的递归直接粗暴，会遍历所有给出的路径。但在有多个出口的情况时，还是无法得出最优路径）
这里写图片描述
有待完善^_^

░冷░月░
关注
专栏目录
递归——迷宫
LateNight_LL的博客
10-31 337
递归 迷宫回溯 如下是一个建议迷宫，编写程序使得显示从开始位置到终点的一条路径 （问题详解与思路均在代码题解中） 代码实现 package recursion; public class labyrinth { public static void main(String[] args) { //先创建一个二维数组，模拟迷宫 //创建地图 int[][]map=new int[8][7]; //使用1来作为围墙 //
C++ 用回溯法求解迷宫问题（递归）
ChanJose的博客
01-08 8470
一、定义：     回溯法（探索与回溯法）是一种选优搜索法，又称为试探法，按选优条件向前搜索，以达到目标。     但当探索到某一步时，发现原先选择并不优或达不到目标，就退回一步重新选择，这种走不通就     退回再走的技术为回溯法，而满足回溯条件的某个状态的点称为“回溯点”。     用回溯法求解问题时常使用递归方法进行试探，或使用栈帮助向前试探和回溯。   二、思路：    1....
递归-迷宫
qq_45464560的博客
10-10 410
有点类似于 深度优先遍历 求迷宫问题就是求出从入口到出口的路径，在求解时，通常用的是“穷举求解”的方法，即从入口出发，顺着某一个方向向前试探，若能走通，则继续往前走，否则沿着原路退回（回溯），换一个方向在继续试探，直到到达终点为止。 public class MiGong { public static void main(String[] args) { //先创建一个二维数组，用于模拟迷宫 int[][] map = new int[8][7]; //使用1表示墙
迷宫回溯——递归
wangke的博客
03-20 138
1.什么是递归？ 自己调用自己，每次传入的方法参数不同。 2.需求： 终止条件，和递归规律 代码： package com; public class Mul { public static void main(String[] args) { //创建一个数组，模拟迷宫 //地图 int[][] map = new int[8][7];...
简单迷宫(递归)
qq_52351978的博客
04-09 301
代码思路 1.创建二位数组作为迷宫 2.数字1为墙壁，2为经过的位置，3为死路，0为未探寻的位置 3,定义一个起点和终点，运用递归的方法，按照自己设计的寻找方向的优先级运行，直到让终点值为2则返回true，未找到返回false。 4.重新遍历输出二维数组,2的轨迹则为出口路径 代码如下 public class MiGongAPP { public static void main(String[] args) { // TODO 自动生成的方法存根 int[][] map=new
迷宫问题的递归回溯算法c语言,递归回溯算法解决迷宫问题
weixin_30728435的博客
05-23 1860
有一个迷宫地图，有一些可达的位置，也有一些不可达的位置(障碍、墙壁、边界)。从一个位置到下一个位置只能通过向上(或者向右、或者向下、或者向左)走一步来实现，从起点出发，如何找到一条到达终点的通路。用二维矩阵来模拟迷宫地图，1代表该位置不可达，0代表该位置可达。每走过一个位置就将地图的对应位置标记，以免重复。找到通路后打印每一步的坐标，最终到达终点位置。封装了点Dot，以及深度优先遍历用到的Bloc...
迷宫问题的递归回溯算法c语言,c语言迷宫问题求解——递归、栈回溯
weixin_36345268的博客
05-23 1884
第一次写，见谅以下是求迷宫的实现为什么下面会出现标签啊，有什么简便的方法去掉吗？求告知最后是关于求所有通路，个人愚笨只想到改变搜索方向顺序这种笨方法，总共有16种不同顺序，有兴趣的小伙伴可以试一下/*第一部分使用递归求解为了数据的简单化，不对路口进行数据结构化，将用一个简单的int类型数组来表示迷宫因为每一个路口的四个方向相对于当前路口的位移都是一样的，这样可以用一个int类型二位数据表示四个方向...
迷宫回溯_迷宫回溯_
10-02
在IT领域，迷宫回溯是一种经典的算法，用于解决寻找从起点到终点的可行路径问题。这个算法通常在游戏设计、图论问题和路径搜索等领域中有广泛应用。在本例中，我们将深入探讨如何使用C语言实现迷宫问题的回溯算法。 ...
迷宫问题递归回溯法
12-06
数组maze[8][8]存储迷宫的信息，0代表可通过，-1代表是墙。 数组fx[4]fy[4]存储当处于（i，j）位置时可走的四个方向，...若有一个位置的四个方向，要么是墙，要么是走过的路，则置这个位置为-2，代表是死路，并回溯。
迷宫回溯算法
08-02
迷宫算法 按钮代表格子 回溯算法
递归解决迷宫问题
12-22
数据结构中递归是一个重要的部分，此程序是回溯法实现了迷宫的问题，比较简单，亲自测试成功。
用回溯法递归实现迷宫
sinat_123
04-19 409
#include #define N 19//整个迷宫大小(包括最外层墙壁) char Maze[N][N] = { { 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1 }, { 1, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 }, { 1, 1, 1
递归（迷宫）
qq_25830587的博客
07-05 89
递归（迷宫） public class MiGong{ public static void main(String[] args) { //1. 先创建迷宫，用二维数组表 int map[][] = new int[8][7]; for(int i = 0; i < 7; i++){ map[0][i] = 1; map[7][i] = 1; } for(int i = 0; i < 8; i++){ map[i][0] = 1; map[i][
递归_迷宫
TalonG的专栏
10-24 1414
package agrisom; import java.util.EmptyStackException; import java.util.Stack; /**  * 递归_迷宫  */ /**  * 位置类  */ class Position{     public int row;     public int col;     public Posi
递归实现简单的迷宫回溯
VInllor的博客
09-05 470
通过该篇文章主要是想了解递归的整个流程 说明:map 表示地图,可以自己定义 i,j 表示从地图的哪个位置开始出发 如果小球能到map[6][5]位置,则说明通路找到 约定:当map[i][j]为0时表示该点没走过,1 ----> 墙 2 ------> 通路 3 -------> 该点已走过,走不通 该处省略了所...
05-递归回溯-迷宫问题
惊鸿的技术博客
09-23 226
package 迷宫问题; public class MiGong { public static void main(String[] args) { //创建数组，模拟迷宫 int[][] map=new int[8][7]; //使用一表示墙 //第一行和最后一行置为一 for (int i = 0; i < 7; i++) { map[0][i]=1; map[7][i]=1; } ...
学习笔记-迷宫回溯（递归）
Shine_QianMo的博客
04-04 2325
递归的应用-迷宫回溯 此代码仅供找到出口，并不能找到最短路径，如果找到纯属巧合。 没出口的话会出现3； public class MiGong { public static void main(String[] args) { //县创建一个二维数组模拟迷宫 int[][] map = new int[8][7]; //使用1表示墙 ...
迷宫问题c++回溯递归
最新发布
05-18
好的，下面是一个简单的迷宫问题的 C++ 回溯递归实现： ```c++ #include<iostream> using namespace std; // 定义迷宫的行列数 const int N = 5; // 定义迷宫地图 int maze[N][N] = { {0, 0, 0, 0, 0}, {0, 1, 1, 0, 0}, {0, 0, 1, 1, 0}, {0, 0, 0, 1, 0}, {1, 1, 0, 0, 0} }; // 定义标记数组 int mark[N][N]; // 定义方向数组 int dir[4][2] = {{0, 1}, {1, 0}, {0, -1}, {-1, 0}}; // 递归函数，判断是否能够到达终点 bool dfs(int x, int y) { // 判断当前位置是否为终点 if (x == N-1 && y == N-1) { return true; } // 标记当前位置已经走过 mark[x][y] = 1; // 枚举四个方向 for (int i = 0; i < 4; i++) { int nx = x + dir[i][0]; int ny = y + dir[i][1]; // 判断是否越界，是否能够走，以及该位置是否已经走过 if (nx >= 0 && nx < N && ny >= 0 && ny < N && !maze[nx][ny] && !mark[nx][ny]) { // 递归搜索下一步是否能够到达终点 if (dfs(nx, ny)) { return true; } } } // 如果四个方向都无法到达终点，则返回 false return false; } int main() { // 如果起点和终点都是 0，那么就可以通过 DFS 判断是否能够到达终点 if (maze[0][0] == 0 && maze[N-1][N-1] == 0 && dfs(0, 0)) { cout << "可以到达
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值