303. 区域和检索 - 数组不可变
题目链接：leetcode-cn.com/problems/ra…
题目要求你实现这样一个类：
class NumArray {
public NumArray(int[] nums) {}
/* 查询闭区间 [left, right] 的累加和 */
public int sumRange(int left, int right) {}
}
sumRange函数需要计算并返回一个索引区间之内的元素和，没学过前缀和的人可能写出如下代码：
class NumArray {
private int[] nums;
public NumArray(int[] nums) {
this.nums = nums;
}
public int sumRange(int left, int right) {
int res = 0;
for (int i = left; i <= right; i++) {
res += nums[i];
}
return res;
}
}
这样，可以达到效果，但是效率很差，因为sumRange方法会被频繁调用，而它的时间复杂度是O(N)，其中N代表nums数组的长度。
这道题的最优解法是使用前缀和技巧，将sumRange函数的时间复杂度降为O(1)，说白了就是不要在sumRange里面用 for 循环，咋整？
直接看代码实现：
class NumArray {
// 前缀和数组
private int[] preSum;
/* 输入一个数组，构造前缀和 */
public NumArray(int[] nums) {
// preSum[0] = 0，便于计算累加和
preSum = new int[nums.length + 1];
// 计算 nums 的累加和
for (int i = 1; i < preSum.length; i++) {
preSum[i] = preSum[i - 1] + nums[i - 1];
}
}
/* 查询闭区间 [left, right] 的累加和 */
public int sumRange(int left, int right) {
return preSum[right + 1] - preSum[left];
}
}
核心思路是我们 new 一个新的数组preSum出来，preSum[i]记录nums[0..i-1]的累加和，看图 10 = 3 + 5 + 2：
304. 二维区域和检索 - 矩阵不可变
题目链接：leetcode-cn.com/problems/ra…
那么sumRegion([2,1,4,3])就是图中红色的子矩阵，你需要返回该子矩阵的元素和 8。这题的思路和一维数组中的前缀和是非常类似的，如下图：
如果我想计算红色的这个子矩阵的元素之和，可以用绿色矩阵减去蓝色矩阵减去橙色矩阵最后加上粉色矩阵，而绿蓝橙粉这四个矩阵有一个共同的特点，就是左上角就是(0, 0)原点。
那么我们可以维护一个二维preSum数组，专门记录以原点为顶点的矩阵的元素之和，就可以用几次加减运算算出任何一个子矩阵的元素和，完整代码如下：
class NumMatrix {
//preSum[i][j]记录矩阵[0,0,i,j]的元素和
private int[][] preSum;
public NumMatrix(int[][] matrix) {
int m = matrix.length;
int n = matrix[0].length;
if(m == 0 || n == 0) {
return;
}
// 构造前缀和矩阵
preSum = new int[m+1][n+1];
for(int i = 1; i <= m; i++) {
for(int j = 1; j <= n; j++) {
//计算每个矩阵[0,0,i,j]的元素和
preSum[i][j] = preSum[i-1][j] + preSum[i][j-1] + matrix[i-1][j-1] - preSum[i-1][j-1];
}
}
}
// 计算子矩阵 [x1, y1, x2, y2] 的元素和
public int sumRegion(int row1, int col1, int row2, int col2) {
// 目标矩阵之和由四个相邻矩阵运算获得
return preSum[row2 + 1][col2 + 1] - preSum[row1][col2 + 1] - preSum[row2 + 1][col1] + preSum[row1][col1];
}
}
这样，sumRegion函数的复杂度也用前缀和技巧优化到了 O(1)。
560. 和为 K 的子数组
题目链接：leetcode-cn.com/problems/su…
我们把所有子数组都穷举出来，算它们的和，看看谁的和等于k不就行了，借助前缀和技巧很容易写出一个解法，代码如下：
class Solution {
public int subarraySum(int[] nums, int k) {
int n = nums.length;
//构造前缀和
int[] preSum = new int[n+1];
preSum[0] = 0;
for(int i = 0; i < n; i++) {
preSum[i+1] = preSum[i] + nums[i];
}
int res = 0;
//穷举所有的子数组
for(int i = 1; i <= n; i++) {
for(int j = 0; j < i; j++) {
if(preSum[i] - preSum[j] == k) {
res++;
}
}
}
return res;
}
}
这个解法的时间复杂度O(N^2)空间复杂度O(N)，并不是最优的解法。不过通过这个解法理解了前缀和数组的工作原理之后，可以使用一些巧妙的办法把时间复杂度进一步降低。
注意前面的解法有嵌套的 for 循环：
for (int i = 1; i <= n; i++)
for (int j = 0; j < i; j++)
if (preSum[i] - preSum[j] == k)
res++;
第二层 for 循环在干嘛呢？翻译一下就是，在计算，有几个j能够使得preSum[i]和preSum[j]的差为k。毎找到一个这样的j，就把结果加一。
我们可以把 if 语句里的条件判断移项，这样写：
if (preSum[j] == preSum[i] - k)
res++;
优化的思路是：我直接记录下有几个preSum[j]和preSum[i] - k相等，直接更新结果，就避免了内层的 for 循环。我们可以用哈希表，在记录前缀和的同时记录该前缀和出现的次数。
int subarraySum(int[] nums, int k) {
int n = nums.length;
// map：前缀和 -> 该前缀和出现的次数
HashMap<Integer, Integer>
preSum = new HashMap<>();
// base case
preSum.put(0, 1);
int res = 0, sum0_i = 0;
for (int i = 0; i < n; i++) {
sum0_i += nums[i];
// 这是我们想找的前缀和 nums[0..j]
int sum0_j = sum0_i - k;
// 如果前面有这个前缀和，则直接更新答案
if (preSum.containsKey(sum0_j))
res += preSum.get(sum0_j);
// 把前缀和 nums[0..i] 加入并记录出现次数
preSum.put(sum0_i, preSum.getOrDefault(sum0_i, 0) + 1);
}
return res;
}
比如说下面这个情况，需要前缀和 8 就能找到和为k的子数组了，之前的暴力解法需要遍历数组去数有几个 8，而优化解法借助哈希表可以直接得知有几个前缀和为 8。
这样，就把时间复杂度降到了O(N)，是最优解法了。
