刷题专题 — 前缀和

玫瑰永不凋零呀

已于 2024-05-29 22:21:48 修改

阅读量273

点赞数 1

分类专栏：每日一题文章标签：算法

于 2024-05-21 21:59:01 首次发布

本文链接：https://blog.csdn.net/weixin_62678196/article/details/139102733

版权

每日一题专栏收录该内容

21 篇文章 0 订阅

订阅专栏

1、【模板】前缀和_牛客题霸_牛客网 (nowcoder.com)

思路：

前缀和就是数组中某一个连续区间的和

解法一：暴力遍历
解法二：预处理dp[ ] (时间复杂度：O(q) + O(n))
预处理出来一个前缀和数组
dp[i] 表示数组1到i位置区间内所有元素的和
dp[i] = dp[i - 1] + arr[i]

注：dp[ ]数组下标从1开始，是为了处理边界情况。

代码：

public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        //1、读入数据
        int n = in.nextInt();
        int q = in.nextInt();
        int[] arr = new int[n+1];
        for(int i = 1; i <= n; i++){
            arr[i] = in.nextInt();
        }
        //2、预处理一个dp数组
        //long 防止溢出
        long[]dp = new long[n+1];
        for(int i = 1;i <= n; i++){
            dp[i] = dp[i-1] + arr[i];
        }
        //3、使用前缀和数组
        while(q > 0){
            int l = in.nextInt();
            int r = in.nextInt();
            System.out.println(dp[r] - dp[l-1]);
            q--;
        }
    }

2、【模板】二维前缀和_牛客题霸_牛客网 (nowcoder.com)

思路：

1、暴力遍历：时间复杂度为 O(m * n * q)，会超时

2、预处理出一个dp[ ] [ ] 数组：

预处理出来一个前缀和矩阵
dp[i] [j] 表示的是数组（1,1）位置到（i，j）位置所有数的和
使用前缀和矩阵

代码：

public class Main {
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        int n = in.nextInt();
        int m = in.nextInt();
        int q = in.nextInt();
        int[][] arr = new int[n+1][m+1];
        //接收数组
        for(int i = 1; i <= n; i++){
            for(int j = 1; j <= m; j++){
                arr[i][j] = in.nextInt();
            }
        }
        //构造一个前缀和矩阵
        long[][] dp = new long[n+1][m+1];
         for(int i = 1; i <= n; i++){
            for(int j = 1; j <= m; j++){
                dp[i][j] = dp[i-1][j] + dp[i][j-1] + arr[i][j] - dp[i-1][j-1];
            }
        }
        //使用前缀和矩阵
        while(q > 0){
            int x1 = in.nextInt();
            int y1 = in.nextInt();
            int x2 = in.nextInt();
            int y2 = in.nextInt();
            System.out.println(dp[x2][y2] - dp[x1-1][y2] - dp[x2][y1-1] + dp[x1-1][y1-1]);
            q--;
        }
    }
}

3、724. 寻找数组的中心下标 - 力扣（LeetCode）

思路：

1、暴力枚举（会超时）

2、构造前缀和数组，和后缀和数组

然后再遍历每一个下标，判断是否相等

代码：

 public int pivotIndex(int[] nums) {
        int n = nums.length;
        //创建数组的时候已经将数组的值初始化为0了
        int[] f = new int[n];
        int[] g = new int[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(g[i] == f[i]){
                return i;
            }
        }
        return -1;
    }

4、小美的平衡矩阵

代码：

    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        // 注意 hasNext 和 hasNextLine 的区别
        int n = in.nextInt();
        //接收的字符二维数组
        char[][] arr = new char[n+1][n+1];
        //前缀和矩阵
        int[][] dp = new int[n+1][n+1];
        for(int i = 1;i <= n; i++){
            //接收输入的字符串
            String str = in.next();
            for(int j = 1; j <= n; j++){
                //转换成字符
                arr[i][j] = str.charAt(j-1);
                //转换成数字
                int value = arr[i][j] == '1' ? 1 : 0;
                //构造前缀和矩阵
                dp[i][j] = dp[i-1][j] + dp[i][j-1] + value - dp[i-1][j-1];
            }
        }
        for(int len = 1; len <= n; len++){
            int count = 0;
            //x，y表示子矩阵的左上角的坐标，(x+len-1,y+len-1) 表示子矩阵右下角的坐标
            for(int x = 1; x <= n - len + 1; x++){
                for(int y = 1; y <= n - len + 1; y++){
                    int sum = dp[x+len-1][y+len-1] - dp[x+len-1][y-1] - dp[x-1][y+len-1] + dp[x-1][y-1];
                    //完美矩阵中，0和1各占一半
                    if(sum*2 == len * len){
                        count++;
                    }
                }
            }
            System.out.println(count);
        }
    }

5、238. 除自身以外数的乘积 - 力扣（LeetCode）

思路：前缀积

代码：

class Solution {
    public int[] productExceptSelf(int[] nums) {
        int n = nums.length;
        int[] f = new int[n];
        int[] g = new int[n];
        //细节处理，初始化为1
        f[0] = 1;
        g[n-1] = 1;
        for(int i = 1; i < n; i++){
            f[i] = f[i-1] * nums[i-1];
        }
        for(int j = n-2; j >= 0; j--){
            g[j] = g[j+1] * nums[j+1];
        }
        int[] ret = new int[n];
        for(int i = 0; i < n; i++){
            ret[i] = f[i] * g[i];
        }
        return ret;
    }
}

6、560. 和为 K 的子数组 - 力扣（LeetCode）

思路：

1、解法一：暴力枚举（超时，O(N^2)）

2、前缀和 + 哈希表

转换成以i结尾的子数组
在[0,i-1]区间内，有多少前缀和为dp[i] - k的
使用哈希表<int（前缀和），int（次数）>
细节问题：
1、在计算i位置之前，哈希表例只保存[0,i-1]位置的前缀和
2、不用真的创建前缀和数组，用一个sum表示即可
3、初始化hash[0] = 1

代码：
public int subarraySum(int[] nums, int k) {
        Map<Integer,Integer> hash = new HashMap<>();
        //当dp[i] - k刚好等于0的时候，说明存在一个
        hash.put(0,1);
        int sum = 0;
        int ret = 0;
        for(int x : nums){
            sum += x;
            //统计有多少个子数组
            ret += hash.getOrDefault(sum-k,0);
            //将前缀和放进哈希表中
            hash.put(sum,hash.getOrDefault(sum,0)+1);
        }
        return ret;
    }

7、974. 和可被 K 整除的子数组 - 力扣（LeetCode）

思路：

首先补充两个知识点：同余定理：（a-b）% k = 0 ==> a%k = b%k

所以我们可以转换成 (sum - x) % k => sum % k = x %k;（x表示区间某一段子数组的和）
即：在[0,i]的区间内，前缀和的余数等于：sum % k
Java中[负数%正数]的结果是负数，但是我们需要正数，需要对其进行修正：
（a % p + p）% p
结合1，即：在[0,i]的区间内，前缀和的余数等于：(sum % k+k) % k
然后我们可以使用前缀和+哈希表

代码：

public int subarraysDivByK(int[] nums, int k) {
        Map<Integer,Integer> hash = new HashMap<>();
        //第一位放的是余数
        hash.put(0 % k,1);
        int sum = 0;
        int ret = 0;
        for(int x : nums){
            //计算当前位置的前缀和
            sum += x;
            //存储余数
            int r = (sum % k + k) % k;
            //统计结果
            ret += hash.getOrDefault(r,0);
            //将前缀和余数放进哈希表中
            hash.put(r,hash.getOrDefault(r,0)+1);
        }
        return ret;
    }