LeetCode 2389.和有限的最长子序列

给你一个长度为 n 的整数数组 nums ，和一个长度为 m 的整数数组 queries 。

返回一个长度为 m 的数组 answer ，其中 answer $i$ 是 nums 中元素之和小于等于 queries $i$ 的子序列的最大长度。

子序列是由一个数组删除某些元素（也可以不删除）但不改变剩余元素顺序得到的一个数组。

示例 1：

输入：nums = $4,5,2,1$ , queries = $3,10,21$

输出： $2,3,4$

解释：queries 对应的 answer 如下：

子序列 $2,1$ 的和小于或等于 3 。可以证明满足题目要求的子序列的最大长度是 2 ，所以 answer $0$ = 2 。
子序列 $4,5,1$ 的和小于或等于 10 。可以证明满足题目要求的子序列的最大长度是 3 ，所以 answer $1$ = 3 。
子序列 $4,5,2,1$ 的和小于或等于 21 。可以证明满足题目要求的子序列的最大长度是 4 ，所以 answer $2$ = 4 。
示例 2：

输入：nums = $2,3,4,5$ , queries = $1$

输出： $0$

解释：空子序列是唯一一个满足元素和小于或等于 1 的子序列，所以 answer $0$ = 0 。

提示：

n == nums.length

m == queries.length

1 <= n, m <= 1000

1 <= nums $i$ , queries $i$ <= 106^66

我们先对nums进行排序，然后计算nums的前缀和，之后遍历queries，对于每一个遍历到的元素q，在前缀和数组中查找第一个大于等于q的值，该值下标即为符合题意的最长子序列：

cpp 复制代码

class Solution {
public:
    vector<int> answerQueries(vector<int>& nums, vector<int>& queries) {
        sort(nums.begin(), nums.end());

        vector<int> presum(nums.size() + 1);

        for (int i = 0; i < nums.size(); ++i) {
            presum[i + 1] = presum[i] + nums[i];
        }

        vector<int> ans(queries.size());
        for (int i = 0; i < queries.size(); ++i) {
            ans[i] = lowerBound(presum, queries[i]);
        }

        return ans;
    }

    int lowerBound(vector<int> &vec, int target) {
        int l = 0;
        int r = vec.size() - 1;

        int ans = 0;

        while (l <= r) {
            int m = l + (r - l) / 2;

            if (vec[m] > target) {
                r = m - 1;
            } else {
                ans = m;
                l = m + 1;
            }
        }

        return ans;
    }
};

如果nums的长度为n，queries的长度为m，则此算法时间复杂度为O((n+m)logn)，空间复杂度为O(n)。