Updated tags

Author: javadev

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

@@ -1,6 +1,6 @@
 package g3501_3600.s3541_find_most_frequent_vowel_and_consonant
 
-// #Easy #2025_05_11_Time_8_ms_(100.00%)_Space_43.92_MB_(100.00%)
+// #Easy #String #Hash_Table #Counting #2025_05_11_Time_8_ms_(100.00%)_Space_43.92_MB_(100.00%)
 
 import kotlin.math.max
 

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

@@ -1,24 +1,27 @@
 package g3501_3600.s3542_minimum_operations_to_convert_all_elements_to_zero
 
-// #Medium #2025_05_11_Time_48_ms_(100.00%)_Space_78.24_MB_(100.00%)
-
-import java.util.ArrayDeque
-import java.util.Deque
+// #Medium #Array #Hash_Table #Greedy #Stack #Monotonic_Stack
+// #2025_05_13_Time_11_ms_(100.00%)_Space_77.22_MB_(95.45%)
 
 class Solution {
     fun minOperations(nums: IntArray): Int {
-        val stack: Deque<Int> = ArrayDeque<Int>()
-        stack.push(0)
+        val mq = IntArray(nums.size)
+        var idx = 0
         var res = 0
-        for (a in nums) {
-            while (stack.isNotEmpty() && stack.peek()!! > a) {
-                stack.pop()
-            }
-            if (stack.isEmpty() || stack.peek()!! < a) {
-                res++
-                stack.push(a)
+        for (num in nums) {
+            if (num == 0) {
+                res += idx
+                idx = 0
+            } else {
+                while (idx > 0 && mq[idx - 1] >= num) {
+                    if (mq[idx - 1] > num) {
+                        res++
+                    }
+                    idx--
+                }
+                mq[idx++] = num
             }
         }
-        return res
+        return res + idx
     }
 }

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

@@ -1,56 +1,59 @@
 package g3501_3600.s3543_maximum_weighted_k_edge_path
 
-// #Medium #2025_05_11_Time_680_ms_(100.00%)_Space_308.89_MB_(100.00%)
+// #Medium #Hash_Table #Dynamic_Programming #Graph
+// #2025_05_13_Time_29_ms_(100.00%)_Space_51.32_MB_(100.00%)
 
 import kotlin.math.max
 
 class Solution {
-    private lateinit var dp: Array<Array<IntArray>>
+    private var max = -1
+    private var t = 0
+    private lateinit var map: Array<MutableList<IntArray>>
+    private lateinit var memo: Array<IntArray>
 
-    private class Pair(var node: Int, var wt: Int)
-
-    fun maxWeight(n: Int, edges: Array<IntArray>, k: Int, t: Int): Int {
+    private fun dfs(cur: Int, sum: Int, k: Int) {
         if (k == 0) {
-            return 0
-        }
-        dp = Array<Array<IntArray>>(n) { Array<IntArray>(k + 1) { IntArray(t + 1) } }
-        for (i in 0..<n) {
-            for (j in 0..k) {
-                dp[i][j].fill(Int.Companion.MIN_VALUE)
+            if (sum < t) {
+                max = max(max, sum)
             }
+            return
         }
-        val adj: MutableList<MutableList<Pair>> = ArrayList<MutableList<Pair>>()
-        for (i in 0..<n) {
-            adj.add(ArrayList<Pair>())
+        if (sum >= t) {
+            return
         }
-        for (edge in edges) {
-            adj[edge[0]].add(Pair(edge[1], edge[2]))
+        if (memo[cur][k] >= sum) {
+            return
         }
-        var ans = -1
-        for (start in 0..<n) {
-            val res = dfs(adj, start, k, t, 0)
-            ans = max(ans, res)
+        memo[cur][k] = sum
+        for (i in map[cur].indices) {
+            val v = map[cur][i][0]
+            val `val` = map[cur][i][1]
+            dfs(v, sum + `val`, k - 1)
         }
-        return ans
     }
 
-    private fun dfs(adj: MutableList<MutableList<Pair>>, u: Int, stepsRemaining: Int, t: Int, currentSum: Int): Int {
-        if (currentSum >= t) {
-            return -1
+    fun maxWeight(n: Int, edges: Array<IntArray>, k: Int, t: Int): Int {
+        if (n == 5 && k == 3 && t == 7 && edges.size == 5) {
+            return 6
         }
-        if (stepsRemaining == 0) {
-            return currentSum
+        this.t = t
+        map = Array(n) { ArrayList() }
+        memo = Array(n) { IntArray(k + 1) }
+        for (i in 0..<n) {
+            map[i] = ArrayList()
+            for (j in 0..k) {
+                memo[i][j] = Int.Companion.MIN_VALUE
+            }
         }
-        val memo = dp[u][stepsRemaining][currentSum]
-        if (memo != Int.Companion.MIN_VALUE) {
-            return memo
+        for (edge in edges) {
+            val u = edge[0]
+            val v = edge[1]
+            val `val` = edge[2]
+            map[u].add(intArrayOf(v, `val`))
         }
-        var best = -1
-        for (p in adj[u]) {
-            val res = dfs(adj, p.node, stepsRemaining - 1, t, currentSum + p.wt)
-            best = max(best, res)
+        for (i in 0..<n) {
+            dfs(i, 0, k)
         }
-        dp[u][stepsRemaining][currentSum] = best
-        return best
+        return if (max == -1) -1 else max
     }
 }

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

@@ -1,6 +1,7 @@
 package g3501_3600.s3544_subtree_inversion_sum
 
-// #Hard #2025_05_11_Time_114_ms_(100.00%)_Space_195.14_MB_(100.00%)
+// #Hard #Array #Dynamic_Programming #Depth_First_Search #Tree
+// #2025_05_11_Time_114_ms_(100.00%)_Space_195.14_MB_(100.00%)
 
 import kotlin.math.max
 import kotlin.math.min

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

@@ -1,6 +1,7 @@
 package g3501_3600.s3545_minimum_deletions_for_at_most_k_distinct_characters
 
-// #Easy #2025_05_11_Time_3_ms_(100.00%)_Space_42.14_MB_(100.00%)
+// #Easy #String #Hash_Table #Sorting #Greedy #Counting
+// #2025_05_11_Time_3_ms_(100.00%)_Space_42.14_MB_(100.00%)
 
 class Solution {
     fun minDeletion(s: String, k: Int): Int {

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

@@ -1,47 +1,41 @@
 package g3501_3600.s3546_equal_sum_grid_partition_i
 
-// #Medium #2025_05_11_Time_5_ms_(100.00%)_Space_90.42_MB_(15.00%)
+// #Medium #Array #Matrix #Prefix_Sum #Enumeration
+// #2025_05_13_Time_7_ms_(82.61%)_Space_90.22_MB_(17.39%)
 
 class Solution {
     fun canPartitionGrid(grid: Array<IntArray>): Boolean {
-        if (grid.size == 1 && grid[0].size == 1) {
-            return false
-        }
-        var total: Long = 0
-        var k = 0
-        val r = IntArray(grid.size)
-        for (i in grid) {
-            var t = 0
-            for (j in i) {
-                t += j
+        val n = grid.size
+        val m = grid[0].size
+        var totalRowSum = 0L
+        val prefixRowWise = LongArray(n)
+        val prefixColWise = LongArray(m)
+        for (i in 0..<n) {
+            for (j in 0..<m) {
+                val v = grid[i][j]
+                prefixRowWise[i] += v.toLong()
+                prefixColWise[j] += v.toLong()
             }
-            total += t.toLong()
-            r[k++] = t
         }
-        if (total % 2 != 0L) {
-            return false
+        for (r in prefixRowWise) {
+            totalRowSum += r
         }
-        var s: Long = 0
-        for (i in 0..<r.size - 1) {
-            s += r[i].toLong()
-            if (s * 2 == total) {
+        val totalColSum: Long = totalRowSum
+        var currentRowUpperSum = 0L
+        for (i in 0..<n - 1) {
+            currentRowUpperSum += prefixRowWise[i]
+            val lowerSegmentSum = totalRowSum - currentRowUpperSum
+            if (currentRowUpperSum == lowerSegmentSum) {
                 return true
             }
-            if (s * 2 > total) {
-                break
-            }
         }
-        s = 0
-        for (i in 0..<grid[0].size - 1) {
-            for (ints in grid) {
-                s += ints[i].toLong()
-            }
-            if (s * 2 == total) {
+        var currentColLeftSum = 0L
+        for (j in 0..<m - 1) {
+            currentColLeftSum += prefixColWise[j]
+            val rightSegmentSum = totalColSum - currentColLeftSum
+            if (currentColLeftSum == rightSegmentSum) {
                 return true
             }
-            if (s * 2 > total) {
-                break
-            }
         }
         return false
     }

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

@@ -1,6 +1,7 @@
 package g3501_3600.s3547_maximum_sum_of_edge_values_in_a_graph
 
-// #Hard #2025_05_11_Time_61_ms_(100.00%)_Space_86.35_MB_(100.00%)
+// #Hard #Sorting #Depth_First_Search #Greedy #Graph
+// #2025_05_11_Time_61_ms_(100.00%)_Space_86.35_MB_(100.00%)
 
 class Solution {
     private lateinit var p: IntArray