C++ 前缀和

已于 2024-05-11 21:31:30 修改
阅读量1.1k 收藏 24
点赞数 35
文章标签： c++ 算法 数据结构 leetcode
于 2024-03-03 11:55:47 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_74922218/article/details/136427802
版权

目录

目录

前缀和

二维前缀和

寻找数组的中心下标

除自身以外数组的乘积

和为 K 的子数组

和可被 K 整除的子数组

连续数组

矩阵区域和

最大子矩阵

前缀和

DP34 【模板】前缀和

分析：dp和arr的大小并不是固定的，就是有没有偏移量，这里的n是从1开始，不如直接放到下标1处，在最后的减法时，如果用第一个参考代码会下标越界到-1，所以说这里的方法并不是固定的，思路，偏移量理清了静下心就可以上手写

注意：a[i] 的最大值是INT_MAX，所以创建long long 类型的dp表

参考代码:dp[n + 1],arr[n + 1]

#include <iostream>
using namespace std;
#include <vector>
int main() {
    int n = 0, q = 0;
    cin >> n >> q;
    vector<int> arr(n + 1);
    for(int i = 1; i < n + 1; i++)
        cin >> arr[i];
    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;
}
// 64 位输出请用 printf("%lld")

参考代码: dp[n],arr[n]

#include <iostream>
using namespace std;
#include <vector>
int main() {
    int n = 0, q = 0;
    cin >> n >> q;
    vector<int> arr(n);
    for(int i = 0; i < n; i++)
        cin >> arr[i];
    vector<long long> dp(n);
    dp[0] = arr[0];
    for(int i = 1; i < n; i++)
        dp[i] = dp[i - 1] + arr[i];
    
    int l = 0, r = 0;
    while(q--)
    {
        cin >> l >> r;
        cout << dp[r - 1] - dp[l - 1] + arr[l - 1] << endl;
    }
    return 0;
}
// 64 位输出请用 printf("%lld")

参考代码：dp[n],arr[n + 1]

#include <iostream>
using namespace std;
#include <vector>
int main() {
    int n = 0, q = 0;
    cin >> n >> q;
    vector<int> arr(n + 1);
    for(int i = 1; i <= n; i++)
        cin >> arr[i];
    vector<long long> dp(n);
    dp[0] = arr[1];
    for(int i = 1; i < n; i++)
        dp[i] = dp[i - 1] + arr[i + 1];
    
    int l = 0, r = 0;
    while(q--)
    {
        cin >> l >> r;
        cout << dp[r - 1] - dp[l - 1] + arr[l] << endl;
    }
    return 0;
}
// 64 位输出请用 printf("%lld")

二维前缀和

DP35 【模板】二维前缀和

 

dp和原数组对齐了，就没有偏移量

注意：a[i][j] 的最大值是INT_MAX，所以创建long long 类型的dp表

参考代码

#include <iostream>
using namespace std;
#include <vector>
int main() {
    int n = 0, m = 0, q = 0;
    cin >> n >> m >> q;
    vector<vector<int>> arr(n + 1, vector<int>(m + 1));
    for(int i = 1; i < n + 1; i++)
        for(int j = 1; j < m + 1; j++)
            cin >> arr[i][j];
    vector<vector<long long>> dp(n + 1, vector<long long>(m + 1));
    for(int i = 1; i < n + 1; i++)
        for(int j = 1; j < m + 1; j++)
            dp[i][j] = dp[i - 1][j] + dp[i][j - 1] - dp[i - 1][j - 1] + arr[i][j];
    while(q--)
    {
        int x1 = 0, y1 = 0, x2 = 0, y2 = 0;
        cin >> x1 >> y1 >> x2 >> y2;
        cout << dp[x2][y2] - dp[x2][y1 - 1] - dp[x1 - 1][y2] + dp[x1 - 1][y1 - 1] << endl; 
    }
    return 0;
}

寻找数组的中心下标

724. 寻找数组的中心下标

 要点：f[i] = f[i - 1] + nums[i - 1];就是看后面的nums，如果是i - 1，就是不包括自己的前缀和，f[0]自然是0，这题包不包括都可以，包括就是等式两边同时加上自己这个元素，

参考代码

class Solution {
public:
    int pivotIndex(vector<int>& nums) {
        int n = nums.size();
        vector<int> f(n), g(n);
        for(int i = 1; i < n ; i++)
            f[i] = f[i - 1] + nums[i - 1];
        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;
    }
};

除自身以外数组的乘积

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

注意点：f[0] = 1， g[n - 2] = 1

参考代码

class Solution {
public:
    vector<int> productExceptSelf(vector<int>& nums) {
        int n = nums.size();
        vector<int> f(n), g(n), ret(n);
        f[0] = g[n - 1] = 1;
        for(int i = 1; i < n; i++)
            f[i] = f[i - 1] * nums[i - 1];
        for(int i = n - 2; i >= 0; i--)
            g[i] = g[i + 1] * nums[i + 1];
        for(int i = 0; i < n; i++)
            ret[i] = f[i] * g[i];
        return ret;
    }
};

和为 K 的子数组

560. 和为 K 的子数组

可以不用前缀和，因为这里不需要用到下标随机访问，这里只需要顺序访问

这里不可以用滑动窗口：因为没有单调性

把有的sum都放到哈希表里就行，先判断 : hash.count(sum)   再放入哈希表

注意：这里有个hash[0] = 1，sum = k时候也是符合条件，但是哈希表里没有hash[0]，(但是之后是会可能会添加上hash[0]，就是中间有个地方前缀和为0)，总的来说就是少了一个起点0

参考代码

class Solution {
public:
    int subarraySum(vector<int>& nums, int k) {
        // int n = nums.size(), ret = 0;
        // vector<int> dp(n);
        // dp[0] = nums[0];
        // for(int i = 1; i < n; i++)
        //     dp[i] = dp[i - 1] + nums[i];
        
        // unordered_map<int, int> hash;
        // hash[0] = 1;
        // for(auto e : dp)
        // {
        //     if(hash.count(e - k)) ret += hash[e - k];//hash[e - k]
        //     hash[e]++;
        // }
        // // for(int i = 0; i < n; i++)
        // // {
        // //     if(hash.count(dp[i] - k)) ret += hash(dp[i] - k);
        // //     hash[dp[i]]++;
        // // }
        // return ret;

        unordered_map<int, int> hash;
        hash[0] = 1;
        int sum = 0, ret = 0;
        for(int i = 0; i < nums.size(); i++)
        {
            sum += nums[i];
            if(hash.count(sum - k)) ret += hash[sum - k];
            hash[sum]++;
        }
        return ret;
    }
};

和可被 K 整除的子数组

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

参考代码

class Solution {
public:
    int subarraysDivByK(vector<int>& nums, int k) {
        unordered_map<int, int> hash;
        hash[0] = 1;
        int sum = 0, ret = 0;
        for(int i = 0; i < nums.size(); i++)
        {
            sum += nums[i];
            if(hash.count((sum % k + k) % k)) ret += hash[(sum % k + k) % k];
            hash[(sum % k + k) % k]++;
        }
        return ret;
    }
};

连续数组

525. 连续数组

题解：把0 改成 -1，之后求和为0的最长子数组，有负数，自然不能用滑动窗口

因为求的是长度吗，那么这里就是最短索引和前缀和的映射，<前缀和，最小索引>

因为是顺序遍历 ，那么不存在就添加进哈希表，这样就可以得到最小索引，既可以不用dp表，也直接找到最小索引

注意：这样就可以理解为什么是i - hash[sum]

参考代码

class Solution 
{
public:
    int findMaxLength(vector<int>& nums) 
    {
        unordered_map<int, int> hash;
        int sum = 0, ret = 0;
        hash[0] = -1;
        // for(auto e : nums)
        // {
        //     sum += e == 0 ? -1 : e;
        //     if(hash.count(sum)) ret = max(ret, );
        //     else hash[sum]++;
        // }
        for(int i = 0; i < nums.size(); i++)
        {
            sum += nums[i] == 0 ? -1 : 1;
            if(hash.count(sum)) ret = max(ret, i - hash[sum]);
            else hash[sum] = i;
        }

        return ret;
    }
};

矩阵区域和

1314. 矩阵区域和

分析：涉及偏移量，和对越界的处理，如果二维dp不是 行列 + 1那么边界情况就麻烦了，一维dp若不是n + 1 只有开头或者结尾处理，

偏移：mat 到dp 的偏移，dp 到 ret的偏移

注意：int x2 = min(i + k, m - 1) + 1, y2 = min(j + k, n - 1) + 1;我在写的时候错在不是m - 1

参考代码

class Solution {
public:
    vector<vector<int>> matrixBlockSum(vector<vector<int>>& mat, int k) {
        int m = mat.size(), n = mat[0].size();
        vector<vector<int>> dp(m + 1, vector<int>(n + 1));
        for(int i = 1; i < m + 1; i++)
            for(int j = 1; j < n + 1; j++)
                dp[i][j] = dp[i - 1][j] + dp[i][j - 1] - dp[i - 1][j - 1] + mat[i - 1][j - 1];
        vector<vector<int>> ret(m, vector<int>(n));
        for(int i = 0; i < m; i++)
            for(int j = 0; j < n; j++)
            {
                int x1 = max(i - k, 0) + 1, y1 = max(j - k, 0) + 1;
                int x2 = min(i + k, m - 1) + 1, y2 = min(j + k, n - 1) + 1;
                ret[i][j] = dp[x2][y2] - dp[x2][y1 - 1] - dp[x1 - 1][y2] + dp[x1 - 1][y1 - 1];
            }
        return ret;
    }
};

最大子矩阵

最大子矩阵_牛客题霸_牛客网

 出现的问题

  • ret没有初始化为INT_MIN，这个在<climits>里
  • ret的式子里dp[i - 1][x]这个横纵写反了
#include <vector>
#include <iostream>
#include <climits>
using namespace std;

int main() //二维前缀和
{
	int n;
	cin >> n;
	vector<vector<int>> arr(n, vector<int>(n));
	for (int i = 0; i < n; i++)
		for (int j = 0; j < n; j++)
			cin >> arr[i][j];
	vector<vector<int>> dp(n + 1, vector<int>(n + 1));
	for (int i = 1; i <= n; i++)
		for (int j = 1; j <= n; j++)
			dp[i][j] = dp[i - 1][j] + dp[i][j - 1] - dp[i - 1][j - 1] + arr[i - 1][j - 1];
	int ret = INT_MIN; // 可能都是负值。。。
	for (int i = 1; i <= n; i++)
		for (int j = 1; j <= n; j++)
			for (int y = i; y <= n; y++)
				for (int x = j; x <= n; x++)
					ret = max(ret, dp[y][x] - dp[y][j - 1] - dp[i - 1][x] + dp[i - 1][j - 1]);
					//dp[i - 1][x]这里写反了
	cout << ret;
}

EffectiveC++
关注
  • 35
    点赞
  • 踩
  • 24
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
C++ 前缀和算法
struct_GS的博客
08-09 2071
目录: 基本知识 一维前缀和 二维前缀和 基本知识： 前缀和是一种预处理算法，能大大降低时间复杂度。 前缀和的操作对象主要是数组。 前缀和主要是计算之前数组元素的值之和。在解决区域问题时，可以减少遍历操作，减少时间复杂度。 一维前缀和： 记原数组为a[n]，前缀和数组为b[n]。那么b[i]内存储的内容为a[1]~a[i-1]的和。 即b[1]=a[1],b[2]=a[1]+a[2],b[3]=a[1]...
c++前缀和
aoligei132的博客
02-14 832
1 2 3 4 5 6 7 8 9 这样一个序列的前缀和是 1 3 6 10 15 21 36 45 很简单，可以直接得出公式 d表示前缀和数组，a表示原数组 d[i] = d[i - 1] + a[i]; 前缀和可以快速求出某以区间的值 如：就上面的那个数据，你想求a[2, 5]这个区间里的和，可以用前缀和d[5] - d[1] 证明 a[2, 5]这个区间里的和是a[2] + a[3] + a[4] + a[5] 而d[5] = a[1] + a[2] + a[3] + a[4] + a[5] d[1
C++前缀和
PingdiGuo_guo的博客
01-29 1413
C++前缀和是一种常用的算法，用于解决求解区间和问题。前缀和数组是一个长度为n的数组，其中第i个元素代表原始数组从下标0到下标i的元素之和。通过预先计算前缀和数组，可以在O(1)的时间复杂度内求解任意区间的和。前缀和算法的基本思想是利用动态规划的思想，通过累加计算出每一个位置的前缀和。具体实现时，可以对原始数组进行一次遍历，累加计算出前缀和数组的每一个元素。在C++中，可以使用一个额外的数组来保存原始数组中每个位置的前缀和，即累加前面所有元素的和。
C++ 前缀和OJ
Han同学
02-27 941
前缀和OJ题
c/c++前缀和
SYC20110120的博客
07-22 270
对于一个给定的数组A，他的前缀和数中 S 中 S[ i ] 表示从第一个元素到第 i 个元素的总和。如下图：绿色区域的和就是前缀和数组中的 S [ 6 ]。
【c++入门（2）】前缀和
小学生蒟蒻
04-09 1649
大纲 1.计算前缀和 2.计算字段和 3.后缀和 4.前缀积 5.后缀积 6.例题 1.计算前缀和 基础问题： 思路1： 枚举 cin (); for (int i = 1; i <= q; i++) { cin >> x; int sum = 0; for (int j = 1; j <= x; j++) { sum += a[j]; } cout << sum << endl; } 时间复杂度：O(QN) 极端情况时间复杂度会超！ 思.
C++前缀和 和 差分的学习
m0_74196680的博客
01-09 723
前缀和是指某序列的前n项和，可以把它理解为数学上的数列的前n项和，而差分可以看成前缀和的逆运算。合理的使用前缀和与差分，可以将某些复杂的问题简单化。（数学角度上分析就是说，给定一数列an，其前n项和为Sn，那么Sn构成的数列是an数列的前缀和数列；而反过来，an数列被称为是Sn数列的差分数列。这种关系就像是导数和不定积分一样，求导后的函数是原函数的导数；原函数是求导后函数的不定积分。差分可以看成前缀和的逆运算，即可以理解为给定数列Sn，求an数列，所求的an数列被称为Sn数列的差分数组。
C++中的前缀和
SYC20110120的博客
12-09 742
通过循环读入一个长度为n的数组（从下标1开始存储）。然后，在下一个循环中计算前缀和，即从下标1开始，相邻两项累加，得到每个元素的前缀和。C++中的前缀和（Prefix Sum）是一种优化算法，用于计算原数组中每个元素前缀和（前面所有元素的累加和），可以在O(n)时间内实现。
前缀和（C++）实现
weixin_73888239的博客
12-14 3890
只会暴力算区间和？不会用前缀和？手把手教你前缀和。
前缀和算法及模板详解
热门推荐
timerring的博客
09-24 2万+
前缀和 一维前缀和 例题：前缀和 代码模板 二维前缀和 例题：子矩阵的和 代码模板
C++算法：前缀和基础
10-15
preSum[i]记录子数组[0,i)的和。比如：nums = {1,2,3,4},则preSum = {0,1,3,6,10}。通过preSum，我们可以求任意nums的子数组和。子数组[i,j)等于子数组[0,j)减去[0,i)，也就是子数组[i,j)的和等于preSum[j] – ...
C++前缀树trie的实现
12-25
C++实现的前缀树trie数据结构
C++整数常量的前缀和后缀的示例代码
08-18
主要介绍了C++整数常量的前缀和后缀,本文通过示例代码给大家介绍的非常详细，对大家的学习或工作具有一定的参考借鉴价值，需要的朋友可以参考下
C++后缀表达式转前缀表达式
06-29
C++程序，将后缀表达式用栈转换为前缀表达式
C语言中指针的说明
ZWW_zhangww的博客
06-05 1070
在C语言当中，我们可以将指针理解为内存当中存储的地址，就像生活当中，一个小区里面，在小区里面有很单元，每一栋单元，单元内的房间有着不同的房间号，我们可以同过几栋几单元去寻找我们想要找到的房间，同样的，我们在C语言当中，指针就是我们寻找想要的房间的一种手段。
【C++】用红黑树封装map、set
m0_74808907的博客
06-08 1797
一文带你由浅入深掌握map、set模拟实现
C++|哈希结构封装unordered_set和unordered_map
最新发布
weixin_68201503的博客
06-11 564
上一篇章，学习了unordered系列容器的使用，以及哈希结构，那么这一篇章将通过哈希结构来封装unordered系列容器，来进一步的学习他们的使用以及理解为何是如此使用。其实，哈希表的封装方式和红黑树的封装方式形式上是差不多的，如果有了红黑树的封装理解经验，我相信在理解哈希封装的过程会减少负担的。当然，在使用哈希结构中采用的是更具代表的哈希桶，接下来进行封装。
小家电Type-C接口PD诱骗芯片 6500
legendary_777的博客
06-11 179
通过使用PD诱骗芯片，小家电设备能够实现对多种充电方式的管理，如9V、12V、15V、20V等，从而确保设备能够得到最佳的充电体验。这时候，PD诱骗芯片应运而生。PD诱骗芯片的工作原理是，当小家电设备插入Type-C接口时，芯片会自动检测接入的电压和电流，并根据设备的实际需求调整输出电压和电流。总的来说，PD诱骗芯片在小家电设备中的应用，不仅提高了设备的充电体验，也大大提高了设备的安全性。未来，随着Type-C接口的普及和USB PD技术的发展，PD诱骗芯片将会在小家电设备中发挥越来越重要的作用。
C语言数字全排列生成器
a15884871479的博客
06-05 805
这个代码的功能是生成并打印出从1到N的所有整数的全排列，并计算总共有多少种排列方式
c++ 前缀和stl
10-10
前缀和是指在一个数列中，从第一个元素开始到当前位置的所有元素的和。C++ STL（Standard Template Library）是C++标准库中的一部分，提供了许多常用的数据结构和算法。在C++中，可以使用STL中的容器和算法来方便地实现前缀和。 下面是一个使用C++ STL计算前缀和的示例代码： ```cpp #include <iostream> #include <vector> #include <numeric> // 包含了accumulate函数 int main() { std::vector<int> nums = {1, 2, 3, 4, 5}; std::vector<int> prefixSum(nums.size()); std::partial_sum(nums.begin(), nums.end(), prefixSum.begin()); for (int num : prefixSum) { std::cout << num << " "; } return 0; } ``` 运行上述代码，将输出前缀和结果：1 3 6 10 15。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值