- greedy
- ๋๋น ์ฐ์ ํ์
- Study
- PGM
- CodingTest
- ๋ฐฑํธ๋ํน
- LV2
- ๊ตฌํ
- ๋ฌธ์์ด
- ์ ๋ ฌ
- SpringBoot
- ๊ทธ๋ํ ํ์
- Brute Force Algorithm
- ๊ต์ฌ
- sort
- DP
- queue
- BFS
- ์๋ฎฌ๋ ์ด์
- BOJ
- ์ํ
- Dynamic Programming
- stack
- ์ ์๋ก
- ์๋ฃ๊ตฌ์กฐ
- Python
- dfs
- ๊น์ด ์ฐ์ ํ์
- ๊ทธ๋ํ ์ด๋ก
- Java
๊ธฐ๋ก๋ฐฉ
PGM : ๋ ๋งต๊ฒ ๋ณธ๋ฌธ
๐น ๋ฌธ์ ๐น
๋งค์ด ๊ฒ์ ์ข์ํ๋ Leo๋ ๋ชจ๋ ์์์ ์ค์ฝ๋น ์ง์๋ฅผ K ์ด์์ผ๋ก ๋ง๋ค๊ณ ์ถ์ต๋๋ค.
๋ชจ๋ ์์์ ์ค์ฝ๋น ์ง์๋ฅผ K ์ด์์ผ๋ก ๋ง๋ค๊ธฐ ์ํด Leo๋ ์ค์ฝ๋น ์ง์๊ฐ ๊ฐ์ฅ ๋ฎ์ ๋ ๊ฐ์ ์์์ ์๋์ ๊ฐ์ด ํน๋ณํ ๋ฐฉ๋ฒ์ผ๋ก ์์ด ์๋ก์ด ์์์ ๋ง๋ญ๋๋ค.์์ ์์์ ์ค์ฝ๋น ์ง์ = ๊ฐ์ฅ ๋งต์ง ์์ ์์์ ์ค์ฝ๋น ์ง์ + (๋ ๋ฒ์งธ๋ก ๋งต์ง ์์ ์์์ ์ค์ฝ๋น ์ง์ * 2)
Leo๋ ๋ชจ๋ ์์์ ์ค์ฝ๋น ์ง์๊ฐ K ์ด์์ด ๋ ๋๊น์ง ๋ฐ๋ณตํ์ฌ ์์ต๋๋ค.
Leo๊ฐ ๊ฐ์ง ์์์ ์ค์ฝ๋น ์ง์๋ฅผ ๋ด์ ๋ฐฐ์ด scoville๊ณผ ์ํ๋ ์ค์ฝ๋น ์ง์ K๊ฐ ์ฃผ์ด์ง ๋,
๋ชจ๋ ์์์ ์ค์ฝ๋น ์ง์๋ฅผ K ์ด์์ผ๋ก ๋ง๋ค๊ธฐ ์ํด ์์ด์ผ ํ๋ ์ต์ ํ์๋ฅผ return ํ๋๋ก solution ํจ์๋ฅผ ์์ฑํด์ฃผ์ธ์.
๐น ์ ํ์ฌํญ ๐น
- scoville์ ๊ธธ์ด๋ 2 ์ด์ 1,000,000 ์ดํ์ ๋๋ค.
- K๋ 0 ์ด์ 1,000,000,000 ์ดํ์ ๋๋ค.
- scoville์ ์์๋ ๊ฐ๊ฐ 0 ์ด์ 1,000,000 ์ดํ์ ๋๋ค.
- ๋ชจ๋ ์์์ ์ค์ฝ๋น ์ง์๋ฅผ K ์ด์์ผ๋ก ๋ง๋ค ์ ์๋ ๊ฒฝ์ฐ์๋ -1์ return ํฉ๋๋ค.
๐น ์ ์ถ๋ ฅ ๐น
์์
์ค๋ช
scoville K return [1, 2, 3, 9, 10, 12] 7 2
1. ์ค์ฝ๋น ์ง์๊ฐ 1์ธ ์์๊ณผ 2์ธ ์์์ ์์ผ๋ฉด ์์์ ์ค์ฝ๋น ์ง์๊ฐ ์๋์ ๊ฐ์ด ๋ฉ๋๋ค.
์๋ก์ด ์์์ ์ค์ฝ๋น ์ง์ = 1 + (2 * 2) = 5
๊ฐ์ง ์์์ ์ค์ฝ๋น ์ง์ = [5, 3, 9, 10, 12]
2. ์ค์ฝ๋น ์ง์๊ฐ 3์ธ ์์๊ณผ 5์ธ ์์์ ์์ผ๋ฉด ์์์ ์ค์ฝ๋น ์ง์๊ฐ ์๋์ ๊ฐ์ด ๋ฉ๋๋ค.
์๋ก์ด ์์์ ์ค์ฝ๋น ์ง์ = 3 + (5 * 2) = 13
๊ฐ์ง ์์์ ์ค์ฝ๋น ์ง์ = [13, 9, 10, 12]
๋ชจ๋ ์์์ ์ค์ฝ๋น ์ง์๊ฐ 7 ์ด์์ด ๋์๊ณ ์ด๋ ์์ ํ์๋ 2ํ์ ๋๋ค.
๐ธ ๋ฌธ์ ๋ถ์ ๐ธ
๋ฐฐ์ด์ ์ต์๊ฐ๊ณผ 2๋ฒ์งธ ์ต์๊ฐ์ ๋ํ๋ฉฐ ์กฐ๊ฑด์ ๋ง์ ๋๊น์ง ์์ ์๋ฅผ ํ๋์ฉ ์ค์ฌ๊ฐ๋๋ค.
1๊ฐ๊ฐ ๋จ์ ๋ ๊น์ง ์กฐ๊ฑด์ ๋ง์ง ์๋ค๋ฉด -1์ ๋ฐํํฉ๋๋ค.
ํจ์จ์ฑ ํ ์คํธ๊ฐ ์กด์ฌํฉ๋๋ค.
๐ธ ์ฝ๋ ๐ธ
#include <vector>
#include <queue>
#include <iostream>
using namespace std;
int solution(vector<int> scoville, int K) {
int answer = 0, a, b;
priority_queue<int, vector<int>, greater<int> > pq(scoville.begin(), scoville.end());
while(pq.top() < K && pq.size() > 1){
a = pq.top();
pq.pop();
b = pq.top();
pq.pop();
pq.push(a + b*2);
answer++;
}
if(pq.top() >= K)
return answer;
else
return -1;
}
/*
#include <vector>
#include <algorithm>
using namespace std;
int solution(vector<int> scoville, int K) {
int answer = 0;
auto iter = scoville.begin();
while(iter < scoville.end() - 1){
nth_element(iter, iter+1, scoville.end());
if(*iter >= K) break;
*(iter+1) = *iter + 2 * *(iter+1);
iter++;
answer++;
}
if(*iter >= K)
return answer;
else
return -1;
}
*/
๐ธ ์ฝ๋ ํด์ ๐ธ
์ฒ์์ vector์ iterator์ ์ด๋์ผ๋ก ํ์ดํ์ต๋๋ค. (์ฃผ์๋ถ๋ถ)
์ ํ์ฑ ํ ์คํธ๋ ํต๊ณผํ์ง๋ง ํจ์จ์ฑ ํ ์คํธ๋ ์ ๋ถ ์คํจ๊ฐ ๋์จ๋ค.
๊ทธ๋์ ํ์ ์ฌ์ฉํ๊ธฐ ์ํด ์ฐ์ ์์ ํ๋ฅผ ์ฌ์ฉํ๋ค.
๋ค์์ ์ฐ์ ์์ ํ์ ์ต๋ํ์ผ๋ก ํ์ดํ ๊ฒฐ๊ณผ์ด๋ค.
ํจ์จ์ฑ ํ ์คํธ๋ฅผ ๋ชจ๋ ํต๊ณผํ๊ณ , ์ ํ์ฑ ํ ์คํธ์ ๊ฒฝ๊ณผ ์๊ฐ๋ ์งง์์ง๊ฑธ ๋ณผ ์ ์๋ค.
์์๋ฅผ ๋ฐ๋ณต์ ์ผ๋ก ์ ๋ ฌํด์ผ ํ ๋ ํ์ ์ฐ๋ฉด ์ผ๋ง๋ ํจ๊ณผ์ ์ธ์ง ์ ์ ์์๋ค.
๐ธ end ๐ธ
- ํ์ ์ฌ์ฉ๋ฒ์ ์ฐ์ตํ ์ ์์๋ค.
- C++์ ์ฐ์ ์์ ํ๋ฅผ ์ฌ์ฉํ๊ธฐ ์ํ ๋ฌธ๋ฒ์ ๋ ๊ณต๋ถํด์ผ๊ฒ ๋ค.
'CodingTest > C++' ์นดํ ๊ณ ๋ฆฌ์ ๋ค๋ฅธ ๊ธ
BOJ_2204 : ๋๋น์ ๋๋ ์ฆ ํ ์คํธ (0) | 2022.05.18 |
---|---|
BOJ_22351 : ์ํ์ ์ฒด์ก๊ณผ๋ชฉ ์ ๋๋ค 3 (0) | 2022.05.12 |
PGM : lv2_์ฌ์ ์ ๋ถ๋ถ๋ฌธ์์ด (0) | 2022.04.02 |
BOJ_1021 : ํ์ ํ๋ ํ (0) | 2022.03.27 |
PGM : K๋ฒ์งธ์ (0) | 2022.03.27 |