Description
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 <= 1050 <= removable.length < s.length0 <= removable[i] < s.lengthp is a subsequence of s.s and p both consist of lowercase English letters.- The elements in
removable are distinct.
Solutions
Solution 1: Binary Search
We notice that if removing the characters at the first k indices in removable still makes p a subsequence of s, then removing the characters at k \lt k' ≤ removable.length indices will also satisfy the condition. This monotonicity allows us to use binary search to find the maximum k.
We define the left boundary of the binary search as l = 0 and the right boundary as r = removable.length. Then we perform binary search. In each search, we take the middle value mid = \left\lfloor l + r + 1⁄2 \right\rfloor and check if removing the characters at the first mid indices in removable still makes p a subsequence of s. If it does, we update the left boundary l = mid; otherwise, we update the right boundary r = mid - 1.
After the binary search ends, we return the left boundary l.
The time complexity is O(k × log k), and the space complexity is O(n). Here, n is the length of the string s, and k is the length of removable.
PythonJavaC++GoTypeScriptRustJavaScriptKotlin
class Solution:
def maximumRemovals(self, s: str, p: str, removable: List[int]) -> int:
def check(k: int) -> bool:
rem = [False] * len(s)
for i in removable[:k]:
rem[i] = True
i = j = 0
while i < len(s) and j < len(p):
if not rem[i] and p[j] == s[i]:
j += 1
i += 1
return j == len(p)
l, r = 0, len(removable)
while l < r:
mid = (l + r + 1) >> 1
if check(mid):
l = mid
else:
r = mid - 1
return l(code-box)
class Solution {
private char[] s;
private char[] p;
private int[] removable;
public int maximumRemovals(String s, String p, int[] removable) {
int l = 0, r = removable.length;
this.s = s.toCharArray();
this.p = p.toCharArray();
this.removable = removable;
while (l < r) {
int mid = (l + r + 1) >> 1;
if (check(mid)) {
l = mid;
} else {
r = mid - 1;
}
}
return l;
}
private boolean check(int k) {
boolean[] rem = new boolean[s.length];
for (int i = 0; i < k; ++i) {
rem[removable[i]] = true;
}
int i = 0, j = 0;
while (i < s.length && j < p.length) {
if (!rem[i] && p[j] == s[i]) {
++j;
}
++i;
}
return j == p.length;
}
}(code-box)
class Solution {
public:
int maximumRemovals(string s, string p, vector<int>& removable) {
int m = s.size(), n = p.size();
int l = 0, r = removable.size();
bool rem[m];
auto check = [&](int k) {
memset(rem, false, sizeof(rem));
for (int i = 0; i < k; i++) {
rem[removable[i]] = true;
}
int i = 0, j = 0;
while (i < m && j < n) {
if (!rem[i] && s[i] == p[j]) {
++j;
}
++i;
}
return j == n;
};
while (l < r) {
int mid = (l + r + 1) >> 1;
if (check(mid)) {
l = mid;
} else {
r = mid - 1;
}
}
return l;
}
};(code-box)
func maximumRemovals(s string, p string, removable []int) int {
m, n := len(s), len(p)
l, r := 0, len(removable)
check := func(k int) bool {
rem := make([]bool, m)
for i := 0; i < k; i++ {
rem[removable[i]] = true
}
i, j := 0, 0
for i < m && j < n {
if !rem[i] && s[i] == p[j] {
j++
}
i++
}
return j == n
}
for l < r {
mid := (l + r + 1) >> 1
if check(mid) {
l = mid
} else {
r = mid - 1
}
}
return l
}(code-box)
function maximumRemovals(s: string, p: string, removable: number[]): number {
const [m, n] = [s.length, p.length];
let [l, r] = [0, removable.length];
const rem: boolean[] = Array(m);
const check = (k: number): boolean => {
rem.fill(false);
for (let i = 0; i < k; i++) {
rem[removable[i]] = true;
}
let i = 0,
j = 0;
while (i < m && j < n) {
if (!rem[i] && s[i] === p[j]) {
j++;
}
i++;
}
return j === n;
};
while (l < r) {
const mid = (l + r + 1) >> 1;
if (check(mid)) {
l = mid;
} else {
r = mid - 1;
}
}
return l;
}(code-box)
impl Solution {
pub fn maximum_removals(s: String, p: String, removable: Vec<i32>) -> i32 {
let m = s.len();
let n = p.len();
let s: Vec<char> = s.chars().collect();
let p: Vec<char> = p.chars().collect();
let mut l = 0;
let mut r = removable.len();
let check = |k: usize| -> bool {
let mut rem = vec![false; m];
for i in 0..k {
rem[removable[i] as usize] = true;
}
let mut i = 0;
let mut j = 0;
while i < m && j < n {
if !rem[i] && s[i] == p[j] {
j += 1;
}
i += 1;
}
j == n
};
while l < r {
let mid = (l + r + 1) / 2;
if check(mid) {
l = mid;
} else {
r = mid - 1;
}
}
l as i32
}
}(code-box)
/**
* @param {string} s
* @param {string} p
* @param {number[]} removable
* @return {number}
*/
var maximumRemovals = function (s, p, removable) {
const [m, n] = [s.length, p.length];
let [l, r] = [0, removable.length];
const rem = Array(m);
const check = k => {
rem.fill(false);
for (let i = 0; i < k; i++) {
rem[removable[i]] = true;
}
let i = 0,
j = 0;
while (i < m && j < n) {
if (!rem[i] && s[i] === p[j]) {
j++;
}
i++;
}
return j === n;
};
while (l < r) {
const mid = (l + r + 1) >> 1;
if (check(mid)) {
l = mid;
} else {
r = mid - 1;
}
}
return l;
};(code-box)
class Solution {
fun maximumRemovals(s: String, p: String, removable: IntArray): Int {
val m = s.length
val n = p.length
var l = 0
var r = removable.size
fun check(k: Int): Boolean {
val rem = BooleanArray(m)
for (i in 0 until k) {
rem[removable[i]] = true
}
var i = 0
var j = 0
while (i < m && j < n) {
if (!rem[i] && s[i] == p[j]) {
j++
}
i++
}
return j == n
}
while (l < r) {
val mid = (l + r + 1) / 2
if (check(mid)) {
l = mid
} else {
r = mid - 1
}
}
return l
}
}(code-box)
