码迷,mamicode.com
首页 > 编程语言 > 详细

10算法策略之贪婪法

时间:2019-02-15 17:40:49      阅读:170      评论:0      收藏:0      [点我收藏+]

标签:山顶   超过   数字   读者   获得   分数   数据结构   cpp   产生   

贪婪算法

贪婪法又叫登山法, 它的根本思想是逐步到达山顶,即逐步获得最优解。贪婪算法没有固定的算法框架,算法设计的关键是贪婪策略的选择。一定要注意,选择的贪婪策略要具有无后向性。某状态以后的过程和不会影响以前的状态,只与当前状态或以前的状态有关,称这种特性为无后效性。

 

 

可绝对贪婪问题

   【例1】键盘输入一个高精度的正整数N,去掉其中任意S个数字后剩下的数字按原左右次序将组成一个新的正整数。编程对给定的N和S,寻找一种方案使得剩下的数字组成的新数最小。

    输入数据均不需判错。输出应包括所去掉的数字的位置和组成的新的正整数(N不超过240位)。

数据结构设计:对高精度正整数的运算在上一节我们刚刚接触过,和那里一样,将输入的高精度数存储为字符串格式。根据输出要求设置数组,在删除数字时记录其位置。

技术图片

技术图片

技术图片

技术图片

我们采用方法1)。

    一种简单的控制相邻数字比较的方法是每次从头开始,最多删除s次,也就从头比较s次。按题目要求设置数组data记录删除的数字所在位置。

 

较s次。按题目要求设置数组data记录删除的数字所在位置
delete(char n[],int b,int k)
{int i; 
for(i=b;i<= length(n)-k;i=i+1) n[i]=n[i+k];}
main()
{char  n[100]; int s,i,j,j1,c,data[100],len;
 input(n);   input(s);   len=length(n);
if(s>len)
  {print(“data error”); return;}
j1=0;
for (i=1;i<=s ;i=i+1)
{for (j=1;j<length(n);j=j+1)
  if (n[j]>n[j+1])                //贪婪选择
      {delete(n,j,1);
      if (j>j1) data[i]=j+i; //记录删除数字位置
      else     //实例2向前删除的情况实例
        data[i]=data[i-1]-1;
      j1=j;  break;  }
  if( j>length(n))   break;
}
for (i=i;i<=s;i=i+1)
{ j=len-i+1;delete(n,j,1); data[i]=j;}
while (n[1]=‘0‘ and length(n) >1) 
   delete(n,1,1);   //将字符串首的若干个“0”去掉       print(n);
for (i=1;i<=s;i=i+1)
  print(data[i],‘ ‘);
}

算法说明1:注意记录删除位置不一定是要删除数字d的下标,因为有可能d的前或后有可能已经有字符被删除,d的前面已经有元素删除容易想到,但一定不要忽略了其后也有可能已删除了字符,实例2中删除1时,其后的2已被删除。要想使记录删除的位置操作简便,使用算法设计1中的介绍第二种删除方式最简单,请读者尝试实现这个设计。

 

算法设计2:删除字符的方式同算法1,只是删除字符后不再从头开始比较,而是向前退一位进行比较,这样设计的算法2的效率较算法1要高一些。delete()函数同前不再重复。

算法2如下:

Delete_digit()
{char  n[100]; int   s,i,j,c,data[100],len; 
input(n);    input(s);    len=length(n);
if(s>len)
  {print(“data error”);   return;}
i=0;    j=1;    j1=0;
while(i<s and j<=length(n)-1)
  {while(n[j]<=n[j+1])     j=j+1;
   if (j<length(n))
       {delete(n,j,1);
        if (j>j1)    data[i]=j+i;   
        else    data[i]=data[i-1]-1;
        i=i+1;  j1=j; j=j-1;}
  }   
for (i=i;i<=s;i=i+1)
   { j=len-i+1; delete(n,j,1);  data[i]=j;}
 while (n[1]=‘0‘ and length(n) >1) 
      delete(n,1,1);   
print(n);
for (i=1;i<=s;i=i+1)
   print(data[i],‘ ‘);
}  

算法说明2:同算法1一样,变量i控制删除字符的个数,变量j控制相邻比较操作的下标,当删除了第j个字符后,j赋值为j-1,以保证实例2(字符串n2)出现的情况得到正确的处理。

 

 

【例2】数列极差问题

    在黑板上写了N个正整数作成的一个数列,进行如下操作:每一次擦去其中的两个数a和b,然后在数列中加入一个数a×b+1,如此下去直至黑板上剩下一个数,在所有按这种操作方式最后得到的数中,最大的记作max,最小的记作min,则该数列的极差定义为M=max-min。  

问题分析

  和上一个例题一样,我们通过实例来认识题目中描述的计算过程。对三个具体的数据3,5,7讨论,可能有以下三种结果:

(3*5+1)*7+1=113、(3*7+1)*5+1=111、(5*7+1)*3+1=109

  由此可见,先运算小数据得到的是最大值,先运算大数据得到的是最小值。

技术图片

 

 

算法设计

    1)由以上分析,大家可以发现这个问题的解决方法和哈夫曼树的构造过程相似,不断从现有的数据中,选取最大和最小的两个数,计算后的结果继续参与运算,直到剩余一个数算法结束。

    2) 选取最大和最小的两个数较高效的算法是用二分法完成, 这里仅仅用简单的逐个比较的方法来求解。 注意到由于找到的两个数将不再参与其后的运算,其中一个自然地是用它们的计算结果代替,另一个我们用当前的最后一个数据覆盖即可。所以不但要选取最大和最小,还必须记录它们的位置,以便将其覆盖。

    3)求max、min的过程必须独立,也就是说求max和min都必须从原始数据开始,否则不能找到真正的max和min。

 

数据结构设计

 1) 由设计2)、3)知,必须用两个数组同时存储初始数据。

 2) 求最大和最小的两个数的函数至少要返回两个数据,为方便起见我们用全局变量实现。

 

 int s1,s2;

  main( )
{int j,n,a[100],b[100],max,min;
print(“How mang data?”);   input(n);
print(“input these data”);
for (j=1;j<=n;j=j+1)
    {input(a[j]);     b[j]=a[j];}
min= calculatemin(a,n);
max= calculatemax(b,n);
print(“max-min=”, max-min)
}
calculatemin(int a[],int n)
 {while (n>2)
    { max2(a,n);    a[s1]= a[s1]* a[s2]+1;
      a[s2]=a[n];    n=n-1;}
   return(a[1]* a[2]+1);
  }

max2(int a[],int n)
  {  int  j;
     if(a[1]>=a[2])       {  s1=1;         s2=2;}
     else  {   s1=2;       s2=1;} 
     for (j=3;j<=n;j++)
       {  if (a[j]>a[s1])         {   s2=s1;       s1=j;}
           else  if (a[j]>a[s2])        s2=j;         }
     } 
calculatemax(int a[],int n)
  {while (n>2)
      {  min2(a,n);         a[s1]= a[s1]* a[s2]+1;
         a[s2]=a[n];         n=n-1;}
     return(a[1]* a[2]+1);
   }  

min2(int a[ ],int n)
   {  int  j;
       if(a[1]<=a[2])           {   s1=1;           s2=2;}
           else             {   s1=2;             s2=1;}
       for (j=3;j<=n;j++)
           if (a[j]<a[s1])       {    s2=s1;        s1=j;}
              else  if (a[j]<a[s2])          s2=j;
     }

算法分析:算法中的主要操作就是比较查找和计算,它们都是线性的,因此算法的时间复杂度为O(n)。由于计算最大结果和计算最小结果需要独立进行,所以算法的空间复杂度为O(2n)。

 

 

 

 贪婪策略不仅仅可以应用于最优化问题中,有时在解决构造类问题时,用这种策略可以尽快地构造出一组解,如下面的例子:

【例3】: 设计一个算法, 把一个真分数表示为埃及分数之和的形式。所谓埃及分数,是指分子为1的形式。如:7/8=1/2+1/3+1/24。

问题分析

    基本思想是, 逐步选择分数所包含的最大埃及分数,这些埃及分数之和就是问题的一个解。

       如:7/8>1/2,

           7/8-1/2>1/3,  

           7/8-1/2-1/3=1/24。

过程如下:

  1)找最小的n(也就是最大的埃及分数),使分数f<1/n;

  2)输出1/n;

  3)计算f=f-1/n;

  4)若此时的f是埃及分数,输出f,算法结束,否则返回1)。

 

数学模型

   记真分数F=A/B;对B/A进行整除运算,商为D, 余数为0<K<A,它们之间的关系及导出关系如下:

      B=A*D+K,B/A=D+K/A<D+1,A/B>1/(D+1),记C=D+1。

   这样我们就找到了分数F所包含的“最大的”埃及分数就是1/C。进一步计算:

               A/B-1/C=(A*C-B)/B*C

也就是说继续要解决的是有关分子为A=A*C-B,分母为B=B*C的问题。

 

算法设计

  由以上数学模型,真正的算法过程如下:

  1)设某个真分数的分子为A(≠1),分母为B;

  2)把B除以A的商的整数部分加1后的值作为埃及分数的一个分母C;

  3)输出1/C;

  4)将A乘以C减去B作为新的A;

  5)将B乘以C作为新的B;

  6)如果A大于1且能整除B,则最后一个分母为B/A;

  7)如果A=1,则最后一个分母为B;否则转步骤(2).

 技术图片

算法

main()
{  int a,b,c;
    print(“input   element”);
    input(a);
    print(“input   denominator”);
    input(b);
    if(a<b)
         print(“input  error”);
    else if (a=1 or b mod a=0)  
    print( a, "/",b, "=" 1, "/",b/a);
    else
  while(a<>1)
   { c = b \ a + 1
      a = a * c - b: b = b * c
       print( "1/",c);
       if  (b mod  a =0  ) 
       {   print ("+1/"; b / a);
           a=1;}
       if( a > 1)
            print("+");
       }    
     }

  

 

相对或近似贪婪问题

【例4】币种统计问题

    某单位给每个职工发工资(精确到元)。为了保证不要临时兑换零钱, 且取款的张数最少,取工资前要统计出所有职工的工资所需各种币值(100,50,20,10,5,2,1元共七种)的张数。请编程完成。

算法设计

 1) 从键盘输入每人的工资。

 2) 对每一个人的工资,用“贪婪”的思想,先尽量多地取大面额的币种,由大面额到小面额币种逐渐统计。

 3) 利用数组应用技巧,将七种币值存储在数组B。这样,七种 币值就可表示为B[i],i=1,2,3,4,5,6,7。为了能实现贪婪策略,七种币应该从大面额的币种到小面额的币种依次存储。

 4) 利用数组技巧,设置一个有7个元素的累加器数组S。

 

算法

main( )
 { int i,j,n,GZ,A;
   int B[8]={0,100,50,20,10,5,2,1},S[8];
   input(n);
   for(i=1;i<=n;i++)
     { input(GZ);
       for(j=1,j<=7;j++) 
          { A=GZ/B[j];
            S[j]=S[j]+A;
            GZ=GZ-A*B[j];}
        }
   for(i=1;i<=7;i++)
        print(B[i], “----”, S[i]);
  }

算法说明

     每求出一种面额所需的张数后, 一定要把这部分金额减去:“GZ=GZ-A*B[j];”,否则将会重复计算。

算法分析

           算法的时间复杂性是O(n)。

 

解决问题的贪婪策略:

    以上问题的背景是在我国,题目中不提示我们也知道有哪些币种,且这样的币种正好适合使用贪婪算法(感兴趣的读者可以证明这个结论)。假若,某国的币种是这样的,共9种:100,70,50,20,10,7,5,2,1。在这样的币值种类下,再用贪婪算法就行不通了,比如某人工资是140,按贪婪算法140=100*(1张)+20*(2张)共需要3张,而事实上,只要取2张70面额的是最佳结果,这类问题可以考虑用动态规划算法来解决。

    由此,在用贪婪算法策略时,最好能用数学方法证明每一步的策略是否能保证得到最优解。

 

 

例5】取数游戏

有2个人轮流取2n个数中的n个数,取数之和大者为胜。请编写算法,让先取数者胜,模拟取数过程。

问题分析

    这个游戏一般假设取数者只能看到2n个数中两边的数,用贪婪算法的情况:

    若一组数据为:6,16,27,6,12,9,2,11,6,5。用贪婪策略每次两人都取两边的数中较大的一个数,先取者胜.以A先取为例:

    取数结果为:

                 A  6,27,12,5,11=61  胜

                 B  16,6,9,6,2=39

其实,若我们只能看到两边的数据,则此题无论先取还是后取都无必胜的策略。这时一般的策略是用近似贪婪算法。

    但若取数者能看到全部2n个数,则此问题可有一些简单的方法,有的虽不能保证所取数的和是最大,但确是一个先取者必胜的策略。

 

数学模型建立:N个数排成一行,我们给这N个数从左到右编号,依次为1,2,…,N,因为N为偶数,又因为是我们先取数,计算机后取数,所以一开始我们既可以取到一个奇编号的数(最左边编号为1的数)又可以取到一个偶编号的数(最右边编号为N的数)。

   如果我们第一次取奇编号(编号为1)的数,则接着计算机只能取到偶编号(编号为2或N)的数;

  如果我们第一次取偶编号(编号为N)的数,则接着计算机只能取到奇编号(编号为1或N-1)的数;

  即无论我们第一次是取奇编号的数还是取偶编号的数,接着计算机只能取到另一种编号(偶编号或奇编号)的数。

    这是对第一个回合的分析,显然对以后整个取数过程都适用。也就是说,我们能够控制让计算机自始自终只取一种编号的数。这样,我们只要比较奇编号数之和与偶编号数之和谁大,以决定最开始我们是取奇编号数还是偶编号数即可。(如果奇编号数之和与偶编号数之和同样大,我们第一次可以任意取数,因为当两者所取数和相同时,先取者为胜。

 

算法设计:有了以上建立的高效数学模型,算法就很简单了,算法只需要分别计算一组数的奇数位和偶数位的数据之和,然后就先了取数者就可以确定必胜的取数方式了。

以下面一排数为例:

1 2 3 10 5 6 7 8 9 4

奇编号数之和为25(=1+3+5+7+9),小于偶编号数之和为30(=2+10+6+8+4)。我们第一次取4,以后,计算机取哪边的数我们就取哪边的数(如果计算机取1,我们就取2;如果计算机取9,我们就取8)。这样可以保证我们自始自终取到偶编号的数,而计算机自始自终取到奇编号的数。

 

算法如下:

main( )
{int i,s1,s2,data;
input(n);  s1=0; s2=0;
 for(i=1;i<=n;i=i+1)
   {input( data);
    if (i  mod 2=0)       s2=s2+data;
            else            s1=s1+data;
         if(s1>s2)       print(“first take left”);
          else           print(“first take right”);

  

贪婪策略算法设计框架

1.贪心法的基本思路:

从问题的某一个初始解出发逐步逼近给定的目标,每一步都作一个不可回溯的决策,尽可能地求得最好的解。当达到某算法中的某一步不需要再继续前进时,算法停止。

2.该算法适用的问题:

    贪婪算法对问题只需考虑当前局部信息就要做出决策,也就是说使用贪婪算法的前提是“局部最优策略能导致产生全局最优解”。

       该算法的适用范围较小, 若应用不当, 不能保证求得问题的最佳解。一般情况下通过一些实际的数据例子(当然要有一定的普遍性),就能从直观上就能判断一个问题是否可以用贪婪算法,如本节的例2。更准确的方法是通过数学方法证明问题对贪婪策略的选用性。

3.该策略下的算法框架:

       从问题的某一初始解出发;

       while能朝给定总目标前进一步do;

       利用可行的决策,求出可行解的一个解元素;

       由所有解元素组合成问题的一个可行解。

4.贪婪策略选择:

首先贪婪算法的原理是通过局部最优来达到全局最优,采用的是逐步构造最优解的方法。在每个阶段,都作出一个看上去最优的(在一定的标准下),决策一旦作出,就不可再更改。用贪婪算法只能解决通过局部最优的策略能达到全局最优的问题。因此一定要注意判断问题是否适合采用贪婪算法策略,找到的解是否一定是问题的最优解。

 

10算法策略之贪婪法

标签:山顶   超过   数字   读者   获得   分数   数据结构   cpp   产生   

原文地址:https://www.cnblogs.com/gd-luojialin/p/10384530.html

(0)
(0)
   
举报
评论 一句话评论(0
登录后才能评论!
© 2014 mamicode.com 版权所有  联系我们:gaon5@hotmail.com
迷上了代码!