Added tasks 3417-3420

Author: javadev

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

@@ -0,0 +1,36 @@
+package g3401_3500.s3417_zigzag_grid_traversal_with_skip;
+
+// #Easy #2025_01_12_Time_1_(100.00%)_Space_45.64_(_%)
+
+import java.util.ArrayList;
+import java.util.List;
+
+public class Solution {
+    public List<Integer> zigzagTraversal(int[][] grid) {
+        List<Integer> ans = new ArrayList<>();
+        int m = grid.length;
+        int n = grid[0].length;
+        int i = 0;
+        boolean flag = true, skip = false;
+        while (i < m) {
+            if (flag) {
+                for (int j = 0; j < n; j++) {
+                    if (!skip) {
+                        ans.add(grid[i][j]);
+                    }
+                    skip = !skip;
+                }
+            } else {
+                for (int j = n - 1; j >= 0; j--) {
+                    if (!skip) {
+                        ans.add(grid[i][j]);
+                    }
+                    skip = !skip;
+                }
+            }
+            flag = !flag;
+            i++;
+        }
+        return ans;
+    }
+}

src/main/java/g3401_3500/s3417_zigzag_grid_traversal_with_skip/readme.md

@@ -0,0 +1,54 @@
+3417\. Zigzag Grid Traversal With Skip
+
+Easy
+
+You are given an `m x n` 2D array `grid` of **positive** integers.
+
+Your task is to traverse `grid` in a **zigzag** pattern while skipping every **alternate** cell.
+
+Zigzag pattern traversal is defined as following the below actions:
+
+*   Start at the top-left cell `(0, 0)`.
+*   Move _right_ within a row until the end of the row is reached.
+*   Drop down to the next row, then traverse _left_ until the beginning of the row is reached.
+*   Continue **alternating** between right and left traversal until every row has been traversed.
+
+**Note** that you **must skip** every _alternate_ cell during the traversal.
+
+Return an array of integers `result` containing, **in order**, the value of the cells visited during the zigzag traversal with skips.
+
+**Example 1:**
+
+**Input:** grid = [[1,2],[3,4]]
+
+**Output:** [1,4]
+
+**Explanation:**
+
+**![](https://assets.leetcode.com/uploads/2024/11/23/4012_example0.png)**
+
+**Example 2:**
+
+**Input:** grid = [[2,1],[2,1],[2,1]]
+
+**Output:** [2,1,2]
+
+**Explanation:**
+
+![](https://assets.leetcode.com/uploads/2024/11/23/4012_example1.png)
+
+**Example 3:**
+
+**Input:** grid = [[1,2,3],[4,5,6],[7,8,9]]
+
+**Output:** [1,3,5,7,9]
+
+**Explanation:**
+
+![](https://assets.leetcode.com/uploads/2024/11/23/4012_example2.png)
+
+**Constraints:**
+
+*   `2 <= n == grid.length <= 50`
+*   `2 <= m == grid[i].length <= 50`
+*   `1 <= grid[i][j] <= 2500`

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

@@ -0,0 +1,54 @@
+package g3401_3500.s3418_maximum_amount_of_money_robot_can_earn;
+
+// #Medium #2025_01_12_Time_156_(_%)_Space_79.73_(_%)
+
+import java.util.Arrays;
+
+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);
+            }
+        }
+        if (j < c - 1) {
+            if (coins[i][j] < 0 && skip > 0) {
+                val2 =
+                        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);
+            }
+        }
+
+        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);
+            }
+        }
+        return solve(coins, r, c, 0, 0, 2, dp);
+    }
+}

src/main/java/g3401_3500/s3418_maximum_amount_of_money_robot_can_earn/readme.md

@@ -0,0 +1,54 @@
+3418\. Maximum Amount of Money Robot Can Earn
+
+Medium
+
+You are given an `m x n` grid. A robot starts at the top-left corner of the grid `(0, 0)` and wants to reach the bottom-right corner `(m - 1, n - 1)`. The robot can move either right or down at any point in time.
+
+The grid contains a value `coins[i][j]` in each cell:
+
+*   If `coins[i][j] >= 0`, the robot gains that many coins.
+*   If `coins[i][j] < 0`, the robot encounters a robber, and the robber steals the **absolute** value of `coins[i][j]` coins.
+
+The robot has a special ability to **neutralize robbers** in at most **2 cells** on its path, preventing them from stealing coins in those cells.
+
+**Note:** The robot's total coins can be negative.
+
+Return the **maximum** profit the robot can gain on the route.
+
+**Example 1:**
+
+**Input:** coins = [[0,1,-1],[1,-2,3],[2,-3,4]]
+
+**Output:** 8
+
+**Explanation:**
+
+An optimal path for maximum coins is:
+
+1.  Start at `(0, 0)` with `0` coins (total coins = `0`).
+2.  Move to `(0, 1)`, gaining `1` coin (total coins = `0 + 1 = 1`).
+3.  Move to `(1, 1)`, where there's a robber stealing `2` coins. The robot uses one neutralization here, avoiding the robbery (total coins = `1`).
+4.  Move to `(1, 2)`, gaining `3` coins (total coins = `1 + 3 = 4`).
+5.  Move to `(2, 2)`, gaining `4` coins (total coins = `4 + 4 = 8`).
+
+**Example 2:**
+
+**Input:** coins = [[10,10,10],[10,10,10]]
+
+**Output:** 40
+
+**Explanation:**
+
+An optimal path for maximum coins is:
+
+1.  Start at `(0, 0)` with `10` coins (total coins = `10`).
+2.  Move to `(0, 1)`, gaining `10` coins (total coins = `10 + 10 = 20`).
+3.  Move to `(0, 2)`, gaining another `10` coins (total coins = `20 + 10 = 30`).
+4.  Move to `(1, 2)`, gaining the final `10` coins (total coins = `30 + 10 = 40`).
+
+**Constraints:**
+
+*   `m == coins.length`
+*   `n == coins[i].length`
+*   `1 <= m, n <= 500`
+*   `-1000 <= coins[i][j] <= 1000`

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

@@ -0,0 +1,73 @@
+package g3401_3500.s3419_minimize_the_maximum_edge_weight_of_graph;
+
+// #Medium #2025_01_12_Time_1014_(100.00%)_Space_114.21_(100.00%)
+
+import java.util.ArrayList;
+import java.util.LinkedList;
+import java.util.List;
+import java.util.Queue;
+
+@SuppressWarnings({"unused", "java:S1172"})
+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<>();
+        for (int i = 0; i < n; i++) {
+            adj.add(new ArrayList<>());
+        }
+        for (int[] e : edges) {
+            if (e[2] <= maxi) {
+                adj.get(e[0]).add(e[1]);
+            }
+        }
+        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<>());
+        }
+        for (int i = 0; i < n; i++) {
+            for (int nb : adj.get(i)) {
+                rev.get(nb).add(i);
+            }
+        }
+        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++;
+                }
+            }
+        }
+        return cnt == n;
+    }
+}

src/main/java/g3401_3500/s3419_minimize_the_maximum_edge_weight_of_graph/readme.md

@@ -0,0 +1,64 @@
+3419\. Minimize the Maximum Edge Weight of Graph
+
+Medium
+
+You are given two integers, `n` and `threshold`, as well as a **directed** weighted graph of `n` nodes numbered from 0 to `n - 1`. The graph is represented by a **2D** integer array `edges`, where <code>edges[i] = [A<sub>i</sub>, B<sub>i</sub>, W<sub>i</sub>]</code> indicates that there is an edge going from node <code>A<sub>i</sub></code> to node <code>B<sub>i</sub></code> with weight <code>W<sub>i</sub></code>.
+
+You have to remove some edges from this graph (possibly **none**), so that it satisfies the following conditions:
+
+*   Node 0 must be reachable from all other nodes.
+*   The **maximum** edge weight in the resulting graph is **minimized**.
+*   Each node has **at most** `threshold` outgoing edges.
+
+Return the **minimum** possible value of the **maximum** edge weight after removing the necessary edges. If it is impossible for all conditions to be satisfied, return -1.
+
+**Example 1:**
+
+**Input:** n = 5, edges = [[1,0,1],[2,0,2],[3,0,1],[4,3,1],[2,1,1]], threshold = 2
+
+**Output:** 1
+
+**Explanation:**
+
+![](https://assets.leetcode.com/uploads/2024/12/09/s-1.png)
+
+Remove the edge `2 -> 0`. The maximum weight among the remaining edges is 1.
+
+**Example 2:**
+
+**Input:** n = 5, edges = [[0,1,1],[0,2,2],[0,3,1],[0,4,1],[1,2,1],[1,4,1]], threshold = 1
+
+**Output:** \-1
+
+**Explanation:**
+
+It is impossible to reach node 0 from node 2.
+
+**Example 3:**
+
+**Input:** n = 5, edges = [[1,2,1],[1,3,3],[1,4,5],[2,3,2],[3,4,2],[4,0,1]], threshold = 1
+
+**Output:** 2
+
+**Explanation:**
+
+![](https://assets.leetcode.com/uploads/2024/12/09/s2-1.png)
+
+Remove the edges `1 -> 3` and `1 -> 4`. The maximum weight among the remaining edges is 2.
+
+**Example 4:**
+
+**Input:** n = 5, edges = [[1,2,1],[1,3,3],[1,4,5],[2,3,2],[4,0,1]], threshold = 1
+
+**Output:** \-1
+
+**Constraints:**
+
+*   <code>2 <= n <= 10<sup>5</sup></code>
+*   `1 <= threshold <= n - 1`
+*   <code>1 <= edges.length <= min(10<sup>5</sup>, n * (n - 1) / 2).</code>
+*   `edges[i].length == 3`
+*   <code>0 <= A<sub>i</sub>, B<sub>i</sub> < n</code>
+*   <code>A<sub>i</sub> != B<sub>i</sub></code>
+*   <code>1 <= W<sub>i</sub> <= 10<sup>6</sup></code>
+*   There **may be** multiple edges between a pair of nodes, but they must have unique weights.

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

@@ -0,0 +1,38 @@
+package g3401_3500.s3420_count_non_decreasing_subarrays_after_k_operations;
+
+// #Hard #2025_01_12_Time_31_(100.00%)_Space_62.21_(100.00%)
+
+import java.util.ArrayDeque;
+import java.util.Deque;
+
+public class Solution {
+    public long countNonDecreasingSubarrays(int[] nums, long k) {
+        // Reverse the array
+        int n = nums.length;
+        for (int i = 0; i < n / 2; ++i) {
+            int temp = nums[i];
+            nums[i] = nums[n - 1 - i];
+            nums[n - 1 - i] = temp;
+        }
+
+        long res = 0;
+        Deque<Integer> q = new ArrayDeque<>();
+        for (int j = 0, i = 0; j < nums.length; ++j) {
+            while (!q.isEmpty() && nums[q.peekLast()] < nums[j]) {
+                int r = q.pollLast();
+                int l = q.isEmpty() ? i - 1 : q.peekLast();
+                k -= (long) (r - l) * (nums[j] - nums[r]);
+            }
+            q.addLast(j);
+            while (k < 0) {
+                k += nums[q.peekFirst()] - nums[i];
+                if (q.peekFirst() == i) {
+                    q.pollFirst();
+                }
+                ++i;
+            }
+            res += j - i + 1;
+        }
+        return res;
+    }
+}