算法设计(eclipse编写贪心算法设计活动安排)
贪心法解活动安排问题(计算机算法设计与分析)

实验报告
课程名称:算法设计与分析实验名称:贪心法解活动安排问题任课教师:专业:计算机科学与技术
班级: 20xx 级x班学号:
姓名:完成日期: 20xx年x月xx日
五、实验总结
在做本实验之前,自己看了课本上所列举的贪心法解活动安排问题的代码,代码很简单,很容易理解,于是就按课本的代码实现。
通过几个测试用例测试发现结果不对,后来发现自己忘了进行贪心法的一个前提条件,事先没有按各个活动结束时间对所有活动进行非递减排序,所以才会导致结果错误。
经过修正后,自己真正理解了贪心法解活动安排问题的原理,重新完成本次实验内容也是很顺利,在编程方面没有遇到什么困难。
贪心算法流程图

贪心算法流程图贪心算法是一种在每一步选择中都采取当前状态下最优决策的算法,以期望能够获得全局最优解。
在实际应用中,贪心算法通常用来解决最优化问题,比如最小生成树、哈夫曼编码等。
贪心算法的流程图可以帮助我们更直观地理解其工作原理和实现过程。
首先,我们来看一下贪心算法的流程图。
在图中,首先我们需要确定问题的解空间,然后根据问题的特点选择合适的贪心策略。
接着,我们需要确定每一步的最优选择,并且不断更新当前状态,直到达到最优解或者无法继续优化为止。
在实际应用中,贪心算法的流程图可以根据具体问题的特点进行调整和优化。
下面我们以一个简单的例子来说明贪心算法的流程图。
假设现在有一组活动,每个活动都有一个开始时间和结束时间,我们希望安排尽可能多的活动,使得它们之间不会相互冲突。
这个问题可以用贪心算法来解决。
首先,我们需要对活动按照结束时间进行排序,然后从第一个活动开始,依次检查每个活动的开始时间是否晚于上一个活动的结束时间。
如果是,则将该活动加入最优解集合中,并更新当前状态。
如果不是,则将该活动舍弃。
通过这样的贪心策略,我们可以得到安排最多活动的最优解。
整个流程可以用一个简单的流程图来表示,从而更直观地理解贪心算法的工作原理。
贪心算法的流程图不仅可以帮助我们理解算法的实现过程,还可以指导我们在实际应用中进行调整和优化。
通过对问题解空间的划分和贪心策略的选择,我们可以更快地找到最优解,提高算法的效率和性能。
总之,贪心算法的流程图是我们理解和应用贪心算法的重要工具,它可以帮助我们更直观地理解算法的工作原理,指导我们进行问题求解和算法优化。
希望通过本文的介绍,读者能对贪心算法有一个更深入的理解,并在实际应用中取得更好的效果。
贪心算法程序设计

贪心算法程序设计贪心算法程序设计1. 什么是贪心算法贪心算法(Greedy Algorithm)是一种常见的算法思想,它在每一步选择中都采取当前状态下的最优选择,从而希望最终达到全局最优解。
贪心算法的核心思想是局部最优解能导致全局最优解。
2. 贪心算法的基本步骤贪心算法的基本步骤如下:1. 定义问题的优化目标。
2. 将问题分解成子问题。
3. 选择当前最优的子问题解,将子问题的解合并成原问题的解。
4. 检查是否达到了问题的优化目标,如果没有达到,则回到第二步,继续寻找下一个最优子问题解。
5. 在所有子问题解合并成原问题解后,得到问题的最优解。
3. 贪心算法的应用场景贪心算法的应用非常广泛,几乎可以用于解决各种优化问题。
以下几个常见的应用场景:1. 零钱找零问题:给定一定面额的纸币和硬币,如何找零使得所需纸币和硬币的数量最小?2. 区间调度问题:给定一些活动的开始时间和结束时间,如何安排活动使得可以办理的活动数量最大?3. 背包问题:给定一些具有重量和价值的物品,如何选择物品使得背包的总价值最大?4. 最小树问题:给定一个带权无向图,如何找到一棵树,使得它的边权之和最小?5. 哈夫曼编码问题:给定一组字符和相应的频率,如何构造一个满足最低编码长度限制的二进制编码?4. 贪心算法的优缺点贪心算法的优点是简单、高效,可以快速得到一个近似最优解。
而且对于一些问题,贪心算法能够得到全局最优解。
贪心算法的缺点在于它不一定能够得到全局最优解,因为在每一步只考虑局部最优解,无法回溯到之前的选择。
5. 贪心算法的程序设计在使用贪心算法进行程序设计时,通常需要以下几个步骤:1. 定义问题的优化目标。
2. 将问题分解成子问题,并设计子问题的解决方案。
3. 设计贪心选择策略,选择局部最优解。
4. 设计贪心算法的递推或迭代公式。
5. 判断贪心算法是否能够得到全局最优解。
6. 编写程序实现贪心算法。
6.贪心算法是一种常见的算法思想,它在每一步选择中都采取当前状态下的最优选择,从而希望最终达到全局最优解。
浅谈Python实现贪心算法与活动安排问题

浅谈Python实现贪⼼算法与活动安排问题贪⼼算法原理:在对问题求解时,总是做出在当前看来是最好的选择。
也就是说,不从整体最优上加以考虑,他所做出的仅是在某种意义上的局部最优解。
贪⼼算法不是对所有问题都能得到整体最优解,但对范围相当⼴泛的许多问题他能产⽣整体最优解或者是整体最优解的近似解。
特性:贪⼼算法采⽤⾃顶向下,以迭代的⽅法做出相继的贪⼼选择,每做⼀次贪⼼选择就将所求问题简化为⼀个规模更⼩的⼦问题,通过每⼀步贪⼼选择,可得到问题的⼀个最优解,虽然每⼀步上都要保证能获得局部最优解,但由此产⽣的全局解有时不⼀定是最优的,所以贪婪法不要回溯。
能够⽤贪⼼算法求解的问题⼀般具有两个重要特性:贪⼼选择性质和最优⼦结构性质。
如题:给出⼀组活动,告诉每个活动的开始时间和结束时间,要求出算出能参加的最多活动的数量或者活动的起⽌时间贪⼼算法思路:⽤两个数组s,f分别存储活动的起⽌时间,根据活动的结束时间对活动进⾏⼀个⾮减的活动序列,同样活动的开始时间list也要做对应的调整,这⾥博主是通过冒泡排序同步交换的,举例:活动(1,4)(2,3)(3,5)那么我们得到的s = [2,1,3]f = [3,4,5]通过⽐较下⼀个活动的开始时间与上⼀个活动的结束时间的⼤⼩关系,确定这两个活动是否是相容的,如果开始时间⼤于结束时间,则相容,反之不相容,代码如下#⽤冒泡排序对结束时间进⾏排序,同时得到对应的开始时间的listdef bubble_sort(s,f):for i in range(len(f)):for j in range(0,len(f)-i-1):if f[j] > f[j+1]:f[j], f[j+1] = f[j+1],f[j]s[j],s[j+1] = s[j+1],s[j]return s,fdef greedy(s,f,n):a = [True for x in range(n)]#初始选择第⼀个活动j = 0for i in range(1,n):#如果下⼀个活动的开始时间⼤于等于上个活动的结束时间if s[i] >= f[j]:a[i] = Truej = ielse:a[i] = Falsereturn an = int(input())arr = input().split()s = []f = []for ar in arr:ar = ar[1:-1]start = int(ar.split(',')[0])end = int(ar.split(',')[1])s.append(start)f.append(end)s,f = bubble_sort(s,f)A = greedy(s,f,n)res = []for k in range(len(A)):if A[k]:res.append('({},{})'.format(s[k],f[k]))print(' '.join(res))执⾏结果如下:输⼊11个活动的起⽌时间,输出相容的活动的起⽌时间以上就是本⽂的全部内容,希望对⼤家的学习有所帮助,也希望⼤家多多⽀持。
计算机算法设计与分析-贪心算法

2023/10/8
计算机算法设计与分析
4
树的基本性质
连通无回路的图G称为树。 树是点比边多一的连通图,G连通且q=p–1 。 树是点比边多一的无回路图:G无回路且q=p–1 树若添条边就有回路:G无回路,但对任意的u,
v∈V(G),若uvE(G),则G+uv中恰有一条回路 树若减条边就不连通:G连通,但对e∈E(G),
图条 出且边 权该。 重回这 较路n小中–的1包n条含–边1e必条1。定边该包(回括在路了实中G现必的中有n体个条现顶不为点是n。e个的这 边样 顶e就 点i。得 的令到 选T’了择={G)T的+。e一1}棵–ei最。小T’生也成是树G的。生成树。又
cc矛K次不 要 是这((TTr盾选行 保 连u’’样))s。≤k择=! 证 通c做a故(cl权因 这 的T算(是T)必重为 或n,法)否定–+较不者T的1c’有可是小能是条(做e图1以G的保无边法) 的G–n证回构呢:的c最–(这路成在?e最1小1条的n树)保,小生–边。,证c生1成(。必条无e成1树)须边回树≤且使构路c包含(这成e的含i有)n树,前了边–?从提e1e1条而下1。。边依
初始化:Path中仅含有源v。
2023/10/8
计算机算法设计与分析
21
最临近算法中的数据结构
图用连接矩阵W[i][j]给出,即W[i][j]为 结点i到结点j的权重。
Path[]记录依次连接的城市,p记录当前 到达的最后一个顶点,cost为当前路径 长度。
如果节点k已经到达,则arrived[k]=true。
3
最小生成树
设G = (V, E)是一个无向连通带权图,即一个网 络。E的每条边(v, w)的权为c[v][w]。
算法设计与分析---贪心算法实验

实验三
报告书
姓名指Βιβλιοθήκη 教师学号日期班级
实验内容
时间限制: 1 s
空间限制: 256000 KB
题目等级 : 钻石 Diamond
题目描述 Description
一条街的一边有几座房子。因为环保原因居民想要在路边种些树。路边的地区被分割成块,并被编号为1…n。每个块的大小为一个单位尺寸并最多可种一裸树。每个居民想在门前种些树并指定了三个号码b,e,t。这三个数表示该居民想在b和e之间最少种t棵树。当然,b≤e,居民必须保证在指定地区不能种多于地区被分割成块数的树,即要求T≤ e-b+1。允许居民想种树的各自区域可以交叉。出于资金短缺的原因,环保部门请你求出能够满足所有居民的要求,需要种树的最少数量。
9
4
1 4 2
4 6 2
8 9 2
3 5 2
样例输出 Sample Output
5
数据范围及提示 Data Size & Hint
【数据规模】
30%的数据满足0<n ≤1000,0<h ≤ 500;100%的数据满足n ≤30000,h ≤5000。
时间限制: 1 s
空间限制: 128000 KB
题目等级 : 黄金 Gold
错了以后想了一下,发现本题解法要改一下。首先肯定是按照损失第一降序排序,然后才是时间第二增序排序。但是贪心过程也不能直接数数。样例有一个例子就是损失多的排序后在前面,损失少的排序在后面。看起来不能兼得,但是实际上,前面那个损失大的游戏的时间不是那么急迫,是允许晚一点去执行的。这样却可以兼得。如何解决这个问题?
种树题,要求的是最少的种树的数量。也就是说,如果一个人种了一棵树,为了使得种的树最少,那就要使得这颗树尽量种在大家都想种的区域之中。每一次针对一个要种树的居民来说,如何种树才能使得以后种树的人能够尽力的享受到“我”种的树带来的好处呢?
贪心算法程序设计

贪心算法程序设计贪心算法程序设计1、简介1.1 算法概述贪心算法是一种在每一步都做出局部最优选择的算法,以期达到全局最优。
贪心算法通常适用于问题具有最优子结构的情况,即问题的最优解包含了其子问题的最优解。
1.2 算法流程贪心算法的通用流程如下:1、初始化:选择一个初始解。
2、选择:从问题的解空间中选择一个局部最优解。
3、约束:验证选择的解是否满足问题的约束条件。
4、更新:更新问题的解空间,继续迭代选择、约束和更新操作,直到满足问题的结束条件。
2、贪心算法的经典问题2.1 零钱找零问题给定一个金额和硬币的面额列表,找到凑成该金额所需的最少硬币数。
步骤:1、初始化一个空的结果列表。
2、将硬币面额列表按从大到小的顺序排序。
3、从硬币面额最大的开始,尽量选择面额最大的硬币,直至不能选择为止。
4、如果当前选择的硬币可以凑成金额,则将该硬币加入结果列表,并将金额减去该硬币的面额。
5、重复步骤3和4,直到金额为0。
6、返回结果列表的长度即为所需的最少硬币数。
2.2 区间覆盖问题给定一个区间列表,选择最少的区间,使得这些区间能够覆盖整个目标区间。
步骤:1、将区间列表按照结束值从小到大排序。
2、初始化一个空的结果列表,用于存储选择的区间。
3、遍历排序后的区间列表,选择第一个结束值最小的区间,并将其加入结果列表。
4、遍历剩余的区间,如果当前区间的起始值大于已选择的最后一个区间的结束值,则将该区间加入结果列表。
5、返回结果列表。
3、贪心算法的优缺点3.1 优点- 简单性:贪心算法通常都比较直观简单,易于理解和实现。
- 效率高:贪心算法通常时间复杂度较低,能够在线性时间内求解问题。
3.2 缺点- 局部最优解:贪心算法只考虑每一步的局部最优解,而不考虑全局最优解。
因此,在某些问题上,贪心算法可能无法得到最优解。
- 缺乏验证:贪心算法没有对解的可行性进行全局验证,因此不能保证求得的解是问题的最优解。
4、附件本文档不涉及附件。
贪心算法解决活动安排问题报告

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相容。
活动安排问题就是在所给的活动集合中选出最大的相容子活动集合。
- 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。
陕西师大计科院2009级《算法设计与分析》课程论文集
算法设计(贪心算法解决活动安排)
设计者:朱亚君
贪心算法的计算过程如下图所示。
图中每行相应于算法的一次迭代。
阴影长条表示的活动是已选入集合A的活动,而空白长条表示的活动是当前正在检查相容性的活动。
图1贪心算法的计算过程图
若被检查的活动i的开始时间Si小于最近选择的活动j的结束时间fi,则不选择活动i,否则选择活动i加入集合A中。
贪心算法并不总能求得问题的整体最优解。
但对于活动安排问题,贪心算法却总能求得的整体最优解,即它最终所确定的相容活动集合A的规模最大。
这个结论可以用数学归纳法证明。
运用贪心算法解决活动安排问题
附录:
贪心算法的实现具体程序如下:
// 贪心算法实现代码 n为活动个数 s为活动开始起始时间队列 f 为活动结束队列 A为已选入集合
import java.util.Scanner;
public class a {
/**
* @param args
*/
static void GreedySelector(int s[],int f[],boolean A[])
{
//第一个活动为结束时间最早进入选入队列
int n=s.length;
A[1]=true;
int j=2;
for(int i=2;i<n;i++)
{
if(s[i]>=f[j])
{
A[i]=true;
j=i;
}
else
A[i]=false;
}
}
static void paixu(int s[],int f[])//进行以结束时间的大小排序
{
int n=s.length;
int m;
for(int i=0;i<n;i++)
for(int j=i;j<n-1;j++)
{
if(f[j]>f[j+1])
{
m=f[j];
f[j]=f[j+1];
f[j+1]=m;//终止时间如果前一个大于后一个就交换位置
陕西师大计科院2009级《算法设计与分析》课程论文集
m=s[j];
s[j]=s[j+1];
s[j+1]=m;//起始时间也同时进行交换位置
}
}
}
static void Output(boolean a[],int s[],int f[])
{
int t=0;
System.out.println("可以安排的活动有以下几个!");
for(int i=0;i<s.length;i++)
{
if(a[i])
{
System.out.print("(");
System.out.print(s[i]+",");
System.out.print(f[i]);
System.out.print("),");
t++;
}
}
System.out.println(";最多可以安排的活动是"+t+"个。
");
}
public static void main(String[] args) {
// TODO Auto-generated method stub
Scanner in=new Scanner(System.in);
System.out.print("请输入有几场活动!");
int n=in.nextInt();
int s[]=new int[n+1];
System.out.println("请输入每场活动的开始时间(用空格隔开,以回车结束)");
for(int i=1;i<=n;i++)
s[i]=in.nextInt();
int f[]=new int[n+1];
System.out.print("请输入每场活动的结束时间(用空格隔开,一回车结束)");
for(int j=1;j<=n;j++)
f[j]=in.nextInt();
boolean a[]=new boolean[12];
paixu(s,f);
GreedySelector(s,f,a);
Output(a,s,f);
}
}。