前缀和问题举例详解

目录

前言

1.梦开始的地方

560. 和为 K 的子数组力扣链接

2.增加一些变式

523. 连续的子数组和力扣

 3.总结

 4.不按套路出牌

2602. 使数组元素全部相等的最少操作次数力扣

---

前言

        这里面的题目都源于力扣。其中我给出的代码第一个函数视为主函数，其中用了一些stl库容器 看见vector<T>当作数组即可，unordered_map<T, TT>是一种关联容器,存储基于键值和映射组成的元素,即key-value。

1.梦开始的地方

560. 和为 K 的子数组力扣链接

给你一个整数数组 nums 和一个整数 k ，请你统计并返回 该数组中和为 k 的连续子数组的个数 。

示例1 ：

输入：nums = [1,1,1],k = 2

输出：2

示例 2：

输入：nums = [1,2,3], k = 3

输出：2

提示：

1 <= nums.length <= 2 * 104

-1000 <= nums[i] <= 1000

-107 <= k <= 107

        先分析题目，这个题的意思就是让我们从一个数组里面找一个连续的子数组，然后他们的和要为指定目标k，我的第一个想法就是写多个循环， 然后去凑，然后发现不可取，因为这个实在是太多了，根本不知道要写几个循环，这个时候我又想起来了滑动窗口，好像可行，但是实现起来发现 时间要的太久了，所以也放弃了，所以在这里引入一个新的思想，那就是前缀和求解。

        首先举个例子，原数组的值为[1，2，3，4，5，6，7]，那么他的前缀和数组就是[0，1，3，6，10，15，21，28]，这个意思就是假如我们 要求解3 + 4 + 5，那么我们可以直接用前缀和数组下标5的值减去下标2的值，这样我们就可以得到3 + 4 + 5 = 15 - 3 = 12，发现什么规律了， 假设end下标为right，start下标为left，那么就是前缀和数组[right + 1] - [left]得到答案。

        这样我们回到题目，我们可以通过这种方式，先将前缀和数组求出来，然后只需要再写一个双循环就可以解决问题了。 

class Solution 
{
public:
    int subarraySum(vector<int>& nums, int k) 
    {
        int n = nums.size();
        vector<int> ans(n + 1, 0);    //前缀和数组
        int cnt = 0;
        for(int i = 0; i < n; ++i)
            ans[i + 1] = ans[i] + nums[i];
        for(int i = 1; i < n + 1; ++i)
            for(int j = i - 1; j >= 0; --j)
                if(ans[i] - ans[j] == k) ++cnt;
        return cnt;
    }
};

        但是时间超时了通过计算时间复杂度发现是O(n^2)，那就想办法降低时间复杂度，我们通过发现我们得知，循环的时候要求解值只跟前面的下标有关，那么我们可以边使用前缀和的时候边统计，这样时间复杂度就变成了O(n)，大大缩短了时间，具体实现如下

class Solution 
{
public:
    int subarraySum(vector<int>& nums, int k) 
    {
        unordered_map<int, int> cnt;
        cnt[0] = 1;                     //为了刚好前缀和为k的情况准备
        int sum = 0;
        int count = 0;
        for(int &num : nums)
        {
            sum += num;
            count += cnt[sum - k];
            cnt[sum]++;
        }
        return count;
    }
};

         我们来分析这些语句，这里我们使用了unordered_map容器，它的本质就是一个散列表，查询时间是O(1)，首先得将0这个值的时候置为1，因为可能存在连续数组求和得到的值刚好为k，然后用sum去模仿求和，count储存答案数量，查看示例1：nums = [1,1,1], k = 2。我们来人脑运行一次，第一次循环，sum = 1， 然后将cnt[1] = 1，记录有一个和为1的值，然后看cnt[sum - k]，sum - k的意思就是寻找前面有没有和现在相差k的值，其实就是双循环里面的相减，要是有那么就加上他出现的次数，当循环第二次时，sum = 2，此时我们发现这个求和的值等于k，那么这就用到了我们一开始设置的cnt[0] = 1，加上它并且记录自己，第三次循环，sum = 3，sum - k = 1，我们得知前面存在一个和为1的值，那么在加上，并且记录自己。

2.增加一些变式

523. 连续的子数组和力扣

给你一个整数数组 nums 和一个整数 k ，编写一个函数来判断该数组是否含有同时满足下述条件的连续子数组：

• 子数组大小 至少为 2 ，且
• 子数组元素总和为 k 的倍数。

如果存在，返回 true ；否则，返回 false 。

如果存在一个整数 n ，令整数 x 符合 x = n * k ，则称 x 是 k 的一个倍数。0 始终视为 k 的一个倍数。

示例 1：

输入：nums = [23,2,4,6,7], k = 6
输出：true
解释：[2,4] 是一个大小为 2 的子数组，并且和为 6 。

示例 2：

输入：nums = [23,2,6,4,7], k = 6
输出：true
解释：[23, 2, 6, 4, 7] 是大小为 5 的子数组，并且和为 42 。 
42 是 6 的倍数，因为 42 = 7 * 6 且 7 是一个整数。

提示：

• 1 <= nums.length <= 105
• 0 <= nums[i] <= 109
• 0 <= sum(nums[i]) <= 231 - 1
• 1 <= k <= 231 - 1

        这题一看也是前缀和，只不过我们不是简单的求和就行了，而是求和并且寻找是不是k的倍数，这里引入一个数学原理，10 % 7 = 3， 3 % 7 = 3，所以(10 - 3) % 7 = 0，这个意思就是相同取模的数相减得到的值时取模数的倍数。这样就符合我们前缀和的思路了，求和然后看有没有符合条件的。代码如下。

class Solution 
{
public:
    // 跟1590很像
    bool checkSubarraySum(vector<int>& nums, int k) 
    {
        unordered_map<int, int> mp;
        mp[0] = -1;
        int s = 0, n = nums.size();
        for(int i = 0; i < n; ++i)
        {
            s = (s + nums[i]) % k;
            if(mp.count(s))
            {
                int pre = mp[s];
                if(i - mp[s] >= 2) return true;
            }
            else mp[s] = i;
        }
        return false;
    }
};

         但是在这里我们就不是简单的记录出现的次数，因为题目中要求的是长度，所以我们得记录下标，那么初始mp[0] = -1必须得这样写，因为还是防止有和刚好为k的值。其他地方差不多就不多说了。

 3.总结

        具体来说其实我们就是看见有连续二字或者题目中暗示是连续的求解，这样我们得想起来前缀和的思想。

总结了一些题

525. 连续数组力扣

974. 和可被 K 整除的子数组力扣

1371. 每个元音包含偶数次的最长子字符串力扣

1542. 找出最长的超赞子字符串力扣

1590. 使数组和能被 P 整除力扣

1915. 最美子字符串的数目力扣

面试题 17.05. 字母与数字力扣

 4.不按套路出牌

2602. 使数组元素全部相等的最少操作次数力扣

给你一个正整数数组 nums 。同时给你一个长度为 m 的整数数组 queries 。第 i 个查询中，你需要将 nums 中所有元素变成 queries[i] 。你可以执行以下操作 任意 次：

• 将数组里一个元素 增大 或者 减小 1 。

请你返回一个长度为 m 的数组 answer ，其中 answer[i]是将 nums 中所有元素变成 queries[i] 的 最少 操作次数。

注意，每次查询后，数组变回最开始的值。

示例 1：

输入：nums = [3,1,6,8], queries = [1,5]
输出：[14,10]
解释：第一个查询，我们可以执行以下操作：
- 将 nums[0] 减小 2 次，nums = [1,1,6,8] 。
- 将 nums[2] 减小 5 次，nums = [1,1,1,8] 。
- 将 nums[3] 减小 7 次，nums = [1,1,1,1] 。
第一个查询的总操作次数为 2 + 5 + 7 = 14 。
第二个查询，我们可以执行以下操作：
- 将 nums[0] 增大 2 次，nums = [5,1,6,8] 。
- 将 nums[1] 增大 4 次，nums = [5,5,6,8] 。
- 将 nums[2] 减小 1 次，nums = [5,5,5,8] 。
- 将 nums[3] 减小 3 次，nums = [5,5,5,5] 。
第二个查询的总操作次数为 2 + 4 + 1 + 3 = 10 。

示例 2：

输入：nums = [2,9,6,3], queries = [10]
输出：[20]
解释：我们可以将数组中所有元素都增大到 10 ，总操作次数为 8 + 1 + 4 + 7 = 20 。

提示

• n == nums.length
• m == queries.length
• 1 <= n, m <= 105
• 1 <= nums[i], queries[i] <= 109

        这个题乍一看，这跟前缀和有什么关系啊，这不就是搞个双循环然后直接加就完事了，但是周赛第三题是不会让你能用暴力解决的，这里你如果使用了循环像我一开始一样。如下

class Solution 
{
public:
    vector<long long> minOperations(vector<int>& nums, vector<int>& queries) 
    {
        vector<long long> ans;
        for(int &num : queries)
        {
            long long sum = 0;
            for(int i = 0; i < nums.size(); ++i)
                sum += abs(num - nums[i]);
            ans.emplace_back(sum);
        }
        return ans;
    }
};

         它会给你报一个超出时间限制，那肯定就得想办法去降低时间复杂度，我首先想到的就是以queries每个下标的值作为一个分界线，然后左边的求和，右边的在求和然后统一变成目标值，这样就牵扯到了前缀和，先将前缀和数组算出来，但是找边界线得有序，所以还得先排序，这样就可以解决问题了。代码如下

class Solution 
{
public:
    vector<long long> minOperations(vector<int>& nums, vector<int>& queries) 
    {
        int n = nums.size();
        sort(nums.begin(), nums.end());
        vector<long long> ans;
        vector<long long> dir(n + 1);
        for(int i = 0; i < n; ++i)
            dir[i + 1] = (long long)dir[i] + (long long)nums[i];
        for(int &num : queries)
        {
            long long i;
            long long sum = 0;
            long long sum1 = 0, sum2 = 0;
            for(i = 0; i < n; ++i) if(nums[i] > num) break;
            sum1 += dir[n] - dir[i] - (n - i) * num;
            sum2 += i * num - dir[i];
            sum += sum1 + sum2;
            ans.emplace_back(sum);
        }
        return ans;
    }
};

         遗憾的是还是超时了，那么就得在继续优化，我当时能想到的只有在查询分界下标的时候用二分查找。代码如下

class Solution 
{
public:
    vector<long long> minOperations(vector<int>& nums, vector<int>& queries) 
    {
        long long n = nums.size();
        sort(nums.begin(), nums.end());
        vector<long long> ans;
        vector<long long> dir(n + 1);
        for(int i = 0; i < n; ++i)
            dir[i + 1] = dir[i] + nums[i];
        for(int &num : queries)
        {
            long long sum = 0;
            long long sum1 = 0, sum2 = 0;
            long long i = f(num, nums);
            sum1 += dir[n] - dir[i] - (n - i) * num;
            sum2 += i * num - dir[i];
            sum += sum1 + sum2;
            ans.emplace_back(sum);
        }
        return ans;
    }

    long long f(int n, vector<int>& nums)
    {
        long long l = 0, r = nums.size() - 1;
        while(l <= r)
        {
            long long mid = l + (r - l) / 2;
            if(n > nums[mid]) l = mid + 1;
            else if(n < nums[mid]) r = mid - 1;
            else return mid;
        }
        return l;
    }
};

         直到这个时候终于过了。这个题综合了各种知识点，而且难度不大很容易就能知道怎么去写，只是优化稍微复杂一点，我觉得是一个完美的题。