贪心题目:IPO

文章目录

题目

标题和出处

标题:IPO

出处:502. IPO

难度

7 级

题目描述

要求

假设力扣(LeetCode)即将开始 IPO。为了以更高的价格将股票卖给风险投资公司,力扣想在 IPO 之前开展一些项目以增加其资本。由于资源有限,力扣只能在 IPO 之前完成最多 k \texttt{k} k 个不同的项目。帮助力扣设计完成最多 k \texttt{k} k 个不同项目后得到最大总资本的方式。

给定 n \texttt{n} n 个项目,其中第 i \texttt{i} i 个项目的纯利润是 profitsi \texttt{profitsi} profitsi,启动该项目需要的最小资本是 capitali \texttt{capitali} capitali。

初始资本为 w \texttt{w} w。当完成一个项目时,将获得纯利润,利润将被添加到总资本中。

从给定项目中选择最多 k \texttt{k} k 个不同项目以最大化最终资本,返回最终可获得的最多资本。

答案保证在 32 \texttt{32} 32 位有符号整数范围内。

示例

示例 1:

输入: k = 2, w = 0, profits = 1,2,3, capital = 0,1,1 \texttt{k = 2, w = 0, profits = 1,2,3, capital = 0,1,1} k = 2, w = 0, profits = 1,2,3, capital = 0,1,1

输出: 4 \texttt{4} 4

解释:

由于初始资本为 0 \texttt{0} 0,因此仅可以从 0 \texttt{0} 0 号项目开始。

在完成后,将获得 1 \texttt{1} 1 的利润,总资本将变为 1 \texttt{1} 1。

此时可以选择开始 1 \texttt{1} 1 号或 2 \texttt{2} 2 号项目。

由于最多可以选择 2 \texttt{2} 2 个项目,所以需要完成 2 \texttt{2} 2 号项目以获得最大的资本。

因此,最多资本为 0 + 1 + 3 = 4 \texttt{0} + \texttt{1} + \texttt{3} = \texttt{4} 0+1+3=4。

示例 2:

输入: k = 3, w = 0, profits = 1,2,3, capital = 0,1,2 \texttt{k = 3, w = 0, profits = 1,2,3, capital = 0,1,2} k = 3, w = 0, profits = 1,2,3, capital = 0,1,2

输出: 6 \texttt{6} 6

数据范围

  • 1 ≤ k ≤ 10 5 \texttt{1} \le \texttt{k} \le \texttt{10}^\texttt{5} 1≤k≤105
  • 0 ≤ w ≤ 10 9 \texttt{0} \le \texttt{w} \le \texttt{10}^\texttt{9} 0≤w≤109
  • n = profits.length = capital.length \texttt{n} = \texttt{profits.length} = \texttt{capital.length} n=profits.length=capital.length
  • 1 ≤ n ≤ 10 5 \texttt{1} \le \texttt{n} \le \texttt{10}^\texttt{5} 1≤n≤105
  • 0 ≤ profitsi ≤ 10 4 \texttt{0} \le \texttt{profitsi} \le \texttt{10}^\texttt{4} 0≤profitsi≤104
  • 0 ≤ capitali ≤ 10 9 \texttt{0} \le \texttt{capitali} \le \texttt{10}^\texttt{9} 0≤capitali≤109

解法

思路和算法

为了在最多选 k k k 个项目的情况下使资本最大化,每次应选可以选择的纯利润最高的项目。理由如下。

用 c c c 表示选项目之前的资本,如果有两个项目的纯利润分别是 p 1 p_1 p1 和 p 2 p_2 p2,其中 p 1 > p 2 p_1 > p_2 p1>p2,则选择纯利润 p 1 p_1 p1 的项目之后的资本是 c 1 = c + p 1 c_1 = c + p_1 c1=c+p1,选择纯利润 p 2 p_2 p2 的项目之后的资本是 c 2 = c + p 2 c_2 = c + p_2 c2=c+p2,由于 p 1 > p 2 p_1 > p_2 p1>p2,因此 c 1 > c 2 c_1 > c_2 c1>c2。每个项目都有最小启动资本,最小启动资本小于等于 c 2 c_2 c2 的项目在资本为 c 1 c_1 c1 和 c 2 c_2 c2 的情况下都可以启动,最小启动资本大于 c 2 c_2 c2 且小于等于 c 1 c_1 c1 的项目只能在资本为 c 1 c_1 c1 的情况下启动而不能在资本为 c 2 c_2 c2 的情况下启动,因此资本越大,可以启动的项目越多,选择纯利润较低的项目一定不可能得到更大的资本。

根据上述分析,可以使用贪心策略计算可获得的最多资本,每次选择剩余项目中的启动资本小于等于当前资本且纯利润最大的项目。

为了方便处理,使用二维数组存储每个项目的纯利润和启动资本,二维数组的长度是 n n n,即所有项目的个数,将二维数组按启动资本升序排序,然后遍历二维数组选择最多 k k k 个项目使资本最大化,遍历过程中维护当前资本 totalCapital \textit{totalCapital} totalCapital、排序后的二维数组中的下标 index \textit{index} index 和存储可选项目纯利润的优先队列, totalCapital \textit{totalCapital} totalCapital 的初始值是 w w w, index \textit{index} index 的初始值是 0 0 0,优先队列的队首元素是最大值。

每次选择项目的做法如下。

  1. 当 index < n \textit{index} < n index<n 且第 index \textit{index} index 个项目的最小启动资本小于等于 totalCapital \textit{totalCapital} totalCapital 时,将第 index \textit{index} index 个项目的纯利润添加到优先队列中,然后将 index \textit{index} index 加 1 1 1。重复该操作,直到 index ≥ n \textit{index} \ge n index≥n 或第 index \textit{index} index 个项目的最小启动资本大于 totalCapital \textit{totalCapital} totalCapital 时结束该操作。

  2. 如果此时优先队列为空,则当前资本下没有更多的项目可以选择,结束遍历。如果此时优先队列不为空,则从优先队列中取出队首元素加到 totalCapital \textit{totalCapital} totalCapital,取出的元素为当前资本下可以选择的项目的的最高纯利润。

当选满 k k k 个项目或没有更多的项目可以选择时,结束遍历,此时的 totalCapital \textit{totalCapital} totalCapital 即为可获得的最多资本。

代码

java 复制代码
class Solution {
    public int findMaximizedCapital(int k, int w, int[] profits, int[] capital) {
        int n = profits.length;
        int[][] profitsCapital = new int[n][2];
        for (int i = 0; i < n; i++) {
            profitsCapital[i][0] = profits[i];
            profitsCapital[i][1] = capital[i];
        }
        Arrays.sort(profitsCapital, (a, b) -> a[1] - b[1]);
        int totalCapital = w;
        int index = 0;
        PriorityQueue<Integer> pq = new PriorityQueue<Integer>((a, b) -> b - a);
        for (int i = 0; i < k; i++) {
            while (index < n && profitsCapital[index][1] <= totalCapital) {
                pq.offer(profitsCapital[index][0]);
                index++;
            }
            if (pq.isEmpty()) {
                break;
            }
            totalCapital += pq.poll();
        }
        return totalCapital;
    }
}

复杂度分析

  • 时间复杂度: O ( ( n + k ) log ⁡ n ) O((n + k) \log n) O((n+k)logn),其中 n n n 是数组 profits \textit{profits} profits 和 capital \textit{capital} capital 的长度, k k k 是最多可选项目数。创建二维数组需要 O ( n ) O(n) O(n) 的时间,排序需要 O ( n log ⁡ n ) O(n \log n) O(nlogn) 的时间,最多将 n n n 个元素加入优先队列,最多将 k k k 个元素从优先队列中取出,因此优先队列操作的时间是 O ( ( n + k ) log ⁡ n ) O((n + k) \log n) O((n+k)logn),总时间复杂度是 O ( ( n + k ) log ⁡ n ) O((n + k) \log n) O((n+k)logn)。

  • 空间复杂度: O ( n ) O(n) O(n),其中 n n n 是数组 profits \textit{profits} profits 和 capital \textit{capital} capital 的长度。二维数组和优先队列需要 O ( n ) O(n) O(n) 的空间。

拓展问题

问题描述

原始问题只有计算可获得的最多资本,在原始问题的基础上,可以提出拓展问题:当获得最多资本时,选择项目的方案是什么,即选择哪些项目,按照什么样的顺序选择项目?如果有多种方案,返回其中任意一种。

解法分析

为了得到获得最多资本时选择项目的方案,需要同时记录每个剩余项目的纯利润和最小启动资本。

原始问题的解法中,使用优先队列存储可选项目的纯利润。拓展问题需要记录可选项目的纯利润和最小启动资本,因此只要在优先队列中同时存储可选项目的纯利润和最小启动资本即可。

遍历过程中,每次从优先队列中取出元素时,将该元素添加到项目列表中。遍历结束之后,项目列表即为选择的项目以及选择项目的顺序。

代码

下面的代码中,返回值是一个列表,列表中的每个元素是长度为 2 2 2 的数组,为按顺序选择的每个项目的纯利润和最小启动资本。

java 复制代码
class Solution {
    public List<int[]> findMaximizedCapital(int k, int w, int[] profits, int[] capital) {
        int n = profits.length;
        int[][] profitsCapital = new int[n][2];
        for (int i = 0; i < n; i++) {
            profitsCapital[i][0] = profits[i];
            profitsCapital[i][1] = capital[i];
        }
        Arrays.sort(profitsCapital, (a, b) -> a[1] - b[1]);
        List<int[]> selected = new ArrayList<int[]>();
        int totalCapital = w;
        int index = 0;
        PriorityQueue<int[]> pq = new PriorityQueue<int[]>((a, b) -> b[0] - a[0]);
        for (int i = 0; i < k; i++) {
            while (index < n && profitsCapital[index][1] <= totalCapital) {
                pq.offer(profitsCapital[index]);
                index++;
            }
            if (pq.isEmpty()) {
                break;
            }
            int[] project = pq.poll();
            selected.add(project);
            totalCapital += project[0];
        }
		return selected;
    }
}

复杂度分析

  • 时间复杂度: O ( ( n + k ) log ⁡ n ) O((n + k) \log n) O((n+k)logn),其中 n n n 是数组 profits \textit{profits} profits 和 capital \textit{capital} capital 的长度, k k k 是最多可选项目数。遍历过程中每次将元素添加到项目列表的时间是 O ( 1 ) O(1) O(1),因此和原始问题的时间复杂度相同。

  • 空间复杂度: O ( n ) O(n) O(n),其中 n n n 是数组 profits \textit{profits} profits 和 capital \textit{capital} capital 的长度。和原始问题的空间复杂度相同。

相关推荐
漂流瓶jz6 天前
UVA-1613 K度图的着色 题解答案代码 算法竞赛入门经典第二版
算法·深度优先·图论·贪心·aoapc·算法竞赛入门经典·uva
伟大的车尔尼10 天前
贪心题目:重构 2 行二进制矩阵
贪心
伟大的车尔尼11 天前
贪心题目:吃苹果的最大数目
贪心
吞下星星的少年·-·20 天前
Div.2 CF 1130B题(构造,贪心)
算法·贪心·构造
伟大的车尔尼23 天前
贪心题目:加油站
贪心
伟大的车尔尼24 天前
贪心题目:给定行和列的和求可行矩阵
贪心
伟大的车尔尼1 个月前
贪心题目:需要教语言的最少人数
贪心
lvwangshu1 个月前
T3 涂鸦带师 题解
题解·贪心·倍增·技巧·思维好题·断环成链
吞下星星的少年·-·1 个月前
牛客周赛 119B题(贪心)
算法·贪心