C语言解决迷宫问题的完整代码（带注释），要求迷宫大小由用户输入，最后输出路径数量与最短路径

以下是使用C语言解决迷宫问题的完整代码，包含注释和用户输入迷宫大小的功能。

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

#define MAX_ROW 10
#define MAX_COL 10

// 定义迷宫结构体
typedef struct{
    int row;
    int col;
}Point;

// 定义栈结构体
typedef struct{
    Point data[MAX_ROW * MAX_COL];
    int top;
}Stack;

// 初始化栈
void initStack(Stack *s){
    s->top = -1;
}

// 判断栈是否为空
int isEmptyStack(Stack *s){
    return s->top == -1;
}

// 入栈
void push(Stack *s, Point p){
    s->data[++s->top] = p;
}

// 出栈
Point pop(Stack *s){
    return s->data[s->top--];
}

// 获取栈顶元素
Point getTop(Stack *s){
    return s->data[s->top];
}

// 判断当前点是否为起点或终点
int isEntry(Point p, Point entry, Point exit){
    return (p.row == entry.row && p.col == entry.col) || (p.row == exit.row && p.col == exit.col);
}

// 判断当前点是否为墙
int isWall(int maze[][MAX_COL], Point p){
    return maze[p.row][p.col] == 1;
}

// 判断当前点是否已经走过
int isVisited(int mark[][MAX_COL], Point p){
    return mark[p.row][p.col] == 1;
}

// 获取当前点的下一个点
Point getNext(Point p, int direction){
    Point next = p;
    switch(direction){
        case 0:
            next.row--;
            break;
        case 1:
            next.col++;
            break;
        case 2:
            next.row++;
            break;
        case 3:
            next.col--;
            break;
    }
    return next;
}

// 搜索迷宫
void mazePath(int maze[][MAX_COL], int mark[][MAX_COL], Point entry, Point exit, Stack *s, int *pathCount, int *minStep){
    Point cur = entry;
    mark[cur.row][cur.col] = 1;
    push(s, cur);
    while(!isEmptyStack(s)){
        cur = getTop(s);
        if(cur.row == exit.row && cur.col == exit.col){
            // 到达终点
            *pathCount += 1;
            if(*minStep == 0 || s->top + 1 < *minStep){
                *minStep = s->top + 1;
            }
            Point temp = pop(s);
            mark[temp.row][temp.col] = 0;
            while(!isEmptyStack(s) && !isEntry(temp, entry, exit)){
                temp = pop(s);
                mark[temp.row][temp.col] = 0;
            }
        }else{
            // 继续搜索
            int i, j;
            for(i = cur.row - 1; i <= cur.row + 1; i++){
                for(j = cur.col - 1; j <= cur.col + 1; j++){
                    if((i == cur.row || j == cur.col) && i >= 0 && j >= 0 && i < MAX_ROW && j < MAX_COL && !isWall(maze, (Point){i, j}) && !isVisited(mark, (Point){i, j})){
                        mark[i][j] = 1;
                        push(s, (Point){i, j});
                    }
                }
            }
        }
    }
}

int main(){
    int maze[MAX_ROW][MAX_COL], mark[MAX_ROW][MAX_COL];
    int i, j, pathCount = 0, minStep = 0;
    Point entry, exit;
    Stack s;
    initStack(&s);

    printf("请输入迷宫的行数和列数：");
    scanf("%d %d", &MAX_ROW, &MAX_COL);

    printf("请输入迷宫，0表示可走，1表示墙：\n");
    for(i = 0; i < MAX_ROW; i++){
        for(j = 0; j < MAX_COL; j++){
            scanf("%d", &maze[i][j]);
            mark[i][j] = 0;
        }
    }

    printf("请输入起点坐标：");
    scanf("%d %d", &entry.row, &entry.col);

    printf("请输入终点坐标：");
    scanf("%d %d", &exit.row, &exit.col);

    mazePath(maze, mark, entry, exit, &s, &pathCount, &minStep);

    printf("路径数量：%d\n", pathCount);
    printf("最短路径长度：%d\n", minStep);

    return 0;
}

在这个代码中，使用了栈来实现深度优先搜索，遍历迷宫，寻找从起点到终点的最短路径。用户可以输入迷宫的大小、起点和终点的坐标，程序会输出路径数量和最短路径长度。