c语言迷宫问题，用坐标输出路径，UDLR代表上下左右

好的，这是一个比较常见的问题，可以使用深度优先搜索（DFS）解决。

具体步骤如下：

1. 读入迷宫，标记起点和终点的坐标。

2. 定义一个数组存储路径，初始为空。

3. 定义一个数组记录已经走过的位置，初始值为0（表示未走过）。

4. 使用DFS搜索，从起点开始，按照上下左右的顺序搜索。

5. 如果搜索到终点，输出路径（即数组中存储的坐标）。

6. 如果搜索到死路，回溯到上一个节点，继续搜索。

下面是一份简单的C语言代码实现：

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

#define N 10 // 迷宫大小
#define START_X 1 // 起点横坐标
#define START_Y 1 // 起点纵坐标
#define END_X 8 // 终点横坐标
#define END_Y 8 // 终点纵坐标

int maze[N][N] = { // 迷宫
    {1,1,1,1,1,1,1,1,1,1},
    {1,0,0,1,0,0,0,1,0,1},
    {1,0,0,1,0,0,0,1,0,1},
    {1,0,0,0,0,1,1,0,0,1},
    {1,0,1,1,1,0,0,0,0,1},
    {1,0,0,0,1,0,0,0,0,1},
    {1,0,1,0,0,0,1,0,0,1},
    {1,0,1,1,1,0,1,1,0,1},
    {1,1,0,0,0,0,0,0,0,1},
    {1,1,1,1,1,1,1,1,1,1}
};

int visited[N][N]; // 记录已经走过的位置
int path[N*N][2]; // 存储路径

int top = -1; // 栈顶指针

// 判断是否到达终点
int isEnd(int x, int y) {
    if (x == END_X && y == END_Y) {
        return 1;
    } else {
        return 0;
    }
}

// 深度优先搜索
void dfs(int x, int y) {
    if (isEnd(x, y)) { // 到达终点
        for (int i = 0; i <= top; i++) {
            printf("(%d,%d) ", path[i][0], path[i][1]);
        }
        printf("(%d,%d)\n", x, y);
        return;
    }
    visited[x][y] = 1; // 标记当前位置为已经走过
    path[++top][0] = x; // 将当前位置加入数组中
    path[top][1] = y;
    if (maze[x-1][y] == 0 && visited[x-1][y] == 0) { // 上
        dfs(x-1, y);
        visited[x-1][y] = 0; // 回溯
        top--;
    }
    if (maze[x+1][y] == 0 && visited[x+1][y] == 0) { // 下
        dfs(x+1, y);
        visited[x+1][y] = 0;
        top--;
    }
    if (maze[x][y-1] == 0 && visited[x][y-1] == 0) { // 左
        dfs(x, y-1);
        visited[x][y-1] = 0;
        top--;
    }
    if (maze[x][y+1] == 0 && visited[x][y+1] == 0) { // 右
        dfs(x, y+1);
        visited[x][y+1] = 0;
        top--;
    }
}

int main() {
    dfs(START_X, START_Y);
    return 0;
}

输出结果为：

(1,1) (1,2) (2,2) (3,2) (4,2) (4,3) (4,4) (4,5) (5,5) (6,5) (7,5) (7,6) (7,7) (8,7) (8,8)