LeetCode 题解(Week 5):502. IPO

原题目

Suppose LeetCode will start its IPO soon. In order to sell a good price of its shares to Venture Capital, LeetCode would like to work on some projects to increase its capital before the IPO. Since it has limited resources, it can only finish at most k distinct projects before the IPO. Help LeetCode design the best way to maximize its total capital after finishing at most k distinct projects.

You are given several projects. For each project i, it has a pure profit Pi and a minimum capital of Ci is needed to start the corresponding project. Initially, you have W capital. When you finish a project, you will obtain its pure profit and the profit will be added to your total capital.

To sum up, pick a list of at most k distinct projects from given projects to maximize your final capital, and output your final maximized capital.

Example 1:

Input: k=2, W=0, Profits=[1,2,3], Capital=[0,1,1].

Output: 4

Explanation: Since your initial capital is 0, you can only start the
project indexed 0. After finishing it you will obtain profit 1 and your capital becomes 1. With capital 1, you can either start the project indexed 1 or the project indexed 2. Since you can choose at most 2 projects, you need to finish the project indexed 2 to get the maximum capital. Therefore, output the final maximized capital, which is 0 + 1 + 3 = 4.

Note:
1. You may assume all numbers in the input are non-negative integers.
2. The length of Profits array and Capital array will not exceed 50,000.
3. The answer is guaranteed to fit in a 32-bit signed integer.

中文大意

给定若干个项目，每一个i项目需要的资金为Ci，每一个项目的收益为Pi。当前的资金为W，可以投资所需基金少于或等于W的项目，并拿到Pi的收益。给定初始资金为W0，求出最终投资k个项目后的最高资金

题解：

class Solution {
public:
    struct  Project
    {
        int profit;
        int capital;

        Project(int _profit, int _capital)
        {
            profit = _profit;
            capital = _capital;
        }

        bool operator > (const Project &p) const {return profit > p.profit;}
        bool operator < (const Project &p) const {return profit < p.profit;}
    };

    int findMaximizedCapital(int k, int W, vector<int>& Profits, vector<int>& Capital) {

        priority_queue<Project,vector<Project>,less<Project> > q;


        //建立一个优先队列，根据profit从大到小排序
        for(int i = 0; i < Profits.size(); i++)
            q.push(Project(Profits[i],Capital[i]));  

        for(int i = 0; i < k; i++)
        {
            vector<Project> projectVec;
            // 将当前排在队列前面但是不够钱投资的项目取出来，放到vector中
            while(!q.empty() && q.top().capital > W)
            {
                projectVec.push_back(q.top());
                q.pop();
            }

            if(q.empty()) return W;
            W += q.top().profit;
            // cout << W <<endl;
            q.pop();
            //将之前不够钱投资的项目重新入队（拿到收益之后有可能就够了）
            for(int j = 0; j < projectVec.size(); j++)
                q.push(projectVec[j]);
        }

        return W;
    }
};

思路

• 这道题的解决途径就是,循环k次，每次只需要找到够资金投资的并且收益最大的项目。
• 从数据结构的角度出发，这道题很适用与优先队列来解决：最初先将所有的项目放到一个优先队列中，队列中的每一个元素按照收益值作为优先级，收益越高，就排在越前面。
• 每一次循环的时候，从队头开始，找到资金符合的最前面的项目
• 在循环结束之后，将原来不符合的项目放回到队列中
• 最坏情况下，需要出队的次数为(n + (n-1) + (n-2) + … + (n-k+1)) * k/2 = O(n^2)
• 因此，算法的时间复杂度为O(n^2)，空间复杂度为O(n)

心得

在解决贪心算法的层面上，用优先队列是一种比较好的数据结构