用户自定义迷宫地图,指定入口和出口,采用图相关算法寻找一条出入口之间最短路径用C++写

好的，我来为您提供一个简单的C++代码，实现用户自定义迷宫地图，指定入口和出口，并采用图相关算法寻找一条出入口之间的最短路径。

首先，您需要定义一个迷宫类，用于存储迷宫地图信息和路径搜索结果。示例代码如下：

#include <iostream>
#include <vector>
#include <queue>
#include <cstring>
using namespace std;

const int MAXN = 1010;
const int INF = 0x3f3f3f3f;

struct Edge {
    int v, w;
    Edge(int v, int w): v(v), w(w) {}
};

class Maze {
private:
    vector<Edge> G[MAXN];
    int dist[MAXN];
    bool vis[MAXN];
    int n, m, s, t;
public:
    void init(int n, int m, int s, int t) {
        this->n = n;
        this->m = m;
        this->s = s;
        this->t = t;
        for (int i = 1; i <= n; i++)
            G[i].clear();
    }
    void addEdge(int u, int v, int w) {
        G[u].push_back(Edge(v, w));
        G[v].push_back(Edge(u, w));
    }
    int bfs() {
        memset(vis, 0, sizeof(vis));
        memset(dist, INF, sizeof(dist));
        queue<int> q;
        q.push(s);
        vis[s] = true;
        dist[s] = 0;
        while (!q.empty()) {
            int u = q.front();
            q.pop();
            for (int i = 0; i < G[u].size(); i++) {
                int v = G[u][i].v;
                int w = G[u][i].w;
                if (!vis[v]) {
                    vis[v] = true;
                    dist[v] = dist[u] + w;
                    q.push(v);
                }
            }
        }
        return dist[t];
    }
};

在这个类中，我们使用了一个邻接表来存储图的信息。其中，`n`表示迷宫的总行数，`m`表示迷宫的总列数，`s`表示起点的编号，`t`表示终点的编号。`addEdge`函数用于添加边，`bfs`函数用于求解最短路径。

接下来，我们需要实现一个函数来读取迷宫地图，并将其转化为图。示例代码如下：

void readMaze(Maze &maze) {
    int n, m;
    cin >> n >> m;
    maze.init(n * m, n * m, 1, n * m);
    int a[n + 1][m + 1];
    memset(a, 0, sizeof(a));
    for (int i = 1; i <= n; i++) {
        for (int j = 1; j <= m; j++) {
            char c;
            cin >> c;
            if (c == '#')
                a[i][j] = -1;
            else if (c == 'S')
                a[i][j] = 1;
            else if (c == 'E')
                a[i][j] = n * m;
            else
                a[i][j] = 0;
        }
    }
    for (int i = 1; i <= n; i++) {
        for (int j = 1; j <= m; j++) {
            if (a[i][j] == -1)
                continue;
            int u = (i - 1) * m + j;
            if (a[i - 1][j] != -1 && i > 1)
                maze.addEdge(u, (i - 2) * m + j, 1);
            if (a[i + 1][j] != -1 && i < n)
                maze.addEdge(u, i * m + j, 1);
            if (a[i][j - 1] != -1 && j > 1)
                maze.addEdge(u, (i - 1) * m + j - 1, 1);
            if (a[i][j + 1] != -1 && j < m)
                maze.addEdge(u, (i - 1) * m + j + 1, 1);
        }
    }
}

在这个函数中，我们首先读取输入的迷宫地图，并将其转化为一个二维数组。其中，`-1`表示墙，`0`表示可以通行的空白格子，`1`表示起点，`n * m`表示终点。接着，我们遍历整个二维数组，将每个可以通行的格子转化为一个节点，并将相邻的格子之间连上边。

最后，我们可以利用这个类来解决迷宫问题。示例代码如下：

int main() {
    Maze maze;
    readMaze(maze);
    cout << maze.bfs() << endl;
    return 0;
}

在主函数中，我们首先调用`readMaze`函数来读取迷宫地图，并将其转化为图。接着，我们调用`bfs`函数来求解最短路径，并输出结果。

希望这个简单的代码可以帮助您解决问题。如果您有任何疑问，欢迎随时向我提问。