text stringlengths 49 983k |
|---|
#include <bits/stdc++.h>
using namespace std;
const long long maxN = 3e5 + 17, N = 5e3 + 7, MOD = 1e9 + 7, Mod = 1e9 + 6;
long long n, k, x, y, a[maxN], dp[N][N], xx, yy;
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
cin >> n >> k;
x = (n % k), y = k - x;
for (long long i = 1; i <= n; i++) cin >> a[i];
sort(a + 1, a + n + 1);
for (long long i = 0; i <= 5000; i++) {
for (long long j = 0; j <= 5000; j++) dp[i][j] = 1LL << 56;
}
dp[0][0] = 0;
for (long long len = 1; len <= k; len++) {
for (long long i = 0; i <= x; i++) {
long long j = len - i, now;
now = (i * ((n / k) + 1)) + (j * (n / k));
if (j <= y && j >= 0) {
if (j)
dp[i][j] =
min(dp[i][j], dp[i][j - 1] + a[now] - a[now - (n / k) + 1]);
if (i)
dp[i][j] = min(dp[i][j], dp[i - 1][j] + a[now] - a[now - (n / k)]);
}
}
}
if (dp[x][y] == 1LL << 56) return cout << "-1\n", 0;
return cout << dp[x][y] << "\n", 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 300007, maxk = 5007;
int n, k;
int a[maxn];
int zusz, s, d;
int dp[maxk][maxk];
int main() {
scanf("%d%d", &n, &k);
for (int i = 0; i < n; i++) scanf("%d", a + i);
for (int i = 0; i < maxk; i++)
for (int j = 0; j < maxk; j++) dp[i][j] = (2147483647 - 214748 + 3647);
sort(a, a + n);
zusz = n / k;
d = n % k;
s = k - d;
dp[0][0] = 0;
for (int i = 0; i <= s; i++)
for (int j = 0; j <= d; j++) {
int cc = i * zusz + j * (zusz + 1);
if (i != s)
dp[i + 1][j] = min(dp[i + 1][j], dp[i][j] + a[cc + zusz - 1] - a[cc]);
if (j != d)
dp[i][j + 1] = min(dp[i][j + 1], dp[i][j] + a[cc + zusz] - a[cc]);
}
printf("%d\n", dp[s][d]);
}
|
#include <bits/stdc++.h>
using namespace std;
int n, k, r, l;
int a[300010];
int f[5010][5010];
int Get(int i, int j) { return a[n + 1 - r * i - j] - a[n - r * i - j]; }
int main() {
scanf("%d%d", &n, &k);
for (int i = 1; i <= n; ++i) scanf("%d", a + i);
sort(a + 1, a + n + 1);
l = n % k, r = n / k;
for (int i = 0; i <= k; ++i)
for (int j = 0; j <= l; ++j) f[i][j] = (1 << 31) - 1;
f[0][0] = a[n] - a[1];
a[0] = a[1];
for (int i = 1; i <= k; ++i)
for (int j = max(0, l - k + i); j <= min(i, l); ++j) {
if (j) f[i][j] = f[i - 1][j - 1] - Get(i, j);
f[i][j] = min(f[i][j], f[i - 1][j] - Get(i, j));
}
printf("%d\n", f[k][l]);
return 0;
}
|
#include <bits/stdc++.h>
const int msc = (int)2e6;
int getint() {
char ch = getchar();
int ret = 0;
bool flag = true;
while ((ch < '0' || ch > '9') && ch != '-') ch = getchar();
if (ch == '-') flag = false, ch = getchar();
while (ch >= '0' && ch <= '9') ret = ret * 10 + ch - '0', ch = getchar();
return flag ? ret : -ret;
}
using namespace std;
long long f[6010], g[6010];
int num[6010];
int a[msc], n, k;
int tA, tB;
void upd(long long& x, long long y) {
if (x > y) x = y;
}
int main() {
cin >> n >> k;
for (int i = 1; i <= n; i++) scanf("%d", a + i);
sort(a + 1, a + n + 1);
for (int i = 1; i <= k; i++) num[i] = (n - i) / k + 1;
for (int i = 1; i <= k; i++)
if (num[i] == num[1])
tA++;
else
tB++;
int A = num[1], B = num[k];
for (int i = 0; i < k; i++) {
for (int j = 0; j <= i + 1; j++) g[j] = 1LL << 60;
for (int j = 0; j <= i && j <= tA; j++) {
int k = i - j, t = j * A + B * k;
if (j < tA) upd(g[j + 1], f[j] + a[t + A] - a[t + 1]);
if (k < tB) upd(g[j], f[j] + a[t + B] - a[t + 1]);
}
for (int j = 0; j <= i + 1; j++) f[j] = g[j];
}
cout << f[tA] << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 311111, M = 5001;
const long long base = 33ll;
const long long MOD = 1000000007ll;
int n, m, a[N];
long long d[M][M];
int main() {
cin >> n >> m;
for (int i = 0; i < n; ++i) cin >> a[i];
sort(a, a + n);
for (int i = 0; i < M; ++i)
for (int j = 0; j < M; ++j) d[i][j] = (long long)1e16;
d[0][0] = 0;
int A = n / m;
for (int i = 1; i <= m; ++i)
for (int j = 0; j <= i; ++j) {
int left = i * A + j - 1;
d[i][j] = d[i - 1][j] + a[left] - a[left - A + 1];
if (j) d[i][j] = min(d[i][j], d[i - 1][j - 1] + a[left] - a[left - A]);
}
cout << d[m][n % m];
}
|
#include <bits/stdc++.h>
using namespace std;
const long long MAXN = 3 * 100 * 1000 + 10, MAX = 1000 * 1000 * 1000 * 15;
long long a[MAXN], dp[5000][5000];
int main() {
long long n, k;
cin >> n >> k;
for (long long i = 0; i < n; i++) cin >> a[i];
sort(a, a + n);
long long s = n / k, ln = n % k;
for (long long i = 0; i <= ln; i++) {
for (long long j = 0; j <= k - ln; j++) {
dp[i][j] = MAX;
}
}
dp[0][0] = 0;
for (long long i = 0; i <= ln; i++) {
for (long long j = 0; j <= k - ln; j++) {
long long m = i * (s + 1) + j * s;
if (i < ln) {
long long d = a[m + s] - a[m];
dp[i + 1][j] = min(dp[i + 1][j], dp[i][j] + d);
}
if (j < k - ln) {
long long d = a[m + s - 1] - a[m];
dp[i][j + 1] = min(dp[i][j + 1], dp[i][j] + d);
}
}
}
cout << dp[ln][k - ln];
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long dp[5010][5010];
int A[300010];
int main() {
ios_base::sync_with_stdio(0);
int n, k;
cin >> n >> k;
for (int i = 0; i < n; i++) cin >> A[i];
sort(A, A + n);
dp[0][0] = 0;
int lsize = (n + k - 1) / k;
int ssize = lsize - 1;
int llim = n % k;
if (llim == 0) llim += k;
for (int l = 1; l <= llim; l++)
dp[l][0] =
dp[l - 1][0] + A[(l - 1) * lsize + lsize - 1] - A[(l - 1) * lsize];
for (int s = 1; s <= k - 1; s++)
dp[0][s] =
dp[0][s - 1] + A[(s - 1) * ssize + ssize - 1] - A[(s - 1) * ssize];
for (int l = 1; l <= llim; l++)
for (int s = 1; s <= k - 1; s++) {
int proc_l = (l - 1) * lsize + s * ssize;
int proc_s = l * lsize + (s - 1) * ssize;
dp[l][s] = min(dp[l - 1][s] + A[proc_l + lsize - 1] - A[proc_l],
dp[l][s - 1] + A[proc_s + ssize - 1] - A[proc_s]);
}
cout << dp[llim][(k - n % k) % k];
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 3e5 + 5, M = 5e3 + 5;
int n, k, a[N], dp[M][M];
int main() {
ios_base::sync_with_stdio(0), cin.tie(0), cout.tie(0);
cin >> n >> k;
for (int i = 0; i < n; i++) cin >> a[i];
sort(a, a + n);
int dovom = n % k, aval = k - dovom, range = n / k;
for (int i = 0; i <= aval; i++) {
for (int j = 0; j <= dovom; j++) {
if (!i && !j) continue;
int t = (i * range) + (j * (range + 1)) - 1;
if (!i) {
dp[i][j] = dp[i][j - 1] + (a[t] - a[t - range]);
} else if (!j) {
dp[i][j] = dp[i - 1][j] + (a[t] - a[t - range + 1]);
} else {
dp[i][j] = min(dp[i - 1][j] + (a[t] - a[t - range + 1]),
dp[i][j - 1] + (a[t] - a[t - range]));
}
}
}
cout << dp[aval][dovom] << "\n";
}
|
#include <bits/stdc++.h>
using namespace std;
long long dp[5010][5010];
int a[300010];
int main(void) {
int n, k;
scanf("%d%d", &n, &k);
for (int i = 1; i <= n; i++) {
scanf("%d", &a[i]);
}
sort(&a[1], &a[n + 1]);
int bsz = n / k, lg = n % k, sm = k - lg;
dp[0][0] = 0;
for (int i = 0; i <= sm; i++) {
for (int j = 0; j <= lg; j++) {
if (!i && !j) continue;
int sz = i * bsz + j * (bsz + 1);
if (!i) {
dp[i][j] = dp[i][j - 1] + a[sz] - a[sz - bsz];
continue;
}
if (!j) {
dp[i][j] = dp[i - 1][j] + a[sz] - a[sz - bsz + 1];
continue;
}
dp[i][j] = min(dp[i - 1][j] + a[sz] - a[sz - bsz + 1],
dp[i][j - 1] + a[sz] - a[sz - bsz]);
}
}
printf("%I64d", dp[sm][lg]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int inf = 1e9 + 10;
const long long INF = 1e18;
const int maxn = 3 * 1e5 + 5;
const int mod = 1e9 + 7;
int n, k;
int a[maxn];
map<int, int> d[maxn];
int lo, sh;
bool check(int i, int r) {
if (i < 0 || r < 0) return false;
if (1LL * r * lo > i + 1 || (i + 1 - r * lo) % sh != 0) return false;
return true;
}
long long dp(int i, int r) {
if (d[i].count(r)) return d[i][r];
if (i == lo - 1 && r == 1) return d[i][r] = a[i] - a[0];
if (i == sh - 1 && r == 0) return d[i][r] = a[i] - a[0];
long long ret = INF;
if (check(i - lo, r - 1))
ret = min(ret, dp(i - lo, r - 1) + a[i] - a[i - lo + 1]);
if (check(i - sh, r)) ret = min(ret, dp(i - sh, r) + a[i] - a[i - sh + 1]);
return d[i][r] = ret;
}
int MAIN() {
scanf("%d%d", &n, &k);
for (int i = 0; i < n; ++i) scanf("%d", &a[i]);
sort(a, a + n);
if (k == 1) {
printf("%d\n", a[n - 1] - a[0]);
return 0;
}
lo = n / k + 1, sh = n / k;
int r = n % k;
printf("%I64d\n", dp(n - 1, r));
return 0;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL), cout.tie(NULL);
cout << fixed << setprecision(16);
int ret = MAIN();
return ret;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MN = 3e5 + 10;
const int MK = 5e3 + 10;
const long long INF = 1e18 + 10;
int n, k;
int arr[MN];
long long dp[MK][MK];
int L, S;
int l, s;
void input() {
ios_base ::sync_with_stdio(false), cin.tie(0), cout.tie(0);
cin >> n >> k;
for (int i = 0; i < n; ++i) cin >> arr[i];
sort(arr, arr + n);
L = n % k;
S = k - L;
l = n / k + 1;
s = n / k;
}
void solve() {
for (int i = 0; i <= L; ++i)
for (int j = 0; j <= S; ++j) dp[i][j] = INF;
dp[0][0] = 0;
for (int i = 0; i <= L; ++i)
for (int j = 0; j <= S; ++j) {
if (i == 0 && j == 0) continue;
int sz = i * l + j * s - 1;
if (i) {
dp[i][j] = min(dp[i][j], dp[i - 1][j] + arr[sz] - arr[sz - l + 1]);
}
if (j) {
dp[i][j] = min(dp[i][j], dp[i][j - 1] + arr[sz] - arr[sz - s + 1]);
}
}
}
int main() {
ios_base ::sync_with_stdio(false), cin.tie(0), cout.tie(0);
input();
if (n % k) {
solve();
cout << dp[L][S] << endl;
} else {
int ans = 0;
for (int i = 0; i < n; i += n / k) ans += arr[i + n / k - 1] - arr[i];
cout << ans << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long N = 1000 * 600;
const int MAX_X = 1000 + 20;
const int MAX_N = 100 + 20;
const int MOD = 1000 * 1000 * 1000 + 7;
const int INF = 1000 * 1000 * 1000 * 1000 * 1000 * 100 + 1;
int poww(int x, int y) {
return (!y ? 1 : (y & 1 ? x * poww(x * x, y / 2) : poww(x * x, y / 2)));
}
long long a[N];
int main() {
ios_base::sync_with_stdio(0);
cout.tie(0);
cout.tie(0);
long long n, k;
cin >> n >> k;
for (int i = 0; i < n; i++) cin >> a[i];
sort(a, a + n);
long long q = n % k, q1 = n / k, x;
long long m = k;
long long dp[m + 1][q + 1];
for (long long i = 0; i <= k; i++)
for (long long j = 0; j <= q; j++) dp[i][j] = 1e17;
dp[0][0] = 0;
for (long long i = 1; i <= m; i++) {
for (long long j = 0; j <= q; j++) {
x = i * q1 + j - 1;
if (j < i && x >= q1 - 1)
dp[i][j] = min(dp[i][j], dp[i - 1][j] + a[x] - a[x - q1 + 1]);
if (j > 0 && j >= 1 && x >= q1)
dp[i][j] = min(dp[i][j], dp[i - 1][j - 1] + a[x] - a[x - q1]);
}
}
cout << dp[m][q];
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 5010;
int dp[N * N];
int a[300010];
void update(int &x, int y) {
if (x == -1 || x > y) x = y;
}
int main() {
int n, m;
scanf("%d%d", &n, &m);
for (int i = 1; i <= n; i++) scanf("%d", &a[i]);
sort(a + 1, a + n + 1);
int p = (n - 1) / m + 1;
int x = n - m * (p - 1);
int y = m - x;
memset(dp, -1, sizeof(dp));
dp[0] = 0;
for (int i = 0; i <= x; i++)
for (int j = 0; j <= y; j++) {
if (i == x && j == y) break;
int id = i * (y + 1) + j;
if (dp[id] == -1) continue;
int pos = i * p + j * (p - 1);
if (i < x)
update(dp[(i + 1) * (y + 1) + j], dp[id] + a[pos + p] - a[pos + 1]);
if (j < y)
update(dp[i * (y + 1) + j + 1], dp[id] + a[pos + p - 1] - a[pos + 1]);
}
cout << dp[x * (y + 1) + y] << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 300005;
const int M = 5005;
int a[N], n, k, sl[2], F[M][M], P[N];
int query(int l, int r) { return P[r] - P[l]; }
int main() {
scanf("%d%d", &n, &k);
for (int i = 1; i <= n; ++i) scanf("%d", &a[i]);
sort(a + 1, a + n + 1);
for (int i = 1; i <= k; ++i) {
int cnt = 0;
for (int j = i; j <= n; j += k) cnt++;
if (cnt == (n - 1) / k + 1)
sl[0]++;
else
sl[1]++;
}
int dodai0 = (n - 1) / k + 1;
int dodai1 = dodai0 - 1;
for (int i = 2; i <= n; ++i) P[i] = P[i - 1] + a[i] - a[i - 1];
for (int i = 0; i <= sl[0]; ++i)
for (int j = 0; j <= sl[1]; ++j) F[i][j] = 2000000000;
F[0][0] = 0;
for (int i = 0; i <= sl[0]; ++i)
for (int j = 0; j <= sl[1]; ++j) {
if (i == sl[0] && j == sl[1]) {
cout << F[i][j];
return 0;
}
int now = i * dodai0 + j * dodai1;
F[i + 1][j] = min(F[i + 1][j], F[i][j] + query(now + 1, now + dodai0));
F[i][j + 1] = min(F[i][j + 1], F[i][j] + query(now + 1, now + dodai1));
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 3e5 + 3;
const int K = 5003;
const long long oo = 1e18;
long long a[N], d[K][K];
int n, k, T1, T2, ZN1, ZN2;
int f(int i) { return (n - i + k - 1) / k; }
int main() {
int i, j, kl, ps;
cin >> n >> k;
for (i = 0; i < n; ++i) cin >> a[i];
sort(a, a + n);
for (i = 0; i <= k; ++i)
for (j = 0; j <= k; ++j) d[i][j] = -1;
kl = 1;
for (i = 1; i < n - k; ++i)
if (f(0) == f(i))
++kl;
else
break;
T1 = kl;
T2 = k - kl;
ZN1 = f(0);
ZN2 = ZN1 - 1;
d[T1][T2] = 0;
for (i = T1; i >= 0; --i)
for (j = T2; j >= 0; --j)
if ((i < T1) || (j < T2)) {
d[i][j] = oo;
ps = i * ZN1 + j * ZN2;
if (i < T1)
d[i][j] = min(d[i][j], d[i + 1][j] + a[ps + ZN1 - 1] - a[ps]);
if (j < T2)
d[i][j] = min(d[i][j], d[i][j + 1] + a[ps + ZN2 - 1] - a[ps]);
}
cout << d[0][0] << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int M = 3e5 + 10;
int a[M], dp[5010][5010];
int main() {
int n, k;
scanf("%d%d", &n, &k);
for (int i = 1; i <= n; i++) {
scanf("%d", &a[i]);
}
sort(a + 1, a + n + 1);
a[0] = a[1], a[n + 1] = a[n];
int len1 = n / k + 1, len2 = n / k;
int count1 = n % k, count2 = k - count1;
memset(dp, 0, sizeof(dp));
for (int i = 0; i <= count1; i++) {
for (int j = 0; j <= count2; j++) {
if (i) {
int pos = (i - 1) * len1 + j * len2;
dp[i][j] = max(dp[i][j], dp[i - 1][j] + a[pos + 1] - a[pos]);
}
if (j) {
int pos = i * len1 + (j - 1) * len2;
dp[i][j] = max(dp[i][j], dp[i][j - 1] + a[pos + 1] - a[pos]);
}
}
}
int ans = a[n] - a[1] - dp[count1][count2];
printf("%d\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int a[1000000];
unsigned s[6000][6000];
unsigned solve(const int a[], const int g, int i, int j) {
if (i < 0 || j < 0)
return 0x7FFFFFFF;
else if (i == 0 && j == 0)
return 0;
else if (s[i][j] == 0xFFFFFFFF)
s[i][j] = min((a[g] - a[0]) + solve(a + g + 1, g, i - 1, j),
(a[g - 1] - a[0]) + solve(a + g, g, i, j - 1));
return s[i][j];
}
int main() {
int n, k;
scanf("%d%d", &n, &k);
memset(a, 0x00, sizeof(a));
memset(s, 0xFF, sizeof(s));
for (int i = 0; i < n; i++) scanf("%d", &a[i]);
sort(a, a + n);
printf("%u\n", solve(a, n / k, n % k, k - n % k));
}
|
#include <bits/stdc++.h>
using namespace std;
void SR(int &x) { scanf("%d", &x); }
void SR(long long &x) { scanf("%lld", &x); }
void SR(double &x) { scanf("%lf", &x); }
void SR(char *s) { scanf("%s", s); }
void RI() {}
template <typename I, typename... T>
void RI(I &x, T &...tail) {
SR(x);
RI(tail...);
}
const int maxn = 3e5 + 5;
int n, k;
int ar[maxn];
void read() {
RI(n, k);
for (int i = (1); i <= int(n); i++) RI(ar[i]);
}
void build() {
sort(ar + 1, ar + n + 1);
ar[n + 1] = ar[n];
}
long long dp[5003][5003];
long long get(int h, int r1, int r0) {
if (~dp[r1][r0]) return dp[r1][r0];
if (!r1 && !r0) return dp[r1][r0] = 0;
int x = h + n / k;
long long &ans = dp[r1][r0];
if (r1 > 0) ans = max(ans, get(x + 1, r1 - 1, r0) + ar[x + 2] - ar[x + 1]);
if (r0 > 0) ans = max(ans, get(x, r1, r0 - 1) + ar[x + 1] - ar[x]);
return ans;
}
void sol() {
memset(dp, -1, sizeof(dp));
printf("%lld\n", ar[n] - ar[1] - get(0, n % k, k - n % k));
}
int main() {
read();
build();
sol();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = (int)3e5 + 10;
long long v[maxn];
long long dp[5010][5010];
int d;
long long go(int a, int b, int pos) {
if (dp[a][b] == -1) {
if (a == 0 && b == 0) {
dp[a][b] = 0;
} else {
dp[a][b] = (long long)1e18;
if (a != 0) {
dp[a][b] = go(a - 1, b, pos + d) + (v[pos + d - 1] - v[pos]);
}
if (b != 0) {
dp[a][b] = min(dp[a][b],
go(a, b - 1, pos + d - 1) + (v[pos + d - 2] - v[pos]));
}
}
}
return dp[a][b];
}
int main() {
memset(dp, -1, sizeof dp);
int n, k;
scanf("%d %d", &n, &k);
d = (n + k - 1) / k;
for (int i = 0; i < n; i++) {
scanf("%I64d", &v[i]);
}
sort(v, v + n);
int a = (n - 1) % k + 1;
int b = k - a;
if (d * a + (d - 1) * b != n) {
throw 1;
}
cout << go(a, b, 0) << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 300005;
const int K = 5005;
const long long INF = 0xfffffffffffffffLL;
int a[N];
long long f[K][K];
int main() {
int n, k;
while (scanf("%d%d", &n, &k) + 1) {
for (int i = 1; i <= n; i++) scanf("%d", &a[i]);
sort(a + 1, a + 1 + n);
int m = n / k, mx = n % k;
for (int i = 0; i <= k; i++)
for (int j = 0; j <= mx; j++) f[i][j] = INF;
f[0][0] = 0;
for (int i = 0; i < k; i++) {
for (int j = 0; j <= mx; j++) {
if (i * m + m + j <= n)
f[i + 1][j] =
min(f[i + 1][j], f[i][j] + a[i * m + m + j] - a[i * m + j + 1]);
if (i * m + m + j + 1 <= n && j + 1 <= mx)
f[i + 1][j + 1] =
min(f[i + 1][j + 1],
f[i][j] + a[i * m + m + j + 1] - a[i * m + j + 1]);
}
}
printf("%I64d\n", f[k][mx]);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long a[300010];
long long sum[300010];
long long dp[5010][5010];
int main() {
int n, k;
scanf("%d%d", &n, &k);
for (int i = 1; i <= n; i++) scanf("%I64d", &a[i]);
sort(a + 1, a + n + 1);
for (int i = 2; i <= n; i++) sum[i] = sum[i - 1] + a[i] - a[i - 1];
if (n % k == 0) {
int t = n / k;
long long ans = 0;
for (int i = 1; i <= n; i += t) ans += sum[i + t - 1] - sum[i];
printf("%I64d\n", ans);
return 0;
}
int x1 = n % k;
int y1 = n / k + 1;
int x2 = k - x1;
int y2 = n / k;
dp[0][0] = 0;
for (int i = 1; i <= x1; i++)
dp[i][0] = dp[i - 1][0] + sum[i * y1] - sum[(i - 1) * y1 + 1];
for (int j = 1; j <= x2; j++)
dp[0][j] = dp[0][j - 1] + sum[j * y2] - sum[(j - 1) * y2 + 1];
for (int i = 1; i <= x1; i++)
for (int j = 1; j <= x2; j++)
dp[i][j] = min(
dp[i - 1][j] + sum[i * y1 + j * y2] - sum[(i - 1) * y1 + j * y2 + 1],
dp[i][j - 1] + sum[i * y1 + j * y2] - sum[i * y1 + (j - 1) * y2 + 1]);
printf("%I64d\n", dp[x1][x2]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAX_N = 300005;
const int MAX_K = 5005;
int dp[MAX_K][MAX_K];
int v[MAX_N];
int main() {
int n, k;
scanf("%d%d", &n, &k);
int a = n % k;
int b = k - n % k;
int sza = n / k, szb = n / k;
if (n % k != 0) sza++;
for (int i = 1; i <= n; ++i) scanf("%d", &v[i]);
sort(v + 1, v + n + 1);
for (int i = 1; i <= a; ++i)
dp[i][0] = dp[i - 1][0] + v[i * sza] - v[1 + (i - 1) * sza];
for (int i = 1; i <= b; ++i)
dp[0][i] = dp[0][i - 1] + v[i * szb] - v[1 + (i - 1) * szb];
for (int i = 1; i <= a; ++i)
for (int j = 1; j <= b; ++j)
dp[i][j] = min(
dp[i - 1][j] + v[i * sza + j * szb] - v[1 + (i - 1) * sza + j * szb],
dp[i][j - 1] + v[i * sza + j * szb] - v[1 + (j - 1) * szb + i * sza]);
printf("%d\n", dp[a][b]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long n, k;
long long a[300005];
long long dp[5005][5005];
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cin >> n >> k;
for (int i = 0; i < (n); i++) {
cin >> a[i];
}
sort(a, a + n);
memset(dp, 0x3f, sizeof dp);
dp[0][0] = 0;
long long ae = n / k;
long long rem = n % k;
for (int i = 0; i < (k); i++) {
for (int j = 0; j < (rem); j++) {
long long loc = i * ae + j;
assert(loc + ae < n);
long long res = dp[i][j] + a[loc + ae - 1] - a[loc];
dp[i + 1][j] = min(dp[i + 1][j], res);
long long res2 = dp[i][j] + a[loc + ae] - a[loc];
dp[i + 1][j + 1] = min(dp[i + 1][j + 1], res2);
}
long long res = dp[i][rem] + a[i * ae + rem + ae - 1] - a[i * ae + rem];
dp[i + 1][rem] = min(dp[i + 1][rem], res);
}
cout << dp[k][rem] << "\n";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int inft = 1000000009;
const int MAXN = 1000006;
int t[MAXN];
long long DP[5006][5006];
void solve() {
int n, k;
scanf("%d%d", &n, &k);
for (int i = 0; i < (n); ++i) scanf("%d", &t[i]);
sort(t, t + n);
int A, B, n_A, n_B;
A = (n - 1) / k + 1;
B = A - 1;
n_A = n % k;
if (n_A == 0) n_A = k;
n_B = k - n_A;
assert(n_A * A + n_B * B == n);
DP[0][0] = 0;
for (int i = 0; i < (n_A + 1); ++i)
for (int j = 0; j < (n_B + 1); ++j)
if (i || j) {
int poz = i * A + j * B - 1;
DP[i][j] = 1LL * inft * inft;
if (i) DP[i][j] = min(DP[i][j], DP[i - 1][j] + t[poz] - t[poz - A + 1]);
if (j) DP[i][j] = min(DP[i][j], DP[i][j - 1] + t[poz] - t[poz - B + 1]);
}
cout << DP[n_A][n_B] << endl;
}
int main() {
int t = 1;
for (int i = 0; i < (t); ++i) solve();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long n, k, a[300030];
long long dp[5010][5010];
long long ans;
signed main() {
scanf("%lld%lld", &n, &k);
long long cnt1 = n % k;
long long cnt2 = k - cnt1;
long long len1 = n / k + 1;
long long len2 = n / k;
for (long long i = 1; i <= n; i++) {
scanf("%lld", &a[i]);
}
sort(a + 1, a + n + 1);
for (long long i = 2; i <= n; i++) {
ans += a[i] - a[i - 1];
}
for (long long i = 2; i <= cnt1; i++) {
dp[i][0] = dp[i - 1][0] + a[i * len1 - len1 + 1] - a[i * len1 - len1];
}
for (long long i = 2; i <= cnt2; i++) {
dp[0][i] = dp[0][i - 1] + a[i * len2 - len2 + 1] - a[i * len2 - len2];
}
for (long long i = 1; i <= cnt1; i++) {
for (long long j = 1; j <= cnt2; j++) {
dp[i][j] = max(dp[i][j - 1] + a[i * len1 + j * len2 - len2 + 1] -
a[i * len1 + j * len2 - len2],
dp[i - 1][j] + a[i * len1 + j * len2 - len1 + 1] -
a[i * len1 + j * len2 - len1]);
}
}
printf("%lld", ans - dp[cnt1][cnt2]);
}
|
#include <bits/stdc++.h>
using namespace std;
int n, k, a[300005], dp[5005][5005];
int main() {
scanf("%d%d", &n, &k);
for (int i = 1; i <= n; i++) scanf("%d", &a[i]);
sort(a + 1, a + n + 1);
int sum = a[n] - a[1], x = n % k, y = k - x, t = n / k;
for (int i = 1; i < n; i++) a[i] = a[i + 1] - a[i];
for (int i = 0; i <= x; i++)
for (int j = 0; j <= y; j++) {
if (i)
dp[i][j] = max(dp[i][j], dp[i - 1][j] + a[(i - 1) * (t + 1) + j * t]);
if (j)
dp[i][j] = max(dp[i][j], dp[i][j - 1] + a[i * (t + 1) + (j - 1) * t]);
}
printf("%d\n", sum - dp[x][y]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int arr[3 * 100005];
long long dp[5005][5005];
int mem, low;
int n, k;
long long rec(int full, int kom) {
if (kom > low) return 10000000000000000ll;
if (full == k) {
if (kom == low) return 0;
return 10000000000000000ll;
}
long long& res = dp[full][kom];
if (res != -1) return res;
int st = full * mem + kom;
res = 10000000000000000ll;
res = min(res, rec(full + 1, kom) + arr[st + mem - 1] - arr[st]);
res = min(res, rec(full + 1, kom + 1) + arr[st + mem] - arr[st]);
return res;
}
int main() {
scanf("%d %d", &n, &k);
for (int i = 0; i < n; i++) {
scanf("%d", &arr[i]);
}
sort(arr, arr + n);
mem = n / k;
low = n % k;
memset(dp, -1, sizeof dp);
printf("%I64d\n", rec(0, 0));
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int dp[5001][5001], n, k, p, q, pp, qq;
int main() {
cin >> n >> k;
p = (n - 1) / k + 1;
q = p - 1, pp = n - q * k, qq = k - pp;
int a[n], sum[n];
for (int i = 0; i < n; i++) {
cin >> a[i];
}
sort(a, a + n);
for (int i = 0; i < n; i++) {
sum[i] = 0;
if (i) sum[i] = (sum[i - 1] + a[i] - a[i - 1]);
}
for (int i = 0; i <= qq; i++) {
for (int j = 0; j <= pp; j++) {
if (!i and !j) continue;
if (!i)
dp[i][j] = sum[j * p - 1] - sum[(j - 1) * p] + dp[i][j - 1];
else if (!j)
dp[i][j] = sum[i * q - 1] - sum[(i - 1) * q] + dp[i - 1][j];
else
dp[i][j] = min(
dp[i][j - 1] + sum[i * q + j * p - 1] - sum[i * q + (j - 1) * p],
dp[i - 1][j] + sum[i * q + j * p - 1] - sum[(i - 1) * q + j * p]);
}
}
cout << dp[qq][pp];
}
|
#include <bits/stdc++.h>
using namespace std;
int n, k, a[300010];
long long f[5050][5050];
int main() {
scanf("%d%d", &n, &k);
for (int i = 1; i <= n; ++i) scanf("%d", &a[i]);
sort(a + 1, a + n + 1);
int num1 = n % k, num2 = k - n % k;
int q = n / k;
memset(f, 127, sizeof(f));
f[0][0] = 0;
for (int i = 0; i <= num1; ++i) {
for (int j = 0; j <= num2; ++j) {
int now = i * (q + 1) + j * q;
if (i) f[i][j] = min(f[i][j], f[i - 1][j] + a[now] - a[now - q]);
if (j) f[i][j] = min(f[i][j], f[i][j - 1] + a[now] - a[now - (q - 1)]);
}
}
printf("%I64d\n", f[num1][num2]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <typename T>
ostream& operator<<(ostream& s, vector<T>& v) {
s << '{';
for (int i = 0; i < v.size(); ++i) s << (i ? "," : "") << v[i];
return s << '}';
}
template <typename S, typename T>
ostream& operator<<(ostream& s, pair<S, T>& p) {
return s << "(" << p.first << "," << p.second << ")";
}
vector<long long> v;
vector<long long> v_diffs;
vector<long long> v_diffs_cum;
int N, K;
long long sum_of_diffs(int pos1, int pos2) {
assert(pos1 >= 0);
assert(pos1 < N);
assert(pos2 >= 0);
assert(pos2 < N);
return v_diffs_cum[pos2] - v_diffs_cum[pos1];
}
int main() {
cin >> N >> K;
for (int i = 0; i < (N); ++i) {
long long t;
cin >> t;
v.push_back(t);
}
sort((v).begin(), (v).end());
for (int i = 0; i < (N - 1); ++i) {
v_diffs.push_back(v[i + 1] - v[i]);
}
long long cum = 0;
for (int i = 0; i < (N); ++i) {
v_diffs_cum.push_back(cum);
cum += v_diffs[i];
}
int NL = N % K;
int size_s = N / K;
int size_l = size_s + 1;
int NS = (N - (NL * size_l)) / size_s;
long long dp[NS + 1][NL + 1];
memset(dp, 0, sizeof dp);
for (int ns = 0; ns < (NS + 1); ++ns) {
for (int nl = 0; nl < (NL + 1); ++nl) {
if (ns == 0 && nl == 0)
dp[ns][nl] = 0;
else {
int pos_end = ns * size_s + nl * size_l;
long long ans = 0x3f3f3f3f3f3f3f3fLL;
if (ns >= 1) {
long long new_one = sum_of_diffs(pos_end - size_s, pos_end - 1);
ans = min(ans, dp[ns - 1][nl] + new_one);
}
if (nl >= 1) {
long long new_one = sum_of_diffs(pos_end - size_l, pos_end - 1);
ans = min(ans, dp[ns][nl - 1] + new_one);
}
assert(ans >= 0);
dp[ns][nl] = ans;
}
}
}
cout << dp[NS][NL] << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
long long int n, k;
cin >> n >> k;
long long int a[n];
for (long long int i = 0; i < n; i++) cin >> a[i];
sort(a, a + n);
long long int segsize = n / k;
long long int large = n % k;
long long int small = k - large;
long long int dp[large + 1][small + 1];
for (long long int i = 0; i <= large; i++) {
for (long long int j = 0; j <= small; j++) dp[i][j] = 100000000000000;
}
dp[0][0] = 0;
for (long long int i = 0; i <= large; i++) {
for (long long int j = 0; j <= small; j++) {
int end = i * (segsize + 1) + j * segsize;
if (i < large)
dp[i + 1][j] = min(dp[i + 1][j], dp[i][j] + a[end + segsize] - a[end]);
if (j < small)
dp[i][j + 1] =
min(dp[i][j + 1], dp[i][j] + a[end + segsize - 1] - a[end]);
}
}
cout << dp[large][small] << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long Max = 1e12;
int n, m, i, j, x, y, l, k, a[300001];
long long f[2][5001];
int main() {
scanf("%d%d", &n, &m);
for (i = 1; i <= n; i++) scanf("%d", &a[i]);
sort(a + 1, a + n + 1);
l = n / m;
k = n % m;
x = 1;
y = 0;
for (i = 0; i <= k; i++) f[0][i] = Max;
f[0][0] = 0;
for (i = 0; i < m; i++) {
x = x ^ 1;
y = y ^ 1;
for (j = 0; j <= k; j++) f[y][j] = Max;
for (j = 0; j <= k; j++) {
f[y][j] = min(f[y][j], f[x][j] + a[i * l + j + l] - a[i * l + j + 1]);
f[y][j + 1] =
min(f[y][j + 1], f[x][j] + a[i * l + j + l + 1] - a[i * l + j + 1]);
}
}
cout << f[y][k];
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int s[300005];
int dp[5005];
void solve() {
int n, k;
cin >> n >> k;
for (int i = 0; i < (n); ++i) {
scanf("%d", s + i);
}
sort(s, s + n);
int a = n % k;
int b = k - a;
int la = n / k + 1;
int lb = n / k;
dp[0] = 0;
for (int j = 1; j <= (b); ++j)
dp[j] = dp[j - 1] + s[j * lb - 1] - s[(j - 1) * lb];
for (int i = 1; i <= (a); ++i) {
dp[0] = dp[0] + s[i * la - 1] - s[(i - 1) * la];
for (int j = 1; j <= (b); ++j)
dp[j] =
min(dp[j] + s[i * la + j * lb - 1] - s[(i - 1) * la + j * lb],
dp[j - 1] + s[i * la + j * lb - 1] - s[i * la + (j - 1) * lb]);
}
cout << dp[b] << endl;
}
int main() {
solve();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, k, ar[1 << 20];
long long dp[5005][5005];
int C;
int cnt[5050];
int c1, c2;
int done;
int main() {
ios_base::sync_with_stdio(0);
cin >> n >> k;
for (int i = 0; i < n; i++) {
cin >> ar[i];
cnt[i % k]++;
}
sort(ar, ar + n);
C = 1e9;
for (int i = 0; i < k; i++) {
if (cnt[i] < C) C = cnt[i];
}
for (int i = 0; i < k; i++)
if (cnt[i] == C)
c1++;
else
c2++;
for (int i = 0; i <= c1; i++)
for (int j = 0; j <= c2; j++) dp[i][j] = 1e18;
dp[0][0] = 0;
for (int i = 0; i <= c1; i++)
for (int j = 0; j <= c2; j++) {
done = i * C + j * (C + 1);
if (i < c1 && C > 0)
dp[i + 1][j] =
min(dp[i + 1][j], dp[i][j] + abs(ar[done + C - 1] - ar[done]));
if (j < c2)
dp[i][j + 1] =
min(dp[i][j + 1], dp[i][j] + abs(ar[done + C] - ar[done]));
}
cout << dp[c1][c2] << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int a[300005];
int l[5005], r[5005];
long long dp[5005][5005];
const long long inf = 2e16;
void Min(long long &a, long long b) {
if (a > b) a = b;
}
int main() {
int n, k;
scanf("%d %d", &n, &k);
for (int i = 1; i <= n; i++) scanf("%d", &a[i]);
sort(a + 1, a + n + 1);
int cur = 0, tmp = n / k;
int c1 = n - tmp * k, c2 = k - c1;
for (int i = 0; i < 5005; i++)
for (int j = 0; j < 5005; j++) dp[i][j] = inf;
for (int i = 1; i <= k; i++) {
if (c1 < i)
r[i] = min(n, c1 * (tmp + 1) + (i - c1) * tmp);
else
r[i] = min(n, i * (tmp + 1));
if (c2 < i)
l[i] = min(n, c2 * tmp + (i - c2) * (tmp + 1));
else
l[i] = min(n, i * tmp);
}
dp[0][0] = 0;
for (int i = 1; i <= k; i++)
for (int j = l[i]; j <= r[i]; j++) {
int pre = j - tmp;
if (pre <= r[i - 1] && pre >= l[i - 1])
Min(dp[i][j - l[i]], dp[i - 1][pre - l[i - 1]] + a[j] - a[pre + 1]);
if (pre - 1 <= r[i - 1] && pre - 1 >= l[i - 1])
Min(dp[i][j - l[i]], dp[i - 1][pre - 1 - l[i - 1]] + a[j] - a[pre]);
}
printf("%d\n", dp[k][n - l[k]]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int A[300010];
int dp[5010][5010];
int small_members, large_members;
int group_members(int l, int s) {
return l * large_members + s * small_members;
}
int main() {
int n, k;
scanf("%d %d", &n, &k);
for (int i = 0; i < (int)(n); i++) scanf("%d", &A[i]);
sort(A, A + n);
int large_groups = n % k, small_groups = k - n % k;
small_members = n / k, large_members = n / k + 1;
for (int l = 0; l < (int)(large_groups + 1); l++) {
for (int s = 0; s < (int)(small_groups + 1); s++) {
if (l == 0 && s == 0) {
continue;
} else if (l == 0) {
dp[0][s] = dp[0][s - 1] +
abs(A[group_members(0, s - 1)] - A[group_members(0, s) - 1]);
} else if (s == 0) {
dp[l][0] = dp[l - 1][0] +
abs(A[group_members(l - 1, 0)] - A[group_members(l, 0) - 1]);
} else {
dp[l][s] = min(dp[l][s - 1] + abs(A[group_members(l, s - 1)] -
A[group_members(l, s) - 1]),
dp[l - 1][s] + abs(A[group_members(l - 1, s)] -
A[group_members(l, s) - 1]));
}
}
}
printf("%d\n", dp[large_groups][small_groups]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long MOD = int(1e9) + 7;
int dp[5050][5050];
int debug = 1;
int a[300005];
int main() {
int n, k;
cin >> n >> k;
for (int i = 1; i < n + 1; i++) cin >> a[i];
sort(a + 1, a + n + 1);
int lg = n % k;
int szl = (n / k + 1);
int szs = (n / k);
int sml = k - lg;
for (int i = 0; i < lg + 1; i++) {
for (int j = 0; j < sml + 1; j++) {
dp[i][j] = 2000 * 1000 * 1000 + 5;
}
}
dp[0][0] = 0;
for (int i = 0; i < lg + 1; i++) {
for (int j = 0; j < sml + 1; j++) {
int ind = szl * i + szs * j;
if (j >= 1) {
dp[i][j] = min(dp[i][j], a[ind] - a[ind - szs + 1] + dp[i][j - 1]);
}
if (i >= 1) {
dp[i][j] = min(dp[i][j], a[ind] - a[ind - szl + 1] + dp[i - 1][j]);
}
}
}
cout << dp[lg][sml] << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 600001;
int n, k;
int a[N];
int dp[5001][5001];
int main() {
cin >> n >> k;
for (int i = 0; i < n; i++) scanf("%d", &a[i]);
sort(a, a + n);
int sz = n / k;
int B = n % k;
int A = k - B;
for (int i = 0; i <= A; i++)
for (int j = 0; j <= B; j++) dp[i][j] = numeric_limits<int>::max();
dp[0][0] = 0;
for (int i = 0; i <= A; i++)
for (int j = 0; j <= B; j++) {
int t = dp[i][j];
int x = (i + j) * sz + j;
dp[i + 1][j] = min(dp[i + 1][j], t + a[x + sz - 1] - a[x]);
dp[i][j + 1] = min(dp[i][j + 1], t + a[x + sz] - a[x]);
}
cout << dp[A][B];
}
|
#include <bits/stdc++.h>
const double EPS = 1e-10;
using namespace std;
inline int rit() {
int f = 0, key = 1;
char c;
do {
c = getchar();
if (c == '-') key = -1;
} while (c < '0' || c > '9');
do {
f = f * 10 + c - '0';
c = getchar();
} while (c >= '0' && c <= '9');
return f * key;
}
int n, k, gc;
long long a[300005];
char mk[5005][5005];
long long ans[5005][5005];
long long go(int p, int x, int siz) {
long long ff = 2e9;
if (!p) return 0;
if (mk[p][x]) return ans[p][x];
mk[p][x] = 1;
if (x) ff = min(ff, a[siz] - a[siz - gc + 1] + go(p - 1, x - 1, siz - gc));
if (p > x)
ff = min(ff, a[siz] - a[siz - n / k + 1] + go(p - 1, x, siz - n / k));
ans[p][x] = ff;
return ans[p][x];
}
void read() {
int i, f;
n = rit(), k = rit();
for (i = 1; i <= n; i++) a[i] = rit();
sort(a + 1, a + n + 1);
gc = n / k + (n % k == 0 ? 0 : 1);
cout << go(k, n % k, n) << endl;
}
int main() {
read();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long n, k, a[300005], l1, l2, dp[2][300005];
signed main() {
ios::sync_with_stdio(false);
cin >> n >> k;
for (long long i = 1; i <= n; ++i) {
cin >> a[i];
}
sort(a + 1, a + 1 + n);
l1 = n / k;
l2 = n / k + 1;
fill(dp[0] + 1, dp[0] + 1 + n, 0x3fffffffffffffff);
for (long long i = 1; i <= k; ++i) {
fill(dp[i & 1], dp[i & 1] + 1 + n, 0x3fffffffffffffff);
long long lim = min(l2 * (i - 1) + l1, n);
for (long long j = l1 * i; j <= lim; ++j) {
dp[i & 1][j] =
min(dp[i & 1][j], dp[!(i & 1)][j - l1] + a[j] - a[j - l1 + 1]);
}
lim = min(l2 * i, n);
for (long long j = l1 * (i - 1) + l2; j <= lim; ++j) {
dp[i & 1][j] =
min(dp[i & 1][j], dp[!(i & 1)][j - l2] + a[j] - a[j - l2 + 1]);
}
}
cout << dp[k & 1][n] << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, k;
int a[300007];
int diff[300007];
int len[300007];
int br1, br2;
int g1, g2;
map<pair<int, int>, long long> ZX;
long long dp[2][5007];
void input();
void solve();
int main() {
ios::sync_with_stdio(false);
cin.tie(NULL);
input();
solve();
return 0;
}
void input() {
scanf("%d%d", &n, &k);
int i;
for (i = 1; i <= n; i++) {
scanf("%d", &a[i]);
}
sort(a + 1, a + n + 1);
for (i = 1; i < n; i++) {
diff[i] = a[i + 1] - a[i];
}
}
void solve() {
int i, j;
for (i = 1; i <= n; i++) {
len[i] = 1;
}
for (i = n; i >= k + 1; i--) {
len[i - k] = len[i] + 1;
}
br1 = br2 = 0;
for (i = 1; i <= k; i++) {
if (len[i] == len[1]) {
br1++;
g1 = len[i];
} else {
br2++;
g2 = len[i];
}
}
dp[0][0] = 0;
int pos;
int prev = 0, cur = 1;
for (i = 0; i <= br1; i++) {
for (j = 0; j <= br2; j++) {
pos = i * g1 + j * g2;
if (i != br1) {
dp[cur][j] = max(dp[cur][j], dp[prev][j] + diff[pos]);
}
if (j != br2) {
dp[prev][j + 1] = max(dp[prev][j + 1], dp[prev][j] + diff[pos]);
}
}
if (i == br1) {
break;
}
prev ^= 1;
cur ^= 1;
for (j = 0; j <= br2; j++) {
dp[cur][j] = 0;
}
}
long long sm = 0;
for (i = 1; i < n; i++) {
sm += diff[i];
}
printf("%I64d\n", sm - dp[prev][br2]);
}
|
#include <bits/stdc++.h>
int a[333333];
long long d[5005][5005];
int main() {
int i, j, n, m, t;
scanf("%d%d", &n, &m);
t = n / m;
for (i = 0; i < n; i++) scanf("%d", &a[i]);
std::sort(a, a + n);
for (i = 0; i <= m; i++)
for (j = 0; j <= m; j++) d[i][j] = 9e18;
d[0][0] = 0;
for (i = 1; i <= m; i++)
for (j = 0; j <= m; j++) {
d[i][j] = d[i - 1][j] + std::abs(a[t * i + j - 1] - a[t * i + j - t]);
if (j)
d[i][j] = std::min(
d[i][j], d[i - 1][j - 1] +
std::abs(a[t * i + j - 1] - a[t * i + j - t - 1]));
}
printf("%I64d", d[m][n % m]);
}
|
#include <bits/stdc++.h>
using namespace std;
const int mx = 3e5 + 5;
long long a[mx];
long long dp[5005][5005];
int main() {
int n, k, l, l1, l2, tmp;
long long ans;
scanf("%d%d", &n, &k);
for (int i = 1; i <= n; i++) scanf("%I64d", &a[i]);
sort(a + 1, a + n + 1);
memset(dp, 0, sizeof(dp));
a[0] = 0;
l1 = n % k;
l2 = k - l1;
l = n / k;
for (int i = 0; i <= l1; i++)
for (int j = 0; j <= l2; j++) {
if (i == 0 && j == 0) continue;
tmp = i * (l + 1) + j * l + 1;
dp[i + 1][j] = max(dp[i + 1][j], dp[i][j] + a[tmp] - a[tmp - 1]);
dp[i][j + 1] = max(dp[i][j + 1], dp[i][j] + a[tmp] - a[tmp - 1]);
}
ans = a[n] - a[1] - dp[l1][l2];
printf("%I64d\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
inline void in(int &n) {
n = 0;
int ch = getchar();
int sign = 1;
while (ch < '0' || ch > '9') {
if (ch == '-') sign = -1;
ch = getchar();
}
while (ch >= '0' && ch <= '9') {
n = (n << 3) + (n << 1) + ch - '0', ch = getchar();
}
n = n * sign;
}
int a[300005];
long long int A[300005], B[300005], memo[5005][5005];
int X, Y;
long long int func(int x, int y, int p, int q, int n) {
if (x == 0 && y == 0) {
return 0;
}
if (x < 0 || y < 0) {
return ((long long int)(1e18));
}
int pos = (X - x) * p + (Y - y) * q + 1;
if (pos > n) {
return ((long long int)(1e18));
}
if (memo[x][y] != -1) {
return memo[x][y];
}
long long int ans;
ans = min(A[pos] + func(x - 1, y, p, q, n), B[pos] + func(x, y - 1, p, q, n));
memo[x][y] = ans;
return ans;
}
int main() {
int n, k;
in(n);
in(k);
for (int i = 1; i <= n; i++) {
in(a[i]);
}
sort(a + 1, a + 1 + n);
int p, q;
X = n % k;
p = (n / k + 1);
Y = k - X;
q = n / k;
for (int i = 1; i <= n; i++) {
if (i + p - 1 <= n) {
A[i] = a[i + p - 1] - a[i];
} else {
A[i] = ((long long int)(1e18));
}
if (i + q - 1 <= n) {
B[i] = a[i + q - 1] - a[i];
} else {
B[i] = ((long long int)(1e18));
}
}
memset(memo, -1, sizeof(memo));
long long int ans = func(X, Y, p, q, n);
printf("%I64d\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long dp[5002][5002];
int main() {
int n, k, a[300002];
cin >> n >> k;
for (int i = 1; i <= n; i++) {
cin >> a[i];
}
sort(a + 1, a + n + 1);
int x = n % k, y = k - n % k;
int q = n / k, p = (n / k) + 1;
for (int i = 1; i <= x; i++)
dp[i][0] = dp[i - 1][0] + (a[p * i] - a[p * (i - 1) + 1]);
for (int i = 1; i <= y; i++)
dp[0][i] = dp[0][i - 1] + (a[q * i] - a[q * (i - 1) + 1]);
for (int i = 1; i <= x; i++) {
for (int j = 1; j <= y; j++) {
dp[i][j] = dp[i - 1][j] + a[p * i + q * j] - a[p * (i - 1) + q * j + 1];
dp[i][j] = min(dp[i][j], dp[i][j - 1] + a[p * i + q * j] -
a[p * i + q * (j - 1) + 1]);
}
}
cout << dp[x][y] << "\n";
return 0;
}
|
#include <bits/stdc++.h>
int n, k, a[300011];
long long s[300001];
int num1, num2, len1, len2;
long long f[5001][5001];
long long calc(int l, int r) { return s[r - 1] - s[l - 1]; }
int get(int len) { return (len / k) + (len % k > 0); }
int main() {
scanf("%d%d", &n, &k);
for (int i = 1; i <= n; i++) scanf("%d", &a[i]);
std::sort(a + 1, a + n + 1);
for (int i = 1; i < n; i++) s[i] = s[i - 1] + a[i + 1] - a[i];
num1 = 1;
num2 = 0;
len1 = get(n);
for (int st = 2; st <= k; st++) {
int lennow = get(n - st + 1);
if (lennow != len1) {
len2 = lennow;
num2++;
} else
num1++;
}
if (num2 == 0) {
long long ans = 0;
for (int i = 1; i <= k; i++) ans += calc((i - 1) * len1 + 1, i * len1);
std::cout << ans << std::endl;
} else {
f[0][0] = 0;
int i, j, totallen;
long long tmp1, tmp2;
for (i = 0; i <= num1; i++)
for (j = 0; j <= num2; j++) {
if (i == 0 && j == 0) continue;
totallen = i * len1 + j * len2;
if (i >= 1)
tmp1 = f[i - 1][j] + calc(totallen - len1 + 1, totallen);
else
tmp1 = -1;
if (j >= 1)
tmp2 = f[i][j - 1] + calc(totallen - len2 + 1, totallen);
else
tmp2 = -1;
if (tmp1 == -1)
f[i][j] = tmp2;
else if (tmp2 == -1)
f[i][j] = tmp1;
else {
if (tmp1 < tmp2)
f[i][j] = tmp1;
else
f[i][j] = tmp2;
}
}
std::cout << f[num1][num2] << std::endl;
}
}
|
#include <bits/stdc++.h>
using namespace std;
int n, k;
int a[300005];
int sz, cnt0, cnt1;
long long d[5005][5005];
const long long INF = 1e18;
int main() {
scanf("%d%d", &n, &k);
for (int i = 0; i < (int)(n); ++i) scanf("%d", a + i);
sort(a, a + n);
sz = n / k;
cnt0 = cnt1 = 0;
for (int i = 0; i < (int)(k); ++i) {
int s = (n - i + k - 1) / k;
if (s == sz)
++cnt0;
else
++cnt1;
}
for (int i = 0; i < (int)(cnt0 + 1); ++i)
for (int j = 0; j < (int)(cnt1 + 1); ++j) d[i][j] = INF;
d[0][0] = 0;
for (int i = 0; i < (int)(cnt0 + 1); ++i)
for (int j = 0; j < (int)(cnt1 + 1); ++j) {
int pos = i * sz + j * (sz + 1);
if (i != cnt0) {
d[i + 1][j] = min(d[i + 1][j], d[i][j] + a[pos + sz - 1] - a[pos]);
}
if (j != cnt1) {
d[i][j + 1] = min(d[i][j + 1], d[i][j] + a[pos + sz] - a[pos]);
}
}
cout << d[cnt0][cnt1] << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 300010;
const int maxk = 5010;
const long long oo = 0x1f1f1f1f1f1f1f1fll;
int a[maxn];
long long s[maxn], res = oo, f[maxk][maxk];
inline void mini(long long& a, long long b) {
if (a > b) a = b;
}
int main() {
int n, k;
scanf("%d %d", &n, &k);
for (int i = 1; i <= n; ++i) scanf("%d", a + i);
sort(a + 1, a + n + 1);
for (int i = 1; i <= n; ++i) s[i] = s[i - 1] + a[i] - a[i - 1];
int minsz = n / k, maxsz = (n + k - 1) / k;
memset(f, 0x1f, sizeof f);
f[0][0] = 0;
for (int i = 0; i * minsz <= n && i <= k; ++i) {
for (int j = 0; j * maxsz + i * minsz <= n && i + j <= k; ++j) {
if (!i && !j) continue;
if (i)
mini(f[i][j], f[i - 1][j] + s[i * minsz + j * maxsz] -
s[(i - 1) * minsz + j * maxsz + 1]);
if (j)
mini(f[i][j], f[i][j - 1] + s[i * minsz + j * maxsz] -
s[i * minsz + (j - 1) * maxsz + 1]);
if (i * minsz + j * maxsz == n && i + j == k) mini(res, f[i][j]);
}
}
printf("%lld\n", res);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long dp[5043][5043];
int main() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
long long n, k;
cin >> n >> k;
vector<long long> vec(n, 0);
for (int i = 0; i < n; i++) cin >> vec[i];
long long t = n % k;
long long m = n / k;
sort(vec.begin(), vec.end());
for (int i = 0; i <= k; i++)
for (int j = 0; j <= k; j++) dp[i][j] = 1e15;
dp[0][0] = 0;
for (int i = 0; i < k; i++) {
for (int j = 0; j < k; j++) {
if (dp[i][j] == 1e15) continue;
int q = i * m + j;
if (q + m < n)
dp[i + 1][j + 1] =
min(dp[i + 1][j + 1], dp[i][j] + vec[q + m] - vec[q]);
if (q + m - 1 < n)
dp[i + 1][j] = min(dp[i + 1][j], dp[i][j] + vec[q + m - 1] - vec[q]);
}
}
cout << dp[k][t] << endl;
}
|
#include <bits/stdc++.h>
#pragma comment(linker, "/stack:225450978")
#pragma GCC optimize("Ofast")
using namespace std;
const long long Mod = 1000000007LL, INF = 1e9, LINF = 1e18;
const long double Pi = 3.141592653589793116, EPS = 1e-9,
Gold = ((1 + sqrt(5)) / 2);
long long keymod[] = {1000000007LL, 1000000009LL, 1000000021LL, 1000000033LL};
long long keyCount = sizeof(keymod) / sizeof(long long);
template <class T>
int getbit(T s, int i) {
return (s >> i) & 1;
}
template <class T>
T onbit(T s, int i) {
return s | (T(1) << i);
}
template <class T>
T offbit(T s, int i) {
return s & (~(T(1) << i));
}
template <class T>
int cntbit(T s) {
return __builtin_popcountll(s);
}
auto TimeStart = chrono::steady_clock::now();
auto TimeEnd = chrono::steady_clock::now();
void ControlIO(int argc, char* argv[]);
void TimerStart();
void TimerStop();
void Exit();
string cppstr_infile = "FILE.IN";
string cppstr_outfile = "FILE.OUT";
long long n, k;
vector<long long> A;
long long dp[5001][5001];
void Input() {
cin >> n >> k;
A.resize(n);
for (auto& x : A) cin >> x;
for (long long i = 0; i <= 5000; i++) {
for (long long j = 0; j <= 5000; j++) {
dp[i][j] = LINF;
}
}
dp[0][0] = 0;
}
void Solve() {
sort(A.begin(), A.end());
long long Large = n / k + 1, Small = n / k;
long long LCnt = n % k, SCnt = k - LCnt;
for (long long i = 0; i <= LCnt; i++) {
for (long long j = 0; j <= SCnt; j++) {
long long x = i * Large + j * Small;
if (i < LCnt) {
long long y = x + Large - 1;
dp[i + 1][j] = min(dp[i + 1][j], dp[i][j] + (A[y] - A[x]));
}
if (j < SCnt) {
long long y = x + Small - 1;
dp[i][j + 1] = min(dp[i][j + 1], dp[i][j] + (A[y] - A[x]));
}
}
}
cout << dp[LCnt][SCnt] << '\n';
}
int main(int argc, char* argv[]) {
ControlIO(argc, argv);
ios_base::sync_with_stdio(0);
cin.tie(NULL);
Input();
TimerStart();
Solve();
TimerStop();
return 0;
}
void ControlIO(int argc, char* argv[]) {
char* infile = new char[cppstr_infile.size() + 1];
char* outfile = new char[cppstr_outfile.size() + 1];
strcpy(infile, cppstr_infile.c_str());
strcpy(outfile, cppstr_outfile.c_str());
}
void TimerStart() {}
void TimerStop() {}
void Exit() {
TimerStop();
exit(0);
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 3e5, F = 2147483646;
int n, k;
long long int arr[N], dif[10 * N], dp[5010][5010];
void solve() {
cin >> n >> k;
for (long long int i = 0; i < n; i++) cin >> arr[i];
sort(arr, arr + n);
dif[0] = 0;
for (int i = 0; i < n - 1; i++) dif[i + 1] = arr[i + 1] - arr[i];
for (long long int i = 0; i < k + 2; i++)
for (long long int j = 0; j < k + 2; j++) dp[i][j] = -1e18;
for (long long int i = 0; i < k + 2; i++) dp[0][i] = 0;
int a = (n % k), b = (n / k);
dif[n + 1] = 0;
for (int i = 1; i <= k; i++) {
for (int j = 0; j <= a; j++) {
if (j > i) {
continue;
}
dp[i][j] = max(dp[i][j], dp[i - 1][j] + dif[j * (b + 1) + (i - j) * b]);
if (j < a) {
dp[i + 1][j + 1] = max(dp[i + 1][j + 1],
dp[i][j] + dif[(j + 1) * (b + 1) + (i - j) * b]);
}
}
}
cout << arr[n - 1] - arr[0] - dp[k][a];
}
int main() {
cin.tie(0);
ios::sync_with_stdio(0);
int T = 1;
while (T--) {
solve();
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int max_n = 300333, max_k = 5005;
const long long inf = 1111111111111111111LL;
int n, k, l1, l2, a1, a2, a[max_n];
long long dp[max_k][max_k];
long long get_sum(int l, int r) { return a[r] - a[l]; }
void get_dp(int a1, int a2) {
if (dp[a1][a2] != -1) {
return;
}
int poz = a1 * l1 + a2 * l2 - 1;
dp[a1][a2] = inf;
if (a1) {
get_dp(a1 - 1, a2);
dp[a1][a2] = min(dp[a1][a2], dp[a1 - 1][a2] + get_sum(poz - l1 + 1, poz));
}
if (a2) {
get_dp(a1, a2 - 1);
dp[a1][a2] = min(dp[a1][a2], dp[a1][a2 - 1] + get_sum(poz - l2 + 1, poz));
}
}
int main() {
scanf("%d%d", &n, &k);
for (int i = 0; i < n; ++i) {
scanf("%d", &a[i]);
}
sort(a, a + n);
l1 = 1 + (n - 1) / k;
for (int i = 0; i < k; ++i) {
int c = (n - i - 1) / k + 1;
if (c == l1) {
++a1;
} else {
++a2;
l2 = c;
}
}
memset(dp, -1, sizeof(dp));
dp[0][0] = 0;
get_dp(a1, a2);
cout << dp[a1][a2] << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int dp[5003][5003], shu[300005];
int main() {
int m, n, lm, ln, fo;
scanf("%d%d", &m, &n);
for (int i = 1; i <= m; ++i) scanf("%d", &shu[i]);
sort(shu + 1, shu + 1 + m);
lm = m / n;
ln = m % n;
fo = n - ln;
for (int i = 0; i <= fo; ++i) {
for (int j = 0; j <= ln; ++j) {
if (!i && !j) continue;
int ll = i * lm + j * (lm + 1);
if (!i)
dp[i][j] = dp[i][j - 1] + shu[ll] - shu[ll - lm];
else if (!j)
dp[i][j] = dp[i - 1][j] + shu[ll] - shu[ll - lm + 1];
else
dp[i][j] = min(dp[i][j - 1] + shu[ll] - shu[ll - lm],
dp[i - 1][j] + shu[ll] - shu[ll - lm + 1]);
}
}
printf("%d\n", dp[fo][ln]);
return 0;
}
|
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:102400000,102400000")
using namespace std;
template <class T>
inline void read(T &x) {
char c = getchar();
x = 0;
while (!isdigit(c)) c = getchar();
while (isdigit(c)) {
x = x * 10 + c - '0';
c = getchar();
}
}
template <class T>
inline void rd(T &res) {
static char ch;
bool sgn = false;
while (ch = getchar(), ch < '0' || ch > '9')
if (ch == '-') sgn = true;
res = ch - 48;
while (ch = getchar(), ch >= '0' && ch <= '9') res = res * 10 + ch - 48;
res = sgn ? -res : res;
}
template <class T>
void Out(T a) {
if (a < 0) {
putchar('-');
a = -a;
}
if (a >= 10) Out(a / 10);
putchar(a % 10 + '0');
}
const int NN = 3e5 + 10;
const int N = 5011;
const long long oo = 0x3f3f3f3f3f3f3f3fLL;
long long a[NN];
long long *dp[N];
int main() {
int n, k;
while (~scanf("%d%d", &n, &k)) {
int p = n / k, q = n % k;
for (int i = 1; i <= n; i++) rd(a[i]);
sort(a + 1, a + n + 1);
int rp = k - q + 1;
for (int i = 0; i <= q; i++) dp[i] = new long long[rp];
for (int i = 0; i <= q; i++)
for (int j = 0; j <= k - q; j++) dp[i][j] = oo;
dp[0][0] = 0;
for (int i = 0; i <= q; i++) {
for (int j = 0; j <= k - q; j++) {
if (i)
dp[i][j] = min(dp[i][j], dp[i - 1][j] + a[i * (p + 1) + j * p] -
a[(i - 1) * (p + 1) + j * p + 1]);
if (j)
dp[i][j] = min(dp[i][j], dp[i][j - 1] + a[i * (p + 1) + j * p] -
a[i * (p + 1) + (j - 1) * p + 1]);
}
}
Out(dp[q][k - q]), puts("");
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int mxn = 3e5 + 100;
int a[mxn];
long long dp[2][mxn];
int main() {
int n, k;
scanf("%d%d", &n, &k);
for (int i = 1; i <= n; ++i) scanf("%d", &a[i]);
sort(a + 1, a + n + 1);
int q = n / k;
const int r1 = n % k, r2 = k - r1;
const int q1 = q + 1, q2 = q;
for (int i = 1; i <= r2; ++i) {
dp[0][i] = a[i * q2] - a[q2 * (i - 1) + 1] + dp[0][i - 1];
}
for (int i = 1; i <= r1; ++i) {
dp[i & 1][0] = dp[i & 1 ^ 1][0] + a[i * q1] - a[q1 * (i - 1) + 1];
for (int j = 1; j <= r2; ++j) {
int idx = i * q1 + j * q2;
dp[i & 1][j] = min(dp[i & 1][j - 1] + a[idx] - a[idx - q2 + 1],
dp[i & 1 ^ 1][j] + a[idx] - a[idx - q1 + 1]);
}
}
printf("%d\n", dp[r1 & 1][r2]);
}
|
#include <bits/stdc++.h>
namespace chtholly {
inline int read() {
int x = 0, f = 1;
char c = getchar();
for (; !isdigit(c); c = getchar()) f ^= c == '-';
for (; isdigit(c); c = getchar()) x = (x << 3) + (x << 1) + (c ^ '0');
return f ? x : -x;
}
template <typename mitsuha>
inline bool read(mitsuha &x) {
x = 0;
int f = 1;
char c = getchar();
for (; !isdigit(c) && ~c; c = getchar()) f ^= c == '-';
if (!~c) return 0;
for (; isdigit(c); c = getchar()) x = (x << 3) + (x << 1) + (c ^ '0');
return x = f ? x : -x, 1;
}
template <typename mitsuha>
inline int write(mitsuha x) {
if (!x) return 0 & putchar(48);
if (x < 0) x = -x, putchar('-');
int bit[20], i, p = 0;
for (; x; x /= 10) bit[++p] = x % 10;
for (i = p; i; --i) putchar(bit[i] + 48);
return 0;
}
inline char fuhao() {
char c = getchar();
for (; isspace(c); c = getchar())
;
return c;
}
} // namespace chtholly
using namespace chtholly;
using namespace std;
const int yuzu = 3e5, aoi = 5013;
int a[yuzu | 10], dp[aoi][aoi];
int main() {
int i, j, n = read(), k = read();
for (i = 1; i <= n; ++i) a[i] = read();
sort(a + 1, a + n + 1);
int xbl = n / k, dbl = n / k + 1, ctx = n % k, ctd = k - ctx;
a[0] = a[1], a[n + 1] = a[n];
for (i = 0; i <= ctx; ++i) {
for (j = 0; j <= ctd; ++j) {
if (i) {
int pos = (i - 1) * dbl + j * xbl;
dp[i][j] = max(dp[i][j], dp[i - 1][j] + a[pos + 1] - a[pos]);
}
if (j) {
int pos = i * dbl + (j - 1) * xbl;
dp[i][j] = max(dp[i][j], dp[i][j - 1] + a[pos + 1] - a[pos]);
}
}
}
write(a[n] - a[1] - dp[ctx][ctd]);
}
|
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:128000000")
using namespace std;
void solve();
void precalc();
int TESTNUM = 0;
int main() {
string s = "";
cin.tie(0);
cout.sync_with_stdio(0);
cout.precision(10);
cout << fixed;
precalc();
int t = 1;
while (t--) {
++TESTNUM;
solve();
}
return 0;
}
int MOD = 1000000007;
int binpow(int q, int w, int mod) {
if (!w) return 1;
if (w & 1) return q * 1LL * binpow(q, w - 1, mod) % mod;
return binpow(q * 1LL * q % mod, w / 2, mod);
}
void precalc() {}
int gcd(int q, int w) {
while (w) {
q %= w;
swap(q, w);
}
return q;
}
void solve() {
int n, k;
cin >> n >> k;
int part = n / k;
int large = n % k;
vector<int> a(n);
for (int i = 0; i < n; ++i) {
cin >> a[i];
}
sort(a.begin(), a.end());
vector<vector<int>> dp(large + 1, vector<int>(k - large + 1, 2e9));
dp[0][0] = 0;
for (int largeParts = 0; largeParts <= large; ++largeParts) {
for (int smallParts = 0; smallParts <= k - large; ++smallParts) {
int nex = largeParts * (part + 1) + smallParts * part;
if (largeParts < large) {
int add = a[nex + part] - a[nex];
dp[largeParts + 1][smallParts] = min(dp[largeParts + 1][smallParts],
dp[largeParts][smallParts] + add);
}
if (smallParts < k - large) {
int add = a[nex + part - 1] - a[nex];
dp[largeParts][smallParts + 1] = min(dp[largeParts][smallParts + 1],
dp[largeParts][smallParts] + add);
}
}
}
cout << dp[large][k - large] << "\n";
}
|
#include <bits/stdc++.h>
using namespace std;
long long n, k;
long long a[300010], dp[5010][5010];
int main() {
for (long long i = 0; i <= 5009; i++)
for (long long j = 0; j <= 5009; j++)
dp[i][j] = (long long)1000000000000009;
dp[0][0] = (long long)0;
cin >> n >> k;
for (long long i = 1; i <= n; i++) scanf("%I64d", &a[i]);
sort(a + 1, a + n + 1);
long long val = n / k;
long long ans = n - val * k;
for (long long i = 0; i <= k - ans; i++)
for (long long j = 0; j <= ans; j++) {
long long res = (i + j) * val + j;
if (i != (long long)0)
dp[i][j] = min(dp[i][j], dp[i - 1][j] + a[res] - a[res - val + 1]);
if (j != (long long)0)
dp[i][j] = min(dp[i][j], dp[i][j - 1] + a[res] - a[res - val]);
}
cout << dp[k - ans][ans] << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int i, j, k, l, n, m, s, an, K, X;
const int N = 5100;
int a[1100000], g[1100000];
long long f[N][N];
int main() {
scanf("%d%d", &n, &K);
for (int i = 1; i <= n; i++) scanf("%d", &a[i]);
sort(&a[1], &a[n + 1]);
int v1 = n / K + 1;
int v2 = n / K;
if (n % K == 0) v1--;
int ss = n % K;
if (!ss) ss = K;
ss = K - ss;
memset(f, 120, sizeof(f));
f[0][0] = 0;
for (int i = 0; i <= K; i++)
for (int j = 0; j <= ss; j++) {
int now = j * v2 + (i - j) * v1;
f[i + 1][j] = min(f[i + 1][j], f[i][j] + a[now + v1] - a[now + 1]);
f[i + 1][j + 1] =
min(f[i + 1][j + 1], f[i][j] + a[now + v2] - a[now + 1]);
}
printf("%I64d\n", f[K][ss]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
vector<long long> arr;
long long memo[5123][5123];
int n, k, large, small, total_large, total_small;
const long long INF = (int)1e18;
long long dp(int num_large, int num_small) {
if (memo[num_large][num_small] != -1) return memo[num_large][num_small];
if (num_large == total_large && num_small == total_small) return 0;
int id = (num_large * large) + (num_small * small);
long long take_large = INF;
if (num_large < total_large)
take_large = arr[id + large - 1] - arr[id] + dp(num_large + 1, num_small);
long long take_small = INF;
if (num_small < total_small)
take_small = arr[id + small - 1] - arr[id] + dp(num_large, num_small + 1);
return memo[num_large][num_small] = min(take_large, take_small);
}
int main() {
cin >> n >> k;
arr.resize(n);
for (int i = 0; i < n; i++) cin >> arr[i];
sort(arr.begin(), arr.end());
memset(memo, -1, sizeof memo);
total_large = n % k;
total_small = k - total_large;
large = n / k + 1;
small = n / k;
cout << dp(0, 0) << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long INF = 1000000000000000, LEN = 5010;
long long n, k, ar[600300], res, len, len1, kol, kol1, dp[LEN][LEN];
int main() {
cin >> n >> k;
for (int i = 0; i < n; i++) cin >> ar[i];
sort(ar, ar + n);
len = (n - 1) / k + 1;
len1 = len - 1;
kol = (n - 1) % k + 1;
kol1 = k - kol;
for (int i = 0; i < LEN; i++)
for (int j = 0; j < LEN; j++) dp[i][j] = INF;
dp[0][0] = 0;
for (int i = 0; i <= kol; i++)
for (int j = 0; j <= kol1; j++) {
dp[i + 1][j] =
min(dp[i + 1][j], dp[i][j] + abs(ar[(i + 1) * len + j * len1 - 1] -
ar[i * len + j * len1]));
dp[i][j + 1] =
min(dp[i][j + 1], dp[i][j] + abs(ar[i * len + (j + 1) * len1 - 1] -
ar[i * len + j * len1]));
}
cout << dp[kol][kol1];
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long DP[5010][5010];
int main() {
ios::sync_with_stdio(false);
long long N, K, i, j, k;
cin >> N >> K;
vector<long long> A(N);
for (i = 0; i < N; i++) {
cin >> A[i];
}
sort(A.begin(), A.end());
for (i = 0; i < 5010; i++) {
for (j = 0; j < 5010; j++) {
DP[i][j] = 1E18;
}
}
DP[0][0] = 0;
long long NL = N % K;
long long NS = K - NL;
long long LL = (N - 1) / K + 1;
long long LS = LL - 1;
if (NL == 0) {
NL = K;
NS = 0;
}
for (i = 0; i <= NL; i++) {
for (j = 0; j <= NS; j++) {
if (i != 0) {
DP[i][j] = min(DP[i][j], DP[i - 1][j] + A[i * LL + j * LS - 1] -
A[(i - 1) * LL + j * LS]);
}
if (j != 0) {
DP[i][j] = min(DP[i][j], DP[i][j - 1] + A[i * LL + j * LS - 1] -
A[i * LL + (j - 1) * LS]);
}
}
}
cout << DP[NL][NS] << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int mas[300100];
long long dp[5010][5010];
int ml;
int n, d, e;
long long ret;
long long doit(int b, int s) {
int pos = b * (ml + 1) + s * ml;
if (pos == n) return 0;
long long &res = dp[b][s];
if (res == -1) {
res = 1e18;
if (b < d) res = mas[pos + ml] - mas[pos] + doit(b + 1, s);
if (s < e) {
long long ret = mas[pos + ml - 1] - mas[pos] + doit(b, s + 1);
res = min(res, ret);
}
}
return res;
}
void Solve() {
int i, j, k, m;
scanf("%d%d", &(n), &(k));
for (i = 0; i < n; i++) scanf("%d", &(mas[i]));
sort(mas, mas + n);
d = n % k;
e = k - d;
ml = n / k;
memset(dp, -1, sizeof(dp));
printf("%I64d", doit(0, 0));
}
int main() {
Solve();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, k;
int num[333333];
long long dp[5555][5555];
int main(void) {
scanf("%d%d", &n, &k);
for (int i = 0; i < n; i++) scanf("%d", &num[i]);
sort(num, num + n);
int kmax = (n - 1) % k + 1;
int x2 = k;
if (n % k)
k = n / k + 1;
else
k = n / k;
for (int i = 0; i <= kmax; i++)
for (int j = 0; j <= x2 - kmax; j++) dp[i][j] = 0xfffffffffffffLL;
dp[0][0] = 0;
for (int i = 0; i <= kmax; i++)
for (int j = 0; j <= x2 - kmax; j++) {
int nowi = i * k + j * (k - 1);
dp[i][j + 1] =
min(dp[i][j + 1], dp[i][j] + num[nowi + k - 2] - num[nowi]);
dp[i + 1][j] =
min(dp[i + 1][j], dp[i][j] + num[nowi + k - 1] - num[nowi]);
}
printf("%I64d\n", dp[kmax][x2 - kmax]);
}
|
#include <bits/stdc++.h>
using namespace std;
int arr[300005];
int dp[5005][5005];
bool vis[5005][5005];
int big, small;
int rec(int a, int b, int idx) {
if (vis[a][b]) return dp[a][b];
vis[a][b] = 1;
int res = INT_MAX;
if (a > 0)
res = min(res, rec(a - 1, b, idx - big) + arr[idx] - arr[idx - big + 1]);
if (b > 0)
res =
min(res, rec(a, b - 1, idx - small) + arr[idx] - arr[idx - small + 1]);
dp[a][b] = res;
return res;
}
int main() {
int n, i, j, t;
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int k;
cin >> n >> k;
for (i = 0; i < n; i++) cin >> arr[i];
sort(arr, arr + n);
big = n / k + 1;
small = n / k;
vis[0][0] = 1;
rec(n % k, k - (n % k), n - 1);
cout << dp[n % k][k - n % k];
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 3e5 + 10, M = 5e3 + 8;
long long a[N], n, k, dp[M][M];
int main() {
ios::sync_with_stdio(0), cin.tie(0), cout.tie(0);
cin >> n >> k;
for (int i = 1; i <= n; i++) cin >> a[i];
for (int i = 0; i <= k; i++) memset(dp[i], 63, sizeof dp[i]);
sort(a + 1, a + n + 1);
int q = n % k;
int x = n / k;
dp[0][0] = 0;
for (int i = 1; i <= k; i++)
for (int j = 0; j <= q; j++) {
int e = i * x + j;
int t1 = abs(a[e] - a[e - x]);
int t2 = abs(a[e] - a[e - x + 1]);
dp[i][j] = min(dp[i - 1][j] + t2, dp[i][j]);
if (j) dp[i][j] = min(dp[i - 1][j - 1] + t1, dp[i][j]);
}
cout << dp[k][q];
}
|
#include <bits/stdc++.h>
using namespace std;
long long n, k, a[300005], f[5002][5002];
int main() {
scanf("%I64d%I64d", &n, &k);
for (int i = 1; i <= n; i++) scanf("%I64d", a + i);
sort(a + 1, a + n + 1);
long long d = n / k;
for (int i = 1; i <= k; i++) f[0][i] = 999999999999999ll;
for (int i = 1; i <= k; i++) {
f[i][0] = f[i - 1][0] + a[d * i] - a[d * i - d + 1];
for (int j = 1; j <= k; j++)
f[i][j] = min(f[i - 1][j] + a[d * i + j] - a[d * i - d + j + 1],
f[i - 1][j - 1] + a[d * i + j] - a[d * i - d + j]);
}
printf("%I64d\n", f[k][n % k]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <typename T>
void print(T t) {
cout << t << endl;
}
template <typename T, typename... Args>
void print(T t, Args... args) {
cout << t << " ";
print(args...);
}
long long n, k;
long long arr[300005];
long long cache[5005][5005];
long long dp(long long tk, long long rem) {
if (tk == k) {
if (rem == n % k) return 0;
return 1e18;
}
if (rem > n % k) return 1e18;
long long &ans = cache[tk][rem];
if (ans != -1) return ans;
long long currind = tk * (n / k) + rem;
long long ahead = currind + n / k - 1;
ans = min(arr[ahead] - arr[currind] + dp(tk + 1, rem),
arr[ahead + 1] - arr[currind] + dp(tk + 1, rem + 1));
return ans;
}
int32_t main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
;
cin >> n >> k;
for (long long i = 0; i < n; i++) cin >> arr[i];
sort(arr, arr + n);
memset(cache, -1, sizeof(cache));
cout << dp(0, 0);
}
|
#include <bits/stdc++.h>
using namespace std;
const long long INF = (1e15);
int n, k;
int a[300010];
long long f[5010][5010];
int main() {
scanf("%d%d", &n, &k);
for (int i = 1; i <= n; i++) scanf("%d", &a[i]);
sort(a + 1, a + 1 + n);
int bn = n % k, cn = k - bn;
int bL = (n / k) + 1, cL = n / k;
f[0][0] = 0;
for (int i = 0; i <= bn; i++) {
for (int j = 0; j <= cn; j++) {
if (i == 0 && j == 0) continue;
f[i][j] = INF;
if (i) {
f[i][j] = min(f[i][j], f[i - 1][j] + (a[i * bL + j * cL] -
a[(i - 1) * bL + j * cL + 1]));
}
if (j) {
f[i][j] = min(f[i][j], f[i][j - 1] + (a[i * bL + j * cL] -
a[i * bL + (j - 1) * cL + 1]));
}
}
}
printf("%lld\n", f[bn][cn]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 3 * 1e5 + 100;
const int M = 5050;
int n, k, a[N], sum[N], ca, cb;
long long dp[M][M];
int main() {
while (~scanf("%d%d", &n, &k)) {
for (int i = 0; i < n; i++) scanf("%d", a + i);
sort(a, a + n);
sum[0] = 0;
for (int i = 1; i < n; i++) sum[i] = sum[i - 1] + a[i] - a[i - 1];
ca = n % k;
cb = k - ca;
int l = n / k;
dp[0][0] = 0;
for (int i = 0; i <= ca; i++) {
for (int j = 0; j <= cb; j++) {
int now = (i + j) * l + i - 1;
if (i + j != 0) dp[i][j] = sum[now];
if (i) dp[i][j] = min(dp[i - 1][j] + sum[now] - sum[now - l], dp[i][j]);
if (j)
dp[i][j] = min(dp[i][j - 1] + sum[now] - sum[now - l + 1], dp[i][j]);
}
}
printf("%I64d\n", dp[ca][cb]);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
vector<vector<long> > dp(5001, vector<long>(5001, -1));
long n, k, x, y, X, Y;
vector<long> A;
long solve(long x, long y) {
if (dp[x][y] != -1) return dp[x][y];
long total = x * (n / k) + y * (n / k + 1);
if (!x)
dp[x][y] = solve(x, y - 1) + A[total - 1] - A[total - n / k - 1];
else if (!y)
dp[x][y] = solve(x - 1, y) + A[total - 1] - A[total - n / k];
else
dp[x][y] = min(solve(x - 1, y) + A[total - 1] - A[total - n / k],
solve(x, y - 1) + A[total - 1] - A[total - n / k - 1]);
return dp[x][y];
}
int main() {
cin >> n >> k;
for (int i = 0; i < n; i++) {
long num;
cin >> num;
A.push_back(num);
}
dp[0][0] = 0;
sort(A.begin(), A.end());
solve(k - n % k, n % k);
cout << dp[k - n % k][n % k] << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 3e5 + 100;
int solve(int n, int m, int len, int num, const vector<int>& v) {
if (m >= n) return 0;
map<pair<int, int>, int> f[N];
f[0][pair<int, int>(num, m - num)] = 0;
for (int i = 0; i < (n + 1); ++i) {
for (auto top : f[i]) {
int num0 = top.first.first, num1 = top.first.second;
if (num0 && i + len <= n) {
int j = i + len;
pair<int, int> k = pair<int, int>(num0 - 1, num1);
if (!f[j].count(k)) f[j][k] = 2e9;
f[j][k] = min(f[j][k], top.second + v[j - 1] - v[i]);
}
if (num1 && i + len - 1 <= n) {
int j = i + len - 1;
pair<int, int> k = pair<int, int>(num0, num1 - 1);
if (!f[j].count(k)) f[j][k] = 2e9;
f[j][k] = min(f[j][k], top.second + v[j - 1] - v[i]);
}
}
}
return f[n][pair<int, int>(0, 0)];
}
int main() {
int n, m;
while (cin >> n >> m) {
vector<int> vec(n);
for (int i = 0; i < (n); ++i) scanf("%d", &vec[i]);
sort(vec.begin(), vec.end());
vec.push_back(vec.back());
int len = (n - 1) / m + 1, num = (n - 1) % m + 1;
int ret = solve(n, m, len, num, vec);
cout << ret << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
inline long long read() {
long long x = 0, f = 1;
char ch = getchar();
while (ch < '0' || ch > '9') {
if (ch == '-') f = -1;
ch = getchar();
}
while (ch >= '0' && ch <= '9') {
x = x * 10 + ch - '0';
ch = getchar();
}
return x * f;
}
inline void wrote(long long x) {
if (x < 0) putchar('-'), x = -x;
if (x >= 10) wrote(x / 10);
putchar(x % 10 + '0');
}
inline void writeln(long long x) {
wrote(x);
puts("");
}
const long long N = 300010;
long long n, k, a[N], pre[N], f[5010][5010];
int main() {
n = read();
k = read();
for (long long i = 1; i <= n; ++i) a[i] = read();
sort(a + 1, a + n + 1);
long long sum_more = n % k, sum_less = k - sum_more;
memset(f, 60, sizeof f);
f[0][0] = 0;
for (long long i = 0; i <= sum_more; ++i)
for (long long j = 0; j <= sum_less; ++j) {
long long now = i * (n / k + 1) + j * (n / k);
if (i) f[i][j] = min(f[i][j], f[i - 1][j] + a[now] - a[now - n / k]);
if (j) f[i][j] = min(f[i][j], f[i][j - 1] + a[now] - a[now - n / k + 1]);
}
writeln(f[sum_more][sum_less]);
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 300000 + 5;
const int MAXK = 5000 + 5;
int n, k;
long long a[MAXN];
long long dp[MAXK];
long long _get(int l, int r) { return a[r] - a[l]; }
int main() {
scanf("%d%d", &n, &k);
for (int i = 1; i <= n; i++) {
scanf("%I64d", &a[i]);
}
sort(a + 1, a + 1 + n);
int LEN = n / k;
int MAXJ = n % k;
dp[0] = _get(1, 1 * LEN);
dp[1] = _get(1, 1 * LEN + 1);
for (int i = 2; i <= k; i++) {
if (MAXJ >= i) {
dp[i] = dp[i - 1] + _get((i - 1) * LEN + (i - 1) + 1, i * LEN + i);
}
for (int j = min(MAXJ, i); j >= 1; j--) {
if (j == i) continue;
dp[j] = min(dp[j - 1] + _get((i - 1) * LEN + (j - 1) + 1, i * LEN + j),
dp[j] + _get((i - 1) * LEN + j + 1, i * LEN + j));
}
dp[0] += _get((i - 1) * LEN + 1, i * LEN);
}
printf("%I64d\n", dp[MAXJ]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
void __print(int x) { cerr << x; }
void __print(long x) { cerr << x; }
void __print(long long x) { cerr << x; }
void __print(unsigned x) { cerr << x; }
void __print(unsigned long x) { cerr << x; }
void __print(unsigned long long x) { cerr << x; }
void __print(float x) { cerr << x; }
void __print(double x) { cerr << x; }
void __print(long double x) { cerr << x; }
void __print(char x) { cerr << '\'' << x << '\''; }
void __print(const char *x) { cerr << '\"' << x << '\"'; }
void __print(const string &x) { cerr << '\"' << x << '\"'; }
void __print(bool x) { cerr << (x ? "true" : "false"); }
template <typename T, typename V>
void __print(const pair<T, V> &x) {
cerr << '{';
__print(x.first);
cerr << ',';
__print(x.second);
cerr << '}';
}
template <typename T>
void __print(const T &x) {
int f = 0;
cerr << '{';
for (auto &i : x) cerr << (f++ ? "," : ""), __print(i);
cerr << "}";
}
void _print() { cerr << "]\n"; }
template <typename T, typename... V>
void _print(T t, V... v) {
__print(t);
if (sizeof...(v)) cerr << ", ";
_print(v...);
}
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);
}
};
template <typename T>
ostream &operator<<(ostream &output, const vector<T> &v) {
if (v.empty()) return output;
for (int i = 0; i < v.size() - 1; i++) output << v[i] << " ";
output << v.back();
return output;
}
template <typename T>
istream &operator>>(istream &input, vector<T> &v) {
for (auto &i : v) cin >> i;
return input;
}
int power(long long x, long long n, const long long P) {
if (x == 0) return 0;
if (n == 0 || x == 1) return 1LL;
x %= P;
int res = 1;
while (n > 0) {
if (n & 1) res = (long long int)res * x % P;
x = (long long int)x * x % P;
n /= 2;
}
return res;
}
long long int power(long long int x, long long int n) {
if (x == 0)
return 0;
else if (n == 0 || x == 1)
return 1;
long long res = 1;
while (n > 0) {
if (n & 1) res *= x;
x *= x;
n /= 2;
}
return res;
}
int inv(long long x) { return power(x, 1000000007 - 2, 1000000007); }
long long int gcd(const long long int a, const long long int b) {
if (b == 0) return a;
return gcd(b, a % b);
}
long long int lcm(const long long int a, const long long int b) {
return (a * b) / gcd(a, b);
}
pair<int, int> dx[4] = {make_pair(-1, 0), make_pair(1, 0), make_pair(0, -1),
make_pair(0, 1)};
long long int dp[5005][5005];
void __sol() {
int n, k;
cin >> n >> k;
vector<long long int> v(n);
cin >> v;
sort(v.begin(), v.end());
int rem = n % k, quo = n / k;
for (int i = 0; i < 5005; i++)
for (int j = 0; j < 5005; j++) dp[i][j] = 1000000000000000000;
dp[0][0] = 0;
for (int j = 1; j <= k; j++) {
int id = (j - 1) * quo;
dp[0][j] = dp[0][j - 1] + v[id + quo - 1] - v[id];
}
for (int i = 1; i <= rem; i++) {
for (int j = 1; j <= k; j++) {
int id = j * quo + i - 1;
dp[i][j] = min(dp[i][j], dp[i][j - 1] + v[id] - v[id - quo + 1]);
dp[i][j] = min(dp[i][j], dp[i - 1][j - 1] + v[id] - v[id - quo]);
}
}
cout << dp[rem][k];
return;
}
int main() {
clock_t time_req = clock();
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int tc = 1;
while (tc--) __sol();
time_req = clock() - time_req;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, k, i, z;
long long a[300100], f[5100][5100];
long long get(int x, int y) {
if (f[x][y] >= 0) return f[x][y];
f[x][y] = 1e15;
int w = x * (z + 1) + y * z;
if (x > 0) f[x][y] = min(f[x][y], get(x - 1, y) + a[w] - a[w - z]);
if (y > 0) f[x][y] = min(f[x][y], get(x, y - 1) + a[w] - a[w - z + 1]);
return f[x][y];
}
int main() {
scanf("%d %d", &n, &k);
for (i = 1; i <= n; ++i) cin >> a[i];
sort(a + 1, a + 1 + n);
for (i = n; i >= 2; --i) a[i] = abs(a[i] - a[i - 1]);
a[1] = 0;
for (i = 2; i <= n; ++i) a[i] += a[i - 1];
memset(f, -1, sizeof(f));
f[0][0] = 0;
z = n / k;
cout << get(n % k, k - n % k);
}
|
#include <bits/stdc++.h>
const long long MAX_N = 3e5 + 10;
const long long MOD = 1e9 + 7;
using namespace std;
int a[MAX_N];
int dp[5001][5001];
int n, k, x;
int main() {
cin >> n >> k;
for (int i = 1; i <= n; ++i) cin >> a[i];
sort(a + 1, a + n + 1);
int x = ceil(n / (double)k);
for (int i = 0; i <= 5000; ++i) {
if (x * i > n) break;
for (int j = 0; j <= 5000; ++j) {
if ((x - 1) * j + x * i > n) break;
if (!i and !j) continue;
int p = (x - 1) * j + x * i;
dp[i][j] = 2e9;
if (i) dp[i][j] = min(dp[i][j], a[p] - a[p - x + 1] + dp[i - 1][j]);
if (j) dp[i][j] = min(dp[i][j], a[p] - a[p - x + 2] + dp[i][j - 1]);
}
}
if (n % k == 0)
cout << dp[k][0];
else
cout << dp[n % k][k - (n % k)];
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
double const pi = 3.14159265358979;
int const MAXN = 2000000;
long long const MOD = 1000000007;
long long const INF = 1000000000000000000ll;
int a[1000000];
long long s[1000000];
long long d[2][5000];
long long sum(int l, int x) {
if (l + x - 1 > 300000) return 0;
return s[l + x - 1] - s[l];
}
int main() {
int n, k;
scanf("%d%d", &n, &k);
for (int i = 0; i < (int)(n); i++) {
scanf("%d", &a[i]);
}
sort(a, a + n);
for (int i = (int)1; i <= (int)(n - 1); i++) {
s[i] = s[i - 1] + abs(a[i] - a[i - 1]);
}
for (int i = (int)1; i <= (int)(k); i++) {
for (int j = 0; j < (int)(i + 1); j++) {
d[i % 2][j] = INF;
if (j <= i - 1) {
d[i % 2][j] =
min(d[i % 2][j],
d[(i - 1) % 2][j] +
sum(j * (n / k) + (i - 1 - j) * (n / k + 1), n / k + 1));
}
if (j > 0) {
d[i % 2][j] =
min(d[i % 2][j],
d[(i - 1) % 2][j - 1] +
sum((j - 1) * (n / k) + (i - j) * (n / k + 1), n / k));
}
}
}
cout << d[k % 2][k - n % k];
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, k;
int step, more;
long long arr[300010];
long long dp[5010][5010];
long long mem(int lev, int rem) {
if (lev == k - 1) return 0;
if (dp[lev][rem] != -1) return dp[lev][rem];
long long &ref = dp[lev][rem];
ref = 0;
int idx = lev * step + more - rem;
if (k - lev > rem)
ref = max(ref, mem(lev + 1, rem) + arr[idx + step] - arr[idx + step - 1]);
if (rem > 0)
ref =
max(ref, mem(lev + 1, rem - 1) + arr[idx + step + 1] - arr[idx + step]);
return ref;
}
int main() {
cin >> n >> k;
for (int i = 0; i < n; i++) cin >> arr[i];
sort(arr, arr + n);
memset(dp, -1, sizeof dp);
step = n / k;
more = n % k;
long long res = arr[n - 1] - arr[0] - mem(0, more);
cout << res << endl;
return 0;
}
|
#include <bits/stdc++.h>
constexpr long long inf = 1e18 + 7, N = 1e6 + 70;
using namespace std;
long long k, n, a[N], vis[N], psum[N], x, dp[5005][5005];
long long calc(long long i, long long j, long long pos) {
if (i < 0 || j < 0) return inf;
if (dp[i][j] != -1) return dp[i][j];
if (i == 0 && j == 0) return 0;
return dp[i][j] =
min(calc(i - 1, j, pos - x) + psum[pos] - psum[pos - x + 1],
calc(i, j - 1, pos - x - 1) + psum[pos] - psum[pos - x]);
}
int32_t main() {
ios::sync_with_stdio(0);
cin.tie(0);
long long n, k;
cin >> n >> k;
long long kk = n % k;
x = n / k;
memset(dp, -1, sizeof dp);
for (long long i = 1; i <= n; i++) cin >> a[i];
sort(a + 1, a + n + 1);
for (long long i = 2; i <= n; i++)
psum[i] = psum[i - 1] + abs(a[i] - a[i - 1]);
cout << calc(k - kk, kk, n);
}
|
#include <bits/stdc++.h>
using namespace std;
long long dp[5001][5001];
long long a[300005];
int main() {
int n, k, i, j;
cin >> n >> k;
for (i = 0; i <= k; i++)
for (j = 0; j <= k; j++) dp[i][j] = 1e10;
for (i = 1; i <= n; i++) cin >> a[i];
sort(a + 1, a + n + 1);
int small, large, sizesmall, sizelarge;
sizesmall = n / k;
sizelarge = n / k + 1;
large = n % k;
small = k - n % k;
dp[0][0] = 0;
for (i = 0; i <= small; i++) {
for (j = 0; j <= large; j++) {
if (i > 0) {
int index = (i - 1) * sizesmall + j * sizelarge;
dp[i][j] =
min(dp[i][j], dp[i - 1][j] + a[index + sizesmall] - a[index + 1]);
}
if (j > 0) {
int index = i * sizesmall + (j - 1) * sizelarge;
dp[i][j] =
min(dp[i][j], dp[i][j - 1] + a[index + sizelarge] - a[index + 1]);
}
}
}
cout << dp[small][large];
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = int(3e5) + 10, mod = int(1e9) + 7;
long long d[5005][5005];
int n, k, x[N], sm, lr;
long long calc(int a, int b) {
if (a == 0 && b == 0) return 0;
if (d[a][b] != -1) return d[a][b];
long long res = (long long)(1e18);
int i = a * lr + b * sm;
if (a > 0) {
res = min(res, calc(a - 1, b) + x[i] - x[i - lr + 1]);
}
if (b > 0) {
res = min(res, calc(a, b - 1) + x[i] - x[i - sm + 1]);
}
return d[a][b] = res;
}
int main() {
scanf("%d%d", &n, &k);
for (int i = 1; i <= n; i++) {
scanf("%d", &x[i]);
}
memset(d, -1, sizeof(d));
sort(x + 1, x + n + 1);
lr = n / k + 1;
sm = n / k;
printf("%lld\n", calc(n % k, k - n % k));
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 5009;
const long long oo = (long long)(1e15);
int a[(int)(3e5) + 10];
int n, k, m, t, block;
long long dp[N][N];
long long W[(int)(3e5) + 10];
int main() {
ios::sync_with_stdio(false);
cin >> n >> k;
for (int i = 1; i <= n; i++) cin >> a[i];
sort(a + 1, a + n + 1);
block = k;
m = n / k;
t = n % k;
W[1] = 0;
for (int i = 2; i <= n; i++) W[i] = W[i - 1] + (a[i] - a[i - 1]);
for (int i = 0; i <= block; i++)
for (int j = 0; j <= t; j++) dp[i][j] = oo;
dp[0][0] = 0;
for (int i = 1; i <= block; i++)
for (int j = 0; j <= min(i, t); j++) {
dp[i][j] = dp[i - 1][j] + W[i * m + j] - W[(i - 1) * m + j + 1];
if (j != 0)
dp[i][j] =
min(dp[i][j], dp[i - 1][j - 1] + W[i * m + j] - W[(i - 1) * m + j]);
}
cout << dp[block][t] << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
long long dp[5001][5001], a[300005];
int main() {
ios_base::sync_with_stdio(false);
int n, k, it;
cin >> n >> k;
for (int i = 1; i <= n; i++) cin >> a[i];
sort(a + 1, a + 1 + n);
memset(dp, 0x3f, sizeof(dp));
dp[0][0] = 0;
for (int i = 0; i <= k - n % k; i++)
for (int j = 0; j <= n % k; j++) {
it = j * (n / k + 1) + i * (n / k);
if (i)
dp[i][j] = min(dp[i][j], dp[i - 1][j] + abs(a[it] - a[it - n / k + 1]));
if (j)
dp[i][j] = min(dp[i][j], dp[i][j - 1] + abs(a[it] - a[it - n / k]));
}
cout << dp[k - n % k][n % k];
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 300300, M = 5050;
const long long oo = 1000000000000000000ll;
int i, j, k, n, m, ch, ff, t, l;
int a[N];
long long f[M][M];
void R(int &x) {
x = ff = 0;
ch = getchar();
while (ch < '0' || '9' < ch) {
if (ch == '-') ff = 1;
ch = getchar();
}
while ('0' <= ch && ch <= '9') x = x * 10 + ch - '0', ch = getchar();
if (ff) x = -x;
}
void W(long long x) {
if (x < 0) putchar('-'), x = -x;
if (x >= 10) W(x / 10);
putchar(x % 10 + '0');
}
int min(const int &x, const int &y) {
if (x < y) return x;
return y;
}
long long min(const long long &x, const long long &y) {
if (x < y) return x;
return y;
}
int main() {
R(n);
R(m);
memset(f, 60, sizeof f);
for (i = 1; i <= n; i++) R(a[i]);
sort(a + 1, a + n + 1);
t = n % m;
l = n / m;
f[0][0] = 0;
for (i = 0; i < m; i++)
for (j = min(t, i); j >= 0; j--)
if (f[i][j] < oo) {
f[i + 1][j] =
min(f[i + 1][j], f[i][j] + a[(i + 1) * l + j] - a[i * l + j + 1]);
if (j + 1 <= t)
f[i + 1][j + 1] =
min(f[i + 1][j + 1],
f[i][j] + a[(i + 1) * l + j + 1] - a[i * l + j + 1]);
}
W(f[m][t]);
puts("");
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 3e5 + 100;
const int maxK = 5000 + 10;
const long long INF = 1e18;
int a[maxn], n, k;
long long f[maxK][maxK];
long long gao(int i, int j, int len) {
int s = i * (n / k) + j * (n / k + 1) + 1;
int t = s + len - 1;
return a[t] - a[s];
}
void solve() {
sort(a + 1, a + 1 + n);
int ni = k - n % k;
int nj = n % k;
f[0][0] = 0;
for (int i = 0; i <= ni; i++) {
for (int j = 0; j <= nj; j++) {
if (i == 0 && j == 0) continue;
f[i][j] = INF;
if (i >= 1) {
f[i][j] = min(f[i][j], f[i - 1][j] + gao(i - 1, j, n / k));
}
if (j >= 1) {
f[i][j] = min(f[i][j], f[i][j - 1] + gao(i, j - 1, n / k + 1));
}
}
}
printf("%I64d\n", f[ni][nj]);
}
int main() {
while (scanf("%d%d", &n, &k) != EOF) {
for (int i = 1; i <= n; i++) scanf("%d", &a[i]);
solve();
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long a[300000 + 10];
long long x[300000 + 10];
long long mem[5050][5050], add, add2;
long long dp(int p, int q, int cur) {
if (p == 0 && q == 0) return 0;
long long &ret = mem[p][q], b;
if (ret != -1) return ret;
if (p) ret = x[cur + add - 1] - x[cur] + dp(p - 1, q, cur + add);
if (q) {
b = x[cur + add2 - 1] - x[cur] + dp(p, q - 1, cur + add2);
if (ret == -1)
ret = b;
else
ret = min(ret, b);
}
return ret;
}
int main() {
memset(mem, -1, sizeof(mem));
long long n, k;
cin >> n >> k;
for (long long i = 1; i <= n; i++) scanf("%I64d", a + i);
sort(a + 1, a + n + 1);
x[1] = 0;
for (long long i = 2; i <= n; i++) x[i] = x[i - 1] + a[i] - a[i - 1];
add = n / k;
add2 = add + 1;
cout << dp(k - (n % k), n % k, 1) << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
inline long long gtmn(long long &a, long long b) {
if (a > b) a = b;
}
int a[300010];
long long dp[5010][5010];
int main(void) {
int n, q;
scanf("%d%d", &n, &q);
for (int i = 1; i <= n; ++i) {
scanf("%d", &a[i]);
}
sort(&a[1], &a[n + 1]);
int sz = n / q, lge = n % q, sml = q - lge;
memset(dp, 63, sizeof(dp));
dp[0][0] = 0;
for (int i = 0; i < q; ++i) {
for (int j = 0; j <= lge; ++j) {
int stt = i * sz + j, lsm = q - i;
if (lsm) {
gtmn(dp[i + 1][j], dp[i][j] + a[stt + sz] - a[stt + 1]);
}
if (j != lge) {
gtmn(dp[i + 1][j + 1], dp[i][j] + a[stt + sz + 1] - a[stt + 1]);
}
}
}
printf("%I64d\n", dp[q][lge]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long A[400000];
long long inf = 1e16;
long long dp[5001][5001];
int n, k, nums, maxskips;
long long f(int pos, int skipped) {
int index = skipped + pos * nums;
if (pos > k || skipped > maxskips) return inf;
if (k == pos && skipped == maxskips) return 0;
if (dp[pos][skipped] != -1) return dp[pos][skipped];
long long o1 = inf, o2 = inf;
if (index + nums < n)
o1 = A[index + nums] - A[index] + f(pos + 1, skipped + 1);
if (index + nums - 1 < n)
o2 = A[index + nums - 1] - A[index] + f(pos + 1, skipped);
return dp[pos][skipped] = min(o1, o2);
}
int main(int argc, char const *argv[]) {
cin >> n >> k;
nums = n / k;
maxskips = n - nums * k;
int tmp;
for (int i = 0; i < n; i++) {
scanf("%d", &tmp);
A[i] = tmp;
}
sort(A, A + n);
memset(dp, -1, sizeof(dp));
cout << f(0, 0) << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const unsigned int INF = 2e9 + 239;
const int MAXN = 3e5 + 239;
const int MAXK = 5e3 + 239;
int a[MAXN];
unsigned int dp[MAXK][MAXK];
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
int n, k;
cin >> n >> k;
for (int i = 0; i < n; i++) {
cin >> a[i];
}
sort(a, a + n);
int len = n / k;
for (int i = 0; i < MAXK; i++) {
for (int j = 0; j < MAXK; j++) {
dp[i][j] = INF;
}
}
dp[0][0] = 0;
for (int i = 0; i < MAXK; i++) {
for (int j = 0; j < MAXK; j++) {
int st = len * i + j;
if (st + len <= n) {
int end = st + len;
dp[i + 1][j] = min(dp[i + 1][j], dp[i][j] + a[end - 1] - a[st]);
}
if (st + len + 1 <= n) {
int end = st + len + 1;
dp[i + 1][j + 1] = min(dp[i + 1][j + 1], dp[i][j] + a[end - 1] - a[st]);
}
}
}
cout << dp[k][n % k] << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long INF = 1e17;
const int N = 3e5 + 1;
long long dp[5555][5555], A[N];
int main() {
int n, k, i, j, t;
scanf("%d %d", &n, &k);
t = n / k;
for (i = 1; i <= n; i++) scanf("%I64d", A + i);
sort(A + 1, A + 1 + n);
for (i = 0; i <= k; i++)
for (j = 0; j <= k; j++) dp[i][j] = INF;
dp[0][0] = 0;
for (i = 1; i <= k; i++) {
for (j = 0; j <= i; j++) {
dp[i][j] = dp[i - 1][j] + abs(A[t * i + j] - A[t * i + j - t + 1]);
if (j)
dp[i][j] = min(dp[i][j],
dp[i - 1][j - 1] + abs(A[t * i + j] - A[t * i + j - t]));
}
}
cout << dp[k][n % k];
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int ara[300005], k, sz;
long long dp[5005][5005];
long long solve(int small, int big) {
if (dp[small][big] != -1) return dp[small][big];
if (!small)
return dp[small][big] =
solve(small, big - 1) +
(ara[big * (sz + 1) - 1] - ara[big * (sz + 1) - 1 - sz]);
if (!big)
return dp[small][big] = solve(small - 1, big) +
(ara[small * sz - 1] - ara[small * sz - sz]);
int total = big * (sz + 1) + small * sz;
return dp[small][big] = min(
solve(small - 1, big) + (ara[total - 1] - ara[total - sz]),
solve(small, big - 1) + (ara[total - 1] - ara[total - sz - 1]));
}
int main() {
int n, i;
scanf("%d", &n);
scanf("%d", &k);
memset(dp, -1, sizeof(dp));
for (i = 0; i < n; i++) scanf("%d", &ara[i]);
sort(ara, ara + n);
dp[0][0] = 0;
int s, b;
s = k - (n % k);
b = n % k;
sz = n / k;
cout << solve(s, b) << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 5005 + 19;
const int inf = 1e9 + 7;
int n, k;
long long dp[N][N];
long long a[500000 + 5];
int main() {
memset(dp, inf, sizeof(dp));
dp[0][0] = 0;
scanf("%d%d", &n, &k);
for (int i = 1; i <= n; i++) scanf("%I64d", a + i);
int len1 = (n / k) + 1;
int len2 = len1 - 1;
int num1 = (n % k);
int num2 = k - num1;
memset(dp, 0x3f, sizeof(dp));
dp[0][0] = 0;
sort(a + 1, a + n + 1);
for (int i = 0; i <= num1; i++) {
for (int j = 0; j <= num2; j++) {
if (i) {
int s, e;
s = j * len2 + (i - 1) * len1 + 1;
e = s + len1 - 1;
dp[i][j] = min(dp[i][j], dp[i - 1][j] + a[e] - a[s]);
}
if (j) {
int s, e;
s = (j - 1) * len2 + i * len1 + 1;
e = s + len2 - 1;
dp[i][j] = min(dp[i][j], dp[i][j - 1] + a[e] - a[s]);
}
}
}
printf("%I64d\n", dp[num1][num2]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
struct greater {
template <class T>
bool operator()(T const &a, T const &b) const {
return a > b;
}
};
int n, k;
int arr[400005];
unsigned long long res[5005][5005];
int main() {
scanf("%d %d", &n, &k);
for (int i = (0); (i) < (n); (i)++) {
scanf("%d ", &arr[i]);
}
for (int i = (0); (i) < (5005); (i)++) {
for (int j = (0); (j) < (5005); (j)++) {
res[i][j] = 9223372036854775806;
}
}
sort(arr, arr + n);
int t = (n - 1) / k;
int a = n % (t * k + 1) + 1;
int b = k - a;
res[0][0] = 0;
for (int i = (0); (i) < (a + 1); (i)++) {
for (int j = (0); (j) < (b + 1); (j)++) {
int basePos = i * (t + 1) + j * (t);
if (basePos + t < n) {
unsigned long long diff = abs(arr[basePos + t] - arr[basePos]);
res[i + 1][j] = min(res[i + 1][j], res[i][j] + diff);
}
if (basePos + t - 1 < n) {
unsigned long long diff = abs(arr[basePos + t - 1] - arr[basePos]);
res[i][j + 1] = min(res[i][j + 1], res[i][j] + diff);
}
}
}
printf("%I64d", res[a][b]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, k;
int a[300009];
long long dp[5009][5009];
long long Solve(int Lg, int Sg) {
int Sl = n / k;
int Ll = n / k + 1;
dp[0][0] = 0;
for (int cntSg = 1; cntSg <= Sg; cntSg++) {
dp[cntSg][0] = dp[cntSg - 1][0] + a[cntSg * Sl - 1] - a[(cntSg - 1) * Sl];
}
for (int cntLg = 1; cntLg <= Lg; cntLg++) {
dp[0][cntLg] = dp[0][cntLg - 1] + (a[cntLg * Ll - 1] - a[(cntLg - 1) * Ll]);
for (int cntSg = 1; cntSg <= Sg; cntSg++) {
dp[cntSg][cntLg] =
min(dp[cntSg - 1][cntLg] + a[cntLg * Ll + cntSg * Sl - 1] -
a[(cntSg - 1) * Sl + cntLg * Ll],
dp[cntSg][cntLg - 1] + a[cntLg * Ll + cntSg * Sl - 1] -
a[cntSg * Sl + (cntLg - 1) * Ll]);
}
}
return dp[Sg][Lg];
}
int main() {
scanf("%d %d", &n, &k);
for (int i = 0; i < n; i++) scanf("%d", &a[i]);
sort(a, a + n);
int G, g;
G = n % k;
g = k - G;
printf("%I64d", Solve(G, g));
}
|
#include <bits/stdc++.h>
using namespace std;
const long long mod = 1000000007;
long long powmod(long long a, long long b) {
long long res = 1;
a %= mod;
for (; b; b >>= 1) {
if (b & 1) res = res * a % mod;
a = a * a % mod;
}
return res;
}
int n, k;
long long dp[5005][5005];
vector<int> input;
int main() {
memset(dp, -1, sizeof(dp));
cin >> n >> k;
input.resize(n);
for (int i = 0; i < (int)n; i++) cin >> input[i];
sort(input.begin(), input.end());
long long dSum = 0;
for (int i = 0; i < (int)n - 1; i++) {
dSum += input[i + 1] - input[i];
}
int len1 = n / k;
int jLim = n % k + 1;
dp[0][0] = 0;
for (int i = 1; i < (int)k; i++) {
for (int j = 0; j < (int)jLim; j++) {
if (j == 0 && dp[i - 1][j] != -1)
dp[i][j] = dp[i - 1][j] + input[i * len1] - input[i * len1 - 1];
else {
long long l1 = (dp[i - 1][j - 1] != -1)
? dp[i - 1][j - 1] + input[i * len1 + j] -
input[i * len1 + j - 1]
: -1;
long long l2 =
(dp[i - 1][j] != -1)
? dp[i - 1][j] + input[i * len1 + j] - input[i * len1 + j - 1]
: -1;
dp[i][j] = max(l1, l2);
}
}
}
long long dSum1 = 0;
if (n % k) {
dSum1 = max(dp[k - 1][n % k], dp[k - 1][n % k - 1]);
} else {
dSum1 = dp[k - 1][0];
}
cout << dSum - dSum1 << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int inf = 1e9 + 10;
const long long INF = 1e18;
const int maxn = 3 * 1e5 + 5;
const int mod = 1e9 + 7;
int n, k;
int a[maxn];
long long d[5005][5005];
bool visit[5005][5005];
int lo, sh;
int idx(int L, int S) { return L * lo + S * sh - 1; }
long long dp(int L, int S) {
if (visit[L][S]) return d[L][S];
visit[L][S] = true;
d[L][S] = INF;
if (L > 0)
d[L][S] = min(d[L][S], dp(L - 1, S) + a[idx(L, S)] - a[idx(L - 1, S) + 1]);
if (S > 0)
d[L][S] = min(d[L][S], dp(L, S - 1) + a[idx(L, S)] - a[idx(L, S - 1) + 1]);
return d[L][S];
}
int MAIN() {
scanf("%d%d", &n, &k);
for (int i = 0; i < n; ++i) scanf("%d", &a[i]);
sort(a, a + n);
if (k == 1) {
printf("%d\n", a[n - 1] - a[0]);
return 0;
}
lo = n / k + 1, sh = n / k;
int r = n % k;
d[1][0] = a[lo - 1] - a[0];
d[0][1] = a[sh - 1] - a[0];
visit[1][0] = visit[0][1] = true;
printf("%I64d\n", dp(r, k - r));
return 0;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL), cout.tie(NULL);
cout << fixed << setprecision(16);
int ret = MAIN();
return ret;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxk = 5005;
const int maxn = 300005;
const long long huge = 10000000000000000LL;
int n, k;
int a[maxn];
long long dp[maxk][maxk];
long long pref[maxn];
int main(void) {
scanf("%d%d", &n, &k);
for (int i = 0; i < n; i++) scanf("%d", &a[i]);
sort(a, a + n);
for (int i = 1; i <= n; i++) {
pref[i] = pref[i - 1];
if (i > 1) pref[i] += a[i - 1] - a[i - 2];
}
int cnt1 = 0;
int cnt2 = 0;
int len1 = (n - 1) / k + 1;
int len2 = (n - 1) / k;
for (int i = 0; i < k; i++) {
int cnt = 0;
for (int j = i; j < n; j += k) cnt++;
if (cnt == len1)
cnt1++;
else
cnt2++;
}
for (int i = 0; i <= cnt1; i++)
for (int j = 0; j <= cnt2; j++) dp[i][j] = huge;
dp[0][0] = 0;
for (int i = 0; i <= cnt1; i++)
for (int j = 0; j <= cnt2; j++) {
if (i == cnt1 && j == cnt2) {
printf("%lld\n", dp[i][j]);
continue;
}
if (dp[i][j] == huge) continue;
int pos = i * len1 + j * len2 + 1;
dp[i + 1][j] =
min(dp[i + 1][j], dp[i][j] + pref[pos + len1 - 1] - pref[pos]);
dp[i][j + 1] =
min(dp[i][j + 1], dp[i][j] + pref[pos + len2 - 1] - pref[pos]);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long double eps = 1e-9;
const int inf = (1 << 30) - 1;
const long long inf64 = ((long long)1 << 62) - 1;
const long double pi = acos(-1);
template <class T>
T sqr(T x) {
return x * x;
}
template <class T>
T abs(T x) {
return x < 0 ? -x : x;
}
const int MAXN = 320 * 1000;
const int MAXK = 5500;
int a[MAXN];
int ans[MAXK][MAXK];
int main() {
int n, k;
scanf("%d%d", &n, &k);
for (int i = 0; i < n; ++i) {
scanf("%d", &a[i]);
}
sort(a, a + n);
ans[0][0] = 0;
int s1 = n / k;
int n1 = k - (n % k);
int s2 = (n + k - 1) / k;
int n2 = n % k;
for (int i = 0; i <= n1; ++i) {
for (int j = 0; j <= n2; ++j) {
if (i == 0 && j == 0) {
continue;
}
ans[i][j] = 2 * inf;
int tmp = i * s1 + j * s2;
if (i > 0) {
ans[i][j] = min(ans[i][j], (ans[i - 1][j] - a[tmp - s1]) + a[tmp - 1]);
}
if (j > 0) {
ans[i][j] = min(ans[i][j], (ans[i][j - 1] - a[tmp - s2]) + a[tmp - 1]);
}
}
}
printf("%d\n", ans[n1][n2]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 300005;
const int M = 5005;
const long long INF = 1LL << 62;
int a[N];
long long f[M][M], sum[N];
int main() {
int n, k;
scanf("%d %d", &n, &k);
for (int i = 0; i < n; ++i) scanf("%d", &a[i]);
int l = 0, n1 = 0, n2 = 0;
for (int i = 0; i < k; ++i) {
int t = 0;
for (int j = i; j < n; j += k) t++;
if (i == 0) {
n1 = 1;
l = t;
} else if (t == l)
n1++;
else
n2++;
}
sort(a, a + n);
k++;
sum[0] = 0;
for (int i = 1; i < n; ++i) sum[i] = sum[i - 1] + abs(a[i] - a[i - 1]);
for (int i = 0; i < M; ++i)
for (int j = 0; j < M; ++j) f[i][j] = INF;
f[0][0] = 0;
for (int i = 0; i <= n1; ++i) {
for (int j = 0; j <= n2; ++j) {
if (i == 0 && j == 0) {
f[i + 1][j] = sum[l - 1];
f[i][j + 1] = sum[l - 2];
continue;
}
int nxt = max(0, i * l + j * (l - 1));
int space = abs(a[nxt] - a[nxt - 1]);
if (i < n1) {
f[i + 1][j] = min(f[i + 1][j], f[i][j] + sum[nxt + l - 1] - sum[nxt]);
}
if (j < n2) {
f[i][j + 1] = min(f[i][j + 1], f[i][j] + sum[nxt + l - 2] - sum[nxt]);
}
}
}
printf("%I64d\n", f[n1][n2]);
return 0;
}
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.