import sys
from collections import defaultdict

def main():
    M, K = map(int, sys.stdin.readline().split())
    A = list(map(int, sys.stdin.readline().split()))
    MK = M * K

    # Precompute S_v: for each value v, list of indices in order they appear
    S = defaultdict(list)
    for idx, num in enumerate(A):
        S[num].append(idx)
    for v in S:
        S[v].sort()  # Although they are appended in order, so already sorted

    min_inv = float('inf')

    for x in range(M):
        # Generate for each value v the target positions for current x
        target_pos = defaultdict(list)
        for j in range(MK):
            v_j = (x + j) % M
            target_pos[v_j].append(j)
        
        # Check if all target_pos[v] has exactly K elements (should always be true)
        # Now, for each value v, sorted target positions are already in order
        
        # For each element in original array, assign to the target positions in order
        perm = [0] * MK
        for v in target_pos:
            tars = target_pos[v]
            srcs = S[v]
            for i in range(len(tars)):
                perm[srcs[i]] = tars[i]
        
        # Compute inversion count of perm
        inv = 0
        # Coordinate compression for Fenwick Tree
        sorted_perm = sorted(set(perm))
        rank = {v: i + 1 for i, v in enumerate(sorted_perm)}
        size = len(sorted_perm)
        fenwick = [0] * (size + 2)
        
        for i in reversed(range(MK)):
            p = rank[perm[i]]
            # Query sum of elements < p
            idx = p - 1
            res = 0
            while idx > 0:
                res += fenwick[idx]
                idx -= idx & -idx
            inv += res
            # Update Fenwick Tree
            idx = p
            while idx <= size:
                fenwick[idx] += 1
                idx += idx & -idx
        
        if inv < min_inv:
            min_inv = inv

    print(min_inv)

if __name__ == "__main__":
    main()