第4章_贪心算法_作业
- 格式:ppt
- 大小:471.00 KB
- 文档页数:16
贪心算法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.贪心算法是一种常见的算法思想,它在每一步选择中都采取当前状态下的最优选择,从而希望最终达到全局最优解。
多机调度问题贪心算法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);}四、结果截图五.实验总结多机调度问题是生活中比较典型的例子,根据经验我们很好确定贪心算法的贪心标准,但是落实到编程,还是有点不够得心应手,还需要加强自己的编程能力。
贪心算法及几个常用的例题贪心算法:一、基本概念:所谓贪心算法是指,在对问题求解时,总是做出在当前看来是最好的选择。
也就是说,不从整体最优上加以考虑,他所做出的仅是在某种意义上的局部最优解。
贪心算法没有固定的算法框架,算法设计的关键是贪心策略的选择。
必须注意的是,贪心算法不是对所有问题都能得到整体最优解,选择的贪心策略必须具备无后效性,即某个状态以后的过程不会影响以前的状态,只与当前状态有关。
所以对所采用的贪心策略一定要仔细分析其是否满足无后效性。
二、贪心算法的基本思路:1.建立数学模型来描述问题。
2.把求解的问题分成若干个子问题。
3.对每一子问题求解,得到子问题的局部最优解。
4.把子问题的解局部最优解合成原来解问题的一个解。
三、贪心算法适用的问题贪心策略适用的前提是:局部最优策略能导致产生全局最优解。
实际上,贪心算法适用的情况很少。
一般,对一个问题分析是否适用于贪心算法,可以先选择该问题下的几个实际数据进行分析,就可做出判断。
四、贪心算法的实现框架从问题的某一初始解出发;while (能朝给定总目标前进一步)利用可行的决策,求出可行解的一个解元素;由所有解元素组合成问题的一个可行解;五、贪心策略的选择因为用贪心算法只能通过解局部最优解的策略来达到全局最优解,因此,一定要注意判断问题是否适合采用贪心算法策略,找到的解是否一定是问题的最优解。
几个经典的例子:一、定义什么是贪心算法呢?所谓贪心算法是指,在对问题求解时,总是做出在当前看来最好的选择。
也就是说,不从整体最优解出发来考虑,它所做出的仅是在某种意义上的局部最优解。
贪心算法不是对所有问题都能得到整体最优解,但对范围相当广泛的许多问题都能产生整体最优解或整体最优解的近似解。
贪心算法的基本思路如下:1. .建立数学模型来描述问题。
2. 把求解的问题分成若干个子问题。
3. 对每个子问题求解,得到每个子问题的局部最优解。
4. 把每个子问题的局部最优解合成为原来问题的一个解。
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++贪心算法经典例题摘要:一、贪心算法简介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)问题是求两个序列中最长的公共子序列。
贪⼼算法基本思想和典型例题(转)贪⼼算法⼀、算法思想贪⼼法的基本思路:——从问题的某⼀个初始解出发逐步逼近给定的⽬标,以尽可能快的地求得更好的解。
当达到某算法中的某⼀步不能再继续前进时,算法停⽌。
该算法存在问题: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 台执行任务的机器,每个任务需要一个单位的时间,在每台机器上只能执行一个任务。
如何安排任务,使得所有任务都能够被执行,并且时间最短。
请使用贪心算法解决此问题,并给出相应的代码实现。
以上是一些常见的贪心算法练习题,通过解决这些问题,读者可以更加深入地理解和掌握贪心算法的应用。
当然,在实际应用中,贪心算法并不是万能的,它只能求解一些特定类型的优化问题,对于其他类型问题的求解可能并不适用。
因此,在使用贪心算法时,需要仔细分析问题的特性,判断是否适用贪心算法,并注意贪心选择的合理性。
通过不断练习和实践,读者可以逐渐掌握贪心算法的应用技巧,提高问题求解的效率和准确性。
最后,希望读者能够善于思考,灵活运用贪心算法解决实际问题,并在实践中不断学习和进步。
贪心算法作为一种常用的解决问题的思想和方法,对于提高算法设计和分析能力具有重要意义。
算法作业——第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次,剩下的数字串便是问题的解了。