502. IPO（最小堆+最大堆法 or 排序法）
题目：
链接：https://leetcode-cn.com/problems/ipo/submissions/
假设 力扣（LeetCode）即将开始其 IPO。为了以更高的价格将股票卖给风险投资公司，力扣 希望在 IPO 之前开展一些项目以增加其资本。 由于资源有限，它只能在 IPO 之前完成最多 k 个不同的项目。帮助 力扣 设计完成最多 k 个不同项目后得到最大总资本的方式。
给定若干个项目。对于每个项目 i，它都有一个纯利润 Pi，并且需要最小的资本 Ci 来启动相应的项目。最初，你有 W 资本。当你完成一个项目时，你将获得纯利润，且利润将被添加到你的总资本中。
总而言之，从给定项目中选择最多 k 个不同项目的列表，以最大化最终资本，并输出最终可获得的最多资本。
示例 1:
输入: k=2, W=0, Profits=[1,2,3], Capital=[0,1,1].
输出: 4
解释:
由于你的初始资本为 0，你尽可以从 0 号项目开始。
在完成后，你将获得 1 的利润，你的总资本将变为 1。
此时你可以选择开始 1 号或 2 号项目。
由于你最多可以选择两个项目，所以你需要完成 2 号项目以获得最大的资本。
因此，输出最后最大化的资本，为 0 + 1 + 3 = 4。
注意:
假设所有输入数字都是非负整数。
表示利润和资本的数组的长度不超过 50000。
答案保证在 32 位有符号整数范围内。
分析：
吃了没文化的亏，题目的实际意思是每次投资需要花费的资本实际上不花费。啥意思呢，就是我有10块钱，我想买个15块钱的东西，不行，不让买。如果买5块的东西，可以倒手挣20块钱。可以，直接送你了，不要钱，然后我就有10+20=30块钱了。。。并不需要你花那5块钱买它再卖。。。
方法1---最小堆+最大堆：
先声明这是题解看来的，我是别的方法做的。
每次想投资的话，我们需要选一个资本不超过我们现有资金的，而对于利润实际上没有什么要求。毕竟利润是白送给我们，资本也不扣钱，所以只要我们现有的钱够的前提下，就应该选一个利润最大的来投资！ 然后我们维护一个最小堆，一个最大堆，其中最小堆存储还没买的所有股票，最大堆存储可以买的所有股票。
一开始最小堆是包含所有数据的，最大堆为空。
1.如果最小堆堆顶不超过我们现在的资金W，那么就可以考虑进行投资。
则我们把最小堆的堆顶pop掉，并加入最大堆。
2.接下来重复以上步骤，直到最小堆堆顶的资本超过当前资金。
3.这时候最大堆中的股票都是可以投资的，堆顶是利润最大的，这正是我们想要的，所以直接pop，完成一笔投资！
继续重复以上步骤K-1次，一共完成K笔交易。或者股票都买完了还不够K次，直接退出就好。
代码（懒得写了。。评论区粘一个）链接在此：https://leetcode-cn.com/problems/ipo/comments/209459
1 class Node{
2 public:
3 Node(){}
4 Node(int c, int p) : cost(c), profit(p){}
5 int cost;
6 int profit;
7 };
8 // 优先队列的比较器 按照花费从小到大排序
9 struct minCompare{
10 bool operator()(Node n1, Node n2){
11 return n1.cost > n2.cost;
12 }
13 };
14 // 优先队列的比较器 按照利润从大到小排序
15 struct maxCompare{
16 bool operator()(Node n1, Node n2){
17 return n1.profit < n2.profit;
18 }
19 };
20 class Solution {
21 public:
22 int findMaximizedCapital(int k, int W, vector<int>& Profits, vector<int>& Capital) {
23 // 全部构造节点
24 vector<Node> vec;
25 for(int i = 0; i < Profits.size(); i++){
26 vec.push_back(Node(Capital[i], Profits[i]));
27 }
28 // 按照花费 从小到大的优先队列
29 priority_queue<Node, vector<Node>, minCompare> minCost;
30 // 按照利润 从大到小的优先队列
31 priority_queue<Node, vector<Node>, maxCompare> maxPro;
32 // 全部加入到小根堆中
33 for(int i = 0; i < vec.size(); i++){
34 minCost.push(vec[i]);
35 }
36 for(int i = 0; i < k; i++){
37 // 把当前能做的放入大根堆
38 while(!minCost.empty() && minCost.top().cost <= W){
39 maxPro.push(minCost.top());
40 minCost.pop();
41 }
42 // 没得做了
43 if(maxPro.empty()){
44 return W;
45 }
46 // 求当前profit
47 W += maxPro.top().profit;
48 maxPro.pop();
49 }
50 return W;
51 }
52 };
方法2---直接硬排序，线性查找法（误？？）：
我自己的方法，感觉复杂度是O(N^2)，不如方法1，但实际跑起来还挺快的，可能数据集都比较小吧。
先建立一个索引数组，0~n-1，其中每个元素都指示题目两数组的某只股票。
然后对其排序，排序原则是利润大在前，利润相等则要求资本小的在前。
之后每次从头查找第一个可以投资的股票，投资之，弃之，再重复，直到K次或者数组空完事儿！
实际复杂度最大是O(n^2)，但只有最后一组数据特别大，单独判断一下，最后时间还比方法1快不少。。
代码：
1 class Solution {
2 public:
3 int findMaximizedCapital(int k, int W, vector<int>& Profits, vector<int>& Capital) {
4 if(*max_element(Capital.begin(),Capital.end())<=W){
5 sort(Profits.begin(),Profits.end());
6 for(int i=Profits.size()-1;i>=max(0,int(Profits.size())-k);--i){W+=Profits[i];}
7 return W;
8 }
9 auto cmp=[&](const int& x,const int& y){return Profits[x]>Profits[y] or Profits[x]==Profits[y] and Capital[x]<Capital[y];};
10 int n=Profits.size();
11 vector<int> nums(n);
12 for(int i=0;i<n;++i){nums[i]=i;}
13 sort(nums.begin(),nums.end(),cmp);
14 int cnt=0,cur_money=W;
15 auto iter=find_if(nums.begin(),nums.end(),[&](int x){return Capital[x]<=cur_money;});
16 while(cnt<k and iter!=nums.end()){
17 cur_money+=Profits[*iter];
18 Capital[*iter]=INT_MAX;//做记录
19 ++cnt;
20 iter=find_if(nums.begin(),nums.end(),[&](int x){return Capital[x]<=cur_money;});
21 }
22 return cur_money;
23 }
24 };
