Skip to content

Commit 2e9459d

Browse files
Triet TRINH MINHtrinhminhtriet
Triet TRINH MINH
authored and
trinhminhtriet
committed
Add solutions for problems 3569, 3585, 3588, 3589, 3590, 3592, 3593, 3594, 3597, 3603, 3604, 3605, and 3607
1 parent 1fab39d commit 2e9459d

File tree

13 files changed

+969
-0
lines changed

13 files changed

+969
-0
lines changed

‎solutions/3500-3599/3569.maximize-count-of-distinct-primes-after-split/Solution.java‎

Lines changed: 125 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,125 @@
1+
import java.util.*;
2+
3+
public class Solution {
4+
static final int MAXV = 100_001;
5+
6+
private boolean[] isPrime = new boolean[MAXV];
7+
8+
public Solution() {
9+
Arrays.fill(isPrime, true);
10+
isPrime[0] = isPrime[1] = false;
11+
for (int i = 2; i * i < MAXV; i++) {
12+
if (isPrime[i]) {
13+
for (int j = i * i; j < MAXV; j += i) {
14+
isPrime[j] = false;
15+
}
16+
}
17+
}
18+
}
19+
20+
class SegmentTree {
21+
int[] sum, max;
22+
int size;
23+
24+
SegmentTree(int n) {
25+
size = 1;
26+
while (size < n + 2)
27+
size <<= 1;
28+
sum = new int[2 * size];
29+
max = new int[2 * size];
30+
}
31+
32+
void pointAdd(int pos, int delta) {
33+
int i = pos + size;
34+
sum[i] += delta;
35+
max[i] = Math.max(sum[i], 0);
36+
for (i >>= 1; i > 0; i >>= 1) {
37+
sum[i] = sum[2 * i] + sum[2 * i + 1];
38+
max[i] = Math.max(max[2 * i], sum[2 * i] + max[2 * i + 1]);
39+
}
40+
}
41+
42+
void applyRange(int from, int to, int delta) {
43+
if (from + 1 <= to) {
44+
pointAdd(from + 1, delta);
45+
pointAdd(to + 1, -delta);
46+
}
47+
}
48+
49+
int getMax() {
50+
return max[1];
51+
}
52+
}
53+
54+
public int[] maximumCount(int[] nums, int[][] queries) {
55+
int n = nums.length;
56+
57+
SegmentTree segTree = new SegmentTree(n);
58+
Map<Integer, TreeSet<Integer>> primeIndices = new HashMap<>();
59+
int distinct = 0;
60+
61+
// Initialize
62+
for (int i = 0; i < n; i++) {
63+
int v = nums[i];
64+
if (isPrime[v]) {
65+
primeIndices.computeIfAbsent(v, x -> new TreeSet<>()).add(i);
66+
}
67+
}
68+
69+
for (int p : primeIndices.keySet()) {
70+
TreeSet<Integer> set = primeIndices.get(p);
71+
int first = set.first(), last = set.last();
72+
segTree.applyRange(first, last, +1);
73+
distinct++;
74+
}
75+
76+
int[] result = new int[queries.length];
77+
for (int q = 0; q < queries.length; q++) {
78+
int idx = queries[q][0], val = queries[q][1];
79+
int old = nums[idx];
80+
81+
if (old == val) {
82+
result[q] = distinct + segTree.getMax();
83+
continue;
84+
}
85+
86+
// Remove old value
87+
if (isPrime[old]) {
88+
TreeSet<Integer> set = primeIndices.get(old);
89+
int f1 = set.first(), l1 = set.last();
90+
segTree.applyRange(f1, l1, -1);
91+
set.remove(idx);
92+
if (set.isEmpty()) {
93+
primeIndices.remove(old);
94+
distinct--;
95+
} else {
96+
int f2 = set.first(), l2 = set.last();
97+
segTree.applyRange(f2, l2, +1);
98+
}
99+
}
100+
101+
// Add new value
102+
if (isPrime[val]) {
103+
if (!primeIndices.containsKey(val)) {
104+
TreeSet<Integer> set = new TreeSet<>();
105+
set.add(idx);
106+
primeIndices.put(val, set);
107+
segTree.applyRange(idx, idx, +1);
108+
distinct++;
109+
} else {
110+
TreeSet<Integer> set = primeIndices.get(val);
111+
int f1 = set.first(), l1 = set.last();
112+
segTree.applyRange(f1, l1, -1);
113+
set.add(idx);
114+
int f2 = set.first(), l2 = set.last();
115+
segTree.applyRange(f2, l2, +1);
116+
}
117+
}
118+
119+
nums[idx] = val;
120+
result[q] = distinct + segTree.getMax();
121+
}
122+
123+
return result;
124+
}
125+
}

‎solutions/3500-3599/3585.find-weighted-median-node-in-tree/Solution.java‎

Lines changed: 125 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,125 @@
1+
import java.util.*;
2+
3+
public class Solution {
4+
List<int[]>[] adj;
5+
long[] depth;
6+
long[] dist;
7+
int LOG = 20;
8+
int[][] up;
9+
10+
public int[] findMedian(int n, int[][] edges, int[][] queries) {
11+
adj = new ArrayList[n + 1];
12+
depth = new long[n + 1];
13+
dist = new long[n + 1];
14+
up = new int[n + 1][LOG];
15+
for (int i = 0; i <= n; i++)
16+
adj[i] = new ArrayList<>();
17+
18+
for (int[] e : edges) {
19+
int u = e[0] + 1;
20+
int v = e[1] + 1;
21+
int w = e[2];
22+
adj[u].add(new int[] { v, w });
23+
adj[v].add(new int[] { u, w });
24+
}
25+
26+
depth[1] = 1;
27+
dfs(1, 0);
28+
29+
for (int j = 1; j < LOG; j++) {
30+
for (int i = 1; i <= n; i++) {
31+
int p = up[i][j - 1];
32+
up[i][j] = (p != 0) ? up[p][j - 1] : 0;
33+
}
34+
}
35+
36+
int q = queries.length;
37+
int[] ans = new int[q];
38+
for (int i = 0; i < q; i++) {
39+
int u = queries[i][0] + 1;
40+
int v = queries[i][1] + 1;
41+
int lca = LCA(u, v);
42+
43+
long totalW = dist[u] + dist[v] - 2 * dist[lca];
44+
long tar = (totalW + 1) / 2;
45+
long len = depth[u] + depth[v] - 2 * depth[lca];
46+
47+
long low = 0, high = len;
48+
int x = v;
49+
50+
while (low <= high) {
51+
long mid = (low + high) / 2;
52+
int mNode = getMNode(u, v, (int) mid, lca);
53+
if (mNode == -1)
54+
break;
55+
56+
long weight = dist[u] + dist[mNode] - 2 * dist[LCA(u, mNode)];
57+
if (weight >= tar) {
58+
x = mNode;
59+
high = mid - 1;
60+
} else {
61+
low = mid + 1;
62+
}
63+
}
64+
65+
ans[i] = x - 1;
66+
}
67+
return ans;
68+
}
69+
70+
void dfs(int node, int par) {
71+
up[node][0] = par;
72+
for (int[] e : adj[node]) {
73+
int nxt = e[0];
74+
int w = e[1];
75+
if (nxt != par) {
76+
depth[nxt] = depth[node] + 1;
77+
dist[nxt] = dist[node] + w;
78+
dfs(nxt, node);
79+
}
80+
}
81+
}
82+
83+
int lift(int node, int k) {
84+
for (int j = LOG - 1; j >= 0; j--) {
85+
if (((k >> j) & 1) == 1) {
86+
node = up[node][j];
87+
if (node == 0)
88+
return -1;
89+
}
90+
}
91+
return node;
92+
}
93+
94+
int LCA(int u, int v) {
95+
if (depth[u] < depth[v]) {
96+
int tmp = u;
97+
u = v;
98+
v = tmp;
99+
}
100+
int diff = (int) (depth[u] - depth[v]);
101+
u = lift(u, diff);
102+
if (u == v)
103+
return u;
104+
for (int j = LOG - 1; j >= 0; j--) {
105+
if (up[u][j] != 0 && up[u][j] != up[v][j]) {
106+
u = up[u][j];
107+
v = up[v][j];
108+
}
109+
}
110+
return up[u][0];
111+
}
112+
113+
int getMNode(int u, int v, int k, int lca) {
114+
int distU = (int) (depth[u] - depth[lca]);
115+
if (k <= distU) {
116+
return lift(u, k);
117+
} else {
118+
int distV = (int) (depth[v] - depth[lca]);
119+
int rem = distV - (k - distU);
120+
if (rem < 0)
121+
return -1;
122+
return lift(v, rem);
123+
}
124+
}
125+
}

‎solutions/3500-3599/3588.find-maximum-area-of-a-triangle/Solution.java‎

Lines changed: 62 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,62 @@
1+
import java.util.*;
2+
3+
class Solution {
4+
public long maxArea(int[][] coords) {
5+
int n = coords.length;
6+
7+
Map<Integer, TreeSet<Integer>> xMap = new HashMap<>();
8+
Map<Integer, TreeSet<Integer>> yMap = new HashMap<>();
9+
TreeSet<Integer> allX = new TreeSet<>();
10+
TreeSet<Integer> allY = new TreeSet<>();
11+
12+
for (int[] coord : coords) {
13+
int x = coord[0], y = coord[1];
14+
xMap.computeIfAbsent(x, k -> new TreeSet<>()).add(y);
15+
yMap.computeIfAbsent(y, k -> new TreeSet<>()).add(x);
16+
allX.add(x);
17+
allY.add(y);
18+
}
19+
20+
long ans = Long.MIN_VALUE;
21+
22+
for (Map.Entry<Integer, TreeSet<Integer>> entry : xMap.entrySet()) {
23+
int x = entry.getKey();
24+
TreeSet<Integer> ySet = entry.getValue();
25+
if (ySet.size() < 2)
26+
continue;
27+
28+
int minY = ySet.first();
29+
int maxY = ySet.last();
30+
int base = maxY - minY;
31+
32+
int minX = allX.first();
33+
int maxX = allX.last();
34+
35+
if (minX != x)
36+
ans = Math.max(ans, 1L * Math.abs(x - minX) * base);
37+
if (maxX != x)
38+
ans = Math.max(ans, 1L * Math.abs(x - maxX) * base);
39+
}
40+
41+
for (Map.Entry<Integer, TreeSet<Integer>> entry : yMap.entrySet()) {
42+
int y = entry.getKey();
43+
TreeSet<Integer> xSet = entry.getValue();
44+
if (xSet.size() < 2)
45+
continue;
46+
47+
int minX = xSet.first();
48+
int maxX = xSet.last();
49+
int base = maxX - minX;
50+
51+
int minY = allY.first();
52+
int maxY = allY.last();
53+
54+
if (minY != y)
55+
ans = Math.max(ans, 1L * Math.abs(y - minY) * base);
56+
if (maxY != y)
57+
ans = Math.max(ans, 1L * Math.abs(y - maxY) * base);
58+
}
59+
60+
return ans == Long.MIN_VALUE ? -1 : ans;
61+
}
62+
}

0 commit comments

Comments
 (0)