LeetCode----IPO「贪心/优先队列」

题目描述

假设 力扣（LeetCode）即将开始其 IPO。为了以更高的价格将股票卖给风险投资公司
力扣 希望在 IPO 之前开展一些项目以增加其资本。 由于资源有限，它只能在 IPO 之前完成最多 k 个不同的项目。
帮助 力扣 设计完成最多 k 个不同项目后得到最大总资本的方式。
给定若干个项目。对于每个项目 i，它都有一个纯利润 Pi，并且需要最小的资本 Ci 来启动相应的项目。
最初，你有 W 资本。当你完成一个项目时，你将获得纯利润，且利润将被添加到你的总资本中。

总而言之，从给定项目中选择最多 k 个不同项目的列表，以最大化最终资本，并输出最终可获得的最多资本。

示例

输入: k=2, W=0, Profits=[1,2,3], Capital=[0,1,1].
输出: 4

解释:

由于你的初始资本为 0，你尽可以从 0 号项目开始。
在完成后，你将获得 1 的利润，你的总资本将变为 1。
此时你可以选择开始 1 号或 2 号项目。
由于你最多可以选择两个项目，所以你需要完成 2 号项目以获得最大的资本。
因此，输出最后最大化的资本，为 0 + 1 + 3 = 4。
LeetCode

思路

贪心：优先选择最大价值、其次最小资本即可
双优先队列：
大顶堆记录可以投资的项目（按价值排序），小顶堆记录不够资本投资的项目（按资本排序）
先选择投资大顶堆中的项目，当资本发生扩张时，再从小顶堆中取出可投资项目加入大顶堆

代码

// 贪心
class Solution {
    private static class Poject implements Comparable<Poject> {
        int val, cost;
        Poject(int val, int cost) {
            this.val = val;
            this.cost = cost;
        }

        @Override
        public int compareTo(Poject poject) {
            int tmp = poject.val - this.val;
            return tmp == 0 ? this.cost - poject.cost : tmp;
        }
    }
    private List<Poject> list = new ArrayList<>();
    public int findMaximizedCapital(int k, int w, int[] Profits, int[] Capital) {
        for(int i = 0; i < Profits.length; ++i) {
            list.add(new Poject(Profits[i], Capital[i]));
        }
        Collections.sort(list);
        for(int i = 0; i < k && !list.isEmpty(); ++i) {
            for(Poject poject : list) {
                if(poject.cost <= w) {
                    w += poject.val;
                    list.remove(poject);
                    break;
                }
            }
        }
        return w;
    }
}

// 双优先队列
class Solution {
    private static class Poject implements Comparable<Poject> {
        int val, cost;
        Poject(int val, int cost) {
            this.val = val;
            this.cost = cost;
        }

        @Override
        public int compareTo(Poject poject) {
            return poject.val - this.val;
        }
    }
    private Queue<Poject> maxHeap = new PriorityQueue<>();
    private Queue<Poject> minHeap = new PriorityQueue<>(new Comparator<Poject>() {
        @Override
        public int compare(Poject o1, Poject o2) {
            return o1.cost - o2.cost;
        }
    });
    public int findMaximizedCapital(int k, int w, int[] Profits, int[] Capital) {
        for(int i = 0; i < Profits.length; ++i) {
            if(w >= Capital[i]) {
                maxHeap.add(new Poject(Profits[i], Capital[i]));
            } else {
                minHeap.add(new Poject(Profits[i], Capital[i]));
            }
        }
        for(int i = 0; i < k && !maxHeap.isEmpty(); ++i) {
            w += maxHeap.poll().val;
            while(!minHeap.isEmpty() && minHeap.peek().cost <= w) {
                maxHeap.add(minHeap.poll());
            }
        }
        return w;
    }
}

原文地址：https://www.cnblogs.com/qq188380780/p/11643650.html