力扣-数组-前缀和数组

303 区域和检索 - 数组不可变

303 区域和检索 - 数组不可变

给定一个整数数组 nums，求出数组从索引 i 到 j（i ≤ j）范围内元素的总和，包含 i、j 两点。
实现 NumArray 类：
NumArray(int[] nums) 使用数组 nums 初始化对象
int sumRange(int i, int j) 返回数组 nums 从索引 i 到 j（i ≤ j）范围内元素的总和，包含 i、j 两点（也就是 sum(nums[i], nums[i + 1], … , nums[j])）

示例：

输入：
[“NumArray”, “sumRange”, “sumRange”, “sumRange”]
[[[-2, 0, 3, -5, 2, -1]], [0, 2], [2, 5], [0, 5]]
输出：
[null, 1, -1, -3]
解释：
NumArray numArray = new NumArray([-2, 0, 3, -5, 2, -1]);
numArray.sumRange(0, 2); // return 1 ((-2) + 0 + 3)
numArray.sumRange(2, 5); // return -1 (3 + (-5) + 2 + (-1))
numArray.sumRange(0, 5); // return -3 ((-2) + 0 + 3 + (-5) + 2 + (-1))

提示：

0 <= nums.length <= 104
-105 <= nums[i] <= 105
0 <= i <= j < nums.length
最多调用 104 次 sumRange 方法

最朴素的想法是存储数组 nums 的值，每次调用 sumRange 时，通过循环的方法计算数组 nums 从下标 i 到下标 j 范围内的元素和，需要计算 j−i+1 个元素的和。由于每次检索的时间和检索的下标范围有关，因此检索的时间复杂度较高，如果检索次数较多，则会超出时间限制。

由于会进行多次检索，即多次调用 sumRange，因此为了降低检索的总时间，应该降低 sumRange 的时间复杂度，最理想的情况是时间复杂度 O(1)。为了将检索的时间复杂度降到 O(1)，需要在初始化的时候进行预处理。

class NumArray {
public:
    vector<int> sums;

    NumArray(vector<int>& nums) {
        int n = nums.size();
        sums.resize(n + 1);
        for (int i = 0; i < n; ++i) sums[i + 1] = sums[i] + nums[i];
    }
    
    int sumRange(int i, int j) {
        return sums[j + 1] - sums[i];
    }
};

• 时间复杂度：初始化 O(n)，每次检索 O(1)，其中 n 是数组 nums 的长度。
  初始化需要遍历数组 nums 计算前缀和，时间复杂度是 O(n)。
  每次检索只需要得到两个下标处的前缀和，然后计算差值，时间复杂度是 O(1)。
• 空间复杂度：O(n)，其中 nn 是数组 nums 的长度。需要创建一个长度为 n+1 的前缀和数组。

304 二维区域和检索 - 矩阵不可变

二维区域和检索 - 矩阵不可变

给定一个二维矩阵，计算其子矩形范围内元素的总和，该子矩阵的左上角为 (row1, col1) ，右下角为 (row2, col2) 。

上图子矩阵左上角 (row1, col1) = (2, 1) ，右下角(row2, col2) = (4, 3)，该子矩形内元素的总和为 8。

示例：

给定 matrix = [
[3, 0, 1, 4, 2],
[5, 6, 3, 2, 1],
[1, 2, 0, 1, 5],
[4, 1, 0, 1, 7],
[1, 0, 3, 0, 5]
]
sumRegion(2, 1, 4, 3) -> 8
sumRegion(1, 1, 2, 2) -> 11
sumRegion(1, 2, 2, 4) -> 12

提示：

你可以假设矩阵不可变。
会多次调用 sumRegion 方法。
你可以假设 row1 ≤ row2 且 col1 ≤ col2 。

二维前缀和
将 sums 的行数和列数分别设为 m+1 和 n+1 的目的是为了方便计算 sumRegion(row1,col1,row2,col2)，不需要对 row1 =0 和 col1=0 的情况特殊处理

class NumMatrix {
public:
    vector<vector<int>> sums;
    NumMatrix(vector<vector<int>>& matrix) {
        int m = matrix.size();
        if (m > 0) {
            int n = matrix[0].size();
            sums.resize(m + 1, vector<int>(n + 1));
            for(int i = 0; i < m; ++i) {
                for(int j = 0; j < n; ++j) 
                sums[i + 1][j + 1] = sums[i][j + 1] + sums[i + 1][j] - sums[i][j] + matrix[i][j];
            }
        }
    }
    
    int sumRegion(int row1, int col1, int row2, int col2) {
        return sums[row2 + 1][col2 + 1] - sums[row1][col2 + 1] - sums[row2 + 1][col1] + sums[row1][col1];
    }
};

• 时间复杂度：初始化 O(mn)，每次检索 O(1)，其中 m 和 n 分别是矩阵 matrix 的行数和列数。
  初始化需要遍历矩阵 matrix 计算二维前缀和，时间复杂度是 O(mn)。
  每次检索的时间复杂度是 O(1)。
• 空间复杂度：O(mn)，其中 m 和 n 分别是矩阵 matrix 的行数和列数。需要创建一个 m+1 行 n+1 列的二维前缀和数组 sums。

238 除自身以外数组的乘积

238 除自身以外数组的乘积

给你一个长度为 n 的整数数组 nums，其中 n > 1，返回输出数组 output ，其中 output[i] 等于 nums 中除 nums[i] 之外其余各元素的乘积。

示例:

输入: [1,2,3,4]
输出: [24,12,8,6]

提示：题目数据保证数组之中任意元素的全部前缀元素和后缀（甚至是整个数组）的乘积都在 32 位整数范围内。
说明: 请不要使用除法，且在 O(n) 时间复杂度内完成此题。
进阶：

你可以在常数空间复杂度内完成这个题目吗？（ 出于对空间复杂度分析的目的，输出数组不被视为额外空间。）

1. 左右乘积列表
   利用索引左侧所有数字的乘积和右侧所有数字的乘积（即前缀与后缀）相乘得到答案

class Solution {
public:
    vector<int> productExceptSelf(vector<int>& nums) {
        int length = nums.size();
        vector<int> L(length, 0), R(length, 0); //初始化两个空数组L和R,L[i]代表i左侧所有数字的乘积,R[i]代表i右侧所有数字的乘积
        vector<int> answer(length);
        L[0] = 1;
        for (int i = 1; i < length; ++i) L[i] = L[i - 1] * nums[i - 1];
        R[length - 1] = 1;
        for (int i = length - 2; i >= 0; --i) R[i] = R[i + 1] * nums[i + 1];
        for (int i = 0; i < length; ++i) answer[i] = L[i] * R[i];
        return answer;
    }
};

-时间复杂度：O(N)，其中 N 指的是数组 nums 的大小。预处理 L 和 R 数组以及最后的遍历计算都是 O(N) 的时间复杂度。

• 空间复杂度：O(N)，其中 N 指的是数组 nums 的大小。使用了 L 和 R 数组去构造答案，L 和 R 数组的长度为数组 nums 的大小。

2. 空间复杂度为O(1)
   构造方式相同。不使用LR，直接把输出数组answer当做L数组从左到右遍历，再遍历回来。
   这种方法的唯一变化就是我们没有构造 R 数组。而是用一个遍历来跟踪右边元素的乘积。并更新数组 answer[i]=answer[i]∗R。然后 R 更新为 R=R∗nums[i]，其中变量 R 表示的就是索引右侧数字的乘积。

class Solution {
public:
    vector<int> productExceptSelf(vector<int>& nums) {
        int length = nums.size();
        vector<int> answer(length);
        answer[0] = 1;
        for (int i = 1; i < length; ++i) answer[i] = answer[i - 1] * nums[i - 1];
        int R = 1;
        for (int i = length - 1; i >= 0; --i) {
            answer[i] = answer[i] * R;
            R *= nums[i];
        }
        return answer;
    }
};

• 时间复杂度：O(N)，其中 N 指的是数组 nums 的大小。分析与方法一相同。
• 空间复杂度：O(1)，输出数组不算进空间复杂度中，因此我们只需要常数的空间存放变量。