๐
2025-10-31
์ฐ์ ์์ ํ๋ ๋จผ์ ๋ค์ด๊ฐ ๊ฒ์ด ๋จผ์ ๋์ค๋ ์ผ๋ฐ ํ์ ๋ฌ๋ฆฌ ์ฐ์ ์์๊ฐ ๋์ ๊ฒ์ด ๋จผ์ ๋์จ๋ค.
๋ด๋ถ ๊ตฌ์กฐ๋ Heap์ผ๋ก ์ด๋ฃจ์ด์ ธ ์๋ค.
Heap์ ํต์ฌ ๊ท์น
Heap์ ์ฌ์ฉํ๋ ๊ฒฝ์ฐ
๋ฌธ์ ๋งํฌ
๋ฌธ์ ์ค๋ช
์คํธ๋ ์์ฆ ๋ํ์ค ๊ฒ์์ ํน ๋น ์ ธ ์์ต๋๋ค. ๋ํ์ค ๊ฒ์์ ์คํธ๊ฐ ๋ณด์ ํ ๋ณ์ฌ n๋ช
์ผ๋ก ์ฐ์๋๋ ์ ์ ๊ณต๊ฒฉ์ ์์๋๋ก ๋ง๋ ๊ฒ์์
๋๋ค. ๋ํ์ค ๊ฒ์์ ๋ค์๊ณผ ๊ฐ์ ๊ท์น์ผ๋ก ์งํ๋ฉ๋๋ค.
์คํธ๋ ์ฒ์์ ๋ณ์ฌ n๋ช
์ ๊ฐ์ง๊ณ ์์ต๋๋ค.
๋งค ๋ผ์ด๋๋ง๋ค enemy[i]๋ง๋ฆฌ์ ์ ์ด ๋ฑ์ฅํฉ๋๋ค.
๋จ์ ๋ณ์ฌ ์ค enemy[i]๋ช
๋งํผ ์๋ชจํ์ฌ enemy[i]๋ง๋ฆฌ์ ์ ์ ๋ง์ ์ ์์ต๋๋ค.
์๋ฅผ ๋ค์ด ๋จ์ ๋ณ์ฌ๊ฐ 7๋ช
์ด๊ณ , ์ ์ ์๊ฐ 2๋ง๋ฆฌ์ธ ๊ฒฝ์ฐ, ํ์ฌ ๋ผ์ด๋๋ฅผ ๋ง์ผ๋ฉด 7 - 2 = 5๋ช
์ ๋ณ์ฌ๊ฐ ๋จ์ต๋๋ค.
๋จ์ ๋ณ์ฌ์ ์๋ณด๋ค ํ์ฌ ๋ผ์ด๋์ ์ ์ ์๊ฐ ๋ ๋ง์ผ๋ฉด ๊ฒ์์ด ์ข
๋ฃ๋ฉ๋๋ค.
๊ฒ์์๋ ๋ฌด์ ๊ถ์ด๋ผ๋ ์คํฌ์ด ์์ผ๋ฉฐ, ๋ฌด์ ๊ถ์ ์ฌ์ฉํ๋ฉด ๋ณ์ฌ์ ์๋ชจ์์ด ํ ๋ผ์ด๋์ ๊ณต๊ฒฉ์ ๋ง์ ์ ์์ต๋๋ค.
๋ฌด์ ๊ถ์ ์ต๋ k๋ฒ ์ฌ์ฉํ ์ ์์ต๋๋ค.
์คํธ๋ ๋ฌด์ ๊ถ์ ์ ์ ํ ์๊ธฐ์ ์ฌ์ฉํ์ฌ ์ต๋ํ ๋ง์ ๋ผ์ด๋๋ฅผ ์งํํ๊ณ ์ถ์ต๋๋ค.
์คํธ๊ฐ ์ฒ์ ๊ฐ์ง๊ณ ์๋ ๋ณ์ฌ์ ์ n, ์ฌ์ฉ ๊ฐ๋ฅํ ๋ฌด์ ๊ถ์ ํ์ k, ๋งค ๋ผ์ด๋๋ง๋ค ๊ณต๊ฒฉํด์ค๋ ์ ์ ์๊ฐ ์์๋๋ก ๋ด๊ธด ์ ์ ๋ฐฐ์ด enemy๊ฐ ๋งค๊ฐ๋ณ์๋ก ์ฃผ์ด์ง๋๋ค. ์คํธ๊ฐ ๋ช ๋ผ์ด๋๊น์ง ๋ง์ ์ ์๋์ง return ํ๋๋ก solution ํจ์๋ฅผ ์์ฑํด์ฃผ์ธ์.
์ ํ์ฌํญ
๋ผ์ด๋๋ณ enemy์ ์์ ํฉ๊ณ๋ฅผ ๊ตฌํ๋ฉด์ ๊ทธ ์ค ์์ ๊ฐ k๊ฐ๋ฅผ ๋ฒกํฐ์ ๋ฃ๊ณ ๋ฐ๋ณต๋ฌธ์ผ๋ก ํญ์ ๋น๊ตํ๋ ๊ฒ์ ๋นํจ์จ์ ์ด๋ผ Min Heap ์ฐ์ ์์ ํ๋ฅผ ์ฌ์ฉํ์ฌ ๋ฌธ์ ๋ฅผ ํ์๋ค.
#include <vector>
#include <queue>
using namespace std;
int solution(int n, int k, vector<int> enemy) {
int answer = 0;
int totalRound = enemy.size();
if(k>=totalRound) return totalRound;
priority_queue<int, vector<int>, greater<int>> minHeap;
int sum=0;
int sumK=0;
for(int i : enemy)
{
if(minHeap.size()<k)
{
minHeap.push(i);
sumK += i;
}
else if(i>minHeap.top())
{
sumK -= minHeap.top();
minHeap.pop();
minHeap.push(i);
sumK += i;
}
sum += i;
if(sum-sumK>n)
{
break;
}
else
{
++answer;
}
}
return answer;
}
์ถ์ฒ ํ๋ก๊ทธ๋๋จธ์ค: ๋ํ์ค ๊ฒ์