查找具有最大值和最小值之间差异的子数组范围正好 K

在给定一个数组的情况下，查找一个长度为 K 的子数组，使得子数组中元素的最大值和最小值之间的差恰好为 K。

这个问题可以使用双指针法来解决。我们可以初始化两个指针 left 和 right，分别指向数组的第一个元素和第 K 个元素。然后，我们可以使用一个循环遍历数组中的元素：

1. 在每次迭代中，我们可以计算 left 和 right 之间的子数组的最大值和最小值。如果它们之间的差等于 K，则我们已经找到了一个符合条件的子数组。

2. 如果差小于 K，则我们将右指针 right 向右移动一位，以便我们得到更大的子数组。

3. 如果差大于 K，则我们将左指针 left 向右移动一位，以便我们得到更小的子数组。

我们可以使用一个字典来记录最大值和最小值之间的差值出现的位置。当我们找到一个差值等于 K 的子数组时，我们可以将其起始位置添加到字典中。如果我们找到了多个差值等于 K 的子数组，则我们可以从字典中选择最小的起始位置。

以下是 Python 代码片段：

def find_subarray_with_diff_k(arr, k):
    n = len(arr)
    left, right = 0, k-1
    diff_dict = {}
    max_val = max(arr[:k])
    min_val = min(arr[:k])
    
    while left <= n-k:
        if max_val - min_val == k:
            diff_dict[left] = right
            left += 1
            right += 1
            if right < n:
                max_val = max(max_val, arr[right])
                min_val = min(min_val, arr[right])
            if left <= right and arr[left-1] == max_val:
                max_val = max(arr[left:right])
            if left <= right and arr[left-1] == min_val:
                min_val = min(arr[left:right])
        elif max_val - min_val < k:
            right += 1
            if right < n:
                max_val = max(max_val, arr[right])
                min_val = min(min_val, arr[right])
        else:
            left += 1
            if left <= right and arr[left-1] == max_val:
                max_val = max(arr[left:right])
            if left <= right and arr[left-1] == min_val:
                min_val = min(arr[left:right])
    
    if len(diff_dict) == 0:
        return None
    else:
        return min(diff_dict.items(), key=lambda x: x[0])[1] - min(diff_dict.keys()) + 1

以上代码返回从起始位置到结束位置的子数组长度，如果没有符合条件的子数组，则返回 None。

此外，我们还可以将上述代码优化为 $O(n)$ 时间复杂度。我们可以使用单调队列来记录当前子数组中的最大值和最小值。每次移动指针时，我们只需要更新队列即可。

以下是 Python 优化代码片段：

def find_subarray_with_diff_k_optimized(arr, k):
    n = len(arr)
    left, right = 0, k-1
    diff_dict = {}
    max_q, min_q = collections.deque(), collections.deque()
    
    for i in range(k):
        while max_q and arr[max_q[-1]] < arr[i]:
            max_q.pop()
        while min_q and arr[min_q[-1]] > arr[i]:
            min_q.pop()
        max_q.append(i)
        min_q.append(i)
        
    while left <= n-k:
        if arr[max_q[0]] - arr[min_q[0]] == k:
            diff_dict[left] = right
            left += 1
            right += 1
            if right < n:
                if max_q[0] == left-1:
                    max_q.popleft()
                if min_q[0] == left-1:
                    min_q.popleft()
                while max_q and arr[max_q[-1]] < arr[right]:
                    max_q.pop()
                while min_q and arr[min_q[-1]] > arr[right]:
                    min_q.pop()
                max_q.append(right)
                min_q.append(right)
        elif arr[max_q[0]] - arr[min_q[0]] < k:
            right += 1
            if right < n:
                while max_q and arr[max_q[-1]] < arr[right]:
                    max_q.pop()
                while min_q and arr[min_q[-1]] > arr[right]:
                    min_q.pop()
                max_q.append(right)
                min_q.append(right)
        else:
            left += 1
    
    if len(diff_dict) == 0:
        return None
    else:
        return min(diff_dict.items(), key=lambda x: x[0])[1] - min(diff_dict.keys()) + 1

以上优化代码同样返回从起始位置到结束位置的子数组长度，如果没有符合条件的子数组，则返回 None。