贪心算法

贪心算法（又称贪婪算法）是指，在对问题求解时，总是做出在当前看来是最好的选择。也就是说，不从整体最优上加以考虑，他所做出的是在某种意义上的局部最优解。

关键思想：就是黑猩猩掰棒子的思想，每次与下一个作比较，如果下一个比较好，那么我就扔掉上一个，获取下一个，也就是说，只关注手中的这一个和下一个，而不关注其他，这样就可以得到局部最优解，在某些问题上就可以得到全局最优解（但是对于智能算法之类的，就可能达不到整体最优值的需求，这里不做讨论）。

1.求解数组中连续数据的最大和

C++代码：

#include<iostream>
#include<string>
#include<vector>
using namespace std;

int MaxSubstring(vector<int>& vec)
{
int sum = vec[0];
int curmax = vec[0];
int i;

for(i=1;i<vec.size();i++)
{
curmax += vec[i];
if(curmax<0)
curmax = 0;
if(curmax>sum)
sum = curmax;
}

if(sum<0){
for(i=0;i<vec.size();i++)
if(vec[i]>sum)
sum = vec[i];
}

return sum;
}

int main()
{
int array[]={-1,1,-3,4,-1,2,1,-5,4};
vector<int> vec(array,array+sizeof(array)/sizeof(int));
cout<<MaxSubstring(vec)<<endl;
return 0;
}

运行结果：

2.糖果问题

问题描述：给站成一排的孩子分糖果，要求给高的孩子的糖果要比他周围比他矮的的孩子的糖果多，问最少要分多少糖果？

C++代码：

#include<iostream>
#include<vector>
using namespace std;

int candy(vector<int>& ratings)
{
vector<int> candy(ratings.size(),1);
int sum,i;
for(i=1;i<ratings.size();i++)
{
if(ratings[i]>ratings[i-1])
candy[i]=candy[i-1]+1;
}
sum=candy[ratings.size()-1];
for(i=ratings.size()-2;i>=0;i--)
{
if(ratings[i]>ratings[i+1]&&candy[i]<=candy[i+1])
candy[i]=candy[i+1]+1;
sum += candy[i];
}
return sum;
}

int main()
{
int array[]={4,2,6,8,5};
vector<int> vec(array,array+sizeof(array)/sizeof(int));
cout<<candy(vec)<<endl;
return 0;
}

运行结果：

3.跳远问题：

问题描述：一个数组表示能从当前跳的最大步数，问能否跳的出去这个数组？

C++代码：

#include<iostream>
#include<vector>
using namespace std;

bool canJump(vector<int>& vec)
{
if(vec.size()<=0)
return true;
int maxstep = vec[0];
int i;
for(i=1;i<vec.size();i++)
{
if(maxstep == 0)
return false;
maxstep--;
if(maxstep<vec[i])
maxstep = vec[i];
if(maxstep+i >= vec.size()-1)
return true;
}
}

int main()
{
int array[]={2,3,1,1,4};
vector<int> vec(array,array+sizeof(array)/sizeof(int));
cout<<canJump(vec)<<endl;
return 0;
}

运行结果：