本文涉及的基础知识点

C++二分查找

LeetCode1898. 可移除字符的最大数目

给你两个字符串 s 和 p ，其中 p 是 s 的一个 子序列 。同时，给你一个元素 互不相同 且下标 从 0 开始 计数的整数数组 removable ，该数组是 s 中下标的一个子集（s 的下标也 从 0 开始 计数）。
请你找出一个整数 k（0 <= k <= removable.length），选出 removable 中的 前 k 个下标，然后从 s 中移除这些下标对应的 k 个字符。整数 k 需满足：在执行完上述步骤后， p 仍然是 s 的一个 子序列 。更正式的解释是，对于每个 0 <= i < k ，先标记出位于 s[removable[i]] 的字符，接着移除所有标记过的字符，然后检查 p 是否仍然是 s 的一个子序列。
返回你可以找出的 最大 k ，满足在移除字符后 p 仍然是 s 的一个子序列。
字符串的一个 子序列 是一个由原字符串生成的新字符串，生成过程中可能会移除原字符串中的一些字符（也可能不移除）但不改变剩余字符之间的相对顺序。
示例 1：
输入：s = “abcacb”, p = “ab”, removable = [3,1,0]
输出：2
解释：在移除下标 3 和 1 对应的字符后，“abcacb” 变成 “accb” 。
“ab” 是 “accb” 的一个子序列。
如果移除下标 3、1 和 0 对应的字符后，“abcacb” 变成 “ccb” ，那么 “ab” 就不再是 s 的一个子序列。
因此，最大的 k 是 2 。
示例 2：
输入：s = “abcbddddd”, p = “abcd”, removable = [3,2,1,4,5,6]
输出：1
解释：在移除下标 3 对应的字符后，“abcbddddd” 变成 “abcddddd” 。
“abcd” 是 “abcddddd” 的一个子序列。
示例 3：

输入：s = “abcab”, p = “abc”, removable = [0,1,2,3,4]
输出：0
解释：如果移除数组 removable 的第一个下标，“abc” 就不再是 s 的一个子序列。

提示：
1 <= p.length <= s.length <= 10⁵
0 <= removable.length < s.length
0 <= removable[i] < s.length
p 是 s 的一个 子字符串
s 和 p 都由小写英文字母组成
removable 中的元素 互不相同

C++二分查找

n = s.length()
m = removable.size()
二分查找类型：选择尾端
Check函数范围：[0,m]
Check函数：
isRevove 记录那些下标已经被删除。
枚举p个字符，看能否则s的非删除下标中按顺序找到对应字符。
Check函数时间复杂度：O(n+m)
总时间复杂度：O(n+m)log(m)

代码

核心代码

template<class INDEX_TYPE>
class CBinarySearch
{
public:
	CBinarySearch(INDEX_TYPE iMinIndex, INDEX_TYPE iMaxIndex):m_iMin(iMinIndex),m_iMax(iMaxIndex) {}
	template<class _Pr>
	INDEX_TYPE FindFrist( _Pr pr)
	{
		auto left = m_iMin - 1;
		auto rightInclue = m_iMax;
		while (rightInclue - left > 1)
		{
			const auto mid = left + (rightInclue - left) / 2;
			if (pr(mid))
			{
				rightInclue = mid;
			}
			else
			{
				left = mid;
			}
		}
		return rightInclue;
	}
	template<class _Pr>
	INDEX_TYPE FindEnd( _Pr pr)
	{
		int leftInclude = m_iMin;
		int right = m_iMax + 1;
		while (right - leftInclude > 1)
		{
			const auto mid = leftInclude + (right - leftInclude) / 2;
			if (pr(mid))
			{
				leftInclude = mid;
			}
			else
			{
				right = mid;
			}
		}
		return leftInclude;
	}
protected:
	const INDEX_TYPE m_iMin, m_iMax;
};


	class Solution {
		public:
			int maximumRemovals(string s, string p, vector<int>& removable) {
				auto Check = [&](int mid) {
					vector<bool> isRevove(s.length(), false);
					for (int i = 0; i < mid; i++) {
						isRevove[removable[i]] = true;
					}
					int i = 0;
					for (const auto& ch : p) {
						for (; i < s.length(); i++) {
							if (isRevove[i]) { continue; }
							if (ch == s[i]) { break; }
						}
						if (s.length() == i) { return false; }
						i++;
					}
					return true;
				};
				return CBinarySearch<int>(0, removable.size()).FindEnd(Check);
			}
		};

单元测试

string s,  p;
		vector<int> removable;
		TEST_METHOD(TestMethod1)
		{
			s = "aaa", p = "aaa", removable = { 0,1,2 };
			auto res = Solution().maximumRemovals(s, p, removable);
			AssertEx(0, res);
		}
		TEST_METHOD(TestMethod11)
		{
			s = "abcacb", p = "ab", removable = { 3, 1, 0 };
			auto res = Solution().maximumRemovals(s, p, removable);
			AssertEx(2, res);
		}
		TEST_METHOD(TestMethod12)
		{
			s = "abcbddddd", p = "abcd", removable = { 3, 2, 1, 4, 5, 6 };
			auto res = Solution().maximumRemovals(s, p, removable);
			AssertEx(1, res);
		}
		TEST_METHOD(TestMethod13)
		{
			s = "abcab", p = "abc", removable = { 0, 1, 2, 3, 4 };
			auto res = Solution().maximumRemovals(s, p, removable);
			AssertEx(0, res);
		}