【算法】贪心算法：LeetCode 1005 K 次取反后最大化的数组和、 LeetCode 134 加油站

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

（简单）

题目

描述
给定一个整数数组 A，我们只能用以下方法修改该数组：我们选择某个索引 i 并将 A[i] 替换为 -A[i]，然后总共重复这个过程 K 次。（我们可以多次选择同一个索引 i。）
以这种方式修改数组后，返回数组可能的最大和。

示例 1：
输入：A = [4,2,3], K = 1
输出：5
解释：选择索引 (1,) ，然后 A 变为 [4,-2,3]。

示例 2：
输入：A = [3,-1,0,2], K = 3
输出：6
解释：选择索引 (1, 2, 2) ，然后 A 变为 [3,1,0,2]。

示例 3：
输入：A = [2,-3,-1,5,-4], K = 2
输出：13
解释：选择索引 (1, 4) ，然后 A 变为 [2,3,-1,5,4]。

思路

本题的题意可理解为，对于一个序列，有 k 次机会将其中的负数变为其相反数（可多次对同一个数转相反数），求序列可能的最大元素和。因此，我们可用贪心的思想，去转变那些绝对值较大的负数，因此，我们可先将序列元素按照绝对值从小到大排序，这样，得到新的序列，从左到右绝对值依次非单调递减，因此，右边是绝对值较大的，我们可从右向左遍历序列，若为负数则转为相反数，从而使其转为正数，并消耗一次 k，直到 k 为 0，或序列遍历结束，之后，可能出现下面三种情况：

• 若k不剩余，则不用再考虑
• 若k剩余，并且数量为偶数，则也不用考虑，正负可抵消
• 若k剩余，并且数量为奇数，则可将最小的一个正数（最左边，即绝对值最小的那个数）转为负数

最终，将序列元素加起来，即可得到最大可能的和。

实现

public class TX7K次取反后最大化的数组和 {
    public int largestSumAfterKNegations(int[] nums, int k) {
        //将元素按照绝对值从小到大排序
        int[] myNums = sortByAbs(nums);

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

        //若k不剩余，则不用再考虑
        //若k剩余，并且数量为偶数，则也不用考虑，正负可抵消
        //若k剩余，并且数量为奇数，则可将最小的一个正数（最左边）转为负数
        if (k % 2 == 1) {
            myNums[0] *= -1;
        }

        int sum = 0;
        for (int i = 0; i < myNums.length; i++) {
            sum += myNums[i];
        }

        return sum;
    }

    private int[] sortByAbs(int[] nums) {
        int i, j;
        int len = nums.length;
        int[] copyNums = Arrays.copyOf(nums, len);
        boolean flag = true;

        for (i = 0; i < len - 1 && flag; i++) {
            flag = false;
            for (j = len - 2; j >= i; j--) {
                if (Math.abs(copyNums[j]) > Math.abs(copyNums[j + 1])) {
                    swap(copyNums, j, j + 1);
                    flag = true;
                }
            }
        }

        return copyNums;
    }

    private void swap(int[] nums, int i, int j) {
        int tmp = nums[i];
        nums[i] = nums[j];
        nums[j] = tmp;
    }

    public static void main(String[] args) {
        TX7K次取反后最大化的数组和 s = new TX7K次取反后最大化的数组和();
        System.out.println(s.largestSumAfterKNegations(new int[]{2, -3, -1, 5, -4}, 2));
        System.out.println(s.largestSumAfterKNegations(new int[]{7, 8, -4, -7, -5, -1, 2, -2, -7}, 4));
    }
}

LeetCode 134：加油站

（中等）

题目

描述
在一条环路上有 N 个加油站，其中第 i 个加油站有汽油 gas[i] 升。
你有一辆油箱容量无限的的汽车，从第 i 个加油站开往第 i+1 个加油站需要消耗汽油 cost[i] 升。你从其中的一个加油站出发，开始时油箱为空。
如果你可以绕环路行驶一周，则返回出发时加油站的编号，否则返回 -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 升汽油。
因此，无论怎样，你都不可能绕环路行驶一周。

思路

本题也是一道典型的贪心算法题，虽然题目中说了，若有答案，则答案唯一，但并没有说汽车必定能行驶完一圈，因此，也要进行成功与否的判断，而至于汽车能否行驶一周，其实可以从整体上抽象考虑，若能行驶完一周，则油量必定大于其消耗量，只需统计 gas 、cost 数组的元素和，前者若小于后者，则不能完成一圈，反之，则能；而如何定位起始点的下标呢？这里用的便是贪心算法，我们从头开始遍历两个数组，每次循环中如果当前 剩余油量 + gas-i - cost-i 的值大于 0，那么至少从 i 到 i+1 加油站是可以到达的，而如果值小于 0，也就是油量入不敷出，则 0 ~ i 作为起始点都是不可行（因为我们一开始也是从正数开始加的），将起始点下标指向当前的下一个下标再判断即可，即指向 i + 1，并且不必回头，因为前面已经解释了，0 ~ i 作为起始点都是不可行，而每次的校验，和最终的统计，同时进行即可，即放入一次遍历中同时进行。

实现

public class TX8加油站 {
    public int canCompleteCircuit(int[] gas, int[] cost) {
        int remainValue = 0; //每次循环中当前 gas-i 与 cost-i 的差值
        int totalValue = 0; //统计循环中所有的 differentValue 的差值
        int startIndex = 0;

        //每次的校验，和最终的统计，同时进行
        for (int i = 0; i < gas.length; i++) {
            remainValue += gas[i] - cost[i];
            totalValue += gas[i] - cost[i];

            if (remainValue < 0) {
                startIndex = i + 1;
                remainValue = 0;
            }
        }

        if (totalValue < 0) {
            return -1;
        }

        return startIndex;
    }
}