## https://yukicoder.me/problems/no/738

class BinaryIndexTree:
    """
    フェニック木(Binary Indexed Tree / Fenwick Tree)
    """

    def __init__(self, size):
        self.size = size
        self.array = [0] * (size + 1)

    def add(self, x, a):
        index = x
        while index <= self.size:
            self.array[index] += a
            index += index & (-index)

    def sum(self, x):
        index = x
        ans = 0
        while index > 0:
            ans += self.array[index]
            index -= index & (-index)
        return ans

    def least_upper_bound(self, value):
        """
        sum(i) >= value を満たす最小の index i を返す。

        すなわち

            min { i | sum(i) >= value }

        を求める。

        条件を満たす index が存在しない場合は -1 を返す。
        """

        if self.sum(self.size) < value:
            return -1
        elif value <= 0:
            return 0

        m = 1
        while (m << 1) <= self.size:
            m <<= 1

        k = 0
        k_sum = 0

        while m > 0:
            k0 = k + m
            if k0 <= self.size:
                if k_sum + self.array[k0] < value:
                    k_sum += self.array[k0]
                    k = k0
            m >>= 1

        return k + 1

    def greatest_lower_bound(self, value):
        """
        sum(i) <= value を満たす最大の index i を返す。

        すなわち

            max { i | sum(i) <= value }

        を求める。

        index 0 について sum(0) = 0 と考える。

        value < 0 の場合は条件を満たす index が存在しないため
        -1 を返す。
        """

        if value < 0:
            return -1

        m = 1
        while (m << 1) <= self.size:
            m <<= 1

        k = 0
        k_sum = 0

        while m > 0:
            k0 = k + m
            if k0 <= self.size:
                if k_sum + self.array[k0] <= value:
                    k_sum += self.array[k0]
                    k = k0
            m >>= 1

        return k


def main():
    N, K = map(int , input().split())
    A = list(map(int ,input().split()))

    # 座標圧縮
    a_set = set(A)
    a_list = list(a_set)
    a_list.sort()
    a_map = {}
    for i, a in enumerate(a_list):
        a_map[a] = i + 1
    a_max = len(a_list)

    bit_count = BinaryIndexTree(a_max)
    bit_sum = BinaryIndexTree(a_max)

    def calc_ans(K, bit_count, bit_sum):
        k = (K + 1) // 2
        l = bit_count.least_upper_bound(k)
        x0 = a_list[l - 1]

        answer = x0 * bit_count.sum(l) - bit_sum.sum(l)
        answer += bit_sum.sum(bit_sum.size) - bit_sum.sum(l) - x0 * (bit_count.sum(bit_count.size) - bit_count.sum(l))
        return answer


    for i in range(K):
        a = A[i]
        a_ = a_map[a]
        bit_count.add(a_, 1)
        bit_sum.add(a_, a)

    answer = calc_ans(K, bit_count, bit_sum)

    for i in range(K, N):
        a = A[i]
        a_ = a_map[a]
        bit_count.add(a_, 1)
        bit_sum.add(a_, a)
        b = A[i - K]
        b_ = a_map[b]
        bit_count.add(b_, -1)
        bit_sum.add(b_, -b)

        ans = calc_ans(K, bit_count, bit_sum)
        answer = min(answer, ans)
    print(answer)

    








if __name__ == '__main__':
    main()