Problem

We have jobs: difficulty[i] is the difficulty of the ith job, and profit[i] is the profit of the ith job.

Now we have some workers. worker[i] is the ability of the ith worker, which means that this worker can only complete a job with difficulty at most worker[i].

Every worker can be assigned at most one job, but one job can be completed multiple times.

For example, if 3 people attempt the same job that pays $1, then the total profit will be $3.  If a worker cannot complete any job, his profit is $0.

What is the most profit we can make?

Example 1:

Input: difficulty = [2,4,6,8,10], profit = [10,20,30,40,50], worker = [4,5,6,7]
Output: 100 
Explanation: Workers are assigned jobs of difficulty [4,4,6,6] and they get profit of [20,20,30,30] seperately.

Notes:

• 1 <= difficulty.length = profit.length <= 10000
• 1 <= worker.length <= 10000
• difficulty[i], profit[i], worker[i]  are in range [1, 10^5]

Solution 1: Sorting + Two pointers

Time complexity: O(nlogn + mlogm)

Space complexity: O(n)

// Author: Huahua
// Running time: 90 ms
class Solution {
public:
  int maxProfitAssignment(vector<int>& difficulty, vector<int>& profit, vector<int>& worker) {
    const int n = difficulty.size();
    vector<pair<int, int>> jobs; // difficulty, profit
    
    for (int i = 0; i < n; ++i)
      jobs.emplace_back(difficulty[i], profit[i]);
    
    std::sort(jobs.begin(), jobs.end());
    std::sort(worker.begin(), worker.end());
    
    int ans = 0;
    int i = 0;
    int best = 0;
    for (int level : worker) {
      while (i < n && level >= jobs[i].first)
        best = max(best, jobs[i++].second);
      ans += best;
    }
    return ans;
  }
};

Solution 2: Bucket + Greedy

Key idea: for each difficulty D, find the most profit job whose requirement is <= D.

Three steps:

1. for each difficulty D, find the most profit job whose requirement is == D, best[D] = max{profit of difficulty D}.
2. if difficulty D – 1 can make more profit than difficulty D, best[D] = max(best[D], best[D – 1]).
3. The max profit each worker at skill level D can make is best[D].

Time complexity: O(n)

Space complexity: O(10000)

C++

// Author: Huahua
// Running time: 112 ms
class Solution {
public:
  int maxProfitAssignment(vector<int>& difficulty, vector<int>& profit, vector<int>& worker) {
    const int N = 100000;
    // max profit at difficulty i
    vector<int> max_profit(N + 1, 0);
    for (int i = 0; i < difficulty.size(); ++i)
      max_profit[difficulty[i]] = max(max_profit[difficulty[i]], profit[i]);
    for (int i = 2; i <= N; ++i)
      max_profit[i] = max(max_profit[i], max_profit[i - 1]);
    int ans = 0;
    for (int level : worker)
      ans += max_profit[level];
    return ans;
  }
};

C++ using map

// Author: Huahua
// Running time: 112 ms
class Solution {
public:
  int maxProfitAssignment(vector<int>& difficulty, vector<int>& profit, vector<int>& worker) {
    map<int, int> bests;
    for (int i = 0; i < difficulty.size(); ++i)
      bests[difficulty[i]] = max(bests[difficulty[i]], profit[i]);
    int best = 0;
    for (auto it = bests.begin(); it != bests.end(); ++it)
      it->second = best = max(it->second, best);    
    int ans = 0;
    for (int level : worker)
      ans += prev(bests.upper_bound(level))->second;
    return ans;
  }
};

The post 花花酱 LeetCode 826. Most Profit Assigning Work appeared first on Huahua's Tech Road.

题目大意：给你每天的股价，没有交易次数限制，但是卖出后要休息一天才能再买进。问你最大收益是多少？

Say you have an array for which the i^th element is the price of a given stock on day i.

Design an algorithm to find the maximum profit. You may complete as many transactions as you like (ie, buy one and sell one share of the stock multiple times) with the following restrictions:

• You may not engage in multiple transactions at the same time (ie, you must sell the stock before you buy again).
• After you sell your stock, you cannot buy stock on next day. (ie, cooldown 1 day)

Example:

prices = [1, 2, 3, 0, 2]
maxProfit = 3
transactions = [buy, sell, cooldown, buy, sell]

Idea:

DP

Solution:

Time complexity: O(n)

Space complexity: O(1)

C++

// Author: Huahua
// Running time: 12 ms
class Solution {
public:
    int maxProfit(vector<int>& prices) {
        int sold = 0;
        int rest = 0;
        int hold = INT_MIN;
        for (const int price : prices) {
            int prev_sold = sold;
            sold = hold + price;
            hold = max(hold, rest - price);
            rest = max(rest, prev_sold);
        }
        return max(rest, sold);
    }
};

Related Problems:

• 花花酱 LeetCode 121. Best Time to Buy and Sell Stock

The post 花花酱 LeetCode 309. Best Time to Buy and Sell Stock with Cooldown appeared first on Huahua's Tech Road.