Improved tasks 3477-3480

Author: javadev

src/main/kotlin/g3401_3500/s3477_fruits_into_baskets_ii/Solution.kt

@@ -1,26 +1,23 @@
 package g3401_3500.s3477_fruits_into_baskets_ii
 
 // #Easy #Array #Binary_Search #Simulation #Segment_Tree
-// #2025_03_10_Time_4_ms_(100.00%)_Space_47.71_MB_(100.00%)
+// #2025_03_11_Time_3_ms_(100.00%)_Space_47.78_MB_(75.61%)
 
 class Solution {
     fun numOfUnplacedFruits(fruits: IntArray, baskets: IntArray): Int {
         val n = fruits.size
-        var ct = 0
-        val used = BooleanArray(n)
-        for (fruit in fruits) {
-            var flag = true
-            for (i in 0..<n) {
-                if (fruit <= baskets[i] && !used[i]) {
-                    used[i] = true
-                    flag = false
+        var currfruits: Int
+        var count = 0
+        for (i in 0..<n) {
+            currfruits = fruits[i]
+            for (j in 0..<n) {
+                if (baskets[j] >= currfruits) {
+                    count++
+                    baskets[j] = 0
                     break
                 }
             }
-            if (flag) {
-                ct++
-            }
         }
-        return ct
+        return n - count
     }
 }

src/main/kotlin/g3401_3500/s3478_choose_k_elements_with_maximum_sum/Solution.kt

@@ -1,35 +1,40 @@
 package g3401_3500.s3478_choose_k_elements_with_maximum_sum
 
 // #Medium #Array #Sorting #Heap_Priority_Queue
-// #2025_03_10_Time_238_ms_(100.00%)_Space_87.94_MB_(100.00%)
+// #2025_03_11_Time_151_ms_(100.00%)_Space_93.64_MB_(40.74%)
 
 import java.util.PriorityQueue
 
 class Solution {
     fun findMaxSum(nums1: IntArray, nums2: IntArray, k: Int): LongArray {
         val n = nums1.size
-        val arr = Array<IntArray>(n) { IntArray(3) }
-        for (i in 0..<n) {
-            arr[i][0] = nums1[i]
-            arr[i][1] = nums2[i]
-            arr[i][2] = i
-        }
-        arr.sortWith { a: IntArray, b: IntArray -> a[0] - b[0] }
         val ans = LongArray(n)
-        val pq = PriorityQueue<Int>()
-        var sum: Long = 0
-        for (i in 0..<n) {
-            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
+        val ps = Array<Point>(n) { i -> Point(nums1[i], nums2[i], i) }
+        ps.sortWith { p1: Point, p2: Point -> p1.x.compareTo(p2.x) }
+        val pq = PriorityQueue<Int?>()
+        var s: Long = 0
+        var i = 0
+        while (i < n) {
+            var 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].toLong()
-            if (pq.size > k) {
-                sum -= pq.remove()!!.toLong()
+            for (p in i..<j) {
+                val cur = ps[p].y
+                if (pq.size < k) {
+                    pq.offer(cur)
+                    s += cur.toLong()
+                } else if (cur > pq.peek()!!) {
+                    s -= pq.poll()!!.toLong()
+                    pq.offer(cur)
+                    s += cur.toLong()
+                }
             }
+            i = j
         }
         return ans
     }
+
+    private class Point(var x: Int, var y: Int, var i: Int)
 }

src/main/kotlin/g3401_3500/s3479_fruits_into_baskets_iii/Solution.kt

@@ -1,36 +1,53 @@
 package g3401_3500.s3479_fruits_into_baskets_iii
 
 // #Medium #Array #Binary_Search #Ordered_Set #Segment_Tree
-// #2025_03_10_Time_555_ms_(100.00%)_Space_78.68_MB_(100.00%)
+// #2025_03_11_Time_53_ms_(92.86%)_Space_86.21_MB_(7.14%)
 
 import kotlin.math.max
 
 class Solution {
     fun numOfUnplacedFruits(fruits: IntArray, baskets: IntArray): Int {
-        var unp = 0
-        var max = 0
-        val list: MutableList<Int> = ArrayList<Int>()
-        for (basket in baskets) {
-            list.add(basket)
-            max = max(max, basket)
+        val n = baskets.size
+        var size = 1
+        while (size < n) {
+            size = size shl 1
         }
-        for (fruit in fruits) {
-            if (fruit > max) {
-                unp++
+        val seg = IntArray(2 * size)
+        for (i in 0..<n) {
+            seg[size + i] = baskets[i]
+        }
+        for (i in n..<size) {
+            seg[size + i] = 0
+        }
+        for (i in size - 1 downTo 1) {
+            seg[i] = max(seg[i shl 1].toDouble(), seg[i shl 1 or 1].toDouble()).toInt()
+        }
+        var ans = 0
+        for (f in fruits) {
+            if (seg[1] < f) {
+                ans++
                 continue
             }
-            var placed = false
-            for (j in list.indices) {
-                if (list[j] >= fruit) {
-                    list.removeAt(j)
-                    placed = true
-                    break
+            var idx = 1
+            while (idx < size) {
+                if (seg[idx shl 1] >= f) {
+                    idx = idx shl 1
+                } else {
+                    idx = idx shl 1 or 1
                 }
             }
-            if (!placed) {
-                unp++
-            }
+            update(seg, idx - size, 0, size)
+        }
+        return ans
+    }
+
+    private fun update(seg: IntArray, pos: Int, `val`: Int, size: Int) {
+        var i = pos + size
+        seg[i] = `val`
+        i /= 2
+        while (i > 0) {
+            seg[i] = max(seg[i shl 1].toDouble(), seg[i shl 1 or 1].toDouble()).toInt()
+            i /= 2
         }
-        return unp
     }
 }

src/main/kotlin/g3401_3500/s3480_maximize_subarrays_after_removing_one_conflicting_pair/Solution.kt

@@ -1,58 +1,86 @@
 package g3401_3500.s3480_maximize_subarrays_after_removing_one_conflicting_pair
 
 // #Hard #Array #Prefix_Sum #Enumeration #Segment_Tree
-// #2025_03_10_Time_742_ms_(100.00%)_Space_165.07_MB_(100.00%)
+// #2025_03_11_Time_48_ms_(100.00%)_Space_164.15_MB_(100.00%)
 
-import java.util.TreeMap
 import kotlin.math.max
+import kotlin.math.min
 
 class Solution {
-    fun maxSubarrays(n: Int, cp: Array<IntArray>): Long {
-        for (pair in cp) {
-            if (pair[0] > pair[1]) {
-                val temp = pair[0]
-                pair[0] = pair[1]
-                pair[1] = temp
+    fun maxSubarrays(n: Int, conflictingPairs: Array<IntArray>): Long {
+        val totalSubarrays = n.toLong() * (n + 1) / 2
+        val h = IntArray(n + 1)
+        val d2 = IntArray(n + 1)
+        h.fill(n + 1)
+        d2.fill(n + 1)
+        for (pair in conflictingPairs) {
+            var a = pair[0]
+            var b = pair[1]
+            if (a > b) {
+                val 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
+            }
+        }
+        val f = IntArray(n + 2)
+        f[n + 1] = n + 1
+        f[n] = h[n]
+        for (i in n - 1 downTo 1) {
+            f[i] = min(h[i], f[i + 1]).toInt()
         }
-        cp.sortWith { a: IntArray, b: IntArray -> a[0].compareTo(b[0]) }
-        val contributions = LongArray(cp.size)
-        var totalPossible = n.toLong() * (n + 1) / 2
-        val endPointMap = TreeMap<Int, MutableList<Int>>()
-        var currentIndex = cp.size - 1
-        for (start in n downTo 1) {
-            while (currentIndex >= 0 && cp[currentIndex][0] >= start) {
-                val end = cp[currentIndex][1]
-                endPointMap.computeIfAbsent(end) { _: Int -> ArrayList<Int>() }
-                    .add(currentIndex)
-                currentIndex--
+        // forbiddenCount(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.
+        var originalUnion: Long = 0
+        for (i in 1..n) {
+            if (f[i] <= n) {
+                originalUnion += (n - f[i] + 1).toLong()
             }
-            if (endPointMap.isEmpty()) {
+        }
+        val originalValid = totalSubarrays - originalUnion
+        var 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 (j in 1..n) {
+            // no conflicting pair at index j
+            if (h[j] == n + 1) {
                 continue
             }
-            val firstEntry = endPointMap.firstEntry()
-            val smallestEnd: Int = firstEntry.key!!
-            val pairIndex: Int = firstEntry.value!![0]
-            if (firstEntry.value!!.size == 1) {
-                endPointMap.remove(smallestEnd)
-            } else {
-                firstEntry.value!!.removeAt(0)
-            }
-            val covered = n - smallestEnd + 1L
-            totalPossible -= covered
-            if (endPointMap.isEmpty()) {
-                contributions[pairIndex] += covered
-            } else {
-                val nextEnd: Int = endPointMap.firstKey()!!
-                contributions[pairIndex] += (nextEnd - smallestEnd).toLong()
+            // Simulate removal: new candidate at j becomes d2[j]
+            val newCandidate = if (j < n) min(d2[j], f[j + 1]).toInt() else 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).
+            val newFj = newCandidate
+            // forbiddenCount(x) is defined as (n - x + 1) if x<= n, else 0.
+            var delta = forbiddenCount(newFj, n) - forbiddenCount(f[j], n)
+            var cur = newFj
+            // Now update backwards for i = j-1 down to 1.
+            for (i in j - 1 downTo 1) {
+                val newVal = min(h[i], cur)
+                // no further change for i' <= i
+                if (newVal == f[i]) {
+                    break
+                }
+                delta += forbiddenCount(newVal, n) - forbiddenCount(f[i], n)
+                cur = newVal
             }
-            endPointMap.computeIfAbsent(smallestEnd) { _: Int -> ArrayList<Int>() }
-                .add(pairIndex)
+            val newUnion = originalUnion + delta
+            val newValid = totalSubarrays - newUnion
+            best = max(best, newValid)
         }
-        var result = totalPossible
-        for (contribution in contributions) {
-            result = max(result, (totalPossible + contribution))
-        }
-        return result
+        return best
+    }
+
+    private fun forbiddenCount(x: Int, n: Int): Long {
+        return (if (x <= n) (n - x + 1) else 0).toLong()
     }
 }

src/test/kotlin/g3401_3500/s3480_maximize_subarrays_after_removing_one_conflicting_pair/SolutionTest.kt

@@ -34,4 +34,12 @@ internal class SolutionTest {
             equalTo<Long>(50L),
         )
     }
+
+    @Test
+    fun maxSubarrays4() {
+        assertThat(
+            Solution().maxSubarrays(25, arrayOf<IntArray>(intArrayOf(9, 7), intArrayOf(15, 7), intArrayOf(4, 7))),
+            equalTo(216L),
+        )
+    }
 }