找到 S 的子序列和 T 的子序列的相等对

给定两个字符串 S 和 T，找到它们中所有的子序列对 (s, t)，使得 s 是 S 的子序列，t 是 T 的子序列，且 s 和 t 的长度相等。

思路

这道问题是一个典型的回溯问题。我们可以考虑对 S 和 T 进行回溯，对于 S 中的每个字符，我们可以选择将其与 T 中的字符进行匹配或者不进行匹配。当匹配完成后，我们可以比较 s 和 t 的长度是否相同即可。

在回溯时，我们需要维护一个指针 i，表示在 T 中查找下一个可以匹配 S[j] 的位置。具体而言，我们首先在 T 中查找第一个等于 S[j] 的位置 i，然后递归处理 S[j+1:] 和 T[i+1:] 的子问题。如果不能找到等于 S[j] 的位置，我们就不匹配 S[j]，递归处理 S[j+1:] 和 T[i:] 的子问题。

代码实现

def countSubsequences(S: str, T: str) -> int:
    """
    Count the number of subsequences (s, t) such that s is a subsequence of S,
    t is a subsequence of T, and len(s) == len(t).
    """
    def backtrack(i, j):
        if j == len(T): # T 中没有满足要求的子序列
            return 0
        if i == len(S): # 找到了一个满足要求的子序列对
            return 1
        # 选择将 S[i] 匹配到 T[j] 或者不匹配
        match = backtrack(i+1, j+1) if S[i] == T[j] else 0
        unmatch = backtrack(i+1, j)
        return match + unmatch

    return backtrack(0, 0)

复杂度分析

该算法的时间复杂度为 $O(2^n)$，其中 $n$ 是字符串的长度。回溯算法本身的复杂度是指数级别的，对于每对 (s,t)，我们需要遍历整个 S 和 T 的子串，所以时间复杂度为 $O(n^2)$。空间复杂度为 $O(n)$，即递归栈的深度。