Posts tagged as “medium”

花花酱 LeetCode 1962. Remove Stones to Minimize the Total

By zxi on December 31, 2021

You are given a 0-indexed integer array piles, where piles[i] represents the number of stones in the i^th pile, and an integer k. You should apply the following operation exactly k times:

Choose any piles[i] and remove floor(piles[i] / 2) stones from it.

Notice that you can apply the operation on the same pile more than once.

Return the minimum possible total number of stones remaining after applying the k operations.

floor(x) is the greatest integer that is smaller than or equal to x (i.e., rounds x down).

Example 1:

Input: piles = [5,4,9], k = 2
Output: 12
Explanation: Steps of a possible scenario are:
- Apply the operation on pile 2. The resulting piles are [5,4,5].
- Apply the operation on pile 0. The resulting piles are [3,4,5].
The total number of stones in [3,4,5] is 12.

Example 2:

Input: piles = [4,3,6,7], k = 3
Output: 12
Explanation: Steps of a possible scenario are:
- Apply the operation on pile 2. The resulting piles are [4,3,3,7].
- Apply the operation on pile 3. The resulting piles are [4,3,3,4].
- Apply the operation on pile 0. The resulting piles are [2,3,3,4].
The total number of stones in [2,3,3,4] is 12.

Constraints:

1 <= piles.length <= 10⁵
1 <= piles[i] <= 10⁴
1 <= k <= 10⁵

Solution: Greedy / Heap

Always choose the largest pile to remove.

Time complexity: O(n + klogn)
Space complexity: O(n)

C++

// Author: Huahua

class Solution {

public:

int minStoneSum(vector<int>& piles, int k) {

int total = accumulate(begin(piles), end(piles), 0);

priority_queue<int> q(begin(piles), end(piles));

while (k--) {

int curr = q.top(); q.pop();

int remove = curr / 2;

total -= remove;

q.push(curr - remove);

}

return total;

}

};

花花酱 LeetCode 1953. Maximum Number of Weeks for Which You Can Work

By zxi on December 31, 2021

There are n projects numbered from 0 to n - 1. You are given an integer array milestones where each milestones[i] denotes the number of milestones the i^th project has.

You can work on the projects following these two rules:

Every week, you will finish exactly one milestone of one project. You must work every week.
You cannot work on two milestones from the same project for two consecutive weeks.

Once all the milestones of all the projects are finished, or if the only milestones that you can work on will cause you to violate the above rules, you will stop working. Note that you may not be able to finish every project’s milestones due to these constraints.

Return the maximum number of weeks you would be able to work on the projects without violating the rules mentioned above.

Example 1:

Input: milestones = [1,2,3]
Output: 6
Explanation: One possible scenario is:
- During the 1^st week, you will work on a milestone of project 0.
- During the 2^nd week, you will work on a milestone of project 2.
- During the 3^rd week, you will work on a milestone of project 1.
- During the 4^th week, you will work on a milestone of project 2.
- During the 5^th week, you will work on a milestone of project 1.
- During the 6^th week, you will work on a milestone of project 2.
The total number of weeks is 6.

Example 2:

Input: milestones = [5,2,1]
Output: 7
Explanation: One possible scenario is:
- During the 1^st week, you will work on a milestone of project 0.
- During the 2^nd week, you will work on a milestone of project 1.
- During the 3^rd week, you will work on a milestone of project 0.
- During the 4^th week, you will work on a milestone of project 1.
- During the 5^th week, you will work on a milestone of project 0.
- During the 6^th week, you will work on a milestone of project 2.
- During the 7^th week, you will work on a milestone of project 0.
The total number of weeks is 7.
Note that you cannot work on the last milestone of project 0 on 8^th week because it would violate the rules.
Thus, one milestone in project 0 will remain unfinished.

Constraints:

n == milestones.length
1 <= n <= 10⁵
1 <= milestones[i] <= 10⁹

Solution: Math

Let x be the longest project.

Case 1: x > sum of the rest.

Obviously, we cannot finish it.
The best we can do is : [x, a}, {x, b}, {x, c}, …., {x, z}, x.
Ans = 2 * rest + 1

Case 2: x <= sum of the rest.

We can finish all the projects by alternating them properly.
Ans = sum

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

C++

// Author: Huahua

class Solution {

public:

long long numberOfWeeks(vector<int>& milestones) {

long long sum = accumulate(begin(milestones), end(milestones), 0LL);

long long longest = *max_element(begin(milestones), end(milestones));

return min(sum, 2 * (sum - longest) + 1);

}

};

花花酱 LeetCode 1946. Largest Number After Mutating Substring

By zxi on December 31, 2021

You are given a string num, which represents a large integer. You are also given a 0-indexed integer array change of length 10 that maps each digit 0-9 to another digit. More formally, digit d maps to digit change[d].

You may choose to mutate a single substring of num. To mutate a substring, replace each digit num[i] with the digit it maps to in change (i.e. replace num[i] with change[num[i]]).

Return a string representing the largest possible integer after mutating (or choosing not to) a single substring of num.

A substring is a contiguous sequence of characters within the string.

Example 1:

Input: num = "132", change = [9,8,5,0,3,6,4,2,6,8]
Output: "832"
Explanation: Replace the substring "1":
- 1 maps to change[1] = 8.
Thus, "132" becomes "832".
"832" is the largest number that can be created, so return it.

Example 2:

Input: num = "021", change = [9,4,3,5,7,2,1,9,0,6]
Output: "934"
Explanation: Replace the substring "021":
- 0 maps to change[0] = 9.
- 2 maps to change[2] = 3.
- 1 maps to change[1] = 4.
Thus, "021" becomes "934".
"934" is the largest number that can be created, so return it.

Example 3:

Input: num = "5", change = [1,4,7,5,3,2,5,6,9,4]
Output: "5"
Explanation: "5" is already the largest number that can be created, so return it.

Constraints:

1 <= num.length <= 10⁵
num consists of only digits 0-9.
change.length == 10
0 <= change[d] <= 9

Solution: Greedy

Find the first digit that is less equal to the mutated one as the start of the substring, keep replacing as long as mutated >= current.

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

C++

// Author: Huahua

class Solution {

public:

string maximumNumber(string num, vector<int>& change) {

const int n = num.size();

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

if (num[i] - '0' < change[num[i] - '0']) {

for (int j = i; j < n && num[j] - '0' <= change[num[j] - '0']; ++j)

num[j] = change[num[j] - '0'] + '0';

break;

}

return num;

}

};

花花酱 LeetCode 1942. The Number of the Smallest Unoccupied Chair

By zxi on December 31, 2021

There is a party where n friends numbered from 0 to n - 1 are attending. There is an infinite number of chairs in this party that are numbered from 0 to infinity. When a friend arrives at the party, they sit on the unoccupied chair with the smallest number.

For example, if chairs 0, 1, and 5 are occupied when a friend comes, they will sit on chair number 2.

When a friend leaves the party, their chair becomes unoccupied at the moment they leave. If another friend arrives at that same moment, they can sit in that chair.

You are given a 0-indexed 2D integer array times where times[i] = [arrival_i, leaving_i], indicating the arrival and leaving times of the i^th friend respectively, and an integer targetFriend. All arrival times are distinct.

Return the chair number that the friend numbered targetFriend will sit on.

Example 1:

Input: times = [[1,4],[2,3],[4,6]], targetFriend = 1
Output: 1
Explanation: 
- Friend 0 arrives at time 1 and sits on chair 0.
- Friend 1 arrives at time 2 and sits on chair 1.
- Friend 1 leaves at time 3 and chair 1 becomes empty.
- Friend 0 leaves at time 4 and chair 0 becomes empty.
- Friend 2 arrives at time 4 and sits on chair 0.
Since friend 1 sat on chair 1, we return 1.

Example 2:

Input: times = [[3,10],[1,5],[2,6]], targetFriend = 0
Output: 2
Explanation: 
- Friend 1 arrives at time 1 and sits on chair 0.
- Friend 2 arrives at time 2 and sits on chair 1.
- Friend 0 arrives at time 3 and sits on chair 2.
- Friend 1 leaves at time 5 and chair 0 becomes empty.
- Friend 2 leaves at time 6 and chair 1 becomes empty.
- Friend 0 leaves at time 10 and chair 2 becomes empty.
Since friend 0 sat on chair 2, we return 2.

Constraints:

n == times.length
2 <= n <= 10⁴
times[i].length == 2
1 <= arrival_i < leaving_i <= 10⁵
0 <= targetFriend <= n - 1
Each arrival_i time is distinct.

Solution: Treeset + Simulation

Use a treeset to track available chairs, sort events by time.
note: process leaving events first.

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

C++

// Author: Huahua

class Solution {

public:

int smallestChair(vector<vector<int>>& times, int targetFriend) {

const int n = times.size();

vector<pair<int, int>> arrival(n);

vector<pair<int, int>> leaving(n);

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

arrival[i] = {times[i][0], i};

leaving[i] = {times[i][1], i};

}

vector<int> pos(n);

iota(begin(pos), end(pos), 0); // pos = [0, 1, ..., n -1]

set<int> aval(begin(pos), end(pos));

sort(begin(arrival), end(arrival));

sort(begin(leaving), end(leaving));

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

const auto [t, u] = arrival[i];

while (j < n && leaving[j].first <= t)

aval.insert(pos[leaving[j++].second]);

aval.erase(pos[u] = *begin(aval));

if (u == targetFriend) return pos[u];

}

return -1;

}

};

花花酱 LeetCode 1936. Add Minimum Number of Rungs

By zxi on December 31, 2021

You are given a strictly increasing integer array rungs that represents the height of rungs on a ladder. You are currently on the floor at height 0, and you want to reach the last rung.

You are also given an integer dist. You can only climb to the next highest rung if the distance between where you are currently at (the floor or on a rung) and the next rung is at most dist. You are able to insert rungs at any positive integer height if a rung is not already there.

Return the minimum number of rungs that must be added to the ladder in order for you to climb to the last rung.

Example 1:

Input: rungs = [1,3,5,10], dist = 2
Output: 2
Explanation:
You currently cannot reach the last rung.
Add rungs at heights 7 and 8 to climb this ladder. 
The ladder will now have rungs at [1,3,5,7,8,10].

Example 2:

Input: rungs = [3,6,8,10], dist = 3
Output: 0
Explanation:
This ladder can be climbed without adding additional rungs.

Example 3:

Input: rungs = [3,4,6,7], dist = 2
Output: 1
Explanation:
You currently cannot reach the first rung from the ground.
Add a rung at height 1 to climb this ladder.
The ladder will now have rungs at [1,3,4,6,7].

Constraints:

1 <= rungs.length <= 10⁵
1 <= rungs[i] <= 10⁹
1 <= dist <= 10⁹
rungs is strictly increasing.

Solution: Math

Check two consecutive rungs, if their diff is > dist, we need insert (diff – 1) / dist rungs in between.
ex1 5 -> 11, diff = 6, dist = 2, (diff – 1) / dist = (6 – 1) / 2 = 2. => 5, 7, 9, 11.
ex2 0 -> 3, diff = 3, dist = 1, (diff – 1) / dist = (3 – 1) / 1 = 2 => 0, 1, 2, 3

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

C++

// Author: Huahua

class Solution {

public:

int addRungs(vector<int>& rungs, int dist) {

int ans = 0;

for (size_t i = 0; i < rungs.size(); ++i)

ans += (rungs[i] - (i ? rungs[i - 1] : 0) - 1) / dist;

return ans;

}

};

Python3

# Author: Huahua

class Solution:

def addRungs(self, rungs: List[int], dist: int) -> int:

return sum((r - 1 - (rungs[i - 1] if i else 0)) // dist for i, r in enumerate(rungs))