Programmers

#include <bits/stdc++.h>
#include <climits>

using namespace std;

template<class T>
using V = vector<T>;
template<class T>
using VV = V<V<T>>;

using ld = long double;
#define ll long long
using ull = unsigned ll;
using PLL = pair<ll, ll>;
using VLL = V<ll>;
using VB = V<bool>;
using VVB = VV<bool>;
using VVLL = VV<ll>;
using Gr = VVLL;
using MLL = map<ll, ll>;
#define UMLL unordered_map<ll, ll, custom_hash>

//using int128 = __int128;
//using double128 = __float128;

#define fast ios_base::sync_with_stdio(0); cin.tie(nullptr); cout.tie(nullptr); cerr.tie(nullptr);

#define INF 2000000000
#define MINF LONG_MIN

#define R &
#define CR const R

#define FORI(i, a, b) for(ll i = a, max##i = b; i < max##i; ++i)
#define FOR(i, n) FORI(i, 0, n)
#define RFORI(i, a, b) for(ll i = a, min##i = b; i >= min##i; --i)
#define RFOR(i, n) RFORI(i, n, 0)
#define FORA(i, a) for(auto i : a)
#define FORAR(i, a) for(auto R i : a)
#define FORACR(i, a) for(auto CR i : a)
#define ALL(obj) begin(obj), end(obj)
#define Count(q) while(q--)
#define OK cerr << "OK\n";

#define mp make_pair
#define pb push_back

//#define DEBUG

template<class T>
T sqr(T x)
{
    return x * x;
}

void YES(bool g, ostream R os, bool upper = true)
{
    if(g)
        if(upper)
            os << "YES";
        else
            os << "Yes";
    else
        if(upper)
            os << "NO";
        else
            os << "No";

    os << "\n";
}

template<class T>
void show(T CR t, ostream R os = cerr)
{
    FORACR(i, t)
        os << i << " ";
    os << "\n";
}

template<class T>
void show2d(T CR t, ostream R os = cerr)
{
    FORACR(i, t)
        show(i, os);
    os << "\n";
}

constexpr ll MOD = 1e9 + 7;
//constexpr ll len = 40320 + 1;

constexpr ld PI = atanl(1.0L) * 4;

struct custom_hash
{
    static uint64_t splitmix64(uint64_t x)
    {
        x += 0x9e3779b97f4a7c15;
        x = (x ^ (x >> 30)) * 0xbf58476d1ce4e5b9;
        x = (x ^ (x >> 27)) * 0x94d049bb133111eb;
        return x ^ (x >> 31);
    }

    size_t operator() (uint64_t x) const
    {
        static const uint64_t FIXED_RANDOM = chrono::steady_clock::now().time_since_epoch().count();
        return splitmix64(x + FIXED_RANDOM);
    }
};

//arr
void init() {}

void solve(istream R is, ostream R os)
{
    ll n, k;
    is >> n >> k;

    VLL a(n);
    FORAR(i, a)
        is >> i;

    MLL m;
    FORACR(i, a)
        ++m[i];

    V<PLL> b;
    FORACR(i, m)
        b.pb(i);

    n = b.size();

    cerr << "creating dp\n";
    V<VVLL> dp(2, VVLL(n, VLL(k + 1, INF)));

    cerr << "filling dp(default)\n";
    ll d = min(b[0].second / 2, k);
    FOR(i, d + 1)
        dp[0][0][i] = 0;

    d = min((b[0].second - 1) / 2, k);
    FOR(i, d + 1)
        dp[1][0][i] = 0;

    cerr << "filling dp\n";
    FORI(i, 1, n)
    {
        cerr << i << " ";
        ll t = b[i].second;

        FOR(j, k + 1)
        {
            ll x = 0;
            if(j - t / 2 >= 0)
                x = dp[0][i - 1][j - t / 2];

            ll y = 0;
            if(j - (1 + (t - 1) / 2) >= 0)
                y = dp[1][i - 1][j - (1 + (t - 1) / 2)] + b[i].first - b[i - 1].first;

            if(t == 0)
                y = INF;

            dp[0][i][j] = min(x, y);
        }

        --t;
        FOR(j, k + 1)
        {
            ll x = 0;
            if(j - t / 2 >= 0)
                x = dp[0][i - 1][j - t / 2];

            ll y = 0;
            if(j - (1 + (t - 1) / 2) >= 0)
                y = dp[1][i - 1][j - (1 + (t - 1) / 2)] + b[i].first - b[i - 1].first;

            if(t == 0)
                y = INF;

            dp[1][i][j] = min(x, y);
        }
    }

    os << min(dp[0][n - 1][k], dp[1][n - 1][k]) << "\n";
}

void tester(istream R is, ostream R os)
{
    fast
    init();
    ll q = 1;
    //is >> q;
    os << setprecision(999);

    Count(q)
        solve(is, os);
}

int main()
{
    //ifstream in("input.txt");
    //ofstream out("output.txt");

    tester(cin, cout);
}

Test 1

Group: 1, 2, 3

Verdict: ACCEPTED

creating dp
filling dp(default)
filling dp
1 2 3 4 5

Test 2

Group: 1, 2, 3

Verdict: ACCEPTED

creating dp
filling dp(default)
filling dp
1

Test 3

Group: 1, 2, 3

Verdict: ACCEPTED

creating dp
filling dp(default)
filling dp
1 2 3 4 5 6 7 8 9

Test 4

Group: 1, 2, 3

Verdict: ACCEPTED

creating dp
filling dp(default)
filling dp
1 2 3 4 5 6 7

Test 5

Group: 1, 2, 3

Verdict: ACCEPTED

creating dp
filling dp(default)
filling dp
1 2 3 4 5 6 7 8 9

Test 6

Group: 1, 2, 3

Verdict: ACCEPTED

creating dp
filling dp(default)
filling dp
1 2 3 4 5 6 7 8

Test 7

Group: 1, 2, 3

Verdict: ACCEPTED

creating dp
filling dp(default)
filling dp
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19...

Test 8

Group: 1, 2, 3

Verdict: ACCEPTED

creating dp
filling dp(default)
filling dp
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19...

Test 9

Group: 1, 2, 3

Verdict: ACCEPTED

creating dp
filling dp(default)
filling dp
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19...

Test 10

Group: 1, 2, 3

Verdict: ACCEPTED

creating dp
filling dp(default)
filling dp
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19...

Test 11

Group: 1, 2, 3

Verdict: ACCEPTED

creating dp
filling dp(default)
filling dp
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19...

Test 12

Group: 1, 3

Verdict: ACCEPTED

creating dp
filling dp(default)
filling dp
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19...

Test 13

Group: 1, 3

Verdict: ACCEPTED

creating dp
filling dp(default)
filling dp
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19...

Test 14

Group: 1, 3

Verdict: ACCEPTED

creating dp
filling dp(default)
filling dp
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19...

Test 15

Group: 1, 3

Verdict: ACCEPTED

creating dp
filling dp(default)
filling dp
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19...

Test 16

Group: 1, 3

Verdict: ACCEPTED

creating dp
filling dp(default)
filling dp
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19...

Test 17

Group: 2, 3

Verdict: ACCEPTED

creating dp
filling dp(default)
filling dp
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19...

Test 18

Group: 2, 3

Verdict: RUNTIME ERROR

creating dp

Test 19

Group: 2, 3

Verdict: RUNTIME ERROR

creating dp

Test 20

Group: 2, 3

Verdict: RUNTIME ERROR

creating dp

Test 21

Group: 2, 3

Verdict: RUNTIME ERROR

creating dp

Test 22

Group: 2, 3

Verdict: RUNTIME ERROR

creating dp

Test 23

Group: 2, 3

Verdict: RUNTIME ERROR

creating dp

Test 24

Group: 3

Verdict: RUNTIME ERROR

creating dp

Test 25

Group: 3

Verdict: RUNTIME ERROR

creating dp

Test 26

Group: 3

Verdict: RUNTIME ERROR

creating dp

Test 27

Group: 3

Verdict: RUNTIME ERROR

creating dp

Test 28

Group: 3

Verdict: RUNTIME ERROR

creating dp

Test 29

Group: 3

Verdict: RUNTIME ERROR

creating dp

Test 30

Group: 3

Verdict: RUNTIME ERROR

creating dp

Test 31

Group: 3

Verdict: RUNTIME ERROR

creating dp