Problem:
MathJax.Hub.Config({ tex2jax: { inlineMath: [["$","$"], ["\\(","\\)"]], processEscapes: true }});

Optimal Tournament

In 21XX, an annual programming contest "Japan Algorithmist GrandPrix (JAG)" has been one of the most popular mind sport events. You, the chairperson of JAG, are preparing this year's JAG competition.

JAG is conducted as a knockout tournament. This year, $N$ contestants will compete in JAG. A tournament is represented as a binary tree having $N$ leaf nodes, to which the contestants are allocated one-to-one. In each match, two contestants compete. The winner proceeds to the next round, and the loser is eliminated from the tournament. The only contestant surviving over the other contestants is the champion. The final match corresponds to the root node of the binary tree.

You know the strength of each contestant, $A_1,A_2, ..., A_N$, which is represented as an integer. When two contestants compete, the one having greater strength always wins. If their strengths are the same, the winner is determined randomly.

In the past JAG, some audience complained that there were too many boring one-sided games. To make JAG more attractive, you want to find a good tournament configuration.

Let's define the boringness of a match and a tournament. For a match in which the $i$-th contestant and the $j$-th contestant compete, we define the boringness of the match as the difference of the strength of the two contestants, $|A_i - A_j|$. And the boringness of a tournament is defined as the sum of the boringness of all matches in the tournament.

Your purpose is to minimize the boringness of the tournament.

You may consider any shape of the tournament, including unbalanced ones, under the constraint that the height of the tournament must be less than or equal to $K$. The height of the tournament is defined as the maximum number of the matches on the simple path from the root node to any of the leaf nodes of the binary tree.

Figure K-1 shows two possible tournaments for Sample Input 1. The height of the left one is 2, and the height of the right one is 3.

Write a program that calculates the minimum boringness of the tournament.

Input

The input consists of a single test case with the following format.

$N$ $K$

$A_1$ $A_2$ ... $A_N$

The first line of the input contains two integers $N$ ($2 \leq N \leq 1,000$) and $K$ ($1 \leq K \leq 50$). You can assume that $N \leq 2^K$. The second line contains $N$ integers $A_1, A_2, ..., A_N$. $A_i$ ($1 \leq A_i \leq 100,000$) represents the strength of the $i$-th contestant.

Output

Output the minimum boringness value achieved by the optimal tournament configuration.

Sample Input 1

4 3
1 3 4 7

Output for the Sample Input 1

6

Sample Input 2

5 3
1 3 4 7 9

Output for the Sample Input 2

10

Sample Input 3

18 7
67 64 52 18 39 92 84 66 19 64 1 66 35 34 45 2 79 34

Output for the Sample Input 3

114

Solution in C# (judge verdict: Accepted)

using System;
using System.Collections.Generic;
using System.Linq;
using Debug = System.Diagnostics.Debug;
//using System.Numerics;
//using static System.Math;
using Number = System.Int64;

namespace Program {
    public class Solver {
        //const long MOD = (long)1e9 + 7;
        public void Solve() {
            var n = ri; var T = ri;
            var a = Enumerate(n, x => ri);
            Array.Sort(a);

            var dp = Enumerate(T + 1, x => Enumerate(n, y => new int[n]));
            var arg = Enumerate(T + 1, x => Enumerate(n, y => new int[n]));
            for (int k = 0; k <= T; k++)
                for (int i = 0; i < n; i++)
                    for (int j = 0; j < n; j++) {
                        dp[k][i][j] = 1000000000;
                        arg[k][i][j] = -1;
                    }
            for (int i = 0; i < n; i++)
                for (int k = 0; k <= T; k++) {
                    dp[k][i][i] = 0;
                    arg[k][i][i] = i;
                }
            for (int d = 1; d < n; d++)
                for (int i = 0; i < n; i++) {
                    var j = i + d;
                    if (j >= n) break;
                    //Debug.WriteLine($"{i} {j}");
                    for (int k = 1; k <= T; k++) {
                        var l = Math.Max(i, arg[k][i][j - 1] - 1);
                        var r = Math.Min(j, arg[k][i + 1][j] + 1);
                        for (int p = l + 1; p <= r; p++) {
                            var v = dp[k - 1][i][p - 1] + dp[k - 1][p][j] + a[j] - a[p - 1];
                            if (dp[k][i][j] > v) {
                                dp[k][i][j] = v;
                                arg[k][i][j] = p - 1;
                            }
                        }
                    }
                }
            Console.WriteLine(dp[T][0][n - 1]);
        }
        const long INF = 1L << 60;
        //int[] dx = { 1, 0, -1, 0 };
        //int[] dy = { 0, 1, 0, -1 };
        //*
        int ri { get { return sc.Integer(); } }
        long rl { get { return sc.Long(); } }
        double rd { get { return sc.Double(); } }
        string rs { get { return sc.Scan(); } }
        //*/

        public IO.StreamScanner sc = new IO.StreamScanner(Console.OpenStandardInput());
        static T[] Enumerate<T>(int n, Func<int, T> f) { var a = new T[n]; for (int i = 0; i < n; ++i) a[i] = f(i); return a; }
        static public void Swap<T>(ref T a, ref T b) { var tmp = a; a = b; b = tmp; }
    }
}

#region main
static class Ex {
    static public string AsString(this IEnumerable<char> ie) { return new string(ie.ToArray()); }
    static public string AsJoinedString<T>(this IEnumerable<T> ie, string st = " ") {
        return string.Join(st, ie.Select(x => x.ToString()).ToArray());
        //return string.Join(st, ie);
    }
    static public void Main() {
        Console.SetOut(new System.IO.StreamWriter(Console.OpenStandardOutput()) { AutoFlush = false });
        var solver = new Program.Solver();
        solver.Solve();
        Console.Out.Flush();
    }
}
#endregion
#region Ex
namespace Program.IO {
    using System.Globalization;
    using System.IO;
    using System.Text;
    public class Printer: StreamWriter {
        public override IFormatProvider FormatProvider { get { return CultureInfo.InvariantCulture; } }
        public Printer(Stream stream) : base(stream, new UTF8Encoding(false, true)) { }
    }
    public class StreamScanner {
        public StreamScanner(Stream stream) { str = stream; }
        public readonly Stream str;
        private readonly byte[] buf = new byte[1024];
        private int len, ptr;
        public bool isEof = false;
        public bool IsEndOfStream { get { return isEof; } }
        private byte read() {
            if (isEof) return 0;
            if (ptr >= len) { ptr = 0; if ((len = str.Read(buf, 0, 1024)) <= 0) { isEof = true; return 0; } }
            return buf[ptr++];
        }
        public char Char() { byte b = 0; do b = read(); while ((b < 33 || 126 < b) && !isEof); return (char)b; }

        public string Scan() {
            var sb = new StringBuilder();
            for (var b = Char(); b >= 33 && b <= 126; b = (char)read())
                sb.Append(b);
            return sb.ToString();
        }
        public string ScanLine() {
            var sb = new StringBuilder();
            for (var b = Char(); b != '\n' && b != 0; b = (char)read())
                if (b != '\r') sb.Append(b);
            return sb.ToString();
        }
        public long Long() { return isEof ? long.MinValue : long.Parse(Scan()); }
        public int Integer() { return isEof ? int.MinValue : int.Parse(Scan()); }
        public double Double() { return isEof ? double.NaN : double.Parse(Scan(), CultureInfo.InvariantCulture); }
    }
}
#endregion