花花酱 LeetCode 594. Longest Harmonious Subsequence

By zxi on March 20, 2018

Problem

https://leetcode.com/problems/longest-harmonious-subsequence/description/

题目大意：找一个最长子序列，要求子序列中最大值和最小值的差是1。

We define a harmonious array is an array where the difference between its maximum value and its minimum value is exactly 1.

Now, given an integer array, you need to find the length of its longest harmonious subsequence among all its possible subsequences.

Example 1:

Input: [1,3,2,2,5,2,3,7]
Output: 5
Explanation: The longest harmonious subsequence is [3,2,2,2,3].

Note: The length of the input array will not exceed 20,000.

Solution1: HashTable

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

C++

// Author: Huahua

// Running time: 127 ms

class Solution {

public:

int findLHS(vector<int>& nums) {

unordered_map<int, int> counts;

int ans = 0;

for (int num : nums) {

++counts[num];

int l = counts[num - 1];

int h = counts[num + 1];

if (l || h)

ans = max(ans, counts[num] + max(l, h));

}

return ans;

}

};

// Running time: 109 ms

class Solution {

public:

int findLHS(vector<int>& nums) {

unordered_map<int, int> counts;

int ans = 0;

for (int num : nums) {

const int c = ++counts[num];

auto it1 = counts.find(num - 1);

auto it2 = counts.find(num + 1);

if (it1 != counts.end())

ans = max(ans, c + it1->second);

if (it2 != counts.end())

ans = max(ans, c + it2->second);

}

return ans;

}

};

// Author: Huahua

// Running time: 102 ms

class Solution {

public:

int findLHS(vector<int>& nums) {

unordered_map<int, int> counts;

int ans = 0;

for (int num : nums)

++counts[num];

for (const auto& p : counts) {

auto it1 = counts.find(p.first - 1);

auto it2 = counts.find(p.first + 1);

if (it1 != counts.end())

ans = max(ans, p.second + it1->second);

if (it2 != counts.end())

ans = max(ans, p.second + it2->second);

}

return ans;

}

};

花花酱 LeetCode 392. Is Subsequence

By zxi on March 16, 2018

题目大意：问s是不是t的子序列。

Problem:

https://leetcode.com/problems/is-subsequence/description/

Given a string s and a string t, check if s is subsequence of t.

You may assume that there is only lower case English letters in both s and t. t is potentially a very long (length ~= 500,000) string, and sis a short string (<=100).

A subsequence of a string is a new string which is formed from the original string by deleting some (can be none) of the characters without disturbing the relative positions of the remaining characters. (ie, "ace" is a subsequence of "abcde" while "aec" is not).

Example 1:
s = "abc", t = "ahbgdc"

Return true.

Example 2:
s = "axc", t = "ahbgdc"

Return false.

Follow up:
If there are lots of incoming S, say S1, S2, … , Sk where k >= 1B, and you want to check one by one to see if T has its subsequence. In this scenario, how would you change your code?

Solution: Brute force

Time Complexity: O(|s| + |t|)

Space Complexity: O(1)

C++

// Author: Huahua

// Running time: 65 ms (beats 99.37%)

class Solution {

public:

bool isSubsequence(const string& s, const string& t) {

int i = 0;

const int n = t.length();

for (const char c : s) {

while (i < n && t[i] != c) ++i;

if (i++ == n) return false;

}

return true;

}

};

花花酱 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))

Posts tagged as “subsequence”

花花酱 LeetCode 594. Longest Harmonious Subsequence

Problem

Solution1: HashTable

花花酱 LeetCode 392. Is Subsequence

Problem:

Solution: Brute force

花花酱 LeetCode 792. Number of Matching Subsequences