[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.

题目大意：
两个无序数组，数组g是孩子们 ，数组s是饼干 。
每个蛋糕有自己的尺寸 。
每个孩子对蛋糕的尺寸有个最小要求，要让孩子接受这个饼干，那么尺寸必须达标。
任务就是如何分配这些蛋糕，使得尽量多的孩子接受你的饼干。返回能接受的孩子数量

思路：
首先对两个数组进行排序,然后按照优先满足贪婪度较低孩子的原则,若饼干大小能满足,则将它分配给该孩子,若不能,则看比它大一点的饼干能不能满足,而之前的饼干必然满足不了其他所有人的欲望.

代码如下：

• 代码1

C++

#include <iostream>
#include <vector>
#include<algorithm>
using namespace std;
class Solution {
public:
    //g[] children    s[] cookies
    //首先对两个数组进行排序,然后按照优先满足贪婪度较低孩子的原则,
    //若饼干大小能满足,则将它分配给该孩子,
    //若不能,则看比它大一点的饼干能不能满足,而之前的饼干必然满足不了其他所有人的欲望.

 //循环套循环 明显效率低
    int findContentChildren(vector<int>& g, vector<int>& s) {
        int maxNum=0;
        sort(g.begin(), g.end());
        sort(s.begin(), s.end());

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

• 代码2

//单循环 效率提高明显
int findContentChildren1(vector<int>& g, vector<int>& s) {
        int maxNum = 0;
        sort(g.begin(), g.end());//将两个数组排序
        sort(s.begin(), s.end());
        int i = 0;
        int j = 0;
        while(i<g.size() && j<s.size()){
            if(g[i] <= s[j]){//不满足条件 maxNum+1 两个数组下标+1
                maxNum++;
                i++;
                j++;
            }
            else{
                j++;//不满足条件 s下标+1 继续和原g[i]比较
            }
        }
        return maxNum;
    }

• 代码3

//代码2写出来后发现maxNum完全可以用i来取代
    int findContentChildren2(vector<int>& g, vector<int>& s) {
        sort(g.begin(), g.end());
        sort(s.begin(), s.end());
        int i = 0;
        int j = 0;
        while(i<g.size() && j<s.size()){
            if(g[i] <= s[j]){
                i++;
                j++;
            }
            else{
                j++;
            }
        }
        return i;
    }

• 代码4

int findContentChildren3(vector<int>& g, vector<int>& s) {
//和上面方法差不多
        int maxNum = 0;
        sort(g.begin(), g.end());
        sort(s.begin(), s.end());
        for(int Size:s) {
            if(Size >= g[maxNum]) {
                ++maxNum;
                if(maxNum == g.size())
                    break;
            }
        }
        return maxNum;
    }

• 代码5

//从数组后面遍历
int findContentChildren4(vector<int>& g, vector<int>& s) {
        int maxNum = 0;
        sort(g.begin(),g.end());
        sort(s.begin(),s.end());

        int i = g.size()-1;
        int j = s.size()-1;
        while(j >= 0){
            while(i >= 0 && g[i]> s[j]) //找到符合条件的孩子下标
                i--;
            if(i >= 0) //若符合条件的孩子下标在数组内 maxNum+1
                maxNum++;
            j--;
            i--;
        }
        return maxNum;
    }

注意：

1. sort排序头文件 algorithm