用c语言写一篇迷宫寻路的代码，记录最短路径

以下是一个简单的迷宫寻路的代码，使用了广度优先搜索算法来寻找最短路径：

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

#define MAX_ROW 100
#define MAX_COL 100

typedef struct {
    int row, col;
} Point;

Point queue[MAX_ROW * MAX_COL];
int visited[MAX_ROW][MAX_COL];
int pre[MAX_ROW][MAX_COL];
Point path[MAX_ROW * MAX_COL];
int front, rear;

int maze[MAX_ROW][MAX_COL] = {
    {0, 1, 0, 0, 0},
    {0, 1, 0, 1, 0},
    {0, 0, 0, 0, 0},
    {0, 1, 1, 1, 0},
    {0, 0, 0, 1, 0}
};

int rows = 5, cols = 5;

void print_path(int r, int c) {
    int i = 0;
    while (pre[r][c] != -1) {
        path[i].row = r;
        path[i].col = c;
        i++;
        int t = pre[r][c];
        r = queue[t].row;
        c = queue[t].col;
    }
    path[i].row = r;
    path[i].col = c;
    i++;
    for (int j = i - 1; j >= 0; j--) {
        printf("(%d,%d)", path[j].row, path[j].col);
        if (j > 0) printf("->");
    }
    printf("\n");
}

void bfs(int start_r, int start_c, int end_r, int end_c) {
    memset(visited, 0, sizeof(visited));
    memset(pre, -1, sizeof(pre));
    front = rear = 0;
    Point p = {start_r, start_c};
    queue[rear++] = p;
    visited[start_r][start_c] = 1;
    while (front < rear) {
        Point cur = queue[front++];
        if (cur.row == end_r && cur.col == end_c) {
            print_path(cur.row, cur.col);
            return;
        }
        if (cur.row > 0 && maze[cur.row - 1][cur.col] == 0 && !visited[cur.row - 1][cur.col]) {
            Point newp = {cur.row - 1, cur.col};
            queue[rear++] = newp;
            visited[cur.row - 1][cur.col] = 1;
            pre[cur.row - 1][cur.col] = front - 1;
        }
        if (cur.row < rows - 1 && maze[cur.row + 1][cur.col] == 0 && !visited[cur.row + 1][cur.col]) {
            Point newp = {cur.row + 1, cur.col};
            queue[rear++] = newp;
            visited[cur.row + 1][cur.col] = 1;
            pre[cur.row + 1][cur.col] = front - 1;
        }
        if (cur.col > 0 && maze[cur.row][cur.col - 1] == 0 && !visited[cur.row][cur.col - 1]) {
            Point newp = {cur.row, cur.col - 1};
            queue[rear++] = newp;
            visited[cur.row][cur.col - 1] = 1;
            pre[cur.row][cur.col - 1] = front - 1;
        }
        if (cur.col < cols - 1 && maze[cur.row][cur.col + 1] == 0 && !visited[cur.row][cur.col + 1]) {
            Point newp = {cur.row, cur.col + 1};
            queue[rear++] = newp;
            visited[cur.row][cur.col + 1] = 1;
            pre[cur.row][cur.col + 1] = front - 1;
        }
    }
}

int main() {
    bfs(0, 0, 4, 4);
    return 0;
}

这个代码中，我们使用了一个 `maze` 数组来存储迷宫，其中 `0` 表示可以通过的路，`1` 表示障碍物。我们从起点 `(0, 0)` 开始，使用广度优先搜索算法寻找到终点 `(4, 4)` 的最短路径，并将路径打印出来。

在搜索过程中，我们使用了一个队列来存储待搜索的点，使用 `visited` 数组来标记某个点是否已经被访问过，并使用 `pre` 数组来记录某个点在搜索树中的父节点。最后，我们使用 `print_path` 函数来打印路径，该函数从终点开始，依次沿着父节点找到起点，将路径存储在 `path` 数组中，最后再反向打印出来。