#include <bits/stdc++.h>
using namespace std;
long long int gcd(long long int a, long long int b) {
  if (a == 0) return b;
  if (b == 0) return a;
  return gcd(b % a, a);
}
long long int my_pow(long long int a, long long int b) {
  if (b == 0) return 1;
  if (b == 1) return a;
  long long int half = my_pow(a, b / 2);
  long long int ans = (half * half);
  if (b % 2) {
    ans = (ans * a);
  }
  return ans;
}
long long int my_pow_mod_p(long long int a, long long int b, long long int p) {
  if (b == 0) return 1;
  if (b == 1) return a % p;
  long long int half = my_pow(a, b / 2);
  long long int ans = (half * half) % p;
  if (b % 2) {
    ans = (ans * a) % p;
  }
  return ans;
}
class combinatorics {
  long long int N;
  long long int p;
  vector<long long int> fact;
  void cal() {
    fact[0] = 1;
    fact[1] = 1;
    for (long long int i = 2; i < N; i++) {
      fact[i] = (i * fact[i - 1]) % 1000000007;
    }
  }

 public:
  combinatorics(long long int n1, long long int p1) {
    p = p1;
    N = max(n1, 2LL);
    fact.resize(N);
    cal();
  }
  long long int nPr(long long int n, long long int r) {
    if (n < r) {
      return 0;
    }
    long long int val = (fact[n] * my_pow_mod_p(fact[n - r], p - 2, p)) % p;
    return val;
  }
  long long int nCr(long long int n, long long int r) {
    if (n < r) {
      return 0;
    }
    long long int val = nPr(n, r);
    val = (val * my_pow_mod_p(fact[r], p - 2, p)) % p;
    return val;
  }
  long long int get_fact(long long int n) { return fact[n]; }
};
struct data {
  long long int mx;
  long long int idx;
  data() : mx(-1000000000000000000), idx(-1){};
  void print() { printf("[%lld : %lld]", mx, idx); }
};
struct SegTree {
  long long int N;
  vector<data> st;
  vector<bool> cLazy;
  vector<long long int> lazy;
  SegTree(long long int n) {
    N = n;
    st.resize(4 * N + 5);
    cLazy.assign(4 * N + 5, false);
    lazy.assign(4 * N + 5, 0);
  }
  void init(long long int n) {
    N = n;
    st.resize(4 * N + 5);
    cLazy.assign(4 * N + 5, false);
    lazy.assign(4 * N + 5, 0);
  }
  void merge(data &cur, data &l, data &r) {
    cur = l;
    if (l.mx <= r.mx) {
      cur = r;
    }
  }
  void propagate(long long int node, long long int L, long long int R) {
    if (L != R) {
      cLazy[node * 2] = 1;
      cLazy[node * 2 + 1] = 1;
      lazy[node * 2] += lazy[node];
      lazy[node * 2 + 1] += lazy[node];
    }
    st[node].mx += lazy[node];
    lazy[node] = 0;
    cLazy[node] = 0;
  }
  void build(long long int node, long long int L, long long int R) {
    if (L == R) {
      st[node].mx = -1000000000000000000;
      return;
    }
    long long int M = (L + R) / 2;
    build(node * 2, L, M);
    build(node * 2 + 1, M + 1, R);
    merge(st[node], st[node * 2], st[node * 2 + 1]);
  }
  void build(long long int node, long long int L, long long int R,
             vector<long long int> &A) {
    if (L == R) {
      st[node].mx = A[L];
      st[node].idx = L;
      return;
    }
    long long int M = (L + R) / 2;
    build(node * 2, L, M, A);
    build(node * 2 + 1, M + 1, R, A);
    merge(st[node], st[node * 2], st[node * 2 + 1]);
  }
  data Query(long long int node, long long int L, long long int R,
             long long int i, long long int j) {
    if (cLazy[node]) propagate(node, L, R);
    if (j < L || i > R) return data();
    if (i <= L && R <= j) return st[node];
    long long int M = (L + R) / 2;
    data left = Query(node * 2, L, M, i, j);
    data right = Query(node * 2 + 1, M + 1, R, i, j);
    data cur;
    merge(cur, left, right);
    return cur;
  }
  data pQuery(long long int node, long long int L, long long int R,
              long long int pos) {
    if (cLazy[node]) propagate(node, L, R);
    if (L == R) return st[node];
    long long int M = (L + R) / 2;
    if (pos <= M)
      return pQuery(node * 2, L, M, pos);
    else
      return pQuery(node * 2 + 1, M + 1, R, pos);
  }
  void Update(long long int node, long long int L, long long int R,
              long long int i, long long int j, long long int val) {
    if (cLazy[node]) propagate(node, L, R);
    if (j < L || i > R) return;
    if (i <= L && R <= j) {
      cLazy[node] = 1;
      lazy[node] += val;
      propagate(node, L, R);
      return;
    }
    long long int M = (L + R) / 2;
    Update(node * 2, L, M, i, j, val);
    Update(node * 2 + 1, M + 1, R, i, j, val);
    merge(st[node], st[node * 2], st[node * 2 + 1]);
  }
  data Print(long long int node, long long int L, long long int R) {
    if (L == R) {
      printf("{%lld, %lld} : ", L, R);
      st[node].print();
      cout << endl;
      printf("L{%lld, %s} : ", lazy[node], cLazy[node] ? "true" : "false");
      cout << endl;
      return st[node];
    }
    long long int M = (L + R) / 2;
    data left = Print(node * 2, L, M);
    data right = Print(node * 2 + 1, M + 1, R);
    data cur;
    merge(cur, left, right);
    printf("{%lld, %lld} : ", L, R);
    cur.print();
    cout << endl;
    printf("L{%lld, %s} : ", lazy[node], cLazy[node] ? "true" : "false");
    cout << endl;
    return cur;
  }
  void pUpdate(long long int node, long long int L, long long int R,
               long long int pos, long long int val) {
    if (cLazy[node]) propagate(node, L, R);
    if (L == R) {
      cLazy[node] = 1;
      lazy[node] = val;
      propagate(node, L, R);
      return;
    }
    long long int M = (L + R) / 2;
    if (pos <= M)
      pUpdate(node * 2, L, M, pos, val);
    else
      pUpdate(node * 2 + 1, M + 1, R, pos, val);
    merge(st[node], st[node * 2], st[node * 2 + 1]);
  }
  data query(long long int pos) { return pQuery(1, 1, N, pos); }
  data query(long long int l, long long int r) { return Query(1, 1, N, l, r); }
  void update(long long int pos, long long int val) {
    pUpdate(1, 1, N, pos, val);
  }
  void update(long long int l, long long int r, long long int val) {
    Update(1, 1, N, l, r, val);
  }
  void print() { Print(1, 1, N); }
};
bool my_compare(pair<long long int, long long int> &p1,
                pair<long long int, long long int> &p2) {
  if (p1.first == p2.first) {
    return p1.second > p2.second;
  }
  return p1.first < p2.first;
}
struct cmp {
  bool operator()(const pair<long long int, long long int> &p1,
                  const pair<long long int, long long int> &p2) const {
    if (p1.first == p2.first) {
      return p1.second > p2.second;
    }
    return p1.first < p2.first;
  }
};
long long int get_orig_ans(vector<long long int> a, long long int n,
                           long long int k) {
  int cur = 0;
  vector<int> v;
  for (int i = n - 1; i >= 0; --i) {
    cur += a[i];
    if (i) v.push_back(cur);
  }
  sort(v.rbegin(), v.rend());
  for (int i = 0; i < k - 1; ++i) {
    cur += v[i];
  }
  return cur;
}
vector<long long int> gen_arr(long long int n, long long int min_val,
                              long long int counter) {
  vector<long long int> V(n, min_val);
  for (long long int i = 0; i < n; i++) {
    cin >> V[i];
  }
  return V;
}
long long int get_ans(long long int n, long long int k) {
  vector<long long int> A(n);
  for (long long int i = 0; i < n; i++) {
    cin >> A[i];
  }
  if (n == 1) {
    return A[0];
  }
  for (int i = n - 2; i >= 0; --i) {
    A[i] += A[i + 1];
  }
  sort(A.begin() + 1, A.end());
  long long int counter = k;
  long long int idx = n - 1;
  long long int ans = 0;
  while (counter > 1) {
    ans += A[idx];
    --idx;
    --counter;
  }
  ans += A[0];
  return ans;
}
void print(vector<long long int> &A) {
  long long int n = A.size();
  for (long long int i = 0; i < n; i++) {
    cout << A[i] << " ";
  }
  cout << endl;
}
int main() {
  ios::sync_with_stdio(0);
  cin.tie(0);
  cout.tie(0);
  ;
  long long int n, k;
  cin >> n >> k;
  long long int ans = get_ans(n, k);
  cout << ans << endl;
  return 0;
}
