LintCode_284 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.

原先的想法是使用线段树来做， 结果超时， 尼玛也是醉了，估计还是LintCode编译器的的问题，汗死......

class Solution {
public:
   /**
     * @param A: An integer array
     * @return: The number of element in the array that 
     *          are smaller that the given integer
     */
    vector<int> countOfSmallerNumber(vector<int> &A, vector<int> &queries) {
        // write your code here
        vector<int> res;
        vector<vector<int>> dat = init(A);
        vector<int> dat_min = dat[0];
        vector<int> dat_max = dat[1];
        for (int i = 0; i < queries.size(); i++) {
            int count = query(dat_min, dat_max, queries[i], 0, 0, dat_min.size() / 2);
            res.push_back(count);
        }
        return res;
    }
     vector<vector<int>> init (vector<int> &A) {
        int len = A.size();
        int n = 1;
        while ( n <= len) {
            n*=2;
        }
        vector<int> dat_min(2 * n, INT_MAX);
        vector<int> dat_max(2 * n, INT_MAX);
        for (int i = 0; i < A.size(); i++) {
            update(dat_min,dat_max, i, A[i]);
        }
        // for (int i = 0; i < dat.size(); i++) {
        //     cout<<dat[i]<<" ";
        // }
        vector<vector<int>> dat = {dat_min, dat_max};
        return dat;
    }
    void update(vector<int> &dat_min, vector<int> &dat_max,int k, int value) {
        int n = dat_min.size() / 2;
        k += n - 1; //注意要去掉第一个；
        dat_min[k] = value;
        dat_max[k] = value;
        while (k > 0) {
            k = (k - 1) / 2;
            dat_min[k] = min(dat_min[k * 2 + 1], dat_min[k * 2 + 2]);
            dat_max[k] = max(dat_max[k * 2 + 1], dat_max[k * 2 + 2]);
        }
    }
    int query (vector<int> &dat_min, vector<int> &dat_max, int t, int k, int l, int r) {
        // l 和 r 代表节点k所代表的区间
        if (dat_min[k] >= t) {
            return 0;
        }
        if (dat_max[k] < t) {
            return r - l;
        }else {
            int count1 = query(dat_min, dat_max, t, k * 2 + 1, l, (l + r) / 2);
            int count2 = query(dat_min, dat_max, t, k * 2 + 2, (l + r) / 2, r);
            return count1 + count2;
        }
    }
};

然后暴力排序破解了.......

class Solution {
public:
   /**
     * @param A: An integer array
     * @return: The number of element in the array that 
     *          are smaller that the given integer
     */
    vector<int> countOfSmallerNumber(vector<int> &A, vector<int> &queries) {
        // write your code here
        sort(A.begin(), A.end());
        vector<int> res;
        for (int i = 0; i < queries.size(); i++) {
            auto itr = lower_bound(A.begin(), A.end(), queries[i]);
            int count = itr - A.begin();
            res.push_back(count);
        }
        return res;
    }
};