diff --git a/gif-algorithm/前缀和/leetcode523连续的子数组和.md b/gif-algorithm/前缀和/leetcode523连续的子数组和.md new file mode 100644 index 0000000..69e15d9 --- /dev/null +++ b/gif-algorithm/前缀和/leetcode523连续的子数组和.md @@ -0,0 +1,69 @@ +### **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](https://cdn.jsdelivr.net/gh/tan45du/github.io.phonto2@master/myphoto/微信截图_20210115174825.7fv366wnz000.png) + +此时我们 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](https://cdn.jsdelivr.net/gh/tan45du/github.io.phonto2@master/myphoto/微信截图_20210115175122.19vnfs51amjk.png) + +此时，仍会显示不满足子区间长度至少为 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 连续的子数组和](https://cdn.jsdelivr.net/gh/tan45du/github.io.phonto2@master/myphoto/leetcode 523 连续的子数组和.1dgqjn0e8we8.gif) + +**题目代码** + +```java +class Solution { + public boolean checkSubarraySum(int[] nums, int k) { + HashMap 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; + } +} +``` + + + diff --git a/gif-algorithm/前缀和/leetcode560和为K的子数组.md b/gif-algorithm/前缀和/leetcode560和为K的子数组.md new file mode 100644 index 0000000..0aa9155 --- /dev/null +++ b/gif-algorithm/前缀和/leetcode560和为K的子数组.md @@ -0,0 +1,146 @@ +### leetcode560. 和为K的子数组 + +**题目描述** + +> 给定一个整数数组和一个整数 k，你需要找到该数组中和为 k 的连续的子数组的个数。 + +**示例 1 :** + +> 输入:nums = [1,1,1], k = 2 +> 输出: 2 , [1,1] 与 [1,1] 为两种不同的情况。 + +**暴力法** + +**解析** + +这个题目的题意很容易理解，就是让我们返回和为 k 的子数组的个数，所以我们直接利用双重循环解决该题，这个是很容易想到的。我们直接看代码吧。 + +```java +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; + } +} +``` + +下面我们我们使用前缀和的方法来解决这个题目，那么我们先来了解一下前缀和是什么东西。其实这个思想我们很早就接触过了。见下图 + +![](https://cdn.jsdelivr.net/gh/tan45du/github.io.phonto2@master/myphoto/微信截图_20210113193831.4wk2b9zc8vm0.png) + +我们通过上图发现，我们的 presum 数组中保存的是 nums 元素的和，presum[1] = presum[0] + nums[0]; + +presum [2] = presum[1] + nums[1],presum[3] = presum[2] + nums[2] ... 所以我们通过前缀和数组可以轻松得到每个区间的和， + +例如我们需要获取 nums[2] 到 nums[4] 这个区间的和，我们则完全根据 presum 数组得到，是不是有点和我们之前说的字符串匹配算法中 BM,KMP 中的 next 数组和 suffix 数组作用类似。 + +那么我们怎么根据presum 数组获取 nums[2] 到 nums[4] 区间的和呢？见下图 + +![前缀和](https://cdn.jsdelivr.net/gh/tan45du/github.io.phonto2@master/myphoto/前缀和.77twdj3gpkg0.png) + +所以我们 nums[2] 到 nums[4] 区间的和则可以由 presum[5] - presum[2] 得到。 + +也就是前 5 项的和减去前 2 项的和，得到第 3 项到第 5 项的和。那么我们可以遍历 presum 就能得到和为 K 的子数组的个数啦。 + +直接上代码。 + +```java +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; + } +} +``` + +我们通过上面的例子我们简单了解了前缀和思想，那么我们如果继续将其优化呢？ + +**前缀和 + HashMap** + +**解析** + +其实我们在之前的两数之和中已经用到了这个方法，我们一起来回顾两数之和 HashMap 的代码. + +```java +class Solution { + public int[] twoSum(int[] nums, int target) { + + HashMap 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[]{}; + } +} +``` + +上面代码中，我们将数组的值和索引存入 map 中，当我们遍历到某一值 x 时，判断 map 中是否含有 target - x，即可。其实我们现在这个题目和两数之和原理是一致的，只不过我们是将**所有的前缀和**该**前缀和出现的次数**存到了 map 里。下面我们来看一下代码的执行过程。 + +**动图解析** + +![](https://img-blog.csdnimg.cn/2021031809231883.gif#pic_center) + +**题目代码** + +```java +class Solution { + public int subarraySum(int[] nums, int k) { + if (nums.length == 0) { + return 0; + } + HashMap 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);//获取presum-k前缀和出现次数 + } + //更新 + map.put(presum,map.getOrDefault(presum,0) + 1); + } + return count; + } +} +``` +