Question

有一个矩阵包含白色单元格（表示为1），黑色单元格（表示为0），只有一个灰色单元格（表示为2），需要从（0,0）到（N-1，数组[N] [N]中的N-1）。

约束：

1）路径应仅覆盖白色单元格，并且必须通过灰色单元格（此灰色单元格可以位于数组中的任何位置）

2）无法再次访问曾经访问过的节点。

以下是典型的迷宫问题解决方案，但此解决方案无法处理遍历GRAY单元格的特定情况......所以，请您帮我修改以下代码以处理特定情况。

我的问题是我不确定如何检查灰色单元格？

#include "stdafx.h"
#include "algorithm"
#include <iostream>
 #include <fstream>
using namespace std;
#include<stdio.h>

// Maze size
#define N 4 

bool solveMazeUtil(int maze[N][N], int x, int y, int sol[N][N]);

/* A utility function to print solution matrix sol[N][N] */
void printSolution(int sol[N][N])
{
    for (int i = 0; i < N; i++)
    {
        for (int j = 0; j < N; j++)
           printf(" %d ", sol[i][j]);
        printf("\n");
    }
}

/* A utility function to check if x,y is valid index for N*N maze */
bool isSafe(int maze[N][N], int x, int y)
{
    //solveMazeUtil() to solve the problem. It returns false if no path is possible,
    //otherwise return true and prints the path in the form of 1s. Please note that
    //there may be more than one solutions, this function prints one of the feasible
    if(x >= 0 && x < N && y >= 0 && y < N && maze[x][y] == 1)
        // if (x,y outside maze) return false
        return true;

    return false;
}

/* This function solves the Maze problem using Backtracking. It mainly uses
solutions.*/
bool solveMaze(int maze[N][N])
{
    int sol[N][N] = { {0, 0, 0, 0},
                      {0, 0, 0, 0},
                      {0, 0, 0, 0},
                      {0, 0, 0, 0}
                    };

    if(solveMazeUtil(maze, 0, 0, sol) == false)
    {
        printf("Solution doesn't exist");
        return false;
    }

    printSolution(sol);
    return true;
}

/* A recursive utility function to solve Maze problem */
bool solveMazeUtil(int maze[N][N], int x, int y, int sol[N][N])
{
    // if (x,y is goal) return true
    if(x == N-1 && y == N-1)
    {
        sol[x][y] = 1;
        return true;
    }

    // Check if maze[x][y] is valid
    if(isSafe(maze, x, y) == true)
    {
        // mark x,y as part of solution path
        sol[x][y] = 1;

        /* Move forward in x direction */
        if (solveMazeUtil(maze, x+1, y, sol) == true)
            return true;

        /* If x moving in x direction doesn't give solution then
        Move down in y direction */
        if (solveMazeUtil(maze, x, y+1, sol) == true)
            return true;

        /* If none of the above movements work then BACKTRACK: 
        unmark x,y as part of solution path */
        sol[x][y] = 0;
        return false;
    } 

    return false;
}

// driver program to test above function
int main()
{
    int maze[N][N] = { {1, 0, 0, 0},
                       {1, 1, 0, 1},
                       {0, 1, 0, 0},
                       {1, 1, 1, 1}
                     };

    solveMaze(maze);
    getchar();
    return 0;
}

我想的一个解决方案是：

生成所有可能的路径（遍历1或2）。

然后，找出哪条路径中有2条。然后打印该路径作为输出。

但我认为这不是一个好方法......所以，请让我知道如何以体面的方式实现我的目标。感谢

Answer 1

因为在您的代码中，您只使用了两种可能的移动：向下和向右，然后这是DAG。 DAG适用于动态编程方法：每个单元有两种可能性到达那里，一个来自上方而另一个来自左侧。因此，单元格的最小距离为：

cost[i][j] = min(cost[i][j-1],cost[i-1][j]) + 1

考虑到进行移动的成本是1.如果单元格是黑色的，您可以给它无限的成本，而您只需找到从P1(start)到P2(gray cell)的路径，然后是从P2到P3(goal)的路径。

为了重建路径，您可以创建另一个父母pi[N][N]矩阵，如果最短路径来自上方，那么pi[i][j] = (i-1, j)如果来自左pi[i][j] = (i, j-1)，如果无法达到该路径pi[i][j] = null(whatever you want)单元格{{1}}。

Answer 2

一般来说，我的方法是：

生成一个图形，其中每个单元格都是一个顶点，并与表示迷宫中相邻白色/灰色单元格的边缘顶点连接。
找到起始顶点（表示Array [0] [0]的那个）和灰色顶点（建议使用A *）之间的最短路径P1。
找到灰色顶点和结束顶点之间的最短路径P2（表示数组[N-1] [N-1]的那个）。
P1和P2可以只交换一次（因为它们代表最短路径），如果它们相交，则从这一点开始，并且将代表相同的路径。从而：
- 如果P1和P2不相交，则P1后跟P2是最佳解决方案。
- 如果P1和P2相交，则删除相交部分中的顶点，再次执行操作2和3，分别找到新的最短路径P3和P4 。最佳解决方案是P1后跟P4和P3后跟P2之间的最小值。

无法追踪迷宫中的灰色细胞

2 个答案: