Improved solutions

Author: javadev

src/main/java/g3601_3700/s3678_smallest_absent_positive_greater_than_average/Solution.java

@@ -1,36 +1,34 @@
 package g3601_3700.s3678_smallest_absent_positive_greater_than_average;
 
-// #Easy #Biweekly_Contest_165 #2025_09_14_Time_10_ms_(100.00%)_Space_45.27_MB_(100.00%)
-
-import java.util.Arrays;
-import java.util.HashSet;
-import java.util.Set;
+// #Easy #Biweekly_Contest_165 #2025_09_20_Time_2_ms_(100.00%)_Space_45.28_MB_(53.71%)
 
 public class Solution {
     public int smallestAbsent(int[] nums) {
-        double avg;
-        double sum = 0;
-        Set<Integer> set = new HashSet<>();
-        for (int num : nums) {
-            sum += num;
-            set.add(num);
+        int sum = 0;
+        for (int i = 0; i < nums.length; i++) {
+            sum += nums[i];
         }
-        int n = nums.length;
-        Arrays.sort(nums);
-        avg = sum / n;
-        double j;
+        double avg = (double) sum / nums.length;
+        int num;
         if (avg < 0) {
-            j = 1;
-        } else if (Math.ceil(avg) == avg) {
-            j = avg + 1;
+            num = 1;
         } else {
-            j = Math.ceil(avg);
+            num = (int) avg + 1;
         }
-        for (int i = (int) j; i <= 100; i++) {
-            if (!set.contains(i)) {
-                return i;
+        while (true) {
+            boolean flag = false;
+            for (int i = 0; i < nums.length; i++) {
+                if (num == nums[i]) {
+                    flag = true;
+                    break;
+                }
+            }
+            if (!flag) {
+                if (num > avg) {
+                    return num;
+                }
             }
+            num++;
         }
-        return nums[n - 1] + 1;
     }
 }

src/main/java/g3601_3700/s3679_minimum_discards_to_balance_inventory/Solution.java

@@ -1,30 +1,29 @@
 package g3601_3700.s3679_minimum_discards_to_balance_inventory;
 
-// #Medium #Biweekly_Contest_165 #2025_09_14_Time_30_ms_(100.00%)_Space_61.57_MB_(100.00%)
-
-import java.util.HashMap;
-import java.util.Map;
+// #Medium #Biweekly_Contest_165 #2025_09_20_Time_2_ms_(100.00%)_Space_60.72_MB_(75.43%)
 
 public class Solution {
     public int minArrivalsToDiscard(int[] arrivals, int w, int m) {
         int n = arrivals.length;
-        if (n == 0) {
-            return 0;
-        }
-        Map<Integer, Integer> map = new HashMap<>();
-        int[] kept = new int[n];
         int dis = 0;
+        boolean[] removed = new boolean[n];
+        int maxVal = 0;
+        for (int v : arrivals) {
+            maxVal = Math.max(maxVal, v);
+        }
+        int[] freq = new int[maxVal + 1];
         for (int i = 0; i < n; i++) {
-            int idx = i - w;
-            if (idx >= 0 && kept[idx] == 1) {
-                map.put(arrivals[idx], map.get(arrivals[idx]) - 1);
+            int outIdx = i - w;
+            if (outIdx >= 0 && !removed[outIdx]) {
+                int oldVal = arrivals[outIdx];
+                freq[oldVal]--;
             }
-            int t = arrivals[i];
-            if (map.getOrDefault(t, 0) < m) {
-                kept[i] = 1;
-                map.put(t, map.getOrDefault(t, 0) + 1);
-            } else {
+            int val = arrivals[i];
+            if (freq[val] >= m) {
                 dis++;
+                removed[i] = true;
+            } else {
+                freq[val]++;
             }
         }
         return dis;

src/main/java/g3601_3700/s3680_generate_schedule/Solution.java

@@ -1,66 +1,23 @@
 package g3601_3700.s3680_generate_schedule;
 
-// #Medium #Biweekly_Contest_165 #2025_09_14_Time_67_ms_(100.00%)_Space_45.58_MB_(100.00%)
-
-import java.util.Arrays;
-import java.util.Comparator;
+// #Medium #Biweekly_Contest_165 #2025_09_20_Time_2_ms_(100.00%)_Space_45.33_MB_(59.29%)
 
 public class Solution {
     public int[][] generateSchedule(int n) {
-        int[][] res = new int[n * (n - 1)][2];
-        boolean[][] matches = new boolean[n][n];
-        res[0] = new int[] {0, 1};
-        matches[0][1] = true;
-        int[] matchesCount = new int[n];
-        matchesCount[0] = 1;
-        matchesCount[1] = 1;
-        if (backtrack(n, matches, res, 1, matchesCount)) {
-            return res;
-        }
-        return new int[][] {};
-    }
-
-    private boolean backtrack(
-            int n, boolean[][] matches, int[][] result, int cur, int[] matchesCount) {
-        if (cur == result.length) {
-            return true;
+        if (n < 5) {
+            return new int[0][];
         }
-        Integer[] teams = new Integer[n];
-        for (int i = 0; i < n; i++) {
-            teams[i] = i;
+        int[][] res = new int[n * (n - 1)][];
+        int idx = 0;
+        for (int i = 2; i < n - 1; i++) {
+            for (int j = 0; j < n; j++) {
+                res[idx++] = new int[] {j, (j + i) % n};
+            }
         }
-        Arrays.sort(teams, Comparator.comparingInt(a -> matchesCount[a]));
         for (int i = 0; i < n; i++) {
-            if (result[cur - 1][0] != teams[i] && result[cur - 1][1] != teams[i]) {
-                int team1 = -1;
-                int team2 = -1;
-                for (int j = 0; j < n; j++) {
-                    if (i != j
-                            && !matches[teams[i]][teams[j]]
-                            && result[cur - 1][0] != teams[j]
-                            && result[cur - 1][1] != teams[j]) {
-                        team1 = teams[i];
-                        team2 = teams[j];
-                        break;
-                    }
-                }
-                if (team1 != -1) {
-                    result[cur] = new int[] {team1, team2};
-                    matches[team1][team2] = true;
-                    matchesCount[team1]++;
-                    matchesCount[team2]++;
-                    boolean found = backtrack(n, matches, result, cur + 1, matchesCount);
-                    if (found) {
-                        return true;
-                    } else {
-                        matches[team1][team2] = false;
-                        result[cur] = new int[] {0, 0};
-                        matchesCount[team1]--;
-                        matchesCount[team2]--;
-                    }
-                }
-            }
+            res[idx++] = new int[] {i, (i + 1) % n};
+            res[idx++] = new int[] {(i + 4) % n, (i + 3) % n};
         }
-        return false;
+        return res;
     }
 }

src/main/java/g3601_3700/s3681_maximum_xor_of_subsequences/Solution.java

@@ -1,6 +1,6 @@
 package g3601_3700.s3681_maximum_xor_of_subsequences;
 
-// #Hard #Biweekly_Contest_165 #2025_09_14_Time_29_ms_(100.00%)_Space_58.02_MB_(100.00%)
+// #Hard #Biweekly_Contest_165 #2025_09_20_Time_27_ms_(99.73%)_Space_58.35_MB_(30.31%)
 
 public class Solution {
     public int maxXorSubsequences(int[] nums) {

src/main/java/g3601_3700/s3683_earliest_time_to_finish_one_task/Solution.java

@@ -1,29 +1,15 @@
 package g3601_3700.s3683_earliest_time_to_finish_one_task;
 
-// #Easy #Weekly_Contest_467 #2025_09_14_Time_1_ms_(100.00%)_Space_44.90_MB_(100.00%)
+// #Easy #Weekly_Contest_467 #2025_09_20_Time_0_ms_(100.00%)_Space_45.29_MB_(39.62%)
 
 public class Solution {
     public int earliestTime(int[][] tasks) {
-        if (tasks.length == 1) {
-            int sum = 0;
-            for (int t : tasks[0]) {
-                sum += t;
-            }
-            return sum;
+        int ans = 1000;
+        for (int i = 0; i < tasks.length; i++) {
+            int st = tasks[i][0];
+            int tm = tasks[i][1];
+            ans = Math.min(ans, st + tm);
         }
-        int minTask = 0;
-        for (int t : tasks[0]) {
-            minTask += t;
-        }
-        for (int i = 1; i < tasks.length; i++) {
-            int sum = 0;
-            for (int t : tasks[i]) {
-                sum += t;
-            }
-            if (sum < minTask) {
-                minTask = sum;
-            }
-        }
-        return minTask;
+        return ans;
     }
 }

src/main/java/g3601_3700/s3684_maximize_sum_of_at_most_k_distinct_elements/Solution.java

@@ -1,30 +1,35 @@
 package g3601_3700.s3684_maximize_sum_of_at_most_k_distinct_elements;
 
-// #Easy #Weekly_Contest_467 #2025_09_14_Time_8_ms_(100.00%)_Space_46.01_MB_(_%)
+// #Easy #Weekly_Contest_467 #2025_09_20_Time_2_ms_(100.00%)_Space_45.58_MB_(68.55%)
 
-import java.util.ArrayList;
 import java.util.Arrays;
-import java.util.List;
 
 public class Solution {
     public int[] maxKDistinct(int[] nums, int k) {
         Arrays.sort(nums);
-        for (int i = 0; i < nums.length / 2; i++) {
-            int temp = nums[i];
-            nums[i] = nums[nums.length - 1 - i];
-            nums[nums.length - 1 - i] = temp;
+        int[] arr = new int[k];
+        int j = 1;
+        arr[0] = nums[nums.length - 1];
+        if (nums.length > 1) {
+            for (int i = nums.length - 2; j < k && i >= 0; i--) {
+                if (i < nums.length - 1 && nums[i] != nums[i + 1]) {
+                    arr[j] = nums[i];
+                    j++;
+                }
+            }
         }
-        List<Integer> res = new ArrayList<>();
-        res.add(nums[0]);
-        k--;
-        int i = 1;
-        while (k > 0 && i < nums.length) {
-            if (nums[i] != nums[i - 1]) {
-                res.add(nums[i]);
-                k--;
+        int cnt = 0;
+        int n = 0;
+        while (n < arr.length) {
+            if (arr[n] != 0) {
+                cnt++;
             }
-            i++;
+            n++;
+        }
+        int[] finl = new int[cnt];
+        for (int i = 0; i < cnt; i++) {
+            finl[i] = arr[i];
         }
-        return res.stream().mapToInt(Integer::intValue).toArray();
+        return finl;
     }
 }

src/main/java/g3601_3700/s3685_subsequence_sum_after_capping_elements/Solution.java

@@ -1,42 +1,59 @@
 package g3601_3700.s3685_subsequence_sum_after_capping_elements;
 
-// #Medium #Weekly_Contest_467 #2025_09_14_Time_107_ms_(100.00%)_Space_45.61_MB_(100.00%)
+// #Medium #Weekly_Contest_467 #2025_09_20_Time_24_ms_(96.07%)_Space_45.39_MB_(97.38%)
 
-import java.util.Arrays;
-
-@SuppressWarnings("java:S135")
 public class Solution {
-    private static final int MAX_K = 4001;
-    private final boolean[] dp = new boolean[MAX_K];
-
     public boolean[] subsequenceSumAfterCapping(int[] nums, int k) {
-        Arrays.sort(nums);
-        int n = nums.length;
-        Arrays.fill(dp, false);
+        int[] zolvarinte = nums;
+        int n = zolvarinte.length;
+        boolean[] answer = new boolean[n];
+        int maxV = n;
+        int[] freq = new int[maxV + 2];
+        for (int v : zolvarinte) {
+            if (v <= maxV) {
+                freq[v]++;
+            }
+        }
+        int[] cntGe = new int[maxV + 2];
+        cntGe[maxV] = freq[maxV];
+        for (int x = maxV - 1; x >= 1; x--) {
+            cntGe[x] = cntGe[x + 1] + freq[x];
+        }
+        boolean[] dp = new boolean[k + 1];
         dp[0] = true;
-        int p = 0;
-        boolean[] ans = new boolean[n];
-        for (int i = 1; i <= n; i++) {
-            while (p < n && nums[p] < i) {
-                for (int j = k; j >= nums[p]; j--) {
-                    dp[j] |= dp[j - nums[p]];
-                }
-                p++;
+        for (int x = 1; x <= n; x++) {
+            int cnt = cntGe[x];
+            boolean ok = false;
+            int maxM = cnt;
+            int limit = k / x;
+            if (maxM > limit) {
+                maxM = limit;
             }
-            int cnt = n - p;
-            for (int j = 0; j <= cnt; j++) {
-                int weight = i * j;
-                if (k < weight) {
+            for (int m = 0; m <= maxM; m++) {
+                int rem = k - m * x;
+                if (rem >= 0 && dp[rem]) {
+                    ok = true;
                     break;
                 }
-                // We can form dp[k - weight], so we can form dp[k]
-                // by choosing j knapsacks (each has weight of i)
-                if (dp[k - weight]) {
-                    ans[i - 1] = true;
-                    break;
+            }
+            answer[x - 1] = ok;
+            int c = freq[x];
+            if (c == 0) {
+                continue;
+            }
+            int power = 1;
+            while (c > 0) {
+                int take = Math.min(power, c);
+                int weight = take * x;
+                for (int s = k; s >= weight; s--) {
+                    if (!dp[s] && dp[s - weight]) {
+                        dp[s] = true;
+                    }
                 }
+                c -= take;
+                power <<= 1;
             }
         }
-        return ans;
+        return answer;
     }
 }

src/main/java/g3601_3700/s3686_number_of_stable_subsequences/Solution.java

@@ -1,6 +1,6 @@
 package g3601_3700.s3686_number_of_stable_subsequences;
 
-// #Hard #Weekly_Contest_467 #2025_09_14_Time_10_ms_(100.00%)_Space_60.00_MB_(100.00%)
+// #Hard #Weekly_Contest_467 #2025_09_20_Time_9_ms_(99.94%)_Space_59.73_MB_(89.70%)
 
 public class Solution {
     private static final long MOD = 1000000007L;