Added tasks 3477-3480

Author: javadev

src/main/java/g3401_3500/s3477_fruits_into_baskets_ii/Solution.java

@@ -0,0 +1,25 @@
+package g3401_3500.s3477_fruits_into_baskets_ii;
+
+// #Easy #2025_03_09_Time_2_ms_(100.00%)_Space_45.04_MB_(100.00%)
+
+public class Solution {
+    public int numOfUnplacedFruits(int[] fruits, int[] baskets) {
+        int n = fruits.length;
+        int ct = 0;
+        boolean[] used = new boolean[n];
+        for (int fruit : fruits) {
+            boolean flag = true;
+            for (int i = 0; i < n; i++) {
+                if (fruit <= baskets[i] && !used[i]) {
+                    used[i] = true;
+                    flag = false;
+                    break;
+                }
+            }
+            if (flag) {
+                ct++;
+            }
+        }
+        return ct;
+    }
+}

src/main/java/g3401_3500/s3477_fruits_into_baskets_ii/readme.md

@@ -0,0 +1,47 @@
+3477\. Fruits Into Baskets II
+
+Easy
+
+You are given two arrays of integers, `fruits` and `baskets`, each of length `n`, where `fruits[i]` represents the **quantity** of the <code>i<sup>th</sup></code> type of fruit, and `baskets[j]` represents the **capacity** of the <code>j<sup>th</sup></code> basket.
+
+From left to right, place the fruits according to these rules:
+
+*   Each fruit type must be placed in the **leftmost available basket** with a capacity **greater than or equal** to the quantity of that fruit type.
+*   Each basket can hold **only one** type of fruit.
+*   If a fruit type **cannot be placed** in any basket, it remains **unplaced**.
+
+Return the number of fruit types that remain unplaced after all possible allocations are made.
+
+**Example 1:**
+
+**Input:** fruits = [4,2,5], baskets = [3,5,4]
+
+**Output:** 1
+
+**Explanation:**
+
+*   `fruits[0] = 4` is placed in `baskets[1] = 5`.
+*   `fruits[1] = 2` is placed in `baskets[0] = 3`.
+*   `fruits[2] = 5` cannot be placed in `baskets[2] = 4`.
+
+Since one fruit type remains unplaced, we return 1.
+
+**Example 2:**
+
+**Input:** fruits = [3,6,1], baskets = [6,4,7]
+
+**Output:** 0
+
+**Explanation:**
+
+*   `fruits[0] = 3` is placed in `baskets[0] = 6`.
+*   `fruits[1] = 6` cannot be placed in `baskets[1] = 4` (insufficient capacity) but can be placed in the next available basket, `baskets[2] = 7`.
+*   `fruits[2] = 1` is placed in `baskets[1] = 4`.
+
+Since all fruits are successfully placed, we return 0.
+
+**Constraints:**
+
+*   `n == fruits.length == baskets.length`
+*   `1 <= n <= 100`
+*   `1 <= fruits[i], baskets[i] <= 1000`

src/main/java/g3401_3500/s3478_choose_k_elements_with_maximum_sum/Solution.java

@@ -0,0 +1,35 @@
+package g3401_3500.s3478_choose_k_elements_with_maximum_sum;
+
+// #Medium #2025_03_09_Time_156_ms_(100.00%)_Space_63.92_MB_(100.00%)
+
+import java.util.Arrays;
+import java.util.PriorityQueue;
+
+public class Solution {
+    public long[] findMaxSum(int[] nums1, int[] nums2, int k) {
+        int n = nums1.length;
+        int[][] arr = new int[n][3];
+        for (int i = 0; i < n; i++) {
+            arr[i][0] = nums1[i];
+            arr[i][1] = nums2[i];
+            arr[i][2] = i;
+        }
+        Arrays.sort(arr, (a, b) -> a[0] - b[0]);
+        long[] ans = new long[n];
+        PriorityQueue<Integer> pq = new PriorityQueue<>();
+        long sum = 0;
+        for (int i = 0; i < n; i++) {
+            if (i > 0 && arr[i - 1][0] == arr[i][0]) {
+                ans[arr[i][2]] = ans[arr[i - 1][2]];
+            } else {
+                ans[arr[i][2]] = sum;
+            }
+            pq.add(arr[i][1]);
+            sum += arr[i][1];
+            if (pq.size() > k) {
+                sum -= pq.remove();
+            }
+        }
+        return ans;
+    }
+}

src/main/java/g3401_3500/s3478_choose_k_elements_with_maximum_sum/readme.md

@@ -0,0 +1,43 @@
+3478\. Choose K Elements With Maximum Sum
+
+Medium
+
+You are given two integer arrays, `nums1` and `nums2`, both of length `n`, along with a positive integer `k`.
+
+For each index `i` from `0` to `n - 1`, perform the following:
+
+*   Find **all** indices `j` where `nums1[j]` is less than `nums1[i]`.
+*   Choose **at most** `k` values of `nums2[j]` at these indices to **maximize** the total sum.
+
+Return an array `answer` of size `n`, where `answer[i]` represents the result for the corresponding index `i`.
+
+**Example 1:**
+
+**Input:** nums1 = [4,2,1,5,3], nums2 = [10,20,30,40,50], k = 2
+
+**Output:** [80,30,0,80,50]
+
+**Explanation:**
+
+*   For `i = 0`: Select the 2 largest values from `nums2` at indices `[1, 2, 4]` where `nums1[j] < nums1[0]`, resulting in `50 + 30 = 80`.
+*   For `i = 1`: Select the 2 largest values from `nums2` at index `[2]` where `nums1[j] < nums1[1]`, resulting in 30.
+*   For `i = 2`: No indices satisfy `nums1[j] < nums1[2]`, resulting in 0.
+*   For `i = 3`: Select the 2 largest values from `nums2` at indices `[0, 1, 2, 4]` where `nums1[j] < nums1[3]`, resulting in `50 + 30 = 80`.
+*   For `i = 4`: Select the 2 largest values from `nums2` at indices `[1, 2]` where `nums1[j] < nums1[4]`, resulting in `30 + 20 = 50`.
+
+**Example 2:**
+
+**Input:** nums1 = [2,2,2,2], nums2 = [3,1,2,3], k = 1
+
+**Output:** [0,0,0,0]
+
+**Explanation:**
+
+Since all elements in `nums1` are equal, no indices satisfy the condition `nums1[j] < nums1[i]` for any `i`, resulting in 0 for all positions.
+
+**Constraints:**
+
+*   `n == nums1.length == nums2.length`
+*   <code>1 <= n <= 10<sup>5</sup></code>
+*   <code>1 <= nums1[i], nums2[i] <= 10<sup>6</sup></code>
+*   `1 <= k <= n`

src/main/java/g3401_3500/s3479_fruits_into_baskets_iii/Solution.java

@@ -0,0 +1,36 @@
+package g3401_3500.s3479_fruits_into_baskets_iii;
+
+// #Medium #2025_03_09_Time_629_ms_(100.00%)_Space_67.19_MB_(100.00%)
+
+import java.util.ArrayList;
+import java.util.List;
+
+public class Solution {
+    public int numOfUnplacedFruits(int[] fruits, int[] baskets) {
+        int unp = 0;
+        int max = 0;
+        List<Integer> list = new ArrayList<>();
+        for (int basket : baskets) {
+            list.add(basket);
+            max = Math.max(max, basket);
+        }
+        for (int fruit : fruits) {
+            if (fruit > max) {
+                unp++;
+                continue;
+            }
+            boolean placed = false;
+            for (int j = 0; j < list.size(); j++) {
+                if (list.get(j) >= fruit) {
+                    list.remove(j);
+                    placed = true;
+                    break;
+                }
+            }
+            if (!placed) {
+                unp++;
+            }
+        }
+        return unp;
+    }
+}

src/main/java/g3401_3500/s3479_fruits_into_baskets_iii/readme.md

@@ -0,0 +1,47 @@
+3479\. Fruits Into Baskets III
+
+Medium
+
+You are given two arrays of integers, `fruits` and `baskets`, each of length `n`, where `fruits[i]` represents the **quantity** of the <code>i<sup>th</sup></code> type of fruit, and `baskets[j]` represents the **capacity** of the <code>j<sup>th</sup></code> basket.
+
+From left to right, place the fruits according to these rules:
+
+*   Each fruit type must be placed in the **leftmost available basket** with a capacity **greater than or equal** to the quantity of that fruit type.
+*   Each basket can hold **only one** type of fruit.
+*   If a fruit type **cannot be placed** in any basket, it remains **unplaced**.
+
+Return the number of fruit types that remain unplaced after all possible allocations are made.
+
+**Example 1:**
+
+**Input:** fruits = [4,2,5], baskets = [3,5,4]
+
+**Output:** 1
+
+**Explanation:**
+
+*   `fruits[0] = 4` is placed in `baskets[1] = 5`.
+*   `fruits[1] = 2` is placed in `baskets[0] = 3`.
+*   `fruits[2] = 5` cannot be placed in `baskets[2] = 4`.
+
+Since one fruit type remains unplaced, we return 1.
+
+**Example 2:**
+
+**Input:** fruits = [3,6,1], baskets = [6,4,7]
+
+**Output:** 0
+
+**Explanation:**
+
+*   `fruits[0] = 3` is placed in `baskets[0] = 6`.
+*   `fruits[1] = 6` cannot be placed in `baskets[1] = 4` (insufficient capacity) but can be placed in the next available basket, `baskets[2] = 7`.
+*   `fruits[2] = 1` is placed in `baskets[1] = 4`.
+
+Since all fruits are successfully placed, we return 0.
+
+**Constraints:**
+
+*   `n == fruits.length == baskets.length`
+*   <code>1 <= n <= 10<sup>5</sup></code>
+*   <code>1 <= fruits[i], baskets[i] <= 10<sup>9</sup></code>

src/main/java/g3401_3500/s3480_maximize_subarrays_after_removing_one_conflicting_pair/Solution.java

@@ -0,0 +1,59 @@
+package g3401_3500.s3480_maximize_subarrays_after_removing_one_conflicting_pair;
+
+// #Hard #2025_03_09_Time_581_ms_(_%)_Space_163.11_MB_(_%)
+
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Comparator;
+import java.util.List;
+import java.util.Map;
+import java.util.TreeMap;
+
+public class Solution {
+    public long maxSubarrays(int n, int[][] cp) {
+        for (int[] pair : cp) {
+            if (pair[0] > pair[1]) {
+                int temp = pair[0];
+                pair[0] = pair[1];
+                pair[1] = temp;
+            }
+        }
+        Arrays.sort(cp, Comparator.comparingInt(a -> a[0]));
+        long[] contributions = new long[cp.length];
+        long totalPossible = (long) n * (n + 1) / 2;
+        TreeMap<Integer, List<Integer>> endPointMap = new TreeMap<>();
+        int currentIndex = cp.length - 1;
+        for (int start = n; start >= 1; start--) {
+            while (currentIndex >= 0 && cp[currentIndex][0] >= start) {
+                int end = cp[currentIndex][1];
+                endPointMap.computeIfAbsent(end, k -> new ArrayList<>()).add(currentIndex);
+                currentIndex--;
+            }
+            if (endPointMap.isEmpty()) {
+                continue;
+            }
+            Map.Entry<Integer, List<Integer>> firstEntry = endPointMap.firstEntry();
+            int smallestEnd = firstEntry.getKey();
+            int pairIndex = firstEntry.getValue().get(0);
+            if (firstEntry.getValue().size() == 1) {
+                endPointMap.remove(smallestEnd);
+            } else {
+                firstEntry.getValue().remove(0);
+            }
+            long covered = n - smallestEnd + 1;
+            totalPossible -= covered;
+            if (endPointMap.isEmpty()) {
+                contributions[pairIndex] += covered;
+            } else {
+                int nextEnd = endPointMap.firstKey();
+                contributions[pairIndex] += nextEnd - smallestEnd;
+            }
+            endPointMap.computeIfAbsent(smallestEnd, k -> new ArrayList<>()).add(pairIndex);
+        }
+        long result = totalPossible;
+        for (long contribution : contributions) {
+            result = Math.max(result, totalPossible + contribution);
+        }
+        return result;
+    }
+}

src/main/java/g3401_3500/s3480_maximize_subarrays_after_removing_one_conflicting_pair/readme.md

@@ -0,0 +1,41 @@
+3480\. Maximize Subarrays After Removing One Conflicting Pair
+
+Hard
+
+You are given an integer `n` which represents an array `nums` containing the numbers from 1 to `n` in order. Additionally, you are given a 2D array `conflictingPairs`, where `conflictingPairs[i] = [a, b]` indicates that `a` and `b` form a conflicting pair.
+
+Remove **exactly** one element from `conflictingPairs`. Afterward, count the number of non-empty subarrays of `nums` which do not contain both `a` and `b` for any remaining conflicting pair `[a, b]`.
+
+Return the **maximum** number of subarrays possible after removing **exactly** one conflicting pair.
+
+**Example 1:**
+
+**Input:** n = 4, conflictingPairs = [[2,3],[1,4]]
+
+**Output:** 9
+
+**Explanation:**
+
+*   Remove `[2, 3]` from `conflictingPairs`. Now, `conflictingPairs = [[1, 4]]`.
+*   There are 9 subarrays in `nums` where `[1, 4]` do not appear together. They are `[1]`, `[2]`, `[3]`, `[4]`, `[1, 2]`, `[2, 3]`, `[3, 4]`, `[1, 2, 3]` and `[2, 3, 4]`.
+*   The maximum number of subarrays we can achieve after removing one element from `conflictingPairs` is 9.
+
+**Example 2:**
+
+**Input:** n = 5, conflictingPairs = [[1,2],[2,5],[3,5]]
+
+**Output:** 12
+
+**Explanation:**
+
+*   Remove `[1, 2]` from `conflictingPairs`. Now, `conflictingPairs = [[2, 5], [3, 5]]`.
+*   There are 12 subarrays in `nums` where `[2, 5]` and `[3, 5]` do not appear together.
+*   The maximum number of subarrays we can achieve after removing one element from `conflictingPairs` is 12.
+
+**Constraints:**
+
+*   <code>2 <= n <= 10<sup>5</sup></code>
+*   `1 <= conflictingPairs.length <= 2 * n`
+*   `conflictingPairs[i].length == 2`
+*   `1 <= conflictingPairs[i][j] <= n`
+*   `conflictingPairs[i][0] != conflictingPairs[i][1]`

src/test/java/g3401_3500/s3477_fruits_into_baskets_ii/SolutionTest.java

@@ -0,0 +1,22 @@
+package g3401_3500.s3477_fruits_into_baskets_ii;
+
+import static org.hamcrest.CoreMatchers.equalTo;
+import static org.hamcrest.MatcherAssert.assertThat;
+
+import org.junit.jupiter.api.Test;
+
+class SolutionTest {
+    @Test
+    void numOfUnplacedFruits() {
+        assertThat(
+                new Solution().numOfUnplacedFruits(new int[] {4, 2, 5}, new int[] {3, 5, 4}),
+                equalTo(1));
+    }
+
+    @Test
+    void numOfUnplacedFruits2() {
+        assertThat(
+                new Solution().numOfUnplacedFruits(new int[] {3, 6, 1}, new int[] {6, 4, 7}),
+                equalTo(0));
+    }
+}

src/test/java/g3401_3500/s3478_choose_k_elements_with_maximum_sum/SolutionTest.java

@@ -0,0 +1,23 @@
+package g3401_3500.s3478_choose_k_elements_with_maximum_sum;
+
+import static org.hamcrest.CoreMatchers.equalTo;
+import static org.hamcrest.MatcherAssert.assertThat;
+
+import org.junit.jupiter.api.Test;
+
+class SolutionTest {
+    @Test
+    void findMaxSum() {
+        assertThat(
+                new Solution()
+                        .findMaxSum(new int[] {4, 2, 1, 5, 3}, new int[] {10, 20, 30, 40, 50}, 2),
+                equalTo(new long[] {80L, 30L, 0L, 80L, 50L}));
+    }
+
+    @Test
+    void findMaxSum2() {
+        assertThat(
+                new Solution().findMaxSum(new int[] {2, 2, 2, 2}, new int[] {3, 1, 2, 3}, 1),
+                equalTo(new long[] {0L, 0L, 0L, 0L}));
+    }
+}