Added tasks 3364-3367

Author: javadev

src/main/java/g3301_3400/s3364_minimum_positive_sum_subarray/Solution.java

@@ -0,0 +1,26 @@
+package g3301_3400.s3364_minimum_positive_sum_subarray;
+
+// #Easy #2024_11_24_Time_28_ms_(100.00%)_Space_44.7_MB_(100.00%)
+
+import java.util.List;
+
+public class Solution {
+    public int minimumSumSubarray(List<Integer> nums, int l, int r) {
+        int size = nums.size();
+        int res = -1;
+        for (int s = l; s <= r; s++) {
+            for (int i = 0; i <= size - s; i++) {
+                int sum = 0;
+                for (int j = i; j < i + s; j++) {
+                    sum += nums.get(j);
+                }
+                if (sum > 0) {
+                    if (res == -1 || res > sum) {
+                        res = sum;
+                    }
+                }
+            }
+        }
+        return res;
+    }
+}

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

@@ -0,0 +1,52 @@
+3364\. Minimum Positive Sum Subarray
+
+Easy
+
+You are given an integer array `nums` and **two** integers `l` and `r`. Your task is to find the **minimum** sum of a **subarray** whose size is between `l` and `r` (inclusive) and whose sum is greater than 0.
+
+Return the **minimum** sum of such a subarray. If no such subarray exists, return -1.
+
+A **subarray** is a contiguous **non-empty** sequence of elements within an array.
+
+**Example 1:**
+
+**Input:** nums = [3, -2, 1, 4], l = 2, r = 3
+
+**Output:** 1
+
+**Explanation:**
+
+The subarrays of length between `l = 2` and `r = 3` where the sum is greater than 0 are:
+
+*   `[3, -2]` with a sum of 1
+*   `[1, 4]` with a sum of 5
+*   `[3, -2, 1]` with a sum of 2
+*   `[-2, 1, 4]` with a sum of 3
+
+Out of these, the subarray `[3, -2]` has a sum of 1, which is the smallest positive sum. Hence, the answer is 1.
+
+**Example 2:**
+
+**Input:** nums = [-2, 2, -3, 1], l = 2, r = 3
+
+**Output:** \-1
+
+**Explanation:**
+
+There is no subarray of length between `l` and `r` that has a sum greater than 0. So, the answer is -1.
+
+**Example 3:**
+
+**Input:** nums = [1, 2, 3, 4], l = 2, r = 4
+
+**Output:** 3
+
+**Explanation:**
+
+The subarray `[1, 2]` has a length of 2 and the minimum sum greater than 0. So, the answer is 3.
+
+**Constraints:**
+
+*   `1 <= nums.length <= 100`
+*   `1 <= l <= r <= nums.length`
+*   `-1000 <= nums[i] <= 1000`

src/main/java/g3301_3400/s3365_rearrange_k_substrings_to_form_target_string/Solution.java

@@ -0,0 +1,27 @@
+package g3301_3400.s3365_rearrange_k_substrings_to_form_target_string;
+
+// #Medium #2024_11_24_Time_61_ms_(100.00%)_Space_49.3_MB_(100.00%)
+
+import java.util.HashMap;
+import java.util.Map;
+
+public class Solution {
+    public boolean isPossibleToRearrange(String s, String t, int k) {
+        int size = s.length();
+        int div = size / k;
+        Map<String, Integer> map = new HashMap<>();
+        for (int i = 0; i < size; i += div) {
+            String sub = s.substring(i, i + div);
+            map.put(sub, map.getOrDefault(sub, 0) + 1);
+        }
+        for (int i = 0; i < size; i += div) {
+            String sub = t.substring(i, i + div);
+            if (map.getOrDefault(sub, 0) > 0) {
+                map.put(sub, map.get(sub) - 1);
+            } else {
+                return false;
+            }
+        }
+        return true;
+    }
+}

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

@@ -0,0 +1,54 @@
+3365\. Rearrange K Substrings to Form Target String
+
+Medium
+
+You are given two strings `s` and `t`, both of which are anagrams of each other, and an integer `k`.
+
+Your task is to determine whether it is possible to split the string `s` into `k` equal-sized substrings, rearrange the substrings, and concatenate them in _any order_ to create a new string that matches the given string `t`.
+
+Return `true` if this is possible, otherwise, return `false`.
+
+An **anagram** is a word or phrase formed by rearranging the letters of a different word or phrase, using all the original letters exactly once.
+
+A **substring** is a contiguous **non-empty** sequence of characters within a string.
+
+**Example 1:**
+
+**Input:** s = "abcd", t = "cdab", k = 2
+
+**Output:** true
+
+**Explanation:**
+
+*   Split `s` into 2 substrings of length 2: `["ab", "cd"]`.
+*   Rearranging these substrings as `["cd", "ab"]`, and then concatenating them results in `"cdab"`, which matches `t`.
+
+**Example 2:**
+
+**Input:** s = "aabbcc", t = "bbaacc", k = 3
+
+**Output:** true
+
+**Explanation:**
+
+*   Split `s` into 3 substrings of length 2: `["aa", "bb", "cc"]`.
+*   Rearranging these substrings as `["bb", "aa", "cc"]`, and then concatenating them results in `"bbaacc"`, which matches `t`.
+
+**Example 3:**
+
+**Input:** s = "aabbcc", t = "bbaacc", k = 2
+
+**Output:** false
+
+**Explanation:**
+
+*   Split `s` into 2 substrings of length 3: `["aab", "bcc"]`.
+*   These substrings cannot be rearranged to form `t = "bbaacc"`, so the output is `false`.
+
+**Constraints:**
+
+*   <code>1 <= s.length == t.length <= 2 * 10<sup>5</sup></code>
+*   `1 <= k <= s.length`
+*   `s.length` is divisible by `k`.
+*   `s` and `t` consist only of lowercase English letters.
+*   The input is generated such that `s` and `t` are anagrams of each other.

src/main/java/g3301_3400/s3366_minimum_array_sum/Solution.java

@@ -0,0 +1,37 @@
+package g3301_3400.s3366_minimum_array_sum;
+
+// #Medium #2024_11_24_Time_66_ms_(100.00%)_Space_55_MB_(100.00%)
+
+public class Solution {
+    public int minArraySum(int[] nums, int k, int op1, int op2) {
+        Integer[][][] dp = new Integer[nums.length][op1 + 1][op2 + 1];
+        return sub(dp, nums, 0, k, op1, op2);
+    }
+
+    private int sub(Integer[][][] dp, int[] nums, int i, int k, int op1, int op2) {
+        if (i == nums.length) {
+            return 0;
+        }
+        if (dp[i][op1][op2] != null) {
+            return dp[i][op1][op2];
+        }
+        int res = sub(dp, nums, i + 1, k, op1, op2) + nums[i];
+        if (nums[i] >= k && op2 > 0) {
+            res = Math.min(res, sub(dp, nums, i + 1, k, op1, op2 - 1) + nums[i] - k);
+            int v = (int) Math.ceil(nums[i] / 2.0);
+            if (v < k) {
+                v = (int) Math.ceil((nums[i] - k) / 2.0);
+            } else {
+                v -= k;
+            }
+            if (op1 > 0) {
+                res = Math.min(res, sub(dp, nums, i + 1, k, op1 - 1, op2 - 1) + v);
+            }
+        }
+        if (op1 > 0) {
+            int v = (int) Math.ceil(nums[i] / 2.0);
+            res = Math.min(res, sub(dp, nums, i + 1, k, op1 - 1, op2) + v);
+        }
+        return dp[i][op1][op2] = res;
+    }
+}

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

@@ -0,0 +1,46 @@
+3366\. Minimum Array Sum
+
+Medium
+
+You are given an integer array `nums` and three integers `k`, `op1`, and `op2`.
+
+You can perform the following operations on `nums`:
+
+*   **Operation 1**: Choose an index `i` and divide `nums[i]` by 2, **rounding up** to the nearest whole number. You can perform this operation at most `op1` times, and not more than **once** per index.
+*   **Operation 2**: Choose an index `i` and subtract `k` from `nums[i]`, but only if `nums[i]` is greater than or equal to `k`. You can perform this operation at most `op2` times, and not more than **once** per index.
+
+**Note:** Both operations can be applied to the same index, but at most once each.
+
+Return the **minimum** possible **sum** of all elements in `nums` after performing any number of operations.
+
+**Example 1:**
+
+**Input:** nums = [2,8,3,19,3], k = 3, op1 = 1, op2 = 1
+
+**Output:** 23
+
+**Explanation:**
+
+*   Apply Operation 2 to `nums[1] = 8`, making `nums[1] = 5`.
+*   Apply Operation 1 to `nums[3] = 19`, making `nums[3] = 10`.
+*   The resulting array becomes `[2, 5, 3, 10, 3]`, which has the minimum possible sum of 23 after applying the operations.
+
+**Example 2:**
+
+**Input:** nums = [2,4,3], k = 3, op1 = 2, op2 = 1
+
+**Output:** 3
+
+**Explanation:**
+
+*   Apply Operation 1 to `nums[0] = 2`, making `nums[0] = 1`.
+*   Apply Operation 1 to `nums[1] = 4`, making `nums[1] = 2`.
+*   Apply Operation 2 to `nums[2] = 3`, making `nums[2] = 0`.
+*   The resulting array becomes `[1, 2, 0]`, which has the minimum possible sum of 3 after applying the operations.
+
+**Constraints:**
+
+*   `1 <= nums.length <= 100`
+*   <code>0 <= nums[i] <= 10<sup>5</sup></code>
+*   <code>0 <= k <= 10<sup>5</sup></code>
+*   `0 <= op1, op2 <= nums.length`

src/main/java/g3301_3400/s3367_maximize_sum_of_weights_after_edge_removals/Solution.java

@@ -0,0 +1,35 @@
+package g3301_3400.s3367_maximize_sum_of_weights_after_edge_removals;
+
+// #Hard #2024_11_24_Time_147_ms_(100.00%)_Space_142.2_MB_(100.00%)
+
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.PriorityQueue;
+
+public class Solution {
+    public long maximizeSumOfWeights(int[][] edges, int k) {
+        HashMap<Integer, ArrayList<int[]>> map = new HashMap<>();
+        for (int[] edge : edges) {
+            map.computeIfAbsent(edge[0], t -> new ArrayList<>()).add(new int[] {edge[1], edge[2]});
+            map.computeIfAbsent(edge[1], t -> new ArrayList<>()).add(new int[] {edge[0], edge[2]});
+        }
+        return maximizeSumOfWeights(0, -1, k, map)[0];
+    }
+
+    private long[] maximizeSumOfWeights(
+            int v, int from, int k, HashMap<Integer, ArrayList<int[]>> map) {
+        long sum = 0;
+        PriorityQueue<Long> queue = new PriorityQueue<>();
+        for (int[] i : map.get(v)) {
+            if (i[0] != from) {
+                long[] next = maximizeSumOfWeights(i[0], v, k, map);
+                sum += Math.max(next[0], next[1] += i[1]);
+                if (next[0] < next[1]) {
+                    queue.offer(next[1] - next[0]);
+                    sum -= queue.size() > k ? queue.poll() : 0;
+                }
+            }
+        }
+        return new long[] {sum, sum - (queue.size() < k ? 0 : queue.peek())};
+    }
+}

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

@@ -0,0 +1,47 @@
+3367\. Maximize Sum of Weights after Edge Removals
+
+Hard
+
+There exists an **undirected** tree with `n` nodes numbered `0` to `n - 1`. You are given a 2D integer array `edges` of length `n - 1`, where <code>edges[i] = [u<sub>i</sub>, v<sub>i</sub>, w<sub>i</sub>]</code> indicates that there is an edge between nodes <code>u<sub>i</sub></code> and <code>v<sub>i</sub></code> with weight <code>w<sub>i</sub></code> in the tree.
+
+Your task is to remove _zero or more_ edges such that:
+
+*   Each node has an edge with **at most** `k` other nodes, where `k` is given.
+*   The sum of the weights of the remaining edges is **maximized**.
+
+Return the **maximum** possible sum of weights for the remaining edges after making the necessary removals.
+
+**Example 1:**
+
+**Input:** edges = [[0,1,4],[0,2,2],[2,3,12],[2,4,6]], k = 2
+
+**Output:** 22
+
+**Explanation:**
+
+![](https://assets.leetcode.com/uploads/2024/10/30/test1drawio.png)
+
+*   Node 2 has edges with 3 other nodes. We remove the edge `[0, 2, 2]`, ensuring that no node has edges with more than `k = 2` nodes.
+*   The sum of weights is 22, and we can't achieve a greater sum. Thus, the answer is 22.
+
+**Example 2:**
+
+**Input:** edges = [[0,1,5],[1,2,10],[0,3,15],[3,4,20],[3,5,5],[0,6,10]], k = 3
+
+**Output:** 65
+
+**Explanation:**
+
+*   Since no node has edges connecting it to more than `k = 3` nodes, we don't remove any edges.
+*   The sum of weights is 65. Thus, the answer is 65.
+
+**Constraints:**
+
+*   <code>2 <= n <= 10<sup>5</sup></code>
+*   `1 <= k <= n - 1`
+*   `edges.length == n - 1`
+*   `edges[i].length == 3`
+*   `0 <= edges[i][0] <= n - 1`
+*   `0 <= edges[i][1] <= n - 1`
+*   <code>1 <= edges[i][2] <= 10<sup>6</sup></code>
+*   The input is generated such that `edges` form a valid tree.

src/test/java/g3301_3400/s3364_minimum_positive_sum_subarray/SolutionTest.java

@@ -0,0 +1,24 @@
+package g3301_3400.s3364_minimum_positive_sum_subarray;
+
+import static org.hamcrest.CoreMatchers.equalTo;
+import static org.hamcrest.MatcherAssert.assertThat;
+
+import java.util.List;
+import org.junit.jupiter.api.Test;
+
+class SolutionTest {
+    @Test
+    void minimumSumSubarray() {
+        assertThat(new Solution().minimumSumSubarray(List.of(3, -2, 1, 4), 2, 3), equalTo(1));
+    }
+
+    @Test
+    void minimumSumSubarray2() {
+        assertThat(new Solution().minimumSumSubarray(List.of(-2, 2, -3, 1), 2, 3), equalTo(-1));
+    }
+
+    @Test
+    void minimumSumSubarray3() {
+        assertThat(new Solution().minimumSumSubarray(List.of(1, 2, 3, 4), 2, 4), equalTo(3));
+    }
+}

src/test/java/g3301_3400/s3365_rearrange_k_substrings_to_form_target_string/SolutionTest.java

@@ -0,0 +1,23 @@
+package g3301_3400.s3365_rearrange_k_substrings_to_form_target_string;
+
+import static org.hamcrest.CoreMatchers.equalTo;
+import static org.hamcrest.MatcherAssert.assertThat;
+
+import org.junit.jupiter.api.Test;
+
+class SolutionTest {
+    @Test
+    void isPossibleToRearrange() {
+        assertThat(new Solution().isPossibleToRearrange("abcd", "cdab", 2), equalTo(true));
+    }
+
+    @Test
+    void isPossibleToRearrange2() {
+        assertThat(new Solution().isPossibleToRearrange("aabbcc", "bbaacc", 3), equalTo(true));
+    }
+
+    @Test
+    void isPossibleToRearrange3() {
+        assertThat(new Solution().isPossibleToRearrange("aabbcc", "bbaacc", 2), equalTo(false));
+    }
+}