基础算法系列总结：贪心算法

     前几天参加了一下ACM比赛，呵呵，权当陪太子读书了，成绩有一点点不好，不过都已经过去了。比赛可以没有，博文不能不继续，呵呵，今天我总结我最近练习的贪心算法。我写文章的顺序是先写的  动态规划 ， 回溯算法 ，分支限界算法 然后再准备写写贪心算法以及基本的递归和分治算法，计算机最常用的算法就这么几种了，如果真正对算法感兴趣的话可以多研究研究算法导论，其实写算法给人的成就感比做项目要大，我们现在的项目其实都不太需要别特好的算法，大都都是阅读SDK等等文档等，运用设计模式，面向对象等基本都可以解决。当然，我也曾经遇到了对数学要求非常非常高的项目，设计到解高斯方程，微分积分这些，不过我当时没有参与这个项目。呵呵。说白了，不太愿意做这样的项目,也对自己没有太多的底气去做这样的项目。

     贪心算法在几个基本算法里面算是相对简单的算法了，思路也是非常简单的，每一步总是做出在当前看来最好的选择。也就是说贪心算法并不从整体最优考虑，它所作出的选择只是在某种意义上的局部最优选择。基本思路就是从问题的某一个初始解出发逐步逼近给定的目标，以尽可能快的地求得更好的解。当达到某算法中的某一步不能再继续前进时，算法停止。

    对于这个比较简单的算法，我们就先了解一下他的利弊吧，利当然就是简单，省时，好用。下面我们看看贪心法存在的一些问题。

贪心法存在的问题：
1. 不能保证求得的最后解是最佳的；
2. 不能用来求最大或最小解问题；
3. 只能求满足某些约束条件的可行解的范围

上述的这些问题可以在动态规划 ， 回溯算法 ，分支限界算法 里面得到相应的解决，但是我们也不会因此放弃对贪心算法的使用。这正是敏捷开发所提倡的,永远没有最好的，只有最适合的.我们选用贪心算法的原因就是因为他能够满足当前的需要并且比其他算法更加简单。

下面请看示例题：

有N个商品,每个商品的重量为WI,价格为:PI,现有一个背包，最多能装Ｍ的重量．其中(0<=I<N,0<wi<M).

问：怎样装能使包中装入的商品价值最高（对于每个商品可以只装该商品的一部分）

伪代码：

参数分别为 n:物品数   M：背包最多能装的重量   v[]：价值数组   w[]重量数组

void Knapsack(int n,float M,float v[],float w[],float x[])

{

Sort(n,v,w);     //进行排序

int i;

for (i = 1 ; i <= n ; i++)

x[i] = 0;

     float c=M;    //C为背包剩余空间

    for (i=1;i<=n;i++) {

   if (w[i] > c) break;

       x[i]=1;   //选取第i个物品

      c-=w[i];    //剩余重量减少

   }

if (i <= n)  //当此时背包的容量不够存放整个物品的情况时，存放一部分

    x[i]=c / w[i];

}

具体代码如下：

View Code

#include < stdio.h >

// 参数:n表示是背包可以存放物品的种类
// 参数:指针p指向的数组是存放物品价值的数组
// 参数:指针q指向的数组是存放物品重量的数组
static   void  sort( int  n, float   * p, float   * q)
{
  int  i;
  int  j;
  for (i = 0 ;i < n - 1 ;i ++ )
  for (j = i + 1 ;j < n;j ++ )
  if (( * (p + i)) / ( * (q + i)) < ( * (p + j)) / ( * (q + j)))
 {
   float  f;
  f =* (p + i);
   * (p + i) =* (p + j);
   * (p + j) = f;
  
  f =* (q + i);
   * (q + i) =* (q + j);
   * (q + j) = f;
 }
  
}
 

// 参数：指针x指向的数组是存放物品的情况
// 参数：m表示的是背包的容量
// 参数:n表示的是背包可以存放物品的种类
static   void  knapsack( int  n, float  m, float   * v, float   * w, float   * x)
{
 sort(n,v,w);
  int  i;
  for (i = 0 ;i < n;i ++ )
 {
   if ( * (w + i) > m) 
    break ;
   // 可以存放该物品时，置1
   * (x + i) = 1 ;
   // 放入后,背包的容量减少
  m -=* (w + i);
 }
  // 当此时背包的容量不够存放整个物品的情况时，存放一部分
  if (i < n)
   * (x + i) = m / ( * (w + i));
 
}
 
int  main()
{
  int  n = 6 ; // 物品种类 
  int  m = 100 ; // 背包容量
  float  w1[ 6 ] = { 15 , 5 , 60 , 25 , 55 , 80 }; // 各种物品的重量
  float  v1[ 6 ] = { 20 , 30 , 30 , 10 , 55 , 40 }; // 各种物品的价值
  float  x1[ 6 ]; // 存放各种物品的存放情况
  float   * x;
  float   * w;
  float   * v;
 w = w1;
 v = v1;
 x = x1;
 
 
  int  i;
 
  for (i = 0 ;i < n;i ++ )
  * (x + i) = 0 ;
 
 knapsack(n,m,v1,w1,x);
 
 printf( " \n===========输出物品容量数组内容======================\n " );
 
  for (i = 0 ;i < n;i ++ )
 printf( " %.1f\t " , * (w + i));
 
 printf( " \n============输出物品价值数组内容=====================\n " );
 
  for (i = 0 ;i < n;i ++ )
 printf( " %.1f\t " , * (v + i));
 
 printf( " \n============输出物品存放情况数组=====================\n " );
  for (i = 0 ;i < n;i ++ )
 printf( " %.1f\t " , * (x + i));
 
 printf( " \n============END=====================\n " );
 
return   0 ; 
}

 算法knapsack的主要计算时间在于将各种物品依其单位重量的价值从大到小排序。若不计较排序的是时间，单单贪心策略的算法复杂度只有O(n),上面的这个例子使用了O(n*n)的排序算法，这里只是为了简单而已，实际上我们可以选择合适的排序算法将排序部分的复杂度降到O(nlgn)..如堆排序，快速排序等等

这里我没有记录完整的例子完全是因为这个算法太好理解了 ，贪心算法一般在开始策略选择前会进行排序，排好序后就进行最优化选择，这和我们生活中找钱的规律是一样的，如我需要找87块钱给顾客，我会怎么做，首先我们知道10〉5>1这个排序，然后更具我们的经验，我们出具8张10块（最大化贪心原则）然后出具 一张5块，最后出具两张一块.当然你也可以说，我全部给一块或者给不给10块只给5块和1块，但是，那不是最简便的方法，细心一下，生活中处处是算法.

 

 

算法系列目录：

1.算法系列总结：分治算法

2.算法系列总结：贪心算法

3.算法系列总结：动态规划(解公司外包成本问题）

4.算法系列总结：回溯算法（解火力网问题）

5.算法系列总结：分支限界算法  

转载于:https://www.cnblogs.com/Creator/archive/2011/06/07/2074227.html