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.

题目大意：

给一个整数数组，对数组进行封装，提供对外接口

1.sumRange(i,j)，求下标i到下标j之间所有元素之和

2.update(i, val)，更新下标为i的元素为val值

思路一：

常规解法，便利[i,j]获取sum值，直接通过下标访问数组修改元素值，时间复杂度分别为O(N)和O(1)

public class NumArray {
    private int nums[];

    public NumArray(int[] nums) {
        this.nums = new int[nums.length];
        for(int i = 0; i < nums.length; i++){
            this.nums[i] = nums[i];
        }
    }

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

    public int sumRange(int i, int j) {
        if(i > j || !positionIsValid(i) || !positionIsValid(j))
            return -1;
        int sum = 0;
        for(int index = i; index <= j; index ++){
            sum += nums[index];
        }
        
        return sum;
    }
    
    private boolean positionIsValid(int index){
        return (index >= 0 && index < nums.length);
    }
}

超时

思路二：

根据提示，可以用分段树(segement tree)或者叫区间树，没用过。参考

http://bookshadow.com/weblog/2015/08/13/segment-tree-set-1-sum-of-given-range/

https://github.com/nanwan03/leetcode/blob/master/Algorithm/Range%20Sum%20Query%20-%20Mutable%20-%20Segment%20Tree.java

//分段树
class SegmentTreeNode{
    public int start;
    public int end;
    public SegmentTreeNode left;
    public SegmentTreeNode right;
    public int sum;
    
    public SegmentTreeNode(int start, int end){
        this.start = start;
        this.end = end;
        sum = 0;
        left = null;
        right = null;
    }
}

public class NumArray {
    private SegmentTreeNode root;
    
    public NumArray(int[] nums) {
        root = buildSegmentTree(nums, 0, nums.length - 1);
    }
    
    //建造分段树
    private SegmentTreeNode buildSegmentTree(int nums[], int start, int end){
        if(start > end)
            return null;
        else{
            SegmentTreeNode ret = new SegmentTreeNode(start, end);
            if(start == end)
                ret.sum = nums[start];
            else{
                int mid = start + (end - start) / 2;
                SegmentTreeNode left = buildSegmentTree(nums, start, mid);
                SegmentTreeNode right = buildSegmentTree(nums, mid + 1, end);
                ret.sum = left.sum + right.sum;
                ret.left = left;
                ret.right = right;
            }//else
            
            return ret;
        }//else
    }//buildSegmentTree
    
    //更新分段树节点的值
    private void update(SegmentTreeNode root, int position, int val){
        if(root.start == root.end)
            root.sum = val;
        else{
            int mid = root.start + (root.end - root.start) / 2;
            if(position <= mid){
                update(root.left, position, val);
            }//if
            else{
                update(root.right, position, val);
            } //else
            
            root.sum = root.left.sum + root.right.sum;
        }//else
    }//update segmentTree
    
    void update(int i, int val) {
        update(root, i, val);
    }
    
    private int sumRange(SegmentTreeNode root, int start, int end){
        if(root.start == start && root.end == end)
            return root.sum;
        else{
            int mid = root.start + (root.end - root.start) / 2;
            if(mid >= end){
                return sumRange(root.left, start, end);
            }else if(start >= mid + 1){
                return sumRange(root.right, start, end);
            }else{
                return sumRange(root.left, start, mid) + sumRange(root.right, mid + 1, end);
            }
        }
    }

    public int sumRange(int i, int j) {
        return sumRange(root, i, j);
    }
}//NumArray

时间复杂度都为O(logn)

思路三：

使用树状数组，（binary index tree）里面有些需要数学推导，可以不用理会。参考

http://blog.csdn.net/lulipeng_cpp/article/details/7816527#comments

https://leetcode.com/discuss/96367/three-implementations-binary-segment-array-segment-comments

import java.util.Arrays;

//树状数组
public class NumArray {
    int arr[];
    int bit[];
    int n;
    
    public NumArray(int[] nums) {
        n = nums.length;
        arr = Arrays.copyOf(nums, n);
        bit = new int[n + 1];
        for(int i = 0; i < arr.length; i++){
            updateBit(i + 1, arr[i]);
        }
    }

    void update(int i, int val) {
        int diff = val - arr[i];
        arr[i] = val;
        updateBit(i + 1, diff);
    }

    public int sumRange(int i, int j) {
        return getSum(j + 1) - getSum(i);
    }
    
    private void updateBit(int j, int diff){
        while(j <= n){
            bit[j] += diff;
            j += j & (-j);
        }
    }
    
    private int getSum(int j){
        int sum = 0;
        while(j > 0){
            sum += bit[j];
            j -= j & (-j);
        }//while
        
        return sum;
    }
}//NumArray

时间复杂度都为O(logn)