output_description: Print a sequence of the minimum in a line. Print a space character between
  adjacent elements.
input_description: The input is given in the following format.
  
  $N$ $L$  
  $a_1$ $a_2$ ... $a_N$
attempt: import sys
  
  sys.setrecursionlimit(2147483647)
  INF = float("inf")
  MOD = 10**9 + 7
  input = lambda: sys.stdin.readline().rstrip()
  
  
  class SWAG(object):
      def __init__(self, dot):
          self.__front = []
          self.__back = []
          self.__dot = dot
  
      def __bool__(self):
          return True if (self.__front or self.__back) else False
  
      def __len__(self):
          return len(self.__front) + len(self.__back)
  
      def sum(self):
          assert self
          front = self.__front
          back = self.__back
          if not front:
              return back[-1][1]
          elif not back:
              return front[-1][1]
          else:
              return self.__dot(front[-1][1], back[-1][1])
  
      def append(self, x):
          back = self.__back
          if not back:
              back.append((x, x))
          else:
              back.append((x, self.__dot(back[-1][1], x)))
  
      def popleft(self):
          assert self
          front = self.__front
          back = self.__back
          if not front:
              front.append((back[-1][0], back[-1][0]))
              back.pop()
              while back:
                  front.append((back[-1][0], self.__dot(back[-1][0], front[-1][1])))
                  back.pop()
          front.pop()
  
  
  def resolve():
      n, k = map(int, input().split())
      A = list(map(int, input().split()))
      ans = [None] * n
      swag = SWAG(min)
      for i, a in enumerate(A):
          swag.append(a)
          ans[i] = swag.sum()
          if i - k + 1 >= 0:
              swag.popleft()
      print(*ans[k - 1 :])
  
  
  resolve()
  
problem_description: Sliding Minimum Element
  
  For a given array $a_1, a_2, a_3, ... , a_N$ of $N$ elements and an integer
  $L$, find the minimum of each possible sub-arrays with size $L$ and print them
  from the beginning. For example, for an array $\\{1, 7, 7, 4, 8, 1, 6\\}$ and
  $L = 3$, the possible sub-arrays with size $L = 3$ includes $\\{1, 7, 7\\}$,
  $\\{7, 7, 4\\}$, $\\{7, 4, 8\\}$, $\\{4, 8, 1\\}$, $\\{8, 1, 6\\}$ and the
  minimum of each sub-array is 1, 4, 4, 1, 1 respectively.
samples: [{"input": "7 3\n    1 7 7 4 8 1 6", "output": "1 4 4 1 1"}]