假设leetcode 即将上市，如何筹集资金的问题。
有两个数组profits和capital, 分别代表第 i 个项目有多少净利润 和 需要多少启动资金。
手上的原始资金是w,
用这个w的资金去启动项目，完成项目之后净利润会加到w上，再做下一个项目，
一共可以做k 个 不同 的项目。
问最后w最多能到多少（能融多少资）。
思路：
来看看作为一个Hard的题目，它到底难在哪。
目前融资受两条线的限制，一个是受手上有多少钱的限制，手上只有w, 只做得起capital <= w的项目。
另一条就是要从做得起的项目中选择净利润最大的。
题目中说做k个不同的项目，说明每个项目只能做一次，做完就删掉。
那目前的做法就是先选出captical <= w的项目，再从这些项目中选择profit最大的，把profit加到w,
再开始下一轮的操作。
从已有的项目中选择profit最大的这点容易想到用优先队列。如果只是这样就算Medium难度了，
现在加了一个问题，怎么从项目中选出capital <= w的，然后再把做过的删掉？
要想把做过项目的删掉，就要把项目放进优先队列里，也就是选择profit最大的项目然后删掉，这点比较容易做到，
那么选择capital <= w的呢，有一个方法，就是把项目按照capital从小到大排序，
从左到右遍历，把capital <= w的都放进优先队列，遇到>w的停止，取出profit最大的加到w，并且把这个项目删掉。
那你会问，如果下一个项目w变小了怎么办，是不是队列里面就有不满足capital<=w的了？是不是又要重新装队列？
题目这里降低了这个难度，规定profit是净利润，就是收回本金之外有这些利润，所以w只会变多。
队列不需要清空，只需要继续向右遍历数组。
class Solution {
public int findMaximizedCapital(int k, int w, int[] profits, int[] capital) {
int n = profits.length;
int idx = 0;
Project[] projects = new Project[n];
PriorityQueue<Project> pq = new PriorityQueue<>((a,b)->(b.profit-a.profit));
for(int i = 0; i < n; i++) {
projects[i] = new Project(profits[i], capital[i]);
}
//按capital排序
Arrays.sort(projects, (a,b)->Integer.compare(a.capital, b.capital));
//注意profit是纯利润，w只会越加越多，w不会变少，所以之前加的project后面一定也能干
while(k > 0) {
while(idx < n && projects[idx].capital <= w){
pq.offer(projects[idx]);
idx ++;
}
if(pq.isEmpty()) break; //没有可做的project了
w += pq.poll().profit;
k--;
}
return w;
}
class Project{
int profit = 0;
int capital = 0;
public Project(int profit, int capital) {
this.profit = profit;
this.capital = capital;
}
}
}
但是上面的方法不是最快的，它耗时在哪里呢，在排序。
如何不排序就能做到两条线一增一减？
前面排序是为了更方便地选出capital <= w的项目。在装入队列时保证装进去的都是capital <= w的项目。
那换一种思路，装入队列的时候不限制，什么项目都可以，但是取出的时候要取出capital <= w的，
那最好是按capital从小往大取，一旦出现capital > w的项目就停止。
所以每次都取出capital最小的项目，想到了最小堆。所以把项目按照capital的顺序放入最小堆（优先队列1）。
每次取出capital <= w的项目，然后和前面方法一样，把profit放进最大堆（优先队列2），取出profit最大的加到w, 并删除这个profit。
取出profit加到w时，我们并不需要capital这个东西，所以profit最大堆（优先队列2）只需要保存profit，不需要保存整个项目。
所以Hard难在哪呢？一般我们只需要考虑一个维度，但是这里有两个维度一增一减，
思路要么是降维（一个维度排好序，变化的只有另一维度），要么是安排一增一减两条线（两个优先队列）。
净利润这个词降低了难度，w只增不减，所以已经放入优先队列的不需要再取出重装。
class Solution {
public int findMaximizedCapital(int k, int w, int[] profits, int[] capital) {
int n = profits.length;
int idx = 0;
//capital升序
PriorityQueue<Project> qProject = new PriorityQueue<>((a,b)->Integer.compare(a.capital, b.capital));
//profit降序
PriorityQueue<Integer> qProfit = new PriorityQueue<>((a,b)->(b-a));
//把capital<=w的装进qProfit,剩下的排进qProject
for(int i = 0; i < n; i++) {
if(capital[i] <= w) {
qProfit.offer(profits[i]);
} else {
qProject.offer(new Project(profits[i], capital[i]));
}
}
while(k > 0) {
//把qProject里面capital<=w的profit提出来放进qProfit
while(!qProject.isEmpty() && qProject.peek().capital <= w) {
qProfit.offer(qProject.poll().profit);
}
if(qProfit.isEmpty()) break; //没有项目可做
w += qProfit.poll();
k --;
}
return w;
}
class Project{
int profit = 0;
int capital = 0;
public Project(int profit, int capital) {
this.profit = profit;
this.capital = capital;
}
}
}
那如果你说两个优先队列太麻烦了，就只想用一个profit的优先队列，
选capital <= w的项目时就遍历整个数组来找，那么，请参考如下方法。
它有一个trick, 就是初始资金比任何项目的capital都大时，就可以无视capital, 直接选k个最大的profit.
public int findMaximizedCapital(int k, int w, int[] profits, int[] capital) {
int maxCapital = 0;
for(int i = 0 ; i < capital.length; i++){
maxCapital = Math.max(capital[i], maxCapital);
}
//如果原始资金很大，无视capital,直接取k个最大的profit
if(w >= maxCapital){
PriorityQueue<Integer> maxHeap = new PriorityQueue<>((a,b)->Integer.compare(a,b));
for (int p: profits) {
maxHeap.add(p);
if (maxHeap.size() > k) maxHeap.poll();
}
for (int h: maxHeap) w += h;
return w;
}
int index; //保存最大profit所在的index
int n = profits.length;
for(int i = 0; i < Math.min(k, n); i++) {
index = -1;
//每次都遍历数组，找出capital<=w的项目，并记下最大profit的index
for(int j = 0; j < n; ++j) {
if (w >= capital[j] && (index == -1 || profits[index] < profits[j])){
index = j;
}
}
if(index == -1) break;
w += profits[index];
//把已经使用过的项目capital置为无穷大，下次就不会再使用
capital[index] = Integer.MAX_VALUE;
}
return w;
}
