leetcode 刷题_day36_贪心03_局部最优推出全局最优

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

思路

基于贪心算法，有两种解法

方法一

每次选择最小的值进行反转，实现每次最大，那最后整体最大

方法二

先按绝对值降序排序，依次从头至尾将负值翻转，如果最后 k 还没用完，则将数组最后一个（值最小）的反复翻转
贪心原理：

1. 按绝对值降序排序后，保证每次翻转都能翻转到当前最小的负数值，局部最优
2. 遍历一遍剩余的 k 值，因为整个 nums 都是正值，末尾的数最小，反复翻转它，能保证局部最优
3. 最后，得出全局最优

解题方法

方法二中，非对象的自定义排序需要转成包装类才能进行，直接拖慢了整体效率

复杂度

• 时间复杂度:
  方法一：$O(kn)$
  方法二：$O(nlogn)$

• 空间复杂度:
  方法一：$O(1)$
  方法二：$O(n)$ --> java 的非对象自定义排序有病

Code

方法一：
class Solution {

    // 每次选择最小的值进行反转，实现每次最大，那最后整体最大
    public int largestSumAfterKNegations(int[] nums, int k) {

        while (k > 0) {
            int minIndex = 0;
            for (int i = 0; i < nums.length; i++) {
                if (nums[i] < nums[minIndex]) minIndex = i;
            }

            nums[minIndex] = -nums[minIndex];
            k--;
        }

        int result = 0;
        for (int i = 0; i < nums.length; i++) result += nums[i];

        return result;
    }

方法二：

class Solution {

    // 先按绝对值降序排序，依次从头至尾将负值翻转，如果最后 k 还没用完，则将数组最后一个（值最小）的反复翻转
    // 贪心原理：
    // 1. 按绝对值降序排序后，保证每次翻转都能翻转到当前最小的负数值，局部最优
    // 2. 遍历一遍剩余的 k 值，因为整个 nums 都是正值，末尾的数最小，反复翻转它，能保证局部最优
    // 最后，得出全局最优
    public int largestSumAfterKNegations(int[] nums, int k) {

        // 自定义比较器只能传入对象
        nums = IntStream.of(nums).boxed().sorted((a, b) -> Math.abs(b) - Math.abs(a)).mapToInt(Integer::intValue).toArray();

        for (int i = 0; i < nums.length && k > 0; i++) {
            if (nums[i] < 0) {
                nums[i] = -nums[i];
                k--;
            }
        }

        while(k > 0) {
            nums[nums.length - 1] = -nums[nums.length - 1];
            k--;
        }

        int result = 0;
        for (int a: nums) result += a;
        return result;
    }
}

134. 加油站

思路

方法一：

1. 每一站到下一站的油余量
2. 如果每一站油余量之和小于零，说明油不够消耗，一定没答案
3. 遍历余量数组，从余量为正的开始，遍历一圈
4. 如果一圈内始终能保证余量差不小于0，则说明能跑完一圈，反之则当前起始位置不行，换下一个

方法二：贪心解法优化

• 局部最优：走过范围内[start, i]，剩余油量不能小于0，如果为0，则说明当前范围不能用，需要从 i + 1开始重新画一个范围
• 全局最优：遍历完，合格的范围的开始就是答案

解题方法

描述你的解题方法

复杂度

时间复杂度:

• 方法一：$O(n^2)$
• 方法二：$O(n)$

空间复杂度: $O(1)$

Code

方法一：

class Solution {
    public int canCompleteCircuit(int[] gas, int[] cost) {
        
        int[] restOil = new int[gas.length];

        for (int i = 0; i < gas.length; i++) {
            restOil[i] = gas[i] - cost[i];
        }

        // 总量不足的情况
        int sumRestOil = 0;
        for (int a: restOil) sumRestOil += a;
        if (sumRestOil < 0) return -1; 

        // 从余量大于等0的地方开始遍历，需要保证转一圈是，所有节点的临时总余量都大于等于0，就是起始点
        for (int i = 0; i < restOil.length; i++) {
            if (restOil[i] >= 0) {
                int tempSumRestOil = 0;
                for (int j = i; j < restOil.length; j++) {
                    tempSumRestOil = tempSumRestOil + restOil[j];
                    if (tempSumRestOil >= 0 && j == restOil.length - 1) {
                        return i;
                    }
                    if (tempSumRestOil < 0) {
                        break;
                    }
                }
            }
        }

        return -1;
    }

}

方法二：

class Solution {

    // 局部最优：走过范围内[start, i]，剩余油量不能小于0，如果为0，则说明当前范围不能用，需要从 i + 1 开始重新画一个范围
    // 全局最优：遍历完，合格的范围的开始就是答案
    public int canCompleteCircuit(int[] gas, int[] cost) {
        
        // 从数组头开始
        // 疑问：从别的地方开始会不会影响
        int start = 0;
        // 范围内的余量
        int rangeRest = 0;
        // 全局的余量，小于 0 则必不能有结果
        int allRest = 0;

        for (int i = 0; i < gas.length; i++) {
            rangeRest += gas[i] - cost[i];
            allRest += gas[i] - cost[i];

            // 当前范围余量小于0，新启一个范围
            if (rangeRest < 0) {
                start = i + 1;
                rangeRest = 0;
            }
        }
        
        if (allRest < 0) return -1;

        return start;
    }
}

135. 分发糖果

思路

采用两次贪心的策略：

• 一次是从左到右遍历，只比较右边孩子评分比左边大的情况。
• 一次是从右到左遍历，只比较左边孩子评分比右边大的情况。

这样从局部最优推出了全局最优，即：相邻的孩子中，评分高的孩子获得更多的糖果

解题方法

描述你的解题方法

复杂度

• 时间复杂度: $O(n)$

• 空间复杂度: $O(n)$

Code

class Solution {

    // 相邻表示左右都要考虑
    // 首先考虑从左到右，也即右边比左边大的情况
    // 然后考虑从右到左，也即左边比右边大的情况
    public int candy(int[] ratings) {
        int[] candyNums = new int[ratings.length];
        candyNums[0] = 1;

        // 从左到右，也即右边比左边大的情况
        for (int i = 1; i < ratings.length; i++) {
            if (ratings[i] > ratings[i - 1]) {
                candyNums[i] = candyNums[i - 1] + 1;
            } else {
                candyNums[i] = 1;
            }
        }

        // 从右到左，也即左边比右边大的情况
        for (int i = ratings.length - 2; i >= 0; i--) {
            if (ratings[i] > ratings[i + 1]) {
                candyNums[i] = Math.max(candyNums[i], candyNums[i + 1] + 1);
            }
        }

        // 统计
        int result = 0;
        for (int a: candyNums) result += a;

        return result;
    }
}