26-9kyo-hwang #104

9kyo-hwang · 2024-02-11T15:34:43Z

🔗 문제 링크

2024 KAKAO WINTER INTERSHIP 문제 3: 주사위 고르기

✔️ 소요된 시간

2시간 + a?

✨ 수도 코드

1. 이해

n개의 주사위가 주어진다. 이를 A, B가 각각 n/2개씩 나눠 갖는다. 각각의 주사위를 모두 굴려, 나온 수들을 합해 점수를 비교한다. 둘 중 큰 쪽이 승리한다. 이 때 A가 승리할 확률이 가장 높은 주사위 조합을 찾아야 한다.

다음은 n = 4인 예시이다.

주사위	구성
#1	[1, 2, 3, 4, 5, 6]
#2	[3, 3, 3, 3, 4, 4]
#3	[1, 3, 3, 4, 4, 4]
#4	[1, 1, 4, 4, 5, 5]

예를 들어 A가 주사위 1번과 2번을 가져간 뒤 6, 3을 굴리고, B가 주사위 3번과 4번을 가져간 뒤 4, 1을 굴린다면 A의 승리이다. (6 + 3 > 4 + 1)

A가 가져가는 주사위 조합에 따라, 주사위를 굴린 1296가지 경우의 승패 결과를 세어보면 아래 표와 같다.

A의 주사위	승	무	패
#1, #2	596	196	504
#1, #3	560	176	560
#1, #4	616	184	496
#2, #3	496	184	616
#2, #4	560	176	560
#3, #4	504	196	596

A가 승리할 확률이 가장 높아지기 위해선 주사위 1번과 4번을 가져가야 한다.

2. 설명

�크게 2가지를 확인해야 한다. 1. A가 가져갈 주사위 선택 2. 가져간 주사위를 굴린 결과 세기

1. A가 가져갈 주사위 선택

주어지는 주사위 개수가 최대 10개밖에 되지 않기 때문에, A가 가져갈 주사위를 선택하는 모든 경우를 완전탐색으로 찾는다.
n개의 주사위 중 n/2개의 주사위를 고르는 방법의 수를 찾는 것인데, n이 최댓값일 때 10개의 주사위 중 5개의 주사위를 고르는 방법의 수는 252이므로 충분히 가능하다.

def solution(dice):
    answer: List[int] = []
    
    n: int = len(dice)
    dice_indices: Set[int] = set(range(n))  # 주사위 번호들을 기록해둔 set
    for A in combinations(range(n), n // 2):  # itertools의 combinations를 이용해 (0 ~ n-1) 인덱스 n개 중 n//2개를 선택
        B: Set[int] = dice_indices.difference(A)  # B는 A가 고른 인덱스의 나머지
        ...

2. 가져간 주사위를 굴린 결과 세기

이 부분이 문제다. 각 주사위를 굴린 모든 경우를 시뮬레이션해 A가 이기는 경우의 수를 구하고자 하면 6^n이므로 최대 252 * 6^10 = 15,237,476,352가지 경우의 수가 나오므로 터진다.
이 부분을 어떻게 해결해야 할 지 감을 못잡아서 시간을 왕왕 날려버렸고... 질문하기 게시판의 글을 보고나서야 해결했다 흑흑

방법은 A, B를 각각 시뮬레이션 하는 것이다.
먼저 A의 주사위를 굴린 결과만 시뮬레이션해 6^(n/2) 가지에 대해 주사위 눈의 합을 저장해 두고, 마찬가지로 B의 주사위를 굴린 결과 6^(n/2) 가지에 대해 주사위 눈의 합을 저장해 둔다.

def get_count_of_each_combo(dices, indices):
    num_combos: Dict[int, int] = defaultdict(int)
    for pips in product(range(6), repeat=len(indices)):
        sum_combo: int = sum(dices[i][j] for i, j in zip(indices, pips))  # i번째 주사위 j번째 눈
        num_combos[sum_combo] += 1
    return sorted(num_combos.items())

indices가 A, B가 각각 고른 주사위들의 번호가 담긴 리스트이다. itertools의 product를 이용해 주사위 눈(0 ~ 5) 순열을 생성한다.
indices와 pips를 동시에 순회해 i번째 주사위의 j번째 눈을 모두 구해 그것의 합을 dictionary에 counting한다.
그러면 num_combos라는 딕셔너리에는 최종적으로 {합1: 개수, 합2: 개수, ...}와 같이 저장된다.
1번 | [1, 2, 3, 4, 5, 6], 2번 | [3, 3, 3, 3, 4, 4] <- 이 2개의 주사위를 골랐다고 하면 {4: 4, 5: 6, 6: 6, 7: 6, 8: 6, 9: 6, 10: 2}가 저장된다.
이를 key, 즉 합을 기준으로 오름차순 정렬한 리스트로 반환한다.

이렇게 A, B에 대해 각각 리스트를 구했다면, A가 가진 주사위로 만들어낼 수 있는 각 합 x에 대해, x보다 작은 B가 가진 주사위로 만들어낼 수 있는 각 합의 개수를 모두 구하면 된다.

        A_combos: List[int] = get_count_of_each_combo(dice, A)
        B_combos: List[int] = get_count_of_each_combo(dice, B)
        
        win_cnt: int = 0
        for A_combo_sum, A_combo_cnt in A_combos:
            for B_combo_sum, B_combo_cnt in B_combos:
                if B_combo_sum >= A_combo_sum:
                    break
                    
                win_cnt += A_combo_cnt * B_combo_cnt

각 리스트의 길이는 6^(n/2) = m이라 할 때, 정렬 과정이 있으므로 시간복잡도는 $O(mlogm)$이다. 최대는 n = 10일 때이므로 6^5 = 7,776이고, 이는 가능한 주사위 조합의 최대값인 252를 곱해도 충분히 빠르다.

3. 전체 코드

python

from itertools import combinations, product
from collections import defaultdict


def get_count_of_each_combo(dices, indices):
    num_combos: Dict[int, int] = defaultdict(int)
    for pips in product(range(6), repeat=len(indices)):
        sum_combo: int = sum(dices[i][j] for i, j in zip(indices, pips))  # i번째 주사위 j번째 눈
        num_combos[sum_combo] += 1
    return sorted(num_combos.items())


def solution(dice):
    answer: List[int] = []
    
    n: int = len(dice)
    dice_indices: Set[int] = set(range(n))
    max_win_cnt: int = 0
    for A in combinations(range(n), n // 2):
        B: Set[int] = dice_indices.difference(A)
        
        A_combos: List[Tuple[int, int]] = get_count_of_each_combo(dice, A)
        B_combos: List[Tuple[int, int]] = get_count_of_each_combo(dice, B)
        
        win_cnt: int = 0
        for A_combo_sum, A_combo_cnt in A_combos:
            for B_combo_sum, B_combo_cnt in B_combos:
                if B_combo_sum >= A_combo_sum:
                    break
                    
                win_cnt += A_combo_cnt * B_combo_cnt
        
        if win_cnt > max_win_cnt:
            max_win_cnt = win_cnt
            answer = A
        
    return [i + 1 for i in answer]

c++

#include <string>
#include <vector>
#include <algorithm>
#include <unordered_map>

using namespace std;

void CountEachComboSums(const vector<vector<int>>& Dices, const vector<int>& SelectedDices, unordered_map<int, int>& DiceComboMap, int ComboSum = 0, int DiceIndex = 0)
{
    if(DiceIndex == SelectedDices.size())
    {
        DiceComboMap[ComboSum] += 1;
        return;
    }
    
    for(const int& DicePip : Dices[SelectedDices[DiceIndex]])
    {
        CountEachComboSums(Dices, SelectedDices, DiceComboMap, ComboSum + DicePip, DiceIndex + 1);
    }
}

vector<int> solution(vector<vector<int>> Dice) 
{
    const int NumDice = Dice.size();
    vector<bool> IsADice(NumDice / 2, false);
    IsADice.insert(IsADice.end(), NumDice / 2, true);
    
    int MaxCntOfAWins = 0;
    vector<int> Answer;
    do 
    {
        vector<int> A, B;
        for(int i = 0; i < NumDice; ++i)
        {
            IsADice[i] ? A.emplace_back(i) : B.emplace_back(i);
        }
        
        unordered_map<int, int> AComboMap, BComboMap;
        CountEachComboSums(Dice, A, AComboMap);
        CountEachComboSums(Dice, B, BComboMap);
        
        vector<pair<int, int>> AComboVector(AComboMap.begin(), AComboMap.end());
        vector<pair<int, int>> BComboVector(BComboMap.begin(), BComboMap.end());
        
        sort(AComboVector.begin(), AComboVector.end());
        sort(BComboVector.begin(), BComboVector.end());
        
        int CntOfAWins = 0;
        for(const auto& [AComboSum, AComboCnt] : AComboVector)
        {
            for(const auto& [BComboSum, BComboCnt] : BComboVector)
            {
                if(BComboSum >= AComboSum)
                {
                    break;
                }
                
                CntOfAWins += AComboCnt * BComboCnt;
            }
        }
        
        if(CntOfAWins > MaxCntOfAWins)
        {
            MaxCntOfAWins = CntOfAWins;
            Answer = A;
        }
    } while(next_permutation(IsADice.begin(), IsADice.end()));
    
    transform(Answer.begin(), Answer.end(), Answer.begin(), [](int& i) { return i + 1; });
    return Answer;
}

📚 새롭게 알게된 내용

자기 직전에 PR을 써서 설명이 부실한 점 양해해주세요... ㅜ
질문 남겨주시면 부가 설명 고봉밥으로 드리겠습니다.

tgyuuAn

덕분에 정말 고민, 삽질 많이했고요

도저히 아니다 싶어서 PR 봤씁니다.

PR을 보니까 제가 착각하고 있떤 부분이

저는 $10C5$를 계산하면 어차피 상대방은 자동적으로 나머지 5개를 가져야 하는데,

그걸 간과하고 252개의 경우가 있다고 했을 때,

A꺼 1개 제외하고 B가 251개의 경우를 선택할 수 있다고 착각해서 계속 $252 X 251$이 전체 경우라고 착각했네요...

🙃🙃🙃🙃🙃🙃

너무 우매했습니다..

저도 PR처럼 접근을 할려고 했었는데,

위 부분에서 가장 worst 케이스 일 경우,

$6^5 = 7739$개이므로

$7739 * 7739 = 60,466,176$ (약 6천만) 번을 순회하지 않나요?

그러면 $10C5$ 인 252와 곱했을 때 타임아웃이 나지 않나요?

혹시 제가 착각하고 있는 부분이 있으면 찝어주시면 감사하겠습니다.

9kyo-hwang · 2024-02-13T07:13:03Z

가장 worst 케이스 일 경우,

65=7739개이므로

7739∗7739=60,466,176 (약 6천만) 번을 순회하지 않나요?

그러면 10C5 인 252와 곱했을 때 타임아웃이 나지 않나요?

혹시 제가 착각하고 있는 부분이 있으면 찝어주시면 감사하겠습니다.

지금 코드로는 정확히 시간 계산이 힘들어서, [각 조합 별 합, 합이 등장한 횟수] dictionary로 반환하지 않고 [각 조합 별 합1, 합2, ...] 이런 식으로 그냥 쭉 나열한 리스트로 반환했다고 가정함.
가장 많은 n = 10, 즉 각각 주사위를 5개씩 들고간 경우로 가정했을 때, A, B는 각각 길이가 7739인 리스트를 반환받음. 이 때 A가 B에 비해 얼마나 우승했는 지는 이진탐색을 수행해서 검사함. 그러면 7739 * 7739가 아닌 $7739 log(7739)$가 돼서 7739 * 3.88868484666... = 약 31,000이 안됨. 그래서 충분히 가능함

from itertools import combinations, product
from collections import defaultdict
from typing import *
from bisect import bisect_left


def get_list_of_combo_sum(dices, indices):
    list_combos: List[int] = []
    for pips in product(range(6), repeat=len(indices)):
        sum_combo: int = sum(dices[i][j] for i, j in zip(indices, pips))  # i번째 주사위 j번째 눈
        list_combos.append(sum_combo)
    return sorted(list_combos)


def solution(dice):
    answer: List[int] = []
    
    n: int = len(dice)
    dice_indices: Set[int] = set(range(n))
    max_win_cnt: int = 0
    for A in combinations(range(n), n // 2):
        B: Set[int] = dice_indices.difference(A)
        
        A_list: List[int] = get_list_of_combo_sum(dice, A)
        B_list: List[int] = get_list_of_combo_sum(dice, B)
        
        win_cnt: int = 0
        for A_combo_sum in A_list:
            win_cnt += bisect_left(B_list, A_combo_sum)
        
        if win_cnt > max_win_cnt:
            max_win_cnt = win_cnt
            answer = A
        
    return [i + 1 for i in answer]

그 코드가 이건데,

빡센 테케 통과 시간이 이만큼 걸림.

그리고 본문에 코드로는

이만큼 시간이 걸림. 1초 가까이 차이나는 걸 보면 각 조합 별 합을 카운팅해서 중복을 제거한 게 생각보다 리스트 길이를 많이 압축해주나 봄.

tgyuuAn · 2024-02-13T07:40:42Z

이 때 A가 B에 비해 얼마나 우승했는 지는 이진탐색을 수행해서 검사함.

이 부분이 잘 이해가 안 되어요.................. 어떻게 쓰는거죠

9kyo-hwang · 2024-02-13T09:22:24Z

이 때 A가 B에 비해 얼마나 우승했는 지는 이진탐색을 수행해서 검사함.

이 부분이 잘 이해가 안 되어요.................. 어떻게 쓰는거죠

1번 테스트 케이스 기준으로, A가 1번/2번 주사위를 가져갔고 B가 3번/4번 주사위를 가져갔을 때 댓글의 get_list_of_combo_sum(dices, indices) 함수를 실행하면 A_list와 B_list에는 각각 아래와 같은 리스트를 반환받음.

A: [4, 4, 4, 4, 5, 5, 5, 5, 5, 5, 6, 6, 6, 6, 6, 6, 7, 7, 7, 7, 7, 7, 8, 8, 8, 8, 8, 8, 9, 9, 9, 9, 9, 9, 10, 10]
B: [2, 2, 4, 4, 4, 4, 5, 5, 5, 5, 5, 5, 5, 5, 6, 6, 7, 7, 7, 7, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 9, 9, 9, 9, 9, 9]

말 그래도 모든 눈 조합에 대한 합이 다 들어가있는 1차원 리스트임.

이제 각 A 원소 x에 대해 B_list에서 x보다 큰 개수를 모두 더하면 되는데,

win_cnt: int = 0
for A_combo_sum in A_list:
    win_cnt += bisect_left(B_list, A_combo_sum)

이를 bisect_left라는 이진탐색 라이브러리 내 함수를 이용해 위치를 찾아냄.
선형 탐색이라면 0번 원소부터 차례로 확인해서 x보다 큰 원소가 나올 때까지 counting을 하겠지만, 이진 검색을 통해 x보다 큰 첫 번째 원소 인덱스를 찾아내면 그 인덱스가 곧 x보다 작은 원소 개수이니까 그거를 더하면 됨.

gjsk132

뭔가 코드 짜려고 하니까 각 주사위 눈의 합에서부터 시간 터지는 방법밖에 생각 안 나서 어쩌지하다가 결국 PR을 봤습니다...
PR을 보고나서야 하나둘씩 이해가네요...

코드 읽다가 뭔가 시간을 줄일 수 있는 방법이 이것저것 생각나서 파이썬 코드를 그대로 들고가서 이것저것 실험했습니다

결론적으로... 꽤나 성공적인 것 같아요

누적합

뭔가 중간에 for 반복문 2번 쓰는 부분을 누적합으로 하면 더 시간이 적게 들지 않을까해서 시도해봤습니다.
B_combo를 누적합을 사용해서 특정 눈의 합 이하인 경우의 수를 만들어줍니다.
( 누적합으로 만들어 줄 경우에는 굳이 정렬된 리스트일 필요가 없어서 딕셔너리로 남겨뒀습니다. )
A_combo_sum이 5일 때, 누적합으로 미리 구한 4 이하인 수를 바로 곱하는 방법을 사용했습니다.

from itertools import combinations, product
from collections import defaultdict, deque


def get_count_of_each_combo(dices, indices):
    num_combos: Dict[int, int] = defaultdict(int)
    
    for pips in product(range(6), repeat=len(indices)):
        sum_combo: int = sum(dices[i][j] for i, j in zip(indices, pips))
        num_combos[sum_combo] += 1
        
    return num_combos

# 리스트 정렬
def change_sort_list(combo):
    return sorted(combo.items())

# 누적합으로 만들어주는 함수
def make_prefix_sum(combo, cnt):
    num_combos, limit = combo, max(combo.keys())
    for i in range(2,cnt):
        num_combos[i] += num_combos[i-1]
    
    return num_combos
    

def solution(dice):
    answer: List[int] = []
    
    n: int = len(dice)
    dice_indices: Set[int] = set(range(n))
    max_win_cnt: int = 0
    for A in combinations(range(n), n // 2):
        B: Set[int] = dice_indices.difference(A)
        
	# A는 원래 형식의 리스트로, B를 누적합으로 받는다.
        A_combos: List[Tuple[int, int]] = change_sort_list(get_count_of_each_combo(dice, A))
        B_combos: Dict[int, int] = make_prefix_sum(get_count_of_each_combo(dice, B), A_combos[-1][0])
        win_cnt: int = 0
	
	# 누적합 결과를 이용해서 바로 접근하기
        for A_combo_sum, A_combo_cnt in A_combos:
            win_cnt += A_combo_cnt * B_combos[A_combo_sum-1]
        
        if win_cnt > max_win_cnt:
            max_win_cnt = win_cnt
            answer = A
        
    return [i + 1 for i in answer]

조합의 절반

`A`가 [1, 4]일 때는 `A`가 [2, 3]일 때의 `B`의 결과와 같습니다. 즉, 조합을 절반만 해줘도 결과를 알 수 있습니다.

그리고 combinations에서 정반대가 되는 인덱스는 결과들을 일렬로 나열했을 때, 중앙을 기준으로 반대편에 있습니다.

따라서, 절반만 탐색해줘도 충분히 결과를 알 수 있다는 점을 이용했습니다!
( 추가로 B_win_cnt를 만들어서 무승부인 경우를 빼고, 마지막에 A_win_cnt를 빼줬습니다.

from itertools import combinations, product
from collections import defaultdict


def get_count_of_each_combo(dices, indices):
    num_combos: Dict[int, int] = defaultdict(int)
    for pips in product(range(6), repeat=len(indices)):
        sum_combo: int = sum(dices[i][j] for i, j in zip(indices, pips))
        num_combos[sum_combo] += 1
    return sorted(num_combos.items())


def solution(dice):
    answer: List[int] = []
    
    n: int = len(dice)
    dice_indices: Set[int] = set(range(n))
    max_win_cnt: int = 0
    for A in combinations(range(n), n // 2):
        
	# 절반이 지난 위치에서 반복을 중단
        if A[0]:
            break
        
        B: Set[int] = dice_indices.difference(A)
        
        A_combos: List[Tuple[int, int]] = get_count_of_each_combo(dice, A)
        B_combos: List[Tuple[int, int]] = get_count_of_each_combo(dice, B)
        
        A_win_cnt: int = 0
	
	# 주사위를 던져서 나올 수 있는 총 경우의 수
        B_win_cnt: int = 6**n
        
        for A_combo_sum, A_combo_cnt in A_combos:
            for B_combo_sum, B_combo_cnt in B_combos:
		
                if B_combo_sum >= A_combo_sum:
		    # 만약 무승부라면 B가 이기는 경우에서 빼준다.
                    B_win_cnt -= (A_combo_cnt * B_combo_cnt) if B_combo_sum == A_combo_sum else 0
                    break
                
                A_win_cnt += A_combo_cnt * B_combo_cnt
        
	# 마지막으로 A가 이기는 경우를 빼준다.
        B_win_cnt -= A_win_cnt
        
	# A의 결과와 B의 결과를 모두 확인해준다.
        if A_win_cnt > max_win_cnt:
            max_win_cnt = A_win_cnt
            answer = A
            
        if B_win_cnt > max_win_cnt:
            max_win_cnt = B_win_cnt
            answer = B
        
    return [i + 1 for i in answer]

누적합 + 조합의 절반

위에꺼 2개 섞은 혼종입니다.

from itertools import combinations, product
from collections import defaultdict, deque


def get_count_of_each_combo(dices, indices):
    num_combos: Dict[int, int] = defaultdict(int)
    
    for pips in product(range(6), repeat=len(indices)):
        sum_combo: int = sum(dices[i][j] for i, j in zip(indices, pips))  # i번째 주사위 j번째 눈
        num_combos[sum_combo] += 1
        
    return num_combos

def change_sort_list(combo):
    return sorted(combo.items())

def make_prefix_sum(combo, cnt):
    num_combos, limit = combo, max(combo.keys())
    for i in range(2,cnt+1):
        num_combos[i] += num_combos[i-1]
    
    return num_combos
    

def solution(dice):
    answer: List[int] = []
    
    n: int = len(dice)
    dice_indices: Set[int] = set(range(n))
    max_win_cnt: int = 0
    for A in combinations(range(n), n // 2):
        
        if A[0]:
            break
        
        B: Set[int] = dice_indices.difference(A)
        
        A_combos: List[Tuple[int, int]] = change_sort_list(get_count_of_each_combo(dice, A))
        B_combos: Dict[int, int] = make_prefix_sum(get_count_of_each_combo(dice, B), A_combos[-1][0])
        
        A_win_cnt: int = 0
        B_win_cnt: int = 6**n
        for A_combo_sum, A_combo_cnt in A_combos:
            A_win_cnt += A_combo_cnt * B_combos[A_combo_sum-1]
            B_win_cnt -= A_combo_cnt * abs(B_combos[A_combo_sum] - B_combos[A_combo_sum-1])
            
        B_win_cnt -= A_win_cnt
            
        if A_win_cnt > max_win_cnt:
            max_win_cnt = A_win_cnt
            answer = A
        
        if B_win_cnt > max_win_cnt:
            max_win_cnt = B_win_cnt
            answer = B
        
    return [i + 1 for i in answer]

열심히 씹고 뜯고 맛본 것 같습니다.
근데 누적합 코드는 너무 복잡해져서 오히려 보기 안 좋은 것 같기도 하네요... 🤔

tgyuuAn · 2024-02-14T05:05:55Z

뭔가 코드 짜려고 하니까 각 주사위 눈의 합에서부터 시간 터지는 방법밖에 생각 안 나서 어쩌지하다가 결국 PR을 봤습니다... PR을 보고나서야 하나둘씩 이해가네요...

코드 읽다가 뭔가 시간을 줄일 수 있는 방법이 이것저것 생각나서 파이썬 코드를 그대로 들고가서 이것저것 실험했습니다

결론적으로... 꽤나 성공적인 것 같아요

누적합
조합의 절반
누적합 + 조합의 절반
열심히 씹고 뜯고 맛본 것 같습니다. 근데 누적합 코드는 너무 복잡해져서 오히려 보기 안 좋은 것 같기도 하네요... 🤔

교황쿠 ㅋㅋㅋㅋㅋㅋㅋㅋㅋㅋㅋㅋㅋㅋㅋㅋㅋ

LJEDD2

프로그래머스 레벨 3 문제는 처음 보는데 난이도가 정말 사악하네요 ^-^
접근법 자체를 떠올리기가 쉽지 않아서 위의 굇수분들의 PR을 보고 차근차근 공부를 해볼 수 있었습니다.
다들 어떻게 문제에 접근하고 해결하는지 엿볼 수 있어서 정말 유익하네요 :>
나영님의 시간 줄이기 과정도 인상깊었습니다 부럽네요 😭

이진탐색과 조합 누적합을 활용하는 게 아직 익숙하지가 않은데 공부를 조금 더 깊게 해봐야겠습니다
좋은 문제 캄사합니다 😎💡

tgyuuAn · 2024-02-15T04:43:47Z

이 때 A가 B에 비해 얼마나 우승했는 지는 이진탐색을 수행해서 검사함.

이 부분이 잘 이해가 안 되어요.................. 어떻게 쓰는거죠

1번 테스트 케이스 기준으로, A가 1번/2번 주사위를 가져갔고 B가 3번/4번 주사위를 가져갔을 때 댓글의 get_list_of_combo_sum(dices, indices) 함수를 실행하면 A_list와 B_list에는 각각 아래와 같은 리스트를 반환받음.
A: [4, 4, 4, 4, 5, 5, 5, 5, 5, 5, 6, 6, 6, 6, 6, 6, 7, 7, 7, 7, 7, 7, 8, 8, 8, 8, 8, 8, 9, 9, 9, 9, 9, 9, 10, 10]

B: [2, 2, 4, 4, 4, 4, 5, 5, 5, 5, 5, 5, 5, 5, 6, 6, 7, 7, 7, 7, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 9, 9, 9, 9, 9, 9]
말 그래도 모든 눈 조합에 대한 합이 다 들어가있는 1차원 리스트임.

이제 각 A 원소 x에 대해 B_list에서 x보다 큰 개수를 모두 더하면 되는데,
win_cnt: int = 0

for A_combo_sum in A_list:

    win_cnt += bisect_left(B_list, A_combo_sum)
이를 bisect_left라는 이진탐색 라이브러리 내 함수를 이용해 위치를 찾아냄.

선형 탐색이라면 0번 원소부터 차례로 확인해서 x보다 큰 원소가 나올 때까지 counting을 하겠지만, 이진 검색을 통해 x보다 큰 첫 번째 원소 인덱스를 찾아내면 그 인덱스가 곧 x보다 작은 원소 개수이니까 그거를 더하면 됨.

와우 이해했습니다 🫡🫡🫡

tgyuuAn

from itertools import combinations, product

def get_dice_sum_list(dice, idxes):
    sum_list = []
    
    for sum_idxes in product(range(6), repeat=len(idxes)):
        accumulate = 0

        for pick_dice_idx, sum_idx in zip(idxes,sum_idxes):
            accumulate += dice[pick_dice_idx][sum_idx]

        sum_list.append(accumulate)
    return sorted(sum_list)

def get_a_win_count(a_dice_sum_list, b_dice_sum_list):
    total_win_count = 0

    for a_element in a_dice_sum_list:
        left, right = 0, len(a_dice_sum_list)
        win_count = 0

        while left+1 < right:
            mid = (left+right)//2
            if check(a_element, b_dice_sum_list[mid]):
                left = mid
                win_count = mid

            else: right = mid

        total_win_count += win_count+1

    return total_win_count

def check(a,b):
    if a>b: return True
    return False

def solution(dice):
    n = len(dice)

    max_win_count = -1
    max_win_indexes = []
    for a_dice_idxes in combinations(range(n),n//2):
        b_dice_idxes = []
        for b_dice_idx in range(n):
            if b_dice_idx in a_dice_idxes: continue

            b_dice_idxes.append(b_dice_idx)


        a_dice_sum_list = get_dice_sum_list(dice, a_dice_idxes)
        b_dice_sum_list = get_dice_sum_list(dice, b_dice_idxes)

        win_count = get_a_win_count(a_dice_sum_list, b_dice_sum_list)

        if win_count > max_win_count: 
            max_win_count = win_count
            max_win_indexes = a_dice_idxes

    return list(map(lambda x : x+1,max_win_indexes))

dice = [[1, 2, 3, 4, 5, 6], [3, 3, 3, 3, 4, 4], [1, 3, 3, 4, 4, 4], [1, 1, 4, 4, 5, 5]]
print(solution(dice))

아이고 ............

janghw0126

저도 프로그래머스 레벨 3 문제는 처음 보는데 정말 정말 쉽지 않았습니다...😭😭
문제를 이해하고 접근하는 방법만 생각해내는데 하루가 걸려서 결국 교황님의 PR을 보고 천천히 코드를 따라하면서 이해했어요🥹
너무너무 대단하신 것 같습니다!👍

또 다른 분들의 리뷰들 덕분에 문제를 더 완벽하게 이해할 수 있었습니다!
이진 탐색이랑 조합 누적 합을 활용하는 과정을 코드를 따라하면서 직접 볼 수 있어서 더욱 더 유익했어요😊 다음에 저도 한번 활용을 해보도록 해보겠습니다!
정말정말 수고하셨어요🍀

26-9kyo-hwang

ebf2242

9kyo-hwang added 9-kyo-hwang 작성 중 ⏱️ labels Feb 11, 2024

9kyo-hwang self-assigned this Feb 11, 2024

Munbin-Lee closed this Feb 11, 2024

Munbin-Lee reopened this Feb 11, 2024

Munbin-Lee closed this Feb 11, 2024

Munbin-Lee reopened this Feb 11, 2024

9kyo-hwang requested review from LJEDD2, gjsk132 and janghw0126 February 11, 2024 17:21

9kyo-hwang added 리뷰 기다리는 중 🔥 and removed 작성 중 ⏱️ labels Feb 11, 2024

Munbin-Lee closed this Feb 11, 2024

Munbin-Lee reopened this Feb 11, 2024

tgyuuAn reviewed Feb 13, 2024

View reviewed changes

gjsk132 approved these changes Feb 13, 2024

View reviewed changes

LJEDD2 approved these changes Feb 14, 2024

View reviewed changes

tgyuuAn approved these changes Feb 15, 2024

View reviewed changes

janghw0126 approved these changes Feb 15, 2024

View reviewed changes

tgyuuAn added 리뷰 완료 ✔️ and removed 리뷰 기다리는 중 🔥 labels Feb 15, 2024

9kyo-hwang merged commit fc705b3 into main Feb 15, 2024
3 of 4 checks passed

9kyo-hwang mentioned this pull request Jun 6, 2024

5 mjj111 #192

Merged

Provide feedback

Saved searches

Use saved searches to filter your results more quickly

26-9kyo-hwang #104

26-9kyo-hwang #104

9kyo-hwang commented Feb 11, 2024 •

edited

Loading

tgyuuAn left a comment •

edited

Loading

9kyo-hwang commented Feb 13, 2024

tgyuuAn commented Feb 13, 2024

9kyo-hwang commented Feb 13, 2024

gjsk132 left a comment •

edited

Loading

tgyuuAn commented Feb 14, 2024

LJEDD2 left a comment

tgyuuAn commented Feb 15, 2024

tgyuuAn left a comment

janghw0126 left a comment •

edited

Loading

26-9kyo-hwang #104

26-9kyo-hwang #104

Conversation

9kyo-hwang commented Feb 11, 2024 • edited Loading

🔗 문제 링크

✔️ 소요된 시간

✨ 수도 코드

1. 이해

2. 설명

1. A가 가져갈 주사위 선택

2. 가져간 주사위를 굴린 결과 세기

3. 전체 코드

📚 새롭게 알게된 내용

tgyuuAn left a comment • edited Loading

Choose a reason for hiding this comment

9kyo-hwang commented Feb 13, 2024

tgyuuAn commented Feb 13, 2024

9kyo-hwang commented Feb 13, 2024

gjsk132 left a comment • edited Loading

Choose a reason for hiding this comment

tgyuuAn commented Feb 14, 2024

LJEDD2 left a comment

Choose a reason for hiding this comment

tgyuuAn commented Feb 15, 2024

tgyuuAn left a comment

Choose a reason for hiding this comment

janghw0126 left a comment • edited Loading

Choose a reason for hiding this comment

9kyo-hwang commented Feb 11, 2024 •

edited

Loading

tgyuuAn left a comment •

edited

Loading

gjsk132 left a comment •

edited

Loading

janghw0126 left a comment •

edited

Loading