求一份C语言迷宫问题的代码

输入迷宫1代表墙，0代表路，最终用路径RULD（右上左下）输出，起点为一排一个，重点为最后一排最后一个（固定），真的不会了，帮下我吧😭

这个简单的可以直接搜索，引自csdn：https://blog.csdn.net/weixin_45629315/article/details/105045621
除了限定了迷宫的值，其他并没更改，有问题可以问

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

#define m 6
#define n 8
#define STACK_INIT_SIZE 100

typedef struct {
    int x, y;
} SElemType;

typedef struct {
    SElemType stack[STACK_INIT_SIZE];
    int top;
} SqStack;

typedef struct {
    int x, y;
} Item;

int maze[m + 2][n + 2] =
{
      /*0,1,2,3,4,5,6,7,8,9*/
/*0*/  {1, 1, 1, 1, 1, 1, 1, 1, 1, 1},
/*1*/  {1, 0, 1, 1, 1, 0, 1, 1, 1, 1},
/*2*/  {1, 1, 0, 1, 0, 1, 1, 1, 1, 1},
/*3*/  {1, 0, 1, 0, 0, 0, 0, 0, 1, 1},
/*4*/  {1, 0, 1, 1, 1, 0, 1, 1, 1, 1},
/*5*/  {1, 1, 0, 0, 1, 1, 0, 0, 0, 1},
/*6*/  {1, 0, 1, 1, 0, 0, 1, 1, 0, 1},
/*7*/  {1, 1, 1, 1, 1, 1, 1, 1, 1, 1},
};
int t[m + 2][n + 2] = { 0 };
Item Move[8] =
{
    {0, 1}, {1, 1}, {1, 0}, {1, -1},
    {0, -1}, {-1, -1}, {-1, 0}, {-1, 1}
};

int sum = 0;

void Print(int sum, SqStack a) {
    int i;
    printf("迷宫的第%d条路径如下:\\n", sum);
    for (i = 0; i <= a.top; i++)
        printf("(%d,%d)->", a.stack[i].x, a.stack[i].y);
    printf("出口\\n\\n");
    printf("\\n");
}

void Push_SqStack(SqStack* s, SElemType x) {
    if (s->top == STACK_INIT_SIZE - 1)
        printf("\\n栈满!");
    else {
        s->top++;
        s->stack[s->top] = x;
    }
}

int Empty_SqStack(SqStack* s) {
    if (s->top == -1)
        return 1;
    else
        return 0;
}

void Pop_SqStack(SqStack* s) {
    if (Empty_SqStack(s)) {
        printf("\\n栈空!");
        exit(0);
    }
    else {
        s->top--;
    }
}

void path(int x, int y, SqStack elem) {
    int i, a, b;
    SElemType temp;

    if (x == 6 && y == 8) {
        sum++;
        Print(sum, elem);
    }
    else {
        for (i = 0; i < 8; i++) {
            a = x + Move[i].x;
            b = y + Move[i].y;
            if (!maze[a][b] && !t[a][b]) {
                temp.x = a; temp.y = b;
                t[a][b] = maze[a][b] = 1;
                Push_SqStack(&elem, temp);
                path(a, b, elem);
                t[a][b] = maze[a][b] = 0;
                Pop_SqStack(&elem);
            }
        }
    }
}

int main() {
    SqStack* s;
    s = (SqStack*)malloc(sizeof(SqStack));
    s->stack[0].x = 1;
    s->stack[0].y = 1;
    s->top = 0;
    t[1][1] = maze[1][1] = 1;
    path(1, 1, *s);
    free(s);
    return 0;
}

该回答引用chatgpt:仅供参考

#include <stdio.h>

#define MAX_SIZE 100

int maze[MAX_SIZE][MAX_SIZE];  // 迷宫数组
int visited[MAX_SIZE][MAX_SIZE];  // 记录访问过的位置
int path[MAX_SIZE * MAX_SIZE];  // 记录路径
int pathLength = 0;  // 路径长度

int rows, cols;  // 迷宫的行数和列数
int startRow = 0, startCol = 0;  // 起点的位置

// 深度优先搜索函数
int dfs(int row, int col) {
    // 如果到达终点，返回成功
    if (row == rows - 1 && col == cols - 1) {
        path[pathLength++] = 'R';  // 终点无需移动，直接加入路径
        return 1;
    }

    // 如果当前位置是墙或者已经访问过，返回失败
    if (maze[row][col] == 1 || visited[row][col])
        return 0;

    visited[row][col] = 1;  // 标记当前位置为已访问

    // 尝试向右移动
    if (col < cols - 1 && dfs(row, col + 1)) {
        path[pathLength++] = 'R';  // 添加向右移动的路径
        return 1;
    }
    // 尝试向上移动
    if (row > 0 && dfs(row - 1, col)) {
        path[pathLength++] = 'U';  // 添加向上移动的路径
        return 1;
    }
    // 尝试向左移动
    if (col > 0 && dfs(row, col - 1)) {
        path[pathLength++] = 'L';  // 添加向左移动的路径
        return 1;
    }
    // 尝试向下移动
    if (row < rows - 1 && dfs(row + 1, col)) {
        path[pathLength++] = 'D';  // 添加向下移动的路径
        return 1;
    }

    // 如果四个方向都不能移动，则返回失败
    return 0;
}

int main() {
    printf("请输入迷宫的行数和列数（以空格分隔）：");
    scanf("%d %d", &rows, &cols);

    printf("请输入迷宫的数据（0代表路，1代表墙）：\n");
    for (int i = 0; i < rows; i++) {
        for (int j = 0; j < cols; j++) {
            scanf("%d", &maze[i][j]);
        }
    }

    printf("正在寻找路径...\n");

    // 调用深度优先搜索函数，从起点开始搜索
    if (dfs(startRow, startCol)) {
        printf("找到一条路径：");
        for (int i = pathLength - 1; i >= 0; i--) {
            printf("%c", path[i]);
        }
        printf("\n");
    } else {
        printf("未找到路径。\n");
    }

    return 0;
}