Algorithm 在大小为n的数组中，查找大小为L的所有相邻子数组中的最小数

大小为L的子数组中的最小数。我必须为数组的所有子数组找到它。除了逐个扫描所有子阵列之外，还有其他方法吗

我有一个解决方案：

a[n]//the array
minimum[n-l+1]//the array to store the minimum numbers

minpos=position_minimum_in_subarray(a,0,l-1);
minimum[0]=a[minpos];
for(i=1;i<=n-l-1;i++)
{
    if(minpos=i-1)
    {
        minpos=position_minimum_in_subarray(a,i,i+l-1);
    }
    else {
        if(a[minpos]>a[i+l-1]) minpos=i+l-1;
        minimum=a[minpos];
    }
}

---

有比这更好的解决方案吗？

您可以使用双端队列Q。找到一种方法，使最小的元素始终出现在Q的前面，并且Q的大小永远不会超过L。因此，您最多只能插入和删除一次元素，从而使解决方案生效。我觉得这足够让你走了

我认为您的解决方案是可以的，但要正常工作，它应该是：

a[n]//the array
minimum[n-l+1]//fixed

minpos=position_minimum_in_subarray(a,0,l-1);
minimum[0]=a[minpos];
for(i=1;i<=n-l-1;i++)
{
    if(minpos=i-1)        
        minpos=position_minimum_in_subarray(a,i,i+l-1);                   
    else if(a[minpos]>a[i+l-1]) //fixed
        minpos=i+l-1; //fixed

    minimum[i] = a[minpos];
}

// Complexity Analysis :

//Time - O(n^2) in worse case(array is sorted) we will run
         "position_minimum_in_subarray" on each iteration

//Space - O(1) - "minimum array" is required for store the result

如果你想提高你的时间复杂度，你可以用额外的空间。 例如，您可以将每个子数组存储在一些自平衡BST中，例如红黑树，并在每次迭代中获取最小值：

for (int i= 0; i<n; i++) {
    bst.add(a[i]);

    if (bst.length == l) {
        minimum[i-l] = bst.min;
        bst.remove(a[i - l]);            
    }
  }

 //It's still not O(n) but close.

 //Complexity Analysis :

 //Time - O(n*log(l)) = O(n*log(n)) - insert/remove in self-balancing tree
                                      is proportional to the height of tree (log)

 //Space - O(l) = O(n) 

Scala版本答案

def movingMin(windowSize: Int, array: Seq[Double]) = { 
    (1 to array.length - (windowSize - 1)).
        map{i => (array.take(i + (windowSize - 1)).takeRight(windowSize)).min}
}

---

这是家庭作业还是面试问题？你说的最小值是什么意思？数组n中l个相邻数字的最小和？我所说的最小是指子数组中的最小数字。与此问题类似，已使用您建议的修复进行了编辑，但是否有更好的解决方案。您希望改进什么？请看我答案中的复杂性分析。我想提高复杂性，让它继续下去。我不确定你能否继续下去。请参阅我对Onlogn解决方案的回答。我对该算法的方法和实现可在此处找到：