๊ธฐ๋ก๋ฐฉ

PGM : ๋” ๋งต๊ฒŒ ๋ณธ๋ฌธ

CodingTest/C++

PGM : ๋” ๋งต๊ฒŒ

Soom_1n 2022. 4. 2. 16:59

๐Ÿ‘‰ ๋ฌธ์ œ๋งํฌ

๐Ÿ”น ๋ฌธ์ œ ๐Ÿ”น

๋งค์šด ๊ฒƒ์„ ์ข‹์•„ํ•˜๋Š” 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++์˜ ์šฐ์„ ์ˆœ์œ„ ํ๋ฅผ ์‚ฌ์šฉํ•˜๊ธฐ ์œ„ํ•œ ๋ฌธ๋ฒ•์„ ๋” ๊ณต๋ถ€ํ•ด์•ผ๊ฒ ๋‹ค.

728x90