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

这一题跟51nod抓兔子那一题有所类似，但是更简单，根本就用不上优先级队列。

package leetcode;

public class Assign_Cookies_455 {

public int findContentChildren(int[] g, int[] s) {
if(g.length==0||s.length==0){
return 0;
}
quicksort(g, 0, g.length-1);//children
quicksort(s, 0, s.length-1);//cookies
int cookiePointer=0;
for(int chidrenPointer=0;chidrenPointer<g.length;chidrenPointer++){
int childrenNeed=g[chidrenPointer];
if(childrenNeed>s[cookiePointer]){
continue;
}
else{
cookiePointer++;
if(cookiePointer==s.length){
break;
}
}
}
return cookiePointer;
}

//倒序快排
public void quicksort(int[] a,int left,int right){
if(left<right){
int low=left;
int high=right;
int pivot=a[low];
while(low<high){
while(low<high&&a[high]<=pivot){
high--;
}
if(low<high){
a[low]=a[high];
low++;
}
while(low<high&&a[low]>=pivot){
low++;
}
if(low<high){
a[high]=a[low];
high--;
}
}
a[low]=pivot;
quicksort(a, left, low-1);
quicksort(a, low+1, right);
}
}

public static void main(String[] args) {
// TODO Auto-generated method stub
Assign_Cookies_455 a=new Assign_Cookies_455();
int[] g=new int[]{1,2,3};
int[] s=new int[]{3};
System.out.println(a.findContentChildren(g, s));
}

}

大神想法跟我类似，只不过是从小到大排序，然后搜索第一个比孩子欲望大的饼。

public class Solution {
public int findContentChildren(int[] g, int[] s) {
Arrays.sort(g);
Arrays.sort(s);

int pointG = 0;
int pointS = 0;

while (pointG<g.length && pointS<s.length) {
if (g[pointG]<=s[pointS]) {
pointG++;
pointS++;
} else {
pointS++;
}
}

return pointG;
}
}

另外一种方法是，使用treemap，treemap内部实现原理是红黑树哦。

首先用treemap记录cookie的<size,个数>，treemap有一个方法叫ceilingKey，The method call returns the least key greater than or equal to key, or null if there is no such key.再对于每个children的贪婪度进行遍历，如果有正好大于等于它的饼，那么就对map做出修改：如果该size只有一个，那么个数减少后，个数为0，那么从map中去掉这个size；如果个数不为1，那么个数--。

public class AssignCookies {
public static int findContentChildren(int[] g, int[] s) {
int count = 0;
TreeMap<Integer,Integer> tree = new TreeMap<>();
for(int temp : s){
Integer num = tree.get(temp);
num = num==null?0:num;
tree.put(temp,num+1);
}
for(int temp : g){
Integer targ = tree.ceilingKey(temp);
if(targ!=null){
Integer num = tree.get(targ);
if(num>0){
count++;
if(num==1){
tree.remove(targ);
}else{
tree.put(targ, num - 1);
}
}
}
}
return count;
}
}