请用C++为我写一段代码，要求能实现以下功能：求出带权值的有向图里任意指定的两点间的五条相对长度最短的路径，输入顶点和边的权重信息，以及要求的两个顶点，输出这两个顶点间的五条相对最短路径，即路径长和路径经过的顶点都要给出

好的，我可以为您提供一份实现以上功能的C++代码，但需要说明的是，这是一个比较复杂的算法，需要使用最短路径算法中的多源最短路径算法，比如Floyd算法或Johnson算法。以下是使用Floyd算法实现的代码：

#include <iostream>
#include <vector>
#include <algorithm>
using namespace std;

const int INF = INT_MAX; // 无穷大

int main() {
    int n, m; // n为顶点数，m为边数
    cin >> n >> m;
    vector<vector<int>> e(n+1, vector<int>(n+1, INF)); // 初始化邻接矩阵
    for (int i = 0; i < m; ++i) {
        int u, v, w;
        cin >> u >> v >> w;
        e[u][v] = w; // u->v的边权重为w
    }

    int s, t; // 要求的两个顶点
    cin >> s >> t;

    // Floyd算法求解任意两点间的最短路径
    vector<vector<int>> dist(n+1, vector<int>(n+1, INF)); // dist[i][j]表示i到j的最短路径长度
    vector<vector<int>> path(n+1, vector<int>(n+1)); // path[i][j]表示i到j的最短路径中，从i到j的下一个顶点
    for (int i = 1; i <= n; ++i) {
        for (int j = 1; j <= n; ++j) {
            dist[i][j] = e[i][j];
            if (e[i][j] != INF && i != j) {
                path[i][j] = i;
            }
        }
    }
    for (int k = 1; k <= n; ++k) {
        for (int i = 1; i <= n; ++i) {
            for (int j = 1; j <= n; ++j) {
                if (dist[i][k] != INF && dist[k][j] != INF && dist[i][j] > dist[i][k] + dist[k][j]) {
                    dist[i][j] = dist[i][k] + dist[k][j];
                    path[i][j] = path[k][j];
                }
            }
        }
    }

    // 找出s到t的五条相对最短路径
    vector<vector<int>> ans; // 存储五条路径的顶点
    vector<int> len; // 存储五条路径的长度
    vector<int> path1; // 存储第一条路径的顶点
    path1.push_back(s);
    int cur = s;
    while (cur != t) {
        cur = path[cur][t];
        path1.push_back(cur);
    }
    ans.push_back(path1);
    len.push_back(dist[s][t]);

    for (int k = 1; k < path1.size()-1; ++k) {
        int u = path1[k];
        int tmp = e[s][u];
        e[s][u] = INF;
        vector<vector<int>> dist2(n+1, vector<int>(n+1, INF)); // dist2[i][j]表示i到j的最短路径长度
        vector<vector<int>> path2(n+1, vector<int>(n+1)); // path2[i][j]表示i到j的最短路径中，从i到j的下一个顶点
        for (int i = 1; i <= n; ++i) {
            for (int j = 1; j <= n; ++j) {
                dist2[i][j] = e[i][j];
                if (e[i][j] != INF && i != j) {
                    path2[i][j] = i;
                }
            }
        }
        for (int k2 = 1; k2 <= n; ++k2) {
            for (int i = 1; i <= n; ++i) {
                for (int j = 1; j <= n; ++j) {
                    if (dist2[i][k2] != INF && dist2[k2][j] != INF && dist2[i][j] > dist2[i][k2] + dist2[k2][j]) {
                        dist2[i][j] = dist2[i][k2] + dist2[k2][j];
                        path2[i][j] = path2[k2][j];
                    }
                }
            }
        }
        vector<int> pathTmp;
        pathTmp.push_back(s);
        cur = s;
        while (cur != u) {
            cur = path[cur][u];
            pathTmp.push_back(cur);
        }
        cur = u;
        while (cur != t) {
            cur = path2[cur][t];
            pathTmp.push_back(cur);
        }
        ans.push_back(pathTmp);
        len.push_back(dist[s][u] + dist2[u][t]);

        e[s][u] = tmp;
    }

    // 按路径长度从小到大排序
    for (int i = 0; i < 5; ++i) {
        int minIdx = i;
        for (int j = i+1; j < len.size(); ++j) {
            if (len[j] < len[minIdx]) {
                minIdx = j;
            }
        }
        if (minIdx != i) {
            swap(len[i], len[minIdx]);
            swap(ans[i], ans[minIdx]);
        }
    }

    // 输出五条相对最短路径
    for (int i = 0; i < 5; ++i) {
        cout << "Path " << i+1 << ": ";
        for (int j = 0; j < ans[i].size(); ++j) {
            cout << ans[i][j] << " ";
        }
        cout << endl;
        cout << "Length: " << len[i] << endl;
    }

    return 0;
}

以上代码实现了对任意两点间的五条相对最短路径的求解，您可以根据需要进行修改和优化。