使用 Map，大小为 K 的所有子数组的最小值和最大值

介绍

在某些应用程序中，我们需要在数组中查找所有大小为 K 的子数组的最小和最大值。

一种可行的解决方案是使用双指针算法，即使用两个指针来遍历数组。但是，这种算法的时间复杂度为 O(n*k)，其中 n 是数组的大小。在数组很大的情况下，这种算法可能非常慢。

更好的解决方案是使用 Map 数据结构。Map 数据结构可以让我们在常量时间内插入和删除元素，因此我们可以在 O(n) 的时间内解决问题。

思路

1. 首先，我们需要创建一个 Map，用于存储子数组的最小和最大值。
2. 然后，我们需要遍历数组并将子数组的最小和最大值存储在 Map 中。
3. 在存储值时，我们需要始终保持 Map 的大小不超过 K。为此，我们可以使用一个双端队列来实现。当遇到一个新的子数组时，我们将它的最小和最大值添加到双端队列中，并将队列中所有大于当前最小和最大值的元素删除。
4. 最终，我们需要遍历 Map 并计算所有子数组的最小和最大值的和。

代码

JavaScript

function findMinMaxSubArrays(nums, k) {
  const minMap = new Map();
  const maxMap = new Map();
  const queue = [];

  for (let i = 0; i < nums.length; i++) {
    // Add new element
    while (queue.length > 0 && nums[i] < queue[queue.length - 1]) {
      queue.pop();
    }
    queue.push(nums[i]);

    // Remove old element
    if (i >= k && nums[i - k] === queue[0]) {
      queue.shift();
    }

    // Store min and max
    if (i - k + 1 >= 0) {
      minMap.set(i - k + 1, queue[0]);
      maxMap.set(i - k + 1, queue[queue.length - 1]);
    }
  }

  let sum = 0;
  for (let i = 0; i <= nums.length - k; i++) {
    sum += minMap.get(i) + maxMap.get(i);
  }
  return sum;
}

const nums = [1, 2, 3, 4, 5];
const k = 3;
const result = findMinMaxSubArrays(nums, k);
console.log(result); // Output: 25

Python

def find_min_max_subarrays(nums, k):
    min_map, max_map = {}, {}
    queue = []

    for i in range(len(nums)):
        # Add new element
        while queue and nums[i] < queue[-1]:
            queue.pop()
        queue.append(nums[i])

        # Remove old element
        if i >= k and nums[i - k] == queue[0]:
            queue.pop(0)

        # Store min and max
        if i - k + 1 >= 0:
            min_map[i - k + 1] = queue[0]
            max_map[i - k + 1] = queue[-1]

    return sum(min_map[i] + max_map[i] for i in range(len(nums) - k + 1))

nums = [1, 2, 3, 4, 5]
k = 3
result = find_min_max_subarrays(nums, k)
print(result) # Output: 25

时间复杂度

这个算法的时间复杂度为 O(n)，其中 n 是数组的长度。尽管需要遍历两次数组，但每个元素最多进入和出队一次，因此仅需要常量时间来插入和删除元素。因此，总运行时间为 O(n)。在没有使用额外空间的情况下，这是最优的时间复杂度。

总结

使用 Map 和双端队列，我们可以在 O(n) 的时间内计算任意大小的子数组的最小和最大值之和。这比使用双指针算法更有效。虽然这个算法使用了额外的空间，但这个算法的时间复杂度为 O(n)，并且空间复杂度往往比暴力解法更低。