19-H0ngJu

[H0ngJu]

🔗 문제 링크

합분해

✔️ 소요된 시간

20분

✨ 수도 코드

문제요약
0부터 N까지의 정수 K개를 더해서 그 합이 N이 되는 경우의 수 반환하라@! (단, 1+2와 2+1은 다른 경우로 생각)

이번엔 행복 코딩.. 했습니다

옛날에 풀었던 쉬운 계단 수와 유사해요!

규칙만 찾으면 끝나는 문제입니다

그냥 K, N = 1부터 하나씩 표를 그리면

와 같이됩니다.

즉,

어떤 수 N을 K개의 수의 합으로 나누는 경우의 수는

N-1을 K개의 수의 합으로 나타내는 경우의 수 + N을 K-1개의 수의 합으로 나타내는 경우의 수

입니다.

따라서 고대로 코드 작성하면 끝!

import sys

def input(): return sys.stdin.readline().rstrip()
DIV = 1000000000

N, K = map(int, input().split())

dp = [[0] * (K+1) for _ in range(N+1)]
dp[0][0] = 1

for i in range(N+1):
    for j in range(1, K+1):
        dp[i][j] = dp[i-1][j] + dp[i][j-1]

print(dp[N][K] % DIV)

📚 새롭게 알게된 내용

[9kyo-hwang]

N개의 수 중 K개를 선택하기 -> 조합? 백트래킹 가즈아~
했는데 최대 (200, 200)이니 DP로 결과 캐싱해야겠네~ 하고 DP 테이블 뚝딱 만들었네요 :)

#include <stdio.h>
#define MOD 1000000000

int N, K; 
int dp[201][201];

int backtracking(int n, int k) {
    if(n < 0) {
        return 0;
    } else if(k == 0) {
        return n == 0;
    } else if(dp[n][k] > 0) {
        return dp[n][k];
    } else {
        for(int i = 0; i <= N; ++i) {
            dp[n][k] += backtracking(n - i, k - 1);
            dp[n][k] %= MOD;
        }
        return dp[n][k];
    }
}

int main() {
    scanf("%d%d", &N, &K);
    printf("%d", backtracking(N, K));
    return 0;
}

확실히 Top-down 방식이 Bottom-up보다 느리네요 :(

[tgyuuAn]

와 DP 오랜만.....

import sys

def input(): return sys.stdin.readline().rstrip()

N, K = map(int, input().split())

DP = [[0 for _ in range(N+1)] for _ in range(K)]

for init in range(N+1):
    DP[0][init] = 1

for step in range(1,K):
    for plus_num in range(N+1):
        for now_num in range(N-plus_num+1):
            DP[step][now_num+plus_num] += DP[step-1][now_num]

print(DP[-1][-1]%1_000_000_000)

덕분에 행복코딩했씁니다.................... 반성합니다......

[SeongHoonC]

처음에 이전 행 0~column 까지 합을 계산했는데 이게 (row, column-1) 이랑 같다는걸 깨닫고 수정했더니 시간이 거의 절반컷..! 재밌었습니당

코틀린은 오버플로 때문에 Long 타입이라도 매번 나머지 계산을 해줘야하네용

import java.io.BufferedReader
import java.io.InputStreamReader

private lateinit var br: BufferedReader

fun main() {
    br = BufferedReader(InputStreamReader(System.`in`))

    val (N, K) = br.readLine().split(" ").map { it.toInt() }
    val dp: Array<Array<Long>> = Array(K + 1) { row ->
        Array(N + 1) { if (row == 1) 1 else 0 }
    }

    for (row in 2..K) {
        dp[row][0] = dp[row - 1][0]
        for (column in 1..N) {
            dp[row][column] = (dp[row - 1][column] + dp[row][column - 1]) % 1_000_000_000L
        }
    }
    println(dp[K][N] % 1_000_000_000L)
}

[alstjr7437]

점화식이 옛날 DP 기본 문제와 비슷해서 바로 떠오른 문제 같네요!!!

따로 홍주님 코드와 완전 똑같 ㄷㄷㄷㄷㄷ

n, k = map(int,input().split())
dp = [[0] * (k+1) for _ in range(n+1)]
dp[0][0] = 1

for i in range(0, n+1):
    for j in range(1, k+1):
            dp[i][j] = dp[i-1][j] + dp[i][j-1]

print(dp[n][k] % 1_000_000_000)