Huahua’s Tech Road

花花酱 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;

}

};

花花酱 LeetCode 1694. Reformat Phone Number

By zxi on December 20, 2020

You are given a phone number as a string number. number consists of digits, spaces ' ', and/or dashes '-'.

You would like to reformat the phone number in a certain manner. Firstly, remove all spaces and dashes. Then, group the digits from left to right into blocks of length 3 until there are 4 or fewer digits. The final digits are then grouped as follows:

2 digits: A single block of length 2.
3 digits: A single block of length 3.
4 digits: Two blocks of length 2 each.

The blocks are then joined by dashes. Notice that the reformatting process should never produce any blocks of length 1 and produce at most two blocks of length 2.

Return the phone number after formatting.

Example 1:

Input: number = "1-23-45 6"
Output: "123-456"
Explanation: The digits are "123456".
Step 1: There are more than 4 digits, so group the next 3 digits. The 1st block is "123".
Step 2: There are 3 digits remaining, so put them in a single block of length 3. The 2nd block is "456".
Joining the blocks gives "123-456".

Example 2:

Input: number = "123 4-567"
Output: "123-45-67"
Explanation: The digits are "1234567".
Step 1: There are more than 4 digits, so group the next 3 digits. The 1st block is "123".
Step 2: There are 4 digits left, so split them into two blocks of length 2. The blocks are "45" and "67".
Joining the blocks gives "123-45-67".

Example 3:

Input: number = "123 4-5678"
Output: "123-456-78"
Explanation: The digits are "12345678".
Step 1: The 1st block is "123".
Step 2: The 2nd block is "456".
Step 3: There are 2 digits left, so put them in a single block of length 2. The 3rd block is "78".
Joining the blocks gives "123-456-78".

Example 4:

Input: number = "12"
Output: "12"

Example 5:

Input: number = "--17-5 229 35-39475 "
Output: "175-229-353-94-75"

Constraints:

2 <= number.length <= 100
number consists of digits and the characters '-' and ' '.
There are at least two digits in number.

Solution:

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

C++

// Author: Huahua

class Solution {

public:

string reformatNumber(string number) {

string ans;

const int total = count_if(begin(number), end(number),

[](char c) { return isdigit(c); });

int l = 0;

for (char c : number) {

if (!isdigit(c)) continue;

ans += c;

++l;

if ((l % 3 == 0 && total - l >= 4) ||

(total % 3 != 0 && total - l == 2)

|| (total % 3 == 0 && total - l == 3))

ans += "-";

}

return ans;

}

};

Huahua's Tech Road

花花酱 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++

花花酱 LeetCode 1694. Reformat Phone Number

Solution:

C++