Description#
You are given an integer n
denoting the number of nodes of a weighted directed graph. The nodes are numbered from 0
to n - 1
.
You are also given a 2D integer array edges
where edges[i] = [fromi, toi, weighti]
denotes that there exists a directed edge from fromi
to toi
with weight weighti
.
Lastly, you are given three distinct integers src1
, src2
, and dest
denoting three distinct nodes of the graph.
Return the minimum weight of a subgraph of the graph such that it is possible to reach dest
from both src1
and src2
via a set of edges of this subgraph. In case such a subgraph does not exist, return -1
.
A subgraph is a graph whose vertices and edges are subsets of the original graph. The weight of a subgraph is the sum of weights of its constituent edges.
Example 1:
![](https://spcdn.pages.dev/leetcode/problems/2203.Minimum%20Weighted%20Subgraph%20With%20the%20Required%20Paths/images/example1drawio.png)
Input: 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
Output: 9
Explanation:
The above figure represents the input graph.
The blue edges represent one of the subgraphs that yield the optimal answer.
Note that the subgraph [[1,0,3],[0,5,6]] also yields the optimal answer. It is not possible to get a subgraph with less weight satisfying all the constraints.
Example 2:
![](https://spcdn.pages.dev/leetcode/problems/2203.Minimum%20Weighted%20Subgraph%20With%20the%20Required%20Paths/images/example2-1drawio.png)
Input: n = 3, edges = [[0,1,1],[2,1,1]], src1 = 0, src2 = 1, dest = 2
Output: -1
Explanation:
The above figure represents the input graph.
It can be seen that there does not exist any path from node 1 to node 2, hence there are no subgraphs satisfying all the constraints.
Constraints:
3 <= n <= 105
0 <= edges.length <= 105
edges[i].length == 3
0 <= fromi, toi, src1, src2, dest <= n - 1
fromi != toi
src1
, src2
, and dest
are pairwise distinct.1 <= weight[i] <= 105
Solutions#
Solution 1#
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
| class Solution:
def minimumWeight(
self, n: int, edges: List[List[int]], src1: int, src2: int, dest: int
) -> int:
def dijkstra(g, u):
dist = [inf] * n
dist[u] = 0
q = [(0, u)]
while q:
d, u = heappop(q)
if d > dist[u]:
continue
for v, w in g[u]:
if dist[v] > dist[u] + w:
dist[v] = dist[u] + w
heappush(q, (dist[v], v))
return dist
g = defaultdict(list)
rg = defaultdict(list)
for f, t, w in edges:
g[f].append((t, w))
rg[t].append((f, w))
d1 = dijkstra(g, src1)
d2 = dijkstra(g, src2)
d3 = dijkstra(rg, dest)
ans = min(sum(v) for v in zip(d1, d2, d3))
return -1 if ans >= inf else ans
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
| class Solution {
private static final Long INF = Long.MAX_VALUE;
public long minimumWeight(int n, int[][] edges, int src1, int src2, int dest) {
List<Pair<Integer, Long>>[] g = new List[n];
List<Pair<Integer, Long>>[] rg = new List[n];
for (int i = 0; i < n; ++i) {
g[i] = new ArrayList<>();
rg[i] = new ArrayList<>();
}
for (int[] e : edges) {
int f = e[0], t = e[1];
long w = e[2];
g[f].add(new Pair<>(t, w));
rg[t].add(new Pair<>(f, w));
}
long[] d1 = dijkstra(g, src1);
long[] d2 = dijkstra(g, src2);
long[] d3 = dijkstra(rg, dest);
long ans = -1;
for (int i = 0; i < n; ++i) {
if (d1[i] == INF || d2[i] == INF || d3[i] == INF) {
continue;
}
long t = d1[i] + d2[i] + d3[i];
if (ans == -1 || ans > t) {
ans = t;
}
}
return ans;
}
private long[] dijkstra(List<Pair<Integer, Long>>[] g, int u) {
int n = g.length;
long[] dist = new long[n];
Arrays.fill(dist, INF);
dist[u] = 0;
PriorityQueue<Pair<Long, Integer>> q
= new PriorityQueue<>(Comparator.comparingLong(Pair::getKey));
q.offer(new Pair<>(0L, u));
while (!q.isEmpty()) {
Pair<Long, Integer> p = q.poll();
long d = p.getKey();
u = p.getValue();
if (d > dist[u]) {
continue;
}
for (Pair<Integer, Long> e : g[u]) {
int v = e.getKey();
long w = e.getValue();
if (dist[v] > dist[u] + w) {
dist[v] = dist[u] + w;
q.offer(new Pair<>(dist[v], v));
}
}
}
return dist;
}
}
|