ํ๋ก๊ทธ๋๋จธ์ค์ ์ฝ๋ฉํ ์คํธ ์ฐ์ต์์ ์นดํ ๊ณ ๋ฆฌ๋ฅผ ์ ๋ณด๋ฉด ์ฌ์ฉํด์ผ ํ๋ ์๋ฃ ๊ตฌ์กฐ๊ฐ ์ ํ ์๋ค. ์ด๋ฒ์ ํ๊ฒ ๋ ๊ฒ์ ํ(Heap) > ๋ ๋งต๊ฒ ์ด๋ค. ์์ ์์ ๊ทธ ๋ค์ ์์ ์๋ฅผ ์ฌ์ฉํด์ ์ฐ์ฐ์ ํ๊ณ ๋ค์ ๋ฆฌ์คํธ์ ๋ฃ์ด์ ์ต์๊ฐ ๊ธฐ์ค์ ๋ํ ์กฐ๊ฑด๋ง ๋ง์ถ๋ฉด ๋๊ฒ ๋ค ์ถ์์ผ๋ ํจ์จ์ฑ์์ ๊ณผ๊ฐํ ์์๋นํ๋ค. ๊ทธ๋ ๋ค๋ฉด ์ ์ฌ๊ธฐ์ 'ํ'์ ์ ์ํ ๊ฑธ๊น?
์คํ ๊ตฌ์กฐ๋ฅผ ์ฌ์ฉํ๋ฉด ์๋๋ ๊ฑธ๊น?
def solution(scovile, k):
answer = 0
while min(scovile) < k :
if len(scovile) == 1 :
answer = -1
break;
index = scovile.index(min(scovile))
first_min = scovile.pop(index)
index_two = scovile.index(min(scovile))
second_min = scovile.pop(index_two)
new_food = first_min + (second_min * 2)
scovile.append(new_food)
answer += 1
return answer
ํ์ด์ฌ์์๋ ๋ฆฌ์คํธ๋ฅผ ์คํ ๊ตฌ์กฐ์ฒ๋ผ ์ฌ์ฉํ ์ ์๊ฒ ํด์ฃผ๋ ๋ฉ์๋๊ฐ ์กด์ฌํ๋ค. ์คํ ๊ตฌ์กฐ๋ ๋ง์ง๋ง์ ๋ค์ด๊ฐ ๋ฐ์ดํฐ๊ฐ ๊ฐ์ฅ ๋จผ์ ๋์ค๋ ๊ตฌ์กฐ๋ฅผ ๊ฐ์ง๊ณ ์๋ค. ์ ๊ตฌ๊ฐ ํ๋๋ฐ์ ์๋ ๊ตฌ์กฐ์ ๋ฐ์ดํฐ๋ฅผ ๋ฃ๊ณ ๋บ๋ค๊ณ ์๊ฐํ๋ฉด ์ฝ๋ค.
list.pop([i])
์ด ๋ฉ์๋๋ i ๋ฒ์งธ ์ธ์๋ฅผ ์ ๊ฑฐํ๋ ๋์์ ๊ทธ ๊ฐ์ ๋ฆฌํดํ๊ธฐ ๋๋ฌธ์ ๋ค๋ฅธ ๋ณ์์ ๋์ ํ์ฌ ์ฌ์ฉ ๊ฐ๋ฅํ๋ค. ์ ํํ์ ํ์ด์ฌ์ document๋ฅผ ์ฐธ๊ณ ํ ๊ฒ์ธ๋ฐ ์ค๊ดํธ๋ฅผ ์ ์ด์ผ ํจ์ ๋งํ๋ ๊ฒ์ด ์๋๋ผ i๋ผ๋ ์ธ๋ฑ์ค๋ฅผ ์ ์ด๋ ๋๊ณ ์ ์ ์ด๋ ๋๋ ์ต์ ๋ ๊ฐ์ด๋ผ๋ ๋ป์ด๋ค. ์ธ๋ฑ์ค๋ฅผ ์ ์ง ์์ผ๋ฉด ์ ์ผ ๋ง์ง๋ง์ ์๋ ๊ฐ์ ์ญ์ ํ๋ ๋์์ ๋ฆฌํดํ๋ค.
list.append(x)
append ๋ฉ์๋๋ list์ ๊ฐ x๋ฅผ ๋ง์ง๋ง ์ธ๋ฑ์ค์ ์ถ๊ฐํ๋ค.
pop()๊ณผ append() ๋ฉ์๋๋ฅผ ์ ์ ํ ์ฌ์ฉํ๋ฉด ์คํ ๊ตฌ์กฐ์ ๊ฐ์ด ๋ง์ง๋ง ์ธ๋ฑ์ค์์ ๋ฐ์ดํฐ๋ฅผ ์ถ๊ฐํ๊ณ ๊บผ๋ผ ์ ์๋ค. ์ด์ ๋ด๊ฐ ์์ฑํ ์ฝ๋๋ฅผ ๋ณด๋ฉด pop() ๋ฉ์๋์ min() ๋ฉ์๋๋ฅผ ์ฌ์ฉํด์ ๊ฐ์ ๋ฐํ ๋ฐ์ ๊ฒ์ ์ ์ ์๋ค. ์์ ๊ฐ์ ์ฐพ๋ ์ ๋ ฌ์ด ์ํ๋์ผ ํ๊ณ ๊ทธ ์ธ๋ฑ์ค๋ฅผ ์ด์ฉํด์ ๊ฐ์ ๋ฐํ ๋ฐ๊ธฐ ๋๋ฌธ์ ์คํ์ ์ด์ฉํ ๊ฒ๋ ์๋๊ฒ ๋๋ค.
์ ํ์ฑ ํ ์คํธ๋ ๋ชจ๋ ํต๊ณผํ์ง๋ง ํจ์จ์ฑ ํ ์คํธ์์๋ ์๊ฐ ์ด๊ณผ๋ก ๋ชจ๋ ์คํจํ๊ณ ๋ง์๋ค. ์ฌ๊ธฐ์ ์ต์๊ฐ์ ๊ตฌํ๊ธฐ ์ํด ๋ฆฌ์คํธ ๋ด๋ถ์์ ์ ๋ ฌ์ด ๋ค์ด๊ฐ๋ค. ์ด ์ต์๊ฐ์ด ์ ์๋ k์ ๊ฐ ์ด์์ด ๋ ๋๊น์ง while๋ฌธ์ ๋ฐ๋ณตํ๋ฏ๋ก ๊ธด ๋ฆฌ์คํธ๊ฐ ๋ค์ด์ค๋ฉด ์๊ฐ ํจ์จ์ฑ ์ธก๋ฉด์์ ์คํจํ๋ ๊ฒ์ด๋ค.
๊ทธ๋ ๋ค๋ฉด ์ ์ฒ์์ ์ด ๋ฌธ์ ๋ 'ํ' ์นดํ ๊ณ ๋ฆฌ๋ก ๋ถ๋ฅ ๋์์๊น?
์คํ ๋ง๊ณ ํ
ํ๋ ์ ์ ์ ์ถ์ ๋ํ์ ์ธ ์๋ฃ๊ตฌ์กฐ์ด๋ค. ์ฒ์ ์ถ๊ฐ๋ ๋ฐ์ดํฐ๋ฅผ ์ฒ์์ผ๋ก ๋ฐํ ๋ฐ์ ์ ์๋ค. enqueue๋ ๋ฐ์ดํฐ ์ ๋ ฅ์, dequeue๋ ๋ฐ์ดํฐ ์ถ๋ ฅ์ ์๋ฏธํ๋ฉฐ ์ด ๋ํ list๋ฅผ ํตํด์ ๊ตฌํ ๊ฐ๋ฅํ๋ค. ํ ๋ผ์ด๋ธ๋ฌ๋ฆฌ๋ฅผ ์ฌ์ฉํ๋ ค๋ฉด collections.deque ๋ชจ๋์ ์ฌ์ฉํ๋ฉด ๋๋ค.
from collections import deque
๊ทธ๋ฌ๋ ์ฌ์ฉ์ ์ฃผ์ํด์ผ ํ ๋ถ๋ถ์ด ์๋ค. ์ฐ์ ๋ฐ์ดํฐ๋ฅผ ๋ฆฌ์คํธ์ ๋์์ ์ถ๊ฐํ๊ณ ์ญ์ ํ๋ ๊ฒ์ ๋น ๋ฅด์ง๋ง, ๋ฆฌ์คํธ์ ์ ๋ถ๋ถ์์ ์ถ๊ฐํ๊ณ ์ญ์ ํ๋ ๊ฒ์ ๋๋ฆฌ๋ค. ๋ฆฌ์คํธ์ ์ ๋ถ๋ถ์์ ๋ฐ๊ฟ ์ค๋ค๋ฉด ๊ฐ ์ธ๋ฑ์ค์ ์๋ ์์๋ค์ ์์น๋ฅผ ์์ผ๋ก ํ์นธ ์ฉ ์ด๋ํ๊ฑฐ๋ ํน์ ๋ค๋ก ๋ฐ์ด์ผ ํ๋ ์ํฉ์ด ์๊ธฐ ๋๋ฌธ์ ๋๋ฆฌ๊ฒ ๋์ํ๋ ๊ฒ์ด๋ค.
์ด ๋ฌธ์ ์์ ํ์๋ก ํ๋ ๊ฒ์ ์์ ๊ฐ์ ์ฐพ๋ ๊ฒ์ด๋ค. ๋๊ฐ์ ์์ ๊ฐ์ ์ฐพ์์ ์ฐ์ฐ์ ํตํด ๋ ํฐ ๊ฐ์ ๋ง๋ค์ด ๋ธ๋ค. ์ฌ๊ธฐ์ ์๊ฐ๋๋ ๊ฒ์ ๋ฐ๋ก 'ํ'!
ํ์ด์ฌ์ ํ์ ์์ ๊ฐ ๋ถํฐ ์ ๋ ฌ๋๋ ์ฐ์ ์์ ํ
ํ์ด์ฌ์์๋ ํ ํ ์๊ณ ๋ฆฌ์ฆ์ ๊ตฌํํ heapq.py ๋ผ๋ ๋ชจ๋์ ์ ๊ณตํ๋ค. ์ผ๋ฐ์ ์ผ๋ก ์ ํ๋ ํ ๋ฐฐ์ด์ ๊ฐ์ด ํฌ๊ณ ์ธ๋ฑ์ค๋ ์์ ๊ฐ์ ๊ฐ์ง๋ ๋ ธ๋ ์์ผ๋ก ํ์๋๋ค. ๊ทธ๋ฌ๋ ํ์ด์ฌ์์ ์ ๊ณตํ๋ ํ์ ๊ทธ ๋ฐ๋๋ผ๊ณ ๋ณด๋ฉด ๋๋ค. heapq์์ ์ ๊ณตํ๋ ๋ฉ์๋ ๋ช ๊ฐ์ง๋ฅผ ์์๋ณด๋ฉด ๋ค์๊ณผ ๊ฐ๋ค.
heapq.heappop(heap)
์ด ๋ฉ์๋๋ ํ์์ ๊ฐ์ฅ ์์ ๊ฐ์ ์ญ์ ํ ๋ค ๋ฆฌํดํ๋ค. ์ด๋ ๋ฆฌ์คํธ์ pop๊ณผ๋ ๋ค๋ฅด๊ฒ pop์ ํ๊ณ ๋ ๋ค์๋ ํ์ ๊ตฌ์กฐ๋ฅผ ์ ์งํ๋ ๊ฒ์ด๋ค. ๋ฐ๋ผ์ heappop์ ํตํด์ ๊ฐ์ฅ ์์ ๊ฐ ๋๊ฐ๋ฅผ ๋ฐํ ๋ฐ๊ธฐ ์ํด ์ฐ์์ ์ผ๋ก pop์ ๋ ๋ฒ ์ฌ์ฉํด๋ ํ ๊ตฌ์กฐ๊ฐ ์ ์ง ๋๋ ๊ฒ์ด๋ฉฐ ์ด๋ ์์ ์์ฑํ ์ฝ๋์์ min() ์ ํตํด ์ต์๊ฐ์ ์ฐพ๊ธฐ ์ํด ์ ๋ ฌ์ ์๋ํ๋ ์ผ์ด ์์ด๋ ๋๋ค๋ ๊ฒ์ ์๋ฏธํ๋ค.
์ฌ๊ธฐ์ ๋ ์ข์ ๋ฉ์๋๊ฐ ์กด์ฌํ๋ค.
heapq.heappushpop(heap, item)
item์ heap์ ์ถ๊ฐ์ํค๋ ๋ฉ์๋์ด๋ค. ์ด๋ฅผ ์ ์ ํ ์ฌ์ฉํด์ ์ฐ์ฐ์ ํตํด ๊ตฌํ ๊ฐ์ ์๋ ํ์ ๋ค์ append ์์ผ์ฃผ๋ฉด ๋๋ค.
IndexError
heapq.heappop(heap)์ ๋์ด์ popํ ๊ฐ์ด ์๋, ์ฆ ๋น ํ์์ pop์ ํ ๊ฒฝ์ฐ IndexError๋ฅผ ๋ฐ์ํ๋ค.
๋ง์ฝ ๋ ์ด์ ์์ ๋ ๊ฐ์ ๊ฐ์ด ์กด์ฌํ์ง ์์์ ๊ธฐ์ค์ ๋ง๋ ์๋ก์ด ํฐ ๊ฐ์ ๋ง๋ค ์ ์๋ ๊ฒฝ์ฐ -1์ ๋ฐํํด์ผ ํ๊ธฐ ๋๋ฌธ์ indexError๊ฐ ์ผ์ด๋ ๊ฒฝ์ฐ try{} exception{}์ ํตํด์ -1์ ๋ฐํํ๋๋ก ํด์ฃผ๋ฉด ๋๋ค.
import heapq
def solution(scovile, k):
answer = 0
h = []
for i in scovile:
heapq.heappush(h, i)
# it is like that...
# heapq.heapify(scovile)
try :
min_val = heapq.heappop(h)
while min_val < k:
min_val = heapq.heappushpop(h, min_val + heapq.heappop(h) * 2)
answer += 1
return answer
except IndexError :
return -1
scovile = [1, 2, 3, 9, 10, 12]
k = 7
theAnswer = solution(scovile, k)
print(theAnswer)
๋๊ธ