Interval Minimum Number

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 minimum number between index start and end in the given array, return the result list.

Example

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

Analysis:

Use Segment tree to maintain the minimun value from index i to j.

 /**
  * 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
      */
     SegmentTreeNode root;

     public ArrayList<Integer> intervalMinNumber(int[] A,
                                                 ArrayList<Interval> queries) {
         // write your code here
         ArrayList<Integer> res = new ArrayList<Integer>();
         root = buildTree(A, , A.length-);
         query(res, queries);
         return res;
     }

     public void query(ArrayList<Integer> res, ArrayList<Interval> queries) {
         for (Interval interval : queries) {
             int result = queryTree(root, interval.start, interval.end);
             res.add(result);
         }
     }

     public int queryTree(SegmentTreeNode cur, int start, int end) {
         if (start==cur.start && end==cur.end) {
             return cur.min;
         }
         int mid = (cur.start + cur.end)/;
         if (end <= mid) return queryTree(cur.left, start, end);
         else if (start > mid) return queryTree(cur.right, start, end);
         else return Math.min(queryTree(cur.left, start, mid), queryTree(cur.right, mid+, end));
     }

     public SegmentTreeNode buildTree(int[] A, int start, int end) {
         SegmentTreeNode cur = new SegmentTreeNode(start, end);
         if (start == end) {
             cur.min = A[start];
         }
         else {
             int mid = (start+end)/;
             cur.left = buildTree(A, start, mid);
             cur.right = buildTree(A, mid+, end);
             cur.min = Math.min(cur.left.min, cur.right.min);
         }
         return cur;
     }
 }

 class SegmentTreeNode {
         int min;
         int start;
         int end;
         SegmentTreeNode left;
         SegmentTreeNode right;
         public SegmentTreeNode(int start, int end) {
             this.start = start;
             this.end = end;
             this.min = Integer.MAX_VALUE;
             this.left = null;
             this.right = null;
         }
     }