Added tasks 3477-3480

Author: javadev

README.md

@@ -2088,6 +2088,10 @@
 
 | #    |      Title     | Difficulty  | Tag         | Time, ms | Time, %
 |------|----------------|-------------|-------------|----------|--------
+| 3480 |[Maximize Subarrays After Removing One Conflicting Pair](src/main/java/g3401_3500/s3480_maximize_subarrays_after_removing_one_conflicting_pair)| Hard | Array, Prefix_Sum, Enumeration, Segment_Tree | 20 | 98.86
+| 3479 |[Fruits Into Baskets III](src/main/java/g3401_3500/s3479_fruits_into_baskets_iii)| Medium | Array, Binary_Search, Ordered_Set, Segment_Tree | 38 | 97.76
+| 3478 |[Choose K Elements With Maximum Sum](src/main/java/g3401_3500/s3478_choose_k_elements_with_maximum_sum)| Medium | Array, Sorting, Heap_Priority_Queue | 105 | 98.60
+| 3477 |[Fruits Into Baskets II](src/main/java/g3401_3500/s3477_fruits_into_baskets_ii)| Easy | Array, Binary_Search, Simulation, Segment_Tree | 1 | 100.00
 | 3475 |[DNA Pattern Recognition](src/main/java/g3401_3500/s3475_dna_pattern_recognition)| Medium | Database | 362 | 83.49
 | 3474 |[Lexicographically Smallest Generated String](src/main/java/g3401_3500/s3474_lexicographically_smallest_generated_string)| Hard | String, Greedy, String_Matching | 17 | 64.86
 | 3473 |[Sum of K Subarrays With Length at Least M](src/main/java/g3401_3500/s3473_sum_of_k_subarrays_with_length_at_least_m)| Medium | Array, Dynamic_Programming, Prefix_Sum | 191 | 52.16

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

@@ -0,0 +1,73 @@
+[![](https://img.shields.io/github/stars/javadev/LeetCode-in-Java?label=Stars&style=flat-square)](https://github.com/javadev/LeetCode-in-Java)
+[![](https://img.shields.io/github/forks/javadev/LeetCode-in-Java?label=Fork%20me%20on%20GitHub%20&style=flat-square)](https://github.com/javadev/LeetCode-in-Java/fork)
+
+## 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`
+
+## Solution
+
+```java
+public class Solution {
+    public int numOfUnplacedFruits(int[] fruits, int[] baskets) {
+        int n = fruits.length;
+        int currfruits;
+        int count = 0;
+        for (int i = 0; i < n; i++) {
+            currfruits = fruits[i];
+            for (int j = 0; j < n; j++) {
+                if (baskets[j] >= currfruits) {
+                    count++;
+                    baskets[j] = 0;
+                    break;
+                }
+            }
+        }
+        return n - count;
+    }
+}
+```

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

@@ -0,0 +1,100 @@
+[![](https://img.shields.io/github/stars/javadev/LeetCode-in-Java?label=Stars&style=flat-square)](https://github.com/javadev/LeetCode-in-Java)
+[![](https://img.shields.io/github/forks/javadev/LeetCode-in-Java?label=Fork%20me%20on%20GitHub%20&style=flat-square)](https://github.com/javadev/LeetCode-in-Java/fork)
+
+## 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`
+
+## Solution
+
+```java
+import java.util.Arrays;
+import java.util.PriorityQueue;
+
+public class Solution {
+    public long[] findMaxSum(int[] nums1, int[] nums2, int k) {
+        int n = nums1.length;
+        long[] ans = new long[n];
+        Point[] ps = new Point[n];
+        for (int i = 0; i < n; i++) {
+            ps[i] = new Point(nums1[i], nums2[i], i);
+        }
+        Arrays.sort(ps, (p1, p2) -> Integer.compare(p1.x, p2.x));
+        PriorityQueue<Integer> pq = new PriorityQueue<>();
+        long s = 0;
+        int i = 0;
+        while (i < n) {
+            int j = i;
+            while (j < n && ps[j].x == ps[i].x) {
+                ans[ps[j].i] = s;
+                j++;
+            }
+            for (int p = i; p < j; p++) {
+                int cur = ps[p].y;
+                if (pq.size() < k) {
+                    pq.offer(cur);
+                    s += cur;
+                } else if (cur > pq.peek()) {
+                    s -= pq.poll();
+                    pq.offer(cur);
+                    s += cur;
+                }
+            }
+            i = j;
+        }
+        return ans;
+    }
+
+    private static class Point {
+        int x;
+        int y;
+        int i;
+
+        Point(int x, int y, int i) {
+            this.x = x;
+            this.y = y;
+            this.i = i;
+        }
+    }
+}
+```

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

@@ -0,0 +1,99 @@
+[![](https://img.shields.io/github/stars/javadev/LeetCode-in-Java?label=Stars&style=flat-square)](https://github.com/javadev/LeetCode-in-Java)
+[![](https://img.shields.io/github/forks/javadev/LeetCode-in-Java?label=Fork%20me%20on%20GitHub%20&style=flat-square)](https://github.com/javadev/LeetCode-in-Java/fork)
+
+## 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>
+
+## Solution
+
+```java
+public class Solution {
+    public int numOfUnplacedFruits(int[] fruits, int[] baskets) {
+        int n = baskets.length;
+        int size = 1;
+        while (size < n) {
+            size <<= 1;
+        }
+        int[] seg = new int[2 * size];
+        for (int i = 0; i < n; i++) {
+            seg[size + i] = baskets[i];
+        }
+        for (int i = n; i < size; i++) {
+            seg[size + i] = 0;
+        }
+        for (int i = size - 1; i > 0; i--) {
+            seg[i] = Math.max(seg[i << 1], seg[i << 1 | 1]);
+        }
+        int ans = 0;
+        for (int f : fruits) {
+            if (seg[1] < f) {
+                ans++;
+                continue;
+            }
+            int idx = 1;
+            while (idx < size) {
+                if (seg[idx << 1] >= f) {
+                    idx = idx << 1;
+                } else {
+                    idx = idx << 1 | 1;
+                }
+            }
+            update(seg, idx - size, 0, size);
+        }
+        return ans;
+    }
+
+    private void update(int[] seg, int pos, int val, int size) {
+        int i = pos + size;
+        seg[i] = val;
+        for (i /= 2; i > 0; i /= 2) {
+            seg[i] = Math.max(seg[i << 1], seg[i << 1 | 1]);
+        }
+    }
+}
+```