目的：深入掌握图便利算法在求解实际问题中的应用。 内容：使用图搜索方法求解迷宫问题编写C语言程序，完成以下功能。 ①建立一个迷宫对应的邻接表表示。 ②采用深度优先遍历算法输出从入口（1，1）到出口（M，N）的所有迷宫路径，其中 0 表示通路，1 表示墙壁。

好的，我可以帮你编写一个C语言程序，用图搜索方法求解迷宫问题。以下是一个实现示例：

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

#define MAX_ROW 20
#define MAX_COL 20

typedef struct {
    int row;
    int col;
} Position;

typedef struct Node {
    Position pos;
    struct Node *next;
} Node;

typedef struct {
    int row;
    int col;
    Node *first;
} Graph[MAX_ROW][MAX_COL];

void add_edge(Graph g, Position u, Position v) {
    Node *node = (Node *)malloc(sizeof(Node));
    node->pos = v;
    node->next = g[u.row][u.col].first;
    g[u.row][u.col].first = node;
}

void dfs(Graph g, int visited[MAX_ROW][MAX_COL], Position start, Position end, Position path[], int len) {
    if (start.row == end.row && start.col == end.col) {
        for (int i = 0; i < len; i++) {
            printf("(%d,%d) ", path[i].row, path[i].col);
        }
        printf("(%d,%d)\n", end.row, end.col);
        return;
    }
    visited[start.row][start.col] = 1;
    path[len] = start;
    len++;
    for (Node *p = g[start.row][start.col].first; p != NULL; p = p->next) {
        Position next = p->pos;
        if (!visited[next.row][next.col]) {
            dfs(g, visited, next, end, path, len);
        }
    }
    visited[start.row][start.col] = 0;
}

int main() {
    int row, col;
    scanf("%d%d", &row, &col);
    Graph g;
    int maze[MAX_ROW][MAX_COL];
    for (int i = 0; i < row; i++) {
        for (int j = 0; j < col; j++) {
            scanf("%d", &maze[i][j]);
            g[i][j].row = i;
            g[i][j].col = j;
            g[i][j].first = NULL;
        }
    }
    for (int i = 0; i < row; i++) {
        for (int j = 0; j < col; j++) {
            if (maze[i][j] == 0) {
                if (i - 1 >= 0 && maze[i - 1][j] == 0) {
                    add_edge(g, (Position){i, j}, (Position){i - 1, j});
                }
                if (i + 1 < row && maze[i + 1][j] == 0) {
                    add_edge(g, (Position){i, j}, (Position){i + 1, j});
                }
                if (j - 1 >= 0 && maze[i][j - 1] == 0) {
                    add_edge(g, (Position){i, j}, (Position){i, j - 1});
                }
                if (j + 1 < col && maze[i][j + 1] == 0) {
                    add_edge(g, (Position){i, j}, (Position){i, j + 1});
                }
            }
        }
    }
    int visited[MAX_ROW][MAX_COL] = {0};
    Position path[MAX_ROW * MAX_COL];
    dfs(g, visited, (Position){0, 0}, (Position){row - 1, col - 1}, path, 0);
    return 0;
}

在这个程序中，我们用一个二维数组 `maze` 存储迷宫的信息，0 表示通路，1 表示墙壁。我们用一个邻接表 `g` 来表示迷宫的图形结构，其中顶点对应迷宫中的每个位置，边表示相邻两个通路之间的连通关系。

我们采用深度优先遍历算法来搜索从入口到出口的所有路径。在搜索过程中，我们用一个二维数组 `visited` 记录每个顶点是否已经被访问过，用一个数组 `path` 记录搜索到当前位置的路径。当搜索到出口时，我们输出 `path` 数组中的所有位置，以得到一条从入口到出口的路径。

这个程序只是一个简单的实现示例，可能还有很多可以优化的地方。但我希望这个程序可以帮助你更深入地理解图便利算法在实际问题中的应用。