LintCode 207: Interval Sum II (线段树和树状数组经典题！!！)

207. Interval Sum II
     中文English
     Given an integer array in the construct method, implement two methods query(start, end) and modify(index, value):

For query(start, end), return the sum from index start to index end in the given array.
For modify(index, value), modify the number in the given index to value
Example
Example 1

Input:
[1,2,7,8,5]
[query(0,2),modify(0,4),query(0,1),modify(2,1),query(2,4)]
Output: [10,6,14]
Explanation:
Given array A = [1,2,7,8,5].
After query(0, 2), 1 + 2 + 7 = 10,
After modify(0, 4), change A[0] from 1 to 4, A = [4,2,7,8,5].
After query(0, 1), 4 + 2 = 6.
After modify(2, 1), change A[2] from 7 to 1，A = [4,2,1,8,5].
After query(2, 4), 1 + 8 + 5 = 14.
Example 2

Input:
[1,2,3,4,5]
[query(0,0),query(1,2),quert(3,4)]
Output: [1,5,9]
Explanation:
1 = 1
2 + 3 = 5
4 + 5 = 9
Challenge
O(logN) time for query and modify.

Notice
We suggest you finish problem Segment Tree Build, Segment Tree Query and Segment Tree Modify first.

解法1：
因为query和modify都要快，所以用segment tree。
注意：
1）build(), query()和modify()都是基于递归。
所以build()里面，一旦(start == end)就要返回root。
query()里面， 一旦(start == root->start && end == root->end)，即返回root->sum。
modify()里面， 也是一旦(index==root->start && index == root->end)，即修改root->sum=value。
2）query()里面， leftsum的多种情况可以用querySegmentTreeNode(root->left, max(start, root->start), min(mid, end))来搞定。rightsum的多种情况也可以用
rightSum = querySegmentTreeNode(root->right, max(mid + 1, start), min(end, root->end));
来搞定。
3) modify()里面， index<=mid时，要注意判断index>=root->start，不然index可能超界。index>mid也是一样。而query()的start和end则一般不会超界。
代码如下：

struct SgmtTreeNode {
    int start;
    int end;
    int sum;
    SgmtTreeNode * left;
    SgmtTreeNode * right;
    SgmtTreeNode(int start = 0, int end = 0, int sum = 0) {
        this->start = start;
        this->end = end;
        this->sum = sum;
        left = right = NULL;
    }
};

class Solution {
public:
    /* you may need to use some attributes here */

    /*
    * @param A: An integer array
    */
    Solution(vector<int> A) {
        cout<<"Solution()"<<endl;
        root = build(A, 0, A.size() - 1);
//cout<<root->sum<<endl;
    }

    /*
     * @param start: An integer
     * @param end: An integer
     * @return: The sum from start to end
     */
    long long query(int start, int end) {
        cout<<" query("<<start<<", "<<end<<");"<<endl;
        return querySegmentTreeNode(root, start, end);
    }

    /*
     * @param index: An integer
     * @param value: An integer
     * @return: nothing
     */
    void modify(int index, int value) {
        cout<<"    modify("<<index<<", "<<value<<");"<<endl;
        modifySegmentTreeNode(root, index, value);
        return;
    }

private:
    SgmtTreeNode * root;
    SgmtTreeNode * build(vector<int> & A, int start, int end) {
        if (start > end) return NULL;
        SgmtTreeNode * root = new SgmtTreeNode(start, end, 0);
        if (start == end) {
            root->sum = A[start];
        } else {
            int mid = start + (end - start) / 2;
            root->left = build(A, start, mid);
            root->right = build(A, mid + 1, end);
            root->sum = root->left->sum + root->right->sum;
        }

        return root;
    }
    
    long long querySegmentTreeNode(SgmtTreeNode * root, int start, int end) {
        if (start > end) return 0;
        if (start == root->start && end == root->end) return root->sum;
        
        int mid = root->start + (root->end - root->start) / 2;
        long long leftSum = 0, rightSum = 0;
        
        if (start <= mid) {
            leftSum = querySegmentTreeNode(root->left, max(start, root->start), min(mid, end));
        }
        
        if (end > mid) {
            rightSum = querySegmentTreeNode(root->right, max(mid + 1, start), min(end, root->end));
        } 
        
        return leftSum + rightSum;
    }
    
    void modifySegmentTreeNode(SgmtTreeNode * root, int index, int value) {
        if (index == root->start && index == root->end) {
            root->sum = value;
            return;
        }
        
        int mid = root->start + (root->end - root->start) / 2;
        
        if (index <= mid && index >= root->start) {
            modifySegmentTreeNode(root->left, index, value);
        } else if (index > mid && index <= root->end) {
            modifySegmentTreeNode(root->right, index, value);
        }
        
        root->sum = root->left->sum + root->right->sum;
    }
    
};

注意：上面的build()用的前序，用后序也是完全可以的。

```cpp
    SgmtTreeNode * build(vector<int> & A, int start, int end) {
        if (start > end) return NULL;
              int sum;
        SgmtTreeNode *left, *right;
        if (start == end) {
            sum = A[start];
        } else {
            int mid = start + (end - start) / 2;
            left = build(A, start, mid);
            right = build(A, mid + 1, end);
            sum = left->sum + right->sum;
        }
        SgmtTreeNode * root = new SgmtTreeNode(start, end, 0);
        root->sum = sum;
        root->left = left;
        root->right = right;
        return root;
    }

二刷：

class SegmentTree {
public:
    int start, end;
    long long sum;
    SegmentTree * left, * right;
    SegmentTree(int _start = 0, int _end = 0, long long _sum = 0) : start(_start), end(_end), sum(_sum), left(NULL), right(NULL) {}

    static SegmentTree * build (vector<int> & A, int start, int end) {
        if (start > end) return NULL;
        SegmentTree * root = new SegmentTree(start, end, A[start]);
        if (start == end) return root;
        int mid = start + (end - start) / 2;
        root->left = build(A, start, mid);
        root->right = build(A, mid + 1, end);
        root->sum = root->left->sum + root->right->sum;
        return root;
    }
    
    static long long query(SegmentTree * root, int start, int end) {
        if (start <= root->start && end >= root->end) return root->sum;
        int mid = root->start + (root->end - root->start) / 2;
        int leftSum = 0, rightSum = 0;
        if (start <= mid) {
            leftSum = query(root->left, start, min(end, mid));
        }
        if (mid + 1 <= end) {
            rightSum = query(root->right, max(mid + 1, start), end);
        }
        return leftSum + rightSum;
    }
    
    static void modify(SegmentTree * root, int index, int value) {
        if (index == root->start && index == root->end) {
            root->sum = value;
            return;
        }
        int mid = root->start + (root->end - root->start) / 2;
        if (index <= mid) {
            modify(root->left, index, value);
        } else {
            modify(root->right, index, value);
        }
        root->sum = root->left->sum + root->right->sum;
    }
};

class Solution {
public:
    /*
    * @param A: An integer array
    */
    Solution(vector<int> A) {
        root = SegmentTree::build(A, 0, A.size() - 1);
    }

    /*
     * @param start: An integer
     * @param end: An integer
     * @return: The sum from start to end
     */
    long long query(int start, int end) {
        return SegmentTree::query(root, start, end);
    }

    /*
     * @param index: An integer
     * @param value: An integer
     * @return: nothing
     */
    void modify(int index, int value) {
        SegmentTree::modify(root, index, value);
    }
    
private:
    SegmentTree * root;
};

解法2：树状数组

class BinaryIndexTree {
public:
    vector<int> C;
    int len;
    BinaryIndexTree(vector<int> & nums) {
        len = nums.size();
        C.resize(len + 1);
        for (int i = 0; i < nums.size(); ++i) {
            add(i, nums[i]);
        }
    }
    
    void add(int index, int value) {
        index++;
        for (int i = index; i <= len; i += lowbit(i)) {
            C[i] += value;
        }
    }
    
    long long presum(int index) {
        long long result = 0;
        index++;
        for (int i = index; i > 0; i -= lowbit(i)) {
            result += C[i];
        }
        return result;
    }
    
private:
    int lowbit(int x) {
        return x & (-x);
    }
};

class Solution {
public:
    /* you may need to use some attributes here */

    /*
    * @param A: An integer array
    */
    Solution(vector<int> A) {
        pBit = new BinaryIndexTree(A);
        this->A = A;
    }

    /*
     * @param start: An integer
     * @param end: An integer
     * @return: The sum from start to end
     */
    long long query(int start, int end) {
        return pBit->presum(end) - pBit->presum(start - 1);
    }

    /*
     * @param index: An integer
     * @param value: An integer
     * @return: nothing
     */
    void modify(int index, int value) {
        pBit->add(index, value - A[index]);
        A[index] = value;
    }

private:
    BinaryIndexTree * pBit;
    vector<int> A;
};