贪心.力扣

860. 柠檬水找零

在柠檬水摊上，每一杯柠檬水的售价为 5 美元。顾客排队购买你的产品，（按账单 bills 支付的顺序）一次购买一杯。

每位顾客只买一杯柠檬水，然后向你付 5 美元、10 美元或 20 美元。你必须给每个顾客正确找零，也就是说净交易是每位顾客向你支付 5 美元。

注意，一开始你手头没有任何零钱。

给你一个整数数组 bills ，其中 bills[i] 是第 i 位顾客付的账。如果你能给每位顾客正确找零，返回 true ，否则返回 false 。

示例 1：

输入：bills = [5,5,5,10,20]
输出：true
解释：
前 3 位顾客那里，我们按顺序收取 3 张 5 美元的钞票。
第 4 位顾客那里，我们收取一张 10 美元的钞票，并返还 5 美元。
第 5 位顾客那里，我们找还一张 10 美元的钞票和一张 5 美元的钞票。
由于所有客户都得到了正确的找零，所以我们输出 true。

示例 2：

输入：bills = [5,5,10,10,20]
输出：false
解释：
前 2 位顾客那里，我们按顺序收取 2 张 5 美元的钞票。
对于接下来的 2 位顾客，我们收取一张 10 美元的钞票，然后返还 5 美元。
对于最后一位顾客，我们无法退回 15 美元，因为我们现在只有两张 10 美元的钞票。
由于不是每位顾客都得到了正确的找零，所以答案是 false。

提示：

• 1 <= bills.length <= 105
• bills[i] 不是 5 就是 10 或是 20

class Solution {
    public boolean lemonadeChange(int[] bills) {
        int bag[]={0,0};
        for (int i = 0; i < bills.length; i++) {
            //5元不找零
            if(bills[i]==5){
                bag[0]++;
            }
            //10元找5元
            if(bills[i]==10){
                if(bag[0]>0){
                    bag[0]--;
                    bag[1]++;
                }else return false;
            }
            //20元找15元
            if(bills[i]==20){
                if(bag[1]>0){
                    bag[1]--;
                    if(bag[0]>0){
                        bag[0]--;
                    }else return false;
                }
                else{
                    if(bag[0]>2){
                        bag[0]-=3;
                    }else return false;
                }
            }
        }
        return true;
    }
}

这里的贪心（好像是吧）：找钱时优先给顾客面值大的，比如20找10+5，而不是5+5+5

11. 盛最多水的容器

给定一个长度为 n 的整数数组 height 。有 n 条垂线，第 i 条线的两个端点是 (i, 0) 和 (i, height[i]) 。

找出其中的两条线，使得它们与 x 轴共同构成的容器可以容纳最多的水。

返回容器可以储存的最大水量。

说明：你不能倾斜容器。

示例 1：

输入：[1,8,6,2,5,4,8,3,7]
输出：49 
解释：图中垂直线代表输入数组 [1,8,6,2,5,4,8,3,7]。在此情况下，容器能够容纳水（表示为蓝色部分）的最大值为 49。

示例 2：

输入：height = [1,1]
输出：1

提示：

• n == height.length
• 2 <= n <= 105
• 0 <= height[i] <= 104

class Solution {
    public int maxArea(int[] height) {
        int left=0;
        int right=height.length-1;
        int max=Math.min(height[left],height[right])*(right-left);
        do{
            if(height[left]>height[right]){
                right--;
                if(Math.min(height[left],height[right])*(right-left)>max)
                    max=Math.min(height[left],height[right])*(right-left);
            }else {
                left++;
                if(Math.min(height[left],height[right])*(right-left)>max)
                    max=Math.min(height[left],height[right])*(right-left);
            }
        }while (left<right);
        return max;
    }
}

 双指针

42. 接雨水

给定 n 个非负整数表示每个宽度为 1 的柱子的高度图，计算按此排列的柱子，下雨之后能接多少雨水。

示例 1：

输入：height = [0,1,0,2,1,0,1,3,2,1,2,1]
输出：6
解释：上面是由数组 [0,1,0,2,1,0,1,3,2,1,2,1] 表示的高度图，在这种情况下，可以接 6 个单位的雨水（蓝色部分表示雨水）。 

示例 2：

输入：height = [4,2,0,3,2,5]
输出：9

提示：

• n == height.length
• 1 <= n <= 2 * 104
• 0 <= height[i] <= 105

class Solution {
    public int trap(int[] height) {
        int left,leftValue,right,rightValue;
        int sum=0;
        for (int i = 1; i < height.length-1; i++) {
            //以[i]为界限，向左向右找比它大的是否存在
            left=i;
            leftValue=height[i-1];
            right=i;
            rightValue=height[i+1];
            while(left>0){
                left--;
                if(height[left]>leftValue){
                    leftValue=height[left];
                }
            }
            if (leftValue<=height[i]) continue;
            while(right<height.length-1){
                right++;
                if(height[right]>rightValue){
                    rightValue=height[right];
                }
            }
            if (rightValue<=height[i]) continue;
            sum+=Math.min(leftValue,rightValue)-height[i];
        }
        return sum;
    }
}

561. 数组拆分

给定长度为 2n 的整数数组 nums ，你的任务是将这些数分成 n 对, 例如 (a1, b1), (a2, b2), ..., (an, bn) ，使得从 1 到 n 的 min(ai, bi) 总和最大。

返回该 最大总和 。

示例 1：

输入：nums = [1,4,3,2]
输出：4
解释：所有可能的分法（忽略元素顺序）为：
1. (1, 4), (2, 3) -> min(1, 4) + min(2, 3) = 1 + 2 = 3
2. (1, 3), (2, 4) -> min(1, 3) + min(2, 4) = 1 + 2 = 3
3. (1, 2), (3, 4) -> min(1, 2) + min(3, 4) = 1 + 3 = 4
所以最大总和为 4

示例 2：

输入：nums = [6,2,6,5,1,2]
输出：9
解释：最优的分法为 (2, 1), (2, 5), (6, 6). min(2, 1) + min(2, 5) + min(6, 6) = 1 + 2 + 6 = 9

提示：

• 1 <= n <= 104
• nums.length == 2 * n
• -104 <= nums[i] <= 104

import java.util.Arrays;

class Solution {
    public int arrayPairSum(int[] nums) {
        Arrays.sort(nums);
        for (int j = 2; j < nums.length; j+=2) {
            nums[0]+=nums[j];
        }
        return nums[0];
    }
}

122. 买卖股票的最佳时机 II

给你一个整数数组 prices ，其中 prices[i] 表示某支股票第 i 天的价格。

在每一天，你可以决定是否购买和/或出售股票。你在任何时候 最多 只能持有 一股 股票。你也可以先购买，然后在 同一天 出售。

返回 你能获得的 最大 利润 。

示例 1：

输入：prices = [7,1,5,3,6,4]
输出：7
解释：在第 2 天（股票价格 = 1）的时候买入，在第 3 天（股票价格 = 5）的时候卖出, 这笔交易所能获得利润 = 5 - 1 = 4 。
     随后，在第 4 天（股票价格 = 3）的时候买入，在第 5 天（股票价格 = 6）的时候卖出, 这笔交易所能获得利润 = 6 - 3 = 3 。
     总利润为 4 + 3 = 7 。

示例 2：

输入：prices = [1,2,3,4,5]
输出：4
解释：在第 1 天（股票价格 = 1）的时候买入，在第 5 天 （股票价格 = 5）的时候卖出, 这笔交易所能获得利润 = 5 - 1 = 4 。
     总利润为 4 。

示例 3：

输入：prices = [7,6,4,3,1]
输出：0
解释：在这种情况下, 交易无法获得正利润，所以不参与交易可以获得最大利润，最大利润为 0 。

提示：

• 1 <= prices.length <= 3 * 104
• 0 <= prices[i] <= 104

class Solution {
    public int maxProfit(int[] prices) {
        //贪心只要有收益为正就加进去
        int sum=0;
        for (int i = 1; i < prices.length; i++) {
            if(prices[i]>prices[i-1]){
                sum+=prices[i]-prices[i-1];
            }
        }
        return sum;
    }
}