20-mj010504

[mj010504]

🔗 문제 링크

주사위 고르기
https://school.programmers.co.kr/learn/courses/30/lessons/258709

✔️ 소요된 시간

1시간

여담

• 문제가 단순하면서도 구현할 것이 많아 복잡할 수 있습니다. 한 문제안에서 여러 문제를 푼다고 생각하시고 도전해보시면 될 것 같습니다.

✨ 수도 코드

• A와 B가 n개의 주사위 중에 n / 2개의 주사위를 각각 골라서 모든 경우의 수를 비교해 승률을 계산하여 가장 승률이 높은 주사위 조합을 구해야하는 문제입니다. 이때 조합을 구현하여 비교해볼텐데 실제로 누가 승률이 높은는 중요하지 않습니다. 당연히 A또는 B가 승률이 높을 것이고 우리는 가장 승률이 높은 조합을 구하기만 하면 됩니다.

• 처음에는 주사위 필승조합을 구할려면 주사위 합들의 평균을 비교해야 할까도 생각해봤는데 그런식으로 최적화하는 문제는 여태까지 많이 없었던 것 같고, 당연히 모든 주사위 조합에 따른 승부의 경우의 수를 구해야할 것 같았습니다. 최악의 경우 주사위가 10개일 때 10C5 * 6^5정도의 시간복잡도가 나올 것 같았고 직접 계산해보지는 않았지만 다른 풀이 방법도 떠오르지 않아 풀이에 들어갔습니다.

• 우선 n / 2개씩 주사위를 나눠가지는 모든 조합을 구하는 pickDice 함수를 만들었습니다. 이때 조합은 재귀함수를 이용했고 한 번 사용했던 조합들은 다시 사용하지 않기 위해 Set<Set>를 만들어 중복을 방지했습니다. 저번에 완전범죄 문제에서 set<tuple<int, int, int>>를 사용하였는데 Set<Set>를 사용하면 웬만한 문제에서 DFS + 메모이제이션이 필요할 때 사용할 수 있을 것 같습니다.

• 주사위를 각자 나눠가지고 모든 합들을 구해야할 텐데 getDiceSum() 재귀함수를 통해 모든 합들을 각각 배열(sumA, sumB)에 저장했습니다. 이때 sumA 및 sumB를 저는 매개변수 참조를 통해 전역변수를 사용하지 않고 합들을 저장할 수 있었습니다.

• 이제 주사위의 조합에 따른 모든 합도 구해졌으므로 모든 값을 각각 비교해서 승리 횟수 와 패배 횟수를 구합니다. 이 문제에서 가장 높은 승률이란 경기 횟수는 무조건 동일하므로 승리 횟수가 가장 많거나, 승리 횟수가 같다면 패배 횟수가 가장 적은 것을 의미하므로 승리 횟수와 패배 횟수를 모두 구합니다. 저는 maxRate라는 pair<int, int> 변수를 만들어서 각각 승리와 패배수를 비교하여 최고의 승률에 따른 승리 수와 패배수 값을 갱신해주었습니다. 값을 갱신해주면서 이 문제의 답인 A가 승률이 가장 높은 주사위 조합 maxA도 갱신해주었습니다.

여담

• 풀이가 다양할 수 있을 것 같은데요. 제 풀이에 비효율적인 부분이 있거나 다르게 생각한 부분이 있다면 많은 지적 부탁드립니다.

📚 새롭게 알게된 내용

[hyeokbini]

구현해야 할 부분이 많아서 많이 어지러웠네요. 저는 전체적으로 2부분으로 나눠서 풀이를 진행했습니다.

1. 주사위의 절반을 가져가는 경우의 수대로 인덱스 벡터 만들기
2. 인덱스 벡터를 기반으로 가진 주사위에서 나오는 합의 벡터를 만들고, 승률 계산하기

1번은 간단한 재귀함수 조합을 통해 구현했습니다. A주사위에 들어갈 N/2개를 뽑은 후, 벡터 길이가 N/2가 된다면 선택되지 않은 것들을 B주사위 벡터에 넣어서 check함수에 두 벡터를 넘겨주었습니다.

2번이 조금 까다로웠는데, 우선 모든 주사위의 눈의 합 경우의 수를 구해야 합니다.

이때 누적해서 합을 갱신하는 방식을 사용해봤는데,

vector<int> arolls = {0};

for (int i = 0; i < (int)adice.size(); ++i)
    {
        int idx = adice[i];
        vector<int> temp;
        for (int j = 0; j < (int)dice[idx].size(); ++j)
        {
            int roll = dice[idx][j];
            for (int k = 0; k < (int)arolls.size(); ++k)
            {
                temp.push_back(arolls[k] + roll);
            }
        }
        arolls = move(temp);
    }

예시를 들어 함수의 작동 방식을 설명한다면,
adice = 0,1
dice[0] = 1,2
dice[1] = 3,4
인 예시를 들어보겠습니다.

arolls에 0을 기록한 뒤, 한 주사위에 대해 arolls[모든 인덱스] + adice[i][j] 값을 temp벡터에 저장합니다.

첫번째 주사위

arolls[0] = 0 -> temp.push_back(0 + 1(dice[0][0])) -> temp = {1}
arolls[0] = 0 -> temp.push_back(0 + 2(dice[0][1])) -> temp = {1,2}

arolls = move(temp) -> arolls = {1,2}

두번째 주사위

arolls[0] = 1 -> temp.push_back(1+3(dice[1][0])) → temp = {4}
arolls[1] = 2 -> temp.push_back(2+3(dice[1][0])) → temp = {4,5}

arolls[0] = 1 -> temp.push_back(1+4(dice[1][1])) → temp = {4,5,5}
arolls[1] = 2 -> temp.push_back(2+4(dice[1][1])) → temp = {4,5,5,6}

arolls = move(temp) -> arolls = {4,5,5,6}

....

이런 식으로 진행됩니다.

그렇게 만들어진 조합들에 대해 승률을 비교해야 하는데, 단순히 2중 for문으로 비교하면 O(N^2)의 시간복잡도라 시간초과가 날 수도 있다고 생각했습니다.

따라서 두 벡터를 정렬한 후 투 포인터 개념을 사용해서 비교하는 방식을 사용했습니다. 2중for문을 쓰는 방식을 테스트해보진 않아서 시간초과가 걸릴지는 모르겠네요. 우선 투포인터 방식은 아슬아슬하긴 하지만 정답을 받긴 했습니다.

이렇게 열심히 구현해놓고 또 1 based index인거 놓쳐서 오답 한번 받았네요. 항상 주의하려 하지만 항상 놓치는 것 같습니다. 더 주의해야겠네요.

아래는 제출 코드입니다. 오랜만에 안 쓰던 개념들을 쓰려니 머리가 따뜻해진 문제였네요. 푸시느라 고생하셨어요! 😎

주사위 고르기 / c++

#include <bits/stdc++.h>
using namespace std;

vector<int> ans;
double maxWinRate = 0.0;

void check(vector<vector<int>> &dice, vector<int> adice, vector<int> bdice) {
    vector<int> arolls = {0};
    vector<int> brolls = {0};

    //  조합의 모든 합
    for (int i = 0; i < (int)adice.size(); i++)
    {
        int idx = adice[i];
        vector<int> temp;
        for (int j = 0; j < (int)dice[idx].size(); j++)
        {
            int roll = dice[idx][j];
            for (int k = 0; k < (int)arolls.size(); k++)
            {
                temp.push_back(arolls[k] + roll);
            }
        }
        arolls = move(temp);
    }

    for (int i = 0; i < (int)bdice.size(); i++)
    {
        int idx = bdice[i];
        vector<int> temp;
        for (int j = 0; j < (int)dice[idx].size(); j++)
        {
            int roll = dice[idx][j];
            for (int k = 0; k < (int)brolls.size(); k++)
            {
                temp.push_back(brolls[k] + roll);
            }
        }
        brolls = move(temp);
    }

    // 정렬 후 투포인터로 A가 이기는 경우 계산
    sort(arolls.begin(), arolls.end());
    sort(brolls.begin(), brolls.end());

    long long winCount = 0;
    int j = 0;
    for (int i = 0; i < (int)arolls.size(); i++)
    {
        while (j < (int)brolls.size() && brolls[j] < arolls[i])
        {
            j++;
        }
        winCount += j;
    }

    long long totalCount = (long long)arolls.size() * brolls.size();
    double winRate = (double)winCount / totalCount;

    // 최고 승률이면 갱신
    if (winRate > maxWinRate)
    {
        maxWinRate = winRate;
        ans = adice;
    }
}


void choose(vector<vector<int>> &dice, vector<int> adice, vector<int> bdice, int dicecount, int start)
{
    if (adice.size() == dicecount / 2)
    {
        for (int i = 0; i < dicecount; i++)
        {
            if (std::find(adice.begin(), adice.end(), i) == adice.end())
            {
                bdice.push_back(i);
            }
        }
        check(dice, adice, bdice);
        return;
    }

    for (int i = start; i < dicecount; i++)
    {
        adice.push_back(i);
        choose(dice, adice, bdice, dicecount, i + 1);
        adice.pop_back();
    }
}


vector<int> solution(vector<vector<int>> dice) {
    vector<int> adice;
    vector<int> bdice;
    choose(dice,adice,bdice,dice.size(),0);
    for(auto &i : ans)
    {
        i++;
    }
    return ans;
}

[Seol-Munhyeok]

쉽게 풀릴 거 처럼 보이는 문제 중에서 진짜 어려운 문제라고 생각합니다...

먼저 브루트포스로 풀 때, 최악의 연산횟수를 생각해봅시다.

$n=10$ 일 때, 10개 중 5개를 뽑아서 주사위를 나누고, A, B가 가진 주사위 10개에 대해서 나올 수 있는 주사위 눈 조합을 곱하면 되니까
$10C5 \times 6^{10} = 15237476352 = 152억$
가 나와서 절대 이 방법은 안된다고 생각했습니다.

어떻게 복잡도를 줄일까를 고민하다가 DP가 떠올랐는데
$dp[i][j] =$ $i$ 번째 주사위까지 살펴볼 때, 합이 $j$가 되는 경우의 수
로 정의하고 초기값을 $dp[0][0] = 1$로 줍니다.
아직 아무 주사위도 안 던졌을 때, 합이 0이 되는 경우의 수를 1이라고 생각하는 것 입니다.
완전 범죄 문제랑 유사한 아이디어입니다.

그러면 점화식이

이 됩니다. 식이라 복잡한데 말로 설명하면
이번 주사위에서 $j$가 나오면, 이전까지 합은 $j−v$ 여야 한다 라고 생각할 수 있습니다.
dp 문제 중에 1, 2, 3만 더해서 특정 숫자 만드는 문제랑 비슷한 논리입니다.

---

근데 사실 이렇게 할 필요가 전혀 없습니다.

민준 님 풀이는 그냥 쉬운 방법으로 for 문으로 모든 주사위 눈의 합을 구하는데 왜 통과가 되는지 생각해봤는데, 제가 연산 횟수를 잘못 계산했습니다.

주사위 눈의 합을 A 합 따로 B 합 따로 구하는 거니까 둘을 곱하는게 아니라 더해야합니다.
정확한 연산횟수를 구하면 $10C5 \times (6^{5} + 6^{5})= 3919104 = 391만$
입니다. 따라서 그냥 구해도 충분합니다...

---

아무튼 DP로 A와 B의 주사위 눈의 합의 경우의 수를 담은 배열을 구하고
B의 누적합 배열을 통해서 A가 이기는 경우의 수를 구했습니다.

A[i], B[i]는 A 또는 B가 주사위를 던져서 합을 i로 만드는 경우의 수이고
A가 이기는 경우의 수는 A[i] > 0 일 때, A[i] * (B[1] + B[2] + ... + B[i-1])를 모든 i에 대해 더한 값이 됩니다.
매번 B[1] + B[2] + ... + B[i-1]를 직접 구하면 시간초과의 위험이 있으므로 누적합을 사용했습니다.

---

주사위 굴리기

from itertools import combinations

def solve(dice_set):
    n = len(dice_set)
    max_value = sum(max(d) for d in dice_set)
    dp = [[0] * (max_value+1) for _ in range(n+1)]
    dp[0][0] = 1
    
    for i, faces in enumerate(dice_set, start=1):
        for s in range(max_value+1):
            for v in faces:
                if s + v <= max_value:
                    dp[i][s + v] += dp[i-1][s]
    
    return dp[n]
    
def solution(dice):
    answer = []
    max_count = -1
    n = len(dice)
    combs = combinations(range(n), n // 2)
    
    for comb in combs:
        # A, B 주사위 선택
        comb_set = set(comb)
        a_dice = [dice[i] for i in range(n) if i in comb_set]
        b_dice = [dice[i] for i in range(n) if i not in comb_set]

        # A, B가 만들 수 있는 주사위 합의 경우의 수 구하기
        A = solve(a_dice)
        B = solve(b_dice)
        
        # B 누적합 배열 생성
        m = max(len(A), len(B))
        b_sum = [0] * (m)
        
        if len(B) > 0:
            b_sum[0] = B[0]
        for i in range(1, m):
            b_sum[i] = b_sum[i-1] + (B[i] if i < len(B) else 0)
                
        # A가 이기는 경우의 수 계산
        count = 0
        for i in range(1, len(A)):
            if A[i]:
                count += A[i] * b_sum[i-1]
        
        # 최댓값 갱신
        if count > max_count:
            answer = comb
            max_count = count
    
    return [x + 1 for x in answer]  # 1-based

다른 풀이를 또 찾아보니까 이분탐색을 사용해서도 풀 수 있다고 합니다.

카카오 공식 해설 을 보면

• A와 B의 주사위를 한꺼번에 모두 시뮬레이션해 승패를 판단하는 대신, A와 B의 주사위를 따로 시뮬레이션 하기
• 누적 합, 투 포인터, 이분 탐색등의 기법을 사용해서 시간복잡도 줄이기

가 이 문제의 핵심인 거 같습니다.

---

추가의견

민준 님께서

"이 문제에서 가장 높은 승률이란 경기 횟수는 무조건 동일하므로 승리 횟수가 가장 많거나, 승리 횟수가 같다면 패배 횟수가 가장 적은 것을 의미" 한다고 하셨는데,

문제에서 "승리할 확률이 가장 높은 주사위 조합이 유일한 경우만 주어집니다." 라고 했으므로 그것까지는 고려할 필요가 없습니다.

저는 그냥 승률은 승리할 경우의 수 / 전체 경우의 수라 해석하고 풀었는데 승률의 해석이 모호해지는 거를 방지하기위해 위와 같은 조건을 추가한 거 같습니다.

다들 문제 푸신다고 고생하셨습니다!

[mj010504]

@Seol-Munhyeok 좋은 지적들 감사합니다! 제가 조금 야매로 푼 느낌이 있긴 하네요.

잠이 안와서 투포인터로 풀어봤습니다. 시간이 10배 줄었습니다. 투포인터가 직관적이라 이해가 쉽네요.

주사위 고르기(투포인터)

#include<bits/stdc++.h>

using namespace std;

int n;
vector<vector<int>> dice;
vector<int> picked;
double maxRate = 0.0;
vector<int> maxA;
set<set<int>> s;

void getDiceSum(int idx, vector<int> v, vector<int>& sv) {
        for(int i = 0; i < v.size(); i++) { 
            int idx = v[i];
            vector<int> temp;

            for(int j = 0; j < 6; j++) {
                for(int k = 0; k < sv.size(); k++) {
                    temp.push_back(sv[k] + dice[idx][j]);
                }
            }

            sv = move(temp);
        }
}

void rollDice(vector<int> a, vector<int> b) {
    vector<int> sumA = {0}; getDiceSum(0, a, sumA);
    vector<int> sumB = {0}; getDiceSum(0, b, sumB);
    
    int victoryA = 0;
    int victoryB = 0;
    
    sort(sumA.begin(), sumA.end());
    sort(sumB.begin(), sumB.end());

    int j = 0;
    for(int i = 0; i < sumA.size(); i++) {
        while(j < sumB.size() && sumA[i] > sumB[j]) {
           j++;
        }
        victoryA += j;
    }
    
    j = 0;
     for(int i = 0; i < sumB.size(); i++) {
        while(j < sumA.size() && sumB[i] > sumA[j]) {
            j++;
        }
        victoryB += j;
    }
    
    double winRateA = (double)victoryA / (sumA.size() * sumB.size());
  double winRateB = (double)victoryB / (sumA.size() * sumB.size());
    
   if(winRateA > maxRate) {
       maxRate = winRateA;
       maxA = a;
   }
    
   if(winRateB > maxRate) {
       maxRate = winRateB;
       maxA = b;
   }

}

void pickDice(int cnt, int idx) {
    if(cnt == n / 2) {
        vector<int> a; vector<int> b;
        for(int i = 0; i < n; i++) {
            if(picked[i]) a.push_back(i);
            else b.push_back(i);
        }

        set<int> as(a.begin(), a.end());
        set<int> bs(b.begin(), b.end());

        if(!s.count(as)) {
            rollDice(a, b);
            s.insert(as); s.insert(bs);
        }
        
        
    }
    else {
        for(int i = idx; i < n; i++) {
            if(!picked[i]) {
                picked[i] = true;
                pickDice(cnt + 1, i + 1);
                picked[i] = false;
            }
        }
    }
}

vector<int> solution(vector<vector<int>> dv) {
    n = dv.size();
    dice = dv;
    picked.resize(n, false);
    pickDice(0, 0);

    for(int i = 0; i < maxA.size(); i++) {
        maxA[i]++;
    }

    return maxA;
}

[flydongwoo]

PR과 리뷰를 보기 전, 먼저 도전해봤는데 와 진짜 구현할 것도 많고 어려웠네요
역시 전 아직 많이 부족한가 봅니다
자극으로 생각하고 더 열심히 해봐야겠습니다

저는 3가지로 나눠서 풀었습니다

1. A가 고를 수 있는 모든 조합을 DFS로 생성하고
2. 각 조합마다 A/B의 모든 합을 만들어서, B 합을 정렬한 뒤 A 합마다 lower_bound로 B < A인 개수만큼 승수를 합산한 뒤
3. 승수가 최대인 조합을 채택하고, 동률이면 사전순으로 가장 빠른 조합을 택했네요

제 코드 너무 복잡하고 메소드도 많아서 그냥 흐름만 참고하시면 될 것 같습니다

좋은 문제 가져와주셔서 감사하고 문제푸느라 고생하셨습니다!

주사위 고르기

#include <iostream>
#include <vector>
#include <algorithm>
using namespace std;

static void buildSums(const vector<vector<int>>& dice, const vector<int>& idxs, vector<int>& out) {
    out.clear();
    out.push_back(0);
    for (size_t t = 0; t < idxs.size(); t++) {
        vector<int> next;
        next.reserve(out.size() * 6);
        const vector<int>& d = dice[idxs[t]];
        for (size_t i = 0; i < out.size(); i++) {
            for (size_t f = 0; f < d.size(); f++) {
                next.push_back(out[i] + d[f]);
            }
        }
        out.swap(next);
    }
}

static bool lexSmaller(const vector<int>& a, const vector<int>& b) {
    size_t n = a.size();
    for (size_t i = 0; i < n; i++) {
        if (a[i] != b[i]) {
            return a[i] < b[i];
        }
    }
    return false;
}

static void complementIndices(int n, const vector<int>& pick, vector<int>& rest) {
    rest.clear();
    vector<char> used(n, 0);
    for (size_t i = 0; i < pick.size(); i++) {
        used[pick[i]] = 1;
    }
    for (int i = 0; i < n; i++) {
        if (!used[i]) {
            rest.push_back(i);
        }
    }
}

vector<int> solution(vector<vector<int>> dice) {
    int n = static_cast<int>(dice.size());
    int half = n / 2;

    vector<int> bestChoice;
    long long bestWin = -1;

    vector<int> comb;
    comb.reserve(half);

    vector<int> aIdx, bIdx;
    vector<int> aSums, bSums;

    function<void(int,int)> dfs = [&](int start, int need) {
        if (need == 0) {
            aIdx = comb;
            complementIndices(n, aIdx, bIdx);

            buildSums(dice, aIdx, aSums);
            buildSums(dice, bIdx, bSums);

            sort(bSums.begin(), bSums.end());

            long long win = 0;
            for (size_t i = 0; i < aSums.size(); i++) {
                int x = aSums[i];
                auto it = lower_bound(bSums.begin(), bSums.end(), x);
                win += static_cast<long long>(it - bSums.begin());
            }

            if (win > bestWin) {
                bestWin = win;
                bestChoice = aIdx;
            } else if (win == bestWin) {
                if (lexSmaller(aIdx, bestChoice)) {
                    bestChoice = aIdx;
                }
            }
            return;
        }

        for (int i = start; i <= n - need; i++) {
            comb.push_back(i);
            dfs(i + 1, need - 1);
            comb.pop_back();
        }
    };

    dfs(0, half);

    vector<int> answer;
    answer.reserve(half);
    for (size_t i = 0; i < bestChoice.size(); i++) {
        answer.push_back(bestChoice[i] + 1);
    }
    return answer;
}