输入:
参数1,正数数组costs
参数2,正数数组profits
参数3,正数k
参数4,正数m
costs[i]表示i号项目的花费
profits[i]表示i号项目在扣除花费之后还能挣到的钱(利润)
k表示你不能并行、只能串行的最多做k个项目
m表示你初始的资金
说明:你每做完一个项目,马上获得的收益,可以支持你去做下一个项目。
输出:
参数1,正数数组costs
参数2,正数数组profits
参数3,正数k
参数4,正数m
costs[i]表示i号项目的花费
profits[i]表示i号项目在扣除花费之后还能挣到的钱(利润)
k表示你不能并行、只能串行的最多做k个项目
m表示你初始的资金
说明:你每做完一个项目,马上获得的收益,可以支持你去做下一个项目。
输出:
你最后获得的最大钱数。
【思路】
考察点:贪心思想和堆结构应用。
自定义写两个比较器,按代价低的项目组成小根堆,按收益最大组成大根堆。
时间复杂度:O(N*logN)
代码:
import java.util.Comparator;
import java.util.PriorityQueue;
public class IPO {
public static class Node {
public int p;
public int c;
public Node(int p, int c) {
this.p = p;
this.c = c;
}
}
//看成锁池,花费最小的小根堆
public static class MinCostComparator implements Comparator<Node> {
@Override
public int compare(Node o1, Node o2) {
return o1.c - o2.c;
}
}
//看成解锁池,利润最大的大根堆
public static class MaxProfitComparator implements Comparator<Node> {
@Override
public int compare(Node o1, Node o2) {
return o2.p - o1.p;
}
}
//w表示总资金
public static int findMaximizedCapital(int k, int W, int[] Profits, int[] Capital) {
Node[] nodes = new Node[Profits.length];
//把所有项目放在node数组里,时间复杂度O(N)
for (int i = 0; i < Profits.length; i++) {
nodes[i] = new Node(Profits[i], Capital[i]);
}
PriorityQueue<Node> minCostQ = new PriorityQueue<>(new MinCostComparator());
PriorityQueue<Node> maxProfitQ = new PriorityQueue<>(new MaxProfitComparator());
//建堆O(N)
for (int i = 0; i < nodes.length; i++) {
minCostQ.add(nodes[i]);
}
//minCostQ.peek().c <= W表示能解锁哪些项目
//时间复杂度O(N*logN),k看成N
for (int i = 0; i < k; i++) {
while (!minCostQ.isEmpty() && minCostQ.peek().c <= W) {
maxProfitQ.add(minCostQ.poll()); //将解锁的项目放入利益的大根堆中,时间复杂度O(logN)
}
//做了项目后带来的利润和总资金的和不够做下一个项目
if (maxProfitQ.isEmpty()) {
return W;
}
//利润最大在堆顶,大根堆解锁池将堆顶弹出
W += maxProfitQ.poll().p;
}
return W;
}
}