19-mj010504

[mj010504]

🔗 문제 링크

완전 범죄
https://school.programmers.co.kr/learn/courses/30/lessons/389480

✔️ 소요된 시간

40분

✨ 수도 코드

• 이 문제의 목표는 a와 b도둑이 모든 물건을 훔치고, a 도둑이 물건을 훔칠 때 최소한의 흔적을 남기면서, a와 b도둑 모두 경찰에 잡히지 않는 것입니다.
• 모든 물건을 훔쳐야하므로 DFS 방식으로 풀었습니다. 하지만 이번에도 시간초과가 나고 말았습니다.. 최악의 경우 시간 복잡도는 O(2^40)이기 때문입니다. 참고로 AI에게 물어보니 대략 2의 25승 쯤부터 시간초과가 난다고 합니다.
• 보통 DFS로 시간초과가 날때는 시간초과를 방지하기 위해선 중복된 경로를 여러 번 탐색하는 것을 방지해야합니다. 즉 DP를 사용하거나 DFS + 메모이제이션 방식으로 풀이가 가능할 것 같습니다. 저는 DFS + 메모이제이션 방법을 사용했습니다. 이 문제에서 중복된 경로란 (a가 남긴 흔적 총합, b가 남긴 흔적 총합, 현재까지 훔친 물건의 index)가 같으면 중복된 경로로 간주하고 저는 set<tuple<int,int,int>>를 이용하여 중복된 경로는 더 탐색하는 것을 방지하여 해결했습니다.
• 중복된 경로가 발생한다는게 처음에 이해가 안갈 수 있는데 물건을 계속해서 훔치다보면 a와 b가 훔친 물건들이 각각 다르더라도 각각 남긴 흔적의 총합 및 index는 같을 수 있으므로 중복된 경로가 발생할 수 있습니다.

📚 새롭게 알게된 내용

• 프로그래머스에 좋은 문제들이 생각보다 많은 것 같습니다!

[Seol-Munhyeok]

DP를 연습할 수 있는 좋은 문제네요.

일단 N=40이라서 완전탐색은 불가능하고 그림을 몇 개 그려보니 DFS로 처리가 될 거 같았습니다. 그러나 단순 DFS로만 하면 역시 시간 초과이므로 여기서 메모이제이션을 사용해서 최적화를 해야할 거 같았습니다. (14주차 PR에서의 경험이 도움이 되었습니다.)

그런데 상태를 어떻게 정의해야할지 도무지 생각이 나지 않았습니다. 뭔가 배낭 문제 같은 느낌이긴 한데 A와 B 두 개의 경우를 모두 고려해야하니 어려웠습니다.

그래서 아래 설명은 제가 생각한 게 아닌 ChatGPT를 참고함을 밝힙니다.

점화식

$dp[i][a] =$ 앞에서 $i$개 처리했고, A의 누적 흔적이 $a$일 때 달성 가능한 B의 흔적 최소 합

• 시작: $dp[0][0] = 0$, 나머지는 INF(= $m$ 이상)로 채움
• 전이(물건 $i$의 정보가 $(a_i, b_i)$일 때):
  • $i$ 를 A가 훔치면: $dp[i+1][a + a_i] = min(dp[i+1][a + a_i], dp[i][a])$
  • $i$ 를 B가 훔치면: $dp[i+1][a] = min(dp[i+1][a], dp[i][a] + b_i)$
• 범위/가지치기:
  • A는 $a &lt; n$만 유지 ($a$가 $n$ 이상이면 A가 잡히므로 버림)
  • B는 값이 $m$ 이상이면 더 볼 필요 없음(잡힘) → 갱신 스킵
• 최종 답 : $i = N$에서 $a = 0..n-1$ 중 $dp[N][a] &lt; m$인 가장 작은 $a$
  • 없으면 : -1

상태 트리

• 예시 값 : info = [(1,2), (3,1), (2,2)], n=5, m=4
• 노드 라벨: (i, a) [최소 B합]

(0,0)[0]
├─ A:+1 → (1,1)[0]
│   ├─ A:+3 → (2,4)[0]
│   │   ├─ A:+2 → (3,6)[0]   ✗ 컷 (a=6≥5)
│   │   └─ B:+2 → (3,4)[2]   ◀ 후보
│   └─ B:+1 → (2,1)[1]
│       ├─ A:+2 → (3,3)[1]   ◀ 후보
│       └─ B:+2 → (3,1)[3]   ◀ 후보
└─ B:+2 → (1,0)[2]
    ├─ A:+3 → (2,3)[2]
    │   ├─ A:+2 → (3,5)[2]   ✗ 컷 (a=5≥5)
    │   └─ B:+2 → (3,3)[4]   ✗ 컷 (b=4≥4)
    └─ B:+1 → (2,0)[3]
        ├─ A:+2 → (3,2)[3]   ◀ 후보
        └─ B:+2 → (3,0)[5]   ✗ 컷 (b=5≥4)

• 리프는 $i=3$(모든 물건 처리)인 노드들.
• 살아남은 리프들의 $(a, b)$는:
  (3,4)[2], (3,3)[1], (3,1)[3], (3,2)[3]
• 여기서 $b &lt; m(=4)$을 만족하는 리프들 중 $a$가 최소인 게 답 → $a=1$이 최솟값.

코드

def solution(info, n, m):
    INF = int(1e9)
    N = len(info)
    capA = min(n-1, 3*N)  # A 흔적 합 상한
    # dp[i][a] = 앞에서 i개 처리했고,
    # A의 누적 흔적이 a일 때 달성 가능한 B의 흔적 최소 합
    dp = [[INF for _ in range(capA + 1)] for _ in range(N + 1)]
    dp[0][0] = 0
    
    for i in range(N):
        a_i, b_i = info[i][0], info[i][1]
        for a in range(capA + 1):
            if dp[i][a] >= INF:
                continue
            # i를 A가 훔치는 경우
            na = a + a_i
            if na < n and na <= capA:
                dp[i + 1][na] = min(dp[i + 1][na], dp[i][a])
            # i를 B가 훔치는 경우
            nb_sum = dp[i][a] + b_i
            if nb_sum < m:
                dp[i + 1][a] = min(dp[i + 1][a], nb_sum)
    
    answer = INF
    for a in range(capA + 1):
        if dp[N][a] < m:
            answer = min(answer, a)

    return answer if answer != INF else -1

소감

제가 문제 풀이에 어려움을 느꼈던 이유는 현재 $i$번째 물건을 훔치는 사람이 누구인가에 따라서 상태를 나누려고 해서였습니다. 우리가 구하는 건 A도둑이 남긴 흔적의 누적 개수의 최솟값 이지, 누가 어떤 걸 훔쳤는지는 전혀 중요하지 않기 때문에, 흔적의 누적 개수 기반으로 생각했어야 했습니다.

또, 흔적의 범위가 최대 3이라는 것도 큰 힌트였는데 만약 3보다 더 크다면 dp 배열의 크기도 더 커지기 때문에 풀 수 없으므로 이는 문제 제작자가 의도한 부분이라 볼 수 있습니다.

DP 문제를 풀 때, 어떤 변수를 축으로 삼을 것인가(DP 테이블을 어떤 변수를 기준으로 배열의 차원으로 삼느냐)를 정할 때, 제약이 적은 쪽을 축으로 삼는 것이 좋다고합니다.
이 문제에서는

• A 제약: A의 흔적 합 $&lt; n$
• B 제약: B의 흔적 합 $&lt; m$

이 되는데 이 문제는 두 제약의 크기가 같으므로 어느 쪽을 축으로 잡아도 비슷하게 풀립니다.

---

간단히 풀리던 DP 문제와는 달리 점화식 찾기부터 시작해서 범위 등 신경써야 할 점이 많은 문제인 거 같습니다. 나중에 따로 해설 보지 않고 스스로도 한 번 풀어봐야겠습니다.

민준 님 풀이처럼 DFS + 메모이제이션으로도 풀 수 있고 다른 사람들 풀이를 살펴보던 중 그리디로도 풀 수 있는 것 같습니다. (확실하지는 않습니다) 나중에 다시 풀 때는 다른 풀이법으로도 풀어봐야겠습니다.

좋은 문제였습니다. 수고하셨습니다!

[hyeokbini]

저도 DP랑 DFS 중 어떤 방법을 사용할까 하다가, DP를 사용하면 냅색 문제 비스무리하게 풀이가 들어갈 것 같아서 한 수 접고 DFS + 경로 메모이제이션 방법을 선택했습니다. 냅색은 알고리즘을 알아도 손을 대기가 무섭네요..

경로 메모이제이션 아이디어는 3차원 int형 dp를 선언해준 후, [물건 인덱스] [A 흔적 개수] [B 흔적 개수] 인덱스에 A 흔적 개수 정보를 담았습니다. 인덱스를 증가시켜 주면서 A가 훔친 경우, B가 훔친 경우 2가지 경우에 대한 방향으로 재귀 깊이를 증가시키고, 기저 조건에 닿이면 현재 A 흔적값을 return합니다. 그리고 2개 방향의 재귀 연산이 끝나면, 두 값들 중 더 작은 값을 dp[현재 물건 인덱스][A][B]에 저장하는 방식을 사용했습니다.

제출 코드입니다.

완전범죄/c++

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

int amax, bmax;
vector<vector<int>> v;
int dp[101][101][101];

int solve(int i, int a, int b) {
    // A나 B가 임계치 이상이면 가지치기
    if (a >= amax || b >= bmax) return INT_MAX;

    // 모든 물건 처리 완료 → 현재 A 흔적이 결과
    if (i == (int)v.size()) return a;

    // 이미 계산된 상태면 바로 반환
    if (dp[i][a][b] != -1) return dp[i][a][b];

    // 선택 1: A가 훔침
    int takeA = solve(i + 1, a + v[i][0], b);

    // 선택 2: B가 훔침
    int takeB = solve(i + 1, a, b + v[i][1]);

    // 두 경우 중 A 흔적이 더 작은 경우 저장
    dp[i][a][b] = min(takeA, takeB);
    return dp[i][a][b];
}

int solution(vector<vector<int>> info, int n, int m) {
    amax = n;
    bmax = m;
    v = info;
    memset(dp, -1, sizeof(dp));

    int ans = solve(0, 0, 0);
    if (ans == INT_MAX) return -1;
    return ans;
}

그리디한 방식으로 풀 수 있다고도 하는데, 이 방법은 구글링해 보니 정해가 아니고 테스트 케이스가 부실해서 통과된 코드일수도 있다고 합니다. 여기를 참고해보시면 좋을 것 같습니다. 문제 푸시느라 고생하셨어요!

[flydongwoo]

으아 리뷰보니까 다들 DP가 아닌 DFS로 푸셨던데 저는 2차원 DP로 해결했습니다!

d[j] = B의 흔적 합이 j(<m)일 때의 A의 최소합을 구하는 상태입니다.
A가 훔치면 j 그대로 +a_i, B가 훔치면 j+b_i(<m)로 이동하며 A 증가 없으므로
min_j dp[j]이 A 최소. 이 값이 n 이상이면 불가능합니다.

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

int solution(int n, int m, vector<vector<int>> info) {
    const int INF = numeric_limits<int>::max() / 4;
    vector<int> dp(m, INF), ndp(m, INF);
    dp[0] = 0;

    for (size_t i = 0; i < info.size(); i++) {
        int a = info[i][0];
        int b = info[i][1];
        for (int j = 0; j < m; j++) {
            ndp[j] = INF;
        }
        for (int j = 0; j < m; j++) {
            if (dp[j] == INF) {
                continue;
            }
            if (dp[j] + a < ndp[j]) {
                ndp[j] = dp[j] + a;
            }
            if (j + b < m) {
                if (dp[j] < ndp[j + b]) {
                    ndp[j + b] = dp[j];
                }
            }
        }
        dp.swap(ndp);
    }

    int ans = *min_element(dp.begin(), dp.end());
    if (ans >= n) {
        return -1;
    }
    return ans;
}

프로그래머스 문제들은 항상 코드 구현 디테일 부분에서 조금씩 막혀서 지선생님 도움 받는 것 같네요.
문제 푸시느라 고생 많으셨어요!