Question

我正在为有关hackerrank deque-stl的问题而苦苦挣扎。我实现了一种算法，该算法可在窗口中找到最大元素并存储其索引，然后仅当最大元素的索引位于索引之间时，才使用上一个窗口中最大元素的索引在下一个窗口中查找最大元素。下一个窗口的使用此算法和注释中提到的建议，我已经实现了此更新的算法，但仍然遇到错误的答案错误。

#include <iostream>
#include <algorithm>
#include <bits/stdc++.h>
using namespace std;
int m,idx;
void maxinwindow(int arr[], int start, int end)
{
    /*If the index of the maximum element in the previous window
    is between the indexes of next windows then no need to compare 
    elements that were in previous window */
    if(idx>=start)
    {
        if(arr[idx]>=arr[end])
        {
            m=arr[idx];
        }
        else
        {
            m=arr[end];
            idx=end;
        }
    }
    else
    {
        if(arr[start]>=arr[start+1])
            m=arr[start];
        else
            m=arr[start+1];
        for(int k=start+2;k<=end;k++)
        {
            if(arr[k]>=m)
            {
                m=arr[k];
                idx=k;
            }
        }
    }
}
int main()
{
    int arr[100000];
    int q;
    cin>>q;
    for(int i=1,size,ws;i<=q;i++)
    {
        m=0;
        cin>>size;  //Array size
        cin>>ws;   //Window Size
        //Entering The Elements In The Array
        for(int j=1;j<=size;j++)
        {
            cin>>arr[j];
        }
        //Boundary Condition i.e. Windows size is equal to 1
        if(ws==1)
        {
            for(int j=1;j<=size;j++)
            {
                cout<<arr[j]<<" ";
            }
        }
        else
        {
            for(int k=1;k<=ws;k++)
            {
                if(arr[k]>=m)
                {
                    m=arr[k];
                    idx=k;
                }
            }
            cout<<m<<" ";
            for(int k=2,j;k<=(size-(ws-1));k++)
            {
                j=(k+(ws-1));
                maxinwindow(arr,k,j);
                cout<<m<<" ";
            }
            cout<<endl;
        }
    }
}

Answer 1

简介

要有效解决此问题，请跟踪在当前或后续滑动窗口内可能是最大值的元素。

算法

在您的 Hackerrank 练习中，应该使用std::deque才能有效地解决问题。因此，我建议不要偏离这一点，并使用std::deque解决它。

让我们考虑一个例子。给定一个数组arr = [4, 3, 4, 2, 5]和窗口k = 3，如何在每个长度为3的子数组中找到最大值？

浏览第一个3元素，并将数组元素的相关索引保留在队列中。
```
Step 1
arr:     |4| 3 4 2 5
queue :  |0|
```
添加第一个元素的索引，因为队列为空。
```
Step 2
arr:     |4 3| 4 2 5
queue :  |0 1|
```
添加索引1，但将0保留为arr[0] > arr[1]。但是，为什么要保留1呢？即使arr11]在此滑动窗口中较小，但在没有arr[0]的情况下，它可能是另一个窗口中最大的。
```
Step 3
arr:     |4 3 4| 2 5
queue :  |  2  |
```
在最后一步中，我们仅将2保留在队列中。为什么？因为arr[2]不小于
arr[0]或arr[1]。因此，将这些索引保持为最大值没有意义子数组中的值仍为arr[2]。

由于第一个滑动窗口已完成，请打印arr[queue.front()]。队列的第一个元素对应于子数组中最大元素的索引。
一旦处理了第一个3元素，在每次迭代中，滑动窗口就会开始向右移动：
```
arr:      4 |3 4 2| 5
queue :     | 2 3 | 
```
将arr[2]打印为最大值。同样，队列的第一个元素对应于子数组中最大元素的索引。 3保留在队列中，因为它可能与下一个滑动窗口中的最大值索引相对应。
```
arr:      4 3 |4 2 5|
queue :       |  4  |
```
最后，4仍然是唯一的元素，因为无论如何2都会弹出（它不属于当前窗口）和arr[4] >= arr[3]，所以对于保留它。

总结一下，这是算法的步骤：

对于数组的前k个元素，将可能的max子数组元素的索引存储在队列中。在每个第i次迭代中，如果它们的映射值不超过arr[i]，则从队列中弹出元素，然后将arr[i]推入队列。

最后，队列的第一个元素包含最大值的索引。
对于其余的数组元素，在每次迭代i上，仅当第一个元素front不再属于当前滑动窗口时，才会弹出第一个元素-i - front == k 。然后，像以前一样，弹出索引值不超过arr[i]的索引，然后将arr[i]推入队列（同样，在每次迭代的末尾，队列包含最大值的索引）。

希望，现在可以清楚地实现此想法了。解决方案的时间复杂度为O（n）。空间复杂度也是O（n）。

代码

#include <algorithm>
#include <iostream>
#include <deque> 

void printKMax(int arr[], int n, int k){
    std::deque<int> queue;

    for (int i = 0; i < k; i++) {
        while (!queue.empty() && arr[queue.back()] <= arr[i]) {
            queue.pop_back();
        }

        queue.push_back(i);
    } 

    for (int i = k; i < n; i++) {
        std::cout << arr[queue.front()] << " ";

        // an element with index queue.front() no longer belong to ths window
        if (i - queue.front() == k) {
            queue.pop_front();  
        }

        // pop all elements that don't exceed arr[i] as they're no longer useful
        while (!queue.empty() && arr[queue.back()] <= arr[i]) {
            queue.pop_back();
        }  

        queue.push_back(i);
    }

    std::cout << arr[queue.front()] << "\n";
}

关于Hackerrank的问题中的错误答案错误

1 个答案:

简介

算法

代码