Updated tags

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;