Updated tags

Author: javadev

src/main/java/g3701_3800/s3722_lexicographically_smallest_string_after_reverse/Solution.java

@@ -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_44.85_MB_(99.91%)
+// #Medium #Binary_Search #Two_Pointers #Enumeration #Biweekly_Contest_168
+// #2025_10_29_Time_7_ms_(100.00%)_Space_45.70_MB_(100.00%)
 
 public class Solution {
     public String lexSmallest(String s) {

src/main/java/g3701_3800/s3723_maximize_sum_of_squares_of_digits/Solution.java

@@ -1,6 +1,7 @@
 package g3701_3800.s3723_maximize_sum_of_squares_of_digits;
 
-// #Medium #Biweekly_Contest_168 #2025_10_28_Time_14_ms_(99.30%)_Space_46.14_MB_(70.05%)
+// #Medium #Math #Greedy #Biweekly_Contest_168
+// #2025_10_29_Time_14_ms_(98.69%)_Space_46.36_MB_(47.20%)
 
 public class Solution {
     public String maxSumOfSquares(int places, int sum) {

src/main/java/g3701_3800/s3724_minimum_operations_to_transform_array/Solution.java

@@ -1,6 +1,7 @@
 package g3701_3800.s3724_minimum_operations_to_transform_array;
 
-// #Medium #Biweekly_Contest_168 #2025_10_28_Time_2_ms_(100.00%)_Space_62.61_MB_(5.39%)
+// #Medium #Array #Greedy #Biweekly_Contest_168
+// #2025_10_29_Time_2_ms_(100.00%)_Space_61.71_MB_(16.98%)
 
 public class Solution {
     public long minOperations(int[] nums1, int[] nums2) {

src/main/java/g3701_3800/s3725_count_ways_to_choose_coprime_integers_from_rows/Solution.java

@@ -1,6 +1,7 @@
 package g3701_3800.s3725_count_ways_to_choose_coprime_integers_from_rows;
 
-// #Hard #Biweekly_Contest_168 #2025_10_28_Time_30_ms_(93.77%)_Space_47.15_MB_(68.37%)
+// #Hard #Array #Dynamic_Programming #Math #Matrix #Number_Theory #Combinatorics
+// #Biweekly_Contest_168 #2025_10_29_Time_31_ms_(94.07%)_Space_47.74_MB_(49.21%)
 
 import java.util.HashMap;
 import java.util.Map;

src/main/java/g3701_3800/s3726_remove_zeros_in_decimal_representation/Solution.java

@@ -1,6 +1,7 @@
 package g3701_3800.s3726_remove_zeros_in_decimal_representation;
 
-// #Easy #Weekly_Contest_473 #2025_10_28_Time_1_ms_(98.76%)_Space_40.81_MB_(93.77%)
+// #Easy #Math #Simulation #Weekly_Contest_473
+// #2025_10_29_Time_1_ms_(98.59%)_Space_40.46_MB_(99.88%)
 
 public class Solution {
     public long removeZeros(long n) {

src/main/java/g3701_3800/s3727_maximum_alternating_sum_of_squares/Solution.java

@@ -1,6 +1,7 @@
 package g3701_3800.s3727_maximum_alternating_sum_of_squares;
 
-// #Medium #Weekly_Contest_473 #2025_10_28_Time_10_ms_(99.97%)_Space_63.08_MB_(17.57%)
+// #Medium #Array #Sorting #Greedy #Weekly_Contest_473
+// #2025_10_29_Time_9_ms_(100.00%)_Space_62.45_MB_(32.41%)
 
 public class Solution {
     public long maxAlternatingSum(int[] nums) {

src/main/java/g3701_3800/s3728_stable_subarrays_with_equal_boundary_and_interior_sum/Solution.java

@@ -1,31 +1,34 @@
 package g3701_3800.s3728_stable_subarrays_with_equal_boundary_and_interior_sum;
 
-// #Medium #Weekly_Contest_473 #2025_10_28_Time_96_ms_(68.14%)_Space_62.66_MB_(83.54%)
+// #Medium #Array #Hash_Table #Prefix_Sum #Weekly_Contest_473
+// #2025_10_29_Time_71_ms_(98.21%)_Space_61.51_MB_(88.86%)
 
 import java.util.HashMap;
 import java.util.Map;
 
 public class Solution {
     public long countStableSubarrays(int[] capacity) {
-        long n = capacity.length;
-        long res = 0;
-        long pre = 0;
-        Map<Long, Map<Long, Long>> mpp = new HashMap<>();
-        for (int i = 0; i < n; i++) {
-            if (mpp.containsKey((long) capacity[i])) {
-                Map<Long, Long> t = mpp.get((long) capacity[i]);
-                Long cnt = t.get(pre - capacity[i]);
-                if (cnt != null) {
-                    res += cnt;
+        long sum = 0;
+        Map<Integer, Map<Long, Integer>> map = new HashMap<>();
+        int index = 0;
+        long ans = 0;
+        for (int c : capacity) {
+            sum += c;
+            Map<Long, Integer> elementMap = map.get(c);
+            if (elementMap == null) {
+                elementMap = new HashMap<>();
+                map.put(c, elementMap);
+                elementMap.put(sum, 1);
+            } else {
+                Integer orDefault = elementMap.getOrDefault(sum - 2 * c, 0);
+                elementMap.put(sum, elementMap.getOrDefault(sum, 0) + 1);
+                if (c == 0 && capacity[index - 1] == 0) {
+                    orDefault--;
                 }
+                ans += orDefault;
             }
-            pre += capacity[i];
-            Map<Long, Long> t = mpp.computeIfAbsent((long) capacity[i], k -> new HashMap<>());
-            t.put(pre, t.getOrDefault(pre, 0L) + 1L);
-            if (i > 0 && capacity[i] == 0 && capacity[i - 1] == 0) {
-                res--;
-            }
+            index++;
         }
-        return res;
+        return ans;
     }
 }

src/main/java/g3701_3800/s3729_count_distinct_subarrays_divisible_by_k_in_sorted_array/Solution.java

@@ -1,36 +1,31 @@
 package g3701_3800.s3729_count_distinct_subarrays_divisible_by_k_in_sorted_array;
 
-// #Hard #Weekly_Contest_473 #2025_10_28_Time_61_ms_(88.70%)_Space_60.47_MB_(80.43%)
+// #Hard #Array #Hash_Table #Prefix_Sum #Weekly_Contest_473
+// #2025_10_29_Time_33_ms_(99.78%)_Space_62.35_MB_(50.99%)
 
 import java.util.HashMap;
 import java.util.Map;
 
 public class Solution {
     public long numGoodSubarrays(int[] nums, int k) {
-        Map<Integer, Long> cnt = new HashMap<>();
-        cnt.put(0, 1L);
-        int pre = 0;
-        int n = nums.length;
-        long res = 0;
-        for (int a : nums) {
-            pre = (pre + a) % k;
-            res += cnt.getOrDefault(pre, 0L);
-            cnt.put(pre, cnt.getOrDefault(pre, 0L) + 1L);
-        }
-        int i = 0;
-        while (i < n) {
-            int j = i;
-            while (j < n && nums[j] == nums[i]) {
-                ++j;
-            }
-            int l = j - i;
-            for (int ll = 1; ll < l; ++ll) {
-                if ((long) ll * nums[i] % k == 0) {
-                    res -= (l - ll);
+        Map<Integer, Integer> cnt = new HashMap<>(nums.length, 1);
+        cnt.put(0, 1);
+        long sum = 0;
+        int lastStart = 0;
+        long ans = 0;
+        for (int i = 0; i < nums.length; i++) {
+            int x = nums[i];
+            if (i > 0 && x != nums[i - 1]) {
+                long s = sum;
+                for (int t = i - lastStart; t > 0; t--) {
+                    cnt.merge((int) (s % k), 1, Integer::sum);
+                    s -= nums[i - 1];
                 }
+                lastStart = i;
             }
-            i = j;
+            sum += x;
+            ans += cnt.getOrDefault((int) (sum % k), 0);
         }
-        return res;
+        return ans;
     }
 }