Interval Sum I && II

Given an integer array (index from 0 to n-1, where n is the size of this array), and an query list. Each query has two integers [start, end]. For each query, calculate the sum number between index start and end in the given array, return the result list.

Example

For array [1,2,7,8,5], and queries [(0,4),(1,2),(2,4)], return [23,9,20].

Analysis:
Use an array to save the sum from 0 to i. Then for query [i, j], we shoud return sum[j] - sum[i - 1].

/**
 * Definition of Interval:
 * public classs Interval {
 *     int start, end;
 *     Interval(int start, int end) {
 *         this.start = start;
 *         this.end = end;
 *     }
 */
public class Solution {
    /**
     *@param A, queries: Given an integer array and an query list
     *@return: The result list
     */
    public ArrayList<Long> intervalSum(int[] A, 
                                       ArrayList<Interval> queries) {
                                           
        ArrayList<Long> list = new ArrayList<Long>();                                   
        if (A == null || A.length == 0) return list;
        if (queries == null || queries.size() == 0) return list;
        
        long[] sum = new long[A.length];
        
        for (int i = 0; i < sum.length; i++) {
            if (i == 0) {
                sum[i] = A[i];
            } else {
                sum[i] += sum[i - 1] + A[i];
            }
        }
        
        for (int i = 0; i < queries.size(); i++) {
            Interval interval = queries.get(i);
            if (interval.start == 0) {
                list.add(sum[interval.end]);
            } else {
                list.add(sum[interval.end] - sum[interval.start - 1]);
            }
        }
        return list;
    }
}

 

Interval Sum II

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

Given array A = [1,2,7,8,5].

• query(0, 2), return 10.
• modify(0, 4), change A[0] from 1 to 4.
• query(0, 1), return 6.
• modify(2, 1), change A[2] from 7 to 1.
• query(2, 4), return 14.

Analysis:

As the value in the array may change, so it is better to build a segement tree. If the value in the tree is changed, we also need to update its parent node.

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

    SegmentTreeNode root;

    /**
     * @param A:
     *            An integer array
     */
    public Solution(int[] A) {
        if (A == null || A.length == 0)
            return;
        root = build(A, 0, A.length - 1);
    }
    
    private SegmentTreeNode build(int[] A, int start, int end) {
        if (A == null || start < 0 || end >= A.length)
            return null;
        SegmentTreeNode root = new SegmentTreeNode(start, end, 0);
        if (start == end) {
            root.sum = A[start];
        } else {
            int mid = (end - start) / 2 + start;
            root.left = build(A, start, mid);
            root.right = build(A, mid + 1, end);
            root.sum = root.left.sum + root.right.sum;
        }
        return root;
    }

    public long query(int start, int end) {
        if (root == null || start > end)
            return 0;
        return helper(root, Math.max(0, start), Math.min(end, root.end));
    }

    public long helper(SegmentTreeNode root, int start, int end) {
        if (root.start == start && root.end == end) {
            return root.sum;
        }

        int mid = (root.start + root.end) / 2;
        if (start >= mid + 1) {
            return helper(root.right, start, end);
        } else if (end <= mid) {
            return helper(root.left, start, end);
        } else {
            return helper(root.left, start, mid) + helper(root.right, mid + 1, end);
        }
    }

    public void modify(int index, int value) {
        if (root == null)
            return;
        if (index < root.start && index > root.end)
            return;
        modifyHelper(root, index, value);
    }

    public void modifyHelper(SegmentTreeNode root, int index, int value) {
        if (root.start == root.end && root.start == index) {
            root.sum = value;
            return;
        }

        int mid = (root.start + root.end) / 2;
        if (index >= mid + 1) {
            modifyHelper(root.right, index, value);
        } else {
            modifyHelper(root.left, index, value);
        }
        root.sum = root.left.sum + root.right.sum;

    }
}

class SegmentTreeNode {
    public int start, end, sum;
    public SegmentTreeNode left, right;

    public SegmentTreeNode(int start, int end, int sum) {
        this.start = start;
        this.end = end;
        this.sum = sum;
        this.left = this.right = null;
    }
}