LeetCode 307. 区域和检索 - 数组可修改

Posted 2021-09-06 ZSYL

LeetCode 307. 区域和检索 - 数组可修改

• 题目描述
• 方法一：暴力解法（超时）
• 方法二：sqrt 分解
• 方法三：线段树

题目描述

给你一个数组 nums ，请你完成两类查询，其中一类查询要求更新数组下标对应的值，另一类查询要求返回数组中某个范围内元素的总和。

实现 NumArray 类：

• NumArray(int[] nums) 用整数数组 nums 初始化对象
• void update(int index, int val) 将 nums[index] 的值更新为 val
• int sumRange(int left, int right) 返回子数组 nums[left, right] 的总和（即，nums[left] + nums[left + 1], …, nums[right]）

示例：

输入：
["NumArray", "sumRange", "update", "sumRange"]
[[[1, 3, 5]], [0, 2], [1, 2], [0, 2]]
输出：
[null, 9, null, 8]

解释：
NumArray numArray = new NumArray([1, 3, 5]);
numArray.sumRange(0, 2); // 返回 9 ，sum([1,3,5]) = 9
numArray.update(1, 2);   // nums = [1,2,5]
numArray.sumRange(0, 2); // 返回 8 ，sum([1,2,5]) = 8

方法一：暴力解法（超时）

区域和检索的一个简单的解决方案 - RSQ(i, j) 是将数组从索引 i 迭代到 j 并对每个元素求和。

class NumArray {

    private int[] nums;

    public NumArray(int[] nums) {
        this.nums = nums;
    }

    public int sumRange(int i, int j) {
        int sum = 0;
        for (int l = i; l <= j; l++) {
            sum += nums[l];
        }
        return sum;
    }

    public void update(int i, int val) {
        nums[i] = val;
    }
}

复杂度分析

• 时间复杂度：O(n)。区域和检索 O(1) 的更新查询
  对于区域和检索，我们从数组中访问每个元素的时间是固定的，在最坏的情况下，我们访问 n 元素。因此，时间复杂度为 O(n)。更新查询的时间复杂度为 O(1)。

• 空间复杂度：O(1)

方法二：sqrt 分解

数据结构-SQRT分解

• 是一种数据结构
• 使用分块(分组)的思想
• 解决区间问题
• 动态维护

分区

基本思想：

其思想是将数组分割成块，块的长度为 $\sqrt{n}$ 。然后我们计算每个块的和，并将其存储在辅助存储器 b 中。要查询 RSQ(i, j)，我们将添加位于内部的所有块和部分在范围 $[i\dots j]$ 重叠的块的总和。

算法：

在上面的示例中，数组 nums 的长度为 9，它被拆分为大小为 $\sqrt{9}$ 的块。为了得到 RSQ(1, 7)，我们添加 b[1]。它存储范围 [3，5] 的和，以及 块0 和 块2 的部分和，它们是重叠的边界块。

class NumArray {
    private int[] b;
    private int len;
    private int[] nums;
    public NumArray(int[] nums) {
        this.nums = nums;  // 初始化
        double l = Math.sqrt(nums.length);  // 每组多少数
        len = (int)Math.ceil(nums.length / l);  // 分组数
        b = new int[len];  // 创建长度len数组
        for (int i = 0; i < nums.length; i++) {
            b[i / len] += nums[i];  // 初始化b数组，为每一分组数据的和
        }
    }
    
    public void update(int index, int val) {
        int b_i = index / len;  // 获取所在组数
        b[b_i] = b[b_i] - nums[index] + val;  // 更新组内和
        nums[index] = val;  // 更新数组index位置的值
    }
    
    public int sumRange(int i, int j) {
        int sum = 0;
        int startBlock = i / len;  // 获取起始下标，所在分组号
        int endBlock = j / len;  // 获取结束下标，所在分组号
        if (startBlock == endBlock) {  // 如果在同一组，直接BF求i,j区域和
            for (int k = i; k <= j; k++) {
                sum += nums[k];
            }
        } else {
            for (int k = i; k <= (startBlock + 1) * len - 1; k++) {
                sum += nums[k];  // i,j区域之间在完整组左边的数
            }
            for (int k = startBlock + 1; k <= endBlock - 1; k++) {
                sum += b[k];  // // i,j区域之间在完整组
            }
            for (int k = endBlock * len; k <= j; k++) {
                sum += nums[k];  // i,j区域之间在完整组右边的数
            }
        }
        return sum;
    }
}

复杂度分析

• 时间复杂度：O(n) 预处理，$O(\sqrt{n})$ ) 区域和检索，O(1) 更新查询
• 空间复杂度：$O(\sqrt{n})$，我们需要额外的 $\sqrt{n}$ 内存来存储所有块和。

方法三：线段树

算法：

线段树是一种非常灵活的数据结构，它可以用于解决多种范围查询问题，比如在对数时间内从数组中找到最小值、最大值、总和、最大公约数、最小公倍数等。

线段树可以分为以下三个步骤：

1. 从给定数组构建线段树的预处理步骤。
2. 修改元素时更新线段树。
3. 使用线段树进行区域和检索。

构建线段树 :

int[] tree;
int n;
public NumArray(int[] nums) {
    if (nums.length > 0) {
        n = nums.length;
        tree = new int[n * 2];
        buildTree(nums);
    }
}
private void buildTree(int[] nums) {
    for (int i = n, j = 0;  i < 2 * n; i++,  j++)
        tree[i] = nums[j];
    for (int i = n - 1; i > 0; --i)
        tree[i] = tree[i * 2] + tree[i * 2 + 1];
}

复杂度分析

更新线段树 :

当我们更新数组中某个索引 i 处的元素时，我们需要重建线段树，因为一些树节点上的和值也会随之产生变化。我们将再次使用自下而上的方法。首先更新存储 a[i] 元素的叶节点。从那里我们将一路向上，直到根节点，并用其子节点值的总和来更新每个父节点的值。

void update(int pos, int val) {
    pos += n;
    tree[pos] = val;
    while (pos > 0) {
        int left = pos;
        int right = pos;
        if (pos % 2 == 0) {
            right = pos + 1;
        } else {
            left = pos - 1;
        }
        // parent is updated after child is updated
        tree[pos / 2] = tree[left] + tree[right];
        pos /= 2;
    }
}

复杂度分析

区域和检索：

public int sumRange(int l, int r) {
    // get leaf with value 'l'
    l += n;
    // get leaf with value 'r'
    r += n;
    int sum = 0;
    while (l <= r) {
        if ((l % 2) == 1) {
           sum += tree[l];
           l++;
        }
        if ((r % 2) == 0) {
           sum += tree[r];
           r--;
        }
        l /= 2;
        r /= 2;
    }
    return sum;
}

复杂度分析

线段树还未学习！(*￣︶￣)