๐ ๋ฌธ์ ํ์ํ๊ธฐ
- ๊ธธ์ด N(1 ≤ N ≤ 100,000)์ ๊ตด๋ค๋ฆฌ๊ฐ ์์
- ๊ตด๋ค๋ฆฌ์ ๋์ด๊ฐ ๊ฐ์ ๊ฐ๋ก๋ฑ M(1 ≤ M ≤ N)๊ฐ๋ฅผ ์์น x๋ค์ ๊ฐ๊ฐ ์ค์น
- ๊ฐ ๊ฐ๋ก๋ฑ์ ์ ํด์ง ๋์ด๋งํผ([x-H ~ x+H]๋งํผ) ์ฃผ์๋ฅผ ๋น์ถ ์ ์์
- ๊ตด๋ค๋ฆฌ์ ๋ชจ๋ ๊ธธ์ ๋ฐํ ์ ์๋ ๊ฐ๋ก๋ฑ์ ์ต์ ๋์ด ๊ตฌํ๊ธฐ
๋จ์ ์์ ํ์์ผ๋ก ์ต์ ๋์ด๋ฅผ ์ฐพ์ ๊ฒฝ์ฐ, ๊ตด๋ค๋ฆฌ์ ๊ธธ์ด๊ฐ N์ด๊ณ , ๊ฐ ๊ตด๋ค๋ฆฌ ๋์ด(์ด M๊ฐ)์ ๋ํด ๋ชจ๋ ๊ธธ์ ๋น์ถ ์ ์๋์ง ํ์ธํด์ผํ๋ฏ๋ก, O(N*M)์ ์๊ฐ์ด ์์๋ ์ ์๋ค.
์๊ฐ ๋ด์ ๋ฌธ์ ๋ฅผ ํด๊ฒฐํ๊ธฐ ์ํด, ์ด๋ถ ํ์ ์๊ณ ๋ฆฌ์ฆ์ ์ฌ์ฉํ ์ ์๋ค. ๊ฐ๋ก๋ฑ ๋์ด์ ๋ฒ์๊ฐ 1๋ถํฐ N์ด๋ฏ๋ก, ์ด ๋ฒ์ ๋ด์์ ์ด๋ถ ํ์์ ์งํํ๋ฉด, O(logN)์ผ๋ก, ์ด ํ์ ์๊ฐ๋ณต์ก๋๊ฐ O(M*logN)๊ฐ ๋๋ค.
๐ ์ฝ๋ ์ค๊ณํ๊ธฐ
- ๊ตด๋ค๋ฆฌ์ ๊ธธ์ด N์ ์ ๋ ฅ๋ฐ๋๋ค.
- ๊ฐ๋ก๋ฑ์ ๊ฐ์ M์ ์ ๋ ฅ๋ฐ๋๋ค.
- ๊ฐ๋ก๋ฑ์ ์์น positions๋ฅผ ๋ฆฌ์คํธ๋ก ์ ๋ ฅ๋ฐ๋๋ค.
- ๊ฐ๋ก๋ฑ ์ฌ์ด์ ๊ฐ๊ฒฉ์ ๊ณ์ฐํด distances ๋ฆฌ์คํธ์ ์ ์ฅํ๋ค.
- ์ด๋, 0๋ถํฐ ์ฒซ๋ฒ์งธ ๊ฐ๋ก๋ฑ๊น์ง, ๋ง์ง๋ง ๊ฐ๋ก๋ฑ๋ถํฐ N๊น์ง์ ๊ฑฐ๋ฆฌ๋ ๊ณ์ฐ
- ๊ฐ๋ก๋ฑ ์ฌ์ด์ ๊ฐ๊ฒฉ์ ์์ชฝ ๊ฐ๋ก๋ฑ์์ ๋น์ถ ์ ์์ผ๋ฏ๋ก 2๋ฅผ ๋๋ ์ค๋ค.
- ์ด๋ถ ํ์์ ์ํํ๊ธฐ ์ํด, low๋ฅผ 1, high๋ฅผ M์ผ๋ก ์ค์ ํ๊ณ mid๋ฅผ ๊ตฌํด์ ํ์์ ์์ํ๋ค.
- ํ์ฌ ๊ฐ๋ก๋ฑ ๋์ด๋ก, ๊ตด๋ค๋ฆฌ ์ ์ฒด๋ฅผ ๋ฐํ ์ ์๋์ง ํ์ธํ๋ค.
- ๋ง์ฝ ํ์ฌ ๋์ด๋ก ๊ตด๋ค๋ฆฌ๋ฅผ ๋ฐํ ์ ์๋ค๋ฉด, ๋ ์์ ๋์ด๋ก ๊ฐ๋ฅํ์ง ํ์ธํ๊ธฐ ์ํด high๋ฅผ mid-1๋ก ์ค์ธ๋ค.
- ๋ง์ฝ ๋ฐํ ์ ์๋ค๋ฉด, ๋ ํฐ ๋์ด์ฌ์ผํ๋ฏ๋ก low๋ฅผ mid + 1๋ก ์ฆ๊ฐ์ํจ๋ค.
- 5๋ฒ ๊ณผ์ ์ ๋ฐ๋ณตํ์ฌ low, high๊ฐ ๊ต์ฐจํ๋ ์๊ฐ, ์ต์ ๋์ด๊ฐ ๋๊ณ ํด๋น ๊ฐ์ ์ถ๋ ฅํ๋ค.
๐ ์ ๋ต ์ฝ๋
import math
N = int(input())
M = int(input())
positions = list(map(int, input().split()))
distances = [positions[0]]
for i in range(M-1):
distances.append(math.ceil((positions[i+1]-positions[i])/2))
distances.append(N-positions[M-1])
low = 1
high = N
def can_iluminate(H):
for distance in distances:
if distance > H:
return False
return True
while low <= high:
mid = (low+high)//2
if can_iluminate(mid):
high = mid - 1
else:
low = mid + 1
print(low)
์์ ๋ฐฉ๋ฒ์ผ๋ก ์ ๋ต์ ๋ฐ๊ธด ํ์ง๋ง, ๊ฐ๋ก๋ฑ ์ฌ์ด์ ๊ฐ๊ฒฉ์ด ํด์๋ก ํ์ํ ๋์ด๊ฐ ๋ ์ปค์ง๋ ๊ฒ์ด๋ฏ๋ก, ๊ฒฐ๊ตญ ๊ฐ๋ก๋ฑ ์ฌ์ด ๊ฐ๊ฒฉ ์ค ์ต๋๊ฐ์ ์ฐพ์ผ๋ฉด ๊ทธ๊ฒ ์ ๋ต์ด ๋๋ ๊ฒ์ด ์๋๊ฐ?๋ผ๋ ์๊ฐ์ด ๋ค์๋ค. ๊ทธ๋์ ์๋์ ๊ฐ์ด ์ด๋ถํ์์ ์ฌ์ฉํ์ง ์๊ณ ๊ธฐ์กด์ ๋ง๋ค์ด๋ ๊ฐ๋ก๋ฑ ๊ฐ๊ฒฉ์ ์ ์ฅํ distances ๋ฆฌ์คํธ๋ฅผ ํ์ฉํด์ ์ฝ๋๋ฅผ ๊ณ ์ณค๊ณ , ์ด ์ฝ๋ ์ญ์ ์ ๋ต์ ๋ฐ์ ์ ์์๋ค.
import math
N = int(input())
M = int(input())
positions = list(map(int, input().split()))
distances = [positions[0]]
for i in range(M-1):
distances.append(math.ceil((positions[i+1] - positions[i])/2))
distances.append(N-positions[M-1])
# ๊ฐ๋ก๋ฑ ์ฌ์ด ๊ฐ๊ฒฉ ์ค ๊ฐ์ฅ ํฐ ๊ฐ ์ถ๋ ฅ
print(max(distances))