Optimize Fruits Into Baskets III with TreeSet/sorted arrays to fix TLE

Author: TechnoBlogger14o3

Medium/2025-08-06-3478-FruitsIntoBasketsIII/explanation.md

@@ -46,13 +46,14 @@ Since we can skip one fruit and place the rest, we return 0.
 - We find the best outcome among all possible skip combinations
 
 ## Complexity Analysis
-- **Time Complexity**: O(n²) - For each skip possibility, we do O(n²) work
-- **Space Complexity**: O(n) - To track which baskets are used
+- **Time Complexity**: O(n log n) - Sort baskets once, then O(n) for each skip possibility
+- **Space Complexity**: O(n) - To maintain sorted list of available baskets
 
 ## Key Insights
 - This is an extension of the previous problem with skip logic
 - We need to try all possible skip combinations to find the optimal solution
-- The greedy placement strategy remains the same for each attempt
+- Using sorted data structures (TreeSet/Array) for efficient basket matching
+- Greedy placement strategy with optimized basket selection
 
 ## Alternative Approaches
 1. **Brute Force**: Try all possible skip combinations - O(n!) time

Medium/2025-08-06-3478-FruitsIntoBasketsIII/solution.java

@@ -1,20 +1,27 @@
+import java.util.*;
+
 class Solution {
     public int numOfUnplacedFruits(int[] fruits, int[] baskets) {
         int minUnplaced = Integer.MAX_VALUE;
 
         // Try placing all fruits without skipping
-        minUnplaced = Math.min(minUnplaced, placeFruits(fruits, baskets, -1));
+        minUnplaced = Math.min(minUnplaced, placeFruitsOptimized(fruits, baskets, -1));
 
         // Try skipping each fruit type
         for (int skipIndex = 0; skipIndex < fruits.length; skipIndex++) {
-            minUnplaced = Math.min(minUnplaced, placeFruits(fruits, baskets, skipIndex));
+            minUnplaced = Math.min(minUnplaced, placeFruitsOptimized(fruits, baskets, skipIndex));
         }
 
         return minUnplaced;
     }
 
-    private int placeFruits(int[] fruits, int[] baskets, int skipIndex) {
-        boolean[] used = new boolean[baskets.length];
+    private int placeFruitsOptimized(int[] fruits, int[] baskets, int skipIndex) {
+        // Use TreeSet to maintain available baskets efficiently
+        TreeSet<Integer> availableBaskets = new TreeSet<>();
+        for (int basket : baskets) {
+            availableBaskets.add(basket);
+        }
+        
         int unplaced = 0;
 
         for (int i = 0; i < fruits.length; i++) {
@@ -23,19 +30,13 @@ private int placeFruits(int[] fruits, int[] baskets, int skipIndex) {
                 continue;
             }
 
-            boolean placed = false;
-            
-            // Find the leftmost available basket with sufficient capacity
-            for (int j = 0; j < baskets.length; j++) {
-                if (!used[j] && baskets[j] >= fruits[i]) {
-                    used[j] = true;  // Mark basket as used
-                    placed = true;
-                    break;
-                }
-            }
+            // Find the smallest available basket that can hold this fruit
+            Integer basket = availableBaskets.ceiling(fruits[i]);
 
-            if (!placed) {
+            if (basket == null) {
                 unplaced++;
+            } else {
+                availableBaskets.remove(basket);
             }
         }
 

Medium/2025-08-06-3478-FruitsIntoBasketsIII/solution.js

@@ -7,18 +7,19 @@ var numOfUnplacedFruits = function(fruits, baskets) {
     let minUnplaced = Infinity;
 
     // Try placing all fruits without skipping
-    minUnplaced = Math.min(minUnplaced, placeFruits(fruits, baskets, -1));
+    minUnplaced = Math.min(minUnplaced, placeFruitsOptimized(fruits, baskets, -1));
 
     // Try skipping each fruit type
     for (let skipIndex = 0; skipIndex < fruits.length; skipIndex++) {
-        minUnplaced = Math.min(minUnplaced, placeFruits(fruits, baskets, skipIndex));
+        minUnplaced = Math.min(minUnplaced, placeFruitsOptimized(fruits, baskets, skipIndex));
     }
 
     return minUnplaced;
 };
 
-function placeFruits(fruits, baskets, skipIndex) {
-    const used = new Array(baskets.length).fill(false);
+function placeFruitsOptimized(fruits, baskets, skipIndex) {
+    // Use sorted array to maintain available baskets efficiently
+    const availableBaskets = [...baskets].sort((a, b) => a - b);
     let unplaced = 0;
 
     for (let i = 0; i < fruits.length; i++) {
@@ -27,19 +28,19 @@ function placeFruits(fruits, baskets, skipIndex) {
             continue;
         }
 
-        let placed = false;
-        
-        // Find the leftmost available basket with sufficient capacity
-        for (let j = 0; j < baskets.length; j++) {
-            if (!used[j] && baskets[j] >= fruits[i]) {
-                used[j] = true;  // Mark basket as used
-                placed = true;
+        // Find the smallest available basket that can hold this fruit
+        let basketIndex = -1;
+        for (let j = 0; j < availableBaskets.length; j++) {
+            if (availableBaskets[j] >= fruits[i]) {
+                basketIndex = j;
                 break;
             }
         }
 
-        if (!placed) {
+        if (basketIndex === -1) {
             unplaced++;
+        } else {
+            availableBaskets.splice(basketIndex, 1); // Remove used basket
         }
     }
 

Medium/2025-08-06-3478-FruitsIntoBasketsIII/solution.py

@@ -1,37 +1,39 @@
 from typing import List
+import bisect
 
 class Solution:
     def numOfUnplacedFruits(self, fruits: List[int], baskets: List[int]) -> int:
         min_unplaced = float('inf')
 
         # Try placing all fruits without skipping
-        min_unplaced = min(min_unplaced, self.place_fruits(fruits, baskets, -1))
+        min_unplaced = min(min_unplaced, self.place_fruits_optimized(fruits, baskets, -1))
 
         # Try skipping each fruit type
         for skip_index in range(len(fruits)):
-            min_unplaced = min(min_unplaced, self.place_fruits(fruits, baskets, skip_index))
+            min_unplaced = min(min_unplaced, self.place_fruits_optimized(fruits, baskets, skip_index))
 
         return min_unplaced
 
-    def place_fruits(self, fruits: List[int], baskets: List[int], skip_index: int) -> int:
-        used = [False] * len(baskets)
+    def place_fruits_optimized(self, fruits: List[int], baskets: List[int], skip_index: int) -> int:
+        # Use sorted list to maintain available baskets efficiently
+        available_baskets = sorted(baskets)
         unplaced = 0
 
         for i in range(len(fruits)):
             if i == skip_index:
                 unplaced += 1  # Count skipped fruit as unplaced
                 continue
 
-            placed = False
-            
-            # Find the leftmost available basket with sufficient capacity
-            for j in range(len(baskets)):
-                if not used[j] and baskets[j] >= fruits[i]:
-                    used[j] = True  # Mark basket as used
-                    placed = True
+            # Find the smallest available basket that can hold this fruit
+            basket_index = -1
+            for j in range(len(available_baskets)):
+                if available_baskets[j] >= fruits[i]:
+                    basket_index = j
                     break
 
-            if not placed:
+            if basket_index == -1:
                 unplaced += 1
+            else:
+                available_baskets.pop(basket_index)  # Remove used basket
 
         return unplaced