g0501_0600.s0502_ipo.Solution Maven / Gradle / Ivy

Go to download
Show more of this group Show more artifacts with this name
Show all versions of leetcode-in-java21 Show documentation
Java-based LeetCode algorithm problem solutions, regularly updated
There is a newer version: 1.38
package g0501_0600.s0502_ipo;

// #Hard #Array #Sorting #Greedy #Heap_Priority_Queue
// #2022_07_24_Time_51_ms_(89.62%)_Space_101.7_MB_(47.03%)

import java.util.Comparator;
import java.util.PriorityQueue;

/**
 * 502 - IPO\.
 *
 * Hard
 *
 * 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 `n` projects where the i^th project has a pure profit `profits[i]` and a minimum capital of `capital[i]` is needed to start it.
 *
 * 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.
 *
 * Pick a list of **at most** `k` distinct projects from given projects to **maximize your final capital** , and return _the final maximized capital_.
 *
 * The answer is guaranteed to fit in a 32-bit signed integer.
 *
 * **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.
 *
 * **Example 2:**
 *
 * **Input:** k = 3, w = 0, profits = [1,2,3], capital = [0,1,2]
 *
 * **Output:** 6
 *
 * **Constraints:**
 *
 * *   1 <= k <= 10⁵
 * *   0 <= w <= 10⁹
 * *   `n == profits.length`
 * *   `n == capital.length`
 * *   1 <= n <= 10⁵
 * *   0 <= profits[i] <= 10⁴
 * *   0 <= capital[i] <= 10⁹
**/
public class Solution {
    public int findMaximizedCapital(int k, int w, int[] profits, int[] capital) {
        PriorityQueue minCapital =
                new PriorityQueue<>(Comparator.comparingInt((int[] a) -> a[1]));
        PriorityQueue maxProfit = new PriorityQueue<>((int[] a, int[] b) -> b[0] - a[0]);
        for (int i = 0; i < profits.length; i++) {
            if (w >= capital[i]) {
                maxProfit.offer(new int[] {profits[i], capital[i]});
            } else {
                minCapital.offer(new int[] {profits[i], capital[i]});
            }
        }
        int count = 0;
        while (count < k && !maxProfit.isEmpty()) {
            int[] temp = maxProfit.poll();
            w += temp[0];
            count += 1;
            while (!minCapital.isEmpty() && minCapital.peek()[1] <= w) {
                maxProfit.offer(minCapital.poll());
            }
        }
        return w;
    }
}