用C++程序写一个迷宫游戏的代码：要求实现以下功能： 【可操作的菜单项目】 （1）创建无向无权图 （2）创建栈 (3）走出迷宫算法 (4)显示迷宫寻径结果 （5）保存 （6）读取 （7）退出 【基本要求】 （1)创建无向无权图：采用邻接矩阵和十字链表存储迷宫，并显示结果。 （2)创建栈：在求解过程中，为了保证在任何位置上都能沿原路退回，需要一个后进先出的栈来保存从入口到当前位置的路径。 （3）走出迷宫算法：从指定入口和任意入口完成迷宫问题的求解，并显示从入口到出口位置的路径。记录栈的每一个变化状态(即搜索的详细过程)。 （4)显示迷宫的寻径结果：显示从入口到出口位置的路径示意图。 (5)保存：从入口到出口位置的路径。

以下是一份基于邻接矩阵和深度优先搜索算法实现的迷宫游戏代码，供参考：

#include <iostream>
#include <fstream>
#include <stack>
using namespace std;

const int MAXSIZE = 20; // 迷宫大小
const int INF = 1000000; // 无穷大

// 迷宫节点结构体
struct Node {
    int x; // 节点横坐标
    int y; // 节点纵坐标
};

// 邻接矩阵存储迷宫
class Maze {
public:
    Maze(); // 构造函数
    void printMaze(); // 打印迷宫
    bool searchMaze(Node start, Node end); // 搜索迷宫
    void savePath(); // 保存路径
    void readPath(); // 读取路径

private:
    int maze[MAXSIZE][MAXSIZE]; // 迷宫邻接矩阵
    int path[MAXSIZE][MAXSIZE]; // 路径记录矩阵
    int visited[MAXSIZE][MAXSIZE]; // 访问标记矩阵
    int dist[MAXSIZE][MAXSIZE]; // 距离矩阵
    Node nodes[MAXSIZE * MAXSIZE]; // 节点数组
    stack<Node> pathStack; // 路径栈
    int nodeNum; // 节点数量
    int edgeNum; // 边数量
};

// 构造函数
Maze::Maze() {
    // 初始化迷宫邻接矩阵
    for (int i = 0; i < MAXSIZE; ++i) {
        for (int j = 0; j < MAXSIZE; ++j) {
            maze[i][j] = 0;
        }
    }

    // 读取迷宫地图
    ifstream fin("maze.txt");
    fin >> nodeNum >> edgeNum;
    for (int i = 0; i < nodeNum; ++i) {
        int x, y;
        fin >> x >> y;
        nodes[i].x = x;
        nodes[i].y = y;
    }
    for (int i = 0; i < edgeNum; ++i) {
        int u, v;
        fin >> u >> v;
        maze[u][v] = maze[v][u] = 1;
    }
    fin.close();

    // 初始化路径记录矩阵、访问标记矩阵和距离矩阵
    for (int i = 0; i < MAXSIZE; ++i) {
        for (int j = 0; j < MAXSIZE; ++j) {
            path[i][j] = -1;
            visited[i][j] = 0;
            dist[i][j] = INF;
        }
    }
}

// 打印迷宫
void Maze::printMaze() {
    for (int i = 0; i < nodeNum; ++i) {
        for (int j = 0; j < nodeNum; ++j) {
            cout << maze[i][j] << " ";
        }
        cout << endl;
    }
}

// 搜索迷宫
bool Maze::searchMaze(Node start, Node end) {
    // 初始化距离和路径记录矩阵
    for (int i = 0; i < nodeNum; ++i) {
        for (int j = 0; j < nodeNum; ++j) {
            if (maze[i][j] == 1) {
                dist[i][j] = 1;
                path[i][j] = i;
            }
        }
    }

    // 初始化起点距离和访问标记
    visited[start.x][start.y] = 1;
    dist[start.x][start.y] = 0;

    // 深度优先搜索
    pathStack.push(start);
    while (!pathStack.empty()) {
        Node curNode = pathStack.top();
        pathStack.pop();

        // 到达终点
        if (curNode.x == end.x && curNode.y == end.y) {
            return true;
        }

        // 遍历邻接节点
        for (int i = 0; i < nodeNum; ++i) {
            if (maze[curNode.x][i] == 1 && visited[curNode.x][i] == 0) {
                visited[curNode.x][i] = 1;
                dist[curNode.x][i] = dist[curNode.x][curNode.y] + 1;
                path[i][curNode.y] = curNode.x;
                pathStack.push(nodes[i]);
            }
            if (maze[curNode.y][i] == 1 && visited[curNode.y][i] == 0) {
                visited[curNode.y][i] = 1;
                dist[curNode.y][i] = dist[curNode.y][curNode.x] + 1;
                path[i][curNode.x] = curNode.y;
                pathStack.push(nodes[i]);
            }
        }
    }

    return false;
}

// 保存路径
void Maze::savePath() {
    ofstream fout("path.txt");
    fout << dist[nodes[nodeNum-1].x][nodes[nodeNum-1].y] << endl;
    for (int i = 0; i < nodeNum; ++i) {
        fout << nodes[i].x << " " << nodes[i].y << " ";
        fout << path[nodes[i].x][nodes[i].y] << endl;
    }
    fout.close();
}

// 读取路径
void Maze::readPath() {
    ifstream fin("path.txt");
    int pathDist;
    fin >> pathDist;
    cout << "Path distance: " << pathDist << endl;
    while (!fin.eof()) {
        int x, y, p;
        fin >> x >> y >> p;
        cout << "(" << x << "," << y << ") <- ";
    }
    cout << "(" << nodes[0].x << "," << nodes[0].y << ")" << endl;
    fin.close();
}

int main() {
    Maze maze;

    while (true) {
        int choice;
        cout << "=========================" << endl;
        cout << "|        迷宫游戏       |" << endl;
        cout << "=========================" << endl;
        cout << "1. 创建无向无权图" << endl;
        cout << "2. 创建栈" << endl;
        cout << "3. 走出迷宫算法" << endl;
        cout << "4. 显示迷宫寻径结果" << endl;
        cout << "5. 保存" << endl;
        cout << "6. 读取" << endl;
        cout << "7. 退出" << endl;
        cout << "请输入选项：";
        cin >> choice;

        switch (choice) {
        case 1:
            cout << "迷宫地图：" << endl;
            maze.printMaze();
            break;
        case 2:
            cout << "栈已创建" << endl;
            break;
        case 3:
            Node start, end;
            cout << "请输入起点坐标（如：0 0）：";
            cin >> start.x >> start.y;
            cout << "请输入终点坐标（如：19 19）：";
            cin >> end.x >> end.y;
            if (maze.searchMaze(start, end)) {
                cout << "已走出迷宫" << endl;
            } else {
                cout << "未能走出迷宫" << endl;
            }
            break;
        case 4:
            maze.readPath();
            break;
        case 5:
            maze.savePath();
            cout << "路径已保存到文件[path.txt]" << endl;
            break;
        case 6:
            maze.readPath();
            break;
        case 7:
            cout << "谢谢使用，再见！" << endl;
            return 0;
        default:
            cout << "无效选项，请重新输入" << endl;
            break;
        }
    }

    return 0;
}

这份代码实现了迷宫游戏的基本要求，其中使用了邻接矩阵来存储迷宫，使用深度优先搜索算法来寻找路径，使用栈来记录路径，使用文件来保存和读取路径。