贪心算法

       贪心算法（又称贪婪算法）是指，在对问题求解时，总是做出在当前看来是最好的选择。也就是说，不从整体最优上加以考虑，他所做出的是在某种意义上的局部最优解。（贪心算法不是对所有问题都能得到整体最优解，关键是贪心策略的选择，选择的贪心策略必须具备无后效性，即某个状态以前的过程不会影响以后的状态，只与当前状态有关。）

使用贪心算法的条件：

     1.具有最优子结构。

     2.贪心选择。

思想

贪心算法的基本思路是从问题的某一个初始解出发一步一步地进行，根据某个优化测度，每一步都要确保能获得局部最优解。每一步只考虑一个数据，他的选取应该满足局部优化的条件。若下一个数据和部分最优解连在一起不再是可行解时，就不把该数据添加到部分解中，直到把所有数据枚举完，或者不能再添加算法停止

 

贪心算法的基本思路：

1.建立数学模型来描述问题。
2.把求解的问题分成若干个子问题。
3.对每一子问题求解，得到子问题的局部最优解。
4.把子问题的解局部最优解合成原来解问题的一个解。

例题：

1.活动时间安排的问题

    设有N个活动时间集合，每个活动都要使用同一个资源，比如说会议场，而且同一时间内只能有一个活动使用，每个活动都有一个使用活动的开始si和结束时间fi，即他的使用区间为（si,fi）,现在要求你分配活动占用时间表，即哪些活动占用该会议室，哪些不占用，使得他们不冲突，要求是尽可能多的使参加的活动最大化，即所占时间区间最大化！

#include <iostream>  
using namespace std;  
  
void GreedyChoose(int len,int *s,int *f,bool *flag);  
  
int main(int argc, char* argv[])  
{  
    int s[11] ={1,3,0,5,3,5,6,8,8,2,12};  
    int f[11] ={4,5,6,7,8,9,10,11,12,13,14};  
  
    bool mark[11] = {0};  
  
    GreedyChoose(11,s,f,mark);  
    for(int i=0;i<11;i++)  
        if(mark[i])  
            cout<<i<<" ";  
    system("pause");  
    return 0;  
}  
  
void GreedyChoose(int len,int *s,int *f,bool *flag)  
{  
    flag[0] = true;  
    int j = 0;  
    for(int i=1;i<len;++i)  
        if(s[i] >= f[j])  
        {  
            flag[i] = true;  
            j = i;  
        }  
}  

2.背包问题：

有一个背包，背包容量是M=150。有7个物品，物品可以分割成任意大小。 
要求尽可能让装入背包中的物品总价值最大，但不能超过总容量。 
物品 A B C D E F G 
重量 35 30 60 50 40 10 25 

价值 10 40 30 50 35 40 30 

贪心策略：首先计算每种物品单位重量的价值Vi/Wi，然后，依贪心选择策略，将尽可能多的单位重量价值最高的物品装入背包。若将这种物品全部装入背包后，背包内的物品总重量未超过C，则选择单位重量价值次高的物品并尽可能多地装入背包。依此策略一直地进行下去，直到背包装满为止。

#include "stdafx.h"  
#include <iostream>   
using namespace std;   
  
const int N = 3;  
  
void Knapsack(int n,float M,float v[],float w[],float x[]);  
  
int main()  
{  
    float M = 50;//背包所能容纳的重量  
    //这里给定的物品按单位价值减序排序  
    float w[] = {0,10,20,30};//下标从1开始  
    float v[] = {0,60,100,120};  
  
    float x[N+1];  
  
    cout<<"背包所能容纳的重量为："<<M<<endl;  
    cout<<"待装物品的重量和价值分别为："<<endl;  
    for(int i=1; i<=N; i++)  
    {  
        cout<<"["<<i<<"]:("<<w[i]<<","<<v[i]<<")"<<endl;  
    }  
      
    Knapsack(N,M,v,w,x);  
  
    cout<<"选择装下的物品比例如下："<<endl;  
    for(int i=1; i<=N; i++)  
    {  
        cout<<"["<<i<<"]:"<<x[i]<<endl;  
    }  
  
    return 0;  
}  
  
void Knapsack(int n,float M,float v[],float w[],float x[])  
{  
    //Sort(n,v,w);//这里假定w[],v[]已按要求排好序  
    int i;  
    for (i=1;i<=n;i++)  
    {  
        x[i]=0;//初始化数组x[]  
    }  
  
    float c=M;  
    for (i=1;i<=n;i++)//物品整件被装下,x[i]=1  
    {  
        if (w[i]>c)  
        {  
            break;  
        }  
        x[i]=1;  
        c-=w[i];  
    }  
  
    //物品i只有部分被装下  
    if (i<=n)  
    {  
        x[i]=c/w[i];  
    }  
}  

3.最大整数

设有n个正整数，将它们连接成一排，组成一个最大的多位整数

例如：n=3时，3个整数13，312，343，连成的最大整数为3431213。
又如：n=4时，4个整数7，13，4，246，连成的最大整数为7424613。
输入：n
N个数

输出：连成的多位数

贪心：先把整数转换成字符串，然后在比较a+b和b+a，如果a+b>=b+a，就把a排在b的前面，反之则把a排在b的后面。

最后：

贪心算法不是对所有问题都能得到整体最优解，关键是贪心策略的选择，选择的贪心策略必须具备无后效性，即某个状态以前的过程不会影响以后的状态，只与当前状态有关。