查找大小为 k 的子数组的最大(或最小)和

在实际开发中，我们经常需要查找大小为 k 的子数组的最大或最小和，并对这个问题进行求解。这个问题可以用多种算法来解决，其中包括暴力算法、滑动窗口算法和分治算法等。本文将说明这些算法的原理和实现，希望对读者有所帮助。

暴力算法

暴力算法是最简单的解决方案，它的基本思路是枚举所有 k 个元素的子数组，并计算它们的和，然后从中找到最大或最小的和。这个算法的时间复杂度为 O(n*k)，其中 n 是数组的长度。虽然这个算法很慢，但是它是最容易理解和实现的算法。

def find_ksubarray_max_sum(nums, k):
    n = len(nums)
    max_sum = float('-inf')
    for i in range(n-k+1):
        cur_sum = sum(nums[i:i+k])
        max_sum = max(max_sum, cur_sum)
    return max_sum

滑动窗口算法

滑动窗口算法是一种优化过的暴力算法，在时间复杂度上要比暴力算法更优。它的基本思路是维护一个大小为 k 的窗口，使窗口的移动次数变为 n-k+1。在每次移动窗口之后，我们只需要用新的元素去更新原来的窗口和，就可以计算出新的子数组的和。如果窗口的右端点超过了数组的长度，那么就可以退出算法。

def find_ksubarray_max_sum(nums, k):
    n = len(nums)
    max_sum = float('-inf')
    cur_sum = sum(nums[:k])
    for i in range(k, n):
        cur_sum += nums[i] - nums[i-k]
        max_sum = max(max_sum, cur_sum)
    return max_sum

分治算法

分治算法是一种高效的解决方案，它的基本思路是把原问题分解成两个或多个子问题，并分别解决它们，然后把这些子问题的结果合并起来得到原问题的解。对于这个问题，我们可以使用分治算法来解决，把原数组分成左右两部分，分别求出左右两部分的最大连续子数组和以及跨越中间的最大连续子数组和，最后把这三个值合并成为一个值即可。

def max_crossing_sum(nums, left, mid, right):
    max_left_sum = float('-inf')
    cur_sum = 0
    for i in range(mid, left-1, -1):
        cur_sum += nums[i]
        max_left_sum = max(max_left_sum, cur_sum)
    
    max_right_sum = float('-inf')
    cur_sum = 0
    for i in range(mid+1, right+1):
        cur_sum += nums[i]
        max_right_sum = max(max_right_sum, cur_sum)
    
    return max_left_sum + max_right_sum

def find_ksubarray_max_sum(nums, k):
    n = len(nums)
    if k > n:
        return 0
    
    if k == n:
        return sum(nums)
    
    mid = n // 2
    left_max_sum = find_ksubarray_max_sum(nums[:mid], k)
    right_max_sum = find_ksubarray_max_sum(nums[mid:], k)
    cross_max_sum = max_crossing_sum(nums, 0, mid-1, n-1)
    return max(left_max_sum, right_max_sum, cross_max_sum)

以上便是三种不同的算法来解决查找大小为 k 的子数组的最大(或最小)和问题，读者可以根据自己的需要来选择合适的算法。