Added tags

Author: javadev

src/main/kotlin/g3701_3800/s3731_find_missing_elements/Solution.kt

@@ -1,17 +1,28 @@
 package g3701_3800.s3731_find_missing_elements
 
-// #Easy #Weekly_Contest_474 #2025_11_03_Time_12_ms_(100.00%)_Space_48.81_MB_(11.11%)
+// #Easy #Array #Hash_Table #Sorting #Weekly_Contest_474
+// #2025_11_05_Time_2_ms_(100.00%)_Space_46.48_MB_(84.44%)
 
 class Solution {
-    fun findMissingElements(nums: IntArray): MutableList<Int> {
+    fun findMissingElements(nums: IntArray): List<Int> {
+        var maxi = 0
+        var mini = 101
         val list: MutableList<Int> = ArrayList()
-        nums.sort()
-        for (i in 0..<nums.size - 1) {
-            if (nums[i + 1] - nums[i] > 1) {
-                for (j in nums[i] + 1..<nums[i + 1]) {
-                    list.add(j)
-                }
+        val array = BooleanArray(101)
+        for (num in nums) {
+            array[num] = true
+            if (maxi < num) {
+                maxi = num
             }
+            if (mini > num) {
+                mini = num
+            }
+        }
+        for (index in mini + 1..<maxi) {
+            if (array[index]) {
+                continue
+            }
+            list.add(index)
         }
         return list
     }

src/main/kotlin/g3701_3800/s3732_maximum_product_of_three_elements_after_one_replacement/Solution.kt

@@ -1,6 +1,7 @@
 package g3701_3800.s3732_maximum_product_of_three_elements_after_one_replacement
 
-// #Medium #Weekly_Contest_474 #2025_11_03_Time_6_ms_(100.00%)_Space_75.20_MB_(76.92%)
+// #Medium #Array #Math #Sorting #Greedy #Weekly_Contest_474
+// #2025_11_05_Time_6_ms_(88.00%)_Space_74.51_MB_(84.00%)
 
 import kotlin.math.abs
 

src/main/kotlin/g3701_3800/s3733_minimum_time_to_complete_all_deliveries/Solution.kt

@@ -1,43 +1,49 @@
 package g3701_3800.s3733_minimum_time_to_complete_all_deliveries
 
-// #Medium #Weekly_Contest_474 #2025_11_03_Time_2_ms_(100.00%)_Space_42.94_MB_(100.00%)
+// #Medium #Math #Binary_Search #Weekly_Contest_474
+// #2025_11_05_Time_2_ms_(100.00%)_Space_42.47_MB_(100.00%)
 
 import kotlin.math.max
 
 class Solution {
-    private fun func(mid: Long, d: IntArray, r: IntArray): Boolean {
-        val lcm = r[0].toLong() * r[1] / gcd(r[0].toLong(), r[1].toLong())
-        val a1 = mid / r[0]
-        val a2 = mid / r[1]
-        val a3 = mid / lcm
-        val b = mid - a1 - a2 + a3
-        val o1 = a2 - a3
-        val o2 = a1 - a3
-        val d0 = max(d[0] - o1, 0)
-        val d1 = max(d[1] - o2, 0)
-        return b >= d0 + d1
+    private fun pos(k: Long, n1: Long, n2: Long, p1: Int, p2: Int, lVal: Long): Boolean {
+        val kP1 = k / p1
+        val kP2 = k / p2
+        val kL = k / lVal
+        val s1 = kP2 - kL
+        val s2 = kP1 - kL
+        val sB = k - kP1 - kP2 + kL
+        val w1 = max(0L, n1 - s1)
+        val w2 = max(0L, n2 - s2)
+        return (w1 + w2) <= sB
     }
 
-    private fun gcd(a: Long, b: Long): Long {
+    private fun findGcd(a: Long, b: Long): Long {
         if (b == 0L) {
             return a
         }
-        return gcd(b, a % b)
+        return findGcd(b, a % b)
     }
 
     fun minimumTime(d: IntArray, r: IntArray): Long {
-        var lo: Long = 0
-        var hi = 1e12.toLong()
-        var ans = Long.MAX_VALUE
+        val n1 = d[0].toLong()
+        val n2 = d[1].toLong()
+        val p1 = r[0]
+        val p2 = r[1]
+        val g = findGcd(p1.toLong(), p2.toLong())
+        val l = p1.toLong() * p2 / g
+        var lo = n1 + n2
+        var hi = (n1 + n2) * max(p1, p2)
+        var res = hi
         while (lo <= hi) {
-            val mid = (lo + hi) / 2
-            if (func(mid, d, r)) {
-                ans = mid
+            val mid = lo + (hi - lo) / 2
+            if (pos(mid, n1, n2, p1, p2, l)) {
+                res = mid
                 hi = mid - 1
             } else {
                 lo = mid + 1
             }
         }
-        return ans
+        return res
     }
 }

src/main/kotlin/g3701_3800/s3734_lexicographically_smallest_palindromic_permutation_greater_than_target/Solution.kt

@@ -1,15 +1,16 @@
 package g3701_3800.s3734_lexicographically_smallest_palindromic_permutation_greater_than_target
 
-// #Hard #Weekly_Contest_474 #2025_11_03_Time_12_ms_(100.00%)_Space_47.24_MB_(100.00%)
+// #Hard #String #Two_Pointers #Enumeration #Weekly_Contest_474
+// #2025_11_05_Time_4_ms_(100.00%)_Space_46.12_MB_(77.78%)
 
 class Solution {
-    fun func(i: Int, target: String, ans: CharArray, l: Int, r: Int, freq: IntArray, end: Boolean): Boolean {
+    private fun func(i: Int, target: String, ans: CharArray, l: Int, r: Int, freq: IntArray, end: Boolean): Boolean {
         if (l > r) {
             return String(ans).compareTo(target) > 0
         }
         if (l == r) {
             var left = '#'
-            for (k in 0..25) {
+            for (k in 0 until 26) {
                 if (freq[k] > 0) {
                     left = (k + 'a'.code).toChar()
                 }
@@ -24,68 +25,67 @@ class Solution {
             return false
         }
         if (end) {
-            for (j in 0..25) {
+            for (j in 0 until 26) {
                 if (freq[j] > 1) {
                     freq[j] -= 2
-                    ans[r] = (j + 'a'.code).toChar()
-                    ans[l] = ans[r]
+                    val charJ = (j + 'a'.code).toChar()
+                    ans[l] = charJ
+                    ans[r] = charJ
                     if (func(i + 1, target, ans, l + 1, r - 1, freq, end)) {
                         return true
                     }
+                    ans[l] = '#'
                     ans[r] = '#'
-                    ans[l] = ans[r]
                     freq[j] += 2
                 }
             }
             return false
         }
         val curr = target[i]
         var next = '1'
-        for (k in target[i].code - 'a'.code + 1..25) {
+        for (k in (curr.code - 'a'.code + 1) until 26) {
             if (freq[k] > 1) {
                 next = (k + 'a'.code).toChar()
                 break
             }
         }
         if (freq[curr.code - 'a'.code] > 1) {
+            ans[l] = curr
             ans[r] = curr
-            ans[l] = ans[r]
             freq[curr.code - 'a'.code] -= 2
-            if (func(i + 1, target, ans, l + 1, r - 1, freq, end)) {
+            if (func(i + 1, target, ans, l + 1, r - 1, freq, false)) { // end = false
                 return true
             }
             freq[curr.code - 'a'.code] += 2
         }
         if (next != '1') {
+            ans[l] = next
             ans[r] = next
-            ans[l] = ans[r]
             freq[next.code - 'a'.code] -= 2
-            if (func(i + 1, target, ans, l + 1, r - 1, freq, true)) {
+            if (func(i + 1, target, ans, l + 1, r - 1, freq, true)) { // end = true
                 return true
             }
-            freq[next.code - 'a'.code] += 2
         }
+        ans[l] = '#'
         ans[r] = '#'
-        ans[l] = ans[r]
         return false
     }
 
     fun lexPalindromicPermutation(s: String, target: String): String {
         val freq = IntArray(26)
-        for (i in 0..<s.length) {
-            freq[s[i].code - 'a'.code]++
+        for (char in s) {
+            freq[char.code - 'a'.code]++
         }
         var oddc = 0
-        for (i in 0..25) {
+        for (i in 0 until 26) {
             if (freq[i] % 2 == 1) {
                 oddc++
             }
         }
         if (oddc > 1) {
             return ""
         }
-        val ans = CharArray(s.length)
-        ans.fill('#')
+        val ans = CharArray(s.length) { '#' }
         if (func(0, target, ans, 0, s.length - 1, freq, false)) {
             return String(ans)
         }