Posts tagged as “medium”

花花酱 LeetCode 1824. Minimum Sideway Jumps

By zxi on April 13, 2021

There is a 3 lane road of length n that consists of n + 1 points labeled from 0 to n. A frog starts at point 0 in the second laneand wants to jump to point n. However, there could be obstacles along the way.

You are given an array obstacles of length n + 1 where each obstacles[i] (ranging from 0 to 3) describes an obstacle on the lane obstacles[i] at point i. If obstacles[i] == 0, there are no obstacles at point i. There will be at most one obstacle in the 3 lanes at each point.

For example, if obstacles[2] == 1, then there is an obstacle on lane 1 at point 2.

The frog can only travel from point i to point i + 1 on the same lane if there is not an obstacle on the lane at point i + 1. To avoid obstacles, the frog can also perform a side jump to jump to another lane (even if they are not adjacent) at the same point if there is no obstacle on the new lane.

For example, the frog can jump from lane 3 at point 3 to lane 1 at point 3.

Return the minimum number of side jumps the frog needs to reach any lane at point n starting from lane 2 at point 0.

Note: There will be no obstacles on points 0 and n.

Example 1:

Input: obstacles = [0,1,2,3,0]
Output: 2 
Explanation: The optimal solution is shown by the arrows above. There are 2 side jumps (red arrows).
Note that the frog can jump over obstacles only when making side jumps (as shown at point 2).

Example 2:

Input: obstacles = [0,1,1,3,3,0]
Output: 0
Explanation: There are no obstacles on lane 2. No side jumps are required.

Example 3:

Input: obstacles = [0,2,1,0,3,0]
Output: 2
Explanation: The optimal solution is shown by the arrows above. There are 2 side jumps.

Constraints:

obstacles.length == n + 1
1 <= n <= 5 * 10⁵
0 <= obstacles[i] <= 3
obstacles[0] == obstacles[n] == 0

Solution: DP

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

C++

class Solution {

public:

int minSideJumps(vector<int>& obstacles) {

const int n = obstacles.size();

vector<vector<int>> dp(3, vector<int>(n, INT_MAX / 2));

dp[1][0] = 0;

dp[0][0] = dp[2][0] = 1;

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

for (int k = 0; k < 3; ++k)

if (obstacles[i] != k + 1)

dp[k][i] = dp[k][i - 1];

for (int k = 0; k < 3; ++k)

if (obstacles[i] != k + 1)

dp[k][i] = min({dp[k][i],

dp[(k + 1) % 3][i] + 1,

dp[(k + 2) % 3][i] + 1});

}

return min({dp[0].back(), dp[1].back(), dp[2].back()});

}

};

C++/O(1) Space

class Solution {

public:

int minSideJumps(vector<int>& obstacles) {

const int n = obstacles.size();

vector<int> dp{1, 0, 1};

for (int o : obstacles) {

if (o) dp[o - 1] = 1e9;

for (int k = 0; k < 3; ++k) {

if (k == o - 1) continue;

dp[k] = min({dp[k],

dp[(k + 1) % 3] + 1,

dp[(k + 2) % 3] + 1});

}

return *min_element(begin(dp), end(dp));

}

};

花花酱 LeetCode 1818. Minimum Absolute Sum Difference

By zxi on April 6, 2021

You are given two positive integer arrays nums1 and nums2, both of length n.

The absolute sum difference of arrays nums1 and nums2 is defined as the sum of |nums1[i] - nums2[i]| for each 0 <= i < n (0-indexed).

You can replace at most one element of nums1 with any other element in nums1 to minimize the absolute sum difference.

Return the minimum absolute sum difference after replacing at most oneelement in the array nums1. Since the answer may be large, return it modulo 10⁹ + 7.

|x| is defined as:

x if x >= 0, or
-x if x < 0.

Example 1:

Input: nums1 = [1,7,5], nums2 = [2,3,5]
Output: 3
Explanation: There are two possible optimal solutions:
- Replace the second element with the first: [1,7,5] => [1,1,5], or
- Replace the second element with the third: [1,7,5] => [1,5,5].
Both will yield an absolute sum difference of |1-2| + (|1-3| or |5-3|) + |5-5| = 3.

Example 2:

Input: nums1 = [2,4,6,8,10], nums2 = [2,4,6,8,10]
Output: 0
Explanation: nums1 is equal to nums2 so no replacement is needed. This will result in an 
absolute sum difference of 0.

Example 3:

Input: nums1 = [1,10,4,4,2,7], nums2 = [9,3,5,1,7,4]
Output: 20
Explanation: Replace the first element with the second: [1,10,4,4,2,7] => [10,10,4,4,2,7].
This yields an absolute sum difference of |10-9| + |10-3| + |4-5| + |4-1| + |2-7| + |7-4| = 20

Constraints:

n == nums1.length
n == nums2.length
1 <= n <= 10⁵
1 <= nums1[i], nums2[i] <= 10⁵

Solution: Binary Search

Greedy won’t work, e.g. finding the max diff pair and replace it. Counter example:
nums1 = [7, 5], nums2 = [1, -2]
pair1 = abs(7 – 1) = 6
pair2 = abs(5 – (-2)) = 7
If we replace 5 with 7, we got pair2′ = abs(7 – (-2)) = 9 > 7.

Every pair of numbers can be the candidate, we just need to find the closest number for each nums2[i].

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

C++

class Solution {

public:

int minAbsoluteSumDiff(vector<int>& nums1, vector<int>& nums2) {

constexpr int kMod = 1e9 + 7;

const int n = nums1.size();

long ans = 0;

int gain = 0;

set<int> s(begin(nums1), end(nums1));

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

const int diff = abs(nums1[i] - nums2[i]);

ans += diff;

if (diff <= gain) continue;

auto it = s.lower_bound(nums2[i]);

if (it != s.end())

gain = max(gain, diff - abs(*it - nums2[i]));

if (it != s.begin())

gain = max(gain, diff - abs(*prev(it) - nums2[i]));

}

return (ans - gain) % kMod;

}

};

花花酱 LeetCode 1817. Finding the Users Active Minutes

By zxi on April 6, 2021

You are given the logs for users’ actions on LeetCode, and an integer k. The logs are represented by a 2D integer array logs where each logs[i] = [ID_i, time_i] indicates that the user with ID_i performed an action at the minute time_i.

Multiple users can perform actions simultaneously, and a single user can perform multiple actions in the same minute.

The user active minutes (UAM) for a given user is defined as the number of unique minutes in which the user performed an action on LeetCode. A minute can only be counted once, even if multiple actions occur during it.

You are to calculate a 1-indexed array answer of size k such that, for each j (1 <= j <= k), answer[j] is the number of users whose UAM equals j.

Return the array answer as described above.

Example 1:

Input: logs = [[0,5],[1,2],[0,2],[0,5],[1,3]], k = 5
Output: [0,2,0,0,0]
Explanation:
The user with ID=0 performed actions at minutes 5, 2, and 5 again. Hence, they have a UAM of 2 (minute 5 is only counted once).
The user with ID=1 performed actions at minutes 2 and 3. Hence, they have a UAM of 2.
Since both users have a UAM of 2, answer[2] is 2, and the remaining answer[j] values are 0.

Example 2:

Input: logs = [[1,1],[2,2],[2,3]], k = 4
Output: [1,1,0,0]
Explanation:
The user with ID=1 performed a single action at minute 1. Hence, they have a UAM of 1.
The user with ID=2 performed actions at minutes 2 and 3. Hence, they have a UAM of 2.
There is one user with a UAM of 1 and one with a UAM of 2.
Hence, answer[1] = 1, answer[2] = 1, and the remaining values are 0.

Constraints:

1 <= logs.length <= 10⁴
0 <= ID_i <= 10⁹
1 <= time_i <= 10⁵
k is in the range [The maximum UAM for a user, 10⁵].

Solution: Hashsets in a Hashtable

key: user_id, value: set{time}

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

C++

class Solution {

public:

vector<int> findingUsersActiveMinutes(vector<vector<int>>& logs, int k) {

unordered_map<int, unordered_set<int>> m;

vector<int> ans(k);

for (const auto& log : logs)

m[log[0]].insert(log[1]);

for (const auto& [id, s] : m)

++ans[s.size() - 1];

return ans;

}

};

花花酱 LeetCode 1814. Count Nice Pairs in an Array

By zxi on April 3, 2021

You are given an array nums that consists of non-negative integers. Let us define rev(x) as the reverse of the non-negative integer x. For example, rev(123) = 321, and rev(120) = 21. A pair of indices (i, j) is nice if it satisfies all of the following conditions:

0 <= i < j < nums.length
nums[i] + rev(nums[j]) == nums[j] + rev(nums[i])

Return the number of nice pairs of indices. Since that number can be too large, return it modulo 10⁹ + 7.

Example 1:

Input: nums = [42,11,1,97]
Output: 2
Explanation: The two pairs are:
 - (0,3) : 42 + rev(97) = 42 + 79 = 121, 97 + rev(42) = 97 + 24 = 121.
 - (1,2) : 11 + rev(1) = 11 + 1 = 12, 1 + rev(11) = 1 + 11 = 12.

Example 2:

Input: nums = [13,10,35,24,76]
Output: 4

Constraints:

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

Solution: Two Sum

Key = x – rev(x)

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

C++

// Author: Huahua

class Solution {

public:

int countNicePairs(vector<int>& nums) {

constexpr int kMod = 1e9 + 7;

unordered_map<int, int> m;

long ans = 0;

for (int x : nums) {

string s = to_string(x);

reverse(begin(s), end(s));

ans += m[x - stoi(s)]++;

}

return ans % kMod;

}

};

花花酱 LeetCode 1813. Sentence Similarity III

By zxi on April 3, 2021

A sentence is a list of words that are separated by a single space with no leading or trailing spaces. For example, "Hello World", "HELLO", "hello world hello world" are all sentences. Words consist of only uppercase and lowercase English letters.

Two sentences sentence1 and sentence2 are similar if it is possible to insert an arbitrary sentence (possibly empty) inside one of these sentences such that the two sentences become equal. For example, sentence1 = "Hello my name is Jane" and sentence2 = "Hello Jane" can be made equal by inserting "my name is" between "Hello" and "Jane" in sentence2.

Given two sentences sentence1 and sentence2, return true if sentence1 and sentence2 are similar. Otherwise, return false.

Example 1:

Input: sentence1 = "My name is Haley", sentence2 = "My Haley"
Output: true
Explanation: sentence2 can be turned to sentence1 by inserting "name is" between "My" and "Haley".

Example 2:

Input: sentence1 = "of", sentence2 = "A lot of words"
Output: false
Explanation: No single sentence can be inserted inside one of the sentences to make it equal to the other.

Example 3:

Input: sentence1 = "Eating right now", sentence2 = "Eating"
Output: true
Explanation: sentence2 can be turned to sentence1 by inserting "right now" at the end of the sentence.

Example 4:

Input: sentence1 = "Luky", sentence2 = "Lucccky"
Output: false

Constraints:

1 <= sentence1.length, sentence2.length <= 100
sentence1 and sentence2 consist of lowercase and uppercase English letters and spaces.
The words in sentence1 and sentence2 are separated by a single space.

Solution: Dequeue / Common Prefix + Suffix

Break sequences to words, store them in two deques. Pop the common prefix and suffix. At least one of the deque should be empty.

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

C++

// Author: Huahua

class Solution {

public:

bool areSentencesSimilar(string s1, string s2) {

auto getWords = [](const string& s) {

stringstream ss(s);

deque<string> words;

while (ss) {

words.emplace_back("");

ss >> words.back();

}

return words;

};

deque<string> w1 = getWords(s1), w2 = getWords(s2);

while (w1.size() && w2.size() && w1.front() == w2.front())

w1.pop_front(), w2.pop_front();

while (w1.size() && w2.size() && w1.back() == w2.back())

w1.pop_back(), w2.pop_back();

return w1.empty() || w2.empty();

}

};

Python3

# Author: Huahua

class Solution:

def areSentencesSimilar(self, s1: str, s2: str) -> bool:

w1 = deque(s1.split())

w2 = deque(s2.split())

while w1 and w2 and w1[0] == w2[0]:

w1.popleft(), w2.popleft()

while w1 and w2 and w1[-1] == w2[-1]:

w1.pop(), w2.pop()

return len(w1) * len(w2) == 0