滑动窗口与动态规划：解决子串问题的核心算法-代码聚汇网

滑动窗口与动态规划：解决子串问题的核心算法

滑动窗口动态规划子串问题

|难度：普通|阅读约 15 分钟

1. 理解hot100-子串问题的本质

hot100系列作为算法面试的经典题库，其中子串类问题占据了相当比重。这类问题看似简单，实则暗藏玄机。我在大厂面试中曾多次遇到候选人在这类题目上栽跟头，究其原因往往是对子串(substring)和子序列(subsequence)的概念区分不清。

子串指的是字符串中连续的字符序列，而子序列则不要求连续。举个例子，字符串"abcde"中，"bcd"是子串，而"ace"则是子序列。这个基本概念的混淆会导致整个解题思路的偏差。

需要模型API调用？免费领10W Token，多模型网关一键接入 Claude、DeepSeek 等主流模型。

2. 滑动窗口：子串问题的万能钥匙

2.1 基础滑动窗口实现

滑动窗口是解决子串问题的核心技巧。我常用一个双指针的模板来解决这类问题：

python复制def sliding_window(s: str):
    left = 0
    result = 0
    freq = {}
    
    for right in range(len(s)):
        # 右指针扩展窗口
        char = s[right]
        freq[char] = freq.get(char, 0) + 1
        
        # 左指针收缩窗口的条件
        while window_needs_shrink(freq):  # 自定义条件
            left_char = s[left]
            freq[left_char] -= 1
            if freq[left_char] == 0:
                del freq[left_char]
            left += 1
            
        # 更新结果
        result = max(result, right - left + 1)
    
    return result

这个模板可以解决80%的子串问题，关键在于如何定义window_needs_shrink条件。例如在"无重复字符的最长子串"问题中，这个条件就是窗口内出现重复字符。

2.2 滑动窗口的变种应用

在实际面试中，我遇到过一些滑动窗口的变种问题。比如需要维护多个条件的窗口：

python复制def complex_window(s: str, t: str):
    from collections import defaultdict
    
    target = defaultdict(int)
    for c in t:
        target[c] += 1
    
    window = defaultdict(int)
    valid = 0
    left = 0
    result = ""
    
    for right in range(len(s)):
        c = s[right]
        if c in target:
            window[c] += 1
            if window[c] == target[c]:
                valid += 1
        
        while valid == len(target):
            # 更新最小覆盖子串
            if not result or right - left + 1 < len(result):
                result = s[left:right+1]
            
            # 移动左指针
            left_c = s[left]
            if left_c in target:
                if window[left_c] == target[left_c]:
                    valid -= 1
                window[left_c] -= 1
            left += 1
    
    return result

这种变种在解决"最小覆盖子串"问题时非常有效。关键在于维护一个valid计数器来跟踪当前窗口满足了多少条件。

3. 动态规划在子串问题中的应用

3.1 最长回文子串问题

滑动窗口并非万能，比如在寻找最长回文子串时，动态规划往往更合适。我常用的DP解法：

python复制def longest_palindrome(s: str):
    n = len(s)
    dp = [[False]*n for _ in range(n)]
    res = ""
    
    for i in range(n-1, -1, -1):
        for j in range(i, n):
            if s[i] == s[j]:
                if j - i <= 1 or dp[i+1][j-1]:
                    dp[i][j] = True
                    if j - i + 1 > len(res):
                        res = s[i:j+1]
    return res

这个解法的时间复杂度是O(n²)，空间复杂度也是O(n²)。在实际编码时，我通常会先写出状态转移方程：

dp[i][j]表示s[i...j]是否是回文
转移条件：s[i]==s[j]且(j-i<=1或dp[i+1][j-1]为True)

3.2 编辑距离问题

另一个经典DP问题是编辑距离，虽然严格来说它处理的是子序列而非子串，但思路值得借鉴：

python复制def min_distance(word1: str, word2: str):
    m, n = len(word1), len(word2)
    dp = [[0]*(n+1) for _ in range(m+1)]
    
    for i in range(m+1):
        dp[i][0] = i
    for j in range(n+1):
        dp[0][j] = j
    
    for i in range(1, m+1):
        for j in range(1, n+1):
            if word1[i-1] == word2[j-1]:
                dp[i][j] = dp[i-1][j-1]
            else:
                dp[i][j] = 1 + min(
                    dp[i-1][j],   # 删除
                    dp[i][j-1],   # 插入
                    dp[i-1][j-1]  # 替换
                )
    
    return dp[m][n]

这个问题的状态转移需要考虑三种操作的可能性，是DP中比较复杂的例子。

4. 前缀和与哈希表的组合技巧

4.1 和为K的子数组

当问题涉及到子串的和时，前缀和+哈希表的组合往往能提供O(n)的解法。以"和为K的子数组"为例：

python复制def subarray_sum(nums: List[int], k: int):
    from collections import defaultdict
    prefix_sum = defaultdict(int)
    prefix_sum[0] = 1
    current_sum = 0
    count = 0
    
    for num in nums:
        current_sum += num
        if current_sum - k in prefix_sum:
            count += prefix_sum[current_sum - k]
        prefix_sum[current_sum] += 1
    
    return count

这个解法的关键在于理解current_sum - k的含义：它表示如果存在某个前缀和使得current_sum - prefix_sum = k，那么这两个位置之间的子数组和就是k。

4.2 最长无重复字符子串的优化

同样的技巧可以用来优化最长无重复字符子串问题：

python复制def length_of_longest_substring(s: str):
    char_index = {}
    left = 0
    max_len = 0
    
    for right, c in enumerate(s):
        if c in char_index and char_index[c] >= left:
            left = char_index[c] + 1
        char_index[c] = right
        max_len = max(max_len, right - left + 1)
    
    return max_len

这个版本比滑动窗口更高效，因为它直接通过哈希表记录字符最后出现的位置，避免了不必要的窗口收缩。

5. 实战中的常见陷阱与优化技巧

5.1 边界条件处理

在解决"最长有效括号"问题时，边界条件的处理尤为关键：

python复制def longest_valid_parentheses(s: str):
    stack = [-1]
    max_len = 0
    
    for i, c in enumerate(s):
        if c == '(':
            stack.append(i)
        else:
            stack.pop()
            if not stack:
                stack.append(i)
            else:
                max_len = max(max_len, i - stack[-1])
    
    return max_len

这个解法使用栈来跟踪可能形成有效括号的起始位置。关键点在于初始时压入-1作为虚拟边界，这样当栈为空时我们可以知道从哪里重新开始计数。

5.2 空间复杂度优化

很多子串问题可以通过观察状态转移的特性来优化空间。例如编辑距离问题可以优化到O(n)空间：

python复制def min_distance_optimized(word1: str, word2: str):
    m, n = len(word1), len(word2)
    dp = [0] * (n + 1)
    
    for j in range(n + 1):
        dp[j] = j
    
    for i in range(1, m + 1):
        prev = dp[0]
        dp[0] = i
        for j in range(1, n + 1):
            temp = dp[j]
            if word1[i - 1] == word2[j - 1]:
                dp[j] = prev
            else:
                dp[j] = 1 + min(dp[j], dp[j - 1], prev)
            prev = temp
    
    return dp[n]

这种优化利用了DP问题中当前行只依赖于前一行的特性，通过滚动数组的方式减少空间使用。

6. 高频hot100子串问题分类解析

6.1 无重复字符的最长子串

这道题是滑动窗口的经典应用。我在面试中经常用它来考察候选人对基本算法的掌握程度。最优解法时间复杂度O(n)，空间复杂度O(min(m,n))，其中m是字符集大小。

python复制def length_of_longest_substring(s: str):
    char_map = {}
    left = 0
    max_len = 0
    
    for right, c in enumerate(s):
        if c in char_map and char_map[c] >= left:
            left = char_map[c] + 1
        char_map[c] = right
        max_len = max(max_len, right - left + 1)
    
    return max_len

6.2 最小覆盖子串

这道题是滑动窗口的高级应用，需要维护多个条件。我建议先理解基本解法，再考虑优化：

python复制def min_window(s: str, t: str):
    from collections import defaultdict
    
    target = defaultdict(int)
    for c in t:
        target[c] += 1
    
    required = len(target)
    formed = 0
    window_counts = defaultdict(int)
    left = 0
    result = (float('inf'), None, None)
    
    for right, c in enumerate(s):
        if c in target:
            window_counts[c] += 1
            if window_counts[c] == target[c]:
                formed += 1
        
        while formed == required and left <= right:
            if right - left + 1 < result[0]:
                result = (right - left + 1, left, right)
            
            left_char = s[left]
            if left_char in target:
                window_counts[left_char] -= 1
                if window_counts[left_char] < target[left_char]:
                    formed -= 1
            left += 1
    
    return "" if result[0] == float('inf') else s[result[1]:result[2]+1]

6.3 字符串的排列

这道题可以看作是"最小覆盖子串"的特殊情况，窗口大小固定为t的长度：

python复制def check_inclusion(s1: str, s2: str):
    from collections import defaultdict
    
    target = defaultdict(int)
    for c in s1:
        target[c] += 1
    
    window = defaultdict(int)
    left = 0
    matched = 0
    
    for right in range(len(s2)):
        c = s2[right]
        if c in target:
            window[c] += 1
            if window[c] == target[c]:
                matched += 1
        
        if right >= len(s1):
            left_c = s2[left]
            if left_c in target:
                if window[left_c] == target[left_c]:
                    matched -= 1
                window[left_c] -= 1
            left += 1
        
        if matched == len(target):
            return True
    
    return False

7. 面试实战技巧与经验分享

7.1 如何选择合适的方法

面对子串问题时，我通常会按照以下思路选择解法：

如果问题涉及"最长"、"最短"、"满足某些条件"的子串，优先考虑滑动窗口
如果问题涉及回文或需要知道子串的某些全局性质，考虑动态规划
如果问题涉及子串的和或积，考虑前缀和+哈希表
如果问题允许暴力解法且输入规模小(如n≤100)，可以先给出O(n²)解法再优化

7.2 代码模板的灵活运用

我建议熟记几个核心模板，但更重要的是理解其背后的思想。例如滑动窗口模板可以这样记忆：

初始化左右指针和辅助数据结构
右指针移动扩展窗口
满足条件时移动左指针收缩窗口
在适当位置更新结果

7.3 调试与验证技巧

在面试中，我常用以下方法验证子串问题的解法：

空字符串输入
单字符输入
所有字符相同的情况
无解的情况
多个解的情况

例如测试最长无重复字符子串时，我会检查：

"" → 0
"a" → 1
"aaaa" → 1
"abcabcbb" → 3
"pwwkew" → 3

7.4 时间复杂度分析要点

分析子串问题的时间复杂度时要注意：

滑动窗口通常是O(n)，因为每个元素最多被处理两次(进窗口和出窗口)
动态规划通常是O(n²)，因为要填充二维表格
空间复杂度取决于辅助数据结构的大小，通常是O(n)或O(字符集大小)

8. 进阶挑战与扩展思考

8.1 多字符串的子串问题

有些问题涉及多个字符串的子串关系，如"最长公共子串"：

python复制def longest_common_substring(text1: str, text2: str):
    m, n = len(text1), len(text2)
    dp = [[0]*(n+1) for _ in range(m+1)]
    max_len = 0
    
    for i in range(1, m+1):
        for j in range(1, n+1):
            if text1[i-1] == text2[j-1]:
                dp[i][j] = dp[i-1][j-1] + 1
                max_len = max(max_len, dp[i][j])
    
    return max_len

这个解法与最长公共子序列(LCS)类似，但要求连续性，因此状态转移方程有所不同。

8.2 带特殊条件的子串问题

有些问题会在基本子串问题上增加特殊条件，如"最多包含K个不同字符的最长子串"：

python复制def length_of_longest_substring_k_distinct(s: str, k: int):
    from collections import defaultdict
    
    freq = defaultdict(int)
    left = 0
    max_len = 0
    
    for right, c in enumerate(s):
        freq[c] += 1
        
        while len(freq) > k:
            left_char = s[left]
            freq[left_char] -= 1
            if freq[left_char] == 0:
                del freq[left_char]
            left += 1
        
        max_len = max(max_len, right - left + 1)
    
    return max_len

这类问题考验对基本算法的灵活应用能力。

8.3 子串问题的实际应用

子串算法在实际开发中有广泛应用：

文本编辑器的查找替换功能
DNA序列比对
抄袭检测系统
编译器中的词法分析
搜索引擎的自动补全

理解这些实际应用场景有助于在面试中更好地解释算法选择的原因。