Leetcode – Page 2 – Huahua’s Tech Road

花花酱 LeetCode Weekly Contest 131 (1021, 1022, 1023, 1024)

By zxi on April 7, 2019

LeetCode 1021. Remove Outermost Parentheses

Solution: Track # of opened parentheses

Let n denote the # of opened parentheses after current char, keep ‘(‘ if n > 1 and keep ‘)’ if n > 0

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

C++

// Author: Huahua

class Solution {

public:

string removeOuterParentheses(string S) {

string ans;

int n = 0;

for (char c : S) {

if (c == '(' && n++) ans += c;

if (c == ')' && --n) ans += c;

}

return ans;

}

};

LeetCode 1022. Sum of Root To Leaf Binary Numbers

Solution: Recursion + Math

Keep tracking the number from root to current node.

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

C++

class Solution {

public:

int sumRootToLeaf(TreeNode* root) {

return sums(root, 0);

}

private:

static constexpr int kMod = 1e9 + 7;

int sums(TreeNode* root, int c) {

if (!root) return 0;

c = ((c << 1) | root->val) % kMod;

if (!root->left && !root->right) {

return c;

}

return sums(root->left, c) + sums(root->right, c);

}

};

LeetCode 1023. Camelcase Matching

Solution: String…

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

C++

// Author: Huahua

class Solution {

public:

vector<bool> camelMatch(vector<string>& queries, string p) {

vector<bool> ans;

for (const string& q : queries)

ans.push_back(match(q, p));

return ans;

}

private:

bool match(const string& q, const string& p) {

int m = p.length();

int n = q.length();

int i = 0;

int j = 0;

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

if (j == m && isupper(q[i])) return false;

if ((j == m || isupper(p[j])) && islower(q[i])) continue;

if ((isupper(p[j]) || isupper(q[i])) && p[j] != q[i]) return false;

if (islower(p[j]) && p[j] != q[i]) continue;

++j;

}

return i == n && j == m;

}

};

LeetCode 1024. Video Stitching

Solution 1: DP

Time complexity: O(nT^2)
Space complexity: O(T^2)

C++

// Author: Huahua, 16 ms / 9.5 MB

class Solution {

public:

int videoStitching(vector<vector<int>>& clips, int T) {

constexpr int kInf = 101;

// dp[i][j] := min clips to cover range [i, j]

vector<vector<int>> dp(T + 1, vector<int>(T + 1, kInf));

for (const auto& c : clips) {

int s = c[0];

int e = c[1];

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

for (int i = 0; i <= T - l; ++i) {

int j = i + l;

if (s > j || e < i) continue;

if (s <= i && e >= j) dp[i][j] = 1;

else if (e >= j) dp[i][j] = min(dp[i][j], dp[i][s] + 1);

else if (s <= i) dp[i][j] = min(dp[i][j], dp[e][j] + 1);

else dp[i][j] = min(dp[i][j], dp[i][s] + 1 + dp[e][j]);

}

return dp[0][T] == kInf ? -1 : dp[0][T];

}

};

C++/V2

// Author: Huahua, running time: 20 ms / 9.4 MB

class Solution {

public:

int videoStitching(vector<vector<int>>& clips, int T) {

constexpr int kInf = 101;

// dp[i][j] := min clips to cover range [i, j]

vector<vector<int>> dp(T + 1, vector<int>(T + 1));

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

for (int j = 0; j <= T; ++j)

dp[i][j] = i < j ? kInf : 0;

for (const auto& c : clips) {

const int s = min(c[0], T);

const int e = min(c[1], T);

for (int l = 1; l <= T; ++l)

for (int i = 0, j = l; j <= T; ++i, ++j)

dp[i][j] = min(dp[i][j], dp[i][s] + 1 + dp[e][j]);

}

return dp[0][T] == kInf ? -1 : dp[0][T];

}

};

花花酱 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 Weekly 125

By zxi on February 24, 2019

Problems

LeetCode Weekly Contest 124

By zxi on February 17, 2019

Posts published in “Leetcode”

花花酱 LeetCode Weekly Contest 131 (1021, 1022, 1023, 1024)

C++

C++

C++

C++

C++/V2

花花酱 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 Weekly 125

Problems

LeetCode Weekly Contest 124

Solutions