Skip to content

Commit 67df942

Browse files
javadevjavadev
committed
Improved tasks 3659, 3660, 3661
1 parent 68a3550 commit 67df942

File tree

3 files changed

+95
-187
lines changed

3 files changed

+95
-187
lines changed

‎src/main/java/g3601_3700/s3659_partition_array_into_k_distinct_groups/Solution.java‎

Lines changed: 12 additions & 8 deletions
Original file line numberDiff line numberDiff line change
@@ -1,20 +1,24 @@
11
package g3601_3700.s3659_partition_array_into_k_distinct_groups;
22

3-
// #Medium #Weekly_Contest_464 #2025_08_24_Time_81_ms_(100.00%)_Space_62.78_MB_(100.00%)
4-
5-
import java.util.HashMap;
3+
// #Medium #Weekly_Contest_464 #2025_08_29_Time_2_ms_(100.00%)_Space_55.86_MB_(99.96%)
64

75
public class Solution {
86
public boolean partitionArray(int[] nums, int k) {
9-
HashMap<Integer, Integer> mpp = new HashMap<>();
7+
int n = nums.length;
8+
if (n % k != 0) {
9+
return false;
10+
}
11+
int max = 0;
1012
for (int x : nums) {
11-
mpp.put(x, mpp.getOrDefault(x, 0) + 1);
13+
max = Math.max(max, x);
1214
}
13-
for (int count : mpp.values()) {
14-
if (count > nums.length / k) {
15+
int[] count = new int[max + 1];
16+
int limit = n / k;
17+
for (int x : nums) {
18+
if (++count[x] > limit) {
1519
return false;
1620
}
1721
}
18-
return nums.length % k == 0;
22+
return true;
1923
}
2024
}

‎src/main/java/g3601_3700/s3660_jump_game_ix/Solution.java‎

Lines changed: 12 additions & 79 deletions
Original file line numberDiff line numberDiff line change
@@ -1,89 +1,22 @@
11
package g3601_3700.s3660_jump_game_ix;
22

3-
// #Medium #Weekly_Contest_464 #2025_08_24_Time_248_ms_(100.00%)_Space_72.98_MB_(100.00%)
4-
5-
import java.util.ArrayDeque;
6-
import java.util.HashMap;
3+
// #Medium #Weekly_Contest_464 #2025_08_29_Time_3_ms_(100.00%)_Space_66.47_MB_(70.03%)
74

85
public class Solution {
96
public int[] maxValue(int[] nums) {
10-
int n = nums.length;
11-
ArrayDeque<Integer> st = new ArrayDeque<>();
12-
UnionFind uf = new UnionFind(n);
13-
for (int i = 0; i < n; i++) {
14-
int prev = i;
15-
if (!st.isEmpty()) {
16-
prev = st.peek();
17-
}
18-
while (!st.isEmpty() && nums[i] < nums[st.peek()]) {
19-
uf.union(st.pop(), i);
20-
}
21-
if (nums[i] > nums[prev]) {
22-
st.push(i);
23-
} else {
24-
st.push(prev);
25-
}
26-
}
27-
st.clear();
28-
for (int i = n - 1; i >= 0; i--) {
29-
int prev = i;
30-
if (!st.isEmpty()) {
31-
prev = st.peek();
32-
}
33-
while (!st.isEmpty() && nums[i] > nums[st.peek()]) {
34-
uf.union(st.pop(), i);
35-
}
36-
if (nums[i] < nums[prev]) {
37-
st.push(i);
38-
} else {
39-
st.push(prev);
40-
}
41-
}
42-
HashMap<Integer, Integer> map = new HashMap<>();
43-
for (int i = 0; i < n; i++) {
44-
int root = uf.find(i);
45-
map.put(root, Math.max(map.getOrDefault(root, Integer.MIN_VALUE), nums[i]));
46-
}
47-
int[] ans = new int[n];
48-
for (int i = 0; i < n; i++) {
49-
ans[i] = map.get(uf.find(i));
7+
int[] f = new int[nums.length];
8+
int cur = 0;
9+
for (int i = 0; i < nums.length; i++) {
10+
cur = Math.max(cur, nums[i]);
11+
f[i] = cur;
5012
}
51-
return ans;
52-
}
53-
54-
private static class UnionFind {
55-
int[] par;
56-
int[] rank;
57-
58-
UnionFind(int n) {
59-
par = new int[n];
60-
rank = new int[n];
61-
for (int i = 0; i < n; i++) {
62-
par[i] = i;
63-
}
64-
}
65-
66-
int find(int x) {
67-
if (par[x] != x) {
68-
par[x] = find(par[x]);
69-
}
70-
return par[x];
71-
}
72-
73-
void union(int x, int y) {
74-
x = find(x);
75-
y = find(y);
76-
if (x == y) {
77-
return;
78-
}
79-
if (rank[x] < rank[y]) {
80-
par[x] = y;
81-
} else if (rank[x] > rank[y]) {
82-
par[y] = x;
83-
} else {
84-
par[y] = x;
85-
rank[x]++;
13+
int min = nums[nums.length - 1];
14+
for (int i = nums.length - 2; i >= 0; i--) {
15+
if (f[i] > min) {
16+
f[i] = Math.max(f[i], f[i + 1]);
8617
}
18+
min = Math.min(min, nums[i]);
8719
}
20+
return f;
8821
}
8922
}

‎src/main/java/g3601_3700/s3661_maximum_walls_destroyed_by_robots/Solution.java‎

Lines changed: 71 additions & 100 deletions
Original file line numberDiff line numberDiff line change
@@ -1,120 +1,91 @@
11
package g3601_3700.s3661_maximum_walls_destroyed_by_robots;
22

3-
// #Hard #Weekly_Contest_464 #2025_08_24_Time_164_ms_(100.00%)_Space_59.97_MB_(100.00%)
3+
// #Hard #Weekly_Contest_464 #2025_08_29_Time_88_ms_(99.25%)_Space_68.62_MB_(40.75%)
44

55
import java.util.Arrays;
66

77
public class Solution {
88
public int maxWalls(int[] robots, int[] distance, int[] walls) {
9-
int n = robots.length;
10-
// Pair robots with distances and sort
11-
int[][] rpair = new int[n][2];
12-
for (int i = 0; i < n; i++) {
13-
rpair[i][0] = robots[i];
14-
rpair[i][1] = distance[i];
9+
if (robots.length == 1) {
10+
int a = 0;
11+
int b = 0;
12+
for (int wall : walls) {
13+
if (wall < robots[0] - distance[0] || wall > robots[0] + distance[0]) {
14+
continue;
15+
}
16+
if (wall < robots[0]) {
17+
a++;
18+
} else if (wall > robots[0]) {
19+
b++;
20+
} else {
21+
a++;
22+
b++;
23+
}
24+
}
25+
return Math.max(a, b);
1526
}
16-
Arrays.sort(rpair, (a, b) -> Integer.compare(a[0], b[0]));
17-
int[] r = new int[n];
18-
int[] d = new int[n];
19-
for (int i = 0; i < n; i++) {
20-
r[i] = rpair[i][0];
21-
d[i] = rpair[i][1];
27+
int[][] arr = new int[robots.length][];
28+
for (int i = 0; i < robots.length; i++) {
29+
arr[i] = new int[] {robots[i], distance[i]};
2230
}
31+
Arrays.sort(arr, (a, b) -> a[0] - b[0]);
2332
Arrays.sort(walls);
24-
// Count walls at robot positions
25-
int base = 0;
26-
for (int i = 0; i < n; i++) {
27-
int idx = Arrays.binarySearch(walls, r[i]);
28-
if (idx >= 0) {
29-
base++;
30-
}
33+
int a = 0;
34+
int b = 0;
35+
int i = 0;
36+
int j = 0;
37+
while (i < walls.length && walls[i] < arr[j][0] - arr[j][1]) {
38+
i++;
3139
}
32-
// Tail walls
33-
int leftTail = countRange(walls, (long) r[0] - d[0], r[0] - 1L);
34-
int rightTail = countRange(walls, r[n - 1] + 1L, (long) r[n - 1] + d[n - 1]);
35-
// Precompute segment ranges
36-
int segs = n - 1;
37-
int max = Math.max(0, segs);
38-
int[] a = new int[max];
39-
int[] b = new int[max];
40-
int[] c = new int[max];
41-
for (int i = 0; i < segs; i++) {
42-
int segL = r[i] + 1;
43-
int segR = r[i + 1] - 1;
44-
if (segL > segR) {
45-
a[i] = b[i] = c[i] = 0;
46-
continue;
47-
}
48-
int aHigh = Math.min(segR, r[i] + d[i]);
49-
a[i] = countRange(walls, segL, aHigh);
50-
int bLow = Math.max(segL, r[i + 1] - d[i + 1]);
51-
b[i] = countRange(walls, bLow, segR);
52-
int cLow = Math.max(segL, r[i + 1] - d[i + 1]);
53-
int cHigh = Math.min(segR, r[i] + d[i]);
54-
c[i] = countRange(walls, cLow, cHigh);
40+
while (i < walls.length && walls[i] <= arr[j][0]) {
41+
a++;
42+
i++;
5543
}
56-
int[][] dp = new int[n][2];
57-
Arrays.fill(dp[0], Integer.MIN_VALUE / 4);
58-
// first fires left
59-
dp[0][0] = base + leftTail;
60-
// first fires right
61-
dp[0][1] = base;
62-
for (int i = 0; i < n - 1; i++) {
63-
Arrays.fill(dp[i + 1], Integer.MIN_VALUE / 4);
64-
for (int choice = 0; choice <= 1; choice++) {
65-
int cur = dp[i][choice];
66-
if (cur < 0) {
67-
continue;
68-
}
69-
int addIfNextLeft = (choice == 1) ? a[i] + b[i] - c[i] : b[i];
70-
dp[i + 1][0] = Math.max(dp[i + 1][0], cur + addIfNextLeft);
71-
int addIfNextRight = (choice == 1) ? a[i] : 0;
72-
dp[i + 1][1] = Math.max(dp[i + 1][1], cur + addIfNextRight);
73-
}
44+
if (i > 0 && walls[i - 1] == arr[j][0]) {
45+
i--;
7446
}
75-
int res;
76-
if (n == 1) {
77-
res = Math.max(dp[0][0], dp[0][1] + rightTail);
78-
} else {
79-
res = Math.max(dp[n - 1][0], dp[n - 1][1] + rightTail);
47+
while (i < walls.length && walls[i] <= arr[j][0] + arr[j][1] && walls[i] < arr[j + 1][0]) {
48+
b++;
49+
i++;
8050
}
81-
return res;
82-
}
83-
84-
private int countRange(int[] arr, long l, long r) {
85-
if (l > r || arr.length == 0) {
86-
return 0;
87-
}
88-
int leftIdx = lowerBound(arr, l);
89-
int rightIdx = upperBound(arr, r);
90-
return Math.max(0, rightIdx - leftIdx);
91-
}
92-
93-
private int lowerBound(int[] a, long x) {
94-
int l = 0;
95-
int r = a.length;
96-
while (l < r) {
97-
int m = (l + r) >>> 1;
98-
if (a[m] < x) {
99-
l = m + 1;
100-
} else {
101-
r = m;
51+
j++;
52+
while (j < arr.length) {
53+
int l1 = 0;
54+
int k = i;
55+
while (k < walls.length && walls[k] < arr[j][0] - arr[j][1]) {
56+
k++;
10257
}
103-
}
104-
return l;
105-
}
106-
107-
private int upperBound(int[] a, long x) {
108-
int l = 0;
109-
int r = a.length;
110-
while (l < r) {
111-
int m = (l + r) >>> 1;
112-
if (a[m] <= x) {
113-
l = m + 1;
58+
while (k < walls.length && walls[k] <= arr[j][0]) {
59+
l1++;
60+
k++;
61+
}
62+
int nextI = k;
63+
int l2 = l1;
64+
k = i - 1;
65+
while (k >= 0 && walls[k] > arr[j - 1][0] && walls[k] >= arr[j][0] - arr[j][1]) {
66+
l2++;
67+
k--;
68+
}
69+
int aNext = Math.max(a + l2, b + l1);
70+
int r = 0;
71+
int lim =
72+
j < arr.length - 1
73+
? Math.min(arr[j + 1][0], arr[j][0] + arr[j][1] + 1)
74+
: arr[j][0] + arr[j][1] + 1;
75+
if (nextI > 0 && walls[nextI - 1] == arr[j][0]) {
76+
i = nextI - 1;
11477
} else {
115-
r = m;
78+
i = nextI;
79+
}
80+
while (i < walls.length && walls[i] < lim) {
81+
r++;
82+
i++;
11683
}
84+
j++;
85+
int bNext = Math.max(a, b) + r;
86+
a = aNext;
87+
b = bNext;
11788
}
118-
return l;
89+
return Math.max(a, b);
11990
}
12091
}

0 commit comments

Comments
 (0)