usaco_money

Money Systems

The cows have not only created their own government but they have chosen to create their own money system. In their own rebellious way, they are curious about values of coinage. Traditionally, coins come in values like 1, 5, 10, 20 or 25, 50, and 100 units, sometimes with a 2 unit coin thrown in for good measure.

The cows want to know how many different ways it is possible to dispense a certain amount of money using various coin systems. For instance, using a system of {1, 2, 5, 10, ...} it is possible to create 18 units several different ways, including: 18x1, 9x2, 8x2+2x1, 3x5+2+1, and many others.

Write a program to compute how many ways to construct a given amount of money using supplied coinage. It is guaranteed that the total will fit into both a signed long long (C/C++) and Int64 (Free Pascal).

PROGRAM NAME: money

INPUT FORMAT

The number of coins in the system is V (1 <= V <= 25).

The amount money to construct is N (1 <= N <= 10,000).

Line 1:	Two integers, V and N
Lines 2..:	V integers that represent the available coins (no particular number of integers per line)

SAMPLE INPUT (file money.in)

3 10
1 2 5

OUTPUT FORMAT

A single line containing the total number of ways to construct N money units using V coins.

SAMPLE OUTPUT (file money.out)

10
一开始想到dp了，可惜，一直背着，外层循环一直想用N来的。。。可恶呀

#include <fstream>
using namespace std;

ifstream fin("money.in");
ofstream fout("money.out");

#ifdef _DEBUG
#define out cout
#define in cin
#else
#define out fout
#define in fin
#endif

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

void solve()
{
    dp[0] = 1;

    int v,n;

    in>>v>>n;

    for(int i=0;i<v;++i)
        in>>coins[i];

    for(int i=0;i<v;++i){
        for(int j=0;j+coins[i]<=n;++j){
            dp[j+coins[i]]+=dp[j];
        }
    }

    out<<dp[n]<<endl;
}

int main(int argc,char *argv[])
{
    solve(); 
    return 0;
}

 

我把别人的详细分析也贴过来，珍藏一下：

又是动态规划，又是动规方程，但是如果你是准备参加noip的选手的话请不要错过这篇解说，因为这倒题虽然简单，但有很大的启发性，因此我准备详细的通过三个代码来讲解这道题。 

首先我会引导读者如何去思考这道题的动规方法，通过一个时间效率为O(v*n*n)、空间效率为O(V*n)的简单方法，让读者理解程序的正确性。 

然后我将改变一下思考的角度，介绍一个时间效率为O(v*n)、空间效率为O(v*n)的方法，让读者注意到对于同样的方法当考虑角度稍有变化时如何影响到算法的效率。 

最后我将介绍一种时间效率为O(v*n)、空间效率为O(n)的方法,指出在动态规划中一种减少空间使用量的常用方法，这对参加编程比赛是很有用的。 

注：ways[i][j]表示在前i种硬币中，拿出总值为j元的方案数 

方法1： 

还是先模拟过程，然后从过程的最后一步考虑起。注意，这里所说的“模拟”，就是在告诉读者如何去思考这个问题。 

可以这样来模拟：有一排桌子，共有v个，每张桌子上面都有一堆拿不完的硬币，但是每张桌子上的硬币都是相同面额的，我从第一张桌子顺序走到最后一张桌子，每路过一张桌子的时候我可以拿取这张桌子上面的任意个硬币，直到路过所有桌子后我手中的硬币总额必须为n元。 

考虑最后一步：如果我在第i张桌子上拿了m个硬币，然后就不再在其它的桌子上拿硬币了，且我手中的钱正好是n元，那么最后一步就是“在第i张桌子上面拿取了m个硬币” 

在最后一步中，我可以拿0个或多个硬币，这就是最后一步的选择，那么选择拿取m个硬币后剩下的子问题就是从前i-1张桌子上拿取j-m×units[i]钱有多少种方法，其中units[i]是第i张桌子上硬币的面额。 

因为每种选择都是独立可行的方法，因此有动规方程： ways[i][j] = Sum(ways[i - 1][j - m * units[i]]) {m = 0、1、2、……、k}，k是最多可以拿取的个数。 

注意到，这里问题数就是ways变量的个数，等于v * n,而选择数最坏情况下为n，因此最坏情况下时间效率为O(v*n*n) 

详细程序见代码 code1 

/**//*
ID: sdjllyh1
PROG: money
LANG: JAVA
complete date: 2008/12/18
complexity: O(v * n * n)
author: LiuYongHui From GuiZhou University Of China
more article: www.cnblogs.com/sdjls
*/

import java.io.*;
import java.util.*;

public class money
{
    private static int v, n;
    private static long[][] ways;//ways[i][j]表示在前i种硬币中，拿出总值为j元的方案数
    private static int[] units;//硬币的面值
    private static long answer;

    public static void main(String[] args) throws IOException
    {
        init();
        run();
        output();
        System.exit(0);
    }

    private static void run()
    {
        //处理边界，当总共要拿j元时，如果j是第一种硬币的整数倍，那么ways[0][j]=1
        for (int j = 1; j <= n; j++)
        {
            if (j % units[0] == 0)
            {
                ways[0][j] = 1;
            }
            else
            {
                ways[0][j] = 0;
            }
        }
        //处理边界，当总共要拿0元时，方案数为1
        for (int i = 0; i < v; i++)
        {
            ways[i][0] = 1;
        }
        //求ways[i][j]
        for (int i = 1; i < v; i++)
        {
            for (int j = 1; j <= n; j++)
            {
                int multiple = 0;//第i种硬币拿取的个数
                //当从第i种硬币中得到的钱不超过j时
                while (multiple * units[i] <= j)
                {
                    ways[i][j] += ways[i - 1][j - multiple * units[i]];
                    multiple++;
                }
            }
        }

        answer = ways[v - 1][n];//注意到i是从0循环到v-1
    }
    
    private static void init() throws IOException
    {
        BufferedReader f = new BufferedReader(new FileReader("money.in"));
        StringTokenizer st = new StringTokenizer(f.readLine());
        v = Integer.parseInt(st.nextToken());
        n = Integer.parseInt(st.nextToken());

        units = new int[v];
        int index = 0;
        String readLine = f.readLine();
        while (readLine != null)
        {
            st = new StringTokenizer(readLine);    
            while (st.hasMoreTokens())
            {
                units[index] = Integer.parseInt(st.nextToken());
                index++;
            }
            readLine = f.readLine();
        }
        f.close();

        ways = new long[v][n + 1];
    }

    private static void output() throws IOException
    {
        PrintWriter out = new PrintWriter(new BufferedWriter(new FileWriter("money.out")));
        out.println(answer);
        out.close();
    }
} 

方法2： 

如果我们在模拟过程中稍微做一点变动就会发现一种效率更高的算法，如下： 

在方法一的模拟过程中，对于每一步的描述可以表达如下“在第i张桌子上我应该拿取多少个硬币？”，现在改为“在第i张桌子上我是否应该再拿取一个硬币？（如果不拿，那就走向下一张桌子）” 

此时思考的角度就从“拿多少个（选择数为O(n)）”到“拿与不拿（选择数为O(1)）”，可见选择数变少了，但是子问题发生了变化。 

方法1的子问题可以表达如下“在前i-1张桌子上拿取总额为j-m*units[i]的方法数”，而方法2的子问题变为“当再拿取一个硬币时，在前i张桌子上拿取总额为j - units[i]的方法数”与“不再拿硬币时，在前i张桌子上拿取总额为j的方法数”，至于“最优子结构”问题读者自己证明。 

因此可得如下动规方程：ways[i][j] = ways[i][j-units[i]] + ways[i-1][j]，ways[i][j-units[i]]是再拿一个的情况，ways[i-1][j]是不再拿走向下一张桌子的情况。 （提示：设在第i张桌子上拿取了m个硬币，当m>0时， 所有的方法都被ways[i][j-units[i]]包含了，因此当走向下一张桌子时仅需要考虑m=0的情况。）

可见子问题数没变而选择数减少了一个数量级，因此时间效率提高到O(v*n) 

主要被改动的代码见 code2 
    private static void run()
    {
        
        for (int j = 1; j <= n; j++)
        {
            if (j % units[0] == 0)
            {
                ways[0][j] = 1;
            }
            else
            {
                ways[0][j] = 0;
            }
        }
        
        for (int i = 0; i < v; i++)
        {
            ways[i][0] = 1;
        }
        
        for (int i = 1; i < v; i++)
        {
            for (int j = 1; j <= n; j++)
            {
                //如果第i种硬币可以拿，即总共要拿取的钱数大于等于第i种硬币的面额
                if (j - units[i] >= 0)
                {
                    ways[i][j] = ways[i - 1][j] + ways[i][j - units[i]];
                }
                else
                {
                    ways[i][j] = ways[i - 1][j];
                }
            }
        }

        answer = ways[v - 1][n];
    }

 

方法3： 

注意到方法2中的动规方程：ways[i][j] = ways[i][j-units[i]] + ways[i-1][j] 

我们在求ways[i][*]时仅会用到ways[i-1][*]，而不会用到ways[i-2][*],ways[i-3][*]等等。 

这就表示，任何时刻我们都可以仅用两个数组来保存ways的值，而不用v个，公式就可以简化为： ways_2[j] = ways_2[j-units[i]] + ways_1[j]。 

且在求ways_2[j]时，ways_2[j]的值可以是任意值而不会影响到ways_2[j]的正确性（因为它的值是由ways_2[j-units[i]]与ways_1[j]决定的）， 

那么我们就可以用ways_2[j]的来保存ways_1[j]的值，公式可以改为： ways_2[j] = ways_2[j-units[i]] + ways_2[j]。 

注意，当计算ways_2[j] = ways_2[j-units[i]] + ways_2[j]时，等号左边的ways_2[j]表示“前i张桌子拿取j元的方案数”，而等号右边的ways_2[j]表示“前i-1张桌子拿取j元的方案数”。 

这就只需要用一个大小为O(n)的ways数组了。空间效率从O(v*n)提高到了O(n)。 

主要被改动的代码见 code3 
 private static void run()
    {
        
        for (int j = 0; j <= n; j++)
        {
            if (j % units[0] == 0)
            {
                ways[j] = 1;
            }
            else
            {
                ways[j] = 0;
            }
        }
        
        for (int i = 1; i < v; i++)
        {
            for (int j = 1; j <= n; j++)
            {
                //如果第i种硬币可以拿，即总共要拿取的钱数大于等于第i种硬币的面额
                if (j - units[i] >= 0)
                {
                    ways[j] = ways[j] + ways[j - units[i]];
                }
                else
                {
                    ways[j] = ways[j];
                }
            }
        }

        answer = ways[n];
    }