1898. Maximum Number of Removable Characters

https://leetcode.com/problems/maximum-number-of-removable-characters/

You are given two strings s and p where p is a subsequence of s. You are also given a distinct 0-indexed integer array removable containing a subset of indices of s (s is also 0-indexed).

You want to choose an integer k (0 <= k <= removable.length) such that, after removing k characters from s using the first k indices in removable, p is still a subsequence of s. More formally, you will mark the character at s[removable[i]] for each 0 <= i < k, then remove all marked characters and check if p is still a subsequence.

Return the maximum k you can choose such that p is still a subsequence of s after the removals.

A subsequence of a string is a new string generated from the original string with some characters (can be none) deleted without changing the relative order of the remaining characters.

Example 1:

Input: s = "abcacb", p = "ab", removable = [3,1,0]
Output: 2
Explanation: After removing the characters at indices 3 and 1, "abcacb" becomes "accb".
"ab" is a subsequence of "accb".
If we remove the characters at indices 3, 1, and 0, "abcacb" becomes "ccb", and "ab" is no longer a subsequence.
Hence, the maximum k is 2.

Example 2:

Input: s = "abcbddddd", p = "abcd", removable = [3,2,1,4,5,6]
Output: 1
Explanation: After removing the character at index 3, "abcbddddd" becomes "abcddddd".
"abcd" is a subsequence of "abcddddd".

Example 3:

Input: s = "abcab", p = "abc", removable = [0,1,2,3,4]
Output: 0
Explanation: If you remove the first index in the array removable, "abc" is no longer a subsequence.

Constraints:

• 1 <= p.length <= s.length <= 105

• 0 <= removable.length < s.length

• 0 <= removable[i] < s.length

• p is a subsequence of s.

• s and p both consist of lowercase English letters.

• The elements in removable are distinct.

对字符串s，removeable中元素值为s的元素index，表示s中对应序号的字符将被删除，问对removable从前往后最多能取多少个index删除，使得p依然是s的子序列。暴力是从头往后依次检查removable是否满足条件，O(N^2)。进一步想如果removable某元素m满足条件，那m之前的已经包括在里头，肯定都满足=>二分，O(NlgN)。

class Solution:
    def maximumRemovals(self, s: str, p: str, removable: List[int]) -> int:
        def check(m):
            r = set(removable[:m + 1])
            i, j = 0, 0
            while i < len(s) and j < len(p):
                if i in r:
                    i += 1
                    continue
                if s[i] == p[j]:
                    j += 1
                i += 1
            return j == len(p)
        start, end = 0, len(removable)
        while start < end:
            m = start + (end - start) // 2
            if check(m):
                start = m + 1
            else:
                end = m
        return start