子序列问-匹配子序列的单词数

792.匹配子序列的单词数

双指针

双指针的最坏计算次数 10^4 * 5000 = 10^7，直接超时

public class Main {
    public int numMatchingSubseq(String s, String[] words) {
        int count = 0;
        for (int i = 0; i < words.length; i++) {
            String word = words[i];
            int o = 0, e = 0;
            while (o < s.length() && e < word.length()) {
                if (s.charAt(o++) == word.charAt(e)) e++;
            }
            if (e == word.length()) count++;
        }
        return count;
    }
}

字母的特点 + 二分

另一种解法是根据26个小字母，用数组快速访问下标O(1)的特点去找到对应字母的下标。但是同一个字母可能会出现两次以上，那就保存多个字母的下标。因为下标本身就是顺序的，所以我们可以用二分去优化搜索的下标。

比如：s = "abcae", words = ["aba"]

a保存有0,3两个下标，当我们确定了b在s字符串中的下表是1的时候，我们就可以拿
1去a里边搜索，得到的结果就是words中第二个a在s字符串中的位置是2。

public class Binary {
    public int numMatchingSubseq(String s, String[] words) {
        ArrayList<Integer>[] arrayLists = new ArrayList[26];
        int count = words.length;
        for (int i = 0; i < 26; i++) {
            arrayLists[i] = new ArrayList<>();
        }
        for (int i = 0; i < s.length(); i++) {
            arrayLists[s.charAt(i) - 'a'].add(i);
        }
        for (int i = 0; i < words.length; i++) {
            String word = words[i];
            int p = -1;
            for (int j = 0; j < word.length(); j++) {
                char c = word.charAt(j);
                if (arrayLists[c - 'a'].isEmpty()
                        || arrayLists[c - 'a'].get(arrayLists[c - 'a'].size() - 1) <= p) {
                    count--;
                    break;
                }
                p = binarySearch(arrayLists[c - 'a'], p);
            }
        }
        return count;
    }

    private int binarySearch(ArrayList<Integer> array, int target) {
        int l = 0, r = array.size() - 1;
        while (l < r) {
            int mid = l + r >> 1;
            // 这里有个细节
            // 我们要搜索的坐标要往target靠近，所以等于的时候l=mid+1
            if (array.get(mid) <= target) l = mid + 1;
            else r = mid;
        }
        return array.get(l);
    }
}