๐ ํ๋ํฐ๋ ์ด์์ ๋์ด๋๋ ๊ฐ ๋ฌธ์ ์ ์ ๊ทผ๋ฐฉํฅ ๋ฟ๋ง ์๋๋ผ, ์ฌ๊ณ ๊ณผ์ ํ๋ฆ๊น์ง ์ต๋ํ ๋ฆฌ๋ง์ธ๋ํ๋ ๋ฐฉ์์ผ๋ก ๊ธฐ์ตํ์!
๐ ์ ๋ ฌ๊ด๋ จ ํฌ์คํ ํ๋จ ์ฐธ์กฐ
๐ ์ ๋ ฌ์๋ ์ ๋ง ๋ง์ ์๊ณ ๋ฆฌ์ฆ์ด ์๋ค. ํ๋์ด์์ ๋์ด๋๊ธ ๋ฌธ์ ์์ ์ ๋ ฌ์ ์ด๋ค ๋ฐฉ์์ผ๋ก ์ ๊ทผํ๋ ์ง ์์๋ณด์
โ 2220 ํ ์ ๋ ฌ โ
import math
n = int(input())
if n==1:print(1)
elif n==2:print(2,1)
elif n==3:print(3,2,1)
else:
arr = [3,2,1]
for i in range(n-3):
end=int(math.log(i+3,2))
idx=len(arr)-1
for _ in range(end):
arr[idx],arr[(idx-1)//2]=arr[(idx-1)//2],arr[idx]
idx=(idx-1)//2
arr[0]=(i+4)
arr.append(1)
print(*arr)
๐คน heapify() ์๊ณ ๋ฆฌ์ฆ์์ ์งํ๋๋ swap ์ฐ์ฐ ํ์๋ฅผ ์ต๋๋ก ํ๋ heap์ ๊ตฌํ๋ ๋ฌธ์ .
๐คน ์ผ๋จ heapsort์ ์๊ฐ ๋ณต์ก๋๋ $O(nlogn)$์ด๋ฉฐ, heapsort๋, binary heap์ด๋ผ๋ ์๋ฃ๊ตฌ์กฐ์์, ์ต์๋จ ๋ ธ๋๋ฅผ ๋งค๋ฒ heapify()๋ง๋ค ๋นผ๊ณ ์ ์ณ๋ ๋ค, ๋งจ ๋ง์ง๋ง ์์๋ฅผ ์ต์๋จ ๋ ธ๋๋ก ๋ค์ ์ฌ๋ ค ๋ค์ heapify()๋ฅผ ๋ฐ๋ณตํ๋ sorting์ด๋ค.
(ํ๋จ heapsort ํฌ์คํ ์ฐธ์กฐ)
๐คน ์ด ๋, heapify()์์ heap ๊ตฌ์กฐ๋ฅผ ์ ์งํ๊ธฐ ์ํด parent node ๊ธฐ์ค, ๋ ์์ node์ ๋์๋น๊ต๋ฅผ ํ๋ ๊ณผ์ ์ด ์๋ค. ์ด ๋, heap์ ๊ธฐ์ค์ ์ถฉ์กฑํ๊ธฐ ์ํด swap์ด ์งํ๋ ์ ์๋๋ฐ, ์ด๊ธฐ์ ์ด๋ป๊ฒ heap ๊ตฌ์กฐ๋ฅผ ์ ์งํ๋ฉด swap ํ์๋ฅผ ์ต๋ํํ ์ ์๋์ง๊ฐ ๊ด๊ฑด.
๐คน * ์ฌ๊ท์ ์ผ๋ก ์ ๊ทผ
ex) ์ต๋ swap ํ์๊ฐ ๋์ค๋, ์์๋ก ๋ n=6์ผ ๋์ ์ด๊ธฐ heap ๊ตฌ์กฐ๋ [6, 5, 3, 2, 4, 1]์ด๋ค. ์ด๋ฅผ heapify()ํ๋ ๊ณผ์ ์ ์ผ์ผ์ด ์ดํด๋ณธ๋ค๋ฉด, ์๋ ๊ทธ๋ฆผ๊ณผ ๊ฐ๋ค.
โป swap ๊ฐ์๊ฐ ์ต๋๊ฐ ๋๊ธฐ ์ํด์๋, ๋ถ๋ชจ์ ์์๊ฐ์ ๋น๊ต์ฐ์ฐ์์ ๋ฌด์กฐ๊ฑด swap์ด ์งํ๋๊ฒ ํ๋ฉด ๋๋ค. ์ด๋ฅผ ๊ตฌํํ ์ ์๊ณ , ์ ๊ทธ๋ฆผ๊ณผ ๊ฐ์ด ์ต์ข 1๋ง ๋จ์ ๋ ๊น์ง ๋ชจ๋ ๊ณผ์ ์ ํด๋ถํ๋ฉด, comparison ๊ณผ์ ์ ์ธ 1๋ถํฐ 5๊น์ง์ max-heap snapshot์ด ํฌํจ๋์ด ์์ผ๋ฉฐ, ์ด๋ ๊ณง 1๋ถํฐ 5๊น์ง์ ์ต๋ swap ๊ฐ์๋ฅผ ๊ฐ์ง๋ heapify() ๊ณผ์ ๋ ํฌํจ(์ฌ๊ท)๋์ด ์๋ค๋ ๋ป์ด๋ค.
→ ๊ทธ๋ ๋ค๋ฉด ๊ฑฐ๊พธ๋ก, n=3([3,2,1]) ๊ณผ์ ๋ถํฐ ์์ํ๋ค๋ฉด, ๊ฐ์ฅ ๋์ ์์ 1์ ํ ์ธต ์ฌ๋ผ๊ฐ๋ฉฐ swapํ๊ณ , ์ต์๋จ node๋ฅผ 1๋ก ๋ํ ๊ฒฐ๊ณผ์ธ 4๋ฅผ ๋ฃ๊ณ , ๋์ ์๋ฆฌ์ 1์ ์ถ๊ฐํ๋ค. / n=4์ ๊ฒฝ์ฐ ๋ก๊ทธ๊ฐ์ 2์ด๋ฏ๋ก heap์ ๋์ด๊ฐ 2๋ก ์ฆ๊ฐ. ๊ฐ ๋์ด๋ณ๋ก ๋ชจ๋ swap๋๊ฒ๋, ๋ฐฉ๊ธ ์ถ๊ฐํ 1์ ์ต์๋จ node๊น์ง ์ฌ๋ผ๊ฐ๋ฉฐ swap. ์์ ํ ๊ฒฐ๊ณผ์ ๋๊ฐ์ด 1๋ก ๋ํ ๊ฒฐ๊ณผ์ธ 5๋ฅผ ์ต์ข 1์ ์๋ฆฌ์ธ ์ต์๋จ node์ ๋ฃ๊ณ , ๋ง์ง๋ง์ 1 ์ถ๊ฐ. / ์ด๋ ๊ฒ ์งํํ๋ค๋ฉด ์ ์ผ ์ต์๊ฐ 1์ ๊ฐ์ง๊ณ ์์ง์ด๋ฏ๋ก ๋ชจ๋ height๋ณ swap์ด ์งํ๋๊ณ , ์ด๋ ๊ณง ๋ชจ๋ height๋ณ๋ก ๋ฌด์กฐ๊ฑด swap์ด ์ผ์ด๋๊ธฐ์ swap ํ์๊ฐ ์ต๋๊ฐ ๋จ์ ๋ปํ๋ฉฐ, ์ต์ข swap ๊ฐฏ์๋ฅผ ๊ฐ์ง๋ ์ํ๋ n ๊ฐ์์ heap์ ๋ง๋ค ์ ์๋ค!
โป ์ฌ๊ท์ ์ผ๋ก ์ ๊ทผํด heapify() ๊ณผ์ ์ ํ์ด ์ดํดํ๊ณ , ๊ฑฐ๊พธ๋ก ๋ค์ ์ฌ๋ผ๊ฐ๋ฉฐ heap์ ์์ฑํ๋ ํ๋ฆ (heapsort ์๊ณ ๋ฆฌ์ฆ์ ๊ฑฐ๊พธ๋ก) โป
→ ์ฝ๋ ๋ถ์)
โ ์ฃผ์ด์ง ๋์ด๊น์ง ์ฌ๋ผ๊ฐ์ผ ํ๋ฏ๋ก, $\lfloor \log_2 (i+3) \rfloor$๊น์ง swap๊ณผ์ ์งํ
โก python(first index 0) ๊ธฐ์ค, ์์ node(idx)๋ฅผ ๊ธฐ์ค์ผ๋ก ํ์ ๋ ๋ถ๋ชจ node์ index๋ $\lfloor \cfrac{(idx-1)}{2} \rfloor$. ๋ฐ๋ผ์ ๋ ๊ฐ์ index์ ํด๋นํ๋ ์์๋ฅผ ์๋ก swap. ์ดํ idx update
โข ๋ง๋ฌด๋ฆฌ๋ก append(1)๋ก ๋งจ ๋์ 1์ ์ถ๊ฐํ๊ณ , ์ฒซ ๋ฒ์งธ ์์(heap ์ต์๋จ)๋ก ๊ธฐ์กด ๋ฐฐ์ด ์ต๋๊ฐ์ 1์ ๋ํ ๊ฐ ์ถ๊ฐ
'BOJ > ๐ ' ์นดํ ๊ณ ๋ฆฌ์ ๋ค๋ฅธ ๊ธ
โ Divide & Conquer Expert(Easy) I - 1 Solvedโ (2) | 2024.06.30 |
---|---|
โ DP Expert(Easy) I - 4 Solvedโ (0) | 2024.01.07 |
๋๊ธ