Updated tags

Author: javadev

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

@@ -1,6 +1,7 @@
 package g3701_3800.s3722_lexicographically_smallest_string_after_reverse
 
-// #Medium #Biweekly_Contest_168 #2025_10_28_Time_8_ms_(100.00%)_Space_45.74_MB_(100.00%)
+// #Medium #Binary_Search #Two_Pointers #Enumeration #Biweekly_Contest_168
+// #2025_10_28_Time_8_ms_(100.00%)_Space_45.74_MB_(100.00%)
 
 class Solution {
     fun lexSmallest(s: String): String {

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

@@ -1,6 +1,7 @@
 package g3701_3800.s3723_maximize_sum_of_squares_of_digits
 
-// #Medium #Biweekly_Contest_168 #2025_10_28_Time_16_ms_(94.44%)_Space_47.62_MB_(61.11%)
+// #Medium #Math #Greedy #Biweekly_Contest_168
+// #2025_10_28_Time_16_ms_(94.44%)_Space_47.62_MB_(61.11%)
 
 class Solution {
     fun maxSumOfSquares(places: Int, sum: Int): String {

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

@@ -1,6 +1,7 @@
 package g3701_3800.s3724_minimum_operations_to_transform_array
 
-// #Medium #Biweekly_Contest_168 #2025_10_28_Time_10_ms_(83.33%)_Space_66.99_MB_(100.00%)
+// #Medium #Array #Greedy #Biweekly_Contest_168
+// #2025_10_28_Time_10_ms_(83.33%)_Space_66.99_MB_(100.00%)
 
 import kotlin.math.abs
 import kotlin.math.max

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

@@ -1,6 +1,7 @@
 package g3701_3800.s3725_count_ways_to_choose_coprime_integers_from_rows
 
-// #Hard #Biweekly_Contest_168 #2025_10_28_Time_29_ms_(100.00%)_Space_51.80_MB_(100.00%)
+// #Hard #Array #Dynamic_Programming #Math #Matrix #Number_Theory #Combinatorics
+// #Biweekly_Contest_168 #2025_10_28_Time_29_ms_(100.00%)_Space_51.80_MB_(100.00%)
 
 import kotlin.math.max
 

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

@@ -1,6 +1,7 @@
 package g3701_3800.s3726_remove_zeros_in_decimal_representation
 
-// #Easy #Weekly_Contest_473 #2025_10_28_Time_2_ms_(73.91%)_Space_41.33_MB_(78.26%)
+// #Easy #Math #Simulation #Weekly_Contest_473
+// #2025_10_28_Time_2_ms_(73.91%)_Space_41.33_MB_(78.26%)
 
 class Solution {
     fun removeZeros(n: Long): Long {

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

@@ -1,6 +1,7 @@
 package g3701_3800.s3727_maximum_alternating_sum_of_squares
 
-// #Medium #Weekly_Contest_473 #2025_10_28_Time_9_ms_(100.00%)_Space_90.79_MB_(13.04%)
+// #Medium #Array #Sorting #Greedy #Weekly_Contest_473
+// #2025_10_28_Time_9_ms_(100.00%)_Space_90.79_MB_(13.04%)
 
 import kotlin.math.abs
 import kotlin.math.min

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

@@ -1,28 +1,31 @@
 package g3701_3800.s3728_stable_subarrays_with_equal_boundary_and_interior_sum
 
-// #Medium #Weekly_Contest_473 #2025_10_28_Time_146_ms_(60.00%)_Space_89.72_MB_(80.00%)
+// #Medium #Array #Hash_Table #Prefix_Sum #Weekly_Contest_473
+// #2025_10_29_Time_109_ms_(100.00%)_Space_82.32_MB_(88.89%)
 
 class Solution {
     fun countStableSubarrays(capacity: IntArray): Long {
-        val n = capacity.size
-        var res: Long = 0
-        var pre: Long = 0
-        val mpp: MutableMap<Long, MutableMap<Long, Long>> = HashMap()
-        for (i in 0..<n) {
-            if (mpp.containsKey(capacity[i].toLong())) {
-                val t: MutableMap<Long, Long> = mpp[capacity[i].toLong()]!!
-                val cnt = t[pre - capacity[i]]
-                if (cnt != null) {
-                    res += cnt
+        var sum: Long = 0
+        val map: MutableMap<Int, MutableMap<Long, Int>> = HashMap()
+        var index = 0
+        var ans: Long = 0
+        for (c in capacity) {
+            sum += c.toLong()
+            var elementMap = map[c]
+            if (elementMap == null) {
+                elementMap = HashMap()
+                map[c] = elementMap
+                elementMap[sum] = 1
+            } else {
+                var orDefault = elementMap.getOrDefault(sum - 2 * c, 0)
+                elementMap[sum] = elementMap.getOrDefault(sum, 0) + 1
+                if (c == 0 && capacity[index - 1] == 0) {
+                    orDefault--
                 }
+                ans += orDefault.toLong()
             }
-            pre += capacity[i].toLong()
-            val t = mpp.computeIfAbsent(capacity[i].toLong()) { _: Long -> HashMap() }
-            t[pre] = t.getOrDefault(pre, 0L) + 1L
-            if (i > 0 && capacity[i] == 0 && capacity[i - 1] == 0) {
-                res--
-            }
+            index++
         }
-        return res
+        return ans
     }
 }

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

@@ -1,33 +1,28 @@
 package g3701_3800.s3729_count_distinct_subarrays_divisible_by_k_in_sorted_array
 
-// #Hard #Weekly_Contest_473 #2025_10_28_Time_76_ms_(100.00%)_Space_80.47_MB_(100.00%)
+// #Hard #Array #Hash_Table #Prefix_Sum #Weekly_Contest_473
+// #2025_10_29_Time_61_ms_(100.00%)_Space_80.76_MB_(100.00%)
 
 class Solution {
     fun numGoodSubarrays(nums: IntArray, k: Int): Long {
-        val cnt: MutableMap<Int, Long> = HashMap()
-        cnt[0] = 1L
-        var pre = 0
-        val n = nums.size
-        var res: Long = 0
-        for (a in nums) {
-            pre = (pre + a) % k
-            res += cnt.getOrDefault(pre, 0L)
-            cnt[pre] = cnt.getOrDefault(pre, 0L) + 1L
-        }
-        var i = 0
-        while (i < n) {
-            var j = i
-            while (j < n && nums[j] == nums[i]) {
-                ++j
-            }
-            val l = j - i
-            for (ll in 1..<l) {
-                if (ll.toLong() * nums[i] % k == 0L) {
-                    res -= (l - ll).toLong()
+        val cnt: MutableMap<Int, Int> = HashMap(nums.size, 1f)
+        cnt[0] = 1
+        var sum: Long = 0
+        var lastStart = 0
+        var ans: Long = 0
+        for (i in nums.indices) {
+            val x = nums[i]
+            if (i > 0 && x != nums[i - 1]) {
+                var s = sum
+                for (t in i - lastStart downTo 1) {
+                    cnt.merge((s % k).toInt(), 1) { a: Int?, b: Int? -> Integer.sum(a!!, b!!) }
+                    s -= nums[i - 1].toLong()
                 }
+                lastStart = i
             }
-            i = j
+            sum += x.toLong()
+            ans += cnt.getOrDefault((sum % k).toInt(), 0).toLong()
         }
-        return res
+        return ans
     }
 }