Find K Pairs with Smallest Sums

Wed, 12 Feb 2025 00:00:00 +0000

373. 查找和最小的K对数字

分析

初始化最小堆：
- 初始时，最小堆可以由 nums1[0] 和 nums2[i]（i 从 0 到 m-1）组成，因为 nums1 和 nums2 都是有序的，最小的数对总是以 nums1[0] 开头与 nums2 的元素组合
- 每个堆元素包含一个三元组 [sum, i, j]，其中 sum 是当前数对的和，i 是 nums1 的索引，j 是 nums2 的索引
使用堆来不断提取和最小的数对：
- 每次从堆中取出和最小的数对，并将其加入结果集。
- 如果 nums1[i+1] 和 nums2[j] 存在，推入堆中新的数对 nums1[i+1] 和 nums2[j] 的组合
堆的操作：
- 每次都取出和最小的数对进行处理，直到得到 k 个数对

时间复杂度

初始化堆：将 nums2 中的每个元素与 nums1[0] 配对，复杂度为 O(mlogm)，其中 m 是 nums2 的大小
每次弹出和插入操作的时间复杂度为 O(logk)

总体时间复杂度为 O(klogk)，其中 k 是要求的数对个数

空间复杂度

空间复杂度为 O(k)

C++代码

class Solution
{
public:
    vector<vector<int>> kSmallestPairs(vector<int>& nums1, vector<int>& nums2, int k)
    {
        std::vector<std::vector<int>> res;   // 存储结果
        int n = nums1.size(), m = nums2.size();
        if (n == 0 || m == 0)                // 如果数组为空，直接返回空结果
            return res;

        // 使用优先队列（最小堆）存储 (sum, i, j)
        std::priority_queue<std::vector<int>, std::vector<std::vector<int>>, std::greater<std::vector<int>>> heap;

        // 将 nums1[0] 与 nums2 中的每个元素配对，推入堆中
        for (int i = 0; i < m; ++i)
            heap.push({nums1[0] + nums2[i], 0, i});

        // 从堆中取出和最小的 k 对
        while (k-- && heap.size())
        {
            std::vector<int> t = heap.top();
            heap.pop();
            res.push_back({nums1[t[1]], nums2[t[2]]});  // 将结果加入 res

            // 如果 t[1]+1 < n，继续将 nums1[t[1]+1] 与 nums2[t[2]] 配对推入堆中
            if (t[1] + 1 < n)
                heap.push({nums1[t[1] + 1] + nums2[t[2]], t[1] + 1, t[2]});
        }
        return res;
    }
};

Maximum Subsequence Score

Sat, 04 Jan 2025 00:00:00 +0000

2542. 最大子序列的分数

分析

贪心策略：
- 优先选择 nums2 值较大的元素，以确保当前子序列的最小值较大，即 min(nums2) 尽可能大，进而最大化分数
降序排序：
- 将 nums2 和 nums1 的对应元素组合成一个二元组 nums2[i], nums1[i]，并按 nums2 降序排列，这样我们可以从最大值开始依次考虑子序列
优先队列维护和：
- 使用一个最小堆 min_heap 来动态维护当前选定子序列中 nums1 的 k 个元素的和
- 如果堆的大小超过 k，移除堆顶（即当前最小的元素），从而保持堆的大小不超过 k
- 这样可以保证始终以较大的元素尽量填满子序列
更新最大分数：
- 每当堆的大小达到 k ，更新最大分数

时间复杂度

排序操作：O(n \log n)，其中 n 是数组的长度
遍历 combine 并维护堆：O(nlogk)，每次插入或删除堆顶操作需要 O(logk)

总时间复杂度：O(nlogn + nlogk)

空间复杂度

使用了一个最小堆，大小为 O(k)
存储组合后的数组，空间为 O(n)

总空间复杂度：O(n + k)

C++代码

class Solution
{
public:
    long long maxScore(vector<int>& nums1, vector<int>& nums2, int k)
    {
        using PII = std::pair<int, int>;
        std::vector<PII> combine;

        // 将 nums1 和 nums2 的元素组合成二元组
        for (int i = 0; i < nums1.size(); ++i)
            combine.push_back({nums2[i], nums1[i]});

        // 按 nums2 降序排列
        std::sort(combine.rbegin(), combine.rend());

        long long nums1_sum = 0, max_score = 0;
        std::priority_queue<int, std::vector<int>, std::greater<int>> min_heap;

        // 遍历每个元素，维护一个大小为 k 的子序列
        for (auto t : combine)
        {
            int num2 = t.first, num1 = t.second;
            nums1_sum += num1;
            min_heap.push(num1);

            // 如果堆大小超过 k，则移除最小值
            if (min_heap.size() > k)
            {
                nums1_sum -= min_heap.top();
                min_heap.pop();
            }

            // 更新最大分数
            if (min_heap.size() == k)
                max_score = std::max(max_score, nums1_sum * num2);
        }

        return max_score;
    }
};

Heap on Hang Zhang

Find K Pairs with Smallest Sums

373. 查找和最小的K对数字

分析

时间复杂度

空间复杂度

C++代码

Maximum Subsequence Score

2542. 最大子序列的分数

分析

时间复杂度

空间复杂度

C++代码