68-9kyo-hwang

[9kyo-hwang]

🔗 문제 링크

2024 KAKAO WINTER INTERNSHIP n + 1 카드게임

1 ~ n 사이 수가 적인 카드가 하나씩 있는 카드 뭉치와 동전 coin개를 가지고 있다. 다음과 같은 순서로 게임을 진행한다.

1. 처음에 카드 뭉치에서 n/3장을 뽑아 모두 가진다. n은 6의 배수이다.
2. 1라운드부터 진행하며, 각 라운드가 시작할 때마다 카드 2장을 뽑는다. 카드 뭉치에 남은 카드가 없다면 게임은 종료된다. 뽑은 카드 한 장 당 동전을 하나 소모해 가지거나, 동전을 소모하지 않고 버릴 수 있다.
3. 카드에 적힌 수의 합이 n+1이 되도록 카드 2장을 내고 다음 라운드를 진행할 수 있다. 만약 카드 2장을 낼 수 없다면 게임은 종료된다.

예시 설명

예를 들어 n = 12, coin = 4이고 [3, 6, 7, 2, 1, 10, 5, 9, 8, 12, 11, 4] 순서대로 카드를 뽑도록 카드 뭉치가 주어진다.
처음에 3, 6, 7, 2 카드 4장(= n/3)과 동전 4개(= coin)를 가지고 시작한다. 다음 라운드로 진행하기 위해 내야 할 카드 두 장에 적힌 수의 합은 13(= n+1)이다. 다음과 같은 방법으로 최대 5라운드까지 도달할 수 있다.

1. 1라운드에서 뽑은 카드 1, 10을 동전 두 개를 소모해서 모두 가진다. 카드 3, 10을 내고 다음 라운드로 진행한다. 이때 손에 남은 카드는 1, 2, 6, 7이고 동전이 2개 남는다.
2. 2라운드에서 뽑은 카드 5, 9를 동전을 소모하지 않고 모두 버린다. 카드 6, 7을 내고 다음 라운드로 진행한다. 이때 손에 남은 카드는 1, 2고 동전이 2개 남는다.
3. 3라운드에서 뽑은 카드 8, 12 중 동전 한 개를 소모해서 카드 12를 가진다. 카드 1, 12을 내고 다음 라운드로 진행한다. 이때 손에 남은 카드는 2이고 동전이 1개 남는다.
4. 4라운드에서 뽑은 카드 11, 4 중 동전 한 개를 소모해서 카드 11을 가진다. 카드 2, 11을 내고 다음 라운드로 진행한다. 이때 손에 남은 카드와 동전은 없다.
5. 5라운드에서 카드 뭉치에 남은 카드가 없으므로 게임을 종료한다.

처음에 가진 동전수를 나타내는 정수 coin과 카드를 뽑는 순서대로 카드에 적힌 수를 담은 1차원 정수 배열 cards가 매개변수로 주어질 때, 게임에서 도달 가능한 최대 라운드의 수를 return 하도록 solution 함수를 완성하라.

✔️ 소요된 시간

1시간 반?

✨ 수도 코드

디펜스 게임을 최근에 풀어서 그런가, 이 문제의 접근법이 생각보다는 금방 떠올랐다. 이 문제도 마찬가지로, 카드를 뽑은 것과는 무관하게 "카드 사용 시점을 뒤로 미룰 수 있다"는 것을 캐치해야 한다.
또한 카드 사용 시점을 뒤로 미룬다는 것은 어딘가에 카드가 저장되어 있다는 것인데, 거기서 n+1 숫자를 만들 수 있는 2장을 빠르게 찾아내야 하므로 Set 자료구조를 사용해야 하는 점도 포인트다.

나의 경우 Set에 <card 숫자, 교환에 필요한 coin 개수> 쌍으로 집어넣는 식으로 coin 소모 개수를 확인할 수 있게 했다.

const int N = (int)InCards.size();
const int RequiredSum = N + 1;
reverse(InCards.begin(), InCards.end());

전처리 과정이다. 이때 주어지는 cards 배열을 뒤집는 이유는 카드를 2장씩 뽑을 때 stack처럼 pop_back()을 호출해서 효율적으로 뽑을 수 있도록 하기 위함이다.

struct Comparator
{
    bool operator()(const pair<int, int>& Lhs, const pair<int, int>& Rhs) const
    {
        const auto& [LhsCard, LhsCoin] = Lhs;
        const auto& [RhsCard, RhsCoin] = Rhs;
        
        return LhsCoin == RhsCoin ? LhsCard < RhsCard : LhsCoin < RhsCoin;
    }
};

set<pair<int, int>, Comparator> Deck;
for(int i = 0; i < N / 3; ++i)
{
    Deck.emplace(InCards.back(), 0); InCards.pop_back();
}

카드를 소지할 Set이다. 처음에 n / 3 장을 갖고 시작하므로, 여기서는 동전 소모 개수를 0으로 설정해서 Set에 삽입한다. Comparator는 뒤에서 설명하겠다.

int Round;
for(Round = 1; !InCards.empty(); ++Round)
{
    Deck.emplace(InCards.back(), 1); InCards.pop_back();
    Deck.emplace(InCards.back(), 1); InCards.pop_back();
    
    ...
}

이제 라운드를 시작한다. 더 이상 주어진 카드가 없을 때까지 라운드를 반복하며, 2장씩 카드를 뽑아 Set에 삽입한다. 이제부터 뽑은 카드를 사용하기 위해선 반드시 동전을 소모해야 하므로 동전 소모 개수를 1로 세팅해서 삽입한다.

bool FindCombination = false;
for(const auto& [Card, Coin] : Deck)
{
    ...
}

이제 보유한 덱을 순회하며 n+1을 만들 수 있는 카드 조합이 있는 지 확인한다.

• 만약 그 조합이 발견됐다면 FindCombination = true로 설정되며 덱 순회를 중단한다.

for(const auto& [Card, Coin] : Deck)
{
    int TargetCard = RequiredSum - Card;
    if(Card == TargetCard)
    {
        continue;
    }
    
    int TargetCoin;
    if(Deck.count({TargetCard, 0}))
    {
        TargetCoin = 0;
    }
    else if(Deck.count({TargetCard, 1}))
    {
        TargetCoin = 1;
    }
    else
    {
        continue;
    }
    
    if(Coin + TargetCoin <= InCoin)
    {
        InCoin -= (Coin + TargetCoin);
        Deck.erase({Card, Coin});
        Deck.erase({TargetCard, TargetCoin});
        FindCombination = true;
        break;
    }
}

덱에 존재하는 모든 카드를 순회하며 n+1, 즉 RequiredSum을 만들 수 있는 TargetCard를 찾는다.

• 계산 상 Card와 TargetCard가 동일한 숫자가 나올 수도 있는데, 문제에서 주어진 카드는 모두 숫자가 다르다.
• 따라서 이 경우 더 이상 진행하지 않도록 continue를 걸어준다.

올바른 TargetCard가 계산되었다면 현재 Deck에 이 카드가 존재하는 지 검사한다.

• 이 카드가 게임 시작 전에 뽑은 카드일 수도 있고, 라운드 진행 중에 뽑은 카드일 수도 있다.
• 이를 검사해서 TargetCoin을 산정한다.
• 만약 카드 자체가 존재하지 않는다면 더 이상 진행하지 않도록 continue를 걸어준다.

덱에 카드가 존재하는 것이 확인됐다면, 마지막으로 이 조합을 쓸 수 있는 지 확인한다.

• 이는 현재 보유한 동전으로 카드 2장을 사용할 수 있는 지를 확인하는 과정이다.
• 만약 동전을 1개 보유했는데, 카드 2장 모두 동전을 내야 한다면 사용할 수 없는 것이다.
• 만약 카드 2장을 사용할 수 있다면 보유 동전 개수를 차감하고, 덱에서 카드 2장을 지우며 FindCombination = true로 설정한다.

여기서 Set에 Comparator라는 별도의 비교 기준이 필요한데,

• n+1을 만드는 카드 조합이 반드시 1가지라는 보장은 없다. 동전을 0개 소모하는 조합, 1개 소모하는 조합, 2개 소모하는 조합이 있을 수 있다.
• 우리는 최대한 라운드를 오래 이어가야 하므로 동전을 최대한 오래 보유해야 한다. 그런데 소모 동전 개수가 많은 카드를 우선적으로 확인해 조합이 만들어질 수가 있다.
• 이러한 경우를 방지하기 위해 Set에 넣을 때 소모 동전 개수가 적은 카드를 먼저 확인할 수 있도록 별도의 정렬 기준을 넣어준 것이다.

if(false == FindCombination)
{
    break;
}

반복문을 빠져나왔는데도 FindCombination == false인 경우, n+1을 만드는 카드 2장이 덱에 존재하지 않는다는 뜻이므로 라운드 진행을 중단한다.

return Round;

전체 반복문이 종료되면 이제까지 진행한 라운드 수가 기록돼있으므로 이를 반환한다.

전체 코드

#include <string>
#include <vector>
#include <set>
#include <algorithm>

using namespace std;

struct Comparator
{
    bool operator()(const pair<int, int>& Lhs, const pair<int, int>& Rhs) const
    {
        const auto& [LhsCard, LhsCoin] = Lhs;
        const auto& [RhsCard, RhsCoin] = Rhs;
        
        return LhsCoin == RhsCoin ? LhsCard < RhsCard : LhsCoin < RhsCoin;
    }
};

int solution(int InCoin, vector<int> InCards) 
{
    const int N = (int)InCards.size();
    const int RequiredSum = N + 1;
    reverse(InCards.begin(), InCards.end());
    
    set<pair<int, int>, Comparator> Deck;
    for(int i = 0; i < N / 3; ++i)
    {
        Deck.emplace(InCards.back(), 0); InCards.pop_back();
    }
    
    int Round;
    for(Round = 1; !InCards.empty(); ++Round)
    {
        Deck.emplace(InCards.back(), 1); InCards.pop_back();
        Deck.emplace(InCards.back(), 1); InCards.pop_back();
        
        bool FindCombination = false;
        for(const auto& [Card, Coin] : Deck)
        {
            int TargetCard = RequiredSum - Card;
            if(Card == TargetCard)
            {
                continue;
            }
            
            int TargetCoin;
            if(Deck.count({TargetCard, 0}))
            {
                TargetCoin = 0;
            }
            else if(Deck.count({TargetCard, 1}))
            {
                TargetCoin = 1;
            }
            else
            {
                continue;
            }
            
            if(Coin + TargetCoin <= InCoin)
            {
                InCoin -= (Coin + TargetCoin);
                Deck.erase({Card, Coin});
                Deck.erase({TargetCard, TargetCoin});
                FindCombination = true;
                break;
            }
        }

        if(false == FindCombination)
        {
            break;
        }
    }
    
    return Round;
}

📚 새롭게 알게된 내용

사실 나는 중복된 코드를 안쓸려고 Set에 Comparator 정의하고 좀 복잡하게 풀이했는데, 다른 분들 풀이를 보면 그냥 초기에 뽑은 카드 목록 Set과 라운드 진행 중에 뽑은 카드 Set 2개를 사용한다. 이게 좀 더 직관적일 수도...?

지난 주에는 바빴어서 PR을 못썼습니다 죄송합니다 😢

[mjj111]

어제 때마침 따끈따끈 하게 풀었었습니다 ㅎ
개인적으로는 저처럼 Set 2개 사용하는 것보다 교황님 풀이가 더 직관적인거 같아요🤔

import java.util.*;

class Solution {    
    public int solution(int coin, int[] cards) {
        int N = cards.length;
        Set<Integer> original = new HashSet();
        Set<Integer> additional = new HashSet();
        
        int index = N / 3;
        for(int i = 0 ; i < index; ++i) {
            original.add(cards[i]);
        }
        
        int target = N + 1;   
        int round = 0;
        while(true){
            round++;
            
            if(index >= N){
                break;
            }
            
            additional.add(cards[index]);
            additional.add(cards[index+1]);
            index += 2;
            
            boolean flag = false;
            for(int i : original){
                if(original.contains(target - i)){
                    original.remove(i);
                    original.remove(target - i);
                    flag = true;
                    break;
                }
            }
            
            if(!flag && coin > 0){
                for(int i : original){
                    if(!additional.contains(target - i)) continue;
                    original.remove(i);
                    additional.remove(target - i);
                    --coin;
                    flag = true;
                    break;
                }
            }
            
            if(!flag && coin > 1){
                for(int i : additional){
                    if(!additional.contains(target - i)) continue;
                    additional.remove(i);
                    additional.remove(target - i);
                    coin -= 2;
                    flag = true;
                    break;
                }
            }
            
            if(!flag) break;
        }
        return round;
    }
}

[gjsk132]

저는 냅다 구현했습니다!
n 값이 작아서 boundary로 라운드당 가능한 범위 지정해줘서 하니까 시간초과 안나고 해결되네요 :)

전체 코드

def solution(coin, cards):
    cards_cnt = len(cards)
    
    target = cards_cnt + 1
    
    default_cards_cnt = len(cards)//3
    round = 0
    boundary = default_cards_cnt + 2
        
    for _ in range(default_cards_cnt+1):
        if not cards:
            continue
        
        round += 1
        go_next_round = False
        boundary = min(boundary, len(cards))
        
        for idx, val in enumerate(cards[:boundary]):
            if not target - val in cards[:boundary]:
                continue
            
            
            pair_idx = cards[:boundary].index(target-val)
            
            if pair_idx < idx:
                break
            
            if pair_idx < default_cards_cnt:
                default_cards_cnt -= 2
                
            elif idx < default_cards_cnt:
                if coin < 1:
                    continue
                coin -= 1
                default_cards_cnt -= 1
                
            else:
                if coin < 2:
                    continue
                coin -= 2
                
            del cards[pair_idx]
            del cards[idx]
            go_next_round = True
            
            break
                    
        if go_next_round:
            continue
            
        break
                    
    return round