力扣第 70 场双周赛：5971. 打折购买糖果的最小开销&&5972. 统计隐藏数组数目

总结

• 两道题的思路都走偏过
• 时间紧张（第一道题30分钟，第二道题40分钟，第三道题编译错误未完成）

5971. 打折购买糖果的最小开销

通过的用户数2663
尝试过的用户数2713
用户总通过次数2719
用户总提交次数3888
题目难度Easy
一家商店正在打折销售糖果。每购买 两个 糖果，商店会 免费 送一个糖果。

免费送的糖果唯一的限制是：它的价格需要小于等于购买的两个糖果价格的 较小值 。

比方说，总共有 4 个糖果，价格分别为 1 ，2 ，3 和 4 ，一位顾客买了价格为 2 和 3 的糖果，那么他可以免费获得价格为 1 的糖果，但不能获得价格为 4 的糖果。
给你一个下标从 0 开始的整数数组 cost ，其中 cost[i] 表示第 i 个糖果的价格，请你返回获得 所有 糖果的 最小 总开销。

示例 1：
输入：cost = [1,2,3]
输出：5
解释：我们购买价格为 2 和 3 的糖果，然后免费获得价格为 1 的糖果。
总开销为 2 + 3 = 5 。这是开销最小的 唯一 方案。
注意，我们不能购买价格为 1 和 3 的糖果，并免费获得价格为 2 的糖果。
这是因为免费糖果的价格必须小于等于购买的 2 个糖果价格的较小值。

示例 2：
输入：cost = [6,5,7,9,2,2]
输出：23
解释：最小总开销购买糖果方案为：
- 购买价格为 9 和 7 的糖果
- 免费获得价格为 6 的糖果
- 购买价格为 5 和 2 的糖果
- 免费获得价格为 2 的最后一个糖果
因此，最小总开销为 9 + 7 + 5 + 2 = 23 。

示例 3：
输入：cost = [5,5]
输出：10
解释：由于只有 2 个糖果，我们需要将它们都购买，而且没有免费糖果。
所以总最小开销为 5 + 5 = 10 。
 

提示：

1 <= cost.length <= 100
1 <= cost[i] <= 100

思路

走过的坑： 使用multiset，在倒序遍历时，得不到正确结果
从大到小遍历，每到第三个免费

代码

class Solution {
public:
    int minimumCost(vector<int>& cost) {
        if(cost.size()==1)
            return cost[0];
        else if(cost.size()==2)
            return cost[0]+cost[1];
        sort(cost.begin(),cost.end());
        
        int i,sum=0;
        for(i=cost.size()-1;i>=0;i--)//倒序遍历
        {
            if( (cost.size()-i)%3!=0 )//第三个免费
                sum+=cost[i];
        }
        return sum;
    }
};

5972. 统计隐藏数组数目

通过的用户数1910
尝试过的用户数2390
用户总通过次数1952
用户总提交次数7066
题目难度Medium
给你一个下标从 0 开始且长度为 n 的整数数组 differences ，它表示一个长度为 n + 1 的 隐藏 数组 相邻 元素之间的 差值 。更正式的表述为：我们将隐藏数组记作 hidden ，那么 differences[i] = hidden[i + 1] - hidden[i] 。

同时给你两个整数 lower 和 upper ，它们表示隐藏数组中所有数字的值都在 闭 区间 [lower, upper] 之间。

比方说，differences = [1, -3, 4] ，lower = 1 ，upper = 6 ，那么隐藏数组是一个长度为 4 且所有值都在 1 和 6 （包含两者）之间的数组。
[3, 4, 1, 5] 和 [4, 5, 2, 6] 都是符合要求的隐藏数组。
[5, 6, 3, 7] 不符合要求，因为它包含大于 6 的元素。
[1, 2, 3, 4] 不符合要求，因为相邻元素的差值不符合给定数据。
请你返回 符合 要求的隐藏数组的数目。如果没有符合要求的隐藏数组，请返回 0 。

示例 1：
输入：differences = [1,-3,4], lower = 1, upper = 6
输出：2
解释：符合要求的隐藏数组为：
- [3, 4, 1, 5]
- [4, 5, 2, 6]
所以返回 2 。

示例 2：
输入：differences = [3,-4,5,1,-2], lower = -4, upper = 5
输出：4
解释：符合要求的隐藏数组为：
- [-3, 0, -4, 1, 2, 0]
- [-2, 1, -3, 2, 3, 1]
- [-1, 2, -2, 3, 4, 2]
- [0, 3, -1, 4, 5, 3]
所以返回 4 。

示例 3：
输入：differences = [4,-7,2], lower = 3, upper = 6
输出：0
解释：没有符合要求的隐藏数组，所以返回 0 。

提示：

n == differences.length
1 <= n <= 105
-105 <= differences[i] <= 105
-105 <= lower <= upper <= 105

思路

走过的坑： 尝试用二重循环，不停的遍历differences，得到下一位数字，超时

• 将differences数组（前后两个数之间的差值）转换为hide数组（数组的总体波动值）
• 获得波动的最大值hide[0]和最小值hide[1]
• 遍历[lower,uppper]，判断是否可以在波动后，仍然保持在[lower,uppper]中（这一步可以再精简成为o(1)，之间计算满足的范围的最大最小，而不遍历）

代码

class Solution {
public:
    int numberOfArrays(vector<int>& differences, int lower, int upper) {
        
        vector<int> hide(differences.size());
        int i,j,count=0;
        hide[0]=differences[0];
        for(j=1;j<differences.size();j++)
        {
            hide[j]=differences[j]+hide[j-1];//事实上，得到的波动
            if(hide[j]+lower>upper||hide[j]+upper<lower)//波动如果过大或过小
                return 0;
        }
        sort(hide.begin(),hide.end());//排序，以获得波动的最大值hide[0]和最小值hide[1]
        for(i=lower;i<=upper;i++)
        {
            if(i+hide[0]>=lower&&i+hide[hide.size()-1]<=upper)//因为[lower,uppper]这块是连续的，这里其实可以不用遍历，直接计算[lower,uppper]之间满足的范围即可
                count++;
        }
        
        return count;
    }
};