Segment Tree -Question 1

Most Beautiful Item for Each Query

You are given a 2D integer array items where items[i] = [pricei, beautyi] denotes the price and beauty of an item respectively.

You are also given a 0-indexed integer array queries. For each queries[j], you want to determine the maximum beauty of an item whose price is less than or equal to queries[j]. If no such item exists, then the answer to this query is 0.

Return an array answer of the same length as queries where answer[j] is the answer to the jth query.

Constraints:

1 <= items.length, queries.length <= 10^5

items[i].length == 2

1 <= pricei, beautyi, queries[j] <= 10^9

Analysis:

The first step can be to sort the items based on the price. Then we can narrow down the search range by a binary search.

But the beauty is not sorted yet. So if without further treatment, we need to scan through the query range, the time complexity is O(N). The query length could be as large as 1e5, thus the overall time complexity is O(N*M) ~ 1e10, which is too large to this question.

If use a segment tree, then the time complexity can decrease to O(M*log(N)).

The key step is to save the beauty values with the original order to a helper array with a double size, then build up the maximum values in a way like building a maximum-root heap (see the code below).

After having the segment-tree array, the time complexity is O(log(N)) for one query. The overall time complexity is O(M*log(N)) for M queries.

See the code below:

class Solution {
public:
    vector<int> maximumBeauty(vector<vector<int>>& items, vector<int>& queries) {
        vector<int> res;
        sort(items.begin(), items.end(), [](auto &a, auto &b) {
            return a[0] < b[0]; 
        });
        int n = items.size();
        vector<int> data(2*n, 0);
        for(int i=n; i<2*n; ++i) data[i] = items[i-n][1];
        build(data);
        for(auto &a : queries) {
            int id = findUpperBound(items, a);
            //cout<<id<<endl;
            res.push_back(query(data, 0, id-1));
        }
        return res;
    }
private:
    int findUpperBound(vector<vector<int>>& its, int val) {
        int left = 0, right = its.size();
        while(left < right) {
            int mid = left + (right - left) / 2;
            //cout<<mid<<" "<<left<<" "<<right<<endl;
            if(its[mid][0] <= val) left = mid + 1;
            else right = mid;
        }
        return left;
    }
    void build(vector<int>& data) {
        int n = data.size();
        n /= 2;
        for(int i=n-1; i>0; --i) data[i] = max(data[2*i], data[2*i+1]);
    }
    int query(vector<int>& data, int left, int right) {
        if(left > right) return 0;
        int res = 0, m = data.size(), n = m/2;
        for(int i = left + n, j = right + n; i <= j; i /= 2, j /= 2) {
            if(i&1) res = max(res, data[i++]);
            if(!(j&1)) res = max(res, data[j--]);
        }
        return res;
    }
};

Upper Layer