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

参考

代码随想录

题目一：LeetCode 1005.k次取反后最大化的数组和

• 第一步，按照绝对值大小将数组从小到大排序；
• 第二步，从后往前遍历数组（保证绝对值最大的负数优先取反），将负数取反，每取反一次，k减1，如果k = 0，退出遍历
• 第三步，如果k > 0且k为奇数，则将第一个数（此时这个数最小）取反
• 第四步，求和

代码实现如下：

class Solution {
public:
    static bool cmp(int a, int b)
    {
        return abs(a) < abs(b);
    }
    int largestSumAfterKNegations(vector<int>& nums, int k) {
        int sum = 0;
        int index = 0;
        bool zero_flag = false;  //数组有无0的标记
        sort(nums.begin(),nums.end(),cmp);  //按照绝对值进行排序
        for(int i = nums.size()-1; i >= 0 && k > 0; i--)
            if(nums[i] < 0) nums[i] = -nums[i],k--;  //负数取反
        if(k > 0 && k % 2 != 0 && zero_flag == false)
            nums[0] = -nums[0];
        //求和
        for(int i = 0; i < nums.size(); i++)
            sum += nums[i];
        return sum;
    }
};
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

题目二：LeetCode 134.加油站

暴力求解

这个题很容易想到的是暴力求解，但是暴力求解会超时。。。暴力求解的思路如下：尝试从某个点出发，计算到下一站剩余的油量，一旦剩余油量为负就说明不可能从这个点出发。代码实现如下：

class Solution {
public:
    int canCompleteCircuit(vector<int>& gas, vector<int>& cost) {
        int sum = 0;
        int index;
        vector<int> diff(gas.size());
        for(int i = 0; i < gas.size(); i++)
            diff[i] = gas[i] - cost[i];
        for(int i = 0; i < diff.size(); i++){
            if(diff[i] >= 0){
                index = i;
                sum = 0;
                do{
                    sum += diff[index];
                    index = (index + 1) % diff.size();
                    if(sum < 0) break;
                }while(index != i);
            if(sum >= 0) return i;
            }
        }
        return -1;
    }
};
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

贪心算法

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

每个加油站的剩余量rest[i]为gas[i] - cost[i]。

i从0开始累加rest[i]，和记为curSum，一旦curSum小于零，说明[0, i]区间都不能作为起始位置，起始位置从i+1算起，再从0计算curSum。这个怎么理解？最理想的情况是每个点油量都有剩余，但实际上更多的是有些点剩很多，有些点不够用，剩余的去填补不够用的，如果到某个点的油量剩余rest[j]为负说明消耗大于存储量（似乎是废话），在[i,j]区间内的任一点开始还是会出现rest为负的情况，因为我们是只有在rest为正的情况下才会继续累加，出现负说明不足以填补。

因此在[i,j]区间累加出现负时，下一次的起始位置是j+1而不是i+1.

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

代码实现如下：

class Solution {
public:
    int canCompleteCircuit(vector<int>& gas, vector<int>& cost) {
        int curSum = 0;
        int totalSum = 0;
        int start = 0;
        for (int i = 0; i < gas.size(); i++) {
            curSum += gas[i] - cost[i];
            totalSum += gas[i] - cost[i];
            if (curSum < 0) {   // 当前累加rest[i]和 curSum一旦小于0
                start = i + 1;  // 起始位置更新为i+1
                curSum = 0;     // curSum从0开始
            }
        }
        if (totalSum < 0) return -1; // 说明怎么走都不可能跑一圈了
        return start;
    }
};
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

题目三：LeetCode 135.分发糖果

这道题目一定是要确定一边之后，再确定另一边，例如比较每一个孩子的左边，然后再比较右边，如果两边一起考虑一定会顾此失彼。
先确定右边评分大于左边的情况（也就是从前向后遍历）

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

局部最优可以推出全局最优。

如果ratings[i] > ratings[i - 1] 那么[i]的糖 一定要比[i - 1]的糖多一个，所以贪心：candyVec[i] = candyVec[i - 1] + 1

// 从前向后
for (int i = 1; i < ratings.size(); i++) {
    if (ratings[i] > ratings[i - 1]) candyVec[i] = candyVec[i - 1] + 1;
}
1
2
3
4

再确定左孩子大于右孩子的情况（从后向前遍历）。为什么不能从前向后遍历呢？

因为如果从前向后遍历，根据 ratings[i + 1] 来确定 ratings[i] 对应的糖果，那么每次都不能利用上前一次的比较结果了。所以确定左孩子大于右孩子的情况一定要从后向前遍历！

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

那么又要贪心了，局部最优：取candyVec[i + 1] + 1 和 candyVec[i] 最大的糖果数量，保证第i个小孩的糖果数量即大于左边的也大于右边的。全局最优：相邻的孩子中，评分高的孩子获得更多的糖果。

局部最优可以推出全局最优。

所以就取candyVec[i + 1] + 1 和 candyVec[i] 最大的糖果数量，candyVec[i]只有取最大的才能既保持对左边candyVec[i - 1]的糖果多，也比右边candyVec[i + 1]的糖果多。

// 从后向前
for (int i = ratings.size() - 2; i >= 0; i--) {
    if (ratings[i] > ratings[i + 1] ) {
        candyVec[i] = max(candyVec[i], candyVec[i + 1] + 1);
    }
}
1
2
3
4
5
6

整体代码如下：

class Solution {
public:
    int candy(vector<int>& ratings) {
        vector<int> candyVec(ratings.size(), 1);
        // 从前向后
        for (int i = 1; i < ratings.size(); i++) {
            if (ratings[i] > ratings[i - 1]) candyVec[i] = candyVec[i - 1] + 1;
        }
        // 从后向前
        for (int i = ratings.size() - 2; i >= 0; i--) {
            if (ratings[i] > ratings[i + 1] ) {
                candyVec[i] = max(candyVec[i], candyVec[i + 1] + 1);
            }
        }
        // 统计结果
        int result = 0;
        for (int i = 0; i < candyVec.size(); i++) result += candyVec[i];
        return result;
    }
};
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

小结：对于每个孩子，他分得的糖果与左右孩子的得分有关，因为每个孩子至少有一个糖果，所以一开始给每个孩子都发一个糖果，然后在确定得分的大小关系。从前往后，如果当前孩子比左边的孩子得分高，就给当前孩子多发一个糖果，这样保证某个孩子如果得分比左边孩子高时得到的糖果也更多；然后再从后往前，如果当前孩子比右边孩子得分高，就给当前孩子多发一个糖果，这样保证某个孩子如果得分比右边孩子高时得到的糖果也更多。整体下来就能保证相邻两个孩子评分更高的孩子会获得更多的糖果。