Huahua’s Tech Road

花花酱 LeetCode 2183. Count Array Pairs Divisible by K

By zxi on March 4, 2022

Given a 0-indexed integer array nums of length n and an integer k, return the number of pairs (i, j) such that:

0 <= i < j <= n - 1 and
nums[i] * nums[j] is divisible by k.

Example 1:

Input: nums = [1,2,3,4,5], k = 2
Output: 7
Explanation: 
The 7 pairs of indices whose corresponding products are divisible by 2 are
(0, 1), (0, 3), (1, 2), (1, 3), (1, 4), (2, 3), and (3, 4).
Their products are 2, 4, 6, 8, 10, 12, and 20 respectively.
Other pairs such as (0, 2) and (2, 4) have products 3 and 15 respectively, which are not divisible by 2.

Example 2:

Input: nums = [1,2,3,4], k = 5
Output: 0
Explanation: There does not exist any pair of indices whose corresponding product is divisible by 5.

Constraints:

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

Solution: Math

a * b % k == 0 <=> gcd(a, k) * gcd(b, k) == 0

Use a counter of gcd(x, k) so far to compute the number of pairs.

Time complexity: O(n*f), where f is the number of gcds, f <= 128 for x <= 1e5
Space complexity: O(f)

C++

// Author: Huahua

class Solution {

public:

long long countPairs(vector<int>& nums, int k) {

unordered_map<int, int> m;

long long ans = 0;

for (int x : nums) {

long long d1 = gcd(x, k);

for (const auto& [d2, c] : m)

if (d1 * d2 % k == 0) ans += c;

++m[d1];

}

return ans;

}

};

花花酱 LeetCode 2182. Construct String With Repeat Limit

By zxi on March 3, 2022

You are given a string s and an integer repeatLimit. Construct a new string repeatLimitedString using the characters of s such that no letter appears more than repeatLimit times in a row. You do not have to use all characters from s.

Return the lexicographically largest repeatLimitedString possible.

A string a is lexicographically larger than a string b if in the first position where a and b differ, string a has a letter that appears later in the alphabet than the corresponding letter in b. If the first min(a.length, b.length) characters do not differ, then the longer string is the lexicographically larger one.

Example 1:

Input: s = "cczazcc", repeatLimit = 3
Output: "zzcccac"
Explanation: We use all of the characters from s to construct the repeatLimitedString "zzcccac".
The letter 'a' appears at most 1 time in a row.
The letter 'c' appears at most 3 times in a row.
The letter 'z' appears at most 2 times in a row.
Hence, no letter appears more than repeatLimit times in a row and the string is a valid repeatLimitedString.
The string is the lexicographically largest repeatLimitedString possible so we return "zzcccac".
Note that the string "zzcccca" is lexicographically larger but the letter 'c' appears more than 3 times in a row, so it is not a valid repeatLimitedString.

Example 2:

Input: s = "aababab", repeatLimit = 2
Output: "bbabaa"
Explanation: We use only some of the characters from s to construct the repeatLimitedString "bbabaa". 
The letter 'a' appears at most 2 times in a row.
The letter 'b' appears at most 2 times in a row.
Hence, no letter appears more than repeatLimit times in a row and the string is a valid repeatLimitedString.
The string is the lexicographically largest repeatLimitedString possible so we return "bbabaa".
Note that the string "bbabaaa" is lexicographically larger but the letter 'a' appears more than 2 times in a row, so it is not a valid repeatLimitedString.

Constraints:

1 <= repeatLimit <= s.length <= 10⁵
s consists of lowercase English letters.

Solution: Greedy

Adding one letter at a time, find the largest one that can be used.

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

C++

// Author: Huahua

class Solution {

public:

string repeatLimitedString(string s, int repeatLimit) {

vector<int> m(26);

for (char c : s) ++m[c - 'a'];

string ans;

int count = 0;

int last = -1;

while (true) {

bool found = false;

for (int i = 25; i >= 0 && !found; --i)

if (m[i] && (count < repeatLimit || last != i)) {

ans += 'a' + i;

count = (last == i) * count + 1;

--m[i];

last = i;

found = true;

}

if (!found) break;

}

return ans;

}

};

花花酱 LeetCode 2181. Merge Nodes in Between Zeros

By zxi on March 2, 2022

You are given the head of a linked list, which contains a series of integers separated by 0‘s. The beginning and end of the linked list will have Node.val == 0.

For every two consecutive 0‘s, merge all the nodes lying in between them into a single node whose value is the sum of all the merged nodes. The modified list should not contain any 0‘s.

Return the head of the modified linked list.

Example 1:

Input: head = [0,3,1,0,4,5,2,0]
Output: [4,11]
Explanation: 
The above figure represents the given linked list. The modified list contains
- The sum of the nodes marked in green: 3 + 1 = 4.
- The sum of the nodes marked in red: 4 + 5 + 2 = 11.

Example 2:

Input: head = [0,1,0,3,0,2,2,0]
Output: [1,3,4]
Explanation: 
The above figure represents the given linked list. The modified list contains
- The sum of the nodes marked in green: 1 = 1.
- The sum of the nodes marked in red: 3 = 3.
- The sum of the nodes marked in yellow: 2 + 2 = 4.

Constraints:

The number of nodes in the list is in the range [3, 2 * 10⁵].
0 <= Node.val <= 1000
There are no two consecutive nodes with Node.val == 0.
The beginning and end of the linked list have Node.val == 0.

Solution: List

Skip the first zero, replace every zero node with the sum of values of its previous nodes.

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

C++

// Author: Huahua

class Solution {

public:

ListNode* mergeNodes(ListNode* head) {

ListNode dummy;

head = head->next;

for (ListNode* prev = &dummy; head; head = head->next) {

int sum = 0;

while (head->val != 0) {

sum += head->val;

head = head->next;

}

prev->next = head;

head->val = sum;

prev = head;

}

return dummy.next;

}

};

花花酱 LeetCode 2180. Count Integers With Even Digit Sum

By zxi on February 28, 2022

Given a positive integer num, return the number of positive integers less than or equal to num whose digit sums are even.

The digit sum of a positive integer is the sum of all its digits.

Example 1:

Input: num = 4
Output: 2
Explanation:
The only integers less than or equal to 4 whose digit sums are even are 2 and 4.

Example 2:

Input: num = 30
Output: 14
Explanation:
The 14 integers less than or equal to 30 whose digit sums are even are
2, 4, 6, 8, 11, 13, 15, 17, 19, 20, 22, 24, 26, and 28.

Constraints:

1 <= num <= 1000

Solution: Brute Force

Use std::to_string to convert an integer to string.

Time complexity: O(nlgn)
Space complexity: O(lgn)

C++

// Author: Huahua

class Solution {

public:

int countEven(int num) {

int ans = 0;

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

int sum = 0;

for (char c : to_string(i))

sum += (c - '0');

if (sum % 2 == 0) ++ans;

}

return ans;

}

};

花花酱 LeetCode 2188. Minimum Time to Finish the Race

By zxi on February 28, 2022

You are given a 0-indexed 2D integer array tires where tires[i] = [f_i, r_i] indicates that the i^th tire can finish its x^th successive lap in f_i * r_i^(x-1) seconds.

For example, if f_i = 3 and r_i = 2, then the tire would finish its 1^st lap in 3 seconds, its 2^nd lap in 3 * 2 = 6 seconds, its 3^rd lap in 3 * 2² = 12 seconds, etc.

You are also given an integer changeTime and an integer numLaps.

The race consists of numLaps laps and you may start the race with any tire. You have an unlimited supply of each tire and after every lap, you may change to any given tire (including the current tire type) if you wait changeTime seconds.

Return the minimum time to finish the race.

Example 1:

Input: tires = [[2,3],[3,4]], changeTime = 5, numLaps = 4
Output: 21
Explanation: 
Lap 1: Start with tire 0 and finish the lap in 2 seconds.
Lap 2: Continue with tire 0 and finish the lap in 2 * 3 = 6 seconds.
Lap 3: Change tires to a new tire 0 for 5 seconds and then finish the lap in another 2 seconds.
Lap 4: Continue with tire 0 and finish the lap in 2 * 3 = 6 seconds.
Total time = 2 + 6 + 5 + 2 + 6 = 21 seconds.
The minimum time to complete the race is 21 seconds.

Example 2:

Input: tires = [[1,10],[2,2],[3,4]], changeTime = 6, numLaps = 5
Output: 25
Explanation: 
Lap 1: Start with tire 1 and finish the lap in 2 seconds.
Lap 2: Continue with tire 1 and finish the lap in 2 * 2 = 4 seconds.
Lap 3: Change tires to a new tire 1 for 6 seconds and then finish the lap in another 2 seconds.
Lap 4: Continue with tire 1 and finish the lap in 2 * 2 = 4 seconds.
Lap 5: Change tires to tire 0 for 6 seconds then finish the lap in another 1 second.
Total time = 2 + 4 + 6 + 2 + 4 + 6 + 1 = 25 seconds.
The minimum time to complete the race is 25 seconds.

Constraints:

1 <= tires.length <= 10⁵
tires[i].length == 2
1 <= f_i, changeTime <= 10⁵
2 <= r_i <= 10⁵
1 <= numLaps <= 1000

Solution: DP

Observation: since ri >= 2, we must change tire within 20 laps, otherwise it will be slower.

pre-compute the time to finish k laps using each type of tire (k < 20), find min for each lap.

dp[i] = best[i], i < 20,
dp[i] = min{dp[i – j] + changeTime + best[j]}, i > 20

Time complexity: O(n)
Space complexity: O(n) -> O(20)

C++

// Author: Huahua

class Solution {

public:

int minimumFinishTime(vector<vector<int>>& tires, int changeTime, int numLaps) {

constexpr int kMax = 20;

vector<long> best(kMax, INT_MAX);

for (const auto& t : tires)

for (long i = 1, l = t[0], s = t[0]; i < kMax && l < t[0] + changeTime; ++i, l *= t[1], s += l)

best[i] = min(best[i], s);

vector<long> dp(numLaps + 1, INT_MAX);

for (int i = 1; i <= numLaps; ++i)

for (int j = 1; j <= min(i, kMax - 1); ++j)

dp[i] = min(dp[i], best[j] + (i > j) * (changeTime + dp[i - j]));

return dp[numLaps];

}

};

Huahua's Tech Road

花花酱 LeetCode 2183. Count Array Pairs Divisible by K

Solution: Math

C++

花花酱 LeetCode 2182. Construct String With Repeat Limit

Solution: Greedy

C++

花花酱 LeetCode 2181. Merge Nodes in Between Zeros

Solution: List

C++

花花酱 LeetCode 2180. Count Integers With Even Digit Sum

Solution: Brute Force

C++

花花酱 LeetCode 2188. Minimum Time to Finish the Race

Solution: DP

C++