Skip to content

Commit b4f5451

Browse files
javadevjavadev
authored
Improved task 3661
1 parent cff42b2 commit b4f5451

File tree

1 file changed

+110
-68
lines changed
  • src/main/kotlin/g3601_3700/s3661_maximum_walls_destroyed_by_robots

1 file changed

+110
-68
lines changed

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

Lines changed: 110 additions & 68 deletions
Original file line numberDiff line numberDiff line change
@@ -1,91 +1,133 @@
11
package g3601_3700.s3661_maximum_walls_destroyed_by_robots
22

3-
// #Hard #Weekly_Contest_464 #2025_08_29_Time_146_ms_(100.00%)_Space_93.92_MB_(16.67%)
3+
// #Hard #Weekly_Contest_464 #2025_08_30_Time_147_ms_(100.00%)_Space_71.82_MB_(100.00%)
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 {
1010
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]) {
15-
continue
16-
}
17-
if (wall < robots[0]) {
18-
a++
19-
} else if (wall > robots[0]) {
20-
b++
21-
} else {
22-
a++
23-
b++
24-
}
25-
}
26-
return max(a, b)
11+
return handleSingleRobot(robots[0], distance[0], walls)
2712
}
28-
val arr = Array<IntArray>(robots.size) { i -> intArrayOf(robots[i], distance[i]) }
29-
arr.sortWith { a: IntArray, b: IntArray -> a[0] - b[0] }
13+
val arr = buildRobotArray(robots, distance)
14+
arr.sortWith { a: IntArray, b: IntArray -> if (a[0] == b[0]) (a[1] - b[1]) else (a[0] - b[0]) }
3015
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++
16+
return processMultipleRobots(arr, walls)
17+
}
18+
19+
private fun handleSingleRobot(robot: Int, dist: Int, walls: IntArray): Int {
20+
var left = 0
21+
var right = 0
22+
for (wall in walls) {
23+
if (wall < robot - dist || wall > robot + dist) {
24+
continue
25+
}
26+
if (wall < robot) {
27+
left++
28+
} else if (wall > robot) {
29+
right++
30+
} else {
31+
left++
32+
right++
33+
}
3734
}
38-
while (i < walls.size && walls[i] <= arr[j][0]) {
39-
a++
40-
i++
35+
return max(left, right)
36+
}
37+
38+
private fun buildRobotArray(robots: IntArray, distance: IntArray): Array<IntArray> {
39+
val arr = Array(robots.size) { IntArray(2) }
40+
for (i in robots.indices) {
41+
arr[i][0] = robots[i]
42+
arr[i][1] = distance[i]
4143
}
44+
return arr
45+
}
46+
47+
private fun processMultipleRobots(arr: Array<IntArray>, walls: IntArray): Int {
48+
var a: Int
49+
var b: Int
50+
var i = 0
51+
var j = 0
52+
i = skipWallsBeforeRange(walls, i, arr[j][0] - arr[j][1])
53+
a = countWallsUpToRobot(walls, i, arr[j][0])
54+
i += a
4255
if (i > 0 && walls[i - 1] == arr[j][0]) {
4356
i--
4457
}
45-
while (i < walls.size && walls[i] <= arr[j][0] + arr[j][1] && walls[i] < arr[j + 1][0]) {
46-
b++
47-
i++
48-
}
58+
b = countWallsInRange(walls, i, arr[j][0] + arr[j][1], arr[j + 1][0])
59+
i += b
4960
j++
5061
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
77-
} else {
78-
nextI
79-
}
80-
while (i < walls.size && walls[i] < lim) {
81-
r++
82-
i++
83-
}
62+
val result = processRobotStep(arr, walls, j, i, a, b)
63+
a = result[0]
64+
b = result[1]
65+
i = result[2]
8466
j++
85-
val bNext = max(a, b) + r
86-
a = aNext
87-
b = bNext
8867
}
8968
return max(a, b)
9069
}
70+
71+
private fun skipWallsBeforeRange(walls: IntArray, i: Int, limit: Int): Int {
72+
var i = i
73+
while (i < walls.size && walls[i] < limit) {
74+
i++
75+
}
76+
return i
77+
}
78+
79+
private fun countWallsUpToRobot(walls: IntArray, i: Int, robotPos: Int): Int {
80+
var count = 0
81+
while (i + count < walls.size && walls[i + count] <= robotPos) {
82+
count++
83+
}
84+
return count
85+
}
86+
87+
private fun countWallsInRange(walls: IntArray, i: Int, maxReach: Int, nextRobot: Int): Int {
88+
var count = 0
89+
while (i + count < walls.size && walls[i + count] <= maxReach && walls[i + count] < nextRobot) {
90+
count++
91+
}
92+
return count
93+
}
94+
95+
private fun processRobotStep(arr: Array<IntArray>, walls: IntArray, j: Int, i: Int, a: Int, b: Int): IntArray {
96+
var i = i
97+
var l1 = 0
98+
var k = i
99+
while (k < walls.size && walls[k] < arr[j][0] - arr[j][1]) {
100+
k++
101+
}
102+
while (k < walls.size && walls[k] <= arr[j][0]) {
103+
l1++
104+
k++
105+
}
106+
val nextI = k
107+
var l2 = l1
108+
k = i - 1
109+
while (k >= 0 && walls[k] > arr[j - 1][0] && walls[k] >= arr[j][0] - arr[j][1]) {
110+
l2++
111+
k--
112+
}
113+
val aNext = max(a + l2, b + l1)
114+
var r = 0
115+
val lim =
116+
if (j < arr.size - 1) {
117+
min(arr[j + 1][0], arr[j][0] + arr[j][1] + 1)
118+
} else {
119+
arr[j][0] + arr[j][1] + 1
120+
}
121+
i = if (nextI > 0 && walls[nextI - 1] == arr[j][0]) {
122+
nextI - 1
123+
} else {
124+
nextI
125+
}
126+
while (i < walls.size && walls[i] < lim) {
127+
r++
128+
i++
129+
}
130+
val bNext = max(a, b) + r
131+
return intArrayOf(aNext, bNext, i)
132+
}
91133
}

0 commit comments

Comments
 (0)