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;
    }
}