##### Welcome to Subscribe On Youtube

Formatted question description: https://leetcode.ca/all/502.html

# 502. IPO

Hard

## Description

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.

## Solution

Use greedy algorithm. For each project, group the profit and the capital into a pair, and sort all projects’ pairs according to capical in ascending order. Create a priority queue that stores profits, where the maximum profit is polled first. Each time offer the profits into the priority queue where the capital does not exceed the current profit, poll one element from the priority queue, and add the element to the total capital. Repeat the process for at most k times. If the priority queue becomes empty, then stop the process. Finally, return the total capital.

• class Solution {
public int findMaximizedCapital(int k, int W, int[] Profits, int[] Capital) {
int length = Profits.length;
int[][] profitsCapital = new int[length];
for (int i = 0; i < length; i++) {
profitsCapital[i] = Profits[i];
profitsCapital[i] = Capital[i];
}
Arrays.sort(profitsCapital, new Comparator<int[]>() {
public int compare(int[] profitsCapital1, int[] profitsCapital2) {
return profitsCapital1 - profitsCapital2;
}
});
int totalCapital = W;
PriorityQueue<Integer> priorityQueue = new PriorityQueue<Integer>(new Comparator<Integer>() {
public int compare(Integer profit1, Integer profit2) {
return profit2 - profit1;
}
});
int index = 0;
while (k > 0) {
while (index < length && profitsCapital[index] <= totalCapital) {
priorityQueue.offer(profitsCapital[index]);
index++;
}
if (priorityQueue.isEmpty())
break;
totalCapital += priorityQueue.poll();
k--;
}
}
}

• // OJ: https://leetcode.com/problems/ipo/
// Time: O(NlogN)
// Space: O(N)
class Solution {
public:
int findMaximizedCapital(int k, int w, vector<int>& P, vector<int>& C) {
vector<int> id(P.size());
iota(begin(id), end(id), 0);
sort(begin(id), end(id), [&](int a, int b) { return C[a] < C[b]; });
auto cmp = [&](int a, int b) { return P[a] < P[b]; };
priority_queue<int, vector<int>, decltype(cmp)> pq(cmp);
for (int i = 0, j = 0; i < k; ++i) {
while (j < id.size() && w >= C[id[j]]) {
pq.push(id[j]);
++j;
}
if (pq.empty()) break;
int p = pq.top();
pq.pop();
w += P[p];
}
return w;
}
};

• class Solution:
def findMaximizedCapital(
self, k: int, w: int, profits: List[int], capital: List[int]
) -> int:
h1 = [(c, p) for c, p in zip(capital, profits)]
heapify(h1)
h2 = []
while k:
while h1 and h1 <= w:
heappush(h2, -heappop(h1))
if not h2:
break
w -= heappop(h2)
k -= 1
return w

############

class Solution(object):
def findMaximizedCapital(self, k, W, Profits, Capital):
current = []
future = sorted(zip(Capital, Profits))[::-1]
for _ in range(k):
while future and future[-1] <= W:
heapq.heappush(current, -future.pop())
if current:
W -= heapq.heappop(current)
return W


• func findMaximizedCapital(k int, w int, profits []int, capital []int) int {
q1 := hp2{}
for i, c := range capital {
heap.Push(&q1, pair{c, profits[i]})
}
q2 := hp{}
for k > 0 {
for len(q1) > 0 && q1.c <= w {
heap.Push(&q2, heap.Pop(&q1).(pair).p)
}
if q2.Len() == 0 {
break
}
w += heap.Pop(&q2).(int)
k--
}
return w
}

type hp struct{ sort.IntSlice }

func (h hp) Less(i, j int) bool  { return h.IntSlice[i] > h.IntSlice[j] }
func (h *hp) Push(v interface{}) { h.IntSlice = append(h.IntSlice, v.(int)) }
func (h *hp) Pop() interface{} {
a := h.IntSlice
v := a[len(a)-1]
h.IntSlice = a[:len(a)-1]
return v
}

type pair struct{ c, p int }
type hp2 []pair

func (h hp2) Len() int            { return len(h) }
func (h hp2) Less(i, j int) bool  { return h[i].c < h[j].c }
func (h hp2) Swap(i, j int)       { h[i], h[j] = h[j], h[i] }
func (h *hp2) Push(v interface{}) { *h = append(*h, v.(pair)) }
func (h *hp2) Pop() interface{}   { a := *h; v := a[len(a)-1]; *h = a[:len(a)-1]; return v }