|
1 | 1 | package g3401_3500.s3419_minimize_the_maximum_edge_weight_of_graph;
|
2 | 2 |
|
3 |
| -// #Medium #2025_01_14_Time_51_(99.43%)_Space_119.08_(34.00%) |
| 3 | +// #Medium #Binary_Search #Graph #Shortest_Path #Depth_First_Search #Breadth_First_Search |
| 4 | +// #2025_01_15_Time_64_(99.28%)_Space_110.17_(57.63%) |
4 | 5 |
|
5 | 6 | import java.util.ArrayList;
|
6 | 7 | import java.util.Arrays;
|
7 | 8 | import java.util.LinkedList;
|
8 |
| -import java.util.List; |
9 | 9 | import java.util.Queue;
|
10 | 10 |
|
11 | 11 | @SuppressWarnings({"unchecked", "unused", "java:S1172"})
|
12 | 12 | public class Solution {
|
| 13 | + private ArrayList<ArrayList<Pair>> adj; |
| 14 | + private ArrayList<ArrayList<Pair>> revadj; |
| 15 | + |
| 16 | + private static class Pair { |
| 17 | + int node; |
| 18 | + int weight; |
| 19 | + |
| 20 | + public Pair(int node, int weight) { |
| 21 | + this.node = node; |
| 22 | + this.weight = weight; |
| 23 | + } |
| 24 | + } |
| 25 | + |
13 | 26 | public int minMaxWeight(int n, int[][] edges, int threshold) {
|
14 |
| - List<int[]>[] reversedG = new ArrayList[n]; |
15 |
| - for (int i = 0; i < n; i++) { |
16 |
| - reversedG[i] = new ArrayList<>(); |
| 27 | + adj = new ArrayList<>(); |
| 28 | + revadj = new ArrayList<>(); |
| 29 | + for (int i = 0; i <= n + 1; i++) { |
| 30 | + adj.add(new ArrayList<>()); |
| 31 | + revadj.add(new ArrayList<>()); |
17 | 32 | }
|
18 |
| - for (int[] i : edges) { |
19 |
| - int a = i[0]; |
20 |
| - int b = i[1]; |
21 |
| - int w = i[2]; |
22 |
| - reversedG[b].add(new int[] {a, w}); |
| 33 | + for (int[] edge : edges) { |
| 34 | + int u = edge[0]; |
| 35 | + int v = edge[1]; |
| 36 | + int wt = edge[2]; |
| 37 | + adj.get(u).add(new Pair(v, wt)); |
| 38 | + revadj.get(v).add(new Pair(u, wt)); |
23 | 39 | }
|
24 |
| - int[] distance = new int[n]; |
25 |
| - Arrays.fill(distance, Integer.MAX_VALUE); |
26 |
| - distance[0] = 0; |
27 |
| - if (reversedG[0].isEmpty()) { |
| 40 | + if (!check(n)) { |
28 | 41 | return -1;
|
29 | 42 | }
|
30 |
| - Queue<Integer> que = new LinkedList<>(); |
31 |
| - que.add(0); |
32 |
| - while (!que.isEmpty()) { |
33 |
| - int cur = que.poll(); |
34 |
| - for (int[] next : reversedG[cur]) { |
35 |
| - int node = next[0]; |
36 |
| - int w = next[1]; |
37 |
| - int nextdis = Math.max(w, distance[cur]); |
38 |
| - if (nextdis < distance[node]) { |
39 |
| - distance[node] = nextdis; |
40 |
| - que.add(node); |
| 43 | + int[] dist = new int[n + 1]; |
| 44 | + Arrays.fill(dist, (int) (1e9)); |
| 45 | + dist[0] = 0; |
| 46 | + Queue<Pair> q = new LinkedList<>(); |
| 47 | + q.offer(new Pair(0, 0)); |
| 48 | + while (q.size() > 0) { |
| 49 | + int u = q.peek().node; |
| 50 | + int currMax = q.peek().weight; |
| 51 | + q.poll(); |
| 52 | + for (int i = 0; i < revadj.get(u).size(); i++) { |
| 53 | + int v = revadj.get(u).get(i).node; |
| 54 | + int wt = revadj.get(u).get(i).weight; |
| 55 | + if (dist[v] > Math.max(wt, currMax)) { |
| 56 | + dist[v] = Math.max(wt, currMax); |
| 57 | + q.offer(new Pair(v, dist[v])); |
41 | 58 | }
|
42 | 59 | }
|
43 | 60 | }
|
44 |
| - int ans = 0; |
| 61 | + int maxi = dist[0]; |
45 | 62 | for (int i = 0; i < n; i++) {
|
46 |
| - if (distance[i] == Integer.MAX_VALUE) { |
47 |
| - return -1; |
| 63 | + maxi = Math.max(maxi, dist[i]); |
| 64 | + } |
| 65 | + return maxi; |
| 66 | + } |
| 67 | + |
| 68 | + private boolean check(int n) { |
| 69 | + int[] vis = new int[n]; |
| 70 | + ArrayList<Integer> nodes = new ArrayList<>(); |
| 71 | + dfs(0, vis, nodes); |
| 72 | + return nodes.size() == n; |
| 73 | + } |
| 74 | + |
| 75 | + private void dfs(int u, int[] vis, ArrayList<Integer> nodes) { |
| 76 | + nodes.add(u); |
| 77 | + vis[u] = 1; |
| 78 | + for (int i = 0; i < revadj.get(u).size(); i++) { |
| 79 | + int v = revadj.get(u).get(i).node; |
| 80 | + if (vis[v] == 0) { |
| 81 | + dfs(v, vis, nodes); |
48 | 82 | }
|
49 |
| - ans = Math.max(ans, distance[i]); |
50 | 83 | }
|
51 |
| - return ans; |
52 | 84 | }
|
53 | 85 | }
|
0 commit comments