贪心算法：活动安排
贪心法解活动安排问题(计算机算法设计与分析)
实验报告
课程名称：算法设计与分析实验名称：贪心法解活动安排问题任课教师：专业：计算机科学与技术
班级: 20xx 级x班学号：
姓名：完成日期： 20xx年x月xx日
五、实验总结
在做本实验之前，自己看了课本上所列举的贪心法解活动安排问题的代码，代码很简单，很容易理解，于是就按课本的代码实现。
通过几个测试用例测试发现结果不对，后来发现自己忘了进行贪心法的一个前提条件，事先没有按各个活动结束时间对所有活动进行非递减排序，所以才会导致结果错误。
经过修正后，自己真正理解了贪心法解活动安排问题的原理，重新完成本次实验内容也是很顺利，在编程方面没有遇到什么困难。
贪心算法（4）：活动选择问题
贪⼼算法（4）：活动选择问题我们继续回到上⼀堂课留下的课外习题：活动选择问题。
活动选择问题是很常见的场景。
例如各个部门共享⼀个会议室，利⽤该算法能使会议室安排尽量多的会议。
【问题】给你n个活动的开始时间和结束时间，从中选择你可以参与的活动，但是同⼀时间你只能参与⼀个活动，请找出你可以参与的最多活动数。
例如：考虑下⾯3个活动a1,a2和a3, 它们{开始时间点,结束时间点}分别为：a1 {start=10,finish=20}a2 {start=12,finish=25}a3 {start=20,finish=30}贪⼼算法直接在每⼀步选择当前看来最好的选择。
在开始时，选择活动结束时间最早的那个活动，这样能够给其他活动尽可能的腾出多余的时间。
⽽后每⼀步都在剩下的活动中选取，也遵循类似的原则。
由于获取已经按照结束时间排序好，所以这⾥第⼀个选择的活动就是a0，由于a0于时间20结束，马上再找⼀个活动，只有a2可以选择，a2结束之后再也没有活动可选了。
因此得到答案：最多可以参加两个活动（a0,a2）。
算法分析和设计现在请你设计⼀种贪⼼算法解决类似活动选择问题。
我们设计下列贪⼼算法的贪⼼策略：选择其余活动中完成时间最短的下⼀个活动，并且开始时间⼤于或等于先前所选活动的结束时间。
我们可以根据他们的完成时间对活动进⾏排序，以便我们始终将下⼀个活动视为最⼩完成时间活动。
算法描述如下{k}}U{1}，必定仍然是⼀个最佳解决⽅案，说明如下：因为S 中的活动是独⽴的，⽽在排序队列中，【活动1】在所有活动中具有最⼩的结束时间，因为k不等于1，【活动k】的完成时间必定是⼤于等与【活动1】的完成时间，因此把【活动k】换成【活动1】后的新⽅案S‘必定也是最佳解决⽅案。
算法实现在以下C/C++代码实现中，假设活动已根据其完成时间进⾏了排序。
#include<stdio.h>// n --> 活动个数// s[] --> 数组保存所有活动的开始时间// f[] --> 数组保存所有活动的结束时间void printMaxActivities(int s[], int f[], int n){int i, j;printf ('选择以下的活动\n');// 第⼀个活动总是选中i = 0;printf('%d ', i);// 依次检查余下的活动for (j = 1; j < n; j++){//如果某活动在之前选择的活动结束之后开始if (s[j] >= f[i]){printf ('%d ', j);i = j;}}}//主程序int main(){int s[] = {1, 3, 0, 5, 8, 5};int f[] = {2, 4, 6, 7, 9, 9};int n = sizeof(s)/sizeof(s[0]);printMaxActivities(s, f, n);return 0;}注意：若是finish数组没有排序，需要先对它进⾏排序。
贪心算法解活动安排实验报告
实验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;}}}五、实验总结(本次实验完成的情况，心得体会)。
贪心算法（会场安排问题、区间选点）
贪⼼算法（会场安排问题、区间选点）学习算法课程之后的第⼀次记录，渐渐的，程序设计考虑的因素增多，程序=数据结构+算法，这个等式让我深有体会。
从开始简单的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贪⼼策略为：把尽可能多的时间互不冲突的活动安排到⼀个会场，若活动时间交叉，则在安排到另⼀个会场。
活动安排贪心算法
活动安排问题问题表述：设有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个活动，使最多的活动能相容地使用公共资源。
如果所给出的活动未按非减序排列，可以用O(nlogn)的时间重排。
例：设待安排的11个活动的开始时间和结束时间按结束时间的非减序排列如下：算法greedySelector 的计算过程如下图所示。
图中每行相应于算法的一次迭代。
阴影长条表示的活动是已选入集合A的活动，而空白长条表示的活动是当前正在检查相容性的活动。
若被检查的活动i的开始时间Si小于最近选择的活动j的结束时间fi，则不选择活动i，否则选择活动i加入集合A中。
贪心算法并不总能求得问题的整体最优解。
但对于活动安排问题，贪心算法greedySelector 却总能求得的整体最优解，即它最终所确定的相容活动集合A的规模最大。
这个结论可以用数学归纳法证明。
活动安排问题实现：#include<iostream>using namespace std;#define SIZE 11 //控制活动总数量的大小typedef int Type;void GreedySelector(int n,Type s[],Type f[],bool A[]){A[0]=true;int j=0;for(int i=1;i<n;i++){if(s[i]>=f[j]){A[i]=true;j=i;}else A[i]=false;}}void main(){int t=0;Type s[SIZE]={1,3,0,5,3,5,6,8,8,2,12};Type f[SIZE]={4,5,6,7,8,9,10,11,12,13,14};bool re[SIZE];GreedySelector(SIZE,s,f,re);cout<<endl<<" 最忧解下可以安排的活动有一下几个:"<<endl; cout<<" 活动";for(int i=0;i<SIZE;i++){if(re[i]){cout<<(i+1)<<" ";t++;}}cout<<"；";cout<<" 最多可以安排"<<t<<"个活动。
0021算法笔记——【贪心算法】贪心算法与精彩活动安排问题
0021算法笔记——【贪心算法】贪心算法与活动安排问题1、贪心算法(1)原理：在对问题求解时，总是做出在当前看来是最好的选择。
也就是说，不从整体最优上加以考虑，他所做出的仅是在某种意义上的局部最优解。
贪心算法不是对所有问题都能得到整体最优解，但对范围相当广泛的许多问题他能产生整体最优解或者是整体最优解的近似解。
(2)特性：贪心算法采用自顶向下，以迭代的方法做出相继的贪心选择，每做一次贪心选择就将所求问题简化为一个规模更小的子问题，通过每一步贪心选择，可得到问题的一个最优解，虽然每一步上都要保证能获得局部最优解，但由此产生的全局解有时不一定是最优的，所以贪婪法不要回溯。
能够用贪心算法求解的问题一般具有两个重要特性：贪心选择性质和最优子结构性质。
1)贪心选择性质所谓贪心选择性质是指所求问题的整体最优解可以通过一系列局部最优的选择，即贪心选择来达到。
这是贪心算法可行的第一个基本要素。
贪心算法则通常以自顶向下的方式进行，以迭代的方式作出相继的贪心选择，每作一次贪心选择就将所求问题简化为规模更小的子问题。
对于一个具体问题，要确定它是否具有贪心选择性质，必须证明每一步所作的贪心选择最终导致问题的整体最优解。
证明的大致过程为：首先考察问题的一个整体最优解，并证明可修改这个最优解，使其以贪心选择开始。
做了贪心选择后，原问题简化为规模更小的类似子问题。
然后用数学归纳法证明通过每一步做贪心选择，最终可得到问题的整体最优解。
其中，证明贪心选择后的问题简化为规模更小的类似子问题的关键在于利用该问题的最优子结构性质。
2)最优子结构性质当一个问题的最优解包含其子问题的最优解时，称此问题具有最优子结构性质。
(3)贪心算法与动态规划算法的差异:动态规划和贪心算法都是一种递推算法，均有最优子结构性质，通过局部最优解来推导全局最优解。
两者之间的区别在于：贪心算法中作出的每步贪心决策都无法改变，因为贪心策略是由上一步的最优解推导下一步的最优解，而上一部之前的最优解则不作保留，贪心算法每一步的最优解一定包含上一步的最优解。
贪心算法解决活动安排问题研究
贪心算法解决活动安排问题研究摘要：利用贪心算法解决如何使用最少的资源安排一系列活动。
并证明了贪心算法解决此问题的有效性，且进行了实例验证，并进行了复杂度分析，此算法是解决资源组合规划问题较好的方法。
关键词：贪心算法；java程序；复杂度分析；活动安排问题中图分类号：tp312文献标识码：a文章编号：16727800（2011）012004302基金项目：广西研究生教育创新计划（22m58）作者简介：苏方方（1986-），女，河南商丘人，广西师范大学计算机科学与信息工程学院硕士研究生，研究方向为自然语言处理和算法；张金玲（1986-），女，山东菏泽人，广西师范大学计算机科学与信息工程学院硕士研究生，研究方向为远程教育和算法。
0引言假设要在足够多的会场里安排一批活动，并希望使用尽可能少的会场。
这里就需要选用合适的算法来解决类似的问题。
虽然计算机的计算能力每年都在飞快增加，但是，需要处理的信息量更是呈指数级的增长。
互联网的信息流量在飞快进步，数据量更是达到了前所未有的程度。
无论是三维图形，海量数据处理等都需要极大的计算量。
在网络时代，越来越多的挑战需要靠卓越的算法来解决。
1贪心算法以及贪心算法的基本要素贪心算法是指从问题的初始状态出发，通过若干次的贪心选择而得出最优值(或较优解)的一种解题方法。
并不是从整体上加以考虑，它所做出的选择只是在某种意义上的局部最优解。
贪心算法可以简单描述为：对一组数据进行排序，找出最小值，进行处理，再找出最小值，再处理。
也就是说贪心算法是一种在每一步选择中都采取在当前状态下最好或最优的选择，从而希望得到结果是最好或最优的算法。
贪心算法解题步骤：①从问题的某个初始解出发；②采用循环语句，就根据局部最优策略，得到一个部分解，缩小问题的范围或规模；③将所有部分解综合起来，得到问题的最终解。
另外它也是一种某种度量意义下的最优解的分级处理方法。
对于一个具体的问题，怎么知道是否可用贪心算法来解决问题，以及能否得到问题的一个最优解呢？从许多可以用贪心算法求解的问题中可以看到它们一般具有两个重要的性质：①贪心选择性质；②最优子结构性质。
贪心算法 活动安排问题
活动安排问题，对每项活动的按照结束时间非减序排列。
然后选第一个。
按照第一个的结束时间来看接下去怎么选，以此类推。
贪心选择性质的证明：
1.活动安排问题的一个最优解是以贪心选择开始。
即最优解包含第一个活动（叫做活动1）。
证明：假设有一个最优解叫做A。
它的活动也是以结束时间的非减序进行排列。
假设A中第一个活动叫做K。
如果K是我们的活动1，则A就是以活动1开始的。
如果K不是活动1.则把K从A中去掉，并加上活动1，而且活动1是相容的是因为活动1 的
结束时间最早。
所以证明了活动安排问题的一个最优解是以贪心选择开始。
最优子结构的证明：
把起始时间大于活动1的结束时间的活动去掉，A也可以把K去掉，这样子有一个递推的关系就是（总活动中）接下去那个与活动1相容的解必然可以相容在最优解（A-K）里面。
（因它又可以化为一个贪心选择的开始）所以每一步做出的贪心选择将使得原问题化为规模变小的相似的子问题。
活动安排算法
活动安排算法有多种不同的方法，具体使用哪种方法取决于活动的性质和约束条件。
以下是几种常见的活动安排算法：贪心算法（Greedy Algorithm）：贪心算法根据当前的最佳选择来逐步安排活动。
它从一组可选活动中选择具有最早结束时间或最短持续时间的活动，并将其安排在日程中，然后继续选择下一个可行的活动。
贪心算法的优点是简单高效，但可能无法得到最优解。
动态规划（Dynamic Programming）：动态规划算法通过将问题分解为子问题并逐步求解，然后利用子问题的解来构建整体解。
在活动安排中，可以使用动态规划来确定最佳活动序列，使得活动之间没有时间冲突且总体利益最大化。
回溯算法（Backtracking Algorithm）：回溯算法通过逐个尝试所有可能的活动安排组合，并根据约束条件进行剪枝，以找到满足要求的最佳安排方案。
回溯算法可以应对更复杂的约束条件，但在问题规模较大时可能会变得计算量较大。
蚁群算法（Ant Colony Algorithm）：蚁群算法模拟了蚂蚁寻找食物的行为，通过信息素的传递和反馈机制，逐步寻找最佳的活动安排方案。
蚁群算法适用于多个活动同时进行且活动之间具有依赖关系的场景。
遗传算法（Genetic Algorithm）：遗传算法模拟了生物进化的过程，通过交叉、变异和选择等操作来生成新的解，并通过适应度函数评估解的质量。
遗传算法可以用于求解复杂的活动安排问题，寻找全局最优解。
需要根据具体的活动安排需求和问题特点选择合适的算法，并根据实际情况进行调整和优化。
在应用算法之前，需要明确活动的约束条件、目标函数以及其他需要考虑的因素，并根据这些因素选择合适的算法进行实施。
C++贪心算法实现活动安排问题（实例代码）
C++贪⼼算法实现活动安排问题（实例代码）贪⼼算法贪⼼算法（⼜称贪婪算法）是指，在对问题求解时，总是做出在当前看来是最好的选择。
也就是说，不从整体最优上加以考虑，他所做出的是在某种意义上的局部最优解。
贪⼼算法不是对所有问题都能得到整体最优解，关键是贪⼼策略的选择，选择的贪⼼策略必须具备⽆后效性，即某个状态以前的过程不会影响以后的状态，只与当前状态有关。
具体代码如下所⽰：#include <cstdio>#include <iostream>#include <ctime>#include <windows.h>#include <algorithm>#include <fstream>using namespace std;struct activity{int no;int start;int finish;};bool cmp(const activity &x, const activity &y){return x.finish<y.finish;//从⼩到⼤排<，若要从⼤到⼩排则>}int greedySelector(int m,int solution[],struct activity activity[]){int number = 1;solution[0] = 1;int i,j = 0,counter = 1;for(i = 1;i < m ;i++){if(activity[i].start >=activity[j].finish){solution[i] = 1;j = i;counter++;}elsesolution[i] = 0;}cout << "The amount of activities is:"<<counter<<endl;cout << "The solution is:";for(i = 0 ;i < m ;i++){if (solution[i] == 1){cout << activity[i].no <<" ";}}return counter;}int main(void){LARGE_INTEGER nFreq;LARGE_INTEGER nBeginTime;LARGE_INTEGER nEndTime;ofstream fout;srand((unsigned int)time(NULL));int m,i,j,t;double cost;cout << "Please enter the number of times you want to run the program:";cin >> t;fout.open("activity.txt",ios::app);if(!fout){cerr<<"Can not open file 'activity.txt' "<<endl;return -1;}fout.setf(ios_base::fixed,ios_base::floatfield); //防⽌输出的数字使⽤科学计数法for (j = 0;j < t;j++){cout << "——————————————————The "<< j + 1 << "th test —————————————————"<<endl;m = 1 + rand()%100000;fout<<m<<",";int solution[m];activity activity[m];for( i = 0;i < m;i++){activity[i].no = i+1;activity[i].start = 1 + rand()%1000;while(1){activity[i].finish = 1 + rand()%10000;if(activity[i].finish > activity[i].start) break;}}QueryPerformanceFrequency(&nFreq);QueryPerformanceCounter(&nBeginTime);sort(activity,activity+m,cmp);greedySelector(m,solution,activity);QueryPerformanceCounter(&nEndTime);cost=(double)(nEndTime.QuadPart - nBeginTime.QuadPart) / (double)nFreq.QuadPart;fout << cost << endl;cout << "\nThe running time is:" << cost << " s" << endl;}fout.close();cout << endl << endl;cout << "Success!" << endl;return 0;}总结以上所述是⼩编给⼤家介绍的C++贪⼼算法实现活动安排问题，希望对⼤家有所帮助，如果⼤家有任何疑问请给我留⾔，⼩编会及时回复⼤家的。
5.5主题活动：贪心算法
二 背包问题
装了音响，价值为3000元。但是价值不是最高的，如果是装笔 记本电脑和吉他，总价 值将为3500元。
在这里，贪心策略显然不能获得最优解，但是非常接近。
贪心算法
有时候，只需要找到一个能够大致解决问题的算法 ，此时贪心算法正好可以派上用场，因 为它们实现起来 很容易，得到的结果又与正确结果相当接近。
评一评
请根据本次动手实践情况，在表5-3中相应的位置涂“☆”。 (“非常好”涂☆☆☆☆ ☆,“好”涂☆☆☆,“还需努力”涂☆)
评价内容 理解贪心算法的含义
自评 ☆☆☆☆☆
能用贪心算法解决教室调度问题 ☆☆☆☆☆
能用贪心算法解决背包问题
☆☆☆☆☆
能说出贪心算法的优缺点
☆☆☆☆☆
互评
教师评
☆☆☆☆☆ ☆☆☆☆☆
请根据图思考具体做法。
一 教室调度问题
具体做法： 步骤1:选出结束最早的课，它就是要在这间教室上的第一堂课。 步骤2:选择第一堂课结束后才开始的课。同样，要选择结束得最早的课，这 将是要 在这间教室上的第二堂课。 步骤3:重复步骤1 和步骤2。 美术课结束得最早，为10:00,因此它就是第一堂课。接下来的课必须在10:00 后开 始，且结束得最早。英语课不行，因为它的时间与美术课冲突，数学课满 足条件。最后计算机课与数学课的时间是冲突的，音乐课可以。具体见表
一 教室调度问题
课程 美术 英语 数学 计算机 音乐
开始时间 9:00 9:30 10:00 10:30 11:00
结束时间 10:00 10:30 11:00 11:30 12:00
备注 √ X √ × √
因此根据表格,我们可以在这间教室上如下三堂课。
二 背包问题
贪心算法解决会场安排问题、多处最优服务次序问题(含源代码)
西安邮电大学（计算机学院）课内实验报告实验名称：贪心算法专业名称：计算机科学与技术班级：学生姓名：学号（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个活动，使最多的活动能相容地使用公共资源。
贪心算法经典问题：活动安排,背包问题,最优装载,单源最短路径 Dijiksra,找零钱问题,多机调度
else a[i]=false;
}
return count;
}
背包问题
void Knapsack(int n,float M,float v[],float w[],float x[])
{Sort(n,v,w);//以每种物品单位重量的价值Vi/Wi从大到小排序
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;
}
dist[v]=0 ; s[v]=true;
for(int i=1;i<n;i++)
{int temp = maxint, u = v;
if(newdist<dist[j]) {dist[j]= newdist;prev[j]=u; }
}
}//ENDFOR
}//END
找零钱问题
#define NUM4
void main()
{int m[NUM]={25,10,5,1};
int n;//假设n=99
cin>>n;
cout<<n<<"的找钱方案为：";
int max(int t[],int num);
int min(int t[],int m);
int set_work2(int t[],int n);
static int time[N]={2,8,18,32,50,72,98,128,182,200},s[M]={0,0,0};
贪心算法补充内容
7
3.1 活动安排问题
若被检查的活动i的开始时间Si小于最近选择的活动j 的结束时间fi，则不选择活动i，否则选择活动i加入集合 A中。 贪心算法并不总能求得问题的整体最优解。但对于活 动安排问题，贪心算法greedySelector却总能求得的整体 最优解，即它最终所确定的相容活动集合A的规模最大。 这个结论可以用数学归纳法证明。
10
一般背包问题最优性证明
证明： 若贪心策略为从剩余物品中选择可装入包的 则据此设计的贪心算法对于 p i / wi 最大， 一般的背包（即允许只放入物品的一部分）问题一定能生成一个最优解。 解： 设 X ( x1 , x2 , , xn ) 是题设中贪心算法的生成的解。 如果所有的 则显然是最优 x i 等于 1，
3
3.1 活动安排问题
在下面所给出的解活动安排问题的贪心算法greedySelector :
• • • • • • • • • • • • • • • • public static int greedySelector(int [] s, int [] f, boolean a[]) { int n=s.length-1; a[1]=true; int j=1; int count=1; 各活动的起始时间和结 for (int i=2;i<=n;i++) { if (s[i]>=f[j]) { 束时间存储于数组s和f a[i]=true; 中且按结束时间的非减 j=i; 序排列 count++; } else a[i]=false; } return count; }
解。设 j 是使 x j 1 的最小下标，由算法可知：
xi 1 1 i j xi 0 j i n 0 x 1 j
算法设计技巧与分析
if(s[i]>=f[j]) {a[i]=true;n++;j=i;} else a[i]=false; cout<<"the least amount meeting place is 1/5/19
12
return n; } void main() { int r;//活动数 int p=0;
cout<<"please input the activity quantity"<<endl; cin>>r; cout<<"please input the start_time"<<endl; int *st=new int[r+1]; bool *a=new bool[r+1]; for(int i=0;i<r;i++) cin>>st[i];
的活动能兼容地使用公共
前提下选择产生最大直 接利益的项。
资源。
2021/5/19
4
设有n个活动的集合e={1，2，…，n}，其中每个 活动都要求使用同一资源，如演讲会场等，而在
同一时间内只有一个活动能使用这一资源。每个 活动i都有一个要求使用该资源的起始时间si和一 个结束时间fi,且si<fi。如果选择了活动i，则它在 半开时间区间[si，fi]内占用资源。若区间[si，fi] 与区间[sj，fj]不相交，则称活动i与活动j是相容 的。也就是说，当si≥fi或sj≥fj时，活动i与活动j相 容。活动安排问题就是要在所给的活动集合中选 出最大的相容活动子集合。