【算法基础】1.5 前缀和与差分

已于 2023-09-06 21:13:28 修改
阅读量451 收藏 1
点赞数 1
分类专栏： 算法 文章标签： 算法 前缀和 差分 二维前缀和 二维差分
于 2023-01-17 00:00:00 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_43406895/article/details/128649597
版权

文章目录

前缀和

https://www.acwing.com/problem/content/797/

题目描述

输入一个长度为 n 的整数序列。
接下来再输入 m 个询问，每个询问输入一对 l,r。
对于每个询问，输出原序列中从第 l 个数到第 r 个数的和。

在这里插入图片描述

解法

Java

import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        int n = scanner.nextInt(), m = scanner.nextInt();
        int[] a = new int[n], s = new int[n + 1];
        for (int i = 0; i < n; ++i) {
            a[i] = scanner.nextInt();
            s[i + 1] = s[i] + a[i];
        }
        while (m-- > 0) {
            int l = scanner.nextInt(), r = scanner.nextInt();
            System.out.println(s[r] - s[l - 1]);
        }
    }
}

cpp

#include <iostream>
#include <cstring>
#include <algorithm>

using namespace std;

int main()
{
    int n, m, l, r;
    scanf("%d%d", &n, &m);
    int a[n], s[n + 1];     // s设置为n+1是为了后面计算方便
    for (int i = 0; i < n; i ++ ) scanf("%d", &a[i]);
    
    s[0] = 0;
    for (int i = 0; i < n; i ++ ) s[i + 1] = s[i] + a[i];
    
    while (m -- ) {
        scanf("%d%d", &l, &r);
        printf("%d\n", s[r] - s[l - 1]);	// 这里的l和r是1~n范围
    }
    return 0;
}

讲解

在这里插入图片描述

有 a1,a2,a3,a4,a5…
想求a2+a3+a4，则只需s4-s1 = (a1+a2+a3+a4) - (a1) = a2+a3+a4。

这道题中可以不初始化 s[0] = 0，事实上，他是任何数都可以，（因为它总是会被消去）。

s[i + 1] = s[i] + a[i]
s[i] 表示从 0 ~ 下标 i - 1的数字之和。

二维前缀和

题目描述——796. 子矩阵的和

https://www.acwing.com/activity/content/problem/content/830/
输入一个 n 行 m 列的整数矩阵，再输入 q 个询问，每个询问包含四个整数 x1,y1,x2,y2，表示一个子矩阵的左上角坐标和右下角坐标。

对于每个询问输出子矩阵中所有数的和。

在这里插入图片描述

解法

Java

import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        int n = scanner.nextInt(), m = scanner.nextInt(), q = scanner.nextInt();
        int[][] a = new int[n][m], s = new int[n + 1][m + 1];
        for (int i = 0; i < n; ++i) {
            for (int j = 0; j < m; ++j) {
                a[i][j] = scanner.nextInt();
                s[i + 1][j + 1] = a[i][j] + s[i + 1][j] + s[i][j + 1] - s[i][j];
            }
        }
        while (q-- > 0) {
            int x1 = scanner.nextInt(), y1 = scanner.nextInt(), x2 = scanner.nextInt(), y2 = scanner.nextInt();
            System.out.println(s[x2][y2] - s[x1 - 1][y2] - s[x2][y1 - 1] + s[x1 - 1][y1 - 1]);
        }
    }
}

Cpp

#include <iostream>
#include <cstring>
#include <algorithm>

using namespace std;

int main()
{
    int n, m, q, x1, y1, x2, y2;
    scanf("%d%d%d", &n, &m, &q);
    int a[n][m], s[n + 1][m + 1];
    for (int i = 0; i < n; ++i) {
        for (int j = 0; j < m; ++j) {
            scanf("%d", &a[i][j]);
            s[i + 1][j + 1] = a[i][j] + s[i + 1][j] + s[i][j + 1] - s[i][j];
        }
    }
    
    while (q--) {
        scanf("%d%d%d%d", &x1, &y1, &x2, &y2);
        printf("%d\n", s[x2][y2] - s[x1 - 1][y2] - s[x2][y1 - 1] + s[x1 - 1][y1 - 1]);
    }
    
    return 0;
}

讲解

在这里插入图片描述
主要看这张图，类似于求面积。

求s：
s[i + 1][j + 1] = a[i][j] + s[i + 1][j] + s[i][j + 1] - s[i][j];

(x1,y1),(x2,y2)之间的和：
s[x2][y2] - s[x1 - 1][y2] - s[x2][y1 - 1] + s[x1 - 1][y1 - 1]

想公式想不明白的时候就想想图。

差分

https://www.acwing.com/activity/content/problem/content/831/

题目描述

输入一个长度为 n 的整数序列。

接下来输入 m 个操作，每个操作包含三个整数 l,r,c，表示将序列中 [l,r] 之间的每个数加上 c。

请你输出进行完所有操作后的序列。

在这里插入图片描述

解法1——模板写法⭐⭐⭐

先求出原始数组的差分数组 b，
然后对每个操作，l, r, c，对差分数组 b 执行

b[l] += c;
b[r + 1] -= c;

意思是从 l 开始往后的数字都要 + c
从 r + 1 开始往后的数字都要 - c，因为真实增加的数字范围只有 l ~ r ，所以要减去前面的影响。

明确 差分数组 b[i] = c，表示 a[i] 比 a[i - 1] 大 c。

Java

总结一下步骤：

  1. 先求差分数组 b
  2. 对差分数组 b 进行一系列操作
  3. 根据差分数组还原原始数组 a
import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        int n = scanner.nextInt(), m = scanner.nextInt();
        int[] a = new int[n + 1], b = new int[n + 2];
        for (int i = 1; i <= n; ++i) {
            a[i] = scanner.nextInt();   // 这里a的存储下标是从1开始的
            b[i] = a[i] - a[i - 1];     // 求差分数组
        }
        while (m-- > 0) {
            int l = scanner.nextInt(), r = scanner.nextInt(), c = scanner.nextInt();
            b[l] += c;
            b[r + 1] -= c;
        }
        for (int i = 0; i < n; ++i) {
            a[i + 1] = a[i] + b[i + 1];
            System.out.print(a[i + 1] + " ");
        }
    }
}

Cpp

#include <iostream>
#include <cstring>
#include <algorithm>

using namespace std;

int main()
{
    int n, m, l, r, c;
    scanf("%d%d", &n, &m);
    int a[n + 1], b[n + 1]; // b是a的差分
    a[0] = 0;
    memset(b, 0, sizeof b);
    for (int i = 1; i <= n; i ++ ) {
        scanf("%d", &a[i]);
        b[i] = a[i] - a[i - 1];
    }
    
    while (m -- ) {
        scanf("%d%d%d", &l, &r, &c);
        b[l] += c;
        b[r + 1] -= c;
    }
    
    for (int i = 0; i < n; ++i) {
        a[i + 1] = a[i] + b[i + 1];
        printf("%d ", a[i + 1]);
    }
    
    return 0;
}

解法2——不求差分数组的写法（自己想的）

b[i] = c 表示从 0 ~ i - 1 的所有下标上的元素值都加上了 c。 （注意 ！：这里数组 b 的定义并不是差分数组了！）

处理完数组 b 之后，从后往前遍历，就可以得到原始数组上的每个数字被影响到了多少数值。

import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        int n = scanner.nextInt(), m = scanner.nextInt();
        int[] a = new int[n], s = new int[n + 1];
        for (int i = 0; i < n; ++i) a[i] = scanner.nextInt();
        while (m-- > 0) {
            int l = scanner.nextInt(), r = scanner.nextInt(), c = scanner.nextInt();
            s[r] += c;
            s[l - 1] -= c;
        }
        int sum = 0;
        // 从后往前进行遍历
        for (int i = n - 1; i >= 0; --i) {
            sum += s[i + 1];
            a[i] += sum;
        }
        for (int i = 0; i < n; ++i) System.out.print(a[i] + " ");
    }
}

后来想了一下，这种其实就是把差分数组的求法反了过来，所以遍历顺序也反了过来。

讲解

b 数组是 a 数组的差分，a 数组是 b 数组的前缀和。
那么，a中某一段变量同时变了一个数，相当于b中对应的两个数（开头和结尾）的变化。
在这里插入图片描述

二维差分⭐⭐⭐⭐⭐

题目描述——798. 差分矩阵

https://www.acwing.com/activity/content/problem/content/832/

输入一个 n 行 m 列的整数矩阵，再输入 q 个操作，每个操作包含五个整数 x1,y1,x2,y2,c，其中 (x1,y1) 和 (x2,y2) 表示一个子矩阵的左上角坐标和右下角坐标。

每个操作都要将选中的子矩阵中的每个元素的值加上 c。

请你将进行完所有操作后的矩阵输出。

在这里插入图片描述

解法

差分矩阵中
b[i][j] = a[i][j] - a[i - 1][j] - a[i][j - 1] + a[i - 1][j - 1];

这样定义的差分矩阵有一个很好的性质，就是如果我们对某个子矩形的四个角（左上角、右上角、左下角、右下角）进行操作（加c或减c），那么当我们求原矩阵时，这个子矩形内的所有元素都会增加或减少c。这就是我们使用差分矩阵处理子矩形区间加法的原理。

java

import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        int n = scanner.nextInt(), m = scanner.nextInt(), q = scanner.nextInt();
        int[][] a = new int[n + 1][m + 1], b = new int[n + 2][m + 2];
        for (int i = 1; i <= n; ++i) {
            for (int j = 1; j <= m; ++j) {
                a[i][j] = scanner.nextInt();
                // 求差分矩阵
                b[i][j] = a[i][j] - a[i - 1][j] - a[i][j - 1] + a[i - 1][j - 1];
            }
        }
        // 对差分数组进行操作
        while (q-- != 0) {
            int x1 = scanner.nextInt(), y1 = scanner.nextInt(), x2 = scanner.nextInt(), y2 = scanner.nextInt(), c = scanner.nextInt();
            b[x1][y1] += c;
            b[x2 + 1][y2 + 1] += c;
            b[x2 + 1][y1] -= c;
            b[x1][y2 + 1] -= c;
        }
        for (int i = 0; i < n; ++i) {
            for (int j = 0; j < m; ++j) {
                a[i + 1][j + 1] = - a[i][j] + a[i + 1][j] + a[i][j + 1] + b[i + 1][j + 1];
                System.out.print(a[i + 1][j + 1] + " ");
            }
            System.out.println();
        }
    }
}

要记住中间的重要代码。

cpp

#include <iostream>
#include <cstring>
#include <algorithm>

using namespace std;

const int N = 1005;
int a[N][N], b[N][N];	// 开大一点可以减少越界的麻烦

int main()
{
    int n, m, q, x1, y1, x2, y2, c;
    scanf("%d%d%d", &n, &m, &q);
    
    for (int i = 1; i <= n; ++i) {
        for (int j = 1; j <= m; ++j) {
            scanf("%d", &a[i][j]);
            b[i][j] = a[i][j] - a[i - 1][j] - a[i][j - 1] + a[i - 1][j - 1];
        }
    }
    
    while (q -- ) {
        scanf("%d%d%d%d%d", &x1, &y1, &x2, &y2, &c);
        b[x1][y1] += c;
        b[x2 + 1][y2 + 1] += c;
        b[x1][y2 + 1] -= c;
        b[x2 + 1][y1] -= c;
    }
    
    for (int i = 1; i <= n; ++i) {
        for (int j = 1; j <= m; ++j) {
            a[i][j] = b[i][j] + a[i - 1][j] + a[i][j - 1] - a[i - 1][j - 1];
            printf("%d ", a[i][j]);
        }
        printf("\n");
    }
    
    return 0;
}

讲解

这里同样可以在脑海中想象那个正方形来帮助写代码。
请添加图片描述

Wei *
关注
  • 1
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
蓝桥杯Python组算法合集（ 二分、倍增、前缀和与差分等）
04-13
蓝桥杯python 蓝桥杯Python组算法合集（ 二分、倍增、前缀和与差分等）
某学长讲课ppt（前缀和与差分，二维前缀和与差分）
03-23
一、内容概述 本资源是一份详尽的关于前缀和与差分的PPT制作素材，旨在帮助使用者通过视觉化的方式，全面而深入地理解这两个在计算机科学中至关重要的概念。PPT内容从基本概念讲起，逐步深入到一维和二维前缀和与差分的计算，以及实际应用示例，旨在为读者提供一套完整的学习体系。 二、主要部分 封面与目录：包含简洁明了的标题和目录结构，为观众提供整体内容预览。 前缀和基本概念：详细解释前缀和的定义、性质及其在计算连续子数组和中的作用，通过文字和图表相结合的方式，帮助观众建立基本概念框架。 一维前缀和与差分的计算：通过具体案例和计算步骤，详细展示如何构造一维前缀和数组，以及如何根据前缀和数组计算差分数组，同时强调它们在算法优化中的应用。 二维前缀和与差分的计算：在一维的基础上，进一步讲解二维前缀和与差分的计算方法，结合图表和实例，展现其在图像处理、矩阵计算等领域的应用价值。 应用示例：通过算法竞赛、数据处理等实际场景中的应用案例，展示前缀和与差分在实际问题中的应用方法和效果，加深观众的理解和应用能力。 总结与回顾：对整个PPT内容进行总结，强调前缀和与差分的重要性，鼓励大家在实际编程
前缀和与差分算法地深入理解
07-11
前缀和与差分算法深入理解 前缀和是一种常用的算法思想，它可以用来解决一些特定的问题，例如计算数组中某个区间的和或者矩阵中某个子矩阵的和。本文将深入讨论前缀和的概念、二维前缀和、差分和差分矩阵，并探讨...
你们需要的前缀和差分在这个里面.pdf
10-25
适合中国人
四种算法学习（适用于算法初学者）
02-19
资源内容主要包括：高精度算法、二分算法、前缀和与差分、双指针； 资源的特点优点：详细，通俗易懂，包含算法思想、算法模板、算法应用，可以帮助使用者，掌握的更加全面，理解的更加深入，让读者百分之百搞明白这...
LeetCode-2779. 数组的最大美丽值【数组 二分查找 排序 滑动窗口】
zik的博客
06-15 321
数组的 子序列 定义是：经由原数组删除一些元素（也可能不删除）得到的一个新数组，且在此过程中剩余元素的顺序不发生改变。将 nums[i] 替换为范围 [nums[i] - k, nums[i] + k] 内的任一整数。将每个数x变为一个区间[x-k，x+k]，然后排序，判断区间是否有交集：也就是说，要满足。对数组 nums 执行上述操作任意次后，返回数组可能取得的 最大 美丽值。输入：nums = [1,1,1,1], k = 10。输入：nums = [4,6,1,2], k = 2。
点云传统算法
weixin_44523062的博客
06-16 144
统计滤波： voxel，
python-求分数序列和
2401_83954530的博客
06-16 631
输入一行一个正整数n(n≤30)。输出一行一个浮点数，表示分数序列前n 项的和，精确到小数点后4位。23.5000p1=1q1=2x1=q1/p1sum=x1i=1q1=q1+p1p1=q1-p1x1=q1/p1sum+=x1i+=1，让用户输入循环次数n,设定p,q的起始值p1=1,q1=2，令x1=q1/p1,总和设定为x1，i为循环密码子，起始值设为1。，观查题目所给的分数序列可知：q2=q1+p1,p2=q1。
【CT】LeetCode手撕—53. 最大子数组和
weixin_44382896的博客
06-12 392
【代码】【CT】LeetCode手撕—53. 最大子数组和。
洛谷题解 - P1036 [NOIP2002 普及组] 选数
Python_enjoy 是一个大帅哥！
06-16 925
个整数相加，可分别得到一系列的和。现在，要求你计算出和为素数共有多少种。NOIP 2002 普及组第二题。第一行两个空格隔开的整数。输出一个整数，表示种类数。
1358 - 素数环
hjxxlsx的博客
06-12 206
i<=n;i++){if(!flag=true;if(!print();i<=n;i++){if(!dfs(k+1);cin>>n;dfs(0);return 0;
openjudge_2.5基本算法之搜索_7221:拯救公主
adam_life的博客
06-11 817
openjudge_2.5基本算法之搜索_7221:拯救公主
【算法——动态规划（从dfs回溯开始推导dp）】
2301_76758064的博客
06-12 1030
递归：递：大问题分解子问题的过程；归：产生答案dp：只进行归；用已知的最底层的（递归的边界，搜索树的底），推出未知一句话：dp数组（不一定是数组，也可以是有限数间的来回递推）递推关系：dfs向下递归的公式dp数组初始化：递归的边界动态规划题目的基础就是：回溯——记忆化——dp（一层比一层效率高）
【算法】Graham 凸包扫描算法 ( 凸包概念 | 常用的凸包算法 | 角排序 | 叉积 | Python 代码示例 )
让 学习 成为一种 习惯 ( 韩曙亮 の 技术博客 )
06-13 1137
一、Graham 凸包扫描算法 1、凸包概念 2、常用的凸包算法 3、Graham 凸包扫描算法 二、Graham 算法前置知识点 1、角排序 2、叉积 3、算法过程分析 二、代码示例 1、完整代码示例 2、执行结果
代码随想录算法训练营第六天| 242.有效的字母异位词 | 349. 两个数组的交集 | 202. 快乐数 |1. 两数之和
weixin_45596561的博客
06-11 837
3. 不知道如何用javascript创建set类型，没有理解这个题用set的原因，利用了hash法在查找元素方面的优点，这里由于元素长度不固定，用数组就不太适合，利用set这个数据结构(底层实现是红黑树，可以用于这种查找元素范围不固定的情况)，将第一个数组转为set1，这样就自动完成了去重操作，然后遍历第二个数组，对每一个元素，在set1中执行查询操作，找到了就添加到结果set2中，利用set2完成去重操作，最后将set2转为数组返回。4，用了一个小时左右，利用set完成去重操作和提高查找效率。
算法设计与分析 实验1 算法性能分析
m0_74175922的博客
06-14 1058
深圳大学算法满分实验
【LeetCode】LCR 124. 推理二叉树
时光、疏离了记忆づ童话的博客
06-16 254
思路：有前备知识我们很快能发现，先序主要作用是确定根，先序中的每个节点都会顺序的成为从上往下的子树的根节点；而通过先序中确定的根节点，在中序序列中，我们能够将二叉树进行初步划分左右子树，然后继续找先序中的根，继续划分左右子树，划分这个过程可以借助递归完成。这样，在找寻到一个根节点的时候，通过这个根节点所在中序中的位置确定下一次划分的区间。：某二叉树的先序遍历结果记录于整数数组 preorder，它的中序遍历结果记录于整数数组 inorder。
【CT】LeetCode手撕—5. 最长回文子串
weixin_44382896的博客
06-13 515
【代码】【CT】LeetCode手撕—5. 最长回文子串。
代码随想录算法训练营day23|669.修剪二叉搜索树、108.将有序数组转换为二叉搜索树、538.把二叉搜索树转换为累加树
最新发布
weixin_43836337的博客
06-16 269
这道题目需要考虑当前节点是否在[low,high]之间，因为是平衡二叉树，所以当当前节点值小于low时，那么其左节点肯定更小，因此删除该节点的方式是给root节点返回其，注意：这里不是直接返回右节点，是因为在右子树中也有可能存在不满足条件的节点，需要继续递归排查；当当前节点值大于high时，那么其右节点肯定更大，因此删除该节点的方式是给root节点返回其。如果root.val符合在[low,high]的区间内，其左右节点承接左右节点的返回值即可。最终返回root。
前缀和与差分（超详细！！！）
06-07
前缀和和差分是一类常用的算法，它们常常被用来优化一些区间操作的问题，如求区间和、区间最大值/最小值等等。下面我们将分别介绍前缀和和差分的定义、用法和常见问题。 ## 前缀和 前缀和，顾名思义，就是把前面...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

Wei *

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值