Updated tags

Author: javadev

src/main/java/g3501_3600/s3572_maximize_ysum_by_picking_a_triplet_of_distinct_xvalues/Solution.java

@@ -1,29 +1,47 @@
 package g3501_3600.s3572_maximize_ysum_by_picking_a_triplet_of_distinct_xvalues;
 
-// #Medium #2025_06_08_Time_51_ms_(100.00%)_Space_57.50_MB_(100.00%)
-
-import java.util.Collections;
-import java.util.HashMap;
-import java.util.Map;
-import java.util.PriorityQueue;
+// #Medium #Array #Hash_Table #Sorting #Greedy #Heap_Priority_Queue
+// #2025_06_10_Time_2_ms_(100.00%)_Space_64.25_MB_(40.62%)
 
 public class Solution {
     public int maxSumDistinctTriplet(int[] x, int[] y) {
-        Map<Integer, Integer> map = new HashMap<>();
-        for (int i = 0; i < x.length; i++) {
-            map.put(x[i], Math.max(map.getOrDefault(x[i], 0), y[i]));
+        int index = -1;
+        int max = -1;
+        int sum = 0;
+        for (int i = 0; i < y.length; i++) {
+            if (y[i] > max) {
+                max = y[i];
+                index = i;
+            }
+        }
+        sum += max;
+        if (max == -1) {
+            return -1;
         }
-        PriorityQueue<Integer> maxHeap = new PriorityQueue<>(Collections.reverseOrder());
-        for (int val : map.values()) {
-            maxHeap.add(val);
+        int index2 = -1;
+        int index3 = -1;
+        max = -1;
+        for (int i = 0; i < y.length; i++) {
+            if (y[i] > max && x[i] != x[index]) {
+                max = y[i];
+                index2 = i;
+            }
         }
-        if (maxHeap.size() < 3) {
+        sum += max;
+        if (max == -1) {
             return -1;
         }
-        int sum = 0;
-        for (int i = 0; i < 3; i++) {
-            sum += maxHeap.poll();
+        max = -1;
+        for (int i = 0; i < y.length; i++) {
+            if (y[i] > max && x[i] != x[index] && x[i] != x[index2]) {
+                max = y[i];
+                index3 = i;
+            }
+        }
+        if (max == -1) {
+            return -1;
         }
+        sum += max;
         return sum;
     }
 }

src/main/java/g3501_3600/s3573_best_time_to_buy_and_sell_stock_v/Solution.java

@@ -1,47 +1,28 @@
 package g3501_3600.s3573_best_time_to_buy_and_sell_stock_v;
 
-// #Medium #2025_06_08_Time_259_ms_(100.00%)_Space_87.72_MB_(100.00%)
-
-import java.util.Arrays;
+// #Medium #Array #Dynamic_Programming #2025_06_10_Time_10_ms_(99.46%)_Space_44.46_MB_(97.36%)
 
 public class Solution {
-    private static final long MN = (long) -1e14;
-    private long[][][] dp;
-    private int[] prices;
-
-    private long f(int i, int k, int state) {
-        if (i == prices.length) {
-            return (state == 0) ? 0 : MN;
-        }
-        if (dp[i][k][state] != MN) {
-            return dp[i][k][state];
-        }
-        long p = prices[i];
-        long profit = MN;
-        profit = Math.max(profit, f(i + 1, k, state));
-        if (state == 0) {
-            profit = Math.max(profit, f(i + 1, k, 1) - p);
-            profit = Math.max(profit, f(i + 1, k, 2) + p);
-        } else if (k > 0) {
-            if (state == 1) {
-                profit = Math.max(profit, f(i + 1, k - 1, 0) + p);
-            } else {
-                profit = Math.max(profit, f(i + 1, k - 1, 0) - p);
-            }
-        }
-        dp[i][k][state] = profit;
-        return profit;
-    }
-
     public long maximumProfit(int[] prices, int k) {
-        this.prices = prices;
         int n = prices.length;
-        dp = new long[n + 1][k + 1][3];
-        for (long[][] twoD : dp) {
-            for (long[] oneD : twoD) {
-                Arrays.fill(oneD, MN);
+        long[] prev = new long[n];
+        long[] curr = new long[n];
+        for (int t = 1; t <= k; t++) {
+            long bestLong = -prices[0];
+            long bestShort = prices[0];
+            curr[0] = 0;
+            for (int i = 1; i < n; i++) {
+                long res = curr[i - 1];
+                res = Math.max(res, prices[i] + bestLong);
+                res = Math.max(res, -prices[i] + bestShort);
+                curr[i] = res;
+                bestLong = Math.max(bestLong, prev[i - 1] - prices[i]);
+                bestShort = Math.max(bestShort, prev[i - 1] + prices[i]);
             }
+            long[] tmp = prev;
+            prev = curr;
+            curr = tmp;
         }
-        return f(0, k, 0);
+        return prev[n - 1];
     }
 }

src/main/java/g3501_3600/s3574_maximize_subarray_gcd_score/Solution.java

@@ -1,45 +1,64 @@
 package g3501_3600.s3574_maximize_subarray_gcd_score;
 
-// #Hard #2025_06_08_Time_364_ms_(100.00%)_Space_44.70_MB_(100.00%)
+// #Hard #Array #Math #Enumeration #Number_Theory
+// #2025_06_10_Time_13_ms_(100.00%)_Space_45.07_MB_(78.08%)
 
 public class Solution {
     public long maxGCDScore(int[] nums, int k) {
+        int mx = 0;
+        for (int x : nums) {
+            mx = Math.max(mx, x);
+        }
+        int width = 32 - Integer.numberOfLeadingZeros(mx);
+        List<Integer>[] lowbitPos = new List[width];
+        Arrays.setAll(lowbitPos, i -> new ArrayList<>());
+        int[][] intervals = new int[width + 1][3];
+        int size = 0;
         long ans = 0;
-        int n = nums.length;
-        for (int i = 0; i < n; i++) {
-            long countGCD = 0;
-            long oddCount = 0;
-            long ongoingGCD = 0;
-            for (int j = i; j < n; j++) {
-                long currentGCD = gcd(ongoingGCD, nums[j]);
-                if (currentGCD != ongoingGCD) {
-                    ongoingGCD = currentGCD;
-                    countGCD = 1;
-                } else if (nums[j] == ongoingGCD) {
-                    countGCD++;
-                }
-                if (nums[j] % 2 != 0) {
-                    oddCount++;
+        for (int i = 0; i < nums.length; i++) {
+            int x = nums[i];
+            int tz = Integer.numberOfTrailingZeros(x);
+            lowbitPos[tz].add(i);
+            for (int j = 0; j < size; j++) {
+                intervals[j][0] = gcd(intervals[j][0], x);
+            }
+            intervals[size][0] = x;
+            intervals[size][1] = i - 1;
+            intervals[size][2] = i;
+            size++;
+            int idx = 1;
+            for (int j = 1; j < size; j++) {
+                if (intervals[j][0] != intervals[j - 1][0]) {
+                    intervals[idx][0] = intervals[j][0];
+                    intervals[idx][1] = intervals[j][1];
+                    intervals[idx][2] = intervals[j][2];
+                    idx++;
+                } else {
+                    intervals[idx - 1][2] = intervals[j][2];
                 }
-                int len = j - i + 1;
-                long res = ongoingGCD * len;
-                if (ongoingGCD % 2 != 0) {
-                    if (k >= oddCount) {
-                        res *= 2L;
-                    }
-                } else if (k >= countGCD) {
-                    res *= 2L;
+            }
+            size = idx;
+            for (int j = 0; j < size; j++) {
+                int g = intervals[j][0];
+                int l = intervals[j][1];
+                int r = intervals[j][2];
+                ans = Math.max(ans, (long) g * (i - l));
+                List<Integer> pos = lowbitPos[Integer.numberOfTrailingZeros(g)];
+                int minL = pos.size() > k ? Math.max(l, pos.get(pos.size() - k - 1)) : l;
+                if (minL < r) {
+                    ans = Math.max(ans, (long) g * 2 * (i - minL));
                 }
-                ans = Math.max(ans, res);
             }
         }
         return ans;
     }
 
-    private long gcd(long a, long b) {
-        if (a == 0) {
-            return b;
+    private int gcd(int a, int b) {
+        while (a != 0) {
+            int tmp = a;
+            a = b % a;
+            b = tmp;
         }
-        return gcd(b % a, a);
+        return b;
     }
 }

src/main/java/g3501_3600/s3575_maximum_good_subtree_score/Solution.java

@@ -1,91 +1,84 @@
 package g3501_3600.s3575_maximum_good_subtree_score;
 
-// #Hard #2025_06_08_Time_564_ms_(100.00%)_Space_45.22_MB_(100.00%)
+// #Hard #Array #Dynamic_Programming #Depth_First_Search #Tree #Bit_Manipulation #Bitmask
+// #2025_06_10_Time_92_ms_(98.73%)_Space_55.23_MB_(11.71%)
 
 import java.util.ArrayList;
-import java.util.HashMap;
-import java.util.HashSet;
 import java.util.List;
-import java.util.Map;
-import java.util.Set;
 
 @SuppressWarnings("unchecked")
 public class Solution {
-    private long ans;
-    private static final int MOD = 1_000_000_007;
+    private int digits = 10;
+    private int full = 1 << digits;
+    private long neg = Long.MIN_VALUE / 4;
+    private long mod = (long) 1e9 + 7;
+    private List<Integer>[] tree;
+    private int[] val;
+    private int[] mask;
+    private boolean[] isOk;
+    private long res = 0;
 
     public int goodSubtreeSum(int[] vals, int[] par) {
         int n = vals.length;
-        List<Integer>[] adj = new ArrayList[n];
+        val = vals;
+        mask = new int[n];
+        isOk = new boolean[n];
         for (int i = 0; i < n; i++) {
-            adj[i] = new ArrayList<>();
+            int m = 0;
+            int v = vals[i];
+            boolean valid = true;
+            while (v > 0) {
+                int d = v % 10;
+                if (((m >> d) & 1) == 1) {
+                    valid = false;
+                    break;
+                }
+                m |= 1 << d;
+                v /= 10;
+            }
+            mask[i] = m;
+            isOk[i] = valid;
         }
+        tree = new ArrayList[n];
+        Arrays.setAll(tree, ArrayList::new);
+        int root = 0;
         for (int i = 1; i < n; i++) {
-            adj[par[i]].add(i);
+            tree[par[i]].add(i);
         }
-        this.ans = 0;
-        dfs(0, vals, adj);
-        return (int) ((this.ans % MOD + MOD) % MOD);
+        dfs(root);
+        return (int) (res % mod);
     }
 
-    private Map<Integer, Integer> dfs(int u, int[] vals, List<Integer>[] adj) {
-        // du: The DP map for the subtree at node u.
-        // Key: bitmask of digits. Value: max sum for that combination of digits.
-        Map<Integer, Integer> du = new HashMap<>();
-        // Base case: A sum of 0 is possible with an empty set of digits (mask 0).
-        du.put(0, 0);
-        // Process the current node's value.
-        String s = String.valueOf(Math.abs(vals[u]));
-        if (hasUniqueDigits(s)) {
-            int mask = 0;
-            for (char c : s.toCharArray()) {
-                mask |= (1 << (c - '0'));
-            }
-            du.put(mask, vals[u]);
+    private long[] dfs(int u) {
+        long[] dp = new long[full];
+        Arrays.fill(dp, neg);
+        dp[0] = 0;
+        if (isOk[u]) {
+            dp[mask[u]] = val[u];
         }
-        for (int v : adj[u]) {
-            Map<Integer, Integer> dv = dfs(v, vals, adj);
-            Map<Integer, Integer> duSnapshot = new HashMap<>(du);
-            for (Map.Entry<Integer, Integer> entryV : dv.entrySet()) {
-                int mv = entryV.getKey();
-                int sv = entryV.getValue();
-                for (Map.Entry<Integer, Integer> entryU : duSnapshot.entrySet()) {
-                    int mu = entryU.getKey();
-                    int su = entryU.getValue();
-                    // If the digit sets are disjoint (no common bits in masks), we can combine
-                    // them.
-                    if ((mu & mv) == 0) {
-                        int newMask = mu | mv;
-                        int newSum = su + sv;
-                        // Update `du` with the best possible sum for the new combined mask.
-                        du.put(
-                                newMask,
-                                Math.max(du.getOrDefault(newMask, Integer.MIN_VALUE), newSum));
+        for (int v : tree[u]) {
+            long[] child = dfs(v);
+            long[] newDp = Arrays.copyOf(dp, full);
+            for (int m1 = 0; m1 < full; m1++) {
+                if (dp[m1] < 0) {
+                    continue;
+                }
+                int remain = full - 1 - m1;
+                for (int m2 = remain; m2 > 0; m2 = (m2 - 1) & remain) {
+                    if (child[m2] < 0) {
+                        continue;
                     }
+                    int newM = m1 | m2;
+                    newDp[newM] = Math.max(newDp[newM], dp[m1] + child[m2]);
                 }
             }
+            dp = newDp;
         }
-        // After processing all children, the max value in `du` is the "good" sum for the subtree at
-        // u.
-        // Initialize with a very small number to correctly find the maximum, even if sums are
-        // negative.
-        int maxSubtreeSum = Integer.MIN_VALUE;
-        for (int sum : du.values()) {
-            maxSubtreeSum = Math.max(maxSubtreeSum, sum);
-        }
-        // Add this subtree's best sum to the total answer.
-        // If du is empty (should not happen due to {0:0}), we add 0.
-        this.ans += (maxSubtreeSum == Integer.MIN_VALUE ? 0 : maxSubtreeSum);
-        return du;
-    }
-
-    private boolean hasUniqueDigits(String s) {
-        Set<Character> digits = new HashSet<>();
-        for (char c : s.toCharArray()) {
-            if (!digits.add(c)) {
-                return false;
-            }
+        long best = 0;
+        for (long v : dp) {
+            best = Math.max(best, v);
         }
-        return true;
+        res = (res + best) % mod;
+        return dp;
     }
 }

src/main/java/g3501_3600/s3576_transform_array_to_all_equal_elements/Solution.java

@@ -1,6 +1,6 @@
 package g3501_3600.s3576_transform_array_to_all_equal_elements;
 
-// #Medium #2025_06_08_Time_7_ms_(99.86%)_Space_62.66_MB_(5.31%)
+// #Medium #Array #Greedy #2025_06_10_Time_7_ms_(99.81%)_Space_56.56_MB_(99.57%)
 
 import java.util.ArrayList;
 import java.util.List;

src/main/java/g3501_3600/s3577_count_the_number_of_computer_unlocking_permutations/Solution.java

@@ -1,6 +1,7 @@
 package g3501_3600.s3577_count_the_number_of_computer_unlocking_permutations;
 
-// #Medium #2025_06_08_Time_1_ms_(100.00%)_Space_62.08_MB_(35.87%)
+// #Medium #Array #Math #Combinatorics #Brainteaser
+// #2025_06_10_Time_1_ms_(100.00%)_Space_62.24_MB_(22.08%)
 
 public class Solution {
     private static final int MOD = 1_000_000_007;