第4章_贪心算法_作业
第4章贪心算法习题(免费阅读)
算法实现题4-5 程序存储问题
数据输入:
第一行是2 个正整数,分别表示文件个数n和磁带的长 度L。接下来的1 行中,有n个正整数,表示程序存放在磁 带上的长度。
结果输出: 最多可以存储的程序数。
输入示例
6 50
2 3 13 8 80 20 输出示例
5
i 012345
x 2 3 13 8 80 20 7
3
算法实现题4-5 程序存储问题
问题描述: 设有n 个程序{1,2,…, n }要存放在长度为L的磁带上。
程序i存放在磁带上的长度是 li,1 ≤ i ≤ n。 程序存储问题要求确定这n 个程序在磁带上的一个
存储方案,使得能够在磁带上存储尽可能多的程序。 编程任务:
对于给定的n个程序存放在磁带上的长度,编程计 算磁带上最多可以存储的程序数。
532.00
10
算法实现题4-6 最优服务次序问题
double greedy( vector<int> x) {
int i,n=x.size(); sort(x.begin(),x.end()); for(i=1;i<n;++i)
x[i] += x[i-1]; double t=0; for(i=0;i<n;++i) t+=x[i]; t /= n;
算法实现题4-5 程序存储问题
int greedy( vector<int> x, int m){
int i=0, sum=0, n=x.size();
sort(x.begin(),x.end());
while(i
if(sum <= m) i++;
贪心算法练习题
贪心算法1.喷水装置(一)描述现有一块草坪,长为20米,宽为2米,要在横中心线上放置半径为Ri的喷水装置,每个喷水装置的效果都会让以它为中心的半径为实数Ri(0<Ri<15)的圆被湿润,这有充足的喷水装置i(1<i<600)个,并且一定能把草坪全部湿润,你要做的是:选择尽量少的喷水装置,把整个草坪的全部湿润。
输入第一行m表示有m组测试数据每一组测试数据的第一行有一个整数数n,n表示共有n个喷水装置,随后的一行,有n个实数ri,ri表示该喷水装置能覆盖的圆的半径。
输出输出所用装置的个数样例输入252 3.2 4 4.5 6101 2 3 1 2 1.2 3 1.1 1 2样例输出25根据日常生活知道,选择半径越大的装置,所用的数目越少。
因此,可以先对半径排序,然后选择半径大的。
另外,当装置刚好喷到矩形的顶点时,数目最少。
此时只要装置的有效喷水距离的和不小于20时,输出此时的装置数目即可。
2.喷水装置(二)时间限制:3000 ms | 内存限制:65535 KB难度:4描述有一块草坪,横向长w,纵向长为h,在它的橫向中心线上不同位置处装有n(n<=10000)个点状的喷水装置,每个喷水装置i喷水的效果是让以它为中心半径为Ri的圆都被润湿。
请在给出的喷水装置中选择尽量少的喷水装置,把整个草坪全部润湿。
输入对于每一组输入,输出最多能够安排的活动数量。
每组的输出占一行样例输入221 1010 1131 1010 1111 20样例输出12提示注意:如果上一个活动在T时间结束,下一个活动最早应该在T+1时间开始。
解题思路:这是一个贪心法中选择不相交区间的问题。
先对活动结束时间从小到大排序,排序的同时活动的起始时间也要跟着变化。
而且,结束时间最小的活动一定会安排,不然这段时间就白白浪费了。
后一个活动的起始时间如果比前一个活动的结束时间大,即两个活动没有相交时间,就把这个活动也安排上。
贪心算法程序设计
贪心算法程序设计贪心算法程序设计1. 什么是贪心算法贪心算法(Greedy Algorithm)是一种常见的算法思想,它在每一步选择中都采取当前状态下的最优选择,从而希望最终达到全局最优解。
贪心算法的核心思想是局部最优解能导致全局最优解。
2. 贪心算法的基本步骤贪心算法的基本步骤如下:1. 定义问题的优化目标。
2. 将问题分解成子问题。
3. 选择当前最优的子问题解,将子问题的解合并成原问题的解。
4. 检查是否达到了问题的优化目标,如果没有达到,则回到第二步,继续寻找下一个最优子问题解。
5. 在所有子问题解合并成原问题解后,得到问题的最优解。
3. 贪心算法的应用场景贪心算法的应用非常广泛,几乎可以用于解决各种优化问题。
以下几个常见的应用场景:1. 零钱找零问题:给定一定面额的纸币和硬币,如何找零使得所需纸币和硬币的数量最小?2. 区间调度问题:给定一些活动的开始时间和结束时间,如何安排活动使得可以办理的活动数量最大?3. 背包问题:给定一些具有重量和价值的物品,如何选择物品使得背包的总价值最大?4. 最小树问题:给定一个带权无向图,如何找到一棵树,使得它的边权之和最小?5. 哈夫曼编码问题:给定一组字符和相应的频率,如何构造一个满足最低编码长度限制的二进制编码?4. 贪心算法的优缺点贪心算法的优点是简单、高效,可以快速得到一个近似最优解。
而且对于一些问题,贪心算法能够得到全局最优解。
贪心算法的缺点在于它不一定能够得到全局最优解,因为在每一步只考虑局部最优解,无法回溯到之前的选择。
5. 贪心算法的程序设计在使用贪心算法进行程序设计时,通常需要以下几个步骤:1. 定义问题的优化目标。
2. 将问题分解成子问题,并设计子问题的解决方案。
3. 设计贪心选择策略,选择局部最优解。
4. 设计贪心算法的递推或迭代公式。
5. 判断贪心算法是否能够得到全局最优解。
6. 编写程序实现贪心算法。
6.贪心算法是一种常见的算法思想,它在每一步选择中都采取当前状态下的最优选择,从而希望最终达到全局最优解。
第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
算法分析贪心算法习题
如果一个游戏没能在规定期限前完成, 则要从奖励费m元中扣去一部分钱wi, wi为自然数。不同的游戏扣去的钱数是 不一样的。
问题描述
当然,每个游戏本身都很简单,保证每 个参赛者都能在一个时段内完成,而且 都必须从整时段开始。主持人只是想考 考每个参赛者如何安排组织自己做游戏 的顺序。
作为参赛者,小伟如何赢取最多的钱!
删数问题
通过键盘输入一个高精度的n(n≤240)位正整数N, 去掉其中任意s个数字后,剩下的数字按原左右次序 将组成一个新的正整数。编程对给定的n和s,寻找 一种方案,使得剩下的数字组成的新数最小。 输入:N
s 输出:最后剩下的最小数
样例输入:178543 S=4
样例输出:13
问题分析
由于正整数N的有效位数最大可达240 位,所以可以采用字符串类型来存储N
解题思路
这个题目思路很容易想,肯定是优先使 用半径大的喷水装置。因为半径越大的 喷水装置所能覆盖的范围就越大。
其实这个确定优先选择哪一个的过程就 是贪心选择的过程。
所以本题就是先对所有的喷水装置半径 排序,计算出,每个喷水装置所能覆盖 的长度。每次都选出当前半径最大的, 直到能覆盖完所有的草地。
智力大冲浪
【问题描述】 小伟报名参加电视台的智力大冲浪节目。本 次挑战赛吸引了众多参赛者,主持人为了表 彰大家的勇气,先奖励每个参赛者m元。先 不要太高兴!因为这些钱还不一定都是你的! 接下来,主持人宣布了比赛规则:
问题描述
首先,比赛时间分为n个时段,它又给 出了很多小游戏,每个小游戏都必须在 规定期限 ti 前完成(1<=ti<=n)。
贪心算法习题
排队接水
多机调度问题贪心算法c语言
多机调度问题贪心算法c语言一、引言多机调度问题是指将一组作业分配给多台机器,使得完成所有作业的时间最短。
在实际生产中,多机调度问题是一个常见的优化问题。
贪心算法是解决多机调度问题的一种有效方法。
本文将介绍贪心算法在C语言中的应用。
二、问题描述假设有n个作业需要分配给m台机器进行加工处理,每个作业需要的时间不同,每台机器的处理速度也不同。
现在需要设计一个算法,将这些作业分配给这些机器进行加工处理,并使得完成所有作业所需时间最短。
三、贪心算法思路贪心算法是一种基于局部最优解来构造全局最优解的思想。
对于多机调度问题,我们可以采用以下贪心策略:1. 将所有作业按照所需时间从大到小排序;2. 将第一个作业分配给第一台机器;3. 对于剩余的作业,选择当前处理时间最短的那台机器进行分配;4. 重复步骤3直到所有作业都被分配完毕。
四、C语言实现下面是C语言实现多机调度问题贪心算法的代码:#include <stdio.h>#include <stdlib.h>#define MAX_JOB 1000#define MAX_MACHINE 1000int cmp(const void *a, const void *b) {return *(int *)b - *(int *)a;}int main() {int n, m, job[MAX_JOB], machine[MAX_MACHINE] = {0}; scanf("%d%d", &n, &m);for (int i = 0; i < n; i++) {scanf("%d", &job[i]);}qsort(job, n, sizeof(int), cmp);for (int i = 0; i < n; i++) {int min_time = machine[0], min_index = 0;for (int j = 1; j < m; j++) {if (machine[j] < min_time) { min_time = machine[j]; min_index = j;}}machine[min_index] += job[i]; }int max_time = machine[0];for (int i = 1; i < m; i++) {if (machine[i] > max_time) { max_time = machine[i];}}printf("%d\n", max_time);return 0;}五、代码解析1. 宏定义和头文件引入:```#define MAX_JOB 1000#define MAX_MACHINE 1000#include <stdio.h>#include <stdlib.h>```定义了最大作业数和最大机器数,并引入了标准输入输出库和标准库。
贪心算法—多机调度
贪心算法-多机调度一、问题描述设有n个独立的作业,由m台机器进行加工处理,作业i所需的处理时间为t(i)。
约定,任何作业可以在任何机器上加工处理,但未完成前不允许中断处理。
任何作业不能拆分成更小的子作业。
多机调度问题要求给出一种作业调度方案,使n个作业在尽可能短的时间内完成。
二、算法分析1当n<=m时,将机器i的【0~t(i)】时间分配给作业i即可。
2当n>m时,首先将n个作业按照时间从大到小排列。
然后照此顺序将作业分配给空闲的处理机即可。
3创建3个类:JobNode类,MachineNode类, MinHeap类分别用于作业信息,机器信息,对机器类型的堆处理三、代码#include<iostream>using namespace std;#define Max 15template <class Type>class MinHeap{public:MinHeap(int ms);~MinHeap();void Insert(const Type& x);void DeleteMin(Type& x);protected:void FilterDown();//自顶向下构造堆void FilterUp();//自底向上构造堆private:Type *heap;int length;};////////////////////////////////////////template <class Type>MinHeap<Type>::MinHeap(int m){heap=new Type[m+1];length=0;}////////////////////////////////////////template <class Type>void MinHeap<Type>::Insert(const Type& x) {heap[++length]=x;FilterUp();}////////////////////////////////////////template <class Type> template <class Type>void MinHeap<Type>::FilterUp(){//自底向上进行调整int i=length,j=i/2;//父节点的编号Type temp=heap[i];while(i>1){if(temp>=heap[j])break;//找到了相应的位置else{heap[i]=heap[j];i=j;j=i/2;}}heap[i]=temp;}////////////////////////////////////////template <class Type>void MinHeap<Type>::DeleteMin(Type &x){x=heap[1];heap[1]=heap[length];length--;FilterDown();}////////////////////////////////////////template <class Type>void MinHeap<Type>::FilterDown(){int i=1,j=i*2;Type temp=heap[i];while(j<=length){if(j<length && heap[j]>heap[j+1])j++;//如果左右子树都存在,找出最小者,用j标记if(temp<heap[j])break;//找到了相应的位置else{heap[i]=heap[j];i=j;j=2*i;}}heap[i]=temp;}////////////////////////////////////////template <class Type>MinHeap<Type>::~MinHeap(){delete[] heap;}////////////////////////////////////////class JobNode{friend void Greedy(JobNode *,int ,int);friend void main(void);public:operator int() const {return time;}int ID,time;};class MachineNode{friend void Greedy(JobNode *,int ,int); public:operator int() const {return avail;}int ID,avail;};void Sort(JobNode a[],int n){int i,j,k;JobNode tmp;for(i=1;i<n;i++){k=i;for(j=i+1;j<=n;j++){if(a[j].time<a[k].time) k=j;}if(k!=i){tmp=a[i];a[i]=a[k];a[k]=tmp;}}}void Greedy(JobNode a[],int n,int m){if(n<=m){cout<<"为每个作业分配一台机器."<<endl;return;}Sort(a,n);MinHeap<MachineNode>H(m);MachineNode x;for(int i=1;i<=m;i++){x.avail=0;x.ID=i;H.Insert(x);}for(i=n;i>=1;i--){H.DeleteMin(x);cout<<"\n将机器"<<x.ID<<"从"<<x.avail<<"到"<<(x.avail+a[i].time)<<"的时间段分配给作业"<<a[i].ID<<endl;x.avail+=a[i].time;H.Insert(x);}}void main(){int i;int job_cnt; //作业的数目float machine_cnt;//机器数目int Time_of_all=0;JobNode a[Max];//作业所需要的时间// MachineNode b[Max];cout<<"==========多机调度问题===========\n";cout<<"输入机器个数:";cin>>machine_cnt;cout<<"输入作业个数(小于15):";cin>>job_cnt;for(i=1;i<=job_cnt;i++){cout<<"\n请输入第"<<i<<"个作业处理时间:";cin>>a[i].time;a[i].ID=i;}Greedy(a,job_cnt,machine_cnt);}四、结果截图五.实验总结多机调度问题是生活中比较典型的例子,根据经验我们很好确定贪心算法的贪心标准,但是落实到编程,还是有点不够得心应手,还需要加强自己的编程能力。
4-贪心法
应用实例
活动安排问题—算法设计与分析
template<class Type> void GreedySelector(int n, Type s[], Type f[], bool A[]) { A[1] = true; int j = 1; for (int i=2;i<=n;i++) { if (s[i]>=f[j]) { A[i]=true; j=i; } else A[i]=false; } }
贪心法的正确性问题
针对具体问题不同,贪心策略的选择可能有多种 ,如何选择合适的贪心策略并证明该策略的正确 性是贪心算法设计中的一个关键问题。 一般可以通过对算法步数的归纳或通过对问题规 模的归纳来证明贪心法的正确性。
应用实例
活动安排问题
有n个活动申请使用同一个礼堂,每项活动有一个开始时间和一 个截止时间,如果任何两个活动不能同时举行,问如何选择这 些活动,从而使得被安排的活动数量达到最多? 设S={1, 2, …, n}为活动的集合,si和fi分别为活动i的开始和截止 时间,i=1, 2, …, n。定义 活动i与j相容:si ≥ fj或sj ≥fi, i≠j 求S最大的两两相容的活动子集。 蛮力法 动态规划方法
若硬币的面值改为一角一分、五分和一分,要找给顾客的 是一角五分,情况如何?
贪心算法的基本思想
顾名思义,贪心算法总是作出在当前看来最好的 选择。也就是说贪心算法并不从整体最优考虑, 它所作出的选择只是在某种意义上的局部最优选 择。 贪心算法不能对所有问题都得到整体最优解,但 对许多问题它能产生整体最优解。 在一些情况下,即使贪心算法不能得到整体最优 解,其最终结果却是最优解的很好近似。
4—贪心法 Greedy Approach
中科院陈玉福算法课件ch4ppt
算法基本思想 调度问题 最小生成树问题 单点源最小路径问题 Huffman编码
贪心算法的基本思想
找零钱:给孩子找回87分硬币,现有硬币规格50分、10分、 5分、2分、1分。 50+3*10+5+2=87 一般方法:尽量找面值大的硬币。 装箱问题:有物品n件,重量分别是 w1,…,wn ; 有箱子m个: B1,…,Bm,每个的容量都是C(C≥wi)。设计装箱方法,使得 所用箱子最少。 1. NF(Next Fit)方法:前面的箱子不能再装了,才开始装下一 个箱子。 2. FF(First Fit)方法:每个物品都选择装进第一个可装的箱子 贪心算法的基本思想: 在每一步决策中总是作出在当前看来是最好的选择 贪心准则,局部最优。
=1≤iΒιβλιοθήκη ≤n∑ pyi i
贪心算法抽象控制流程
proc Greedy(A, n) // A[1:n]代表输入 solution={}; //解初始化为空集 for i to n do x:=Select(A); if Feasible(solution, x) then solution:=Union(solution, x); end{if} end{for} return(solution); end{Greedy} Select(A)是按照贪心 准则选取A中的输入 项; Feasible(solution, x)是 判断已知的解的部分 solution与新选取的x 的结合是否是可行 解。 Union(solution, x)x与 已经选到的部分 solution结合成解的更 大部分
GreedyJob获得最优解
假设贪心算法所选择的作业集J不是最优解,则一定有相容作 业集I,其产生更大的效益值。假定I是具有最大效益值的相容作 业集中使得|I∩J|最大者,往证 I=J。 反证法:若I=J 不成立,则这两个作业集合之间没有包含关 系。这是因为算法GreedyJob的特性和假定I 产生的效益值比J的 效益值更大。假设a是J\I中具有最大效益的作业,即J中比a具有 更大效益的作业(如果有的话)都应该在 I 中。如果作业 b∈I\J 且 pb>pa,那么由算法中对J中作业的选取办法(相容性要求),J中 至少有 fb个效益值≥pb的作业,其期限值≤ fb。这些作业一定在 I 中,因而 I 中至少有个fb+1作业,其期限值≤ fb ,这与 I 的相容性 矛盾。所以,I\J中事件的效益值均不超过pa。 称区间[k-1,k]为时间片k,相容作业集 I 的一个调度表就是指定 I 中各个作业的加工时间片。如果 I 有一个调度表 S 将时刻 fa前 的时间片均安排给I∩J中的作业,且I\J中最早被安排的是作业b, 在时间片k上,则k>fa。
贪 心 算 法
贪心算法及几个常用的例题贪心算法:一、基本概念:所谓贪心算法是指,在对问题求解时,总是做出在当前看来是最好的选择。
也就是说,不从整体最优上加以考虑,他所做出的仅是在某种意义上的局部最优解。
贪心算法没有固定的算法框架,算法设计的关键是贪心策略的选择。
必须注意的是,贪心算法不是对所有问题都能得到整体最优解,选择的贪心策略必须具备无后效性,即某个状态以后的过程不会影响以前的状态,只与当前状态有关。
所以对所采用的贪心策略一定要仔细分析其是否满足无后效性。
二、贪心算法的基本思路:1.建立数学模型来描述问题。
2.把求解的问题分成若干个子问题。
3.对每一子问题求解,得到子问题的局部最优解。
4.把子问题的解局部最优解合成原来解问题的一个解。
三、贪心算法适用的问题贪心策略适用的前提是:局部最优策略能导致产生全局最优解。
实际上,贪心算法适用的情况很少。
一般,对一个问题分析是否适用于贪心算法,可以先选择该问题下的几个实际数据进行分析,就可做出判断。
四、贪心算法的实现框架从问题的某一初始解出发;while (能朝给定总目标前进一步)利用可行的决策,求出可行解的一个解元素;由所有解元素组合成问题的一个可行解;五、贪心策略的选择因为用贪心算法只能通过解局部最优解的策略来达到全局最优解,因此,一定要注意判断问题是否适合采用贪心算法策略,找到的解是否一定是问题的最优解。
几个经典的例子:一、定义什么是贪心算法呢?所谓贪心算法是指,在对问题求解时,总是做出在当前看来最好的选择。
也就是说,不从整体最优解出发来考虑,它所做出的仅是在某种意义上的局部最优解。
贪心算法不是对所有问题都能得到整体最优解,但对范围相当广泛的许多问题都能产生整体最优解或整体最优解的近似解。
贪心算法的基本思路如下:1. .建立数学模型来描述问题。
2. 把求解的问题分成若干个子问题。
3. 对每个子问题求解,得到每个子问题的局部最优解。
4. 把每个子问题的局部最优解合成为原来问题的一个解。
c++贪心算法经典例题
c++贪心算法经典例题和详解贪心算法(Greedy Algorithm)是一种优化问题解决方法,其基本思想是每一步都选择当前状态下的最优解,以期望达到全局最优解。
贪心算法的特点是每一步都要做出一个局部最优的选择,而这些局部最优选择最终构成了全局最优解。
下面是一个经典的贪心算法例题以及详解:例题:活动选择问题(Activity Selection Problem)假设有一个需要在同一时段使用同一个资源的活动集合,每个活动都有一个开始时间和结束时间。
设计一个算法,使得能够安排最多数量的互不相交的活动。
# 输入:-活动的开始时间数组`start[]`。
-活动的结束时间数组`end[]`。
# 输出:-选择的互不相交的活动的最大数量。
# 算法详解:1. 首先,将活动按照结束时间从小到大排序。
2. 选择第一个活动,并将其加入最终选择的集合中。
3. 对于剩下的活动,选择下一个结束时间最早且与前一个活动不冲突的活动。
4. 重复步骤3,直到所有活动都被选择。
```cpp#include <iostream>#include <algorithm>#include <vector>using namespace std;// 定义活动结构体struct Activity {int start, end;};// 比较函数,用于排序bool compareActivities(Activity a, Activity b) {return a.end < b.end;}// 贪心算法解决活动选择问题void activitySelection(vector<Activity>& activities) {// 按照结束时间排序sort(activities.begin(), activities.end(), compareActivities);// 第一个活动总是被选中cout << "Selected activity: (" << activities[0].start << ", " << activities[0].end << ")" << endl;// 选择其余活动int lastSelected = 0;for (int i = 1; i < activities.size(); i++) {// 如果当前活动的开始时间大于等于上一个选择的活动的结束时间,则选择该活动if (activities[i].start >= activities[lastSelected].end) {cout << "Selected activity: (" << activities[i].start << ", " << activities[i].end << ")" << endl;lastSelected = i;}}}int main() {vector<Activity> activities = {{1, 2}, {3, 4}, {0, 6}, {5, 7}, {8, 9}, {5, 9}};cout << "Activities before sorting:" << endl;for (const Activity& activity : activities) {cout << "(" << activity.start << ", " << activity.end << ") ";}cout << endl;activitySelection(activities);return 0;}```在这个例子中,我们首先定义了一个活动的结构体`Activity`,然后编写了一个比较函数`compareActivities` 用于排序。
c++贪心算法经典例题
c++贪心算法经典例题摘要:一、贪心算法简介1.贪心算法的定义2.贪心算法的特点3.贪心算法适用的问题类型二、C++贪心算法经典例题1.背包问题a.0-1 背包问题b.完全背包问题c.动态背包问题2.最小生成树a.Kruskal 算法b.Prim 算法3.单源点最短路径a.Dijkstra 算法b.Floyd-Warshall 算法4.最长公共子序列a.贪心算法实现b.动态规划实现正文:一、贪心算法简介贪心算法(Greedy Algorithm)是一种求解最优解的方法。
它是在对问题求解时,总是做出在当前看来是最好的选择。
贪心算法并不追求整体最优解,只希望得到较为满意的解。
贪心算法的关键是贪心策略的选择,必须满足无后效性,即某个状态以后的过程不会影响以前的状态,只与当前状态有关。
贪心算法适用的问题类型包括背包问题、最小生成树、单源点最短路径和最长公共子序列等。
二、C++贪心算法经典例题1.背包问题背包问题(Knapsack Problem)是一种典型的贪心算法问题。
它描述的是有一个背包,有一定的容量,需要装载若干物品,每个物品有一定的价值和重量,要求在不超过背包容量的前提下,如何选择装载物品使得背包中的物品总价值最大。
背包问题可以分为0-1 背包问题、完全背包问题和动态背包问题。
2.最小生成树最小生成树(Minimum Spanning Tree,简称MST)是一种图论中的算法问题。
给定一个加权连通图,求解一个生成树,使得该生成树中所有边的权值之和最小。
最小生成树的经典算法有Kruskal 算法和Prim 算法。
3.单源点最短路径单源点最短路径(Single Source Shortest Path)问题是在一个图中,从源点出发到其他所有顶点的最短路径。
经典算法包括Dijkstra 算法和Floyd-Warshall 算法。
4.最长公共子序列最长公共子序列(Longest Common Subsequence,简称LCS)问题是求两个序列中最长的公共子序列。
(算法分析与设计)2.贪心算法
n
wixi
vixi
28.2
31
31.5
...
i1
[算法思路]1).将各物体按单位价值由高到低排序.
2).取价值最高者放入背包.
3).计算背包剩余空间.
4).在剩余物体中取价值最高者放入背包.
若背包剩余容量=0或物体全部装入背包为止
算法设计与分析 > 贪心算法
背包问题的贪心算法
print tour, cost }
*该算法不能求得最优解. 算法的最坏时间复杂性为O(n2)
该问题为NP难问题.
算法设计与分析 > 贪心算法
4.7 多机调度问题
问题:设有n个独立的作业{1, 2, …, n}, 由m台相同的机器进行加工 处理. 作业i所需时间为t i. 约定:任何作业可以在任何一台机器上 加工处理, 但未完工前不允许中断处理,任何作业不能拆分成更小 的子作业。要求给出一种作业调度方案,使所给的n 个作业在尽 可能短的时间内 由m台机器加工处理完成。 该问题为NP完全问题.
A complete tree is filled from the left: • all the leaves are on • the same level or • two adjacent ones and • all nodes at the lowest level are as far to the left as possible.
最大相容活动子集(1, 4, 8, 11), 也可表示为等长n元数组:(1, 0, 0, 1, 0, 0, 0, 1, 0, 0, 1)
算法设计与分析 > 贪心算法
活动安排问题贪心算法
template< class Type > void GreedySelector(int n, Type s[ ], Type f[ ], bool A[] ) { A[ 1 ] = true;
贪心算法基本思想和典型例题(转)
贪⼼算法基本思想和典型例题(转)贪⼼算法⼀、算法思想贪⼼法的基本思路:——从问题的某⼀个初始解出发逐步逼近给定的⽬标,以尽可能快的地求得更好的解。
当达到某算法中的某⼀步不能再继续前进时,算法停⽌。
该算法存在问题:1. 不能保证求得的最后解是最佳的;2. 不能⽤来求最⼤或最⼩解问题;3. 只能求满⾜某些约束条件的可⾏解的范围。
实现该算法的过程:从问题的某⼀初始解出发;while 能朝给定总⽬标前进⼀步 do 求出可⾏解的⼀个解元素;由所有解元素组合成问题的⼀个可⾏解;⼆、例题分析1、[背包问题]有⼀个背包,背包容量是M=150。
有7个物品,物品可以分割成任意⼤⼩。
要求尽可能让装⼊背包中的物品总价值最⼤,但不能超过总容量。
物品 A B C D E F G重量 35 30 60 50 40 10 25价值 10 40 30 50 35 40 30分析:⽬标函数: ∑pi最⼤约束条件是装⼊的物品总重量不超过背包容量:∑wi<=M( M=150)(1)根据贪⼼的策略,每次挑选价值最⼤的物品装⼊背包,得到的结果是否最优?(2)每次挑选所占空间最⼩的物品装⼊是否能得到最优解?(3)每次选取单位容量价值最⼤的物品,成为解本题的策略。
实现这个算法是学习算法分析与设计这门课程的需要。
贪⼼算法是所接触到的第⼀类算法。
算法从局部的最优出发,简单⽽快捷。
对于⼀个问题的最优解只能⽤穷举法得到时,⽤贪⼼法是寻找问题次优解的较好算法。
贪⼼法是⼀种改进了的分级处理⽅法。
⽤贪⼼法设计算法的特点是⼀步⼀步地进⾏,根据某个优化测度(可能是⽬标函数,也可能不是⽬标函数),每⼀步上都要保证能获得局部最优解。
每⼀步只考虑⼀个数据,它的选取应满⾜局部优化条件。
若下⼀个数据与部分最优解连在⼀起不再是可⾏解时,就不把该数据添加到部分解中,直到把所有数据枚举完,或者不能再添加为⽌。
这种能够得到某种度量意义下的最优解的分级处理⽅法称为贪⼼法。
选择能产⽣问题最优解的最优度量标准是使⽤贪⼼法的核⼼问题。
贪心算法一般解题步骤
贪心算法一般解题步骤
贪心算法是一种在求解最优解时,每次都选择当前最优解的算法。
它的基本思想是:每一步都选择当前最优的解,最终得到的解就是最优解。
贪心算法的优点是简单易懂,实现起来也比较容易,但是它的缺点是不一定能得到最优解。
贪心算法一般解题步骤如下:
1、确定问题的最优解:首先要确定问题的最优解,即最终要求的最优解。
2、确定贪心策略:根据问题的最优解,确定贪心策略,即每一步都选择当前最优解。
3、实施贪心策略:根据贪心策略,每一步都选择当前最优解,最终得到的解就是最优解。
4、检验最优解:最后,要检验最优解是否正确,如果正确,则说明贪心算法得到的解是最优解;如果不正确,则说明贪心算法得到的解不是最优解。
贪心算法是一种在求解最优解时,每次都选择当前最优解的算法,它的优点是简单易懂,实现起来也比较容易,但是它的缺点是不一定能得到最优解。
贪心算法一般解题步骤是:首先要确定问题的最优解,然后根据问题的最优解确定贪心策略,接着根据贪心策略每一步都选择当前最优解,最后检验最优解是否正确。
贪心算法在许多场景中都有应用,比如资源分配、路径规划、排序等。
它的优点是简单易懂,实现起来也比较容易,但是它的缺点是不一定能得到最优解,因此在实际应用中,要根据实际情况来选择合适的算法。
贪心算法练习题
贪心算法练习题贪心算法是一种常用的解决问题的思想和方法,它通常用于求解优化问题。
贪心算法的核心思想是:在每一步选择中都采取当前状态下最优的选择,从而希望最终能够达到全局最优。
在实际应用中,贪心算法常用于解决一些分类问题,如最小生成树、最短路径、背包问题等。
下面,将给出一些贪心算法的练习题,帮助读者更好地理解和掌握贪心算法的应用。
1. 零钱兑换问题假设我们有不同面额的硬币,如 1 美元、2 美元、5 美元等,我们希望找零 n 美元的时候,最少需要多少个硬币。
请用贪心算法解决此问题,并给出相应的代码实现。
2. 区间覆盖问题给定一个区间集合,选择尽可能少的区间,使得这些区间的并集能够覆盖全部的区间。
请使用贪心算法解决此问题,并给出相应的代码实现。
3. 活动选择问题给定 n 个活动的开始时间和结束时间,选择尽可能多的不相交的活动。
请使用贪心算法解决此问题,并给出相应的代码实现。
4. 任务调度问题假设我们有 n 个任务和 m 台执行任务的机器,每个任务需要一个单位的时间,在每台机器上只能执行一个任务。
如何安排任务,使得所有任务都能够被执行,并且时间最短。
请使用贪心算法解决此问题,并给出相应的代码实现。
以上是一些常见的贪心算法练习题,通过解决这些问题,读者可以更加深入地理解和掌握贪心算法的应用。
当然,在实际应用中,贪心算法并不是万能的,它只能求解一些特定类型的优化问题,对于其他类型问题的求解可能并不适用。
因此,在使用贪心算法时,需要仔细分析问题的特性,判断是否适用贪心算法,并注意贪心选择的合理性。
通过不断练习和实践,读者可以逐渐掌握贪心算法的应用技巧,提高问题求解的效率和准确性。
最后,希望读者能够善于思考,灵活运用贪心算法解决实际问题,并在实践中不断学习和进步。
贪心算法作为一种常用的解决问题的思想和方法,对于提高算法设计和分析能力具有重要意义。
《计算机算法设计与分析》PPT第四章贪心算法资料
假设活动已按结束时间的单调非递减顺序排序 f0≤f1≤f2≤… ≤fn<fn+1
则,当i≥j时, Sij=φ。
假设存在一活动ak∈Sij,其中i≥j,则在已排的序列中 ai在aj后面。
因fi≤sk<fk≤sj<fj ,与在已排的序列中ai在aj后面的 假设相矛盾。
所以,设活动按结束时间的单调非递减顺序排序,子 问题空间被用来从sij中选择最大相容活动子集,其中 0≤i<j≤n+1,而且所有其它的sij是空的。
14
步骤2:递归地定义最优解的值 设c[i, j]为Sij中最大相容子集中的活动数。当 Sij=φ时,c[i, j] = 0。对于一个非空子集Sij, 如果ak在Sij的最大相容子集中被使用,则子问 题Sik和Skj的最大相容子集也被使用。从而:
c[i, j] = c[i, k] + c[k, j] + 1
活动安排问题:要在所给的活动集合中选出最大 的相容活动子集合。
10
用动态规划方法求解
步骤1:分析最优解的结构特征 构造子问题空间 Sij={ ak∈S: fi≤sk<fk≤sj} Sij是S中活动的子集,其中每个活动都在活动ai 结束之后开始,且在活动aj开始之前结束。 Sij包含了所有与ai和aj相容的活动,并且与不迟 于ai结束和不早于aj开始的活动相容。此外, 虚构活动a0和an+1,其中f0=0, Sn+1=∞。原 问题即为寻找S0,n+1中最大相容活动子集。
(5)约束函数constraint:检查解集合中加入一 个候选对象是否满足约束条件。例如,在找零钱 问题中,约束函数是每一步选择的货币和已付出 的货币相加不超过应找零钱。
7
贪心算法的一般框架
算法作业——第4章贪心算法
算法作业——第4章贪⼼算法第4章 贪⼼算法 习题贪⼼算法 习题第4章【+】阅读、掌握课本经典范例代码的实现:(1)活动安排问题;(2)最优装载问题;(3)哈夫曼编码;(4)单源最短路径;(5)最⼩⽣成树;(6)多机调度问题。
【第1题】单项选择题(1)下⾯是贪⼼算法的基本要素的是( )。
A.重叠⼦问题B.构造最优解C.贪⼼选择性质D.定义最优解(2)下⾯问题( )不能使⽤贪⼼法解决。
A.单源最短路径问题B. n皇后问题C.最⼩花费⽣成树问题D.背包问题(3)采⽤贪⼼算法的最优装载问题的主要计算量在于将集装箱依其重量从⼩到⼤排序,故算法的时间复杂度为( )。
A.O(n)B.O(n2)C.O(n3)D.O(nlog2n)(4)关于0-1背包问题以下描述正确的是( )。
A.可以使⽤贪⼼算法找到最优解B.能找到多项式时间的有效算法C.使⽤教材介绍的动态规划⽅法可求解任意0-1背包问题D.对于同⼀背包与相同的物品,做背包问题取得的总价值⼀定⼤于等于做0-1背包问题(5)⼀棵哈夫曼树共有215个结点,对其进⾏哈夫曼编码,共能得到( )个不同的码字。
A.107B.108C.214D.215【第2题】求解哈夫曼编码中如何体现贪⼼思路?【第3题】举反例证明0-1背包问题若使⽤的算法是按照vi/wi的⾮递减次序考虑选择的物品,即只要正在被考虑的物品装得进就装⼊背包,则此⽅法不⼀定能得到最优解(此题说明0-1背包问题与背包问题的不同)。
*【第4题】给定数轴X上n个不同点的集合,{x1,x2,...,xn},其中,x1<x2<...<xn。
现在⽤若⼲个长度为1的闭区间来覆盖这些点。
设计⼀个算法找到最少的闭区间个数和位置。
证明算法的正确性并估计算法的时间复杂度。
【第5题】(编程)求解硬币问题。
有1分、2分、5分、10分、50分和100分的硬币各若⼲枚,现在要⽤这些硬币来⽀付W元,最少需要多少枚硬币。
说明:⽤结构体数组A存放硬币数据,A[i].v存放硬币i的⾯额,A[i].c存放硬币i的枚数。
贪心算法-例题讲解
贪⼼算法-例题讲解前⾔:此博客在写作过程中参考了⼤量资料和博客,不能⼀⼀列举,还请见谅。
概述贪⼼法:从问题的某⼀个初始状态出发,逐步构造最优解从⽽向⽬标前进,并期望通过这种⽅法产⽣出⼀个全局最优解的⽅法贪⼼是⼀种解题策略,也是⼀种解题思想,⽽不是算法贪⼼策略与其他算法的区别贪⼼与递推:贪⼼法推进每⼀步不依据某⼀固定的递推式,⽽是当前看似最佳的贪⼼决策,不断的将问题归纳为更加⼩的相似的⼦问题贪⼼与动态规划:贪⼼是“⿏⽬⼨光”;动态规划是“统揽全局”贪⼼法的优缺点优点:思维复杂度低、代码量⼩、运⾏效率⾼、空间复杂度低等缺点:很难找到⼀个简单可⾏并且保证正确的贪⼼思路贪⼼算法的应⽤贪⼼算法的常⽤范围有明显的贪⼼可证明贪⼼策略的贪⼼(最常见的)贪⼼数据结构:堆/Kruskal/Prim/Dijkstra博弈/游戏策略,这些策略⼤多是贪⼼求较优解或多次逼近求最优解⼏个简单的贪⼼例⼦最优装载问题:给n个物体,第i个物体重量为wi,选择尽量多的物体,使得总重量不超过C贪⼼策略:先拿轻的部分背包问题:有n个物体,第i个物体的重量为wi,价值为vi,在总重量不超过C的情况下让总价值尽量⾼。
每⼀个物体可以只取⾛⼀部分,价值和重量按⽐例计算贪⼼策略:先拿性价⽐⾼的乘船问题:有n个⼈,第i个⼈重量为wi。
每艘船的载重量均为C,最多乘两个⼈。
⽤最少的船装载所有⼈贪⼼策略:最轻的⼈和最重的⼈配对例题(基础)1.删数问题-【问题描述】键盘输⼊⼀个⾼精度的正整数n(n<=240位),去掉其中任意s个数字后剩下的数字按照原来的次序将组成⼀个新的正整数。
编程对给定的n和s,寻求⼀种⽅案,使得剩下组成的新数最⼩。
贪⼼策略为:每⼀步总是选择⼀个使剩下的数最⼩的数字删去,即按⾼位到低位的顺序搜索,若各位数字递增,则删除最后⼀个数字,否则删除第⼀个递减区间的⾸字符。
然后回到串⾸,按上述规则再删除下⼀个数字。
重复以上过程s次,剩下的数字串便是问题的解了。
- 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。
课后练习
• 练习3:活动安排问题。假设有9个活动申请使用1 个会议室,每个活动的开始时间和终止时间如下。 用贪心算法设计一个活动安排表,要求要尽可能 的多安排活动。会议室不允许被多个活动同时占 用。
活动序号 起始时间 结束时间 1 2 5 2 1 5 3 2 8 4 5 10 5 7 11 6 4 13 7 6 15 8 8 22 9 15 24
活动序号
起始时间 结束时间
1
2 5
2
1 5
3
2 8
4
5 10
5
7 11
6
4 13
7
6 15
8
8 22
9
15 24
• 根据贪心算法,第1个被安排的活动为1号活动,因为它的 结束时间(时刻5)最早。(贪心选择性质) • 然后每次都选取起始时间最接近于上一次活动的结束时间 的活动,所以分别依次选择4号活动(时刻10结束)、9号 活动(时刻24结束),则最优解为:( 1, 4, 9 )。 • 显然,最优解不唯一,比如: ( 2, 4, 9 )。但显然,用贪心 策略求出的可行解是最优的。
课后练习:算法分析题
• 算法分析题4-6(教材第128页):字符a~h出现 的频率恰好是前8个Fibonacci数,它们的哈夫曼 编码是什么? • 解答: Fibonacci数列
1 n0 F n 1 n1 F n 1 F n 2 n 1
前8个Fibonacci数为: 1, 1, 2, 3, 5, 8, 13, 21, ……
q j p j-1 q j q j-1 j j-1
• 由此可以推得: xq – xp ≤ d,即旅行者能够选择在1天之 j j-1 内走完从xp 到xq 的所有路程;因此他们最后停留的宿营地 j-1 j xp 只能比xq 更远。命题得证!
j j
• 设R = { xp , …, xp }表示由贪心算法选择的停止点的集合, 1 k 根据反证法,假设存在一个更小的停止点的有效集合:把 这个较小的集合称为S = { xq , …, xq },显然此时m<k。
V2
3
5
5
4
V4
2
6
V5 3
V6
课后练习
• Kruskal算法: V1 V2 1 V3 V4 V2
6
5 6 V5
V1
5 5 V4
1
V3
3
4
3 V1 1 1 V3 3 V6 5 5 4 3 V6
2
3
V5
4
3 V6
2
V2 V 2
6
5 6 V5
V V44
3
• Prim算法:
2
• 练习6:一队徒步旅行者要从A地到B地,两地间距离为L公 里。他们每天最多可以走d公里(与地形、天气条件等无 关),中间需要就地宿营。 • 假定这些潜在的宿营地点位于起点A地的距离为x1, x2, ……, xn的地方,显然它们之间的距离小于等于d,称这些地点(停 止点)是有效的。 • 于是,一组停止点是有效的,如果人们只能在这些地方宿营 并且仍旧能顺利完成旅行。则必须假设n个停止点所组成的 集合都是有效的;否则就没法走完整个路程。 • 问题1:假设两地距离为100公里,潜在的宿营地点为{ 6, 14, 30, 37, 48, 65, 73, 76, 88, 90,94 }。旅行者每天最多走18公里。 给出最优(最少)的有效宿营地组合(最少几天能走完)。 • 问题2:证明该算法的正确性(解的最优)。
课后练习
• 问题1:假设两地距离为100公里,潜在的宿营地 点为{ 6, 14, 30, 37, 48, 65, 73, 76, 88, 90,94 }。旅行 者每天最多走18公里。给出最优(最少)的有效 宿营地组合(最少几天能走完)。 • 解答:根据贪心算法,潜在的宿营地点的选取应 该遵循每天尽量多走(但不多于18公里)的原则, 以期用最短的时间走完100公里的行程。
100
2
3
{0,1,3}
{0,1,3,2}
3
2
10
10
50
50
30
30
90
60
4
{0,1,3,2,4}
4
10
50
30
60
• 算法正确性证明:教材114页-115页
课后练习
练习5:最小生成树问题。
① 用Prim或者Kruskal算法求出下图中的最小生成树。
② 证明该算法的正确性。(教材116页) 6 V1 1 V3 5
j j
• 证明I:贪心算法在每一天到达的停止点j比在其它解下到 达的停止点更远,即: 对每个j = 1, 2, …, m,有xp ≥xq
j j
• 证:j = 1的情况直接从贪心算法的定义得出:旅行者第1天 在停止之前走得尽可能远。
• 现在令j > 1并且假设这个断言对所有的i < j为真,那么 xq – xq ≤ d • 因为S是停止点的有效集合,且根据归纳假设,由xp ≥xq j-1 j-1 有: x –x ≤x –x
课后练习
• 设R = { xp , …, xp }表示由贪心算法选择的停止点的集合, 1 k 根据反证法,假设存在一个更小的停止点的有效集合: 把这个较小的集合称为S = { xq , …, xq },显然此时m< 1 m k。
• 证明I:贪心算法在每一天到达的停止点j比在其它解下 到达的停止点更远,即: 对每个j = 1, 2, …, m,有xp ≥xq
• 从而,不可能有m < k,即存在一个更小的停止点的有效集 合(较小的集合)S = { xq , …, xq }的假设是不成立的!
1 m
• 所以贪心算法产生一个最小的有效停止点集合得证!
End
课后练习
练习4:单源最短路径问题。求下面连通图中从源 顶点v0到其它各顶点的最短路径。 ① 列出源顶点到其它顶点的最短路径长度和路径中 顶点序列。 ② 证明该算法的正确性。
迭代
S2]
dist[3]
dist[4]
初始
1
{0}
{0,1}
1
10
10
maxint
60
30
30
100
源点 14 30 48 65 76 94
目的点
B地
A地
需要7天才能走完,这与[100/18]+1 = 6结果符合!
课后练习
• 问题2:证明该算法的正确性(解的最优)。 • 解答:这个策略有可能是无效的么? • 一个想法:该算法能否保证某一天提早停止就使 后面一些天的宿营地点同步提前。有没有可能真 存在一个解,它故意落在贪心解的后面,然后突 然加速并且越过贪心解?在给出贪心解每天旅行 尽可能远的条件下,它怎样越过贪心解?
1 7 1 4 0 2 0 1 1 1 1 2
e: 0010
g: 01
f: 000
h: 1
课后练习
• 练习2:假设有25分、10分、5分和1分四种硬币, 需要找给顾客2元5角钱,请问用贪心算法可以求 出何种找零方案?该方案是最优的么?为什么? • 解答: – 2元5角 = 250分,按照贪心算法(尽量用面值大 的硬币找零),则需要25分硬币10个即可。 – 该算法是最优的,因为五种硬币的面值中5分是 25分和10分的约数(因数)。
• 则a, b, c, d, e, f, g, h这 8个字符出现的次数依 次为:1, 1, 2, 3, 5, 8, 13, 21次。
0 33 0
54
1
21
20
0 8 0 5 0 3 1 12
1
13
• 以此构造一颗 Huffman树(不唯一) 如右:
• 对应的Huffman编码 为: a: 0011100 b:0011101 c: 001111 d: 00110
1 m
对每个j = 1, 2, …, m,有xp ≥xq
j m m
j
• 由上述命题(已证明),推出xp ≥ xq 式①。 • 现在m < k,那么一定有: xp < L – d 式② ,否则旅行者不 m 必停在xp 。
m+1
• 把两式组合可得: xq < L – d ;但这与假设S是一个有效的 m 停止点集合相矛盾。