Added tasks 3379-3382

Author: javadev

src/main/java/g3301_3400/s3375_minimum_operations_to_make_array_values_equal_to_k/Solution.java

@@ -1,6 +1,6 @@
 package g3301_3400.s3375_minimum_operations_to_make_array_values_equal_to_k;
 
-// #Easy #2024_12_07_Time_3_ms_(100.00%)_Space_44.5_MB_(100.00%)
+// #Easy #Array #Hash_Table #2024_12_10_Time_3_ms_(78.92%)_Space_44.6_MB_(67.39%)
 
 import java.util.HashSet;
 import java.util.Set;

src/main/java/g3301_3400/s3376_minimum_time_to_break_locks_i/Solution.java

@@ -1,43 +1,53 @@
 package g3301_3400.s3376_minimum_time_to_break_locks_i;
 
-// #Medium #2024_12_07_Time_760_ms_(100.00%)_Space_45_MB_(100.00%)
+// #Medium #Array #Dynamic_Programming #Bit_Manipulation #Backtracking #Bitmask
+// #2024_12_10_Time_3_ms_(99.63%)_Space_42_MB_(92.34%)
 
 import java.util.ArrayList;
 import java.util.Collections;
 import java.util.List;
 
 public class Solution {
     public int findMinimumTime(List<Integer> strength, int k) {
-        List<Integer> perm = new ArrayList<>(strength);
-        Collections.sort(perm);
-        int minTime = Integer.MAX_VALUE;
-        do {
-            int time = 0;
-            int factor = 1;
-            for (int required : perm) {
-                int neededTime = (required + factor - 1) / factor;
-                time += neededTime;
-                factor += k;
+        List<Integer> strengthLocal = new ArrayList<>(strength);
+        Collections.sort(strengthLocal);
+        int res = strengthLocal.get(0);
+        strengthLocal.remove(0);
+        int x = 1;
+        while (!strengthLocal.isEmpty()) {
+            x += k;
+            int nextTime = (strengthLocal.get(0) - 1) / x + 1;
+            int canBreak = nextTime * x;
+            int indexRemove = findIndex(strengthLocal, canBreak);
+            if (strengthLocal.size() > 1) {
+                int nextTime1 = (strengthLocal.get(1) - 1) / x + 1;
+                int canBreak1 = nextTime1 * x;
+                int indexRemove1 = findIndex(strengthLocal, canBreak1);
+                if (nextTime1 + (strengthLocal.get(0) - 1) / (x + k)
+                        < nextTime + (strengthLocal.get(1) - 1) / (x + k)) {
+                    nextTime = nextTime1;
+                    indexRemove = indexRemove1;
+                }
             }
-            minTime = Math.min(minTime, time);
-        } while (nextPermutation(perm));
-        return minTime;
+            res += nextTime;
+            strengthLocal.remove(indexRemove);
+        }
+        return res;
     }
 
-    private boolean nextPermutation(List<Integer> nums) {
-        int i = nums.size() - 2;
-        while (i >= 0 && nums.get(i) >= nums.get(i + 1)) {
-            i--;
-        }
-        if (i < 0) {
-            return false;
-        }
-        int j = nums.size() - 1;
-        while (nums.get(j) <= nums.get(i)) {
-            j--;
+    private int findIndex(List<Integer> strength, int canBreak) {
+        int l = 0;
+        int r = strength.size() - 1;
+        int res = -1;
+        while (l <= r) {
+            int mid = (l + r) / 2;
+            if (strength.get(mid) <= canBreak) {
+                res = mid;
+                l = mid + 1;
+            } else {
+                r = mid - 1;
+            }
         }
-        Collections.swap(nums, i, j);
-        Collections.reverse(nums.subList(i + 1, nums.size()));
-        return true;
+        return res;
     }
 }

src/main/java/g3301_3400/s3377_digit_operations_to_make_two_integers_equal/Solution.java

@@ -1,6 +1,7 @@
 package g3301_3400.s3377_digit_operations_to_make_two_integers_equal;
 
-// #Medium #2024_12_07_Time_255_ms_(100.00%)_Space_44.9_MB_(100.00%)
+// #Medium #Math #Heap_Priority_Queue #Graph #Shortest_Path #Number_Theory
+// #2024_12_10_Time_246_ms_(38.59%)_Space_45.2_MB_(73.52%)
 
 import java.util.Arrays;
 import java.util.PriorityQueue;

src/main/java/g3301_3400/s3378_count_connected_components_in_lcm_graph/Solution.java

@@ -1,6 +1,7 @@
 package g3301_3400.s3378_count_connected_components_in_lcm_graph;
 
-// #Hard #2024_12_07_Time_48_ms_(100.00%)_Space_59.5_MB_(100.00%)
+// #Hard #Array #Hash_Table #Math #Union_Find #Number_Theory
+// #2024_12_10_Time_68_ms_(67.83%)_Space_59.8_MB_(62.24%)
 
 import java.util.ArrayList;
 import java.util.Arrays;

src/main/java/g3301_3400/s3379_transformed_array/Solution.java

@@ -0,0 +1,22 @@
+package g3301_3400.s3379_transformed_array;
+
+// #Easy #Array #Simulation #2024_12_10_Time_1_ms_(99.87%)_Space_44.9_MB_(75.08%)
+
+public class Solution {
+    public int[] constructTransformedArray(int[] nums) {
+        int n = nums.length;
+        int[] res = new int[n];
+        for (int i = 0; i < n; i++) {
+            if (nums[i] == 0) {
+                res[i] = nums[i];
+            }
+            if (nums[i] > 0) {
+                res[i] = nums[(i + nums[i]) % n];
+            } else if (nums[i] < 0) {
+                int r = (Math.abs(nums[i])) / n;
+                res[i] = nums[Math.abs((i + nums[i] + r * n + n)) % n];
+            }
+        }
+        return res;
+    }
+}

src/main/java/g3301_3400/s3379_transformed_array/readme.md

@@ -0,0 +1,45 @@
+3379\. Transformed Array
+
+Easy
+
+You are given an integer array `nums` that represents a circular array. Your task is to create a new array `result` of the **same** size, following these rules:
+
+For each index `i` (where `0 <= i < nums.length`), perform the following **independent** actions:
+
+*   If `nums[i] > 0`: Start at index `i` and move `nums[i]` steps to the **right** in the circular array. Set `result[i]` to the value of the index where you land.
+*   If `nums[i] < 0`: Start at index `i` and move `abs(nums[i])` steps to the **left** in the circular array. Set `result[i]` to the value of the index where you land.
+*   If `nums[i] == 0`: Set `result[i]` to `nums[i]`.
+
+Return the new array `result`.
+
+**Note:** Since `nums` is circular, moving past the last element wraps around to the beginning, and moving before the first element wraps back to the end.
+
+**Example 1:**
+
+**Input:** nums = [3,-2,1,1]
+
+**Output:** [1,1,1,3]
+
+**Explanation:**
+
+*   For `nums[0]` that is equal to 3, If we move 3 steps to right, we reach `nums[3]`. So `result[0]` should be 1.
+*   For `nums[1]` that is equal to -2, If we move 2 steps to left, we reach `nums[3]`. So `result[1]` should be 1.
+*   For `nums[2]` that is equal to 1, If we move 1 step to right, we reach `nums[3]`. So `result[2]` should be 1.
+*   For `nums[3]` that is equal to 1, If we move 1 step to right, we reach `nums[0]`. So `result[3]` should be 3.
+
+**Example 2:**
+
+**Input:** nums = [-1,4,-1]
+
+**Output:** [-1,-1,4]
+
+**Explanation:**
+
+*   For `nums[0]` that is equal to -1, If we move 1 step to left, we reach `nums[2]`. So `result[0]` should be -1.
+*   For `nums[1]` that is equal to 4, If we move 4 steps to right, we reach `nums[2]`. So `result[1]` should be -1.
+*   For `nums[2]` that is equal to -1, If we move 1 step to left, we reach `nums[1]`. So `result[2]` should be 4.
+
+**Constraints:**
+
+*   `1 <= nums.length <= 100`
+*   `-100 <= nums[i] <= 100`

src/main/java/g3301_3400/s3380_maximum_area_rectangle_with_point_constraints_i/Solution.java

@@ -0,0 +1,49 @@
+package g3301_3400.s3380_maximum_area_rectangle_with_point_constraints_i;
+
+// #Medium #Array #Math #Sorting #Enumeration #Geometry #Segment_Tree #Binary_Indexed_Tree
+// #2024_12_10_Time_8_ms_(81.05%)_Space_45_MB_(66.32%)
+
+import java.util.Arrays;
+import java.util.HashSet;
+import java.util.Set;
+
+public class Solution {
+    public int maxRectangleArea(int[][] points) {
+        Set<String> set = new HashSet<>();
+        for (int[] p : points) {
+            set.add(Arrays.toString(p));
+        }
+        int maxArea = -1;
+        for (int[] point : points) {
+            for (int j = 1; j < points.length; j++) {
+                int[] p2 = points[j];
+                if (point[0] == p2[0]
+                        || point[1] == p2[1]
+                        || !set.contains(Arrays.toString(new int[] {point[0], p2[1]}))
+                        || !set.contains(Arrays.toString(new int[] {p2[0], point[1]}))
+                        || !validate(points, point, p2)) {
+                    continue;
+                }
+                maxArea = Math.max(maxArea, (p2[1] - point[1]) * (p2[0] - point[0]));
+            }
+        }
+        return maxArea;
+    }
+
+    private boolean validate(int[][] points, int[] p1, int[] p2) {
+        int top = Math.max(p1[1], p2[1]);
+        int bot = Math.min(p1[1], p2[1]);
+        int left = Math.min(p1[0], p2[0]);
+        int right = Math.max(p1[0], p2[0]);
+        for (int[] p : points) {
+            int x = p[0];
+            int y = p[1];
+            if ((y == top || y == bot) && x > left && x < right
+                    || (x == left || x == right) && y > bot && y < top
+                    || (x > left && x < right && y > bot && y < top)) {
+                return false;
+            }
+        }
+        return true;
+    }
+}

src/main/java/g3301_3400/s3380_maximum_area_rectangle_with_point_constraints_i/readme.md

@@ -0,0 +1,56 @@
+3380\. Maximum Area Rectangle With Point Constraints I
+
+Medium
+
+You are given an array `points` where <code>points[i] = [x<sub>i</sub>, y<sub>i</sub>]</code> represents the coordinates of a point on an infinite plane.
+
+Your task is to find the **maximum** area of a rectangle that:
+
+*   Can be formed using **four** of these points as its corners.
+*   Does **not** contain any other point inside or on its border.
+*   Has its edges **parallel** to the axes.
+
+Return the **maximum area** that you can obtain or -1 if no such rectangle is possible.
+
+**Example 1:**
+
+**Input:** points = [[1,1],[1,3],[3,1],[3,3]]
+
+**Output:** 4
+
+**Explanation:**
+
+**![Example 1 diagram](https://assets.leetcode.com/uploads/2024/11/02/example1.png)**
+
+We can make a rectangle with these 4 points as corners and there is no other point that lies inside or on the border. Hence, the maximum possible area would be 4.
+
+**Example 2:**
+
+**Input:** points = [[1,1],[1,3],[3,1],[3,3],[2,2]]
+
+**Output:** \-1
+
+**Explanation:**
+
+**![Example 2 diagram](https://assets.leetcode.com/uploads/2024/11/02/example2.png)**
+
+There is only one rectangle possible is with points `[1,1], [1,3], [3,1]` and `[3,3]` but `[2,2]` will always lie inside it. Hence, returning -1.
+
+**Example 3:**
+
+**Input:** points = [[1,1],[1,3],[3,1],[3,3],[1,2],[3,2]]
+
+**Output:** 2
+
+**Explanation:**
+
+**![Example 3 diagram](https://assets.leetcode.com/uploads/2024/11/02/example3.png)**
+
+The maximum area rectangle is formed by the points `[1,3], [1,2], [3,2], [3,3]`, which has an area of 2. Additionally, the points `[1,1], [1,2], [3,1], [3,2]` also form a valid rectangle with the same area.
+
+**Constraints:**
+
+*   `1 <= points.length <= 10`
+*   `points[i].length == 2`
+*   <code>0 <= x<sub>i</sub>, y<sub>i</sub> <= 100</code>
+*   All the given points are **unique**.

src/main/java/g3301_3400/s3381_maximum_subarray_sum_with_length_divisible_by_k/Solution.java

@@ -0,0 +1,24 @@
+package g3301_3400.s3381_maximum_subarray_sum_with_length_divisible_by_k;
+
+// #Medium #Array #Hash_Table #Prefix_Sum #2024_12_10_Time_4_ms_(100.00%)_Space_80.2_MB_(22.05%)
+
+public class Solution {
+    public long maxSubarraySum(int[] nums, int k) {
+        int n = nums.length;
+        long[] maxSum = new long[n];
+        long minSum = 0;
+        for (int i = n - 1; i > n - k; i--) {
+            maxSum[i] = Integer.MIN_VALUE;
+            minSum += nums[i];
+        }
+        minSum += nums[n - k];
+        maxSum[n - k] = minSum;
+        long ans = minSum;
+        for (int i = n - k - 1; i >= 0; i--) {
+            minSum = minSum + nums[i] - nums[i + k];
+            maxSum[i] = Math.max(minSum, minSum + maxSum[i + k]);
+            ans = Math.max(maxSum[i], ans);
+        }
+        return ans;
+    }
+}

src/main/java/g3301_3400/s3381_maximum_subarray_sum_with_length_divisible_by_k/readme.md

@@ -0,0 +1,44 @@
+3381\. Maximum Subarray Sum With Length Divisible by K
+
+Medium
+
+You are given an array of integers `nums` and an integer `k`.
+
+Return the **maximum** sum of a **non-empty subarray** of `nums`, such that the size of the subarray is **divisible** by `k`.
+
+A **subarray** is a contiguous **non-empty** sequence of elements within an array.
+
+**Example 1:**
+
+**Input:** nums = [1,2], k = 1
+
+**Output:** 3
+
+**Explanation:**
+
+The subarray `[1, 2]` with sum 3 has length equal to 2 which is divisible by 1.
+
+**Example 2:**
+
+**Input:** nums = [-1,-2,-3,-4,-5], k = 4
+
+**Output:** \-10
+
+**Explanation:**
+
+The maximum sum subarray is `[-1, -2, -3, -4]` which has length equal to 4 which is divisible by 4.
+
+**Example 3:**
+
+**Input:** nums = [-5,1,2,-3,4], k = 2
+
+**Output:** 4
+
+**Explanation:**
+
+The maximum sum subarray is `[1, 2, -3, 4]` which has length equal to 4 which is divisible by 2.
+
+**Constraints:**
+
+*   <code>1 <= k <= nums.length <= 2 * 10<sup>5</sup></code>
+*   <code>-10<sup>9</sup> <= nums[i] <= 10<sup>9</sup></code>