[LeetCode] Number of Matching Subsequences 匹配的子序列的個數
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 inwordsthat are a subsequence ofS: "a", "acd", "ace".
Note:
- All words in
wordsandSwill only consists of lowercase letters. - The length of
Swill be in the range of[1, 50000]. - The length of
wordswill be in the range of[1, 5000]. - The length of
words[i]will be in the range of[1, 50].
這道題給了我們一個字串S，又給了一個單詞陣列，問我們陣列有多少個單詞是字串S的子序列。注意這裡是子序列，而不是子串，子序列並不需要連續。那麼只要我們知道如何驗證一個子序列的方法，那麼就可以先嚐試暴力搜尋法，就是對陣列中的每個單詞都驗證一下是否是字串S的子序列。驗證子序列的方法就是用兩個指標，對於子序列的每個一個字元，都需要在母字元中找到相同的，在母字串所有字串遍歷完之後或之前，只要子序列中的每個字元都在母字串中按順序找到了，那麼就驗證成功了。很不幸，這種暴力搜尋的方法在C++的解法版本中會TLE，貌似Java版本的可以通過，感覺C++被dis了誒～ However，我們可以進行優化呀，在暴力搜尋的基礎上稍作些優化，就可以騙過OJ啦。下面這種優化的motivation是由於看了使暴力搜尋跪了的那個test case，其實是words數組裡有大量相同的單詞，而且字串S巨長無比，那麼為了避免相同的單詞被不停的重複檢驗，我們用兩個HashSet來記錄驗證過的單詞，為啥要用兩個呢？因為驗證的結果有兩種，要麼通過，要麼失敗，我們要分別存在兩個HashSet中，這樣再遇到每種情況的單詞時，我們就知道要不要結果增1了。如果單詞沒有驗證過的話，那麼我們就用雙指標的方法進行驗證，然後根據結果的不同，存到相應的HashSet中去，參見程式碼如下：
解法一：
class Solution { public: int numMatchingSubseq(string S, vector<string>& words) { int res = 0, n = S.size(); unordered_set<string> pass, out; for (string word : words) { if (pass.count(word) || out.count(word)) {if (pass.count(word)) ++res; continue; } int i = 0, j = 0, m = word.size(); while (i < n && j < m) { if (word[j] == S[i]) ++j; ++i; } if (j == m) {++res; pass.insert(word);} else out.insert(word); } return res; } };
上面的解法已經優化的不錯了，但是我們還有更叼的方法。這種解法按照每個單詞的首字元進行群組，群組裡面儲存的是一個pair對，由當前字母和下一個位置組成的。然後在遍歷字串S的時候，根據當前遍歷到的字母，進入該字母對應的群組中處理，如果群組中某個pair的下一個位置已經等於單詞長度了，說明該單詞已經驗證完成，是子序列，結果自增1；否則的話就將下一個位置的字母提取出來，然後將pair中的下一個位置自增1後組成的新pair加入之前提取出的字母對應的群組中。是不是讀到這裡已然懵逼了，沒關係，博主會舉栗子來說明的，就拿題目中的那個例子來說吧：
S = "abcde"
words = ["a", "bb", "acd", "ace"]
那麼首先我們將words陣列中的單詞按照其首字母的不同放入對應的群組中，得到：
a -> {0, 1}, {2, 1}, {3, 1}
b -> {1, 1}
這裡，每個pair的第一個數字是該單詞在words中的位置，第二個數字是下一個字母的位置。比如 {0, 1} 表示 "a" 在words陣列中位置為0，且下一個位置為1（因為當前位置是首字母）。{2, 1} 表示 "acd" 在words陣列中位置為2，且下一個位置為1。{3, 1} 表示 "ace" 在words陣列中位置為3，且下一個位置為1。{1, 1} 表示 "bb" 在words陣列中位置為1，且下一個位置為1。
好，下面我們來遍歷字串S，第一個遇到的字母是 'a'。
那麼我們群組中a對應了三個pair，將其提取出來分別進行操作。首先處理 {0, 1}，此時我們發現下一個位置為1，和單詞"a"的長度相同了，說明是子序列，結果res自增1。然後處理 {2, 1}，在"acd"中取下一個位置1的字母為'c'，則將下一位置自增1後的新pair {2, 2} 加入c對應的群組。然後處理 {3, 1}，在"ace"中取下一個位置1的字母為'c'，則將下一位置自增1後的新pair {3, 2} 加入c對應的群組。則此時的群組為：
b -> {1, 1}
c -> {2, 2}, {3, 2}
好，繼續來遍歷字串S，第二個遇到的字母是 'b'。
那麼我們群組中b對應了一個pair，處理 {1, 1}，在"bb"中取下一個位置1的字母為'b'，則將下一位置自增1後的新pair {1, 2} 加入b對應的群組。則此時的群組為：
b -> {1, 2}
c -> {2, 2}, {3, 2}
好，繼續來遍歷字串S，第三個遇到的字母是 'c'。
那麼我們群組中c對應了兩個pair，將其提取出來分別進行操作。首先處理 {2, 2}，在"ace"中取下一個位置2的字母為'e'，則將下一位置自增1後的新pair {2, 3} 加入e對應的群組。然後處理 {3, 2}，在"acd"中取下一個位置2的字母為'd'，則將下一位置自增1後的新pair {3, 3} 加入d對應的群組。則此時的群組為：
b -> {1, 2}
d -> {3, 3}
e -> {2, 3}
好，繼續來遍歷字串S，第四個遇到的字母是 'd'。
那麼我們群組中d對應了一個pair，處理 {3, 3}，此時我們發現下一個位置為3，和單詞"acd"的長度相同了，說明是子序列，結果res自增1。則此時的群組為：
b -> {1, 2}
e -> {2, 3}
好，繼續來遍歷字串S，第五個遇到的字母是 'e'。
那麼我們群組中e對應了一個pair，處理 {2, 3}，此時我們發現下一個位置為3，和單詞"ace"的長度相同了，說明是子序列，結果res自增1。則此時的群組為：
b -> {1, 2}
此時S已經遍歷完了，已經沒有b了，說明"bb"不是子序列，這make sense，返回結果res即可，參見程式碼如下：
解法二：
class Solution { public: int numMatchingSubseq(string S, vector<string>& words) { vector<pair<int, int>> all[128]; int res = 0, n = words.size(); for (int i = 0; i < n; i++) { all[words[i][0]].emplace_back(i, 1); } for (char c : S) { auto vect = all[c]; all[c].clear(); for (auto it : vect) { if (it.second == words[it.first].size()) ++res; else all[words[it.first][it.second++]].push_back(it); } } return res; } };
類似題目：
參考資料：