从给定源到给定目的地的路径，在图中具有第 K 个最大权重

在图论中，给定一个有向加权图，路径的权重是其沿途边的权重之和。 给定源顶点 src 和目标顶点 dst，在这样的图中找到从 src 到 dst 的路径中第 K 个最大权重的路径，此路径指的是路径权值按递减顺序排列后的第 K 个路径。

方法

一种自然的方法是使用最短路径算法，例如 Dijkstra 或 Bellman-Ford，并且相应地更改权重函数来通过取其负值而转换为最短路径。这对于找到第K最短路径非常有用，但更改权重函数后，我们必须根据权重值排序，因此算法的时间复杂度将变得较高。

另一种方法是使用深度优先搜索（DFS）和堆优化，从源顶点开始进行 DFS，使用堆来保存之前访问过的路径。递归 DFS 时，我们可以将当前路径的权重值插入堆中，并在达到目标节点或堆大小达到 K 后从堆中弹出最大值。这将确保我们在堆中只保留 K 个最大权重的路径，并且我们只需要在 DFS 结束后排列堆并输出第 K 条路径即可。

复杂度

这种方法的复杂度为 $O(E + K\log K)$，其中 E 表示边的数量。时间复杂度为 $O(E)$，因为每条边最多访问一次，而空间复杂度为 $O(K)$，因为我们仅维护 K 条路径。

参考代码

以下是 Python 3 中使用深度优先搜索和最小堆的实现：

import heapq

def kthLargestPath(graph, src, dst, k):
    def dfs(v, weight, path):
        if v == dst:
            heapq.heappush(heap, (-weight, path)) # (-weight, path) will sort paths in descending order
            if len(heap) > k:
                heapq.heappop(heap) # remove smallest path
            return
        for u, w in graph[v]:
            dfs(u, weight + w, path + [u])

    heap = []
    dfs(src, 0, [src])
    return heap[-1][1] if len(heap) == k else None

在一些编程语言中，可能没有提供最小堆的内置数据结构，但我们可以用标准库中的排序方法排序路径列表，如在 C++ 中使用 STL 的 <algorithm> 头文件：

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

bool cmp(const vector<int>& a, const vector<int>& b) {
    return a.back() > b.back();
}

vector<int> kthLargestPath(int n, vector<vector<int>>& edges, int src, int dst, int k) {
    vector<pair<int, int>> graph[n];
    for (auto& e : edges)
        graph[e[0]].emplace_back(e[1], e[2]);

    priority_queue<vector<int>, vector<vector<int>>, decltype(&cmp)> pq(cmp);
    vector<int> path = {src}, ans;

    function<void(int, int, vector<int>&)> dfs = [&](int u, int w, vector<int>& path) {
        if (u == dst) {
            path.push_back(w);
            pq.push(path);
            path.pop_back();
            if (pq.size() > k)
                pq.pop();
            return;
        }
        for (auto& [v, nw] : graph[u]) {
            path.push_back(v);
            dfs(v, w + nw, path);
            path.pop_back();
        }
    };

    dfs(src, 0, path);
    if (pq.size() == k)
        ans = pq.top();
    return ans;
}

上述代码的时间复杂度与 Python 3 版本的实现方法相同，但是空间复杂度可能较高，因为必须显式地保留所有路径，而不是存储在优先队列中。