Added tasks 3618-3621

Author: javadev

src/main/java/g3601_3700/s3618_split_array_by_prime_indices/Solution.java

@@ -0,0 +1,46 @@
+package g3601_3700.s3618_split_array_by_prime_indices;
+
+// #Medium #2025_07_20_Time_3_ms_(100.00%)_Space_62.52_MB_(100.00%)
+
+public class Solution {
+    public long splitArray(int[] nums) {
+        int n = nums.length;
+        boolean[] isPrime = sieve(n);
+        long sumA = 0;
+        long sumB = 0;
+        for (int i = 0; i < n; i++) {
+            if (isPrime[i]) {
+                sumA += nums[i];
+            } else {
+                sumB += nums[i];
+            }
+        }
+        return Math.abs(sumA - sumB);
+    }
+
+    // Sieve of Eratosthenes to find all prime indices up to n
+    private boolean[] sieve(int n) {
+        boolean[] isPrime = new boolean[n];
+        if (n > 2) {
+            isPrime[2] = true;
+        }
+        for (int i = 3; i < n; i += 2) {
+            isPrime[i] = true;
+        }
+        if (n > 2) {
+            isPrime[2] = true;
+        }
+        for (int i = 3; i * i < n; i += 2) {
+            if (isPrime[i]) {
+                for (int j = i * i; j < n; j += i * 2) {
+                    isPrime[j] = false;
+                }
+            }
+        }
+        isPrime[0] = false;
+        if (n > 1) {
+            isPrime[1] = false;
+        }
+        return isPrime;
+    }
+}

src/main/java/g3601_3700/s3618_split_array_by_prime_indices/readme.md

@@ -0,0 +1,45 @@
+3618\. Split Array by Prime Indices
+
+Medium
+
+You are given an integer array `nums`.
+
+Split `nums` into two arrays `A` and `B` using the following rule:
+
+*   Elements at **prime** indices in `nums` must go into array `A`.
+*   All other elements must go into array `B`.
+
+Return the **absolute** difference between the sums of the two arrays: `|sum(A) - sum(B)|`.
+
+**Note:** An empty array has a sum of 0.
+
+**Example 1:**
+
+**Input:** nums = [2,3,4]
+
+**Output:** 1
+
+**Explanation:**
+
+*   The only prime index in the array is 2, so `nums[2] = 4` is placed in array `A`.
+*   The remaining elements, `nums[0] = 2` and `nums[1] = 3` are placed in array `B`.
+*   `sum(A) = 4`, `sum(B) = 2 + 3 = 5`.
+*   The absolute difference is `|4 - 5| = 1`.
+
+**Example 2:**
+
+**Input:** nums = [-1,5,7,0]
+
+**Output:** 3
+
+**Explanation:**
+
+*   The prime indices in the array are 2 and 3, so `nums[2] = 7` and `nums[3] = 0` are placed in array `A`.
+*   The remaining elements, `nums[0] = -1` and `nums[1] = 5` are placed in array `B`.
+*   `sum(A) = 7 + 0 = 7`, `sum(B) = -1 + 5 = 4`.
+*   The absolute difference is `|7 - 4| = 3`.
+
+**Constraints:**
+
+*   <code>1 <= nums.length <= 10<sup>5</sup></code>
+*   <code>-10<sup>9</sup> <= nums[i] <= 10<sup>9</sup></code>

src/main/java/g3601_3700/s3619_count_islands_with_total_value_divisible_by_k/Solution.java

@@ -0,0 +1,50 @@
+package g3601_3700.s3619_count_islands_with_total_value_divisible_by_k;
+
+// #Medium #2025_07_20_Time_16_ms_(96.67%)_Space_70.90_MB_(100.00%)
+
+public class Solution {
+    private int m;
+    private int n;
+
+    public int countIslands(int[][] grid, int k) {
+        int count = 0;
+        m = grid.length;
+        n = grid[0].length;
+        for (int i = 0; i < m; i++) {
+            for (int j = 0; j < n; j++) {
+                if (grid[i][j] != 0) {
+                    int curr = dfs(i, j, grid);
+                    if (curr % k == 0) {
+                        count++;
+                    }
+                }
+            }
+        }
+        return count;
+    }
+
+    private int dfs(int i, int j, int[][] grid) {
+        if (i >= m || j >= n || i < 0 || j < 0 || grid[i][j] == 0) {
+            return Integer.MAX_VALUE;
+        }
+        int count = grid[i][j];
+        grid[i][j] = 0;
+        int x = dfs(i + 1, j, grid);
+        int y = dfs(i, j + 1, grid);
+        int a = dfs(i - 1, j, grid);
+        int b = dfs(i, j - 1, grid);
+        if (x != Integer.MAX_VALUE) {
+            count += x;
+        }
+        if (y != Integer.MAX_VALUE) {
+            count += y;
+        }
+        if (a != Integer.MAX_VALUE) {
+            count += a;
+        }
+        if (b != Integer.MAX_VALUE) {
+            count += b;
+        }
+        return count;
+    }
+}

src/main/java/g3601_3700/s3619_count_islands_with_total_value_divisible_by_k/readme.md

@@ -0,0 +1,42 @@
+3619\. Count Islands With Total Value Divisible by K
+
+Medium
+
+You are given an `m x n` matrix `grid` and a positive integer `k`. An **island** is a group of **positive** integers (representing land) that are **4-directionally** connected (horizontally or vertically).
+
+The **total value** of an island is the sum of the values of all cells in the island.
+
+Return the number of islands with a total value **divisible by** `k`.
+
+**Example 1:**
+
+![](https://assets.leetcode.com/uploads/2025/03/06/example1griddrawio-1.png)
+
+**Input:** grid = [[0,2,1,0,0],[0,5,0,0,5],[0,0,1,0,0],[0,1,4,7,0],[0,2,0,0,8]], k = 5
+
+**Output:** 2
+
+**Explanation:**
+
+The grid contains four islands. The islands highlighted in blue have a total value that is divisible by 5, while the islands highlighted in red do not.
+
+**Example 2:**
+
+![](https://assets.leetcode.com/uploads/2025/03/06/example2griddrawio.png)
+
+**Input:** grid = [[3,0,3,0], [0,3,0,3], [3,0,3,0]], k = 3
+
+**Output:** 6
+
+**Explanation:**
+
+The grid contains six islands, each with a total value that is divisible by 3.
+
+**Constraints:**
+
+*   `m == grid.length`
+*   `n == grid[i].length`
+*   `1 <= m, n <= 1000`
+*   <code>1 <= m * n <= 10<sup>5</sup></code>
+*   <code>0 <= grid[i][j] <= 10<sup>6</sup></code>
+*   <code>1 <= k <= 10<sup>6</sup></code>

src/main/java/g3601_3700/s3620_network_recovery_pathways/Solution.java

@@ -0,0 +1,59 @@
+package g3601_3700.s3620_network_recovery_pathways;
+
+// #Hard #2025_07_20_Time_18_ms_(100.00%)_Space_120.24_MB_(100.00%)
+
+import java.util.ArrayList;
+
+@SuppressWarnings("unchecked")
+public class Solution {
+    private int ans = -1;
+    private int d;
+    private long k = 0;
+
+    public int findMaxPathScore(int[][] edges, boolean[] online, long k) {
+        int n = online.length;
+        this.k = k;
+        this.d = n - 1;
+        ArrayList<P>[] g = new ArrayList[n];
+        for (int i = 0; i < n; ++i) {
+            g[i] = new ArrayList<>();
+        }
+        for (int[] i : edges) {
+            if (online[i[0]] && online[i[1]]) {
+                g[i[0]].add(new P(i[1], i[2]));
+            }
+        }
+        dfs(g, 0, 0L, Integer.MAX_VALUE);
+        return ans;
+    }
+
+    private void dfs(ArrayList<P>[] g, int s, long tc, int max) {
+        if (s == d) {
+            if (ans == -1) {
+                ans = max;
+            } else {
+                ans = Math.max(ans, max);
+            }
+            return;
+        }
+        for (P i : g[s]) {
+            long cost = tc + i.c;
+            if (ans != -1 && ans >= max) {
+                return;
+            }
+            if (cost <= k) {
+                dfs(g, i.d, cost, Math.min(max, i.c));
+            }
+        }
+    }
+
+    private static final class P {
+        int d;
+        int c;
+
+        P(int d, int c) {
+            this.d = d;
+            this.c = c;
+        }
+    }
+}

src/main/java/g3601_3700/s3620_network_recovery_pathways/readme.md

@@ -0,0 +1,87 @@
+3620\. Network Recovery Pathways
+
+Hard
+
+You are given a directed acyclic graph of `n` nodes numbered from 0 to `n − 1`. This is represented by a 2D array `edges` of length `m`, where <code>edges[i] = [u<sub>i</sub>, v<sub>i</sub>, cost<sub>i</sub>]</code> indicates a one‑way communication from node <code>u<sub>i</sub></code> to node <code>v<sub>i</sub></code> with a recovery cost of <code>cost<sub>i</sub></code>.
+
+Some nodes may be offline. You are given a boolean array `online` where `online[i] = true` means node `i` is online. Nodes 0 and `n − 1` are always online.
+
+A path from 0 to `n − 1` is **valid** if:
+
+*   All intermediate nodes on the path are online.
+*   The total recovery cost of all edges on the path does not exceed `k`.
+
+For each valid path, define its **score** as the minimum edge‑cost along that path.
+
+Return the **maximum** path score (i.e., the largest **minimum**\-edge cost) among all valid paths. If no valid path exists, return -1.
+
+**Example 1:**
+
+**Input:** edges = [[0,1,5],[1,3,10],[0,2,3],[2,3,4]], online = [true,true,true,true], k = 10
+
+**Output:** 3
+
+**Explanation:**
+
+![](https://assets.leetcode.com/uploads/2025/06/06/graph-10.png)
+
+*   The graph has two possible routes from node 0 to node 3:
+    
+    1.  Path `0 → 1 → 3`
+        
+        *   Total cost = `5 + 10 = 15`, which exceeds k (`15 > 10`), so this path is invalid.
+            
+    2.  Path `0 → 2 → 3`
+        
+        *   Total cost = `3 + 4 = 7 <= k`, so this path is valid.
+            
+        *   The minimum edge‐cost along this path is `min(3, 4) = 3`.
+            
+*   There are no other valid paths. Hence, the maximum among all valid path‐scores is 3.
+    
+
+**Example 2:**
+
+**Input:** edges = [[0,1,7],[1,4,5],[0,2,6],[2,3,6],[3,4,2],[2,4,6]], online = [true,true,true,false,true], k = 12
+
+**Output:** 6
+
+**Explanation:**
+
+![](https://assets.leetcode.com/uploads/2025/06/06/graph-11.png)
+
+*   Node 3 is offline, so any path passing through 3 is invalid.
+    
+*   Consider the remaining routes from 0 to 4:
+    
+    1.  Path `0 → 1 → 4`
+        
+        *   Total cost = `7 + 5 = 12 <= k`, so this path is valid.
+            
+        *   The minimum edge‐cost along this path is `min(7, 5) = 5`.
+            
+    2.  Path `0 → 2 → 3 → 4`
+        
+        *   Node 3 is offline, so this path is invalid regardless of cost.
+            
+    3.  Path `0 → 2 → 4`
+        
+        *   Total cost = `6 + 6 = 12 <= k`, so this path is valid.
+            
+        *   The minimum edge‐cost along this path is `min(6, 6) = 6`.
+            
+*   Among the two valid paths, their scores are 5 and 6. Therefore, the answer is 6.
+    
+
+**Constraints:**
+
+*   `n == online.length`
+*   <code>2 <= n <= 5 * 10<sup>4</sup></code>
+*   `0 <= m == edges.length <=` <code>min(10<sup>5</sup>, n * (n - 1) / 2)</code>
+*   <code>edges[i] = [u<sub>i</sub>, v<sub>i</sub>, cost<sub>i</sub>]</code>
+*   <code>0 <= u<sub>i</sub>, v<sub>i</sub> < n</code>
+*   <code>u<sub>i</sub> != v<sub>i</sub></code>
+*   <code>0 <= cost<sub>i</sub> <= 10<sup>9</sup></code>
+*   <code>0 <= k <= 5 * 10<sup>13</sup></code>
+*   `online[i]` is either `true` or `false`, and both `online[0]` and `online[n − 1]` are `true`.
+*   The given graph is a directed acyclic graph.