Priority Queue on Hang Zhang

IPO

Tue, 25 Feb 2025 00:00:00 +0000

502.IPO

分析

项目排序
- 将每个项目的启动资本和利润配对，并按照启动资本排序
动态选择
- 将当前资本 w 可以启动的所有项目的利润放入最大堆
- 从堆中选择一个利润最大的项目并完成，更新当前资本
退出条件
- 如果没有可以选择的项目（即堆为空），或者已经完成了 k 个项目，就可以退出

时间复杂度

排序项目数组：O(nlogn)
每次操作通过堆插入或弹出元素，最多需要 O(logn) 时间，因此 k 次操作的复杂度是 O(klogn)

总时间复杂度 O(nlogn)

空间复杂度

空间复杂度为 O(n)

C++代码

class Solution
{
public:
    int findMaximizedCapital(int k, int w, vector<int>& profits, vector<int>& capital)
    {
        int n = profits.size();
        std::vector<std::pair<int, int>> projects;

        // 将项目的启动资本和利润配对，并按启动资本排序
        for (int i = 0; i < n; ++i)
            projects.push_back({capital[i], profits[i]});
        std::sort(projects.begin(), projects.end());

        // 最大堆，用来存放前资本 w 可以启动的所有项目的利润
        std::priority_queue<int> heap;
        int i = 0;

        // 完成最多 k 个项目
        while (k--)
        {
            // 将所有可以启动的项目的利润加入堆
            while (i < n && projects[i].first <= w)
                heap.push(projects[i++].second);

            // 如果堆为空，表示没有可用的项目，退出
            if (heap.empty())
                break;

            // 从堆中选择利润最大的项目并完成
            w += heap.top();
            heap.pop();
        }

        return w;
    }
};

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;
    }
};

Total Cost To Hire K Workers

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

2462. 雇佣k位工人的总代价

分析

双端选择策略：
- 使用两个最小堆分别管理两端候选工人的代价：
  - 左堆 left_heap：存储前 candidates 个工人
  - 右堆 right_heap：存储后 candidates 个工人
- 每轮从两堆中选择代价最小的工人。如果代价相同，优先选择左堆的工人（即下标较小的工人）
动态维护候选集合：
- 每次从堆中弹出一个工人后：
  - 如果是左堆弹出，在左堆加入新的候选工人（如果剩余工人足够）
    - 如果是右堆弹出，在右堆加入新的候选工人（如果剩余工人足够）
模拟雇佣过程：
- 进行 k 轮雇佣，每轮计算当前最小代价并累加到总成本

时间复杂度

初始化堆：最多处理 2 * candidates 个工人，复杂度为 O(candidates * log candidates)
每次雇佣需要从堆中弹出元素并可能插入一个新元素，复杂度为 O(log candidates)
总共雇佣 k 轮，因此雇佣过程的复杂度为 O(k * log candidates)

总时间复杂度：O((k + candidates) * log candidates)

空间复杂度

使用两个最小堆，每个堆最多存储 candidates 个元素

总空间复杂度：O(candidates)

C++代码

class Solution
{
public:
    long long totalCost(vector<int>& costs, int k, int candidates)
    {
        // 左、右堆分别维护前 candidates 和后 candidates 个工人的代价
        std::priority_queue<int, std::vector<int>, std::greater<int>> left_heap, right_heap;
        int l = 0, r = costs.size() - 1;

        // 初始化左堆
        for (int i = 0; i < candidates && l <= r; ++i, ++l)
            left_heap.push(costs[l]);
        // 初始化右堆
        for (int i = 0; i < candidates && l <= r; ++i, --r)
            right_heap.push(costs[r]);

        long long totalCost = 0; // 总代价
        for (int i = 0; i < k; ++i)
        {
            // 从两堆中选择代价最小的工人
            if (left_heap.size() && (right_heap.empty() || left_heap.top() <= right_heap.top()))
            {
                totalCost += left_heap.top();  // 累加代价
                left_heap.pop();              // 移除工人
                if (l <= r)                   // 更新左堆
                    left_heap.push(costs[l++]);
            }
            else
            {
                totalCost += right_heap.top(); // 累加代价
                right_heap.pop();              // 移除工人
                if (l <= r)                    // 更新右堆
                    right_heap.push(costs[r--]);
            }
        }

        return totalCost; // 返回总代价
    }
};

Find Median From Data Stream

Mon, 09 Dec 2024 00:00:00 +0000

295. 数据流的中位数

分析

为了高效地获取中位数，使用两个优先队列（堆）来维护数据流的有序性：

down 堆（大顶堆）：
- 存储较小的一半元素，堆顶是最大值
up 堆（小顶堆）：
- 存储较大的一半元素，堆顶是最小值

通过以下规则维持堆的平衡和正确性：

插入元素：
- 如果当前元素小于或等于 down 堆的堆顶，将其插入 down
- 否则，将其插入 up
调整堆的平衡：
- 如果 down 的元素个数比 up 多 2，将 down 堆顶移到 up
- 如果 up 的元素个数比 down 多 1，将 up 堆顶移到 down
计算中位数：
- 如果两个堆的元素个数相等，中位数为两个堆顶的平均值；
- 如果 down 堆的元素个数比 up 多 1，中位数为 down 堆顶的值

时间复杂度

插入操作：O(logn) （堆的插入与删除）
获取中位数：O(1)

总体复杂度：O(logn) （单次操作）

空间复杂度

使用两个堆存储所有元素，空间复杂度为 O(n)

C++代码

class MedianFinder {
public:
    // 大顶堆，存储较小的一半元素
    std::priority_queue<int> down;
    // 小顶堆，存储较大的一半元素
    std::priority_queue<int, std::vector<int>, std::greater<int>> up;

    MedianFinder() {}

    void addNum(int num)
    {
        // 插入到适当的堆
        if (down.empty() || num <= down.top())
            down.push(num);
        else
            up.push(num);

        // 调整堆的平衡
        if (down.size() == up.size() + 2)
        {
            int x = down.top();
            down.pop();
            up.push(x);
        }
        else if (down.size() + 1 == up.size())
        {
            int x = up.top();
            up.pop();
            down.push(x);
        }
    }

    double findMedian()
    {
        if (down.size() == up.size())
            return (down.top() + up.top()) / 2.0;
        return down.top();
    }
};