Create 792. 匹配子序列的单词数.md

Author: CompetitiveLin

Dichotomy/792. 匹配子序列的单词数.md

@@ -0,0 +1,131 @@
+#### 792. 匹配子序列的单词数
+
+难度：中等
+
+---
+
+给定字符串 `s` 和字符串数组 `words`, 返回  _`words[i]` 中是`s`的子序列的单词个数_ 。
+
+字符串的  **子序列**  是从原始字符串中生成的新字符串，可以从中删去一些字符(可以是none)，而不改变其余字符的相对顺序。
+
+*   例如， `“ace”` 是 `“abcde”` 的子序列。
+
+ **示例 1:** 
+
+```
+输入: s = "abcde", words = ["a","bb","acd","ace"]
+输出: 3
+解释: 有三个是 s 的子序列的单词: "a", "acd", "ace"。
+```
+
+ **Example 2:** 
+
+```
+输入: s = "dsahjpjauf", words = ["ahjpjau","ja","ahbwzgqnuk","tnmlanowax"]
+输出: 2
+```
+
+ **提示:** 
+
+*   `1 <= s.length <= 5 * 10^4`
+*   `1 <= words.length <= 5000`
+*   `1 <= words[i].length <= 50`
+*   `words[i]`和 s 都只由小写字母组成。
+
+---
+
+因为题目要求子序列是不改变字符的相对顺序的序列，那么将字符串 `s` 中的所有字符下标按顺序存放到 26 个字母表的下标列表中，针对 `words` 字符串数组中的每一个字符串，检查每个字符在字符串 `s` 中的下标是否按升序排序即可。
+
+但是需要注意的是，上述检查的过程中需要用到二分查找，否则会超时。寻找的内容是大于 `index` (初始值为 `-1` )的最小下标，例如在下标数组 `{0, 1, 4, 6}` 中寻找大于 `index = 2` 最小下标，即下标为 `2`，值为 `4`，接着将 `index` 赋值为 `4` 接着寻找下一个下标。
+
+```java
+class Solution {
+    public int numMatchingSubseq(String s, String[] words) {
+        ArrayList<Integer>[] list = new ArrayList[26];
+        for(int i = 0; i < 26; i++){
+            list[i] = new ArrayList<>();
+        }
+        for(int i = 0; i < s.length(); i++){
+            list[s.charAt(i) - 'a'].add(i);
+        }
+        int ans = words.length;
+        for(String word: words){
+            int index = -1;
+            for(int i = 0; i < word.length(); i++){
+                char c = word.charAt(i);
+                if(list[c - 'a'].isEmpty() || index >= list[c - 'a'].get(list[c - 'a'].size() - 1)){
+                    ans--;
+                    break;
+                }
+                int left = 0, right = list[c - 'a'].size();
+                while(left < right){
+                    int mid = (left + right) >>> 1;
+                    if(list[c - 'a'].get(mid) > index) right = mid;
+                    else left = mid + 1;
+                }
+                index = list[c - 'a'].get(left);
+            }
+        }
+        return ans;
+    }
+}
+```
+
+---
+
+#### 补充
+
+与[寻找左右边界](https://github.com/CompetitiveLin/Leetcode/blob/61cb8c9c65c1e2f1784aaab92fb95ee78c67eea7/Dichotomy/704.%20%E4%BA%8C%E5%88%86%E6%9F%A5%E6%89%BE.md#%E8%A1%A5%E5%85%85)类似，下面两部分展示的是求小于 `target` 的最大下标以及大于 `target ` 的最小下标。
+
+**寻找最大下标**
+
+在一个升序数组（数组内数字可重复）中，求小于 `target` 的最大下标，返回值的范围为 `[-1, arrays.length - 1]`。
+
+`-1` 代表数组内的所有数都比 `target` 大，`arrays.length - 1` 代表数组内所有数都比 `target` 小。
+
+```java
+/**
+*
+* @param arrays
+* @param left = 0
+* @param right = arrays.length
+* @param target
+* @return
+*/
+public static int rightmost_before(int[] arrays, int left, int right, int target){
+    while(left < right){
+        int mid = left + (right - left) / 2;
+        if(target > arrays[mid]){
+            left = mid + 1;
+        } else right = mid;
+    }
+    return left - 1;
+}
+```
+
+**寻找最小下标**
+
+在一个升序数组（数组内数字可重复）中，大于 `target` 的最小下标，返回值的范围为 `[0, arrays.length]`。
+
+`0` 代表数组内的所有数都比 `target` 大，`arrays.length` 代表数组内所有数都比 `target` 小。
+
+```java
+/**
+*
+* @param arrays
+* @param left = 0
+* @param right = arrays.length
+* @param target
+* @return
+*/
+public static int leftmost_after(int[] arrays, int left, int right, int target){
+    while(left < right){
+        int mid = left + (right - left) / 2;
+        if(target < arrays[mid]){
+            right = mid;
+        } else left = mid + 1;
+    }
+    return left;
+}
+```
+