给定数组 A 和数字 K 创建数组 B 其中 B[i] = min(A[i], A[i+1].. A[i + K - 1]) [关闭]

Question

给定一个整数数组A和一个整数值K，创建数组B，其中B[i]是子数组A[i], A[i+1], ..., A[i+K-1]中的最小值。请注意，B.length 将等于 A.length - K。

例如对于K = 3 和A=[1,2,3,4,0,1,2]，解决方案是B=[1,2,0,0,0]。

A  =  [1,2,3,4,0,1,2]
       _____| | | | |      
B[1] = 1      | | | | 
         _____| | | | 
B[2] =   2      | | | 
           _____| | | 
B[3] =         0  | | 
             _____| | 
B[4] =         0    | 
               _____| 
B[5] =         0

O(kn)时间复杂度的解决方案如下：

public static int[] createArray(int[] arr, int k) {
    int[] result = new int[arr.length];
    for (int i = 0; i <= arr.length - k; i++) {
        int curSmallestVal = arr[i];
        for (int j = i + 1; j < i + k; j++) {
            curSmallestVal = Math.min(curSmallestVal, arr[j]);
        }
        result[i] = curSmallestVal;
    }

    return result;
}

你能提供一个更优雅的 O(n) 运行时解决方案吗？ （可能使用队列）

使用 O(n) 解决方案更新：

public static int[] getMinSlidingWindow(int[] arr, int k) {
    int[] result = new int[arr.length-k+1];
    Deque<Integer> queue = new LinkedList<Integer>();
    //initialize sliding window
    for (int i = 0; i < k; i++) {
        if (!queue.isEmpty() && arr[queue.getLast()] >= arr[i])
            queue.removeLast();
        queue.addLast(i);
    }

    for (int i = k; i < arr.length; i++) {
        result[i-k] = arr[queue.getFirst()];
        while (!queue.isEmpty() && arr[queue.getLast()] >= arr[i])
            queue.removeLast();
        queue.addLast(i);
        while (!queue.isEmpty() && queue.getFirst() <= i-k)
            queue.removeFirst();
    }

    result[arr.length-k] = arr[queue.removeFirst()]; 

    return result;
}

Answer 1

使用带有一些额外逻辑的双端队列（支持从前面和后面添加推送和弹出的队列），您可以构建一个运行 O(n) 的解决方案。

这是解决方案的伪代码。

void getMaxSlidingWindow(int[] A, int k) {
    int[] B = new int[A.length - k];
    // Store the indexes of A in Q
    // Q.front(): index of smallest element in the window, Q.back(): index of the largest one in the window
    DobuleEndedQueue<int> Q = new DobuleEndedQueue<int>(); 

    for(int i=0; i<k; i++) {
       // Fill up the double ended queue for the first k elements
       // Remove elements that we would ignore because they're bigger than the next one in the window
       while(!Q.empty() && A[i] <= A[Q.back()]) {
          Q.popBack();
       }
       Q.pushBack(i);
    }

     for(int i=k; i < A.length; i++) {
       B[i - k] = A[Q.front()]; // The first element in the queue is the index of the smallest element in the window
       // Add the current element to the queue. Before we do, remove all elements that we would ignore immediately because they're bigger than the current one
       while(!Q.empty() && A[i] <= A[Q.back()]  ) {
          Q.popBack();
       }
       Q.pushToBack(i);
       // Remove any index from the front of the queue which is no longer in the window
       while(!Q.empty() && Q.front() <= i-k) {
         Q.popFront();
       }
    }
    B[A.length - k] = A[Q.front()];
}

此解决方案的时间复杂度为 O(n)：我们遍历所有元素一次，然后将它们添加或删除一次到双端队列。完成的最大操作是 2n，这是一个 O(n) 复杂度。

要使此解决方案起作用，您需要使用以下操作实现双端队列数据结构：

class DobuleEndedQueue
int front(), void pushFront(int n), void popFront() // peeks at the front element, adds and removes to the front
int back(), void pushBack(int n) , void popBack() // same for the back element

用一个简单的例子进一步解释算法：

• 遍历前 k 个元素并将它们作为索引插入到双端 Q 数据结构中，这样 A[Q.front()] 是最小元素，A[Q.back()] 是最大元素窗口。
• 在我们构建窗口时，从该队列中丢弃“不必要的”元素：不会被计算在内的最小元素和窗口外的元素
• 为 A=[8, 6, 9, 2] 和 k-3 构建队列的示例
• 1. Q = [0]，（在 Q 后面插入 0，因为 A[0] 是我们见过的最小元素。）
• 2. Q = [1], (A[1]
• 3. Q = [1, 2], B=[8] (A[2] is > Q.back(), 所以我们只需在 Q 上加 2。B[0] 将是 Q 中的最小项，即A[Q.first()]，即A[1])
• 4. Q = [3], B=[8, 2] (A[4] 小于 Q 中的所有元素，所以我们将它们全部弹出。B[1] 将是 Q 中的最小项，A[ Q.first()]，即A[3]

Answer 2

使用带有双端队列的标准滑动窗口最小算法可以实现O(n) 时间复杂度。这是它的详细描述：http://people.cs.uct.ac.za/~ksmith/articles/sliding_window_minimum.html

Answer 3

我想到的第一个想法是使用两组。两组都存储std::pair<index_t,value_t>，但顺序不同。 （一个按索引排序，一个按值排序）。这样，您可以在每一步迭代槽数组找到最小值（集合中的第一个元素按值排序）以及要从两个集合中删除的元素/对（集合中的第一个元素按索引排序）。在每个步骤中，您在每组中添加对并从每组中删除对。