18-mj010504

[mj010504]

🔗 문제 링크

비밀 코드 해독
https://school.programmers.co.kr/learn/courses/30/lessons/388352

✔️ 소요된 시간

1시간 30분

✨ 수도 코드

• 문제 자체는 조합 을 활용하여 여러 숫자 조합을 만들고 주어진 조건을 만족하는 숫자 조합의 개수를 구하는 간단한 문제입니다.
• 처음에는 1 ~ n까지의 모든 nC5 조합을 구하기 위해 비트마스킹 기법을 활용했습니다.

원래 코드

#include<bits/stdc++.h>

using namespace std;

int m;
bool isValid(vector<int> v, vector<vector<int>> q, vector<int> ans) {
    for(int i = 0; i < q.size(); i++) {
        auto tv = q[i];
         int sum = 0;
        for(int j = 0; j < m; j++) {
            for(int k = 0; k < m; k++) {
                if(v[k] == tv[j]) {
                    sum++;
                    break;
                }
            }
        }
            
         
        if(sum != ans[i]) return false;
    
    }

    return true;
}


int solution(int n, vector<vector<int>> q, vector<int> ans) {
    int res = 0;
    m =  q[0].size();

    for(int i = 0; i < (1 << n); i++) {
        vector<int> v;
        for(int j = 0; j < n; j++) {
            if(i & (1 << j)) v.push_back(j + 1);
        }

        if(v.size() == m && isValid(v, q, ans)) {
            res++;
        }
    }


    return res;
}

• 하지만 다음과 같은 풀이는 최악의 경우O(2^30)의 시간복잡도를 가질 수 있기 때문에 테스트 케이스 12번부터 시간초과가 났습니다.
• 따라서 여러가지 시간초과를 최적화할 풀이방법을 찾아봤습니다.
• 첫번째로 시도한 방법은 두 배열을 비교하여 같은 원소가 몇개인지 찾는 로직을 이중 포인터를 사용했습니다. 하지만 이렇게 해도 시간초과가 났고 구글링해봤습니다.
• 구글링을 해보고 나서 알게 된건데 q[i]의 길이가 5로 고정되있다는 사실을 알게 되었습니다. 제가 또 문제를 제대로 읽지 않고 풀이를 시작했네요. 길이가 5로 고정되어있기 때문에 5중 for문을 이용하여 1 ~ n까지의 nC5의 모든 조합을 불필요한 조합을 거르는 과정없이 구할 수 있었고 시간이 훨씬 적게 걸리는 것을 확인할 수 있었습니다.

질문

• 여러분들은 조합이 필요할 때 어떻게 처리하는지 궁금합니다. 저는 주로 비트마스킹 기법을 활용합니다.

📚 새롭게 알게된 내용

• 문제를 꼼꼼히 읽어야 한다는 걸 다시 한번 리마인드했습니다.
• 내가 짜는 로직이 시간초과가 날 것 같은지 항상 생각하고, 좋은 방안이 떠오르지 않는다면 문제를 다시 한번 꼼꼼이 읽어봐야한다는 걸 알았습니다!

[hyeokbini]

저는 조합을 만들 때 그때그때 상황에 맞게 다양한 방법을 시도하려고 하지만, 대체적으로는 재귀함수를 사용하는 것 같습니다.

이번 문제에서도 결국 모든 케이스를 만든 후 브루트포스로 이 케이스가 가능한지에 대해 체크하는 과정이 필요한데, 필연적으로 nC5 연산을 할 수밖에 없습니다. 재귀를 쓸 때는 파라미터로 여러 변수를 줘야 하거나, 그게 싫다면 변수를 전역으로 빼버린 후에 사용하는 과정이 필요하긴 하지만 이 방법이 몸에 익어서 자주 사용하게 되는 것 같습니다.

void comb(vector<int> combination,int start)
{
    if(combination.size() == 5)
    {
        check(combination);
        return;
    }
    for(int i = start; i <= n; i++)
    {
        combination.push_back(i);
        comb(combination,i + 1);
        combination.pop_back();
    }
}

문제에서 사용한 조합 코드입니다. 단순하게 이번 값을 사용했다면 다음 깊이에서는 그 값부터 반복문을 시작하는 로직입니다.

아래는 제출 코드입니다. 문제 푸시느라 고생하셨어요!

비밀 코드 해독/c++

#include <bits/stdc++.h>

using namespace std;
int n;
vector<vector<int>> q;
vector<int> ans;
int answer;


void check(vector<int> comb)
{
    for(int i = 0; i < q.size(); i++)
    {
        int checkcount = 0;
        vector<bool> used(n + 1,false);
        for(int j = 0; j < 5; j++)
        {
            used[q[i][j]] = true;
        }
        for(int j = 0; j < 5; j++)
        {
            if(used[comb[j]])
            {
                checkcount++;
            }
        }
        if(checkcount != ans[i])
        {
            return;
        }
    }
    answer++;
    return;
}

void comb(vector<int> combination,int start)
{
    if(combination.size() == 5)
    {
        check(combination);
        return;
    }
    for(int i = start; i <= n; i++)
    {
        combination.push_back(i);
        comb(combination,i + 1);
        combination.pop_back();
    }
}

int solution(int n_in, vector<vector<int>> q_in, vector<int> ans_in) {
    n = n_in;
    q = q_in;
    ans = ans_in;
    vector<int> combination;
    comb(combination,1);
    return answer;
}

[Seol-Munhyeok]

5개만 뽑는 거니까 5중 for 문까지는 솔직히 해볼만하기 때문에 간단한 거면 for문으로 하거나, 또는 혁빈 님처럼 재귀함수로 짜거나, itertools의 combinations 라이브러리를 사용해서 자주 풉니다!
(참고로 itertools에는 순열, 중복순열, 조합, 중복조합을 모두 지원합니다.)

일단 n이 될 수 있는 최대값이 30이고 그 중 5개를 뽑는 경우의 수는 $30C5=142506$ 이고, m이 최대 10이고, 두 배열에서 일치하는 원소 개수를 탐색하는데 또 5번의 연산이 필요하기 때문에 총 필요한 연산 수는 $142,506 \times 10 \times 5 = 7,125,300$ 가 됩니다. 일단 천만은 넘지 않기 때문에 풀 수 있겠다고 생각했습니다.

비밀코드가 될 수 있는 모든 경우의 수를 뽑고 그 후보마다 입력한 정수와 일치하는 개수가 주어진 것과 일치하는 지를 하나하나 비교했습니다.
여기서 비밀코드와 q[i] 가 오름차순으로 정렬되어 있다는 것도 큰 힌트인데 두 배열이 이미 정렬됨이 보장되면 두 배열에서 일치하는 원소의 개수를 구하는 것을 투포인터를 이용해서 $O(n)$에 구할 수 있습니다. 만약 정렬되어 있지 않았다면 제가 구한 연산 횟수 7,125,300 보다 더 커질 수 있어서 시간 제한에 걸릴 수도 있었을 것 같습니다!

파이썬 풀이

from itertools import combinations

def check(x, y):
    i = j = 0
    count = 0
    while i < len(x) and j < len(y):
        if x[i] == y[j]:
            count += 1
            i += 1
            j += 1
        elif x[i] < y[j]:
            i += 1
        else:
            j += 1
    
    return count
        
            
def solution(n, q, ans):
    answer = 0
    cands = combinations(list(range(1, n+1)), 5)
    for cand in cands:
        found = True
        for q1, a1 in zip(q, ans):
            if check(cand, q1) != a1:
                found = False
                break
        if found:
            answer += 1     
        
    return answer

코드를 읽다가 zip 함수가 뭐지? 하고 생각할 수 있는데 매번 q[i]와 ans[i]를 따로 따로 적지않고 한줄로 쓸 수 있게하는 파이썬 함수라고 생각하시면 됩니다.

파이썬이라서 조합 날먹하네하고 생각할 수도 있는데 c++에도 next_permutation 이라는 라이브러리 함수가 있습니다. 이건 순열만 뽑아주기는 하는데 어떻게 잘 조작하면 조합으로도 사용할 수 있습니다. 참고하시면 좋을 거 같습니다!

최근에 풀었던 리모컨 문제랑 비슷한 방법이라서 풀이법이 쉽게 떠오른 거 같습니다. 항상 문제 풀 때는 브루트포스로 먼저 풀리는지 확인하는 습관이 중요한 거 같습니다!

수고하셨습니다.

추가(set 자료형을 이용한 풀이)

다른 사람이 푼 풀이를 살펴보는데 엄청난 풀이가 있어서 가져왔습니다.

import itertools 

def solution(n, q, ans):
    f = list(itertools.combinations(range(1, n + 1), 5))

    for g, cnt in zip(q, ans):
         f = [code for code in f if len(set(code) & set(g)) == cnt]

    return len(f)

제가 신기하다 느꼈던 건 두 배열에서 일치하는 원소의 개수를 구하는 로직을 len(set(code) & set(g)) == cnt로 처리한 부분이었습니다. 파이썬에서 제공하는 세트(집합) 자료형을 이용해 두 배열을 집합으로 만들고 교집합의 개수로 처리했습니다.
투 포인터 풀이가 떠오르기 어려운 것은 아니지만 시간을 절약하기 위해서는 이런 방법도 알아두면 나쁘지 않을 거 같습니다!

[flydongwoo]

저는 완전 탐색으로 풀어보았습니다.
너무 복잡하고 어려운 문제네요 ㅜㅜ
문제 푸느라 고생하셨습니다.

코드/c++

#include <string>
#include <vector>
using namespace std;

int solution(int n, vector<vector<int>> q, vector<int> ans) {
    int answer = 0;
    int q_rows = (int)q.size();
    int ans_len = (int)ans.size();

    for (int a = 1; a <= n - 4; a++) {
        for (int b = a + 1; b <= n - 3; b++) {
            for (int c = b + 1; c <= n - 2; c++) {
                for (int d = c + 1; d <= n - 1; d++) {
                    for (int e = d + 1; e <= n; e++) {
                        bool inCand[31] = { false };
                        inCand[a] = true;
                        inCand[b] = true;
                        inCand[c] = true;
                        inCand[d] = true;
                        inCand[e] = true;

                        bool ok = true;
                        for (int i = 0; i < q_rows; i++) {
                            int cnt = 0;
                            bool seen[31] = { false };
                            for (int j = 0; j < (int)q[i].size(); j++) {
                                int v = q[i][j];
                                if (1 <= v && v <= n) {
                                    if (!seen[v]) {
                                        if (inCand[v]) {
                                            cnt++;
                                        }
                                        seen[v] = true;
                                    }
                                }
                            }
                            if (i < ans_len) {
                                if (cnt != ans[i]) {
                                    ok = false;
                                    break;
                                }
                            } else {
                                ok = false;
                                break;
                            }
                        }
                        if (ok) {
                            answer++;
                        }
                    }
                }
            }
        }
    }
    return answer;
}