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

好的，这里给出一个用C++实现的最短路径寻找程序，使用了Dijkstra算法。假设迷宫地图是一个二维数组，0表示可通行，1表示障碍物。程序中使用了一个二维数组来表示图中的节点（即迷宫单元格）。

#include <iostream>
#include <vector>
#include <queue>
#include <limits.h>
using namespace std;

const int MAX_N = 100;   // 最大节点数
int n;                   // 节点数
int map[MAX_N][MAX_N];   // 迷宫地图
int dist[MAX_N][MAX_N];  // 距离数组
bool visited[MAX_N][MAX_N];  // 标记数组

struct Node {
    int x;
    int y;
    int dist;
    Node(int _x, int _y, int _dist) : x(_x), y(_y), dist(_dist) {}
    bool operator<(const Node &other) const {
        return dist > other.dist;
    }
};

void dijkstra(int sx, int sy, int tx, int ty) {
    // 初始化距离和标记数组
    for (int i = 0; i < n; i++) {
        for (int j = 0; j < n; j++) {
            dist[i][j] = INT_MAX;
            visited[i][j] = false;
        }
    }
    dist[sx][sy] = 0;
    priority_queue<Node> pq;
    pq.push(Node(sx, sy, 0));
    while (!pq.empty()) {
        Node node = pq.top();
        pq.pop();
        int x = node.x;
        int y = node.y;
        if (visited[x][y]) continue;
        visited[x][y] = true;
        if (x == tx && y == ty) return;  // 到达终点
        // 更新相邻节点的距离
        if (x > 0 && map[x-1][y] == 0 && !visited[x-1][y] && dist[x][y] + 1 < dist[x-1][y]) {
            dist[x-1][y] = dist[x][y] + 1;
            pq.push(Node(x-1, y, dist[x-1][y]));
        }
        if (y > 0 && map[x][y-1] == 0 && !visited[x][y-1] && dist[x][y] + 1 < dist[x][y-1]) {
            dist[x][y-1] = dist[x][y] + 1;
            pq.push(Node(x, y-1, dist[x][y-1]));
        }
        if (x < n-1 && map[x+1][y] == 0 && !visited[x+1][y] && dist[x][y] + 1 < dist[x+1][y]) {
            dist[x+1][y] = dist[x][y] + 1;
            pq.push(Node(x+1, y, dist[x+1][y]));
        }
        if (y < n-1 && map[x][y+1] == 0 && !visited[x][y+1] && dist[x][y] + 1 < dist[x][y+1]) {
            dist[x][y+1] = dist[x][y] + 1;
            pq.push(Node(x, y+1, dist[x][y+1]));
        }
    }
}

int main() {
    // 读入地图和起点终点坐标
    int sx, sy, tx, ty;
    cin >> n >> sx >> sy >> tx >> ty;
    for (int i = 0; i < n; i++) {
        for (int j = 0; j < n; j++) {
            cin >> map[i][j];
        }
    }
    // 使用Dijkstra算法寻找最短路径
    dijkstra(sx, sy, tx, ty);
    // 输出结果
    cout << dist[tx][ty] << endl;
    return 0;
}

这个程序使用了一个优先队列来实现Dijkstra算法，在每次迭代中选择距离最短的节点进行扩展。这个程序可以处理最大100x100的迷宫地图，但如果需要处理更大的地图，可能需要使用其他算法或者优化Dijkstra算法的实现。