LeetCode_455. Assign Cookies

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.

题意理解：
给N个孩子分M块饼干，每个孩子最多分得一块，每个孩子有其满足值g，只有当饼干的大小s超过孩子的满足值时，将饼干分给这个孩子，尽可能多的使满足的孩子最多，求这个数量。

解题思路：
先排序，再两次循环。

class Solution {
public:
    int findContentChildren(vector<int>& g, vector<int>& s) {
        sort(g.begin(), g.end());
        sort(s.begin(), s.end());
        int count=0;

        int j=0;
        for (int i=0; i<g.size(); i++)
        {
            while (j<s.size())
            {
                if (g[i]<=s[j++])
                {
                    count++;
                    break;
                }
            }
        }
        return count;
    }
};

运行时间400+ms（好慢好慢）, 即使贪婪值较低的孩子也无法得到合适大小的饼干，那么就没有必要考虑是否能满足贪婪值更高的孩子，但代码上还是会进行所有的循环，效率较低。

Top Solution:

class Solution {
public:
    int findContentChildren(vector<int>& g, vector<int>& s) {
        sort(g.begin(), g.end());
        sort(s.begin(), s.end());
        int i=0, j=0; //two pointers

    while (i<g.size() && j<s.size())
        {
            if (g[i]<s[j])
            {
                i++; 
                j++;
            }
            else
            {
                j++;
            }
        }
        return i;
     }
};