leetcode 502. IPO（上市，3种方法）

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