窗口里的最小值走了，为什么不能只记住一个最小数？

"""Integer sliding minima; no third-party dependencies or benchmark claims."""
from collections import deque
from itertools import product


def require(condition, message):
    if not condition:
        raise AssertionError(message)


def sliding_minimum(values, width, trace=False):
    if type(width) is not int or not 1 <= width <= len(values):
        raise ValueError("width must be an integer in 1..len(values)")
    if any(type(value) is not int for value in values):
        raise TypeError("this example accepts integer values only")
    queue, minima, events = deque(), [], []
    pushes = removals = 0
    for index, value in enumerate(values):
        expired, dominated = [], []
        while queue and queue[0] <= index - width:
            expired.append(queue.popleft())
            removals += 1
        while queue and values[queue[-1]] >= value:
            dominated.append(queue.pop())
            removals += 1
        queue.append(index)
        pushes += 1
        minimum = values[queue[0]] if index >= width - 1 else None
        if index >= width - 1:
            minima.append(minimum)
        if trace:
            events.append((index, expired, dominated, list(queue), minimum))
    return minima, events, (pushes, removals)


def oracle(values, width):
    return [min(values[i:i + width]) for i in range(len(values) - width + 1)]


def main():
    values, width = [4, 2, 2, 5, 1, 3], 3
    minima, events, counts = sliding_minimum(values, width, trace=True)
    print(f"values={values}; width={width}")
    for index, expired, dominated, queue, minimum in events:
        print(f"i={index}; expired={expired}; dominated={dominated}; "
              f"queue={queue}; min={minimum}")
    print(f"minima={minima}; pushes={counts[0]}; removals={counts[1]}")
    require(minima == [2, 2, 1, 1], "default example")
    expiry, expiry_events, _ = sliding_minimum([1, 2, 3, 4], 2, trace=True)
    require(expiry == [1, 2, 3], "expiry")
    print(f"expiry_minima={expiry}; expired_indices={[e[1] for e in expiry_events]}")
    require(sliding_minimum([2, 2, 2], 2)[0] == [2, 2], "equal values")
    require(sliding_minimum([-3, 0, -1], 1)[0] == [-3, 0, -1], "width one")
    require(sliding_minimum([5, 4, 3], 3)[0] == [3], "full width")
    invalid = 0
    for data, size in [([], 1), ([1], 0), ([1], 2), ([1], True)]:
        try:
            sliding_minimum(data, size)
        except ValueError:
            invalid += 1
        else:
            raise AssertionError("invalid width accepted")
    try:
        sliding_minimum([float("nan")], 1)
    except TypeError:
        invalid += 1
    else:
        raise AssertionError("unsupported numeric domain accepted")
    cases = 0
    for length in range(1, 8):
        for data in product((-1, 0, 1), repeat=length):
            for size in range(1, length + 1):
                actual, _, (pushes, removals) = sliding_minimum(data, size)
                require(actual == oracle(data, size), (data, size))
                require(pushes == length and removals <= length, "operation bound")
                cases += 1
    print(f"oracle_cases={cases}; rejected_inputs={invalid}")
    print("PASS")


if __name__ == "__main__":
    main()