Optimize Maximum Fruits solution with sliding window approach to fix TLE

Author: TechnoBlogger14o3

Hard/2025-08-03-2106-MaximumFruitsHarvestedAfterAtMostKSteps/explanation.md

@@ -43,17 +43,19 @@ Explanation:
 
 **Algorithm**:
 1. Sort the fruits by position to get them in order.
-2. Use a sliding window approach to find the maximum sum of fruits that can be harvested within `k` steps.
-3. For each window, calculate the minimum steps needed to reach all fruits in the window.
-4. The minimum steps for a window from position `left` to `right` is: `right - left + min(left, right - left)`.
+2. Use a sliding window approach with two pointers (left and right).
+3. Expand the window by moving the right pointer and add fruits to the current sum.
+4. When the window becomes invalid (steps > k), shrink it from the left until it's valid again.
+5. Keep track of the maximum sum of fruits found in any valid window.
 
 **Why this works**:
 - We need to visit all fruits in a contiguous range
 - The optimal path is to go to one end, then to the other end
 - The total steps is the distance between the two ends plus the distance from start to the closer end
+- Sliding window ensures we find the optimal range efficiently
 
 ## Complexity Analysis
-- **Time Complexity**: O(n log n) - Due to sorting the fruits by position
+- **Time Complexity**: O(n log n) - Due to sorting the fruits by position, then O(n) for sliding window
 - **Space Complexity**: O(1) - Only using a few variables for the sliding window
 
 ## Key Insights
@@ -63,9 +65,10 @@ Explanation:
 - Use sliding window to find the maximum sum within the step constraint
 
 ## Alternative Approaches
-1. **Brute Force**: Try all possible ranges - O(n²) time
-2. **Binary Search**: Can be used to optimize the sliding window approach
-3. **Dynamic Programming**: Can be used but overkill for this problem
+1. **Brute Force**: Try all possible ranges - O(n²) time (causes TLE)
+2. **Sliding Window**: O(n) time after sorting - optimal approach
+3. **Binary Search**: Can be used to optimize the sliding window approach
+4. **Dynamic Programming**: Can be used but overkill for this problem
 
 ## Solutions in Different Languages
 

Hard/2025-08-03-2106-MaximumFruitsHarvestedAfterAtMostKSteps/solution.java

@@ -7,24 +7,33 @@ public int maxTotalFruits(int[][] fruits, int startPos, int k) {
 
         int n = fruits.length;
         int maxFruits = 0;
+        int left = 0;
+        int currentSum = 0;
 
-        // Try all possible ranges
-        for (int left = 0; left < n; left++) {
-            for (int right = left; right < n; right++) {
+        // Sliding window approach
+        for (int right = 0; right < n; right++) {
+            currentSum += fruits[right][1];
+            
+            // Shrink window from left while it's invalid
+            while (left <= right) {
                 int leftPos = fruits[left][0];
                 int rightPos = fruits[right][0];
 
-                // Calculate minimum steps needed
+                // Calculate minimum steps needed for current window
                 int steps = rightPos - leftPos + Math.min(Math.abs(startPos - leftPos), Math.abs(startPos - rightPos));
 
                 if (steps <= k) {
-                    // Calculate total fruits in this range
-                    int totalFruits = 0;
-                    for (int i = left; i <= right; i++) {
-                        totalFruits += fruits[i][1];
-                    }
-                    maxFruits = Math.max(maxFruits, totalFruits);
+                    break; // Window is valid, keep it
                 }
+                
+                // Remove leftmost fruit and shrink window
+                currentSum -= fruits[left][1];
+                left++;
+            }
+            
+            // Update max fruits if window is valid
+            if (left <= right) {
+                maxFruits = Math.max(maxFruits, currentSum);
             }
         }
 

Hard/2025-08-03-2106-MaximumFruitsHarvestedAfterAtMostKSteps/solution.js

@@ -10,24 +10,33 @@ var maxTotalFruits = function(fruits, startPos, k) {
 
     const n = fruits.length;
     let maxFruits = 0;
+    let left = 0;
+    let currentSum = 0;
 
-    // Try all possible ranges
-    for (let left = 0; left < n; left++) {
-        for (let right = left; right < n; right++) {
+    // Sliding window approach
+    for (let right = 0; right < n; right++) {
+        currentSum += fruits[right][1];
+        
+        // Shrink window from left while it's invalid
+        while (left <= right) {
             const leftPos = fruits[left][0];
             const rightPos = fruits[right][0];
 
-            // Calculate minimum steps needed
+            // Calculate minimum steps needed for current window
             const steps = rightPos - leftPos + Math.min(Math.abs(startPos - leftPos), Math.abs(startPos - rightPos));
 
             if (steps <= k) {
-                // Calculate total fruits in this range
-                let totalFruits = 0;
-                for (let i = left; i <= right; i++) {
-                    totalFruits += fruits[i][1];
-                }
-                maxFruits = Math.max(maxFruits, totalFruits);
+                break; // Window is valid, keep it
             }
+            
+            // Remove leftmost fruit and shrink window
+            currentSum -= fruits[left][1];
+            left++;
+        }
+        
+        // Update max fruits if window is valid
+        if (left <= right) {
+            maxFruits = Math.max(maxFruits, currentSum);
         }
     }
 

Hard/2025-08-03-2106-MaximumFruitsHarvestedAfterAtMostKSteps/solution.py

@@ -7,19 +7,30 @@ def maxTotalFruits(self, fruits: List[List[int]], startPos: int, k: int) -> int:
 
         n = len(fruits)
         max_fruits = 0
+        left = 0
+        current_sum = 0
 
-        # Try all possible ranges
-        for left in range(n):
-            for right in range(left, n):
+        # Sliding window approach
+        for right in range(n):
+            current_sum += fruits[right][1]
+            
+            # Shrink window from left while it's invalid
+            while left <= right:
                 left_pos = fruits[left][0]
                 right_pos = fruits[right][0]
 
-                # Calculate minimum steps needed
+                # Calculate minimum steps needed for current window
                 steps = right_pos - left_pos + min(abs(startPos - left_pos), abs(startPos - right_pos))
 
                 if steps <= k:
-                    # Calculate total fruits in this range
-                    total_fruits = sum(fruits[i][1] for i in range(left, right + 1))
-                    max_fruits = max(max_fruits, total_fruits)
+                    break  # Window is valid, keep it
+                
+                # Remove leftmost fruit and shrink window
+                current_sum -= fruits[left][1]
+                left += 1
+            
+            # Update max fruits if window is valid
+            if left <= right:
+                max_fruits = max(max_fruits, current_sum)
 
         return max_fruits