Range Sum Query - Mutable:对区域内的值经常改变的数组求区域内的和 线段数

Given an integer array nums, find the sum of the elements between indices i and j (i ≤ j), inclusive.

The  update(i, val)  function modifies  nums  by updating the element at index  i  to  val .

Example:

Given nums = [1, 3, 5]

sumRange(0, 2) -> 9
update(1, 2)
sumRange(0, 2) -> 8

Note:

1. The array is only modifiable by the update function.
2. You may assume the number of calls to update and sumRange function is distributed evenly.

思路一：因为区域内的值经常改变，朴素的直接查找范围需要O(n)，会超时，因此考虑线段树

可以看看这个链接，关于线段树，写的挺好的。

https://leetcode.com/problems/range-sum-query-mutable/solution/

时空复杂度：

预处理：O(n) O(N)

查询:O(logN) O(1)

更新:O(logN) O(1)

class NumArray {  
    int[] segtree;
    int n;
    //int[] lazy;
    public NumArray(int[] nums) {
        n = nums.length;
        segtree = new int[2*nums.length];
        buildTree(nums);
    }
   
    public void buildTree(int[] nums){
        //构建线段树，其父节点包含两个子节点区域的求和信息
        //存储时segtree[]中 n到2n-1存储的叶子节点（nums数组），1-n-1存储的中间节点（区域信息），0位置未使用
        for(int i = n,j = 0;i<2*n&&j<n;i++,j++){
            segtree[i] = nums[j];
        }
        for(int i =n-1;i>0;i--){
            segtree[i] = segtree[2*i] + segtree[2*i+1];
        }       
    }    
 
    public void update(int i, int val) {
        int pos = i+n;
        segtree[pos] = val;         
        while(pos>0){
            int left = pos;
            int right = pos;
            if(pos%2==0)//因为构建树时，i = i*2 + i*2+1，所以左孩子为2*n为偶数，右孩子为2*n+1为奇数
            {
                right = pos+1;
            }else{
                left = pos -1;
            }
            segtree[pos/2] = segtree[left] + segtree[right];
            pos = pos/2;
        }
    }   
           
    public int sumRange(int i, int j) {
        int left = i+n;
        int right = j+n;
        int result = 0;
        while(left<=right){//范围未重合，等号表示父节点刚好表示左右的范围
            if(left%2==1)//左边界是父节点的右孩子，那么其父节点的范围过大，所以不必将父节点累加，只需将其单独累加进结果，并缩小范围
            {
                result += segtree[left];
                left++;
            }
            if(right%2==0)//右边界是父节点的左孩子，那么父节点的范围超出了查询范围，所以不考虑其父节点，单独将右边界的结果加入结果中
            {
                result += segtree[right];
                right--;
            }
            left /= 2;//查询值其父节点，因为构建树时父节点包含了区域信息
            right /=2;
        }
        return result;
    }
}

/**
 * Your NumArray object will be instantiated and called as such:
 * NumArray obj = new NumArray(nums);
 * obj.update(i,val);
 * int param_2 = obj.sumRange(i,j);
 */

思路二：

(Sqrt decomposition)

就是预先划分出若干部分，提前算好和，加快速度
时空复杂度：

预处理：O(n) O(sqrt(N))

查询:O(sqrt(N)) O(1)

更新:  O(1)  O(1)

class NumArray {  
    //分而治之，没sqrt(n)为一块，预先统计出每一块的总和，加快速度
    int[] block;
    int len;
    int[] num;
    public NumArray(int[] nums) {
        double l =Math.sqrt(nums.length);//计算每段的长度
        len =(int)Math.ceil(nums.length/l);//九三一共需要的段数，需要向上取证，因为要包括所有的元素
        block = new int[nums.length];
        num = nums;
        for(int i = 0;i<nums.length;i++){
            block[i/len] += nums[i];
        }
    }
   
    public void update(int i, int val) {
        block[i/len] = block[i/len] + val - num[i];
        num[i] = val;
    }   
           
    public int sumRange(int i, int j) {
        int result = 0;
        int lblock = i/len;
        int rblock = j/len;
        if(lblock == rblock){
            for(int a = i;a<=j;a++){
                result += num[a];
            }
            return result;
        }else{
            for(int a = i;a<=(lblock+1)*len-1;a++){
                result += num[a];                
            }
            for(int a = lblock+1;a<rblock;a++){
                result += block[a];               
            }
            for(int a = rblock*len;a<=j;a++){
                result += num[a];                
            }      
            return result;
        }        
    }
}

/**
 * Your NumArray object will be instantiated and called as such:
 * NumArray obj = new NumArray(nums);
 * obj.update(i,val);
 * int param_2 = obj.sumRange(i,j);
 */