lintcode - 统计比给定整数小的数的个数(两种方法)

 class Solution {
 public:
     /*
      * @param A: An integer array
      * @param queries: The query list
      * @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> ans;
         sort(A.begin(), A.end());
         for(int i = ; i < queries.size(); ++i){
                 int tmp = lower_bound(A.begin(), A.end(), queries[i]) - A.begin();
                 ans.push_back(tmp);
         }
         return ans;
     }

 };

二分查找的方法

/*
把A数组各个数字出现的次数放进线段树里，然后每次查询 0到A[i] - 1的个数，就是小于A[i]的个数
*/
class Solution {
public:
    /*
     * @param A: An integer array
     * @param queries: The query list
     * @return: The number of element in the array that are smaller that the given integer
     */
     //const int inf = -0x3f3f3f3f;
class SegmentTree{
                public:
                SegmentTree* left;
                SegmentTree* right;
                int start;
                int end;
                int sum;
                SegmentTree(int start, int end, int sum){
                        this -> start = start;
                        this -> end = end;
                        this -> left = NULL;
                        this -> right = NULL;
                        this -> sum = sum;
                }
        };
        int build(SegmentTree* &root, int left, int right, vector<int> &st){
                if(left > right) return ;
                root -> start = left;
                root -> end = right;

                if(left == right) root -> sum = st[left];
                else {
                        int mid = (left + right) / ;
                        root -> left = new SegmentTree(left, mid, );
                        root -> right = new SegmentTree(mid+, right, );
                        root -> sum = build(root -> left, left, mid, st) + build(root -> right, mid + , right, st);
                }
                return root -> sum;
        }
        int query(SegmentTree* &root, int left, int right){
                if(root == NULL || left > right) return ;
                if(left <= root -> start && root -> end <= right){
                        return root -> sum;
                }

                int mid = (root -> start + root -> end) / ;
                if(left > mid){
                        return query(root -> right, left, right);
                } else if(right <= mid){
                        return query(root -> left, left, right);
                } else {
                        return query(root -> left, left, mid) + query(root -> right, mid+, right);
                }

        }
    vector<int> countOfSmallerNumber(vector<int> A, vector<int> queries) {
        // write your code here
        vector<int> ans;
        if(A.size() == ){
                for(int i = ; i < queries.size(); ++i){
                        ans.push_back();
                }
                return ans;
        }
        sort(A.begin(), A.end());
        vector<int> st;
        st.resize(A[A.size() - ] + , );
        for(int i = ; i < A.size(); ++i){
                st[A[i]] += ;
        }
        SegmentTree* root = new SegmentTree(, , );
        build(root, , A[A.size() - ], st);
        for(int i = ; i < queries.size(); ++i){
                int tmp = query(root, , queries[i] - );
                ans.push_back(tmp);
        }
        delete(root);
        return ans;
    }

};

线段树