Huahua’s Tech Road

花花酱 LeetCode 575. Distribute Candies

By zxi on March 5, 2018

题目大意：有一些不同种类的糖果，男生女生各得一半数量的糖果，问女生最多可能得到多少种不同种类的糖果。

Given an integer array with even length, where different numbers in this array represent different kinds of candies. Each number means one candy of the corresponding kind. You need to distribute these candies equally in number to brother and sister. Return the maximum number of kinds of candies the sister could gain.

Example 1:

Input: candies = [1,1,2,2,3,3]

Output: 3

Explanation:

There are three different kinds of candies (1, 2 and 3), and two candies for each kind.

Optimal distribution: The sister has candies [1,2,3] and the brother has candies [1,2,3], too.

The sister has three different kinds of candies.

Example 2:

Input: candies = [1,1,2,3]

Output: 2

Explanation: For example, the sister has candies [2,3] and the brother has candies [1,1].

The sister has two different kinds of candies, the brother has only one kind of candies.

Note:

The length of the given array is in range [2, 10,000], and will be even.
The number in given array is in range [-100,000, 100,000].

Solution 1: Greedy

Give all unique candies to sisters until they have n/2 candies.

Time complexity: O(n)

Space complexity: O(n)

C++ Hashset

// Author: Huahua

// Running time: 258 ms

class Solution {

public:

int distributeCandies(vector<int>& candies) {

unordered_set<int> kinds(candies.begin(), candies.end());

return min(kinds.size(), candies.size() / 2);

}

};

C++ Bitset

// Author: Huahua

// Running time: 195 ms (beats 97.61%)

class Solution {

public:

int distributeCandies(vector<int>& candies) {

constexpr int kMaxKinds = 200001;

constexpr int kOffset = 100000;

bitset<kMaxKinds> s;

for (int candy : candies)

if (!s.test(candy + kOffset))

s.set(candy + kOffset);

return std::min(s.count(), candies.size() / 2);

}

};

花花酱 LeetCode 793. Preimage Size of Factorial Zeroes Function

By zxi on March 4, 2018

Let f(x) be the number of zeroes at the end of x!. (Recall that x! = 1 * 2 * 3 * ... * x, and by convention, 0! = 1.)

For example, f(3) = 0 because 3! = 6 has no zeroes at the end, while f(11) = 2 because 11! = 39916800 has 2 zeroes at the end. Given K, find how many non-negative integers x have the property that f(x) = K.

Example 1:

Input: K = 0

Output: 5

Explanation: 0!, 1!, 2!, 3!, and 4! end with K = 0 zeroes.

Example 2:

Input: K = 5

Output: 0

Explanation: There is no x such that x! ends in K = 5 zeroes.

Note:

K will be an integer in the range [0, 10^9].

Idea:

First we need to compute how many trailing zeros n! has.

See 花花酱 LeetCode 172. Factorial Trailing Zeroes for details

It’s hard to say how many numbers have trailing zeros equals to K, but we can find the largest number p whose trailing zeros is K using binary search. (p+1)! has more than K trailing zeros. And do the same thing to find the largest number q whose trailing zeros is K – 1 using binary search.

Then we know that are exact p numbers 1,2,…,p whose trailing zeros are less or equal to K.

And exact q numbers 1, 2, …, q whose trailing zeros are less or equal to K – 1.

q + 1, q + 2, …, m (m – q numbers in total) the numbers with trailing zeros equal to K.

Solution 1: Math + Binary Search

Time complexity: O(log2(INT_MAX)*log5(INT_MAX))

Space complexity: O(1)

C++

// Author: Huahua

// Running time: 3 ms

class Solution {

public:

int preimageSizeFZF(int K) {

return g(K) - g(K - 1);

}

private:

// Find the largest number l, that numZeros(l!) == K and numZeros((l+1)!) > K

int g(int K) {

int l = 0;

int r = INT_MAX;

while (l < r) {

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

int zeros = numZeros(m);

if (zeros <= K)

l = m + 1;

else

r = m;

}

return l;

}

int numZeros(int n) {

return n < 5 ? 0 : n / 5 + numZeros(n / 5);

}

};

花花酱 LeetCode 792. Number of Matching Subsequences

By zxi on March 3, 2018

题目大意：给你一些单词，问有多少单词出现在字符串S的子序列中。

https://leetcode.com/problems/number-of-matching-subsequences/description/

Given string S and a dictionary of words words, find the number of words[i] that is a subsequence of S.

Example :

Input:

S = "abcde"

words = ["a", "bb", "acd", "ace"]

Output: 3

Explanation: There are three words in <code>words</code> that are a subsequence of <code>S</code>: "a", "acd", "ace".

Note:

All words in words and S will only consists of lowercase letters.
The length of S will be in the range of [1, 50000].
The length of words will be in the range of [1, 5000].
The length of words[i] will be in the range of [1, 50].

Solution 1: Brute Force

Time complexity: O((S + L) * W)

C++ w/o cache TLE

Space complexity: O(1)

C++ w/ cache 155 ms

Space complexity: O(W * L)

// Author: Huahua

// Running time: 155 ms

class Solution {

public:

int numMatchingSubseq(const string& S, vector<string>& words) {

int ans = 0;

unordered_map<string, bool> m;

for (const string& word : words) {

auto it = m.find(word);

if (it == m.end()) {

bool match = isMatch(word, S);

ans += m[word] = match;

} else {

ans += it->second;

}

return ans;

}

private:

bool isMatch(const string& word, const string& S) {

int start = 0;

for (const char c : word) {

bool found = false;

for (int i = start; i < S.length(); ++i)

if (S[i] == c) {

found = true;

start = i + 1;

break;

}

if (!found) return false;

}

return true;

}

};

Solution 2: Indexing+ Binary Search

Time complexity: O(S + W * L * log(S))

Space complexity: O(S)

S: length of S

W: number of words

L: length of a word

C++

// Author: Huahua

// Running time: 183 ms

class Solution {

public:

int numMatchingSubseq(const string& S, vector<string>& words) {

vector<vector<int>> pos(128);

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

pos[S[i]].push_back(i);

int ans = 0;

for (const string& word : words)

ans += isMatch(word, pos);

return ans;

}

private:

unordered_map<string, bool> m_;

bool isMatch(const string& word, const vector<vector<int>>& pos) {

if (m_.count(word)) return m_[word];

int last_index = -1;

for (const char c : word) {

const vector<int>& p = pos[c];

const auto it = std::lower_bound(p.begin(), p.end(), last_index + 1);

if (it == p.end()) return m_[word] = false;

last_index = *it;

}

return m_[word] = true;

}

};

Java

// Author: Huahua

// Running time: 135 ms

class Solution {

private List<List<Integer>> pos;

private boolean isMatch(String word) {

int l = -1;

for (char c : word.toCharArray()) {

List<Integer> p = pos.get(c);

int index = Collections.binarySearch(p, l + 1);

if (index < 0) index = -index - 1;

if (index >= p.size()) return false;

l = p.get(index);

}

return true;

}

public int numMatchingSubseq(String S, String[] words) {

pos = new ArrayList<>();

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

pos.add(new ArrayList<Integer>());

char[] s = S.toCharArray();

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

pos.get(s[i]).add(i);

int ans = 0;

for (String word : words)

if (isMatch(word)) ++ans;

return ans;

}

Python 3:

w/o cache

"""

Author: Huahua

Running time: 1120 ms

"""

class Solution:

def numMatchingSubseq(self, S, words):

import bisect

def isMatch(word):

l = -1

for c in word:

index = bisect.bisect_left(pos[c], l + 1)

if index == len(pos[c]): return 0

l = pos[c][index]

return 1

pos = {chr(i + ord('a')) : [] for i in range(26)}

for i, c in enumerate(S):

pos[c].append(i)

return sum(map(isMatch, words))

w/ cache

"""

Author: Huahua

Running time: 632 ms

"""

class Solution:

def numMatchingSubseq(self, S, words):

import bisect

def isMatch(word):

if word in m: return m[word]

l = -1

for c in word:

index = bisect.bisect_left(pos[c], l + 1)

if index == len(pos[c]):

m[word] = 0

return 0

l = pos[c][index]

m[word] = 1

return 1

m = {}

pos = {chr(i + ord('a')) : [] for i in range(26)}

for i, c in enumerate(S):

pos[c].append(i)

return sum(map(isMatch, words))

花花酱 LeetCode 795. Number of Subarrays with Bounded Maximum

By zxi on March 3, 2018

题目大意：问一个数组中有多少个子数组的最大元素值在[L, R]的范围里。

We are given an array A of positive integers, and two positive integers L and R (L <= R).

Return the number of (contiguous, non-empty) subarrays such that the value of the maximum array element in that subarray is at least L and at most R.

Example :

Input:

A = [2, 1, 4, 3]

L = 2

R = 3

Output: 3

Explanation: There are three subarrays that meet the requirements: [2], [2, 1], [3].

Solution 1:

C++

// Author: Huahua

// Running time: 42 ms

class Solution {

public:

int numSubarrayBoundedMax(vector<int>& A, int L, int R) {

return count(A, R) - count(A, L - 1);

}

private:

// Count # of sub arrays whose max element is <= N

int count(const vector<int>& A, int N) {

int ans = 0;

int cur = 0;

for (int a: A) {

if (a <= N)

ans += ++cur;

else

cur = 0;

}

return ans;

}

};

Solution 2: One pass

C++

// Author: Huahua

// Running time: 38 ms

class Solution {

public:

int numSubarrayBoundedMax(vector<int>& A, int L, int R) {

int ans = 0;

int left = -1;

int right = -1;

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

if (A[i] >= L) right = i;

if (A[i] > R) left = i;

ans += (right - left);

}

return ans;

}

};

花花酱 LeetCode 794. Valid Tic-Tac-Toe State

By zxi on March 3, 2018

题目大意：判断一个井字棋的棋盘是否有效。

A Tic-Tac-Toe board is given as a string array board. Return True if and only if it is possible to reach this board position during the course of a valid tic-tac-toe game.

The board is a 3 x 3 array, and consists of characters " ", "X", and "O". The ” ” character represents an empty square.

Here are the rules of Tic-Tac-Toe:

Players take turns placing characters into empty squares (” “).
The first player always places “X” characters, while the second player always places “O” characters.
“X” and “O” characters are always placed into empty squares, never filled ones.
The game ends when there are 3 of the same (non-empty) character filling any row, column, or diagonal.
The game also ends if all squares are non-empty.
No more moves can be played if the game is over.

Example 1:

Input: board = ["O ", " ", " "]

Output: false

Explanation: The first player always plays "X".

Example 2:

Input: board = ["XOX", " X ", " "]

Output: false

Explanation: Players take turns making moves.

Example 3:

Input: board = ["XXX", " ", "OOO"]

Output: false

Example 4:

Input: board = ["XOX", "O O", "XOX"]

Output: true

Note:

board is a length-3 array of strings, where each string board[i] has length 3.
Each board[i][j] is a character in the set {" ", "X", "O"}.

Idea: Verify all rules

C++

class Solution {

public:

bool validTicTacToe(vector<string>& board) {

int x = 0;

int o = 0;

int wins_x = getWins(board, 'X', x);

int wins_o = getWins(board, 'O', o);

return wins_x + wins_o <= 1 && x >= o + wins_x && x <= o + 1 - wins_o;

}

private:

int getWins(const vector<string>& board, char p, int& count) {

vector<string> rows(3);

string diag1, diag2;

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

diag1 += board[i][i];

diag2 += board[i][2 - i];

for (int j = 0; j < 3; ++j) {

char c = board[i][j];

rows[j] += c;

count += c == p;

}

string win(3, p);

int wins = (diag1 == win) + (diag2 == win);

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

wins += rows[i] == win;

wins += board[i] == win;

}

return wins;

}

};

Huahua's Tech Road

花花酱 LeetCode 575. Distribute Candies

花花酱 LeetCode 793. Preimage Size of Factorial Zeroes Function

花花酱 LeetCode 792. Number of Matching Subsequences

花花酱 LeetCode 795. Number of Subarrays with Bounded Maximum

花花酱 LeetCode 794. Valid Tic-Tac-Toe State