13迷宫问题（回溯思想）

于 2021-08-12 14:03:35 发布
阅读量1.6k 收藏 7
点赞数 23
分类专栏： 数据结构（C语言实现）
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_52670477/article/details/119641996
版权

算法 c语言

迷宫问题是回溯思想的一种运用，一般可以用栈来实现

文章目录

迷宫问题求解

原题链接迷宫问题.

在这里插入图片描述

题目分析

  1. 题目要求我们先输入两个数代表迷宫的行和列，然后再输入具体的数组内容。这里的起点是左上角，终点是右下角，注意这里有可能让我们输入多组迷宫，所以此时需要用while循环来实现多次输入。另外这个题目中，1代表墙，不能走，0代表路，可以走。
  2. 从起点开始走迷宫，我们得先告诉程序向哪走，这里按上下左右的顺序依次走，如果走不通就向另一个方向走,要实现这个很简单,只需修改横纵坐标即可。然后判断要走的位置是否是墙（1）,如果为0可以向这个地方走一步,四个方向就是四次判断。
  3. 走完第一步，我们只需要不断重复上一步的步骤就可以走第二步，后面都是重复这个过程。所以这里要用递归实现
  4. 除了判断四周是否是障碍物之外,还需要判断这个地方之前是否走过了,因为四个方向是都有可能判断一次的,如果不把已经走过的地方标记出来就会走重复了.这里把已经走过的点标记为2。
  5. 有时候可能会走到死路，也就是上下左右都走不通，这个时候我们就要回到上一步走另一个方向。直到走到终点为止。
  6. 如何将走过的路径打印出来呢？这里就要用到栈实现，栈里面保存每一步的坐标。栈有先进先出的特点，我们走不通的时候回溯到上一步，栈顶的坐标只需要出栈即可。
  7. 但是栈里的顺序是倒着打印出来的，所以在打印栈里面的数据的时候只需要再定义一个栈，利用栈实现队列的思想即可打印正着的数据。

在这里插入图片描述

代码实现

#include<stdio.h>
#include<stdlib.h>
#include<stdbool.h>
#include<assert.h>
//定义坐标的结构体
typedef struct Postion
{
    int row;
    int col;
}PT;

//
typedef PT STDataType;

typedef struct Stack
{
    STDataType* a;
    int top;
    int capacity;
}ST;
//初始化
void StackInit(ST* ps)
{
    assert(ps);
    ps->a = (STDataType*)malloc(sizeof(STDataType) * 4);
    if (ps->a == NULL)
    {
        exit(-1);
    }
    ps->capacity = 4;
    //top初始为0，top指向栈顶元素的下一个元素，top初识为-1，top指向栈顶的元素
    ps->top = 0;
}

//销毁
void StackDestory(ST* ps)
{
    assert(ps);
    free(ps->a);
    ps->a = NULL;
    ps->top = ps->capacity = 0;
}

//入栈
void StackPush(ST* ps, STDataType x)
{
    assert(ps);
    if (ps->top == ps->capacity)
    {
        STDataType* tmp = (STDataType*)realloc(ps->a, ps->capacity * 2 * sizeof(STDataType));
        if (tmp == NULL)
        {
            exit(-1);
        }
        else
        {
            ps->a = tmp;
            ps->capacity *= 2;
        }
    }
    ps->a[ps->top] = x;
    ps->top++;
}

//出栈
void StackPop(ST* ps)
{
    assert(ps);
    ps->top--;
}
//取栈顶的数据
STDataType StackTop(ST* ps)
{
    assert(ps);
    assert(ps->top > 0);
    return ps->a[ps->top - 1];
}
//求数据的个数
int StackSize(ST* ps)
{
    assert(ps);
    return ps->top;
}
//判断是否为空
bool StackEmpty(ST* ps)
{
    assert(ps);
    return ps->top == 0;
}

//上面都是栈的代码

ST path;//定义一个全局的栈，来保存走过的路径

//输出栈里面的坐标路径，再用一个栈实现数据的顺序输出
void PrintPath(ST* ps)
{
    //将path的数据导入rPath
    ST rPath;
    StackInit(&rPath);
    while (!StackEmpty(&path))//将path里的数据全部放到rPath
    {
        StackPush(&rPath, StackTop(&path));
        StackPop(&path);
    }
    while (!StackEmpty(&rPath))//输出rPath数据
    {
        PT top = StackTop(&rPath);
        printf("(%d,%d)\n", top.row, top.col);
        StackPop(&rPath);
    }

    StackDestory(&rPath);
}
//判断是否越界或者走不通
bool IsPass(int** maze, int N, int M, PT pos)
{
    if (pos.row >= 0 && pos.row < N && pos.col >= 0 && pos.col < M && maze[pos.row][pos.col] == 0)
    {
        return true;
    }
    else
    {
        return false;
    }
}

bool GetMazePath(int** maze, int N, int M, PT cur)//实现走迷宫的函数
{
    StackPush(&path, cur);//将坐标放入栈
    //如果走到出口就返回真
    if (cur.row == N - 1 && cur.col == M - 1)
    {
        return true;
    }
    //探测cur上下左右四个方向
    PT next;
    //把行和列对应的位置置成2
    maze[cur.row][cur.col] = 2;

    //上，纵坐标-1
    next = cur;
    next.row -= 1;
    if (IsPass(maze, N, M, next))//判断下一步能否走通
    {
        if (GetMazePath(maze, N, M, next))//继续走下一步
        {
            return true;
        }
    }


    //下，纵坐标+1
    next = cur;
    next.row += 1;
    if (IsPass(maze, N, M, next))
    {
        if (GetMazePath(maze, N, M, next))
        {
            return true;
        }
    }


    //左，横坐标-1
    next = cur;
    next.col -= 1;
    if (IsPass(maze, N, M, next))
    {
        if (GetMazePath(maze, N, M, next))
        {
            return true;
        }
    }

    //右，横坐标+1
    next = cur;
    next.col += 1;
    if (IsPass(maze, N, M, next))
    {
        if (GetMazePath(maze, N, M, next))
        {
            return true;
        }
    }
    StackPop(&path);//如果走不通就将栈顶的数据出栈
    return false;//回到上一步
}


int main()
{
    int N = 0, M = 0;
    while (scanf("%d%d", &N, &M) != EOF)//输入行和列
    {
        int** maze = (int**)malloc(sizeof(int*) * N);//动态创建二维数组
        for (int i = 0; i < N; i++)
        {
            maze[i] = (int*)malloc(sizeof(int) * M);
        }

        //二维数组的输入
        for (int i = 0; i < N; i++)
        {
            for (int j = 0; j < M; j++)
            {
                scanf("%d", &maze[i][j]);
            }
        }
        StackInit(&path);//初始化栈
        PT entry = { 0,0 };//创建起点
        if (GetMazePath(maze, N, M, entry))//走到出口就打印栈里面的数据
        {
            PrintPath(&path);
        }
        else
        {
            printf("没找到通路");
        }
        StackDestory(&path);
        for (int i = 0; i < N; i++)//释放动态开辟的数组
        {
            free(maze[i]);
        }
        free(maze);
        maze = NULL;
    }

    return 0;
}

迷宫最短路径求解

原题链接地下迷宫
在这里插入图片描述

题目分析

  1. 这个问题和上个问题类似，但是注意这里的墙换成0，能走的路换成了1，起点的位置是左上角，但是终点的位置是右下角。
  2. 这个问题增加了体力限制。一般这种类型的问题都是要求最短路径，也就是消耗体力最少的路径。
  3. 求最短路径只需要我们把所有的路径都求出来然后比较找出最短的即可。
  4. 由于要求最短路径，这也就意味着有的位置我们会走很多次，因此在回溯的时候我们需要把已经改成2的位置再改回1
  5. 其他地方和上一个题一样。

代码实现

#include<stdio.h>
#include<stdlib.h>
#include<stdbool.h>
#include<assert.h>
#include<string.h>
//定义坐标的结构体
typedef struct Postion
{
    int row;
    int col;
}PT;

//
typedef PT STDataType;

typedef struct Stack
{
    STDataType* a;
    int top;
    int capacity;
}ST;
//初始化
void StackInit(ST* ps)
{
    assert(ps);
    ps->a = (STDataType*)malloc(sizeof(STDataType) * 4);
    if (ps->a == NULL)
    {
        exit(-1);
    }
    ps->capacity = 4;
    //top初始为0，top指向栈顶元素的下一个元素，top初识为-1，top指向栈顶的元素
    ps->top = 0;
}

//销毁
void StackDestory(ST* ps)
{
    assert(ps);
    free(ps->a);
    ps->a = NULL;
    ps->top = ps->capacity = 0;
}

//入栈
void StackPush(ST* ps, STDataType x)
{
    assert(ps);
    if (ps->top == ps->capacity)
    {
        STDataType* tmp = (STDataType*)realloc(ps->a, ps->capacity * 2 * sizeof(STDataType));
        if (tmp == NULL)
        {
            exit(-1);
        }
        else
        {
            ps->a = tmp;
            ps->capacity *= 2;
        }
    }
    ps->a[ps->top] = x;
    ps->top++;
}

//出栈
void StackPop(ST* ps)
{
    assert(ps);
    ps->top--;
}
//取栈顶的数据
STDataType StackTop(ST* ps)
{
    assert(ps);
    assert(ps->top > 0);
    return ps->a[ps->top - 1];
}
//求数据的个数
int StackSize(ST* ps)
{
    assert(ps);
    return ps->top;
}
//判断是否为空
bool StackEmpty(ST* ps)
{
    assert(ps);
    return ps->top == 0;
}

//
ST path;//保存路径坐标
ST minpath;//保存最短路径的坐标

//输出栈里面的坐标路径
void PrintPath(ST* ps)
{
    //将path的数据导入rPath
    ST rPath;
    StackInit(&rPath);
    while (!StackEmpty(ps))
    {
        StackPush(&rPath, StackTop(ps));
        StackPop(ps);
    }
    while (StackSize(&rPath) > 1)
    {
        PT top = StackTop(&rPath);
        printf("[%d,%d],", top.row, top.col);
        StackPop(&rPath);
    }
    PT top = StackTop(&rPath);
    printf("[%d,%d]", top.row, top.col);
    StackPop(&rPath);

    StackDestory(&rPath);
}
//判断是否越界
bool IsPass(int** maze, int N, int M, PT pos)
{
    if (pos.row >= 0 && pos.row < N && pos.col >= 0 && pos.col < M
        && maze[pos.row][pos.col] == 1)
    {
        return true;
    }
    else
    {
        return false;
    }

}
//将路径坐标拷贝到最短路径坐标里面
void StackCooy(ST* ppath, ST* pcopy)
{
    pcopy->a = (STDataType*)malloc(sizeof(STDataType) * ppath->capacity);
    memcpy(pcopy->a, ppath->a, sizeof(STDataType) * ppath->top);
    pcopy->top = ppath->top;
    pcopy->capacity = ppath->capacity;
}

//实现走迷宫的函数，注意这里的类型改成void，因为路径不止一条
void GetMazePath(int** maze, int N, int M, PT cur, int p)
{
    StackPush(&path, cur);//将坐标放到栈中
    //如果走到出口
    if (cur.row == 0 && cur.col == M - 1)
    {
        //如果体力大于等于0并且Path栈里面的坐标数量比minpath少，就将Path拷贝到minpath
        if (p >= 0 && StackEmpty(&minpath)
            || StackSize(&path) < StackSize(&minpath))
        {
            StackDestory(&minpath);
            StackCooy(&path, &minpath);
        }
    }
    //探测cur上下左右四个方向
    PT next;
    //把行和列对应的位置置成2
    maze[cur.row][cur.col] = 2;

    //上
    next = cur;
    next.row -= 1;
    if (IsPass(maze, N, M, next))
    {
        GetMazePath(maze, N, M, next, p - 3);
    }


    //下
    next = cur;
    next.row += 1;
    if (IsPass(maze, N, M, next))
    {
        GetMazePath(maze, N, M, next, p);
    }


    //左
    next = cur;
    next.col -= 1;
    if (IsPass(maze, N, M, next))
    {
        GetMazePath(maze, N, M, next, p - 1);

    }

    //右
    next = cur;
    next.col += 1;
    if (IsPass(maze, N, M, next))
    {
        GetMazePath(maze, N, M, next, p - 1);
    }
    maze[cur.row][cur.col] = 1;//回溯的时候将已经走过的位置改成1
    StackPop(&path);//出栈

}


int main()
{
    int N = 0, M = 0, p = 0;//P代表体力
    while (scanf("%d%d%d", &N, &M, &p) != EOF)//输入行和列以及体力
    {
        int** maze = (int**)malloc(sizeof(int*) * N);
        for (int i = 0; i < N; i++)
        {
            maze[i] = (int*)malloc(sizeof(int) * M);
        }

        //二维数组的输入
        for (int i = 0; i < N; i++)
        {
            for (int j = 0; j < M; j++)
            {
                scanf("%d", &maze[i][j]);
            }
        }
        StackInit(&path);//初始化两个栈
        StackInit(&minpath);
        PT entry = { 0,0 };
        GetMazePath(maze, N, M, entry, p);

        if (!StackEmpty(&minpath))//如果minpath里面不为空说明已经有最短路径
        {
            PrintPath(&minpath);
        }
        else
        {
            printf("Can not escape!");
        }

        StackDestory(&path);//销毁栈
        StackDestory(&minpath);
        for (int i = 0; i < N; i++)//释放动态开辟的数组
        {
            free(maze[i]);
        }
        free(maze);
        maze = NULL;
    }
    return 0;
}

注意，这里有个将Path栈里的数据拷贝到minpath里的操作，这里不能采用直接赋值minpath=Path的方式，因为直接赋值是将minpath指向Path的空间，这样之前minpath的空间就会丢失，而且minpath和Path指向同一块空间，在销毁时就会销毁两次。

在这里插入图片描述

这里采用的方法是将minpath的空间销毁，然后再动态创建一个和Path同样大小的空间让minpath指向，最后将Path里面的数据用memcp函数拷贝到minpath中。

今天也要写bug、
关注
专栏目录
栈的思想用于求解迷宫问题
kelvinmao的博客
04-08 1172
迷宫问题是一个经典的问题，当迷宫规模较大时，手工求解是十分困难的，所以用善于进行重复繁琐计算的计算机来求解便十分合适。基本思想和解决“八皇后问题” 的思想一致，都是利用回溯法。从入口开始，探索每一个迷宫中没有被墙挡住的位置，如果该位置可以移动到下一个位置，则标记该位置已被探索过并入栈；如果不能移动到下一位置，则标记为探索失败并回退到上一个位置，如果最终退回了出发点，则说明迷宫无解。下面附上代码:#i
hncu1102:迷宫问题(BFS)
ACM！荣耀之路！
07-04 5197
http://hncu.acmclub.com/index.php?app=problem_title&id=111&problem_id=1102 题目描述 小明置身于一个迷宫，请你帮小明找出从起点到终点的最短路程。 小明只能向上下左右四个方向移动。 输入格式 输入包含多组测试数据。输入的第一行是一个整数T，表示有T组测试数据。 每组输入的第一行是两个整数N和M（1 接下来N行
迷宫问题
01-06
简单的迷宫问题
用回溯的思想解决迷宫问题
12-25
对于给定的"用回溯的思想解决迷宫问题"的压缩包文件，可能包含了实现这一算法的源代码，可以下载并研究其具体实现细节，以便更好地理解和应用回溯法解决迷宫问题。 总之，回溯法是一种强大而灵活的解决问题的方法，...
java 实现迷宫回溯算法示例详解
08-18
Java 实现迷宫回溯算法示例详解 本文主要介绍了 Java 实现迷宫回溯算法的示例详解，通过示例代码介绍了迷宫回溯算法的实现，文中对大家的学习或者工作具有一定的参考学习价值。 一、迷宫回溯算法的原理 迷宫回溯...
迷宫问题的递归回溯算法c语言,递归回溯算法解决迷宫问题
weixin_30728435的博客
05-23 1869
有一个迷宫地图，有一些可达的位置，也有一些不可达的位置(障碍、墙壁、边界)。从一个位置到下一个位置只能通过向上(或者向右、或者向下、或者向左)走一步来实现，从起点出发，如何找到一条到达终点的通路。用二维矩阵来模拟迷宫地图，1代表该位置不可达，0代表该位置可达。每走过一个位置就将地图的对应位置标记，以免重复。找到通路后打印每一步的坐标，最终到达终点位置。封装了点Dot，以及深度优先遍历用到的Bloc...
基于迷宫问题的回溯法求解及算法实现
10-31
### 基于迷宫问题的回溯法求解及算法实现 #### 1. 回溯法简介 回溯法是一种系统地搜索问题解的方法，通常用于解决约束满足问题和优化问题。它通过尝试性地构建解，并在发现当前构建的解无法达到目标时回退（或...
回溯法解迷宫问题.
01-28
### 回溯法解迷宫问题 #### 一、引言 迷宫问题是计算机科学中的一个经典问题，常被用来测试算法效率与解决问题的能力。在众多解决迷宫问题的方法中，回溯法因其简单易懂且能有效找到解而被广泛采用。本文将通过...
解密迷宫：回溯法求解路径探索策略
回溯法是一种通过试错来寻找问题解的算法，其基本思想是：对于给定的问题，设置一些可能的解，并通过尝试这些可能的解来找出所有解。如果一个可能的解被确认不是一个可行的解，算法会“回溯”到上一个步骤，并尝试另...
评论 6
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

今天也要写bug、

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值