算法日记day 30（贪心之k次取反后最大化的数组和|加油站|分发糖果|柠檬水找零）

一、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] 。

示例 3：

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

 思路：

这里的贪心策略主要在于两点，

第一点是把最小的数反转为最大的正数

第二点是当数组中没有负数后，为了保证数组和是最大化的，应该将最小的正数反复转化，消耗k剩余的次数，这样保证了数组和的最大性

代码：

public int largestSumAfterKNegations(int[] nums, int k) {
    // 对数组进行排序
    Arrays.sort(nums);
    // 初始化结果
    int result = 0;
    
    // 第一次遍历：将负数取反操作进行最多 k 次
    for (int i = 0; i < nums.length; i++) {
        // 如果当前数字是负数且还有剩余的取反次数 k
        if (nums[i] < 0 && k > 0) {
            // 取反操作
            nums[i] = -nums[i];
            // 取反次数 k 减少一次
            k--;
        }
    }
    
    // 再次对数组进行排序（因为上面修改了数组内容）
    Arrays.sort(nums);
    
    // 如果剩余取反次数 k 是奇数，则再次将数组中最小的元素取反
    if (k % 2 == 1)
        nums[0] = -nums[0];
    
    // 计算最终结果的和
    for (int i = 0; i < nums.length; i++) {
        result += nums[i];
    }
    
    // 返回最终的结果
    return result;
}

1. Arrays.sort(nums);：

   • 对输入的数组 nums 进行升序排序。这是为了方便后续取反操作和计算最终和的逻辑。

2. 第一个 for 循环：

   • 遍历数组 nums，尝试将数组中的负数取反操作，直到取反次数 k 用尽或者没有负数可以取反为止。
   • 如果 nums[i] 是负数且 k > 0，则将 nums[i] 取反（即变成正数），并将 k 减一。

3. 再次 Arrays.sort(nums);：

   • 因为上面的取反操作可能会改变数组的顺序，所以再次对数组进行排序，确保数组是有序的。

4. if (k % 2 == 1)：

   • 如果剩余的取反次数 k 是奇数，说明还需要再取反一个数以保持最大化和的目标。
   • 在这里选择将数组中最小的元素取反（即 nums[0] 取反），因为排序后 nums[0] 是最小的。

5. 第二个 for 循环：

   • 遍历经过取反操作后的数组 nums，计算其所有元素的和，作为最终的结果 result。

6. 返回结果：

   • 返回最终的和 result，即经过最多 k 次取反操作后能得到的最大和。

二、加油站

题目：

在一条环路上有 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 升汽油。
因此，无论怎样，你都不可能绕环路行驶一周。

思路：

如果在做差中遇到剩余汽油小于0，说明前面的无论从哪开始都不能环绕一周，因此需要从小于0的下一位置开始作为起始点位，记录该点位，如果可以环绕一周返回该点，否则继续变更点位，如果所有点位均遍历完仍不能环绕一周，返回-1

代码：

public int canCompleteCircuit(int[] gas, int[] cost) {
    int total = 0;   // 记录总的剩余汽油量与消耗的差值
    int cur = 0;     // 记录当前从某个起点到当前加油站的剩余汽油量与消耗的差值
    int result = 0;  // 记录能够完整环绕一圈的起始加油站索引
    
    // 遍历每一个加油站
    for (int i = 0; i < gas.length; i++) {
        // 计算从当前加油站到下一加油站的剩余汽油量与消耗的差值
        total += gas[i] - cost[i];
        cur += gas[i] - cost[i];
        
        // 如果当前剩余汽油量不足以到达下一加油站
        if (cur < 0) {
            result = (i + 1) % gas.length;  // 更新起始加油站索引为下一个加油站
            cur = 0;  // 重置当前剩余汽油量与消耗的差值
        }
    }
    
    // 如果总的剩余汽油量与消耗的差值小于0，则无法完整环绕一圈，返回-1
    if (total < 0)
        return -1;
    
    // 返回能够完整环绕一圈的起始加油站索引
    return result;
}

1. 变量说明：

   • total: 记录从起点到当前位置的总剩余汽油量与消耗的差值。它用来判断整体是否可以完成环绕。
   • cur: 记录从某个起点到当前加油站的剩余汽油量与消耗的差值。用于判断当前起点是否可行。
   • result: 记录能够完整环绕一圈的起始加油站的索引。

2. 循环遍历：

   • for (int i = 0; i < gas.length; i++): 遍历每个加油站。

3. 更新 total 和 cur：

   • total += gas[i] - cost[i];: 更新总剩余汽油量与消耗的差值。
   • cur += gas[i] - cost[i];: 更新当前起点到当前加油站的剩余汽油量与消耗的差值。

4. 判断当前起点是否可行：

   • if (cur < 0) { result = (i + 1) % gas.length; cur = 0; }:
     • 如果 cur 小于 0，表示当前起点无法到达下一个加油站。
     • 更新 result 为下一个加油站的索引 (i + 1) % gas.length，即更新可能的新起点。
     • 将 cur 重置为 0，因为需要重新计算新的起点到达下一个加油站的情况。

5. 判断是否能够完整环绕一圈：

   • if (total < 0) return -1;:
     • 如果 total 小于 0，表示总剩余汽油量不足以完成一次完整的环绕，返回 -1。

6. 返回结果：

   • 返回能够完整环绕一圈的起始加油站索引 result。

三、分发糖果 

题目：

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

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

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

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

示例 1：

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

示例 2：

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

思路：

总共需要两次遍历，初始化所有孩子糖果为1

第一次从左往右遍历，如果右孩子得分大于左孩子，则右孩子的糖果数等于其在左孩子糖果数的基础上再加一 

第二次从右往左遍历，如果左孩子得分大于右孩子，则左孩子的糖果数等于其在右孩子糖果数的基础上再加一，但是如果这个值小于在第一次遍历中糖果数，应该取一个最大值的为该孩子的最终糖果数

代码：

public int candy(int[] ratings) {
    int n = ratings.length;
    int[] candyVec = new int[n]; // 用于存储每个孩子分到的糖果数量的数组
    int result = 0; // 总糖果数

    // 第一次遍历：从左到右确定每个孩子分到的糖果数量
    candyVec[0] = 1; // 第一个孩子至少分到一个糖果
    for (int i = 1; i < n; i++) {
        if (ratings[i] > ratings[i - 1]) {
            candyVec[i] = candyVec[i - 1] + 1; // 如果当前孩子评分比前一个高，分的糖果比前一个多一个
        } else {
            candyVec[i] = 1; // 否则只分一个糖果
        }
    }

    // 第二次遍历：从右到左，确保每个孩子分到的糖果数量满足条件
    for (int i = n - 2; i >= 0; i--) {
        if (ratings[i] > ratings[i + 1]) {
            candyVec[i] = Math.max(candyVec[i], candyVec[i + 1] + 1); // 如果当前孩子评分比后一个高，确保分到的糖果数量符合要求
        }
    }

    // 计算总糖果数
    for (int i = 0; i < n; i++) {
        result += candyVec[i]; // 累加每个孩子分到的糖果数量
    }

    return result; // 返回总糖果数
}

1. 变量定义和初始化：

   • n：评分数组 ratings 的长度，即孩子的数量。
   • candyVec：长度为 n 的整数数组，用于存储每个孩子分到的糖果数量。
   • result：用于存储最终的总糖果数。

2. 第一次遍历 (从左到右)：

   • 每个孩子至少分到一个糖果，所以初始化 candyVec[0] = 1。
   • 从第二个孩子开始遍历到最后一个孩子 (for (int i = 1; i < n; i++))：
     • 如果当前孩子的评分比前一个孩子高 (ratings[i] > ratings[i - 1])，则当前孩子应比前一个孩子多一个糖果 (candyVec[i] = candyVec[i - 1] + 1)。
     • 否则，当前孩子只分到一个糖果 (candyVec[i] = 1)。

3. 第二次遍历 (从右到左)：

   • 从倒数第二个孩子开始向前遍历到第一个孩子 (for (int i = n - 2; i >= 0; i--))：
     • 如果当前孩子的评分比后一个孩子高 (ratings[i] > ratings[i + 1])，则需要确保当前孩子分到的糖果数量不少于后一个孩子加一 (candyVec[i] = Math.max(candyVec[i], candyVec[i + 1] + 1))。

4. 计算总糖果数：

   • 最后一个循环 (for (int i = 0; i < n; i++)) 用于累加 candyVec 数组中每个孩子分到的糖果数量到 result 中。

5. 返回结果：

   • 函数返回最终的总糖果数 result。

四、柠檬水找零 

题目：

在柠檬水摊上，每一杯柠檬水的售价为 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。

思路：

定义两个变量分别记录收到的5，10元个数，其中如果收到10元，应该减去一个5元个数，如果收到20元，减去一个10和5，或者减去三个5元，如果5元和10元个数均小于0，这说明找不齐零钱，返回false

代码：

public boolean lemonadeChange(int[] bills) {
    int five = 0;
    int ten = 0;

    for (int i = 0; i < bills.length; i++) {
        if (bills[i] == 5) {
            five++; // 如果顾客支付5美元，直接增加5美元的数量
        } else if (bills[i] == 10) {
            five--; // 如果顾客支付10美元，减少5美元的数量
            ten++; // 同时增加10美元的数量
        } else if (bills[i] == 20) {
            if (ten > 0) {
                ten--; // 如果顾客支付20美元且有10美元的零钱，则使用一张10美元
                five--; // 同时使用一张5美元
            } else {
                five -= 3; // 如果没有10美元的零钱，则使用三张5美元
            }
        }
        
        // 检查5美元和10美元的数量是否为负数，如果为负数则无法找零
        if (five < 0 || ten < 0)
            return false;
    }

    return true; // 如果所有账单都能正确找零，则返回true
}

1. 变量初始化：

   • five：用于记录当前手中5美元的数量。
   • ten：用于记录当前手中10美元的数量。

2. 遍历账单数组：

   • for (int i = 0; i < bills.length; i++)：遍历顾客的支付账单。

3. 根据支付金额进行处理：

   • if (bills[i] == 5)：如果顾客支付5美元，直接增加手中5美元的数量 five++。
   • else if (bills[i] == 10)：如果顾客支付10美元，减少手中5美元的数量 five--，同时增加手中10美元的数量 ten++。
   • else if (bills[i] == 20)：如果顾客支付20美元，
     • 如果手中有10美元的零钱 (ten > 0)，则优先使用一张10美元和一张5美元找零，分别减少 ten-- 和 five--。
     • 如果没有10美元的零钱，只能使用三张5美元找零，减少 five -= 3。

4. 检查找零过程中是否能够满足需求：

   • 在每一次找零之后，都会检查当前手中5美元和10美元的数量是否小于0，如果小于0，则无法找零，返回 false。

5. 返回结果：

   • 如果遍历完所有账单后，都能正确找零，则返回 true。

今天的学习就到这里