O(n) 时间内的滑动窗口最大值

Question

输入：

listi = [9, 7, 8, 4, 6, 1, 3, 2, 5]

输出：

# m=3
listo = [9, 8, 8, 6, 6, 3, 5]

给定一个由n 数字组成的随机列表，我需要找到m 后续元素的所有子列表，从子列表中选择最大值并将它们放入一个新列表中。

def convert(listi, m):
    listo = []
    n = len(listi)
    for i in range(n-m+1):
        listo.append(max(listi[i:3+i]))
    return listo

这个实现的时间复杂度是O(m\^{(n-m+1)}，如果listi很长的话就很糟糕了，有没有办法在O(n)的复杂度中实现这个？

Answer 1

我尝试使用 zip 进行计时，结果似乎比您当前的函数快 50% - 但无法真正分辨出时间复杂度的差异。

import timeit

setup = """
from random import randint
listi = [randint(1,100) for _ in range(1000)]

def convert(iterable, m):
    t = [iterable[x:] for x in range(m)]
    result = [max(combo) for combo in zip(*t)]
    return result"""

print (min(timeit.Timer('a=listi; convert(a,3)', setup=setup).repeat(7, 1000)))
#0.250054761


setup2 = """
from random import randint
listi = [randint(1,100) for _ in range(1000)]

def convert2(listi, m):
    listo = []
    n = len(listi)
    for i in range(n-m+1):
        listo.append(max(listi[i:3+i]))
    return listo"""

print (min(timeit.Timer('a=listi; convert2(a,3)', setup=setup2).repeat(7, 1000)))
#0.400374625

Answer 2

令人惊讶的是，这个算法的简单描述并不那么容易理解，所以诀窍是这样的：

当您在长度为 n 的列表上滑动长度为 m 的窗口时，您会维护当前窗口中的所有元素的双端队列，可能在某些时候成为任何窗口中的最大值。

当前窗口中的一个元素可能成为最大值，如果它大于窗口中出现在它之后的所有元素。请注意，这始终包括当前窗口中的最后一个元素。

由于双端队列中的每个元素都是>它之后的所有元素，双端队列中的元素是单调递减的，因此第一个是当前窗口中的最大元素。

当窗口向右滑动一个位置时，您可以按如下方式维护此双端队列：从末尾删除所有

为了便于判断双端队列前面的元素何时掉出窗口，请将元素的 索引 存储在双端队列中，而不是它们的值。

这是一个相当有效的python实现：

def windowMax(listi, m):
    # the part of this list at positions >= qs is a deque
    # with elements monotonically decreasing.  Each one
    # may be the max in a window at some point
    q = []
    qs = 0

    listo=[]
    for i in range(len(listi)):

        # remove items from the end of the q that are <= the new one
        while len(q) > qs and listi[q[-1]] <= listi[i]:
            del q[-1]

        # add new item
        q.append(i)

        if i >= m-1:
            listo.append(listi[q[qs]])
            # element falls off start of window
            if i-q[qs] >= m-1:
                qs+=1

        # don't waste storage in q. This doesn't change the deque
        if qs > m:
            del q[0:m]
            qs -= m
    return listo

Answer 3

有一个运行时间独立于 M 的漂亮解决方案。

在下图中，第一行表示初始序列。在第二行中，我们有从左到右的 1、2、...M 个连续元素的组的最大值（“前缀”最大值）。在第三行中，我们有 1、2、... M 个连续元素的组的最大值，从右到左（“后缀”最大值）。并且在第四行中，第二行和第三行的元素的最大值。

a   b   c    d    e    f    g    h    i    j    k    l    m    n    o

a   ab  abc  d    de   def  g    gh   ghi  j    jk   jkl  m    mn   mno
        abc  bc   c    def  ef   f    ghi  hi   i    jkl  kl   l    mno  no   o

        abc  bcd  cde  def  efg  fgh  ghi  hij  ijk  jkl  klm  lmn  mno          
    

请注意，第三行中有重复的元素，我们不需要计算。

第二行的计算对每个 M 个元素的切片进行 M-1 次比较；第二行 M-2 和第三行 M。所以忽略末端的影响，我们对每个元素执行略少于 3 次的比较。

所需的存储空间是一个额外的 M 元素数组，用于临时评估第三行的切片。

来源：高效膨胀、侵蚀、开闭 算法， JOSEPH (YOSSI) GIL & RON KIMMEL。