1005、K 次取反后最大化的数组和

给你一个整数数组 nums 和一个整数 k ，按以下方法修改该数组：

• 选择某个下标 i 并将 nums[i] 替换为 -nums[i] 。

重复这个过程恰好 k 次。可以多次选择同一个下标 i 。

以这种方式修改数组后，返回数组 可能的最大和 。

示例 1：

输入：nums = [4,2,3], k = 1
输出：5
解释：选择下标 1 ，nums 变为 [4,-2,3] 。

示例 2：

输入：nums = [3,-1,0,2], k = 3
输出：6
解释：选择下标 (1, 2, 2) ，nums 变为 [3,1,0,2] 。

class Solution {
    public int largestSumAfterKNegations(int[] nums, int k) {
        // 排序，把可能有的负数排到前面
        Arrays.sort(nums);
        int sum = 0;
        for (int i = 0; i < nums.length; i++) {
            // 贪心：如果是负数，而k还有盈余，就把负数反过来
            if (nums[i] < 0 && k > 0) {
                nums[i] = -1 * nums[i];
                k--;
            }
            sum += nums[i];
        }
        Arrays.sort(nums);
        // 如果k没剩，那说明能转的负数都转正了，已经是最大和，返回sum，此时k等于0
        // 如果k有剩，说明负数已经全部转正，所以如果k还剩偶数个就自己抵消掉，不用删减，如果k还剩奇数个就减掉2倍最小正数。
        return sum - (k % 2 == 0 ? 0 : 2 * nums[0]); 
    }
}

134、加油站

在一条环路上有 n 个加油站，其中第 i 个加油站有汽油 gas[i] 升。

你有一辆油箱容量无限的的汽车，从第 i 个加油站开往第 i+1 个加油站需要消耗汽油 cost[i] 升。你从其中的一个加油站出发，开始时油箱为空。

给定两个整数数组 gas 和 cost ，如果你可以按顺序绕环路行驶一周，则返回出发时加油站的编号，否则返回 -1 。如果存在解，则 保证 它是 唯一 的。

示例 1:

输入: gas = [1,2,3,4,5], cost = [3,4,5,1,2]
输出: 3
解释:
从 3 号加油站(索引为 3 处)出发，可获得 4 升汽油。此时油箱有 = 0 + 4 = 4 升汽油
开往 4 号加油站，此时油箱有 4 - 1 + 5 = 8 升汽油
开往 0 号加油站，此时油箱有 8 - 2 + 1 = 7 升汽油
开往 1 号加油站，此时油箱有 7 - 3 + 2 = 6 升汽油
开往 2 号加油站，此时油箱有 6 - 4 + 3 = 5 升汽油
开往 3 号加油站，你需要消耗 5 升汽油，正好足够你返回到 3 号加油站。
因此，3 可为起始索引。

示例 2:

输入: gas = [2,3,4], cost = [3,4,3]
输出: -1
解释:
你不能从 0 号或 1 号加油站出发，因为没有足够的汽油可以让你行驶到下一个加油站。
我们从 2 号加油站出发，可以获得 4 升汽油。 此时油箱有 = 0 + 4 = 4 升汽油
开往 0 号加油站，此时油箱有 4 - 3 + 2 = 3 升汽油
开往 1 号加油站，此时油箱有 3 - 3 + 3 = 3 升汽油
你无法返回 2 号加油站，因为返程需要消耗 4 升汽油，但是你的油箱只有 3 升汽油。
因此，无论怎样，你都不可能绕环路行驶一周。

首先如果总油量减去总消耗大于等于零那么一定可以跑完一圈，说明 各个站点的加油站 剩油量rest[i]相加一定是大于等于零的。

i从0开始累加rest[i]，和记为curSum，一旦curSum小于零，说明[0, i]区间都不能作为起始位置，因为这个区间选择任何一个位置作为起点，到i这里都会断油，那么起始位置从i+1算起，再从0计算curSum。

有没有可能从[0, i]区间的某一位置开始，也可以有起始位置？，即curSum大于0

如图：

如果 curSum<0 说明 区间和1 + 区间和2 < 0， 那么 假设从上图中的位置开始计数curSum不会小于0的话，就是 区间和2>0。

区间和1 + 区间和2 < 0 同时 区间和2>0，只能说明区间和1 < 0， 那么就会从假设的箭头初就开始从新选择其实位置了。即如果可以作为起始位置，我们在i之前就会把它作为起始位置了

那么局部最优：当前累加rest[i]的和curSum一旦小于0，起始位置至少要是i+1，因为从i之前开始一定不行。全局最优：找到可以跑一圈的起始位置

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

    }
}

135、分发糖果

n 个孩子站成一排。给你一个整数数组 ratings 表示每个孩子的评分。

你需要按照以下要求，给这些孩子分发糖果：

• 每个孩子至少分配到 1 个糖果。
• 相邻两个孩子评分更高的孩子会获得更多的糖果。

请你给每个孩子分发糖果，计算并返回需要准备的 最少糖果数目 。

示例 1：

输入：ratings = [1,0,2]
输出：5
解释：你可以分别给第一个、第二个、第三个孩子分发 2、1、2 颗糖果。

示例 2：

输入：ratings = [1,2,2]
输出：4
解释：你可以分别给第一个、第二个、第三个孩子分发 1、2、1 颗糖果。
     第三个孩子只得到 1 颗糖果，这满足题面中的两个条件。

先确定右边评分大于左边的情况（也就是从前向后遍历）

此时局部最优：只要右边评分比左边大，右边的孩子就多一个糖果，全局最优：相邻的孩子中，评分高的右孩子获得比左边孩子更多的糖果

再确定左孩子大于右孩子的情况（从后向前遍历）

如果 ratings[i] > ratings[i + 1]，此时candyVec[i]（第i个小孩的糖果数量）就有两个选择了，一个是candyVec[i + 1] + 1（从右边这个加1得到的糖果数量），一个是candyVec[i]（之前比较右孩子大于左孩子得到的糖果数量）。

class Solution {
    public int candy(int[] ratings) {

        int len =ratings.length;
        int[] candynum =new int[len];
        candynum[0]=1;
        //从左向右比较
        for(int i=1;i<len;i++)
        {
            if(ratings[i]>ratings[i-1])
            {
                candynum[i]=candynum[i-1]+1;
            }
            else{
                candynum[i]=1;
            }
        }
        //从右向左比较：
        for(int i=len-2;i>=0;i--)
        {
            if(ratings[i]>ratings[i+1])
            {
                candynum[i]=Math.max(candynum[i],candynum[i+1]+1);
            }
        }

        //统计：
        int sum=0;
        for(int i=0;i<candynum.length;i++)
        {
            sum+=candynum[i];
        }
        return sum;

    }
}

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。

逻辑是非常固定的，唯一贪心的点就是尽可能的多留下五元的。

class Solution {
    public boolean lemonadeChange(int[] bills) {

        int[] money=new int[2]; //存储剩余的5块和10块的数量

        for(int i=0;i<bills.length;i++)
        {
            if(bills[i]==5)
            {
                money[0]++;
            }
            else if(bills[i]==10)
            {
                if(money[0]>0)
                {
                    money[0]--;
                    money[1]++;

                } 
                else 
                    return false;
            }
            else if(bills[i]==20)
            {
                if(money[0]>0 && money[1]>0)
                {
                    money[0]--;
                    money[1]--;
                }
                else if(money[0]>=3){
                    money[0]=money[0]-3;
                }
                else{
                    return false;
                }
            }
        }
        return true;

    }
}

406、根据身高重建队列

设有打乱顺序的一群人站成一个队列，数组 people 表示队列中一些人的属性（不一定按顺序）。每个 people[i] = [hi, ki] 表示第 i 个人的身高为 hi ，前面 正好 有 ki 个身高大于或等于 hi 的人。

请你重新构造并返回输入数组 people 所表示的队列。返回的队列应该格式化为数组 queue ，其中 queue[j] = [hj, kj] 是队列中第 j 个人的属性（queue[0] 是排在队列前面的人）。

示例 1：

输入：people = [[7,0],[4,4],[7,1],[5,0],[6,1],[5,2]]
输出：[[5,0],[7,0],[5,2],[6,1],[4,4],[7,1]]
解释：
编号为 0 的人身高为 5 ，没有身高更高或者相同的人排在他前面。
编号为 1 的人身高为 7 ，没有身高更高或者相同的人排在他前面。
编号为 2 的人身高为 5 ，有 2 个身高更高或者相同的人排在他前面，即编号为 0 和 1 的人。
编号为 3 的人身高为 6 ，有 1 个身高更高或者相同的人排在他前面，即编号为 1 的人。
编号为 4 的人身高为 4 ，有 4 个身高更高或者相同的人排在他前面，即编号为 0、1、2、3 的人。
编号为 5 的人身高为 7 ，有 1 个身高更高或者相同的人排在他前面，即编号为 1 的人。
因此 [[5,0],[7,0],[5,2],[6,1],[4,4],[7,1]] 是重新构造后的队列

本题好人分发糖果一样，都是有两个维度！所以要一个一个的来确定！

如果按照k来从小到大排序，排完之后，会发现k的排列并不符合条件，身高也不符合条件，两个维度哪一个都没确定下来。

那么按照身高h来排序呢，身高一定是从大到小排（身高相同的话则k小的站前面），让高个子在前面。

此时我们可以确定一个维度了，就是身高，前面的节点一定都比本节点高！

那么只需要按照k为下标重新插入队列就可以了

例如：

局部最优：优先按身高高的people的k来插入。插入操作过后的people满足队列属性

全局最优：最后都做完插入操作，整个队列满足题目队列属性

people[i] = [hi, ki]表示前面 正好 有 ki 个身高大于或等于 hi 的人。

所以，先按照身高进行排序，然后k来进行插入。

class Solution {
    public int[][] reconstructQueue(int[][] people) {
        int[][] result =new int[people.length][];
        Arrays.sort(people,(a,b)->{
            if(a[0]==b[0]) return a[1]-b[1]; //身高相同的，让k小的在前面
            return b[0]-a[0];  //身高不同，按身高降序
        });

        LinkedList<int []> list =new LinkedList<>();
        for(int[] p:people)
        {
            list.add(p[1],p);  //使用LinkedList 来根据位置进行插入
        }
        return list.toArray(result);

    }
}

452、用最少数量的箭引爆气球

有一些球形气球贴在一堵用 XY 平面表示的墙面上。墙面上的气球记录在整数数组 points ，其中points[i] = [xstart, xend] 表示水平直径在 xstart 和 xend之间的气球。你不知道气球的确切 y 坐标。

一支弓箭可以沿着 x 轴从不同点 完全垂直 地射出。在坐标 x 处射出一支箭，若有一个气球的直径的开始和结束坐标为 xstart</font><font style="color:rgb(51, 51, 51);">，</font><font style="color:rgb(51, 51, 51);background-color:rgb(243, 244, 244);">xend， 且满足 xstart ≤ x ≤ x``end，则该气球会被 引爆 。可以射出的弓箭的数量 没有限制 。 弓箭一旦被射出之后，可以无限地前进。

给你一个数组 points ，返回引爆所有气球所必须射出的 最小 弓箭数 。

示例 1：

输入：points = [[10,16],[2,8],[1,6],[7,12]]
输出：2
解释：气球可以用2支箭来爆破:
-在x = 6处射出箭，击破气球[2,8]和[1,6]。
-在x = 11处发射箭，击破气球[10,16]和[7,12]。

示例 2：

输入：points = [[1,2],[3,4],[5,6],[7,8]]
输出：4
解释：每个气球需要射出一支箭，总共需要4支箭。

局部最优：当气球出现重叠，一起射，所用弓箭最少。全局最优：把所有气球射爆所用弓箭最少。

为了让气球尽可能的重叠，需要对数组进行排序。

使用重叠气球最小右边界来 判断是否重叠，只要后面的气球的左边界小于前面重叠气球的最小右边界，就可以使用同一只箭来引爆，另外要注意要收缩后面气球的右边界。

如果气球重叠了，重叠气球中右边边界的最小值 之前的区间一定需要一个弓箭

可以看出首先第一组重叠气球，一定是需要一个箭，气球3，的左边界大于了 第一组重叠气球的最小右边界，所以再需要一支箭来射气球3了。

class Solution {
    public int findMinArrowShots(int[][] points) {

        // 根据气球直径的开始坐标从小到大排序
        // 使用Integer内置比较方法，不会溢出
        Arrays.sort(points,(a,b)->Integer.compare(a[0],b[0]));
        //Arrays.sort(points,(a,b)->{ return a[0]-b[0];});   会超时溢出

        int count=1; //不为空 至少需要一个

        for(int i=1;i<points.length;i++)
        {
            if(points[i][0]>points[i-1][1])  //和前面的没有重叠
            {
                count++;
            }
            else   //有重叠，把当前的右边界收缩到最短,这样才能使用同一个箭，弓箭数不需要加
            {
                points[i][1]=Math.min(points[i-1][1],points[i][1]);
            }
        }
        return count;

    }
}

超时： 即最小的int减去最大的int，结果溢出。

435、无重叠区间

给定一个区间的集合 intervals ，其中 intervals[i] = [starti, endi] 。返回 需要移除区间的最小数量，使剩余区间互不重叠 。

示例 1:

输入: intervals = [[1,2],[2,3],[3,4],[1,3]]
输出: 1
解释: 移除 [1,3] 后，剩下的区间没有重叠。

示例 2:

输入: intervals = [ [1,2], [1,2], [1,2] ]
输出: 2
解释: 你需要移除两个 [1,2] 来使剩下的区间没有重叠。

本题和前一题思路相同，先排序然后看是否重叠，如果重叠的话count++，并且把intervals[i]的右边界取最小，相当于把右边界大的给移除了

class Solution {
    public int eraseOverlapIntervals(int[][] intervals) {

        Arrays.sort(intervals,(a,b)->{
            return Integer.compare(a[0],b[0]);
        });

        int count=0; //用来计算需要移除的区间

        for(int i=1;i<intervals.length;i++)
        {
            if(intervals[i][0]>=intervals[i-1][1]) //不重叠
            {
                continue;
            }
            else{  //重叠
                count++;
                //移除,并且右边界取最小的,即右边界大的会被移除
                intervals[i][1]=Math.min(intervals[i-1][1],intervals[i][1]);
            }
        }
        return count;
    }
}

763、划分字母区间

给你一个字符串 s 。我们要把这个字符串划分为尽可能多的片段，同一字母最多出现在一个片段中。

注意，划分结果需要满足：将所有划分结果按顺序连接，得到的字符串仍然是 s 。

返回一个表示每个字符串片段的长度的列表。

示例 1：

输入：s = "ababcbacadefegdehijhklij"
输出：[9,7,8]
解释：
划分结果为 "ababcbaca"、"defegde"、"hijhklij" 。
每个字母最多出现在一个片段中。
像 "ababcbacadefegde", "hijhklij" 这样的划分是错误的，因为划分的片段数较少。

在遍历的过程中相当于是要找每一个字母的边界，如果找到之前遍历过的所有字母的最远边界，说明这个边界就是分割点了。此时前面出现过所有字母，最远也就到这个边界了。

可以分为如下两步：

• 统计每一个字符最后出现的位置
• 从头遍历字符，并更新字符的最远出现下标，如果找到字符最远出现位置下标和当前下标相等了，则找到了分割点

如图：

即找到最大的那个字符边界，就是这一段的分割点

class Solution {
    public List<Integer> partitionLabels(String s) {
    List<Integer> result =new LinkedList<>();
    int [] edge =new int [26];   //记录每个字母最后出现的位置
    char[] chars =s.toCharArray();

    for(int i=0;i<chars.length;i++)
    {
        edge[chars[i]-'a']=i;   //记录每个字母最后出现的位置
    }

    int index=0;
    int last=0;

    for(int i=0;i<chars.length;i++)
    {
        //找到最后出现的最大值，以防止字母在后面还会出现
        index=Math.max(index,edge[chars[i]-'a']);  
        if(i==index)   //如果i就等于最后出现的位置，就可以是分界点了
        {
            result.add(index-last+1);
            last=index+1;
        }
    }
    return result;

}
}

56、合并区间

以数组 intervals 表示若干个区间的集合，其中单个区间为 intervals[i] = [starti, endi] 。请你合并所有重叠的区间，并返回 一个不重叠的区间数组，该数组需恰好覆盖输入中的所有区间 。

示例 1：

输入：intervals = [[1,3],[2,6],[8,10],[15,18]]
输出：[[1,6],[8,10],[15,18]]
解释：区间 [1,3] 和 [2,6] 重叠, 将它们合并为 [1,6].

示例 2：

输入：intervals = [[1,4],[4,5]]
输出：[[1,5]]
解释：区间 [1,4] 和 [4,5] 可被视为重叠区间。

class Solution {
    public int[][] merge(int[][] intervals) {

        List<int[]> result =new LinkedList<>();
        Arrays.sort(intervals,(a,b)->{
            return a[0]-b[0];
        });
        result.add(intervals[0]);

        for(int i=1;i<intervals.length;i++)
        {
            if(intervals[i][0]>intervals[i-1][1])  //没有重叠
            {
                result.add(intervals[i]);
            }
            else //有重叠的话,要移除前一个
            {
                intervals[i][1]=Math.max(intervals[i][1],intervals[i-1][1]);
                intervals[i][0]=intervals[i-1][0];
                result.removeLast();
                result.add(intervals[i]);
            }
        }
        return result.toArray(new int[result.size()][]);
    }
}

738、单调递增的数字

当且仅当每个相邻位数上的数字 x 和 y 满足 x <= y 时，我们称这个整数是单调递增的。

给定一个整数 n ，返回 小于或等于 n 的最大数字，且数字呈 __单调递增 。

示例 1:

输入: n = 10
输出: 9

示例 2:

输入: n = 1234
输出: 1234

示例 3:

输入: n = 332
输出: 299

例如：98，一旦出现strNum[i - 1] > strNum[i]的情况（非单调递增），首先想让strNum[i - 1]–，然后strNum[i]给为9，这样这个整数就是89，即小于98的最大的单调递增整数。

从前向后遍历的话，遇到strNum[i - 1] > strNum[i]的情况，让strNum[i - 1]减一，但此时如果strNum[i - 1]减一了，可能又小于strNum[i - 2]。

所以要从后向前遍历，就可以重复利用上次比较得出的结果了

class Solution {
    public int monotoneIncreasingDigits(int n) {

        String s=String.valueOf(n);
        char[] chars=s.toCharArray();
        int start=chars.length;
        for(int i=chars.length-2;i>=0;i--)   //从后向前判断
        {
            if(chars[i]>chars[i+1])
            {
                chars[i]--;
                start=i+1;    //从最后一个减1的数之后开始都要变为9
            }
        }
        for(int i=start;i<chars.length;i++)
        {
            chars[i]='9';
        }
        //先把chars变为String，在转为Integer
        return Integer.parseInt(String.valueOf(chars));
    }
}

968、监控二叉树

给定一个二叉树，我们在树的节点上安装摄像头。

节点上的每个摄影头都可以监视其父对象、自身及其直接子对象。

计算监控树的所有节点所需的最小摄像头数量。

示例 1：

输入：[0,0,null,0,0]
输出：1
解释：如图所示，一台摄像头足以监控所有节点。

示例 2：

输入：[0,0,null,0,null,0,null,null,0]
输出：2

贪心思想：为了充分利用摄像头的覆盖，要让叶子结点的父节点安装摄像头。

所以我们要从下往上看，局部最优：让叶子节点的父节点安摄像头，所用摄像头最少，整体最优：全部摄像头数量所用最少！

从下到上，所以是后序遍历。

jclass Solution {
    int  res=0;
    public int minCameraCover(TreeNode root) {
    // 对根节点的状态做检验,防止根节点是无覆盖状态 .
    if(minCame(root)==0){
        res++;
    }
    return res;
}
/**
     节点的状态值：
       0 表示无覆盖
       1 表示 有摄像头
       2 表示有覆盖
    后序遍历，根据左右节点的情况,来判读 自己的状态
     */
public int minCame(TreeNode root){
if(root==null){
    // 空节点默认为 有覆盖状态，避免在叶子节点上放摄像头
    return 2;
}
int left=minCame(root.left);
int  right=minCame(root.right);

// 如果左右节点都覆盖了的话, 那么本节点的状态就应该是无覆盖,没有摄像头
if(left==2&&right==2){
    //(2,2)
    return 0;
}else if(left==0||right==0){
    // 左右节点都是无覆盖状态,那根节点此时应该放一个摄像头
    // (0,0) (0,1) (0,2) (1,0) (2,0)
    // 状态值为 1 摄像头数 ++;
    res++;
    return 1;
}else{
    // 左右节点的 状态为 (1,1) (1,2) (2,1) 也就是左右节点至少存在 1个摄像头
    // 那么本节点就是处于被覆盖状态
    return 2;
}
}
}