得了，我这下把前缀和给扒的干干净净了。

时间  2021-08-14
标签 java git github 算法 数组 微信 markdown 框架 函数 oop 栏目 Java 繁體版
原文   原文链接

今天咱们来讲一下刷题时常常用到的前缀和思想，前缀和思想和滑动窗口会常常用在求子数组和子串问题上，当咱们遇到此类问题时，则应该须要想到此类解题方式，该文章深刻浅出描述前缀和思想，读完这个文章就会有属于本身的解题框架，遇到此类问题时就可以轻松应对。java

下面咱们先来了解一下什么是前缀和。git

前缀和其实咱们很早以前就了解过的，咱们求数列的和时，Sn = a1+a2+a3+...an; 此时Sn就是数列的前 n 项和。例 S5 = a1 + a2 + a3 + a4 + a5; S2 = a1 + a2。因此咱们彻底能够经过 S5-S2 获得 a3+a4+a5 的值，这个过程就和咱们作题用到的前缀和思想相似。咱们的前缀和数组里保存的就是前 n 项的和。见下图github

咱们经过前缀和数组保存前 n 位的和，presum[1]保存的就是 nums 数组中前 1 位的和，也就是 presum[1] = nums[0], presum[2] = nums[0] + nums[1] = presum[1] + nums[1]. 依次类推，因此咱们经过前缀和数组能够轻松获得每一个区间的和。算法

例如咱们须要获取 nums[2] 到 nums[4] 这个区间的和，咱们则彻底根据 presum 数组获得，是否是有点和咱们以前说的字符串匹配算法中 BM,KMP 中的 next 数组和 suffix 数组做用相似。那么咱们怎么根据 presum 数组获取 nums[2] 到 nums[4] 区间的和呢？见下图数组

前缀和

好啦，咱们已经了解了前缀和的解题思想了，咱们能够经过下面这段代码获得咱们的前缀和数组，很是简单微信

for (int i = 0; i < nums.length; i++) {
      presum[i+1] = nums[i] + presum[i];
 }
复制代码

好啦，咱们开始实战吧。markdown

leetcode 724. 寻找数组的中心索引

题目描述框架

给定一个整数类型的数组 nums，请编写一个可以返回数组 “中心索引” 的方法。函数

咱们是这样定义数组 中心索引 的：数组中心索引的左侧全部元素相加的和等于右侧全部元素相加的和。oop

若是数组不存在中心索引，那么咱们应该返回 -1。若是数组有多个中心索引，那么咱们应该返回最靠近左边的那一个。

示例 1：

输入： nums = [1, 7, 3, 6, 5, 6] 输出：3

解释： 索引 3 (nums[3] = 6) 的左侧数之和 (1 + 7 + 3 = 11)，与右侧数之和 (5 + 6 = 11) 相等。 同时, 3 也是第一个符合要求的中心索引。

示例 2：

输入： nums = [1, 2, 3] 输出：-1

解释： 数组中不存在知足此条件的中心索引。

理解了咱们前缀和的概念（不知道好像也能够作，这个题太简单了哈哈）。咱们能够一下就能把这个题目作出来，先遍历一遍求出数组的和，而后第二次遍历时，直接进行对比左半部分和右半部分是否相同，若是相同则返回 true，不一样则继续遍历。

class Solution {
    public int pivotIndex(int[] nums) {
        int presum = 0;
        //数组的和
        for (int x : nums) {
           presum += x;
        }      
        int leftsum = 0;
        for (int i = 0; i < nums.length; ++i) {
            //发现相同状况
            if (leftsum == presum - nums[i] - leftsum) {
                return i;
            }
            leftsum += nums[i];          
        }
        return -1;
    }
}
复制代码

leetcode 560. 和为K的子数组

题目描述

给定一个整数数组和一个整数 k，你须要找到该数组中和为 k 的连续的子数组的个数。

示例 1 :

输入:nums = [1,1,1], k = 2 输出: 2 , [1,1] 与 [1,1] 为两种不一样的状况。

暴力法

解析

咱们先来用暴力法解决这个题目，很简单，一下就能 AC。

这个题目的题意很容易理解，就是让咱们返回和为 k 的子数组的个数，因此咱们直接利用双重循环解决该题，这个是很容易想到的。咱们直接看代码吧。

class Solution {
    public int subarraySum(int[] nums, int k) {
         int len = nums.length;
         int sum = 0;
         int count = 0;
         //双重循环
         for (int i = 0; i < len; ++i) {
             for (int j = i; j < len; ++j) {
                 sum += nums[j];
                 //发现符合条件的区间
                 if (sum == k) {
                     count++;
                 }
             }
             //记得归零，从新遍历
             sum = 0;
         }
         return count;
    }
}
复制代码

好啦，既然咱们已经知道如何求前缀和数组了，那咱们来看一下如何用前缀和思想来解决这个问题。

class Solution {
    public int subarraySum(int[] nums, int k) {
        //前缀和数组
        int[] presum = new int[nums.length+1];
        for (int i = 0; i < nums.length; i++) {
            //这里须要注意，咱们的前缀和是presum[1]开始填充的
            presum[i+1] = nums[i] + presum[i];
        }
        //统计个数
        int count = 0;
        for (int i = 0; i < nums.length; ++i) {
            for (int j = i; j < nums.length; ++j) {
                //注意偏移，由于咱们的nums[2]到nums[4]等于presum[5]-presum[2]
                //因此这样就能够获得nums[i,j]区间内的和
                if (presum[j+1] - presum[i] == k) {
                    count++;
                }
            }
        }
        return count;
    }
}
复制代码

咱们分析上面的代码，发现该代码虽然用到了前缀和数组，可是对比暴力法并无提高性能，时间复杂度仍为O(n^2)，空间复杂度成了 O(n)。那咱们有没有其余方法解决呢？

前缀和 + HashMap

了解这个方法前，咱们先来看一下下面这段代码，保证你很熟悉

class Solution {
    public int[] twoSum(int[] nums, int target) {

        HashMap<Integer,Integer> map  = new HashMap<>();
        //一次遍历
        for (int i = 0; i < nums.length; ++i) {
            //存在时，咱们用数组得值为 key，索引为 value
            if (map.containsKey(target - nums[i])){              
               return new int[]{i,map.get(target-nums[i])};
            }
            //存入值
            map.put(nums[i],i);
        }
        //返回
        return new int[]{};
    }
}
复制代码

上面的这段代码是否是贼熟悉，没错就是那个快被咱们作烂的两数之和。这一段代码就是用到了咱们的前缀和+ HashMap 思想，那么咱们如何经过这个方法来解决这个题目呢？

在上面的代码中，咱们将数组的值和索引存入 map 中，当咱们遍历到某一值 x 时，判断 map 中是否含有 target - x，便可。

其实咱们如今这个题目和两数之和原理是一致的，只不过咱们是将全部的前缀和该前缀和出现的次数存到了 map 里。下面咱们来看一下代码的执行过程。

![leetcode 560 和为k的子数组](cdn.jsdelivr.net/gh/tan45du/… 560 和为k的子数组.22vke3otf8sg.gif)

咱们来拆解一下动图，可能有的同窗会思考为何咱们只要查看是否含有 presum - k ，并获取到presum - k 出现的次数就行呢？见下图，因此咱们彻底能够经过 presum - k的个数得到 k 的个数

微信截图_20210115194113

好啦咱们来看一下代码吧

class Solution {
    public int subarraySum(int[] nums, int k) {
        if (nums.length == 0) {
            return 0;
        }
        HashMap<Integer,Integer> map = new HashMap<>();
        //细节，这里须要预存前缀和为 0 的状况，会漏掉前几位就知足的状况
        //例如输入[1,1,0]，k = 2 若是没有这行代码，则会返回0,漏掉了1+1=2，和1+1+0=2的状况
        //输入：[3,1,1,0] k = 2时则不会漏掉
        //由于presum[3] - presum[0]表示前面 3 位的和，因此须要map.put(0,1),垫下底
        map.put(0, 1);
        int count = 0;
        int presum = 0;
        for (int x : nums) {
            presum += x;
            //当前前缀和已知，判断是否含有 presum - k的前缀和，那么咱们就知道某一区间的和为 k 了。
            if (map.containsKey(presum - k)) {
                count += map.get(presum - k);//获取次数
            }
            //更新
            map.put(presum,map.getOrDefault(presum,0) + 1);
        }
        return count;
    }
}
复制代码

作完这个题目，各位也能够去完成一下这个题目，两个题目几乎彻底相同 leetcode 930. 和相同的二元子数组

leetcode1248. 统计「优美子数组」

题目描述

给你一个整数数组 nums 和一个整数 k。

若是某个 连续 子数组中刚好有 k 个奇数数字，咱们就认为这个子数组是「优美子数组」。

请返回这个数组中「优美子数组」的数目。

示例 1：

输入：nums = [1,1,2,1,1], k = 3 输出：2 解释：包含 3 个奇数的子数组是 [1,1,2,1] 和 [1,2,1,1] 。

示例 2：

输入：nums = [2,4,6], k = 1 输出：0 解释：数列中不包含任何奇数，因此不存在优美子数组。

示例 3：

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

若是上面那个题目咱们完成了，这个题目作起来，分分钟的事，不信你去写一哈，百分百就整出来了，咱们继续按上面的思想来解决。

HashMap

解析

上个题目咱们是求和为 K 的子数组，这个题目是让咱们求 刚好有 k 个奇数数字的连续子数组，这两个题几乎是同样的，上个题中咱们将前缀区间的和保存到哈希表中，这个题目咱们只需将前缀区间的奇数个数保存到区间内便可，只不过将 sum += x 改为了判断奇偶的语句，见下图。

微信截图_20210114222339

咱们来解析一下哈希表，key 表明的是含有 1 个奇数的前缀区间，value 表明这种子区间的个数，含有两个，也就是nums[0],nums[0,1].后面含义相同，那咱们下面直接看代码吧，一下就能读懂。

class Solution {
    public int numberOfSubarrays(int[] nums, int k) {
        
        if (nums.length == 0) {
            return 0;
        }
        HashMap<Integer,Integer> map = new HashMap<>();
        //统计奇数个数，至关于咱们的 presum
        int oddnum = 0;
        int count = 0;
        map.put(0,1);
        for (int x : nums) {
            // 统计奇数个数
            oddnum += x & 1;
            // 发现存在，则 count增长
            if (map.containsKey(oddnum - k)) {
             count += map.get(oddnum - k);
            }
            //存入
            map.put(oddnum,map.getOrDefault(oddnum,0)+1);
        }
        return count;
    }
}
复制代码

可是也有一点不一样，就是咱们是统计奇数的个数，数组中的奇数个数确定不会超过原数组的长度，因此这个题目中咱们能够用数组来模拟 HashMap ，用数组的索引来模拟 HashMap 的 key，用值来模拟哈希表的 value。下面咱们直接看代码吧。

class Solution {
    public int numberOfSubarrays(int[] nums, int k) {      
        int len = nums.length;
        int[] map = new int[len + 1];
        map[0] = 1;
        int oddnum = 0;
        int count = 0;
        for (int i = 0; i < len; ++i) {
            //若是是奇数则加一，偶数加0，至关于没加
            oddnum += nums[i] & 1;
            if (oddnum - k >= 0) {
                count += map[oddnum-k];
            }
            map[oddnum]++;
        }
        return count;
    }
}
复制代码

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

题目描述

给定一个整数数组 A，返回其中元素之和可被 K 整除的（连续、非空）子数组的数目。

示例：

输入：A = [4,5,0,-2,-3,1], K = 5 输出：7

解释：

有 7 个子数组知足其元素之和可被 K = 5 整除： [4, 5, 0, -2, -3, 1], [5], [5, 0], [5, 0, -2, -3], [0], [0, -2, -3], [-2, -3]

前缀和+HashMap

解析

咱们在该文的第一题 **和为K的子数组 **中，咱们须要求出知足条件的区间，见下图

微信截图_20210115194113

咱们须要找到知足，和为 K 的区间。咱们此时 presum 是已知的，k 也是已知的，咱们只须要找到 presum - k区间的个数，就能获得 k 的区间个数。可是咱们在当前题目中应该怎么作呢？见下图。

微信截图_20210115150520

咱们在以前的例子中说到，presum[j+1] - presum[i] 能够获得 nums[i] + nums[i+1]+.... nums[j]，也就是[i,j]区间的和。

那么咱们想要判断区间 [i,j] 的和是否能整除 K，也就是上图中紫色那一段是否能整除 K，那么咱们只需判断

(presum[j+1] - presum[i] ) % k 是否等于 0 便可，

咱们假设 (presum[j+1] - presum[i] ) % k == 0；则

presum[j+1] % k - presum[i] % k == 0;

presum[j +1] % k = presum[i] % k ;

咱们 presum[j +1] % k 的值 key 是已知的，则是当前的 presum 和 k 的关系，咱们只须要知道以前的前缀区间里含有相同余数 （key）的个数。则可以知道当前可以整除 K 的区间个数。见下图

微信截图_20210115152113

题目代码

class Solution {
    public int subarraysDivByK(int[] A, int K) {
        HashMap<Integer,Integer> map = new HashMap<>();
        map.put(0,1);
        int presum = 0;
        int count = 0;
        for (int x : A) {
             presum += x;
             //当前 presum 与 K的关系，余数是几，当被除数为负数时取模结果为负数，须要纠正
             int key = (presum % K + K) % K;
             //查询哈希表获取以前key也就是余数的次数
             if (map.containsKey(key)) {
                 count += map.get(key);
             }
             //存入哈希表当前key，也就是余数
             map.put(key,map.getOrDefault(key,0)+1);
        }
        return count;
    }
}
复制代码

咱们看到上面代码中有一段代码是这样的

int key = (presum % K + K) % K;
复制代码

这是为何呢？不能直接用 presum % k 吗？

这是由于当咱们 presum 为负数时，须要对其纠正。纠正前(-1) %2 = (-1)，纠正以后 ( (-1) % 2 + 2) % 2=1 保存在哈希表中的则为 1.则不会漏掉部分状况，例如输入为 [-1,2,9],K = 2若是不对其纠正则会漏掉区间 [2] 此时 2 % 2 = 0，符合条件，可是不会被计数。

那么这个题目咱们可不能够用数组，代替 map 呢？固然也是能够的，由于此时咱们的哈希表存的是余数，余数最大也只不过是 K-1因此咱们能够用固定长度 K 的数组来模拟哈希表。

class Solution {
    public int subarraysDivByK(int[] A, int K) {
        int[] map = new int[K];
        map[0] = 1;
        int len = A.length;
        int presum = 0;
        int count = 0;
        for (int i = 0; i < len; ++i) {
            presum += A[i];
            //求key
            int key = (presum % K + K) % K;
            //count添加次数，并将当前的map[key]++;
            count += map[key]++;         
        }
        return count;
    }
}
复制代码

leetcode 523 连续的子数组和

题目描述

给定一个包含 非负数 的数组和一个目标 整数 k，编写一个函数来判断该数组是否含有连续的子数组，其大小至少为 2，且总和为 k 的倍数，即总和为 n*k，其中 n 也是一个整数。

示例 1：

输入：[23,2,4,6,7], k = 6 输出：True

解释：[2,4] 是一个大小为 2 的子数组，而且和为 6。

示例 2：

输入：[23,2,6,4,7], k = 6 输出：True

解释：[23,2,6,4,7]是大小为 5 的子数组，而且和为 42。

前缀和 + HashMap

这个题目算是对刚才那个题目的升级，前半部分是同样的，都是为了让你找到能被 K 整除的子数组，可是这里加了一个限制，那就是子数组的大小至少为 2，那么咱们应该怎么判断子数组的长度呢？咱们能够根据索引来进行判断，见下图。

微信截图_20210115174825

此时咱们 K = 6, presum % 6 = 4 也找到了相同余数的前缀子数组 [0,1] 可是咱们此时指针指向为 2，咱们的前缀子区间 [0,1]的下界为1，因此 2 - 1 = 1，但咱们的中间区间的长度小于2，因此不能返回 true，须要继续遍历，那咱们有两个区间[0,1],[0,2]都知足 presum % 6 = 4，那咱们哈希表中保存的下标应该是 1 仍是 2 呢？咱们保存的是1，若是咱们保存的是较大的那个索引，则会出现下列状况，见下图。

微信截图_20210115175122

此时，仍会显示不知足子区间长度至少为 2 的状况，仍会继续遍历，可是咱们此时的 [2,3]区间已经知足该状况，返回 true，因此咱们往哈希表存值时，只存一次，即最小的索引便可。下面咱们看一下该题的两个细节

细节1：咱们的 k 若是为 0 时怎么办，由于 0 不能够作除数。因此当咱们 k 为 0 时能够直接存到数组里，例如输入为 [0,0] , K = 0 的状况

细节2：另一个就是以前咱们都是统计个数，value 里保存的是次数，可是此时咱们加了一个条件就是长度至少为 2，保存的是索引，因此咱们不能继续 map.put(0,1)，应该赋初值为 map.put(0,-1)。这样才不会漏掉一些状况，例如咱们的数组为[2,3,4],k = 1,当咱们 map.put(0,-1) 时，当咱们遍历到 nums[1] 即 3 时，则能够返回 true，由于 1-（-1）= 2，5 % 1=0 , 同时知足。

视频解析

![leetcode 523 连续的子数组和](cdn.jsdelivr.net/gh/tan45du/… 523 连续的子数组和.1dgqjn0e8we8.gif)

题目代码

class Solution {
    public boolean checkSubarraySum(int[] nums, int k) {
        HashMap<Integer,Integer> map = new HashMap<>();
        //细节2
        map.put(0,-1);
        int presum = 0;
        for (int i = 0; i < nums.length; ++i) {
            presum += nums[i];
            //细节1，防止 k 为 0 的状况
            int key = k == 0 ? presum : presum % k;
            if (map.containsKey(key)) {
                if (i - map.get(key) >= 2) {
                     return true;
                }
                //由于咱们须要保存最小索引，当已经存在时则不用再次存入，否则会更新索引值
                continue;           
            } 
            map.put(key,i);                  
        }
        return false;
    }
}
复制代码
相关文章
相关标签/搜索
每日一句
    每一个你不满意的现在，都有一个你没有努力的曾经。
本站公众号
   欢迎关注本站公众号,获取更多信息
联系我们 最近搜索 最新文章 沪ICP备13005482号-10 MyBatis教程 SQL 教程 MySQL教程 Java 教程 Thymeleaf 教程 Hibernate教程 Spring教程 Redis教程