455. Assign Cookies

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是全局函数，而非静态成员函数是依赖于具体对象的，无法被全局函数调用。静态成员函数或全局函数是不依赖于具体对象的，可以不经实例化就能调用。同时类的静态成员函数不可以调用类的非静态成员