import sys

INF = 10**18

def min_total_loss(T, k, loss):
    """
    返回在不允许连续跳过的条件下，恰好跳过k步的最小总损失；无解返回-1
    """
    n = T - 1  # 可跳过的位置数量
    if k < 0 or k > n:
        return -1

    # dp[i][j][0/1]
    dp = [[[INF, INF] for _ in range(k + 1)] for _ in range(n + 1)]
    dp[0][0][0] = 0

    for i in range(1, n + 1):
        cost = loss[i - 1]  # 位置i对应的损失
        for j in range(0, k + 1):
            # 不跳过位置i
            dp[i][j][0] = min(dp[i - 1][j][0], dp[i - 1][j][1])

            # 跳过位置i：上一位置必须不跳过，且j>=1
            if j >= 1 and dp[i - 1][j - 1][0] != INF:
                dp[i][j][1] = dp[i - 1][j - 1][0] + cost

    ans = min(dp[n][k][0], dp[n][k][1])
    return -1 if ans >= INF else ans

def main():
    data = sys.stdin.read().strip().split()
    if not data:
        return
    T = int(data[0])
    k = int(data[1])
    # 题面保证是T-1个正整数；直接按token读取
    loss = list(map(int, data[2:2 + (T - 1)]))
    print(min_total_loss(T, k, loss))

if __name__ == "__main__":
    main()

#include <bits/stdc++.h>
using namespace std;

static const long long INF = (long long)4e18;

// 返回最小总损失；无解返回-1
long long minTotalLoss(int T, int k, const vector<int>& loss) {
    int n = T - 1; // 可跳过的位置数
    if (k < 0 || k > n) return -1;

    // dp[i][j][0/1]
    vector<vector<array<long long, 2>>> dp(n + 1, vector<array<long long, 2>>(k + 1, {INF, INF}));
    dp[0][0][0] = 0;

    for (int i = 1; i <= n; i++) {
        long long cost = loss[i - 1]; // 位置i的损失
        for (int j = 0; j <= k; j++) {
            // 不跳过位置i
            dp[i][j][0] = min(dp[i - 1][j][0], dp[i - 1][j][1]);

            // 跳过位置i：上一位置必须不跳过
            if (j >= 1 && dp[i - 1][j - 1][0] < INF) {
                dp[i][j][1] = dp[i - 1][j - 1][0] + cost;
            }
        }
    }

    long long ans = min(dp[n][k][0], dp[n][k][1]);
    return ans >= INF ? -1 : ans;
}

int main() {
    ios::sync_with_stdio(false);
    cin.tie(nullptr);

    int T, k;
    cin >> T >> k;

    int n = T - 1;
    vector<int> loss(n);
    for (int i = 0; i < n; i++) cin >> loss[i];

    cout << minTotalLoss(T, k, loss) << "\n";
    return 0;
}

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.StringTokenizer;

public class Main {

    private static final long INF = (long) 4e18;

    // 返回最小总损失；无解返回-1
    public static long minTotalLoss(int T, int k, int[] loss) {
        int n = T - 1; // 可跳过的位置数
        if (k < 0 || k > n) return -1;

        // dp[i][j][0/1]
        long[][][] dp = new long[n + 1][k + 1][2];
        for (int i = 0; i <= n; i++) {
            for (int j = 0; j <= k; j++) {
                dp[i][j][0] = INF;
                dp[i][j][1] = INF;
            }
        }
        dp[0][0][0] = 0;

        for (int i = 1; i <= n; i++) {
            long cost = loss[i - 1]; // 位置i的损失
            for (int j = 0; j <= k; j++) {
                // 不跳过位置i
                dp[i][j][0] = Math.min(dp[i - 1][j][0], dp[i - 1][j][1]);

                // 跳过位置i：上一位置必须不跳过
                if (j >= 1 && dp[i - 1][j - 1][0] < INF) {
                    dp[i][j][1] = dp[i - 1][j - 1][0] + cost;
                }
            }
        }

        long ans = Math.min(dp[n][k][0], dp[n][k][1]);
        return ans >= INF ? -1 : ans;
    }

    public static void main(String[] args) throws Exception {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        StringBuilder sb = new StringBuilder();
        String line;
        while ((line = br.readLine()) != null) {
            line = line.trim();
            if (!line.isEmpty()) sb.append(line).append(" ");
        }
        StringTokenizer st = new StringTokenizer(sb.toString());
        if (!st.hasMoreTokens()) return;

        int T = Integer.parseInt(st.nextToken());
        int k = Integer.parseInt(st.nextToken());

        int n = T - 1;
        int[] loss = new int[n];
        for (int i = 0; i < n; i++) {
            loss[i] = Integer.parseInt(st.nextToken());
        }

        System.out.println(minTotalLoss(T, k, loss));
    }
}