LeetCode刷题——区域和检索-数组可修改#307#Medium

区域和检索-数组可修改的思路探讨与源码
    区域和检索-数组可修改的题目如下图，该题属于数组类和树类型的题目，主要考察对于数组搜索方法的使用和树结构方法的理解。本文的题目作者想到2种方法，分别是树状数组搜索方法和线段树方法，其中树状数组搜索方法使用Java进行编写，而线段树方法使用Python进行编写，当然这可能不是最优的解法，还希望各位大佬给出更快的算法。

    本人认为该题目可以使用树状数组搜索方法的思路进行解决，首先计算数组的长度并初始化数组，然后对数组进行搜索，按照区间的容斥原理查询1到当前位置的和是多少，并最终返回查询的结果。那么按照这个思路我们的Java代码如下：

#喷火龙与水箭龟
class NumArray {
    int[] arr;
	int[] nums;
    int n;
    int lowFun(int x) {
        return x & -x;
    }
    void add(int x, int u) {
        for (int ir = x; ir <= n; ir = ir + lowFun(ir)){
			arr[ir] = arr[ir] + u;
		}
    }
    int query(int x) {
        int ans = 0;
        for (int iz = x; iz > 0; iz = iz - lowFun(iz)){
            ans = ans + arr[iz];
        }
        return ans;
    }
 
    public NumArray(int[] _nums) {
        nums = _nums;
        n = nums.length;
        arr = new int[n + 10];
        for (int i = 0; i < n; i++) add(i + 1, nums[i]);
    }
    public void update(int index, int val) {
        add(index + 1, val - nums[index]);
        nums[index] = val;
    }
    public int sumRange(int left, int right) {
        return query(right + 1) - query(left);
    }
}

    显然，我们看到树状数组搜索方法的效果还可以，同时还可以使用线段树的方法解决。首先构建树节点的结构，并计算传入数组的长度，对线段树的数组进行初始化，长度为原数组的4倍，遍历每一个数组的元素并更新树的节点。在进行查询时，如果一个区间范围被覆盖的话，直接返回整个区间的求和结果，否则向下递归找到被查询区间覆盖的区间，统计所有区间的求和结果。所以按照这个思路就可以解决，下面是Python代码：

#喷火龙与水箭龟
class NumArray:
    def __init__(self, nums: List[int]):
        n = len(nums)
        self.tr = [None] * (4 * n)
        self.nums = nums
        self.build(1, 1, n)
        for ir, num in enumerate(nums):
            self.update_tree(1,ir+1,num)
    def update(self, index: int, val: int) -> None:
        self.update_tree(1, index + 1, val - self.nums[index])
        self.nums[index] = val
    def sumRange(self, left: int, right: int) -> int:
        return self.query(1, left + 1, right + 1)
    def build(self, u, l, r):
        self.tr[u] = Node(l, r)
        if(l<r):
            mid = (l + r) >> 1
            self.build(u << 1, l, mid)
            self.build(u << 1 | 1, mid + 1, r)
    def update_tree(self, u, x, v):
        if(self.tr[u].l == x and self.tr[u].r == x):
            self.tr[u].v = self.tr[u].v + v
            return
        mid = (self.tr[u].l + self.tr[u].r) >> 1
        if(x <= mid):
            self.update_tree(u << 1, x, v)
        else:
            self.update_tree(u << 1 | 1, x, v)
        self.pushup(u)
    
    def query(self, u, l , r):
        if(l <= self.tr[u].l and self.tr[u].r <= r):
            return self.tr[u].v
        mid = (self.tr[u].l + self.tr[u].r) >> 1
        ans = 0
        if(l <= mid):
            ans = ans + self.query(u << 1, l, r)
        if(r > mid):
            ans = ans + self.query(u << 1 | 1, l, r)
        return ans
    
    def pushup(self, u):
        self.tr[u].v = self.tr[u << 1].v + self.tr[u << 1 | 1].v

class Node:
    def __init__(self, l, r):
        self.l = l
        self.r = r
        self.v = 0

    从结果来说Java版本的树状数组搜索的效率还可以，而Python版本的线段树方法的速度比较差，但应该是有更多的方法可以进一步提速的，希望朋友们能够多多指教，非常感谢。