Huahua’s Tech Road

花花酱 LeetCode 273. Integer to English Words

By zxi on April 3, 2019

Convert a non-negative integer to its english words representation. Given input is guaranteed to be less than 2³¹ – 1.

Example 1:

Input: 123
Output: "One Hundred Twenty Three"

Example 2:

Input: 12345
Output: "Twelve Thousand Three Hundred Forty Five"

Example 3:

Input: 1234567
Output: "One Million Two Hundred Thirty Four Thousand Five Hundred Sixty Seven"

Example 4:

Input: 1234567891
Output: "One Billion Two Hundred Thirty Four Million Five Hundred Sixty Seven Thousand Eight Hundred Ninety One"

Solution: Recursion

Time complexity: O(logn)
Space complexity: O(logn)

C++

// Author: Huahua

constexpr char * kUnder20[] = {"One", "Two", "Three", "Four", "Five",

"Six", "Seven", "Eight", "Nine","Ten",

"Eleven", "Twelve", "Thirteen", "Fourteen",

"Fifteen", "Sixteen", "Seventeen", "Eighteen",

"Nineteen"};

constexpr char * kUnder100[] = {"Twenty", "Thirty", "Forty", "Fifty",

"Sixty", "Seventy", "Eighty", "Ninety"};

constexpr char * kHTMB[] = {"Hundred", "Thousand", "Million", "Billion"};

constexpr long kP[] = {100, 1000, 1000*1000, 1000*1000*1000};

class Solution {

public:

string numberToWords(int n) {

if (n == 0) return "Zero";

return convert(n).substr(1);

}

private:

string convert(int n) {

if (n == 0) return "";

if (n < 20) return string(" ") + kUnder20[n - 1]; // 1 - 19

if (n < 100) return string(" ") + kUnder100[n / 10 - 2] + convert(n % 10); // 20 ~ 99

for (int i = 3; i >= 0; --i)

if (n >= kP[i]) return convert(n / kP[i]) + " " + kHTMB[i] + convert(n % kP[i]);

return "";

}

};

花花酱 LeetCode Weekly Contest 130 (1017, 1018, 1019, 1020)

By zxi on March 30, 2019

1017. Convert to Base -2

Solution: Math / Simulation

Time complexity: O(logn)
Space complexity: O(logn)

C++

// Author: Huahua

class Solution {

public:

string baseNeg2(int N) {

if (N == 0) return "0";

vector<char> ans;

while (N) {

ans.push_back((N & 1) + '0');

N = -(N >> 1);

}

return {rbegin(ans), rend(ans)};

}

};

base K

// Author: Huahua

class Solution {

public:

string baseNeg2(int N) {

if (N == 0) return "0";

return baseNegK(N, -2);

}

private:

string baseNegK(int N, int K) {

vector<char> ans;

while (N) {

int r = N % K;

N /= K;

if (r < 0) {

r += -K;

N += 1;

}

ans.push_back(r + '0');

}

return {rbegin(ans), rend(ans)};

}

};

1018. Binary Prefix Divisible By 5

Solution: Math

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

C++

// Author: Huahua

class Solution {

public:

vector<bool> prefixesDivBy5(vector<int>& A) {

int num = 0;

vector<bool> ans(A.size());

for (int i = 0; i < A.size(); ++i) {

num = ((num << 1) | A[i]) % 5;

ans[i] = num == 0;

}

return ans;

}

};

1019. Next Greater Node In Linked List

Solution: Reverse + Monotonic Stack

Process in reverse order and keep a monotonically increasing stack, pop all the elements that are smaller than the current one, then the top of the stack (if exists) will be the next greater node.

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

C++

// Author: Huahua

class Solution {

public:

vector<int> nextLargerNodes(ListNode* head) {

vector<int> nums;

while (head) {

nums.push_back(head->val);

head = head->next;

}

stack<int> s;

vector<int> ans(nums.size());

for (int i = nums.size() - 1; i >= 0; --i) {

while (!s.empty() && s.top() <= nums[i]) s.pop();

ans[i] = s.empty() ? 0 : s.top();

s.push(nums[i]);

}

return ans;

}

};

1020. Number of Enclaves

Solution: DFS / Connected Components

Time complexity: O(mn)
Space complexity: O(mn)

C++

// Author: Huahua

class Solution {

public:

int numEnclaves(vector<vector<int>>& A) {

int ans = 0;

for (int i = 0; i < A.size(); ++i)

for (int j = 0; j < A[0].size(); ++j) {

int count = 0;

if (!dfs(A, j, i, count))

ans += count;

}

return ans;

}

private:

static constexpr int dirs[5]{0, -1, 0, 1, 0};

bool dfs(vector<vector<int>>& A, int x, int y, int& count) {

if (x < 0 || x == A[0].size() || y < 0 || y == A.size()) return true;

if (A[y][x] == 0) return false;

++count;

A[y][x] = 0;

bool valid = false;

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

valid |= dfs(A, x + dirs[i], y + dirs[i + 1], count);

return valid;

}

};

花花酱 LeetCode Weekly Contest 129 (1020, 1021, 1022, 1023)

By zxi on March 24, 2019

1020. Partition Array Into Three Parts With Equal Sum

Return true if there is a 2/3*sum prefix sum after a 1/3 prefix sum

1 2	[---- 1/3 ----][-----1/3-----][-----1/3-----] [------------2/3-------------][-----1/3-----]

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

Python

class Solution:

def canThreePartsEqualSum(self, A: List[int]) -> bool:

s = sum(A)

if s % 3 != 0: return False

c = 0

found = False

for a in A:

c += a

if c == s // 3 * 2 and found: return True

if c == s // 3: found = True

return False

1021. Best Sightseeing Pair

Greedy, only keep the best A[i] + i so far and pair with A[j] – j, i < j

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

C++

class Solution {

public:

int maxScoreSightseeingPair(vector<int>& A) {

int ans = 0;

int left = 0;

for (int i = 0; i < A.size(); ++i) {

ans = max(ans, left + A[i] - i);

left = max(left, A[i] + i);

}

return ans;

}

};

1022. Smallest Integer Divisible by K

Math

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

C++

class Solution {

public:

int smallestRepunitDivByK(int K) {

if (K % 2 == 0 || K % 5 == 0) return -1;

int r = 0;

for (int l = 1; l <= K; ++l) {

r = (r * 10 + 1) % K;

if (r == 0) return l;

}

return -1;

}

};

1023. Binary String With Substrings Representing 1 To N

Brute Force, try all possible substrings and convert them into decimals.

Time complexity: O(|S|*log(N)^2)

Python

class Solution:

def queryString(self, S: str, N: int) -> bool:

s = set()

c = 0

for l in range(1, 32):

for i in range(0, len(S) - l + 1):

n = int(S[i:i+l], 2)

if n == 0 or n > N or n in s: continue

s.add(n)

c += 1

return c == N

花花酱 LeetCode 1011. Capacity To Ship Packages Within D Days

By zxi on March 16, 2019

A conveyor belt has packages that must be shipped from one port to another within D days.

The i-th package on the conveyor belt has a weight of weights[i]. Each day, we load the ship with packages on the conveyor belt (in the order given by weights). We may not load more weight than the maximum weight capacity of the ship.

Return the least weight capacity of the ship that will result in all the packages on the conveyor belt being shipped within D days.

Example 1:

Input: weights = [1,2,3,4,5,6,7,8,9,10], D = 5
Output: 15
Explanation: 
A ship capacity of 15 is the minimum to ship all the packages in 5 days like this:
1st day: 1, 2, 3, 4, 5
2nd day: 6, 7
3rd day: 8
4th day: 9
5th day: 10

Note that the cargo must be shipped in the order given, so using a ship of capacity 14 and splitting the packages into parts like (2, 3, 4, 5), (1, 6, 7), (8), (9), (10) is not allowed.

Example 2:

Input: weights = [3,2,2,4,1,4], D = 3
Output: 6
Explanation: 
A ship capacity of 6 is the minimum to ship all the packages in 3 days like this:
1st day: 3, 2
2nd day: 2, 4
3rd day: 1, 4

Example 3:

Input: weights = [1,2,3,1,1], D = 4
Output: 3
Explanation: 
1st day: 1
2nd day: 2
3rd day: 3
4th day: 1, 1

Note:

1 <= D <= weights.length <= 50000
1 <= weights[i] <= 500

Solution: Binary Search

Find the smallest capacity such that can finish in D days.

Time complexity: O(n * log(sum(weights))
Space complexity: O(1)

C++

// Author: Huahua, running time: 52 ms, 11.9 MB

class Solution {

public:

int shipWithinDays(vector<int>& weights, int D) {

int l = *max_element(begin(weights), end(weights));

int r = accumulate(begin(weights), end(weights), 0) + 1;

while (l < r) {

int m = l + (r - l) / 2;

int d = 1;

int t = 0;

for (int w : weights)

if ((t += w) > m) {

t = w;

++d;

}

d > D ? l = m + 1 : r = m;

}

return l;

}

};

花花酱 LeetCode 1013. Pairs of Songs With Total Durations Divisible by 60

By zxi on March 16, 2019

In a list of songs, the i-th song has a duration of time[i] seconds.

Return the number of pairs of songs for which their total duration in seconds is divisible by 60. Formally, we want the number of indices i < j with (time[i] + time[j]) % 60 == 0.

Example 1:

Input: [30,20,150,100,40]
Output: 3
Explanation: Three pairs have a total duration divisible by 60:
(time[0] = 30, time[2] = 150): total duration 180
(time[1] = 20, time[3] = 100): total duration 120
(time[1] = 20, time[4] = 40): total duration 60

Example 2:

Input: [60,60,60]
Output: 3
Explanation: All three pairs have a total duration of 120, which is divisible by 60.

Note:

1 <= time.length <= 60000
1 <= time[i] <= 500

Solution: Two Sum of 60

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

C++

// Author: Huahua, running time: 36 ms, 11.6 MB

class Solution {

public:

int numPairsDivisibleBy60(vector<int>& time) {

vector<int> c(60);

int ans = 0;

for (int t : time) {

t %= 60;

ans += c[(60 - t) % 60];

++c[t];

}

return ans;

}

};

Huahua's Tech Road

花花酱 LeetCode 273. Integer to English Words

C++

花花酱 LeetCode Weekly Contest 130 (1017, 1018, 1019, 1020)

1017. Convert to Base -2

C++

base K

1018. Binary Prefix Divisible By 5

C++

1019. Next Greater Node In Linked List

C++

1020. Number of Enclaves

C++

花花酱 LeetCode Weekly Contest 129 (1020, 1021, 1022, 1023)

1020. Partition Array Into Three Parts With Equal Sum

Python

1021. Best Sightseeing Pair

C++

1022. Smallest Integer Divisible by K

C++

1023. Binary String With Substrings Representing 1 To N

Python

花花酱 LeetCode 1011. Capacity To Ship Packages Within D Days

Solution: Binary Search

C++

花花酱 LeetCode 1013. Pairs of Songs With Total Durations Divisible by 60

Solution: Two Sum of 60

C++