算法练习：前缀和

已于 2024-03-17 15:17:56 修改
阅读量521 收藏 11
点赞数 8
分类专栏： 算法练习 文章标签： 算法
于 2024-03-17 15:15:48 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_71806743/article/details/136666695
版权

目录

1. 一维前缀和

  1. 题目信息：
    在这里插入图片描述
  2. 题目链接：
    一维前缀和
  3. 思路：求前缀和数组，sum = dp[r] - dp[l - 1]
#include <iostream>
#include <vector>
using namespace std;

int main() 
{
    int n = 0;
    int q = 0;
    cin >> n >> q;
    //先求前缀和数组
    int num = 0;
    //计算时可能溢出
    vector<long long> dp;
    dp.push_back(0);
    for(int i = 0; i < n; i++)
    {
        cin >> num;
        dp.push_back(num + dp[i]);
    }

    //求询问区间之和
    //dp[i] - dp[i - 1]
    //计算时可能溢出
    vector<long long> ret;
    int left = 0,right = 0;
    for(int i = 0; i < q; i++)
    {
        cin >> left >> right;
        ret.push_back(dp[right] - dp[left - 1]);
    }

    for(auto e : ret)
    {
        cout << e << endl;
    }

    return 0;    
}

优化：

int main() 
{
    int n = 0;
    int q = 0;
    cin >> n >> q;
    //先求前缀和数组
    int num = 0;
    //默认初始化为0
    vector<int> arr(n + 1);
    for(int i = 1; i < n + 1; i++)
    {
        cin >> num;
        arr[i] = num;
    }

    //防溢出
    vector<long long> dp(n + 1);
    for(int i = 1; i < n + 1; i++)
    {
        dp[i] = dp[i - 1] + arr[i];
    }

    int l = 0, r = 0;
    while(q--)
    {
        cin >> l >> r;
        cout << dp[r] - dp[l - 1] << endl;
    }
    
    return 0;    
}

2. 二维前缀和

  1. 题目信息：
    在这里插入图片描述
  2. 题目链接：
    二维前缀和
  3. 思路：二维前缀和

在这里插入图片描述

int main()
{
    int n = 0, m = 0, q = 0;
    //先遍历，得值    
    cin >> n >> m >> q;
    vector<vector<long long>> arr;
    vector<long long> part(m + 1);
    for (int i = 0; i < n + 1; i++)
    {
        arr.push_back(part);
    }

    vector<vector<long long>> dp(arr);

    for (int i = 1; i <= n; i++)
    {
        for (int j = 1; j <= m; j++)
        {
            cin >> arr[i][j];
        }
    }

    //求前缀和数组
    for (int i = 1; i <= n; i++)
    {
        for (int j = 1; j <= m; j++)
        {
            dp[i][j] = arr[i][j] + dp[i - 1][j] + dp[i][j - 1] - dp[i - 1][j - 1];
        }
    }

    //求区间值
    //x1,y1小，x2,y2大
    int x1, x2, y1, y2 = 0;
    while (q--)
    {
        cin >> x1 >> y1 >> x2 >> y2;
        cout << dp[x2][y2] - dp[x1 - 1][y2] - dp[x2][y1 - 1] + dp[x1 - 1][y1 - 1] << endl;

    }

    return 0;
}

3. 寻找数组中心下标

  1. 题目信息：
    在这里插入图片描述
  2. 题目链接：
    寻找数组的中心下标
  3. 思路：正向与逆向前缀和数组，边界处理，特殊情况处理
class Solution
{
public:
    int pivotIndex(vector<int>& nums)
    {
        int n = nums.size();
        vector<int> dp1(n);
        vector<int> dp2(n);
        //空
        if(nums.size() == 1)
        {
            return 0;
        }

        int left = 0, right = nums.size() - 1;
        //求前缀和数组
        //顺序
        while (left < nums.size())
        {
            if (left > 0)
            {
                dp1[left] = nums[left] + dp1[left - 1];
            }
            else
            {
                dp1[left] = nums[left];
            }
            left++;
        }
        //倒序
        while (right >= 0)
        {
            if (right < nums.size() - 1)
            {
                dp2[right] = nums[right] + dp2[right + 1];
            }
            else
            {
                dp2[right] = nums[right];
            }
            right--;
        }


        //遍历求中间结点
        for (int cur = 0; cur < nums.size(); cur++)
        {
            //dp1顺序
            //dp2倒序
            if (cur == 0)
            {
                if (dp2[cur + 1] == 0)
                {
                    return cur;
                }
            }
            else if (cur == nums.size() - 1)
            {
                if (dp1[cur - 1] == 0)
                {
                    return cur;
                }
            }
            else
            {
                if (dp1[cur - 1] == dp2[cur + 1])
                {
                    return cur;
                }
            }
        }

        return -1;
    }
};

优化：
在这里插入图片描述

class Solution 
{
public:
    int pivotIndex(vector<int>& nums) 
    {
        int n = nums.size();
        //顺序
        vector<int> f(n);
        //逆序
        vector<int> g(n);

        //边界问题特殊处理
        f[0] = 0;
        //f[i] -> [0, i - 1]
        for(int i = 1; i < n; i++)
        {
            f[i] = nums[i - 1] + f[i - 1];
        }

        g[n - 1] = 0;
        for(int i = n - 2; i >= 0; i--)
        {
            g[i] = g[i + 1] + nums[i + 1];
        }

        for(int i = 0; i < n; i++)
        {
            if(f[i] == g[i])
            {
                return i;
            }
        }

        return -1;
    }
};

4. 除自身以外数组的乘积

  1. 题目信息：
    在这里插入图片描述
  2. 题目链接：
    除自身以外数组的乘积
  3. 思路：前缀 + 后缀数组
class Solution 
{
public:
    vector<int> productExceptSelf(vector<int>& nums) 
    {
        int n = nums.size();
        vector<int> f(n);
        vector<int> g(n);
        f[0] = nums[0];
        for(int i = 1; i < n; i++)
        {
            f[i] = nums[i] * f[i - 1];
        }

        g[n - 1] = nums[n - 1];
        for(int i = n - 2; i >= 0; i--)
        {
            g[i] = nums[i] * g[i + 1];
        }

        vector<int> ret(n);
        for(int i = 0; i < n; i++)
        {
            if(i == 0)
            {
                ret[i] = g[i + 1];
            }
            else if(i == n - 1)
            {
                ret[i] = f[i - 1];
            }
            else
            {
                ret[i] = g[i + 1] * f[i - 1];
            }
        }

        return ret;
    }
};

优化：
在这里插入图片描述

class Solution 
{
public:
    vector<int> productExceptSelf(vector<int>& nums) 
    {
        int n = nums.size();
        vector<int> f(n);
        vector<int> g(n);

        f[0] = 1;
        //顺序
        for(int i = 1; i < n; i++)
        {
            f[i] = f[i - 1] * nums[i - 1];
        }

        g[n - 1] = 1;
        //逆序
        for(int i = n - 2; i >= 0; i--)
        {
            g[i] = g[i + 1] * nums[i + 1];
        }

        vector<int> ret(n);
        for(int i = 0; i < n; i++)
        {
            ret[i] = f[i] * g[i];
        }

        return ret;
    }
};

5. !和为k的子数字

  1. 题目信息：
    在这里插入图片描述
  2. 题目链接：
    和为k的子数组
  3. 思路：前缀和，元素没有单调性，无法使用滑动窗口，逆向求sum - k，可以求得为i为尾的所有数组
class Solution 
{
public:
    int subarraySum(vector<int>& nums, int k) 
    {
        int ret = 0;
        unordered_map<int ,int> hash;
        //sum - k == 0时，即sum就为k
        hash[0] = 1;

        int sum = 0;
        //用哈希表代替遍历
        for(auto e : nums)
        {
            sum += e;
            if(hash.count(sum - k))
            {
                ret += hash[sum - k];
            }
            //插入哈希表
            //可能存在重复前缀和
            hash[sum]++;
        }

        return ret;
    }
};

6. !和可被k整除的子数组

  1. 题目信息：
    在这里插入图片描述
  2. 题目链接：
    和可被k整除的子数组
  3. 思路：前缀和，哈希表，同余定理，C++中负数除以整数的余数修正(num % k + k) % k
class Solution 
{
public:
    int subarraysDivByK(vector<int>& nums, int k) 
    {
        int sum = 0;
        unordered_map<int,int> hash;
        int ret = 0;
        int count = 0;
        //sum % k 本身就符合要求
        hash[0] = 1;
        for(auto e : nums)
        {
            sum += e;
            //(sum1 - sum2) % k == 0
            //同余定理
            //负数除整数的余数
            //哈希表中存余数
            if(hash.count((sum % k + k) % k))
            {
                ret += hash[(sum % k + k) % k];
            }
            hash[(sum % k + k) % k]++;
        }

        return ret;
    }
};

7. !连续数组

  1. 题目信息：
    在这里插入图片描述
  2. 题目链接：
    连续数组
    3.思路：前缀加哈希表，求长度，记录下标
class Solution 
{
public:
    int findMaxLength(vector<int>& nums) 
    {
        for(auto& e : nums)
        {
            if(e == 0)
            {
                e = -1;
            }
        }

        unordered_map<int,int> hash;
        int sum = 0;
        int len = 0;
        //细节，刚好sum为0
        hash[0] = -1;
        for(int i = 0; i < nums.size(); i++)
        {
            //将所有的前缀和与对应下标记录至哈希表中
            sum += nums[i];
            //返回的是长度，最长数组的长度
            if(hash.count(sum) && len < i - hash[sum])
            {
                len = i - hash[sum];
            }
            
            //不存在添加下标
            if(!hash.count(sum))
            {
                hash[sum] = i;
            }
        }

        return len;
    }
};

@8. 矩阵区域和

  1. 题目信息：
    在这里插入图片描述
  2. 题目链接：
    矩阵区域和
  3. 思路：前缀和二维数组，边界问题分析

思路：
在这里插入图片描述
边界问题：
在这里插入图片描述

class Solution 
{
public:
    vector<vector<int>> matrixBlockSum(vector<vector<int>>& mat, int k)
    {
        vector<int> part1(mat[0].size(), 0);
        vector<vector<int>> answer(mat.size(), part1);
        vector<int> part2(mat[0].size() + 1, 0);
        vector<vector<int>> dp(mat.size() + 1, part2);
        //二维数组的前缀和
        for (int i = 1; i < dp.size(); i++)
        {
            for (int j = 1; j < dp[0].size(); j++)
            {
                dp[i][j] = dp[i - 1][j] + dp[i][j - 1] - dp[i - 1][j - 1] + mat[i - 1][j - 1];
            }
        }

        for (int i = 0; i < mat.size(); i++)
        {
            for (int j = 0; j < mat[0].size(); j++)
            {
                int sum = 0;
                //右下角
                //边界情况，修正
                int pos1 = i + k + 1;
                int pos2 = j + k + 1;
                if (pos1 >= dp.size())
                {
                    pos1 = dp.size() - 1;
                }

                if (pos2 >= dp[0].size())
                {
                    pos2 = dp[0].size() - 1;
                }
                sum += dp[pos1][pos2];

                //右上角
                pos1 = i - k;
                pos2 = j + k + 1;
                //i符合，j不符合
                if (pos1 >= 1 && pos2 >= dp[0].size())
                {
                    pos2 = dp[0].size() - 1;
                }

                if (pos1 >= 1 && pos2 < dp[0].size())
                {
                    sum -= dp[pos1][pos2];
                }

                //左下角
                pos1 = i + k + 1;
                pos2 = j - k;
                //i不符合，j符合
                if (pos1 >= dp.size() && pos2 >= 1)
                {
                    pos1 = dp.size() - 1;
                }

                if (pos1 < dp.size() && pos2 >= 1)
                {
                    sum -= dp[pos1][pos2];
                }

                //左上角
                if (i - k >= 1 && j - k >= 1)
                {
                    sum += dp[i - k][j - k];
                }

                answer[i][j] = sum;
            }
        }

        return answer;
    }
};
执笔者548
关注
  • 8
    点赞
  • 踩
  • 11
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
leetcode气温-leetcode:leetcode算法练习
07-01
leetcode气温 leetcode leetcode算法练习 最长上升子序列 重叠 不重叠 dp 贪心算法 : 贪心算法、队列 单调栈 拓扑排序 前缀和: 前缀和之间的差 动态规划 回文串 需要注意dp的计算顺序, 被依赖的dp状态需要先通过已知的状态计算出来 回溯算法: 剪枝排除重复项 考虑剪枝 隐式回溯 组合总和两题的不同在于每个元素能否重复使用 路径和
leetcode单词接龙2-algo_practice:数据结构和算法练习,php,golang刷leetcode
06-30
leetcode单词接龙2 数据结构和算法练习 Success belongs to the persevering! leetcode 编号 php (leetcode/php) go （leetcode/go/algo） c 001.两数之和 001.php 001.go - 002.两数相加 002.php 002.go - 003.无重复字符的最长子串 003.php 003.go - 004.寻找两个正序数组的中位数 04.php - - 005.最长回文子串 05 005.go - 006.Z 字形变换 006.php 006.go - 007.整数反转 07.php 007.go - 008.字符串转换整数 (atoi) 08.php - - 009.回文数 09.php 009.go - 010.正则表达式匹配 10.php - - 011.盛水最多的容器 11.php 011.go 012.整数转罗马数字 12.php . 013.罗马数字转整数 13.php . 014.最长公共前缀 014.php 014.go 015.三数之和 015.php 015.go 01
算法专题：前缀和
zhishichengjin的博客
02-18 961
算法专题：前缀和
算法专练：前缀和
m0_67739923的博客
05-10 497
前缀和水题
算法3：前缀和
weixin_73538099的博客
01-17 332
前缀和是指某序列的前n项和，可以把它理解为数学上的数列的前n项和，合理的使用前缀和，可以将某些复杂的问题简单化，从而降低时间复杂度。
算法学习：前缀和
2301_76884895的博客
09-09 74
一维数组：先算各区间的和，利用区间和算出目标值二维数组：找到一个共同的顶点(从目标矩阵的四个顶点中找到最合适的一个)，以顶点向四周矩形状发散，通过大矩形加减内部小矩形的方式算出目标区域的元素和子数组的数量查找：类似于一维数组先进行前缀和的存储，然后根据题意利用已算好的前缀和去找到目标值，其难点在于利用哈希表去存储前缀和并映射出其出现的次数，方便查找。
Java前缀和算法
m0_65431718的博客
05-24 6386
通俗来讲，前缀和算法就是使用一个新数组来储存原数组中前n-1个元素的和（如果新数组的当前元素的下标为n，计算当前元素的值为原数组中从0到n-1下标数组元素的和
算法--前缀和
程天爽的博客
02-02 968
前缀和概念及相应练习题
算法练习六： 最长公共前缀
csx19911206的博客
01-03 128
题目： 编写一个函数来查找字符串数组中的最长公共前缀。 如果不存在公共前缀，返回空字符串 ""。 示例 1: 输入: ["flower","flow","flight"] 输出: "fl" 示例 2: 输入: ["dog","racecar","car"] 输出: "" 解释: 输入不存在公共前缀。 说明:
lrucacheleetcode-leetcode:算法实践
06-29
Leetcode练习题极客时间算法训练营题目练习 基础算法 简单的二和 EasyValid 括号 中解码字符串https://leetcode.com/problems/decode-string/ HardLRU 缓存https://leetcode.com/problems/lru-cache/submissions/ ...
数据结构实现：我在练习问题时实现的算法集合
02-21
排序算法（气泡，选择，插入，合并，堆和快速排序） Knuth-Morris-Pratt（ ） 广度优先搜索图 深度优先搜索图 合并K排序数组（ ） Dijkstra的算法邻接矩阵（shorturl.at/rIMQ0） 拓扑排序（ ） 有向图的循环...
lrucacheleetcode-LeetCode_Solutions:练习题以提高C++语言中的算法和数据结构使用
06-29
最长公共前缀 20 ---> 有效括号 21 ---> 合并两个排序列表 26 ---> 从排序数组中删除重复项 27 ---> 删除元素 28 ---> 实现 strStr() 88 ---> 合并排序数组 141 --> 链表循环 242 --> 有效...
1 月 28日算法练习-前缀和
小蒋的博客
01-28 320
思路：把 L 看成 1，Q 看成 -1，利用前缀和来得到输入串的前缀子串中LQ 的和，利用前缀和差的性质得到子串，通过枚举看它是否平衡。将L看做1，Q看做－1，只有当某个区间的和为0时，字符串是平衡的。我们可以预处理出前缀和，然后枚举所有区间（这一步的时间复杂度是O（n^2）的），得到所有平衡区间的长度最后取大输出即可。
LeetCode算法题：9. 回文数（Java解法）
tqh267的博客
05-08 394
只是在防止反转后数值溢出处理使用了判断逻辑，判断int型溢出逻辑可以查看我的第8题讲解文章，即在计算之前判断是否大于int的最大值/10，以及再计算之后的值是否小于0。将整数转为字符串->分别定义一个下标指向字符串头和尾，以此对比头和尾所指字符是否相同，如果不同则返回false，直到头下标超过尾下标，表示是回文数，返回true。将整数转为字符串->将字符串反转->判断反转后的字符串是否与之前字符串相同，如果相同则是回文数，否则不是回文数。是指正序（从左向右）和倒序（从右向左）读都是一样的整数。
算法训练Day26 | 332.重新安排行程 ● 51. N皇后 ● 37. 解数独
最新发布
WIIIter的博客
05-08 135
【代码】算法训练Day26 | 332.重新安排行程 ● 51. N皇后 ● 37. 解数独。
浅谈TopK问题（堆的应用，文件处理，堆排序）
lzh20040919的博客
04-30 466
这些排序方法就不适用了，就比如当数据到达10亿时，再使用冒泡排序，它的时间复杂度就相当恐怖了，这时我们就要用到。，如果我们按上述操作对堆顶元素进行替换，那么也只能不断更新这个最大值，我们能使用的方法有很多，就比如比较简单的冒泡排序，他的时间复杂度是。的性质来满足我们的TopK了，这时它的时间复杂度是。在文件data.txt中找出前K个最大的数据。，循环完成后小堆就剩下前K个最大的数据。堆实现思路：（前K个最大的数据）找出最大或最小的前K个数据。找最大建小堆，找最小建大堆。个数据建大小为K的小堆。
c++容器与算法概述
北风
05-01 599
简单讲述输入输出运算符重载 以及容器的简单使用及接口哦苦
基于模糊PI控制算法的龙格库塔CSTR模型控制系统simulink建模与仿真
熟悉MATLAB/fpga/RK3588/LABVIEW/protus/单片机/dsp/Multisim
04-30 747
基于模糊PI控制算法的龙格库塔CSTR模型控制系统simulink建模与仿真。基于模糊PI控制算法的龙格-库塔（Runge-Kutta, RK）连续搅拌釜反应器（Continuous Stirred Tank Reactor, CSTR）模型控制系统，是将模糊控制理论与经典的数值积分方法相结合的一种先进控制策略。模糊控制是一种基于模糊集合理论和语言变量的控制方法，适用于非线性、时变系统的控制。
贪心算法练习：数列极差问题
05-31
- 第一行包含两个整数 n 和 k，表示数列的长度和所求的差值。 - 第二行包含 n 个整数，表示整个数列。 输出格式： - 输出一个整数，表示答案。 输入样例： ``` 5 2 1 3 5 6 9 ``` 输出样例： ``` 5 ``` 算法分析...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值