Updated tags

Author: javadev

src/main/java/g3701_3800/s3718_smallest_missing_multiple_of_k/Solution.java

@@ -1,18 +1,20 @@
 package g3701_3800.s3718_smallest_missing_multiple_of_k;
 
-// #Easy #Weekly_Contest_472 #2025_10_19_Time_3_ms_(_%)_Space_43.23_MB_(_%)
-
-import java.util.Arrays;
+// #Easy #Weekly_Contest_472 #2025_10_21_Time_0_ms_(100.00%)_Space_43.07_MB_(95.91%)
 
 public class Solution {
     public int missingMultiple(int[] nums, int k) {
-        Arrays.sort(nums);
-        int x = k;
-        for (int i : nums) {
-            if (i == x) {
-                x += k;
+        for (int i = 1; ; i++) {
+            int curr = i * k;
+            int j;
+            for (j = 0; j < nums.length; j++) {
+                if (nums[j] == curr) {
+                    break;
+                }
+            }
+            if (j == nums.length) {
+                return curr;
             }
         }
-        return x;
     }
 }

src/main/java/g3701_3800/s3719_longest_balanced_subarray_i/Solution.java

@@ -1,24 +1,47 @@
 package g3701_3800.s3719_longest_balanced_subarray_i;
 
-// #Medium #Weekly_Contest_472 #2025_10_19_Time_302_ms_(50.00%)_Space_45.14_MB_(50.00%)
-
-import java.util.HashSet;
+// #Medium #Weekly_Contest_472 #2025_10_21_Time_10_ms_(100.00%)_Space_45.40_MB_(48.93%)
 
 public class Solution {
     public int longestBalanced(int[] nums) {
-        int ans = 0;
         int n = nums.length;
+        int maxVal = 0;
+        for (int v : nums) {
+            if (v > maxVal) {
+                maxVal = v;
+            }
+        }
+        int[] evenMark = new int[maxVal + 1];
+        int[] oddMark = new int[maxVal + 1];
+        int stampEven = 0;
+        int stampOdd = 0;
+        int ans = 0;
         for (int i = 0; i < n; i++) {
-            HashSet<Integer> even = new HashSet<>();
-            HashSet<Integer> odd = new HashSet<>();
+            if (n - i <= ans) {
+                break;
+            }
+            stampEven++;
+            stampOdd++;
+            int distinctEven = 0;
+            int distinctOdd = 0;
             for (int j = i; j < n; j++) {
-                if (nums[j] % 2 == 0) {
-                    even.add(nums[j]);
+                int v = nums[j];
+                if ((v & 1) == 0) {
+                    if (evenMark[v] != stampEven) {
+                        evenMark[v] = stampEven;
+                        distinctEven++;
+                    }
                 } else {
-                    odd.add(nums[j]);
+                    if (oddMark[v] != stampOdd) {
+                        oddMark[v] = stampOdd;
+                        distinctOdd++;
+                    }
                 }
-                if (even.size() == odd.size()) {
-                    ans = Math.max(ans, j - i + 1);
+                if (distinctEven == distinctOdd) {
+                    int len = j - i + 1;
+                    if (len > ans) {
+                        ans = len;
+                    }
                 }
             }
         }

src/main/java/g3701_3800/s3720_lexicographically_smallest_permutation_greater_than_target/Solution.java

@@ -1,57 +1,41 @@
 package g3701_3800.s3720_lexicographically_smallest_permutation_greater_than_target;
 
-// #Medium #Weekly_Contest_472 #2025_10_19_Time_38_ms_(_%)_Space_46.56_MB_(_%)
-
-import java.util.HashMap;
-import java.util.Map;
+// #Medium #Weekly_Contest_472 #2025_10_21_Time_2_ms_(96.02%)_Space_43.66_MB_(74.82%)
 
 public class Solution {
     public String lexGreaterPermutation(String s, String target) {
-        int n = s.length();
-        Map<Character, Integer> sCounts = new HashMap<>();
+        int[] freq = new int[26];
         for (char c : s.toCharArray()) {
-            sCounts.put(c, sCounts.getOrDefault(c, 0) + 1);
+            freq[c - 'a']++;
+        }
+        StringBuilder sb = new StringBuilder();
+        if (dfs(0, freq, sb, target, false)) {
+            return sb.toString();
+        }
+        return "";
+    }
+
+    private boolean dfs(int i, int[] freq, StringBuilder sb, String target, boolean check) {
+        if (i == target.length()) {
+            return check;
         }
-        String bestSolution = "";
-        Map<Character, Integer> prefixCounts = new HashMap<>();
-        for (int i = 0; i < n; i++) {
-            // Create a copy of counts available for suffix and pivot
-            Map<Character, Integer> availableCounts = new HashMap<>(sCounts);
-            for (Map.Entry<Character, Integer> entry : prefixCounts.entrySet()) {
-                availableCounts.put(
-                        entry.getKey(),
-                        availableCounts.getOrDefault(entry.getKey(), 0) - entry.getValue());
+        for (int j = 0; j < 26; j++) {
+            if (freq[j] == 0) {
+                continue;
             }
-            // Find the smallest char > target[i] to use as the pivot
-            for (char pivotChar = (char) (target.charAt(i) + 1); pivotChar <= 'z'; pivotChar++) {
-                if (availableCounts.getOrDefault(pivotChar, 0) > 0) {
-                    // We found a valid pivot character
-                    availableCounts.put(pivotChar, availableCounts.get(pivotChar) - 1);
-                    String currentPrefix = target.substring(0, i);
-                    // Build the smallest possible suffix from remaining characters
-                    StringBuilder suffix = new StringBuilder();
-                    for (char k = 'a'; k <= 'z'; k++) {
-                        if (availableCounts.getOrDefault(k, 0) > 0) {
-                            int count = availableCounts.get(k);
-                            suffix.append(String.valueOf(k).repeat(Math.max(0, count)));
-                        }
-                    }
-                    String candidate = currentPrefix + pivotChar + suffix;
-                    if (bestSolution.isEmpty() || candidate.compareTo(bestSolution) < 0) {
-                        bestSolution = candidate;
-                    }
-                    // Since we want the smallest pivotChar, we break after finding one
-                    break;
-                }
+            char can = (char) ('a' + j);
+            if (!check && can < target.charAt(i)) {
+                continue;
             }
-            // Update prefix_counts for the next iteration
-            char targetChar = target.charAt(i);
-            prefixCounts.put(targetChar, prefixCounts.getOrDefault(targetChar, 0) + 1);
-            if (prefixCounts.get(targetChar) > sCounts.getOrDefault(targetChar, 0)) {
-                // We can't match the target's prefix any further, so stop.
-                break;
+            freq[j]--;
+            sb.append(can);
+            boolean next = check || can > target.charAt(i);
+            if (dfs(i + 1, freq, sb, target, next)) {
+                return true;
             }
+            sb.deleteCharAt(sb.length() - 1);
+            freq[j]++;
         }
-        return bestSolution;
+        return false;
     }
 }

src/main/java/g3701_3800/s3721_longest_balanced_subarray_ii/Solution.java

@@ -1,6 +1,6 @@
 package g3701_3800.s3721_longest_balanced_subarray_ii;
 
-// #Hard #Weekly_Contest_472 #2025_10_19_Time_274_ms_(50.00%)_Space_61.82_MB_(100.00%)
+// #Hard #Weekly_Contest_472 #2025_10_21_Time_267_ms_(59.29%)_Space_61.94_MB_(28.32%)
 
 import java.util.HashMap;
 import java.util.Map;