Welcome to Subscribe On Youtube
2203. Minimum Weighted Subgraph With the Required Paths
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] = [from_{i}, to_{i}, weight_{i}]
denotes that there exists a directed edge from from_{i}
to to_{i}
with weight weight_{i}
.
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:
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:
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 <= 10^{5}
0 <= edges.length <= 10^{5}
edges[i].length == 3
0 <= from_{i}, to_{i}, src1, src2, dest <= n  1
from_{i} != to_{i}
src1
,src2
, anddest
are pairwise distinct.1 <= weight[i] <= 10^{5}
Solutions

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; } }

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