12-dohyeondol1

[dohyeondol1]

🔗 문제 링크

합분해

✔️ 소요된 시간

30분! 쉬운 DP 문제는 조금씩 시간단축이 되어가는 것 같아 기쁩니다 ㅎㅎ

✨ 수도 코드

0부터 N까지의 정수 K개를 더해서 그 합이 N이 되는 경우의 수를 구하는 문제입니다.

Warning

0부터 N까지의 정수이므로, 0을 더해서 정수의 개수를 채우는 경우도 포함해야 합니다.
ex) 0부터 1까지의 정수 2개를 더해서 합이 1이 되는 경우 : 1+0, 0+1 = 2개

예제 입력인 N = 20, K = 2 와 N = 6, K = 4를 확인하기 위해,
0부터 i까지의 정수 k개를 더해서 합이 i가 되는 경우의 수를 i = 0 ~ 20, k = 0 ~ 6 의 테이블로 작성하면 다음과 같습니다.

제가 풀 때 이만큼 많이 쓰진 않았지만... 어느정도 직접 경우의수를 구해서 표를 그려보면 규칙을 찾을 수 있습니다.

$i ≥ 1$ 이고 $k ≥ 2$ 인 조건에서, 다음 점화식이 성립합니다.

$$ dp[i][k] = dp[i-1][k] + dp[i][k-1] $$

해당 점화식이 적용되지 않는 범위는 i = 0 이거나, 0 ≤ k ≤ 1 일 경우입니다.
이는 단순히 문제대로 이해하면 쉬운데,

"0부터 0까지의 정수 k개를 더해서 합이 0이 되는 경우의 수"를 구하는 것이므로, 사용할 수 있는 수가 0하나밖에 없습니다.
다른 수가 없으므로 개수만 채워질 뿐 합은 0인 경우의 수 하나만 존재하게 되는 것이죠.

또한 k가 0일 경우 사용할 수 있는 정수가 없으므로 경우의 수는 아무것도 선택하지 않는 경우 하나며,

0부터 i까지의 정수 범위에서, 개수 k가 1일 경우 합이 i가 될 수 있는 경우는 자기자신을 선택하는 경우 하나입니다.

따라서 위와 같은 범위에서의 초기값을 설정해주고,
앞서 구한 점화식을 이용해 각 결과를 1,000,000,000으로 나눈 나머지를 구하면 문제를 해결할 수 있습니다.

수도 코드

int main() {
    N과 K를 입력받음

    크기가 (N+1) x (K+1)인 2차원 dp 배열을 0으로 초기화

    i를 0부터 N까지 반복:
        dp[i][0] = 0으로 설정
        dp[i][1] = 1로 설정

    i를 0부터 K까지 반복:
        dp[0][i] = 1로 설정

    i를 1부터 N까지 반복:
        j를 2부터 K까지 반복:
            dp[i][j]에 dp[i-1][j]와 dp[i][j-1]을 더한 값을 저장
            (단, 결과는 1,000,000,000으로 나눈 나머지를 저장)

    dp[N][K] 값을 출력

    return 0
}

2차원 DP는 처음 사용해보는데 쉬운 문제라서 금방 풀었습니다.
DP는 항상 규칙 찾는 재미에 하는 것 같아요 :D

PR을 쓰고보니 k = 0일 경우는 굳이 배열에 포함하지 않았어도 문제없이 풀었을 것 같긴 하네요

📚 새롭게 알게된 내용

[froglike6]

저는 조합으로 접근해봤습니다. 별과 막대라는 이론을 사용했습니다.
그렇게 어려운 이론은 아니고, "특정 조합 정리를 도출하는 데 도움이 되는 그래픽 도구"라고 하네요 ㅎㅎ.
한번 별과 막대를 이용해 문제를 풀어보겠습니다.

예시: $N=6$이고, $M=4$일 때

이 경우에 구하고자 하는 것은, $x_1 + x_2 + x_3 + x_4 = 6$($x_1, x_2, x_3, x_4\geq0$)이 가능한 경우의 수를 구하는 것입니다.
별이 6개 있고, 막대가 3개 있습니다(* * * * * * | | |). 막대가 3인 이유는, 별을 막대 3개로 나누면 4개의 구역으로 나누어지기 때문입니다.

경우의 수

│ │ │ * * * * * * 인 경우에는, $x_1=0,;x_2=0,;x_3=0,;x_4=6$입니다.
│ │ * │ * * * * * 인 경우에는, $x_1=0,;x_2=0,;x_3=1,;x_4=5$입니다.
│ │ * * │ * * * * 인 경우에는, $x_1=0,;x_2=0,;x_3=2,;x_4=4$입니다.
│ │ * * * │ * * * 인 경우에는, $x_1=0,;x_2=0,;x_3=3,;x_4=3$입니다.
│ │ * * * * │ * * 인 경우에는, $x_1=0,;x_2=0,;x_3=4,;x_4=2$입니다.
│ │ * * * * * │ * 인 경우에는, $x_1=0,;x_2=0,;x_3=5,;x_4=1$입니다.
│ │ * * * * * * │ 인 경우에는, $x_1=0,;x_2=0,;x_3=6,;x_4=0$입니다.
│ * │ │ * * * * * 인 경우에는, $x_1=0,;x_2=1,;x_3=0,;x_4=5$입니다.
│ * │ * │ * * * * 인 경우에는, $x_1=0,;x_2=1,;x_3=1,;x_4=4$입니다.
│ * │ * * │ * * * 인 경우에는, $x_1=0,;x_2=1,;x_3=2,;x_4=3$입니다.
│ * │ * * * │ * * 인 경우에는, $x_1=0,;x_2=1,;x_3=3,;x_4=2$입니다.
│ * │ * * * * │ * 인 경우에는, $x_1=0,;x_2=1,;x_3=4,;x_4=1$입니다.
│ * │ * * * * * │ 인 경우에는, $x_1=0,;x_2=1,;x_3=5,;x_4=0$입니다.
│ * * │ │ * * * * 인 경우에는, $x_1=0,;x_2=2,;x_3=0,;x_4=4$입니다.
│ * * │ * │ * * * 인 경우에는, $x_1=0,;x_2=2,;x_3=1,;x_4=3$입니다.
│ * * │ * * │ * * 인 경우에는, $x_1=0,;x_2=2,;x_3=2,;x_4=2$입니다.
│ * * │ * * * │ * 인 경우에는, $x_1=0,;x_2=2,;x_3=3,;x_4=1$입니다.
│ * * │ * * * * │ 인 경우에는, $x_1=0,;x_2=2,;x_3=4,;x_4=0$입니다.
│ * * * │ │ * * * 인 경우에는, $x_1=0,;x_2=3,;x_3=0,;x_4=3$입니다.
│ * * * │ * │ * * 인 경우에는, $x_1=0,;x_2=3,;x_3=1,;x_4=2$입니다.
│ * * * │ * * │ * 인 경우에는, $x_1=0,;x_2=3,;x_3=2,;x_4=1$입니다.
│ * * * │ * * * │ 인 경우에는, $x_1=0,;x_2=3,;x_3=3,;x_4=0$입니다.
│ * * * * │ │ * * 인 경우에는, $x_1=0,;x_2=4,;x_3=0,;x_4=2$입니다.
│ * * * * │ * │ * 인 경우에는, $x_1=0,;x_2=4,;x_3=1,;x_4=1$입니다.
│ * * * * │ * * │ 인 경우에는, $x_1=0,;x_2=4,;x_3=2,;x_4=0$입니다.
│ * * * * * │ │ * 인 경우에는, $x_1=0,;x_2=5,;x_3=0,;x_4=1$입니다.
│ * * * * * │ * │ 인 경우에는, $x_1=0,;x_2=5,;x_3=1,;x_4=0$입니다.
│ * * * * * * │ │ 인 경우에는, $x_1=0,;x_2=6,;x_3=0,;x_4=0$입니다.

이렇게 하면, 모든 경우의 수를 구할 수 있습니다.

따라서 문제를 푸는 방법은, ${n + k - 1 \choose k - 1}$이 됩니다.

import sys, math
input = sys.stdin.readline

n,k=map(int,input().split())
print(math.comb(n+k-1,k-1)%1000000000)

근데 알고리즘 분류에 조합론이 없네요.. 추가 해야겠습니다 ㅎㅎ

[dohyeondol1]

@froglike6
우왁......!!! 신기하네요 이런 풀이가 가능하다니...
저는 dp가 더 익숙해서 dp가 푸는데에는 빨랐을 것 같은데, 조합을 잘 알았더라면 저 풀이가 훨씬 빨랐을지도 모르겠습니다 ㅎ

[hadongun]

생각보다 금방 푸셔서 쉬울 줄 알고 덤볐다가 뚜까 맞았네요

점화식을 구하려고 k는 그대로 둔 채로 n 값이 증가할 때 마다 변화를 관찰했는데.. 발견하지 못했습니다.
제가 생각한 이 점화식의 핵심은 n과 k의 변화를 동시에(?) 보는 것이 핵심이 아닐까...하네요
그렇게 n,k를 동시에 보니 점화식이 보이더군요!

이후 n이 0인경우, k가 1인 경우 모두 경우의 수가 1임을 초기화 하여 문제를 해결했습니답

파이썬 co드

n, k = map(int, input().split())
dp = [[0]*(k+1) for _ in range(n+1)]
for i in range(n+1):
    dp[i][1] = 1
for i in range(k+1):
    dp[0][i] = 1
  
for i in range(1, n+1):
    for j in range(1, k+1):
        dp[i][j] = dp[i-1][j] + dp[i][j-1]
        
    
print(dp[n][k]%1000000000)

[caucsejunseo]

확통 문제 풀 듯이 경우의 수 따라 생각해보며 이해하면서 풀려고 했는데 안되네요...
도현님같은 수학 고수가 아니면 그냥 수열 문제 풀 듯이 규칙만 찾는게 더 효율적인 것 같슴다.

C

#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
#include <stdlib.h>
#include <stdbool.h>
#include <string.h>



#define MOD 1000000000

int main() {
    int n, k;
    scanf("%d %d", &n, &k);

    int dp[201][201] = { 0 };

    for (int i = 0; i <= n; i++)
        dp[1][i] = 1;

    for (int i = 2; i <= k; i++) 
    {
        for (int j = 0; j <= n; j++) 
        {
            for (int l = 0; l <= j; l++) 
            {
                dp[i][j] = (dp[i][j] + dp[i - 1][j - l]) % MOD;
            }
        }
    }


    printf("%d\n", dp[k][n]);
    return 0;
}