2021. 5. 16. 12:28ใ๐ฑ Algorithm/Else
๋ฌธ์ ์ค๋ช
์์ธ์์ ์ผ์ง์ ๋ชจ์์ ์๋ก์ด ๋๋ก๊ฐ ์๊ฒผ์ต๋๋ค. ์๋ก์ด ๋๋ก์ ์ ์ฒด ๊ธธ์ด๋ l์ด๊ณ ๋๋ก์๋ ์ด n๊ฐ์ ๊ฐ๋ก๋ฑ์ด ์ธ์์ก์ต๋๋ค. ์ด ๋๋ก์ ๋ชจ๋ ๊ฐ๋ก๋ฑ์ ์ ๊ตฌ๋ฅผ ์ฌ์ ๋ฌ๋ ค๊ณ ํฉ๋๋ค. ์ ๊ตฌ๋ฅผ ์ ํํ๋ ๊ธฐ์ค์ ๋ค์๊ณผ ๊ฐ์ต๋๋ค.
- ์ ๊ตฌ๋ ๊ธธ์ ์ข์ธก, ์ฐ์ธก ๋ฐฉํฅ์ผ๋ก ๊ฐ๊ฐ d ๊ธธ์ด๋งํผ ๊ธธ์ ๋ฐํ ์ ์๊ณ , d๋ ์์ฐ์์ ๋๋ค.
- ๋ชจ๋ ๊ฐ๋ก๋ฑ์๋ ๊ฐ์ ์ข ๋ฅ(d ๊ฐ์ด ๊ฐ์)์ ์ ๊ตฌ๋ฅผ ๋ฌ์์ผ ํฉ๋๋ค.
- ์์ ์ ์ํ์ฌ ๋๋ก์์ ์ด๋์ด ๋ถ๋ถ์ด ์์ด์๋ ์ ๋ฉ๋๋ค.
์ด๋, d ๊ฐ์ด ์ถฉ๋ถํ ํฌ๋ค๋ฉด ์ ์ฒด ๋๋ก๋ฅผ ๋ฐ๊ฒ ๋น์ถ ์ ์์ง๋ง, d ๊ฐ์ด ์์์ง๋ค๋ฉด ๋๋ก ์์ ๋น์ด ๋ฟ์ง ์๋ ๋ถ๋ถ์ด ์๊ธธ ์๋ ์์ต๋๋ค. ๋ฐ๋ผ์, ๋๋ก ์์ ์ด๋์ด ๋ถ๋ถ์ด ์๊ธฐ์ง ์๋๋ก ํ๋ d ๊ฐ ์ค ์ต์๊ฐ์ ๊ตฌํ๋ ค๊ณ ํฉ๋๋ค. ์ ์ฒด ๋๋ก์ ๊ธธ์ด l, ๊ฐ๋ก๋ฑ์ด ์ธ์์ ธ ์๋ ์์น๊ฐ ๋ค์ด์๋ ๋ฐฐ์ด v๊ฐ ๋งค๊ฐ๋ณ์๋ก ์ฃผ์ด์ง ๋, ์์ ๋ชจ๋ ์กฐ๊ฑด์ ๋ง์กฑํ๋ d ์ ์ต์๊ฐ์ return ํ๋๋ก solution ํจ์๋ฅผ ์์ฑํด์ฃผ์ธ์.
์ ํ์ฌํญ
- l์ 1 ์ด์ 1,000,000,000 ์ดํ์ ์์ฐ์์ ๋๋ค.
- v์๋ ๊ฐ๋ก๋ฑ์ ์์น์ ๋ณด๊ฐ ๋ค์ด์์ต๋๋ค.
- ๊ฐ๋ก๋ฑ์ ์์น๋ 0 ์ด์ l ์ดํ์ ์ ์์ด๋ฉฐ, ๊ฐ์ ์์น์ 2๊ฐ ์ด์์ ๊ฐ๋ก๋ฑ์ด ์๋ ๊ฒฝ์ฐ๋ ์ฃผ์ด์ง์ง ์์ต๋๋ค.
- ๊ฐ๋ก๋ฑ์ ๊ฐ์๋ 1์ด์ 1,000 ์ดํ์ ์์ฐ์์ ๋๋ค.
์ ์ถ๋ ฅ ์
l | v | output |
15 | [15,5,3,7,9,14,0] | 3 |
5 | [2,5] | 2 |
์ ๊ทผ
- ๊ธฐ๋ณธ์ ์ผ๋ก ์ด์งํ์์ ์์์ผ๋ก ์ ๊ทผ
- ๊ฐ๋ก๋ฑ ๊ฐ์ distance๋ฅผ distance_list์ append
- distance ๊ฐ์ ์ธ์ ํ ๊ฐ๋ก๋ฑ ๊ฐ ๊ฑฐ๋ฆฌ๋ฅผ 2๋ฑ๋ถํ ๊ฐ์ผ๋ก ๊ตฌํ๋ค. (๊ฑฐ๋ฆฌ๊ฐ ํ์์ผ ๊ฒฝ์ฐ +1)
def solution(road_length, locations):
locations.sort()
print(locations)
distance_list = [] # ๊ฐ๋ก๋ฑ ์ฌ์ด์ ๊ฑฐ๋ฆฌ
if 0 < locations[0]:
distance_list.append(locations[0])
for x, y in zip(locations[1:], locations[:-1]):
if (x - y) % 2 == 0:
distance = (x - y) // 2
else:
distance = (x - y) // 2 + 1
distance_list.append(distance)
if road_length > locations[-1]:
distance_list.append(road_length - locations[-1])
return max(distance_list)
์ฃผ์ํ ์
- locations[0], locations[-1]์ด ๊ผญ road์ ์์์ ๊ณผ ๋์ ์ ์๋ค๋ ์๊ฐ์ด ํจ์ ์ผ๋ก ์ด์ด์ง๋ค.
- locations[0], locations[-1] ์ ์ฒซ๋ฒ์งธ์ ๋ง์ง๋ง ๊ฐ๋ก๋ฑ์ผ ๋ฟ์ด์ง, ์ด๋ค์ ์์น๊ฐ ๊ผญ road์ ์์์ ๊ณผ ๋์ ์ ์์ ํ์๋ ์๋ค.
ํ์ด
- distance๋ฅผ ๊ฐ์ฅ ํฌ๊ฒ ์ก์ distance_list์ ๋ฃ์ผ๋ฉด, ๋ชจ๋ ๊ฑฐ๋ฆฌ๋ฅผ ๋ค ๋น์ถ ์ ์๋ค.
- ํ์ง๋ง ๊ตฌํ๊ณ ์ ํ๋ ๊ฐ์, ๋ชจ๋ ๊ฑฐ๋ฆฌ๋ฅผ ๋ค ๋น์ถ ์ ์๋ distance ์ค ๊ฐ์ฅ ์์ ๊ฐ์ ๊ตฌํ๋ ๊ฒ
- distance_list์ ๊ฐ๋ก๋ฑ ์ฌ์ด๋ฅผ ๋ค ์ปค๋ฒํ ์ ์๋ distance์ ๋ฒ์๊ฐ ๋ค์ด์๋ค. => ์ด์ค์์ ์ต์๊ฐ(min(distance_list))์ ๊ตฌํ๋ฉด, ์ด๋ค ๊ณณ์ ์ปค๋ฒํ๊ณ , ๋ค๋ฅธ ๊ณณ์ ์ปค๋ฒํ ์ ์๋ ๊ฒฝ์ฐ๊ฐ ๋ฐ์ํ๋ค.
- ๊ทธ๋ ๊ธฐ ๋๋ฌธ์ d_list์ ๊ฐ ์ค ๊ฐ์ฅ ํฐ ๊ฐ์ ์ ํํ๋ ๊ฒ์ด ์ณ๋ค (๊ฐ์ฅ ํฐ ๊ฐ: ๊ฐ๋ก๋ฑ ์ฌ์ด๊ฐ ๊ฐ์ฅ ๋ง์ด ๋จ์ด์ ธ ์๋ ๊ฒฝ์ฐ์ distance)
๋ค๋ฅธ ํ์ด : parametric search
def solution(road_length: int, locations: list):
locations.sort()
left = 1
right = road_length
while left <= right:
# mid๋ฅผ ๋น์ ๋ฒ์๋ก ์ ์ => ์ ์ฐจ ์ค์ฌ๋๊ฐ๋ค ์ด์ง ํ์ ์ฒ๋ผ
mid = (left + right) // 2
if is_possible(road_length, locations, mid): # True ์ผ ๋
right = mid - 1
else:
left = mid + 1
return right + 1
def is_possible(road_length, locations, light_range):
if (0 < locations[0] - light_range) or (locations[-1] + light_range < road_length):
return False
for i in range(1, len(locations)):
if locations[i - 1] + light_range < locations[i] - light_range: # ๊ฐ๋ก๋ฑ ๊ฐ ๊ณต๋ฐฑ์ด ์๊ธฐ๋ ๊ฒฝ์ฐ
return False
return True
'๐ฑ Algorithm > Else' ์นดํ ๊ณ ๋ฆฌ์ ๋ค๋ฅธ ๊ธ
๋ฐฑ์ค 10830 ํ์ด์ฌ (0) | 2021.12.26 |
---|---|
ํ๋ก๊ทธ๋๋จธ์ค [lv1] ๋ก๋์์ต๊ณ ์์์์ต์ ์์ ํ์ด์ฌ (0) | 2021.05.18 |
ํ๋ก๊ทธ๋๋จธ์ค [lv4] N-Queen ํ์ด์ฌ (0) | 2021.05.16 |
ํ๋ก๊ทธ๋๋จธ์ค [lv2] ๊ฐ์ฅ ํฐ ์ ์ฌ๊ฐํ ํ์ด์ฌ (0) | 2021.05.15 |
ํ๋ก๊ทธ๋๋จธ์ค [lv2] ๊ดํธ๋ณํ ํ์ด์ฌ (0) | 2021.04.25 |