python-leetcode-1638. 统计只差一个字符的子串数目

1638. 统计只差一个字符的子串数目 - 力扣（LeetCode）

我们可以使用 暴力枚举 和 动态规划 来解决这个问题。思路如下：

解题思路

1. 枚举所有可能的子串

   • 遍历 s 的所有子串 s[i:j]。
   • 遍历 t 的所有子串 t[k:m]，其中 len(s[i:j]) == len(t[k:m])。
   • 统计它们的不同字符个数，如果恰好是 1，则计数。

2. 优化检查方式

   • 如果 s[i:j] 和 t[k:m] 长度相等，可以直接比较字符不同的个数，利用 O(1) 的方式计算不同字符数，而不是每次都遍历整个子串。

代码实现

def countSubstrings(s: str, t: str) -> int:
    def count_diff_by_one(s1, s2):
        """ 判断两个等长字符串是否恰好有一个字符不同 """
        diff = 0
        for c1, c2 in zip(s1, s2):
            if c1 != c2:
                diff += 1
                if diff > 1:
                    return False
        return diff == 1
    
    count = 0
    len_s, len_t = len(s), len(t)

    # 遍历 s 的所有子串
    for i in range(len_s):
        for j in range(i, len_s):
            sub_s = s[i:j + 1]
            len_sub = j - i + 1

            # 遍历 t 的所有相同长度的子串
            for k in range(len_t - len_sub + 1):
                sub_t = t[k:k + len_sub]
                if count_diff_by_one(sub_s, sub_t):
                    count += 1

    return count

# 示例
s = "aba"
t = "baba"
print(countSubstrings(s, t))  # 输出: 6

复杂度分析

• 遍历 s 的子串：O(n^2)
• 遍历 t 的子串：O(m)
• 比较子串的不同字符：O(L), 其中 L 为子串长度

总时间复杂度大致为 O(n^2 * m), 适用于小规模字符串。对于较长字符串，我们可以进一步优化，例如使用动态规划优化比较步骤。