Huahua’s Tech Road

花花酱 LeetCode 1674. Minimum Moves to Make Array Complementary

By zxi on November 29, 2020

You are given an integer array nums of even length n and an integer limit. In one move, you can replace any integer from nums with another integer between 1 and limit, inclusive.

The array nums is complementary if for all indices i (0-indexed), nums[i] + nums[n - 1 - i] equals the same number. For example, the array [1,2,3,4] is complementary because for all indices i, nums[i] + nums[n - 1 - i] = 5.

Return the minimum number of moves required to make nums complementary.

Example 1:

Input: nums = [1,2,4,3], limit = 4
Output: 1
Explanation: In 1 move, you can change nums to [1,2,2,3] (underlined elements are changed).
nums[0] + nums[3] = 1 + 3 = 4.
nums[1] + nums[2] = 2 + 2 = 4.
nums[2] + nums[1] = 2 + 2 = 4.
nums[3] + nums[0] = 3 + 1 = 4.
Therefore, nums[i] + nums[n-1-i] = 4 for every i, so nums is complementary.

Example 2:

Input: nums = [1,2,2,1], limit = 2
Output: 2
Explanation: In 2 moves, you can change nums to [2,2,2,2]. You cannot change any number to 3 since 3 > limit.

Example 3:

Input: nums = [1,2,1,2], limit = 2
Output: 0
Explanation: nums is already complementary.

Constraints:

n == nums.length
2 <= n <= 10⁵
1 <= nums[i] <= limit <= 10⁵
n is even.

Solution: Sweep Line / Prefix Sum

Let a = min(nums[i], nums[n-i-1]), b = max(nums[i], nums[n-i-1])
The key to this problem is how many moves do we need to make a + b == T.

if 2 <= T < a + 1, two moves, lower both a and b.
if a +1 <= T < a + b, one move, lower b
if a + b == T, zero move
if a + b + 1 <= T < b + limit + 1, one move, increase a
if b + limit + 1 <= T <= 2*limit, two moves, increase both a and b.

Time complexity: O(n + limit) or O(nlogn) if limit >>n
Space complexity: O(limit) or O(n)

C++

// Author: Huahua

class Solution {

public:

int minMoves(vector<int>& nums, int limit) {

const int n = nums.size();

vector<int> delta(limit * 2 + 2);

for (int i = 0; i < n / 2; ++i) {

const int a = min(nums[i], nums[n - i - 1]);

const int b = max(nums[i], nums[n - i - 1]);

delta[2] += 2; // dec a, dec b

--delta[a + 1]; // dec a

--delta[a + b]; // no op

++delta[a + b + 1]; // inc a

++delta[b + limit + 1]; // inc a, inc b

}

int ans = n;

for (int t = 2, cur = 0; t <= limit * 2; ++t) {

cur += delta[t];

ans = min(ans, cur);

}

return ans;

}

};

花花酱 LeetCode 1673. Find the Most Competitive Subsequence

By zxi on November 29, 2020

Given an integer array nums and a positive integer k, return the most competitive subsequence of nums of size k.

An array’s subsequence is a resulting sequence obtained by erasing some (possibly zero) elements from the array.

We define that a subsequence a is more competitive than a subsequence b (of the same length) if in the first position where a and b differ, subsequence a has a number less than the corresponding number in b. For example, [1,3,4] is more competitive than [1,3,5] because the first position they differ is at the final number, and 4 is less than 5.

Example 1:

Input: nums = [3,5,2,6], k = 2
Output: [2,6]
Explanation: Among the set of every possible subsequence: {[3,5], [3,2], [3,6], [5,2], [5,6], [2,6]}, [2,6] is the most competitive.

Example 2:

Input: nums = [2,4,3,3,5,4,9,6], k = 4
Output: [2,3,3,4]

Constraints:

1 <= nums.length <= 10⁵
0 <= nums[i] <= 10⁹
1 <= k <= nums.length

Solution: Stack

Use a stack to track the best solution so far, pop if the current number is less than the top of the stack and there are sufficient numbers left. Then push the current number to the stack if not full.

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

C++

// Author: Huahua

class Solution {

public:

vector<int> mostCompetitive(vector<int>& nums, int k) {

const int n = nums.size();

vector<int> ans(k);

int c = 0;

for (int i = 0; i < n; ++i) {

while (c && ans[c - 1] > nums[i] && c + n - i - 1 >= k)

--c;

if (c < k) ans[c++] = nums[i];

}

return ans;

}

};

Java

// Author: Huahua

class Solution {

public int[] mostCompetitive(int[] nums, int k) {

int n = nums.length;

int[] ans = new int[k];

int c = 0;

for (int i = 0; i < n; ++i) {

while (c > 0 && ans[c - 1] > nums[i] && c + n - i - 1 >= k)

--c;

if (c < k) ans[c++] = nums[i];

}

return ans;

}

Python3

# Author: Huahua

class Solution:

def mostCompetitive(self, nums: List[int], k: int) -> List[int]:

ans = [None] * k

n = len(nums)

c = 0

for i, x in enumerate(nums):

while c and ans[c - 1] > x and c + n - i - 1 >= k:

c -= 1

if c < k:

ans[c] = x

c += 1

return ans

花花酱 LeetCode 1672. Richest Customer Wealth

By zxi on November 29, 2020

You are given an m x n integer grid accounts where accounts[i][j] is the amount of money the i^th customer has in the j^th bank. Return the wealth that the richest customer has.

A customer’s wealth is the amount of money they have in all their bank accounts. The richest customer is the customer that has the maximum wealth.

Example 1:

Input: accounts = [[1,2,3],[3,2,1]]
Output: 6
Explanation:
1st customer has wealth = 1 + 2 + 3 = 6
2nd customer has wealth = 3 + 2 + 1 = 6
Both customers are considered the richest with a wealth of 6 each, so return 6.

Example 2:

Input: accounts = [[1,5],[7,3],[3,5]]
Output: 10
Explanation: 
1st customer has wealth = 6
2nd customer has wealth = 10 
3rd customer has wealth = 8
The 2nd customer is the richest with a wealth of 10.

Example 3:

Input: accounts = [[2,8,7],[7,1,3],[1,9,5]]
Output: 17

Constraints:

m == accounts.length
n == accounts[i].length
1 <= m, n <= 50
1 <= accounts[i][j] <= 100

Solution: Sum each row up

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

C++

// Author: Huahua

class Solution {

public:

int maximumWealth(vector<vector<int>>& accounts) {

int ans = 0;

for (const vector<int>& row : accounts)

ans = max(ans, accumulate(begin(row), end(row), 0));

return ans;

}

};

Python3

# Author: Huahua

class Solution:

def maximumWealth(self, accounts: List[List[int]]) -> int:

return max(sum(account) for account in accounts)

花花酱 LeetCode 1671. Minimum Number of Removals to Make Mountain Array

By zxi on November 28, 2020

You may recall that an array arr is a mountain array if and only if:

arr.length >= 3
There exists some index i (0-indexed) with 0 < i < arr.length - 1 such that:
- arr[0] < arr[1] < ... < arr[i - 1] < arr[i]
- arr[i] > arr[i + 1] > ... > arr[arr.length - 1]

Given an integer array nums, return the minimum number of elements to remove to make numsa mountain array.

Example 1:

Input: nums = [1,3,1]
Output: 0
Explanation: The array itself is a mountain array so we do not need to remove any elements.

Example 2:

Input: nums = [2,1,1,5,6,2,3,1]
Output: 3
Explanation: One solution is to remove the elements at indices 0, 1, and 5, making the array nums = [1,5,6,3,1].

Example 3:

Input: nums = [4,3,2,1,1,2,3,1]
Output: 4

Example 4:

Input: nums = [1,2,3,4,4,3,2,1]
Output: 1

Constraints:

3 <= nums.length <= 1000
1 <= nums[i] <= 10⁹
It is guaranteed that you can make a mountain array out of nums.

Solution: DP / LIS

LIS[i] := longest increasing subsequence ends with nums[i]
LDS[i] := longest decreasing subsequence starts with nums[i]
Let nums[i] be the peak, the length of the mountain array is LIS[i] + LDS[i] – 1
Note: LIS[i] and LDS[i] must be > 1 to form a valid mountain array.
ans = min(n – (LIS[i] + LDS[i] – 1)) 0 <= i < n

Time complexity: O(n^2)
Space complexity: O(n)

C++

// Author: Huahua

class Solution {

public:

int minimumMountainRemovals(vector<int>& nums) {

const int n = nums.size();

vector<int> LIS(n, 1); // LIS[i] := Longest increasing subseq ends with nums[i]

vector<int> LDS(n, 1); // LDS[i] := Longest decreasing subseq starts with nums[i]

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

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

if (nums[i] > nums[j]) LIS[i] = max(LIS[i], LIS[j] + 1);

for (int i = n - 1; i >= 0; --i)

for (int j = n - 1; j > i; --j)

if (nums[i] > nums[j]) LDS[i] = max(LDS[i], LDS[j] + 1);

int ans = INT_MAX;

for (int i = 0; i < n; ++i) {

if (LIS[i] < 2 || LDS[i] < 2) continue;

ans = min(ans, n - (LIS[i] + LDS[i] - 1));

}

return ans;

}

};

花花酱 LeetCode 1670. Design Front Middle Back Queue

By zxi on November 28, 2020

Design a queue that supports push and pop operations in the front, middle, and back.

Implement the FrontMiddleBack class:

FrontMiddleBack() Initializes the queue.
void pushFront(int val) Adds val to the front of the queue.
void pushMiddle(int val) Adds val to the middle of the queue.
void pushBack(int val) Adds val to the back of the queue.
int popFront() Removes the front element of the queue and returns it. If the queue is empty, return -1.
int popMiddle() Removes the middle element of the queue and returns it. If the queue is empty, return -1.
int popBack() Removes the back element of the queue and returns it. If the queue is empty, return -1.

Notice that when there are two middle position choices, the operation is performed on the frontmost middle position choice. For example:

Pushing 6 into the middle of [1, 2, 3, 4, 5] results in [1, 2, 6, 3, 4, 5].
Popping the middle from [1, 2, 3, 4, 5, 6] returns 3 and results in [1, 2, 4, 5, 6].

Example 1:

Input:
["FrontMiddleBackQueue", "pushFront", "pushBack", "pushMiddle", "pushMiddle", "popFront", "popMiddle", "popMiddle", "popBack", "popFront"]
[[], [1], [2], [3], [4], [], [], [], [], []]
Output:
[null, null, null, null, null, 1, 3, 4, 2, -1]
Explanation:
FrontMiddleBackQueue q = new FrontMiddleBackQueue();
q.pushFront(1);   // [1]
q.pushBack(2);    // [1, 2]
q.pushMiddle(3);  // [1, 3, 2]
q.pushMiddle(4);  // [1, 4, 3, 2]
q.popFront();     // return 1 -> [4, 3, 2]
q.popMiddle();    // return 3 -> [4, 2]
q.popMiddle();    // return 4 -> [2]
q.popBack();      // return 2 -> []
q.popFront();     // return -1 -> [] (The queue is empty)

Constraints:

1 <= val <= 10⁹
At most 1000 calls will be made to pushFront, pushMiddle, pushBack, popFront, popMiddle, and popBack.

Solution: List + Middle Iterator

Time complexity: O(1) per op
Space complexity: O(n) in total

C++

// Author: Huahua

class FrontMiddleBackQueue {

public:

FrontMiddleBackQueue() {}

void pushFront(int val) {

q_.push_front(val);

updateMit(even() ? -1 : 0);

}

void pushMiddle(int val) {

if (q_.empty())

q_.push_back(val);

else

q_.insert(even() ? next(mit_) : mit_, val);

updateMit(even() ? -1 : 1);

}

void pushBack(int val) {

q_.push_back(val);

updateMit(even() ? 0 : 1);

}

int popFront() {

if (q_.empty()) return -1;

int val = q_.front();

q_.pop_front();

updateMit(even() ? 0 : 1);

return val;

}

int popMiddle() {

if (q_.empty()) return -1;

int val = *mit_;

mit_ = q_.erase(mit_);

updateMit(even() ? -1 : 0);

return val;

}

int popBack() {

if (q_.empty()) return -1;

int val = q_.back();

q_.pop_back();

updateMit(even() ? -1 : 0);

return val;

}

private:

void updateMit(int delta) {

if (q_.size() <= 1) {

mit_ = begin(q_);

} else {

if (delta > 0) ++mit_;

if (delta < 0) --mit_;

}

bool even() const { return q_.size() % 2 == 0; }

list<int> q_;

list<int>::iterator mit_;

};

Huahua's Tech Road

花花酱 LeetCode 1674. Minimum Moves to Make Array Complementary

Solution: Sweep Line / Prefix Sum

C++

花花酱 LeetCode 1673. Find the Most Competitive Subsequence

Solution: Stack

C++

Java

Python3

花花酱 LeetCode 1672. Richest Customer Wealth

Solution: Sum each row up

C++

Python3

花花酱 LeetCode 1671. Minimum Number of Removals to Make Mountain Array

Solution: DP / LIS

C++

花花酱 LeetCode 1670. Design Front Middle Back Queue

Solution: List + Middle Iterator

C++