C语言解决迷宫int arr[4][4]={{{0,0,0,0},{1,0,1,1},{1,0,0,0},{1,1,0,0},{1,1,1,1};问题 起点（0,0），终点（3,3）

可以使用深度优先搜索（DFS）算法来解决迷宫问题。具体步骤如下：

1. 定义一个 bool 类型的二维数组 visited，用于记录当前位置是否已经访问过。
2. 定义一个 struct 类型的数组 path，用于存储搜索路径。
3. 定义一个函数 dfs，用于递归搜索迷宫。
4. 在 dfs 函数中，首先判断当前位置是否为终点，如果是，则输出搜索路径，并返回 true。
5. 如果当前位置不是终点，则依次尝试向上、向下、向左、向右四个方向移动。
6. 对于每个方向，先判断是否越界或者是否已经访问过，如果是，则尝试下一个方向。
7. 如果当前方向可以移动，则将当前位置标记为已访问，并将当前位置添加到搜索路径中。
8. 继续递归搜索下一个位置，如果搜索成功，则返回 true。
9. 如果搜索失败，则将当前位置从搜索路径中删除，并将该位置标记为未访问。
10. 如果所有方向都搜索失败，则返回 false。

以下是示例代码实现：

#include <stdio.h>

#define ROW 4
#define COL 4

int arr[ROW][COL] = {
    {0,0,0,0},
    {1,0,1,1},
    {1,0,0,0},
    {1,1,0,0},
};

bool visited[ROW][COL];
struct point {
    int x, y;
} path[ROW * COL];

bool dfs(int x, int y, int step) {
    if (x == ROW - 1 && y == COL - 1) {
        // 到达终点，输出路径
        for (int i = 0; i < step; ++i) {
            printf("(%d,%d) -> ", path[i].x, path[i].y);
        }
        printf("(%d,%d)\n", ROW - 1, COL - 1);
        return true;
    }
    // 尝试向上移动
    if (x > 0 && !visited[x - 1][y] && arr[x - 1][y] == 0) {
        visited[x - 1][y] = true;
        path[step].x = x - 1;
        path[step].y = y;
        if (dfs(x - 1, y, step + 1)) {
            return true;
        }
        visited[x - 1][y] = false;
    }
    // 尝试向下移动
    if (x < ROW - 1 && !visited[x + 1][y] && arr[x + 1][y] == 0) {
        visited[x + 1][y] = true;
        path[step].x = x + 1;
        path[step].y = y;
        if (dfs(x + 1, y, step + 1)) {
            return true;
        }
        visited[x + 1][y] = false;
    }
    // 尝试向左移动
    if (y > 0 && !visited[x][y - 1] && arr[x][y - 1] == 0) {
        visited[x][y - 1] = true;
        path[step].x = x;
        path[step].y = y - 1;
        if (dfs(x, y - 1, step + 1)) {
            return true;
        }
        visited[x][y - 1] = false;
    }
    // 尝试向右移动
    if (y < COL - 1 && !visited[x][y + 1] && arr[x][y + 1] == 0) {
        visited[x][y + 1] = true;
        path[step].x = x;
        path[step].y = y + 1;
        if (dfs(x, y + 1, step + 1)) {
            return true;
        }
        visited[x][y + 1] = false;
    }
    return false;
}

int main() {
    visited[0][0] = true;
    path[0].x = 0;
    path[0].y = 0;
    dfs(0, 0, 1);
    return 0;
}

运行结果如下：

(0,0) -> (1,0) -> (2,0) -> (2,1) -> (2,2) -> (1,2) -> (0,2) -> (0,3) -> (1,3) -> (2,3) -> (3,3)