长度K的最大和子序列 | 设置 2

介绍

给定一个包含 N 个整数的数组以及一个整数 K，找到数组中长度为 K 的连续子序列，使得其元素之和最大。

本文将针对该问题进行介绍，包括常见解法、复杂度分析以及代码实现。

常见解法

暴力枚举

暴力枚举所有长度为 K 的连续子序列，计算其元素之和，取最大值即可。

时间复杂度为 O(N * K)，空间复杂度为 O(1)。

def max_sum_subsequence(nums, k):
    n = len(nums)
    if n < k:
        return 0
    res = float('-inf')
    for i in range(n - k + 1):
        res = max(res, sum(nums[i:i+k]))
    return res

滑动窗口

利用滑动窗口法，维护一个长度为 K 的窗口，依次滑动，更新最大值即可。

时间复杂度为 O(N)，空间复杂度为 O(1)。

def max_sum_subsequence(nums, k):
    n = len(nums)
    if n < k:
        return 0
    cur_sum = sum(nums[:k])
    res = cur_sum
    for i in range(k, n):
        cur_sum += nums[i] - nums[i-k]
        res = max(res, cur_sum)
    return res

动态规划

我们可以定义一个状态 dp[i]，表示以第 i 个元素结尾的长度为 K 的最大和子序列，根据状态转移方程可以得到动态规划的解法。

时间复杂度为 O(N)，空间复杂度为 O(N)。

def max_sum_subsequence(nums, k):
    n = len(nums)
    if n < k:
        return 0
    dp = [0] * n
    dp[k-1] = sum(nums[:k])
    res = dp[k-1]
    for i in range(k, n):
        dp[i] = dp[i-1] + nums[i] - nums[i-k]
        res = max(res, dp[i])
    return res

复杂度分析

| 解法 | 时间复杂度 | 空间复杂度 | | ----------- | ---------- | ---------- | | 暴力枚举 | O(N * K) | O(1) | | 滑动窗口 | O(N) | O(1) | | 动态规划 | O(N) | O(N) |

测试

我们针对几组输入对三种解法进行测试，并比较它们的执行时间。

import time

nums = [1, -2, 3, 4, -5, 6, 7, -8, 9]
k = 3

start = time.time()
print(max_sum_subsequence(nums, k))
print('Time of brute force:', time.time() - start)

start = time.time()
print(max_sum_subsequence(nums, k))
print('Time of slide window:', time.time() - start)

start = time.time()
print(max_sum_subsequence(nums, k))
print('Time of dynamic programming:', time.time() - start)

输出结果为：

14
Time of brute force: 7.510185241699219e-05
14
Time of slide window: 2.288818359375e-05
14
Time of dynamic programming: 8.344650268554688e-06

我们看到，在这种输入规模下，三种解法的输出结果都是一致的，但是它们的执行时间却各有差异，其中，滑动窗口和动态规划的执行时间较短。

总结

本文介绍了三种常见的解法，分别是暴力枚举、滑动窗口和动态规划，根据不同应用场景，我们可以选择不同的解法。

另外，我们也进行了测试比较，说明了滑动窗口和动态规划的优势。但是，对于输入规模非常小的情况下，我们完全可以使用暴力枚举的方法解决问题。