Updated tags

Author: javadev

src/main/java/g3601_3700/s3663_find_the_least_frequent_digit/Solution.java

@@ -1,27 +1,25 @@
 package g3601_3700.s3663_find_the_least_frequent_digit;
 
-// #Easy #Biweekly_Contest_164 #2025_08_31_Time_4_ms_(100.00%)_Space_41.21_MB_(100.00%)
-
-import java.util.HashMap;
-import java.util.Map;
+// #Easy #Biweekly_Contest_164 #2025_09_06_Time_1_ms_(97.91%)_Space_41.14_MB_(60.27%)
 
 public class Solution {
     public int getLeastFrequentDigit(int n) {
-        String s = String.valueOf(n);
-        int k = s.length();
-        Map<Integer, Integer> freq = new HashMap<>();
-        for (int i = 0; i < k; i++) {
-            int digit = s.charAt(i) - '0';
-            freq.put(digit, freq.getOrDefault(digit, 0) + 1);
-        }
-        int minfreq = Integer.MAX_VALUE;
-        for (Map.Entry<Integer, Integer> it : freq.entrySet()) {
-            minfreq = Math.min(minfreq, it.getValue());
+        int[] freq = new int[10];
+        String numStr = String.valueOf(n);
+        for (char c : numStr.toCharArray()) {
+            freq[c - '0']++;
         }
-        int result = 10;
-        for (Map.Entry<Integer, Integer> it : freq.entrySet()) {
-            if (it.getValue() == minfreq) {
-                result = Math.min(result, it.getKey());
+        int minFreq = Integer.MAX_VALUE;
+        int result = -1;
+        for (int d = 0; d <= 9; d++) {
+            if (freq[d] == 0) {
+                continue;
+            }
+            if (freq[d] < minFreq) {
+                minFreq = freq[d];
+                result = d;
+            } else if (freq[d] == minFreq && d < result) {
+                result = d;
             }
         }
         return result;

src/main/java/g3601_3700/s3664_two_letter_card_game/Solution.java

@@ -1,6 +1,6 @@
 package g3601_3700.s3664_two_letter_card_game;
 
-// #Medium #Biweekly_Contest_164 #2025_08_31_Time_8_ms_(99.42%)_Space_60.09_MB_(52.34%)
+// #Medium #Biweekly_Contest_164 #2025_09_06_Time_8_ms_(98.82%)_Space_60.21_MB_(45.56%)
 
 public class Solution {
     public int score(String[] cards, char x) {

src/main/java/g3601_3700/s3665_twisted_mirror_path_count/Solution.java

@@ -1,46 +1,37 @@
 package g3601_3700.s3665_twisted_mirror_path_count;
 
-// #Medium #Biweekly_Contest_164 #2025_08_31_Time_204_ms_(100.00%)_Space_86.33_MB_(100.00%)
-
-import java.util.Arrays;
+// #Medium #Biweekly_Contest_164 #2025_09_06_Time_28_ms_(100.00%)_Space_86.70_MB_(69.78%)
 
 public class Solution {
-    private static final int MOD = 1000000007;
-
     public int uniquePaths(int[][] grid) {
+        // 0 right, 1 down
         int n = grid.length;
         int m = grid[0].length;
-        int[][][] dp = new int[n][m][2];
-        for (int i = 0; i < n; i++) {
-            for (int j = 0; j < m; j++) {
-                Arrays.fill(dp[i][j], -1);
+        int mod = 1_000_000_007;
+        int[] dp = new int[m];
+        dp[0] = 1;
+        for (int j = 1; j < m; j++) {
+            if (grid[0][j - 1] == 0) {
+                dp[j] = dp[j - 1];
             }
         }
-        return f(0, 0, 0, grid, n, m, dp);
-    }
-
-    private int f(int i, int j, int dir, int[][] grid, int n, int m, int[][][] dp) {
-        if (i == n - 1 && j == m - 1) {
-            return 1;
-        }
-        if (i >= n || j >= m) {
-            return 0;
-        }
-        if (dp[i][j][dir] != -1) {
-            return dp[i][j][dir];
-        }
-        long ways = 0;
-        if (grid[i][j] == 1) {
-            if (dir == 0) {
-                ways = f(i + 1, j, 1, grid, n, m, dp);
-            } else {
-                ways = f(i, j + 1, 0, grid, n, m, dp);
+        for (int i = 1; i < n; i++) {
+            int[] next = new int[m];
+            if (grid[i - 1][0] == 0 && grid[i][0] == 0) {
+                next[0] = dp[0];
+            }
+            for (int j = 1; j < m; j++) {
+                if (grid[i][j] == 0) {
+                    next[j] = (next[j] + dp[j]) % mod;
+                }
+                if (grid[i][j - 1] == 0) {
+                    next[j] = (next[j] + next[j - 1]) % mod;
+                } else {
+                    next[j] = (next[j] + dp[j - 1]) % mod;
+                }
             }
-        } else {
-            ways += f(i + 1, j, 1, grid, n, m, dp);
-            ways += f(i, j + 1, 0, grid, n, m, dp);
+            dp = next;
         }
-        dp[i][j][dir] = (int) ways % MOD;
-        return dp[i][j][dir];
+        return dp[m - 1];
     }
 }

src/main/java/g3601_3700/s3666_minimum_operations_to_equalize_binary_string/Solution.java

@@ -1,63 +1,106 @@
 package g3601_3700.s3666_minimum_operations_to_equalize_binary_string;
 
-// #Hard #Biweekly_Contest_164 #2025_08_31_Time_22_ms_(100.00%)_Space_45.62_MB_(100.00%)
-
-import java.util.ArrayDeque;
-import java.util.Queue;
+// #Hard #Biweekly_Contest_164 #2025_09_06_Time_4_ms_(100.00%)_Space_46.11_MB_(31.99%)
 
 public class Solution {
     public int minOperations(String s, int k) {
-        int zeros = s.chars().map(x -> x == '0' ? 1 : 0).sum();
-        if ((zeros % k) == 0) {
-            return zeros / k;
+        int zero = 0;
+        for (char chr : s.toCharArray()) {
+            zero += '1' - chr;
+        }
+        if (zero % 2 != 0 && k % 2 == 0) {
+            return -1;
+        }
+        if (zero % k == 0) {
+            return zero / k;
         }
-        int n = s.length();
-        Queue<Integer> q = new ArrayDeque<>();
-        q.add(zeros);
-        int res = 1;
-        // use bounds for optimization
-        int[][] bounds = new int[2][2];
-        bounds[zeros & 1][0] = bounds[zeros & 1][1] = zeros;
-        bounds[1 - (zeros & 1)][0] = Integer.MAX_VALUE;
-        bounds[1 - (zeros & 1)][1] = Integer.MIN_VALUE;
-        while (!q.isEmpty()) {
-            // find min number of zeros and max number of zeros in this round
-            int minv = Integer.MAX_VALUE;
-            int maxv = Integer.MIN_VALUE;
-            for (int len = q.size(); len > 0; len--) {
-                int h = q.poll();
-                int t = n - h;
-                int x = Math.min(h, k);
-                if (t >= k - x) {
-                    int fst = h - x + (k - x);
-                    minv = Math.min(minv, fst);
-                    maxv = Math.max(maxv, fst);
-                }
-                x = Math.min(t, k);
-                if (h >= k - x) {
-                    int snd = h - (k - x) + x;
-                    minv = Math.min(minv, snd);
-                    maxv = Math.max(maxv, snd);
-                }
-            }
-            // possible children are sequence of equal difference 2
-            int ind = minv & 1;
-            int temp = minv;
-            while (temp <= maxv) {
-                if ((temp % k) == 0) {
-                    return res + temp / k;
-                }
-                if (temp < bounds[ind][0] || temp > bounds[ind][1]) {
-                    q.add(temp);
-                    temp += 2;
-                } else {
-                    temp = bounds[ind][1] + 2;
-                }
-            }
-            bounds[ind][0] = Math.min(bounds[ind][0], minv);
-            bounds[ind][1] = Math.max(bounds[ind][1], maxv);
+        if (k % 2 == 0) {
+            return get(zero, s.length(), k);
+        } else {
+            return get1(zero, s.length(), k);
+        }
+    }
+
+    private int get(int zero, int sum, int k) {
+        int l = zero;
+        int r = zero;
+        int res = 0;
+        while (true) {
+            if (l == 0) {
+                return res;
+            }
+            int lNext;
+            if (l >= k) {
+                lNext = l - k;
+            } else if (r >= k) {
+                lNext = 0;
+            } else {
+                lNext = k - r;
+            }
+            int rNext;
+            int a = sum - r;
+            int b = sum - l;
+            if (a >= k) {
+                rNext = r + k;
+            } else if (b >= k) {
+                rNext = sum;
+            } else {
+                rNext = l + b - (k - b);
+            }
+            if (l == lNext && r == rNext) {
+                break;
+            }
+            if (l > lNext) {
+                l = lNext;
+            }
+            if (r < rNext) {
+                r = rNext;
+            }
             res++;
         }
         return -1;
     }
+
+    private int get1(int zero, int sum, int k) {
+        int[] l = {Integer.MAX_VALUE, zero};
+        int[] r = {Integer.MIN_VALUE, zero};
+        int res = 0;
+        while (true) {
+            int idx1 = res % 2;
+            int idx = 1 - idx1;
+            int lNext;
+            int offset = 1 - l[idx] % 2;
+            if (l[idx] >= k) {
+                lNext = l[idx] - k;
+            } else if (r[idx] >= k) {
+                lNext = offset;
+            } else {
+                lNext = k - r[idx];
+            }
+            int rNext;
+            int a = sum - r[idx];
+            int b = sum - l[idx];
+            if (a >= k) {
+                rNext = r[idx] + k;
+            } else if (b >= k) {
+                rNext = sum - offset;
+            } else {
+                rNext = l[idx] + b - (k - b);
+            }
+            if (l[idx1] == lNext && r[idx1] == rNext) {
+                break;
+            }
+            if (l[idx1] > lNext) {
+                l[idx1] = lNext;
+            }
+            if (r[idx1] < rNext) {
+                r[idx1] = rNext;
+            }
+            res++;
+            if (l[idx1] == 0) {
+                return res;
+            }
+        }
+        return -1;
+    }
 }

src/main/java/g3601_3700/s3668_restore_finishing_order/Solution.java

@@ -1,6 +1,6 @@
 package g3601_3700.s3668_restore_finishing_order;
 
-// #Easy #Weekly_Contest_465 #2025_08_31_Time_1_ms_(100.00%)_Space_45.15_MB_(49.19%)
+// #Easy #Weekly_Contest_465 #2025_09_06_Time_1_ms_(100.00%)_Space_45.18_MB_(44.72%)
 
 public class Solution {
     public int[] recoverOrder(int[] order, int[] friends) {

src/main/java/g3601_3700/s3669_balanced_k_factor_decomposition/Solution.java

@@ -1,6 +1,6 @@
 package g3601_3700.s3669_balanced_k_factor_decomposition;
 
-// #Medium #Weekly_Contest_465 #2025_08_31_Time_13_ms_(73.81%)_Space_45.35_MB_(27.49%)
+// #Medium #Weekly_Contest_465 #2025_09_06_Time_13_ms_(78.36%)_Space_45.64_MB_(10.38%)
 
 import java.util.ArrayList;
 import java.util.Collections;

src/main/java/g3601_3700/s3670_maximum_product_of_two_integers_with_no_common_bits/Solution.java

@@ -1,6 +1,6 @@
 package g3601_3700.s3670_maximum_product_of_two_integers_with_no_common_bits;
 
-// #Medium #Weekly_Contest_465 #2025_08_31_Time_138_ms_(99.69%)_Space_64.47_MB_(29.81%)
+// #Medium #Weekly_Contest_465 #2025_09_06_Time_151_ms_(99.28%)_Space_64.23_MB_(47.58%)
 
 public class Solution {
     public long maxProduct(int[] nums) {

src/main/java/g3601_3700/s3671_sum_of_beautiful_subsequences/Solution.java

@@ -1,6 +1,6 @@
 package g3601_3700.s3671_sum_of_beautiful_subsequences;
 
-// #Hard #Weekly_Contest_465 #2025_08_31_Time_224_ms_(99.03%)_Space_56.07_MB_(89.32%)
+// #Hard #Weekly_Contest_465 #2025_09_06_Time_233_ms_(96.31%)_Space_62.03_MB_(69.80%)
 
 public class Solution {
     private static final int MOD = 1000000007;