贪心算法解决活动安排问题报告
贪心法解活动安排问题(计算机算法设计与分析)
实验报告
课程名称：算法设计与分析实验名称：贪心法解活动安排问题任课教师：专业：计算机科学与技术
班级: 20xx 级x班学号：
姓名：完成日期： 20xx年x月xx日
五、实验总结
在做本实验之前，自己看了课本上所列举的贪心法解活动安排问题的代码，代码很简单，很容易理解，于是就按课本的代码实现。
通过几个测试用例测试发现结果不对，后来发现自己忘了进行贪心法的一个前提条件，事先没有按各个活动结束时间对所有活动进行非递减排序，所以才会导致结果错误。
经过修正后，自己真正理解了贪心法解活动安排问题的原理，重新完成本次实验内容也是很顺利，在编程方面没有遇到什么困难。
贪心法解活动安排问题(计算机算法设计与分析)
实验报告
课程名称：算法设计与分析实验名称：贪心法解活动安排问题任课教师：专业：计算机科学与技术
班级: 20xx 级x班学号：
姓名：完成日期： 20xx年x月xx日
五、实验总结
在做本实验之前，自己看了课本上所列举的贪心法解活动安排问题的代码，代码很简单，很容易理解，于是就按课本的代码实现。
通过几个测试用例测试发现结果不对，后来发现自己忘了进行贪心法的一个前提条件，事先没有按各个活动结束时间对所有活动进行非递减排序，所以才会导致结果错误。
经过修正后，自己真正理解了贪心法解活动安排问题的原理，重新完成本次实验内容也是很顺利，在编程方面没有遇到什么困难。
贪心算法解活动安排实验报告
实验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; }}四、运行结果五、实验小结贪心算法总是做出在当前看来最好的选择，也就是说贪心算法并不从整体最优考虑，它所作出的选择只是在某种意义上的局部最优选择。
Java实验贪心算法,包含普通背包和贪心算法中的活动安排
实验报告7课程数据结构与算法实验名称贪心策略第页班级11计本学号105032011130 姓名风律澈实验日期：2013年4月15日报告退发(订正、重做)一、实验目的掌握贪心策略的原理和应用。
二、实验环境1、微型计算机一台2、WINDOWS操作系统，Java SDK，Eclipse开发环境三、实验内容必做题：1、编写程序，求解普通背包问题，要求输出背包所能容纳物品的最大价值(最优值)，及与该最大价值相应的装入背包中的每件物品信息。
2、设有n个活动的集合E={1,2,…,n}，其中每个活动都要求使用同一资源，如演讲会场等，而在同一时间内只有一个活动能使用这一资源。
每个活动i都有一个要求使用该资源的起始时间si和一个结束时间fi,且si <fi 。
如果选择了活动i，则它在半开时间区间[si, fi)内占用资源。
若区间[si, fi)与区间[sj, fj)不相交，则称活动i与活动j是相容的。
也就是说，当si≥fj或sj≥fi时，活动i与活动j 相容。
编写程序，在所给的活动集合中选出最大的相容活动子集合。
要求输出活动数量(即最优值)和最大相容活动子集中的每个活动(即最优解)。
四、实验步骤和结果(附上代码和程序运行结果截图)1、普通背包问题//goods.classpublic class goods implements Comparable<goods> {private static int ids=1;private int id;private int weight;private int value;private int use;//初始化对象//public goods(int w,int v){super();id=ids++;weight=w;value=v;use=0;}//获取输出值//public float getVW(){return this.value/this.weight;}public int getw(){return this.weight;}public int getv(){return this.value;}public int getuse(){return e;}//输出设置//public void setuse(int u){e=u;}//方法//public int compareTo(goods o){if(this.value*o.weight>o.value*this.weight) return-1;//使用交叉相乘的方法避免除法，a/b?c/d=ad?bcif(this.value*o.weight<o.value*this.weight) return 1;return 0;}public String toString(){return"物品编号"+this.id+" 物品重量"+this.weight+" 物品价值"+this.value+" 物品使用情况"+e;}}//NormalBagimport java.util.ArrayList;import java.util.PriorityQueue;public class NormalBag {/*** @param args*/public static void main(String[] args) {// TODO Auto-generated method stub//初始化队列//PriorityQueue<goods> pq=initpq();//定义暂存结果数组//ArrayList<goods> place=new ArrayList<goods>();//初始化背包值//int c=10;//背包当前容量int v=0;//背包当前价值//开始放入物品//goods t;//设定暂存记录变脸while(true){//设定借宿条件//if(c==0)break;if(pq.isEmpty())break;//取出替换元素//t=pq.poll();//开始比较//if(t.getw()<=c){v+=t.getv();t.setuse(t.getw());c-=t.getw();}else{v+=c*t.getVW();t.setuse(c);c=0;}place.add(t);}//输出结果//System.out.println(v);System.out.println(place);}//创建队列元素private static PriorityQueue<goods> initpq() {// TODO Auto-generated method stubPriorityQueue<goods>pq=new PriorityQueue<goods>();pq.offer(new goods(2,6));pq.offer(new goods(2,3));pq.offer(new goods(6,5));pq.offer(new goods(5,4));pq.offer(new goods(4,6));return pq;}}2.活动安排问题public class GreedySelector {/*** @param args*/public static void main(String[] args) {// TODO Auto-generated method stub//初始化//int s[]={1,3,0,5,3,5,6,8,8,2,12};//开始时间数组，已排序int f[]={4,5,6,7,8,9,10,11,12,13,14};//结束时间数组，已排序int a[]=new int[s.length];//定义标记选择过的活动数组int count=0;//活动数量计数器//开始选择//greedyselector(s,f,a);//输出//for(int i=0;i<s.length;i++){//输出活动序号if(a[i]==1){System.out.print("活动"+(i+1)+" ");count++;}}System.out.println();System.out.print("活动总数量为："+count);//输出总活动数量}private static void greedyselector(int[] s, int[] f, int[] a) { // TODO Auto-generated method stub//贪心选择为，先结束的互动优先，这样剩余的时间达到最大，安排活动最多//int n=s.length-1;a[0]=1;//最先的那个最优int j=0;for(int i=1;i<=n;i++){if(s[i]>=f[j]){a[i]=1;j=i;}elsea[i]=0;}}}五、实验总结(本次实验完成的情况，心得体会)。
第4章 贪心算法(1)活动安排问题
4.1 活动安排问题
活动安排问题是可以用贪心算法有效求解的很 好例子。
该问题要求高效地安排一系列争用某一公共资 源的活动，使得尽可能多的活动能兼容地使用 公共资源。
4
问题描述
设有n个活动的集合E={1, 2, …, n}，其中每个 活动都要求使用同一资源，而在同一时间内只 有一个活动能使用这一资源。
2
贪心算法
例2：若上述硬币面值改为：
一角一分、五分和一分 现在要找给顾客一角五分钱，如何给出硬币？ 答案：错：1个一角一分，4个一分
对：3个五分
虽然贪心算法不能对所有问题都得到整体最优 解，但对许多问题它能产生整体最优解。
在一些情况下，即使贪心算法不能得到整体最 优解，其最终结果却是最优解的很好的近似解。
ቤተ መጻሕፍቲ ባይዱ17
0-1背包问题
给定n种物品和一个背包。物品i的重量是wi， 其价值为vi，背包的容量为c。应如何选择装 入背包的物品，使得装入背包中物品的总价 值最大?
说明：在选择装入背包的物品时，对每种物 品i只有2种选择，即装入背包或不装入背包。 不能将物品i装入背包多次，也不能只装入部 分的物品i。
16
3、贪心算法与动态规划算法的 差异
贪心算法和动态规划算法都要求问题具有最 优子结构性质，这是两类算法的一个共同点。
对于具有最优子结构的问题应该选用贪心算 法还是动态规划算法求解?
是否能用动态规划算法求解的问题也能用贪 心算法求解?
下面研究2个经典的组合优化问题，并以此 说明贪心算法与动态规划算法的主要差别。
每个活动i都有一个要求使用该资源的起始时 间si和一个结束时间fi,且si <fi 。
5
问题描述
如果选择了活动i，则它在半开时间区间[si, fi) 内占用资源。若区间[si, fi)与区间[sj, fj)不相交， 则称活动i与活动j是相容的。也就是说，当si≥fj
贪心算法（会场安排问题、区间选点）
贪⼼算法（会场安排问题、区间选点）学习算法课程之后的第⼀次记录，渐渐的，程序设计考虑的因素增多，程序=数据结构+算法，这个等式让我深有体会。
从开始简单的C++编程，再到选择合适数据结构，现在需要更进⼀步，从算法层次上考虑程序执⾏的效率。
我对算法的理解是⽤更少的开销获得更优的执⾏效果。
分治法、动态规划在此之前没有记录下来，学到贪⼼算法的时候，觉得需要总结⼀下学过的东西，也能更好的理解。
动态规划的设计，要满⾜最优⼦结构性质和重叠⼦问题，采⽤⾃底向上的策略，计算出最优值，找到整体最优解。
这个过程有时候挺难的，主要在写出递归式，要⾃底向上填表。
贪⼼策略有点像动态规划，但在⼀些⽅⾯是不同的，有时候贪⼼算法的思想更容易想到。
它要满⾜⼦问题最优⽽得到整体最优？两个条件：最优⼦结构性质和贪⼼选择性质。
满⾜贪⼼选择性质⼀定满⾜最优⼦结构性质，⽽满⾜最优⼦结构性质不⼀定满⾜贪⼼选择性质，⽐如背包问题可以⽤贪⼼算法解决，⽽0-1背包问题只能⽤动态规划。
典型的贪⼼问题活动安排，有n个活动，给出开始时间和结束时间，要尽可能安排多的活动（时间互相不冲突）。
解决这个问题正确的贪⼼思想是以每个活动结束时间为⽐较变量，按结束时间升序排好活动次序，接着就进⾏⽐较选择。
⽽会场安排问题与活动⼜有些不同之处，下⾯是我的解题过程。
7-2 会场安排问题 (20 分)假设要在⾜够多的会场⾥安排⼀批活动，并希望使⽤尽可能少的会场。
设计⼀个有效的贪⼼算法进⾏安排。
（这个问题实际上是著名的图着⾊问题。
若将每⼀个活动作为图的⼀个顶点，不相容活动间⽤边相连。
使相邻顶点着有不同颜⾊的最⼩着⾊数，相应于要找的最⼩会场数。
）输⼊格式:第⼀⾏有 1 个正整数k，表⽰有 k个待安排的活动。
接下来的 k⾏中，每⾏有 2个正整数，分别表⽰ k个待安排的活动开始时间和结束时间。
时间以 0 点开始的分钟计。
输出格式:输出最少会场数。
输⼊样例:51 2312 2825 3527 8036 50输出样例:3#include<iostream>#include<algorithm>using namespace std;struct node {int begin;int end;int flag;//标记该活动是否被安排，0表⽰未安排，1表⽰已安排}t[10001];int cmp(const node &a,const node &b)//⽐较规则：以结束时间升序排列{return a.end<b.end;}int main(){int i,j,n;node temp;cin>>n;for(i=0;i<n;i++){cin>>t[i].begin>>t[i].end;t[i].flag=0;}sort(t,t+n,cmp);int sum=0;//总共需要的会场数量for(i=0;i<n;i++)//⽅法2{if(!t[i].flag)//找到未安排的活动，进⾏场地安排{sum++;int p=i;for(j=p+1;j<n;j++)//当前活动结束时间与下⼀个活动开始不相交，则安排到同⼀个会场{if(t[p].end<=t[j].begin&&!t[j].flag){p=j;t[j].flag=1;}}t[i].flag=1;}}cout<<sum;return0;}View Code贪⼼策略为：把尽可能多的时间互不冲突的活动安排到⼀个会场，若活动时间交叉，则在安排到另⼀个会场。
《算法设计与分析》课程实验报告 (贪心算法(一))
《算法设计与分析》课程实验报告实验序号：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算法：从任意一个顶点开始，逐步添加边，直到所有顶点都被包含在生成树中。
贪心算法解决活动安排问题研究
贪心算法解决活动安排问题研究摘要：利用贪心算法解决如何使用最少的资源安排一系列活动。
并证明了贪心算法解决此问题的有效性，且进行了实例验证，并进行了复杂度分析，此算法是解决资源组合规划问题较好的方法。
关键词：贪心算法；java程序；复杂度分析；活动安排问题中图分类号：tp312文献标识码：a文章编号：16727800（2011）012004302基金项目：广西研究生教育创新计划（22m58）作者简介：苏方方（1986-），女，河南商丘人，广西师范大学计算机科学与信息工程学院硕士研究生，研究方向为自然语言处理和算法；张金玲（1986-），女，山东菏泽人，广西师范大学计算机科学与信息工程学院硕士研究生，研究方向为远程教育和算法。
0引言假设要在足够多的会场里安排一批活动，并希望使用尽可能少的会场。
这里就需要选用合适的算法来解决类似的问题。
虽然计算机的计算能力每年都在飞快增加，但是，需要处理的信息量更是呈指数级的增长。
互联网的信息流量在飞快进步，数据量更是达到了前所未有的程度。
无论是三维图形，海量数据处理等都需要极大的计算量。
在网络时代，越来越多的挑战需要靠卓越的算法来解决。
1贪心算法以及贪心算法的基本要素贪心算法是指从问题的初始状态出发，通过若干次的贪心选择而得出最优值(或较优解)的一种解题方法。
并不是从整体上加以考虑，它所做出的选择只是在某种意义上的局部最优解。
贪心算法可以简单描述为：对一组数据进行排序，找出最小值，进行处理，再找出最小值，再处理。
也就是说贪心算法是一种在每一步选择中都采取在当前状态下最好或最优的选择，从而希望得到结果是最好或最优的算法。
贪心算法解题步骤：①从问题的某个初始解出发；②采用循环语句，就根据局部最优策略，得到一个部分解，缩小问题的范围或规模；③将所有部分解综合起来，得到问题的最终解。
另外它也是一种某种度量意义下的最优解的分级处理方法。
对于一个具体的问题，怎么知道是否可用贪心算法来解决问题，以及能否得到问题的一个最优解呢？从许多可以用贪心算法求解的问题中可以看到它们一般具有两个重要的性质：①贪心选择性质；②最优子结构性质。
贪心算法解决活动安排问题报告
1.引言：贪心法是一种改进了的分级处理方法。
用贪心法设计算法的特点是一步一步地进行，每一步上都要保证能获得局部最优解。
每一步只考虑一个数据，它的选取满足局部优化条件。
若下一个数据与部分最优解连在一起不再是可行解时，就不把该数据添加到部分解中，直到把所有数据枚举完，或者不能再添加为止。
这种能够得到某种度量意义下的最优解的分级处理方法称为贪心法。
贪心算法总是做出在当前看来是最优的选择，也就是说贪心算法并不是从整体上加以考虑，它所做出的选择只是在某种意义上的局部最优解，而许多问题自身的特性决定了该题运用贪心算法可以得到最优解或较优解。
2.贪心算法的基本思想及存在问题贪心法的基本思想：从问题的某一个初始解出发逐步逼近给定的目标，以尽可能快的地求得更好的解。
当达到某算法中的某一步不能再继续前进时，算法停止。
1.建立数学模型来描述问题。
2.把求解的问题分成若干个子问题。
3.对每一子问题求解，得到子问题的局部最优解。
4.把子问题的解局部最优解合成原来解问题的一个解。
3.活动安排问题：3.1 贪心算法解决活动安排问题学校举办活动的安排问题是用贪心算法有效求解的一个很好例子。
活动安排问题要求安排一系列争用某一公共资源的活动。
用贪心算法可使尽可能多的活动能兼容的使用公共资源。
设有n个活动的集合｛0，1，2，…，n-1｝，其中每个活动都要求使用同一资源，如会场等，而在同一时间内只有一个活动能使用这一资源。
每个活动i都有一个要求使用该资源的起始时间starti和一个结束时间endi，且starti<endi。
如选择了活动i，则它在半开时间区间[starti,endi）内占用资源。
若区间[starti,endi)与区间[startj,endj)不相交，称活动i与活动j是相容的。
也就是说，当start j≥endi或starti≥endj时，活动i与活动j相容。
活动安排问题就是在所给的活动集合中选出最大的相容子活动集合。
贪心算法实验报告(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）算法源码/**********************单源最短路径问题。
数据结构与算法-贪心算法实验报告
贪心算法实验报告课程数据结构与算法实验名称贪心策略第页班级学号姓名实验日期：2019年9月15日报告退发(订正、重做)一、实验目的掌握贪心策略的原理和应用。
二、实验环境1、微型计算机一台2、WINDOWS操作系统，Java SDK，Eclipse开发环境三、实验内容必做题：1、编写程序，求解普通背包问题，要求输出背包所能容纳物品的最大价值(最优值)，及与该最大价值相应的装入背包中的每件物品信息。
2、设有n个活动的集合E={1,2,…,n}，其中每个活动都要求使用同一资源，如演讲会场等，而在同一时间内只有一个活动能使用这一资源。
每个活动i都有一个要求使用该资源的起始时间si和一个结束时间fi,且si <fi 。
如果选择了活动i，则它在半开时间区间[si, fi)内占用资源。
若区间[si, fi)与区间[sj, fj)不相交，则称活动i与活动j是相容的。
也就是说，当si≥fj或sj≥fi时，活动i与活动j 相容。
编写程序，在所给的活动集合中选出最大的相容活动子集合。
要求输出活动数量(即最优值)和最大相容活动子集中的每个活动(即最优解)。
四、实验步骤和结果(附上代码和程序运行结果截图)1、普通背包问题//goods.classpublic class goods implements Comparable<goods> {private static int ids=1;private int id;private int weight;private int value;private int use;//初始化对象//public goods(int w,int v){super();id=ids++;weight=w;value=v;use=0;}//获取输出值//public float getVW(){return this.value/this.weight;}public int getw(){return this.weight;}public int getv(){return this.value;}public int getuse(){return e;}//输出设置//public void setuse(int u){e=u;}//方法//public int compareTo(goods o){if(this.value*o.weight>o.value*this.weight) return -1;//使用交叉相乘的方法避免除法，a/b?c/d=ad?bcif(this.value*o.weight<o.value*this.weight) return 1;return 0;}public String toString(){return"物品编号"+this.id+" 物品重量"+this.weight+" 物品价值"+this.value+" 物品使用情况"+e;}}//NormalBagimport java.util.ArrayList;import java.util.PriorityQueue;public class NormalBag {/*** @param args*/public static void main(String[] args) {// TODO Auto-generated method stub//初始化队列//PriorityQueue<goods> pq=initpq();//定义暂存结果数组//ArrayList<goods> place=new ArrayList<goods>();//初始化背包值//int c=10;//背包当前容量int v=0;//背包当前价值//开始放入物品//goods t;//设定暂存记录变脸while(true){//设定借宿条件//if(c==0)break;if(pq.isEmpty())break;//取出替换元素//t=pq.poll();//开始比较//if(t.getw()<=c){v+=t.getv();t.setuse(t.getw());c-=t.getw();}else{v+=c*t.getVW();t.setuse(c);c=0;}place.add(t);}//输出结果//System.out.println(v);System.out.println(place);}//创建队列元素private static PriorityQueue<goods> initpq() {// TODO Auto-generated method stubPriorityQueue<goods>pq=new PriorityQueue<goods>();pq.offer(new goods(2,6));pq.offer(new goods(2,3));pq.offer(new goods(6,5));pq.offer(new goods(5,4));pq.offer(new goods(4,6));return pq;}}2.活动安排问题public class GreedySelector {/*** @param args*/public static void main(String[] args) {// TODO Auto-generated method stub//初始化//int s[]={1,3,0,5,3,5,6,8,8,2,12};//开始时间数组，已排序int f[]={4,5,6,7,8,9,10,11,12,13,14};//结束时间数组，已排序int a[]=new int[s.length];//定义标记选择过的活动数组int count=0;//活动数量计数器//开始选择//greedyselector(s,f,a);//输出//for(int i=0;i<s.length;i++){//输出活动序号if(a[i]==1){System.out.print("活动"+(i+1)+" ");count++;}}System.out.println();System.out.print("活动总数量为："+count);//输出总活动数量}private static void greedyselector(int[] s, int[] f, int[] a) { // TODO Auto-generated method stub//贪心选择为，先结束的互动优先，这样剩余的时间达到最大，安排活动最多//int n=s.length-1;a[0]=1;//最先的那个最优int j=0;for(int i=1;i<=n;i++){if(s[i]>=f[j]){a[i]=1;j=i;}elsea[i]=0;}}}五、实验总结(本次实验完成的情况，心得体会)。
贪心算法解决会场安排问题、多处最优服务次序问题(含源代码)
西安邮电大学（计算机学院）课内实验报告实验名称：贪心算法专业名称：计算机科学与技术班级：学生姓名：学号（8位）：指导教师：实验日期： 2014年5月22日1．实验目的及实验环境实验目的：通过实际应用熟悉贪心算法，并解决会场安排问题、多出最优服务次序问题实验环境：Visual C++ 6.0二. 实验内容1.会场安排问题.假设要在足够多的回厂里安排一批活动，并希望使用尽可能少的会场，设计一个有效的贪心算大进行安排（这个问题实际上是注明的图着色问题。
若将每一个活动作为图的一个顶点，不相容活动间用边相连。
使相邻顶点着有不同颜色的最小着色数，相应于要找的最小会场数）2.多处最优服务次序问题设有n个顾客同时等待一项服务。
顾客i需要的服务时间为ti，1<=i<=n。
共有s处可以提供此项服务。
应如何安排n个顾客的服务次序才能使平均等待时间达到最小？平均等待时间是n个顾客等待服务时间的总和除以n。
三．方案设计1、设有n个活动的集合E={1,2,…,n}，其中每个活动都要求使用同一资源，如演讲会场等，而在同一时间内只有一个活动能使用这一资源。
每个活动i都有一个要求使用该资源的起始时间si和一个结束时间fi,且si <fi 。
如果选择了活动i，则它在半开时间区间[si, fi)内占用资源。
若区间[si, fi)与区间[sj, fj)不相交，则称活动i与活动j是相容的。
也就是说，当si≥fj或sj≥fi时，活动i与活动j相容。
由于输入的活动以其完成时间的非减序排列，所以算法greedySelector每次总是选择具有最早完成时间的相容活动加入集合A中。
直观上，按这种方法选择相容活动为未安排活动留下尽可能多的时间。
也就是说，该算法的贪心选择的意义是使剩余的可安排时间段极大化，以便安排尽可能多的相容活动。
算法greedySelector的效率极高。
当输入的活动已按结束时间的非减序排列，算法只需O(n)的时间安排n个活动，使最多的活动能相容地使用公共资源。
算法贪婪法实验报告
一、实验背景与目的随着计算机科学的不断发展，算法在解决实际问题中的应用日益广泛。
贪婪法作为一种重要的算法设计方法，在许多领域都得到了广泛应用。
本实验旨在通过实际案例，让学生了解和掌握贪婪法的基本原理、设计方法以及应用场景。
二、实验内容与步骤1. 实验内容本实验选取两个经典问题作为案例，分别是“最小生成树”和“硬币找零问题”，分别使用贪婪法进行求解。
2. 实验步骤（1）最小生成树问题① 确定问题背景：给定一个无向连通图，要求找到一棵包含图中所有顶点的最小生成树。
② 设计贪心算法：以图中的任意一个顶点为根，选择与根顶点距离最短的顶点作为下一个顶点，并添加到最小生成树中。
重复此步骤，直到所有顶点都被包含在最小生成树中。
③ 实现代码：使用C++语言实现贪心算法，计算最小生成树的总权值。
（2）硬币找零问题① 确定问题背景：给定一系列不同面值的硬币和找零金额，要求找出最少硬币数来凑齐该金额。
② 设计贪心算法：从面值最大的硬币开始，尽可能地使用硬币凑齐金额。
若当前硬币面值大于剩余金额，则尝试使用面值较小的硬币，重复此步骤，直到金额为0。
③ 实现代码：使用C++语言实现贪心算法，计算最少硬币数。
三、实验结果与分析1. 最小生成树问题实验结果表明，使用贪心法求解最小生成树问题时，能够得到一棵包含图中所有顶点的最小生成树。
在实验过程中，我们发现贪心法在求解最小生成树问题时，存在一定的局限性。
例如，当图中存在多个顶点距离相同的情况下，贪心法可能会得到次优解。
2. 硬币找零问题实验结果表明，使用贪心法求解硬币找零问题时，能够得到最少硬币数来凑齐给定金额。
在实验过程中，我们发现贪心法在求解硬币找零问题时，具有较好的性能。
四、实验总结与讨论1. 贪婪法的基本原理贪婪法是一种在每一步都选择当前最优解的算法。
它通过在每一步选择局部最优解，期望得到全局最优解。
然而，贪婪法并不保证能够得到全局最优解，因为它的决策过程是基于局部最优解的。
算法实验05贪心法的应用
a>b ? star[i] = b, ter[i] = a : star[i] = a, ter[i] = b;
}
}
//进行排序:按照结束时间排int i = 0; i < N; i++){
for (int j = 0; j<N - i - 1; j++) {
}
//初始化函数
void init(){
srand((unsigned)time(NULL)); //给一个时间种子
for (int i = 0; i < N; i++){
int a = rand() % 100 + 1;
int b = rand() % 100 + 1;
//进行随机数的赋值，保证左边小于右边
//随机数生成函数
int number(){
int a = rand() % 10000 + 1;
return a;
}
//初始化函数
void init(){
srand((unsigned)time(NULL)); //给一个时间种子
for (int i = 0; i < N; i++){
int a = number();
a>b ? A[i].right = a, A[i].left = b : A[i].left = a, A[i].right=b;
}
return;
}
//主函数
int main()
{
N = 4;
do{
N *= 2;
init();//进行一次初始化
贪心算法实验报告
贪心算法实验报告实验报告题目实验四贪心算法开课实验室:数学实验室指导老师:韩逢庆时间: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设计内容 (1)2）输入要求 (1)3）输出要求 (1)2设计分析 (1)2.1排序（将数组按照从小到大排序）的设计 (1)2.2多个测试案例的处理方法的设计 (2)2.3 for循环设计 (2)2.4系统流程图 (2)3设计实践 (2)3.1希尔排序模块设计 (2)3.2 多个测试案例的处理方法的模块设计 (3)4测试方法 (4)5程序运行效果 (4)6设计心得 (6)7附录 (6)贪心算法：任务调度问题的设计1设计内容有n项任务，要求按顺序执行，并设定第I项任务需要t[i]单位时间。
如果任务完成的顺序为1，2，…，n，那么第I项任务完成的时间为c[i]=t[1]+…+t[i]，平均完成时间（ACT）即为（c[1]+..+c[n]）/n。
本题要求找到最小的任务平均完成时间。
2）输入要求输入数据中包含n个测试案例。
每一个案例的第一行给出一个不大于2000000的整数n，接着下面一行开始列出n各非负整数t（t≤1000000000），每个数之间用空格相互隔开，以一个负数来结束输入。
3）输出要求对每一个测试案例，打印它的最小平均完成时间，并精确到0.01。
每个案例对应的输出结果都占一行。
若输入某一个案例中任务数目n=0，则对应输出一个空行。
2 设计分析这个题目属于贪心算法应用中的任务调度问题。
要得到所有任务的平均完成时间，只需要将各个任务完成时间从小到大排序，任务实际完成需要的时间等于它等待的时间与自身执行需要的时间之和。
这样给出的调度是按照最短作业优先进行来安排的。
贪心算法通过一系列的选择来得到一个问题的解。
它所做的每一个选择都是当前状态下某种意义的最好选择，即贪心选择。
在许多可以用贪心算法求解的问题中一般具有两个重要的性质：贪心选择性质和最有子结构性质。
所谓贪心选择性只是指所求问题的整体最优解可以通过一系列局部最优的选择，即贪心选择来达到，这是贪心算法可行的第一基本要素。
算法分析与设计实验报告--贪心法 (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当前所对应的最短特殊路径长度。
贪心算法学习总结
贪心算法一、算法思想贪心法的基本思路:—-从问题的某一个初始解出发逐步逼近给定的目标,以尽可能快的地求得更好的解。
当达到某算法中的某一步不能再继续前进时，算法停止.该算法存在问题：1. 不能保证求得的最后解是最佳的;2. 不能用来求最大或最小解问题;3. 只能求满足某些约束条件的可行解的范围。
实现该算法的过程：从问题的某一初始解出发；while 能朝给定总目标前进一步do求出可行解的一个解元素;由所有解元素组合成问题的一个可行解；二、例题分析1、[背包问题]有一个背包,背包容量是M=150。
有7个物品，物品可以分割成任意大小。
要求尽可能让装入背包中的物品总价值最大，但不能超过总容量。
分析：目标函数：∑pi最大约束条件是装入的物品总重量不超过背包容量：∑wi<=M( M=150）（1）根据贪心的策略，每次挑选价值最大的物品装入背包，得到的结果是否最优？（2）每次挑选所占重量最小的物品装入是否能得到最优解？(3）每次选取单位重量价值最大的物品，成为解本题的策略。
？值得注意的是，贪心算法并不是完全不可以使用，贪心策略一旦经过证明成立后，它就是一种高效的算法。
贪心算法还是很常见的算法之一，这是由于它简单易行，构造贪心策略不是很困难。
可惜的是，它需要证明后才能真正运用到题目的算法中。
一般来说，贪心算法的证明围绕着：整个问题的最优解一定由在贪心策略中存在的子问题的最优解得来的。
对于例题中的3种贪心策略,都是无法成立（无法被证明）的，解释如下:(1）贪心策略：选取价值最大者.反例:W=30物品：A B C重量:28 12 12价值：30 20 20根据策略，首先选取物品A，接下来就无法再选取了,可是，选取B、C则更好.(2)贪心策略:选取重量最小.它的反例与第一种策略的反例差不多。
（3）贪心策略：选取单位重量价值最大的物品。
反例：W=30物品：A B C重量：28 20 10价值：28 20 10根据策略，三种物品单位重量价值一样，程序无法依据现有策略作出判断，如果选择A，则答案错误。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
贪心算法解决活动安排问题
金潇
Use the greedy algorithm to solve the arrangement for activities
Jinxiao
摘要：贪心算法在当前来看是最好的选择。
是用利用启发式策略，在不从整体最优上加以考虑的情况下，来做出局部最优选择的一种算法。
本文通过贪心算法的经典案例—活动安排问题入手，描述了贪心算法的基本思想和可能产生的问题，并简述该算法的好处和特点，最后给出几种经典的贪心算法。
关键字：贪心算法、局部最优选择
Abstract:A greedy algorithm is any algorithm that follows the problem solving heuristic of making the locally optimal choice at each stage with the hope of finding the global optimum. This article through the greedy algorithm of the classic case--activities problems, describes the greedy algorithm the basic ideas and possible problems, and briefly introduces the advantages and characteristics of the algorithm, and finally gives several classic the greedy algorithm. Keywords：greedy algorithm、the locally optimal choice
1.引言：
贪心法是一种改进了的分级处理方法。
用贪心法设计算法的特点是一步一步地进行，每一步上都要保证能获得局部最优解。
每一步只考虑一个数据，它的选取满足局部优化条件。
若下一个数据与部分最优解连在一起不再是可行解时，就不把该数据添加到部分解中，直到把所有数据枚举完，或者不能再添加为止。
这种能够得到某种度量意义下的最优解的分级处理方法称为贪心法。
其实，从"贪心"一词我们便可以看出，贪心算法总是做出在当前看来是最优的选择，也就是说贪心算法并不是从整体上加以考虑，它所做出的选择只是在某种意义上的局部最优解，而许多问题自身的特性决定了该题运用贪心算法可以得到最优解或较优解。
许多可以用贪心算法求解的问题一般具有贪心选择性质和最优子结构，贪心选择性质是指所求问题的整体最优解包含着局部最优的选择，对于一个具体问题，关键是证明或验证每一步所作的贪心选择最终将导致问题的一个整体最优解。
2.贪心算法的基本思想及存在问题
2.1 贪心法的基本思想：
从问题的某一个初始解出发逐步逼近给定的目标，以尽可能快的地求得更好的解。
当达到某算法中的某一步不能再继续前进时，算法停止。
1.建立数学模型来描述问题。
2.把求解的问题分成若干个子问题。
3.对每一子问题求解，得到子问题的局部最优解。
4.把子问题的解局部最优解合成原来解问题的一个解。
2.2 该算法存在问题：
1. 不能保证求得的最后解是最佳的；
2. 不能用来求最大或最小解问题；
3. 只能求满足某些约束条件的可行解的范围。
3.活动安排问题：
3.1 贪心算法解决活动安排问题
活动安排问题是用贪心算法有效求解的一个很好例子。
活动安排问题要求安排一系列争用某一公共资源的活动。
用贪心算法可提供一个简单、漂亮的方法，使尽可能多的活动能兼容的使用公共资源。
设有n个活动的集合｛0，1，2，…，n-1｝，其中每个活动都要求使用同一资源，如会场等，而在同一时间内只有一个活动能使用这一资源。
每个活动i都有一个要求使用该资源的起始时间starti和一个结束时间endi，且starti<endi。
如选择了活动i，则它在半开时间区间[starti,endi）内占用资源。
若区间[starti,endi)与区间[startj,endj)不相交，称活动i与活动j是相容的。
也就是说，当start j≥endi或starti≥endj时，活动i与活动j相容。
活动安排问题就是在所给的活动集合中选出最大的相容子活动集合。
在下面所给出的解活动安排问题的贪心算法中，设各活动的起始时间和结束时间存储于数组start[]和end[]中，不失一般性，假设结束时间安非递减排列：end[0]≤end[1] ≤…≤end[n-1]。
算法中用集合a来存储所选择的活动。
活动i被选择当且仅当a[i]的值为true。
变量j记录最近一次选择的活动。
设j是当前最近选择的活动，也就是所选择的活动中编号最大的活动，即：
j=max{i|0≤i<n,a[i]=true}
算法开始选择活动0，并将j初始化为0.然后依次检查活动i是否与当前已选择的所有活动相容。
如相容则安排活动i，否则不安排活动i，再继续检查下一活动与所有已选择活动的相容性。
由于k是当前已选择活动的最大结束时间，故活动i与当前所有选择活动相容的充分且必要条件是其开始时间start[i]不早于最近选择的活动j的结束时间end[j]，即start[i]
≥end[j]。
若活动i满足此条件，则活动i被选择，因而取代活动j的位置。
由于活动是以其完成时间的非减序排列的，所以算法每次总是选择具有最早完成时间的相容活动i。
这种方法选择相容活动就使剩余活动留下尽可能多的时间。
也就是该算法的贪心选择的意义是使剩余的可安排时间段极大化，以便安排尽可能多的相容活动。
3.2 活动安排实例
设待安排的11个活动的开始时间和结束时间按结束时间的非减序排列如下：
算法的计算过程如下图所示。
图中每行相应于算法的一次迭代。
阴影长条表示的活动是已选入集合的活动，而空白长条表示的活动是当前正在检查相容性的活动。
若被检查的活动i的开始时间starti小于最近选择的活动j的结束时间endj，则不选择活动i，否则选择活动i加入集合中。
3.3 活动安排问题证明贪心算法获得整体最优解
贪心算法并不总能求得问题的整体最优解，但对于活动安排问题，可以证明贪心算法能求得的整体最优解，下面将给与证明：
设E=｛0，1，2，…，n-1｝为所给的活动集合。
由于E中活动安排安结束时间的非减序
排列，所以活动0具有最早完成时间。
首先证明活动安排问题有一个最优解以贪心选择开始，即该最优解中包含活动0.设a是所给的活动安排问题的一个最优解，且a中活动也按结束时间非减序排列，a中的第一个活动是活动k。
如k=0，则a就是一个以贪心选择开始的最优解。
若k>0，则我们设b=a-｛k｝∪｛0｝。
由于end[0] ≤end[k],且a中活动是互为相容的，故b中的活动也是互为相容的。
又由于b中的活动个数与a中活动个数相同，且a是最优的，故b也是最优的。
也就是说b是一个以贪心选择活动0开始的最优活动安排。
因此，证明了总存在一个以贪心选择开始的最优活动安排方案，也就是算法具有贪心选择性质。
4.贪心算法解决活动安排问题的好处
运用该算法解决活动安排问题的效率极高。
当输入的活动已按结束时间的非减序排列，算法只需O(n)的时间安排n个活动，使最多的活动能相容地使用公共资源。
如果所给出的活动未按非减序排列，可以用O(nlogn)的时间重排。
5.几种经典的贪心算法
1.库鲁斯卡尔（Kruskal）算法
2.普林（Prim）算法
3.戴克斯德拉（Dijkstra）算法
6.结束语
贪心策略是指从问题的初始状态出发，通过若干次的贪心选择而得出最优值(或较优解)的一种解题方法，本文通过活动安排问题这一经典案例对贪心算法进行简要分析，利用图表给出较直观实例，得到了贪心算法是一种高效算法的结论。
7．参考文献
《数据结构与算法（c++版）》清华大学出版社唐宁九游洪跃等主编。