[BOJ][๐ก5][๋ฐฑ์ค#02110] ๊ณต์ ๊ธฐ ์ค์น
์์ฑ:    
์ ๋ฐ์ดํธ:
์นดํ ๊ณ ๋ฆฌ: BOJ Gold V
๋ฌธ์ ์ถ์ฒ
๋ฌธ์
๋ํ์ด์ ์ง N๊ฐ๊ฐ ์์ง์ ์์ ์๋ค. ๊ฐ๊ฐ์ ์ง์ ์ขํ๋ย x1, โฆ, xN์ด๊ณ , ์ง ์ฌ๋ฌ๊ฐ๊ฐ ๊ฐ์ ์ขํ๋ฅผ ๊ฐ์ง๋ ์ผ์ ์๋ค. ๋ํ์ด๋ ์ธ์ ์ด๋์๋ ์์ดํ์ด๋ฅผ ์ฆ๊ธฐ๊ธฐ ์ํด์ ์ง์ ๊ณต์ ๊ธฐ C๊ฐ๋ฅผ ์ค์นํ๋ ค๊ณ ํ๋ค. ์ต๋ํ ๋ง์ ๊ณณ์์ ์์ดํ์ด๋ฅผ ์ฌ์ฉํ๋ ค๊ณ ํ๊ธฐ ๋๋ฌธ์, ํ ์ง์๋ ๊ณต์ ๊ธฐ๋ฅผ ํ๋๋ง ์ค์นํ ์ ์๊ณ , ๊ฐ์ฅ ์ธ์ ํ ๋ ๊ณต์ ๊ธฐ ์ฌ์ด์ ๊ฑฐ๋ฆฌ๋ฅผ ๊ฐ๋ฅํ ํฌ๊ฒ ํ์ฌ ์ค์นํ๋ ค๊ณ ํ๋ค. C๊ฐ์ ๊ณต์ ๊ธฐ๋ฅผ N๊ฐ์ ์ง์ ์ ๋นํ ์ค์นํด์, ๊ฐ์ฅ ์ธ์ ํ ๋ ๊ณต์ ๊ธฐ ์ฌ์ด์ ๊ฑฐ๋ฆฌ๋ฅผ ์ต๋๋ก ํ๋ ํ๋ก๊ทธ๋จ์ ์์ฑํ์์ค.
์ ๋ ฅ
์ฒซ์งธ ์ค์ ์ง์ ๊ฐ์ N (2 โค N โค 200,000)๊ณผ ๊ณต์ ๊ธฐ์ ๊ฐ์ C (2 โค C โค N)์ด ํ๋ ์ด์์ ๋น ์นธ์ ์ฌ์ด์ ๋๊ณ ์ฃผ์ด์ง๋ค. ๋์งธ ์ค๋ถํฐ N๊ฐ์ ์ค์๋ ์ง์ ์ขํ๋ฅผ ๋ํ๋ด๋ xi (0 โค xi โค 1,000,000,000)๊ฐ ํ ์ค์ ํ๋์ฉ ์ฃผ์ด์ง๋ค.
์ถ๋ ฅ
์ฒซ์งธ ์ค์ย ๊ฐ์ฅ ์ธ์ ํ ๋ ๊ณต์ ๊ธฐ ์ฌ์ด์ ์ต๋ ๊ฑฐ๋ฆฌ๋ฅผ ์ถ๋ ฅํ๋ค.
์์
์ ๋ ฅ
5 3
1
2
8
4
9
์ถ๋ ฅ
3
My Sol
import sys
input = sys.stdin.readline
def binary_search():
global houses, ans, N, C
s, e = 1, houses[-1] - houses[0]
while s <= e:
m = (s + e) // 2
cur = houses[0]
cnt = 1
for i in range(1, N):
if houses[i] >= cur + m:
cnt += 1
cur = houses[i]
if cnt < C:
e = m-1
continue
s = m+1
ans = m
N, C = map(int, input().split())
houses = sorted([int(input()) for _ in range(N)])
ans = 0
binary_search()
print(ans)
๊ณ ๋ฏผํด๋ ๋ต์ด ์ ๋์์ ๋ธ๋ก๊ทธ(๋งํฌ)๋ฅผ ์ฐธ๊ณ ํด ํ์๋ค.
์ด๋ถํ์์ ํ์ฉํ๋ ๋ฌธ์ ์๋ค. ์ด๋ถํ์์ ๊ฒฐ๊ณผ์ธ mid๋ ๊ณต์ ๊ธฐ ์ฌ์ด์ ๊ฑฐ๋ฆฌ๋ก ๋๊ณ , ์ด ๊ฑฐ๋ฆฌ๋ฅผ ์กฐ์ ํ๋ฉฐ, ํด๋น ๊ฑฐ๋ฆฌ ๋ด์ ์ง๋ค์ด ๋ถํฌํ๋์ง ํ์ธํ๋ ๋ฐฉ์์ ์ฌ์ฉํ๋ ๊ฒ์ด๋ค.
- ์ฒซ ์ง๋ถํฐ ๊ณต์ ๊ธฐ๋ฅผ ์ค์นํ๋ค.
- ์์ง(cur)๊ณผ ํ์ฌ ์ค์ ๋ ๊ณต์ ๊ธฐ ์ต๋ ๊ฑฐ๋ฆฌ๋ฅผ ๋ํ ๊ฐ๊ณผ ์์น๊ฐ ๊ฐ๊ฑฐ๋ ํฌ๋ค๋ฉด ํด๋น ์์น์ ์ง์ ๊ณต์ ๊ธฐ๋ฅผ ์ค์นํ๊ณ ํด๋น ์ง์ ์์ง์ผ๋ก ์ค์ ํ๋ค.
- ๊ณต์ ๊ธฐ๋ฅผ ์ค์นํ ๋๋ง๋ค cnt๋ฅผ 1์ฉ ์ฌ๋ ค์ค๋ค.
- ๋ชจ๋ ์ง์ ์กฐํํ๋ค๋ฉด, cnt๋ฅผ ํ์ธํ๋ค.
- cnt๊ฐ ๊ณต์ ๊ธฐ ๊ฐ์(C)๋ณด๋ค ์์ผ๋ฉด ๊ณต์ ๊ธฐ๊ฐ์ ๊ฑฐ๋ฆฌ๊ฐ ํฐ ๊ฒ์ด๋ฏ๋ก e๋ฅผ m-1๋ก ์ค์ธ๋ค.
- cnt๊ฐ C๋ณด๋ค ๊ฐ๊ฑฐ๋ ํฌ๋ฉด ๊ณต์ ๊ธฐ ๊ฑฐ๋ฆฌ๋ฅผ ๋ ํค์๋ณผ ์ ์์ผ๋ฏ๋ก s๋ฅผ m+1๋ก ์ง์ ํ๊ณ , ans๋ฅผ m์ผ๋ก ์ค์ ํ๋ค.
๊ฒฐ๊ณผ
๋ง์์ต๋๋ค!!
๋๊ธ๋จ๊ธฐ๊ธฐ