Problem:
ストーブ(Stove)
JOI 君の部屋にはストーブがある．JOI 君自身は寒さに強いのでひとりで部屋にいるときはストーブをつける必要はないが，来客があるときはストーブをつける必要がある．
この日，JOI 君のもとには
N
人の来客がある．
i
番目(
1 \leq i \leq N
) の来客は時刻
T_i
に到着し，時刻
T_i + 1
に退出する．同時に複数人の来客があることはない．
JOI 君は任意の時刻にストーブをつけたり消したりできる．ただし，ストーブをつける度にマッチを1本消費する．JOI 君はマッチを
K
本しか持っていないので，
K
回までしかストーブをつけることができない．一日のはじめにストーブは消えている．
ストーブをつけているとその分だけ燃料を消費するので，ストーブをつけたり消したりする時刻をうまく定めて，ストーブがついている時間の合計を最小化したい．
課題
JOI 君の部屋への来客の情報と，JOI 君の持っているマッチの本数が与えられたとき，ストーブがついている時間の合計の最小値を求めよ．
入力
標準入力から以下の入力を読み込め．
1 行目には，2 つの整数
N, K
が空白を区切りとして書かれている．これは，JOI 君の部屋に
N
人の来客があり，JOI 君は
K
本のマッチを持っていることを表す．
続く
N
行のうちの
i
行目(
1 \leq i \leq N
) には，整数
T_i
が書かれている．これは，
i
番目の来客が時刻
T_i
に到着し，時刻
T_i + 1
に退出することを表す．
出力
標準出力に，ストーブがついている時間の合計の最小値を1 行で出力せよ．
制限
すべての入力データは以下の条件を満たす．
1 \leq N \leq 100 000．
1 \leq K \leq N．
1 \leq T_i \leq 1 000 000 000 (1 \leq i \leq N)．
T_i < T_{i+1} (1 \leq i \leq N - 1)
．
問入出力例
入力例1
3 2
1
3
6
出力例1
4
この入力例では，JOI 君の部屋への来客が3 人ある．以下のようにストーブをつけたり消したりすると，来客がある間はストーブがついており，ストーブをつける回数は2 回であり，ストーブがついている時間の合計は(4 - 1) + (7 - 6) = 4 である．
1 番目の来客が到着する時刻1 にストーブをつける．
2 番目の来客が退出する時刻4 にストーブを消す．
3 番目の来客が到着する時刻6 にストーブをつける．
3 番目の来客が退出する時刻7 にストーブを消す．
ストーブをつけている時間の合計を4 未満にすることはできないので，答えとして4 を出力する．
入力例2
3 1
1
2
6
出力例2
6
この入力例では，JOI 君は1 回しかストーブをつけることができないので，1 番目の来客が到着する時刻1 にストーブをつけ，3 番目の来客が退出する時刻7 にストーブを消せばよい．
来客が退出する時刻と，その次の来客が到着する時刻が一致する場合があることに注意せよ．
入力例3
3 3
1
3
6
出力例3
3
この入力例では，JOI 君は来客が到着する度にストーブをつけ，来客が退出する度にストーブを消せばよい．
入力例4
10 5
1
2
5
6
8
11
13
15
16
20
出力例4
12
情報オリンピック日本委員会作 『第17 回日本情報オリンピック(JOI 2017/2018) 本選』

Submitted solutions:

code_snippet: #include "bits/stdc++.h"

#define REP(i,n) for(ll i=0;i<ll(n);++i)
#define RREP(i,n) for(ll i=ll(n)-1;i>=0;--i)
#define FOR(i,m,n) for(ll i=m;i<ll(n);++i)
#define RFOR(i,m,n) for(ll i=ll(n)-1;i>=ll(m);--i)
#define ALL(v) (v).begin(),(v).end()
#define UNIQUE(v) v.erase(unique(ALL(v)),v.end());
#define DUMP(v) REP(aa, (v).size()) { cout << v[aa]; if (aa != v.size() - 1)cout << " "; else cout << endl; }
#define INF 1000000001ll
#define MOD 1000000007ll
#define EPS 1e-9

const int dx[8] = { 1,1,0,-1,-1,-1,0,1 };
const int dy[8] = { 0,1,1,1,0,-1,-1,-1 };


using namespace std;
typedef long long ll;
typedef vector<int> vi;
typedef vector<ll> vl;
typedef vector<vi> vvi;
typedef vector<vl> vvl;
typedef pair<int, int> pii;
typedef pair<ll, ll> pll;
ll max(ll a, int b) { return max(a, ll(b)); }
ll max(int a, ll b) { return max(ll(a), b); }
ll min(ll a, int b) { return min(a, ll(b)); }
ll min(int a, ll b) { return min(ll(a), b); }


int main() {
	cin.tie(0);
	ios::sync_with_stdio(false);
	int n, k;
	cin >> n >> k;
	vi t(n);
	REP(i, n)cin >> t[i];

	vi v(n - 1);
	REP(i, n - 1)v[i] = t[i + 1] - t[i];
	sort(ALL(v));
	int ans = 0;
	REP(i, n - k)ans += v[i] - 1;
	cout << ans + n << endl;


}
accuracy: 1
time_ms: 10
memory_kb: 3868
final_rank: 4

code_snippet: #include <iostream>
#include <vector>
#include <algorithm>
#include<utility>
#include<set>
#include<deque>
#include <unordered_map>
#include<string>
#include<cmath>

using namespace std;

int MIN = -1e9;
const int MOD = 10000;

int main() {
	int N,M;
	cin >> N>>M;
	deque<int>L;
	int x;
	cin >> x;
	int ans = 0;
	ans += 1;
	int y;
	for (int i = 1; i < N; i++) {
		cin >> y;
		L.push_back(y - (x + 1));
		ans += 1;
		x = y;
	}

	sort(L.rbegin(), L.rend());
	for (int i = 0; i < M - 1; i++) {
		L.pop_front();
	}

	for (int i = 0; i < L.size(); i++) {
		ans += L[i];
	}

	cout << ans<<endl;
}
accuracy: 1
time_ms: 20
memory_kb: 3764
final_rank: 9

code_snippet: #include <iostream>
#include <set>
#include <vector>
#include <stack>
#include <queue>
#include <unordered_map>
#include <algorithm>
#include <numeric>
#include <cstdlib>
using namespace std;
#define rep(i, n) for (int i = 0; i < (int)(n); ++i)

int main(){
  int n,k;
  cin >> n >> k;
  vector<int> t(n);
  rep(i,n){
    cin >> t[i];
  }
  vector<int> d(n-1);
  rep(i,n-1){
    d[i]=abs(t[i]+1-t[i+1]);
  }
  sort(d.begin(),d.end());
  long long res=n;
  if(n>k){
    rep(i,n-k){
      res += d[i];
    }
  }
  cout << res << endl;
  return 0;
}
accuracy: 1
time_ms: 20
memory_kb: 3868
final_rank: 11

code_snippet: #include <bits/stdc++.h>


using namespace std;
//make -f ../makefile SRC=
/*
*/


//------------------------------------------------------------------------------
bool DEBUG = false;
const int INF = 2147483647;

const int MAX_N = 100000;
static int vect[MAX_N];
//------------------------------------------------------------------------------
struct Diff
{
    int i, v;

    Diff(): i(-1), v(0) {}
    Diff(int val): i(-1), v(val) {}
    Diff(int idx, int val): i(idx), v(val) {}
    bool operator<(const Diff& e1) const
    {
        if (v == e1.v) return i < e1.i;
        return v > e1.v;
    }
    void debug() const { printf("i=%d, v=%d\n", i, v); }
};

typedef vector<Diff> Diffs;


//------------------------------------------------------------------------------
int64_t solve(int N, int K)
{
    //--------------------------------------------------------------------------
    // base cases:
    if (K == 1) return vect[N-1]-vect[0]+1;
    else if (K == N) return N;

    //--------------------------------------------------------------------------
    // init:
    Diffs DD(N-1);
    for (int i=0; i<N-1; ++i) DD[i] = Diff(i, vect[i+1]-vect[i]);
    sort(DD.begin(), DD.end());

    vector<int> indices(K-1);
    for (int k=0; k<K-1; ++k) indices[k] = DD[k].i;
    sort(indices.begin(), indices.end());
    //--------------------------------------------------------------------------
    // compute:
    int64_t res = 0;
    int start = 0;
    for (int k=0; k<K-1; ++k)
    {
        int back = indices[k];
        res += vect[back] - vect[start] + 1;
        start = back + 1;
    }
    res += vect[N-1] - vect[start] + 1;

    //--------------------------------------------------------------------------
    // report:
    return res;
}

//------------------------------------------------------------------------------
void test()
{

}

//------------------------------------------------------------------------------
int main()
{
    //test(); return 0;
    //DEBUG = true;
    //--------------------------------------------------------------------------
    int N, K, num;
    num = scanf("%d %d ", &N, &K);
    for (int i=0; i<N; ++i) num = scanf("%d ", &vect[i]);
    int64_t res = solve(N, K);
    printf("%ld\n", res);
    //--------------------------------------------------------------------------
    return 0;
}
//------------------------------------------------------------------------------
accuracy: 1
time_ms: 10
memory_kb: 4720
final_rank: 10

code_snippet: #include <iostream>
#include <vector>
#include <algorithm>

using namespace std;

int main() {
    int N, K;
    cin >> N >> K;
    
    vector<int> T(N);
    for (int i = 0; i < N; ++i) {
        cin >> T[i];
    }
    
    // ストーブを点けた状態の合計時間を計算
    int total_time = T[N-1] - T[0] + 1;

    // ギャップを計算
    vector<int> gaps;
    for (int i = 1; i < N; ++i) {
        gaps.push_back(T[i] - T[i-1] - 1);
    }

    // ギャップを大きい順にソート
    sort(gaps.begin(), gaps.end(), greater<int>());
    
    // K-1個の最大ギャップを使って合計時間を短縮
    int max_gap_sum = 0;
    for (int i = 0; i < K-1; ++i) {
        if (i < gaps.size()) {
            max_gap_sum += gaps[i];
        }
    }
    
    // 最小のストーブ点灯時間を計算
    int min_time = total_time - max_gap_sum;
    
    cout << min_time << endl;
    
    return 0;
}
accuracy: 1
time_ms: 20
memory_kb: 4132
final_rank: 15

code_snippet: #include<algorithm>
#include<iostream>
#include<vector>
using namespace std;

int main(void) {
    int n, k;
    cin >> n >> k;
    vector<int> t(n), btw(n-1);
    for (int i = 0; i < n; i++) cin >> t[i];
    for (int i = 0; i < n-1; i++) btw[i] = t[i+1] - t[i] - 1;
    sort(btw.rbegin(), btw.rend());

    int ans = t.back() - t.front() + 1, loop_cnt = k - 1;
    for (int i = 0; i < loop_cnt; i++) {
        ans -= btw[i];
    }
    cout << ans << endl;
    return 0;
}
accuracy: 1
time_ms: 20
memory_kb: 3904
final_rank: 12

code_snippet: #line 1 "/opt/library/template.hpp"
#include <bits/stdc++.h>
using namespace std;

using ll = long long;
using i64 = long long;
using u32 = unsigned int;
using u64 = unsigned long long;
using i128 = __int128;
using u128 = unsigned __int128;
using f128 = __float128;

template <class T>
constexpr T infty = 0;
template <>
constexpr int infty<int> = 1'000'001'000;
template <>
constexpr ll infty<ll> = ll(infty<int>) * infty<int> * 2;
template <>
constexpr u32 infty<u32> = infty<int>;
template <>
constexpr u64 infty<u64> = infty<ll>;
template <>
constexpr i128 infty<i128> = i128(infty<ll>) * infty<ll>;
template <>
constexpr double infty<double> = infty<ll>;
template <>
constexpr long double infty<long double> = infty<ll>;
#define inf infty<ll>

using pi = pair<ll, ll>;
using vi = vector<ll>;
using vvi = vector<vector<ll>>;
template <class T>
using vc = vector<T>;
template <class T>
using vvc = vector<vc<T>>;
template <class T>
using vvvc = vector<vvc<T>>;
template <class T>
using vvvvc = vector<vvvc<T>>;
template <class T>
using vvvvvc = vector<vvvvc<T>>;
template <class T>
using pq = priority_queue<T>;
template <class T>
using pqg = priority_queue<T, vector<T>, greater<T>>;

#define vv(type, name, h, ...) \
  vector<vector<type>> name(h, vector<type>(__VA_ARGS__))
#define vvv(type, name, h, w, ...)   \
  vector<vector<vector<type>>> name( \
      h, vector<vector<type>>(w, vector<type>(__VA_ARGS__)))
#define vvvv(type, name, a, b, c, ...)       \
  vector<vector<vector<vector<type>>>> name( \
      a, vector<vector<vector<type>>>(       \
             b, vector<vector<type>>(c, vector<type>(__VA_ARGS__))))

#define rep1(a) for (ll _ = 0; _ < (ll)(a); ++_)
#define rep2(i, a) for (ll i = 0; i < (ll)(a); ++i)
#define rep3(i, a, b) for (ll i = a; i < (ll)(b); ++i)
#define rep4(i, a, b, c) for (ll i = a; i < (ll)(b); i += (c))
#define rrep1(a) for (ll i = (a)-1; i >= (ll)(0); --i)
#define rrep2(i, a) for (ll i = (a)-1; i >= (ll)(0); --i)
#define rrep3(i, a, b) for (ll i = (b)-1; i >= (ll)(a); --i)
#define rrep4(i, a, b, c) for (ll i = (b)-1; i >= (ll)(a); i -= (c))
#define overload4(a, b, c, d, e, ...) e
#define rep(...) overload4(__VA_ARGS__, rep4, rep3, rep2, rep1)(__VA_ARGS__)
#define rrep(...) overload4(__VA_ARGS__, rrep4, rrep3, rrep2, rrep1)(__VA_ARGS__)

#define all(x) (x).begin(),(x).end()
#define len(x) (ll)(x.size())
#define elif else if
#define bit(x, i) (((x)>>(i))&1)

#define eb emplace_back
#define mp make_pair
#define mt make_tuple
#define fi first
#define se second

#define stoi stoll
#define abs llabs

#define MIN(v) *min_element(all(v))
#define MAX(v) *max_element(all(v))
#define LB(c, x) distance((c).begin(), lower_bound(all(c), (x)))
#define UB(c, x) distance((c).begin(), upper_bound(all(c), (x)))
#define UNIQUE(x) \
  sort(all(x)), x.erase(unique(all(x)), x.end()), x.shrink_to_fit()

ll popcnt(ll x) { return __builtin_popcountll(x); }
ll popcnt(u64 x) { return __builtin_popcountll(x); }
ll popcnt_mod_2(ll x) { return __builtin_parityll(x); }
ll popcnt_mod_2(u64 x) { return __builtin_parityll(x); }
ll topbit(ll x) { return (x == 0 ? -1 : 63 - __builtin_clzll(x)); }
ll topbit(u64 x) { return (x == 0 ? -1 : 63 - __builtin_clzll(x)); }
ll lowbit(ll x) { return (x == 0 ? -1 : __builtin_ctzll(x)); }
ll lowbit(u64 x) { return (x == 0 ? -1 : __builtin_ctzll(x)); }

template <typename T>
T floor(T a, T b) {
  return a / b - (a % b && (a ^ b) < 0);
}
template <typename T>
T ceil(T x, T y) {
  return floor(x + y - 1, y);
}
template <typename T>
T bmod(T x, T y) {
  return x - y * floor(x, y);
}
template <typename T>
pair<T, T> divmod(T x, T y) {
  T q = floor(x, y);
  return {q, x - q * y};
}

template<typename T> T SUM(const vector<T> &A) {
  T s = 0; for (auto &&a: A) s += a;
  return s;
}

// A[I[0]], A[I[1]], ...
template <typename T>
vc<T> rearrange(const vc<T> &A, const vi &I) {
  vc<T> B(len(I));
  rep(i, len(I)) B[i] = A[I[i]];
  return B;
}

template<typename T> inline bool chmax(T &a, T b) {return ((a<b)?(a=b,true):(false));}
template<typename T> inline bool chmin(T &a, T b) {return ((a>b)?(a=b,true):(false));}

inline void wt(const char c) { cout << c; }
inline void wt(const string s) { cout << s; }
inline void wt(const char *s) { cout << s; }

template <typename T>
void wt_integer(T x) {
  if (x < 0) { cout << (i64)(x); }
  else { cout << (u64)(x); }
}
template <typename T>
void wt_real(T x) {
  cout << fixed << setprecision(15) << (long double)(x);
}

inline void wt(int x) { wt_integer(x); }
inline void wt(ll x) { wt_integer(x); }
inline void wt(i128 x) { wt_integer(x); }
inline void wt(u32 x) { wt_integer(x); }
inline void wt(u64 x) { wt_integer(x); }
inline void wt(u128 x) { wt_integer(x); }
inline void wt(double x) { wt_real(x); }
inline void wt(long double x) { wt_real(x); }
inline void wt(f128 x) { wt_real(x); }

template <class T, class U>
void wt(const pair<T, U> val) {
  wt(val.first); wt(' '); wt(val.second);
}
template <size_t N = 0, typename T>
void wt_tuple(const T t) {
  if constexpr (N < std::tuple_size<T>::value) {
    if constexpr (N > 0) { wt(' '); }
    const auto x = std::get<N>(t);
    wt(x);
    wt_tuple<N + 1>(t);
  }
}
template <class... T>
void wt(tuple<T...> tpl) {
  wt_tuple(tpl);
}
template <class T, size_t S>
void wt(const array<T, S> val) {
  auto n = val.size();
  for (size_t i = 0; i < n; i++) {
    if (i) wt(' ');
    wt(val[i]);
  }
}
template <class T>
void wt(const vector<T> val) {
  auto n = val.size();
  for (size_t i = 0; i < n; i++) {
    if (i) wt(' ');
    wt(val[i]);
  }
}

void print() { wt('\n'); }
template <class Head, class... Tail>
void print(Head &&head, Tail &&... tail) {
  wt(head);
  if (sizeof...(Tail)) wt(' ');
  print(forward<Tail>(tail)...);
}

void YES(bool t = 1) { print(t ? "YES" : "NO"); }
void NO(bool t = 1) { YES(!t); }
void Yes(bool t = 1) { print(t ? "Yes" : "No"); }
void No(bool t = 1) { Yes(!t); }
void yes(bool t = 1) { print(t ? "yes" : "no"); }
void no(bool t = 1) { yes(!t); }
void onez(bool t = 1) { print(t ? 1 : 0); }
#define endl '\n'
#define dump(x) {cerr << #x " = " << x << '\n';}
#line 2 "main.cpp"

int solve();
int main() {
  cin.tie(nullptr);
  ios_base::sync_with_stdio(false);
  while (!solve()) {break;}
  return 0;
}

int solve() {
  ll N, K;
  cin >> N >> K;
  vi T(N);
  rep(i, N) cin >> T[i];
  vi d(N-1);
  rep(i, N-1) d[i] = T[i+1] - T[i] - 1;
  sort(all(d));
  ll ans = N + accumulate(d.begin(), d.begin()+max(0LL,N-K), 0LL);
  print(ans);
  return 0;
}
accuracy: 1
time_ms: 10
memory_kb: 4628
final_rank: 7

code_snippet: #include "bits/stdc++.h"

#define REP(i,num) for(ll i=0;i<(num);++i)
#define FOR(i,c,num) for(ll (i)=(c);(i)<(num);++(i))
#define LOOP(i) while(i--)
#define ALL(c) c.begin(),c.end()
#define PRINTALL(c) for(auto pitr=c.begin();pitr!=c.end();++pitr){cout<<*pitr;if(next(pitr,1)!=c.end())cout<<' ';}cout<<endl;
#define PAIRCOMP(c,comp) [](const pair<ll,ll>& lhs,const pair<ll,ll>& rhs){return lhs.c comp rhs.c;}

using namespace std;
using ll = long long;
using ull = unsigned long long;
using vll = vector<ll>;
using vvll = vector<vector<ll>>;

constexpr ll atcoder_mod = 1e9+7;

template<typename T=ll>
T in(){ T x; cin >> x; return (x); }
template<typename T=ll,typename C=vector<T>>
C vecin(int N){ C x(N);REP(i,N){ x[i]=in<T>(); }return x; }
template<typename T=ll,size_t N>
array<T,N> arrin(){array<T,N> x;REP(i,N){ x[i]=in<T>(); }return x;}

void vout(){ cout << endl; }
template<typename Head,typename... Tail>
void vout(Head&& h,Tail&&... t){ cout << ' ' << h;vout(forward<Tail>(t)...); }
void out(){ cout << endl; }
template<typename Head,typename... Tail>
void out(Head&& h,Tail&&... t){ cout << h;vout(forward<Tail>(t)...); }

template<typename T>
bool chmax(T& a,T b){ if(a<b){ a=b;return true; }return false; }
template<typename T>
bool chmin(T& a,T b){ if(a>b){ a=b;return true; }return false; }

int main(){
	cin.tie(0);
	ios::sync_with_stdio(false);
	cout<<fixed<<setprecision(10);
	
	auto N=in(),M=in();
	auto A=vecin(N);
	if(N==M){
		out(N);
		return 0;
	}
	vll D(N-1);
	REP(i,N-1){
		D[i]=A[i+1]-A[i];
	}
	ll L=N-M;
	sort(ALL(D));
	ll C=N;
	REP(i,L){
		C += D[i]-1ll;
	}
	out(C);
	return 0;
}
accuracy: 1
time_ms: 10
memory_kb: 4664
final_rank: 8

code_snippet: #include <iostream>
#include <algorithm>
using namespace std;
int main(void){

    int n,k,t[100000],x[100000],sum;
    cin>>n>>k;
    for(int i = 0;i < n;i++){
        cin>>t[i];
    }
    for(int i = 0;i < n-1;i++){
        x[i] = t[i+1] - t[i];
    }
    sort(x,x+n-1);
    sum = k;
    for(int i = 0;i < n-k;i++){
        sum += x[i];
    }
    cout<<sum<<endl;

return 0;
}
accuracy: 1
time_ms: 30
memory_kb: 3868
final_rank: 17

code_snippet: #include<cstdio>
#include<vector>
#include<algorithm>
using namespace std;
int main(){
  int n,k;
  long long a[100005];
  vector<long long> vec;
  scanf("%d %d",&n,&k);
  for(int i=0;i<n;i++) scanf("%lld",a+i);
   
  long long ans = a[n-1]-a[0]+1;
  for(int i=1;i<n;i++) vec.push_back(a[i]-a[i-1]-1);

  sort(vec.begin(),vec.end());
  reverse(vec.begin(),vec.end());
  for(int i=0;i<k-1;i++) ans -= vec[i];
  printf("%lld\n",ans);
  return(0);
}
accuracy: 1
time_ms: 10
memory_kb: 4220
final_rank: 6

code_snippet: #include <queue>
#include <stdio.h>
using namespace std;
#define N_MAX 100000
int N, K;
long long time[N_MAX];
priority_queue<int> que;
int main(void) {
  scanf("%d %d", &N, &K);
  int i, j;
  for (i = 0; i < N; ++i) {
    scanf("%d", time + i);
    if (i > 0) {
      que.push(-(time[i] - time[i - 1] - 1));
    }
  }
  if (K >= N)
    printf("%d\n", N);
  else if (K == 1)
    printf("%lld\n", time[N - 1] - time[0] + 1);
  else {
    long long sum = N;
    N -= K;
    for (i = 0; i < N; ++i) {
      sum += -que.top();
      que.pop();
    }
    printf("%lld\n", sum);
  }
  return 0;
}
accuracy: 1
time_ms: 10
memory_kb: 3688
final_rank: 2

code_snippet: #include <queue>
#include <stdio.h>
using namespace std;
#define N_MAX 100000
int N, K;
int time[N_MAX];
priority_queue<int> que;
int main(void) {
  scanf("%d %d", &N, &K);
  int i, j;
  for (i = 0; i < N; ++i) {
    scanf("%d", time + i);
    if (i > 0) {
      que.push(-(time[i] - time[i - 1] - 1));
    }
  }
  long long sum = N;
  N -= K;
  for (i = 0; i < N; ++i) {
    sum += -que.top();
    que.pop();
  }
  printf("%lld\n", sum);
  return 0;
}
accuracy: 1
time_ms: 10
memory_kb: 3408
final_rank: 1

code_snippet: #include <bits/stdc++.h>
using namespace std;
long long sa[100000];
int main(void) {
  long long n, k, t, tt, ans, i;
  cin >> n >> k;
  ans = n;
  cin >> t;
  t++;
  for (i = 0; i < n - 1; i++) {
    cin >> tt;
    sa[i] = tt - t;
    t = tt + 1;
  }
  sort(sa, sa + n - 1);
  n = n - k;
  i = 0;
  while (n > 0) {
    ans += sa[i];
    i++;
    n--;
  }
  cout << ans << endl;
  return 0;
}
accuracy: 1
time_ms: 30
memory_kb: 3940
final_rank: 18

code_snippet: /* -*- coding: utf-8 -*-
 *
 * 0647.cc: ストーブ(Stove)
 */

#include<cstdio>
#include<algorithm>
 
using namespace std;

/* constant */

const int MAX_N = 100000;

/* typedef */

typedef long long ll;

/* global variables */

int ts[MAX_N], ds[MAX_N];

/* subroutines */

/* main */

int main() {
  int n, k;
  scanf("%d%d", &n, &k);
  for (int i = 0; i < n; i++) scanf("%d", ts + i);

  for (int i = 0; i + 1 < n; i++) ds[i] = ts[i + 1] - (ts[i] + 1);
  sort(ds, ds + n - 1);

  int m = n - k;
  ll sum = 0;
  for (int i = 0; i < m; i++) sum += ds[i];

  printf("%lld\n", sum + n);

  return 0;
}
accuracy: 1
time_ms: 10
memory_kb: 3720
final_rank: 3

code_snippet: #include <bits/stdc++.h>
using namespace std;
using ll = long long;
using vll = vector<ll>;
#define all(A) A.begin(),A.end()
#define rep(i, n) for (ll i = 0; i < (ll) (n); i++)

int main() {
    ll N,K;
    cin>>N>>K;
    K--;
    vll A(N),S(N-1);
    rep(i,N)cin>>A[i];
    rep(i,N-1)S[i]=A[i+1]-A[i];
    sort(all(S));
    reverse(all(S));
    ll an=A[N-1]+1-A[0]+K;
    rep(k,K)an-=S[k];
    cout<<an<<endl;
}
accuracy: 1
time_ms: 20
memory_kb: 4620
final_rank: 16

code_snippet: #include <bits/stdc++.h>

using namespace std;

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

    int n, k;
    cin >> n >> k;

    vector<int> t(n, 0);
    for (int i = 0; i < n; ++i) {
        cin >> t[i];
    }

    vector<int> gap;
    for (int i = 0; i < n - 1; ++i) {
        gap.push_back(t[i + 1] - (t[i] + 1));
    }
    sort(gap.begin(), gap.end(), [](int x, int y) { return x > y; });
    int total_time = t[n - 1] + 1 - t[0];
    for (int i = 0; i < k - 1; ++i) {
        total_time -= gap[i];
    }
    cout << total_time << endl;
    return 0;
}
accuracy: 1
time_ms: 10
memory_kb: 4144
final_rank: 5

code_snippet: #include <bits/stdc++.h>
using namespace std;
const long long MOD1 = 1000000007;
const long long MOD2 = 998244353;
typedef long long ll;
//typedef int ll;
//typedef pair<ll, ll> P;
const long long INF = 1e9;
template <typename T>
void input_arr(vector<T>& A, ll N) {
	for (ll i = 0; i < N; i++) {
		cin >> A[i];
	}
}
template <typename T, typename Q>
void input_arr(vector<pair<T, Q>>& A, ll N) {
	for (ll i = 0; i < N; i++) {
		cin >> A[i].first >> A[i].second;
	}
}
template <typename T>
void input_arr(vector<vector<T>>& A, ll H, ll W) {
	for (ll i = 0; i < H; i++) {
		for (ll j = 0; j < W; j++) {
			cin >> A[i][j];
		}
	}
}
int main() {
    ll N, M; cin >> N >> M;
    vector<ll>A(N); input_arr(A, N);
    ll ans = A.back() + 1 - A[0];
    vector<ll>B;
    for (ll i = 1; i < N; i++) {
        B.push_back(A[i] - (A[i - 1] + 1));
    }
    sort(B.begin(), B.end(), greater<ll>());
    for (ll i = 0; i < M - 1; i++) {
        ans -= B[i];
    }
    cout << ans << endl;
}
accuracy: 1
time_ms: 20
memory_kb: 4912
final_rank: 19

code_snippet: #include<iostream>
#include<vector>
#include<algorithm>

using namespace std;

int main()
{
	int N, K;
	cin >> N >> K;
	int* T = new int[N];
	cin >> T[0];
	vector<int> vec;
	for (int i = 1; i < N; i++)
	{
		cin >> T[i];
		vec.push_back(T[i] - T[i - 1] - 1);
	}
	sort(vec.begin(), vec.end());
	int ans = N;
	for (int i = 0; i < N - K; i++)
		ans += vec[i];
	cout << ans << endl;

	//system("pause");
}
accuracy: 1
time_ms: 20
memory_kb: 4076
final_rank: 14

code_snippet: #define _USE_MATH_DEFINES
#include<iostream>
#include<string>
#include<vector>
#include<stack>
#include<queue>
#include<set>
#include<map>
#include<list>
#include<algorithm>
#include<numeric>
#include<cmath>
#include<iomanip>
#include<sstream>
#include<regex>
#include<random>
using namespace std;
#define int long long
#define uint unsigned long long
const int mod=1e9+7;
const int Mod=998244353;
const int inf=mod*mod;
const double eps=1e-9;
signed main(){
	int n,k,t[100000],dif[99999];
	cin>>n>>k;
	for(int i=0;i<n;i++)
		cin>>t[i];
	for(int i=0;i<n-1;i++)
		dif[i]=t[i+1]-t[i]-1;
	sort(dif,dif+n-1);
	int ans=n;
	for(int i=0;i<n-k;i++)
		ans+=dif[i];
	cout<<ans<<endl;
}
accuracy: 1
time_ms: 20
memory_kb: 5000
final_rank: 20

code_snippet: #include <iostream>
#include <vector>
#include <algorithm>
using namespace std;

int main(void) {
	int n, k;
	cin >> n >> k;
	vector<int> v(n-1);
	int prev;
	cin >> prev;
	for (int i = 0; i < (n - 1); ++i)
	{
		int t;
		cin >> t;
		v[i] = t - prev - 1;
		prev = t;
	}
	sort(v.begin(), v.end());
	int ans = n;
	for (int i = 0; i < (n-k); ++i)
	{
		ans += v[i];
	}
	cout << ans << endl;
	return 0;
}
accuracy: 1
time_ms: 30
memory_kb: 3144
final_rank: 13