Huahua’s Tech Road

花花酱 LeetCode 1701. Average Waiting Time

By zxi on December 26, 2020

There is a restaurant with a single chef. You are given an array customers, where customers[i] = [arrival_i, time_i]:

arrival_i is the arrival time of the i^th customer. The arrival times are sorted in non-decreasing order.
time_i is the time needed to prepare the order of the i^th customer.

When a customer arrives, he gives the chef his order, and the chef starts preparing it once he is idle. The customer waits till the chef finishes preparing his order. The chef does not prepare food for more than one customer at a time. The chef prepares food for customers in the order they were given in the input.

Return the average waiting time of all customers. Solutions within 10^-5 from the actual answer are considered accepted.

Example 1:

Input: customers = [[1,2],[2,5],[4,3]]
Output: 5.00000
Explanation:
1) The first customer arrives at time 1, the chef takes his order and starts preparing it immediately at time 1, and finishes at time 3, so the waiting time of the first customer is 3 - 1 = 2.
2) The second customer arrives at time 2, the chef takes his order and starts preparing it at time 3, and finishes at time 8, so the waiting time of the second customer is 8 - 2 = 6.
3) The third customer arrives at time 4, the chef takes his order and starts preparing it at time 8, and finishes at time 11, so the waiting time of the third customer is 11 - 4 = 7.
So the average waiting time = (2 + 6 + 7) / 3 = 5.

Example 2:

Input: customers = [[5,2],[5,4],[10,3],[20,1]]
Output: 3.25000
Explanation:
1) The first customer arrives at time 5, the chef takes his order and starts preparing it immediately at time 5, and finishes at time 7, so the waiting time of the first customer is 7 - 5 = 2.
2) The second customer arrives at time 5, the chef takes his order and starts preparing it at time 7, and finishes at time 11, so the waiting time of the second customer is 11 - 5 = 6.
3) The third customer arrives at time 10, the chef takes his order and starts preparing it at time 11, and finishes at time 14, so the waiting time of the third customer is 14 - 10 = 4.
4) The fourth customer arrives at time 20, the chef takes his order and starts preparing it immediately at time 20, and finishes at time 21, so the waiting time of the fourth customer is 21 - 20 = 1.
So the average waiting time = (2 + 6 + 4 + 1) / 4 = 3.25.

Constraints:

1 <= customers.length <= 10⁵
1 <= arrival_i, time_i <= 10⁴
arrival_i<= arrival_i+1

Solution: Simulation

When a customer arrives, if the arrival time is greater than current, then advance the clock to arrival time. Advance the clock by cooking time. Waiting time = current time – arrival time.

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

C++

// Author: Huahua

class Solution {

public:

double averageWaitingTime(vector<vector<int>>& customers) {

int t = 0;

double w = 0;

for (const auto& c : customers) {

if (c[0] > t) t = c[0];

t += c[1];

w += t - c[0];

}

return w / customers.size();

}

};

Python3

# Author: Huahua

class Solution:

def averageWaitingTime(self, customers: List[List[int]]) -> float:

cur = 0

waiting = 0

for arrival, time in customers:

cur = max(cur, arrival) + time

waiting += cur - arrival

return waiting / len(customers)

花花酱 LeetCode 1700. Number of Students Unable to Eat Lunch

By zxi on December 26, 2020

The school cafeteria offers circular and square sandwiches at lunch break, referred to by numbers 0 and 1 respectively. All students stand in a queue. Each student either prefers square or circular sandwiches.

The number of sandwiches in the cafeteria is equal to the number of students. The sandwiches are placed in a stack. At each step:

If the student at the front of the queue prefers the sandwich on the top of the stack, they will take it and leave the queue.
Otherwise, they will leave it and go to the queue’s end.

This continues until none of the queue students want to take the top sandwich and are thus unable to eat.

You are given two integer arrays students and sandwiches where sandwiches[i] is the type of the i^th sandwich in the stack (i = 0 is the top of the stack) and students[j] is the preference of the j^th student in the initial queue (j = 0 is the front of the queue). Return the number of students that are unable to eat.

Example 1:

Input: students = [1,1,0,0], sandwiches = [0,1,0,1]
Output: 0 
Explanation:
- Front student leaves the top sandwich and returns to the end of the line making students = [1,0,0,1].
- Front student leaves the top sandwich and returns to the end of the line making students = [0,0,1,1].
- Front student takes the top sandwich and leaves the line making students = [0,1,1] and sandwiches = [1,0,1].
- Front student leaves the top sandwich and returns to the end of the line making students = [1,1,0].
- Front student takes the top sandwich and leaves the line making students = [1,0] and sandwiches = [0,1].
- Front student leaves the top sandwich and returns to the end of the line making students = [0,1].
- Front student takes the top sandwich and leaves the line making students = [1] and sandwiches = [1].
- Front student takes the top sandwich and leaves the line making students = [] and sandwiches = [].
Hence all students are able to eat.

Example 2:

Input: students = [1,1,1,0,0,1], sandwiches = [1,0,0,0,1,1]
Output: 3

Constraints:

1 <= students.length, sandwiches.length <= 100
students.length == sandwiches.length
sandwiches[i] is 0 or 1.
students[i] is 0 or 1.

Solution 1: Simulation

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

C++

// Author: Huahua

class Solution {

public:

int countStudents(vector<int>& students, vector<int>& sandwiches) {

queue<int> q;

for (int s : students) q.push(s);

int c = 0;

int i = 0;

while (!q.empty()) {

int s = q.front(); q.pop();

if (s == sandwiches[i]) {

++i;

c = 0;

} else {

q.push(s);

}

if (++c > q.size()) break;

}

return q.size();

}

};

Solution 2: Counting

Count student’s preferences. Then process students from 1 to n, if there is no sandwich for current student then we can stop, since he/she will block all the students behind him/her.

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

C++

// Author: Huahua

class Solution {

public:

int countStudents(vector<int>& students, vector<int>& sandwiches) {

const int n = students.size();

vector<int> c(2);

for (int p : students) ++c[p];

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

if (--c[sandwiches[i]] < 0) return n - i;

return 0;

}

};

花花酱 LeetCode 1697. Checking Existence of Edge Length Limited Paths

By zxi on December 20, 2020

An undirected graph of n nodes is defined by edgeList, where edgeList[i] = [u_i, v_i, dis_i] denotes an edge between nodes u_i and v_i with distance dis_i. Note that there may be multiple edges between two nodes.

Given an array queries, where queries[j] = [p_j, q_j, limit_j], your task is to determine for each queries[j] whether there is a path between p_j and q_jsuch that each edge on the path has a distance strictly less than limit_j .

Return a boolean array answer, where answer.length == queries.length and the j^th value of answer is true if there is a path for queries[j] is true, and false otherwise.

Example 1:

Input: n = 3, edgeList = [[0,1,2],[1,2,4],[2,0,8],[1,0,16]], queries = [[0,1,2],[0,2,5]]
Output: [false,true]
Explanation: The above figure shows the given graph. Note that there are two overlapping edges between 0 and 1 with distances 2 and 16.
For the first query, between 0 and 1 there is no path where each distance is less than 2, thus we return false for this query.
For the second query, there is a path (0 -> 1 -> 2) of two edges with distances less than 5, thus we return true for this query.

Example 2:

Input: n = 5, edgeList = [[0,1,10],[1,2,5],[2,3,9],[3,4,13]], queries = [[0,4,14],[1,4,13]]
Output: [true,false]
Exaplanation: The above figure shows the given graph.

Constraints:

2 <= n <= 10⁵
1 <= edgeList.length, queries.length <= 10⁵
edgeList[i].length == 3
queries[j].length == 3
0 <= u_i, v_i, p_j, q_j <= n - 1
u_i != v_i
p_j != q_j
1 <= dis_i, limit_j <= 10⁹
There may be multiple edges between two nodes.

Solution: Union Find

Since queries are offline, we can reorder them to optimize time complexity. Answer queries by their limits in ascending order while union edges by weights up to the limit. In this case, we just need to go through the entire edge list at most once.

Time complexity: O(QlogQ + ElogE)
Space complexity: O(Q + E)

C++

// Author: Huahua

class Solution {

public:

vector<bool> distanceLimitedPathsExist(int n, vector<vector<int>>& E, vector<vector<int>>& Q) {

vector<int> parents(n);

iota(begin(parents), end(parents), 0);

function<int(int)> find = [&](int x) {

return parents[x] == x ? x : parents[x] = find(parents[x]);

};

const int m = Q.size();

for (int i = 0; i < m; ++i) Q[i].push_back(i);

// Sort edges by weight in ascending order.

sort(begin(E), end(E), [](const auto& a, const auto& b) { return a[2] < b[2]; });

// Sort queries by limit in ascending order

sort(begin(Q), end(Q), [](const auto& a, const auto& b) { return a[2] < b[2]; });

vector<bool> ans(m);

int i = 0;

for (const auto& q : Q) {

while (i < E.size() && E[i][2] < q[2])

parents[find(E[i++][0])] = find(E[i][1]);

ans[q[3]] = find(q[0]) == find(q[1]);

}

return ans;

}

};

花花酱 LeetCode 1696. Jump Game VI

By zxi on December 20, 2020

You are given a 0-indexed integer array nums and an integer k.

You are initially standing at index 0. In one move, you can jump at most k steps forward without going outside the boundaries of the array. That is, you can jump from index i to any index in the range [i + 1, min(n - 1, i + k)] inclusive.

You want to reach the last index of the array (index n - 1). Your score is the sum of all nums[j] for each index j you visited in the array.

Return the maximum score you can get.

Example 1:

Input: nums = [1,-1,-2,4,-7,3], k = 2
Output: 7
Explanation: You can choose your jumps forming the subsequence [1,-1,4,3] (underlined above). The sum is 7.

Example 2:

Input: nums = [10,-5,-2,4,0,3], k = 3
Output: 17
Explanation: You can choose your jumps forming the subsequence [10,4,3] (underlined above). The sum is 17.

Example 3:

Input: nums = [1,-5,-20,4,-1,3,-6,-3], k = 2
Output: 0

Constraints:

1 <= nums.length, k <= 10⁵
-10⁴ <= nums[i] <= 10⁴

Solution: DP + Monotonic Queue

dp[i] = nums[i] + max(dp[j]) i – k <= j < i

Brute force time complexity: O(n*k) => TLE

Python3 / TLE

# Author: Huahua 52/58 Passed (TLE)

class Solution:

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

@lru_cache(None)

def dp(i: int) -> int:

return nums[0] if i == 0 else nums[i] + max(dp(j) for j in range(max(0, i - k), i))

return dp(len(nums) - 1)

This problem can be reduced to find the maximum for a sliding window that can be solved by monotonic queue.

Time complexity: O(n)
Space complexity: O(n+k) -> O(k)

C++

// Author: Huahua

class Solution {

public:

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

const int n = nums.size();

vector<int> dp(n);

deque<int> q{{0}};

dp[0] = nums[0];

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

dp[i] = nums[i] + dp[q.front()];

while (!q.empty() && dp[i] >= dp[q.back()]) q.pop_back();

while (!q.empty() && i - q.front() >= k) q.pop_front();

q.push_back(i);

}

return dp[n - 1];

}

};

C++/O(n) Space

// Author: Huahua

class Solution {

public:

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

const int n = nums.size();

deque<pair<int, int>> q{{nums[0], 0}};

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

const int cur = nums[i] + q.front().first;

while (!q.empty() && cur >= q.back().first)

q.pop_back();

while (!q.empty() && i - q.front().second >= k)

q.pop_front();

q.emplace_back(cur, i);

}

for (const auto& [v, i] : q)

if (i == n - 1) return v;

return 0;

}

};

花花酱 LeetCode 1695. Maximum Erasure Value

By zxi on December 20, 2020

You are given an array of positive integers nums and want to erase a subarray containing unique elements. The score you get by erasing the subarray is equal to the sum of its elements.

Return the maximum score you can get by erasing exactly one subarray.

An array b is called to be a subarray of a if it forms a contiguous subsequence of a, that is, if it is equal to a[l],a[l+1],...,a[r] for some (l,r).

Example 1:

Input: nums = [4,2,4,5,6]
Output: 17
Explanation: The optimal subarray here is [2,4,5,6].

Example 2:

Input: nums = [5,2,1,2,5,2,1,2,5]
Output: 8
Explanation: The optimal subarray here is [5,2,1] or [1,2,5].

Constraints:

1 <= nums.length <= 10⁵
1 <= nums[i] <= 10⁴

Solution: Sliding window + Hashset

Maintain a window that has no duplicate elements.

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

C++

// Author: Huahua

class Solution {

public:

int maximumUniqueSubarray(vector<int>& nums) {

const int n = nums.size();

unordered_set<int> t;

int ans = 0;

for (int l = 0, r = 0, s = 0; r < n; ++r) {

while (t.count(nums[r]) && l < r) {

s -= nums[l];

t.erase(nums[l++]);

}

t.insert(nums[r]);

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

}

return ans;

}

};

Huahua's Tech Road

花花酱 LeetCode 1701. Average Waiting Time

Solution: Simulation

C++

Python3

花花酱 LeetCode 1700. Number of Students Unable to Eat Lunch

Solution 1: Simulation

C++

Solution 2: Counting

C++

花花酱 LeetCode 1697. Checking Existence of Edge Length Limited Paths

Solution: Union Find

C++

花花酱 LeetCode 1696. Jump Game VI

Solution: DP + Monotonic Queue

Python3 / TLE

C++

C++/O(n) Space

花花酱 LeetCode 1695. Maximum Erasure Value

Solution: Sliding window + Hashset

C++