Problem:
Max Score: 350 Points

Problem Statement

There are N buildings along the line. The i-th building from the left is colored in color i, and its height is currently a_i meters.

Chokudai is a mayor of the city, and he loves colorful thigs. And now he wants to see at least K buildings from the left.

You can increase height of buildings, but it costs 1 yens to increase 1 meters. It means you cannot make building that height is not integer.

You cannot decrease height of buildings.

Calculate the minimum cost of satisfying Chokudai's objective.

Note: "Building i can see from the left" means there are no j exists that (height of building j) ≥ (height of building i) and j < i.

Input Format

N K
a_1 a_2 a_3 ... a_N

Output Format

Print the minimum cost in one line. In the end put a line break.

Constraints

1 ≤ K ≤ N ≤ 15

1 ≤ a_i ≤ 10^9

Scoring

Subtask 1 [120 points]

N = K

Subtask 2 [90 points]

N ≤ 5

a_i ≤ 7

Subtask 3 [140 points]

There are no additional constraints.

Sample Input 1

5 5
3949 3774 3598 3469 3424

Sample Output 1

1541

The optimal solution is (height of buildings from the left) = [3949, 3950, 3951, 3952, 3953].

Sample Input 2

5 3
7 4 2 6 4

Sample Output 2

7

The optimal solution is (height of buildings from the left) = [7, 8, 2, 9, 4].

Solution in C# (Mono 4.6.2.0) (judge verdict: Wrong Answer)

//#define TEST

using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Text;
using System.Linq;
using static System.Math;

class Program
{
    static int N;
    static int K;
    static long[] a;
    static long inf = (long)1e15;

    static void Main()
    {
        string[] s = Console.ReadLine().Split();
        N = int.Parse(s[0]);
        K = int.Parse(s[1]);
        a = Console.ReadLine().Split().Select(long.Parse).ToArray();

        Pair[,] dp = new Pair[N, N + 1];
        dp[0, 0].cost = 0;
        dp[0, 0].max = a[0];
        dp[0, 1].cost = 0;
        dp[0, 1].max = a[0];
        for (int j = 2; j <= N; j++)
        {
            dp[0, j].cost = inf;
            dp[0, j].max = a[0];
        }

        for (int i = 1; i < N; i++)
        {
            dp[i, 0].cost = dp[i - 1, 0].cost;
            dp[i, 0].max = Max(dp[i - 1, 0].max, a[i]);
            for (int j = 1; j <= N; j++)
            {
                long l = dp[i - 1, j].cost;
                long r = dp[i - 1, j - 1].cost;
                if (dp[i - 1, j - 1].max >= a[i])
                    r += dp[i - 1, j - 1].max + 1 - a[i];
                if (l <= r)
                {
                    dp[i, j].cost = l;
                    dp[i, j].max = Max(dp[i - 1, j].max, a[i]);
                }
                else
                {
                    dp[i, j].cost = r;
                    if (dp[i - 1, j - 1].max >= a[i]) dp[i, j].max = dp[i - 1, j - 1].max + 1;
                    else dp[i, j].max = a[i];
                }
            }
        }
#if TEST
        for (int i = 0; i < N; i++)
        {
            for (int j = 0; j <= N; j++)
                Console.Write("({0},{1}) ", dp[i, j].cost, dp[i, j].max);
            Console.WriteLine();
        }
#endif
        Console.WriteLine(dp[N - 1, K].cost);
    }
}

struct Pair
{
    public long cost;
    public long max;
}