检查字符串能否只拆分为子序列ABC

在某些场景下，我们需要检查一个字符串是否能够仅被拆分为特定的子序列。本文将介绍一种基于贪心算法和双指针法的解决方案。

算法思路

我们尝试使用一个指针 i 遍历字符串，同时使用两个指针 j 和 k 分别记录子序列 A 和 B 的起始位置，当遍历到一个字符时，我们检查该字符是否与子序列 A 或 B 的下一个字符相同。如果相同，我们移动子序列 A 或 B 的指针，否则我们尝试将该字符作为新的子序列 A 或 B 的起点，如果都不行则返回 false。

当 i 遍历完整个字符串时，如果子序列 A 和 B 都已经遍历完，则返回 true，否则返回 false。

代码实现

def can_split_to_abc(s: str) -> bool:
    n = len(s)
    if n == 0:
        return False
    i, j, k = 0, -1, -1
    while i < n:
        if j >= 0 and s[i] == "B" and s[j] == "A":
            j += 1
        elif k >= 0 and s[i] == "C" and s[k] == "B":
             k += 1
        elif s[i] == "A":
            j = i
        elif s[i] == "B":
            if j < 0:
                j = i
            else:
                k = i
        else:
            return False
        i += 1
    return j >= 0 and k >= 0

测试案例

assert can_split_to_abc("ABC") == True
assert can_split_to_abc("AAAAAB") == False
assert can_split_to_abc("AACBCCCCCB") == True
assert can_split_to_abc("CBA") == False
assert can_split_to_abc("ACAAAACACAB") == False

时间复杂度

该算法只遍历一次字符串，所以时间复杂度为 $O(n)$，其中 $n$ 是字符串的长度。

空间复杂度

该算法只使用固定数量的变量，所以空间复杂度为 $O(1)$。