[๋ฐฑ์ค]1508 - ๋ ์ด์ค (#ํ์ด์ฌ #๊ทธ๋ฆฌ๋ #์ด๋ถํ์ #๊ฒฝ๊ณ ์ค์ ํ ์นด์ดํ )
1508๋ฒ: ๋ ์ด์ค
boj.ma
๋ฌธ์ ๋ฅผ ๊ฐ๋จํ๊ฒ ํํํ๋ฉด ๊ฐ์ฅ ๊ฐ๊น์ด ์ฌํ ๊ฐ ๊ฑฐ๋ฆฌ๊ฐ ์ต๋๊ฐ ๋๋๋ก ๋ฐฐ์นํ๋ ๋ฌธ์ ์ด๋ค. ์ต๋ํ ๋ฌ์ฑ๋ฌ์ฑ ๋ฐฐ์นํ๋ ๊ฒ์ด๋ค. ์ต๋ํ '๋ฌ์ฑ๋ฌ์ฑ' ๋ฐฐ์นํ๊ธฐ ์ํด '์ฌํ ๊ฐ ๊ฑฐ๋ฆฌ์ ๋ํด ๊ทธ๋ฆฌ๋ ์ ๋ต'์ ์ทจํ ์ ์๋ค. ์ฌํ์ ๊ฑฐ๋ฆฌ๋ฅผ ์ต๋ํ ๋ํ์ ๋ฐฐ์นํด ๋ณด๊ณ , ๋ฌธ์ ์กฐ๊ฑด์ ๋ง์ง ์์ผ๋ฉด ์ขํ์ ๋ฐฐ์นํด ๋ณด๊ณ , ๋๋ค์ ๋ํ ๋ณด๊ณ , ... ๋ฐ๋ณตํ๋ฉฐ ์ ๋ต์ ์ฐพ์ ์ ์๋ค. ์ฆ, ์ด๋ถํ์์ผ๋ก ๊ฒฝ๊ณ(์ฌํ ๊ฐ ์ต๋ ๊ฑฐ๋ฆฌ)๋ฅผ ์ค์ ํ ํ์ ํด๋น ๊ฒฝ๊ณ์์ ๋ช ๋ช ์ ์ฌํ์ ๋ฐฐ์นํ ์ ์๋์ง ๋ฐฐ์นํด๋ณด๋ ๊ฒ์ด๋ค.
์ฌํ ๋ฐฐ์น ๋ก์ง
์ถ๋ ฅํ ๋๋ ์์ ์ ๊ฐ์ด ์ฌํ์ ์ธ์ธ ๊ณณ์๋ 1์, ์ธ์ฐ์ง ์์ ๊ณณ์๋ 0์ ์ถ๋ ฅํ๋ค. ๋ง์ฝ ์ ๋ต์ด ์ฌ๋ฌ๊ฐ์ผ ๊ฒฝ์ฐ์๋ ์ฌ์ ์์ผ๋ก ๊ฐ์ฅ ๋ฆ๋ ๊ฒ์ ์ถ๋ ฅํ๋ค.
๋ฌธ์ ์ ์ถ๋ ฅ ์กฐ๊ฑด์ ์ดํด๋ณด๋ฉด '์ฌ์ ์์ผ๋ก ๊ฐ์ฅ ๋ฆ๋ ๊ฒ์ ์ถ๋ ฅํ๋ค'๋ ์กฐ๊ฑด์ด ์๋ค. ์ด๋ฅผ ํตํด ์ ์ ์๋ ๊ฒ์ ์ฌํ์ ์์น๊ฐ ์์ ๊ฒ๋ถํฐ ๋ฐฐ์น๋ฅผ ํ๊ณ , ๋ฌธ์ ์ ์กฐ๊ฑด์ ๋ถํฉํ๋ค๋ฉด ํด๋น ๋ฐฐ์น๊ฐ ์ ๋ต์ด ๋๋ค๋ ๊ฒ์ด๋ค.
๊ฐ๋ น ์ฌํ์ ์์น๊ฐ 0, 5, 10, 15์ด๊ณ , ๊ฒฝ๊ณ(= ์ต๋ ๋จ์ด์ง ๊ฑฐ๋ฆฌ)๋ฅผ 5๋ผ๊ณ ๊ฐ์ ํ๋ฉด '1110', '0111' ๋ฐฐ์น ๋ชจ๋ ๊ฐ๋ฅํ๋ค. ๊ทธ๋ฐ๋ฐ, ์ถ๋ ฅ ์กฐ๊ฑด์์ ์ฌ์ ์์ผ๋ก ๊ฐ์ฅ ๋ฆ๋ ๊ฒ์ ์ถ๋ ฅํ๋ค๋ ์กฐ๊ฑด์ ์ํด '1110'์ด ์ ๋ต์ด ๋๋ ๊ฒ์ด๋ค. ์ฌํ์ ์์น๊ฐ ์์ ๊ฒ๋ถํฐ ๋ฐฐ์นํ๋ฉด ๋๋ ๊ฒ์์ ํ๋จํ ์ ์๋ค.
์ฌํ ๋ฐฐ์น ์์์ ์ด๋์๋ถํฐ?
๋๋ ์ฌํ ๋ฐฐ์น์ ์์ ์์น๋ฅผ ๋ชจ๋ ์ผ์ด์ค์ ๋ํด ๋ชจ๋ ๊ฒ์ฆํด์ฃผ์๋ค. ์๋ํ๋ฉด K ๊ฐ์ด ์ต๋ 50์ผ๋ก ์ถฉ๋ถํ ์์ ๋ชจ๋ ์ผ์ด์ค์ ๋ํด ๊ฒ์ฆํ๋๋ผ๋ ์๊ฐ ๋ณต์ก๋๊ฐ O(2500) ์์ค์ผ๋ก ๋งค์ฐ ์๊ธฐ ๋๋ฌธ์ด๋ค.
์๋์ ์ฝ๋๋ฅผ ๋ณด๋ฉด, st ์ธ๋ฑ์ค์๋ ๋ฌด์กฐ๊ฑด ์ฌํ์ด ๋ฐฐ์น๋๊ณ , ํด๋น ์ธ๋ฑ์ค๋ณด๋ค ์์น ๊ฐ์ด ํฐ ๊ณณ์๋ง ์ฌํ์ด ๋ฐฐ์น๋๋ ๊ฒ์ ์ ์ ์๋ค.
for st in range(K):
# st ์ธ๋ฑ์ค์๋ ๋ฌด์กฐ๊ฑด ์ฌํ ๋ฐฐ์น
order = ''
cnt = 1
for _ in range(st): order += '0'
order += '1'
prev = st
for i in range(st + 1, K):
if cnt == M:
order += '0'
continue
if seq[i] - seq[prev] >= gap:
prev = i
order += '1'
cnt += 1
else:
order += '0'
st ์ธ๋ฑ์ค ์ ์๋ ์ฌํ์ด ๋ฐฐ์น๋์ง ์์ผ๋ฉฐ(= for _ in range(st): order += '0'), ํด๋น ์์น ์ดํ๋ถํฐ ์ํํ๋ค(= for i in range(st + 1, K):).
์ฌํ ๋ฐฐ์น์ ๋์ ์ธ์ ?
์ ์ฝ๋ ๋ธ๋ญ์ cnt๊ฐ M์ด ๋๋ฉด ๋ฌด์กฐ๊ฑด order += '0' ์ฒ๋ฆฌ๋๋ ๋ถ๋ถ์ผ๋ก ์ฌํ ๋ฐฐ์น๊ฐ ๋๋ ๊ฒฝ์ฐ์ ๋ํด ์ฒ๋ฆฌํ์๋ค. ์ฆ, ์ฌํ ๋ฐฐ์น ๊ฐ์์ธ cnt๊ฐ M์ผ๋ก ๋ฌธ์ ์กฐ๊ฑด์ ๋ถํฉํ๊ฒ ๋ฐฐ์น๊ฐ ๋๋ฌ๋ค๋ฉด ๋ค์๋ ๋ ์ด์ ์ฌํ์ ๋ฐฐ์นํ์ง ์๋ ๊ฒ์ด๋ค. ์ด๋ ๊ฒ ์ฒ๋ฆฌํ ์ ์๋ ์ด์ ๋ ์ ๋ต์ด ์ฌ๋ฌ ๊ฐ์ธ ๊ฒฝ์ฐ '์ฌ์ ์์ผ๋ก ๊ฐ์ฅ ๋ฆ์ ๊ฒ์ ์ถ๋ ฅํ๋ค'๋ ์กฐ๊ฑด์ด ์๊ธฐ ๋๋ฌธ์ด๋ค. cnt๊ฐ M๊ฐ ๋งํผ ๋ฐฐ์นํ์ง ๋ชปํ๋ ๊ฒฝ์ฐ์๋ ๋ฌธ์ ์กฐ๊ฑด์ ๋ง์กฑํ์ง ๋ชปํ๋ ๊ฒฝ์ฐ์ด๋ฏ๋ก ์ด๋ถํ์์์ ์กฐ๊ฑด ์กฐ์ ์ด ์ด๋ฃจ์ด์ง๋ค.
์ด๋ถ ํ์์์ ๊ฒฝ๊ณ ์กฐ์
l = 1
r = N
while l <= r:
length = (l + r) // 2
refCnt, refOrder = refreeCount(length)
if refCnt > M:
l = length + 1
elif refCnt < M:
r = length - 1
else:
ans = refOrder
l = length + 1
print(ans)
์ด๊ธฐ l๊ณผ r์ ๊ฐ๊ฐ 1, N์ผ๋ก ์ค์ ๋๋ค. ์ด l, r์ ํตํด ๊ฒฝ๊ณ(length)๋ฅผ ์ค์ ํ์ฌ ํด๋น ๊ฒฝ๊ณ๋ฅผ ๋ฐํ์ผ๋ก ์ฌํ ๋ฐฐ์น ์, ์ฌํ ๋ฐฐ์น ๊ฒฐ๊ณผ(refCnt, refOrder)๋ฅผ ๋ฐํ๋ฐ๋๋ค.
์ฌํ ๋ฐฐ์น ์๊ฐ ๋ฌธ์ ์กฐ๊ฑด๋ณด๋ค ํฐ ๊ฒฝ์ฐ ๊ฒฝ๊ณ๋ฅผ ๋๋ ค์ ์ฌํ ๋ฐฐ์น๊ฐ ๋ ์ ๊ฒ ๋๋๋ก ์กฐ์ ํ๋ค. ์ฌํ ๋ฐฐ์น์๊ฐ ๋ฌธ์ ์กฐ๊ฑด๋ณด๋ค ์์ ๊ฒฝ์ฐ ๊ฒฝ๊ณ๋ฅผ ์ค์ฌ์ ์ฌํ ๋ฐฐ์น๊ฐ ๋ ๋ง๊ฒ ๋๋๋ก ์กฐ์ ํ๋ค. ๋ฌธ์ ์กฐ๊ฑด๊ณผ ๋ง๊ฒ ์ฌํ์ด ๋ฐฐ์น๋ ๊ฒฝ์ฐ ans ๊ฐ์ ์ฌํ ๋ฐฐ์น ๊ฒฐ๊ณผ๋ฅผ ํ ๋นํ๊ณ , ๊ฒฝ๊ณ๊ฐ ๋ ์ปค์ก์ ๋๋ ์ ๋ต์ ์ฐพ์ ์๋ ์์์ง ํ์ธํ ์ ์๋๋ก ์กฐ์ (l = length + 1)ํ๋ค.
์๊ฐ ๋ณต์ก๋(Time Complexity)
์ด๋ถ ํ์์ ํตํด ๊ฒฝ๊ณ๋ฅผ ์ค์ ํ๋ ๊ฒ์ ์๊ฐ ๋ณต์ก๋๋ O(log(N))์ด๋ค. ์ด๋ถ ํ์ ๋ด์์ ์ฌํ์ ๋ฐฐ์นํ๋ ๊ณผ์ ์ ์๊ฐ ๋ณต์ก๋๋ฅผ ๊ณ์ฐํด ๋ณด๋ฉด O(K^2)์ด๋ค. K๋ 50 ์ดํ์ด๋ฏ๋ก O(K^2 * log(N))์ ์ถฉ๋ถํ ๊ณ์ฐ ๊ฐ๋ฅํ ์๊ฐ ๋ณต์ก๋์์ ์ ์ ์๋ค.