题目来源于leetcode,解法和思路仅代表个人观点。传送门。
难度: 困难(T4)
时间:-
题目
给你一个整数 n ,它表示一个 带权有向 图的节点数,节点编号为 0 到 n - 1 。
同时给你一个二维整数数组 edges ,其中 edges[i] = [fromi, toi, weighti] ,表示从 fromi 到 toi 有一条边权为 weighti 的 有向 边。
最后,给你三个 互不相同 的整数 src1 ,src2 和 dest ,表示图中三个不同的点。
请你从图中选出一个 边权和最小 的子图,使得从 src1 和 src2 出发,在这个子图中,都 可以 到达 dest 。如果这样的子图不存在,请返回 -1 。
子图 中的点和边都应该属于原图的一部分。子图的边权和定义为它所包含的所有边的权值之和。
示例1:
输入:n = 6, edges = [[0,2,2],[0,5,6],[1,0,3],[1,4,5],[2,1,1],[2,3,3],[2,3,4],[3,4,2],[4,5,1]], src1 = 0, src2 = 1, dest = 5
输出:9
解释:
上图为输入的图。
蓝色边为最优子图之一。
注意,子图 [[1,0,3],[0,5,6]] 也能得到最优解,但无法在满足所有限制的前提下,得到更优解。
示例 2:
输入:n = 3, edges = [[0,1,1],[2,1,1]], src1 = 0, src2 = 1, dest = 2
输出:-1
解释:
上图为输入的图。
可以看到,不存在从节点 1 到节点 2 的路径,所以不存在任何子图满足所有限制。
提示:
3 <= n <= 105
0 <= edges.length <= 105
edges[i].length == 3
0 <=fromi, toi, src1, src2, dest <= n - 1
fromi != toi
src1 ,src2 和 dest 两两不同。
1 <= weight[i] <= 105
思路
src1
和src2
到dest
总有一部分是重合的。
设d[i][j]
为i->j
的距离,则如果有重合,最小权值为D = d[src1][M] + d[src2][M] + d[M][dest]
。其中M
为0~n-1
的一个中间节点。
所以,步骤如下:
- 对
src1
和src2
分别求(到每个顶点的)最短路径。 - 对于
dest
我们需要将有向图翻转(即方向翻转)。然后求dest
的(到每个顶点的)最短路径。 - 遍历节点
i ∈ 0~n-1
,计算当i
当作中间节点M
时,的最小权值D
。
最短路径算法,使用 d i j k s t r a dijkstra dijkstra算法的O(ElogE)
实现方式。
d i j k s t r a dijkstra dijkstra算法能在 O ( E l o g E ) O(ElogE) O(ElogE)的时间内算出,从源点到其他每个点的最短距离。
代码
两种dijkstra
的实现,看到大部分人都是用的第一种。
class Solution {
public:
using ll = long long;
const ll INF = LONG_MAX/3;
vector<long long> dijkstra(vector<vector<pair<int,int>>>& adj, int s){
/*
总体思想:
到达某个点后,都更新 s到该点 的最短距离,并将这个距离存入队列。
对于distance[i]可能更新多次。
时间复杂度:O(ElogV)。对于每个点V都遍历其所有边,每个点最多入队V次(实际上可能大于V,因为当前的节点可能已经找到最短路径了)。最坏情况下为O(ElogE)。
空间复杂度:O(E)。最差情况下,需要所有边加入。
*/
int n = adj.size();
// distance[i]: s到i 的距离
vector<long long> distance(n, INF);
// [d,u]: s到节点u 的距离为d
priority_queue<pair<long long,int>,vector<pair<long long,int>>,greater<pair<long long,int>>> q;
q.emplace(0,s);
distance[s] = 0;
while(!q.empty()){
auto [d, u] = q.top();
q.pop();
if(d > distance[u]){
continue;
}
for(auto& [to, weight]:adj[u]){
if(d + weight < distance[to]){
distance[to] = d + weight;
q.emplace(distance[to],to);
}
}
}
return distance;
}
vector<long long> dijkstra2(vector<vector<pair<int,int>>>& adj, int s){
/*
总体思想:每次确定一个顶点的最短路径。
记录 s从 某条边 到达 该点 的距离。
对于distance[i]只更新一次。
时间复杂度:O(VlogE)。对于每个点V,把所有边加入队列中,总共弹出V次(实际上可能大于V,因为当前节点可能已经遍历过了)。最坏情况下为O(ElogE)。
空间复杂度:O(E)。把所有边都加入队列中。
*/
int n = adj.size();
// d[i]: s到i的距离
vector<long long> distance(n, INF);
// [d,u]: s到节点u的距离为d
priority_queue<pair<long long,int>,vector<pair<long long,int>>,greater<pair<long long,int>>> q;
q.emplace(0,s);
// distance[s] = 0;
while(!q.empty()){
auto [d, u] = q.top();
q.pop();
if(distance[u] != INF){
continue;
}
distance[u] = d;
for(auto& [to, weight]:adj[u]){
q.emplace(distance[u] + weight,to);
}
}
return distance;
}
long long minimumWeight(int n, vector<vector<int>>& edges, int src1, int src2, int dest) {
vector<vector<pair<int,int>>> adj(n),rev(n);
for(auto& e:edges){
int from = e[0];
int to = e[1];
int weight = e[2];
adj[from].emplace_back(to,weight);
rev[to].emplace_back(from,weight);
}
auto d1 = dijkstra2(adj, src1);
auto d2 = dijkstra2(adj, src2);
auto d3 = dijkstra2(rev, dest);
long long ans = INF;
for(int i=0;i<n;i++){
ans = min(ans, d1[i]+d2[i]+d3[i]);
}
return ans==INF?-1:ans;
}
};
算法复杂度
时间复杂度: O ( E l o g E ) O(ElogE) O(ElogE)。其中, E E E为边的数目。
空间复杂度: O ( E + V ) O(E+V) O(E+V)。其中, E E E为边的数目, V V V为顶点的数目。