Improved tasks 3417-3420

Author: javadev

src/main/java/g3401_3500/s3417_zigzag_grid_traversal_with_skip/Solution.java

@@ -1,6 +1,6 @@
 package g3401_3500.s3417_zigzag_grid_traversal_with_skip;
 
-// #Easy #2025_01_14_Time_1_(100.00%)_Space_45.81_(35.36%)
+// #Easy #Array #Matrix #Simulation #2025_01_15_Time_1_(100.00%)_Space_45.56_(84.25%)
 
 import java.util.ArrayList;
 import java.util.List;

src/main/java/g3401_3500/s3418_maximum_amount_of_money_robot_can_earn/Solution.java

@@ -1,6 +1,6 @@
 package g3401_3500.s3418_maximum_amount_of_money_robot_can_earn;
 
-// #Medium #2025_01_14_Time_12_(99.87%)_Space_71.91_(98.93%)
+// #Medium #Array #Dynamic_Programming #Matrix #2025_01_15_Time_12_(99.86%)_Space_72.43_(98.47%)
 
 public class Solution {
     public int maximumAmount(int[][] coins) {

src/main/java/g3401_3500/s3419_minimize_the_maximum_edge_weight_of_graph/Solution.java

@@ -1,53 +1,85 @@
 package g3401_3500.s3419_minimize_the_maximum_edge_weight_of_graph;
 
-// #Medium #2025_01_14_Time_51_(99.43%)_Space_119.08_(34.00%)
+// #Medium #Binary_Search #Graph #Shortest_Path #Depth_First_Search #Breadth_First_Search
+// #2025_01_15_Time_64_(99.28%)_Space_110.17_(57.63%)
 
 import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.LinkedList;
-import java.util.List;
 import java.util.Queue;
 
 @SuppressWarnings({"unchecked", "unused", "java:S1172"})
 public class Solution {
+    private ArrayList<ArrayList<Pair>> adj;
+    private ArrayList<ArrayList<Pair>> revadj;
+
+    private static class Pair {
+        int node;
+        int weight;
+
+        public Pair(int node, int weight) {
+            this.node = node;
+            this.weight = weight;
+        }
+    }
+
     public int minMaxWeight(int n, int[][] edges, int threshold) {
-        List<int[]>[] reversedG = new ArrayList[n];
-        for (int i = 0; i < n; i++) {
-            reversedG[i] = new ArrayList<>();
+        adj = new ArrayList<>();
+        revadj = new ArrayList<>();
+        for (int i = 0; i <= n + 1; i++) {
+            adj.add(new ArrayList<>());
+            revadj.add(new ArrayList<>());
         }
-        for (int[] i : edges) {
-            int a = i[0];
-            int b = i[1];
-            int w = i[2];
-            reversedG[b].add(new int[] {a, w});
+        for (int[] edge : edges) {
+            int u = edge[0];
+            int v = edge[1];
+            int wt = edge[2];
+            adj.get(u).add(new Pair(v, wt));
+            revadj.get(v).add(new Pair(u, wt));
         }
-        int[] distance = new int[n];
-        Arrays.fill(distance, Integer.MAX_VALUE);
-        distance[0] = 0;
-        if (reversedG[0].isEmpty()) {
+        if (!check(n)) {
             return -1;
         }
-        Queue<Integer> que = new LinkedList<>();
-        que.add(0);
-        while (!que.isEmpty()) {
-            int cur = que.poll();
-            for (int[] next : reversedG[cur]) {
-                int node = next[0];
-                int w = next[1];
-                int nextdis = Math.max(w, distance[cur]);
-                if (nextdis < distance[node]) {
-                    distance[node] = nextdis;
-                    que.add(node);
+        int[] dist = new int[n + 1];
+        Arrays.fill(dist, (int) (1e9));
+        dist[0] = 0;
+        Queue<Pair> q = new LinkedList<>();
+        q.offer(new Pair(0, 0));
+        while (q.size() > 0) {
+            int u = q.peek().node;
+            int currMax = q.peek().weight;
+            q.poll();
+            for (int i = 0; i < revadj.get(u).size(); i++) {
+                int v = revadj.get(u).get(i).node;
+                int wt = revadj.get(u).get(i).weight;
+                if (dist[v] > Math.max(wt, currMax)) {
+                    dist[v] = Math.max(wt, currMax);
+                    q.offer(new Pair(v, dist[v]));
                 }
             }
         }
-        int ans = 0;
+        int maxi = dist[0];
         for (int i = 0; i < n; i++) {
-            if (distance[i] == Integer.MAX_VALUE) {
-                return -1;
+            maxi = Math.max(maxi, dist[i]);
+        }
+        return maxi;
+    }
+
+    private boolean check(int n) {
+        int[] vis = new int[n];
+        ArrayList<Integer> nodes = new ArrayList<>();
+        dfs(0, vis, nodes);
+        return nodes.size() == n;
+    }
+
+    private void dfs(int u, int[] vis, ArrayList<Integer> nodes) {
+        nodes.add(u);
+        vis[u] = 1;
+        for (int i = 0; i < revadj.get(u).size(); i++) {
+            int v = revadj.get(u).get(i).node;
+            if (vis[v] == 0) {
+                dfs(v, vis, nodes);
             }
-            ans = Math.max(ans, distance[i]);
         }
-        return ans;
     }
 }

src/main/java/g3401_3500/s3420_count_non_decreasing_subarrays_after_k_operations/Solution.java

@@ -1,6 +1,7 @@
 package g3401_3500.s3420_count_non_decreasing_subarrays_after_k_operations;
 
-// #Hard #2025_01_14_Time_29_(92.59%)_Space_62.14_(57.41%)
+// #Hard #Array #Two_Pointers #Stack #Monotonic_Stack #Queue #Segment_Tree #Monotonic_Queue
+// #2025_01_15_Time_29_(83.94%)_Space_62.04_(56.93%)
 
 import java.util.ArrayDeque;
 import java.util.Deque;