USACO 2.3 Money Systems (money)

//Main idea:
//Dynamic Programming
//dp[i][j] denote the number of ways to  construct money j by coins[0...i]
//state transition equation:
//dp[i][j] = dp[i-1][j] + dp[i-1][j-coins[i]] + ...dp[i-1][j-m*coins[i]]
//if j - m * coins[i] >= 0;

/*
ID: haolink1
PROG: money
LANG: C++
*/

//#include <iostream>
#include <fstream>

using namespace std;

int coins[25];
long long dp[25][10001];

int main(){
    ifstream fin("money.in");
    int coins_num = 0;
    int N = 0;
    fin >> coins_num >> N;
    for(int i = 0; i < coins_num; i++){
        fin >> coins[i];
    }
    //Boundary condition  
    for(int i = 1; i <= N; i++){
        //Check whether money i can be constructed by coins[0]
        if((i % coins[0]) == 0)
            dp[0][i] = 1; 
    }
    //Note dp[0][0]
    //dp[i][0] count for dp[i+1][j - m*coins[i+1]], that is money j is 
    //constructed only by coins[i+1]. So the value of dp[i][0] is 1;
    for(int i = 0; i < coins_num; i++){
        dp[i][0] = 1;
    }
    for(int i = 1; i < coins_num; i++){
        for(int j = 1; j <= N; j++){
            dp[i][j] = dp[i-1][j];
            int ways = j / coins[i];
            for(int m = 1; m <= ways; m++){
                dp[i][j] += dp[i-1][j - m*coins[i]];
            }
        }
    }
    ofstream fout("money.out");
    fout << dp[coins_num-1][N] << endl;
    return 0;
}

/*
方法2：
如果我們在模擬過程中稍微做一點變動就會發現一種效率更高的算法，如下：
在方法一的模擬過程中，對於每一步的描述可以表達如下“在第i張桌子上我應該拿取多少個硬幣？”，現在改爲“在第i張桌子上我是否應該再拿取一個硬幣？（如果不拿，那就走向下一張桌子）”
此時思考的角度就從“拿多少個（選擇數爲O(n)）”到“拿與不拿（選擇數爲O(1)）”，可見選擇數變少了，但是子問題發生了變化。
方法1的子問題可以表達如下“在前i-1張桌子上拿取總額爲j-m*a[i]的方法數”，而方法2的子問題變爲“當再拿取一個硬幣時，在前i張桌子上拿取總額爲j – a[i]的方法數”與“不再拿硬幣時，在前i張桌子上拿取總額爲j的方法數”，至於“最優子結構”問題讀者自己證明。
因此可得如下動規方程：dp[i][j] = dp[i][j-a[i]] + dp[i-1][j]，dp[i][j-a[i]]是再拿一個的情況，dp[i-1][j]是不再拿走向下一張桌子的情況。 （提示：設在第i張桌子上拿取了m個硬幣，當m>0時， 所有的方法都被dp[i][j-a[i]]包含了，因此當走向下一張桌子時僅需要考慮m=0的情況。）
可見子問題數沒變而選擇數減少了一個數量級，因此時間效率提高到O(v*n)
*/

/*
ID: 
PROG:money
LANG:C++
*/

//#include<iostream>
#include<fstream>
using namespace std;
ifstream fin("money.in");
//ofstream cout("money.out");
unsigned long long dp[25][10001];
int main(){
    int v,n,a[30];
    fin>>v>>n;
    int i,j;
    for(i=0;i!=v;++i)
        fin>>a[i];
    for(j=1;j<=n;++j)
        if(j%a[0]==0)
                dp[0][j]=1;
    for(i=0;i!=v;++i)
        dp[i][0]=1;
    for(i=1;i!=v;++i)
        for(j=1;j<=n;++j){
            if (j - a[i] >= 0){
                dp[i][j] = dp[i - 1][j] + dp[i][j - a[i]];
            }
            else{
                dp[i][j] = dp[i - 1][j];
            }
        }
    cout<<dp[v-1][n]<<endl;
    return 0;
}

/*
 方法3：
注意到方法2中的動規方程：dp[i][j] = dp[i][j-a[i]] + dp[i-1][j]
我們在求dp[i][*]時僅會用到dp[i-1][*]，而不會用到dp[i-2][*],dp[i-3][*]等等。
這就表示，任何時刻我們都可以僅用兩個數組來保存dp的值，而不用v個，公式就可以簡化爲： dp_2[j] = dp_2[j-a[i]] + dp_1[j]。
且在求dp_2[j]時，dp_2[j]的值可以是任意值而不會影響到dp_2[j]的正確性（因爲它的值是由dp_2[j-a[i]]與dp_1[j]決定的），那麼我們就可以用dp_2[j]的來保存dp_1[j]的值，公式可以改爲： dp_2[j] = dp_2[j-a[i]] + dp_2[j]。
注意，當計算dp_2[j] = dp_2[j-a[i]] + dp_2[j]時，等號左邊的dp_2[j]表示“前i張桌子拿取j元的方案數”，而等號右邊的dp_2[j]表示“前i-1張桌子拿取j元的方案數”。
這就只需要用一個大小爲O(n)的dp數組了。空間效率從O(v*n)提高到了O(n)。
*/

/*
ID:jzzlee1
PROG:money
LANG:C++
*/

//#include<iostream>
#include<fstream>
#include<iostream>
using namespace std;
ifstream fin("money.in");
//ofstream fout("money.out");
unsigned long long dp[10001];
int main(){
    int v,n,a[30];
    fin>>v>>n;
    int i,j;
    for(i=0;i!=v;++i)
        fin>>a[i];
    for(j=0;j<=n;++j)
        if(j%a[0]==0)
            dp[j]=1;
    for(i=1;i!=v;++i)
        for(j=1;j<=n;++j){
            if (j - a[i] >= 0){
                dp[j] = dp[j] + dp[j - a[i]];
            }
        }
    cout<<dp[n]<<endl;
    return 0;
}