Posts tagged as “medium”

花花酱 LeetCode 921. Minimum Add to Make Parentheses Valid

By zxi on October 13, 2018

Given a string S of '(' and ')' parentheses, we add the minimum number of parentheses ( '(' or ')', and in any positions ) so that the resulting parentheses string is valid.

Formally, a parentheses string is valid if and only if:

It is the empty string, or
It can be written as AB (A concatenated with B), where A and B are valid strings, or
It can be written as (A), where A is a valid string.

Given a parentheses string, return the minimum number of parentheses we must add to make the resulting string valid.

Example 1:

Input: "())"
Output: 1

Example 2:

Input: "((("
Output: 3

Example 3:

Input: "()"
Output: 0

Example 4:

Input: "()))(("
Output: 4

Note:

S.length <= 1000
S only consists of '(' and ')' characters.

Solution: Counting

Time complexity: O(n)

Space complexity: O(1)

C++

// Author: Huahua

class Solution {

public:

int minAddToMakeValid(string S) {

int l = 0;

int m = 0;

for (char c : S) {

if (c == '(') ++l;

if (c == ')' && l > 0) {

--l;

++m;

}

return S.size() - m * 2;

}

};

花花酱 LeetCode 923. 3Sum With Multiplicity

By zxi on October 13, 2018

Problem

Given an integer array A, and an integer target, return the number of tuples i, j, k such that i < j < k and A[i] + A[j] + A[k] == target.

As the answer can be very large, return it modulo 10^9 + 7.

Example 1:

Input: A = [1,1,2,2,3,3,4,4,5,5], target = 8
Output: 20
Explanation: 
Enumerating by the values (A[i], A[j], A[k]):
(1, 2, 5) occurs 8 times;
(1, 3, 4) occurs 8 times;
(2, 2, 4) occurs 2 times;
(2, 3, 3) occurs 2 times.

Example 2:

Input: A = [1,1,2,2,2,2], target = 5
Output: 12
Explanation: 
A[i] = 1, A[j] = A[k] = 2 occurs 12 times:
We choose one 1 from [1,1] in 2 ways,
and two 2s from [2,2,2,2] in 6 ways.

Note:

3 <= A.length <= 3000
0 <= A[i] <= 100
0 <= target <= 300

Solution: Math / Combination

Time complexity: O(n + |target|^2)

Space complexity: O(|target|)

C++

// Author: Huahua, runtime: 4 ms

class Solution {

public:

int threeSumMulti(vector<int>& A, int target) {

constexpr int kMaxN = 100;

constexpr int kMod = 1e9 + 7;

vector<long> c(kMaxN + 1, 0);

for (int a : A) ++c[a];

long ans = 0;

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

for (int j = i; j <= target; ++j) {

const int k = target - i - j;

if (k < 0 || k >= c.size() || k < j) continue;

if (!c[i] || !c[j] || !c[k]) continue;

if (i == j && j == k)

ans += (c[i] - 2) * (c[i] - 1) * c[i] / 6;

else if (i == j && j != k)

ans += c[i] * (c[i] - 1) / 2 * c[k];

else if (i != j && j == k)

ans += c[i] * (c[j] - 1) * c[j] / 2;

else

ans += c[i] * c[j] * c[k];

}

return ans % kMod;

}

};

花花酱 LeetCode 31. Next Permutation

By zxi on October 2, 2018

Problem

Implement next permutation, which rearranges numbers into the lexicographically next greater permutation of numbers.

If such arrangement is not possible, it must rearrange it as the lowest possible order (ie, sorted in ascending order).

The replacement must be in-place and use only constant extra memory.

Here are some examples. Inputs are in the left-hand column and its corresponding outputs are in the right-hand column.

1,2,3 → 1,3,2
3,2,1 → 1,2,3
1,1,5 → 1,5,1

Solution

Find the last acceding element x, swap with the smallest number y, y is after x that and y is greater than x.

Reverse the elements after x.

Time complexity: O(n)

Space complexity: O(1)

C++

// Author: Huahua, 8 ms

class Solution {

public:

void nextPermutation(vector<int>& nums) {

int i = nums.size() - 2;

while (i >= 0 && nums[i + 1] <= nums[i]) --i;

if (i >= 0) {

int j = nums.size() - 1;

while (j >= 0 && nums[j] <= nums[i]) --j;

swap(nums[i], nums[j]);

}

reverse(begin(nums) + i + 1, end(nums));

}

};

Python3

# Author: Huahua, 48 ms

class Solution:

def nextPermutation(self, nums):

n = len(nums)

i = n - 2

while i >= 0 and nums[i] >= nums[i + 1]: i -= 1

if i >= 0:

j = n - 1

while j >= 0 and nums[j] <= nums[i]: j -= 1

nums[i], nums[j] = nums[j], nums[i]

nums[i + 1:] = nums[i+1:][::-1]

花花酱 LeetCode 915. Partition Array into Disjoint Intervals

By zxi on September 30, 2018

Problem

Given an array A, partition it into two (contiguous) subarrays left and right so that:

Every element in left is less than or equal to every element in right.
left and right are non-empty.
left has the smallest possible size.

Return the length of left after such a partitioning. It is guaranteed that such a partitioning exists.

Example 1:

Input: [5,0,3,8,6]
Output: 3
Explanation: left = [5,0,3], right = [8,6]

Example 2:

Input: [1,1,1,0,6,12]
Output: 4
Explanation: left = [1,1,1,0], right = [6,12]

Note:

2 <= A.length <= 30000
0 <= A[i] <= 10^6
It is guaranteed there is at least one way to partition A as described.

Solution 1: BST

Time complexity: O(nlogn)

Space complexity: O(n)

C++

// Author: Huahua, 100 ms

class Solution {

public:

int partitionDisjoint(vector<int>& A) {

multiset<int> s(begin(A) + 1, end(A));

int left_max = A[0];

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

if (*begin(s) >= left_max) return i;

s.erase(s.equal_range(A[i]).first);

left_max = max(left_max, A[i]);

}

return -1;

}

};

Solution 2: Greedy

Time complexity: O(n)

Space complexity: O(1)

C++

// Author: Huahua, 28 ms

class Solution {

public:

int partitionDisjoint(vector<int>& A) {

int left_max = A[0];

int cur_max = A[0];

int left_len = 1;

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

if (A[i] < left_max) {

left_max = cur_max;

left_len = i + 1;

} else {

cur_max = max(cur_max, A[i]);

}

return left_len;

}

};

花花酱 LeetCode 916. Word Subsets

By zxi on September 30, 2018

Problem

We are given two arrays A and B of words. Each word is a string of lowercase letters.

Now, say that word b is a subset of word a if every letter in b occurs in a, including multiplicity. For example, "wrr" is a subset of "warrior", but is not a subset of "world".

Now say a word a from A is universal if for every b in B, b is a subset of a.

Return a list of all universal words in A. You can return the words in any order.

Example 1:

Input: A = ["amazon","apple","facebook","google","leetcode"], B = ["e","o"]
Output: ["facebook","google","leetcode"]

Example 2:

Input: A = ["amazon","apple","facebook","google","leetcode"], B = ["l","e"]
Output: ["apple","google","leetcode"]

Example 3:

Input: A = ["amazon","apple","facebook","google","leetcode"], B = ["e","oo"]
Output: ["facebook","google"]

Example 4:

Input: A = ["amazon","apple","facebook","google","leetcode"], B = ["lo","eo"]
Output: ["google","leetcode"]

Example 5:

Input: A = ["amazon","apple","facebook","google","leetcode"], B = ["ec","oc","ceo"]
Output: ["facebook","leetcode"]

Note:

1 <= A.length, B.length <= 10000
1 <= A[i].length, B[i].length <= 10
A[i] and B[i] consist only of lowercase letters.
All words in A[i] are unique: there isn’t i != j with A[i] == A[j].

Solution: Hashtable

Find the max requirement for each letter from B.

Time complexity: O(|A|+|B|)

Space complexity: O(26)

C++

// Author: Huahua, 104 ms

class Solution {

public:

vector<string> wordSubsets(vector<string>& A, vector<string>& B) {

vector<int> req(26);

for (const string& b : B) {

vector<int> cur(getCount(b));

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

req[i] = max(req[i], cur[i]);

}

vector<string> ans;

for (const string& a : A) {

vector<int> cur(getCount(a));

bool universal = true;

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

if (cur[i] < req[i]) {

universal = false;

break;

}

if (universal) ans.push_back(a);

}

return ans;

}

private:

vector<int> getCount(const string& a) {

vector<int> count(26);

for (char c : a)

++count[c - 'a'];

return count;

}

};