Problem:
Problem E:
カントリーロード
ある過疎地域での話である．
    この地域ではカントリーロードと呼ばれるまっすぐな道に沿って，
    家がまばらに建っている．
    今までこの地域には電気が通っていなかったのだが，
    今回政府からいくつかの発電機が与えられることになった．
    発電機は好きなところに設置できるが，
    家に電気が供給されるにはどれかの発電機に電線を介してつながっていなければならず，
    電線には長さに比例するコストが発生する．
    地域で唯一の技術系公務員であるあなたの仕事は，
    すべての家に電気が供給されるという条件の下で，
    できるだけ電線の長さの総計が短くなるような発電機
    および電線の配置を求めることである．
    なお，発電機の容量は十分に大きいので，
    いくらでも多くの家に電気を供給することができるものとする．
サンプル入力の1番目のデータセットを図2に示す．
    この問題に対する最適な配置を与えるには，
    図のように
x
= 20 と
x
= 80 の位置に発電機を配置し，
    それぞれ図中のグレーで示した位置に電線を引けばよい．
図2: 発電機と電線の配置の例（入力例の最初のデータセット）．
Input
入力の1行目にはデータセットの個数
t
(0 <
t
≤ 50) が与えられる．
引き続き
t
個のデータセットが与えられる．
    データセットはそれぞれ次のような形式で2行で与えられる．
n
k
x
1
x
2
...
x
n
n
は家の戸数，
k
は発電機の個数である．
x
1
,
x
2
, ...,
x
n
はそれぞれ家の位置を表す一次元座標である．
    これらの値はすべて整数であり，
    0 <
n
≤ 100000,
    0 <
k
≤ 100000,
    0 ≤
x
1
<
x
2
<
    ... <
x
n
≤ 1000000
    を満たす．
さらに，データセットのうち 90% は，
    0 <
n
≤ 100, 0 <
k
≤ 100 を満たしている．
Output
各データセットに対し，
    必要な電線の長さの総計の最小値を1行に出力せよ．
Sample Input
6
5 2
10 30 40 70 100
7 3
3 6 10 17 21 26 28
1 1
100
2 1
0 1000000
3 5
30 70 150
6 4
0 10 20 30 40 50
Output for the Sample Input
60
13
0
1000000
0
20

Submitted solutions:

code_snippet: #include<stdio.h>
#include<math.h>
#include<string.h>
#include<iostream>
#include<algorithm>
#include<vector>
#define MAXSIZE 1000005
#define LL long long
#define INF 0x3f3f3f3f

using namespace std;

LL pos[MAXSIZE];
LL dist[MAXSIZE];

LL Solve(int n,int k)
{
    LL sum = 0;
    for(int i=1;i<n;i++)
    {
        dist[i] = pos[i+1]-pos[i];
        sum += dist[i];
    }

    sort(dist+1,dist+1+n-1);
    for(int i=n-1;i>=n-k+1 && i>=1;i--)
    {
        sum -= dist[i];
    }
    return sum;
}

int main()
{
    int T,n,k;
    scanf("%d",&T);
    while(T--)
    {
        scanf("%d%d",&n,&k);
        for(int i=1;i<=n;i++)
        {
            scanf("%lld",&pos[i]);
        }

        LL ans = Solve(n,k);
        printf("%lld\n",ans);
    }
    return 0;
}
accuracy: 1
time_ms: 20
memory_kb: 8420
final_rank: 14

code_snippet: //Q:https://judge.u-aizu.ac.jp/onlinejudge/description.jsp?id=2104
// AC
//何も考えずsortすればよかった
#include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (int i = 0; i < (int)(n); i++)


int main(){
    int num;
    cin >> num;
    rep(i,num){
        int n,k;
        cin >> n >> k;
        int pre;
        cin >> pre;
        vector<int> v;
        rep(ii,n-1){
            int cur;
            cin >> cur;
            pre = cur - pre;
            v.push_back(pre);
            pre = cur;
        }
        sort(v.begin(), v.end());
        int ans = 0;
        rep(ii,n-k){
            ans += v.at(ii);
        }
        cout << ans << endl;
    }
}
accuracy: 1
time_ms: 70
memory_kb: 3708
final_rank: 4

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

int main(){
    int t;
    cin >> t;
    for (int i = 0; i<t; i++){
        int n,k;
        cin >> n >> k;
        if (n == 1 && k >= 1){
            int x;
            cin >> x;
            cout << 0 << endl;
        }
        else if(n<=k){
            vector<int>number(n);
            for (int j = 0; j<n; j++){
                cin >> number.at(j);
            }
            cout << 0 << endl;
        }
        else if(n == 2){
            int a,b;
            cin >> a >> b;
            cout << b-a << endl;
        }
        else{
            vector<int>house(n);
            vector<int>between(n-1);
            for (int j = 0; j<n; j++){
                cin >> house.at(j);
            }
            for (int j = 0; j<n-1; j++){
                between.at(j) = house.at(j+1) - house.at(j);
            }
            sort(between.begin(),between.end());
            int num = n-k;
            int ans = 0;
            for (int j = 0; j<num; j++){
                ans += between[j];
            }
            cout << ans << endl;
        }
    }
}
accuracy: 1
time_ms: 70
memory_kb: 3808
final_rank: 6

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

int solve(int n,int k, vector<int> A){
    vector<int> B(n-1);
    for(int i=0; i<(n-1);i++){
        B.at(i)=A.at(i+1)-A.at(i);
    }
    sort(B.begin(),B.end());
    int sum=0;
    for(int i=0; i<(n-k);i++){
        sum+=B.at(i);
    }
    return sum;
}

int main()  {
    int t,N,K;
    cin>>t;
    for(int i=0;i<t;i++){
        cin>>N>>K;
        vector<int> a(N);
        for(int j=0; j<N;j++){
            cin>>a.at(j);
        }
        cout<<solve(N,K,a)<<endl;
    }
}
accuracy: 1
time_ms: 70
memory_kb: 4200
final_rank: 8

code_snippet: #include<bits/stdc++.h>
using namespace std;
using ll = long long;

int main() {
 ll t;
 cin >> t;
for(int i = 0; i < t; i++){
    ll n,k;
    cin >> n >> k;
    vector<ll>home(n);
    vector<ll>road(n);
    road[0] = 0;
 for(int j = 0; j < n; j++){
 cin >> home[j];
 if(j >0) road[j] = home[j] - home[j-1];
 }
 
 sort(road.begin(),road.end());
 reverse(road.begin(),road.end());
 if(n > k){
 ll ans = home[n-1] - home[0];
 for(int j = 0; j < k-1; j++){
   ans -= road[j];
 }
 cout << ans << endl;
}
else{
  cout << 0 << endl;
}
}
}
accuracy: 1
time_ms: 70
memory_kb: 4560
final_rank: 11

code_snippet: // 問題：https://onlinejudge.u-aizu.ac.jp/problems/2104
//　判定：

//学習コメント：

#include <bits/stdc++.h>
#include <vector>
using namespace std;
int main() {
    int n,k,a,b,c,one,ans;
    cin >> a;
    for (int i=0;i<a;i++){
        cin >> n >> k;
        if(n==1 or n <= k){
            for(int u = 0;u<n;u++){
                cin >> b;
            }
            cout << 0 << endl;
            continue;
        }
        vector<int>N(n-1,0);
        cin >> c;
        one = c;
        for(int u = 0;u<n-1;u++){
            cin >> b;
            N[u] = b - c;
            c = b;
        }
        sort(N.begin(),N.end());
        reverse(N.begin(),N.end());
        ans = c - one;
        for(int u=0;u<k-1;u++){
            ans-=N[u];
        }
        cout << ans << endl;
    }
}
accuracy: 1
time_ms: 70
memory_kb: 3452
final_rank: 3

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


using namespace std;

typedef long long int ll;
typedef vector<ll> vll;

void solve() {
  ll n, k;
  cin >> n >> k;

  vll x;
  for (ll i = 0; i < n; i++) {
    ll xi;
    cin >> xi;
    x.push_back(xi);
  }

  if (k >= n) {
    cout << 0 << endl;
    return;
  }

  vll wires;
  for (ll i = 0; i < n-1; i++) {
    wires.push_back(x[i+1] - x[i]);
  }
  sort(wires.begin(), wires.end());
  ll wires_to_keep = n-1 - (k-1);
  ll res = 0;
  for (ll i = 0; i < wires_to_keep; i++) {
    res += wires[i];
  }
  cout << res << endl;
}

int main() {
  ll t;
  cin >> t;

  for (ll i = 0; i < t; i++) {
    solve();
  }
}
accuracy: 1
time_ms: 70
memory_kb: 5640
final_rank: 20

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


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


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

const int MAX_N = 100000;
static int vect[MAX_N];
static int D[MAX_N]; // difference between adjacent houses
//------------------------------------------------------------------------------
int solve(int N, int K)
{
    if (DEBUG) printf("N=%d, K=%d\n", N, K);
    //--------------------------------------------------------------------------
    if (K >= N || N == 1) return 0;
    else if (K == 1) return vect[N-1] - vect[0];
    //--------------------------------------------------------------------------
    // init params:
    //--------------------------------------------------------------------------
    // compute:
    for (int i=0; i<N-1; ++i) D[i] = vect[i+1] - vect[i];
    int M = N-1;
    sort(D, D+M);
    int res = accumulate(D, D+M-K+1, 0);
    //--------------------------------------------------------------------------
    // report:
    return res;
}

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

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

code_snippet: #include <bits/stdc++.h>
using namespace std;
int main(){
	int t,n,k;
	int x[100000];
	int d[100000];
	cin>>t;
	int ans=0;
	for(int l=0;l<t;l++){
		cin>>n>>k;
		cin>>x[0];
		for(int i=1;i<n;i++){
			cin>>x[i];
			d[i-1]=x[i]-x[i-1];
		}
		if(k>=n){
			cout<<0<<endl;
			continue;
		}
		ans=x[n-1]-x[0];
		sort(d,d+n-1);
		for(int i=0;i<k-1;i++){
			ans-=d[n-2-i];
		}
		cout<<ans<<endl;
	}
}
accuracy: 1
time_ms: 80
memory_kb: 3932
final_rank: 12

code_snippet: #include <bits/stdc++.h>
using namespace std;
using ll = long long;
using ull = unsigned long long;

int main()
{
    ll N;
    cin >> N;
    for(int j=0;j<N;j++){
    ll n,k;
    cin >> n >> k;
    vector<ll> a(n);
    for(int i=0;i<n;i++) cin >> a[i];
    sort(a.begin(), a.end());
    ll ans=a[n-1]-a[0];
    vector<ll> b(n-1);
    for(int i=0;i<n-1;i++) b[i]=a[i+1]-a[i];
    sort(b.begin(), b.end(), greater<ll>());
    for(int i=0;i<k-1;i++){
        if(i>=n-1) break;
        ans-=b[i];
    }
    cout << ans << endl;
    }
    return 0;
}
    // vector<ll> a();
    // for(int i=0;i<n;i++){}

    //vector<vector<ll>> 変数名(n, vector<ll>(m, 0));
    // for(int i=0;i<n;i++){
    //     for(int j=0;j<m;j++){
    //     }
    // }

    // int 関数名(ll x, ll y) {}
    
    // sort(a.begin(), a.end(), greater<ll>());
    
    // do{
    // }while(next_permutation(a.begin(),a.end()));

    //cout << fixed << setprecision(15) << ans << endl;

    //deque<型> 変数名;
    // d.push_back(value) d.push_front(value)
    // d.front() d.back()d.at(i)
    // d.pop_back() d.pop_front()
    // d.size() d.empty()
    
    // for(ll bit=0;bit<(1<<n);bit++){
    //     for(ll i=0;i<n;i++){
    //         if(bit&(1<<i)){
    //         }                
    //     }
    // }

    //     ll c=0;
    //     std::reverse(s.begin(), s.end());
    //    for(int i=0;i<s.size();i++){
    //     int x;
    //         if(s[i]=='0') x=0;
    //         if(s[i]=='1') x=1;
    //         if(s[i]=='2') x=2;
    //         if(s[i]=='3') x=3;
    //         if(s[i]=='4') x=4;
    //         if(s[i]=='5') x=5;
    //         if(s[i]=='6') x=6;
    //         if(s[i]=='7') x=7;
    //         if(s[i]=='8') x=8;
    //         if(s[i]=='9') x=9;
    //     int y=1;
    //     for(int j=0;j<i;j++) y*=10;
    //     c+=x*y;
    //    }
accuracy: 1
time_ms: 70
memory_kb: 4548
final_rank: 10

code_snippet: #pragma GCC optimize("Ofast")
#include <bits/stdc++.h>
using namespace std;
typedef long long int ll;
typedef unsigned long long int ull;

mt19937_64 rng(chrono::steady_clock::now().time_since_epoch().count());
ll myRand(ll B) {
    return (ull)rng() % B;
}
inline double time() {
    return static_cast<long double>(chrono::duration_cast<chrono::nanoseconds>(chrono::steady_clock::now().time_since_epoch()).count()) * 1e-9;
}

int main(){
    cin.tie(nullptr);
    ios::sync_with_stdio(false);
    int q; cin >> q;
    while (q--) {
        int n,k; cin >> n >> k;
        int x; cin >> x;
        vector<int> v(n-1);
        int res = 0;
        for (int i = 0; i < n-1; ++i) {
            int y; cin >> y;
            v[i] = y-x; x = y;
            res += v[i];
        }
        sort(v.rbegin(), v.rend());
        for (int i = 0; i < min(n-1, k-1); ++i) {
            res -= v[i];
        }
        cout << res << endl;
    }
}
accuracy: 1
time_ms: 20
memory_kb: 3704
final_rank: 1

code_snippet: #include <bits/stdc++.h>
using namespace std;
#ifdef LOCAL
  #include "settings/debug.cpp"
  #define _GLIBCXX_DEBUG
#else
  #define Debug(...) void(0)
#endif
using ll = long long;
#define rep(i, n) for (int i = 0; i < (n); ++i)

void solve() {
  int n, k;
  cin >> n >> k;
  vector<int> a(n);
  rep(i, n) cin >> a[i];
  vector<int> diff(n - 1);
  rep(i, n - 1) diff[i] = a[i + 1] - a[i];
  sort(diff.begin(), diff.end());
  rep(_, k - 1) if (!diff.empty()) diff.pop_back();
  cout << accumulate(diff.begin(), diff.end(), 0LL) << endl;
}

int main() {
  int t;
  cin >> t;
  while (t--) solve();
  return 0;
}
accuracy: 1
time_ms: 70
memory_kb: 3844
final_rank: 7

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

using namespace std;

int main()
{
    int t;
    cin >> t;
    for (int _ = 0; _ < t; _++)
    {
        int n, k;
        int s[100001]; // 差分格納用
        int X[100001]; // 入力用

        cin >> n >> k;
        for (int i = 0; i < n; i++)
        {
            cin >> X[i];
        }
        if (n > 1 && n > k) // 各家の前に発電機が置ける(距離　=0)でない時
        {
            for (int i = 1; i < n; i++)
            {
                s[i - 1] = X[i] - X[i - 1]; // 差分は0からn-2まで詰める
            }
        }
        else // 解がtrivialな場合
        {
            cout << 0 << endl;
            continue;
        }
        sort(&s[0], &s[n - 1], greater<int>()); // 0からn-2までソート(当初endを&s[n-2]としていたためうまくいかなかった)
        int sum = 0;                            // 消すものを数える
        if (k > 1)
        {
            for (int i = 0; i < k - 1; i++)
            {
                sum += s[i];
            }
        }
        cout << X[n - 1] - X[0] - sum << endl;
    }
}
/*学習コメント
貪欲法は見つけるのに訓練が必要だと感じた。また実装の際には、配列のsortでのindexの管理方法で躓いたが、解決できてよかった。*/
accuracy: 1
time_ms: 90
memory_kb: 3796
final_rank: 18

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

using namespace std;

int main()
{
    int t;
    cin >> t;
    for (int _ = 0; _ < t; _++)
    {
        int n, k;
        long s[100001];
        long X[100001];

        cin >> n >> k;
        for (int i = 0; i < n; i++)
        {
            cin >> X[i];
        }
        if (n > 1 && n > k)
        {
            for (int i = 1; i < n; i++)
            {
                s[i - 1] = X[i] - X[i - 1];
            }
        }
        else
        {
            cout << 0 << endl;
            continue;
        }
        sort(&s[0], &s[n - 1], greater<int>());
        long sum = 0;
        if (k > 1)
        {
            for (int i = 0; i < k - 1; i++)
            {
                sum += s[i];
            }
        }
        cout << X[n - 1] - X[0] - sum << endl;
    }
}
accuracy: 1
time_ms: 80
memory_kb: 4716
final_rank: 19

code_snippet: #include <iostream>
#include <algorithm>
#include <vector>
using namespace std;
void check(){
  int n,k;
  cin>>n>>k;
  long long ans=0;
    
    vector<long long> x(n);
for(int i=0;i<n;i++) cin>>x.at(i);
  if(n<=k){
        cout<<0<<endl;
        return;
    } 
vector<long long> distance (n-1);
for(int i=0;i<n-1;i++) distance.at(i)=x.at(i+1)-x.at(i);
sort(distance.begin(),distance.end());

for(int i=0;i<n-k;i++) ans+=distance.at(i);
cout<<ans<<endl;
return;


}
int main(){
    int t;
    cin >> t;
    for(int i=0;i<t;i++){
        check();
    }
    
}
accuracy: 1
time_ms: 80
memory_kb: 4256
final_rank: 15

code_snippet: #include<iostream>
#include<algorithm>
using namespace std;
int main(){
    int T, N, K, X[100000+10], A[100000+10];
    cin >> T;
    int ans[50+10]={};
    for(int i=0;i<T;i++){
        cin >> N >> K;
        for(int j=0;j<N;j++) {
            cin >> X[j];
         }
        for(int k=0;k<N-1;k++) {
            A[k]=X[k+1]-X[k];
        }
        sort(A,A+N-1);
        if(K>=N){
            ans[i] = 0;
        }
        else{
            for(int l=0;l<N-K;l++) {
            ans[i] += A[l];
        }
        }
        }
    
    for(int i=0;i<T;i++){
        cout << ans[i] << endl;
    }
}
accuracy: 1
time_ms: 80
memory_kb: 3940
final_rank: 13

code_snippet: #include <iostream>
#include <vector>
#include <algorithm>
using namespace std;
#define rep(i, n) for(int i = 0; i < n; i++)
int main(){
    int t, n, k;
    cin >> t;
    rep(i, t){
        cin >> n >> k;
        vector<int> x(n);
        rep(j, n) cin >> x.at(j);
        vector<int> kyori(n-1);
        rep(l, kyori.size()){
            kyori.at(l) = x.at(l + 1)-x.at(l);
        }
        sort(kyori.begin(), kyori.end());
        int ans = 0;
        for(int m = 0; m < n-k; m++) ans += kyori.at(m);
        cout << ans << endl;

    }
}
accuracy: 1
time_ms: 90
memory_kb: 3604
final_rank: 16

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

using namespace std;

int main()
{
    int t;
    cin >> t;
    for (int i=0; i<t; i++){
        int n, k;
        int x[100009];
        vector<int> y;
        
        cin >> n >> k;
        for (int j=0; j<n; j++){
            cin >> x[j];
        }
        for (int j=0; j<n-1; j++){
            y.push_back(x[j+1]-x[j]);
        }

        sort(begin(y), end(y));
        long long ans = 0;
        for (int j=0; j<max(0, n-k); j++){
            ans += y[j];
        }
        cout << ans << endl;
    }
}
accuracy: 1
time_ms: 70
memory_kb: 4516
final_rank: 9

code_snippet: #include<iostream>
#include<algorithm>
#include<vector>
using namespace std;
int main(){
    int t;cin>>t;
    while(t--){
        int n,k;cin>>n>>k;
        vector<int>x(n);
        vector<int>b(n-1);
        for(int i=0;i<n;i++){
            cin>>x[i];
        }
        if(n==1){
            cout<<""<<0<<endl;
            continue;
        }
        for(int i=0;i<n-1;i++){
            b[i]=x[i+1]-x[i];
        }
        sort(b.begin(),b.end());
        int ans=x[n-1]-x[0];
        for(int i=0;i<min(n-1,k-1);i++){
            ans-=b[n-i-2];
        }
        cout<<""<<ans<<endl;
    }
}
accuracy: 1
time_ms: 70
memory_kb: 3784
final_rank: 5

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

int main() {

    int t;
    cin >> t;

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

        vector<int> l(n - 1); // 「家の間」の長さ
        for (int i = 0; i < n - 1; i++) {
            l[i] = x[i + 1] - x[i];
        }
        sort(l.begin(), l.end(), greater<int>()); // 長い順に並べ替える

        int ans = 0;
        // 「家の間」は n-1 個存在するが、そのうち長い方から k-1 個は電線を引かなくて良い。
        for (int i = k - 1; i < n - 1; i++) {
            ans += l[i];
        }

        cout << ans << '\n';
    }
}
accuracy: 1
time_ms: 90
memory_kb: 3624
final_rank: 17