2021. 1. 10. 01:21ใ๐ Algorithm/๐ช๐ป Python ๋ฌธ์ ํ์ด
๋ฌธ์ ์ค๋ช
๋งค์ด ๊ฒ์ ์ข์ํ๋ Leo๋ ๋ชจ๋ ์์์ ์ค์ฝ๋น ์ง์๋ฅผ K ์ด์์ผ๋ก ๋ง๋ค๊ณ ์ถ์ต๋๋ค. ๋ชจ๋ ์์์ ์ค์ฝ๋น ์ง์๋ฅผ K ์ด์์ผ๋ก ๋ง๋ค๊ธฐ ์ํด Leo๋ ์ค์ฝ๋น ์ง์๊ฐ ๊ฐ์ฅ ๋ฎ์ ๋ ๊ฐ์ ์์์ ์๋์ ๊ฐ์ด ํน๋ณํ ๋ฐฉ๋ฒ์ผ๋ก ์์ด ์๋ก์ด ์์์ ๋ง๋ญ๋๋ค.
์์ ์์์ ์ค์ฝ๋น ์ง์ = ๊ฐ์ฅ ๋งต์ง ์์ ์์์ ์ค์ฝ๋น ์ง์ + (๋ ๋ฒ์งธ๋ก ๋งต์ง ์์ ์์์ ์ค์ฝ๋น ์ง์ * 2)
Leo๋ ๋ชจ๋ ์์์ ์ค์ฝ๋น ์ง์๊ฐ K ์ด์์ด ๋ ๋๊น์ง ๋ฐ๋ณตํ์ฌ ์์ต๋๋ค.
Leo๊ฐ ๊ฐ์ง ์์์ ์ค์ฝ๋น ์ง์๋ฅผ ๋ด์ ๋ฐฐ์ด scoville๊ณผ ์ํ๋ ์ค์ฝ๋น ์ง์ K๊ฐ ์ฃผ์ด์ง ๋, ๋ชจ๋ ์์์ ์ค์ฝ๋น ์ง์๋ฅผ K ์ด์์ผ๋ก ๋ง๋ค๊ธฐ ์ํด ์์ด์ผ ํ๋ ์ต์ ํ์๋ฅผ return ํ๋๋ก solution ํจ์๋ฅผ ์์ฑํด์ฃผ์ธ์.
์ ํ ์ฌํญ
- scoville์ ๊ธธ์ด๋ 2 ์ด์ 1,000,000 ์ดํ์ ๋๋ค.
- K๋ 0 ์ด์ 1,000,000,000 ์ดํ์ ๋๋ค.
- scoville์ ์์๋ ๊ฐ๊ฐ 0 ์ด์ 1,000,000 ์ดํ์ ๋๋ค.
- ๋ชจ๋ ์์์ ์ค์ฝ๋น ์ง์๋ฅผ K ์ด์์ผ๋ก ๋ง๋ค ์ ์๋ ๊ฒฝ์ฐ์๋ -1์ return ํฉ๋๋ค.
์ ์ถ๋ ฅ ์์
-
์ค์ฝ๋น ์ง์๊ฐ 1์ธ ์์๊ณผ 2์ธ ์์์ ์์ผ๋ฉด ์์์ ์ค์ฝ๋น ์ง์๊ฐ ์๋์ ๊ฐ์ด ๋ฉ๋๋ค.
์๋ก์ด ์์์ ์ค์ฝ๋น ์ง์ = 1 + (2 * 2) = 5
๊ฐ์ง ์์์ ์ค์ฝ๋น ์ง์ = [5, 3, 9, 10, 12] -
์ค์ฝ๋น ์ง์๊ฐ 3์ธ ์์๊ณผ 5์ธ ์์์ ์์ผ๋ฉด ์์์ ์ค์ฝ๋น ์ง์๊ฐ ์๋์ ๊ฐ์ด ๋ฉ๋๋ค.
์๋ก์ด ์์์ ์ค์ฝ๋น ์ง์ = 3 + (5 * 2) = 13
๊ฐ์ง ์์์ ์ค์ฝ๋น ์ง์ = [13, 9, 10, 12]
๋ชจ๋ ์์์ ์ค์ฝ๋น ์ง์๊ฐ 7 ์ด์์ด ๋์๊ณ ์ด๋ ์์ ํ์๋ 2ํ์ ๋๋ค.
ํ์ด ๊ณผ์
์๋ฃ๊ตฌ์กฐ heap์ ์ด์ฉํ์ฌ ํ๋ฉด ํจ์จ์ฑ ํ ์คํธ๋ ๋ชจ๋ ํต๊ณผํ ์ ์๋ ๋ฌธ์ ์๋ค.
ํ์ง๋ง slicing์ ๋๋ฌด ์์ฃผ ์ฌ์ฉํ๋ฉด ์๊ฐ ๋ณต์ก๋๊ฐ ์ฆ๊ฐํ์ฌ ํจ์จ์ฑ ํ ์คํธ์ ์ฝ๊ฒ ํต๊ณผํ ์ ์์๋ค. ๊ทธ๋์ ์ต๋ํ slicing์ ์ค์ด๊ณ ,
while๋ฌธ์ ์ ๊ฒ ๋๋ฆฌ๋ ๋ฐฉ๋ฒ์ผ๋ก ๊ตฌํํ๋ค.
while๋ฌธ์ ์กฐ๊ฑด์ scoville ๊ธธ์ด๊ฐ 1๋ณด๋ค ํด ๋ (์ฆ, ๋ชจ๋ ์์๋ค์ ๋ค ๋๋ฆฐ ๊ฒฐ๊ณผ๊ฐ์ด K๋ณด๋ค ์์ผ๋ฉด ๊ตณ์ด while๋ฌธ์ ๊ณ์ ๋๋ฆด ํ์ ์๊ธฐ ๋๋ฌธ์) , scoville[0] ์ด K๋ณด๋ค ์์ ๋ ๋ฅผ ์กฐ๊ฑด์ผ๋ก ๋์๋ค.
scoville์ heapq.heapify๋ฅผ ํตํด heap์ผ๋ก ๋ฐ๊พธ์ด, MinHeap์ด ๋๋๋ก ํ์ฌ scoville[0]์ ํญ์ ์์ ๊ฐ์ด ๋์๋ค.
heapq.heappop์ ํตํด ์ ์ผ ์์ ๊ฐ๊ณผ ๋๋ฒ ์งธ๋ก ์์ ๊ฐ์ ๊บผ๋ด K๋ณด๋ค ํด ์ ์๋๋ก ๊ฐ์ ๊ตฌํ๊ณ , ๊ทธ ๊ฐ์ heapq.heappush๋ก ๋ค์ ๋ฃ์ด์ฃผ๋ ํ์์ผ๋ก ๊ตฌํํ๋ค.
while๋ฌธ์ ๋ชจ๋ ๋๊ณ ๋์ค๋ฉด, ๋ชจ๋ ์์์ K ์ด์์ผ๋ก ๋ง๋ค ์ ์๋ ๊ฒฝ์ฐ๋ฅผ -1์ ๋ฆฌํดํด์ค์ผํ๊ธฐ ๋๋ฌธ์ len(scoville)์ด 1์ธ ๊ฒฝ์ฐ(๋ชจ๋ ์์๋ฅผ ํตํด ๊ตฌํ ํฉ์ด K๋ณด๋ค ์์์ while๋ฌธ์ ๋น ์ ธ๋์จ ๊ฒฝ์ฐ์ด๊ธฐ ๋๋ฌธ) , scoville[0] < K ์ธ ๊ฒฝ์ฐ์๋ง return -1 ํ๋๋ก ๊ตฌํํ๋ค.
๋ชจ๋ ์์์ ๊ฐ์ ํตํด ๊ตฌํ ๊ฐ์ด ๋ฑ K์ ๊ฐ์ด ๊ฐ์ ๊ฒฝ์ฐ๊ฐ ์กด์ฌํ ์ ์๊ธฐ ๋๋ฌธ์ if ๋ฌธ ์กฐ๊ฑด์ ์์ ๊ฐ์ด ์งฐ๋ค.
import heapq
def solution(scoville, K):
answer = 0
heapq.heapify(scoville)
while len(scoville) > 1 and scoville[0] < K:
num = heapq.heappop(scoville) + (heapq.heappop(scoville) * 2)
answer += 1
heapq.heappush(scoville, num)
if len(scoville) == 1 and scoville[0] < K:
return -1
return answer
'๐ Algorithm > ๐ช๐ป Python ๋ฌธ์ ํ์ด' ์นดํ ๊ณ ๋ฆฌ์ ๋ค๋ฅธ ๊ธ
[Python - ๋ฐฑ์ค 2606] ๋ฐ์ด๋ฌ์ค (0) | 2021.01.12 |
---|---|
[Python - ํ๋ก๊ทธ๋๋จธ์ค Level2] ๊ธฐ๋ฅ ๊ฐ๋ฐ (0) | 2021.01.08 |
[Python - ๋ฐฑ์ค 1966] ํ๋ฆฐํฐ ํ (0) | 2021.01.08 |