Improved tasks 3477-3480

Author: javadev

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

@@ -1,26 +1,23 @@
 package g3401_3500.s3477_fruits_into_baskets_ii;
 
 // #Easy #Array #Binary_Search #Simulation #Segment_Tree
-// #2025_03_10_Time_2_ms_(100.00%)_Space_43.96_MB_(100.00%)
+// #2025_03_10_Time_1_ms_(100.00%)_Space_44.78_MB_(36.06%)
 
 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;
+        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;
                 }
             }
-            if (flag) {
-                ct++;
-            }
         }
-        return ct;
+        return n - count;
     }
 }

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

@@ -1,36 +1,54 @@
 package g3401_3500.s3478_choose_k_elements_with_maximum_sum;
 
 // #Medium #Array #Sorting #Heap_Priority_Queue
-// #2025_03_10_Time_157_ms_(100.00%)_Space_62.83_MB_(100.00%)
+// #2025_03_10_Time_105_ms_(98.60%)_Space_69.10_MB_(28.75%)
 
 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];
+        long[] ans = new long[n];
+        Point[] ps = new Point[n];
         for (int i = 0; i < n; i++) {
-            arr[i][0] = nums1[i];
-            arr[i][1] = nums2[i];
-            arr[i][2] = i;
+            ps[i] = new Point(nums1[i], nums2[i], i);
         }
-        Arrays.sort(arr, (a, b) -> a[0] - b[0]);
-        long[] ans = new long[n];
+        Arrays.sort(ps, (p1, p2) -> Integer.compare(p1.x, p2.x));
         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;
+        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++;
             }
-            pq.add(arr[i][1]);
-            sum += arr[i][1];
-            if (pq.size() > k) {
-                sum -= pq.remove();
+            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/Solution.java

@@ -1,37 +1,49 @@
 package g3401_3500.s3479_fruits_into_baskets_iii;
 
 // #Medium #Array #Binary_Search #Ordered_Set #Segment_Tree
-// #2025_03_10_Time_655_ms_(100.00%)_Space_65.58_MB_(100.00%)
-
-import java.util.ArrayList;
-import java.util.List;
+// #2025_03_10_Time_38_ms_(97.76%)_Space_67.52_MB_(38.48%)
 
 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);
+        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]);
         }
-        for (int fruit : fruits) {
-            if (fruit > max) {
-                unp++;
+        int ans = 0;
+        for (int f : fruits) {
+            if (seg[1] < f) {
+                ans++;
                 continue;
             }
-            boolean placed = false;
-            for (int j = 0; j < list.size(); j++) {
-                if (list.get(j) >= fruit) {
-                    list.remove(j);
-                    placed = true;
-                    break;
+            int idx = 1;
+            while (idx < size) {
+                if (seg[idx << 1] >= f) {
+                    idx = idx << 1;
+                } else {
+                    idx = idx << 1 | 1;
                 }
             }
-            if (!placed) {
-                unp++;
-            }
+            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]);
         }
-        return unp;
     }
 }

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

@@ -1,60 +1,91 @@
 package g3401_3500.s3480_maximize_subarrays_after_removing_one_conflicting_pair;
 
 // #Hard #Array #Prefix_Sum #Enumeration #Segment_Tree
-// #2025_03_10_Time_567_ms_(100.00%)_Space_159.65_MB_(100.00%)
+// #2025_03_10_Time_20_ms_(98.86%)_Space_141.78_MB_(52.27%)
 
-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;
+    public long maxSubarrays(int n, int[][] conflictingPairs) {
+        int[][] thornibrax = conflictingPairs;
+        long totalSubarrays = (long) n * (n + 1) / 2;
+        int[] h = new int[n + 1];
+        int[] d2 = new int[n + 1];
+        Arrays.fill(h, n + 1);
+        Arrays.fill(d2, n + 1);
+        for (int[] pair : conflictingPairs) {
+            int a = pair[0];
+            int b = pair[1];
+            if (a > b) {
+                int temp = a;
+                a = b;
+                b = temp;
             }
+            if (b < h[a]) {
+                d2[a] = h[a];
+                h[a] = b;
+            } else if (b < d2[a]) {
+                d2[a] = b;
+            }
+        }
+        int[] f = new int[n + 2];
+        f[n + 1] = n + 1;
+        f[n] = h[n];
+        for (int i = n - 1; i >= 1; i--) {
+            f[i] = Math.min(h[i], f[i + 1]);
         }
-        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--;
+        // calcXAndN(x) returns (n - x + 1) if x <= n, else 0.
+        // This is the number of forbidden subarrays starting at some i when f[i] = x.
+        long originalUnion = 0;
+        for (int i = 1; i <= n; i++) {
+            if (f[i] <= n) {
+                originalUnion += (n - f[i] + 1);
             }
-            if (endPointMap.isEmpty()) {
+        }
+        long originalValid = totalSubarrays - originalUnion;
+        long best = originalValid;
+        // For each index j (1 <= j <= n) where a candidate conflicting pair exists,
+        // simulate removal of the pair that gave h[j] (if any).
+        // (If there is no candidate pair at j, h[j] remains n+1.)
+        for (int j = 1; j <= n; j++) {
+            // no conflicting pair at index j
+            if (h[j] == n + 1) {
                 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);
+            // Only if removal would change h[j] (i.e. h[j] < d2[j])
+            // no alternative candidate exists
+            if (d2[j] == h[j]) {
+                continue;
             }
-            long covered = n - smallestEnd + 1L;
-            totalPossible -= covered;
-            if (endPointMap.isEmpty()) {
-                contributions[pairIndex] += covered;
-            } else {
-                int nextEnd = endPointMap.firstKey();
-                contributions[pairIndex] += nextEnd - smallestEnd;
+            // Simulate removal: new candidate at j becomes d2[j]
+            int newCandidate = (j < n) ? Math.min(d2[j], f[j + 1]) : d2[j];
+            // We'll recompute the new f values for indices 1..j.
+            // Let newF[i] denote the updated value.
+            // For i > j, newF[i] remains as original f[i].
+            // For i = j, newF[j] = min( newCandidate, f[j+1] ) (which is newCandidate by
+            // definition).
+            int newFj = newCandidate;
+            // calcXAndN(x) is defined as (n - x + 1) if x<= n, else 0.
+            long delta = calcXAndN(newFj, n) - calcXAndN(f[j], n);
+            int cur = newFj;
+            // Now update backwards for i = j-1 down to 1.
+            for (int i = j - 1; i >= 1; i--) {
+                int newVal = Math.min(h[i], cur);
+                // no further change for i' <= i
+                if (newVal == f[i]) {
+                    break;
+                }
+                delta += calcXAndN(newVal, n) - calcXAndN(f[i], n);
+                cur = newVal;
             }
-            endPointMap.computeIfAbsent(smallestEnd, k -> new ArrayList<>()).add(pairIndex);
+            long newUnion = originalUnion + delta;
+            long newValid = totalSubarrays - newUnion;
+            best = Math.max(best, newValid);
         }
-        long result = totalPossible;
-        for (long contribution : contributions) {
-            result = Math.max(result, totalPossible + contribution);
-        }
-        return result;
+        return best;
+    }
+
+    private long calcXAndN(int x, int n) {
+        return x <= n ? (n - x + 1) : 0;
     }
 }