贪心算法的应用.docx
《贪心算法的应用.docx》由会员分享，可在线阅读，更多相关《贪心算法的应用.docx（16页珍藏版）》请在冰豆网上搜索。
贪心算法的应用
在求最优解问题的过程中，依据某种贪心标准，从问题的初始状态出发，直接去求每一步的最优解，通过若干次的贪心选择，最终得出整个问题的最优解，这种求解方法就是贪心算法。
从贪心算法的定义可以看出，贪心法并不是从整体上考虑问题，它所做出的选择只是在某种意义上的局部最优解，而由问题自身的特性决定了该题运用贪心算法可以得到最优解。
我们看看下面的例子
例1均分纸牌（NOIP2002tg）
[问题描述] 有N堆纸牌，编号分别为1，2，…,N。
每堆上有若干张，但纸牌总数必为N的倍数。
可以在任一堆上取若干张纸牌，然后移动。
移牌规则为：
在编号为1堆上取的纸牌，只能移到编号为2的堆上；在编号为N的堆上取的纸牌，只能移到编号为N-1的堆上；其他堆上取的纸牌，可以移到相邻左边或右边的堆上。
现在要求找出一种移动方法，用最少的移动次数使每堆上纸牌数都一样多。
例如N=4，4堆纸牌数分别为：
① 9 ② 8 ③ 17 ④ 6
移动3次可达到目的：
从③取4张牌放到④（981310）->从③取3张牌放到②（9111010）->从②取1张牌放到①（10101010）。
[输入]：
键盘输入文件名。
文件格式：
N（N堆纸牌，1<=N<=100）
A1A2…An（N堆纸牌，每堆纸牌初始数，l<=Ai<=10000）
[输出]：
输出至屏幕。
格式为：
所有堆均达到相等时的最少移动次数。
[输入输出样例]
a.in：
4
98176
屏慕显示：
3
算法分析：
设a[i]为第i堆纸牌的张数（0<=i<=n），v为均分后每堆纸牌的张数，s为最小移到次数。
我们用贪心法，按照从左到右的顺序移动纸牌。
如第i堆（0（1） 若a[i]>v，则将a[i]-v张纸牌从第I堆移动到第I+1堆；
（2） 若a[i]为了设计的方便，我们把这两种情况统一看作是将a[I]-v张牌从第I堆移动到第I+1堆；移动后有：
a[I]:
=v；a[I+1]:
=a[I+1]+a[I]-v；
在从第i+1堆中取出纸牌补充第i堆的过程中，可能会出现第i+1堆的纸牌数小于零（a[i+1]+a[i]-v<0）的情况。
如n=3，三堆纸牌数为（1，2，27）这时v=10，为了使第一堆数为10，要从第二堆移9张纸牌到第一堆，而第二堆只有2张纸牌可移，这是不是意味着刚才使用的贪心法是错误的呢？
我们继续按规则分析移牌过程，从第二堆移出9张到第一堆后，第一堆有10张纸牌，第二堆剩下-7张纸牌，再从第三堆移动17张到第二堆，刚好三堆纸牌数都是10，最后结果是对的，从第二堆移出的牌都可以从第三堆得到。
我们在移动过程中，只是改变了移动的顺序，而移动的次数不变，因此此题使用贪心法是可行的。
源程序：
var
i,n,s:
integer;v:
longint;
a:
array[1..100]oflongint;
f:
text;fil:
string;
begin
readln（fil）;
assign（f,fil）;reset（f）;
readln（f,n）;v:
=0;
fori:
=1tondobegin
read（f,a[i]）;inc（v,a[i]）;
end;
v:
=vdivn;{每堆牌的平均数}
fori:
=1ton-1do
ifa[i]<>vthen{贪心选择}
begin
inc（s）;{移牌步数计数}
a[i+1]:
=a[i+1]+a[i]-v;{使第i堆牌数为v}
end;{then}
writeln（s）;
end.
利用贪心算法解题，需要解决两个问题：
一是问题是否适合用贪心法求解。
我们看一个找币的例子,如果一个货币系统有3种币值,面值分别为一角、五分和一分，求最小找币数时，可以用贪心法求解；如果将这三种币值改为一角一分、五分和一分，就不能使用贪心法求解。
用贪心法解题很方便，但它的适用范围很小，判断一个问题是否适合用贪心法求解，目前还没有一个通用的方法，在信息学竞赛中，需要凭个人的经验来判断何时该使用贪心算法。
二是确定了可以用贪心算法之后，如何选择一个贪心标准，才能保证得到问题的最优解。
在选择贪心标准时，我们要对所选的贪心标准进行验证才能使用，不要被表面上看似正确的贪心标准所迷惑，如下面的列子。
例2（NOIP1998tg）设有n个正整数，将他们连接成一排，组成一个最大的多位整数。
例如:
n=3时，3个整数13,312,343,连成的最大整数为:
34331213
又如:
n=4时,4个整数7,13,4,246连接成的最大整数为7424613
输入：
N
N个数
输出:
连接成的多位数
算法分析：
此题很容易想到使用贪心法，在考试时有很多同学把整数按从大到小的顺序连接起来，测试题目的例子也都符合，但最后测试的结果却不全对。
按这种贪心标准，我们很容易找到反例：
12，121应该组成12121而非12112,那么是不是相互包含的时候就从小到大呢？
也不一定，如：
12，123就是12312而非12112,这样情况就有很多种了。
是不是此题不能用贪心法呢？
其实此题是可以用贪心法来求解，只是刚才的贪心标准不对，正确的贪心标准是：
先把整数化成字符串，然后再比较a+b和b+a，如果a+b>b+a，就把a排在b的前面，反之则把a排在b的后面。
源程序：
var
s:
array[1..20]ofstring;
t:
string;i,j,k,n:
longint;
begin
readln（n）;
fori:
=1tondobegin
read（k）;
str（k,s[i]）;
end;
fori:
=1ton-1do
forj:
=i+1tondo
ifs[i]+s[j] begin{交换}
t:
=s[i];
s[i]:
=s[j];
s[j]:
=t;
end;
fori:
=1tondowrite（s[i]）;
end.
贪心算法所作的选择可以依赖于以往所作过的选择，但决不依赖于将来的选择，也不依赖于子问题的解，因此贪心算法与其它算法相比具有一定的速度优势。
如果一个问题可以同时用几种方法解决，贪心算法应该是最好的选择之一。
贪心算法经典例子（2009-07-1510:
17:
04）
标签：
贪心 算法 背包问题 it
分类：
简单算法
一、定义
什么是贪心算法呢？
所谓贪心算法是指，在对问题求解时，总是做出在当前看来最好的选择。
也就是说，不从整体最优解出发来考虑，它所做出的仅是在某种意义上的局部最优解。
贪心算法不是对所有问题都能得到整体最优解，但对范围相当广泛的许多问题都能产生整体最优解或整体最优解的近似解。
贪心算法的基本思路如下：
1.建立数学模型来描述问题。
2.把求解的问题分成若干个子问题。
3.对每个子问题求解，得到每个子问题的局部最优解。
4.把每个子问题的局部最优解合成为原来问题的一个解。
实现该算法的过程：
从问题的某一初始状态出发；
while能朝给定总目标前进一步do
求出可行解的一个解元素；
由所有解元素组合成问题的一个可行解；
二、例题分析
[背包问题]有一个背包，背包容量是M=150。
有7个物品，物品可以分割成任意大小。
要求尽可能让装入背包中的物品总价值最大，但不能超过总容量。
物品 A B C D E F G
重量35306050401025
价值10403050354030
记得当时学算法的时候，就是这个例子，可以说很经典。
分析：
目标函数：
∑pi最大
约束条件是装入的物品总重量不超过背包容量，即∑wi<=M（M=150）
（1）根据贪心的策略，每次挑选价值最大的物品装入背包，得到的结果是否最优？
（2）每次挑选所占重量最小的物品装入是否能得到最优解？
（3）每次选取单位重量价值最大的物品，成为解本题的策略?
贪心算法是很常见的算法之一，这是由于它简单易行，构造贪心策略简单。
但是，它需要证明后才能真正运用到题目的算法中。
一般来说，贪心算法的证明围绕着整个问题的最优解一定由在贪心策略中存在的子问题的最优解得来的。
对于本例题中的3种贪心策略，都无法成立，即无法被证明，解释如下：
（1）贪心策略：
选取价值最大者。
反例：
W=30
物品：
A B C
重量：
281212
价值：
302020
根据策略，首先选取物品A，接下来就无法再选取了，可是，选取B、C则更好。
（2）贪心策略：
选取重量最小。
它的反例与第一种策略的反例差不多。
（3）贪心策略：
选取单位重量价值最大的物品。
反例：
W=30
物品：
A B C
重量：
282010
价值：
282010
根据策略，三种物品单位重量价值一样，程序无法依据现有策略作出判断，如果选择A，则答案错误。
值得注意的是，贪心算法并不是完全不可以使用，贪心策略一旦经过证明成立后，它就是一种高效的算法。
比如，求最小生成树的Prim算法和Kruskal算法都是漂亮的贪心算法。
［均分纸牌］有N堆纸牌，编号分别为1，2，…，n。
每堆上有若干张,但纸牌总数必为n的倍数.可以在任一堆上取若干张纸牌,然后移动。
移牌的规则为：
在编号为1上取的纸牌，只能移到编号为2的堆上；在编号为n的堆上取的纸牌，只能移到编号为n-1的堆上；其他堆上取的纸牌，可以移到相邻左边或右边的堆上。
现在要求找出一种移动方法，用最少的移动次数使每堆上纸牌数都一样多。
例如：
n=4，4堆纸牌分别为：
①9②8③17④6移动三次可以达到目的：
从③取4张牌放到④再从③区3张放到②然后从②去1张放到①。
输入输出样例：
4
9 8176
屏幕显示：
3
算法分析：
设a[i]为第I堆纸牌的张数（0<=I<=n），v为均分后每堆纸牌的张数，s为最小移动次数。
我们用贪心算法，按照从左到右的顺序移动纸牌。
如第I堆的纸牌数不等于平均值，则移动一次（即s加1），分两种情况移动：
1．若a[i]>v，则将a[i]-v张从第I堆移动到第I+1堆；
2．若a[i]为了设计的方便，我们把这两种情况统一看作是将a[i]-v从第I堆移动到第I+1堆，移动后有a[i]=v;a[I+1]=a[I+1]+a[i]-v.
在从第I+1堆取出纸牌补充第I堆的过程中可能回出现第I+1堆的纸牌小于零的情况。
如n=3，三堆指派数为1227，这时v=10，为了使第一堆为10，要从第二堆移9张到第一堆，而第二堆只有2张可以移，这是不是意味着刚才使用贪心法是错误的呢？
我们继续按规则分析移牌过程，从第二堆移出9张到第一堆后，第一堆有10张，第二堆剩下-7张，在从第三堆移动17张到第二堆，刚好三堆纸牌都是10，最后结果是对的，我们在移动过程中，只是改变了移动的顺序，而移动次数不便，因此此题使用贪心法可行的。
Java源程序：
publicclassGreedy{
publicstaticvoidmain（String[]args）{
intn=0,avg=0,s=0;
Scannerscanner=newScanner（System.in）;
ArrayListarray=newArrayList（）;
System.out.println（"Pleaseinputthenumberofheaps:
"）;
n=scanner.nextInt（）;
System.out.println（"Pleaseinputheapnumber:
"）;
for（inti=0;i array.add（scanner.nextInt（））;
}
for（inti=0;i avg+=array.get（i）;
}
avg=avg/array.size（）;
System.out.println（array.size（））;
System.out.println（avg）;
for（inti=0;i s++;
array.set（i+1,array.get（i+1）+array.get（i）-avg）;
}
System.out.println（"s:
"+s）;
}
}
利用贪心算法解题，需要解决两个问题：
一是问题是否适合用贪心法求解。
我们看一个找币的例子，如果一个货币系统有三种币值，面值分别为一角、五分和一分，求最小找币数时，可以用贪心法求解；如果将这三种币值改为一角一分、五分和一分，就不能使用贪心法求解。
用贪心法解题很方便，但它的适用范围很小，判断一个问题是否适合用贪心法求解，目前还没有一个通用的方法，在信息学竞赛中，需要凭个人的经验来判断。
二是确定了可以用贪心算法之后，如何选择一个贪心标准，才能保证得到问题的最优解。
在选择贪心标准时，我们要对所选的贪心标准进行验证才能使用，不要被表面上看似正确的贪心标准所迷惑，如下面的例子。
［最大整数］设有n个正整数，将它们连接成一排，组成一个最大的多位整数。
例如：
n=3时，3个整数13，312，343，连成的最大整数为34331213。
又如：
n=4时，4个整数7，13，4，246，连成的最大整数为7424613。
输入：
n
N个数
输出：
连成的多位数
算法分析：
此题很容易想到使用贪心法，在考试时有很多同学把整数按从大到小的顺序连接起来，测试题目的例子也都符合，但最后测试的结果却不全对。
按这种标准，我们很容易找到反例：
12，121应该组成12121而非12112，那么是不是相互包含的时候就从小到大呢？
也不一定，如12，123就是12312而非12123，这种情况就有很多种了。
是不是此题不能用贪心法呢？
其实此题可以用贪心法来求解，只是刚才的标准不对，正确的标准是：
先把整数转换成字符串，然后在比较a+b和b+a，如果a+b>=b+a，就把a排在b的前面，反之则把a排在b的后面。
java源程序：
publicstaticvoidmain（String[]args）{
Stringstr="";
ArrayListarray=newArrayList（）;
Scannerin=newScanner（System.in）;
System.out.println（"Pleaseinputthenumberofdata:
"）;
intn=in.nextInt（）;
System.out.println（"Pleaseinputthedata:
"）;
while（n-->0）{
array.add（in.next（））;
}
for（inti=0;i for（intj=i+1;j if（（array.get（i）+array.get（j））.compareTo（array.get（j）+array.get（i））<0）{
Stringtemp=array.get（i）;
array.set（i,array.get（j））;
array.set（j,temp）;
}
}
for（inti=0;i str+=array.get（i）;
}
System.out.println（"str=:
"+str）;
}
}
贪心算法所作的选择可以依赖于以往所作过的选择，但决不依赖于将来的选择，也不依赖于子问题的解，因此贪心算法与其他算法相比具有一定的速度优势。
如果一个问题可以同时用几种方法解决，贪心算法应该是最好的选择之一。
贪心算法实例：
找零钱（Java实现）收藏
/**********从桌面txt文件里读取零钱数目以及需要找的钱总额然后利用贪心算法求解之后重新生成txt文件******************************************************************
importjava.io.*;
publicclassGreedySelect
{
publicGreedySelect（Stringfile）throwsIOException
{
try
{
this.file=file;
FileReaderreader=newFileReader（file）;
BufferedReaderBreader=newBufferedReader（reader）;
Strings=Breader.readLine（）;
inti,j;
change=newChange[10];
intk=0;
while（s!
=null）
{
j=0;
i=0;
String[]temp=newString[9];
temp=s.split（"\\s"）;
change[k]=newChange（）;
while（i<6）
{
intnum=Integer.parseInt（temp[i]）;
if（num==0）j++;
change[k].coins[i]=num;
i++;
}
if（j==5）break;
doublemoney=Double.parseDouble（temp[i]）*100;
change[k].money=（int）money;
k++;
s=Breader.readLine（）;
}
client=k-1;
Breader.close（）;
}
catch（IOExceptione）
{
e.printStackTrace（）;
}
}
publicvoidgreedySort（）//核心代码，贪心求解
{
doublemoney;
doubletemp=0;
for（inti=0;i{
System.out.println（change[i]）;
money=change[i].money;
for（intj=5;j>=0;j--）
{
if（j==5）temp=200;
elseif（j==4）temp=100;
elseif（j==3）temp=50;
elseif（j==2）temp=20;
elseif（j==1）temp=10;
elseif（j==0）temp=5;
if（money>=temp&&change[i].coins[j]>0）
{
money-=temp;
change[i].needCoins[j]++;
change[i].coins[j]--;
if（money>=temp&&change[i].coins[j]>0）
j++;
}
}
if（money!
=0）change[i].successful=false;
elsechange[i].successful=true;
}
}
publicvoidsaveResult（）throwsIOException//保存解决方案文件到桌面
{
try
{
FileWriterfileW=newFileWriter（"C:
\\DocumentsandSettings\\Administrator\\桌面\\solution.txt"）;
PrintWriterwriter=newPrintWriter（fileW）;
for（inti=0;i{
if（change[i].successful）
{
writer.println（"顾客"+i+"需要"+change[i].money+"找零钱如下：
"）;
for（intj=0;j<6;j++）
{
intk=change[i].needCoins[j];
if（k>0）
if（j==0）writer.println（"五分:
"+k）;
elseif（j==1）writer.println（"一角:
"+k）;
elseif（j==2）writer.println（"两角:
"+k）;
elseif（j==3）writer.println（"五角:
"+k）;
elseif（j==4）writer.println（"一元：
"+k）;
elseif（j==5）writer.println（"一元：
"+k）;
}
}
else
{
writer.println（"顾客"+i+"无法完成"）;
}
}
writer.close（）;
}
catch（IOExceptione）
{
e.printStackTrace（）;
}
}
privateintclient;
privateChange[]change;
privateStringfile;
privateclassChange
{
publicChange（）//定义顾客问题类
{
coins=newint[6];
needCoins=newint[6];
successful=false;
money=0;
}
publicint[]coins;
publicint[]needCoins;
publicintmoney;
publicbooleansuccessful;
}
}
（一）问题描述
一辆汽车加满油后可以行驶N千米。
旅途中有若干个加油站。
指出若要使沿途的加油次数最少，设计一个有效的算法，指出应在那些加油站停靠加油。
给出N，并以数组的形式给出加油站的个数及相邻距离，指出若要使沿途的加油次数最少，设计一个有效的算法，指出应在那些加油站停靠加油。
要求：
算法执行的速度越快越好。
（二）问题分析（前提行驶
升级会员 