๐ ๋ฌธ์ ๋งํฌ
๋ฌด์ง์ ๋จน๋ฐฉ ๋ผ์ด๋ธ
์ฝ๋ฉํ
์คํธ ์ฐ์ต - ๋ฌด์ง์ ๋จน๋ฐฉ ๋ผ์ด๋ธ ๋ฌธ์ ์
๋๋ค.
๐ก ๋ฌธ์ ํ์
- ์์์ 1๋ฒ๋ถํฐ ์์๋๋ก, 1์ด์ 1๊ฐ์ฉ ๋จน๋ค๊ฐ ๋จ์ ์๊ฐ์ด 0์ธ ์์์ ๊ฑด๋๋ด๋ค.
- ๋ง์ง๋ง ์์๊น์ง ๋ค ๋จน์ผ๋ฉด ๋ค์ 1๋ฒ ์์์ผ๋ก ๋์๊ฐ ๋ฐ๋ณตํ๋ค.
k์ด ํ์ ๋จน๊ณ ์์ ์์์ ๋ฒํธ๋ฅผ ๊ตฌํด์ผ ํ๋ฉฐ,k์ด๊ฐ ๋๊ธฐ ์ ์ ๋ชจ๋ ์์์ ๋ค ๋จน์ด๋ฒ๋ฆฌ๋ฉด-1์ ๋ฐํํ๋ค.k๊ฐ ์ต๋2 ร 10^13๊น์ง ์ฃผ์ด์ง ์ ์์ด, ๋งค ์ด ํ๋์ฉ ์๋ฎฌ๋ ์ด์ ํ๋ ๋ฐฉ์์ ์ฌ์ฉํ ์ ์๋ค.
๐๏ธ ์ ๊ทผ ๋ฐฉ๋ฒ
- ๋จ์์๋ ๋ชจ๋ ์์์ ์๊ฐ์ ํ ์ธต์ฉ ๋์์ ๊น์๋๊ฐ๋ค๊ณ ์๊ฐํ๋ค.
- ์๋ฅผ ๋ค์ด
[3, 1, 2]๋ผ๋ฉด[2, 0, 1] โ [1, 0, 0] โ [0, 0, 0]์์ผ๋ก ์ค์ด๋ ๋ค.
- ์๋ฅผ ๋ค์ด
- ๊ฐ์ฅ ์ ๊ฒ ๋จ์ ์์๋ถํฐ ์ฒ๋ฆฌํ๊ธฐ ์ํด ์ฐ์ ์์ ํ๋ฅผ ์ฌ์ฉํ๋ค.
- ์ด์ ์ ๊น์๋ธ ์ธต ์๋ฅผ
prev, ๋จ์ ์์ ๊ฐ์๋ฅผremain์ด๋ผ ํ๋ฉด, ์ต์ ์๊ฐ์ ์์๊น์ง ํ ์ธต์ ๊น๋ ๋ฐ ํ์ํ ์๊ฐ์(cur - prev) * remain์ด๋ค. k๊ฐ ์ด ์๊ฐ๋ณด๋ค ํฌ๊ฑฐ๋ ๊ฐ์ผ๋ฉด ๊ทธ ์ธต ์ ์ฒด๋ฅผ ์ค์ ๋ก ๊น์๋ด๊ณ (์๊ฐ์ด 0์ด ๋ ์์๋ค์ ํ์์ ์ ๊ฑฐ), ์์ผ๋ฉด ๋ ์ด์ ํ ์ธต ์ ์ฒด๋ฅผ ๊น์ ์ ์๋ค๋ ๋ป์ด๋ฏ๋ก ๋ฐ๋ณต์ ์ข ๋ฃํ๋ค.
- ์ด์ ์ ๊น์๋ธ ์ธต ์๋ฅผ
- ๋ฐ๋ณต์ด ๋๋๋ฉด ๋จ์ ์์๋ค์ ์๋ ๋ฒํธ ์์ผ๋ก ์ ๋ ฌํ๊ณ ,
k % remain๋ฒ์งธ ์์์ ์ฐพ์ ๋ฐํํ๋ค.
๐งฉ ์ฝ๋ ๊ตฌํ
import java.util.*;
class Solution {
public int solution(int[] food_times, long k) {
long total = 0;
for (int time : food_times) {
total += time;
}
if (total <= k) {
return -1;
}
PriorityQueue<int[]> pq = new PriorityQueue<>( // {time, idx}
Comparator.comparingInt(arr -> arr[0])
);
for (int idx = 0; idx < food_times.length; ++idx) {
pq.offer(new int[]{food_times[idx], idx + 1});
}
long prev = 0;
long remain = food_times.length;
while (!pq.isEmpty()) {
long cur = pq.peek()[0];
long spend = (cur - prev) * remain;
if (k >= spend) {
k -= spend;
prev = cur;
while (!pq.isEmpty() && pq.peek()[0] == cur) {
pq.poll();
remain--;
}
} else {
break;
}
}
List<int[]> foods = new ArrayList<>(pq);
foods.sort(Comparator.comparingInt(a -> a[1]));
return foods.get((int) (k % remain))[1];
}
}