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 == ) return list;
         if (queries == null || queries.size() == ) return list;

         long[] sum = new long[A.length];

         for (int i = ; i < sum.length; i++) {
             if (i == ) {
                 sum[i] = A[i];
             } else {
                 sum[i] += sum[i - ] + A[i];
             }
         }

         for (int i = ; i < queries.size(); i++) {
             Interval interval = queries.get(i);
             if (interval.start == ) {
                 list.add(sum[interval.end]);
             } else {
                 list.add(sum[interval.end] - sum[interval.start - ]);
             }
         }
         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 == )
             return;
         root = build(A, , A.length - );
     }

     private SegmentTreeNode build(int[] A, int start, int end) {
         if (A == null || start <  || end >= A.length)
             return null;
         SegmentTreeNode root = new SegmentTreeNode(start, end, );
         if (start == end) {
             root.sum = A[start];
         } else {
             int mid = (end - start) /  + start;
             root.left = build(A, start, mid);
             root.right = build(A, mid + , end);
             root.sum = root.left.sum + root.right.sum;
         }
         return root;
     }

     public long query(int start, int end) {
         if (root == null || start > end)
             return ;
         return helper(root, Math.max(, 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) / ;
         if (start >= mid + ) {
             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 + , 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) / ;
         if (index >= mid + ) {
             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;
     }
 }