Skip to content

Commit b6cbefb

Browse files
javadevjavadev
committed
Improved tasks 3659, 3660, 3661
1 parent f4ea973 commit b6cbefb

File tree

3 files changed

+98
-185
lines changed

3 files changed

+98
-185
lines changed

‎src/main/kotlin/g3601_3700/s3659_partition_array_into_k_distinct_groups/Solution.kt‎

Lines changed: 14 additions & 6 deletions
Original file line numberDiff line numberDiff line change
@@ -1,18 +1,26 @@
11
package g3601_3700.s3659_partition_array_into_k_distinct_groups
22

3-
// #Medium #Weekly_Contest_464 #2025_08_25_Time_96_ms_(100.00%)_Space_93.60_MB_(100.00%)
3+
// #Medium #Weekly_Contest_464 #2025_08_29_Time_6_ms_(100.00%)_Space_80.65_MB_(71.43%)
4+
5+
import kotlin.math.max
46

57
class Solution {
68
fun partitionArray(nums: IntArray, k: Int): Boolean {
7-
val mpp = HashMap<Int, Int>()
9+
val n = nums.size
10+
if (n % k != 0) {
11+
return false
12+
}
13+
var max = 0
814
for (x in nums) {
9-
mpp.put(x, mpp.getOrDefault(x, 0) + 1)
15+
max = max(max, x)
1016
}
11-
for (count in mpp.values) {
12-
if (count > nums.size / k) {
17+
val count = IntArray(max + 1)
18+
val limit = n / k
19+
for (x in nums) {
20+
if (++count[x] > limit) {
1321
return false
1422
}
1523
}
16-
return nums.size % k == 0
24+
return true
1725
}
1826
}

‎src/main/kotlin/g3601_3700/s3660_jump_game_ix/Solution.kt‎

Lines changed: 13 additions & 77 deletions
Original file line numberDiff line numberDiff line change
@@ -1,89 +1,25 @@
11
package g3601_3700.s3660_jump_game_ix
22

3-
// #Medium #Weekly_Contest_464 #2025_08_25_Time_205_ms_(100.00%)_Space_89.04_MB_(100.00%)
3+
// #Medium #Weekly_Contest_464 #2025_08_29_Time_5_ms_(100.00%)_Space_83.83_MB_(92.31%)
44

5-
import java.util.ArrayDeque
65
import kotlin.math.max
6+
import kotlin.math.min
77

88
class Solution {
99
fun maxValue(nums: IntArray): IntArray {
10-
val n = nums.size
11-
val st = ArrayDeque<Int>()
12-
val uf = UnionFind(n)
13-
for (i in 0..<n) {
14-
var prev = i
15-
if (st.isNotEmpty()) {
16-
prev = st.peek()!!
17-
}
18-
while (st.isNotEmpty() && 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 (i in n - 1 downTo 0) {
29-
var prev = i
30-
if (st.isNotEmpty()) {
31-
prev = st.peek()!!
32-
}
33-
while (st.isNotEmpty() && 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-
val map = HashMap<Int, Int>()
43-
for (i in 0..<n) {
44-
val root = uf.find(i)
45-
map.put(root, max(map.getOrDefault(root, Int.Companion.MIN_VALUE), nums[i]))
10+
val f = IntArray(nums.size)
11+
var cur = 0
12+
for (i in nums.indices) {
13+
cur = max(cur, nums[i])
14+
f[i] = cur
4615
}
47-
val ans = IntArray(n)
48-
for (i in 0..<n) {
49-
ans[i] = map[uf.find(i)]!!
50-
}
51-
return ans
52-
}
53-
54-
private class UnionFind(n: Int) {
55-
var par: IntArray = IntArray(n)
56-
var rank: IntArray = IntArray(n)
57-
58-
init {
59-
for (i in 0..<n) {
60-
par[i] = i
61-
}
62-
}
63-
64-
fun find(x: Int): Int {
65-
if (par[x] != x) {
66-
par[x] = find(par[x])
67-
}
68-
return par[x]
69-
}
70-
71-
fun union(x: Int, y: Int) {
72-
var x = x
73-
var y = 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]++
16+
var min = nums[nums.size - 1]
17+
for (i in nums.size - 2 downTo 0) {
18+
if (f[i] > min) {
19+
f[i] = max(f[i], f[i + 1])
8620
}
21+
min = min(min, nums[i])
8722
}
23+
return f
8824
}
8925
}

‎src/main/kotlin/g3601_3700/s3661_maximum_walls_destroyed_by_robots/Solution.kt‎

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

3-
// #Hard #Weekly_Contest_464 #2025_08_25_Time_233_ms_(100.00%)_Space_75.24_MB_(100.00%)
3+
// #Hard #Weekly_Contest_464 #2025_08_29_Time_146_ms_(100.00%)_Space_93.92_MB_(16.67%)
44

55
import kotlin.math.max
66
import kotlin.math.min
77

88
class Solution {
99
fun maxWalls(robots: IntArray, distance: IntArray, walls: IntArray): Int {
10-
val n = robots.size
11-
// Pair robots with distances and sort
12-
val rpair = Array<IntArray>(n) { IntArray(2) }
13-
for (i in 0..<n) {
14-
rpair[i][0] = robots[i]
15-
rpair[i][1] = distance[i]
16-
}
17-
rpair.sortWith { a: IntArray, b: IntArray -> a[0].compareTo(b[0]) }
18-
val r = IntArray(n)
19-
val d = IntArray(n)
20-
for (i in 0..<n) {
21-
r[i] = rpair[i][0]
22-
d[i] = rpair[i][1]
23-
}
24-
walls.sort()
25-
// Count walls at robot positions
26-
var base = 0
27-
for (i in 0..<n) {
28-
val idx = walls.binarySearch(r[i])
29-
if (idx >= 0) {
30-
base++
31-
}
32-
}
33-
// Tail walls
34-
val leftTail = countRange(walls, r[0].toLong() - d[0], r[0] - 1L)
35-
val rightTail = countRange(walls, r[n - 1] + 1L, r[n - 1].toLong() + d[n - 1])
36-
// Precompute segment ranges
37-
val segs = n - 1
38-
val max = max(0, segs)
39-
val a = IntArray(max)
40-
val b = IntArray(max)
41-
val c = IntArray(max)
42-
for (i in 0..<segs) {
43-
val segL = r[i] + 1
44-
val segR = r[i + 1] - 1
45-
if (segL > segR) {
46-
c[i] = 0
47-
b[i] = c[i]
48-
a[i] = b[i]
49-
continue
50-
}
51-
val aHigh = min(segR, r[i] + d[i])
52-
a[i] = countRange(walls, segL.toLong(), aHigh.toLong())
53-
val bLow = max(segL, r[i + 1] - d[i + 1])
54-
b[i] = countRange(walls, bLow.toLong(), segR.toLong())
55-
val cLow = max(segL, r[i + 1] - d[i + 1])
56-
val cHigh = min(segR, r[i] + d[i])
57-
c[i] = countRange(walls, cLow.toLong(), cHigh.toLong())
58-
}
59-
val dp = Array<IntArray>(n) { IntArray(2) }
60-
dp[0].fill(Int.Companion.MIN_VALUE / 4)
61-
// first fires left
62-
dp[0][0] = base + leftTail
63-
// first fires right
64-
dp[0][1] = base
65-
for (i in 0..<n - 1) {
66-
dp[i + 1].fill(Int.Companion.MIN_VALUE / 4)
67-
for (choice in 0..1) {
68-
val cur = dp[i][choice]
69-
if (cur < 0) {
10+
if (robots.size == 1) {
11+
var a = 0
12+
var b = 0
13+
for (wall in walls) {
14+
if (wall < robots[0] - distance[0] || wall > robots[0] + distance[0]) {
7015
continue
7116
}
72-
val addIfNextLeft = if (choice == 1) a[i] + b[i] - c[i] else b[i]
73-
dp[i + 1][0] = max(dp[i + 1][0], cur + addIfNextLeft)
74-
val addIfNextRight = if (choice == 1) a[i] else 0
75-
dp[i + 1][1] = max(dp[i + 1][1], cur + addIfNextRight)
17+
if (wall < robots[0]) {
18+
a++
19+
} else if (wall > robots[0]) {
20+
b++
21+
} else {
22+
a++
23+
b++
24+
}
7625
}
26+
return max(a, b)
7727
}
78-
val res: Int = if (n == 1) {
79-
max(dp[0][0], dp[0][1] + rightTail)
80-
} else {
81-
max(dp[n - 1][0], dp[n - 1][1] + rightTail)
28+
val arr = Array<IntArray>(robots.size) { i -> intArrayOf(robots[i], distance[i]) }
29+
arr.sortWith { a: IntArray, b: IntArray -> a[0] - b[0] }
30+
walls.sort()
31+
var a = 0
32+
var b = 0
33+
var i = 0
34+
var j = 0
35+
while (i < walls.size && walls[i] < arr[j][0] - arr[j][1]) {
36+
i++
8237
}
83-
return res
84-
}
85-
86-
private fun countRange(arr: IntArray, l: Long, r: Long): Int {
87-
if (l > r || arr.isEmpty()) {
88-
return 0
38+
while (i < walls.size && walls[i] <= arr[j][0]) {
39+
a++
40+
i++
8941
}
90-
val leftIdx = lowerBound(arr, l)
91-
val rightIdx = upperBound(arr, r)
92-
return max(0, rightIdx - leftIdx)
93-
}
94-
95-
private fun lowerBound(a: IntArray, x: Long): Int {
96-
var l = 0
97-
var r = a.size
98-
while (l < r) {
99-
val m = (l + r) ushr 1
100-
if (a[m] < x) {
101-
l = m + 1
102-
} else {
103-
r = m
104-
}
42+
if (i > 0 && walls[i - 1] == arr[j][0]) {
43+
i--
10544
}
106-
return l
107-
}
108-
109-
private fun upperBound(a: IntArray, x: Long): Int {
110-
var l = 0
111-
var r = a.size
112-
while (l < r) {
113-
val m = (l + r) ushr 1
114-
if (a[m] <= x) {
115-
l = m + 1
45+
while (i < walls.size && walls[i] <= arr[j][0] + arr[j][1] && walls[i] < arr[j + 1][0]) {
46+
b++
47+
i++
48+
}
49+
j++
50+
while (j < arr.size) {
51+
var l1 = 0
52+
var k = i
53+
while (k < walls.size && walls[k] < arr[j][0] - arr[j][1]) {
54+
k++
55+
}
56+
while (k < walls.size && walls[k] <= arr[j][0]) {
57+
l1++
58+
k++
59+
}
60+
val nextI = k
61+
var l2 = l1
62+
k = i - 1
63+
while (k >= 0 && walls[k] > arr[j - 1][0] && walls[k] >= arr[j][0] - arr[j][1]) {
64+
l2++
65+
k--
66+
}
67+
val aNext = max(a + l2, b + l1)
68+
var r = 0
69+
val lim =
70+
if (j < arr.size - 1) {
71+
min(arr[j + 1][0], arr[j][0] + arr[j][1] + 1)
72+
} else {
73+
arr[j][0] + arr[j][1] + 1
74+
}
75+
i = if (nextI > 0 && walls[nextI - 1] == arr[j][0]) {
76+
nextI - 1
11677
} else {
117-
r = m
78+
nextI
79+
}
80+
while (i < walls.size && walls[i] < lim) {
81+
r++
82+
i++
11883
}
84+
j++
85+
val bNext = max(a, b) + r
86+
a = aNext
87+
b = bNext
11988
}
120-
return l
89+
return max(a, b)
12190
}
12291
}

0 commit comments

Comments
 (0)