Assume you are an awesome parent and want to give your children some cookies. But, you should give each child at most one cookie. Each child i has a greed factor gi, which is the minimum size of a cookie that the child will be content with; and each cookie j has a size sj. If sj >= gi, we can assign the cookie j to the child i, and the child i will be content. Your goal is to maximize the number of your content children and output the maximum number.
Note:
You may assume the greed factor is always positive.
You cannot assign more than one cookie to one child.
Example 1:
Input: [1,2,3], [1,1]
Output: 1
Explanation: You have 3 children and 2 cookies. The greed factors of 3 children are 1, 2, 3.
And even though you have 2 cookies, since their size is both 1, you could only make the child whose greed factor is 1 content.
You need to output 1.
Example 2:
Input: [1,2], [1,2,3]
Output: 2
Explanation: You have 2 children and 3 cookies. The greed factors of 2 children are 1, 2.
You have 3 cookies and their sizes are big enough to gratify all of the children,
You need to output 2.
超时做法:
class Solution {
public:
int findContentChildren(vector<int>& g, vector<int>& s) {
if(!(g.size()&&s.size())) return 0;
int count=0;
for(vector<int>::iterator itg=g.begin();itg!=g.end();itg++)
{
if(s.size()==0) break;
vector<int>::iterator its=s.begin();
vector<int>::iterator itmark=s.begin();
int mins=*its;
int mark_in=0;
int mark_out=0;
for( ;its!=s.end();its++)
{
if(*its>=*itg)
{
if(mark_in==0)
{
mark_in=1;
mins=*its;
}
if(*its<=mins)
{
itmark=its;
mark_out=1;
}
}
}
if(mark_out==1)
{
s.erase(itmark);
count++;
}
}
return count;
}
};
于是改用了贪心法算:
class Solution {
public:
static bool less(const int &a,const int &b)
{
return a<b;
}
int findContentChildren(vector<int>& g, vector<int>& s) {
int count=0;
sort(g.begin(),g.end(),less);//默认就是从大到小排序,即可以不用加less这个函数,这里只是示例
sort(s.begin(),s.end(),less);//
vector<int>::iterator itg=g.begin();
vector<int>::iterator its=s.begin();
for(;itg!=g.end();itg++)
{
for(;its!=s.end();its++)
{
if(*its>=*itg)
{
count++;
its++;
break;
}
}
}
return count;
}
};
注意,这里其实可以不用less函数而直接写
sort(g.begin(),g.end());和 sort(s.begin(),s.end());
因为默认就是从大到小的。
如果想实现从小到大的话就改为a>b
而且一定要用static,因为sort是全局函数,而非静态成员函数是依赖于具体对象的,无法被全局函数调用。静态成员函数或全局函数是不依赖于具体对象的,可以不经实例化就能调用。同时类的静态成员函数不可以调用类的非静态成员