leetcode 2070. 每一个查询的最大美丽值中等

给你一个二维整数数组 items ，其中 items[i] = [pricei, beautyi] 分别表示每一个物品的价格和 美丽值 。

同时给你一个下标从 0 开始的整数数组 queries 。对于每个查询 queries[j] ，你想求出价格小于等于 queries[j] 的物品中，最大的美丽值 是多少。如果不存在符合条件的物品，那么查询的结果为 0 。

请你返回一个长度与 queries 相同的数组answer，其中answer[j]是第 j 个查询的答案。

示例 1：

复制代码

输入：items = [[1,2],[3,2],[2,4],[5,6],[3,5]], queries = [1,2,3,4,5,6]
输出：[2,4,5,5,6,6]
解释：
- queries[0]=1 ，[1,2] 是唯一价格 <= 1 的物品。所以这个查询的答案为 2 。
- queries[1]=2 ，符合条件的物品有 [1,2] 和 [2,4] 。
  它们中的最大美丽值为 4 。
- queries[2]=3 和 queries[3]=4 ，符合条件的物品都为 [1,2] ，[3,2] ，[2,4] 和 [3,5] 。
  它们中的最大美丽值为 5 。
- queries[4]=5 和 queries[5]=6 ，所有物品都符合条件。
  所以，答案为所有物品中的最大美丽值，为 6 。

示例 2：

复制代码

输入：items = [[1,2],[1,2],[1,3],[1,4]], queries = [1]
输出：[4]
解释：
每个物品的价格均为 1 ，所以我们选择最大美丽值 4 。
注意，多个物品可能有相同的价格和美丽值。

示例 3：

复制代码

输入：items = [[10,1000]], queries = [5]
输出：[0]
解释：
没有物品的价格小于等于 5 ，所以没有物品可以选择。
因此，查询的结果为 0 。

提示：

1 <= items.length, queries.length <= 10^5
items[i].length == 2
1 <= pricei, beautyi, queries[j] <= 10^9

分析：设物品总数为 n，对于单次查询，最简单的方法是遍历整个数组，寻找价格符合要求的物品并维护其最大美丽值，但这样的总时间复杂度为 O(nq)，需要优化单次查询的时间复杂度。

单次查询的过程实际上可以分为两步：首先寻找到所有价格小于等于查询价格的物品；然后求出这些物品中的最大美丽值。如果物品的价格是有序的，就可以用二分查找的方法进行查找满足条件物品。而物品的价格有序很容易做到。****

在物品价格有序的情况下，某个物品的最大美丽值实际上可以转化为，所有小于等于当前物品价值的最大美丽值。可以遍历所有物品，将当前物品的最大美丽值改为从第一个物品开始，到它自己的最大美丽值。

这样一来就实现了单次查询的两步。首先将物品按照价格大小进行排序，价格小的放在前面；价格一样的按照它的美丽值大小排序，美丽值小的放在前面。之后遍历所有的物品，将每个物品的美丽值，改为从第一个物品开始到它自己的最大美丽值。对于每一次查询，用二分查找找到第一个小于等于查询价格的物品，此时它的美丽值就是我们要找的答案。

cpp 复制代码

/**
 * Note: The returned array must be malloced, assume caller calls free().
 */
int getans(int replace[][2],int replaceSize,int price)
{
    if(price<replace[0][0])return 0;
    int left=0,right=replaceSize,cnt=0;
    while(left<right)
    {
        int mid=(left+right)/2;
        //printf("l=%d r=%d mid=%d price=%d replace[0]=%d replace[1]=%d cnt=%d\n",left,right,mid,price,replace[mid][0],replace[mid][1],cnt);
        if(replace[mid][0]<=price)
        {
            cnt=fmax(replace[mid][1],cnt);
            left=mid+1;
        }
        else right=mid;
    }
    return cnt;
}

int cmp(const void *a,const void *b)
{
    int *aa=*(int**)a;
    int *bb=*(int**)b;
    if(aa[0]!=bb[0])return aa[0]-bb[0];
    return aa[1]-bb[1];
}
int* maximumBeauty(int** items, int itemsSize, int* itemsColSize, int* queries, int queriesSize, int* returnSize) {
    qsort(items,itemsSize,sizeof(int*),cmp);
    int replaceSize=1,t=1;
    int replace[itemsSize][2];
    replace[0][0]=items[0][0],replace[0][1]=items[0][1];
    for(int i=1;i<itemsSize;++i)
    {
        if(replace[t-1][0]!=items[i][0])replace[t][0]=items[i][0],replace[t][1]=fmax(items[i][1],replace[t-1][1]),++t;
        else
        {
            if(replace[t-1][1]<items[i][1])replace[t-1][1]=items[i][1];
        }
    }
    replaceSize=t,t=0;

    int *ans=(int*)malloc(sizeof(int)*queriesSize);
    *returnSize=queriesSize;
    for(int i=0;i<queriesSize;++i)
        ans[i]=getans(replace,replaceSize,queries[i]);

    return ans;
}

leetcode 2070. 每一个查询的最大美丽值 中等

leetcode 2070. 每一个查询的最大美丽值中等