Added tasks 3566-3569

Author: javadev

src/main/java/g0101_0200/s0178_rank_scores/script.sql

@@ -7,4 +7,3 @@ FROM
     Scores
 ORDER BY
     Rank ASC;
-

src/main/java/g0101_0200/s0182_duplicate_emails/script.sql

@@ -8,4 +8,3 @@ GROUP BY
     Email
 HAVING
     COUNT(Email) > 1;
-

src/main/java/g3501_3600/s3558_number_of_ways_to_assign_edge_weights_i/Solution.java

@@ -1,6 +1,6 @@
 package g3501_3600.s3558_number_of_ways_to_assign_edge_weights_i;
 
-// #Medium #Math #Tree #Depth_First_Search #2025_05_27_Time_12_ms_(100.00%)_Space_106.62_MB_(76.01%)
+// #Medium #Math #Depth_First_Search #Tree #2025_05_27_Time_12_ms_(100.00%)_Space_106.62_MB_(76.01%)
 
 public class Solution {
     private static int mod = (int) 1e9 + 7;

src/main/java/g3501_3600/s3559_number_of_ways_to_assign_edge_weights_ii/Solution.java

@@ -1,6 +1,6 @@
 package g3501_3600.s3559_number_of_ways_to_assign_edge_weights_ii;
 
-// #Hard #Array #Dynamic_Programming #Math #Tree #Depth_First_Search
+// #Hard #Array #Dynamic_Programming #Math #Depth_First_Search #Tree
 // #2025_05_27_Time_138_ms_(64.66%)_Space_133.20_MB_(11.56%)
 
 import java.util.ArrayList;

src/main/java/g3501_3600/s3562_maximum_profit_from_trading_stocks_with_discounts/Solution.java

@@ -1,6 +1,6 @@
 package g3501_3600.s3562_maximum_profit_from_trading_stocks_with_discounts;
 
-// #Hard #Array #Dynamic_Programming #Tree #Depth_First_Search
+// #Hard #Array #Dynamic_Programming #Depth_First_Search #Tree
 // #2025_05_27_Time_27_ms_(100.00%)_Space_45.29_MB_(82.12%)
 
 import java.util.ArrayList;

src/main/java/g3501_3600/s3566_partition_array_into_two_equal_product_subsets/Solution.java

@@ -0,0 +1,19 @@
+package g3501_3600.s3566_partition_array_into_two_equal_product_subsets;
+
+// #Medium #Array #Bit_Manipulation #Recursion #Enumeration
+// #2025_06_03_Time_0_ms_(100.00%)_Space_42.45_MB_(36.66%)
+
+public class Solution {
+    public boolean checkEqualPartitions(int[] nums, long target) {
+        for (int num : nums) {
+            if (target % num != 0) {
+                return false;
+            }
+        }
+        long pro = 1;
+        for (long n : nums) {
+            pro *= n;
+        }
+        return pro == target * target;
+    }
+}

src/main/java/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/java/g3501_3600/s3567_minimum_absolute_difference_in_sliding_submatrix/Solution.java

@@ -0,0 +1,37 @@
+package g3501_3600.s3567_minimum_absolute_difference_in_sliding_submatrix;
+
+// #Medium #Array #Sorting #Matrix #2025_06_03_Time_7_ms_(99.69%)_Space_45.24_MB_(99.03%)
+
+import java.util.Arrays;
+
+public class Solution {
+    public int[][] minAbsDiff(int[][] grid, int k) {
+        int rows = grid.length;
+        int cols = grid[0].length;
+        int[][] result = new int[rows - k + 1][cols - k + 1];
+        for (int x = 0; x <= rows - k; x++) {
+            for (int y = 0; y <= cols - k; y++) {
+                int size = k * k;
+                int[] elements = new int[size];
+                int idx = 0;
+                for (int i = x; i < x + k; i++) {
+                    for (int j = y; j < y + k; j++) {
+                        elements[idx++] = grid[i][j];
+                    }
+                }
+                Arrays.sort(elements);
+                int minDiff = Integer.MAX_VALUE;
+                for (int i = 1; i < size; i++) {
+                    if (elements[i] != elements[i - 1]) {
+                        minDiff = Math.min(minDiff, elements[i] - elements[i - 1]);
+                        if (minDiff == 1) {
+                            break;
+                        }
+                    }
+                }
+                result[x][y] = minDiff == Integer.MAX_VALUE ? 0 : minDiff;
+            }
+        }
+        return result;
+    }
+}

src/main/java/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/java/g3501_3600/s3568_minimum_moves_to_clean_the_classroom/Solution.java

@@ -0,0 +1,100 @@
+package g3501_3600.s3568_minimum_moves_to_clean_the_classroom;
+
+// #Medium #Array #Hash_Table #Breadth_First_Search #Matrix #Bit_Manipulation
+// #2025_06_03_Time_94_ms_(99.86%)_Space_53.76_MB_(99.86%)
+
+import java.util.ArrayDeque;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.List;
+import java.util.Queue;
+
+@SuppressWarnings({"java:S135", "java:S6541"})
+public class Solution {
+    private static class State {
+        int x;
+        int y;
+        int energy;
+        int mask;
+        int steps;
+
+        State(int x, int y, int energy, int mask, int steps) {
+            this.x = x;
+            this.y = y;
+            this.energy = energy;
+            this.mask = mask;
+            this.steps = steps;
+        }
+    }
+
+    public int minMoves(String[] classroom, int energy) {
+        int m = classroom.length;
+        int n = classroom[0].length();
+        char[][] grid = new char[m][n];
+        for (int i = 0; i < m; i++) {
+            grid[i] = classroom[i].toCharArray();
+        }
+        int startX = -1;
+        int startY = -1;
+        List<int[]> lumetarkon = new ArrayList<>();
+        for (int i = 0; i < m; i++) {
+            for (int j = 0; j < n; j++) {
+                char c = grid[i][j];
+                if (c == 'S') {
+                    startX = i;
+                    startY = j;
+                } else if (c == 'L') {
+                    lumetarkon.add(new int[] {i, j});
+                }
+            }
+        }
+        int totalLitter = lumetarkon.size();
+        int allMask = (1 << totalLitter) - 1;
+        int[][][] visited = new int[m][n][1 << totalLitter];
+        for (int[][] layer : visited) {
+            for (int[] row : layer) {
+                Arrays.fill(row, -1);
+            }
+        }
+        Queue<State> queue = new ArrayDeque<>();
+        queue.offer(new State(startX, startY, energy, 0, 0));
+        visited[startX][startY][0] = energy;
+        int[][] dirs = {{0, 1}, {1, 0}, {0, -1}, {-1, 0}};
+        while (!queue.isEmpty()) {
+            State curr = queue.poll();
+            if (curr.mask == allMask) {
+                return curr.steps;
+            }
+            for (int[] dir : dirs) {
+                int nx = curr.x + dir[0];
+                int ny = curr.y + dir[1];
+                if (nx < 0 || ny < 0 || nx >= m || ny >= n || grid[nx][ny] == 'X') {
+                    continue;
+                }
+                int nextEnergy = curr.energy - 1;
+                if (nextEnergy < 0) {
+                    continue;
+                }
+                char cell = grid[nx][ny];
+                if (cell == 'R') {
+                    nextEnergy = energy;
+                }
+                int nextMask = curr.mask;
+                if (cell == 'L') {
+                    for (int i = 0; i < lumetarkon.size(); i++) {
+                        int[] pos = lumetarkon.get(i);
+                        if (pos[0] == nx && pos[1] == ny) {
+                            nextMask |= (1 << i);
+                            break;
+                        }
+                    }
+                }
+                if (visited[nx][ny][nextMask] < nextEnergy) {
+                    visited[nx][ny][nextMask] = nextEnergy;
+                    queue.offer(new State(nx, ny, nextEnergy, nextMask, curr.steps + 1));
+                }
+            }
+        }
+        return -1;
+    }
+}