Improved tasks 3360-3367

javadev · javadev · commit 6ff72325f3fa · 2024-12-03T04:26:07.000+02:00
diff --git a/src/main/kotlin/g3301_3400/s3360_stone_removal_game/Solution.kt b/src/main/kotlin/g3301_3400/s3360_stone_removal_game/Solution.kt
@@ -1,6 +1,6 @@
 package g3301_3400.s3360_stone_removal_game
 
-// #Easy #Math #Simulation #2024_11_24_Time_0_ms_(100.00%)_Space_33.5_MB_(100.00%)
+// #Easy #Math #Simulation #2024_12_03_Time_0_ms_(100.00%)_Space_34.3_MB_(6.00%)
 
 class Solution {
     fun canAliceWin(n: Int): Boolean {
diff --git a/src/main/kotlin/g3301_3400/s3361_shift_distance_between_two_strings/Solution.kt b/src/main/kotlin/g3301_3400/s3361_shift_distance_between_two_strings/Solution.kt
@@ -1,28 +1,42 @@
 package g3301_3400.s3361_shift_distance_between_two_strings
 
-// #Medium #Array #String #Prefix_Sum #2024_11_24_Time_425_ms_(100.00%)_Space_41_MB_(100.00%)
+// #Medium #Array #String #Prefix_Sum #2024_12_03_Time_350_ms_(82.50%)_Space_41.7_MB_(57.50%)
 
 import kotlin.math.min
 
 class Solution {
     fun shiftDistance(s: String, t: String, nextCost: IntArray, previousCost: IntArray): Long {
-        var sum: Long = 0
-        val n = s.length
-        for (i in 0..<n) {
-            val ch1 = s[i].code - 'a'.code
-            val ch2 = t[i].code - 'a'.code
-            val forwardDiff = (ch2 - ch1 + 26) % 26
-            var forwardCost: Long = 0
-            for (j in 0..<forwardDiff) {
-                forwardCost += nextCost[(ch1 + j) % 26].toLong()
+        val costs = Array<LongArray?>(26) { LongArray(26) }
+        var cost: Long
+        for (i in 0..25) {
+            cost = nextCost[i].toLong()
+            var j = if (i == 25) 0 else i + 1
+            while (j != i) {
+                costs[i]!![j] = cost
+                cost += nextCost[j].toLong()
+                if (j == 25) {
+                    j = -1
+                }
+                j++
             }
-            val reverseDiff = (26 + ch1 - ch2) % 26
-            var backwardCost: Long = 0
-            for (j in 0..<reverseDiff) {
-                backwardCost += previousCost[(ch1 - j + 26) % 26].toLong()
+        }
+        for (i in 0..25) {
+            cost = previousCost[i].toLong()
+            var j = if (i == 0) 25 else i - 1
+            while (j != i) {
+                costs[i]!![j] = min(costs[i]!![j].toDouble(), cost.toDouble()).toLong()
+                cost += previousCost[j].toLong()
+                if (j == 0) {
+                    j = 26
+                }
+                j--
             }
-            sum = sum + min(forwardCost, backwardCost)
         }
-        return sum
+        val n = s.length
+        var ans: Long = 0
+        for (i in 0..<n) {
+            ans += costs[s[i].code - 'a'.code]!![t[i].code - 'a'.code]
+        }
+        return ans
     }
 }
diff --git a/src/main/kotlin/g3301_3400/s3362_zero_array_transformation_iii/Solution.kt b/src/main/kotlin/g3301_3400/s3362_zero_array_transformation_iii/Solution.kt
@@ -1,13 +1,13 @@
 package g3301_3400.s3362_zero_array_transformation_iii
 
 // #Medium #Array #Sorting #Greedy #Heap_Priority_Queue #Prefix_Sum
-// #2024_11_24_Time_217_ms_(100.00%)_Space_105.7_MB_(100.00%)
+// #2024_12_03_Time_195_ms_(81.82%)_Space_106.3_MB_(72.73%)
 
 import java.util.PriorityQueue
 
 class Solution {
     fun maxRemoval(nums: IntArray, queries: Array<IntArray>): Int {
-        queries.sortWith { a: IntArray, b: IntArray -> a[0] - b[0] }
+        queries.sortWith { a: IntArray?, b: IntArray? -> a!![0] - b!![0] }
         val last = PriorityQueue<Int?>(Comparator { a: Int?, b: Int? -> b!! - a!! })
         val diffs = IntArray(nums.size + 1)
         var idx = 0
diff --git a/src/main/kotlin/g3301_3400/s3363_find_the_maximum_number_of_fruits_collected/Solution.kt b/src/main/kotlin/g3301_3400/s3363_find_the_maximum_number_of_fruits_collected/Solution.kt
@@ -1,6 +1,7 @@
 package g3301_3400.s3363_find_the_maximum_number_of_fruits_collected
 
-// #Hard #Array #Dynamic_Programming #Matrix #2024_11_24_Time_53_ms_(100.00%)_Space_162_MB_(100.00%)
+// #Hard #Array #Dynamic_Programming #Matrix
+// #2024_12_03_Time_39_ms_(88.89%)_Space_161.2_MB_(100.00%)
 
 import kotlin.math.max
 
diff --git a/src/main/kotlin/g3301_3400/s3364_minimum_positive_sum_subarray/Solution.kt b/src/main/kotlin/g3301_3400/s3364_minimum_positive_sum_subarray/Solution.kt
@@ -1,22 +1,29 @@
 package g3301_3400.s3364_minimum_positive_sum_subarray
 
-// #Easy #Array #Prefix_Sum #Sliding_Window #2024_11_24_Time_24_ms_(100.00%)_Space_38_MB_(100.00%)
+// #Easy #Array #Prefix_Sum #Sliding_Window #2024_12_03_Time_3_ms_(98.15%)_Space_38.1_MB_(33.33%)
+
+import kotlin.math.min
 
 class Solution {
-    fun minimumSumSubarray(nums: List<Int>, l: Int, r: Int): Int {
-        val size = nums.size
-        var res = -1
-        for (s in l..r) {
-            for (i in 0..size - s) {
-                var sum = 0
-                for (j in i..<i + s) {
-                    sum += nums[j]
-                }
-                if (sum > 0 && (res == -1 || res > sum)) {
-                    res = sum
+    fun minimumSumSubarray(li: List<Int>, l: Int, r: Int): Int {
+        val n = li.size
+        var min = Int.Companion.MAX_VALUE
+        val a = IntArray(n + 1)
+        for (i in 1..n) {
+            a[i] = a[i - 1] + li[i - 1]
+        }
+        for (size in l..r) {
+            for (i in size - 1..<n) {
+                val sum = a[i + 1] - a[i + 1 - size]
+                if (sum > 0) {
+                    min = min(min, sum)
                 }
             }
         }
-        return res
+        return if (min == Int.Companion.MAX_VALUE) {
+            -1
+        } else {
+            min
+        }
     }
 }
diff --git a/src/main/kotlin/g3301_3400/s3365_rearrange_k_substrings_to_form_target_string/Solution.kt b/src/main/kotlin/g3301_3400/s3365_rearrange_k_substrings_to_form_target_string/Solution.kt
@@ -1,6 +1,6 @@
 package g3301_3400.s3365_rearrange_k_substrings_to_form_target_string
 
-// #Medium #String #Hash_Table #Sorting #2024_11_24_Time_490_ms_(100.00%)_Space_50.5_MB_(100.00%)
+// #Medium #String #Hash_Table #Sorting #2024_12_03_Time_457_ms_(100.00%)_Space_51.5_MB_(81.40%)
 
 class Solution {
     fun isPossibleToRearrange(s: String, t: String, k: Int): Boolean {
diff --git a/src/main/kotlin/g3301_3400/s3366_minimum_array_sum/Solution.kt b/src/main/kotlin/g3301_3400/s3366_minimum_array_sum/Solution.kt
@@ -1,41 +1,80 @@
 package g3301_3400.s3366_minimum_array_sum
 
-// #Medium #Array #Dynamic_Programming #2024_11_24_Time_59_ms_(100.00%)_Space_53.4_MB_(100.00%)
-
-import kotlin.math.ceil
-import kotlin.math.min
+// #Medium #Array #Dynamic_Programming #2024_12_03_Time_15_ms_(100.00%)_Space_39.5_MB_(92.86%)
 
 class Solution {
     fun minArraySum(nums: IntArray, k: Int, op1: Int, op2: Int): Int {
-        val dp = Array<Array<Array<Int?>?>?>(nums.size) { Array<Array<Int?>?>(op1 + 1) { arrayOfNulls<Int>(op2 + 1) } }
-        return sub(dp, nums, 0, k, op1, op2)
-    }
-
-    private fun sub(dp: Array<Array<Array<Int?>?>?>, nums: IntArray, i: Int, k: Int, op1: Int, op2: Int): Int {
-        if (i == nums.size) {
-            return 0
-        }
-        if (dp[i]!![op1]!![op2] != null) {
-            return dp[i]!![op1]!![op2]!!
+        var op1 = op1
+        var op2 = op2
+        nums.sort()
+        val high = lowerBound(nums, k * 2 - 1)
+        val low = lowerBound(nums, k)
+        val n = nums.size
+        for (i in n - 1 downTo high) {
+            if (op1 > 0) {
+                nums[i] = (nums[i] + 1) / 2
+                op1--
+            }
+            if (op2 > 0) {
+                nums[i] -= k
+                op2--
+            }
         }
-        var res = sub(dp, nums, i + 1, k, op1, op2) + nums[i]
-        if (nums[i] >= k && op2 > 0) {
-            res = min(res, (sub(dp, nums, i + 1, k, op1, op2 - 1) + nums[i] - k))
-            var v = ceil(nums[i] / 2.0)
-            if (v < k) {
-                v = ceil((nums[i] - k) / 2.0)
+        val count: MutableMap<Int?, Int?> = HashMap<Int?, Int?>()
+        var odd = 0
+        for (i in low..<high) {
+            if (op2 > 0) {
+                nums[i] -= k
+                if (k % 2 > 0 && nums[i] % 2 > 0) {
+                    count.merge(nums[i], 1) { a: Int?, b: Int? -> Integer.sum(a!!, b!!) }
+                }
+                op2--
             } else {
-                v -= k
+                odd += nums[i] % 2
             }
-            if (op1 > 0) {
-                res = min(res, (sub(dp, nums, i + 1, k, op1 - 1, op2 - 1) + v).toInt())
+        }
+        nums.sort(0, high)
+        var ans = 0
+        if (k % 2 > 0) {
+            var i = high - op1
+            while (i < high && odd > 0) {
+                val x = nums[i]
+                if (count.containsKey(x)) {
+                    if (count.merge(x, -1) { a: Int?, b: Int? ->
+                            Integer.sum(a!!, b!!)
+                        } == 0
+                    ) {
+                        count.remove(x)
+                    }
+                    odd--
+                    ans--
+                }
+                i++
             }
         }
-        if (op1 > 0) {
-            val v = ceil(nums[i] / 2.0)
-            res = min(res, (sub(dp, nums, i + 1, k, op1 - 1, op2) + v).toInt())
+        var i = high - 1
+        while (i >= 0 && op1 > 0) {
+            nums[i] = (nums[i] + 1) / 2
+            i--
+            op1--
+        }
+        for (x in nums) {
+            ans += x
+        }
+        return ans
+    }
+
+    private fun lowerBound(nums: IntArray, target: Int): Int {
+        var left = -1
+        var right = nums.size
+        while (left + 1 < right) {
+            val mid = (left + right) ushr 1
+            if (nums[mid] >= target) {
+                right = mid
+            } else {
+                left = mid
+            }
         }
-        dp[i]!![op1]!![op2] = res
-        return res
+        return right
     }
 }
diff --git a/src/main/kotlin/g3301_3400/s3367_maximize_sum_of_weights_after_edge_removals/Solution.kt b/src/main/kotlin/g3301_3400/s3367_maximize_sum_of_weights_after_edge_removals/Solution.kt
@@ -1,7 +1,7 @@
 package g3301_3400.s3367_maximize_sum_of_weights_after_edge_removals
 
 // #Hard #Dynamic_Programming #Depth_First_Search #Tree
-// #2024_11_27_Time_118_ms_(100.00%)_Space_140.5_MB_(100.00%)
+// #2024_12_03_Time_113_ms_(100.00%)_Space_141.5_MB_(81.82%)
 
 import java.util.PriorityQueue
 import kotlin.math.max
@@ -33,7 +33,7 @@ class Solution {
                 continue
             }
             val res = dfs(w, v)
-            val max = max((e[2] + res[0]), res[1])
+            val max = max(e[2] + res[0], res[1])
             sum += max
             pq.add(max - res[1])
         }
diff --git a/src/test/kotlin/g3301_3400/s3364_minimum_positive_sum_subarray/SolutionTest.kt b/src/test/kotlin/g3301_3400/s3364_minimum_positive_sum_subarray/SolutionTest.kt
@@ -24,7 +24,7 @@ internal class SolutionTest {
     @Test
     fun minimumSumSubarray3() {
         assertThat<Int>(
-            Solution().minimumSumSubarray(mutableListOf<Int>(1, 2, 3, 4), 2, 4),
+            Solution().minimumSumSubarray(listOf<Int>(1, 2, 3, 4), 2, 4),
             equalTo<Int>(3),
         )
     }
diff --git a/src/test/kotlin/g3301_3400/s3366_minimum_array_sum/SolutionTest.kt b/src/test/kotlin/g3301_3400/s3366_minimum_array_sum/SolutionTest.kt
@@ -20,4 +20,20 @@ internal class SolutionTest {
             equalTo<Int>(3),
         )
     }
+
+    @Test
+    fun minArraySum3() {
+        assertThat<Int>(
+            Solution()
+                .minArraySum(
+                    intArrayOf(
+                        1, 3, 5, 7, 9, 12, 12, 12, 13, 15, 15, 15, 16, 17, 19, 20,
+                    ),
+                    11,
+                    15,
+                    4,
+                ),
+            equalTo<Int>(77),
+        )
+    }
 }
diff --git a/src/test/kotlin/g3301_3400/s3367_maximize_sum_of_weights_after_edge_removals/SolutionTest.kt b/src/test/kotlin/g3301_3400/s3367_maximize_sum_of_weights_after_edge_removals/SolutionTest.kt
@@ -37,7 +37,18 @@ internal class SolutionTest {
                     ),
                     3,
                 ),
-            equalTo<Long?>(65L),
+            equalTo<Long>(65L),
+        )
+    }
+
+    @Test
+    fun maximizeSumOfWeights3() {
+        assertThat<Long>(
+            Solution().maximizeSumOfWeights(
+                arrayOf<IntArray>(intArrayOf(0, 1, 34), intArrayOf(0, 2, 17)),
+                1,
+            ),
+            equalTo<Long>(34L),
         )
     }
 }

Original file line number	Diff line number	Diff line change
`@@ -24,7 +24,7 @@ internal class SolutionTest {`
`24`	`24`	`@Test`
`25`	`25`	`fun minimumSumSubarray3() {`
`26`	`26`	`assertThat<Int>(`
`27`		`- Solution().minimumSumSubarray(mutableListOf<Int>(1, 2, 3, 4), 2, 4),`
	`27`	`+ Solution().minimumSumSubarray(listOf<Int>(1, 2, 3, 4), 2, 4),`
`28`	`28`	`equalTo<Int>(3),`
`29`	`29`	`)`
`30`	`30`	`}`