Improved tasks

Author: javadev

src/main/kotlin/g3601_3700/s3663_find_the_least_frequent_digit/Solution.kt

@@ -1,26 +1,25 @@
 package g3601_3700.s3663_find_the_least_frequent_digit
 
-// #Easy #Biweekly_Contest_164 #2025_08_31_Time_3_ms_(100.00%)_Space_41.13_MB_(100.00%)
-
-import kotlin.math.min
+// #Easy #Biweekly_Contest_164 #2025_09_07_Time_1_ms_(96.30%)_Space_40.60_MB_(100.00%)
 
 class Solution {
     fun getLeastFrequentDigit(n: Int): Int {
-        val s = n.toString()
-        val k = s.length
-        val freq: MutableMap<Int, Int> = HashMap<Int, Int>()
-        for (i in 0..<k) {
-            val digit = s[i].code - '0'.code
-            freq.put(digit, freq.getOrDefault(digit, 0) + 1)
-        }
-        var minfreq = Int.Companion.MAX_VALUE
-        for (it in freq.entries) {
-            minfreq = min(minfreq, it.value)
+        val freq = IntArray(10)
+        val numStr = n.toString()
+        for (c in numStr.toCharArray()) {
+            freq[c.code - '0'.code]++
         }
-        var result = 10
-        for (it in freq.entries) {
-            if (it.value == minfreq) {
-                result = min(result, it.key)
+        var minFreq = Int.Companion.MAX_VALUE
+        var result = -1
+        for (d in 0..9) {
+            if (freq[d] == 0) {
+                continue
+            }
+            if (freq[d] < minFreq) {
+                minFreq = freq[d]
+                result = d
+            } else if (freq[d] == minFreq && d < result) {
+                result = d
             }
         }
         return result

src/main/kotlin/g3601_3700/s3664_two_letter_card_game/Solution.kt

@@ -1,6 +1,6 @@
 package g3601_3700.s3664_two_letter_card_game
 
-// #Medium #Biweekly_Contest_164 #2025_08_31_Time_11_ms_(100.00%)_Space_82.34_MB_(_%)
+// #Medium #Biweekly_Contest_164 #2025_09_07_Time_11_ms_(100.00%)_Space_69.41_MB_(100.00%)
 
 import kotlin.math.min
 
@@ -12,8 +12,8 @@ class Solution {
         val right = IntArray(10)
         var xx = 0
         for (c in cards) {
-            val a = c[0]
-            val b = c[1]
+            val a = c.get(0)
+            val b = c.get(1)
             if (a == x && b == x) {
                 xx++
             } else if (a == x) {

src/main/kotlin/g3601_3700/s3665_twisted_mirror_path_count/Solution.kt

@@ -1,46 +1,37 @@
 package g3601_3700.s3665_twisted_mirror_path_count
 
-// #Medium #Biweekly_Contest_164 #2025_08_31_Time_114_ms_(100.00%)_Space_120.02_MB_(100.00%)
+// #Medium #Biweekly_Contest_164 #2025_09_07_Time_33_ms_(100.00%)_Space_113.52_MB_(72.73%)
 
 class Solution {
     fun uniquePaths(grid: Array<IntArray>): Int {
+        // 0 right, 1 down
         val n = grid.size
         val m = grid[0].size
-        val dp = Array<Array<IntArray>>(n) { Array<IntArray>(m) { IntArray(2) } }
-        for (i in 0..<n) {
-            for (j in 0..<m) {
-                dp[i][j].fill(-1)
+        val mod = 1000000007
+        var dp = IntArray(m)
+        dp[0] = 1
+        for (j in 1..<m) {
+            if (grid[0][j - 1] == 0) {
+                dp[j] = dp[j - 1]
             }
         }
-        return f(0, 0, 0, grid, n, m, dp)
-    }
-
-    private fun f(i: Int, j: Int, dir: Int, grid: Array<IntArray>, n: Int, m: Int, dp: Array<Array<IntArray>>): Int {
-        if (i == n - 1 && j == m - 1) {
-            return 1
-        }
-        if (i >= n || j >= m) {
-            return 0
-        }
-        if (dp[i][j][dir] != -1) {
-            return dp[i][j][dir]
-        }
-        var ways: Long = 0
-        if (grid[i][j] == 1) {
-            ways = if (dir == 0) {
-                f(i + 1, j, 1, grid, n, m, dp).toLong()
-            } else {
-                f(i, j + 1, 0, grid, n, m, dp).toLong()
+        for (i in 1..<n) {
+            val next = IntArray(m)
+            if (grid[i - 1][0] == 0 && grid[i][0] == 0) {
+                next[0] = dp[0]
+            }
+            for (j in 1..<m) {
+                if (grid[i][j] == 0) {
+                    next[j] = (next[j] + dp[j]) % mod
+                }
+                if (grid[i][j - 1] == 0) {
+                    next[j] = (next[j] + next[j - 1]) % mod
+                } else {
+                    next[j] = (next[j] + dp[j - 1]) % mod
+                }
             }
-        } else {
-            ways += f(i + 1, j, 1, grid, n, m, dp).toLong()
-            ways += f(i, j + 1, 0, grid, n, m, dp).toLong()
+            dp = next
         }
-        dp[i][j][dir] = ways.toInt() % MOD
-        return dp[i][j][dir]
-    }
-
-    companion object {
-        private const val MOD = 1000000007
+        return dp[m - 1]
     }
 }

src/main/kotlin/g3601_3700/s3666_minimum_operations_to_equalize_binary_string/Solution.kt

@@ -1,66 +1,46 @@
 package g3601_3700.s3666_minimum_operations_to_equalize_binary_string
 
-// #Hard #Biweekly_Contest_164 #2025_08_31_Time_29_ms_(100.00%)_Space_48.47_MB_(100.00%)
+// #Hard #Biweekly_Contest_164 #2025_09_07_Time_8_ms_(100.00%)_Space_46.70_MB_(100.00%)
 
-import java.util.ArrayDeque
-import java.util.Queue
 import kotlin.math.max
-import kotlin.math.min
 
 class Solution {
     fun minOperations(s: String, k: Int): Int {
-        val zeros = s.chars().map { x: Int -> if (x == '0'.code) 1 else 0 }.sum()
-        if ((zeros % k) == 0) {
-            return zeros / k
-        }
         val n = s.length
-        val q: Queue<Int> = ArrayDeque<Int>()
-        q.add(zeros)
-        var res = 1
-        // use bounds for optimization
-        val bounds = Array<IntArray>(2) { IntArray(2) }
-        bounds[zeros and 1][1] = zeros
-        bounds[zeros and 1][0] = bounds[zeros and 1][1]
-        bounds[1 - (zeros and 1)][0] = Int.Companion.MAX_VALUE
-        bounds[1 - (zeros and 1)][1] = Int.Companion.MIN_VALUE
-        while (q.isNotEmpty()) {
-            // find min number of zeros and max number of zeros in this round
-            var minv = Int.Companion.MAX_VALUE
-            var maxv = Int.Companion.MIN_VALUE
-            for (len in q.size downTo 1) {
-                val h: Int = q.poll()
-                val t = n - h
-                var x = min(h, k)
-                if (t >= k - x) {
-                    val fst = h - x + (k - x)
-                    minv = min(minv, fst)
-                    maxv = max(maxv, fst)
-                }
-                x = min(t, k)
-                if (h >= k - x) {
-                    val snd = h - (k - x) + x
-                    minv = min(minv, snd)
-                    maxv = max(maxv, snd)
-                }
+        var cnt0 = 0
+        for (c in s.toCharArray()) {
+            if (c == '0') {
+                cnt0++
+            }
+        }
+        if (cnt0 == 0) {
+            return 0
+        }
+        if (k == n) {
+            return if (cnt0 == n) 1 else -1
+        }
+        val kP = k and 1
+        val needP = cnt0 and 1
+        var best = Long.Companion.MAX_VALUE
+        for (p in 0..1) {
+            if ((p * kP) % 2 != needP) {
+                continue
+            }
+            val mismatch = (if (p == 0) cnt0 else (n - cnt0)).toLong()
+            val b1 = (cnt0 + k - 1L) / k
+            val b2: Long
+            b2 = (mismatch + (n - k) - 1L) / (n - k)
+            var lb = max(b1, b2)
+            if (lb < 1) {
+                lb = 1
+            }
+            if ((lb and 1L) != p.toLong()) {
+                lb++
             }
-            // possible children are sequence of equal difference 2
-            val ind = minv and 1
-            var temp = minv
-            while (temp <= maxv) {
-                if ((temp % k) == 0) {
-                    return res + temp / k
-                }
-                if (temp < bounds[ind][0] || temp > bounds[ind][1]) {
-                    q.add(temp)
-                    temp += 2
-                } else {
-                    temp = bounds[ind][1] + 2
-                }
+            if (lb < best) {
+                best = lb
             }
-            bounds[ind][0] = min(bounds[ind][0], minv)
-            bounds[ind][1] = max(bounds[ind][1], maxv)
-            res++
         }
-        return -1
+        return if (best == Long.Companion.MAX_VALUE) -1 else best.toInt()
     }
 }

src/main/kotlin/g3601_3700/s3668_restore_finishing_order/Solution.kt

@@ -1,6 +1,6 @@
 package g3601_3700.s3668_restore_finishing_order
 
-// #Easy #Weekly_Contest_465 #2025_08_31_Time_2_ms_(100.00%)_Space_49.00_MB_(93.75%)
+// #Easy #Weekly_Contest_465 #2025_09_07_Time_2_ms_(94.29%)_Space_49.08_MB_(72.86%)
 
 class Solution {
     fun recoverOrder(order: IntArray, friends: IntArray): IntArray {

src/main/kotlin/g3601_3700/s3669_balanced_k_factor_decomposition/Solution.kt

@@ -1,6 +1,6 @@
 package g3601_3700.s3669_balanced_k_factor_decomposition
 
-// #Medium #Weekly_Contest_465 #2025_08_31_Time_33_ms_(100.00%)_Space_58.00_MB_(40.00%)
+// #Medium #Weekly_Contest_465 #2025_09_07_Time_30_ms_(85.71%)_Space_56.41_MB_(28.57%)
 
 import kotlin.math.max
 import kotlin.math.min

src/main/kotlin/g3601_3700/s3670_maximum_product_of_two_integers_with_no_common_bits/Solution.kt

@@ -1,6 +1,6 @@
 package g3601_3700.s3670_maximum_product_of_two_integers_with_no_common_bits
 
-// #Medium #Weekly_Contest_465 #2025_08_31_Time_103_ms_(100.00%)_Space_82.76_MB_(33.33%)
+// #Medium #Weekly_Contest_465 #2025_09_07_Time_113_ms_(88.89%)_Space_78.00_MB_(100.00%)
 
 class Solution {
     fun maxProduct(nums: IntArray): Long {

src/main/kotlin/g3601_3700/s3671_sum_of_beautiful_subsequences/Solution.kt

@@ -1,6 +1,6 @@
 package g3601_3700.s3671_sum_of_beautiful_subsequences
 
-// #Hard #Weekly_Contest_465 #2025_08_31_Time_270_ms_(100.00%)_Space_79.84_MB_(100.00%)
+// #Hard #Weekly_Contest_465 #2025_09_07_Time_225_ms_(100.00%)_Space_75.96_MB_(100.00%)
 
 import kotlin.math.sqrt
 

src/test/kotlin/g3601_3700/s3666_minimum_operations_to_equalize_binary_string/SolutionTest.kt

@@ -19,4 +19,64 @@ internal class SolutionTest {
     fun minOperations3() {
         assertThat<Int>(Solution().minOperations("101", 2), equalTo<Int>(-1))
     }
+
+    @Test
+    fun minOperations4() {
+        val k = 3
+        assertThat<Int>(Solution().minOperations("111111", k), equalTo<Int>(0))
+    }
+
+    @Test
+    fun minOperations5() {
+        val k = 6
+        assertThat<Int>(Solution().minOperations("000000", k), equalTo<Int>(1))
+    }
+
+    @Test
+    fun minOperations6() {
+        val k = 6
+        assertThat<Int>(Solution().minOperations("000111", k), equalTo<Int>(-1))
+    }
+
+    @Test
+    fun minOperations7() {
+        val k = 3
+        assertThat<Int>(Solution().minOperations("0011", k), equalTo<Int>(2))
+    }
+
+    @Test
+    fun minOperations8() {
+        val k = 4
+        assertThat<Int>(Solution().minOperations("000011", k), equalTo<Int>(1))
+    }
+
+    @Test
+    fun minOperations9() {
+        val k = 2
+        assertThat<Int>(Solution().minOperations("000111", k), equalTo<Int>(-1))
+    }
+
+    @Test
+    fun minOperations10() {
+        val k = 4
+        assertThat<Int>(Solution().minOperations("001100", k), equalTo<Int>(1))
+    }
+
+    @Test
+    fun minOperations11() {
+        val k = 3
+        assertThat<Int>(Solution().minOperations("000100", k), equalTo<Int>(3))
+    }
+
+    @Test
+    fun minOperations12() {
+        val k = 4
+        assertThat<Int>(Solution().minOperations("111111", k), equalTo<Int>(0))
+    }
+
+    @Test
+    fun minOperations13() {
+        val k = 4
+        assertThat<Int>(Solution().minOperations("001001", k), equalTo<Int>(1))
+    }
 }