解决迷宫回溯

【问题标题】：Solve a maze backtracking解决迷宫回溯
【发布时间】：2017-10-24 05:25:41
【问题描述】：

我正在尝试使用 C 中的回溯解决迷宫。要解决迷宫，请遵循以下规则：

  • 你从S的位置开始，需要向E走
  • 你只能继续'.'路径
  • 转换所有的 '.'进入“#”，包括 S 和 E

输入由一个 m x n 矩阵组成： 输入示例：

11 11
+-+-+-+-+-+
S.|...|...|
+.+.+.+-+.+
|.|.|.....|
+.+-+-+-+.+
|...|.|...|
+.+.+.+.+-+
|.|...|.|.|
+.+-+.+.+.+
|...|.....E
+-+-+-+-+-+

预期的解决方案：

+-+-+-+-+-+
##|...|...|
+#+.+.+-+.+
|#|.|.....|
+#+-+-+-+.+
|###|.|...|
+.+#+.+.+-+
|.|###|.|.|
+.+-+#+.+.+
|...|######
+-+-+-+-+-+

我非常努力地解决它，但由于某种原因，一旦我到达迷宫中的某个点，我无法继续前进，我的程序就不会返回。它只是朝着它看到的所有方向前进'。'

我的想法是从 S 的位置开始，并在每个递归步骤中使用我们原来的位置。 如果我正在看的位置是“。”，我将从我站立的位置向所有方向走。如果那一点不是我的旧职位。

我还认为，当我回溯到一个十字路口时，我遇到了问题。例如：

+-+-+-+-+-+
##|...|...|
+#+.+.+-+.+
|#|.|.....|
+#+-+-+-+.+
|0##|.|...|
+.+#+.+.+-+
|.|###|.|.|
+.+-+#+.+.+
|..1|######
+-+-+-+-+-+

想象一下，我在位置 0。我从 1 回溯，将 # 改回 '.'。我如何发表声明说你有 2 # 种可能性回去，但你应该停下来？

我的代码：

#include <stdio.h>
#include <stdlib.h>

void *safeMalloc(int n) {
    void *p = malloc(n);
    if (p == NULL) {
        printf("Error: malloc(%d) failed. Out of memory?\n", n);
        exit(EXIT_FAILURE);
    }
    return p;
}


char ** readMatrix(int m,int n,int* startI,int* startJ,int* endI,int* endJ){
    char **arr = safeMalloc(m*sizeof(char *));
    int row;
    for (row=0; row < m; row++) {
        arr[row] = safeMalloc(n*sizeof(char));
    }
    int i,j;
    for(i=0;i<m;i++){
        for(j=0;j<m;j++){
            scanf(" %c",&arr[i][j]);
            if(arr[i][j]=='S'){
                *startI=i;
                *startJ=j;
            }
            if(arr[i][j]=='E'){
                *endI=i;
                *endJ=j;
            }
        }
        getchar();
    }

    return arr;
}

void printNumber(char **arr,int m,int n){
    int i,j;
    for(i=0;i<m;i++){
        for(j=0;j<n;j++){
            printf("%c", arr[i][j]);
        }
        printf("\n");
    }
}

void findPath(char** arr,int m,int n,int startI,int startJ,int endI,int endJ,int oldI,int oldJ){
    int i=startI,j=startJ;
    int stepsPossible=4;
            //going up
           if(i-1>=0){
                if((arr[i-1][j]=='.') && ((i-1!=oldI) || (j!=oldJ))){
                    arr[i][j]='#';
                    oldI=i;
                    oldJ=j;
                    findPath(arr,m,n,i-1,j,endI,endJ,oldI,oldJ);
                }else{
                    stepsPossible--;
                }
           }
           //going right

           if(j+1<n){
                if((arr[i][j+1]=='.') && ((i!= oldI) || (j+1!=oldJ))){
                    arr[i][j]='#';
                    oldI=i;
                    oldJ=j;
                    findPath(arr,m,n,i,j+1,endI,endJ,oldI,oldJ);
                }else{
                    stepsPossible--;
                }
           }
           //going left
           if(j-1>=0){
                if((arr[i][j-1]=='.') && ((i!= oldI) || (j-1!=oldJ))){
                    arr[i][j]='#';
                    oldI=i;
                    oldJ=j;
                    findPath(arr,m,n,i,j-1,endI,endJ,oldI,oldJ);
                }else{
                    stepsPossible--;
                }
           }

           //going down
            if(i+1<m){
                if((arr[i+1][j]=='.') && ((i+1!= oldI) || (j!=oldJ))){
                    arr[i][j]='#';
                    oldI=i;
                    oldJ=j;
                    findPath(arr,m,n,i+1,j,endI,endJ,oldI,oldJ);
                }else{
                    stepsPossible--;
                }
           }
        //if the next block is E then we can stop.
           if((arr[i-1][j]=='E') || (arr[i][j+1]=='E') || (arr[i][j-1]=='E') || (arr[i+1][j]=='E')){
                if(arr[i-1][j]=='E'){
                    arr[i-1][j]='#';
                }

                if(arr[i][j+1]=='E'){
                    arr[i][j+1]='#';
                }

                if(arr[i][j-1]=='E'){
                    arr[i][j-1]='#';
                }

                if(arr[i+1][j]=='E'){
                    arr[i+1][j]='#';
                }
                return;
            }


            if(stepsPossible==0){
                if(arr[i-1][j]=='#'){
                    arr[i][j]='.';
                    oldI=i;
                    oldJ=j;
                    findPath(arr,m,n,i-1,j,endI,endJ,oldI,oldJ);
                }else{
                    return;
                }

                if(arr[i][j+1]=='#' ){
                    arr[i][j]='.';
                    oldI=i;
                    oldJ=j;
                    findPath(arr,m,n,i,j+1,endI,endJ,oldI,oldJ);
                }else{
                    return;
                }

                if(arr[i][j-1]=='#' ){
                    arr[i][j]='.';
                    oldI=i;
                    oldJ=j;
                    findPath(arr,m,n,i,j-1,endI,endJ,oldI,oldJ);
                }else{
                    return;
                }

                if(arr[i+1][j]=='#' ){
                    arr[i][j]='.';
                    oldI=i;
                    oldJ=j;
                    findPath(arr,m,n,i+1,j,endI,endJ,oldI,oldJ);
                }else{
                    return;
                }
            }
}


int main()
{
    int m,n;
    scanf("%d %d",&m,&n);
    int startI,startJ,endI,endJ;
    char** arr;
    arr=readMatrix(m,n,&startI,&startJ,&endI,&endJ);
    findPath(arr,m,n,startI,startJ,endI,endJ,startI,startJ);
    printNumber(arr,m,n);
    return 0;
}

【问题讨论】：

  • 你用的是什么算法？这听起来像 A* 会很好。
  • 我真的没有搜索要使用的特定算法。我的想法是从 S 开始，如果我看到一个 '.'，就往各个方向走。当我没有任何方向可走时，只需搜索“#”，将自己转换回“。”并将您的位置保存为 oldI,oldJ ，然后从您看到“#”的位置再次应用该功能。
  • 无论如何，我不认为我应该使用任何已知的搜索算法，因为我们没有在本练习中看到它们中的任何一个。
  • 除非说明说你不应该这样做，否则我看不出有任何理由不这样做。
  • 如果你想自己制作一个算法，你还没有准备好实际的代码。在实施之前确保算法有效。

标签： c backtracking maze


【解决方案1】：

正确使用返回值，因为您可以利用它来简化逻辑。在findPath 上为错误情况（需要回溯）和成功情况（到达终点）选择不同的返回值。

现在您可以将# 无条件地设置在该函数的开头，并在最后无条件地重置回. 以用于回溯情况。

也不需要计算可能的方向，只检查某个调用是否返回成功。

也不需要一遍又一遍地编写边界检查，如果您只是在函数开始时检查它们，您可以传递无效坐标而不会出现任何问题。

bool findPath(char** arr, size_t sx, size_t sy, int x, int y) {
    if (x < 0 || x >= sx || y < 0 || y >= sy) return false;
    if (arr[x][y] == 'E') {
        are[x][y] = '#';
        return true;
    }
    if (arr[x][y] != '.') return false;
    arr[x][y] = '#';
    bool success = findPath(arr, sx, sy, x-1, y) ||
        findPath(arr, sx, sy, x+1, y) ||
        findPath(arr, sx, sy, x, y-1) ||
        findPath(arr, sx, sy, x, y+1);
    if (!success) arr[x][y] = '.';
    return success;
}

回溯算法的实现通常都遵循相同的模式：

  1. 尽量拒绝或接受当前的解决方案。
  2. 修改当前解决方案。
  3. 尝试变体。
  4. 如果不成功，请清理修改。

【讨论】：

    【解决方案2】：

    我建议使用 BFS，因为

    • BFS 会找到最短的解决方案。
    • DFS 对某些迷宫的处理非常糟糕。

    以下是针对您的案例的 BFS 的简短描述：

    1. 在迷宫中找到“S”并将其添加到队列中
    2. 当队列不为空时，检查从队列中获取元素。 用“#”替换元素。如果元素是E，你就完成了。检查元素的邻居（上、下、左、右），如果它们是“.”，则添加到队列中。
    3. 如果队列为空且未找到 E，则没有从 S 到 E 的直接路径

    【讨论】：

    • 这种情况下最简单的算法，因为迷宫不包含循环，是 DFS，它也能产生理想的结果。
    • @Ext3h，即使在您描述的条件下，DFS 也远非理想。不正确的早期猜测会大大增加搜索时间。
    猜你喜欢
    相关资源
    最近更新 更多
    热门标签
    Java Python linux javascript C# Mysql Docker 算法 前端 SpringBoot Redis Vue spring .net 设计模式 .net core c++ kubernetes 数据库 机器学习 大数据 数据结构 微服务 js 人工智能 Go Android 面试 程序员 JVM 云原生 后端 ASP.net core 深度学习 CSS k8s git golang PHP devops Nginx Django React mybatis 架构 多线程 Spring Boot 云计算 LeetCode 分布式