区间最小数

给定一个整数数组（下标由 0 到 n-1，其中 n 表示数组的规模），以及一个查询列表。每一个查询列表有两个整数 [start, end]。 对于每个查询，计算出数组中从下标 start 到 end 之间的数的最小值，并返回在结果列表中。

样例

对于数组 [1,2,7,8,5]， 查询 [(1,2),(0,4),(2,4)]，返回 [2,1,5]

挑战

每次查询在O(logN)的时间内完成

/**
 * Definition of Interval:
 * classs Interval {
 *     int start, end;
 *     Interval(int start, int end) {
 *         this->start = start;
 *         this->end = end;
 *     }
 */
class Solution { 
public:
    /**
     *@param A, queries: Given an integer array and an query list
     *@return: The result list
     */
    vector<int> intervalMinNumber(vector<int> &A, vector<Interval> &queries) {
        // write your code here
        vector<int> result;
        int m = A.size();
        int n = queries.size();

        if (m < 1 || n < 1)
        {
            return result;
        }
        int node[m*4 + 10];
        build(node, A, 1, 0, m-1);
    
        for (int i = 0; i < n; i++)
        {
            result.push_back(query(node, 1, 0, m-1, queries[i].start, queries[i].end));
        }

        return result;
    }
private:
    void build(int *node, vector<int> &A,  int pos, int begin, int end)
    {
        if (begin == end)
        {
            node[pos] = A[begin];
        }
        else
        {
            build(node, A, 2*pos, begin, (begin+end)/2);
            build(node, A, 2*pos+1, (begin+end)/2+1, end);

            node[pos] = min(node[2*pos], node[2*pos+1]);
        }
    }

    int query(int *node, int pos, int begin, int end, int left, int right)
    {
        int p1, p2;

        if (left > end || right < begin)
        {
            return INT_MAX;
        }
        if (begin >= left && end <= right)
        {
            return node[pos];
        }   

        p1 = query(node, 2*pos, begin, (begin+end)/2, left, right);
        p2 = query(node, 2*pos+1, (begin+end)/2+1, end, left, right);

        return min(p1, p2);
    }
};