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

题目描述

给你两个字符串 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、两个字符串，一个是原字符串s，一个是原字符串的子序列p（eg:s=“abcacb”,p=“ab”,s2即为s1的子序列）
  • 2、一个整数数组 removable = [3,1,0]，数组元素代表原字符串s1的下标
  • 求：选出 removable 中的前 k 个下标，然后从 s 中移除这些下标对应的字符，整数k需要满足，执行完上述步骤之后，p仍然是s的子序列，返回可找出的最大k

• 思路

  • 1.还是一个查找问题，查找问题满足几个条件：
    • 1.1一个有序的区间（数组小标）
    • 1.2寻找的目标值处于有序区间内
  • 2.定义check()函数，
    • 2.1满足check()函数，继续完后找(left = mid+1)，不满足，往前找(right = mid)
    • 2.2check()函数规则：
      • 2.2.1 移除完对应的字符，比较两个字符串是否依然是子序列
      • 2.2.2 双指针法，原字符串指针无条件递进，子序列字符串指针，相同一个字符，递进一次
      • 2.2.3 循环终止条件，原字符串和子序列字符串都遍历完毕（i<s1.length() && j<p.length()）
      • 2.2.4 比较子序列字符串指针最后是否等于p.length，相等，则说明p依旧是s的子序列

代码实现

public int getCanRemoveMaxStr(String str, String p, int[] removable) {
        int left = 0;
        int right = removable.length - 1;
        while (left < right) {
            int mid = (left + right + 1) >> 1;
            if (check(str, p, removable, mid)) {
                //符合check()函数，继续往后找
                left = mid;
            } else {
                //不符合，往前找
                right = mid - 1;
            }
        }
        return left;

    }

    /**
     * @param str
     * @param p
     * @param removable
     * @param mid
     * @return
     */
    private boolean check(String str, String p, int[] removable, int mid) {
        //原字符串长度
        int m = str.length();
        //子序列字符串长度
        int n = p.length();
        //双指针
        int i = 0, j = 0;
        //用来存储需要过滤掉的字符位置索引
        Set<Integer> excludeIndexs = new HashSet<Integer>();
        for (int k = 0; k < mid; k++) {
            excludeIndexs.add(removable[k]);
        }
        //双指针开始遍历
        while (i < m && j < n) {
            if (!excludeIndexs.contains(i) && str.charAt(i) == p.charAt(j)) {
                //过滤掉已经删除的字符，比较原字符和子序列字符，相等，j++
                j++;
            }
            i++;
        }
        //j==n 说明子序列字符串和原字符串都匹配上了
        return j==n;
    }