代码随想录算法训练营第三十四天|1005.K次取反后最大化的数组和、134. 加油站、135. 分发糖果

代码随想录算法训练营第三十四天|1005.K次取反后最大化的数组和、134. 加油站、135. 分发糖果

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

1005.K次取反后最大化的数组和
文章讲解：https://programmercarl.com/1005.K%E6%AC%A1%E5%8F%96%E5%8F%8D%E5%90%8E%E6%9C%80%E5%A4%A7%E5%8C%96%E7%9A%84%E6%95%B0%E7%BB%84%E5%92%8C.html
题目链接：https://leetcode.cn/problems/maximize-sum-of-array-after-k-negations/
视频讲解：https://www.bilibili.com/video/BV138411G7LY/

自己看到题目的第一想法

1. 先排序，然后把最小的负数取逆，如果都是正数则把最小的正数取逆
   这里有2个场景，负数数量大于等于k，负数数量小于k

• 负数数量大于k时，直接将负数从最小开始取逆就行
• 负数数量小于k时，先把最小的取逆，然后看剩下的k是偶数还是奇数，是偶数直接不变，是奇数则直接取最后一个值做取逆，正数也开始取逆。

按照自己的想法写出来的代码有问题，当负数取反后的值增量小于正数取反就出错了。

public int largestSumAfterKNegations(int[] nums, int k) {
	 // 1. 先排序，然后把最小的负数取逆，如果都是正数则把最小的正数取逆
	 // 这里有2个场景，负数数量大于等于k，负数数量小于k
	 // 负数数量大于k时，直接将负数从最小开始取逆就行
	 // 负数数量小于k时，先把最小的取逆，然后看剩下的k是偶数还是奇数，是偶数直接不变，是奇数则直接取最后一个值做取逆，正数也开始取逆
	 Arrays.sort(nums);
	 int sum = 0;
	 int limit = k;
	 for(int i = 0;i < nums.length; i++){
	     if(limit > 0){
	         // 当前值小于0时，取逆
	         if(nums[i] < 0){
	             sum += -nums[i];
	             limit--;
	         }else if(nums[i] > 0){
	             // 当前值大于0时，看limit的值是否为2的倍数，如果是则直接不变更，处理完之后limit = 0
	             if(limit % 2 == 0){
	                 sum += nums[i];
	             }else{
	                 sum += -nums[i];
	             }
	             limit = 0;
	         }else{
	             sum += nums[i];
	             limit = 0;
	         }
	     }else{
	         sum += nums[i];
	     }
	 }
	 return sum;
	}

看完代码随想录之后的想法

贪心的思想：

• 局部最优：让绝对值大的负数变为正数。
• 局部最优：当所有负数已经转变为正数后k依然大于0，此时只找数值最小的正整数进行反转，当前数值和可以达到最大。

整体逻辑：

1. 先将数组按照绝对值进行从大到小排序
2. 从前往后遍历，遇到负数将其变为正数，同时k–
3. 如果k还大于0，则反复转变数值最小的元素将K用完
4. 求和

自己实现过程中遇到哪些困难

排序的方式并没有按照绝对值去排序，没有想到使用贪心。

加油站

134. 加油站
文章讲解：https://programmercarl.com/0134.%E5%8A%A0%E6%B2%B9%E7%AB%99.html
题目链接：https://leetcode.cn/problems/gas-station/
视频讲解：https://www.bilibili.com/video/BV1jA411r7WX/

自己看到题目的第一想法

求出left数组，left数组为gas[i] - cost[i]。
然后使用快慢指针移动，从left中找出一个能累加后的值一直大于0的位置slow位置。

class Solution {
    public int canCompleteCircuit(int[] gas, int[] cost) {
        // 局部最优：每次走得到的gas[i + 1]-cost[i]都要大于0，全局最优
        // 求出cost[i + 1] - gas[i] 的数组，然后找到一个位置，使得从该位置往后累加的值都大于0
        if(gas.length == 1){
            if(gas[0] < cost[0]){
                return -1;
            }else{
                return 0;
            }
        }
        int[] left = new int[gas.length];
        for(int i = 0; i < gas.length; i++){
            left[i] = gas[i] - cost[i];
        }
        // 从left中找出一个能累加后的值一直大于0的位置
        //System.out.println(Arrays.toString(left));
        int fast = 1;
        int slow = 0;
        int sum = left[slow];
        while(slow != fast){
            //System.out.println("slow:" + slow);
            //System.out.println("fast:" + fast);
            sum += left[fast];
            //System.out.println("sum:" + sum);
            if(sum < 0 || left[slow] < 0){
                slow++;
                if(slow == left.length){
                    break;
                }
                fast = slow + 1;
                sum = left[slow];
            }else{
                fast++;
            }
            if(fast == left.length){
                fast = 0;
            }
            
        }
        if(sum >= 0){
            return slow;
        }else{
            return -1;
        }
    }
}

最终结果超出时间限制。。。。

看完代码随想录之后的想法

我的方法属于暴力方法，超时了。
代码随想录贪心方法一：全局最优思想

• 把情况分成了3种：
  • 情况一：如果gas总和小于cost总和，那无论哪里出发都到不了终点
  • 情况二：rest[i] = gas[i]-cost[i]为一天剩下的油，i从0开始计算累加到最后一站，如果累加没有出现负数，说明从0出发，油就没有断过，那么0就是起点。
  • 情况三：如果累加的最小值是负数（所有的值的最小和），汽车就要从非0节点出发，从后向前，看哪个节点能把这个负数填平，能把这个负数填平的节点就是出发节点。

代码随想录方法二：局部最优

• 全局累加，如果发现全局累加的值小于0的时候，i就i+1开始取值。
• 每个加油站的剩余量rest[i]为gas[i] - cost[i]。
• i从0开始累加rest[i]，和记为curSum，一旦curSum小于零，说明[0, i]区间都不能作为起始位置，因为这个区间选择任何一个位置作为起点，到i这里都会断油，那么起始位置从i+1算起，再从0计算curSum。比如rest数组为 -3 -5 8 -2，这里在计算的时候会直接跳过 -3 -5，从8开始作为i取值
• 那么局部最优：当前累加rest[i]的和curSum一旦小于0，起始位置至少要是i+1，因为从i之前开始一定不行。全局最优：找到可以跑一圈的起始位置。
• 所以这种方法只用一个for循环就能处理完逻辑。

自己实现过程中遇到哪些困难

看完代码随想录写出的答案，这里要注意局部最优的处理逻辑，当前累加rest[i]的和curSum一旦小于0，起始位置至少要是i+1。

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

分发糖果

135. 分发糖果 
文章讲解：https://programmercarl.com/0135.%E5%88%86%E5%8F%91%E7%B3%96%E6%9E%9C.html
题目链接：https://leetcode.cn/problems/candy/
视频讲解：https://www.bilibili.com/video/BV1ev4y1r7wN/

自己看到题目的第一想法

看完代码随想录之后的想法

每个小孩既要和左边的进行比较也要和右边的进行比较。

1. 双向考虑过于复杂，只先考虑单边的比较。
2. 一次只确定一边：
   2.1. 如右边小孩比左边小孩得分高的情况 [1,2,2,5,4,3,2] -> [1,2,1,2,1,1,1]；只考虑右边和左边比较的情况（从前向后遍历）
   2.2. 处理左边孩子比右边孩子得分高的情况[1,2,2,5,4,3,2]->1,1,1,4,3,2,1
   2.3. 此时其实计算左边孩子比右边孩子得分高的情况时，会和2.1计算的结果匹配上，这里就能知道当前节点左右的情况，在计算左边孩子比右边孩子高的情况下，计算candy[i]的时候candy[i] = max(candy[i + 1] + 1,candy[i])。
   千万不要两边一起比较

先确定右边评分大于左边的情况（也就是从前向后遍历）
此时局部最优：只要右边评分比左边大，右边的孩子就多一个糖果，全局最优：相邻的孩子中，评分高的右孩子获得比左边孩子更多的糖果
局部最优可以推出全局最优。
如果ratings[i] > ratings[i - 1] 那么[i]的糖 一定要比[i - 1]的糖多一个，所以贪心：candyVec[i] = candyVec[i - 1] + 1

自己实现过程中遇到哪些困难

class Solution {
    public int candy(int[] ratings) {
        // 每个小孩既要和左边的进行比较也要和右边的进行比较，过于复杂容易两边都考虑出错。
        // 这里可以循环2次先确定右边大于左边，得到一个结果集。再确定左边大于右边，确定左边大于右边的时候同时进行计算，得到最终的结果集，然后同时满足遍历的右边大于左边，左边大于右边的条件。
        if(ratings.length == 1){
            return 1;
        }
        int[] candy = new int[ratings.length];
        // fill逻辑很核心。没写fill没ac出来
        Arrays.fill(candy,1);
        // 右大于左的逻辑
        for(int i = 1; i < ratings.length; i++){
            if(ratings[i] > ratings[i - 1]){
                candy[i] = candy[i - 1] + 1;
            }
        }
        // 左大于右的逻辑，左大于右的逻辑，需要特别关注下，这里是从后往前遍历
        // 为什么要从后往前遍历呢？这里可以实际操作下，左大于右取值得从右边的初始值去取，如果从左边开始取就取不到比较值了。因为 rating[5]与rating[4]的比较 要利用上 rating[5]与rating[6]的比较结果，所以 要从后向前遍历。如果从前向后遍历，rating[5]与rating[4]的比较 就不能用上 rating[5]与rating[6]的比较结果了 。
        // 比如[1,5,4,3,2] 5比4大，但是该取什么值？不知道，没有一个基准值
        for(int i = ratings.length - 2; i >= 0; i--){
            if(ratings[i]> ratings[i + 1]){
                candy[i] = Math.max(candy[i + 1] + 1 , candy[i]);
            }
        }
        int sum = 0;
        for(int can : candy){
            sum += can;
        }
        return sum;
    }
}

今日收获&学习时长

学习时长：3小时以上
今日收获：贪心逻辑太难想到了，3道题目都是看题解和视频才理解的。摸不着套路求解～