Updated tags

javadev · javadev · commit 414e64cf4246 · 2025-04-01T13:20:06.000+03:00
diff --git a/src/main/kotlin/g3401_3500/s3498_reverse_degree_of_a_string/Solution.kt b/src/main/kotlin/g3401_3500/s3498_reverse_degree_of_a_string/Solution.kt
@@ -1,6 +1,6 @@
 package g3401_3500.s3498_reverse_degree_of_a_string
 
-// #Easy #2025_03_30_Time_1_ms_(100.00%)_Space_42.68_MB_(100.00%)
+// #Easy #String #Simulation #2025_04_01_Time_2_ms_(87.18%)_Space_42.65_MB_(89.74%)
 
 class Solution {
     fun reverseDegree(s: String): Int {
diff --git a/src/main/kotlin/g3401_3500/s3499_maximize_active_section_with_trade_i/Solution.kt b/src/main/kotlin/g3401_3500/s3499_maximize_active_section_with_trade_i/Solution.kt
@@ -1,6 +1,6 @@
 package g3401_3500.s3499_maximize_active_section_with_trade_i
 
-// #Medium #2025_03_30_Time_45_ms_(100.00%)_Space_49.16_MB_(100.00%)
+// #Medium #String #Enumeration #2025_04_01_Time_52_ms_(73.08%)_Space_47.99_MB_(100.00%)
 
 import kotlin.math.max
 
diff --git a/src/main/kotlin/g3401_3500/s3500_minimum_cost_to_divide_array_into_subarrays/Solution.kt b/src/main/kotlin/g3401_3500/s3500_minimum_cost_to_divide_array_into_subarrays/Solution.kt
@@ -1,73 +1,26 @@
 package g3401_3500.s3500_minimum_cost_to_divide_array_into_subarrays
 
-// #Hard #2025_03_30_Time_200_ms_(100.00%)_Space_88.62_MB_(_%)
+// #Hard #Array #Dynamic_Programming #Prefix_Sum
+// #2025_04_01_Time_28_ms_(92.31%)_Space_49.69_MB_(69.23%)
 
 class Solution {
     fun minimumCost(nums: IntArray, cost: IntArray, k: Int): Long {
         val n = nums.size
-        val prefixNums = LongArray(n)
-        var total: Long = 0
-        for (i in 0..<n) {
-            total += nums[i].toLong()
-            prefixNums[i] = total
+        val k = k.toLong()
+        val preNums = LongArray(n + 1)
+        val preCost = LongArray(n + 1)
+        for (i in 0..n - 1) {
+            preNums[i + 1] = preNums[i] + nums[i]
+            preCost[i + 1] = preCost[i] + cost[i]
         }
-        val prefixCost = LongArray(n + 1)
-        total = 0
-        for (i in 0..<n) {
-            total += cost[i].toLong()
-            prefixCost[i + 1] = total
+        val dp = LongArray(n + 1) {
+            Long.MAX_VALUE / 2
+        }.also { it[0] = 0L }
+        for (r in 1..n) for (l in 0..r - 1) {
+            val sumNums = preNums[r] * (preCost[r] - preCost[l])
+            val sumCost = k * (preCost[n] - preCost[l])
+            dp[r] = minOf(dp[r], dp[l] + sumNums + sumCost)
         }
-        val memo: Array<LongArray> = Array<LongArray>(n) { LongArray(n + 1) }
-        for (row in memo) {
-            row.fill(-1)
-        }
-        val bestSplit = IntArray(n)
-        bestSplit.fill(-1)
-        return rec(0, 1, nums, prefixNums, prefixCost, k, memo, bestSplit)
-    }
-
-    private fun rec(
-        index: Int,
-        i: Int,
-        nums: IntArray,
-        prefixNums: LongArray,
-        prefixCost: LongArray,
-        k: Int,
-        memo: Array<LongArray>,
-        bestSplit: IntArray,
-    ): Long {
-        val n = nums.size
-        if (index == n) {
-            return 0
-        }
-        if (memo[index][i] != -1L) {
-            return memo[index][i]
-        }
-        if (bestSplit[index] != -1) {
-            val j = bestSplit[index]
-            val `val` =
-                (
-                    (prefixNums[j] + k.toLong() * i) * (prefixCost[j + 1] - prefixCost[index]) +
-                        rec(j + 1, i + 1, nums, prefixNums, prefixCost, k, memo, bestSplit)
-                    )
-            memo[index][i] = `val`
-            return `val`
-        }
-        var best = Long.Companion.MAX_VALUE
-        var bestIndex = -1
-        for (j in index..<n) {
-            val `val` =
-                (
-                    (prefixNums[j] + k.toLong() * i) * (prefixCost[j + 1] - prefixCost[index]) +
-                        rec(j + 1, i + 1, nums, prefixNums, prefixCost, k, memo, bestSplit)
-                    )
-            if (`val` < best) {
-                best = `val`
-                bestIndex = j
-            }
-        }
-        bestSplit[index] = bestIndex
-        memo[index][i] = best
-        return best
+        return dp[n]
     }
 }
diff --git a/src/main/kotlin/g3501_3600/s3501_maximize_active_section_with_trade_ii/Solution.kt b/src/main/kotlin/g3501_3600/s3501_maximize_active_section_with_trade_ii/Solution.kt
@@ -1,6 +1,7 @@
 package g3501_3600.s3501_maximize_active_section_with_trade_ii
 
-// #Hard #2025_03_30_Time_219_ms_(100.00%)_Space_142.64_MB_(100.00%)
+// #Hard #Array #String #Binary_Search #Segment_Tree
+// #2025_04_01_Time_259_ms_(100.00%)_Space_140.14_MB_(_%)
 
 import kotlin.math.max
 
diff --git a/src/main/kotlin/g3501_3600/s3502_minimum_cost_to_reach_every_position/Solution.kt b/src/main/kotlin/g3501_3600/s3502_minimum_cost_to_reach_every_position/Solution.kt
@@ -1,6 +1,6 @@
 package g3501_3600.s3502_minimum_cost_to_reach_every_position
 
-// #Easy #2025_03_30_Time_1_ms_(100.00%)_Space_47.23_MB_(86.36%)
+// #Easy #Array #2025_04_01_Time_1_ms_(100.00%)_Space_46.62_MB_(96.30%)
 
 import kotlin.math.min
 
diff --git a/src/main/kotlin/g3501_3600/s3503_longest_palindrome_after_substring_concatenation_i/Solution.kt b/src/main/kotlin/g3501_3600/s3503_longest_palindrome_after_substring_concatenation_i/Solution.kt
@@ -1,39 +1,76 @@
 package g3501_3600.s3503_longest_palindrome_after_substring_concatenation_i
 
-// #Medium #2025_03_30_Time_206_ms_(66.67%)_Space_47.71_MB_(86.67%)
+// #Medium #String #Dynamic_Programming #Two_Pointers #Enumeration
+// #2025_04_01_Time_42_ms_(83.33%)_Space_43.01_MB_(100.00%)
 
 import kotlin.math.max
 
 class Solution {
     fun longestPalindrome(s: String, t: String): Int {
-        var result = 0
-        for (i in 0..s.length) {
-            for (j in i..s.length) {
-                val subStrS = s.substring(i, j)
-                for (k in 0..t.length) {
-                    for (l in k..t.length) {
-                        val subStrT = t.substring(k, l)
-                        val combineStr = subStrS + subStrT
-                        if (isPalindrome(combineStr)) {
-                            result = max(result, combineStr.length)
+        var maxLen = 0
+        maxLen = max(maxLen, longestPalindromicSubstring(s))
+        maxLen = max(maxLen, longestPalindromicSubstring(t))
+        val sLen = s.length
+        val tLen = t.length
+        for (i in 0..<sLen) {
+            for (j in i..<sLen) {
+                val m = j - i + 1
+                for (k in 0..<tLen) {
+                    for (l in k..<tLen) {
+                        val n = l - k + 1
+                        val totalLength = m + n
+                        if (totalLength <= maxLen) {
+                            continue
+                        }
+                        var isPalindrome = true
+                        for (p in 0..<totalLength / 2) {
+                            val q = totalLength - 1 - p
+                            val c1: Char = if (p < m) {
+                                s[i + p]
+                            } else {
+                                t[k + (p - m)]
+                            }
+                            val c2: Char = if (q < m) {
+                                s[i + q]
+                            } else {
+                                t[k + (q - m)]
+                            }
+                            if (c1 != c2) {
+                                isPalindrome = false
+                                break
+                            }
+                        }
+                        if (isPalindrome) {
+                            maxLen = totalLength
                         }
                     }
                 }
             }
         }
-        return result
+        return maxLen
     }
 
-    private fun isPalindrome(input: String): Boolean {
-        var left = 0
-        var right = input.length - 1
-        while (left < right) {
-            if (input.get(left) != input.get(right)) {
-                return false
+    private fun longestPalindromicSubstring(str: String): Int {
+        var max = 0
+        val len = str.length
+        for (i in 0..<len) {
+            for (j in i..<len) {
+                var isPalin = true
+                var left = i
+                var right = j
+                while (left < right) {
+                    if (str[left] != str[right]) {
+                        isPalin = false
+                        break
+                    }
+                    left++
+                    right--
+                }
+                if (isPalin) {
+                    max = max(max, (j - i + 1))
+                }
             }
-            left++
-            right--
         }
-        return true
+        return max
     }
 }
diff --git a/src/main/kotlin/g3501_3600/s3504_longest_palindrome_after_substring_concatenation_ii/Solution.kt b/src/main/kotlin/g3501_3600/s3504_longest_palindrome_after_substring_concatenation_ii/Solution.kt
@@ -1,6 +1,7 @@
 package g3501_3600.s3504_longest_palindrome_after_substring_concatenation_ii
 
-// #Hard #2025_03_30_Time_58_ms_(100.00%)_Space_60.00_MB_(50.00%)
+// #Hard #String #Dynamic_Programming #Two_Pointers
+// #2025_04_01_Time_59_ms_(100.00%)_Space_58.68_MB_(57.14%)
 
 import kotlin.math.max
 
diff --git a/src/main/kotlin/g3501_3600/s3505_minimum_operations_to_make_elements_within_k_subarrays_equal/Solution.kt b/src/main/kotlin/g3501_3600/s3505_minimum_operations_to_make_elements_within_k_subarrays_equal/Solution.kt
@@ -1,6 +1,7 @@
 package g3501_3600.s3505_minimum_operations_to_make_elements_within_k_subarrays_equal
 
-// #Hard #2025_03_30_Time_565_ms_(100.00%)_Space_121.62_MB_(_%)
+// #Hard #Array #Hash_Table #Dynamic_Programming #Math #Heap_Priority_Queue #Sliding_Window
+// #2025_04_01_Time_537_ms_(100.00%)_Space_115.99_MB_(20.00%)
 
 import java.util.Collections
 import java.util.PriorityQueue
