[PS] 99ํด๋ฝ ์ฝํ ์คํฐ๋ 9์ผ์ฐจ TIL (๋ ๋งต๊ฒ)
ํ๊ทธ: 99ํด๋ฝ, PS, TIL, ์ฝ๋ฉํ ์คํธ์ค๋น, ํญํด99, ํ(Heap)
์นดํ ๊ณ ๋ฆฌ: PS
![]()
๋ฌธ์

ํ์ด
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
class Solution {
public int solution(int[] scoville, int K) {
PriorityQueue<Integer> minHeap = new PriorityQueue<>();
for (int j : scoville) {
minHeap.add(j);
}
return getInteger(minHeap, K);
}
private Integer getInteger(PriorityQueue<Integer> minHeap, int K) {
int count = 0;
while (minHeap.peek() < K) {
// 1
if (minHeap.size() <= 1) {
count = -1;
break;
}
Integer firstMin = minHeap.poll();
Integer secondMin = minHeap.poll();
int newScoville = firstMin + (secondMin * 2);
// 2
minHeap.add(newScoville);
count++;
}
return count;
}
}
๋ฌธ์ ์์ ์์ ์์๋ฅผ ๊ณ์ํด์ ๋ฝ์๋ด ๊ณ์ฐํ๋ ์กฐ๊ฑด์ด ์๊ธฐ๋๋ฌธ์ ์ฐ์ ์์ ํ(Heap) ์ ์ฌ์ฉํ๊ธฐ์ ์ข์ ๋ณด์ธ๋ค.
์ด๊ธฐ ์
๋ ฅ ๋ฐฐ์ด์ ๋ชจ๋ Heap ์ ๋ฃ์ผ๋ฉด ์ดํ poll() ๋ก ๊บผ๋ผ๋๋ง๋ค ์ต์๊ฐ์ด ๊บผ๋ด์ง๊ธฐ ๋๋ฌธ์ ํธ๋ฆฌํ๋ค.
(๋ง์ฝ ์ต์ํ์ด ์๋๋ผ ์ต๋ํ์ด ํ์ํ๋ค๋ฉด new PriorityQueue<>(Comparator.reverseOrder()) ์ด๋ฐ ์์ผ๋ก Comparator ํ์
์ ์ ๋ ฌ ์กฐ๊ฑด์ ๋๋ฒ์งธ ์ธ์๋ก ๋ฃ์ด์ฃผ๋ฉด ๋๋ค.)
๋จผ์ ์ค์ฝ๋น ์ง์๋ฅผ ์ฌ๊ณ์ฐ ํด์ ๋ค์ ํ์ผ๋ก ๊ณ์ํด์ ๋ฃ์ด์ฃผ๋ ์์
์ด ํ์ํ๋ค. 2๋ฒ ์ฃผ์์์ ๊ทธ ์ญํ ์ ํ๊ณ ์๋ค.
๊ทธ ํ ์์
ํ์๋ฅผ 1 ์ฆ๊ฐ์์ผ ์ค ๋ค ๋ค์ while ๋ฌธ ์กฐ๊ฑด์ ํ์ธํ๊ฒ ๋๋ค. ์ต์ํ์์ minHeap.peek() ์ ํญ์ ์ต์๊ฐ์ ๋ฐํํ๊ธฐ ๋๋ฌธ์
๋ฌธ์ ์์ ์๊ตฌํ๋ ๋ชจ๋ ํญ๋ชฉ์ด K ๋ณด๋ค ์ปค์ผ ๋๋ค ๋ ๊ฒ์ ์ต์๊ฐ์ด K ๋ณด๋ค ํฌ๋ค๋ฉด ๋๋จธ์ง ํญ๋ชฉ์ ๋ณผ ํ์ ์๊ฒ๋๋ค.
๋จ์ง ํ์์ ๊บผ๋ธ ๊ทธ ๊ฐ๋ง ๊ฐ์ง๊ณ ์กฐ๊ฑด์ ๋ง๋ค ์ ์์ด ์ฝ๋๊ฐ ๊ฐ๊ฒฐํด ์ง๋ค.
๋ง์ฝ ์ฐ์ ์์ ํ๊ฐ ์๋ ArrayList ๋ ๋ฐฐ์ด๋ก ํ๊ฒ๋๋ฉด ์ ๋ ฌ ํ๋ ์์ ์ ์ถ๊ฐ๋ก ํด์ผ๋๋ค.
while ๋ฌธ์ ์ถฉ๋ถํ ๋๊ณ ๋๋ฉด ํ์ ํญ๋ชฉ์ด ๊ณ์ ์ค์ด๋ค์ด ๊ฒฐ๊ตญ ์ ๊ณ์ฐ์์ ์ํํ ๋งํผ์ ํญ๋ชฉ๋ ๋จ์ง ์๊ฒ ๋ ๊ฒ์ด๋ค. ๊ทธ ์กฐ๊ฑด์ด 1๋ฒ ์ฃผ์์ ํด๋นํ๋ค. ํ์ ํญ๋ชฉ์ด 1๊ฐ ์ดํ๋ก ๋จ์ด์ง๊ฒ ๋๋ฉด ๋์ด์ newScoville ๊ฐ์ ๋ง๋ค ์ ์๊ธฐ ๋๋ฌธ์ ๋ฌธ์ ์์ ์๊ตฌํ๋ -1 ์ ๋ฆฌํดํด์ค์ผ ํ๋ค.
๋๊ธ๋จ๊ธฐ๊ธฐ