11-dohyeondol1

[dohyeondol1]

🔗 문제 링크

동전 1

✔️ 소요된 시간

1시간

✨ 수도 코드

저번 동전 0 이 합이 k가 되는 동전 개수의 최솟값이었다면,
이번 문제는 합이 k가 되는 동전 개수의 경우의 수를 구해야 합니다.

설명하기에 앞서,
구하고자 하는 가치 합이 0인 경우, 아무 동전도 선택하지 않는 경우 하나가 존재합니다.
따라서 0은 항상 1의 값을 가집니다. 저는 이 부분을 생각 못해서 시간이 더 걸렸습니다 ㅎ

문제의 예제 입력 1과 같이, 동전의 가치를 1, 2, 5로 설정하고 문제를 바라봅시다.
편의를 위해서 동전의 가치를 원(KRW, ₩)으로 설명하겠습니다.

다음과 같은 표에서 시작해봅시다.
동전의 가치가 주어지지 않은 경우 0부터 10까지의 가치합을 표현할 수 있는 경우의 수 테이블입니다.
이를 가치 i에 따른 dp[i]라고 설정해놓겠습니다.

0	1	2	3	4	5	6	7	8	9	10
1	0	0	0	0	0	0	0	0	0	0

먼저 1원만 있는 경우 0부터 10까지의 가치합을 표현할 수 있는 경우의 수는 다음과 같습니다.

0	1	2	3	4	5	6	7	8	9	10
1	1	1	1	1	1	1	1	1	1	1

그리고 2원만 있는 경우는 다음과 같습니다.

0	1	2	3	4	5	6	7	8	9	10
1	0	1	0	1	0	1	0	1	0	1

1원과 2원이 둘 다 있는 경우는 다음과 같습니다.

0	1	2	3	4	5	6	7	8	9	10
1	1	2	2	3	3	4	4	5	5	6

수가 어떤 규칙성이 있는것만 같죠..?
굳이 굳이 여기서 규칙성을 찾아보면, 다음과 같습니다.

• 1원만 있는 경우 : $\text{dp[i]} = \text{dp[i]}+\text{dp[i-1]}$
• 2원만 있는 경우 : $\text{dp[i]} = \text{dp[i]}+\text{dp[i-2]}$

1원과 2원이 둘 다 있는 경우는 규칙성이 있는 것 같지만,
독립적으로 바라보면 앞서 구한 규칙성과 전혀 다른 식이 나오게 됩니다.

$\text{dp[i]} = \left\lfloor \frac{\text{i}}{2} \right\rfloor + 1$

결국 문제에서 동전의 가치가 주어지고 이를 이용해 규칙성이 생겨야 하기 때문에,
1원과 2원이 동시에 있는 경우는
$\text{dp[i]} = \text{dp[i]}+\text{dp[i-1]}$ 이 선행되고,
$\text{dp[i]} = \text{dp[i]}+\text{dp[i-2]}$ 이 계산되어야 합니다.

이는 동전의 가치를 coin[j]라고 했을 때, 다음과 같이 표현할 수 있습니다.

for(int i = 0; i < n; i++)
	for(int j = coin[i]; j <= k; j++)
		dp[j] += dp[j - coin[i]];

이를 검증하기 위해서, 아직 사용하지 않은 5원짜리 동전을 추가해봅시다.

5원만 있는 경우 0부터 10까지의 가치합을 표현할 수 있는 경우의 수는 다음과 같습니다.

0	1	2	3	4	5	6	7	8	9	10
1	0	0	0	0	1	0	0	0	0	1

이제 1원, 2원, 5원이 모두 있는 경우의 수를 위에서 구한 규칙성을 통해 하나하나 식을 구해보면, 다음과 같습니다.

가정한 규칙성을 적용해 1,2,5원의 동전이 있는 경우 가치합 0부터 10까지의 경우의 수를 계산한 과정

• $\text{dp}[0] = 1$ 가정

• 동전의 가치 = 1
  $\text{dp}[1] \quad \text{+=} \quad \text{dp}[0] = 1 $
  $\text{dp}[2] \quad \text{+=} \quad \text{dp}[1] = 1 $
  $\text{dp}[3] \quad \text{+=} \quad \text{dp}[2] = 1 $
  $\text{dp}[4] \quad \text{+=} \quad \text{dp}[3] = 1 $
  $\text{dp}[5] \quad \text{+=} \quad \text{dp}[4] = 1 $
  $\text{dp}[6] \quad \text{+=} \quad \text{dp}[5] = 1 $
  $\text{dp}[7] \quad \text{+=} \quad \text{dp}[6] = 1 $
  $\text{dp}[8] \quad \text{+=} \quad \text{dp}[7] = 1 $
  $\text{dp}[9] \quad \text{+=} \quad \text{dp}[8] = 1 $
  $\text{dp}[10] \quad \text{+=} \quad \text{dp}[9] = 1 $

• 동전의 가치 = 2
  $\text{dp}[2] \quad \text{+=} \quad \text{dp}[0] = 2 $
  $\text{dp}[3] \quad \text{+=} \quad \text{dp}[1] = 2 $
  $\text{dp}[4] \quad \text{+=} \quad \text{dp}[2] = 3 $
  $\text{dp}[5] \quad \text{+=} \quad \text{dp}[3] = 3 $
  $\text{dp}[6] \quad \text{+=} \quad \text{dp}[4] = 4 $
  $\text{dp}[7] \quad \text{+=} \quad \text{dp}[5] = 4 $
  $\text{dp}[8] \quad \text{+=} \quad \text{dp}[6] = 5 $
  $\text{dp}[9] \quad \text{+=} \quad \text{dp}[7] = 5 $
  $\text{dp}[10] \quad \text{+=} \quad \text{dp}[8] = 6 $

• 동전의 가치 = 5
  $\text{dp}[5] \quad \text{+=} \quad \text{dp}[0] = 4 $
  $\text{dp}[6] \quad \text{+=} \quad \text{dp}[1] = 5 $
  $\text{dp}[7] \quad \text{+=} \quad \text{dp}[2] = 6 $
  $\text{dp}[8] \quad \text{+=} \quad \text{dp}[3] = 7 $
  $\text{dp}[9] \quad \text{+=} \quad \text{dp}[4] = 8 $
  $\text{dp}[10] \quad \text{+=} \quad \text{dp}[5] = 10 $

따라서 다음과 같은 결과를 테이블로 표현할 수 있씁니닷...

0	1	2	3	4	5	6	7	8	9	10
1	1	2	2	3	4	5	6	7	8	10

이는 실제 0부터 10까지의 가치합을 표현하는 경우의 수와 동일하며,
이 점화식을 이용한 풀이로 문제를 해결할 수 있습니다.

수도 코드

int main() {
	동전의 개수 n, 구하는 가치합 k 입력
	각 동전의 가치를 저장할 배열 coin 선언
	각 가치합을 구하는 경우의 수를 저장할 배열 dp 선언
	coin 배열을 순회:
		각 동전 가치 입력

	가치합이 0인 경우 1 저장
	i는 0부터 n까지 반복:
		j는 coin[i] 부터 k까지 반복: 
			dp[j]에 dp[j - coin[i]] 만큼을 전부 더하기

	가치합이 k가 되는 경우의 수 출력
}

📚 새롭게 알게된 내용

[froglike6]

설명을 잘 해주셔서, 설명만 보고 문제를 풀 수 있을 정도입니다 ㅎㅎ
저도 같은 방법으로 파이썬으로 문제를 해결해봤습니다.
이러한 문제를 Unbounded Knapsack라고도 한다네요. 갯수 제한없는 배낭 문제라고 합니다.

import sys
input = sys.stdin.readline

n, k = map(int, input().split())
coins = [int(input()) for _ in range(n)]

dp = [0 for _ in range(k+1)]
dp[0] = 1

for coin in coins:
    for j in range(coin, k + 1):
        dp[j] += dp[j - coin]

print(dp[k])

[hadongun]

으..어 아직 dp문제에 익숙하지 않아서 이것저것 써보면서 해도 잘 모르겠네용
설명 자세히 써 주셔서 중간에 힌트를 얻고 꾸역꾸역 파이썬으로 풀어냈습니답..!

dp 볼수록 매력적이군요. 조금 더 익숙해져보겠습니다

동전1

n, k = map(int, input().split())
coin = []
for _ in range(n):
    coin.append(int(input()))

dp = [0] * (k + 1)
dp[0] = 1

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

print(dp[k])

[caucsejunseo]

표로 주시니 이해하기 편했습니다! 경우의 수를 나누는게 1,2,3 만들기 문제랑 비슷한 느낌인 거 같아요. 이제 dp에 좀 익숙해지는 거 같습니다

동전1

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

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

    int* coin = (int*)malloc(sizeof(int) * n);
    int* dp = (int*)malloc(sizeof(int) * (k + 1));


    for (int i = 0; i < n; i++)
    {
        scanf("%d", &coin[i]);
    }

    memset(dp, 0, sizeof(int) * (k + 1));
    dp[0] = 1;


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

    printf("%d", dp[k]);

    return 0;
}