Improved task 3389

Author: javadev

src/main/kotlin/g3301_3400/s3386_button_with_longest_push_time/Solution.kt

@@ -1,6 +1,6 @@
 package g3301_3400.s3386_button_with_longest_push_time
 
-// #Easy #Array #2024_12_15_Time_1_ms_(100.00%)_Space_40.6_MB_(100.00%)
+// #Easy #Array #2024_12_18_Time_1_ms_(100.00%)_Space_41.1_MB_(91.89%)
 
 import kotlin.math.min
 

src/main/kotlin/g3301_3400/s3387_maximize_amount_after_two_days_of_conversions/Solution.kt

@@ -1,7 +1,7 @@
 package g3301_3400.s3387_maximize_amount_after_two_days_of_conversions
 
 // #Medium #Array #String #Depth_First_Search #Breadth_First_Search #Graph
-// #2024_12_15_Time_13_ms_(100.00%)_Space_43.7_MB_(100.00%)
+// #2024_12_18_Time_13_ms_(88.46%)_Space_47.8_MB_(30.77%)
 
 import kotlin.math.max
 

src/main/kotlin/g3301_3400/s3388_count_beautiful_splits_in_an_array/Solution.kt

@@ -1,6 +1,6 @@
 package g3301_3400.s3388_count_beautiful_splits_in_an_array
 
-// #Medium #Array #Dynamic_Programming #2024_12_15_Time_162_ms_(100.00%)_Space_235.2_MB_(100.00%)
+// #Medium #Array #Dynamic_Programming #2024_12_18_Time_155_ms_(100.00%)_Space_227.9_MB_(26.67%)
 
 import kotlin.math.min
 

src/main/kotlin/g3301_3400/s3389_minimum_operations_to_make_character_frequencies_equal/Solution.kt

@@ -1,44 +1,44 @@
 package g3301_3400.s3389_minimum_operations_to_make_character_frequencies_equal
 
 // #Hard #String #Hash_Table #Dynamic_Programming #Counting #Enumeration
-// #2024_12_15_Time_88_ms_(100.00%)_Space_40.7_MB_(100.00%)
-
-import kotlin.math.max
-import kotlin.math.min
+// #2024_12_18_Time_9_ms_(78.95%)_Space_39.3_MB_(18.42%)
 
 class Solution {
     fun makeStringGood(s: String): Int {
         val n = s.length
-        val a = IntArray(110)
-        for (ch in s.toCharArray()) {
-            a[ch.code - 'a'.code + 1]++
-        }
-        val f: Array<IntArray> = Array<IntArray>(30) { IntArray(3) }
-        val inf = Int.Companion.MAX_VALUE / 2
-        var ans = inf
-        for (avg in 1..n) {
-            for (row in f) {
-                row.fill(inf)
+        val cnt = IntArray(26)
+        for (c in s) cnt[c - 'a']++
+        var mn = n
+        var mx = 0
+        for (c in cnt)
+            if (c != 0) {
+                mn = Math.min(mn, c)
+                mx = Math.max(mx, c)
             }
-            f[0][0] = 0
-            for (i in 1..26) {
-                f[i][0] = min(min(f[i - 1][0], f[i - 1][1]), f[i - 1][2]) + a[i]
-                if (a[i] <= avg) {
-                    f[i][1] = min(
-                        min(
-                            (f[i - 1][0] + max(avg - a[i - 1] - a[i], 0)),
-                            (f[i - 1][1] + (avg - a[i])),
-                        ),
-                        (f[i - 1][2] + max(avg - (a[i - 1] - avg) - a[i], 0)),
-                    ).toInt()
-                }
-                if (a[i] >= avg) {
-                    f[i][2] =
-                        min(min(f[i - 1][0], f[i - 1][1]), f[i - 1][2]) + (a[i] - avg)
+        if (mn == mx) return 0
+        var dp0 = 0
+        var dp1 = 0
+        var tmp0 = 0
+        var tmp1 = 0
+        var ans = n - 1
+        for (i in mn..mx) {
+            dp0 = cnt[0]
+            dp1 = Math.abs(i - cnt[0])
+            for (j in 1 until 26) {
+                tmp0 = dp0
+                tmp1 = dp1
+                dp0 = Math.min(tmp0, tmp1) + cnt[j]
+                if (cnt[j] >= i) {
+                    dp1 = Math.min(tmp0, tmp1) + (cnt[j] - i)
+                } else {
+                    dp1 = Math.min(
+                        tmp0 + i - Math.min(i, cnt[j] + cnt[j - 1]),
+                        tmp1 + i - Math.min(i, cnt[j] + Math.max(0, cnt[j - 1] - i)),
+                    )
                 }
             }
-            ans = min(ans, min(f[26][0], min(f[26][1], f[26][2])))
+            ans = Math.min(ans, minOf(dp0, dp1))
         }
-        return if (ans == inf) -1 else ans
+        return ans
     }
 }