6.7 分发饼干 && 摆动序列 && 跳跃游戏 && 加油站（贪心算法）

分发饼干

思想：先用大的饼干去满足胃口大的孩子，以此来保证大饼干的收益最大化。

    public int findContentChildren(int[] g, int[] s) {
    	//g是孩子胃口
    	Arrays.sort(g);
    	Arrays.sort(s);
    	//尺寸大的饼干先去满足胃口大的孩子
    	int j=s.length-1;
    	int count=0;
    	for(int i=g.length-1; i>=0 && j>=0; i--) {
    		if(g[i]<=s[j]) {
    			count++;
    			j--;
    		}
    	}
    	return count;
    }

摆动序列

思想：pre当前的摆动序列的末尾，flag==true代表前面是一个波峰，false代表前面是一个波谷。

但是这道题是有三种情况，前面既不是波峰也不是波谷，所以我第一次的代码写的有问题而且很繁琐，不应该设置flag，反而复杂了。直接由前一个差值来表示波峰、波谷

    public int wiggleMaxLength(int[] nums) {
    	if(nums.length<2)return nums.length;
    	if(nums.length==2 && nums[0]!=nums[1])return nums.length;
    	if(nums.length==2 && nums[0]==nums[1])return 1;    
    	int pre=nums[1];
    	boolean flag = false;
    	int count = 0;
    	if(nums[1]-nums[0]>0) {
    		flag=true;
    		count=2;
    	}
    	else if(nums[1]-nums[0]<0) {
    		flag=false;
    		count=2;
    	}
    	else if (nums[1]-nums[0]==0) {
			count=1;
			flag=false;
		}
    	for(int i=2; i<nums.length; i++) {
    		if(nums[i]>pre && flag==false) {
    			count++;
    			pre=nums[i];
    			flag=true;
    		}
    		else if(nums[i]<pre && flag==true) {
    			count++;
    			pre=nums[i];
    			flag=false;
    		}
    	}
    	return count;
    }

AC

public int wiggleMaxLength(int[] nums) {
        if (nums.length <= 1) {
            return nums.length;
        }
        //当前差值
        int curDiff = 0;
        //上一个差值
        int preDiff = 0;
        int count = 1;
        for (int i = 1; i < nums.length; i++) {
            //得到当前差值
            curDiff = nums[i] - nums[i - 1];
            //如果当前差值和上一个差值为一正一负
            //等于0的情况表示初始时的preDiff
            if ((curDiff > 0 && preDiff <= 0) || (curDiff < 0 && preDiff >= 0)) {
                count++;
                preDiff = curDiff;
            }
        }
        return count;
    }

买卖股票的最佳时机2

思想：把整体利润拆分为每天的利润，然后只用收集每天的正利润（真正赚钱的买卖股票时机）。

想获得利润至少要两天为一个交易单元

假如第0天买入，第3天卖出，那么利润为：prices[3] - prices[0]。

相当于(prices[3] - prices[2]) + (prices[2] - prices[1]) + (prices[1] - prices[0])。

此时就是把利润分解为每天为单位的维度，而不是从0天到第3天整体去考虑！

那么根据prices可以得到每天的利润序列：(prices[i] - prices[i - 1]).....(prices[1] - prices[0])。

    public int maxProfit(int[] prices) {
        int[] profile=new int[prices.length-1];
        for(int i=0; i<prices.length-1; i++) {
        	profile[i]=prices[i+1]-prices[i];
        }
        int sum=0;
        for(int i=0; i<profile.length; i++) {
        	sum+=Math.max(profile[i], 0);
        }
        return sum;
    }

跳跃游戏

思想：每次跳到一个地方。就用当前能跳的最大步数和nums[i]作比较，选最大的。如果maxdis==0,则说明跳不动了。

	 public boolean canJump(int[] nums) {
		 int maxdis=nums[0];
		 int i;
		 for(i=1; i<nums.length; i++) {
             if(maxdis-1<0)break;
			 maxdis=Math.max(maxdis-1, nums[i]);
		 }
		 if(i==nums.length)return true;
		 else return false;
	 }

跳跃游戏2

思想：用当前的可覆盖最大距离和下一步可以覆盖的最大距离作比较，谁大取谁

	    public int jump(int[] nums) {
	        if (nums == null || nums.length == 0 || nums.length == 1) {
	            return 0;
	        }
	        //记录跳跃的次数
	        int count=0;
	        //当前的覆盖最大区域
	        int curDistance = 0;
	        //最大的覆盖区域
	        int maxDistance = 0;
	        for (int i = 0; i < nums.length; i++) {
	            //在可覆盖区域内更新最大的覆盖区域
	            maxDistance = Math.max(maxDistance,i+nums[i]);
	            //说明当前一步，再跳一步就到达了末尾
	            if (maxDistance>=nums.length-1){
	                count++;
	                break;
	            }
	            //走到当前覆盖的最大区域时，更新下一步可达的最大区域
	            if (i==curDistance){
	                curDistance = maxDistance;
	                count++;
	            }
	        }
	        return count;
	    }

加油站

暴力解法，但是超时了

   public int canCompleteCircuit(int[] gas, int[] cost) {
    	int rest=0;//记录剩余油量
    	int index;//记录起始位置；
    	for(int i=0; i<gas.length; i++) {
    		rest=gas[i]-cost[i];
    		index=(i+1)%gas.length;
    		//模拟以i为起点走一圈
    		while(rest>0 && index!=i) {
    			rest=rest+gas[index]-cost[index];
    			index=(index+1)%gas.length;
    		}
    		if(rest>=0 && index==i)return index;
    	}
    	return -1;
    }

如果rest加起来小于0，肯定找不到一个起点能使其环岛行驶。

如果碰见rest小于0的时候，应该将start=i+1，因为此时rest小于0，你需要在下一段加油站去寻找可能环岛的点。

    public int canCompleteCircuit(int[] gas, int[] cost) {
    	int start=0, rest=0;
    	for(int i=0; i<gas.length; i++) {
    		rest+=gas[i]-cost[i];
    	}
    	if(rest<0)return -1;
    	rest=0;
    	for(int i=0; i<gas.length; i++) {
    		rest+=gas[i]-cost[i];
    		if(rest<0) {
    			start=i+1;
    			rest=0;
    		}
    	}
    	return start;
    }