import bisect


class segt:
  def __init__(self, n, ele, calc):
    self.num = 2 ** (n - 1).bit_length()
    self.el = ele
    self.data = [ele] * (2 * self.num)
    self.calc = calc

  def update(self, idx, x):
    idx += self.num - 1
    self.data[idx] = x
    while idx > 0:
      idx = (idx - 1) // 2
      self.data[idx] = self.calc(self.data[2*idx+1], self.data[2*idx+2])
  
  def renew(self, idx, x):
    self.update(idx, self.calc(self.get(idx), x))

  def prod(self, left, right):
    l = left + self.num
    r = right + self.num
    res = self.el
    while l < r:
      if l % 2:
        res = self.calc(res, self.data[l-1])
        l += 1
      if r % 2:
        r -= 1
        res = self.calc(res, self.data[r-1])
      l //= 2
      r //= 2
    return res

  def get(self, idx):
    return self.data[idx+self.num-1]

def add(x, y):
  return x + y


n, k, d = map(int, input().split())
h = list(map(int, input().split()))
sorted_h = sorted(h)

st = segt(n, 0, add)
cnt = segt(n, 0, add)

di = dict()
di_inv = dict()
for v in sorted_h:
  if v in di:
    continue
  di[v] = len(di)
  di_inv[di[v]] = v

for v in h[:k]:
  st.renew(di[v], v)
  cnt.renew(di[v], 1)

ans = 1 << 60
for i in range(n-k+1):
  l, r = 0, n
  while r - l > 1:
    piv = (l + r) // 2
    x = di_inv[piv]
    u = bisect.bisect_right(sorted_h, x+d)
    # print(piv, u, x)
    if cnt.prod(0, x) > cnt.prod(u, n):
      r = piv
    else:
      l = piv
    # print(l, r)
  x = di_inv[r]
  y = x + d
  u = bisect.bisect_right(sorted_h, y)
  res = (cnt.prod(0, r) * x - st.prod(0, r)) + (st.prod(u, n) - y * cnt.prod(u, n))
  # print((r, u), (x, y), res)
  # print((cnt.prod(0, r), cnt.prod(u, n)))
  ans = min(ans, res)

  if i < n - k:
    st.renew(di[h[i]], -h[i])
    cnt.renew(di[h[i]], -1)
    st.renew(di[h[i+k]], h[i+k])
    cnt.renew(di[h[i+k]], 1)

print(ans)