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;
}