20-Seol-Munhyeok

[Seol-Munhyeok]

🔗 문제 링크

코딩 테스트 공부

✔️ 소요된 시간

50분

✨ 수도 코드

접근법

이전에 푼 완전범죄 문제와 유사한 형식의 DP 문제입니다.

문제를 크게 보면 결국 자원(용량) 제한 + 아이템 선택 유형의 배낭 문제와 비슷합니다.

요소	배낭 문제에서의 의미	"코딩테스트 공부" 문제에서의 대응
용량(자원)	배낭의 무게 제한	목표 알고력(maxA)과 코딩력(maxC)
현재 상태	배낭에 채운 무게	현재 알고력 a, 현재 코딩력 c
가치(value)	아이템 넣어서 얻는 가치	알고력 증가량, 코딩력 증가량
비용(weight)	무게	문제를 푸는 데 드는 시간 (cost)

따라서 자원(용량) 제한 + 아이템 선택 유형의 문제라면 이 문제 상황을 어떻게 배낭 문제의 형태로 변형할지를 고민해보면 문제가 풀립니다!

상태 정의 (State)

2차원 DP를 사용해서 상태를 다음과 같이 정의합니다.

• $dp[a][c]$ : 알고력 $a$, 코딩력 $c$ 를 얻는데 걸린 시간

초기값 (Initialization)

dp 테이블의 초기값은 다음과 같이 설정합니다.

• $dp[alp][cop] = 0$
• 나머지 값은 INF로 초기화

alp, cop 는 문제에서 주어진 처음에 가진 알고력과 코딩력입니다. 당연히 초기 상태에서는 걸린 시간이 0입니다.

정답 위치 (Answer)

이 문제에서 구하는 것은 모든 문제들을 풀 수 있는 알고력과 코딩력을 얻는 최단시간입니다. 알고력과 코딩력이 문제의 알고력과 코딩력의 최댓값 이상이면 모든 문제를 풀 수 있습니다.

$maxA$ : 문제들 중 알고력의 최댓값
$maxC$ : 문제들 중 코딩력의 최댓값

• 정답 = $dp[maxA][maxC]$

전이 (Transition)

상태를 잘 정의했으면 다음과 같은 점화식이 도출됩니다.

$alp_{rwd}$ : 문제를 풀었을 때 얻는 알고력
$cop_{rwd}$ : 문제를 풀었을 때 얻는 코딩력
$cost$ : 문제를 푸는데 필요한 시간

• 알고력을 공부하는 경우 : $dp[a+1][c] = \min(dp[a+1][c],\ dp[a][c] + 1)$
• 코딩력을 공부하는 경우 : $dp[a][c+1] = \min(dp[a][c+1],\ dp[a][c] + 1)$
• 문제를 푸는 경우 : $dp[a + alp_{rwd}][c + cop_{rwd}] = \min(dp[a + alp_{rwd}][c + cop_{rwd}],\ dp[a][c] + cost)$

컷(경계 처리, Pruning)

위 점화식을 그대로 코드로 작성하면 런타임 에러가 발생할 것입니다.
범위를 벗어나는 전이는 무시하도록 경계 처리를 해야 오류가 발생하지 않습니다.

초기의 알고력(코딩력) 자체가 maxA(maxC)보다 높은 경우는 예외처리를 해야합니다.

alp, cop = min(alp, maxA), min(cop, maxC)

이렇게 예외처리를 하고 나면 dp 테이블의 크기를 정할 수 있습니다.

dp = [[INF for _ in range(maxC + 1)] for _ in range(maxA + 1)]

그리고 dp 테이블을 채울 때, 문제를 푸는 경우, 채우려는 a가 alp_req 이상, c가 cop_req 이상일 때만 dp 테이블을 채워야합니다.
그리고 항상 a 또는 c를 채울 때 그 값이 maxA과 maxC를 초과하지 않도록 처리해주어야합니다.

for a in range(alp, maxA + 1):
        for c in range(cop, maxC + 1): 
            # 공부하는 경우
            ta, tc = min(maxA, a+1), min(maxC, c+1)
            dp[ta][c] = min(dp[ta][c], dp[a][c] + 1)
            dp[a][tc] = min(dp[a][tc], dp[a][c] + 1)
            
            # 문제 풀이하는 경우
            for alp_req, cop_req, alp_rwd, cop_rwd, cost in problems:
                if a >= alp_req and c >= cop_req:
                    na, nc = min(maxA, a + alp_rwd), min(maxC, c + cop_rwd)
                    dp[na][nc] = min(dp[na][nc], dp[a][c] + cost)

전체 코드는 Files changed를 확인해주세요!

📚 새롭게 알게된 내용

• DP문제를 풀 때, 상태 정의, 초기값, 정답 위치, 전이, 컷(경계 처리, Pruning) 이 5단계를 생각하면서 문제를 풀면 조금 수월합니다!
• 배낭문제를 단순하게 내면 문제가 너무 쉬워지니까 코딩 테스트에서는 문제를 풀기 위해서는 문제가 요구하는 일정 이상의 알고력과 코딩력이 필요하다 처럼 추가적인 제한을 걸어서 난도를 올리는 거 같습니다. 이렇게 제한이 있는 경우는 for 문 속에서 적절한 if 문으로 처리해서 조건을 만족할 때만 dp 테이블을 채우는 방식으로 풀면 됩니다.

[hyeokbini]

구하는 값은 시간에 관한 내용이고, 이 값은 결국 특정 알고력 / 코딩력에 관한 값으로 저장될 수 있을 것 같아서 무작정 2차원 벡터를 만들고, 값이 어떻게 갱신될 수 있을지 적어 보면서 확인해 봤습니다.

엑셀로 만든 거라 퀄리티가 좀 저렴해 보이네요... 예제 2번의 경우에 대해서 직접 값을 적고, 갱신해 보면서 규칙성을 찾았습니다.

값의 갱신은 크게 2가지로 나눌 수 있습니다.

• 공부를 통한 특정 능력치 + 1, 시간 + 1
• 문제풀이를 통한 능력치 + @, 시간 + @

공부를 통한 능력치 합산 / 시간 계산은 이전 칸 + 1 로직으로 간단히 짤 수 있습니다.

문제풀이를 통한 능력치 합산은 증가량만큼 인덱스를 증가시키고, 해당 칸에 갱신되어있던 값이 현재 칸 + 시간 소모량보다 많다면, 새로운 값으로 갱신시키는 로직을 사용했습니다.

인덱싱에 있어 아웃 오브 레인지가 뜰 것 같아서 조심하면서 로직을 짰는데도, 두 번 정도 코어 덤프를 먹었네요. 항상 DP테이블을 사용할 때는 인덱싱에 주의하면서 코드를 적어야 할 것 같습니다.

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

코딩 테스트 공부 / c++

#include <bits/stdc++.h>

using namespace std;

int solution(int alp, int cop, vector<vector<int>> problems) {
    int maxalgo = 0;
    int maxcod = 0;
    for(int i = 0; i < problems.size(); i++)
    {
        maxalgo = max(maxalgo, problems[i][0]);
        maxcod = max(maxcod, problems[i][1]);
    }

    alp = min(alp, maxalgo);
    cop = min(cop, maxcod);

    vector<vector<int>> dp(maxalgo + 1, vector<int>(maxcod + 1, 1000000000));
    dp[alp][cop] = 0;

    for(int i = alp; i <= maxalgo; i++)
    {
        for(int j = cop; j <= maxcod; j++)
        {
            // 공부해서 능력치 올리기
            if(i + 1 <= maxalgo)
            {
                dp[i + 1][j] = min(dp[i + 1][j], dp[i][j] + 1);
            }
            if(j + 1 <= maxcod)
            {
                dp[i][j + 1] = min(dp[i][j + 1], dp[i][j] + 1);
            }

            // 각 문제 풀기
            for(int k = 0; k < problems.size(); k++)
            {
                if(i >= problems[k][0] && j >= problems[k][1])
                {
                    int ni = min(maxalgo, i + problems[k][2]);
                    int nj = min(maxcod, j + problems[k][3]);
                    dp[ni][nj] = min(dp[ni][nj], dp[i][j] + problems[k][4]);
                }
            }
        }
    }

    return dp[maxalgo][maxcod];
}

[mj010504]

dp문제에 대한 연습과 팁도 많이 얻고 갑니다. 덕분에 dp에 대한 두려움이 조금 사라진 것 같습니다. 감사드립니다.

코딩테스트 공부

#include<bits/stdc++.h>

using namespace std;

int solution(int a, int c, vector<vector<int>> pv) {
    int maxA = 0, maxC = 0;
    for(int i = 0; i < pv.size(); i++) {
        maxA = max(maxA, pv[i][0]);
        maxC = max(maxC, pv[i][1]);
    }

    vector<vector<int>> dp(maxA + 1, vector<int> (maxC + 1, 21437900));
    a = min(a, maxA); c = min(c, maxC);
    dp[a][c] = 0;

    for(int i = a; i <= maxA; i++) {
        for(int j = c; j <= maxC; j++) {
            int ni = min(maxA, i + 1); int nj = min(maxC, j + 1);
            dp[ni][j] = min(dp[ni][j], dp[i][j] + 1);
            dp[i][nj] = min(dp[i][nj], dp[i][j] + 1);

            for(int k = 0; k < pv.size(); k++) {
                if(pv[k][0] <= i && pv[k][1] <= j) {
                    ni = min(maxA, i + pv[k][2]); nj = min(maxC, j + pv[k][3]);
                    dp[ni][nj] = min(dp[ni][nj], dp[i][j] + pv[k][4]);
                }
            }
        }
    }

 
    return dp[maxA][maxC];
}

[flydongwoo]

오랜만에 보는 knapsack 문제이군요!

(알고력, 코딩력) 두 값으로만 정의되고, 어떤 행동을 하든, 결국 새로운 (알고력, 코딩력) 상태로 옮겨가는 거니까 상태공간 탐색 문제라고 생각ㅎ해서 최소 비용으로 특정 상태에 도달하는 것이 목표라고 봤습니다. 그래서 DP를 선택했습니다.
단순 탐색도 잠깐 생각했었는데, 완전 탐색으로 모든 선택을 따라가면 시간 복잡도가 너무 커질 것 같았습니다
모든 행동의 비용이 1이었으면 BFS로 풀었을 것 같네요!

문제 푸느라 고생하셨습니다!

코딩 테스트 공부

```cpp #include #include #include using namespace std;

int solution(int alp, int cop, vector<vector> problems) {
int targetA = 0;
int targetC = 0;
for (size_t k = 0; k < problems.size(); k++) {
targetA = max(targetA, problems[k][0]);
targetC = max(targetC, problems[k][1]);
}

alp = min(alp, targetA);
cop = min(cop, targetC);

const int INF = 1e9;
vector<vector<int>> dp(targetA + 1, vector<int>(targetC + 1, INF));
dp[alp][cop] = 0;

for (int i = alp; i <= targetA; i++) {
    for (int j = cop; j <= targetC; j++) {
        if (dp[i][j] == INF) {
            continue;
        }

        if (i + 1 <= targetA) {
            dp[i + 1][j] = min(dp[i + 1][j], dp[i][j] + 1);
        }

        if (j + 1 <= targetC) {
            dp[i][j + 1] = min(dp[i][j + 1], dp[i][j] + 1);
        }

        for (size_t k = 0; k < problems.size(); k++) {
            int reqA = problems[k][0];
            int reqC = problems[k][1];
            int rwdA = problems[k][2];
            int rwdC = problems[k][3];
            int cost = problems[k][4];

            if (i >= reqA && j >= reqC) {
                int ni = min(targetA, i + rwdA);
                int nj = min(targetC, j + rwdC);
                dp[ni][nj] = min(dp[ni][nj], dp[i][j] + cost);
            }
        }
    }
}

return dp[targetA][targetC];

}