ํ์คํ, ์นด์นด์ค ์ฝํ ๊ธฐ์ถ๋ฌธ์ ๋ผ ๊ทธ๋ฐ์ง ์ด๋ ค์ ๋ค.
์ ํ์ฑ ํ ์คํธ๋, ์ฝ๊ฒ ํ ์ ์์๋๋ฐ ํจ์จ์ฑ ํ ์คํธ์์ ์ ์ ๋ฐ๋๊ฒ ๋งค์ฐ ํ๋ค์๊ณ ๊ฒฐ๊ตญ ๋ค๋ฅธ ์ฌ๋๋ค์ ํ์ด๋ฅผ ์ฐธ๊ณ ํ๋ค..ใ
import heapq
def solution(food_times, k):
answer = -1
# ์์ ์ดํฉ ๋ณด๋ค k๊ฐ ํฌ๋ฉด ์ญ์ทจํ ์์์ด ์์ด์ง๋ฏ๋ก -1 ๋ฐํ
if sum(food_times) <=k:
return -1
foods = []
# ์ฐ์ ์์ ํ์ [์์์,์์๋ฒํธ] ์
๋ ฅ, ์์์์ ๊ธฐ์ค์ผ๋ก ์ค๋ฆ์ฐจ์ ์ ๋ ฌ์ด ๋์ด์์ ๊ฒ
for i in range(len(food_times)):
heapq.heappush(foods,[food_times[i],i+1])
eat = 0
while foods:
#์์์ ๋ค ๋จน๋๋ฐ ๊ฑธ๋ฆฌ๋ ์๊ฐ (์ต์๋ถํฐ)
time = (foods[0][0]-eat)*len(foods)
if time <= k:
food, idx = heapq.heappop(foods)
k-=time
eat = food
else:
idx = k%len(foods)
foods.sort(key=lambda x : x[1])
return foods[idx][1]
return answer
์ฝ๋๋ ์์ ๊ฐ๋ค.
์ฌ์ค์ while ๋ฌธ ๋ค์ด๊ฐ๊ธฐ ์ ๊ฐ์ง๋, ์ฐ์ ์์ ํ์ [์์์, ์์๋ฒํธ]๋ฅผ ๋ฃ๋ ๊ณผ์ ์ด๊ณ while ๋ฌธ ๋ถํฐ๊ฐ ์ดํด๊ฐ ์ข ํ์ํ๋ค.
๋๋ฆ ๋ด๊ฐ ์ดํดํ ๋ฐฉ๋ฒ์ ๋ฐํ์ผ๋ก ์ ์ค๋ช ์ ํด๋ณด๊ฒ ๋ค..ใ ใ
์์ ๋ก ํ์ธํด๋ณด๊ฒ ๋ค.
ํ์ฌ 1๋ฒ์ ์์์ด 3๊ฐ, 2๋ฒ์ 1๊ฐ, 3๋ฒ์ 1๊ฐ๊ฐ ์๋ ์ํฉ์ด๋ค.
๊ทธ๋ฆฌ๊ณ ์ฐ์ ์์ ํ์ ์์ ์์ ๊ธฐ์ค์ผ๋ก ์ ๋ ฅํ๋ฉด ์ค๋ฅธ์ชฝ๊ณผ ๊ฐ์ด ์ ๋ ฌ๋๋ค.
๊ทธ๋ฆฌ๊ณ ๋ชจ๋ ๋ฒํธ๋ฅผ ์ต์ ์์์ ๋งํผ์ ํ ์ธ์ดํด์ ๋จน์ ์ ์๋์ง ํ์ธํ๋ค.
์ ์์์์ ์ต์ ์์์์ด 1์ด์ด๋ฏ๋ก ์ด 3์ด๊ฐ ๊ฑธ๋ฆฐ๋ค.
k๊ฐ 4์ด์ธ ๊ฒฝ์ฐ 1์ด๊ฐ ๋จ๊ฒ ๋๋ค.
๊ทธ๋ฌ๋ฉด ๋ค์ ์ต์ ์์ธ 3๋ฒ์ผ๋ก ์ ๊ณผ์ ์ ๋ ํด๋ณธ๋ค.
๋ค์ ์์ ์ต์์์ ์ฐธ๊ณ ๋ก 2๊ฐ ์๋๋ผ 1์ด๋ค. ์๋ํ๋ฉด ์ฒซ ์ฌ์ดํด์์ ๋ชจ๋ ๋ฒํธ์ ์์์ด 1๋งํผ ๊ฐ์ํ๊ธฐ ๋๋ฌธ์ด๋ค.
๊ทธ๋ฌ๋ฏ๋ก ํ ์ธ์ดํด์ ๋๊ธฐ ์ํด์๋ 2์ด๊ฐ ํ์ํ๋ฐ ๋จ์ k๋ 1์ด๋ฏ๋ก ํ ์ธ์ดํด์ ๋ ์ ์์ด์ง๋ค.
์ธ์ดํด์ ๋ ์ ์๋ ์ํฉ์ด๋ผ๋ฉด ๋ค์ ์์ ๋ฒํธ ์์ผ๋ก ์ ๋ ฌ ํ, k๋ฅผ ์ด์ฉํด์ ์์ ๋ฒํธ๋ฅผ ์ฐพ์ผ๋ฉด ๋๋ค.
2๋ฒ ์์์ ๋ค ๋จน์์ผ๋ฏ๋ก ๊ณ ๋ คํ์ง ์์๋ ๋๊ณ , k๊ฐ 1์ด๋ฏ๋ก 0~1์ด๋์ 1๋ฒ์ ๋จน๊ณ ๋ฐฉ์ก์ด ์ค๋จ๋๋ฏ๋ก
๋ฐฉ์ก์ด ์ฌ๊ฐ๋์์๋ ๋จน์ ์์์ 3๋ฒ์ด ๋๋ค.
์ฆ, k๊ฐ ์ต์ ์์์์ผ๋ก ํ์ฌ์ดํด์ ๋ ์ ์์ ๋, foods[k][1] ์ด ๋ต์ด ๋๋ค.
์์ ๊ฐ์ ๊ฒฝ์ฐ๋ k=2 ์์ ๋ค์ ์์ ์ต์๊ฐ์ด 2์ด์ธ๋ฐ ํ์ฌ์ดํด์ ๋๋๋ฐ 4์ด๊ฐ ๊ฑธ๋ฆฌ๋ฏ๋ก ์ธ์ดํด์ ๋ ์ ์์ด์ง๋ค.
์ด ์ํฉ์์ ๋ค์ ์์ ๋ฒํธ์์ผ๋ก ์ ๋ ฌํ ๋ค, ์ค๋จ ๋ค ๋จน์ ์์ ๋ฒํธ๋ฅผ ๊ตฌํด์ผํ๋ค.
foods[k][1] ๋ก ๊ตฌํ๊ฒ ๋๋ฉด ์ธ๋ฑ์ค ๋ฒ์ ์ค๋ฅ๊ฐ ์๊ธธ ์ ์๋ค.
๋ฐ๋ผ์ foods[k%len(foods)][1] ๋ก ๊ตฌํด์ผํ๋ค. (foods๋ ๋ค ๋จน์ ์์์ ํฌํจ๋์ง ์์)
๋ฐ๋ผ์ foods[0][1]์ด ๋๊ณ ๋จน์ ์์์ 1๋ฒ์ด ๋๋ค.