给定一张包含 � n 个点以及 � m 条边的无向图，点按 1 1 到 � n 进行编号，试求出点 � s 到点 � t 的最短路长度。

有许多算法可以求解两点之间的最短路，其中比较常用的是 Dijkstra 算法和 Floyd-Warshall 算法。

Dijkstra 算法适用于边权为非负数的图，时间复杂度为 O(nlogn)。Floyd-Warshall 算法适用于任意边权的图，时间复杂度为 O(n^3)。

下面是使用 Dijkstra 算法求解两点之间最短路的 C++ 代码：

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

const int N = 1e5 + 10;
const int INF = 0x3f3f3f3f;

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

vector<Edge> g[N];
int dist[N];
bool vis[N];

void dijkstra(int s, int n) {
    memset(dist, 0x3f, sizeof(dist));
    memset(vis, false, sizeof(vis));
    dist[s] = 0;
    priority_queue<pair<int, int>, vector<pair<int, int>>, greater<pair<int, int>>> pq;
    pq.push({0, s});
    while (!pq.empty()) {
        int u = pq.top().second;
        pq.pop();
        if (vis[u]) continue;
        vis[u] = true;
        for (auto& e : g[u]) {
            int v = e.v, w = e.w;
            if (!vis[v] && dist[v] > dist[u] + w) {
                dist[v] = dist[u] + w;
                pq.push({dist[v], v});
            }
        }
    }
}

int main() {
    int n, m, s, t;
    cin >> n >> m >> s >> t;
    for (int i = 0; i < m; i++) {
        int u, v, w;
        cin >> u >> v >> w;
        g[u].push_back(Edge(v, w));
        g[v].push_back(Edge(u, w));
    }
    dijkstra(s, n);
    cout << dist[t] << endl;
    return 0;
}

在这个程序中，我们使用了 STL 中的 vector 和 priority_queue 来实现图的存储和 Dijkstra 算法的优先队列。其中，vector g[i] 存储了以 i 为起点的所有边，dist[i] 表示从起点 s 到点 i 的最短路长度，vis[i] 表示点 i 是否已经被访问。

在 dijkstra 函数中，我们首先初始化 dist 数组和 vis 数组。然后将起点 s 加入优先队列，并开始进行循环。每次从队列中取出当前距离起点最近的点 u，并将它标记为已访问。然后遍历 u 的所有邻居点 v，如果 v 还没有被访问，并且从 s 到 u 再到 v 的距离比之前计算的 dist[v] 更短，则更新 dist[v]，并将 v 加入优先队列。

最后输出 dist[t]，即为起点 s 到终点 t 的最短路径长度。

需要注意的是，如果图中存在负边权，不能使用 Dijkstra 算法。此时可以使用 Bellman-Ford 算法或 SPFA 算法来求解最短路。