已知N，如果我們想要換N分，而且每種S = { S1, S2, .. , Sm} 價值的硬幣是不限數量的，那麼我們有多少種方法來兌換？硬幣的順序是無所謂的。

例如：N = 4，S = {1,2,3},，因此有四種答案： {1,1,1,1}，{1,1,2}，{2,2}，{1,3}。所以輸出應該是4。N = 10，S = {2, 5, 3, 6}，因此有四種答案： {2,2,2,2,2}，{2,2,3,3}，{2,2,6}，{2,3,5}和{5,5}。所以輸出應該是5。

1）最優的子結構
想得到答案的總數，我們可以將所有的方法分成兩部分。
1）方案中不包含第m種硬幣（或者Sm）
2）方案中至少包含一個Sm
設count(S[], m, n) 是解決方案的總數，那麼它可以寫為count(S[], m-1, n)與count(S[], m, n-Sm)的和。
所以這個問題具有最優子結構屬性，可以通過解決子問題來解決。

2）重複的子問題
下面是硬幣兌換問題的一個簡單遞迴實現，這個實現是根據上述的遞迴結構來寫的。

#include<stdio.h>

// Returns the count of ways we can sum  S[0...m-1] coins to get sum n
int count( int S[], int m, int n )
{
    // If n is 0 then there is 1 solution (do not include any coin)
    if (n == 0)
        return 1;

    // If n is less than 0 then no solution exists
 

    if (n < 0)
        return 0;

    // If there are no coins and n is greater than 0, then no solution exist
    if (m <=0 && n >= 1)
        return 0;

    // count is sum of solutions (i) including S[m-1] (ii) excluding S[m-1]
    return count( S, m - 1, n ) + count( S, m, n-S[m-1] );
}

// Driver program to test above function
 

int main()
{
    int i, j;
    int arr[] = {1, 2, 3};
    int m = sizeof(arr)/sizeof(arr[0]);
    printf("%d ", count(arr, m, 4));
    getchar();
    return 0;
}

你應該能發現有的子問題已經被重複計算了，請看下面S = {1, 2, 3}，n = 5的遞迴樹。
C({1}, 3)被呼叫了兩次，如果我們把樹完全畫出來，那麼我們可以看到有許多子問題都重複計算了。

C() --> count()
                              C({1,2,3}, 5)                     
                           /                \
                         /                   \              
             C({1,2,3}, 2)                 C({1,2}, 5)
            /     \                        /         \
           /        \                     /           \
   C({1,2,3}, -1)  C({1,2}, 2)        C({1,2}, 3)    C({1}, 5)
           /         \                /    \           /   \
          /           \              /      \         /     \
    C({1,2},0)  C({1},2)        C({1,2},1) C({1},3)C({1}, 4)  C({}, 5)
                   / \             / \       / \        /  \    
                  /   \           /   \     /   \      /    \ 
                .      .         .     .   .     . C({1}, 3) C({}, 4)
                                               /  \
                                              /    \  
                                             .      .

因為相同的問題又被呼叫了，這個問題有重複子問題屬性，所以這個硬幣兌換問題同時具有動態規劃問題的兩個屬性。就像其他典型的動態規劃問題一樣，可以通過自底向上地建立一個臨時陣列table[][]來避免子問題的重複計算。

動態規劃問題答案

#include<stdio.h>

int count( int S[], int m, int n )
{
    int i, j, x, y;

    // We need n+1 rows as the table is consturcted in bottom up manner using 
    // the base case 0 value case (n = 0)
    int table[n+1][m];

    // Fill the enteries for 0 value case (n = 0)
    for (i=0; i<m; i++)
        table[0][i] = 1;

    // Fill rest of the table enteries in bottom up manner  
    for (i = 1; i < n+1; i++)
    {
        for (j = 0; j < m; j++)
        {
            // Count of solutions including S[j]
            x = (i-S[j] >= 0)? table[i - S[j]][j]: 0;

            // Count of solutions excluding S[j]
            y = (j >= 1)? table[i][j-1]: 0;

            // total count
            table[i][j] = x + y;
        }
    }
    return table[n][m-1];
}

// Driver program to test above function
int main()
{
    int arr[] = {1, 2, 3};
    int m = sizeof(arr)/sizeof(arr[0]);
    int n = 4;
    printf(" %d ", count(arr, m, n));
    return 0;
}

輸出：

4

時間複雜度：O(mn)
下面是方法2的簡單版本，只需要O(n)的附件空間。

int count( int S[], int m, int n )
{
    // table[i] will be storing the number of solutions for
    // value i. We need n+1 rows as the table is consturcted
    // in bottom up manner using the base case (n = 0)
    int table[n+1];

    // Initialize all table values as 0
    memset(table, 0, sizeof(table));

    // Base case (If given value is 0)
    table[0] = 1;

    // Pick all coins one by one and update the table[] values
    // after the index greater than or equal to the value of the
    // picked coin
    for(int i=0; i<m; i++)
        for(int j=S[i]; j<=n; j++)
            table[j] += table[j-S[i]];

    return