贪心算法解汽车加油问题实验报告
实验三-贪心算法
for(inti=0;i<s.length();i++){
buf.append(getEachCode(s.substring(i,i+1)));
}
returnbuf.toString();
}
publicString getEachCode(String name){
for(inti=0;i<buffer.length();i++){
if(name.equals(codes[i].name)){
returnhuffstring[i];
}
}
return"";
}
publicvoidgetCode(intn,String[] thecodes,String thebuffer){
importjava.util.Scanner;
classHuffmanCode{
Stringname;
doubleweight;
intlc,rc,pa;
publicHuffmanCode(){
name="";
weight=0;
lc=-1;rc=-1;pa=-1;
}
}
publicclassHuffman1 {
dist[j]=newdist;prev[j]=u;}}}}
(3)运行结果
3、题目三
(1)问题分析
设G=（V，E）是连通带权图，V={1，2，…,n}。构造G的最小生成树的Prim算法的基本思想是：首先置S{1}，然后，只要S是V的真子集，就进行如下的贪心选择：选取满足条件i∈S，j∈V-S，且c[i][j]最小的边，将顶点j添加到S中。这个过程一直进行到S=V时为止。过程中所取到的边恰好构成G的一棵最小生成树。
贪心算法 实验报告
贪心算法实验报告贪心算法实验报告引言：贪心算法是一种常用的算法设计策略，它通常用于求解最优化问题。
贪心算法的核心思想是在每一步选择中都选择当前最优的解，从而希望最终能够得到全局最优解。
本实验旨在通过实际案例的研究，探索贪心算法的应用和效果。
一、贪心算法的基本原理贪心算法的基本原理是每一步都选择当前最优解，而不考虑整体的最优解。
这种贪婪的选择策略通常是基于局部最优性的假设，即当前的选择对于后续步骤的选择没有影响。
贪心算法的优点是简单高效，但也存在一定的局限性。
二、实验案例：零钱兑换问题在本实验中，我们以零钱兑换问题为例，来说明贪心算法的应用。
问题描述：假设有不同面值的硬币，如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个。
贪心算法Tsp实习报告1
2.2.2 贪心算法的缺陷
贪心算法（又称贪心算法）是指，在对问题求解时，总是做出在当前看来是最好的选择。 也就是说，不从整体最优上加以考虑，它所做出的仅是在某种意义上的局部最优解。贪心算 法不是对所有问题都能得到整体最优解，但对范围相当广泛的许多问题他能产生整体最优解 或者是整体最优解的近似解。
1.3 贪心算法的概念
贪心算法（又称贪婪算法）是指，在对问题求解时，总是做出在当前看来是最好的选择。 也就是说，不从整体最优上加以考虑，他所做出的仅是在某种意义上的局部最优解。贪心算 法不是对所有问题都能得到整体最优解，但对范围相当广泛的许多问题他能产生整体最优解 或者是整体最优解的近似解。
为了解决问题，需要寻找一个构成解的候选对象集合，它可以优化目标函数，贪心算 法一步一步的进行。起初，算法选出的候选对象的集合为空。接下来的每一步中，根据选择 函数，算法从剩余候选对象中选出最有希望构成解的对象。如果集合中加上该对象后不可行， 那么该对象就被丢弃并不再考虑；否则就加到集合里。每一次都扩充集合，并检查该集合是 否构成解。如果贪心算法正确工作，那么找到的第一个解通常是最优的。
3. 课程实习报告内容
3.1 了解并掌握贪心算法
贪心算法（Greedy algorithm）是一种对某些求最优解问题的更简单、更迅速的设计技 术。用贪心法设计算法的特点是一步一步地进行，常以当前情况为基础根据某个优化测度作 最优选择，而不考虑各种可能的整体情况，它省去了为找最优解要穷尽所有可能而必须耗费 的大量时间，它采用自顶向下，以迭代的方法做出相继的贪心选择，每做一次贪心选择就将
2. 课程实习题目描述和要求.........................................................................................................1 2.1 TSP 问题介绍.................................................................................................................1 2.2 贪心算法的特性.............................................................................................................2 2.2.1 贪心算法的特性：............................................................................................ 2 2.2.2 贪心算法的缺陷................................................................................................ 2 2.3 关于贪心算法的备注.................................................................................................... 2
《算法设计与分析》课程实验报告 (贪心算法(一))
《算法设计与分析》课程实验报告实验序号：07实验项目名称：实验8 贪心算法（一）一、实验题目1.删数问题问题描述：键盘输入一个高精度的正整数N（不超过250 位），去掉其中任意k个数字后剩下的数字按原左右次序将组成一个新的非负整数。
编程对给定的N 和k，寻找一种方案使得剩下的数字组成的新数最小。
若输出前有0则舍去2.区间覆盖问题问题描述：设x1,x2,...xn是实轴上的n个点。
用固定长度为k的闭区间覆盖n个点，至少需要多少个这样的固定长度的闭区间？请你设计一个有效的算法解决此问题。
3.会场安排问题问题描述：假设要在足够多的会场里安排一批活动，并希望使用尽可能少的会场。
设计一个有效的贪心算法进行安排。
（这个问题实际上是著名的图着色问题。
若将每一个活动作为图的一个顶点，不相容活动间用边相连。
使相邻顶点着有不同颜色的最小着色数，相应于要找的最小会场数。
）4.导弹拦截问题问题描述：某国为了防御敌国的导弹袭击，发展出一种导弹拦截系统。
但是这种导弹拦截系统有一个缺陷：虽然它的第一发炮弹能够到达任意的高度，但是以后每一发炮弹都不能高于前一发的高度。
某天，雷达捕捉到敌国的导弹来袭。
由于该系统还在试用阶段，所以只有一套系统，因此有可能不能拦截所有的导弹。
给定导弹依次飞来的高度（雷达给出的高度数据是≤50000的正整数），计算这套系统最多能拦截多少导弹，如果要拦截所有导弹最少要配备多少套这种导弹拦截系统。
二、实验目的（1）通过实现算法，进一步体会具体问题中的贪心选择性质，从而加强对贪心算法找最优解步骤的理解。
（2）掌握通过迭代求最优的程序实现技巧。
（3）体会将具体问题的原始数据预处理后（特别是以某种次序排序后），常能用贪心求最优解的解决问题方法。
三、实验要求（1）写出题1的最优子结构性质、贪心选择性质及相应的子问题。
（2）给出题1的贪心选择性质的证明。
（3）（选做题）：写出你的算法的贪心选择性质及相应的子问题，并描述算法思想。
《算法分析与设计》汽车加油问题
汽车加油问题1. 问题描述一辆汽车加油满后可行驶n千米，旅途中有若干加油站（不包含汽车的出发点）。
假如在出发时已加满油，设计一个有效算法，指出应在哪些加油站停靠加油，使沿途加油次数最少，并给出加油的地点。
证明算法能产生一个最优解。
算法设计：对于给定的n和k个加油站位置，计算最少加油次数。
2. 算法流程分析设汽车加满油后可行驶n千米，且除了出发点和目的地，旅途中有k个加油站。
把目的地假设为最后一个加油站，有k个加油站。
令数组x存储加油站间距，x[i]表示第i-1个加油站到第i 个加油站之间的距离。
x[0]即出发地到0号加油站的距离。
x[k-1]是第k-2个加油站到第k-1个加油站即终点的距离。
判断s加上x[i]后是否超出n，若超出则必定在i-1处加了油a[i-1]=true ，sum加1表示加油次数加一，且加油后里程从0开始计算，从i-1到达到i处里程为x[i]。
i++进入下一轮，即判断下一个加油站是否能到达。
3. 算法正确性证明通过几组实例证明合法的输入可以得到正确的输出。
实例见附录第2部分。
4. 算法复杂度分析O（n）5.参考文献[1] 王晓东编著，计算机算法设计与分析（第4版）。
北京：电子工业出版社，2012.26.附录（1）可执行代码如下：#include<iostream>using namespace std;int main(){int j,n,k,x[10],c=0,m=0;bool a[10];cout<<"请输入汽车加满油后可行驶的距离（km）: ";cin>>n;cout<<"请输入旅途中所经过的加油站个数：";cin>>k;cout<<"请输入每两个相邻加油站之间的距离："<<endl;for(int i=0;i<=k;i++)cin>>x[i];for(i=0;i<=k;i++)a[i]=false;for(j=0;j<=k;j++){m+=x[j];if(m+x[j+1]>=7){a[j+1]=true;m=0;}}cout<<"在第";for(int s=0;s<=k;s++)if(a[s]==true){c++;cout<<s<<" ";}cout<<"个加油站加油了。
贪心算法实验报告(C语言)
实验2、《贪心算法实验》一、实验目的1. 了解贪心算法思想2. 掌握贪心法典型问题，如背包问题、作业调度问题等。
二、实验内容1. 编写一个简单的程序，实现单源最短路径问题。
2. 编写一段程序，实现找零。
【问题描述】当前有面值分别为2角5分，1角，5分，1分的硬币，请给出找n分钱的最佳方案（要求找出的硬币数目最少）。
3. 编写程序实现多机调度问题【问题描述】要求给出一种作业调度方案，使所给的n个作业在尽可能短的时间内由m 台机器加工处理完成。
约定，每个作业均可在任何一台机器上加工处理，但未完工前不允许中断处理。
作业不能拆分成更小的子作业。
三、算法思想分析1.初始化将源点设计为红点集，其余点设计为蓝点，重复选择蓝点集中与源点路径最短的点加入红点集，更新剩余的蓝点集路径，直至蓝点集为空或者只剩下没有连通的点，那么源点到其余所有点的最短路径就出来了。
2.找零问题是典型的贪心问题，但是并不代表所有的找零都能用贪心算法找到最优解。
只有满足贪心选择性质的找零才能找到最优解，本题满足贪心选择性质，直接先一直选面值最大的硬币，再一次减小即可。
3.先对作业按时长进行重排序，再依次找目前用时最短的机器安排工作并加上对应时长，最后总时长为机器中用时最长的那个时长。
四、实验过程分析1.单源最短路径的算法思想并不难，但是在实际编码过程中还是有很多小问题需要注意，首先，一定要新建数组存储路径变化，因为后面计算路径时会用到原数组，如果直接在原数组上更改后面就找不到原数据了，那么就会出现偏差。
其次就是建议先写个伪代码，判断的if-else语句比较多，容易搞混，在代码中一定要及时备注，某些代码的功能是什么，不然再次看代码时需要思考很久甚至忘记。
2.找零问题直接用while循环或者不断取余取模即可解决。
3.作业调度问题大致分为三步，一是排序，二是不断找最短时长的机器安排作业，三是找最长时间为作业完成时间。
五、算法源代码及用户屏幕1.（1）算法源码/**********************单源最短路径问题。
实验二 贪心算法-最少活动会场安排问题
中原工学院计算机学院实验报告实验项目名称实验二、最少活动会场安排问题课程名称算法设计与分析学生姓名梁斐燕学生学号************所在班级网络14卓越学科专业网络工程任课教师吴志刚完成日期2016年月日实验二最少活动会场安排问题一、实验目的1．掌握贪心算法的基本概念和两个基本要素2．熟练掌握贪心算法解决问题的基本步骤。
3．学会利用贪心算法解决实际问题。
二、实验内容•问题描述：•题目一：假设要在足够多的会场里安排一批活动，并希望使用尽可能少的会场。
设计一个有效的贪心算法来进行安排，试编程实现。
•题目二：一辆汽车加满油后,可行使n千米。
旅途中有若干个加油站。
若要使沿途加油次数最少,设计一个有效算法，指出应在哪些加油站停靠加油。
•数据输入：个人设定，由键盘输入。
•要求：–上述题目任选一做。
上机前，完成程序代码的编写–独立完成实验及实验报告三、实验步骤㈠、数据结构与核心算法的设计描述提示：题目一：参考教材活动安排问题；有关队列操作参考数据结构。
void GreedySelector(int n, int *s, int *f, int *A) {//用集合A来存储所选择的活动A[1] = TURE; //默认从第一次活动开始执行int j = 1; //j记录最近一次加入到A中的活动for (int i = 2; i <= n; i++) { //f[j]为当前集合A中所有活动的最大结束时间//活动i的开始时间不早于最近加入到集合A中的j的时间f[j]if (s[i] >= f[j]) {A[i] = TURE; //当A[i]=TURE时，活动i在集合A中j = i;}else A[i] = FALSE;}}㈡、函数调用及主函数设计㈢程序调试及运行结果分析㈣实验总结在做本实验之前，自己看了课本上所列举的贪心法解活动安排问题的代码，代码很简单，很容易理解，于是就按课本的代码实现。
通过几个测试用例测试发现结果不对，后来发现自己忘了进行贪心法的一个前提条件，事先没有按各个活动结束时间对所有活动进行非递减排序，所以才会导致结果错误。
实验二(贪心算法)
华东师范大学计算机科学技术系上机实践报告课程名称：算法设计与分析年级：05上机实践成绩：指导教师：柳银萍姓名：张翡翡上机实践名称：贪心算法学号：10052130119上机实践日期：2007-4-10上机实践编号：NO.2组号：上机实践时间：10:00-11:30一、目的了解熟悉掌握贪心算法实质并学会灵活运用，从而解决生活中一些实际问题。
二、内容与设计思想1.超市的自动柜员机(POS)要找给顾客各种数值的现金，表面上看，这是一个很简单的任务，但交给机器办就不简单了。
你作为一个计算机专家，要求写一个程序来对付这个“简单”的问题。
你的自动柜员机有以下的币种：100元，50元，20元，10元，5元，2元，1元。
你可以假设每种钱币的数量是无限的。
现在有一笔交易，需要找个客户m元，请你设计一个算法，使得找给顾客的钱币张数最少。
要求：输入：第一行仅有一个整数n(0<n<=10000),表示有几组测试数据。
每组测试数据仅有一行，每行只有一个整数m(0<m<2000000000)，表示需要找的钱币数。
(提示：对于大量的输出，请使用scanf,不要使用cin)输出：每组测试数据输出一行，每行有7个整数(两两之间有一个空格，结尾不能有空格)，表示100元，50元，20元，10元，5元，2元，1元所需要的张数。
1.1其思路是：1)定义相关变量；2)接收相关数据，如测试数据组数n和要找的钱币数；3)依次考虑100，50，20，10，5，2，1的需要找的钱币张数，用最简单的加减乘除；4)输出其值。
1.2具体算法是：while(n--)m 输入a=m/100b=(m-100*a)/50c=(m-100a-50b)/20d=(m-100a-50b-20c)/10e=(m-100a-50b-20c-10d)/5f=(m-100a-50b-20c-10d-5e)/2g=m-100a-50b-20c-10d-5e-2fend while2.若在0-1背包问题中各物品是依重量递增排列时，其价值恰好依递减序排列。
第四章贪心算法实验报告
第四章贪⼼算法实验报告《贪⼼算法实验报告》计科2001 陈梓聪 20201003024贪⼼算法的思想：通过第四章学习了贪⼼算法，我们知道，贪⼼算法总是做出在当下看来最好的选择，通过每个最优的选择来得出原问题的最优解。
贪⼼算法的使⽤条件：贪⼼算法有的时候并不能得出最优解，只有在满⾜⼀下两个条件的时候才能使⽤：1.贪⼼性质：整体的最优解可通过⼀系列局部最优解达到，并且每次的选择可以依赖以前做出的选择，但不能依赖于以后的选择。
2.最优⼦结构：问题整体的最优解包括⼦问题的最优解。
贪⼼算法的局限性：贪⼼算法有他的局限性，有的时候我们选择局部的最优解，但是它对与全局并⾮最优解，就⽐如硬币找零问题。
但是我们依然可以⽤我们上⼀章所学的动态规划思想来解决。
贪⼼算法的分析过程：⾸先，我们需要确定我们的贪⼼策略，只有正确的贪⼼策略才能得出我们的结论。
下⾯是我们的实验题。
4-1程序储存问题：设有n 个程序{1,2,…, n }要存放在长度为L的磁带上。
程序i存放在磁带上的长度是 li，1≤i≤n。
程序存储问题要求确定这n 个程序在磁带上的⼀个存储⽅案，使得能够在磁带上存储尽可能多的程序。
对于给定的n个程序存放在磁带上的长度，计算磁带上最多可以存储的程序数。
输⼊格式：第⼀⾏是2 个正整数，分别表⽰⽂件个数n和磁带的长度L。
接下来的1⾏中，有n个正整数，表⽰程序存放在磁带上的长度。
输出格式：输出最多可以存储的程序数。
输⼊：6 50 输出： 52 3 13 8 80 20#include <iostream>#include <algorithm>using namespace std;int main() {int n, l, res;cin >> n >> l;int *a = new int [n];for(int i = 0; i < n; i ++) {cin >> a[i];}sort(a, a + n);for(int i = 0; i < n; i ++) {l -= a[i];if(l < 0) {res = i;break;}}cout << res;return0;}贪⼼策略：我的贪⼼策略是将还未存⼊磁带中最⼩的程序放⼊磁带，直到放⼊⼀个程序后，再放⼊下⼀个程序时程序的总长度>L，此时能存下最多程序数。
题目汽车加油问题
题目汽车加油问题论文提要一辆汽车加满油后可行驶n公里，旅途中有若干个加油站，设计一个有效算法，指出应在哪些加油站停靠加油，使沿途加油次数最少，对于给定的n和k个加油站位置，编程计算最少加油次数。
可以利用贪心选择性质来求解汽车加油问题，也就是所求问题的整体最优解可以通过一系列局部最优的选择，即贪心选择来达到。
这是贪心选择算法可行的第一个基本要素，也是贪心算法与动态规划算法的主要区别。
在动态规划算法中，每步所做的选择往往信赖于相关子问题的解，因而只有在解出相关子问题后，才能做出选择。
而在贪心算法中仅在当前状态下做出最好选择，即局部最优选择，然后再去解出这个选择后产生的相应的子问题，贪心算法所做的贪心选择可以依赖于以往所做过的选择，但决不依赖于将来所做的选择，也不依赖于子问题的解。
关于汽车加油问题摘要：汽车行驶过程中，应走到自己能走到并且离自己最远的那个加油站，在那个加油站加油后再按照同样的方法，其中保持车子每次加油都能够行驶最远距离。
当然有可能是达到不了终点的情况，也就是存在某两个加油站之间的距离大于每次加油能够行驶的最远距离，首先检测各加油站之间的距离，若发现其中有一个距离大于汽车加满油能跑的距离，则输出“No Solution”。
否则，对加油站间的距离进行逐个扫描，尽量选择往远处走，不能走了就让num++，最终统计出来的num便是最少的加油站数。
关键词：汽车加油贪心性质最优化问题一、汽车加油问题描述一辆汽车加满油后可行驶n公里，旅途中有若干个加油站，设计一个有效算法，指出应在哪些加油站停靠加油，使沿途加油次数最少。
对于给定的n和k个加油站位置，编程计算最少加油次数。
并证明算法能产生一个最优解。
输入：第一行有个正整数n和k，表示汽车加满油后可行驶n公里，且旅途中有k个加油站。
接下来的行驶中，有k+1 个整数，表示第k个加油站与第k-1 个加油站之间的距离。
第k个加油站表示出发地，汽车已加满油。
第k+1 个加油站表示目的地。
算法分析与设计实验报告--贪心法 (2)
Dijkstra方法的基本思想是从vs出发，逐步地向外探寻最短路。执行过程中，与每个点对应，记录下一个数(称为这个点的标号)，它或者表示从vs到该点的最短路的权(称为P标号)、或者是从vs到该点的最短路的权的上界(称为T标号)，方法的每一步是去修改T标号，并且把某一个具T标号的改变为具P标号的点，从而使G中具P标号的顶点数多一个，这样至多经过n-1(n为图G的顶点数)步，就可以求出从vs到各点的最短路。
if(D[j]>D[min]+graph[min][j]||D[j]==-1)
{D[j]=D[min]+graph[min][j]; //每次迭代求最小值，最后一次即为到源点的最短路径
P[j]=min;
}
}
}
void main()
{instital(R, B, D, P);
theshortestway(R, B, D, P);
using namespace std;
int const ZUSHU = 5;
int Ling[] = {50,20,10,5,1};
int GeShu[ZUSHU];
void ZhaoLing(int n)
{for(int i=0;i<ZUSHU;i++)
{GeShu[i] = n / Ling[i];n = n % Ling[i];}
（1）初始时，S中仅含有源节点。
（2）设u是G的某一个顶点，把从源到u且中间只经过S中顶点的路称为从源到u的特殊路径，用数组D[i]记录顶点i当前所对应的最短特殊路径长度。
旅行家的预算（贪心算法）
旅行家的预算（贪心算法）问题描述一个旅行家想驾驶汽车以最少的费用从一个城市到另一个城市（假设出发时油箱是空的）。
给定两个城市之间的距离D1、汽车油箱的容量C（以升为单位）、每升汽油能行驶的距离D2、出发点每升汽油价格P和沿途油站数N（N可以为零），油站i离出发点的距离Di、每升汽油价格Pi（i=1，2，……N）。
计算结果四舍五入至小数点后两位。
如果无法到达目的地，则输出“No Solution”。
输入格式第一行为4个实数D1、C、D2、P与一个非负整数N；接下来N行，每行两个实数Di、Pi。
输出格式如果可以到达目的地，输出一个实数（四舍五入至小数点后两位），表示最小费用；否则输出“No Solution”（不含引号）。
样例输入275.6 11.9 27.4 2.8 2102.0 2.9220.0 2.2样例输出26.95思路:是找在最大行驶距离内寻找比当前便宜的加油站,然后判断是否能一次到达,不能的话先加满,然后一个一个判断直到剩下的油量不足到下一个加油站就加油，加适量。
于是有以下2 situations：1.这个站点j 就是pos再细分两种情况：1.从pos就可以走到终点于是我们把油加到刚好到达终点即可cost += ((d[i] - d[pos]) / d2 - remain)*p[pos];就得到了最后答案。
remain是当前剩余的油2.从pos不能一把走到终点于是，从当前位置走，走到哪里加油都不够在pos这里加油划算。
所以加满。
2.这个站点j 是在pos后面的某个站点也有两种情况1.当前剩余的油remain不够走到j于是我们，把油加来刚好能够走到j就行了。
（因为j这里好好便宜！）2.剩余的油remain足够，直接开过去就行了。
########具体操作见如下代码1.#include<iostream>2.#include<algorithm>3.#include<iomanip>ing namespace std;5.double d[10000], p[10000]; //出发点每升汽油的价格p6.int main()7.{8.ios::sync_with_stdio(false); //取消cin在stdin上的同步，增加cin的读取效率9.double d1, c, d2;10.int n; //沿途油站数目11.cin >> d1 >> c >> d2 >> p[0] >> n;12.d[n + 1] = d1; //第n个油站后即为最后的站点13.for (int i = 1; i <= n; i++) //输入每一个油站离出发点的距离以及每个站点汽油的价格14.{15.cin >> d[i] >> p[i];16.}17.int pos = 0;18.double remain = 0, cost = 0;19.do20.{21.bool found = false; //判定能不能到达22.for (int i = pos + 1; i <= n + 1 && d[i] <= d[pos] + c*d2; i++) //循环判断加满油能不能到达下一个加油站23.{24.if (p[i] < p[pos]) //判断下个站点汽油的价格是不是比这个pos站点汽油的价格小25.{26.if (d[pos] + remain*d2 >= d[i]) //若是剩余的油足够，刚好开过去27.{28.remain -= (d[i] - d[pos]) / d2; //剩余的油减少，减少量就是从一个站点到下一个站点用到的油29.}30.else //剩余的油不够31.{32.cost += ((d[i] - d[pos]) / d2 - remain)*p[pos]; //还需要加的油花费的价钱，不用加满33.remain = 0; //到达下一个站点恰好没油了，所以剩余汽油量清034.}35.pos = i;36.found = true;37.break;38.}39.}40.if (!found)41.{42.cost += (c - remain)*p[pos]; //不能到达前花费了多少钱43.remain = c - (d[pos + 1] - d[pos]) / d2; //还剩多少油44.if (remain >= 0) pos++; //小于0，油根本不够到达下一个站点，大于0，代表可以去下一个加油站45.else46.{47.cout << "No Solution";48.return 0;49.}50.}51.} while (pos <= n); //循环条件：没到达终点52.cout.setf(ios::fixed); //以定点形式显示浮点数53.cout << setprecision(2) << cost;54.}。
算法_汽车加油问题
算法分析与设计实验报告实验名称：汽车加油问题实验日期：学生姓名：学生学号：一、实验目的一辆汽车加满油后可行驶nkm。
旅途中有若干加油站。
设计一个有效算法，指出应在哪些加油站停靠加油，使沿途加油次数最少。
对于给定的n和k个加油站位置，计算最少加油次数。
二、实验环境Windows7 + Visual Studio 2010三、实验内容1.设计思路利用贪心算法每次使加油前行驶距离最大，一旦剩余油量不够行驶下一个加油站，就将油加满，从而最终到达目的地。
2.相关模块#include<iostream>using namespace std;void main(){int n, //加满油能走的距离k; //加油站个数cin >> n >> k;int *dist = new int [k+1]; //被加油站分割出的k+1段路程的长度for (int i = 0; i <= k; ++i)cin >> dist[i];int petrol = n, //剩下油量count = 0; //加油次数//判断是否有Solution, 该步可以被合并for (int i = 0; i <= k; ++i){if (dist[i] > n)cout << "No Solution" << endl;}for (int i = 1; i <= k; ++i){//跑不完这段距离, 需要加油了if (dist[i] > petrol){++count;petrol = n - dist[i];}//还有油能到达下一站elsepetrol -= dist[i];}cout << count << endl;system("pause");}四、实验结果分析及结论。
贪心算法实验报告
贪心算法实验报告实验报告题目实验四贪心算法开课实验室:数学实验室指导老师:韩逢庆时间:2011.12 学院:理学院专业:信息与计算科学班级:2009级2班姓名:古月学号:09180230一、实验目的1(加深学生对贪心算法设计方法的基本思想、基本步骤、基本方法的理解与掌握;2(提高学生利用课堂所学知识解决实际问题的能力;3(提高学生综合应用所学知识解决实际问题的能力。
二、实验内容题目见P143:4-16,4-23.三、实验要求(1)用分治法求解最少加油次数和最少硬币个数问题;(2 )再选择自己熟悉的其它方法求解本问题;(3)上机实现所设计的所有算法;四、实验过程设计(算法设计过程)(1) 最少加油次数实验题目一辆汽车加满油以后可以行使n公里，旅途中有若干个加油站，设计一个有效算法，指出应在哪些加油站停靠加油，使沿路加油次数最少。
并证明算法能产生一个最优解。
过程设计贪心算法总是作出在当前看来最好的选择。
也就是说贪心算法并不从整体最优考虑，它所作出的选择只是在某种意义上的局部最优选择。
当然，希望贪心算法得到的最终结果也是整体最优的。
虽然贪心算法不能对所有问题都得到整体最优解，但对许多问题它能产生整体最优解。
比如说最少加油次数的问题。
在这个算法中，我采用的贪心算法的策略。
首先人机互动的设定加满油以后最长能够行使的距离，然后输入了各个站点之间的距离，在程序的设计中，首先检查了程序的可行性。
要是遇到当某两个站点之间的距离大于汽车一次加油以后所能够行使的最大距离时，我们认为此问题是不可行的。
这个在实际情况中也是很容易理解的。
然后在满足可行性条件下，依次采用贪心算法对问题得以实现。
采用s这个来保存现在车里面留下的油，当此时留下的有能够行驶完这一站点到下一站点之间的距离是，在这一站点的时候就不加油。
但是若不能行使完这一段路程的时候，就加满油。
核心算法如下:for(i=0,s=0;i<n;i++){s=s+a[i];if(s>n){sum++;s=a[i];}}(2) 最少硬币个数问题实验题目考虑下面的用最少硬币个数找出n分钱的问题:当使用2角5分，1角，5分和1分四种硬币面值时，设计一个找n分钱的贪心算法，并证明算法能产生最优解。
汽车加油问题
汽车加油问题
1.题目：
汽车加油问题：一辆汽车加满油后可行驶n 公里。
旅途中有若干个加油站。
设计一个有效算法，指出应在哪些加油站停靠加油，使沿途加油次数最少。
2.算法步骤：
1.请求输入数组并规定格式以及代表意义。
2.以字符串形式读取数组并初始化数组。
3.建立循环求距离之和并判断是否需要加油，如果需要继续
执行否则停止程序。
4.建立循环判断当前油量是否足够到达下一个加油站，如果
不够则输出当前加油站的序号并刷新油量为最大油量，如果足够则仅刷新油量进入下一次循环。
3.源代码：
package汽车加油问题贪心;
import class Greedy {
public static void main(String[] args) {
"请输入一个数组，数组元素依此表示：汽车满油量行驶距离、距第一个加油站的距离、各个加油站之间的间距");
"(注意加油站距离不得大于最大行驶距离)");
Scanner in=new Scanner;
int f=0,b=0,c=0;
String h=();
2.。
贪心算法Tsp实习报告1
浙江农林大学信息工程学院课程实习报告课程名称：数据结构实习班级：电信****班题目： TSP问题的贪心算法组长： ******* 成员： ******* 指导教师： *******2014年6月17 日目录1.课程实习目的 (1)1.1贪心算法实习的目的 (1)1.2TSP问题的解决及贪心算法的应用 (1)1.3贪心算法的概念 (1)2.课程实习题目描述和要求 (1)2.1TSP问题介绍 (1)2.2贪心算法的特性 (2)2.2.1贪心算法的特性： (2)2.2.2贪心算法的缺陷 (2)2.3关于贪心算法的备注 (2)3.课程实习报告内容 (2)3.1了解并掌握贪心算法 (2)3.2设计内容 (3)3.2.1问题描述 (3)3.2.2设计思想 (3)3.3需求分析 (3)3.3.1程序的功能： (3)3.3.2输入输出的要求 (4)3.4贪心算法解决TSP问题的流程图 (4)3.5贪心算法解决TSP问题的步骤 (5)4.总结 (5)5.任务分配 (5)1.课程实习目的1.1贪心算法实习的目的此次实习通过贪心算法来解决TSP问题。
假设有n个城市，任意两个城市之间都有路径相通，并设第i个城市与第j个城市之间的距离为Dij，求从某个城市出发经过所有城市并且只经过一次又回到原点的都短距离。
首先，本文运用Visual C++集成开发环境将贪心算法编程实现，并解决TSP问题。
然后通过改变各个参数的值来观察计算结果，接着对运算结果的进行对比分析，从而验证各个参数对贪心算法的影响。
1.2TSP问题的解决及贪心算法的应用旅行商问题(Traveling Salesman Problem, TSP),是一个著名的组合优化问题，该类问题具有非常广泛的运用背景。
如物流的调度问题、数控机床上的最优钻孔路线的选取、电路板的焊接都属于旅行商问题。
因此旅行商问题受到了各方面的关注，有效解决TSP问题在计算理论和实际应用上都有很高的价值。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
计算机算法与分析
设计报告
班级：信管一班信管二班
姓名（学号）：赵立贺(060340219) 赵艳（060340114）刘辉（060340125）王勇（060340116）万玉琪（060340213）刘旺（060340205）指导教师：赵晓峰姚天祥
设计地点：信息系统实验室
信息管理系
2008年12月13日
一、实验名称：
用贪心算法、回溯算法、动态规划等解决汽车加油次数最少问题。
二、实验目的：
课程设计是《计算机算法与设计》课程不可缺少的重要实践性环节。
通过实践教学，要达到以下目的：
（1）使学生掌握线性表、栈、队列、串、树、二叉树、图、集合等各种典型抽象数据类型的数学模型及其所支持基本运算的实现方法；
（2）使学生掌握以抽象数据类型为模块的面向对象程序设计方法；
（3）使学生提高对实际问题的分析、设计和实现能力；
（4）为学生后续课程的学习及课程设计打下坚实的实践基础。
三、使用的策略：
贪心算法、回溯算法等。
四、实验内容：
（一）问题描述
一辆汽车加满油后可以行驶N千米。
旅途中有若干个加油站。
指出若要使沿途的加油次数最少，设计一个有效的算法，指出应在那些加油站停靠加油。
给出N，并以数组的形式给出加油站的个数及相邻距离，指出若要使沿途的加油次数最少，设计一个有效的算法，指出应在那些加油站停靠加油。
要求：算法执行的速度越快越好。
（二）问题分析（前提行驶前车里加满油）
对于这个问题我们有以下几种情况：设加油次数为k，每个加油站间距离为a[i]；i=0，1，2，3……n
1.始点到终点的距离小于Ｎ，则加油次数k=0；
2.始点到终点的距离大于N，
A 加油站间的距离相等，即ａ[i]=a[j]=L=N，则加油次数最少k=n；
B 加油站间的距离相等，即ａ[i]=a[j]=L>N，则不可能到达终点；
C 加油站间的距离相等，即ａ[i]=a[j]=L<N，则加油次数k=n/N(n%N==0)或k=[n/N]+1(n%N！=0)；
D 加油站间的距离不相等，即ａ[i]！=a[j]，则加油次数k通过以下算法求解。
（三）算法描述
1.贪心算法解决方案
贪心算法的基本思想
该题目求加油最少次数，即求最优解的问题，可分成几个步骤，一般来说，每个步骤的最优解不一定是整个问题的最优解，然而对于有些问题，局部贪心可以得到全局的最优解。
贪心算法将问题的求解过程看作是一系列选择，从问题的某一个初始解出发，向给定目标推进。
推进的每一阶段不是依据某一个固定的递推式，而是在每一个阶段都看上去是一个最优的决策（在一定的标准下）。
不断地将问题实例归纳为更小的相似的子问题，并期望做出的局部最优的选择产生一个全局得最优解。
●贪心算法的适用的问题
贪心算法适用的问题必须满足两个属性：
（１）贪心性质：整体的最优解可通过一系列局部最优解达到，并且每次的选择可以依赖以前做出的选择，但不能依赖于以后的选择。
（２）最优子结构：问题的整体最优解包含着它的子问题的最优解。
●贪心算法的基本步骤
（１）分解：将原问题分解为若干相互独立的阶段。
（２）解决：对于每一个阶段求局部的最优解。
（３）合并：将各个阶段的解合并为原问题的解。
[问题分析]
由于汽车是由始向终点方向开的,我们最大的麻烦就是不知道在哪个加油站加油可以使我们既可以到达终点又可以使我们加油次数最少。
提出问题是解决的开始.为了着手解决遇到的困难,取得最优方案。
我们可以假设不到万不得已我们不加油，即除非我们油箱里的油不足以开到下一个加油站，我们才加一次油。
在局部找到一个最优的解。
却每加一次油我们可以看作是一个新的起点，用相同的递归方法进行下去。
最终将各个阶段的最优解合并为原问题的解得到我们原问题的求解。
加油站贪心算法设计（C）：
include<math.h>
include<studio.h>
int add(int b[ ],int m,int n)
{ //求一个从m到n的数列的和
int sb;
for(int i=m;i<n;i++) sb+=b[i];
return sb;
}
int Tanxin(int a[n], int N) //a[n]表示加油站的个数，N为加满油能行驶的最远距离
{
int b[n]; //若在a[i]加油站加油，则b[i]为1，否则为0
int m=0;
if(a[i]>N) return ERROR; //如果某相邻的两个加油站间的距离大于N，则不能到达终点
if(add(a[i], 0, n)<N)
{ //如果这段距离小于N，则不需要加油
b[i]=0;
return add(b[i],0,n);
}
if(a[i]==a[j]&&a[i]==N)
{ //如果每相邻的两个加油站间的距离都是N，则每个加油站都需要加油
b[i]=1;。