#include<bits/stdc++.h>

#define int long long
#define all(x) x.begin(),x.end()
#define rall(x) x.rbegin() , x.rend()
#define f first
#define second

using namespace std;
using ll = long long;
using vll = vector<ll>;
using vvll = vector<vll>;
using pi = pair<int , int>;
using vpi = vector<pi>;


const int mod = 1e9 + 7;

ll summ(int a , int b , const int &mod) {
    return ((a + b) % mod + mod) % mod;
}
ll mn(int a , int b , const int &mod) {
    return ((a - b) % mod + mod) % mod;
}
ll umn(int a , int b , const int &mod) {
    return ((a * b) % mod + mod) % mod;
}
int binpow(int a , int p) {
    if (p == 0) return 1;
    if (p & 1) {
        return umn(a , binpow(a , p - 1) , mod);
    } else {
        int x = binpow(a , p / 2);
        return umn(x , x , mod);
    }
}

int del(int a , int b , const int &mod) {
    return umn(a , binpow(b , mod - 2) , mod);
}

struct node {
    int ans , cnt , mx , pos;
};
bool operator<(const node a , const node b) {
    return ((a.mx == b.mx ? a.pos < b.pos : a.mx < b.mx));
}

struct pope {
    int x , ind;
};
int inf = 2e9;

struct sg {
    vector<pope> tree;
    pope comp(pope a , pope b) {
        if(a.x < b.x) {
            return a;
        }
        if(a.x > b.x) {
            return b;
        }
        return {a.x , max(a.ind , b.ind)};
    }
    void build(int num , int vl , int vr) {
        if(vl + 1 == vr) {
            tree[num] = {inf , vl};
        } else {
            int vm = (vl + vr) / 2;
            build(num * 2 + 1 , vl , vm);
            build(num * 2 + 2 , vm , vr);
            tree[num] = comp(tree[num * 2 + 1] , tree[num * 2 + 2]);
        }
    }
    pope get (int num , int vl , int vr  , int l , int r) {
        if (l <= vl && vr <= r) {
            return tree[num];
        }
        if (vr <= l || r <= vl) {
            return {inf  , -1};
        }
        int vm = (vl + vr) / 2;
        return comp(get(num * 2 + 1 , vl , vm , l , r) , get(num * 2 + 2 , vm , vr , l , r));
    }
    void upd(int num , int vl , int vr , int pos , pope x) {
        if(vl + 1 == vr) {
            tree[num] = x;
        } else {
            int vm = (vl + vr) / 2;
            if(pos < vm) {
                upd(num * 2 + 1 , vl , vm , pos , x);
            } else {
                upd(num * 2 + 2 , vm , vr , pos , x);
            }
            tree[num] = comp(tree[num * 2 + 1] , tree[num * 2 + 2]);
        }
    }
};

void solve() {
    int n , k;
    cin >> n >> k;
    vector<int> a(n);
    vector<node> st;
    int sum = 0;
    for(int i = 0 ; i < n ; i++) {
        cin >> a[i];
        sum += a[i] + 1;
        st.push_back({a[i] + 1 , 1 , a[i] , i});
    }
    for(int i = 0 ; i < n - k ; i++) {
        sg t1 , t2;
        int m = st.size();
        t1.tree.resize(4 * n);
        t2.tree.resize(4 * n);
        t1.build(0 , 0 , n);
        t2.build(0 , 0 , n);
        sort(all(st));
        int best = inf , ib = -1 , jb = -1 , mn = inf , kb = -1;
        for(int j = 0 ; j < st.size() ; j++) {
            pope p = t1.get(0 , 0 , n , 0 , st[j].pos);
//            pope p2 = t2.get(0 , 0 , n , 0 , n);
            if (st[j].ans < mn) {
                mn = st[j].ans;
                kb = j;
            }
            if (p.x != 2e9) {
                if(best > p.x) {
                    best = p.x;
                    ib = j;
                    jb = p.ind;
                }
            }
//            if (p2.x != 2e9) {
//                if(best > p2.x) {
//                    best = p2.x;
//                    ib = j;
//                    jb = p2.ind;
//                }
//            }
            t1.upd(0 , 0 , n , st[j].pos , {st[j].ans - st[j].cnt , j});
//            t2.upd(0 , 0 , n , st[j].pos , {st[j].ans , j});
        }
        vector<node> c;
        if(best != inf) {
            sum -= best;
            for (int j = 0 ; j < m ; j++) {
                if(j == ib) {
                    st[j].ans += st[jb].cnt;
                    st[j].cnt += st[jb].cnt;
                }
                if(j != jb) {
                    c.push_back(st[j]);
                }
            }
        } else {
            sum -= mn;

            for (int j = 0 ; j < m ; j++) {
                if(j != kb) {
                    c.push_back(st[j]);
                }
            }
        }
//        cout << sum << ' ' << mn << ' ' << best << '\n';
//        for(auto i : c) {
//            cout << i.mx << ' ';
//        }
//        cout << '\n';
        st = c;
    }
    cout << sum;
}

signed main() {
    ios_base::sync_with_stdio(false);
    cin.tie(0);
    cout.tie(0);

    solve();
}

