Huahua’s Tech Road

花花酱 LeetCode 2266. Count Number of Texts

By zxi on May 10, 2022

Alice is texting Bob using her phone. The mapping of digits to letters is shown in the figure below.

In order to add a letter, Alice has to press the key of the corresponding digit i times, where i is the position of the letter in the key.

For example, to add the letter 's', Alice has to press '7' four times. Similarly, to add the letter 'k', Alice has to press '5' twice.
Note that the digits '0' and '1' do not map to any letters, so Alice does not use them.

However, due to an error in transmission, Bob did not receive Alice’s text message but received a string of pressed keys instead.

For example, when Alice sent the message "bob", Bob received the string "2266622".

Given a string pressedKeys representing the string received by Bob, return the total number of possible text messages Alice could have sent.

Since the answer may be very large, return it modulo 10⁹ + 7.

Example 1:

Input: pressedKeys = "22233"
Output: 8
Explanation:
The possible text messages Alice could have sent are:
"aaadd", "abdd", "badd", "cdd", "aaae", "abe", "bae", and "ce".
Since there are 8 possible messages, we return 8.

Example 2:

Input: pressedKeys = "222222222222222222222222222222222222"
Output: 82876089
Explanation:
There are 2082876103 possible text messages Alice could have sent.
Since we need to return the answer modulo 10⁹ + 7, we return 2082876103 % (10⁹ + 7) = 82876089.

Constraints:

1 <= pressedKeys.length <= 10⁵
pressedKeys only consists of digits from '2' – '9'.

Solution: DP

Similar to 花花酱 LeetCode 91. Decode Ways, let dp[i] denote # of possible messages of substr s[i:]

dp[i] = dp[i + 1]
+ dp[i + 2] (if s[i:i+1] are the same)
+ dp[i + 3] (if s[i:i+2] are the same)
+ dp[i + 4] (if s[i:i+3] are the same and s[i] in ’79’)

dp[n] = 1

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

Python3

# Author: Huahua

class Solution:

def countTexts(self, s: str) -> int:

kMod = 10**9 + 7

n = len(s)

@cache

def dp(i: int) -> int:

if i >= n: return 1

ans = dp(i + 1)

ans += dp(i + 2) if i + 2 <= n and s[i] == s[i + 1] else 0

ans += dp(i + 3) if i + 3 <= n and s[i] == s[i + 1] == s[i + 2] else 0

ans += dp(i + 4) if i + 4 <= n and s[i] == s[i + 1] == s[i + 2] == s[i + 3] and s[i] in '79' else 0

return ans % kMod

return dp(0)

花花酱 LeetCode 2265. Count Nodes Equal to Average of Subtree

By zxi on May 10, 2022

Given the root of a binary tree, return the number of nodes where the value of the node is equal to the average of the values in its subtree.

Note:

The average of n elements is the sum of the n elements divided by n and rounded down to the nearest integer.
A subtree of root is a tree consisting of root and all of its descendants.

Example 1:

Input: root = [4,8,5,0,1,null,6]
Output: 5
Explanation: 
For the node with value 4: The average of its subtree is (4 + 8 + 5 + 0 + 1 + 6) / 6 = 24 / 6 = 4.
For the node with value 5: The average of its subtree is (5 + 6) / 2 = 11 / 2 = 5.
For the node with value 0: The average of its subtree is 0 / 1 = 0.
For the node with value 1: The average of its subtree is 1 / 1 = 1.
For the node with value 6: The average of its subtree is 6 / 1 = 6.

Example 2:

Input: root = [1]
Output: 1
Explanation: For the node with value 1: The average of its subtree is 1 / 1 = 1.

Constraints:

The number of nodes in the tree is in the range [1, 1000].
0 <= Node.val <= 1000

Solution: Recursion

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

C++

// Author: Huahua

class Solution {

public:

int averageOfSubtree(TreeNode* root) {

// Returns {sum(val), sum(node), ans}

function<tuple<int, int, int>(TreeNode*)> getSum

= [&](TreeNode* root) -> tuple<int, int, int> {

if (!root) return {0, 0, 0};

auto [lv, lc, la] = getSum(root->left);

auto [rv, rc, ra] = getSum(root->right);

int sum = lv + rv + root->val;

int count = lc + rc + 1;

int ans = la + ra + (root->val == sum / count);

return {sum, count, ans};

};

return get<2>(getSum(root));

}

};

花花酱 LeetCode 2264. Largest 3-Same-Digit Number in String

By zxi on May 9, 2022

You are given a string num representing a large integer. An integer is good if it meets the following conditions:

It is a substring of num with length 3.
It consists of only one unique digit.

Return the maximum good integer as a string or an empty string "" if no such integer exists.

Note:

A substring is a contiguous sequence of characters within a string.
There may be leading zeroes in num or a good integer.

Example 1:

Input: num = "6777133339"
Output: "777"
Explanation: There are two distinct good integers: "777" and "333".
"777" is the largest, so we return "777".

Example 2:

Input: num = "2300019"
Output: "000"
Explanation: "000" is the only good integer.

Example 3:

Input: num = "42352338"
Output: ""
Explanation: No substring of length 3 consists of only one unique digit. Therefore, there are no good integers.

Constraints:

3 <= num.length <= 1000
num only consists of digits.

Solution:

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

C++

// Author: Huahua

class Solution {

public:

string largestGoodInteger(string num) {

string ans;

for (int i = 0; i < num.size() - 2; ++i) {

if (num[i] == num[i + 1] && num[i] == num[i + 2] &&

(ans.empty() || num[i] > ans[0]))

ans = num.substr(i, 3);

}

return ans;

}

};

花花酱 LeetCode 2260. Minimum Consecutive Cards to Pick Up

By zxi on May 3, 2022

You are given an integer array cards where cards[i] represents the value of the i^th card. A pair of cards are matching if the cards have the same value.

Return the minimum number of consecutive cards you have to pick up to have a pair of matching cards among the picked cards. If it is impossible to have matching cards, return -1.

Example 1:

Input: cards = [3,4,2,3,4,7]
Output: 4
Explanation: We can pick up the cards [3,4,2,3] which contain a matching pair of cards with value 3. Note that picking up the cards [4,2,3,4] is also optimal.

Example 2:

Input: cards = [1,0,5,3]
Output: -1
Explanation: There is no way to pick up a set of consecutive cards that contain a pair of matching cards.

Constraints:

1 <= cards.length <= 10⁵
0 <= cards[i] <= 10⁶

Solution: Hashtable

Record the last position of each number,
ans = min{card_i – last[card_i]}

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

C++

// Author: Huahua

class Solution {

public:

int minimumCardPickup(vector<int>& cards) {

const int n = cards.size();

unordered_map<int, int> m;

int ans = INT_MAX;

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

if (m.count(cards[i]))

ans = min(ans, i - m[cards[i]] + 1);

m[cards[i]] = i;

}

return ans == INT_MAX ? -1 : ans;

}

};

花花酱 LeetCode 2259. Remove Digit From Number to Maximize Result

By zxi on May 3, 2022

You are given a string number representing a positive integer and a character digit.

Return the resulting string after removing exactly one occurrence of digit from number such that the value of the resulting string in decimal form is maximized. The test cases are generated such that digit occurs at least once in number.

Example 1:

Input: number = "123", digit = "3"
Output: "12"
Explanation: There is only one '3' in "123". After removing '3', the result is "12".

Example 2:

Input: number = "1231", digit = "1"
Output: "231"
Explanation: We can remove the first '1' to get "231" or remove the second '1' to get "123".
Since 231 > 123, we return "231".

Example 3:

Input: number = "551", digit = "5"
Output: "51"
Explanation: We can remove either the first or second '5' from "551".
Both result in the string "51".

Constraints:

2 <= number.length <= 100
number consists of digits from '1' to '9'.
digit is a digit from '1' to '9'.
digit occurs at least once in number.

Solution 1: Brute Force

Try all possible resulting strings.

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

C++

// Author: Huahua

class Solution {

public:

string removeDigit(string number, char digit) {

const int n = number.size();

string ans(number.size() - 1, '1');

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

if (number[i] == digit)

ans = max(ans, number.substr(0, i) + number.substr(i + 1));

return ans;

}

};

Huahua's Tech Road

花花酱 LeetCode 2266. Count Number of Texts

Solution: DP

Python3

花花酱 LeetCode 2265. Count Nodes Equal to Average of Subtree

Solution: Recursion

C++

花花酱 LeetCode 2264. Largest 3-Same-Digit Number in String

C++

花花酱 LeetCode 2260. Minimum Consecutive Cards to Pick Up

Solution: Hashtable

C++

花花酱 LeetCode 2259. Remove Digit From Number to Maximize Result

Solution 1: Brute Force

C++