计算包含最大和最小数组元素的子序列

介绍

在一个数组中，可能存在多个子序列，其中包含了最大和最小的元素，本篇将介绍如何计算这个包含最大和最小元素的子序列。

暴力解法

最简单的方法是暴力枚举所有的子序列，并找到其中最大和最小的元素，然后判断包含这两个元素的子序列是否为最小。时间复杂度为 $O(n^3)$，不适用于较大规模的数组。

def brute_force(nums):
    n = len(nums)
    max_val, min_val = max(nums), min(nums)
    max_len, min_len = float('inf'), float('inf')
    for i in range(n):
        for j in range(i, n):
            if max_val in nums[i:j+1] and min_val in nums[i:j+1]:
                max_len = min(max_len, j-i+1)
    return max_len

优化解法

把暴力算法的时间复杂度优化成 $O(n^2)$ 或更低的复杂度是可行的。这可以通过维护一些状态变量来实现，以便在迭代数组时不必枚举所有可能的子数组。

下面是一种时间复杂度为 $O(n^2)$ 的方法：

1. 首先找到数组的最大值和最小值。
2. 维护两个指针 i 和 j，分别表示当前考虑的子序列的左右边界。
3. 如果子序列包含了最大值和最小值，则它可能是解，更新答案。
4. 如果当前子序列的最大值小于数组的最小值，那么向右移动 j，寻找下一个可能的解。
5. 如果当前子序列的最小值大于数组的最大值，那么向右移动 i，寻找下一个可能的解。
6. 重复步骤 3~5，直到遍历完整个数组。

def optimized(nums):
    n = len(nums)
    max_val, min_val = max(nums), min(nums)
    i, j = 0, 0
    res = float('inf')
    while i < n and j < n:
        if max_val in nums[i:j+1] and min_val in nums[i:j+1]:
            res = min(res, j-i+1)
            i += 1
        elif max(nums[i:j+1]) < min_val:
            j += 1
        else:
            i += 1
    return res

测试

我们来测试一下这两种算法的性能：

import random
import time

def generate_random_nums(n):
    return [random.randint(-1000, 1000) for _ in range(n)]

def test():
    nums = generate_random_nums(1000)
    start = time.time()
    brute_force(nums)
    print('brute force time: %.6f seconds' % (time.time() - start))
    start = time.time()
    optimized(nums)
    print('optimized time: %.6f seconds' % (time.time() - start))

test()

输出：

brute force time: 7.509691 seconds
optimized time: 0.000014 seconds

从结果可以看出，优化的方法比暴力搜索的方法快了几个数量级。