用c++语言建立一个带权无向图的邻接矩阵存储，用迪杰斯特拉（Dijkstra）算法求该图中给定的某起点到某终点之间的最短路径，按顺序输出该最短路径上的各顶点

好的，我会为您提供一个c++实现的例子，用于建立一个带权无向图的邻接矩阵存储，并使用Dijkstra算法求出给定起点到终点的最短路径。

首先，我们需要定义一个结构体用于表示图中的一条边：

// 表示一条边
struct Edge {
    int to; // 目标顶点
    int weight; // 边的权值
    Edge(int t, int w): to(t), weight(w) {} // 构造函数
};

然后，我们定义一个类来表示带权无向图，其中包括顶点个数、邻接矩阵、以及Dijkstra算法的实现：

class WeightedUndirectedGraph {
public:
    WeightedUndirectedGraph(int V) : V_(V) {
        // 初始化邻接矩阵
        adjMatrix_.resize(V_, vector<int>(V_, 0));
    }

    // 添加一条边
    void addEdge(int u, int v, int w) {
        adjMatrix_[u][v] = w;
        adjMatrix_[v][u] = w;
    }

    // 迪杰斯特拉算法求最短路径
    vector<int> dijkstra(int start, int end) {
        // 记录起点到各个顶点的距离
        vector<int> dist(V_, INT_MAX);
        dist[start] = 0;

        // 记录顶点是否已经被访问过
        vector<bool> visited(V_, false);

        // 记录最短路径的前驱顶点
        vector<int> prev(V_, -1);

        // 依次访问所有顶点
        for (int i = 0; i < V_; ++i) {
            // 选择当前距离起点最近的顶点
            int u = -1;
            for (int v = 0; v < V_; ++v) {
                if (!visited[v] && (u == -1 || dist[v] < dist[u])) {
                    u = v;
                }
            }

            visited[u] = true;

            // 更新与u相邻的顶点的距离
            for (int v = 0; v < V_; ++v) {
                if (!visited[v] && adjMatrix_[u][v] > 0 && dist[u] + adjMatrix_[u][v] < dist[v]) {
                    dist[v] = dist[u] + adjMatrix_[u][v];
                    prev[v] = u;
                }
            }
        }

        // 回溯得到最短路径
        vector<int> path;
        for (int u = end; u != -1; u = prev[u]) {
            path.push_back(u);
        }
        reverse(path.begin(), path.end());

        return path;
    }

private:
    int V_; // 顶点个数
    vector<vector<int>> adjMatrix_; // 邻接矩阵
};

最后，我们可以使用上面定义的类来建立一个带权无向图，然后调用Dijkstra算法求出最短路径，并按顺序输出该最短路径上的各顶点：

int main() {
    // 建立一个带权无向图
    WeightedUndirectedGraph graph(5);
    graph.addEdge(0, 1, 2);
    graph.addEdge(0, 3, 1);
    graph.addEdge(1, 2, 3);
    graph.addEdge(1, 3, 2);
    graph.addEdge(2, 4, 4);
    graph.addEdge(3, 4, 3);

    // 使用Dijkstra算法求最短路径
    int start = 0, end = 4;
    vector<int> path = graph.dijkstra(start, end);

    // 输出最短路径
    cout << "Shortest path from " << start << " to " << end << ": ";
    for (int i = 0; i < path.size(); ++i) {
        cout << path[i] << " ";
        if (i < path.size() - 1) {
            cout << "-> ";
        }
    }
    cout << endl;

    return 0;
}

输出结果为：

Shortest path from 0 to 4: 0 -> 3 -> 4

希望这个例子能够帮助您理解如何用c++语言建立一个带权无向图的邻接矩阵存储，并使用Dijkstra算法求出最短路径。