Skip to content

Navigation Menu

Sign in
Appearance settings

Search code, repositories, users, issues, pull requests...

Provide feedback

We read every piece of feedback, and take your input very seriously.

Saved searches

Use saved searches to filter your results more quickly
Sign up
Appearance settings

Commit 1dffcda

Browse files
authored
Added tasks 3572-3579
1 parent c74cdf6 commit 1dffcda

File tree

24 files changed

+1012
-0
lines changed

24 files changed

+1012
-0
lines changed
Lines changed: 45 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,45 @@
1+
package g3501_3600.s3572_maximize_ysum_by_picking_a_triplet_of_distinct_xvalues;
2+
3+
// #Medium #Array #Hash_Table #Sorting #Greedy #Heap_Priority_Queue
4+
// #2025_06_10_Time_2_ms_(100.00%)_Space_64.25_MB_(40.62%)
5+
6+
public class Solution {
7+
public int maxSumDistinctTriplet(int[] x, int[] y) {
8+
int index = -1;
9+
int max = -1;
10+
int sum = 0;
11+
for (int i = 0; i < y.length; i++) {
12+
if (y[i] > max) {
13+
max = y[i];
14+
index = i;
15+
}
16+
}
17+
sum += max;
18+
if (max == -1) {
19+
return -1;
20+
}
21+
int index2 = -1;
22+
max = -1;
23+
for (int i = 0; i < y.length; i++) {
24+
if (y[i] > max && x[i] != x[index]) {
25+
max = y[i];
26+
index2 = i;
27+
}
28+
}
29+
sum += max;
30+
if (max == -1) {
31+
return -1;
32+
}
33+
max = -1;
34+
for (int i = 0; i < y.length; i++) {
35+
if (y[i] > max && x[i] != x[index] && x[i] != x[index2]) {
36+
max = y[i];
37+
}
38+
}
39+
if (max == -1) {
40+
return -1;
41+
}
42+
sum += max;
43+
return sum;
44+
}
45+
}
Lines changed: 40 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,40 @@
1+
3572\. Maximize Y‐Sum by Picking a Triplet of Distinct X‐Values
2+
3+
Medium
4+
5+
You are given two integer arrays `x` and `y`, each of length `n`. You must choose three **distinct** indices `i`, `j`, and `k` such that:
6+
7+
* `x[i] != x[j]`
8+
* `x[j] != x[k]`
9+
* `x[k] != x[i]`
10+
11+
Your goal is to **maximize** the value of `y[i] + y[j] + y[k]` under these conditions. Return the **maximum** possible sum that can be obtained by choosing such a triplet of indices.
12+
13+
If no such triplet exists, return -1.
14+
15+
**Example 1:**
16+
17+
**Input:** x = [1,2,1,3,2], y = [5,3,4,6,2]
18+
19+
**Output:** 14
20+
21+
**Explanation:**
22+
23+
* Choose `i = 0` (`x[i] = 1`, `y[i] = 5`), `j = 1` (`x[j] = 2`, `y[j] = 3`), `k = 3` (`x[k] = 3`, `y[k] = 6`).
24+
* All three values chosen from `x` are distinct. `5 + 3 + 6 = 14` is the maximum we can obtain. Hence, the output is 14.
25+
26+
**Example 2:**
27+
28+
**Input:** x = [1,2,1,2], y = [4,5,6,7]
29+
30+
**Output:** \-1
31+
32+
**Explanation:**
33+
34+
* There are only two distinct values in `x`. Hence, the output is -1.
35+
36+
**Constraints:**
37+
38+
* `n == x.length == y.length`
39+
* <code>3 <= n <= 10<sup>5</sup></code>
40+
* <code>1 <= x[i], y[i] <= 10<sup>6</sup></code>
Lines changed: 28 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,28 @@
1+
package g3501_3600.s3573_best_time_to_buy_and_sell_stock_v;
2+
3+
// #Medium #Array #Dynamic_Programming #2025_06_10_Time_10_ms_(99.46%)_Space_44.46_MB_(97.36%)
4+
5+
public class Solution {
6+
public long maximumProfit(int[] prices, int k) {
7+
int n = prices.length;
8+
long[] prev = new long[n];
9+
long[] curr = new long[n];
10+
for (int t = 1; t <= k; t++) {
11+
long bestLong = -prices[0];
12+
long bestShort = prices[0];
13+
curr[0] = 0;
14+
for (int i = 1; i < n; i++) {
15+
long res = curr[i - 1];
16+
res = Math.max(res, prices[i] + bestLong);
17+
res = Math.max(res, -prices[i] + bestShort);
18+
curr[i] = res;
19+
bestLong = Math.max(bestLong, prev[i - 1] - prices[i]);
20+
bestShort = Math.max(bestShort, prev[i - 1] + prices[i]);
21+
}
22+
long[] tmp = prev;
23+
prev = curr;
24+
curr = tmp;
25+
}
26+
return prev[n - 1];
27+
}
28+
}
Lines changed: 49 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,49 @@
1+
3573\. Best Time to Buy and Sell Stock V
2+
3+
Medium
4+
5+
You are given an integer array `prices` where `prices[i]` is the price of a stock in dollars on the <code>i<sup>th</sup></code> day, and an integer `k`.
6+
7+
You are allowed to make at most `k` transactions, where each transaction can be either of the following:
8+
9+
* **Normal transaction**: Buy on day `i`, then sell on a later day `j` where `i < j`. You profit `prices[j] - prices[i]`.
10+
11+
* **Short selling transaction**: Sell on day `i`, then buy back on a later day `j` where `i < j`. You profit `prices[i] - prices[j]`.
12+
13+
14+
**Note** that you must complete each transaction before starting another. Additionally, you can't buy or sell on the same day you are selling or buying back as part of a previous transaction.
15+
16+
Return the **maximum** total profit you can earn by making **at most** `k` transactions.
17+
18+
**Example 1:**
19+
20+
**Input:** prices = [1,7,9,8,2], k = 2
21+
22+
**Output:** 14
23+
24+
**Explanation:**
25+
26+
We can make 14ドル of profit through 2 transactions:
27+
28+
* A normal transaction: buy the stock on day 0 for 1ドル then sell it on day 2 for 9ドル.
29+
* A short selling transaction: sell the stock on day 3 for 8ドル then buy back on day 4 for 2ドル.
30+
31+
**Example 2:**
32+
33+
**Input:** prices = [12,16,19,19,8,1,19,13,9], k = 3
34+
35+
**Output:** 36
36+
37+
**Explanation:**
38+
39+
We can make 36ドル of profit through 3 transactions:
40+
41+
* A normal transaction: buy the stock on day 0 for 12ドル then sell it on day 2 for 19ドル.
42+
* A short selling transaction: sell the stock on day 3 for 19ドル then buy back on day 4 for 8ドル.
43+
* A normal transaction: buy the stock on day 5 for 1ドル then sell it on day 6 for 19ドル.
44+
45+
**Constraints:**
46+
47+
* <code>2 <= prices.length <= 10<sup>3</sup></code>
48+
* <code>1 <= prices[i] <= 10<sup>9</sup></code>
49+
* `1 <= k <= prices.length / 2`
Lines changed: 69 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,69 @@
1+
package g3501_3600.s3574_maximize_subarray_gcd_score;
2+
3+
// #Hard #Array #Math #Enumeration #Number_Theory
4+
// #2025_06_10_Time_13_ms_(100.00%)_Space_45.07_MB_(78.08%)
5+
6+
import java.util.ArrayList;
7+
import java.util.Arrays;
8+
import java.util.List;
9+
10+
@SuppressWarnings("unchecked")
11+
public class Solution {
12+
public long maxGCDScore(int[] nums, int k) {
13+
int mx = 0;
14+
for (int x : nums) {
15+
mx = Math.max(mx, x);
16+
}
17+
int width = 32 - Integer.numberOfLeadingZeros(mx);
18+
List<Integer>[] lowbitPos = new List[width];
19+
Arrays.setAll(lowbitPos, i -> new ArrayList<>());
20+
int[][] intervals = new int[width + 1][3];
21+
int size = 0;
22+
long ans = 0;
23+
for (int i = 0; i < nums.length; i++) {
24+
int x = nums[i];
25+
int tz = Integer.numberOfTrailingZeros(x);
26+
lowbitPos[tz].add(i);
27+
for (int j = 0; j < size; j++) {
28+
intervals[j][0] = gcd(intervals[j][0], x);
29+
}
30+
intervals[size][0] = x;
31+
intervals[size][1] = i - 1;
32+
intervals[size][2] = i;
33+
size++;
34+
int idx = 1;
35+
for (int j = 1; j < size; j++) {
36+
if (intervals[j][0] != intervals[j - 1][0]) {
37+
intervals[idx][0] = intervals[j][0];
38+
intervals[idx][1] = intervals[j][1];
39+
intervals[idx][2] = intervals[j][2];
40+
idx++;
41+
} else {
42+
intervals[idx - 1][2] = intervals[j][2];
43+
}
44+
}
45+
size = idx;
46+
for (int j = 0; j < size; j++) {
47+
int g = intervals[j][0];
48+
int l = intervals[j][1];
49+
int r = intervals[j][2];
50+
ans = Math.max(ans, (long) g * (i - l));
51+
List<Integer> pos = lowbitPos[Integer.numberOfTrailingZeros(g)];
52+
int minL = pos.size() > k ? Math.max(l, pos.get(pos.size() - k - 1)) : l;
53+
if (minL < r) {
54+
ans = Math.max(ans, (long) g * 2 * (i - minL));
55+
}
56+
}
57+
}
58+
return ans;
59+
}
60+
61+
private int gcd(int a, int b) {
62+
while (a != 0) {
63+
int tmp = a;
64+
a = b % a;
65+
b = tmp;
66+
}
67+
return b;
68+
}
69+
}
Lines changed: 56 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,56 @@
1+
3574\. Maximize Subarray GCD Score
2+
3+
Hard
4+
5+
You are given an array of positive integers `nums` and an integer `k`.
6+
7+
You may perform at most `k` operations. In each operation, you can choose one element in the array and **double** its value. Each element can be doubled **at most** once.
8+
9+
The **score** of a contiguous **subarray** is defined as the **product** of its length and the _greatest common divisor (GCD)_ of all its elements.
10+
11+
Your task is to return the **maximum** **score** that can be achieved by selecting a contiguous subarray from the modified array.
12+
13+
**Note:**
14+
15+
* The **greatest common divisor (GCD)** of an array is the largest integer that evenly divides all the array elements.
16+
17+
**Example 1:**
18+
19+
**Input:** nums = [2,4], k = 1
20+
21+
**Output:** 8
22+
23+
**Explanation:**
24+
25+
* Double `nums[0]` to 4 using one operation. The modified array becomes `[4, 4]`.
26+
* The GCD of the subarray `[4, 4]` is 4, and the length is 2.
27+
* Thus, the maximum possible score is `2 ×ばつ 4 = 8`.
28+
29+
**Example 2:**
30+
31+
**Input:** nums = [3,5,7], k = 2
32+
33+
**Output:** 14
34+
35+
**Explanation:**
36+
37+
* Double `nums[2]` to 14 using one operation. The modified array becomes `[3, 5, 14]`.
38+
* The GCD of the subarray `[14]` is 14, and the length is 1.
39+
* Thus, the maximum possible score is `1 ×ばつ 14 = 14`.
40+
41+
**Example 3:**
42+
43+
**Input:** nums = [5,5,5], k = 1
44+
45+
**Output:** 15
46+
47+
**Explanation:**
48+
49+
* The subarray `[5, 5, 5]` has a GCD of 5, and its length is 3.
50+
* Since doubling any element doesn't improve the score, the maximum score is `3 ×ばつ 5 = 15`.
51+
52+
**Constraints:**
53+
54+
* `1 <= n == nums.length <= 1500`
55+
* <code>1 <= nums[i] <= 10<sup>9</sup></code>
56+
* `1 <= k <= n`
Lines changed: 85 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,85 @@
1+
package g3501_3600.s3575_maximum_good_subtree_score;
2+
3+
// #Hard #Array #Dynamic_Programming #Depth_First_Search #Tree #Bit_Manipulation #Bitmask
4+
// #2025_06_10_Time_92_ms_(98.73%)_Space_55.23_MB_(11.71%)
5+
6+
import java.util.ArrayList;
7+
import java.util.Arrays;
8+
import java.util.List;
9+
10+
@SuppressWarnings("unchecked")
11+
public class Solution {
12+
private int digits = 10;
13+
private int full = 1 << digits;
14+
private long neg = Long.MIN_VALUE / 4;
15+
private long mod = (long) 1e9 + 7;
16+
private List<Integer>[] tree;
17+
private int[] val;
18+
private int[] mask;
19+
private boolean[] isOk;
20+
private long res = 0;
21+
22+
public int goodSubtreeSum(int[] vals, int[] par) {
23+
int n = vals.length;
24+
val = vals;
25+
mask = new int[n];
26+
isOk = new boolean[n];
27+
for (int i = 0; i < n; i++) {
28+
int m = 0;
29+
int v = vals[i];
30+
boolean valid = true;
31+
while (v > 0) {
32+
int d = v % 10;
33+
if (((m >> d) & 1) == 1) {
34+
valid = false;
35+
break;
36+
}
37+
m |= 1 << d;
38+
v /= 10;
39+
}
40+
mask[i] = m;
41+
isOk[i] = valid;
42+
}
43+
tree = new ArrayList[n];
44+
Arrays.setAll(tree, ArrayList::new);
45+
int root = 0;
46+
for (int i = 1; i < n; i++) {
47+
tree[par[i]].add(i);
48+
}
49+
dfs(root);
50+
return (int) (res % mod);
51+
}
52+
53+
private long[] dfs(int u) {
54+
long[] dp = new long[full];
55+
Arrays.fill(dp, neg);
56+
dp[0] = 0;
57+
if (isOk[u]) {
58+
dp[mask[u]] = val[u];
59+
}
60+
for (int v : tree[u]) {
61+
long[] child = dfs(v);
62+
long[] newDp = Arrays.copyOf(dp, full);
63+
for (int m1 = 0; m1 < full; m1++) {
64+
if (dp[m1] < 0) {
65+
continue;
66+
}
67+
int remain = full - 1 - m1;
68+
for (int m2 = remain; m2 > 0; m2 = (m2 - 1) & remain) {
69+
if (child[m2] < 0) {
70+
continue;
71+
}
72+
int newM = m1 | m2;
73+
newDp[newM] = Math.max(newDp[newM], dp[m1] + child[m2]);
74+
}
75+
}
76+
dp = newDp;
77+
}
78+
long best = 0;
79+
for (long v : dp) {
80+
best = Math.max(best, v);
81+
}
82+
res = (res + best) % mod;
83+
return dp;
84+
}
85+
}

0 commit comments

Comments
(0)

AltStyle によって変換されたページ (->オリジナル) /