贪心算法-找零问题 实验报告

合集下载

贪心算法 实验报告

贪心算法 实验报告

贪心算法实验报告贪心算法实验报告引言:贪心算法是一种常用的算法设计策略,它通常用于求解最优化问题。

贪心算法的核心思想是在每一步选择中都选择当前最优的解,从而希望最终能够得到全局最优解。

本实验旨在通过实际案例的研究,探索贪心算法的应用和效果。

一、贪心算法的基本原理贪心算法的基本原理是每一步都选择当前最优解,而不考虑整体的最优解。

这种贪婪的选择策略通常是基于局部最优性的假设,即当前的选择对于后续步骤的选择没有影响。

贪心算法的优点是简单高效,但也存在一定的局限性。

二、实验案例:零钱兑换问题在本实验中,我们以零钱兑换问题为例,来说明贪心算法的应用。

问题描述:假设有不同面值的硬币,如1元、5元、10元、50元和100元,现在需要支付给客户x元,如何用最少的硬币数完成支付?解决思路:贪心算法可以通过每次选择当前面值最大的硬币来求解。

具体步骤如下:1. 初始化一个空的硬币集合,用于存放选出的硬币。

2. 从面值最大的硬币开始,如果当前硬币的面值小于等于待支付金额,则将该硬币放入集合中,并将待支付金额减去该硬币的面值。

3. 重复步骤2,直到待支付金额为0。

实验过程:以支付金额为36元为例,我们可以通过贪心算法求解最少硬币数。

首先,面值最大的硬币为100元,但36元不足以支付100元硬币,因此我们选择50元硬币。

此时,剩余待支付金额为36-50=-14元。

接下来,面值最大的硬币为50元,但待支付金额为负数,因此我们选择下一个面值最大的硬币,即10元硬币。

此时,剩余待支付金额为-14-10=-24元。

继续选择10元硬币,剩余待支付金额为-24-10=-34元。

再次选择10元硬币,剩余待支付金额为-34-10=-44元。

最后,选择5元硬币,剩余待支付金额为-44-5=-49元。

由于待支付金额已经为负数,我们无法继续选择硬币。

此时,集合中的硬币数为1个50元和3个10元,总共4个硬币。

实验结果:通过贪心算法,我们得到了36元支付所需的最少硬币数为4个。

贪心算法实验报告心得

贪心算法实验报告心得

贪心算法实验报告心得前言贪心算法是一种常见且重要的算法设计思想,通过每一步都选择当下最优的解决方案,以期望最终得到全局最优解。

在学习与实践贪心算法的过程中,我有了许多心得与体会。

什么是贪心算法?贪心算法是一种求解问题的算法思想,它的特点是每一步都选择当前最优的解决方案,而不考虑该选择对以后步骤的影响。

贪心算法通常适用于可以将问题分解为若干个子问题,并且通过每次选择当前最优解来得到整体最优解的情况。

贪心算法的基本步骤贪心算法的基本步骤可以总结为以下几个方面:1.确定问题的解空间,并找到问题的最优解。

贪心算法通常通过穷举法或者利用问题的特殊性质来确定解空间。

2.制定贪心策略。

贪心算法的核心是确定每一步选择的贪心策略,即选择当前最优解。

3.确定贪心策略的正确性。

贪心算法的一个关键问题是如何证明贪心策略的正确性。

可以通过数学证明、反证法或者举反例等方式来进行证明。

4.实现贪心算法。

将贪心策略转化为实际可执行的算法步骤,编写代码来求解问题。

贪心算法实验结果分析在本次实验中,我使用贪心算法解决了一个经典问题:找零钱问题(Change-Making Problem)。

给定一定面额的硬币和需找的金额,我们的目标是使用最少的硬币来完成找零钱。

贪心算法的思路是每次选择面额最大的硬币进行找零。

实验设计1.实验输入:我设计了多组输入来测试贪心算法的性能。

每组输入包括一个需找的金额和一个硬币集合。

2.实验输出:对于每组输入,贪心算法输出一个最优的硬币找零方案,以及使用的硬币数量。

3.实验评价:我使用了实际需找金额与贪心算法计算得到的找零金额的差值来评估算法的准确性,并统计了算法的时间复杂度。

实验结果从多组实验结果中可以观察到,贪心算法在大部分情况下给出了正确的找零金额,并且算法的时间复杂度较低。

结果分析贪心算法在找零钱问题中的应用是合理的。

每次选择面额最大的硬币进行找零,可以快速接近最优解,并且相对其他算法具有较低的时间复杂度。

单源最短路径(贪心法)实验报告

单源最短路径(贪心法)实验报告

算法分析与设计实验报告第 5 次实验使用贪心法求出给定图各点的最短路径,并计算算法的执行时间,分析算法的有效性。

已知一个有向网络 G=(V,E)和源点 V1,如上所示,求出从源点出发到图中其余顶点的最短路径。

1 用邻接矩阵表示有向图,并进行初始化,同时选择源点;}手动输入实现实验所给图形:随机数产生图的权值:通过这次实验,我回顾了回溯法求解最短路径问题,在其中加入了舍伍德附录:完整代码#include<stdio.h>#include<stdlib.h>#include<time.h>#define maxint 1000int c[200][200]={0};void Dijkstra(int n,int v,int dist[],int prev[]){ bool s[maxint];for(int i=1;i<=n;i++){dist[i]=c[v][i];s[i]=false;if(dist[i]==maxint) prev[i]=0;else prev[i]=v;} //找到第一个可行源点 s[]标志,记录prev[]前一个点dist[v]=0;s[v]=true;for(int i=1;i<n;i++){int temp=maxint;int u=v;for(int j=1;j<=n;j++){if((!s[j])&&(dist[j]<temp)){u=j;temp=dist[j];}}s[u]=true;for(int j=1;j<=n;j++){int newdist=dist[u]+c[u][j];if(newdist<dist[j]){dist[j]=newdist;prev[j]=u;}}}}int main(){int n,v;printf("请输入顶点数: ");scanf("%d",&n);//printf("路径: ");srand(time(0));for(int i=1;i<n+1;i++){for(int j=1;j<n+1;j++){/* scanf("%d",&c[i][j]);*/ ///手动输入if(i!=j){if((c[j][i]==0)||(c[j][i]==1000))c[i][j]=rand()%100+1;else c[i][j]=1000;if(c[i][j]>50) c[i][j]=1000;}}}printf("请输入源点: ");scanf("%d",&v);int dist[n+1],prev[n+1];printf("\n路径:\n");for(int i=1;i<n+1;i++){for(int j=1;j<n+1;j++)printf("%5d ",c[i][j]);printf("\n");}Dijkstra(n,v,dist,prev);for(int i=1;i<n+1;i++){printf("\n%d到%d的最短路径为:%d",v,i,dist[i]);}}。

算法实验报告贪心

算法实验报告贪心

一、实验背景贪心算法是一种在每一步选择中都采取当前状态下最好或最优的选择,从而希望导致结果是全局最好或最优的算法策略。

贪心算法并不保证能获得最优解,但往往能获得较好的近似解。

在许多实际应用中,贪心算法因其简单、高效的特点而被广泛应用。

本实验旨在通过编写贪心算法程序,解决经典的最小生成树问题,并分析贪心算法的优缺点。

二、实验目的1. 理解贪心算法的基本原理和应用场景;2. 掌握贪心算法的编程实现方法;3. 分析贪心算法的优缺点,并尝试改进;4. 比较贪心算法与其他算法在解决最小生成树问题上的性能。

三、实验内容1. 最小生成树问题最小生成树问题是指:给定一个加权无向图,找到一棵树,使得这棵树包含所有顶点,且树的总权值最小。

2. 贪心算法求解最小生成树贪心算法求解最小生成树的方法是:从任意一个顶点开始,每次选择与当前已选顶点距离最近的顶点,将其加入生成树中,直到所有顶点都被包含在生成树中。

3. 算法实现(1)数据结构- 图的表示:邻接矩阵- 顶点集合:V- 边集合:E- 已选顶点集合:selected- 最小生成树集合:mst(2)贪心算法实现```def greedy_mst(graph):V = set(graph.keys()) # 顶点集合selected = set() # 已选顶点集合mst = set() # 最小生成树集合for i in V:selected.add(i)mst.add((i, graph[i]))while len(selected) < len(V):min_edge = Nonefor edge in mst:u, v = edgeif v not in selected and (min_edge is None or graph[u][v] < graph[min_edge[0]][min_edge[1]]):min_edge = edgeselected.add(min_edge[1])mst.add(min_edge)return mst```4. 性能分析为了比较贪心算法与其他算法在解决最小生成树问题上的性能,我们可以采用以下两种算法:(1)Prim算法:从任意一个顶点开始,逐步添加边,直到所有顶点都被包含在生成树中。

贪心算法-找零问题 实验报告

贪心算法-找零问题 实验报告

实验三课程名称:算法设计与实现实验名称:贪心算法-找零问题实验日期:2019年5月2日仪器编号:007班级:数媒0000班姓名:郝仁学号0000000000实验内容假设零钱系统的币值是{1,p,p^2,……,p^n},p>1,且每个钱币的重量都等于1,设计一个最坏情况下时间复杂度最低的算法,使得对任何钱数y,该算法得到的零钱个数最少,说明算法的主要设计思想,证明它的正确性,并给出最坏情况下的时间复杂度。

实验分析引理1(离散数学其及应用3.1.4):若n是正整数,则用25美分、10美分、5美分和1美分等尽可能少的硬币找出的n美分零钱中,至多有2个10美分、至多有1个5美分、至多有4个1美分硬币,而不能有2个10美分和1个5美分硬币。

用10美分、5美分和1美分硬币找出的零钱不能超过24美分。

证明如果有超过规定数目的各种类型的硬币,就可以用等值的数目更少的硬币来替换。

注意,如果有3个10美分硬币,就可以换成1个25美分和1个5美分硬币;如果有2个5美分硬币,就可以换成1个10美分硬币;如果有5个1美分硬币,就可以换成1个5美分硬币;如果有2个10美分和1个5美分硬币,就可以换成1个25美分硬币。

由于至多可以有2个10美分、1个5美分和4个1美分硬币,而不能有2个10美分和1个5美分硬币,所以当用尽可能少的硬币找n美分零钱时,24美分就是用10美分、5美分和1美分硬币能找出的最大值。

假设存在正整数n,使得有办法将25美分、10美分、5美分和1美分硬币用少于贪心算法所求出的硬币去找n美分零钱。

首先注意,在这种找n美分零钱的最优方式中使用25美分硬币的个数q′,一定等于贪心算法所用25美分硬币的个数。

为说明这一点,注意贪心算法使用尽可能多的25美分硬币,所以q′≤q。

但是q′也不能小于q。

假如q′小于q,需要在这种最优方式中用10美分、5美分和1美分硬币至少找出25美分零钱。

而根据引理1,这是不可能的。

算法分析与设计实验三贪心算法

算法分析与设计实验三贪心算法

实验三贪心算法实验目的1. 掌握贪心法的基本思想方法;2. 了解适用于用贪心法求解的问题类型,并能设计相应贪心法算法;3. 掌握贪心算法复杂性分析方法分析问题复杂性。

预习与实验要求1. 预习实验指导书及教材的有关内容,掌握贪心法的基本思想;2. 严格按照实验内容进行实验,培养良好的算法设计和编程的习惯;3. 认真听讲,服从安排,独立思考并完成实验。

实验设备与器材硬件:PC机软件:C++或Java等编程环境实验原理有一类问题是要从所有的允许解中求出最优解,其策略之一是“贪心法”,即逐次实施“贪心选择”:在每个选择步骤上做出的选择都是当前状态下最优的。

贪心选择依赖于在此之前所做出的选择,但不依赖于后续步骤所需要的选择,即不依赖于后续待求解子问题。

显然,这种选择方法是局部最优的,但不是从问题求解的整体考虑进行选择,因此不能保证最后所得一定是最优解。

贪心法是求解问题的一种有效方法,所得到的结果如果不是最优的,通常也是近似最优的。

实验内容以下几个问题选做一项:1. 用贪心法实现带有期限作业排序的快速算法应用贪心设计策略来解决操作系统中单机、无资源约束且每个作业可在等量时间内完成的作业调度问题。

假定只能在一台机器上处理N个作业,每个作业均可在单位时间内完成;又假定每个作业i都有一个截止期限di>0(它是整数),当且仅当作业i在它的期限截止以前被完成时,则获得pi的效益。

这个问题的一个可行解是这N个作业的一个子集合J,J中的每个作业都能在各自的截止期限之前完成。

可行解的效益值是J中这些作业的效益之和,即Σp。

具有最大效益值的可行解就是最优解。

2. 实现K元归并树贪心算法两个分别包含n个和m个记录的已分类文件可以在O(n+m)时间内归并在一起而得到一个分类文件。

当要把两个以上的已分类文件归并在一起时,可以通过成对地重复归并已分类的文件来完成。

例如:假定X1,X2,X3,X4是要归并的文件,则可以首先把X1和X2归并成文件Y1,然后将Y1和X3归并成Y2,最后将Y2和X4归并,从而得到想要的分类文件;也可以先把X1和X2归并成Y1,然后将X3和X4归并成Y2,最后归并Y1和Y2而得到想要的分类文件。

找零问题贪心算法实现

找零问题贪心算法实现

找零问题贪心算法实现一、实验描述当前有面值分别为2角5分,1角,5分,1分的硬币,请给出找n分钱的最佳方案(要求找出的硬币数目最少)。

二、实验原理具体实例:假如老板要找给我99分钱,他有上面的面值分别为25,10,5,1的硬币数,为了找给我最少的硬币数,那么他是不是该这样找呢,先看看该找多少个25分的, 99/25=3,好像是3个,要是4个的话,我们还得再给老板一个1分的,我不干,那么老板只能给我3个25分的拉,由于还少给我24,所以还得给我2个10分的和4个1分。

具体实现:<<endl;outputFile<<setw(4)<<"面值"<<setw(7)<<"个数"<<endl;int sum=0;for (int i=1;i<=number;i++){ inputFile>>T[i];inputFile>>Coins[i];outputFile<<setw(3)<<T[i]<<setw(3)<<" "<<setw(3)<<Coins[i]<<endl;sum+=T[i]*Coins[i];}inputFile>>TotalMoney;outputFile<<"需要找回的总钱数为: "<<TotalMoney<<endl;if (T!=NULL && Coins!=NULL){ if (sum>=TotalMoney)return true;else outputFile<<"所有硬币的总钱数是"<<sum<<" 小于需要找回的总钱数"<<TotalMoney<<endl;return false;}return false;}int LeastCoins::changeMoney(int i,int j){ if (i>1){ if (j<T[i]) // 要找的钱数小于该硬币的面值{m[i-1][j]=changeMoney(i-1,j);m[i][j]=m[i-1][j]; return m[i][j]; }else{ int X=j/T[i];X=(X<Coins[i] X : Coins[i]) ;int T1=changeMoney(i-1,j-X*T[i]);int T2=changeMoney(i-1,j-(X-1)*T[i]);m[i-1][j-X*T[i]]=T1;m[i-1][j-(X-1)*T[i]]=T2;if ((T1+X)>(T2+X-1)) m[i][j]=T2+X-1;else m[i][j]=T1+X;return m[i][j];}}else if(i==1)// 此时 i==1{ if ((j%T[1])==0 && (j/T[1]<=Coins[1])){ m[1][j]=j/T[1]; return m[1][j]; } else return 1000000;}else return 1000000;}void LeastCoins::output(){ if (m[number][TotalMoney]<1000000) // 判断是否有解{ outputFile<<"需要最少的硬币个数是: "<<m[number][TotalMoney]<<endl;outputFile<<setw(4)<<"面值"<<setw(7)<<"个数"<<endl;traceback();}else outputFile<<"无解"<<endl;}void LeastCoins::traceback(){int j=TotalMoney;for (int i=number;i>=2;i--){int X=j/T[i]; // 最多需要面值为 T[i] 的硬币的个数X=(X<Coins[i] X : Coins[i]) ; // 取 X 和 Coins[i]的较小值int T1=m[i-1][j-X*T[i]]+X;int T2=m[i-1][j-(X-1)*T[i]]+X-1;if (T1<T2){ outputFile<<setw(3)<<T[i]<<setw(3)<<" "<<setw(3)<<X<<endl; j-=X*T[i]; } else { outputFile<<setw(3)<<T[i]<<setw(3)<<" "<<setw(3)<<(X-1)<<endl;j-=(X-1)*T[i]; }}outputFile<<setw(3)<<T[i]<<setw(3)<<" "<<setw(3)<<(j/T[1])<<endl;}int main(){ LeastCoins LC;();return 0;}三、运行结果图1 运行结果四、实验总结对贪心算法不是特别熟悉,以至于在编写程序时遇到好多错误,好在差不多都改正了,此程序尚有不足之处,希望在以后的深入学习后能编写个更好的程序。

贪心算法_实验报告

贪心算法_实验报告

贪心算法_实验报告一、设计分析●问题描述:键盘输入一个高精度的正整数N(N不超过240位),去掉其中任意S个数字后剩下的数字按原左右次序将组成一个新的正整数。

编程对给定的N和S,寻找一种方案使得剩下的数字组成的新数最小。

●设计思路:在位数固定的前提下,让高位的数字尽量小其值就较小,依据此贪心策略解决此问题。

删除高位较大的数字。

具体:相邻两位比较若高位比低位大则删除高位。

删除字符的方法:1)物理删除,用后面的字符覆盖已删除的字符。

有比较多字符移动操作,算法效率不高。

2)用数组记录字符的状态,“1”表示对应数字存在,“0”表示对应数字已删除。

3)利用数组,记录未删除字符的下标:n=“1 2 4 3 5 8 3 3”0 0 0 0 0 04比3大删除“1 2 3 5 8 3 3” 1 2 4 5 0 08比3大删除“1 2 3 5 3 3” 1 2 4 5 05比3大删除“1 2 3 3 3” 1 2 4 7 8二、程序代码c语言实现#include<stdio.h>#include<string.h>#define N 10000int main(void){char a[N];int i,j,k,n;printf("输入要处理的数据:\n");gets(a);printf("输入要删除的数字个数:\n");scanf("%d",&n);三、测试用例四、实验总结加深了对贪心算法的理解与运用。

所谓贪心选择性质是指所求问题的整体最优解可以通过一系列局部最优的选择,即贪心选择来达到。

这是贪心算法可行的第一个基本要素,也是贪心算法与动态规划算法的主要区别。

动态规划算法通常以自底向上的方式解各子问题,而贪心算法则通常以自顶向下的方式进行,以迭代的方式作出相继的贪心选择,每作一次贪心选择就将所求问题简化为规模更小的子问题。

  1. 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
  2. 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
  3. 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。

实验三
课程名称:算法设计与实现实验名称:贪心算法-找零问题
实验日期:2019年5月2日仪器编号:007
班级:数媒0000班姓名:郝仁学号0000000000
实验内容
假设零钱系统的币值是{1,p,p^2,……,p^n},p>1,且每个钱币的重量都等于1,设计一个最坏情况下时间复杂度最低的算法,使得对任何钱数y,该算法得到的零钱个数最少,说明算法的主要设计思想,证明它的正确性,并给出最坏情况下的时间复杂度。

实验分析
引理1(离散数学其及应用3.1.4):若n是正整数,则用25美分、10美分、5美分和1美分等尽可能少的硬币找出的n美分零钱中,至多有2个10美分、至多有1个5美分、至多有4个1美分硬币,而不能有2个10美分和1个5美分硬币。

用10美分、5美分和1美分硬币找出的零钱不能超过24美分。

证明如果有超过规定数目的各种类型的硬币,就可以用等值的数目更少的硬币来替换。

注意,如果有3个10美分硬币,就可以换成1个25美分和1个5美分硬币;如果有2个5美分硬币,就可以换成1个10美分硬币;如果有5个1美分硬币,就可以换成1个5美分硬币;如果有2个10美分和1个5美分硬币,就可以换成1个25美分硬币。

由于至多可以有2个10美分、1个5美分和4个1美分硬币,而不能有2个10美分和1个5美分硬币,所以当用尽可能少的硬币找n美分零钱时,24美分就是用10美分、5美分和1美分硬币能找出的最大值。

假设存在正整数n,使得有办法将25美分、10美分、5美分和1美分硬币用少于贪心算法所求出的硬币去找n美分零钱。

首先注意,在这种找n美分零钱的最优方式中使用25美分硬币的个数q′,一定等于贪心算法所用25美分硬币的个数。

为说明这一点,注意贪心算法使用尽可能多的25美分硬币,所以q′≤q。

但是q′也不能小于q。

假如q′小于q,需要在这种最优方式中用10美分、5美分和1美分硬币至少找出25美分零钱。

而根据引理1,这是不可能的。

由于在找零钱的这两种方式中一定有同样多的25美分硬币,所以在这两种方式中10美分、5美分和1美分硬币的总值一定相等,并且这些硬币的总值不超过24美分。

10美分硬币的个数一定相等,因为贪心算法使用尽可能多的10美分硬币。

而根据引理1,当使用尽可能少的硬币找零钱时,至多使用1个5分硬币和4个1分硬币,所以在找零钱的最优方式中也使用尽可能多的10美分硬币。

类似地,5美分硬币的个数相等;最终,1美分的个数相等。

同上,由于1+p1+p2+p3+...pk-1=pk - 1<pk,故当n大于pk时,可以分解为pk与n-pk的值,其中pk只用一个硬币值为pk的硬币就能得到最少硬币数,而子问题变成n-pk的最少硬币数,依次类推,贪心算法总能得到最好的结果。

假若最优解不含币值j
p 的钱币,即112210--+⋯+++=j j p x p x p x x y 那么存在{}1,1,0,-⋯∈≥j i p x i ,,如果不是,则
11)(1(12112210-=+⋯+++-≤+⋯+++=---j j j j p p p p p p x p x p x x y
与j p ≥y 矛盾,不妨设p x i ≥,那么用1个币值为1+i p 的钱币替换p 个币值为j
p 的钱币,总钱币数将减少1-p ,与这个解为最优解矛盾。

下面证明最优解签好含有⎣⎦
j p /y 个币值j p 的钱币。

设钱数为y 时最优解是()y F j ,则
()()
()⎪⎩⎪⎨⎧<≥+-=-j j j j j j p y y F p y p y F y F 11 设()j j p tp y <+=δδ其中⎣⎦j
p y t /= 通过对t 的归纳不难证明()()δ1
j -+=j F t y F ,即最优解中含有⎣⎦
j p y /个币值j p 的钱币。

上诉算法在最坏情况下的时间复杂度是()()}log ,m in{y n O n W =.
实验源代码
// 找零ConsoleApplication1.cpp : 此文件包含 "main" 函数。

程序执行将在此处开始并结束。

//数媒1703班-1191170329-唐思成
// coin.cpp : 定义控制台应用程序的入口点。

//
#include "pch.h"
#include <iostream>
#include <math.h>
using namespace std;
//money 需要找零的钱
//coin 可用的硬币的种类
//n 硬币种类的数量
void ZhaoLing(int money , int *coin , int n ){
int *coinNum = new int [money + 1]();//存储1...money 找零最少需要的硬币的个数
int *coinValue = new int [money + 1]();//最后加入的硬币,方便后面输出是哪几个硬币 coinNum[0] = 0;
for (int i = 1; i <= money; i++)
{
int minNum = i;//i面值钱,需要最少硬币个数
int usedMoney = 0;//这次找零,在原来的基础上需要的硬币
for (int j = 0; j < n; j++)
{
if (i >= coin[j])//找零的钱大于这个硬币的面值
{
if (coinNum[i - coin[j]] + 1 <= minNum && (i == coin[j] || coinValue[i - coin[j]] != 0))//所需硬币个数减少了
{
minNum = coinNum[i - coin[j]] + 1;//更新
usedMoney = coin[j];//更新
}
}
}
coinNum[i] = minNum;
coinValue[i] = usedMoney;
}
//输出结果
if (coinValue[money] == 0)
cout <<"找不开零钱"<< endl;
else
{
cout <<"需要最少硬币个数为:"<< coinNum[money] << endl;
cout <<"硬币分别为:";
while (money > 0)
{
cout << coinValue[money] <<",";
money -= coinValue[money];
}
cout << endl;
}
delete[]coinNum;
delete[]coinValue;
}
int main(){
int Money;
int n,i,p;
cout <<"请输入需要找零的钱的值"<< endl;
cin >> Money;
cout <<"请输入硬币种类的数量"<< endl;
cin >> n;
int*coin = (int*)malloc(n * sizeof(int));//定义动态长度的数组
cout <<"请输入零钱的底数"<< endl;
while(1) {
cin >> p;
if (p > 0) {
break;
}
else {
cout <<"输入的数小于零,请重新输入"<< endl;
}
}
for (i = 0; i < n; i++) {
coin[i] = pow(p, i);
}
cout <<"找零系统中的零钱种类为:"<< endl;
for (i = 0; i < n; i++) {
cout << coin[i] <<",";
}
cout << endl;
ZhaoLing(Money, coin, n);
system("pause");
return 0;
}
实验结果。

相关文档
最新文档