Question

我正在编写一个计算从A点到B点的最短路程的程序。我有一个带有值的地图（矩阵）：

0是块（墙，无法通过）;
1是免费的方式（你可以通过）;
2是起点;

在下面的代码中，我声明了2个数组：一个数组“map”，并在运行程序演示访问点时更改了数组“visited”。

我检查4个方向（不是对角线）的单元格为1或0.如果它是1（可能通过），我将计数器增加1.因为不计算前一个单元格我试图避免它条件。我意识到在两个一维数组{1 0 -1 0}和{0,1,0，-1}中检查邻居点（我检查[i + 1] [j]，[i-1]是什么意思[j]，[i] [j + 1]和[i] [j-1]）。

因此，我希望看到“访问”矩阵，其中有几行显示了到达B点的方式（1,2,3，... 15）。我想找到点[7] [7]点的方法。

现在这里的错误是我为前一个位置计算++。如何避免？

谢谢。

P.S。我写了一些函数来实现一个带有0值的新数组，可以自由计算单元格和打印数组。

main.c中：

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

#define WIDTH 8
#define HEIGHT 8

int mapZero(int map[WIDTH][HEIGHT]);
int mapPrint(int map[WIDTH][HEIGHT]);
int mapInit(int map[WIDTH][WIDTH]);
int findFreeToGoCells(int map[WIDTH][HEIGHT]);

int main(int argc, char * argv[])
{
    bool stop;
    unsigned int count;
    unsigned int max;

    int visited[WIDTH][HEIGHT];
    int map[WIDTH][HEIGHT] =
    {
        { 1, 1, 1, 1, 1, 0, 0, 1 },
        { 0, 1, 1, 1, 1, 1, 0, 1 },
        { 0, 0, 1, 0, 1, 1, 1, 0 },
        { 1, 0, 1, 1, 1, 0, 1, 1 },
        { 0, 0, 0, 1, 0, 0, 0, 1 },
        { 1, 0, 1, 1, 1, 0, 0, 1 },
        { 0, 0, 0, 0, 1, 0, 0, 1 },
        { 0, 1, 1, 1, 1, 1, 1, 1 },

    };

    mapZero(visited);
    printf("Matrix of zeroed-visited cells:\n\n");
    mapPrint(visited);
    printf("Matrix of the map:\n\n");
    mapPrint(map);
    printf("Free to go cells: %d\n\n", findFreeToGoCells(map));

    max = WIDTH * HEIGHT - 1;
    visited[0][0] = map[0][0];
    count = 0;
    visited[0][0] = 0;

    int di[4] = { 1, -1, 0, 0 };
    int dj[4] = { 0, 0, 1, -1 };

    //do
    {
        for (int i = 0; i < WIDTH; ++i)
        {
            for (int j = 0; j < HEIGHT; ++j)
            {
                if (visited[i][j] == count)
                {
                    for (int k = 0; k < 4; ++k)
                    {
                        int i_check = i + di[k];
                        int j_check = j + dj[k];

                        if ((i_check >= 0 && i_check < WIDTH) && (j_check >= 0 && j_check < HEIGHT) && (map[i_check][j_check] != 0))
                        {
                            visited[i_check][j_check] = count + 1;
                        }
                    }
                    count++;
                }
            }
        }
    }// while (visited[7][7] == 0);

    if (count > max + 99999) 
        printf("The way couldn't be found\n");
    else
    {
        printf("Matrix of visited cells:\n\n");
        mapPrint(visited);
        printf("Free to go cells from [0][0] to [7][7]: %d\n", findFreeToGoCells(visited));
    }

/*************************************************************************************/
/*************************************************************************************/

    int len;
    int x = 7;
    int y = 7;
    int x_path[WIDTH * HEIGHT];
    int y_path[WIDTH * HEIGHT];

    len = visited[7][7];
    count = len;

    while (count > 0)
    {
        x_path[count] = x;
        y_path[count] = y;            
        count--;
        for (int k = 0; k < 4; ++k)
        {
            int i_check = x + di[k];
            int j_check = y + dj[k];
            if ((i_check >= 0 && i_check < WIDTH) && (j_check >= 0 && j_check < HEIGHT) && (map[i_check][j_check] == count))
            {
                x = x + di[k];
                y = y + dj[k];
                break;
            }
        }
    }
    x_path[0] = 0;
    y_path[0] = 0;
    printf("\nThe shortest way consist of %d cells\nThere are %d the shortest way to reach th the final point\n\n", len, findFreeToGoCells(visited)-len);

    system("pause");
    return 0;
}

int mapZero(int map[WIDTH][HEIGHT])
{
    for (int i = 0; i < WIDTH; ++i)
    {
        for (int j = 0; j < HEIGHT; ++j)
        {
            map[i][j] = 0;
        }
    }
    return 0;
}

int mapPrint(int map[WIDTH][HEIGHT])
{
    for (int i = 0; i < WIDTH; ++i)
    {
        for (int j = 0; j < HEIGHT; ++j)
        {
            printf("%2d  ", map[i][j]);
        }
        printf("\n\n");
    }
    printf("\n");
    return 0;
}

int findFreeToGoCells(int map[WIDTH][HEIGHT])
{
    int count = 0;
    for (int i = 0; i < WIDTH; ++i)
    {
        for (int j = 0; j < HEIGHT; ++j)
        {
            if (map[i][j] != 0) count++;
        }
    }
    return count;
}

结果：

波算法（李的算法）：不正确的最终矩阵

0 个答案: