Added task 3566-3569

Author: javadev

src/main/kotlin/g3501_3600/s3566_partition_array_into_two_equal_product_subsets/Solution.kt

@@ -0,0 +1,18 @@
+package g3501_3600.s3566_partition_array_into_two_equal_product_subsets
+
+// #Medium #2025_06_01_Time_1_ms_(100.00%)_Space_42.26_MB_(100.00%)
+
+class Solution {
+    fun checkEqualPartitions(nums: IntArray, target: Long): Boolean {
+        for (num in nums) {
+            if (target % num != 0L) {
+                return false
+            }
+        }
+        var pro: Long = 1
+        for (n in nums) {
+            pro *= n
+        }
+        return pro == target * target
+    }
+}

src/main/kotlin/g3501_3600/s3566_partition_array_into_two_equal_product_subsets/readme.md

@@ -0,0 +1,34 @@
+3566\. Partition Array into Two Equal Product Subsets
+
+Medium
+
+You are given an integer array `nums` containing **distinct** positive integers and an integer `target`.
+
+Determine if you can partition `nums` into two **non-empty** **disjoint** **subsets**, with each element belonging to **exactly one** subset, such that the product of the elements in each subset is equal to `target`.
+
+Return `true` if such a partition exists and `false` otherwise.
+
+A **subset** of an array is a selection of elements of the array.
+
+**Example 1:**
+
+**Input:** nums = [3,1,6,8,4], target = 24
+
+**Output:** true
+
+**Explanation:** The subsets `[3, 8]` and `[1, 6, 4]` each have a product of 24. Hence, the output is true.
+
+**Example 2:**
+
+**Input:** nums = [2,5,3,7], target = 15
+
+**Output:** false
+
+**Explanation:** There is no way to partition `nums` into two non-empty disjoint subsets such that both subsets have a product of 15. Hence, the output is false.
+
+**Constraints:**
+
+*   `3 <= nums.length <= 12`
+*   <code>1 <= target <= 10<sup>15</sup></code>
+*   `1 <= nums[i] <= 100`
+*   All elements of `nums` are **distinct**.

src/main/kotlin/g3501_3600/s3567_minimum_absolute_difference_in_sliding_submatrix/Solution.kt

@@ -0,0 +1,37 @@
+package g3501_3600.s3567_minimum_absolute_difference_in_sliding_submatrix
+
+// #Medium #2025_06_01_Time_18_ms_(100.00%)_Space_53.66_MB_(25.00%)
+
+import kotlin.math.min
+
+class Solution {
+    fun minAbsDiff(grid: Array<IntArray>, k: Int): Array<IntArray> {
+        val rows = grid.size
+        val cols = grid[0].size
+        val result = Array<IntArray>(rows - k + 1) { IntArray(cols - k + 1) }
+        for (x in 0..rows - k) {
+            for (y in 0..cols - k) {
+                val size = k * k
+                val elements = IntArray(size)
+                var idx = 0
+                for (i in x..<x + k) {
+                    for (j in y..<y + k) {
+                        elements[idx++] = grid[i][j]
+                    }
+                }
+                elements.sort()
+                var minDiff = Int.Companion.MAX_VALUE
+                for (i in 1..<size) {
+                    if (elements[i] != elements[i - 1]) {
+                        minDiff = min(minDiff, elements[i] - elements[i - 1])
+                        if (minDiff == 1) {
+                            break
+                        }
+                    }
+                }
+                result[x][y] = if (minDiff == Int.Companion.MAX_VALUE) 0 else minDiff
+            }
+        }
+        return result
+    }
+}

src/main/kotlin/g3501_3600/s3567_minimum_absolute_difference_in_sliding_submatrix/readme.md

@@ -0,0 +1,60 @@
+3567\. Minimum Absolute Difference in Sliding Submatrix
+
+Medium
+
+You are given an `m x n` integer matrix `grid` and an integer `k`.
+
+For every contiguous `k x k` **submatrix** of `grid`, compute the **minimum absolute** difference between any two **distinct** values within that **submatrix**.
+
+Return a 2D array `ans` of size `(m - k + 1) x (n - k + 1)`, where `ans[i][j]` is the minimum absolute difference in the submatrix whose top-left corner is `(i, j)` in `grid`.
+
+**Note**: If all elements in the submatrix have the same value, the answer will be 0.
+
+A submatrix `(x1, y1, x2, y2)` is a matrix that is formed by choosing all cells `matrix[x][y]` where `x1 <= x <= x2` and `y1 <= y <= y2`.
+
+**Example 1:**
+
+**Input:** grid = [[1,8],[3,-2]], k = 2
+
+**Output:** [[2]]
+
+**Explanation:**
+
+*   There is only one possible `k x k` submatrix: `[[1, 8], [3, -2]]`.
+*   Distinct values in the submatrix are `[1, 8, 3, -2]`.
+*   The minimum absolute difference in the submatrix is `|1 - 3| = 2`. Thus, the answer is `[[2]]`.
+
+**Example 2:**
+
+**Input:** grid = [[3,-1]], k = 1
+
+**Output:** [[0,0]]
+
+**Explanation:**
+
+*   Both `k x k` submatrix has only one distinct element.
+*   Thus, the answer is `[[0, 0]]`.
+
+**Example 3:**
+
+**Input:** grid = [[1,-2,3],[2,3,5]], k = 2
+
+**Output:** [[1,2]]
+
+**Explanation:**
+
+*   There are two possible `k × k` submatrix:
+    *   Starting at `(0, 0)`: `[[1, -2], [2, 3]]`.
+        *   Distinct values in the submatrix are `[1, -2, 2, 3]`.
+        *   The minimum absolute difference in the submatrix is `|1 - 2| = 1`.
+    *   Starting at `(0, 1)`: `[[-2, 3], [3, 5]]`.
+        *   Distinct values in the submatrix are `[-2, 3, 5]`.
+        *   The minimum absolute difference in the submatrix is `|3 - 5| = 2`.
+*   Thus, the answer is `[[1, 2]]`.
+
+**Constraints:**
+
+*   `1 <= m == grid.length <= 30`
+*   `1 <= n == grid[i].length <= 30`
+*   <code>-10<sup>5</sup> <= grid[i][j] <= 10<sup>5</sup></code>
+*   `1 <= k <= min(m, n)`

src/main/kotlin/g3501_3600/s3568_minimum_moves_to_clean_the_classroom/Solution.kt

@@ -0,0 +1,82 @@
+package g3501_3600.s3568_minimum_moves_to_clean_the_classroom
+
+// #Medium #2025_06_01_Time_149_ms_(100.00%)_Space_64.20_MB_(100.00%)
+
+import java.util.ArrayDeque
+import java.util.Queue
+
+class Solution {
+    private class State(var x: Int, var y: Int, var energy: Int, var mask: Int, var steps: Int)
+
+    fun minMoves(classroom: Array<String>, energy: Int): Int {
+        val m = classroom.size
+        val n = classroom[0].length
+        val grid = Array<CharArray>(m) { CharArray(n) }
+        for (i in 0..<m) {
+            grid[i] = classroom[i].toCharArray()
+        }
+        var startX = -1
+        var startY = -1
+        val lumetarkon: MutableList<IntArray> = ArrayList<IntArray>()
+        for (i in 0..<m) {
+            for (j in 0..<n) {
+                val c = grid[i][j]
+                if (c == 'S') {
+                    startX = i
+                    startY = j
+                } else if (c == 'L') {
+                    lumetarkon.add(intArrayOf(i, j))
+                }
+            }
+        }
+        val totalLitter = lumetarkon.size
+        val allMask = (1 shl totalLitter) - 1
+        val visited: Array<Array<IntArray>> =
+            Array<Array<IntArray>>(m) { Array<IntArray>(n) { IntArray(1 shl totalLitter) } }
+        for (layer in visited) {
+            for (row in layer) {
+                row.fill(-1)
+            }
+        }
+        val queue: Queue<State> = ArrayDeque<State>()
+        queue.offer(State(startX, startY, energy, 0, 0))
+        visited[startX][startY][0] = energy
+        val dirs = arrayOf<IntArray>(intArrayOf(0, 1), intArrayOf(1, 0), intArrayOf(0, -1), intArrayOf(-1, 0))
+        while (!queue.isEmpty()) {
+            val curr = queue.poll()
+            if (curr.mask == allMask) {
+                return curr.steps
+            }
+            for (dir in dirs) {
+                val nx = curr.x + dir[0]
+                val ny = curr.y + dir[1]
+                if (nx < 0 || ny < 0 || nx >= m || ny >= n || grid[nx][ny] == 'X') {
+                    continue
+                }
+                var nextEnergy = curr.energy - 1
+                if (nextEnergy < 0) {
+                    continue
+                }
+                val cell = grid[nx][ny]
+                if (cell == 'R') {
+                    nextEnergy = energy
+                }
+                var nextMask = curr.mask
+                if (cell == 'L') {
+                    for (i in lumetarkon.indices) {
+                        val pos = lumetarkon[i]
+                        if (pos[0] == nx && pos[1] == ny) {
+                            nextMask = nextMask or (1 shl i)
+                            break
+                        }
+                    }
+                }
+                if (visited[nx][ny][nextMask] < nextEnergy) {
+                    visited[nx][ny][nextMask] = nextEnergy
+                    queue.offer(State(nx, ny, nextEnergy, nextMask, curr.steps + 1))
+                }
+            }
+        }
+        return -1
+    }
+}

src/main/kotlin/g3501_3600/s3568_minimum_moves_to_clean_the_classroom/readme.md

@@ -0,0 +1,66 @@
+3568\. Minimum Moves to Clean the Classroom
+
+Medium
+
+You are given an `m x n` grid `classroom` where a student volunteer is tasked with cleaning up litter scattered around the room. Each cell in the grid is one of the following:
+
+*   `'S'`: Starting position of the student
+*   `'L'`: Litter that must be collected (once collected, the cell becomes empty)
+*   `'R'`: Reset area that restores the student's energy to full capacity, regardless of their current energy level (can be used multiple times)
+*   `'X'`: Obstacle the student cannot pass through
+*   `'.'`: Empty space
+
+You are also given an integer `energy`, representing the student's maximum energy capacity. The student starts with this energy from the starting position `'S'`.
+
+Each move to an adjacent cell (up, down, left, or right) costs 1 unit of energy. If the energy reaches 0, the student can only continue if they are on a reset area `'R'`, which resets the energy to its **maximum** capacity `energy`.
+
+Return the **minimum** number of moves required to collect all litter items, or `-1` if it's impossible.
+
+**Example 1:**
+
+**Input:** classroom = ["S.", "XL"], energy = 2
+
+**Output:** 2
+
+**Explanation:**
+
+*   The student starts at cell `(0, 0)` with 2 units of energy.
+*   Since cell `(1, 0)` contains an obstacle 'X', the student cannot move directly downward.
+*   A valid sequence of moves to collect all litter is as follows:
+    *   Move 1: From `(0, 0)` → `(0, 1)` with 1 unit of energy and 1 unit remaining.
+    *   Move 2: From `(0, 1)` → `(1, 1)` to collect the litter `'L'`.
+*   The student collects all the litter using 2 moves. Thus, the output is 2.
+
+**Example 2:**
+
+**Input:** classroom = ["LS", "RL"], energy = 4
+
+**Output:** 3
+
+**Explanation:**
+
+*   The student starts at cell `(0, 1)` with 4 units of energy.
+*   A valid sequence of moves to collect all litter is as follows:
+    *   Move 1: From `(0, 1)` → `(0, 0)` to collect the first litter `'L'` with 1 unit of energy used and 3 units remaining.
+    *   Move 2: From `(0, 0)` → `(1, 0)` to `'R'` to reset and restore energy back to 4.
+    *   Move 3: From `(1, 0)` → `(1, 1)` to collect the second litter `'L'`.
+*   The student collects all the litter using 3 moves. Thus, the output is 3.
+
+**Example 3:**
+
+**Input:** classroom = ["L.S", "RXL"], energy = 3
+
+**Output:** \-1
+
+**Explanation:**
+
+No valid path collects all `'L'`.
+
+**Constraints:**
+
+*   `1 <= m == classroom.length <= 20`
+*   `1 <= n == classroom[i].length <= 20`
+*   `classroom[i][j]` is one of `'S'`, `'L'`, `'R'`, `'X'`, or `'.'`
+*   `1 <= energy <= 50`
+*   There is exactly **one** `'S'` in the grid.
+*   There are **at most** 10 `'L'` cells in the grid.