整币兑零问题动态规划，枚举方法解决

已于 2022-10-13 20:09:19 修改
阅读量785 收藏 2
点赞数 3
分类专栏： 算法 文章标签： 动态规划 算法 java
于 2022-09-18 19:22:22 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_58642780/article/details/126819794
版权

文章目录

整币兑零

问题描述

把n元整币兑换成1元、5元、10元、20元、50元、100元(共6种零币)的兑换种数？

解题方法

枚举法

基本枚举设计
解题思路
  1. 该题目显然需要解一次不定方程：
    • i + 5j + 10k + 20p + 50q + 100r = n.
  2. 对这6个变量实施枚举，确定枚举范围：
    • 0 <= i <= n.
    • 0 <= j <= n/5.
    • 0 <= k <= n/10.
    • 0 <= p <= n/20.
    • 0 <= q <= n/50.
    • 0 <= r <= n/100.
  3. 在以上枚举的6重循环中，满足上述不定方程，则为一种兑换方法。
代码
public static int mei1(int n) {
    int m = 0;
    for (int i = 0; i <= n; i++) {
        for (int j = 0; j <= n / 5; j++) {
            for (int k = 0; k <= n / 10; k++) {
                for (int l = 0; l <= n / 20; l++) {
                    for (int o = 0; o <= n / 50; o++) {
                        for (int p = 0; p <= n / 100; p++) {
                            if (i + j * 5 + k * 10 + l * 20 + o * 50 + p * 100 == n) {
                                m++;
                            }
                        }
                    }
                }
            }
        }
    }
    return m;
}
精简枚举设计
解题思路

在上述设计的6层循环中，可精简 i 循环，在循环内为：
i = n - (5j + 10k + 20p + 50q + 100r).
如果i>=0，满足不定方程，为一种兑换方法。

代码
public static int mei2(int n) {
    int m = 0;
    for (int j = 0; j <= n / 5; j++) {
        for (int k = 0; k <= n / 10; k++) {
            for (int l = 0; l <= n / 20; l++) {
                for (int o = 0; o <= n / 50; o++) {
                    for (int p = 0; p <= n / 100; p++) {
                        int i = n - (j * 5 + k * 10 + l * 20 + o * 50 + p * 100);
                        if (i >= 0) {
                            m++;
                        }
                    }
                }
            }
        }
    }
    return m;
}
优化枚举设计
解题思路

以上程序循环次数已经大大精简了。进一步分析，可以看到在程序的循环设置中，k循环可以从0 ~ n/10改进为0 ~ （n - 5 * j），因为在n中j已经占去了5 * j。依次类推，对剩下的变量作类似的循环参数优化。

代码
public static int mei3(int n) {
    int m = 0;
    for (int j = 0; j <= n / 5; j++) {
        for (int k = 0; k <= (n - j * 5) / 10; k++) {
            for (int l = 0; l <= (n - (j * 5 + k * 10)) / 20; l++) {
                for (int o = 0; o <= (n - (j * 5 + k * 10 + l * 20)) / 50; o++) {
                    for (int p = 0; p <= (n - (j * 5 + k * 10 + l * 20 + o * 50)) / 100; p++) {
                        int i = n - (j * 5 + k * 10 + l * 20 + o * 50 + p * 100);
                        if (i >= 0) {
                            m++;
                        }
                    }
                }
            }
        }
    }
    return m;
}

动态规划

二维数组
解题思路

以一种条件去统计兑换种数，防止重复。
以兑换成零币的最大面值来分类（包含最大面值）。

  1. 定义二维数组f，f[i][j]表示i元整币，兑换成面值最大为下标为j 的零币的兑换种数。（一定注意是下标为j）
    • 比如f[37][2] = 12表示37元整币兑换成5元为最大面值的零币的兑换种数为12。（此题中下标为2的是5元）。如果无法兑换则为0，比如：f [2][1] = 0，两元整币无法兑换成最大面额为五元的零币。
  2. 自顶向下分析，当整币面值为n时：
    • n减去其中一种零币i 得到结果小于0，说明无法兑换。即，f [n][i] = 0.
    • n减去其中一种零币i 得到结果等于0，说明整币n和零币i 的面值相同，只能兑换一张。即，f [n][i] = 1.
    • n减去其中一种零币i 得到结果大于0，说明整币n兑换成以零币i为最大面值的方案数 可以由n-i的所有兑换成最大面值小于等于i的兑换方案 再加上一张面值为i的零币完成。即，f[n][i]等于整币n-i的兑换成的最大面值小于等于i的兑换方案数之和。
      注：f[n][i]中的i的位置应该是零币i的下标，即零币在数组中的位置，为了叙述方便，没有修改。
  3. 最终兑换方案数为f[n]那一行的求和。

举例说明，整币为10：
兑换成最大面额为1的零币时（1在数组中的下标为0），10-1=9，9>0，
所以f [10][0] = f [9][0] = 1.
兑换成最大面额为5的零币时（5在数组中的下标为1），10-5=5，5>0，
所以f [10][1] = f [5][1] + f [5][0] = 2.
兑换成最大面额为10的零币时（10在数组中的下标为2），10-10=0，说明能兑换一张10元零币，
所以f [10][2] = 1.
兑换成最大面额为20的零币时（20在数组中的下标为3），10 - 20 < 0，无法兑换，
所以f [10][3] = 0.

兑换成最大面额为50的零币时（50在数组中的下标为4），10 - 50 < 0，无法兑换，
所以f [10][4] = 0.
兑换成最大面额为100的零币时（100在数组中的下标为5），10 - 100 < 0，无法兑换，
所以f [10][5] = 0.
所以最终兑换方案数
sum = f [10][0] + f [10][1] + f [10][2] + f [10][3] + f [10][4] + f [10][5] = 1 + 2 + 1 + 0 + 0 + 0 = 4.

在这里插入图片描述

代码
public static int di1(int n) {
    int[] money = {1, 5, 10, 20, 50, 100};
    int[][] f = new int[n + 1][money.length];
    int sum = 0;
    for (int i = 1; i <= n; i++) {
        for (int j = 0; j < money.length; j++) {
            int res = i - money[j];
            if (res < 0) {
                f[i][j] = 0;//无法兑换
            } else if (res == 0) {
                f[i][j] = 1;//存在一种零币等于j，自身也是一种兑换方式
            } else {
                int temp = 0;
                for (int k = 0; k <= j; k++) {
                    temp += f[res][k];
                }
                f[i][j] = temp;
            }
        }
    }
    for (int i = 0; i < money.length; i++) {
        sum += f[n][i];
    }
    return sum;
}
一维数组
解题思路
  1. 定义一维数组f，f[i]表示i元整币可以兑换成零币的兑换种数。
  2. 增加零币的种数，进行遍历。（最重要）
    • 增加零币的种数也就是再外层循环遍历零币。这样可以避免重复的情况。

举例说明：
把6元整币兑换成零币，有两种兑换方案，一种是6个一元，另一种时一个一元和一个五元。增加零币的种数，是先把一元的遍历完，此时f [1] = 1（1元整币兑换成1个1元零币），f [5] = 1（5元整币兑换成5个1元零币），f [6] =f [6] + f [6 - 1] = 0 + f [5] = 1（6元整币兑换方案在5元整币所有兑换方案的后面加1元零币，即由6个1元零币组成）。之后再遍历五元零币，f[5] = 2（有5个1元组成，或者1个5元组成）。f [6] = f [6] + f [6 - 5] = 1 + f [1] = 2（6元的兑换方案数等于原来6元的兑换方案数 + 在1元所有兑换方案后加上5元零币，即1个一元和一个5元）。
上述情况中六元 的兑换方案数为2，即
6 = 1 + 1 + 1 + 1 + 1 + 1.
6 = 1 + 5.
不会出现再去在五元的所有兑换方案方案后面加一元，也就是不会出现6 = 5 + 1的情况，避免了和6 = 1 + 5重复。

在这里插入图片描述
在这里插入图片描述
3. 自顶向下分析，当整币面值为n时：

  • 兑换种数等于n减去其中一种零币i 得到结果大于0的兑换种数和。
    • 递推关系式： f[n] = f[n] + f [n - i].
  • 如果整币n的面值等于零币i 的面值，则n本身也是一种兑换方案。
    • 递推关系式：f[n] = f[n] + 1.
代码
public static int di2(int n) {
    int[] money = {1, 5, 10, 20, 50, 100};
    int[] f = new int[n + 1];
    for (int i = 0; i < money.length; i++) {
        if (money[i] <= n) {
            f[money[i]] += 1;
        }
        for (int j = money[i] + 1; j <= n; j++) {
            f[j] += f[j - money[i]];
        }
    }
    return f[n];
}

代码还可以这样改进：

public static int di2(int n) {
    int[] money = {1, 5, 10, 20, 50, 100};
    int[] f = new int[n + 1];
    f[0] = 1;//将f[0]赋值为1
    for (int i = 0; i < money.length; i++) {
        for (int j = money[i]; j <= n; j++) {
            f[j] += f[j - money[i]];
        }
    }
    return f[n];
}

将f[0]赋值为1，但是笔者想不到f[0]为1的意义。（如有想法，可联系笔者）
只是为了使j==money[i]时，f[j] = f[j] + 1.也满足f[j] += f[j - money[i]].规律。

完整代码

public class Demo2 {
    public static void main(String[] args) {

        int n;
        long begin, end;
        Scanner sc = new Scanner(System.in);
        System.out.println("input n:");
        n = sc.nextInt();

        begin = System.currentTimeMillis();
        System.out.println("枚举方法1：" + mei1(n));
        end = System.currentTimeMillis();
        System.out.println("枚举方法1用时：" + (end - begin) + "\n");

        begin = System.currentTimeMillis();
        System.out.println("枚举方法2：" + mei2(n));
        end = System.currentTimeMillis();
        System.out.println("枚举方法2用时：" + (end - begin) + "\n");

        begin = System.currentTimeMillis();
        System.out.println("枚举方法3：" + mei3(n));
        end = System.currentTimeMillis();
        System.out.println("枚举方法3用时：" + (end - begin) + "\n");

        begin = System.currentTimeMillis();
        System.out.println("递推1：" + di1(n));
        end = System.currentTimeMillis();
        System.out.println("递推1用时：" + (end - begin) + "\n");

        begin = System.currentTimeMillis();
        System.out.println("递推2：" + di2(n));
        end = System.currentTimeMillis();
        System.out.println("递推2用时：" + (end - begin) + "\n");
    }

    public static int mei1(int n) {
        int m = 0;
        for (int i = 0; i <= n; i++) {
            for (int j = 0; j <= n / 5; j++) {
                for (int k = 0; k <= n / 10; k++) {
                    for (int l = 0; l <= n / 20; l++) {
                        for (int o = 0; o <= n / 50; o++) {
                            for (int p = 0; p <= n / 100; p++) {
                                if (i + j * 5 + k * 10 + l * 20 + o * 50 + p * 100 == n) {                
                                    m++;
                                }
                            }
                        }
                    }
                }
            }
        }
        return m;
    }

    public static int mei2(int n) {
        int m = 0;
        for (int j = 0; j <= n / 5; j++) {
            for (int k = 0; k <= n / 10; k++) {
                for (int l = 0; l <= n / 20; l++) {
                    for (int o = 0; o <= n / 50; o++) {
                        for (int p = 0; p <= n / 100; p++) {
                            int i = n - (j * 5 + k * 10 + l * 20 + o * 50 + p * 100);
                            if (i >= 0) {          
                                m++;
                            }
                        }
                    }
                }
            }
        }
        return m;
    }

    public static int mei3(int n) {
        int m = 0;
        for (int j = 0; j <= n / 5; j++) {
            for (int k = 0; k <= (n - j * 5) / 10; k++) {
                for (int l = 0; l <= (n - (j * 5 + k * 10)) / 20; l++) {
                    for (int o = 0; o <= (n - (j * 5 + k * 10 + l * 20)) / 50; o++) {
                        for (int p = 0; p <= (n - (j * 5 + k * 10 + l * 20 + o * 50)) / 100; p++) {
                            int i = n - (j * 5 + k * 10 + l * 20 + o * 50 + p * 100);
                            if (i >= 0) {
                                m++;
                            }
                        }
                    }
                }
            }
        }
        return m;
    }

    public static int di1(int n) {
        int[] money = {1, 5, 10, 20, 50, 100};
        int[][] f = new int[n + 1][money.length];
        int sum = 0;
        for (int i = 1; i <= n; i++) {
            for (int j = 0; j < money.length; j++) {
                int res = i - money[j];
                if (res < 0) {
                    f[i][j] = 0;
                } else if (res == 0) {
                    f[i][j] = 1;
                } else {
                    int temp = 0;
                    for (int k = 0; k <= j; k++) {
                        temp += f[res][k];
                    }
                    f[i][j] = temp;
                }
            }
        }
        for (int i = 0; i < money.length; i++) {
            sum += f[n][i];
        }
        return sum;
    }

    public static int di2(int n) {
	    int[] money = {1, 5, 10, 20, 50, 100};
	    int[] f = new int[n + 1];
	    for (int i = 0; i < money.length; i++) {
	        if (money[i] <= n) {
	            f[money[i]] += 1;
	        }
	        for (int j = money[i] + 1; j <= n; j++) {
	            f[j] += f[j - money[i]];
	        }
	    }
	    return f[n];
	}
}

运行结果

在这里插入图片描述

总结

通过运行结果可以看出，枚举法的时间复杂度要远远高于动态规划，但是它可以输出兑换方案中各种零币的数量。总之，各有利弊吧！！！

Xbory
关注
专栏目录
动态规划 & 枚举算法
Zllvincent的博客
06-16 1140
一.简介 二.实现 package com.vincent; import java.util.ArrayList; import java.util.List; public class Main { public static void main(String[] args) throws Exception { int[][] data = {{1,1500},{4,3000},{3,2000}}; List<Integer> rst =
整币兑零
double_main的博客
12-30 2016
整币兑零是一个特殊的分解统计案例，其不同的的兑换种类与零币的种类及各零币的具体数值密切相关；本节探讨特定的6种零币与一般从键盘输入的m种零币的两类兑零统计；特定整币兑零把一张1元整币兑换成1分，2分，5分，1角，2角和5角共6种零币，共有多少种不同兑换种数？一般地，把一张二元整币，5元整币或一张n元整币兑换成1分，2分，5分，1角，2角和5角共6种零币，共有多少种不同兑换种数？1.说明：一般地设整币
整币兑零问题
qq_23697497的博客
10-16 501
#include #include using namespace std; int main() { int p, n, m; static int x[12]; static long int a[12][1001]; int b=0; cout << "请输入整币值："; cin >> n; cout << "请输入零币种数："; cin >> m; cout << "(从
整元换零钱问题
Winda_shi的博客
10-24 2020
整元换零钱问题
【计算机算法】枚举——换硬币
passer__jw767的博客
11-11 845
题目 将一笔零钱换成5分、2分和1分的硬币，要求每种硬币至少有一枚，有几种不同的换法？ 输入格式 输入在一行中给出待换的零钱数额x∈(8,100)。 输出格式 要求按5分、2分和1分硬币的数量依次从大到小的顺序，输出各种换法。每行输出一种换法，格式为：“fen5:5分硬币数量, fen2:2分硬币数量, fen1:1分硬币数量, total:硬币总数量”。最后一行输出“count = 换法个数”。 输入样例 13 输出样例 fen5:2, fen2:1, fen1:1, total:4 f
枚举,回溯,动态规划解决01背包问题课程设计
最新发布
07-02
"枚举、回溯、动态规划解决01背包问题课程设计" 本课程设计旨在解决经典的01背包问题，使用枚举、回溯和动态规划三种方法来解决该问题。 一、 问题描述 01背包问题是指商人带着一个能装m千克的背包去收购货物，...
动态规划专题——背包问题
热门推荐
⚡
02-13 4万+
详解四种背包：01背包、完全背包、多重背包、分组背包。
动态规划问题解决方法及示例
宋铮的博客
05-04 1万+
什么是动态规划 动态规划是求解决策过程最优化的数学方法。如果一个问题可以分解成若干个子问题，并且子问题之间还有重叠的更小的子问题，就可以考虑用动态规划来解决这个问题。 应用动态规划之前要分析能否把大问题分解成小问题，分解后的每个小问题也存在最优解。如果将小问题的最优解组合起来能够得到整个问题的最优解，那么就可以使用动态规划解决问题。 可以应用动态规划求解的问题主要由四个特点： 1. 问题是...
java 动态 枚举_java 动态生成枚举值
weixin_34195649的博客
02-18 2978
在某些场景下我们需要动态生成一些枚举值，主要是通过反射生成，但是这种生成枚举值是不能switch的1.枚举值类public enum CodeInfoEnum {LOCK(1L, 1L, "LOCK_TYPE", "LOCK"), UNLOCK(1L, 2L, "LOCK_TYPE", "LOCK");public Long classId;public Long infoId;public St...
从枚举到动态规划
weixin_51635753的博客
04-02 390
动态规划特点 1、重叠子问题 2、状态转移方程（最关键） 3、最优子结构 题型：求最值 核心：穷举 解题套路 1、明确【状态】 2、明确【选择】 3、明确 dp函数/数组的定义 4、明确 base case 动态规划解法代码框架 //初始化 base case dp[0][]0][...] = base //进行状态转移 for 状态1 to 状态1的所有取值 for 状态2 to 状态2的所有取值 for ... dp[状态1][状态
[蓝桥杯2018决赛]换零钞-枚举
m0_51955470的博客
03-15 236
题目描述 x星球的钞票的面额只有：100元，5元，2元，1元，共4种。 小明去x星旅游，他手里只有2张100元的x星币，太不方便，恰好路过x星银行就去换零钱。 小明有点强迫症，他坚持要求200元换出的零钞中2元的张数刚好是1元的张数的10倍，剩下的当然都是5元面额的。 银行的工作人员有点为难，你能帮助算出：在满足小明要求的前提下，最少要换给他多少张钞票吗？ （5元，2元，1元面额的必须都有，不能是0） 输出 输出一个整数表示答案 代码如下: #include <iostream> using n
整钱换零钱 循环 方程思想
m0_73113235的博客
10-22 537
题目描述给定任意的人民币的整币m（10、20、50和100元），将其兑换成5元、2元和1元币值（要求三种币值均有），统计兑换的的方法有多少种。输入多样例。每个样例输入一行，为任意人民币的整币100,50,20,10中的一个数据。输出每一个样例输出一行，包括一个整数，表示兑换的方法有多少种。样例输入5010样例输出1062。
提升：从枚举、进阶，到动态规划（Dynamic Programming）
GitChat
07-03 3369
枚举，一般容易想到，但不是高效的算法，怎么办？动态规划（DP）通常可以拿来做优化。 本次 Chat 我们 Talk：如何通过3个难度依次增大的实例，一步一步接近 DP，主要内容包括： 通过最通俗易懂的例子：Climbing Stairs （爬楼梯），初步领悟 DP，带有详细的分析思路和代码。代码版本一步一步从1.0，优化到1.1，最后形成终极版1.2. 聊一道面试真题，分析机器人行驶最短路径，...
n元人民币换成1元、2元、5元的零钱，请计算共有多少种兑换方法？
weixin_64357178的博客
11-26 7349
输入描述: 输入一行，包含一个整数n 1 <= n <= 200 输出描述: 输出一行，包含一个整数 #include<stdio.h> int main () {int a,b,c,n,sum=0; scanf("%d",&n); for(a=0;a<=n/5;a++) for(b=0;b<=n/2;b++) for(c=0;c<=n;c++) {if(a*5+b*2+c==n) ..
用C语言写一个换零钱算法
weixin_42588555的博客
01-06 1078
这里是一个使用 C 语言实现的算法来解决换零钱问题： 首先，需要有一个数组来存储可用的货币面值，例如使用美元的话，可以使用 1 美分、5 美分、10 美分、25 美分等。 然后，输入需要支付的金额和实际支付的金额，计算出找零的金额。 接着，可以使用一个循环来枚举货币面值的每一种可能，每次从找零的金额中减去当前货币面值的整数倍。当找零的金额小于 0 时，说明当前货币面值的数量已经达到最大值，应当跳出...
蓝桥杯2018第九届C语言B组省赛总决赛习题题解——习题A.换零钞（暴力枚举法）
Atticus的博客
03-28 721
每日刷题（四十五） 蓝桥杯第九届C语言B组总决赛习题 习题A：换零钞 这个题算简单，直接暴力枚举法 #include<stdio.h> int main() { int i, j; for(i = 1; i <= 200; i++) for(j = 1; j < 40; j++) if(i + 10 * 2 * i + 5 * j == 200) ...
2.5算法_枚举-换硬币
ctaloguesofivoy的博客
11-26 267
将一笔零钱换成5分、2分和1分的硬币，要求每种硬币至少有一枚，有几种不同的换法？ 输入格式: 输入在一行中给出待换的零钱数额x∈(8,100)。 输出格式: 要求按5分、2分和1分硬币的数量依次从大到小的顺序，输出各种换法。每行输出一种换法，格式为：“fen5:5分硬币数量, fen2:2分硬币数量, fen1:1分硬币数量, total:硬币总数量”。最后一行输出“count = 换法个数”。 输入样例: 13 输出样例: fen5:2, fen2:1, fen1:1, total:4 fen5:1, f
硬币兑换方案总数（动态规划）
hamburgerJ的博客
09-01 357
【代码】硬币兑换方案总数（动态规划）
"C语言解决背包可行性问题的枚举、回溯和动态规划方法
综上所述，本课程设计通过使用C语言实现了三种不同的方法来解决背包问题：枚举法、回溯法和动态规划法。经过初步的调试运行，这些方法已经能够达到设计的目标。在实际生活中，我们可以根据具体情况选择不同的方法来...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值