花花酱 LeetCode 20. Valid Parentheses

By zxi on October 2, 2018

Problem

Given a string containing just the characters '(', ')', '{', '}', '[' and ']', determine if the input string is valid.

An input string is valid if:

Open brackets must be closed by the same type of brackets.
Open brackets must be closed in the correct order.

Note that an empty string is also considered valid.

Example 1:

Input: "()"
Output: true

Example 2:

Input: "()[]{}"
Output: true

Example 3:

Input: "(]"
Output: false

Example 4:

Input: "([)]"
Output: false

Example 5:

Input: "{[]}"
Output: true

Solution: Stack

Using a stack to track the existing open parentheses, if the current one is a close parenthesis but does not match the top of the stack, return false, otherwise pop the stack. Check whether the stack is empty in the end.

Time complexity: O(n)

Space complexity: O(n)

C++

// Author: Huahua, 0 ms

class Solution {

public:

bool isValid(string s) {

map<char, char> p{{')', '('}, {']', '['}, {'}', '{'}};

stack<char> st;

for (char c : s) {

if (!p.count(c)) {

st.push(c);

} else {

if (st.empty() || p[c] != st.top()) return false;

st.pop();

}

return st.empty();

}

};

Python3

# Author: Huahua

class Solution:

def isValid(self, s):

p = {')' : '(', ']': '[', '}' : '{'}

stack = []

for c in s:

if c not in p:

stack.append(c)

else:

if not stack or stack[-1] != p[c]: return False

stack.pop()

return not stack

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;

}

};

花花酱 LeetCode 914. X of a Kind in a Deck of Cards

By zxi on September 30, 2018

Problem

n a deck of cards, each card has an integer written on it.

Return true if and only if you can choose X >= 2 such that it is possible to split the entire deck into 1 or more groups of cards, where:

Each group has exactly X cards.
All the cards in each group have the same integer.

Example 1:

Input: [1,2,3,4,4,3,2,1]
Output: true
Explanation: Possible partition [1,1],[2,2],[3,3],[4,4]

Example 2:

Input: [1,1,1,2,2,2,3,3]
Output: false
Explanation: No possible partition.

Example 3:

Input: [1]
Output: false
Explanation: No possible partition.

Example 4:

Input: [1,1]
Output: true
Explanation: Possible partition [1,1]

Example 5:

Input: [1,1,2,2,2,2]
Output: true
Explanation: Possible partition [1,1],[2,2],[2,2]

Note:

1 <= deck.length <= 10000
0 <= deck[i] < 10000

Solution 1: HashTable + Brute Force

Try all possible Xs. 2 ~ deck.size()

Time complexity: ~O(n)

Space complexity: O(1)

C++

// Author: Huahua, 16 ms

class Solution {

public:

bool hasGroupsSizeX(vector<int>& deck) {

unordered_map<int, int> counts;

for (int card : deck) ++counts[card];

for (int i = 2; i <= deck.size(); ++i) {

if (deck.size() % i) continue;

bool ok = true;

for (const auto& pair : counts)

if (pair.second % i) {

ok = false;

break;

}

if (ok) return true;

}

return false;

}

};

Solution 2: HashTable + GCD

Time complexity: O(nlogn)

Space complexity: O(1)

C++

// Author: Huahua, 16 ms

class Solution {

public:

bool hasGroupsSizeX(vector<int>& deck) {

unordered_map<int, int> counts;

for (int card : deck) ++counts[card];

int X = deck.size();

for (const auto& p : counts)

X = __gcd(X, p.second);

return X >= 2;

}

};

Java

// Author: Somebody

class Solution {

public boolean hasGroupsSizeX(int[] deck) {

HashMap<Integer, Integer> map = new HashMap<Integer, Integer>();

for (int i=0; i<deck.length; i++) {

int curr = deck[i];

if (map.containsKey(curr)) {

map.put(curr, map.get(curr) + 1);

} else {

map.put(curr, 1);

}

// O(nLogn)

int gcd = 0;

for(Integer key: map.keySet()) {

gcd = findGCDOfTwoNumbers(map.get(key), gcd);

}

return gcd >= 2;

}

// O(Log n)

public static int findGCDOfTwoNumbers (int a, int b) {

if (b == 0) {

return a;

}

return findGCDOfTwoNumbers(b, a%b);

}

花花酱 LeetCode 20. Valid Parentheses

Problem

Solution: Stack

C++

Python3

Related Problems

花花酱 LeetCode 915. Partition Array into Disjoint Intervals

Problem

Solution 1: BST

C++

Solution 2: Greedy

C++

花花酱 LeetCode 916. Word Subsets

Problem

Solution: Hashtable

C++

花花酱 LeetCode 914. X of a Kind in a Deck of Cards

Problem

Solution 1: HashTable + Brute Force

C++

Solution 2: HashTable + GCD

C++

Java

Huahua's Tech Road

花花酱 LeetCode 23. Merge k Sorted Lists

Problem

Solution 1: Brute Force

C++

Solution 2: Heap / Priority Queue

C++

花花酱 LeetCode 20. Valid Parentheses

Problem

Solution: Stack

C++

Python3

Related Problems

花花酱 LeetCode 915. Partition Array into Disjoint Intervals

Problem

Solution 1: BST

C++

Solution 2: Greedy

C++

花花酱 LeetCode 916. Word Subsets

Problem

Solution: Hashtable

C++

花花酱 LeetCode 914. X of a Kind in a Deck of Cards

Problem

Solution 1: HashTable + Brute Force

C++

Solution 2: HashTable + GCD

C++

Java