#248 Count of Smaller Number

题目描述：

Give you an integer array (index from 0 to n-1, where n is the size of this array, value from 0 to 10000) and an query list. For each query, give you an integer, return the number of element in the array that are smaller than the given integer.

 Notice

We suggest you finish problem Segment Tree Build and Segment Tree Query II first.

Have you met this question in a real interview? 

Yes

Example

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

Challenge 

Could you use three ways to do it.

1. Just loop
2. Sort and binary search
3. Build Segment Tree and Search.

题目思路：

这题好像不用segment tree会超时。用segment tree其实很简单，build一个tree，然后用root->count去记录在start ~ end这个范围内出现数字的总次数，然后根据每个value去query就好了。

Mycode（AC = 301ms）：

class SegmentTree {
public:
    int start, end, count;
    SegmentTree *left, *right;
    SegmentTree(int start, int end, int count) {
        this->start = start;
        this->end = end;
        this->count = count;
        this->left = NULL;
        this->right = NULL;
    }
};

class Solution {
public:
   /**
     * @param A: An integer array
     * @return: The number of element in the array that 
     *          are smaller that the given integer
     */
    
    SegmentTree* buildSegmentTree(int start, int end) {
        if (start > end) {
            return NULL;
        }
        else if (start == end) {
            return new SegmentTree(start, end, 0);
        }
        else {
            SegmentTree* root = new SegmentTree(start, end, 0);
            root->left = buildSegmentTree(start, (start + end) / 2);
            root->right = buildSegmentTree((start + end) / 2 + 1, end);
            return root;
        }
    }
    
    void insertSegmentTree(SegmentTree* root, int value) {
        if (root == NULL || root->start > value || root->end < value) {
            return;
        }
        else if (root->start == root->end) {
            if (root->start == value) {
                root->count += 1;
            }
            return;
        }
        else {
            insertSegmentTree(root->left, value);
            insertSegmentTree(root->right, value);
            
            root->count = root->left->count + root->right->count;
            return;
        }
    }
    
    int querySegmentTree(SegmentTree* root, int value) {
        if (root == NULL || root->start >= value) {
            return 0;
        }
        else if (root->end < value) {
            return root->count;
        }
        else {
            int left = querySegmentTree(root->left, value);
            int right = querySegmentTree(root->right, value);
            
            return left + right;
        }
    }
     
    vector<int> countOfSmallerNumber(vector<int> &A, vector<int> &queries) {
        // write your code here
        vector<int> ans;
        if (queries.size() == 0) return ans;
        
        ans.resize(queries.size());
        SegmentTree* root = buildSegmentTree(0, 10000);
        
        for (int i = 0; i < A.size(); i++) {
            insertSegmentTree(root, A[i]);
        }
        
        for (int i = 0; i < queries.size(); i++) {
            ans[i] = querySegmentTree(root, queries[i]);
        }
        
        return ans;
    }
};