Huahua’s Tech Road

LeetCode 1801. Number of Orders in the Backlog

By zxi on March 21, 2021

You are given a 2D integer array orders, where each orders[i] = [price_i, amount_i, orderType_i] denotes that amount_iorders have been placed of type orderType_i at the price price_i. The orderType_i is:

0 if it is a batch of buy orders, or
1 if it is a batch of sell orders.

Note that orders[i] represents a batch of amount_i independent orders with the same price and order type. All orders represented by orders[i] will be placed before all orders represented by orders[i+1] for all valid i.

There is a backlog that consists of orders that have not been executed. The backlog is initially empty. When an order is placed, the following happens:

If the order is a buy order, you look at the sell order with the smallest price in the backlog. If that sell order’s price is smaller than or equal to the current buy order’s price, they will match and be executed, and that sell order will be removed from the backlog. Else, the buy order is added to the backlog.
Vice versa, if the order is a sell order, you look at the buy order with the largest price in the backlog. If that buy order’s price is larger than or equal to the current sell order’s price, they will match and be executed, and that buy order will be removed from the backlog. Else, the sell order is added to the backlog.

Return the total amount of orders in the backlog after placing all the orders from the input. Since this number can be large, return it modulo 10⁹ + 7.

Example 1:

Input: orders = [[10,5,0],[15,2,1],[25,1,1],[30,4,0]]
Output: 6
Explanation: Here is what happens with the orders:
- 5 orders of type buy with price 10 are placed. There are no sell orders, so the 5 orders are added to the backlog.
- 2 orders of type sell with price 15 are placed. There are no buy orders with prices larger than or equal to 15, so the 2 orders are added to the backlog.
- 1 order of type sell with price 25 is placed. There are no buy orders with prices larger than or equal to 25 in the backlog, so this order is added to the backlog.
- 4 orders of type buy with price 30 are placed. The first 2 orders are matched with the 2 sell orders of the least price, which is 15 and these 2 sell orders are removed from the backlog. The 3^rd order is matched with the sell order of the least price, which is 25 and this sell order is removed from the backlog. Then, there are no more sell orders in the backlog, so the 4^th order is added to the backlog.
Finally, the backlog has 5 buy orders with price 10, and 1 buy order with price 30. So the total number of orders in the backlog is 6.

Example 2:

Input: orders = [[7,1000000000,1],[15,3,0],[5,999999995,0],[5,1,1]]
Output: 999999984
Explanation: Here is what happens with the orders:
- 10⁹ orders of type sell with price 7 are placed. There are no buy orders, so the 10⁹ orders are added to the backlog.
- 3 orders of type buy with price 15 are placed. They are matched with the 3 sell orders with the least price which is 7, and those 3 sell orders are removed from the backlog.
- 999999995 orders of type buy with price 5 are placed. The least price of a sell order is 7, so the 999999995 orders are added to the backlog.
- 1 order of type sell with price 5 is placed. It is matched with the buy order of the highest price, which is 5, and that buy order is removed from the backlog.
Finally, the backlog has (1000000000-3) sell orders with price 7, and (999999995-1) buy orders with price 5. So the total number of orders = 1999999991, which is equal to 999999984 % (10⁹ + 7).

Constraints:

1 <= orders.length <= 10⁵
orders[i].length == 3
1 <= price_i, amount_i <= 10⁹
orderType_i is either 0 or 1.

Solution: Treemap / PriorityQueue / Heap

buy backlog: max heap
sell backlog: min heap
Trade happens between the tops of two queues.

Time complexity: O(nlogn)
Space complexity: O(n)

C++

// Author: Huahua

class Solution {

public:

int getNumberOfBacklogOrders(vector<vector<int>>& orders) {

constexpr int kMod = 1e9 + 7;

map<int64_t, int64_t> buys;

map<int64_t, int64_t> sells;

for (const auto& order : orders) {

auto& m = order[2] == 0 ? buys : sells;

m[order[0]] += order[1];

while (buys.size() && sells.size()) {

auto b = rbegin(buys);

auto s = begin(sells);

if (b->first < s->first) break;

const int k = min(b->second, s->second);

if (!(b->second -= k)) buys.erase((++b).base());

if (!(s->second -= k)) sells.erase(s);

}

int64_t ans = 0;

for (const auto& [p, c] : buys) ans += c;

for (const auto& [p, c] : sells) ans += c;

return ans % kMod;

}

};

花花酱 LeetCode 1800. Maximum Ascending Subarray Sum

By zxi on March 21, 2021

Given an array of positive integers nums, return the maximum possible sum of an ascending subarray in nums.

A subarray is defined as a contiguous sequence of numbers in an array.

A subarray [nums_l, nums_l+1, ..., nums_r-1, nums_r] is ascending if for all i where l <= i < r, nums_i< nums_i+1. Note that a subarray of size 1 is ascending.

Example 1:

Input: nums = [10,20,30,5,10,50]
Output: 65
Explanation: [5,10,50] is the ascending subarray with the maximum sum of 65.

Example 2:

Input: nums = [10,20,30,40,50]
Output: 150
Explanation: [10,20,30,40,50] is the ascending subarray with the maximum sum of 150.

Example 3:

Input: nums = [12,17,15,13,10,11,12]
Output: 33
Explanation: [10,11,12] is the ascending subarray with the maximum sum of 33.

Example 4:

Input: nums = [100,10,1]
Output: 100

Constraints:

1 <= nums.length <= 100
1 <= nums[i] <= 100

Solution: Running sum with resetting

Time complexity: O(n)
Space complexity: O(1)

Track the running sum and reset it to zero if nums[i] <= nums[i – 1]

C++

// Author: Huahua

class Solution {

public:

int maxAscendingSum(vector<int>& nums) {

int ans = 0;

for (int i = 0, s = 0; i < nums.size(); ++i) {

if (i && nums[i] <= nums[i - 1])

s = 0;

ans = max(ans, s += nums[i]);

}

return ans;

}

};

花花酱 LeetCode 1799. Maximize Score After N Operations

By zxi on March 20, 2021

You are given nums, an array of positive integers of size 2 * n. You must perform n operations on this array.

In the i^th operation (1-indexed), you will:

Choose two elements, x and y.
Receive a score of i * gcd(x, y).
Remove x and y from nums.

Return the maximum score you can receive after performing n operations.

The function gcd(x, y) is the greatest common divisor of x and y.

Example 1:

Input: nums = [1,2]
Output: 1
Explanation: The optimal choice of operations is:
(1 * gcd(1, 2)) = 1

Example 2:

Input: nums = [3,4,6,8]
Output: 11
Explanation: The optimal choice of operations is:
(1 * gcd(3, 6)) + (2 * gcd(4, 8)) = 3 + 8 = 11

Example 3:

Input: nums = [1,2,3,4,5,6]
Output: 14
Explanation: The optimal choice of operations is:
(1 * gcd(1, 5)) + (2 * gcd(2, 4)) + (3 * gcd(3, 6)) = 1 + 4 + 9 = 14

Constraints:

1 <= n <= 7
nums.length == 2 * n
1 <= nums[i] <= 10⁶

Solution: Mask DP

dp(mask, i) := max score of numbers (represented by a binary mask) at the i-th operations.
ans = dp(1, mask)
base case: dp = 0 if mask == 0
Transition: dp(mask, i) = max(dp(new_mask, i + 1) + i * gcd(nums[m], nums[n]))

Time complexity: O(n²*2²ⁿ)
Space complexity: O(2²ⁿ)

C++

// Author: Huahua, 184 ms, 8.3 MB

class Solution {

public:

int maxScore(vector<int>& nums) {

const int l = nums.size();

vector<int> cache(1 << l);

function<int(int)> dp = [&](int mask) {

if (mask == 0) return 0;

int& ans = cache[mask];

if (ans > 0) return ans;

const int k = (l - __builtin_popcount(mask)) / 2 + 1;

for (int i = 0; i < l; ++i)

for (int j = i + 1; j < l; ++j)

if ((mask & (1 << i)) && (mask & (1 << j)))

ans = max(ans, k * gcd(nums[i], nums[j])

+ dp(mask ^ (1 << i) ^ (1 << j)));

return ans;

};

return dp((1 << l) - 1);

}

};

Bottom-Up

C++

// Author: Huahua, 156 ms, 8.3 MB

class Solution {

public:

int maxScore(vector<int>& nums) {

const int l = nums.size();

vector<int> dp(1 << l);

for (int mask = 0; mask < 1 << l; ++mask) {

int c = __builtin_popcount(mask);

if (c & 1) continue; // only do in pairs

int k = c / 2 + 1;

for (int i = 0; i < l; ++i)

for (int j = i + 1; j < l; ++j)

if ((mask & (1 << i)) + (mask & (1 << j)) == 0) {

int new_mask = mask | (1 << i) | (1 << j);

dp[new_mask] = max(dp[new_mask],

k * gcd(nums[i], nums[j]) + dp[mask]);

}

return dp[(1 << l) - 1];

}

};

花花酱 LeetCode 1798. Maximum Number of Consecutive Values You Can Make

By zxi on March 20, 2021

You are given an integer array coins of length n which represents the n coins that you own. The value of the i^th coin is coins[i]. You can make some value x if you can choose some of your n coins such that their values sum up to x.

Return the maximum number of consecutive integer values that you can make with your coins starting from and including 0.

Note that you may have multiple coins of the same value.

Example 1:

Input: coins = [1,3]
Output: 2
Explanation: You can make the following values:
- 0: take []
- 1: take [1]
You can make 2 consecutive integer values starting from 0.

Example 2:

Input: coins = [1,1,1,4]
Output: 8
Explanation: You can make the following values:
- 0: take []
- 1: take [1]
- 2: take [1,1]
- 3: take [1,1,1]
- 4: take [4]
- 5: take [4,1]
- 6: take [4,1,1]
- 7: take [4,1,1,1]
You can make 8 consecutive integer values starting from 0.

Example 3:

Input: nums = [1,4,10,3,1]
Output: 20

Constraints:

coins.length == n
1 <= n <= 4 * 10⁴
1 <= coins[i] <= 4 * 10⁴

Solution: Greedy + Math

We want to start with smaller values, sort input array in ascending order.

First of all, the first number has to be 1 in order to generate sum of 1.
Assuming the first i numbers can generate 0 ~ k.
Then the i+1-th number x can be used if and only if x <= k + 1, such that we can have a consecutive sum of k + 1 by adding x to a sum between [0, k] and the new maximum sum we have will be k + x.

Time complexity: O(nlogn)
Space complexity: O(1)

C++

// Author: Huahua

class Solution {

public:

int getMaximumConsecutive(vector<int>& coins) {

sort(begin(coins), end(coins));

int ans = 0;

for (int c : coins) {

if (c > ans + 1) break;

ans += c;

}

return ans + 1;

}

};

花花酱 LeetCode 1797. Design Authentication Manager

By zxi on March 20, 2021

There is an authentication system that works with authentication tokens. For each session, the user will receive a new authentication token that will expire timeToLive seconds after the currentTime. If the token is renewed, the expiry time will be extended to expire timeToLive seconds after the (potentially different) currentTime.

Implement the AuthenticationManager class:

AuthenticationManager(int timeToLive) constructs the AuthenticationManager and sets the timeToLive.
generate(string tokenId, int currentTime) generates a new token with the given tokenId at the given currentTime in seconds.
renew(string tokenId, int currentTime) renews the unexpired token with the given tokenId at the given currentTime in seconds. If there are no unexpired tokens with the given tokenId, the request is ignored, and nothing happens.
countUnexpiredTokens(int currentTime) returns the number of unexpired tokens at the given currentTime.

Note that if a token expires at time t, and another action happens on time t (renew or countUnexpiredTokens), the expiration takes place before the other actions.

Example 1:

Input
["AuthenticationManager", "renew", "generate", "countUnexpiredTokens", "generate", "renew", "renew", "countUnexpiredTokens"]
[[5], ["aaa", 1], ["aaa", 2], [6], ["bbb", 7], ["aaa", 8], ["bbb", 10], [15]]
Output
[null, null, null, 1, null, null, null, 0]

Explanation AuthenticationManager authenticationManager = new AuthenticationManager(5); // Constructs the AuthenticationManager with timeToLive = 5 seconds. authenticationManager.renew(“aaa”, 1); // No token exists with tokenId “aaa” at time 1, so nothing happens. authenticationManager.generate(“aaa”, 2); // Generates a new token with tokenId “aaa” at time 2. authenticationManager.countUnexpiredTokens(6); // The token with tokenId “aaa” is the only unexpired one at time 6, so return 1. authenticationManager.generate(“bbb”, 7); // Generates a new token with tokenId “bbb” at time 7. authenticationManager.renew(“aaa”, 8); // The token with tokenId “aaa” expired at time 7, and 8 >= 7, so at time 8 the renew request is ignored, and nothing happens. authenticationManager.renew(“bbb”, 10); // The token with tokenId “bbb” is unexpired at time 10, so the renew request is fulfilled and now the token will expire at time 15. authenticationManager.countUnexpiredTokens(15); // The token with tokenId “bbb” expires at time 15, and the token with tokenId “aaa” expired at time 7, so currently no token is unexpired, so return 0.

Constraints:

1 <= timeToLive <= 10⁸
1 <= currentTime <= 10⁸
1 <= tokenId.length <= 5
tokenId consists only of lowercase letters.
All calls to generate will contain unique values of tokenId.
The values of currentTime across all the function calls will be strictly increasing.
At most 2000 calls will be made to all functions combined.

Solution: Hashtable

Use a hashtable to store the token and its expiration time.

Time complexity: at most O(n) per operation
Space complexity: O(n)

C++

// Author: Huahua, 160 ms, 30.1 MB

class AuthenticationManager {

public:

AuthenticationManager(int timeToLive) : ttl_(timeToLive) {}

void generate(string tokenId, int currentTime) {

clear(currentTime);

tokens_[tokenId] = currentTime + ttl_;

}

void renew(string tokenId, int currentTime) {

clear(currentTime);

if (!tokens_.count(tokenId)) return;

tokens_[tokenId] = currentTime + ttl_;

}

int countUnexpiredTokens(int currentTime) {

clear(currentTime);

return tokens_.size();

}

private:

void clear(int currentTime) {

vector<string> ids;

for (const auto& [id, t] : tokens_)

if (t <= currentTime) ids.push_back(id);

for (const string& id : ids)

tokens_.erase(id);

}

unordered_map<string, int> tokens_;

int ttl_;

};

/**

* Your AuthenticationManager object will be instantiated and called as such:

* AuthenticationManager* obj = new AuthenticationManager(timeToLive);

* obj->generate(tokenId,currentTime);

* obj->renew(tokenId,currentTime);

* int param_3 = obj->countUnexpiredTokens(currentTime);

Huahua's Tech Road

LeetCode 1801. Number of Orders in the Backlog

Solution: Treemap / PriorityQueue / Heap

C++

花花酱 LeetCode 1800. Maximum Ascending Subarray Sum

Solution: Running sum with resetting

C++

花花酱 LeetCode 1799. Maximize Score After N Operations

Solution: Mask DP

C++

C++

花花酱 LeetCode 1798. Maximum Number of Consecutive Values You Can Make

Solution: Greedy + Math

C++

花花酱 LeetCode 1797. Design Authentication Manager

Solution: Hashtable

C++