Improved tasks

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_12_Time_1_(100.00%)_Space_45.64_(_%)
+// #Easy #2025_01_14_Time_1_(100.00%)_Space_45.81_(35.36%)
 
 import java.util.ArrayList;
 import java.util.List;

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

@@ -1,54 +1,56 @@
 package g3401_3500.s3418_maximum_amount_of_money_robot_can_earn;
 
-// #Medium #2025_01_12_Time_156_(_%)_Space_79.73_(_%)
-
-import java.util.Arrays;
+// #Medium #2025_01_14_Time_12_(99.87%)_Space_71.91_(98.93%)
 
 public class Solution {
-    private int solve(int[][] coins, int r, int c, int i, int j, int skip, int[][][] dp) {
-        if (i == r - 1 && j == c - 1) {
-            if (coins[i][j] < 0 && skip > 0) {
-                return 0;
-            }
-            return coins[i][j];
-        } else if (dp[i][j][skip] != Integer.MIN_VALUE) {
-            return dp[i][j][skip];
-        }
-        int val1 = Integer.MIN_VALUE;
-        int val2 = Integer.MIN_VALUE;
-        if (i < r - 1) {
-            if (coins[i][j] < 0 && skip > 0) {
-                val1 =
-                        Math.max(
-                                solve(coins, r, c, i + 1, j, skip - 1, dp),
-                                coins[i][j] + solve(coins, r, c, i + 1, j, skip, dp));
-            } else {
-                val1 = coins[i][j] + solve(coins, r, c, i + 1, j, skip, dp);
+    public int maximumAmount(int[][] coins) {
+        int m = coins.length;
+        int n = coins[0].length;
+        int[][] dp = new int[m][n];
+        int[][] dp1 = new int[m][n];
+        int[][] dp2 = new int[m][n];
+        dp[0][0] = coins[0][0];
+        for (int j = 1; j < n; j++) {
+            dp[0][j] = dp[0][j - 1] + coins[0][j];
+        }
+        for (int i = 1; i < m; i++) {
+            dp[i][0] = dp[i - 1][0] + coins[i][0];
+        }
+        for (int i = 1; i < m; i++) {
+            for (int j = 1; j < n; j++) {
+                dp[i][j] = Math.max(dp[i][j - 1], dp[i - 1][j]) + coins[i][j];
             }
         }
-        if (j < c - 1) {
-            if (coins[i][j] < 0 && skip > 0) {
-                val2 =
+        dp1[0][0] = Math.max(coins[0][0], 0);
+        for (int j = 1; j < n; j++) {
+            dp1[0][j] = Math.max(dp[0][j - 1], dp1[0][j - 1] + coins[0][j]);
+        }
+        for (int i = 1; i < m; i++) {
+            dp1[i][0] = Math.max(dp[i - 1][0], dp1[i - 1][0] + coins[i][0]);
+        }
+        for (int i = 1; i < m; i++) {
+            for (int j = 1; j < n; j++) {
+                dp1[i][j] =
                         Math.max(
-                                solve(coins, r, c, i, j + 1, skip - 1, dp),
-                                coins[i][j] + solve(coins, r, c, i, j + 1, skip, dp));
-            } else {
-                val2 = coins[i][j] + solve(coins, r, c, i, j + 1, skip, dp);
+                                Math.max(dp[i][j - 1], dp[i - 1][j]),
+                                Math.max(dp1[i][j - 1], dp1[i - 1][j]) + coins[i][j]);
             }
         }
-
-        return dp[i][j][skip] = Math.max(val1, val2);
-    }
-
-    public int maximumAmount(int[][] coins) {
-        int r = coins.length;
-        int c = coins[0].length;
-        int[][][] dp = new int[r][c][3];
-        for (int[][] arr1 : dp) {
-            for (int[] arr2 : arr1) {
-                Arrays.fill(arr2, Integer.MIN_VALUE);
+        dp2[0][0] = Math.max(coins[0][0], 0);
+        for (int j = 1; j < n; j++) {
+            dp2[0][j] = Math.max(dp1[0][j - 1], dp2[0][j - 1] + coins[0][j]);
+        }
+        for (int i = 1; i < m; i++) {
+            dp2[i][0] = Math.max(dp1[i - 1][0], dp2[i - 1][0] + coins[i][0]);
+        }
+        for (int i = 1; i < m; i++) {
+            for (int j = 1; j < n; j++) {
+                dp2[i][j] =
+                        Math.max(
+                                Math.max(dp1[i][j - 1], dp1[i - 1][j]),
+                                Math.max(dp2[i][j - 1], dp2[i - 1][j]) + coins[i][j]);
             }
         }
-        return solve(coins, r, c, 0, 0, 2, dp);
+        return dp2[m - 1][n - 1];
     }
 }

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

@@ -1,74 +1,54 @@
 package g3401_3500.s3419_minimize_the_maximum_edge_weight_of_graph;
 
-// #Medium #2025_01_12_Time_1014_(100.00%)_Space_114.21_(100.00%)
+// #Medium #2025_01_14_Time_51_(99.43%)_Space_119.08_(34.00%)
 
+import java.util.Arrays;
 import java.util.ArrayList;
 import java.util.LinkedList;
 import java.util.List;
 import java.util.Queue;
 
-@SuppressWarnings({"unused", "java:S1172"})
+@SuppressWarnings("unchecked")
 public class Solution {
     public int minMaxWeight(int n, int[][] edges, int threshold) {
-        int minW = Integer.MAX_VALUE;
-        int maxW = 0;
-        for (int[] e : edges) {
-            minW = Math.min(minW, e[2]);
-            maxW = Math.max(maxW, e[2]);
-        }
-        int ans = -1;
-        int l = minW;
-        int h = maxW;
-        while (l <= h) {
-            int mid = (l + h) >> 1;
-            if (find(n, edges, mid)) {
-                ans = mid;
-                h = mid - 1;
-            } else {
-                l = mid + 1;
-            }
-        }
-        return ans;
-    }
-
-    private boolean find(int n, int[][] edges, int maxi) {
-        List<List<Integer>> adj = new ArrayList<>();
+        List<int[]>[] graph = new ArrayList[n];
+        List<int[]>[] reversedG = new ArrayList[n];
         for (int i = 0; i < n; i++) {
-            adj.add(new ArrayList<>());
+            reversedG[i] = new ArrayList<>();
         }
-        for (int[] e : edges) {
-            if (e[2] <= maxi) {
-                adj.get(e[0]).add(e[1]);
-            }
+        for (int[] i : edges) {
+            int a = i[0];
+            int b = i[1];
+            int w = i[2];
+            reversedG[b].add(new int[] {a, w});
         }
-        return zero(n, adj);
-    }
-
-    public boolean zero(int n, List<List<Integer>> adj) {
-        List<List<Integer>> rev = new ArrayList<>();
-        for (int i = 0; i < n; i++) {
-            rev.add(new ArrayList<>());
+        int[] distance = new int[n];
+        Arrays.fill(distance, Integer.MAX_VALUE);
+        distance[0] = 0;
+        if (reversedG[0].size() == 0) {
+            return -1;
         }
-        for (int i = 0; i < n; i++) {
-            for (int nb : adj.get(i)) {
-                rev.get(nb).add(i);
+        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);
+                }
             }
         }
-        boolean[] vis = new boolean[n];
-        Queue<Integer> q = new LinkedList<>();
-        q.add(0);
-        int cnt = 1;
-        vis[0] = true;
-        while (!q.isEmpty()) {
-            int curr = q.poll();
-            for (int nb : rev.get(curr)) {
-                if (!vis[nb]) {
-                    vis[nb] = true;
-                    q.add(nb);
-                    cnt++;
-                }
+        int ans = 0;
+        for (int i = 0; i < n; i++) {
+            if (distance[i] == Integer.MAX_VALUE) {
+                return -1;
             }
+            ans = Math.max(ans, distance[i]);
         }
-        return cnt == n;
+        return ans;
     }
 }

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

@@ -1,6 +1,6 @@
 package g3401_3500.s3420_count_non_decreasing_subarrays_after_k_operations;
 
-// #Hard #2025_01_12_Time_31_(100.00%)_Space_62.21_(100.00%)
+// #Hard #2025_01_14_Time_29_(92.59%)_Space_62.14_(57.41%)
 
 import java.util.ArrayDeque;
 import java.util.Deque;