文档章节

动态规划之硬币表示问题

一贱书生
 一贱书生
发布于 2016/11/22 10:17
字数 2563
阅读 6
收藏 1

问题描述:

  有数量不限的硬币,币值为25分、10分、5分和1分,请编写代码计算n分有几种表示法。

求解思路:

  这也是典型的动态规划问题,我们可以这样考虑:当只有1分的硬币时,n从1到n分别有多少种表示方法;当有1分和5分的硬币时,n从1到n分别有多少种表示方法,因此类推,直到我们将1分、5分、10分和25分的硬币全部使用完。思想类似于0-1背包问题,0-1背包问题的具体求解方法可以参考我的上一篇博客动态规划之0-1背包问题。我们用数组coins[i]={1,5,10,25}表示各种币值,此时可以维护一张二维表ways[i][j],其中横坐标表示前i种表示币值,j表示硬币的总值,则ways[i][j]表示能用前i种硬币来表示j分的方法数。

 当增加一种新的硬币币值时,有两种情况:

(1)不加入此种币值:ways[i][j]=ways[i-1][j];

(2)加入此种币值:加入该枚硬币之前的方法数为ways[i][j-coins[i]],那么加入该枚硬币之后构成j分的方法数也为ways[i][j-coins[i]]。

 因此当增加一种新的币值时,j分的表示方法数为ways[i][j]=ways[i-1][j]+ways[i][j-coins[i]]。

代码实现

[java] view plain copy

 

  1. import java.util.Scanner;  
  2. public class Main {  
  3.     public static void main(String[] args) {  
  4.         Scanner sc = new Scanner(System.in);  
  5.         int n = sc.nextInt();  
  6.         int[] coins = {1, 5, 10, 25};  
  7.         int[][] ways = new int[4][n + 1];  
  8.         for (int i = 0; i < 4; i++)  
  9.             ways[i][0] = 1; //第0行初始化为1  
  10.         for (int j = 1; j <= n; j++)  
  11.             ways[0][j] = 1; //第0列初始化为1  
  12.         for (int i = 1; i < 4; i++) {  
  13.             for (int j = 1; j <= n; j++) {  
  14.                 if (j >= coins[i])  
  15.                     ways[i][j] = ways[i - 1][j] + ways[i][j - coins[i]];  
  16.                 else  
  17.                     ways[i][j] = ways[i - 1][j];  
  18.             }  
  19.         }  
  20.         System.out.println(ways[3][n]);  
  21.     }  
  22. }  

当然,维护二维表未免过于复杂,我们可以维护一张一维表,即用一维数组ways[j]来记录j分的表示方法数。改进的代码实现如下:

[java] view plain copy

 

  1. import java.util.Scanner;  
  2. public class Main {  
  3.     public static void main(String[] args) {  
  4.         Scanner sc=new Scanner(System.in);  
  5.         int n=sc.nextInt();  
  6.         int []coins={1,5,10,25};  
  7.         int []ways=new int[n+1];  
  8.         ways[0]=1;  
  9.         for(int i=0;i<4;i++){  
  10.             for(int j=coins[i];j<=n;j++){  
  11.                 ways[j]=ways[j]+ways[j-coins[i]];  
  12.             }  
  13.         }  
  14.         System.out.println(ways[n]);  
  15.     }  
  16. }

 

问题:要找K元的零钱,零钱的种类已知,保存在数组coins[]中,要求:求出构成K所需的最少硬币的数量和零钱的具体数值。
分析:(1)贪心算法:,先从面额最大的硬币开始尝试,一直往下找,知道硬币总和为N。但是贪心算法不能保证能够找出解(例如,给,2,3,5,然后N=11,导致无解5,5,1)。
(2)动态规划:
思想:快速实现递归(将前面计算的结果保存在数据里,后面重复用的时候直接调用就行,减少重复运算)
动态规划算法与分治法类似,其基本思想也是将待求解问题分解成若干个子问题,先求解子问题,然后从这些子问题的解得到原问题的解。与分治法不同的是,适合 于用动态规划求解的问题,经分解得到子问题往往不是互相独立的。若用分治法来解这类问题,则分解得到的子问题数目太多,有些子问题被重复计算了很多次。如 果我们能够保存已解决的子问题的答案,而在需要时再找出已求得的答案,这样就可以避免大量的重复计算,节省时间。我们可以用一个表来记录所有已解的子问题 的答案。不管该子问题以后是否被用到,只要它被计算过,就将其结果填入表中。
代码:

/*找零钱问题:要找 K元的零钱,零钱的种类有 coins[],要求零钱的张数最少,用 road[]来找出具体使用的零钱*/
public class MinCount_coins {
    public static void main (String[] args) { 
       int coins[]={3,5};
       int k=4;
       int road[]=new int[k+1];
       int min=getMinCount(k ,coins ,road );
       if(min>Integer. MAX_VALUE-k ){ //min 没有另外赋值,则表示零钱不够
        System.out. println( "零钱不够!" );
       }else{
        System.out. println( "数值为" +k +" 时,需要的最少的硬币数为: "+ min);
           for(int j=k;j>0;){
            System.out. print( road[ j]+ "\t");
            j=j-road[j];  //j为当前要找的零钱值, road[j]为当前面额下,最近加入的零钱
           }
       }
    } 

    public static int getMinCount (int k,int c[],int r[]){
     int a[]=new int[k+1];//保存最近加入的零钱值
     a [0]=0;
     for(int x=1;x<k+1;x++){ //要求a[k],先求a[1]~a[k-1]
         if(x>=c[0]){  //给a[x]附初值
             a[x]=a[x-c[0]]+1;
             r[x]=c[0];
         }else{   //要找零钱比最小零钱值还小,零钱不够
             a[x]=Integer.MAX_VALUE- k;
         }
         for(int i=1;i<c.length;i++){
             if(x>=c[i]&&(a[x]>a[x-c[i]]+1)){//x-c[i]表示当前值减去coins[]中值,即可由前面那些子问题+1一次得来
                  a[ x]= a[ x- c[ i]]+1;
                  r[ x]= c[ i];
             }
         }
     }
     return a[k];
    }
}

 

本文中的解解法综合考虑了各种情况,比如改变了零钱的种类,零钱不够等情况

 

 

动态规划的基本思想是将待求解问题分解成若干个子问题,先求解子问题,并将这些子问题的解保存起来,如果以后在求解较大子问题的时候需要用到这些子问题的解,就可以直接取出这些已经计算过的解而免去重复运算。保存子问题的解可以使用填表方式,例如保存在数组中。

用一个实际例子来体现动态规划的算法思想——硬币找零问题。

硬币找零问题描述:现存在一堆面值为 V1、V2、V3 … 个单位的硬币,问最少需要多少个硬币才能找出总值为 T 个单位的零钱?假设这一堆面值分别为 1、2、5、21、25 元,需要找出总值 T 为 63 元的零钱。

很明显,只要拿出 3 个 21 元的硬币就凑够了 63 元了。

基于上述动态规划的思想,我们可以从 1 元开始计算出最少需要几个硬币,然后再求 2 元、3元…每一次求得的结果都保存在一个数组中,以后需要用到时则直接取出即可。那么我们什么时候需要这些子问题的解呢?如何体现出由子问题的解得到较大问题的解呢?

其实,在我们从 1 元开始依次找零时,可以尝试一下当前要找零的面值(这里指 1 元)是否能够被分解成另一个已求解的面值的找零需要的硬币个数再加上这一堆硬币中的某个面值之和,如果这样分解之后最终的硬币数是最少的,那么问题就得到答案了。

单是上面的文字描述太抽象,先假定以下变量:

values[] : 保存每一种硬币的币值的数组
valueKinds :币值不同的硬币种类数量,即values[]数组的大小

money : 需要找零的面值
coinsUsed[] : 保存面值为 i 的纸币找零所需的最小硬币数

算法描述:

当求解总面值为 i 的找零最少硬币数 coinsUsed[ i ] 时,将其分解成求解 coinsUsed[ i – cents]和一个面值为 cents 元的硬币,由于 i – cents < i , 其解 coinsUsed[ i – cents] 已经存在,如果面值为 cents 的硬币满足题意,那么最终解 coinsUsed[ i ] 则等于 coinsUsed[ i – cents] 再加上 1(即面值为 cents)的这一个硬币。

下面用代码实现并测试一下:

 
  1. public class CoinsChange {  
  2.     /**  
  3.      * 硬币找零:动态规划算法  
  4.      *   
  5.      * @param values  
  6.      *            :保存每一种硬币的币值的数组  
  7.      * @param valueKinds  
  8.      *            :币值不同的硬币种类数量,即coinValue[]数组的大小  
  9.      * @param money  
  10.      *            :需要找零的面值  
  11.      * @param coinsUsed  
  12.      *            :保存面值为i的纸币找零所需的最小硬币数  
  13.      */ 
  14.     public static void makeChange(int[] values, int valueKinds, int money,  
  15.             int[] coinsUsed) {  
 
    • coinsUsed[0] = 0;  
    •         // 对每一分钱都找零,即保存子问题的解以备用,即填表  
    •         for (int cents = 1; cents <= money; cents++) {  
    •  
    •             // 当用最小币值的硬币找零时,所需硬币数量最多  
    •             int minCoins = cents;  
    •  
    •             // 遍历每一种面值的硬币,看是否可作为找零的其中之一  
    •             for (int kind = 0; kind < valueKinds; kind++) {               
    •                 // 若当前面值的硬币小于当前的cents则分解问题并查表  
    •                 if (values[kind] <= cents) {  
    •                     int temp = coinsUsed[cents - values[kind]] + 1;  
    •                     if (temp < minCoins) {  
    •                         minCoins = temp;  
    •                     }  
    •                 }  
    •             }  
    •             // 保存最小硬币数  
    •             coinsUsed[cents] = minCoins;  
    •  
    •             System.out.println("面值为 " + (cents) + " 的最小硬币数 : " 
    •                     + coinsUsed[cents]);  
    •         }  
    •     }  
    •       
    •     public static void main(String[] args) {  
    •  
    •         // 硬币面值预先已经按降序排列  
    •         int[] coinValue = new int[] { 25211051 };  
    •         // 需要找零的面值  
    •         int money = 63;  
    •  
    •  // 保存每一个面值找零所需的最小硬币数,0号单元舍弃不用,所以要多加1  
    •         int[] coinsUsed = new int[money + 1];  
    •  
    •         makeChange(coinValue, coinValue.length, money, coinsUsed);  
    •     }  
    • 测试结果:

      面值为 1 的最小硬币数 : 1
      面值为 2 的最小硬币数 : 2
      面值为 3 的最小硬币数 : 3
      面值为 4 的最小硬币数 : 4
      面值为 5 的最小硬币数 : 1
      面值为 6 的最小硬币数 : 2
      ...
      ...
      面值为 60 的最小硬币数 : 3
      面值为 61 的最小硬币数 : 4
      面值为 62 的最小硬币数 : 4
      面值为 63 的最小硬币数 : 3

       上面的代码并没有给出具体应该是哪几个面值的硬币,这个可以再使用一些数组保存而打印出来。

/**
 * 功能:给定数量不限的硬币,币值为25分,10分,5分,1分,计算n分有几种表示法。

 */

 

 

[java] view plain copy

 

  1. public static int makeChange(int n){  
  2.     return makeChange(n,25);  
  3. }  
  4.   
  5. /** 
  6.  * 递归的终止条件:完全简化为1分。 
  7.  * @param n 
  8.  * @param denom 
  9.  * @return 
  10.  */  
  11. public static int makeChange(int n,int denom){  
  12.     int next_denom=0;  
  13.     switch(denom){  
  14.     case 25:  
  15.         next_denom=10;  
  16.         break;  
  17.     case 10:  
  18.         next_denom=5;  
  19.         break;  
  20.     case 5:  
  21.         next_denom=1;  
  22.         break;  
  23.     case 1:  
  24.         return 1;  
  25.     }  
  26.       
  27.     int ways=0;  
  28.     for(int i=0;i*denom<=n;i++){  
  29.         ways+=makeChange(n-i*denom,next_denom);  
  30.     }  
  31.     return ways;  
 

© 著作权归作者所有

共有 人打赏支持
一贱书生
粉丝 19
博文 724
码字总数 600123
作品 0
动态规划算法思想解决找零钱问题

动态规划算法思想解决找零钱问题 前言 关于找零钱问题,网上已经有很多相关的资料以及优秀的文章博客等。这里写这篇博客的初衷很简单,就是为了方便自己,回过头来捡起这个知识能快一点,接受...

niaonao
2017/10/16
0
0
动态规划

动态规划(Dynamic Programming) 本文包括: 动态规划定义 状态转移方程 动态规划算法步骤 最长非降子序列(LIS) 最大乘积子串 Unique Paths Unique Paths II Minimum Path Sum Triangle 最...

廖少少
2017/09/27
0
0
动态规划入门之硬币问题

动态规划算法通常基于一个递推公式及一个或多个初始状态。 当前子问题的解将由上一次子问题的解推出。使用动态规划来解题只需要多项式时间复杂度, 因此它比回溯法、暴力法等要快许多。动态规...

SVD
2016/09/13
112
0
js算法初窥05(算法模式02-动态规划与贪心算法)

  在前面的文章中(js算法初窥02(排序算法02-归并、快速以及堆排)我们学习了如何用分治法来实现归并排序,那么动态规划跟分治法有点类似,但是分治法是把问题分解成互相独立的子问题,最...

zaking
05/29
0
0
动态规划(Dynamic Programming)算法与LC实例的理解

动态规划(Dynamic Programming)算法与LC实例的理解 希望通过写下来自己学习历程的方式帮助自己加深对知识的理解,也帮助其他人更好地学习,少走弯路。也欢迎大家来给我的Github的Leetcode算法...

qq_32690999
05/10
0
0

没有更多内容

加载失败,请刷新页面

加载更多

下一页

移除或自定义 WordPress 仪表盘欢迎面板

第一次登录 WordPress 后台仪表盘页面,默认都会显示 WordPress 的欢迎面板: 如果我们要移除这个面板,在主题的 functions.php 中添加下面的代码即可: 12 //移除 WordPress 仪表盘欢迎面...

james_laughing
22分钟前
0
0
HashMap实现原理及源码分析

HashMap实现原理及源码分析   哈希表(hash table)也叫散列表,是一种非常重要的数据结构,应用场景及其丰富,许多缓存技术(比如memcached)的核心其实就是在内存中维护一张大的哈希表,...

DemonsI
26分钟前
0
0
eggjs学习笔记

快速初始化 生成项目(要求最低的node版本8.x) npm i egg-init -gegg-init egg-example --type=simplecd egg-examplenpm i 启动项目 npm run dev 配置 环境配置会覆盖默认配置 config...

别人说我名字很长
29分钟前
1
0
Winform Timer控件时间间隔

sender as System.Timers.Timer).Interval = 23 * 60 * 60 * 1000.0;//将时间间隔改为23小时,23小时后重新发生timer_Elapsed事件。 //60000:时间间隔1分钟,300000:时间间隔5分钟,600000:...

笑丶笑
30分钟前
0
0
在win10系统下怎样快速切换任务视图

切换窗口:Alt + Tab 任务视图:Win + Tab (松开键盘界面不会消失) 切换任务视图:Win + Ctrl +左/右 创建新的虚拟桌面:Win + Ctrl + D 关闭当前虚拟桌面:Win + Ctrl + F4...

SummerGao
33分钟前
0
0

没有更多内容

加载失败,请刷新页面

加载更多

下一页

返回顶部
顶部