Huahua’s Tech Road

花花酱 LeetCode 1748. Sum of Unique Elements

By zxi on February 6, 2021

You are given an integer array nums. The unique elements of an array are the elements that appear exactly once in the array.

Return the sum of all the unique elements of nums.

Example 1:

Input: nums = [1,2,3,2]
Output: 4
Explanation: The unique elements are [1,3], and the sum is 4.

Example 2:

Input: nums = [1,1,1,1,1]
Output: 0
Explanation: There are no unique elements, and the sum is 0.

Example 3:

Input: nums = [1,2,3,4,5]
Output: 15
Explanation: The unique elements are [1,2,3,4,5], and the sum is 15.

Constraints:

1 <= nums.length <= 100
1 <= nums[i] <= 100

Solution: Hashtable

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

C++

// Author: Huahua

class Solution {

public:

int sumOfUnique(vector<int>& nums) {

vector<int> seen(101);

int ans = 0;

for (int x : nums)

++seen[x];

for (int x : nums)

if (seen[x] == 1) ans += x;

return ans;

}

};

花花酱 LeetCode 1745. Palindrome Partitioning IV

By zxi on January 30, 2021

Given a string s, return true if it is possible to split the string s into three non-empty palindromic substrings. Otherwise, return false.

A string is said to be palindrome if it the same string when reversed.

Example 1:

Input: s = "abcbdd"
Output: true
Explanation: "abcbdd" = "a" + "bcb" + "dd", and all three substrings are palindromes.

Example 2:

Input: s = "bcbddxy"
Output: false
Explanation: s cannot be split into 3 palindromes.

Constraints:

3 <= s.length <= 2000
s consists only of lowercase English letters.

Solution: DP

dp[i][j] := whether s[i]~s[j] is a palindrome.

dp[i][j] = s[i] == s[j] and dp[i+1][j-1]

ans = any(dp[0][i-1] and dp[i][j] and dp[j][n-1]) for j in range(i, n – 1) for i in range(1, n)

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

C++

// Author: Huahua

class Solution {

public:

bool checkPartitioning(string s) {

const int n = s.length();

vector<vector<int>> dp(n, vector<int>(n, 1));

for (int l = 2; l <= n; ++l)

for (int i = 0, j = i + l - 1; j < n; ++i, ++j)

dp[i][j] = (s[i] == s[j]) && dp[i + 1][j - 1];

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

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

if (dp[0][i - 1] && dp[i][j] && dp[j + 1][n - 1])

return true;

return false;

}

};

花花酱 LeetCode 1744. Can You Eat Your Favorite Candy on Your Favorite Day?

By zxi on January 30, 2021

You are given a (0-indexed) array of positive integers candiesCount where candiesCount[i] represents the number of candies of the i^th type you have. You are also given a 2D array queries where queries[i] = [favoriteType_i, favoriteDay_i, dailyCap_i].

You play a game with the following rules:

You start eating candies on day 0.
You cannot eat any candy of type i unless you have eaten all candies of type i - 1.
You must eat at least one candy per day until you have eaten all the candies.

Construct a boolean array answer such that answer.length == queries.length and answer[i] is true if you can eat a candy of type favoriteType_i on day favoriteDay_i without eating more than dailyCap_i candies on any day, and false otherwise. Note that you can eat different types of candy on the same day, provided that you follow rule 2.

Return the constructed array answer.

Example 1:

Input: candiesCount = [7,4,5,3,8], queries = [[0,2,2],[4,2,4],[2,13,1000000000]]
Output: [true,false,true]
Explanation:
1- If you eat 2 candies (type 0) on day 0 and 2 candies (type 0) on day 1, you will eat a candy of type 0 on day 2.
2- You can eat at most 4 candies each day.
   If you eat 4 candies every day, you will eat 4 candies (type 0) on day 0 and 4 candies (type 0 and type 1) on day 1.
   On day 2, you can only eat 4 candies (type 1 and type 2), so you cannot eat a candy of type 4 on day 2.
3- If you eat 1 candy each day, you will eat a candy of type 2 on day 13.

Example 2:

Input: candiesCount = [5,2,6,4,1], queries = [[3,1,2],[4,10,3],[3,10,100],[4,100,30],[1,3,1]]
Output: [false,true,true,false,false]

Constraints:

1 <= candiesCount.length <= 10⁵
1 <= candiesCount[i] <= 10⁵
1 <= queries.length <= 10⁵
queries[i].length == 3
0 <= favoriteType_i < candiesCount.length
0 <= favoriteDay_i <= 10⁹
1 <= dailyCap_i <= 10⁹

Solution: Prefix Sum

We must have enough capacity to eat all candies before the current type.
We must have at least prefix sum candies than days, since we have to eat at least one each day.

sum[i] = sum(candyCount[0~i])
ans = {days * cap > sum[type – 1] && days <= sum[type])

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

C++

// Author: Huhua

class Solution {

public:

vector<bool> canEat(vector<int>& candiesCount, vector<vector<int>>& queries) {

const int n = candiesCount.size();

vector<long> sums(n + 1);

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

sums[i] += sums[i - 1] + candiesCount[i - 1];

vector<bool> ans;

for (const auto& q : queries) {

const long type = q[0], days = q[1] + 1, cap = q[2];

ans.push_back(days * cap > sums[type] && days <= sums[type + 1]);

}

return ans;

}

};

花花酱 LeetCode 1743. Restore the Array From Adjacent Pairs

By zxi on January 30, 2021

There is an integer array nums that consists of n unique elements, but you have forgotten it. However, you do remember every pair of adjacent elements in nums.

You are given a 2D integer array adjacentPairs of size n - 1 where each adjacentPairs[i] = [u_i, v_i] indicates that the elements u_i and v_i are adjacent in nums.

It is guaranteed that every adjacent pair of elements nums[i] and nums[i+1] will exist in adjacentPairs, either as [nums[i], nums[i+1]] or [nums[i+1], nums[i]]. The pairs can appear in any order.

Return the original array nums. If there are multiple solutions, return any of them.

Example 1:

Input: adjacentPairs = [[2,1],[3,4],[3,2]]
Output: [1,2,3,4]
Explanation: This array has all its adjacent pairs in adjacentPairs.
Notice that adjacentPairs[i] may not be in left-to-right order.

Example 2:

Input: adjacentPairs = [[4,-2],[1,4],[-3,1]]
Output: [-2,4,1,-3]
Explanation: There can be negative numbers.
Another solution is [-3,1,4,-2], which would also be accepted.

Example 3:

Input: adjacentPairs = [[100000,-100000]]
Output: [100000,-100000]

Constraints:

nums.length == n
adjacentPairs.length == n - 1
adjacentPairs[i].length == 2
2 <= n <= 10⁵
-10⁵ <= nums[i], u_i, v_i <= 10⁵
There exists some nums that has adjacentPairs as its pairs.

Solution: Hashtable

Reverse thinking! For a given input array, e.g.
[1, 2, 3, 4, 5]
it’s adjacent pairs are [1,2] , [2,3], [3,4], [4,5]
all numbers appeared exactly twice except 1 and 5, since they are on the boundary.
We just need to find the head or tail of the input array, and construct the rest of the array in order.

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

C++

// Author: Huahua

class Solution {

public:

vector<int> restoreArray(vector<vector<int>>& adjacentPairs) {

const int n = adjacentPairs.size() + 1;

unordered_map<int, vector<int>> g;

for (const auto& p : adjacentPairs) {

g[p[0]].push_back(p[1]);

g[p[1]].push_back(p[0]);

}

vector<int> ans(n);

for (const auto& [u, vs] : g)

if (vs.size() == 1) {

ans[0] = u;

ans[1] = vs[0];

break;

}

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

const auto& vs = g[ans[i - 1]];

ans[i] = vs[0] == ans[i - 2] ? vs[1] : vs[0];

}

return ans;

}

};

花花酱 LeetCode 1742. Maximum Number of Balls in a Box

By zxi on January 30, 2021

You are working in a ball factory where you have n balls numbered from lowLimit up to highLimit inclusive (i.e., n == highLimit - lowLimit + 1), and an infinite number of boxes numbered from 1 to infinity.

Your job at this factory is to put each ball in the box with a number equal to the sum of digits of the ball’s number. For example, the ball number 321 will be put in the box number 3 + 2 + 1 = 6 and the ball number 10 will be put in the box number 1 + 0 = 1.

Given two integers lowLimit and highLimit, return the number of balls in the box with the most balls.

Example 1:

Input: lowLimit = 1, highLimit = 10
Output: 2
Explanation:
Box Number:  1 2 3 4 5 6 7 8 9 10 11 ...
Ball Count:  2 1 1 1 1 1 1 1 1 0  0  ...
Box 1 has the most number of balls with 2 balls.

Example 2:

Input: lowLimit = 5, highLimit = 15
Output: 2
Explanation:
Box Number:  1 2 3 4 5 6 7 8 9 10 11 ...
Ball Count:  1 1 1 1 2 2 1 1 1 0  0  ...
Boxes 5 and 6 have the most number of balls with 2 balls in each.

Example 3:

Input: lowLimit = 19, highLimit = 28
Output: 2
Explanation:
Box Number:  1 2 3 4 5 6 7 8 9 10 11 12 ...
Ball Count:  0 1 1 1 1 1 1 1 1 2  0  0  ...
Box 10 has the most number of balls with 2 balls.

Constraints:

1 <= lowLimit <= highLimit <= 10⁵

Solution: Hashtable and base-10

Max sum will be 9+9+9+9+9 = 45

Time complexity: O((hi-lo) * log(hi))
Space complexity: O(1)

C++

// Author: Huahua

class Solution {

public:

int countBalls(int lowLimit, int highLimit) {

vector<int> balls(46);

int ans = 0;

for (int i = lowLimit; i <= highLimit; ++i) {

int n = i;

int box = 0;

while (n) { box += n % 10; n /= 10; }

ans = max(ans, ++balls[box]);

}

return ans;

}

};

Python3

# Author: Huahua

class Solution:

def countBalls(self, lowLimit: int, highLimit: int) -> int:

balls = defaultdict(int)

ans = 0

for x in range(lowLimit, highLimit + 1):

s = sum(int(d) for d in str(x))

balls[s] += 1

ans = max(ans, balls[s])

return ans

Huahua's Tech Road

花花酱 LeetCode 1748. Sum of Unique Elements

Solution: Hashtable

C++

花花酱 LeetCode 1745. Palindrome Partitioning IV

Solution: DP

C++

花花酱 LeetCode 1744. Can You Eat Your Favorite Candy on Your Favorite Day?

Solution: Prefix Sum

C++

花花酱 LeetCode 1743. Restore the Array From Adjacent Pairs

Solution: Hashtable

C++

花花酱 LeetCode 1742. Maximum Number of Balls in a Box

Solution: Hashtable and base-10

C++

Python3