LeetCode 307. Range Sum Query - Mutable

原题链接在这里：https://leetcode.com/problems/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.

题解：

Could use Binary Indexed Tree.

For binary indexed tree, for each binary index, looking for its last digit 1. Then supdate it moves these steps to the next one.

e.g. update 0001 means update 0001 + 1 = 0010, means update 0010 + 2 = 0100, menas update 0100 + 4 = 1000.

0001 S1 = A1

0010 S2 = A1+A2

0011 S3 = A3

0100 S4 = A1+A2+A3+A4

0101 S5 = A5

0110 S6 = A5+A6

0111 S7 = A7

1000 S8 = A1+A2+A3+A4+A5+A6+A7+A8

It could be 100, actually last digit 1 here construct number 4. Then its sum, sum already involves previous 4 numbers, like S4. 

Update this index only reports to this index +4 number, like change A4, updating S4, then update S8.

更新与求和都能维持O(log n)时间.

Time Complexity: NumArray, O(nlogn). update, O(logn). sumRange, O(logn). n = nums.length.

Space: O(n).

AC Java:

public class NumArray {
    int [] bit;
    int [] nums;
    
    public NumArray(int[] nums) {
        if(nums == null || nums.length == 0){
            return;
        }
        this.bit = new int[nums.length+1];
        this.nums = new int[nums.length];
        for(int i = 0; i<nums.length; i++){
            update(i, nums[i]);
        }
    }
    
    public void update(int i, int val) {
        int diff = val - this.nums[i];
        this.nums[i] = val;
        for(int j = i+1; j<this.bit.length; j+=(j&-j)){
            this.bit[j] += diff;
        }
    }
    
    public int sumRange(int i, int j) {
        return getSum(j+1) - getSum(i);
    }
    
    private int getSum(int i){
        int sum = 0;
        while(i > 0){
            sum += this.bit[i];
            i -= (i&-i);
        }
        return sum;
    }
}

/**
 * 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);
 */

Could use Segment Tree.

For segment tree, tree[i] = tree[2*i] + tree[2*i+1]. left child is 2*i, right child is 2*i+1.

When constructing segment tree, tree size is 2*n. n = nums.length. Assign nums value to tree from index n to 2*n-1.

While updating,

　　find the pos = i+n. For each level, if pos is even number, then it is left child. Its peer pos+1 is the right child.

　　If pos is odd, it is right child, its peer pos-1 is the left child.

When getting sum,

　　find the right position l = i+n, r = j+n.

　　For each left, if l is odd, then it is actually right child of its partent, we only need l part, not its parent, sum += tree[l].

　　same for r, if r is even, then tis is actually left child of its parent, we only need r part, not its parent. sum += tree[r].

　　Otherwise we need the parent, this would be got later. Loop while l <= r.

Time Complexity: NumArray, O(n). update, O(logn). sumRange, O(logn). n = nums.length.

Space: O(n).

AC Java:

class NumArray {
    int n;
    int [] tree;
    
    public NumArray(int[] nums) {
        n = nums.length;
        tree = new int[2*n];
        
        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[2*i]+tree[2*i+1];
        }
    }
    
    public void update(int i, int val) {
        int pos = i+n;
        tree[pos] = val;

        while(pos>0){
            int left = pos;
            int right = pos;
            if(pos%2 == 0){
                right++;
            }else{
                left--;
            }
            
            tree[pos/2] = tree[left] + tree[right];
            pos /= 2;
        }
    }
    
    public int sumRange(int i, int j) {
        int l = i+n;
        int r = j+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;
    }
}

/**
 * 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);
 */

类似Range Sum Query - Immutable. 

跟上Range Sum Query 2D - Mutable.

Reference: http://www.cnblogs.com/grandyang/p/4985506.html.