๋งค์ด ๊ฒ์ ์ข์ํ๋ Leo๋ ๋ชจ๋ ์์์ ์ค์ฝ๋น ์ง์๋ฅผ K ์ด์์ผ๋ก ๋ง๋ค๊ณ ์ถ์ต๋๋ค. ๋ชจ๋ ์์์ ์ค์ฝ๋น ์ง์๋ฅผ K ์ด์์ผ๋ก ๋ง๋ค๊ธฐ ์ํด Leo๋ ์ค์ฝ๋น ์ง์๊ฐ ๊ฐ์ฅ ๋ฎ์ ๋ ๊ฐ์ ์์์ ์๋์ ๊ฐ์ด ํน๋ณํ ๋ฐฉ๋ฒ์ผ๋ก ์์ด ์๋ก์ด ์์์ ๋ง๋ญ๋๋ค.
์์ ์์์ ์ค์ฝ๋น ์ง์ = ๊ฐ์ฅ ๋งต์ง ์์ ์์์ ์ค์ฝ๋น ์ง์ + (๋ ๋ฒ์งธ๋ก ๋งต์ง ์์ ์์์ ์ค์ฝ๋น ์ง์ * 2)
Leo๋ ๋ชจ๋ ์์์ ์ค์ฝ๋น ์ง์๊ฐ K ์ด์์ด ๋ ๋๊น์ง ๋ฐ๋ณตํ์ฌ ์์ต๋๋ค.
Leo๊ฐ ๊ฐ์ง ์์์ ์ค์ฝ๋น ์ง์๋ฅผ ๋ด์ ๋ฐฐ์ด scoville๊ณผ ์ํ๋ ์ค์ฝ๋น ์ง์ K๊ฐ ์ฃผ์ด์ง ๋, ๋ชจ๋ ์์์ ์ค์ฝ๋น ์ง์๋ฅผ K ์ด์์ผ๋ก ๋ง๋ค๊ธฐ ์ํด ์์ด์ผ ํ๋ ์ต์ ํ์๋ฅผ return ํ๋๋ก solution ํจ์๋ฅผ ์์ฑํด์ฃผ์ธ์.
scoville | K | return |
---|---|---|
[1, 2, 3, 9, 10, 12] | 7 | 2 |
์ค์ฝ๋น ์ง์๊ฐ 1์ธ ์์๊ณผ 2์ธ ์์์ ์์ผ๋ฉด ์์์ ์ค์ฝ๋น ์ง์๊ฐ ์๋์ ๊ฐ์ด ๋ฉ๋๋ค.
์๋ก์ด ์์์ ์ค์ฝ๋น ์ง์ = 1 + (2 * 2) = 5
๊ฐ์ง ์์์ ์ค์ฝ๋น ์ง์ = [5, 3, 9, 10, 12]
์ค์ฝ๋น ์ง์๊ฐ 3์ธ ์์๊ณผ 5์ธ ์์์ ์์ผ๋ฉด ์์์ ์ค์ฝ๋น ์ง์๊ฐ ์๋์ ๊ฐ์ด ๋ฉ๋๋ค.
์๋ก์ด ์์์ ์ค์ฝ๋น ์ง์ = 3 + (5 * 2) = 13
๊ฐ์ง ์์์ ์ค์ฝ๋น ์ง์ = [13, 9, 10, 12]
๋ชจ๋ ์์์ ์ค์ฝ๋น ์ง์๊ฐ 7 ์ด์์ด ๋์๊ณ ์ด๋ ์์ ํ์๋ 2ํ์ ๋๋ค.
์ด๋ ๊ฒ ์ฌ๋ฌ ์์๋ค ์ค์์ ์ต์๊ฐ์ด๋ ์ต๋๊ฐ์ ํ์ฉํด์ผ ํ๋ ๋ฌธ์ ๋ ํ(Heap)์ ํ์ฉํ๋ฉด ์ฝ๊ฒ ์ ๊ทผํ ์ ์๊ฒ ๋ค๋ ์๊ฐ์ด ๋ค์๋ค. ์ด๋ฒ์๋ ์ต์๊ฐ์ K
๋ ๋น๊ตํด์ผ ํ๊ธฐ ๋๋ฌธ์ ์ต์ํ์ ์ฌ์ฉํ๊ธฐ๋ก ํ๋ค.
ํ์ ๋ํ ๊ฐ๋ ์ ์๊ณ ์์์ผ๋, ์ค์ ๋ก ๋ฌธ์ ์ ์ ์ฉํด ๋ณธ ๊ฒฝํ์ ์์ด์ ๋ฌธ๋ฒ ๊ฐ์ ๊ฒฝ์ฐ์๋ ๊ฒ์์ ํด์ ๋ฌธ์ ๋ฅผ ํ์๋ค.
import java.util.*;
class Solution {
public int solution(int[] scoville, int K) {
PriorityQueue<Integer> scvHeap = new PriorityQueue<>();
int count = 0;
for (int i = 0; i < scoville.length; i++) {
scvHeap.add(scoville[i]);
}
while (scvHeap.peek() < K) {
int a = scvHeap.poll();
int b = scvHeap.poll();
scvHeap.add(a + b * 2);
count++;
}
if (count == 0) {
count = -1;
}
return count;
}
}
์ฐ์ , scoville
์ ๋ชจ๋ ์์๋ฅผ ์ต์ํ์ ๋ฃ์ด์ฃผ์๋ค.
๊ทธ๋ฆฌ๊ณ , peek()
ํจ์๋ก ๋ฃจํธ ๋
ธ๋์ ๊ฐ(์ต์๊ฐ)์ ํ์ธํด K
๊ฐ๊ณผ ๋น๊ตํด์ K
๋ณด๋ค ํฐ ์ค์ฝ๋น ์ง์๊ฐ ๋ ๋๊น์ง ์์์ ์๋ ๊ณผ์ ์ ๋ฐ๋ณตํ๋๋ก ํด์ฃผ์๋ค.
์์์ ์๊ธฐ ์ํด์ ์ค์ฝ๋น ์ง์๊ฐ ๊ฐ์ฅ ๋ฎ์ ์์ ์ฆ, ๋ฃจํธ ๋
ธ๋์ ๊ฐ์ ๋จผ์ ์ถ์ถํ๊ณ ,
์ค์ฝ๋น ์ง์๊ฐ ๋ ๋ฒ์งธ๋ก ๋ฎ์ ์์์ ์ฐ๋ฌ์ ์ถ์ถํด a
์ b
์ ๊ฐ๊ฐ ๋ฃ์ด์ฃผ์๋ค.
๊ทธ๋ฆฌ๊ณ ๋ฌธ์ ์ ์ ์๋ ๋ฐฉ๋ฒ์ ๋ฐ๋ผ a
์ b
๋ฅผ ์กฐํฉํ ํ, ๋ค์ ํ์ ๋ฃ์ด์ฃผ์๋ค.
์ต์ข
๋ฐํํด์ผ ํ๋ ๊ฐ์ ์์์ ์์ ํ์์ด๊ธฐ ๋๋ฌธ์, count
๋ณ์์ 1์ ๋ํด์ฃผ์๋ค.
๋ง์ง๋ง์ผ๋ก ๋ฌธ์ ์ ํ ์ฌํญ์ "๋ชจ๋ ์์์ ์ค์ฝ๋น ์ง์๋ฅผ K ์ด์์ผ๋ก ๋ง๋ค ์ ์๋ ๊ฒฝ์ฐ์๋ -1์ return ํฉ๋๋ค."๋ผ๋ ๋ถ๋ถ์ ๊ณ ๋ คํ๊ธฐ ์ํด count
๊ฐ 0์ธ ๊ฒฝ์ฐ ์ฆ, ์์์ ์์ง ์๋ ๊ฒฝ์ฐ์๋ -1์ count
์ ์ ์ฅ๋๋๋ก ํ์๋ค.
๊ทธ๋ฌ๋๋ ๋ช๋ช ํ ์คํธ ์ผ์ด์ค์์ ์คํจ๊ฐ ๋ฐ์ํ์๋ค..!
์๊ณ ๋ณด๋, ๋ชจ๋ ์์์ ์ค์ฝ๋น ์ง์๋ฅผ K ์ด์์ผ๋ก ๋ง๋ค ์ ์๋ ๊ฒฝ์ฐ๋ฅผ ์ฒ๋ฆฌํ๋ ๋ฐฉ๋ฒ์ ๋ฌธ์ ๊ฐ ์์๋ค.
์ค์ฝ๋น ์ง์๊ฐ K๋ณด๋ค ์์ ์์๊ฐ 2๊ฐ ๋จ์ ์๊ณ , ๋ ์์๋ฅผ ์กฐํฉํด๋ K
๋ณด๋ค ์์ ๊ฒฝ์ฐ, -1์ด ๋ฐํ๋์ด์ผ ํ๋๋ฐ,
๋ด๊ฐ ์ง ์ฝ๋์์๋ ๊ทธ๋๋ก while๋ฌธ์ ๋ค์ ํธ์ถํด๋ฒ๋ฆฌ๊ณ , ์์๊ฐ ํ ๊ฐ ๋ฟ์ธ๋ฐ ๋ ๊ฐ๋ฅผ ์ถ์ถํ๋ ค๊ณ ํ๋ ๋ฐํ์ ์๋ฌ๊น์ง ๋ฐ์ํด๋ฒ๋ฆฌ๋ ๊ฒ์ด์๋ค!
import java.util.*;
class Solution {
public int solution(int[] scoville, int K) {
PriorityQueue<Integer> scvHeap = new PriorityQueue<>();
int count = 0;
for (int i = 0; i < scoville.length; i++) {
scvHeap.add(scoville[i]);
}
while (!scvHeap.isEmpty() && scvHeap.peek() < K) {
int a = scvHeap.poll();
if (!scvHeap.isEmpty()) {
int b = scvHeap.poll();
scvHeap.add(a + b * 2);
count++;
}
else {
count = -1;
}
}
return count;
}
}
๊ทธ๋์ while ์กฐ๊ฑด์ ํ์ด ๋น์ด์์ง ์๋ค๋ ์กฐ๊ฑด์ ์ถ๊ฐํด ์ฃผ์๊ณ , ๋จ์ ์๋ ์์์ ๊ฐฏ์๊ฐ 2๊ฐ ์ด์์ธ ๊ฒฝ์ฐ์๋ง ์์์ ์๋๋ก ์กฐ๊ฑด๋ฌธ์ ์ถ๊ฐํด ์ฃผ์๋ค. ์ด๋ ๊ฒ ์ฒ๋ฆฌํจ์ผ๋ก์จ, ๋ง์ฝ ์์๊ฐ ํ ๊ฐ ๋ฟ์ธ ์ํฉ์์๋ count
์ -1์ด ์ ์ฅ๋๋๋ก ๊ตฌํํ ์ ์์๋ค๐
๐ฅ