Skip to content

Commit d20f5be

Browse files
javadevjavadev
committed
Improved task 3661
1 parent bd13d7d commit d20f5be

File tree

2 files changed

+110
-68
lines changed

2 files changed

+110
-68
lines changed

‎README.md‎

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -2088,7 +2088,7 @@
20882088

20892089
| # | Title | Difficulty | Tag | Time, ms | Time, %
20902090
|------|----------------|-------------|-------------|----------|--------
2091-
| 3661 |[Maximum Walls Destroyed by Robots](src/main/kotlin/g3601_3700/s3661_maximum_walls_destroyed_by_robots)| Hard | Weekly_Contest_464 | 146 | 100.00
2091+
| 3661 |[Maximum Walls Destroyed by Robots](src/main/kotlin/g3601_3700/s3661_maximum_walls_destroyed_by_robots)| Hard | Weekly_Contest_464 | 147 | 100.00
20922092
| 3660 |[Jump Game IX](src/main/kotlin/g3601_3700/s3660_jump_game_ix)| Medium | Weekly_Contest_464 | 5 | 100.00
20932093
| 3659 |[Partition Array Into K-Distinct Groups](src/main/kotlin/g3601_3700/s3659_partition_array_into_k_distinct_groups)| Medium | Weekly_Contest_464 | 6 | 100.00
20942094
| 3658 |[GCD of Odd and Even Sums](src/main/kotlin/g3601_3700/s3658_gcd_of_odd_and_even_sums)| Easy | Weekly_Contest_464 | 0 | 100.00

‎src/main/kotlin/g3601_3700/s3661_maximum_walls_destroyed_by_robots/readme.md‎

Lines changed: 109 additions & 67 deletions
Original file line numberDiff line numberDiff line change
@@ -73,85 +73,127 @@ import kotlin.math.min
7373
class Solution {
7474
fun maxWalls(robots: IntArray, distance: IntArray, walls: IntArray): Int {
7575
if (robots.size == 1) {
76-
var a = 0
77-
var b = 0
78-
for (wall in walls) {
79-
if (wall < robots[0] - distance[0] || wall > robots[0] + distance[0]) {
80-
continue
81-
}
82-
if (wall < robots[0]) {
83-
a++
84-
} else if (wall > robots[0]) {
85-
b++
86-
} else {
87-
a++
88-
b++
89-
}
90-
}
91-
return max(a, b)
76+
return handleSingleRobot(robots[0], distance[0], walls)
9277
}
93-
val arr = Array<IntArray>(robots.size) { i -> intArrayOf(robots[i], distance[i]) }
94-
arr.sortWith { a: IntArray, b: IntArray -> a[0] - b[0] }
78+
val arr = buildRobotArray(robots, distance)
79+
arr.sortWith { a: IntArray, b: IntArray -> if (a[0] == b[0]) (a[1] - b[1]) else (a[0] - b[0]) }
9580
walls.sort()
96-
var a = 0
97-
var b = 0
98-
var i = 0
99-
var j = 0
100-
while (i < walls.size && walls[i] < arr[j][0] - arr[j][1]) {
101-
i++
81+
return processMultipleRobots(arr, walls)
82+
}
83+
84+
private fun handleSingleRobot(robot: Int, dist: Int, walls: IntArray): Int {
85+
var left = 0
86+
var right = 0
87+
for (wall in walls) {
88+
if (wall < robot - dist || wall > robot + dist) {
89+
continue
90+
}
91+
if (wall < robot) {
92+
left++
93+
} else if (wall > robot) {
94+
right++
95+
} else {
96+
left++
97+
right++
98+
}
10299
}
103-
while (i < walls.size && walls[i] <= arr[j][0]) {
104-
a++
105-
i++
100+
return max(left, right)
101+
}
102+
103+
private fun buildRobotArray(robots: IntArray, distance: IntArray): Array<IntArray> {
104+
val arr = Array(robots.size) { IntArray(2) }
105+
for (i in robots.indices) {
106+
arr[i][0] = robots[i]
107+
arr[i][1] = distance[i]
106108
}
109+
return arr
110+
}
111+
112+
private fun processMultipleRobots(arr: Array<IntArray>, walls: IntArray): Int {
113+
var a: Int
114+
var b: Int
115+
var i = 0
116+
var j = 0
117+
i = skipWallsBeforeRange(walls, i, arr[j][0] - arr[j][1])
118+
a = countWallsUpToRobot(walls, i, arr[j][0])
119+
i += a
107120
if (i > 0 && walls[i - 1] == arr[j][0]) {
108121
i--
109122
}
110-
while (i < walls.size && walls[i] <= arr[j][0] + arr[j][1] && walls[i] < arr[j + 1][0]) {
111-
b++
112-
i++
113-
}
123+
b = countWallsInRange(walls, i, arr[j][0] + arr[j][1], arr[j + 1][0])
124+
i += b
114125
j++
115126
while (j < arr.size) {
116-
var l1 = 0
117-
var k = i
118-
while (k < walls.size && walls[k] < arr[j][0] - arr[j][1]) {
119-
k++
120-
}
121-
while (k < walls.size && walls[k] <= arr[j][0]) {
122-
l1++
123-
k++
124-
}
125-
val nextI = k
126-
var l2 = l1
127-
k = i - 1
128-
while (k >= 0 && walls[k] > arr[j - 1][0] && walls[k] >= arr[j][0] - arr[j][1]) {
129-
l2++
130-
k--
131-
}
132-
val aNext = max(a + l2, b + l1)
133-
var r = 0
134-
val lim =
135-
if (j < arr.size - 1) {
136-
min(arr[j + 1][0], arr[j][0] + arr[j][1] + 1)
137-
} else {
138-
arr[j][0] + arr[j][1] + 1
139-
}
140-
i = if (nextI > 0 && walls[nextI - 1] == arr[j][0]) {
141-
nextI - 1
142-
} else {
143-
nextI
144-
}
145-
while (i < walls.size && walls[i] < lim) {
146-
r++
147-
i++
148-
}
127+
val result = processRobotStep(arr, walls, j, i, a, b)
128+
a = result[0]
129+
b = result[1]
130+
i = result[2]
149131
j++
150-
val bNext = max(a, b) + r
151-
a = aNext
152-
b = bNext
153132
}
154133
return max(a, b)
155134
}
135+
136+
private fun skipWallsBeforeRange(walls: IntArray, i: Int, limit: Int): Int {
137+
var i = i
138+
while (i < walls.size && walls[i] < limit) {
139+
i++
140+
}
141+
return i
142+
}
143+
144+
private fun countWallsUpToRobot(walls: IntArray, i: Int, robotPos: Int): Int {
145+
var count = 0
146+
while (i + count < walls.size && walls[i + count] <= robotPos) {
147+
count++
148+
}
149+
return count
150+
}
151+
152+
private fun countWallsInRange(walls: IntArray, i: Int, maxReach: Int, nextRobot: Int): Int {
153+
var count = 0
154+
while (i + count < walls.size && walls[i + count] <= maxReach && walls[i + count] < nextRobot) {
155+
count++
156+
}
157+
return count
158+
}
159+
160+
private fun processRobotStep(arr: Array<IntArray>, walls: IntArray, j: Int, i: Int, a: Int, b: Int): IntArray {
161+
var i = i
162+
var l1 = 0
163+
var k = i
164+
while (k < walls.size && walls[k] < arr[j][0] - arr[j][1]) {
165+
k++
166+
}
167+
while (k < walls.size && walls[k] <= arr[j][0]) {
168+
l1++
169+
k++
170+
}
171+
val nextI = k
172+
var l2 = l1
173+
k = i - 1
174+
while (k >= 0 && walls[k] > arr[j - 1][0] && walls[k] >= arr[j][0] - arr[j][1]) {
175+
l2++
176+
k--
177+
}
178+
val aNext = max(a + l2, b + l1)
179+
var r = 0
180+
val lim =
181+
if (j < arr.size - 1) {
182+
min(arr[j + 1][0], arr[j][0] + arr[j][1] + 1)
183+
} else {
184+
arr[j][0] + arr[j][1] + 1
185+
}
186+
i = if (nextI > 0 && walls[nextI - 1] == arr[j][0]) {
187+
nextI - 1
188+
} else {
189+
nextI
190+
}
191+
while (i < walls.size && walls[i] < lim) {
192+
r++
193+
i++
194+
}
195+
val bNext = max(a, b) + r
196+
return intArrayOf(aNext, bNext, i)
197+
}
156198
}
157199
```

0 commit comments

Comments
 (0)