๐ก ์กฐ๊ฑด ๋ฐ ํ์ด
- ์ด์ง ํธ๋ฆฌ์ ๊น์ด๋ฅผ ๋ํ๋ด๋
1<=K<=10
, ๊น์ด๊ฐ K
์ธ ์ด์ง ํธ๋ฆฌ๋ ์ด 2 * K - 1
๊ฐ์ ๋
ธ๋๋ก ์ด๋ฃจ์ด์ ธ ์๋ค.
- ๊ฐ์ฅ ๋ง์ง๋ง ๋ ๋ฒจ์ ์ ์ธํ ๋ชจ๋ ์ง์ ์ผ์ชฝ ์์๊ณผ ์ค๋ฅธ์ชฝ ์์์ ๊ฐ๋๋ค.
- ์ด๋ถํ์, ํธ๋ฆฌ, ์ฌ๊ท๊ตฌํ ๋ฌธ์
- ๋ชจ๋ ๋น๋ฉ์ ๋ฒํธ๋ ์ค๋ณต๋์ง ์๋๋ค.
๐ฅ ์์ค ์ฝ๋
from sys import stdin, setrecursionlimit
setrecursionlimit(int(1e9))
k = int(stdin.readline())
arr = list(map(int, stdin.readline().split()))
res = [[] for _ in range(k)]
def binary_separation(arr, depth):
if len(arr) == 1:
res[depth].extend(arr)
return
length = len(arr)
mid = length // 2
res[depth].append(arr[mid])
binary_separation(arr[:mid], depth + 1)
binary_separation(arr[mid + 1:], depth + 1)
binary_separation(arr, 0)
for i in range(k):
if i == 0:
print(res[i][0])
else:
print(*res[i])
๐ ์์ ๋ฐ ์คํ๊ฒฐ๊ณผ
์์
3
1 6 4 3 5 2 7
์คํ๊ฒฐ๊ณผ
3
6 2
1 4 5 7
โจ๏ธ ๋ฌธ์ ํ์ด
- ๊น์ด๊ฐ
k
์ธ 2์ฐจ์ ๋ฆฌ์คํธ res
๋ฅผ ์์ฑํ๊ณ , ์ด ๋ฆฌ์คํธ์ ๋
ธ๋๋ฅผ ์์ ๊ฒ์
๋๋ค.
- Python ๋ฆฌ์คํธ ์๋ฃ๊ตฌ์กฐ์
extend()
ํจ์๋ฅผ ์ฌ์ฉํ์ต๋๋ค.
extend
๋ ๋ฆฌ์คํธ๋ฅผ ๋ฆฌ์คํธ ์์ผ๋ก ๋ฃ์ ๋ ๋ฆฌ์คํธ์ ์์๋ง ๋ฃ์ด์ค๋๋ค.
- ์
๋ ฅ๋ฐ์ ๋น๋ฉ๋ฒํธ์ ๊ธธ์ด๋ฅผ 2๋ก ๋๋์ด ๊ฐ์
mid
๋ณ์์ ๋ฃ์ด ๊ฐ์ง๊ณ ์์ต๋๋ค.
res
์ ํ๋ผ๋ฏธํฐ๋ก ๋ฐ์ depth
๊ฐ์ ๋ฃ์ด์ค๋๋ค.
๊ฐ์ฅ ๋งจ ์ฒ์์ผ๋ก ์ด๋ถํ์์ ํตํด ๋ฝ์๋ธ ๊ฐ์ด๋ฐ ๊ฐ์ด ๋ฃจํธ ๋
ธ๋์
๋๋ค.
- ๊ฐ์ด๋ฐ ๊ฐ์ ๊ธฐ์ค์ผ๋ก ์์ชฝ์ ๋ถ๋ฆฌํด ๊ฐ๊ฐ ๋ค์ ์ด๋ถํ์์ ์ํํฉ๋๋ค.
- ์ด๋ถ ํ์์ ํ๋ค๊ฐ, ํ๋ผ๋ฏธํฐ๋ก ๋ฐ์
arr
๋ฆฌ์คํธ์ ๊ธธ์ด๊ฐ 1์ธ ๊ฒฝ์ฐ depth
์ ํด๋นํ๋
๋ฆฌ์คํธ์ ๋ฃ์ด์ค๋๋ค.
- ๋ง๋ค์ด์ง ํธ๋ฆฌ(
res
)๋ฅผ ์ถ๋ ฅํด์ค๋๋ค.
- ํ์ด์ฌ์ผ๋ก ์ฌ๊ท๋ฅผ ๊ตฌํํ ๋,์๋์ ํจ์๋ฅผ ์ฌ์ฉํด์ผ ์๋ฌ๊ฐ ๋์ง ์๋ ๊ฒฝ์ฐ๊ฐ ๋ง์ต๋๋ค.
์ด๋ค๊ณ ๋ฌธ์ ๋ ๊ฒ์ด ์์ผ๋, ์ฌ๊ท๋ฅผ ๊ตฌํํ์ฌ ๋ฌธ์ ๋ฅผ ํธ์ค ๋ ๊ผญ ์
๋ ฅํ์ธ์.
setrecursionlimit(int(1e9))โ
๐พ ๋๋์
- ์ด๋ถํ์๊ณผ ์ฌ๊ท๋ฅผ ์ฌ์ฉํ์ฌ ๋ฌธ์ ๋ฅผ ํธ๋ ๋ฐฉ์์ ์ต์ํด์ง ๊ฒ์ ๋๊ผ๋ค.
- ๋ถํ ์ ๋ณต ๋ฌธ์ ๋ฅผ ํ๋ค๊ฐ ์ด ๋ฌธ์ ๋ฅผ ํธ๋ ํจ์ฌ ๋์์ด ๋์๋ค.