Added 3618-3625

Author: javadev

README.md

@@ -2088,6 +2088,14 @@
 
 | #    |      Title     | Difficulty  | Tag         | Time, ms | Time, %
 |------|----------------|-------------|-------------|----------|--------
+| 3625 |[Count Number of Trapezoids II](src/main/kotlin/g3601_3700/s3625_count_number_of_trapezoids_ii)| Hard | Array, Hash_Table, Math, Geometry, Weekly_Contest_459 | 377 | 100.00
+| 3624 |[Number of Integers With Popcount-Depth Equal to K II](src/main/kotlin/g3601_3700/s3624_number_of_integers_with_popcount_depth_equal_to_k_ii)| Hard | Array, Segment_Tree, Weekly_Contest_459 | 38 | 100.00
+| 3623 |[Count Number of Trapezoids I](src/main/kotlin/g3601_3700/s3623_count_number_of_trapezoids_i)| Medium | Array, Hash_Table, Math, Geometry, Weekly_Contest_459 | 58 | 68.00
+| 3622 |[Check Divisibility by Digit Sum and Product](src/main/kotlin/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/kotlin/g3601_3700/s3621_number_of_integers_with_popcount_depth_equal_to_k_i)| Hard | Dynamic_Programming, Math, Combinatorics, Biweekly_Contest_161 | 2 | 100.00
+| 3620 |[Network Recovery Pathways](src/main/kotlin/g3601_3700/s3620_network_recovery_pathways)| Hard | Array, Dynamic_Programming, Binary_Search, Heap_Priority_Queue, Graph, Topological_Sort, Shortest_Path, Biweekly_Contest_161 | 212 | 66.67
+| 3619 |[Count Islands With Total Value Divisible by K](src/main/kotlin/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 | 14 | 100.00
+| 3618 |[Split Array by Prime Indices](src/main/kotlin/g3601_3700/s3618_split_array_by_prime_indices)| Medium | Array, Math, Number_Theory, Biweekly_Contest_161 | 6 | 100.00
 | 3617 |[Find Students with Study Spiral Pattern](src/main/kotlin/g3601_3700/s3617_find_students_with_study_spiral_pattern)| Hard | Database | 553 | 100.00
 | 3615 |[Longest Palindromic Path in Graph](src/main/kotlin/g3601_3700/s3615_longest_palindromic_path_in_graph)| Hard | String, Dynamic_Programming, Bit_Manipulation, Graph | 635 | 100.00
 | 3614 |[Process String with Special Operations II](src/main/kotlin/g3601_3700/s3614_process_string_with_special_operations_ii)| Hard | String, Simulation | 37 | 100.00

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

@@ -0,0 +1,105 @@
+[![](https://img.shields.io/github/stars/javadev/LeetCode-in-Kotlin?label=Stars&style=flat-square)](https://github.com/javadev/LeetCode-in-Kotlin)
+[![](https://img.shields.io/github/forks/javadev/LeetCode-in-Kotlin?label=Fork%20me%20on%20GitHub%20&style=flat-square)](https://github.com/javadev/LeetCode-in-Kotlin/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
+
+```kotlin
+import kotlin.math.abs
+
+class Solution {
+    fun splitArray(nums: IntArray): Long {
+        val n = nums.size
+        val isPrime = sieve(n)
+        var sumA: Long = 0
+        var sumB: Long = 0
+        for (i in 0..<n) {
+            if (isPrime[i]) {
+                sumA += nums[i].toLong()
+            } else {
+                sumB += nums[i].toLong()
+            }
+        }
+        return abs(sumA - sumB)
+    }
+
+    // Sieve of Eratosthenes to find all prime indices up to n
+    private fun sieve(n: Int): BooleanArray {
+        val isPrime = BooleanArray(n)
+        if (n > 2) {
+            isPrime[2] = true
+        }
+        run {
+            var i = 3
+            while (i < n) {
+                isPrime[i] = true
+                i += 2
+            }
+        }
+        if (n > 2) {
+            isPrime[2] = true
+        }
+        var i = 3
+        while (i * i < n) {
+            if (isPrime[i]) {
+                var j = i * i
+                while (j < n) {
+                    isPrime[j] = false
+                    j += i * 2
+                }
+            }
+            i += 2
+        }
+        isPrime[0] = false
+        if (n > 1) {
+            isPrime[1] = false
+        }
+        return isPrime
+    }
+}
+```

src/main/kotlin/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-Kotlin?label=Stars&style=flat-square)](https://github.com/javadev/LeetCode-in-Kotlin)
+[![](https://img.shields.io/github/forks/javadev/LeetCode-in-Kotlin?label=Fork%20me%20on%20GitHub%20&style=flat-square)](https://github.com/javadev/LeetCode-in-Kotlin/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
+
+```kotlin
+class Solution {
+    private var m = 0
+    private var n = 0
+
+    fun countIslands(grid: Array<IntArray>, k: Int): Int {
+        var count = 0
+        m = grid.size
+        n = grid[0].size
+        for (i in 0..<m) {
+            for (j in 0..<n) {
+                if (grid[i][j] != 0) {
+                    val curr = dfs(i, j, grid)
+                    if (curr % k == 0) {
+                        count++
+                    }
+                }
+            }
+        }
+        return count
+    }
+
+    private fun dfs(i: Int, j: Int, grid: Array<IntArray>): Int {
+        if (i >= m || j >= n || i < 0 || j < 0 || grid[i][j] == 0) {
+            return Int.Companion.MAX_VALUE
+        }
+        var count = grid[i][j]
+        grid[i][j] = 0
+        val x = dfs(i + 1, j, grid)
+        val y = dfs(i, j + 1, grid)
+        val a = dfs(i - 1, j, grid)
+        val b = dfs(i, j - 1, grid)
+        if (x != Int.Companion.MAX_VALUE) {
+            count += x
+        }
+        if (y != Int.Companion.MAX_VALUE) {
+            count += y
+        }
+        if (a != Int.Companion.MAX_VALUE) {
+            count += a
+        }
+        if (b != Int.Companion.MAX_VALUE) {
+            count += b
+        }
+        return count
+    }
+}
+```