写一个c语言程序 输入一个5乘5的迷宫 1为可通行的地方0为障碍求迷宫左上角到右下角的最短路径

以下是一个基于广度优先搜索（BFS）的 C 语言程序，可以求解给定的 5x5 迷宫中左上角到右下角的最短路径。程序假设迷宫由 0 和 1 组成，其中 0 表示障碍，1 表示可通行的地方。

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

#define ROWS 5
#define COLS 5

// 定义迷宫类型，包含行数、列数和二维数组表示的迷宫
typedef struct {
    int rows;
    int cols;
    int maze[ROWS][COLS];
} Maze;

// 定义坐标类型，包含 x 和 y 坐标
typedef struct {
    int x;
    int y;
} Coord;

// 定义队列类型，用于广度优先搜索
typedef struct {
    Coord data[ROWS * COLS];
    int front;
    int rear;
} Queue;

// 初始化队列
void initQueue(Queue *q) {
    q->front = 0;
    q->rear = -1;
}

// 插入元素到队列尾部
void enqueue(Queue *q, Coord c) {
    q->data[++q->rear] = c;
}

// 删除队列头部元素
Coord dequeue(Queue *q) {
    return q->data[q->front++];
}

// 检查队列是否为空
bool isQueueEmpty(Queue *q) {
    return q->front > q->rear;
}

// 判断坐标是否在迷宫范围内
bool isCoordValid(Maze *maze, Coord c) {
    return c.x >= 0 && c.x < maze->cols && c.y >= 0 && c.y < maze->rows;
}

// 判断坐标是否为可通行的地方
bool isCoordPassable(Maze *maze, Coord c) {
    return maze->maze[c.y][c.x] == 1;
}

// 广度优先搜索，返回左上角到右下角的最短路径长度
int bfs(Maze *maze) {
    int dist[ROWS][COLS]; // 记录每个格子到起点的距离
    Coord prev[ROWS][COLS]; // 记录每个格子的前驱格子
    Queue q;
    Coord start = {0, 0}; // 起点坐标
    Coord end = {maze->cols - 1, maze->rows - 1}; // 终点坐标
    Coord dirs[4] = {{1, 0}, {-1, 0}, {0, 1}, {0, -1}}; // 四个方向
    int i, j;

    // 初始化距离和前驱
    for (i = 0; i < maze->rows; i++) {
        for (j = 0; j < maze->cols; j++) {
            dist[i][j] = -1;
            prev[i][j] = (Coord) {-1, -1};
        }
    }

    // 从起点开始搜索
    initQueue(&q);
    enqueue(&q, start);
    dist[start.y][start.x] = 0;

    // 广度优先搜索
    while (!isQueueEmpty(&q)) {
        Coord curr = dequeue(&q);

        // 如果到达终点，则停止搜索
        if (curr.x == end.x && curr.y == end.y)
            break;

        // 搜索四个方向
        for (i = 0; i < 4; i++) {
            Coord next = {curr.x + dirs[i].x, curr.y + dirs[i].y};

            // 如果下一个坐标在迷宫范围内且为可通行的地方，并且没有被访问过，则进行搜索
            if (isCoordValid(maze, next) && isCoordPassable(maze, next) && dist[next.y][next.x] == -1) {
                dist[next.y][next.x] = dist[curr.y][curr.x] + 1;
                prev[next.y][next.x] = curr;
                enqueue(&q, next);
            }
        }
    }

    // 返回左上角到右下角的最短路径长度
    return dist[end.y][end.x];
}

int main() {
    int i, j;
    Maze maze;

    // 输入迷宫
    printf("请输入迷宫（0 表示障碍，1 表示可通行的地方）：\n");
    for (i = 0; i < ROWS; i++) {
        for (j = 0; j < COLS; j++) {
            scanf("%d", &maze.maze[i][j]);
        }
    }
    maze.rows = ROWS;
    maze.cols = COLS;

    // 求解迷宫左上角到右下角的最短路径长度
    printf("迷宫左上角到右下角的最短路径长度为：%d\n", bfs(&maze));

    return 0;
}

注意：该程序假设输入的迷宫是一个 5x5 的矩阵，若要处理其他规模的迷宫，需要相应修改常量 `ROWS` 和 `COLS` 的值，并输入相应规模的迷宫。