Updated tags

Author: javadev

src/main/kotlin/g3501_3600/s3572_maximize_ysum_by_picking_a_triplet_of_distinct_xvalues/Solution.kt

@@ -1,28 +1,45 @@
 package g3501_3600.s3572_maximize_ysum_by_picking_a_triplet_of_distinct_xvalues
 
-// #Medium #2025_06_08_Time_72_ms_(100.00%)_Space_77.69_MB_(100.00%)
-
-import java.util.Collections
-import java.util.PriorityQueue
-import kotlin.math.max
+// #Medium #Array #Hash_Table #Sorting #Greedy #Heap_Priority_Queue
+// #2025_06_10_Time_5_ms_(100.00%)_Space_82.11_MB_(56.00%)
 
 class Solution {
     fun maxSumDistinctTriplet(x: IntArray, y: IntArray): Int {
-        val map: MutableMap<Int, Int> = HashMap<Int, Int>()
-        for (i in x.indices) {
-            map.put(x[i], max(map.getOrDefault(x[i], 0), y[i]))
+        var index = -1
+        var max = -1
+        var sum = 0
+        for (i in y.indices) {
+            if (y[i] > max) {
+                max = y[i]
+                index = i
+            }
+        }
+        sum += max
+        if (max == -1) {
+            return -1
         }
-        val maxHeap = PriorityQueue<Int>(Collections.reverseOrder<Int>())
-        for (`val` in map.values) {
-            maxHeap.add(`val`)
+        var index2 = -1
+        max = -1
+        for (i in y.indices) {
+            if (y[i] > max && x[i] != x[index]) {
+                max = y[i]
+                index2 = i
+            }
         }
-        if (maxHeap.size < 3) {
+        sum += max
+        if (max == -1) {
             return -1
         }
-        var sum = 0
-        for (i in 0..2) {
-            sum += maxHeap.poll()!!
+        max = -1
+        for (i in y.indices) {
+            if (y[i] > max && x[i] != x[index] && x[i] != x[index2]) {
+                max = y[i]
+            }
+        }
+        if (max == -1) {
+            return -1
         }
+        sum += max
         return sum
     }
 }

src/main/kotlin/g3501_3600/s3573_best_time_to_buy_and_sell_stock_v/Solution.kt

@@ -1,50 +1,30 @@
 package g3501_3600.s3573_best_time_to_buy_and_sell_stock_v
 
-// #Medium #2025_06_08_Time_157_ms_(100.00%)_Space_99.08_MB_(100.00%)
+// #Medium #Array #Dynamic_Programming #2025_06_10_Time_27_ms_(100.00%)_Space_48.69_MB_(80.00%)
 
 import kotlin.math.max
 
 class Solution {
-    private lateinit var dp: Array<Array<LongArray>>
-    private lateinit var prices: IntArray
-
-    private fun f(i: Int, k: Int, state: Int): Long {
-        if (i == prices.size) {
-            return if (state == 0) 0 else MN
-        }
-        if (dp[i][k][state] != MN) {
-            return dp[i][k][state]
-        }
-        val p = prices[i].toLong()
-        var profit: Long = MN
-        profit = max(profit, f(i + 1, k, state))
-        if (state == 0) {
-            profit = max(profit, f(i + 1, k, 1) - p)
-            profit = max(profit, f(i + 1, k, 2) + p)
-        } else if (k > 0) {
-            profit = if (state == 1) {
-                max(profit, f(i + 1, k - 1, 0) + p)
-            } else {
-                max(profit, f(i + 1, k - 1, 0) - p)
-            }
-        }
-        dp[i][k][state] = profit
-        return profit
-    }
-
     fun maximumProfit(prices: IntArray, k: Int): Long {
-        this.prices = prices
         val n = prices.size
-        dp = Array<Array<LongArray>>(n + 1) { Array<LongArray>(k + 1) { LongArray(3) } }
-        for (twoD in dp) {
-            for (oneD in twoD) {
-                oneD.fill(MN)
+        var prev = LongArray(n)
+        var curr = LongArray(n)
+        for (t in 1..k) {
+            var bestLong = -prices[0].toLong()
+            var bestShort = prices[0].toLong()
+            curr[0] = 0
+            for (i in 1..<n) {
+                var res = curr[i - 1]
+                res = max(res, prices[i] + bestLong)
+                res = max(res, -prices[i] + bestShort)
+                curr[i] = res
+                bestLong = max(bestLong, prev[i - 1] - prices[i])
+                bestShort = max(bestShort, prev[i - 1] + prices[i])
             }
+            val tmp = prev
+            prev = curr
+            curr = tmp
         }
-        return f(0, k, 0)
-    }
-
-    companion object {
-        private val MN = -1e14.toLong()
+        return prev[n - 1]
     }
 }

src/main/kotlin/g3501_3600/s3574_maximize_subarray_gcd_score/Solution.kt

@@ -1,47 +1,67 @@
 package g3501_3600.s3574_maximize_subarray_gcd_score
 
-// #Hard #2025_06_08_Time_269_ms_(100.00%)_Space_63.86_MB_(100.00%)
+// #Hard #Array #Math #Enumeration #Number_Theory
+// #2025_06_10_Time_27_ms_(100.00%)_Space_48.98_MB_(100.00%)
 
 import kotlin.math.max
 
 class Solution {
     fun maxGCDScore(nums: IntArray, k: Int): Long {
+        var mx = 0
+        for (x in nums) {
+            mx = max(mx, x)
+        }
+        val width = 32 - Integer.numberOfLeadingZeros(mx)
+        val lowbitPos: Array<MutableList<Int>> = Array<MutableList<Int>>(width) { i: Int -> ArrayList<Int>() }
+        val intervals = Array<IntArray?>(width + 1) { IntArray(3) }
+        var size = 0
         var ans: Long = 0
-        val n = nums.size
-        for (i in 0..<n) {
-            var countGCD: Long = 0
-            var oddCount: Long = 0
-            var ongoingGCD: Long = 0
-            for (j in i..<n) {
-                val currentGCD = gcd(ongoingGCD, nums[j].toLong())
-                if (currentGCD != ongoingGCD) {
-                    ongoingGCD = currentGCD
-                    countGCD = 1
-                } else if (nums[j].toLong() == ongoingGCD) {
-                    countGCD++
-                }
-                if (nums[j] % 2 != 0) {
-                    oddCount++
+        for (i in nums.indices) {
+            val x = nums[i]
+            val tz = Integer.numberOfTrailingZeros(x)
+            lowbitPos[tz].add(i)
+            for (j in 0..<size) {
+                intervals[j]!![0] = gcd(intervals[j]!![0], x)
+            }
+            intervals[size]!![0] = x
+            intervals[size]!![1] = i - 1
+            intervals[size]!![2] = i
+            size++
+            var idx = 1
+            for (j in 1..<size) {
+                if (intervals[j]!![0] != intervals[j - 1]!![0]) {
+                    intervals[idx]!![0] = intervals[j]!![0]
+                    intervals[idx]!![1] = intervals[j]!![1]
+                    intervals[idx]!![2] = intervals[j]!![2]
+                    idx++
+                } else {
+                    intervals[idx - 1]!![2] = intervals[j]!![2]
                 }
-                val len = j - i + 1
-                var res = ongoingGCD * len
-                if (ongoingGCD % 2 != 0L) {
-                    if (k >= oddCount) {
-                        res *= 2L
-                    }
-                } else if (k >= countGCD) {
-                    res *= 2L
+            }
+            size = idx
+            for (j in 0..<size) {
+                val g = intervals[j]!![0]
+                val l = intervals[j]!![1]
+                val r = intervals[j]!![2]
+                ans = max(ans, g.toLong() * (i - l))
+                val pos = lowbitPos[Integer.numberOfTrailingZeros(g)]
+                val minL = if (pos.size > k) max(l, pos.get(pos.size - k - 1)!!) else l
+                if (minL < r) {
+                    ans = max(ans, g.toLong() * 2 * (i - minL))
                 }
-                ans = max(ans, res)
             }
         }
         return ans
     }
 
-    private fun gcd(a: Long, b: Long): Long {
-        if (a == 0L) {
-            return b
+    private fun gcd(a: Int, b: Int): Int {
+        var a = a
+        var b = b
+        while (a != 0) {
+            val tmp = a
+            a = b % a
+            b = tmp
         }
-        return gcd(b % a, a)
+        return b
     }
 }

src/main/kotlin/g3501_3600/s3575_maximum_good_subtree_score/Solution.kt

@@ -1,86 +1,85 @@
 package g3501_3600.s3575_maximum_good_subtree_score
 
-// #Hard #2025_06_08_Time_414_ms_(100.00%)_Space_66.06_MB_(100.00%)
+// #Hard #Array #Dynamic_Programming #Depth_First_Search #Tree #Bit_Manipulation #Bitmask
+// #2025_06_10_Time_86_ms_(100.00%)_Space_67.73_MB_(33.33%)
 
-import kotlin.math.abs
 import kotlin.math.max
 
 class Solution {
-    private var ans: Long = 0
+    private val digits = 10
+    private val full = 1 shl digits
+    private val neg = Long.Companion.MIN_VALUE / 4
+    private val mod = 1e9.toLong() + 7
+    private lateinit var tree: Array<ArrayList<Int>>
+    private lateinit var `val`: IntArray
+    private lateinit var mask: IntArray
+    private lateinit var isOk: BooleanArray
+    private var res: Long = 0
+
     fun goodSubtreeSum(vals: IntArray, par: IntArray): Int {
         val n = vals.size
-        val adj: Array<MutableList<Int>> = Array<MutableList<Int>>(n) { mutableListOf() }
+        `val` = vals
+        mask = IntArray(n)
+        isOk = BooleanArray(n)
+        for (i in 0..<n) {
+            var m = 0
+            var v = vals[i]
+            var valid = true
+            while (v > 0) {
+                val d = v % 10
+                if (((m shr d) and 1) == 1) {
+                    valid = false
+                    break
+                }
+                m = m or (1 shl d)
+                v /= 10
+            }
+            mask[i] = m
+            isOk[i] = valid
+        }
+        tree = Array(n) { initialCapacity: Int -> ArrayList(initialCapacity) }
+        Arrays.setAll<MutableList<out Any?>?>(tree, IntFunction { initialCapacity: Int -> ArrayList(initialCapacity) })
+        val root = 0
         for (i in 1..<n) {
-            adj[par[i]].add(i)
+            tree[par[i]].add(i)
         }
-        this.ans = 0
-        dfs(0, vals, adj)
-        return ((this.ans % MOD + MOD) % MOD).toInt()
+        dfs(root)
+        return (res % mod).toInt()
     }
 
-    private fun dfs(u: Int, vals: IntArray, adj: Array<MutableList<Int>>): MutableMap<Int, Int> {
-        // du: The DP map for the subtree at node u.
-        // Key: bitmask of digits. Value: max sum for that combination of digits.
-        val du: MutableMap<Int, Int> = HashMap<Int, Int>()
-        // Base case: A sum of 0 is possible with an empty set of digits (mask 0).
-        du.put(0, 0)
-        // Process the current node's value.
-        val s = abs(vals[u]).toString()
-        if (hasUniqueDigits(s)) {
-            var mask = 0
-            for (c in s.toCharArray()) {
-                mask = mask or (1 shl (c.code - '0'.code))
-            }
-            du.put(mask, vals[u])
+    private fun dfs(u: Int): LongArray {
+        var dp = LongArray(full)
+        Arrays.fill(dp, neg)
+        dp[0] = 0
+        if (isOk[u]) {
+            dp[mask[u]] = `val`[u].toLong()
         }
-        for (v in adj[u]) {
-            val dv = dfs(v, vals, adj)
-            val duSnapshot: MutableMap<Int, Int> = HashMap<Int, Int>(du)
-            for (entryV in dv.entries) {
-                val mv: Int = entryV.key
-                val sv: Int = entryV.value
-                for (entryU in duSnapshot.entries) {
-                    val mu: Int = entryU.key
-                    val su: Int = entryU.value
-                    // If the digit sets are disjoint (no common bits in masks), we can combine
-                    // them.
-                    if ((mu and mv) == 0) {
-                        val newMask = mu or mv
-                        val newSum = su + sv
-                        // Update `du` with the best possible sum for the new combined mask.
-                        du.put(
-                            newMask,
-                            max(du.getOrDefault(newMask, Int.Companion.MIN_VALUE), newSum),
-                        )
+        for (v in tree[u]) {
+            val child = dfs(v)
+            val newDp = dp.copyOf(full)
+            for (m1 in 0..<full) {
+                if (dp[m1] < 0) {
+                    continue
+                }
+                val remain = full - 1 - m1
+                var m2 = remain
+                while (m2 > 0) {
+                    if (child[m2] < 0) {
+                        m2 = (m2 - 1) and remain
+                        continue
                     }
+                    val newM = m1 or m2
+                    newDp[newM] = max(newDp[newM], dp[m1] + child[m2])
+                    m2 = (m2 - 1) and remain
                 }
             }
+            dp = newDp
         }
-        // After processing all children, the max value in `du` is the "good" sum for the subtree at
-        // u.
-        // Initialize with a very small number to correctly find the maximum, even if sums are
-        // negative.
-        var maxSubtreeSum = Int.Companion.MIN_VALUE
-        for (sum in du.values) {
-            maxSubtreeSum = max(maxSubtreeSum, sum)
+        var best: Long = 0
+        for (v in dp) {
+            best = max(best, v)
         }
-        // Add this subtree's best sum to the total answer.
-        // If du is empty (should not happen due to {0:0}), we add 0.
-        this.ans += (if (maxSubtreeSum == Int.Companion.MIN_VALUE) 0 else maxSubtreeSum).toLong()
-        return du
-    }
-
-    private fun hasUniqueDigits(s: String): Boolean {
-        val digits: MutableSet<Char> = HashSet<Char>()
-        for (c in s.toCharArray()) {
-            if (!digits.add(c)) {
-                return false
-            }
-        }
-        return true
-    }
-
-    companion object {
-        private const val MOD = 1000000007
+        res = (res + best) % mod
+        return dp
     }
 }

src/main/kotlin/g3501_3600/s3576_transform_array_to_all_equal_elements/Solution.kt

@@ -1,6 +1,6 @@
 package g3501_3600.s3576_transform_array_to_all_equal_elements
 
-// #Medium #2025_06_08_Time_10_ms_(91.67%)_Space_82.55_MB_(58.33%)
+// #Medium #Array #Greedy #2025_06_10_Time_11_ms_(92.31%)_Space_84.38_MB_(15.38%)
 
 class Solution {
     fun canMakeEqual(nums: IntArray, k: Int): Boolean {

src/main/kotlin/g3501_3600/s3577_count_the_number_of_computer_unlocking_permutations/Solution.kt

@@ -1,6 +1,7 @@
 package g3501_3600.s3577_count_the_number_of_computer_unlocking_permutations
 
-// #Medium #2025_06_08_Time_2_ms_(100.00%)_Space_70.32_MB_(14.29%)
+// #Medium #Array #Math #Combinatorics #Brainteaser
+// #2025_06_10_Time_2_ms_(100.00%)_Space_70.49_MB_(30.00%)
 
 class Solution {
     fun countPermutations(complexity: IntArray): Int {