Added tasks 3618-3625

Author: javadev

README.md

@@ -2088,6 +2088,14 @@
 
 | #    |      Title     | Difficulty  | Tag         | Time, ms | Time, %
 |------|----------------|-------------|-------------|----------|--------
+| 3625 |[Count Number of Trapezoids II](src/main/java/g3601_3700/s3625_count_number_of_trapezoids_ii)| Hard | Array, Hash_Table, Math, Geometry, Weekly_Contest_459 | 347 | 99.10
+| 3624 |[Number of Integers With Popcount-Depth Equal to K II](src/main/java/g3601_3700/s3624_number_of_integers_with_popcount_depth_equal_to_k_ii)| Hard | Array, Segment_Tree, Weekly_Contest_459 | 27 | 96.44
+| 3623 |[Count Number of Trapezoids I](src/main/java/g3601_3700/s3623_count_number_of_trapezoids_i)| Medium | Array, Hash_Table, Math, Geometry, Weekly_Contest_459 | 30 | 99.92
+| 3622 |[Check Divisibility by Digit Sum and Product](src/main/java/g3601_3700/s3622_check_divisibility_by_digit_sum_and_product)| Easy | Math, Weekly_Contest_459 | 0 | 100.00
+| 3621 |[Number of Integers With Popcount-Depth Equal to K I](src/main/java/g3601_3700/s3621_number_of_integers_with_popcount_depth_equal_to_k_i)| Hard | Dynamic_Programming, Math, Combinatorics, Biweekly_Contest_161 | 9 | 70.67
+| 3620 |[Network Recovery Pathways](src/main/java/g3601_3700/s3620_network_recovery_pathways)| Hard | Array, Dynamic_Programming, Binary_Search, Heap_Priority_Queue, Graph, Topological_Sort, Shortest_Path, Biweekly_Contest_161 | 151 | 66.08
+| 3619 |[Count Islands With Total Value Divisible by K](src/main/java/g3601_3700/s3619_count_islands_with_total_value_divisible_by_k)| Medium | Array, Depth_First_Search, Breadth_First_Search, Matrix, Union_Find, Biweekly_Contest_161 | 16 | 96.65
+| 3618 |[Split Array by Prime Indices](src/main/java/g3601_3700/s3618_split_array_by_prime_indices)| Medium | Array, Math, Number_Theory, Biweekly_Contest_161 | 3 | 100.00
 | 3617 |[Find Students with Study Spiral Pattern](src/main/java/g3601_3700/s3617_find_students_with_study_spiral_pattern)| Hard | Database | 553 | 100.00
 | 3615 |[Longest Palindromic Path in Graph](src/main/java/g3601_3700/s3615_longest_palindromic_path_in_graph)| Hard | String, Dynamic_Programming, Bit_Manipulation, Graph | 641 | 100.00
 | 3614 |[Process String with Special Operations II](src/main/java/g3601_3700/s3614_process_string_with_special_operations_ii)| Hard | String, Simulation | 33 | 100.00

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

@@ -0,0 +1,95 @@
+[![](https://img.shields.io/github/stars/javadev/LeetCode-in-Java?label=Stars&style=flat-square)](https://github.com/javadev/LeetCode-in-Java)
+[![](https://img.shields.io/github/forks/javadev/LeetCode-in-Java?label=Fork%20me%20on%20GitHub%20&style=flat-square)](https://github.com/javadev/LeetCode-in-Java/fork)
+
+## 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>
+
+## Solution
+
+```java
+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/s3619_count_islands_with_total_value_divisible_by_k/readme.md

@@ -0,0 +1,96 @@
+[![](https://img.shields.io/github/stars/javadev/LeetCode-in-Java?label=Stars&style=flat-square)](https://github.com/javadev/LeetCode-in-Java)
+[![](https://img.shields.io/github/forks/javadev/LeetCode-in-Java?label=Fork%20me%20on%20GitHub%20&style=flat-square)](https://github.com/javadev/LeetCode-in-Java/fork)
+
+## 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>
+
+## Solution
+
+```java
+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;
+    }
+}
+```