Question

迷宫拼图中的鼠标 - 迷宫作为块的N * N二进制矩阵给出，其中源块是最左上方的块，即迷宫[0] [0]和目标块是最右下方的块，即迷宫[N -1] [N-1]。老鼠从源头开始，必须到达目的地。老鼠可以向任何方向移动：向前，向下，向左，向右。在迷宫矩阵中，0表示块是死角，1表示块可以用于从源到目的地的路径。

问题 - 找到所有可能的解决方案和解决方案，让老鼠走出迷宫。我能够在迷宫拼图中为老鼠找到“单一解决方案”。但是，我如何确定不同的可能解决方案和解决方案的数量？粘贴下面的代码将确定单个解决方案并打印相同的解决方案。请帮助我如何确定不同的可能解决方案和解决方案的数量。

#include<stdio.h>
#include<conio.h>
#define N 5 //Maze Size 5X5 matrix

//Function declarations
void maze(int m[N][N]);
int maze_soln(int soln[N][N], int m[N][N],int ,int,int path[N][N]);
int issafe(int m[N][N], int x, int y,int path[N][N]);

// This function checks for valid cell. If already visited in the past
// path[][] will take care of returning false.
int issafe(int m[N][N], int x, int y,int path[N][N])
{
    if (x >= 0 && y >= 0 && x < N && y < N && m[x][y] == 1 && path[x][y] !=1)
        return true; // Valid cell.
    else
        return false;
}

// Maze solutions. Checks for proper cell. finds proper path 
// By going LEFT,RIGHT,UP or DOWN
int maze_soln(int soln[N][N], int m[N][N],int x,int y,int path[N][N])
{
    //All the cells have been visited
    if (x == N - 1 && y == N - 1)
    {
        soln[x][y] = 1; //mark the cell as possible path
        return true;
    }

    // Find out different paths
    if (issafe(m, x, y,path) == true)
    {
        soln[x][y] = 1; // mark the cell as possible solution
        path[x][y] = 1; //mark the path as visited

        // Go RIGHT and see if there's a path
        if (maze_soln(soln, m, x, y + 1,path))
            return true;

        //LEFT
        if (y> 0 && maze_soln(soln, m, x, y-1,path))
            return true;

        //DOWN
        if (maze_soln(soln, m, x + 1, y,path))
            return true;

        //UP
        if (x>0 && maze_soln(soln, m, x - 1, y,path))
            return true;

        soln[x][y] = 0;
        return false;
    }
    return false;
}

// Prints the solution matrix if proper path is found
void maze(int m[N][N])
{
    int i, j;
    int soln[N][N] = { 0 };
    int path[N][N] = { 0 };
    if (maze_soln(soln, m, 0, 0,path) == true)
    {
        printf("\n Solution\n"); //Print solution matrix
        for (i = 0; i < N; i++)
        {
            for (j = 0; j < N; j++)
            {
                printf("\t%d", soln[i][j]);
            }
            printf("\n");
        }
    }

    return;
}

// Main function
int main()
{
    int i, j;
    //Maze matrix
    int m[N][N] = { { 1,1,1,0,0 },
                    { 1,1,0,1,0 },
                    { 0,1,0,1,1 },
                    { 1,1,1,1,1 },
                    { 1,0,0,1,1 } };

    //Print the Maze
    printf("MAZE\n");
    for (i = 0; i < N; i++)
    {
        for (j = 0; j < N; j++)
        {
            printf("\t%d", m[i][j]);
        }
        printf("\n");
    }

    //Call maze function to find out the path
    // and print the solution matrix
    maze(m);
    _getch();
}

Answer 1

当您找到第一个解决方案时，您会提前返回。如果您想了解更多解决方案，您必须继续前进并探索所有路径。而不是真值，核心功能现在返回解决方案的数量。

当然，您必须在找到解决方案时存储解决方案，以便以后可以打印。这可能非常耗费内存，因为在稀疏的迷宫中可能存在许多可能的解决方案。你也不知道有多少解决方案。

因此，一个简单的替代方案是在找到当前解决方案后打印它。

与您的问题无关，但您并不需要三个独立的阵列。当您添加另一个可能的值，访问空间时，您可以使用原始的墙和空间数组。此值充当面包屑，告诉您已经存在的位置。有效的下一步只能是未访问的空间。

将此付诸实践，例如：

#include <stdio.h>

#define N 5

int issafe(int m[N][N], int x, int y)
{
    if (x < 0 || x >= N) return 0;
    if (y < 0 || y >= N) return 0;

    return (m[x][y] == 1);
}

void print(int m[N][N])
{
    static const char *glyph = "#.*";
    static int nsol = 0;
    int i, j;

    printf("Solution %d\n\n", ++nsol);

    for (i = 0; i < N; i++) {
        for (j = 0; j < N; j++) {
            putchar(glyph[m[i][j]]);
        }
        putchar('\n');
    }
    putchar('\n');
}

int maze(int m[N][N], int x, int y)
{
    int nsol = 0;

    if (issafe(m, x, y)) {
        m[x][y] = 2;

        if (x == N - 1 && y == N - 1) {
            print(m);
            nsol = 1;
        } else {
            nsol += maze(m, x, y + 1);
            nsol += maze(m, x, y - 1);
            nsol += maze(m, x + 1, y);
            nsol += maze(m, x - 1, y);
        }

        m[x][y] = 1;
    }

    return nsol;
}

int main()
{
    int m[N][N] = { 
        { 1, 1, 1, 0, 0 },
        { 1, 1, 0, 1, 0 },
        { 0, 1, 0, 1, 1 },
        { 1, 1, 1, 1, 1 },
        { 1, 0, 0, 1, 1 } 
    };
    int nsol;

    nsol = maze(m, 0, 0);
    printf("%d solutions.\n", nsol);

    return 0;
}

迷宫拼图中大鼠的解决方案数量

1 个答案: