贪心算法实验报告
实验三-贪心算法
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的一棵最小生成树。
实验3贪心算法（定稿）
实验3贪心算法（定稿）第一篇：实验3 贪心算法（定稿）《算法设计与分析》实验报告实验3贪心算法姓名学号班级实验日期实验地点一、实验目的1、掌握贪心算法的设计思想。
2、理解最小生成树的相关概念。
二、实验环境1、硬件环境 CPU：酷睿i5 内存：4GB 硬盘：1T2、软件环境操作系统：Windows10 编程环境：jdk 编程语言：Java三、实验内容：在Prim算法与Kruskal算法中任选一种求解最小生成树问题。
1、你选择的是：Prim算法2、数据结构（1）图的数据结构——图结构是研究数据元素之间的多对多的关系。
在这种结构中，任意两个元素之间可能存在关系，即结点之间的关系可以是任意的，图中任意元素之间都可能相关。
图形结构——多个对多个，如（2）树的数据结构——树结构是研究数据元素之间的一对多的关系。
在这种结构中，每个元素对下(层)可以有0个或多个元素相联系，对上(层)只有唯一的一个元素相关，数据元素之间有明显的层次关系。
树形结构——一个对多个，如3、算法伪代码 Prim(G,E,W)输入：连通图G 输出：G的最小生成树T 1.S←{1};T=∅ 2.While V-S ≠∅ do3.从V-S中选择j使得j到S中顶点的边e的权最小；T←T∪{e}4.S←S∪{j}3、算法分析时间复杂度：O(n)空间复杂度：O(n^2)4、关键代码（含注释）package Prim;import java.util.*;publicclass Main { staticintMAXCOST=Integer.MAX_VALUE;staticint Prim(intgraph[][], intn){ /* lowcost[i]记录以i为终点的边的最小权值，当lowcost[i]=0时表示终点i加入生成树 */ intlowcost[]=newint[n+1];/* mst[i]记录对应lowcost[i]的起点，当mst[i]=0时表示起点i加入生成树 */ intmst[]=newint[n+1];intmin, minid, sum = 0;/* 默认选择1号节点加入生成树，从2号节点开始初始化*/ for(inti = 2;i<= n;i++){/* 标记1号节点加入生成树 */ mst[1] = 0;/* n个节点至少需要n-1条边构成最小生成树 */ for(inti = 2;i<= n;i++){/* 找满足条件的最小权值边的节点minid */ for(intj = 2;j<= n;j++){/* 输出生成树边的信息:起点，终点，权值 */System.out.printf(“%c1, minid + 'A''A' + 1;intj = chy-'A' + 1;graph[i][j] = cost;graph[j][i] = cost;for(intj = 1;j<= n;j++){ } graph[i][j] = MAXCOST;} } System.out.println(”Total:"+cost);} }5、实验结果（1）输入（2）输出最小生成树的权值为：生成过程：(a)(b)(d)(e)(c)四、实验总结（心得体会、需要注意的问题等）这次实验，使我受益匪浅。
贪心算法解活动安排实验报告
实验3 贪心算法解活动安排问题一、实验要求1．要求按贪心法求解问题；2．要求读文本文件输入活动安排时间区间数据；3．要求显示结果。
二、实验仪器和软件平台仪器：带usb接口微机软件平台：WIN-XP + VC++6.0三、源程序#include "stdafx.h"#include<stdio.h>#include<stdlib.h>#include<algorithm>#define N 50#define TURE 1#define FALSE 0int s[N];/*开始时间*/int f[N];/*结束时间*/int A[N];/*用A存储所有的*/int Partition(int *b,int *a,int p,int r);void QuickSort(int *b,int *a,int p,int r);void GreedySelector(int n,int *s,int *f,int *A);int main(){int n=0,i;while(n<=0||n>50){printf("\n");printf("请输入活动的个数,n=");scanf("%d",&n);if(n<=0) printf("请输入大于零的数!");else if(n>50) printf("请输入小于50的数!");}printf("\n请分别输入开始时间s[i]和结束时间f[i]:\n\n");for(i=1;i<=n;i++){printf("s[%d]=",i,i);scanf("%d",&s[i]);printf("f[%d]=",i,i);scanf("%d",&f[i]);printf("\n");}QuickSort(s,f,1,n); //按结束时间非减序排列printf("按结束时间非减序排列如下:\n"); /*输出排序结果*/ printf("\n 序号\t开始时间结束时间\n");printf("-------------------------\n");for(i=1;i<=n;i++)printf(" %d\t %d\t %d\n",i,s[i],f[i]);printf("-------------------------\n");GreedySelector(n,s,f,A);//贪心算法实现活动安排printf("安排的活动序号依次为：");for(i=1;i<=n;i++){if(A[i])printf("\n%d %d-->%d",i,s[i],f[i]);}printf("\n");system("pause");return 0;}//快速排序void QuickSort(int *b,int *a,int p,int r){int q;if(p<r)q=Partition(b,a,p,r);QuickSort(b,a,p,q-1);/*对左半段排序*/ QuickSort(b,a,q+1,r);/*对右半段排序*/ }}//产生中间数int Partition(int *b,int *a,int p,int r){int k,m,y,i=p,j=r+1;int x=a[p];y=b[p];while(1){while(a[++i]<x);while(a[--j]>x);if(i>=j)break;else{k=a[i];a[i]=a[j];a[j]=k;m=b[i];b[i]=b[j];b[j]=m;}a[p]=a[j];b[p]=b[j];a[j]=x;b[j]=y;return j;}//贪心算法实现活动安排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; }}四、运行结果五、实验小结贪心算法总是做出在当前看来最好的选择，也就是说贪心算法并不从整体最优考虑，它所作出的选择只是在某种意义上的局部最优选择。
贪心算法 实验报告
贪心算法实验报告贪心算法实验报告引言：贪心算法是一种常用的算法设计策略，它通常用于求解最优化问题。
贪心算法的核心思想是在每一步选择中都选择当前最优的解，从而希望最终能够得到全局最优解。
本实验旨在通过实际案例的研究，探索贪心算法的应用和效果。
一、贪心算法的基本原理贪心算法的基本原理是每一步都选择当前最优解，而不考虑整体的最优解。
这种贪婪的选择策略通常是基于局部最优性的假设，即当前的选择对于后续步骤的选择没有影响。
贪心算法的优点是简单高效，但也存在一定的局限性。
二、实验案例：零钱兑换问题在本实验中，我们以零钱兑换问题为例，来说明贪心算法的应用。
问题描述：假设有不同面值的硬币，如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.实验评价：我使用了实际需找金额与贪心算法计算得到的找零金额的差值来评估算法的准确性，并统计了算法的时间复杂度。
实验结果从多组实验结果中可以观察到，贪心算法在大部分情况下给出了正确的找零金额，并且算法的时间复杂度较低。
结果分析贪心算法在找零钱问题中的应用是合理的。
每次选择面额最大的硬币进行找零，可以快速接近最优解，并且相对其他算法具有较低的时间复杂度。
数据优化算法实验报告
数据优化算法实验报告1. 引言数据优化算法是在处理大规模数据时的重要工具。
随着数据量的增大和计算需求的增加，需要寻找更加高效的算法来处理和优化数据。
本实验旨在研究并比较两种常见的数据优化算法：贪心算法和动态规划算法。
通过实验比较它们在不同场景下的优化效果和性能。
2. 贪心算法贪心算法是一种简单而直观的算法。
其基本思想是每次选择局部最优解，并希望通过局部最优解的组合来达到全局最优解。
贪心算法能够在很短的时间内找到一个近似最优解，但不能保证一定得到最优解。
本实验中，我们以背包问题为例，使用贪心算法进行优化。
背包问题是在给定背包容量的情况下，选择一些物品放入背包，使得放入背包的物品总价值最大化。
贪心算法的核心思想是每次选择单位重量价值最大的物品放入背包。
实验结果表明，贪心算法在小规模问题上有着较好的效果，但在大规模问题上有可能得不到最优解。
这是因为贪心算法只考虑了当前局部最优解，没有考虑到全局最优解的可能性。
3. 动态规划算法动态规划算法是一种通过分别解决子问题并将解决方案合并来解决复杂问题的方法。
与贪心算法相比，动态规划算法更加追求全局最优解，但也需要更多的计算时间和空间。
同样以背包问题为例，使用动态规划算法进行优化。
动态规划算法的核心思想是将问题分解为子问题，通过递归地求解子问题的最优解，最后合并子问题的解来获得全局最优解。
在背包问题中，动态规划算法采用二维数组来存储每个子问题的最优解。
实验结果表明，动态规划算法能够在较短的时间内得到全局最优解，但对于大规模问题，算法的时间和空间复杂度会显著增加。
4. 实验对比和讨论通过实验对比，我们可以看到贪心算法和动态规划算法在不同场景下的优化效果和性能有所不同。
对于小规模问题，贪心算法能够快速计算得到一个近似最优解，并能在较短的时间内完成计算。
然而，贪心算法不能保证一定得到全局最优解，可能会得到次优解。
对于大规模问题，动态规划算法能够在较短的时间内得到全局最优解。
《算法设计与分析》课程实验报告 (贪心算法(一))
《算法设计与分析》课程实验报告实验序号：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. 理解贪心算法的基本原理和应用场景；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算法：从任意一个顶点开始，逐步添加边，直到所有顶点都被包含在生成树中。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
福建工程学院计算机与信息科学系实验报告12345篇二：北邮算法作业贪心算法实验报告第三次算法作业（贪心算法）姓名：吴迪班级：08211312学号：08211488班内序号 15 摘要：本文为完成作业problem1，problem3，problem4，problem5的四道贪心算法题。
备注：所有后缀为_ex的可执行文件为文件输入输出模式的程序，比如problem1_ex.exe （所有算法实现代码承诺为本人自己编写并且截图为实际有效截图，所有程序均通过dev-c++编译器实际测试可以运行）problem 1 特殊的01背包（原算法分析题4-3）问题描述：01背包是在n件物品取出若干件放在空间为c的背包里，每件物品的体积为w1，w2??wn，与之相对应的价值为p1,p2??pn，并取得最大价值。
普通的01背包中物品的重量和价值没有明确的关系，这里定义一种特殊的01背包：向背包中放入的物品的价值和体积成反比，也就是价值越高，体积越小，注意这里物品价值和体积的乘积并不是固定值。
例如：如下的物品满足这个“特殊的01背包”,5件物品: 物品1,价值 v=6,体积w=20 物品2,价值 v=1,体积w=60 物品3,价值 v=20,体积w=3 物品4,价值 v=15,体积w=15 物品5,价值 v=99,体积w=1 假如我有一个容量为c的背包,c=20，那么选择物品3、4、5可以获得最大价值134。
输入：首先是一个整数t,代表测试数据的组数。
每组测试数据首先是两个正整数n和c，n代表物品的个数，c代表背包的最大容积。
然后有n行整数，每行有两个整数，分别代表物品的价值v和体积w。
t的范围是(1-100),n的范围是(1-100000),c、v、w的范围不超过四字节的int型。
输出：首先输出测试数据的组号，例如第一组的组号为“case 1:”，占一行。
然后是一个整数，代表可以取得的最大价值，占一行。
sample input:55 206 201 6020 315 1599 1 1 1100 100 5 1092 17101 1093 18109 387 26 10 2296 1396 1889 17106 171 4086 2783 3178 31106 7 68 46 15 1954 55103 782 3375 3599 1094 2153 5695 1691 2039 6982 2854 54110 242 6765 46 sample output:case 1:134case 2: case 3:109case 4:212case 5:312 问题分析:本题是特殊的01背包问题，由于其价值和重量的反比规律易证明贪婪算法的有效性，故本题可以采用贪心算法求解，即每次优选最轻物品也是最大价值物品。
源代码：（仅附文件输入输出版本，标准输入输出版本见cpp代码文件）#include<iostream>#include<fstream>using namespace std;int greedy_calculate(int* v,int* w,const int n,const int c); int main(){//input int t; //test group num 1-100 int n; //object num 1-100000 int c; //capacityint *v;int *w;fstream in;fstream out;in.open(problem1_input.txt,ios::in); out.open(problem1_output.txt,ios::out); in >> t; if(t>100||t<1)out<<error input of t!<<endl; for(int i=0;i<t;i++){in >> n;if(n>100000||n<1)out<<error input of n!<<endl; in >> c; if(c<=0)out<<error input of c!<<endl; v=new int [n]; w=new int [n];for(int j=0;j<n;j++){in >> v[j];in >> w[j];} //outputout<<case <<i<<:<<endl; out<<greedy_calculate(v,w,n,c)<<endl; //safetydelete v;delete w;}in.close();out.close();system(pause);return 0;}int greedy_calculate(int* v,int* w,const int n,const int c) { unsigned int least_weight=-1; int lw_num=0; int count=0;int total_value=0;int total_weight=0;bool *x;x=new bool [n];for(int i=0;i<n;i++){x[i]=0;}while(total_weight<=c&&count<n){ least_weight=-1;for(int i=0;i<n;i++){if(x[i]==0){if(w[i]<least_weight){least_weight=w[i];lw_num=i; } }}x[lw_num]=1;total_value+=v[lw_num];total_weight+=w[lw_num];count++;}if(total_weight>c){total_value-=v[lw_num];total_weight-=w[lw_num]; } delete x;return total_value;}运行截图篇三：算法实验报告贵州大学计算机科学与技术学院计算机科学与技术系上机实验报告贵州大学计算机科学与技术学院计算机科学与技术系上机实验报告篇四：贪心算法解汽车加油问题实验报告一、实验名称：用贪心算法、回溯算法、动态规划等解决汽车加油次数最少问题。
二、实验目的：课程设计是《计算机算法与设计》课程不可缺少的重要实践性环节。
通过实践教学，要达到以下目的：（1）使学生掌握线性表、栈、队列、串、树、二叉树、图、集合等各种典型抽象数据类型的数学模型及其所支持基本运算的实现方法；（2）使学生掌握以抽象数据类型为模块的面向对象程序设计方法；（3）使学生提高对实际问题的分析、设计和实现能力；（4）为学生后续课程的学习及课程设计打下坚实的实践基础。
三、使用的策略：贪心算法、回溯算法等。
四、实验内容：（一）问题描述一辆汽车加满油后可以行驶n千米。
旅途中有若干个加油站。
指出若要使沿途的加油次数最少，设计一个有效的算法，指出应在那些加油站停靠加油。
给出n，并以数组的形式给出加油站的个数及相邻距离，指出若要使沿途的加油次数最少，设计一个有效的算法，指出应在那些加油站停靠加油。
要求：算法执行的速度越快越好。
（二）问题分析（前提行驶前车里加满油）对于这个问题我们有以下几种情况：设加油次数为k，每个加油站间距离为a[i]；i=0，1，2，3……n1.始点到终点的距离小于ｎ，则加油次数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<iostream>using namespace std;int main(){int i,j,n,k,l[10],c=0,m=0; bool a[10];cout<<请输入加满油后可行驶的距离（km）： ; cin>>n;cout<<请输入途中所经的加油站个数： ; cin>>k;cout<<请输入每相邻两个加油站之间的距离： <<endl; for(i=0;i<=k;i++)cin>>l[i];for(i=0;i<=k;i++)a[i]=false;for(j=0;j<=k;j++){m+=l[j];if(m+l[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<<个加油站加油了! ^_^<<endl; cout<<最少加油次数为： <<c<<endl; return 0; }贪心算法正确性证明：贪心选择性质所谓贪心选择性质是指所求问题的整体最优解可以通过一系列局部最优的选择，即贪心选择来达到。