text stringlengths 49 983k |
|---|
#include <bits/stdc++.h>
using namespace std;
int n, k;
int a[300005];
long long dp[5005][5005];
int main() {
int n, k;
scanf("%d%d", &n, &k);
int i, j;
int large = n % k;
int small = k - n % k;
int len = n / k;
for (i = 1; i <= n; i++) {
scanf("%d", a + i);
}
sort(a + 1, a + n + 1);
for (i = 0; i <= large + 1; i++) {
for (j = 0; j <= small + 1; j++) {
dp[i][j] = 1e15;
}
}
dp[0][0] = 0;
for (i = 0; i <= large; i++) {
for (j = 0; j <= small; j++) {
int cur = i * (len + 1) + j * (len) + 1;
if (i < large) {
int x = a[cur + len] - a[cur];
dp[i + 1][j] = min(dp[i + 1][j], dp[i][j] + x);
}
if (j < small) {
int x = a[cur + len - 1] - a[cur];
dp[i][j + 1] = min(dp[i][j + 1], dp[i][j] + x);
}
}
}
cout << dp[large][small];
}
|
#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) {
int p, q;
p = n - i;
q = k;
if (p % q)
return p / q + 1;
else
return p / q;
}
long long dfs(int k1, int k2) {
if ((k1 == T1) && (k2 == T2)) return 0;
if (d[k1][k2] >= 0) return d[k1][k2];
int ps = k1 * ZN1 + k2 * ZN2;
d[k1][k2] = oo;
if (k1 < T1) d[k1][k2] = dfs(k1 + 1, k2) + a[ps + ZN1 - 1] - a[ps];
if (k2 < T2)
d[k1][k2] = min(d[k1][k2], dfs(k1, k2 + 1) + a[ps + ZN2 - 1] - a[ps]);
return d[k1][k2];
}
int main() {
int i, j, kl;
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;
cout << dfs(0, 0);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long ways(long long from, long long to) {
return ((to + 1) * (to + 2) - from * (from + 1)) / 2;
}
int main() {
int n, k, l, nb, nc;
cin >> n >> k;
l = n / k;
nc = n % k;
nb = k - nc;
vector<long long> a(n), b(n - l + 1), c(n - l), d(n - 1);
for (__typeof(n) i = 0; i < n; ++i) cin >> a[i];
sort(a.begin(), a.end());
for (__typeof(n - 1) i = 0; i < n - 1; ++i)
d[i] = (((a[i] - a[i + 1]) < 0) ? -(a[i] - a[i + 1]) : (a[i] - a[i + 1]));
for (__typeof(l - 1) i = 0; i < l - 1; ++i) b[0] += d[i];
for (__typeof(n - l + 1) i = 1; i < n - l + 1; ++i) {
b[i] = b[i - 1] - d[i - 1] + d[i + l - 2];
}
for (__typeof(n - l) i = 0; i < n - l; ++i) c[i] = b[i] + d[i + l - 1];
vector<vector<int>> dp(nb + 1, vector<int>(nc + 1));
dp[0][0] = 0;
for (__typeof(nb) i = 0; i < nb; ++i) {
dp[i + 1][0] = dp[i][0] + b[i * l];
}
for (__typeof(nc) i = 0; i < nc; ++i) {
dp[0][i + 1] = dp[0][i] + c[i * (l + 1)];
}
for (__typeof(nb) i = 0; i < nb; ++i) {
for (__typeof(nc) j = 0; j < nc; ++j) {
dp[i + 1][j + 1] = ((dp[i][j + 1] + b[i * l + (j + 1) * (l + 1)]) >
(dp[i + 1][j] + c[(i + 1) * l + j * (l + 1)])
? (dp[i + 1][j] + c[(i + 1) * l + j * (l + 1)])
: (dp[i][j + 1] + b[i * l + (j + 1) * (l + 1)]));
}
}
cout << dp[nb][nc] << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, k;
int sz;
long long int a[312345];
int main() {
scanf("%d %d", &n, &k);
sz = n / k;
int L = n % k;
int S = k - L;
for (int i = 1; i <= n; i++) scanf("%I64d", &a[i]);
sort(a + 1, a + 1 + n);
map<pair<int, int>, long long int> m;
map<pair<int, int>, long long int>::iterator mi;
m[make_pair(1, 0)] = 0;
long long int ans = 1e18;
ans += 5;
while (m.size()) {
int pos = m.begin()->first.first;
int l = m.begin()->first.second;
int s = (pos - l * (sz + 1) - 1) / sz;
long long int cost = m.begin()->second;
m.erase(m.begin());
if (pos == n + 1) {
ans = min(ans, cost);
continue;
}
if (l < L) {
int ll = l + 1, ss = s;
int pp = pos + sz + 1;
pair<int, int> x = make_pair(pp, ll);
mi = m.find(x);
if (mi == m.end())
m[x] = cost + (a[pp - 1] - a[pos]);
else
mi->second = min(mi->second, cost + (a[pp - 1] - a[pos]));
}
if (s < S) {
int ll = l, ss = s + 1;
int pp = pos + sz;
pair<int, int> x = make_pair(pp, ll);
mi = m.find(x);
if (mi == m.end())
m[x] = cost + (a[pp - 1] - a[pos]);
else
mi->second = min(mi->second, cost + (a[pp - 1] - a[pos]));
}
}
printf("%I64d\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, k, b[300005], l1, l2, num1, num2;
int dp[5005][5005];
int main() {
scanf("%d%d", &n, &k);
for (int i = 1; i <= n; i++) scanf("%d", &b[i]);
sort(b + 1, b + n + 1);
l1 = n / k;
l2 = l1 + 1;
num2 = n % k;
num1 = k - num2;
for (int i = 0; i <= num1; i++)
for (int j = 0; j <= num2; j++) {
if (i + j == 0) continue;
int t1 = 0x7fffffff, t2 = 0x7fffffff;
if (j != 0) {
t1 = dp[i][j - 1] + b[i * l1 + j * l2] - b[i * l1 + j * l2 - l2 + 1];
}
if (i != 0) {
t2 = dp[i - 1][j] + b[i * l1 + j * l2] - b[i * l1 + j * l2 - l1 + 1];
}
dp[i][j] = min(t1, t2);
}
cout << dp[num1][num2] << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const double pi =
3.141592653589793238462643383279502884197169399375105820974944592307816406286208998628034825342;
int A[300010];
long long dp[2][5010][2];
int main() {
long long res = 0;
int n, k;
scanf("%d%d", &n, &k);
for (int i = 0; i < (n); ++i) {
scanf("%d", &A[i]);
res += abs(A[i]);
}
sort(A, A + n);
int dl = n / k;
if (!(n % k)) {
res = 0;
int p = 0;
for (int i = 0; i < (k); ++i) {
res += A[p + dl - 1] - A[p];
p += dl;
}
printf("%lld\n", res);
return 0;
}
for (int i = 0; i < (2); ++i)
for (int j = 0; j < (5010); ++j)
for (int z = 0; z < (2); ++z) dp[i][j][z] = res;
int ile = n % k;
dp[0][0][0] = A[dl - 1] - A[0];
dp[0][0][1] = A[dl] - A[0];
for (int i = (1); i < (k); ++i) {
int wsk = i & 1;
int p = i * dl;
int v = A[p + dl - 1] - A[p];
dp[wsk][0][0] = v + dp[!wsk][0][0];
v = A[p + dl] - A[p];
dp[wsk][0][1] = v + dp[!wsk][0][0];
for (int j = (1); j < (min(ile, i + 1)); ++j) {
p = j * (dl + 1) + (i - j) * dl;
v = A[p + dl - 1] - A[p];
dp[wsk][j][0] = v + min(dp[!wsk][j][0], dp[!wsk][j - 1][1]);
v = A[p + dl] - A[p];
dp[wsk][j][1] = v + min(dp[!wsk][j][0], dp[!wsk][j - 1][1]);
}
if (i >= ile) {
p = ile * (dl + 1) + (i - ile) * dl;
v = A[p + dl - 1] - A[p];
dp[wsk][ile][0] = v + min(dp[!wsk][ile][0], dp[!wsk][ile - 1][1]);
}
}
int wsk = (k - 1) & 1;
printf("%lld\n", min(dp[wsk][ile][0], dp[wsk][ile - 1][1]));
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
class node {
public:
long long int second;
long long int length;
};
void FastIO() {
ios_base::sync_with_stdio(0);
cin.tie(NULL);
cout.tie(NULL);
}
long long int a[3 * 100001], ans[3 * 100001], mem[5001][5001];
long long int n, k, i, j, small, large, small_length, large_length;
long long int DP(long long int s, long long int l) {
if (s == 0 && l == 0) return 0;
if (s < 0 || l < 0) return 10000000000;
if (mem[s][l] != -1) return mem[s][l];
long long int first = ans[s * small_length + l * large_length - 1] -
ans[(s - 1) * small_length + l * large_length];
long long int second = ans[s * small_length + l * large_length - 1] -
ans[(s)*small_length + (l - 1) * large_length];
mem[s][l] = min(DP(s - 1, l) + first, DP(s, l - 1) + second);
return mem[s][l];
}
int main() {
FastIO();
cin >> n >> k;
for (i = 0; i < n; i++) cin >> a[i];
for (i = 0; i < 5001; i++) {
for (j = 0; j < 5001; j++) mem[i][j] = -1;
}
sort(a, a + n);
ans[0] = 0;
for (i = 1; i < n; i++) ans[i] = a[i] - a[i - 1] + ans[i - 1];
small_length = n / k;
large_length = n / k + 1;
large = n % k;
small = k - large;
cout << DP(small, large) << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long a[300005], dp[5005][5005];
long long min(long long a, long long b) { return a < b ? a : b; }
int main() {
int n, k, q, r;
long long sum = 0LL;
ios::sync_with_stdio(0);
cin >> n >> k;
for (int i = 0; i < n; i++) cin >> a[i];
sort(a, a + n);
q = n / k;
r = n % k;
if (r) {
memset(dp, 0x33, sizeof dp);
dp[0][0] = 0LL;
for (int i = 1; i <= k; i++)
for (int j = 0; j <= r; j++) {
if (j > i) break;
long long pos = q * i + j;
long long add = a[pos - 1] - a[pos - q];
dp[i][j] = min(dp[i][j], dp[i - 1][j] + add);
if (j) {
add = a[pos - 1] - a[pos - q - 1];
dp[i][j] = min(dp[i][j], dp[i - 1][j - 1] + add);
}
}
sum = dp[k][r];
} else {
for (int i = 0, s = 0; i < k; i++, s += q) sum += a[s + q - 1] - a[s];
}
cout << sum << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int i, j, k, n;
int a[300005];
void solve(int x, int y) {
int f[x + 5][y + 5], sum = a[n] - a[1];
memset(f, 0, sizeof(f));
for (int i = 0; i <= x; i++)
for (int j = 0; j <= y; j++) {
int w = i * (n / k) + j * (n / k + 1);
if (i) f[i][j] = max(f[i][j], f[i - 1][j] + a[w + 1] - a[w]);
if (j) f[i][j] = max(f[i][j], f[i][j - 1] + a[w + 1] - a[w]);
}
printf("%d\n", sum - max(f[x - 1][y], f[x][y - 1]));
return;
}
int main() {
scanf("%d%d", &n, &k);
for (i = 1; i <= n; i++) scanf("%d", &a[i]);
a[0] = a[1], a[n + 1] = a[n];
sort(a + 1, a + n + 1);
solve(k - n % k, n % k);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 5010, INF = 2000 * 1000 * 1000 + 10;
int d[N][N], a[300100];
int main() {
ios_base::sync_with_stdio(0), cin.tie(0), cout.tie(0);
int n, k;
cin >> n >> k;
for (int i = 0; i < n; i++) {
cin >> a[i];
}
sort(a, a + n);
int x = n % k, y = k - x, l = n / k;
for (int i = 0; i <= y; i++) {
for (int j = 0; j <= x; j++) {
if (i || j) {
d[i][j] = INF;
}
if (j) {
d[i][j] = min(d[i][j], d[i][j - 1] + (a[l * i + (l + 1) * j - 1] -
a[l * i + (l + 1) * (j - 1)]));
}
if (i) {
d[i][j] = min(d[i][j], d[i - 1][j] + (a[l * i + (l + 1) * j - 1] -
a[l * (i - 1) + (l + 1) * j]));
}
}
}
cout << d[y][x] << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long MAXV = 5500;
const long long MAXN = 5e5 + 5;
const long long INF = 2e18;
long long a[MAXN + 1];
long long ans[MAXV + 2][MAXV + 2];
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 l1 = n / k;
long long l2 = l1 + 1;
long long ct2 = n % k;
long long ct1 = k - ct2;
for (long long i = 0; i <= ct1; i++) {
for (long long j = 0; j <= ct2; j++) {
ans[i][j] = INF;
}
}
ans[0][0] = 0;
for (long long i = 0; i <= ct1; i++) {
for (long long j = 0; j <= ct2; j++) {
if (i < ct1) {
long long s1 = a[(i + 1) * l1 + j * l2 - 1] - a[i * l1 + j * l2];
ans[i + 1][j] = min(ans[i + 1][j], ans[i][j] + s1);
}
if (j < ct2) {
long long s2 = a[(i + 1) * l1 + j * l2] - a[i * l1 + j * l2];
ans[i][j + 1] = min(ans[i][j + 1], ans[i][j] + s2);
}
}
}
cout << ans[ct1][ct2];
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int a[300005];
int n, k;
long long dp[2][10005];
int main() {
scanf("%d%d", &n, &k);
for (int i = 0; i < n; i++) scanf("%d", &a[i]);
sort(a, a + n);
int z = n % k, x = n / k;
a[n] = a[n - 1];
int id = 0;
for (int i = 1; i <= k; i++, id = !id) {
int ri = min(n, i * x + min(i, z));
for (int j = x * i, sum = 1; j <= ri; j++, sum++)
dp[!id][sum] = max(dp[id][sum], dp[id][sum - 1]) + abs(a[j] - a[j - 1]);
}
long long ans = 0;
for (int i = 1; i < n; i++) ans += abs(a[i] - a[i - 1]);
ans -= dp[id][z + 1];
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long inf = 1e18;
const int maxn = 300000 + 30;
int n, k;
long long a[maxn];
long long dp[5050][5050];
int main() {
scanf("%d%d", &n, &k);
for (int i = 1; i <= n; i++) scanf("%lld", &a[i]);
sort(a + 1, a + n + 1);
int t1 = k - n % k;
int t2 = n % k;
int len1 = n / k, len2 = n / k + 1;
for (int i = 0; i <= t1; i++)
for (int j = 0; j <= t2; j++) dp[i][j] = inf;
dp[0][0] = 0;
for (int i = 0; i <= t1; i++)
for (int j = 0; j <= t2; j++) {
if (i && j)
dp[i][j] = min(dp[i][j], min(dp[i - 1][j] + a[i * len1 + j * len2] -
a[(i - 1) * len1 + j * len2 + 1],
dp[i][j - 1] + a[i * len1 + j * len2] -
a[i * len1 + (j - 1) * len2 + 1]));
else if (j)
dp[i][j] = min(dp[i][j], dp[i][j - 1] + a[i * len1 + j * len2] -
a[i * len1 + (j - 1) * len2 + 1]);
else if (i)
dp[i][j] = min(dp[i][j], dp[i - 1][j] + a[i * len1 + j * len2] -
a[(i - 1) * len1 + j * len2 + 1]);
}
printf("%lld\n", dp[t1][t2]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXK = 5010;
long long dp[MAXK][MAXK];
const int MAXN = 300010;
long long a[MAXN];
int n, k, ssz, lsz;
long long rec(int n, int l) {
if (dp[n][l] >= 0) return dp[n][l];
long long& res = dp[n][l];
res = 2000000010;
if (n == 1) {
if (l == 1) {
res = a[lsz - 1] - a[0];
} else {
res = a[ssz - 1] - a[0];
}
} else {
int s = n - l;
if (l > 0) {
res = min(res, rec(n - 1, l - 1) + a[ssz * s + lsz * l - 1] -
a[ssz * s + lsz * (l - 1)]);
}
if (s > 0) {
res = min(res, rec(n - 1, l) + a[ssz * s + lsz * l - 1] -
a[ssz * (s - 1) + lsz * l]);
}
}
return res;
}
int main() {
scanf("%d%d", &n, &k);
for (int i = 0; i < (int)(n); i++) scanf("%I64d", &a[i]);
sort(a, a + n);
int tgrps = k;
int lgrps = n - k * (n / k);
ssz = n / k;
lsz = n / k + 1;
memset(dp, -1, sizeof dp);
cout << rec(tgrps, lgrps) << endl;
return 0;
}
|
#include <bits/stdc++.h>
int a[500005], f[5005][5005];
int n, K;
int read() {
int t = 0, f = 1;
char ch = getchar();
while (ch < '0' || ch > '9') {
if (ch == '-') f = -1;
ch = getchar();
}
while ('0' <= ch && ch <= '9') {
t = t * 10 + ch - '0';
ch = getchar();
}
return t * f;
}
int main() {
n = read();
K = read();
for (int i = 1; i <= n; i++) a[i] = read();
std::sort(a + 1, a + 1 + n);
int num1 = n % K, len1 = n / K + 1;
int num2 = K - n % K, len2 = n / K;
a[0] = a[1];
for (int i = 0; i <= num1; i++)
for (int j = 0; j <= num2; j++) {
if (i) {
int k = (i - 1) * len1 + j * len2;
f[i][j] = std::max(f[i][j], f[i - 1][j] + a[k + 1] - a[k]);
}
if (j) {
int k = i * len1 + (j - 1) * len2;
f[i][j] = std::max(f[i][j], f[i][j - 1] + a[k + 1] - a[k]);
}
}
printf("%d\n", a[n] - a[1] - f[num1][num2]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long a[500007], dp[5007][5007];
int main() {
int n, k;
cin >> n >> k;
int res = n % k, len = n / k;
for (int i = 1; i <= n; ++i) cin >> a[i];
sort(a + 1, a + n + 1);
memset(dp, 0x3f, sizeof dp);
dp[0][0] = 0;
for (int i = 1; i <= k; ++i)
for (int j = 0; j <= res; ++j) {
dp[i][j] = dp[i - 1][j] + a[i * len + j] - a[(i - 1) * len + j + 1];
if (j)
dp[i][j] = min(
dp[i][j], dp[i - 1][j - 1] + a[i * len + j] - a[(i - 1) * len + j]);
}
cout << dp[k][res] << endl;
}
|
#include <bits/stdc++.h>
#pragma comment(linker, "/stack:32000000")
using namespace std;
const int INF = 2147483647;
const long long LLINF = 9223372036854775807LL;
const long long cinf = 1e18;
const int maxn = 5010;
long long dp[maxn];
int main() {
int n, k;
scanf("%d%d", &n, &k);
int shlen = n / k;
int llen = (n + k - 1) / k;
int lcnt = n % k;
int shcnt = k - lcnt;
vector<int> a(n);
for (int i = 0; i < n; ++i) scanf("%d", &a[i]);
sort(a.begin(), a.end());
for (int i = 0; i < maxn; ++i) dp[i] = -cinf;
dp[0] = 0;
for (int i = 1; i <= k; ++i) {
for (int j = i; j >= 0; --j) {
int lst = (i - j) * shlen + j * llen - 1;
if (lst >= n) continue;
int st = lst - shlen + 1;
if (st >= 0) {
int add = 0;
if (st > 0) add = a[st] - a[st - 1];
if (dp[j] != -cinf) dp[j] += add;
} else
dp[j] = -cinf;
if (j) {
st = lst - llen + 1;
int add = 0;
if (st >= 0) {
if (st > 0) add = a[st] - a[st - 1];
}
if (dp[j - 1] != -cinf) dp[j] = max(dp[j], dp[j - 1] + add);
}
}
}
long long ans = 0;
for (int i = 0; i < n - 1; ++i) ans += a[i + 1] - a[i];
ans -= dp[lcnt];
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
long long int n, k;
cin >> n >> k;
long long int *arr = new long long int[n];
for (long long int i = 0; i < n; i++) cin >> arr[i];
sort(arr, arr + n);
long long int part = n / k;
long long int large = n % k;
long long int dp[large + 1][k - large + 1];
for (long long int i = 0; i <= large; i++)
for (long long int j = 0; j <= k - large; j++) dp[i][j] = 2 * 1e9;
dp[0][0] = 0;
for (long long int i = 0; i <= large; i++) {
for (long long int j = 0; j <= k - large; j++) {
long long int x = i * (part + 1) + j * part;
if (i < large) {
dp[i + 1][j] = min(dp[i + 1][j], dp[i][j] + arr[x + part] - arr[x]);
}
if (j < k - large) {
dp[i][j + 1] = min(dp[i][j + 1], dp[i][j] + arr[x + part - 1] - arr[x]);
}
}
}
cout << dp[large][k - large] << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int A[300010];
long long best[5010][5010];
int main() {
int N, K, x, y, lx, ly;
int hop;
scanf("%d%d", &N, &K);
for (int i = (0); i < (N); i++) scanf("%d", A + i);
sort(A, A + N);
x = N % K;
y = K - x;
ly = N / K;
lx = ly + 1;
best[0][0] = 0;
for (int i = (0); i < (x + 1); i++)
for (int j = (0); j < (y + 1); j++) {
if (i == 0 && j == 0) continue;
best[i][j] = 2000000000000000LL;
hop = lx * i + ly * j - 1;
if (i) {
best[i][j] =
min(best[i][j], best[i - 1][j] + (A[hop] - A[hop - lx + 1]));
}
if (j) {
best[i][j] =
min(best[i][j], best[i][j - 1] + (A[hop] - A[hop - ly + 1]));
}
}
printf("%I64d\n", best[x][y]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, k;
int m = 0;
int arr[300009];
long long dp[5009][5009];
long long par[300009];
long long calc(int a, int b) {
long long &ans = dp[a][b];
if (ans != -1) return ans;
ans = INT_MAX;
if (a == 0 && b == 0) {
ans = 0;
return ans;
}
if (a != 0) {
int l = (a - 1) * (m + 1) + b * m;
int r = l + (m + 1);
ans = min(ans, par[r - 1] - par[l] + calc(a - 1, b));
}
if (b != 0) {
int l = (a) * (m + 1) + (b - 1) * m;
int r = l + m;
ans = min(ans, par[r - 1] - par[l] + calc(a, b - 1));
}
return ans;
}
int main() {
cin >> n >> k;
for (int i = 1; i <= n; i++) cin >> arr[i];
sort(arr + 1, arr + n + 1);
int a = n % k;
int b = k - a;
m = n / k;
memset(dp, -1, sizeof dp);
for (int i = 1; i <= n; i++) par[i] = abs(arr[i + 1] - arr[i]) + par[i - 1];
cout << calc(a, b) << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int N, K;
signed long long A[303030];
signed long long dp[5050][5050];
void solve() {
int i, j, k, l, r, x, y;
string s;
cin >> N >> K;
for (i = 0; i < N; i++) cin >> A[i];
sort(A, A + N);
int step = N / K;
int large = N % K, small = K - large;
memset(dp, 0x7f, sizeof(dp));
dp[0][0] = 0;
for (x = 0; x < large + 1; x++)
for (y = 0; y < small + 1; y++) {
int pos = x * (step + 1) + y * step;
if (x < large)
dp[x + 1][y] = min(dp[x + 1][y], dp[x][y] + A[pos + step] - A[pos]);
if (y < small)
dp[x][y + 1] = min(dp[x][y + 1], dp[x][y] + A[pos + step - 1] - A[pos]);
}
cout << dp[large][small] << endl;
}
int main(int argc, char** argv) {
string s;
int i;
if (argc == 1) ios::sync_with_stdio(false);
for (i = 0; i < argc - 1; i++) s += argv[i + 1], s += '\n';
for (i = 0; i < s.size(); i++) ungetc(s[s.size() - 1 - i], stdin);
solve();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 3e5 + 10;
int n, k;
int a[N];
long long s[3000010], dp[5010][5010];
int main() {
scanf("%d%d", &n, &k);
int cnt = n / k;
for (int i = 0; i < n; i++) {
scanf("%d", &a[i]);
}
sort(a, a + n);
for (int i = 1; i < n; i++) s[i] = s[i - 1] + a[i] - a[i - 1];
memset(dp, 63, sizeof(dp));
dp[0][0] = 0;
int m = n % k, len = k - m;
for (int i = 0; i <= len; i++)
for (int j = 0; j <= m; j++) {
int x = (i + j) * cnt + j;
dp[i + 1][j] = min(dp[i + 1][j], dp[i][j] + s[x + cnt - 1] - s[x]);
dp[i][j + 1] = min(dp[i][j + 1], dp[i][j] + s[x + cnt] - s[x]);
}
printf("%I64d\n", dp[len][m]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long int dp[5009][5009];
int p, x, y, a[300009];
long long int memoize(int i, int j) {
if (i == x && y == j) return 0;
if (dp[i][j] != -1) return dp[i][j];
long long int ans = 20000000 * 1ll * 20000000;
int idx = i * (p + 1) + j * p;
if (i < x) {
ans = min(ans, a[idx + p] - a[idx] + memoize(i + 1, j));
}
if (j < y) {
ans = min(ans, a[idx + p - 1] - a[idx] + memoize(i, j + 1));
}
return dp[i][j] = ans;
}
int main() {
memset(dp, -1, sizeof(dp));
int n, k;
scanf("%d", &n);
scanf("%d", &k);
for (int i = int(0); i <= int(n - 1); i++) scanf("%d", &a[i]);
sort(a, a + n);
p = n / k;
x = n % k;
y = k - x;
long long int ans = memoize(0, 0);
printf("%lld\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 300005;
const long long INF = 0x3f3f3f3f3f3f3f3f;
int n, k;
long long ori[maxn];
long long dp[5005][5005];
long long ans;
int main() {
while (~scanf("%d%d", &n, &k)) {
ans = 0;
for (int i = 1; i <= n; i++) scanf("%I64d", ori + i);
sort(ori + 1, ori + 1 + n);
memset(dp, 0x3f, sizeof(dp));
dp[0][0] = 0;
int large = n / k + 1;
int small = n / k;
int cntl = n % k;
int cnts = k - n % k;
int qian, hou;
for (int i = 0; i <= cntl; i++) {
for (int j = 0; j <= cnts; j++) {
if (i > 0) {
qian = (i - 1) * large + j * small + 1;
hou = (i)*large + j * small;
dp[i][j] = min(dp[i][j], dp[i - 1][j] + ori[hou] - ori[qian]);
}
if (j > 0) {
qian = i * large + (j - 1) * small + 1;
hou = i * large + j * small;
dp[i][j] = min(dp[i][j], dp[i][j - 1] + ori[hou] - ori[qian]);
}
}
}
cout << dp[cntl][cnts] << "\n";
}
}
|
#include <bits/stdc++.h>
using namespace std;
int n, k;
long long a[300010];
long long dp[5000][5000];
int main() {
while (cin >> n >> k) {
for (int i = 1; i <= n; i++) scanf("%I64d", &a[i]);
sort(a + 1, a + n + 1);
long long sum = 0;
int n2 = n - n / k * k;
int n1 = k - n2;
for (int i = 0; i <= n1; i++)
for (int j = 0; j <= n2; j++) dp[i][j] = 999999999999;
dp[0][0] = 0;
for (int i = 0; i <= n1; i++)
for (int j = 0; j <= n2; j++) {
if (i > 0)
dp[i][j] =
min(dp[i][j], dp[i - 1][j] + a[i * (n / k) + j * (n / k + 1)] -
a[(i - 1) * (n / k) + j * (n / k + 1) + 1]);
if (j > 0)
dp[i][j] =
min(dp[i][j], dp[i][j - 1] + a[i * (n / k) + j * (n / k + 1)] -
a[(i) * (n / k) + (j - 1) * (n / k + 1) + 1]);
}
printf("%I64d\n", dp[n1][n2]);
}
}
|
#include <bits/stdc++.h>
using namespace std;
long long dp[5010][5010];
int n, k, a, b, x, y, z[300010];
long long inf = 1e18;
int main() {
while (scanf("%d %d", &n, &k) != EOF) {
for (int i = 1; i <= n; i++) scanf("%d", &z[i]);
sort(z + 1, z + n + 1);
x = n / k;
y = n / k + 1;
b = n - k * x;
a = k - b;
dp[1][0] = z[y] - z[1];
dp[1][1] = z[x] - z[1];
for (int i = 2; i <= a + b; i++) {
for (int j = 0; j <= min(a, i); j++) {
if (i == j) {
dp[i][j] = dp[i - 1][j - 1] + (long long)z[(i - 1) * x + x] -
z[(i - 1) * x + 1];
} else {
int tmp = j * x + (i - 1 - j) * y;
if (tmp + y <= n)
dp[i][j] = dp[i - 1][j] + (long long)z[tmp + y] - z[tmp + 1];
else
dp[i][j] = inf;
if (j > 0) {
tmp = (j - 1) * x + (i - j) * y;
if (tmp + x <= n)
dp[i][j] = min(dp[i][j], dp[i - 1][j - 1] +
(long long)z[tmp + x] - z[tmp + 1]);
}
}
}
}
printf("%I64d\n", dp[a + b][a]);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 300005;
const int K = 5005;
const int INF = numeric_limits<int>::max();
int dp[K][K], a[N], n, k, i, j, smallChains, bigChains, chainLength;
int main() {
scanf("%d %d", &n, &k);
for (i = 1; i <= n; ++i) {
scanf("%d", a + i);
}
sort(a + 1, a + n + 1);
bigChains = n % k;
smallChains = k - bigChains;
chainLength = n / k;
for (i = 0; i <= smallChains; ++i) {
for (j = 0; j <= bigChains; ++j) {
if (!i && !j) continue;
dp[i][j] = INF;
if (i) {
dp[i][j] = dp[i - 1][j] + a[(i + j) * chainLength + j] -
a[(i + j - 1) * chainLength + j + 1];
}
if (j) {
dp[i][j] = min(dp[i][j - 1] + a[(i + j) * chainLength + j] -
a[(i + j - 1) * chainLength + j],
dp[i][j]);
}
}
}
printf("%d", dp[smallChains][bigChains]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long n, k;
long long a[300010];
long long dp[5005][5005];
signed main() {
scanf("%lld %lld", &n, &k);
for (long long i = 0; i < n; i++) {
scanf("%lld", &a[i]);
}
sort(a, a + n);
for (long long i = 0; i <= k; i++)
for (long long j = 0; j <= k; j++) dp[i][j] = 1e18;
dp[0][0] = 0;
for (long long S = 0; S <= k - n % k; S++) {
for (long long L = 0; L <= n % k; L++) {
long long pos = L * ((n / k) + 1) + S * (n / k);
if (S < k - n % k) {
dp[L][S + 1] =
min(dp[L][S + 1], dp[L][S] + a[pos + n / k - 1] - a[pos]);
}
if (L < n % k) {
dp[L + 1][S] = min(dp[L + 1][S], dp[L][S] + a[pos + n / k] - a[pos]);
}
}
}
printf("%lld", dp[n % k][k - n % k]);
}
|
#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], pre[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] = pre[i];
if (i == sh - 1 && r == 0) return d[i][r] = pre[i];
long long ret = INF;
if (check(i - lo, r - 1))
ret = min(ret, dp(i - lo, r - 1) + pre[i] - pre[i - lo + 1]);
if (check(i - sh, r))
ret = min(ret, dp(i - sh, r) + pre[i] - pre[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) {
long long tot = 0;
for (int i = 1; i < n; ++i) tot += abs(a[i] - a[i - 1]);
printf("%I64d\n", tot);
return 0;
}
lo = (n - 1) / k + 1;
sh = (n - k) / k + 1;
int r = 0;
for (int i = 0; i < k; ++i) {
if (i + k * (lo - 1) < n) ++r;
}
for (int i = 1; i < n; ++i) pre[i] = pre[i - 1] + abs(a[i] - a[i - 1]);
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 long long N = 5e3 + 5, mod = 1e9 + 7, mod1 = 998244353, mod2 = 1e9 + 9,
inf = 1e18 + 7;
const long long infll = 1e18 + 7;
long long n, k, X, Y, Z;
long long a[(long long)3e5 + 5];
long long dp[N][N];
signed main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> n >> k;
Y = n % k;
X = k - Y;
Z = n / k;
for (long long i = 1; i <= n; i++) {
cin >> a[i];
}
sort(a + 1, a + 1 + n);
for (long long i = 0; i <= X; i++) {
for (long long j = 0; j <= Y; j++) {
if (i == 0 && j == 0) {
dp[i][j] = 0;
continue;
}
dp[i][j] = inf;
long long t = i * Z + j * (Z + 1);
if (i) {
dp[i][j] = min(dp[i][j], dp[i - 1][j] + a[t] - a[t - Z + 1]);
}
if (j) {
dp[i][j] = min(dp[i][j], dp[i][j - 1] + a[t] - a[t - Z]);
}
}
}
cout << dp[X][Y];
}
|
#include <bits/stdc++.h>
using namespace std;
int n, k;
long long a[300005], pr[300005];
long long get(int l, int r) { return pr[r] - pr[l]; }
long long dp[5005][5005];
const long long oo = 2e18 + 11;
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cin >> n >> k;
for (int i = 0; i < n; i++) cin >> a[i];
sort(a, a + n);
int n1 = 0, m = 0;
for (int i = 0; i < k; i++) {
int cc = 0;
for (int j = 0; i + j * k < n; j++) cc++;
if (i == 0) m = cc;
if (cc == m) n1++;
}
int n2 = k - n1;
for (int i = 0; i < n; i++) {
pr[i + 1] = pr[i];
if (i != 0) pr[i + 1] += a[i] - a[i - 1];
}
for (int i = 0; i <= n1; i++) {
for (int j = 0; j <= n2; j++) dp[i][j] = oo;
}
dp[0][0] = 0;
for (int i = 0; i <= n1; i++) {
for (int j = 0; j <= n2; j++) {
if (i != n1)
dp[i + 1][j] = min(
dp[i + 1][j],
dp[i][j] + get(i * m + j * (m - 1) + 1, (i + 1) * m + j * (m - 1)));
if (j != n2)
dp[i][j + 1] = min(
dp[i][j + 1],
dp[i][j] + get(i * m + j * (m - 1) + 1, i * m + (j + 1) * (m - 1)));
}
}
cout << dp[n1][n2];
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long MXN = 5e3 + 10;
const long long MXM = 3e5 + 10;
long long n, k, t, r;
long long A[MXM], dp[MXN][MXN];
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
memset(dp, 63, sizeof dp);
cin >> n >> k;
r = n % k;
for (int i = 1; i <= n; i++) cin >> A[i];
sort(A + 1, A + n + 1);
dp[0][0] = 0;
for (int i = 0; i <= k - r; i++) {
for (int j = 0; j <= r; j++) {
if (i + j == 0) continue;
long long now = (i + j) * (n / k) + j, a = 1e17, b = 1e17;
if (i) a = dp[i - 1][j] + A[now] - A[now - n / k + 1];
if (j) b = dp[i][j - 1] + A[now] - A[now - n / k];
dp[i][j] = min(a, b);
}
}
cout << dp[k - r][r];
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int read() {
int re = 0;
char ch = '!';
while (ch < '0' || ch > '9') ch = getchar();
while (ch >= '0' && ch <= '9') {
re = re * 10 + ch - '0';
ch = getchar();
}
return re;
}
const int MAXN = 1e6 + 7;
long long n, k, k1, k2, siz;
long long a[MAXN];
long long f[2][5007];
int main() {
for (int i = 0; i <= 5000; i++) f[0][i] = f[1][i] = 2e18;
cin >> n >> k;
for (int i = 1; i <= n; i++) cin >> a[i];
sort(a + 1, a + 1 + n);
k1 = n % k;
k2 = k - k1;
siz = n / k + 1;
f[0][0] = 0;
for (int j = 0; j <= k2; j++) {
if (j)
f[0][j] = min(f[0][j], f[0][j - 1] + a[0 * siz + j * (siz - 1)] -
a[0 * siz + (j - 1) * (siz - 1) + 1]);
}
for (int i = 1; i <= k1; i++) {
for (int j = 0; j <= k2; j++) {
if (i && f[0][j] < 1e18)
f[1][j] = min(f[1][j], f[0][j] + a[i * siz + j * (siz - 1)] -
a[(i - 1) * siz + j * (siz - 1) + 1]);
if (j && f[1][j - 1] < 1e18)
f[1][j] = min(f[1][j], f[1][j - 1] + a[i * siz + j * (siz - 1)] -
a[i * siz + (j - 1) * (siz - 1) + 1]);
}
for (int j = 0; j <= k2; j++) {
f[0][j] = f[1][j];
f[1][j] = 2e18;
}
}
cout << f[0][k2] << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
inline int S() {
int ret = 0, neg = 0;
char c;
for (c = getchar(); c < '0' || c > '9'; c = getchar())
if (c == '-') neg = 1;
for (; c >= '0' && c <= '9'; c = getchar())
ret = (ret << 3) + (ret << 1) + c - '0';
return neg ? -ret : ret;
}
const int N = 3e5 + 10;
int n, k;
int a[N], b[N];
long long dp[2][5010][2], sum[N];
long long cal(int st, int ed) {
long long ret = 0;
for (int i = st + 1; i <= ed; ++i) {
ret += a[i] - a[i - 1];
}
return ret;
}
int main() {
n = S();
k = S();
for (int i = 1; i <= n; ++i) {
a[i] = S();
}
sort(a + 1, a + 1 + n);
for (int i = 0; i < 2; ++i) {
for (int j = 0; j < 5010; ++j) {
for (int k = 0; k < 2; ++k) {
dp[i][j][k] = 1LL << 60;
}
}
}
if (n % k) {
int b = n / k, a = b + 1, ta = n % k, tb = k - ta;
dp[1][0][1] = cal(1, b);
dp[1][1][0] = cal(1, a);
for (int i = 2; i <= k; ++i) {
for (int j = 0; j <= ta; ++j) {
if (i < j) {
break;
}
int curI = i & 1, lastI = curI ^ 1;
int st = a * (j - 1) + b * (i - j) + 1;
int ed = st + a - 1;
long long val = cal(st, ed);
if (j) {
dp[curI][j][0] = min(dp[lastI][j - 1][0], dp[lastI][j - 1][1]) + val;
}
st = a * j + b * (i - j - 1) + 1;
ed = st + b - 1;
long long val1 = cal(st, ed);
dp[curI][j][1] = min(dp[lastI][j][0], dp[lastI][j][1]) + val1;
}
}
long long ans = min(dp[k & 1][ta][0], dp[k & 1][ta][1]);
cout << ans << endl;
} else {
int cnt = 0, group = 1, pos = 1;
while (1) {
if (cnt == n) {
break;
}
if (pos <= n) {
b[pos] = a[++cnt];
pos += k;
} else {
group++;
pos = group;
}
}
long long ans = 0;
for (int i = k + 1; i <= n; ++i) {
ans += abs(b[i] - b[i - k]);
}
cout << ans << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 3e5 + 5;
const int maxk = 5000 + 5;
const long long INF = 1LL << 60;
long long dp[3][maxk];
int a[maxn];
int main() {
int n, k;
while (~scanf("%d%d", &n, &k)) {
for (int i = 0; i < n; ++i) {
scanf("%d", a + i);
}
sort(a, a + n);
int cnt1 = n % k, cnt2 = k - cnt1;
for (int i = 0; i < 2; ++i) {
fill(dp[i], dp[i] + cnt2 + 1, INF);
}
dp[0][0] = 0;
for (int i = 0; i <= cnt1; ++i) {
for (int j = 0; j <= cnt2; ++j) {
if (i == cnt1 && j == cnt2) {
printf("%I64d\n", dp[i & 1][j]);
}
int temp = i * (n / k + 1) + j * (n / k);
if (i < cnt1) {
dp[i & 1 ^ 1][j] =
min(dp[i & 1 ^ 1][j], dp[i & 1][j] + a[temp + n / k] - a[temp]);
}
if (j < cnt2) {
dp[i & 1][j + 1] = min(dp[i & 1][j + 1],
dp[i & 1][j] + a[temp + n / k - 1] - a[temp]);
}
dp[i & 1][j] = INF;
}
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, k, a, b;
long long dp[5005][5005], s[300005];
int main() {
scanf("%d %d", &n, &k);
for (int i = 1; i <= n; i++) {
scanf("%lld", &s[i]);
}
sort(s + 1, s + n + 1);
a = n % k;
b = k - a;
for (int i = 0; i <= a; i++) {
for (int j = 0; j <= b; j++) {
if (i == 0 && j == 0)
dp[i][j] = 0;
else {
int cur = i * (n / k + 1) + j * (n / k);
if (i == 0)
dp[i][j] = dp[i][j - 1] + s[cur] - s[cur - n / k + 1];
else if (j == 0)
dp[i][j] = dp[i - 1][j] + s[cur] - s[cur - n / k];
else
dp[i][j] = min(dp[i][j - 1] + s[cur] - s[cur - n / k + 1],
dp[i - 1][j] + s[cur] - s[cur - n / k]);
}
}
}
printf("%lld\n", dp[a][b]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
vector<int> x(5000);
vector<vector<int>> dp(5001, x);
vector<int> v;
int k;
int n;
int len;
long long make_dp(int pos, int num, int rem) {
if (num == 1 && rem < 2) return 0;
if (num == 1 && rem > 1) return INT_MIN;
if (dp[num][rem] != -1) return dp[num][rem];
if (rem == 0)
return dp[num][rem] = make_dp(pos + len, num - 1, rem) +
abs(v[pos + len] - v[pos + len - 1]);
else if (rem == num)
return dp[num][rem] = make_dp(pos + len + 1, num - 1, rem - 1) +
abs(v[pos + len + 1] - v[pos + len]);
else
return dp[num][rem] = max(make_dp(pos + len, num - 1, rem) +
abs(v[pos + len] - v[pos + len - 1]),
make_dp(pos + len + 1, num - 1, rem - 1) +
abs(v[pos + len + 1] - v[pos + len]));
}
int main() {
cin >> n >> k;
long long ans = 0;
len = n / k;
for (int i = 0; i < int(n); i++) {
int a;
cin >> a;
v.push_back(a);
}
sort(v.begin(), v.end());
for (int i = 0; i < int(k + 1); i++) {
for (int j = 0; j < int(n % k + 1); j++) dp[i][j] = -1;
}
for (int i = 0; i < int(n - 1); i++) ans += v[i + 1] - v[i];
ans -= make_dp(0, k, n % k);
cout << ans;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 3e5 + 5;
const int M = 5005;
const long long inf = 0x3f3f3f3f3f3f3f3f;
int n, a[N], k;
long long dp[M][M];
int main() {
scanf("%d%d", &n, &k);
memset(dp, inf, sizeof(dp));
for (int i = 1; i <= n; i++) scanf("%d", &a[i]);
sort(a + 1, a + 1 + n);
dp[0][0] = 0;
int num1 = n % k, num2 = k - (n % k);
int cnt1 = n / k + 1, cnt2 = n / k;
for (int i = 0; i <= num1; i++) {
for (int j = 0; j <= num2; j++) {
if (i == 0 && j == 0) continue;
int pos1 = i * cnt1 + j * cnt2, pos2 = (i - 1) * cnt1 + j * cnt2 + 1;
if (i > 0) dp[i][j] = min(dp[i][j], dp[i - 1][j] + a[pos1] - a[pos2]);
pos2 = i * cnt1 + (j - 1) * cnt2 + 1;
if (j > 0) dp[i][j] = min(dp[i][j], dp[i][j - 1] + a[pos1] - a[pos2]);
}
}
printf("%lld\n", dp[num1][num2]);
return 0;
}
|
#include <bits/stdc++.h>
template <class T>
inline int maximize(T& a, T b) {
if (a < b) {
a = b;
return 1;
}
return 0;
}
template <class T>
inline int minimize(T& a, T b) {
if (a > b) {
a = b;
return 1;
}
return 0;
}
using namespace std;
const int IINF = 0x3f3f3f3f;
const long long LINF = 0x3f3f3f3f3f3f3f3fll;
const double DINF = numeric_limits<double>::infinity();
const int MOD = 1000000007;
const double EPS = 1e-9;
const int DX[] = {1, 0, -1, 0, 1, -1, 1, -1};
const int DY[] = {0, 1, 0, -1, 1, -1, -1, 1};
long long gcd(long long a, long long b) { return b ? gcd(b, a % b) : a; }
long long sqr(long long x) { return x * x; }
long long sqr(int x) { return (long long)x * x; }
double sqr(double x) { return x * x; }
long double sqr(long double x) { return x * x; }
mt19937 mmtw(960172);
long long rnd(long long x, long long y) {
static uniform_int_distribution<long long> d;
return d(mmtw) % (y - x + 1) + x;
}
inline int bits_count(int v) {
v = v - ((v >> 1) & 0x55555555);
v = (v & 0x33333333) + ((v >> 2) & 0x33333333);
return ((v + (v >> 4) & 0xF0F0F0F) * 0x1010101) >> 24;
}
inline int bits_count(long long v) {
int t = v >> 32;
int p = (v & ((1LL << 32) - 1));
return bits_count(t) + bits_count(p);
}
unsigned int reverse_bits(register unsigned int x) {
x = (((x & 0xaaaaaaaa) >> 1) | ((x & 0x55555555) << 1));
x = (((x & 0xcccccccc) >> 2) | ((x & 0x33333333) << 2));
x = (((x & 0xf0f0f0f0) >> 4) | ((x & 0x0f0f0f0f) << 4));
x = (((x & 0xff00ff00) >> 8) | ((x & 0x00ff00ff) << 8));
return ((x >> 16) | (x << 16));
}
inline int sign(int x) { return (x >> 31) | (-x >> 31); }
inline bool ispow2(int x) { return (x != 0 && (x & (x - 1)) == 0); }
int arr[300003];
long long dp[5005][5005];
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int n, k;
cin >> n >> k;
for (int i = 0; i < n; i++) {
cin >> arr[i];
}
sort(arr, arr + n);
int a = n % k;
int as = n / k + 1;
int b = k - n % k;
int bs = n / k;
for (int i = 0; i < 5005; i++) {
for (int j = 0; j < 5005; j++) {
dp[i][j] = LINF;
}
}
dp[0][0] = 0;
for (int i = 0; i <= a; i++) {
for (int j = 0; j <= b; j++) {
if (i) {
dp[i][j] = min(dp[i][j], dp[i - 1][j] + arr[i * as + j * bs - 1] -
arr[(i - 1) * as + j * bs]);
}
if (j) {
dp[i][j] = min(dp[i][j], dp[i][j - 1] + arr[i * as + j * bs - 1] -
arr[i * as + (j - 1) * bs]);
}
}
}
cout << dp[a][b] << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int max_n = 300 * 1000, max_k = 5000;
int a[max_n];
long long sum[max_n];
long long dp[max_k + 1][max_k + 1];
const long long inf = 1e16;
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);
sum[0] = 0;
for (int i = (1); i < (n); i++) sum[i] = abs(a[i] - a[i - 1]) + sum[i - 1];
const int x = n / k;
const int a = n % k, b = k - n % k;
if (x == 0) {
cout << 0 << endl;
return 0;
}
for (int i = 0; i < (a + 1); i++)
for (int j = 0; j < (b + 1); j++) dp[i][j] = inf;
dp[0][0] = 0;
for (int i = 0; i < (a + 1); i++)
for (int j = 0; j < (b + 1); j++)
if (dp[i][j] < inf) {
int cur = i * (x + 1) + j * x;
if (i < a)
dp[i + 1][j] = min(sum[cur + x] - sum[cur] + dp[i][j], dp[i + 1][j]);
if (j < b)
dp[i][j + 1] =
min(sum[cur + x - 1] - sum[cur] + dp[i][j], dp[i][j + 1]);
}
cout << dp[a][b] << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 3 * 100 * 1000 + 10;
const int K = 5 * 1000 + 5;
long long Inf = 1ll * 1000 * 1000 * 1000 * 1000 * 1000;
long long a[N];
long long dp[K][K];
long long ps[N];
long long n;
long long k;
long long c;
void input() {
cin >> n >> k;
for (int i = 0; i < n; i++) cin >> a[i];
c = n / k;
sort(a, a + n);
}
void partialSum() {
ps[0] = 0;
ps[1] = 0;
for (int i = 2; i <= n; i++) ps[i] = ps[i - 1] + a[i - 1] - a[i - 2];
}
long long get(long long l, long long r) { return ps[r] - ps[l]; }
void update(int n, int m) {
long long ans = Inf;
dp[n][m] = ans;
if (n != m) dp[n][m] = dp[n - 1][m] + get((n - 1) * c + m + 1, n * c + m);
if (m > 0) {
long long tmp;
tmp = dp[n - 1][m - 1] + get((n - 1) * c + m, n * c + m);
dp[n][m] = min(dp[n][m], tmp);
}
}
void solver() {
for (int i = 1; i <= k; i++)
for (int j = 0; j <= n % k; j++) update(i, j);
cout << dp[k][n % k] << endl;
}
int main() {
input();
partialSum();
solver();
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 3e5 + 100;
const int MAXK = 5e3 + 10;
const int dx[9] = {0, 1, -1, 0, 0, -1, -1, 1, 1};
const int dy[9] = {0, 0, 0, -1, 1, -1, 1, -1, 1};
const double pi = acos(-1.0);
int n, k, a[MAXN], f[MAXK][MAXK];
int bn, sn, t;
int main() {
for (int i = 0; i <= MAXK - 1; i++)
for (int j = 0; j <= MAXK - 1; j++) f[i][j] = 2000000000;
scanf("%d", &n);
scanf("%d", &k);
for (int i = 1; i <= n; i++) scanf("%d", &a[i]);
sort(a + 1, a + 1 + n);
t = n / k;
bn = n % k, sn = k - bn;
f[0][0] = 0;
for (int i = 0; i <= bn; i++)
for (int j = 0; j <= sn; j++) {
if (i)
f[i][j] = min(f[i][j], f[i - 1][j] + a[i * (t + 1) + j * t] -
a[(i - 1) * (t + 1) + j * t + 1]);
if (j)
f[i][j] = min(f[i][j], f[i][j - 1] + a[i * (t + 1) + j * t] -
a[i * (t + 1) + (j - 1) * t + 1]);
}
printf("%d\n", f[bn][sn]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long int n, k, a[300001];
long long int f[5000][5000];
int main() {
cin >> n >> k;
for (int i = 0; i < n; i++) cin >> a[i];
sort(a, a + n);
memset(f, 0x3f, sizeof(f));
int len1 = n / k + 1, len2 = n / k;
int num1 = n % k, num2 = k - n % k;
for (int i = 0; i <= num1; i++) {
for (int j = 0; j <= num2; j++) {
if (i == 0 && j == 0) f[i][j] = 0;
if (i != 0)
f[i][j] = min(f[i][j], f[i - 1][j] + a[i * len1 + j * len2 - 1] -
a[(i - 1) * len1 + j * len2]);
if (j != 0)
f[i][j] = min(f[i][j], f[i][j - 1] + a[i * len1 + j * len2 - 1] -
a[i * len1 + (j - 1) * len2]);
}
}
cout << f[num1][num2];
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, k, a[300000];
long long dp[2][5000 + 1];
int main() {
ios::sync_with_stdio(false);
cin >> n >> k;
for (int i = 0; i < n; ++i) cin >> a[i];
sort(a, a + n);
int n1 = n % k, n2 = k - n % k;
int sz1 = n / k + 1, sz2 = n / k;
dp[0][0] = 0;
for (int i = 1, pos = 0; i <= n2; ++i) {
dp[0][i] = dp[0][i - 1] + a[pos + sz2 - 1] - a[pos];
pos += sz2;
}
for (int i = 1, r = 1; i <= n1; ++i, r ^= 1) {
int pos = sz1 * i;
for (int j = 0; j <= n2; ++j) {
dp[r][j] = dp[r ^ 1][j] + a[pos - 1] - a[pos - sz1];
if (j > 0)
dp[r][j] = min(dp[r][j], dp[r][j - 1] + a[pos - 1] - a[pos - sz2]);
pos += sz2;
}
}
cout << dp[n1 & 1][n2] << '\n';
return 0;
}
|
#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;
assert(b >= 0);
for (; b; b >>= 1) {
if (b & 1) res = res * a % mod;
a = a * a % mod;
}
return res;
}
long long gcd(long long a, long long b) { return b ? gcd(b, a % b) : a; }
const int INF = 1e9;
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int n, k;
cin >> n >> k;
vector<long long> a(n);
for (int i = (0); i < (n); ++i) cin >> a[i];
sort((a).begin(), (a).end());
int NL = n % k;
int NS = k - NL;
int SL = n / k + 1;
int SS = n / k;
vector<vector<long long>> dp(NL + 1, vector<long long>(NS + 1, LLONG_MAX));
dp[0][0] = 0;
for (int i = (0); i < (NL + 1); ++i) {
for (int j = (0); j < (NS + 1); ++j) {
if (i > 0) {
int low = (i - 1) * SL + j * SS;
int high = low + SL - 1;
long long diff = a[high] - a[low];
dp[i][j] = min(dp[i][j], dp[i - 1][j] + diff);
}
if (j > 0) {
int low = i * SL + (j - 1) * SS;
int high = low + SS - 1;
long long diff = a[high] - a[low];
dp[i][j] = min(dp[i][j], dp[i][j - 1] + diff);
}
}
}
cout << dp[NL][NS] << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 3e5 + 10, MAXK = 5010;
int N, K;
int cmin, cmax, minsz = MAXN, maxsz;
int A[MAXN];
int sz[MAXN];
int dp[MAXK][MAXK];
int getdp(int nmax, int nmin) {
int &ref = dp[nmax][nmin];
if (ref != -1) {
return ref;
}
ref = INT_MAX;
int len = nmax * maxsz + nmin * minsz;
if (nmax) {
ref = min(ref, getdp(nmax - 1, nmin) + A[len - 1] - A[len - maxsz]);
}
if (nmin) {
ref = min(ref, getdp(nmax, nmin - 1) + A[len - 1] - A[len - minsz]);
}
return ref;
}
int main() {
if (fopen("input.txt", "r")) {
freopen("input.txt", "r", stdin);
}
ios::sync_with_stdio(false);
cin >> N >> K;
for (int i = 0; i < N; i++) {
cin >> A[i];
}
sort(A, A + N);
for (int i = 0; i < N; i++) {
sz[i % K]++;
}
for (int i = 0; i < K; i++) {
minsz = min(minsz, sz[i]);
maxsz = max(maxsz, sz[i]);
}
cmin = count(sz, sz + K, minsz);
cmax = K - cmin;
memset((dp), (-1), sizeof(dp));
dp[0][0] = 0;
cout << getdp(cmax, cmin) << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 3e5 + 100;
long long a[N], dp[5010][5010];
int main() {
int n, k;
cin >> n >> k;
for (int i = 0; i < n; i++) cin >> a[i];
sort(a, a + n);
int b = n % k, b1 = k - (n % k), c = n / k, c1 = n / k + 1;
dp[0][0] = 0;
for (int i = 0; i <= b; i++) {
for (int j = 0; j <= b1; j++)
if (i || j) {
int sum = i * c1 + j * c;
dp[i][j] = INT_MAX;
if (i)
dp[i][j] = min(dp[i][j], dp[i - 1][j] + a[sum - 1] - a[sum - c1]);
if (j) dp[i][j] = min(dp[i][j], dp[i][j - 1] + a[sum - 1] - a[sum - c]);
}
}
cout << dp[b][b1];
}
|
#include <bits/stdc++.h>
using namespace std;
int n, k, b[1000005], p, q, w, dp[5050][5050];
int abs__(int x) { return x > 0 ? x : -x; }
int main() {
int i, j;
memset(dp, -1, 5050 * 5050 * sizeof(int));
scanf("%d %d ", &n, &k);
for (i = 0; i < n; i++) {
scanf("%d", &b[i]);
}
sort(b, b + n);
p = k - n % k;
q = n % k;
w = n / k;
dp[0][0] = 0;
for (i = 0; i <= k; i++) {
for (j = 0; j <= k; j++) {
if (i * w + j * (w + 1) <= 300000) {
if (dp[i + 1][j] > dp[i][j] + abs(b[i * w + j * (w + 1)] -
b[(i + 1) * w + j * (w + 1) - 1]) ||
dp[i + 1][j] == -1)
dp[i + 1][j] = dp[i][j] + abs(b[i * w + j * (w + 1)] -
b[(i + 1) * w + j * (w + 1) - 1]);
if (dp[i][j + 1] > dp[i][j] + abs(b[i * w + j * (w + 1)] -
b[i * w + (j + 1) * (w + 1) - 1]) ||
dp[i][j + 1] == -1)
dp[i][j + 1] = dp[i][j] + abs(b[i * w + j * (w + 1)] -
b[i * w + (j + 1) * (w + 1) - 1]);
}
}
}
printf("%d", dp[p][q]);
}
|
#include <bits/stdc++.h>
using namespace std;
int i, j, n, k, a[300005], answ, c1, c2, dp[5005][5005];
int main() {
scanf("%d%d", &n, &k);
for (i = 1; i <= n; i++) scanf("%d", &a[i]);
sort(a + 1, a + n + 1);
for (i = 2; i <= n; i++) answ += a[i] - a[i - 1];
a[n + 1] = a[n];
int xumb = n / k + 1;
c1 = n % k;
c2 = k - c1;
for (i = 1; i <= k; i++) {
for (j = 0; j <= i; j++) {
int ind1 = max(0, (j - 1)) * xumb + (i - j) * (xumb - 1),
ind2 = j * xumb + max((i - j - 1), 0) * (xumb - 1);
if (j == 0)
dp[j][i - j] = dp[j][i - j - 1] + a[ind2 + xumb] - a[ind2 + xumb - 1];
else if (j == i)
dp[j][i - j] = dp[j - 1][i - j] + a[ind1 + xumb + 1] - a[ind1 + xumb];
else
dp[j][i - j] =
max(dp[j - 1][i - j] + a[ind1 + xumb + 1] - a[ind1 + xumb],
dp[j][i - j - 1] + a[ind2 + xumb] - a[ind2 + xumb - 1]);
}
}
cout << answ - dp[c1][c2] << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 5005;
int n, k, a[300010];
int dp[maxn][maxn];
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 p = n % k, q = k - p;
dp[0][0] = 0;
for (int i = (0); i <= (p); i++)
for (int j = (0); j <= (q); j++) {
if (!i && !j) continue;
dp[i][j] = 0x7fffffff;
if (i) {
int tmp = (i - 1) * (n / k + 1) + j * (n / k);
dp[i][j] =
min(dp[i][j], dp[i - 1][j] + a[tmp + n / k + 1] - a[tmp + 1]);
}
if (j) {
int tmp = i * (n / k + 1) + (j - 1) * (n / k);
dp[i][j] = min(dp[i][j], dp[i][j - 1] + a[tmp + n / k] - a[tmp + 1]);
}
}
printf("%d\n", dp[p][q]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long n, k, dp[5010][5010], n1, n2, len1, len2, i, a[310000], j, x;
int main() {
scanf("%I64d %I64d", &n, &k);
n1 = n % k;
n2 = k - n1;
len1 = (n / k) + 1;
len2 = (n / k);
for (i = 1; i <= n; i++) {
scanf("%I64d", &a[i]);
}
sort(a + 1, a + 1 + n);
memset(dp, 0x7f, sizeof(dp));
dp[0][0] = 0;
for (i = 0; i <= n1; i++) {
for (j = 0; j <= n2; j++) {
x = i * len1 + j * len2;
if (i) dp[i][j] = min(dp[i][j], dp[i - 1][j] + a[x] - a[x - len1 + 1]);
if (j) dp[i][j] = min(dp[i][j], dp[i][j - 1] + a[x] - a[x - len2 + 1]);
}
}
printf("%I64d\n", dp[n1][n2]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 3E5 + 5;
const int M = 5005;
int a[N], n, k, u, v, x, y, w;
long long f[M][M];
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++) {
w = (n - i) / k + 1;
if (!x) x = w;
if (x != w && !y) y = w;
if (x == w)
u++;
else if (y == w)
v++;
}
for (int i = 0; i <= u; i++)
for (int j = 0; j <= v; j++) f[i][j] = 1E18;
f[0][0] = 0;
for (int i = 0; i <= u; i++)
for (int j = 0; j <= v; j++) {
w = i * x + j * y + 1;
if (i < u) f[i + 1][j] = min(f[i + 1][j], f[i][j] + a[w + x - 1] - a[w]);
if (j < v) f[i][j + 1] = min(f[i][j + 1], f[i][j] + a[w + y - 1] - a[w]);
}
cout << f[u][v];
}
|
#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;
long long int dp[5001][5001], a[1000001];
int main() {
long long int i, j, n, k, small, big, len;
cin >> n >> k;
for (i = 1; i <= n; i++) cin >> a[i];
sort(a + 1, a + n + 1);
big = n % k;
small = k - n % k;
len = n / k;
for (i = 0; i <= k; i++) {
for (j = 0; j <= k; j++) dp[i][j] = 1000000000000;
}
dp[0][0] = 0;
for (i = 0; i <= small; i++) {
for (j = 0; j <= big; j++) {
if (i)
dp[i][j] = min(dp[i][j], dp[i - 1][j] + a[(i + j) * len + j] -
a[(i - 1 + j) * len + j + 1]);
if (j)
dp[i][j] = min(dp[i][j], dp[i][j - 1] + a[(i + j) * len + j] -
a[(i + j - 1) * len + j]);
}
}
cout << dp[small][big] << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, k;
int main() {
cin >> n >> k;
vector<int> a;
a.resize(n);
for (int i = 0; i < n; ++i) cin >> a[i];
sort(a.begin(), a.end());
if (n % k == 0) {
int result = 0;
for (int i = 1; i < n; i++) {
if (i % (n / k) != 0) result += a[i] - a[i - 1];
}
cout << result;
} else {
int y2 = n % k;
int y3 = k - y2;
vector<vector<int> > b;
b.resize(y2 + 1);
for (int i = 0; i < y2 + 1; ++i) b[i].resize(y3 + 1);
for (int i = 0; i < y2 + 1; i++) {
for (int j = 0; j < y3 + 1; j++) {
if ((i < y2 || j < y3) && (i > 0 || j > 0)) {
b[i][j] = a[i * (n / k + 1) + j * (n / k)] -
a[i * (n / k + 1) + j * (n / k) - 1];
int max = 0;
if (i > 0) max = b[i - 1][j];
if (j > 0 && b[i][j - 1] > max) max = b[i][j - 1];
b[i][j] += max;
}
}
}
int result = 0;
for (int i = 1; i < n; i++) {
result += a[i] - a[i - 1];
}
int temp = b[y2 - 1][y3];
if (b[y2][y3 - 1] > temp) {
temp = b[y2][y3 - 1];
}
result -= temp;
cout << result;
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1e6 + 7;
const int M = 48;
const int inf = 1e9 + 7;
const long long base = 1e18;
const double pi = acos(-1);
const double ep = 1e-9;
int n, k;
int a[N];
long long dp[5007][5007];
int last(int u, int v) { return u * k + v; }
int main() {
cin >> n >> k;
for (int i = 1; i < n + 1; i++) {
scanf("%d", a + i);
}
sort(a + 1, a + n + 1);
int t = n % k;
int len = n / k;
for (int j = 1; j < t + 1; j++) dp[0][j] = base;
for (int i = 1; i < k + 1; i++) {
dp[i][0] = dp[i - 1][0] + a[i * len] - a[(i - 1) * len + 1];
for (int j = 1; j < t + 1; j++) {
dp[i][j] = base;
if (j > i) continue;
int ls = (i - 1) * len + j - 1;
long long tmp0 = dp[i - 1][j - 1] + a[ls + len + 1] - a[ls + 1];
dp[i][j] = tmp0;
ls = (i - 1) * len + j;
tmp0 = dp[i - 1][j] + a[ls + len] - a[ls + 1];
dp[i][j] = min(dp[i][j], tmp0);
}
}
cout << dp[k][t];
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 3e5 + 5, maxk = 5005;
int n, k, a[maxn + 1];
long long d[maxk + 1][maxk + 1];
void read() {
scanf("%d %d", &n, &k);
for (int i = 1; i <= n; i++) {
scanf("%d", a + i);
}
}
int val(int le, int ri) { return a[ri] - a[le]; }
void work() {
sort(a + 1, a + 1 + n);
memset(d, 0, sizeof(d));
int les = n % k;
int l1 = n / k;
int l2 = l1 + 1;
for (int i = 1; i <= k; i++) {
for (int j = 0; j <= min(i, les); j++) {
int ri = l2 * j + l1 * (i - j);
if (j && (i != j))
d[i][j] = min(d[i - 1][j - 1] + val(ri - l2 + 1, ri),
d[i - 1][j] + val(ri - l1 + 1, ri));
else if (j == 0)
d[i][j] = d[i - 1][j] + val(ri - l1 + 1, ri);
else
d[i][j] = d[i - 1][j - 1] + val(ri - l2 + 1, ri);
}
}
printf("%lld\n", d[k][les]);
}
int main() {
read();
work();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int fastMax(int x, int y) { return (((y - x) >> (32 - 1)) & (x ^ y)) ^ y; }
int fastMin(int x, int y) { return (((y - x) >> (32 - 1)) & (x ^ y)) ^ x; }
const long long int MAXN = 3e5 + 10;
long long int a[MAXN];
const long long int MAXK = 5003;
long long int dp[MAXK][MAXK];
long long int large, small, lar_len, small_len;
long long int rec(long long int l, long long int second) {
if (l > large || second > small) return 1e15;
if (l == large && second == small) return 0;
long long int &ans = dp[l][second];
if (ans != -1) return ans;
ans = 1e15;
long long int curr = lar_len * l + small_len * second + 1;
ans = min(ans, rec(l + 1, second) + a[curr + lar_len - 1] - a[curr]);
ans = min(ans, rec(l, second + 1) + a[curr + small_len - 1] - a[curr]);
return ans;
}
void solve() {
long long int n, k;
cin >> n >> k;
for (long long int i = (1); i <= (n); ++i) cin >> a[i];
sort(a + 1, a + n + 1);
large = n % k, small = k - n % k;
lar_len = n / k + 1, small_len = n / k;
memset((dp), -1, sizeof((dp)));
cout << rec(0, 0) << '\n';
}
signed main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
;
long long int t;
t = 1;
for (long long int i = (1); i <= (t); ++i) {
solve();
}
}
|
#include <bits/stdc++.h>
using namespace std;
const long double sqr5 = sqrt(5), p_ = (1 + sqr5) / 2;
const long double PI = ((long double)2 * asin(1));
const long long INF = ((long long)1e12);
const long long MOD = ((long long)1e9 + 7);
const long long BIG_HSH = ((long long)9999999900000001);
const long long SML_HSH = ((long long)100030001);
inline long long tavan(long long a, long long b) {
return (b) ? (tavan((a) * (a), (b) >> 1) * ((b)&1 ? (a) : 1)) : 1;
}
inline long long tavan(long long a, long long n, long long mod) {
long long p = 1;
while (n > 0) {
if (n % 2) {
p = p * a;
p %= mod;
}
n >>= 1;
a *= a;
a %= mod;
}
return p % mod;
}
inline long double fib(long long x) {
return (tavan(p_, x) - tavan(1 - p_, x)) / (sqr5);
}
inline long double fib(long long x, long long mod) {
return (tavan(p_, x, mod) - tavan(1 - p_, x, mod)) / (sqr5);
}
inline long long gcd(long long a, long long b) {
while (b ^= a ^= b ^= a = a % b)
;
return a;
}
template <class T>
inline void smx(T &x, T y) {
x = max((x), (y));
}
template <class T>
inline void smn(T &x, T y) {
x = min((x), (y));
}
ifstream fin("input.txt");
ofstream fout("output.txt");
long long n, k, a[301 * 1000], dp[(5500)][(5500)];
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> n >> k;
for (long long i = 0; i < n; i++) cin >> a[i];
for (long long i = 0; i < (5500); i++)
for (long long j = 0; j < (5500); j++) dp[i][j] = INF;
dp[0][0] = 0;
sort(a, a + n);
long long t = n / k, q = n % k;
for (long long i = 1; i <= k; i++)
for (long long j = 0; j <= min(q, i); j++) {
long long x = i * t + j - 1;
if (x >= t - 1) smn(dp[i][j], dp[i - 1][j] + a[x] - a[x - t + 1]);
if (x >= t) smn(dp[i][j], dp[i - 1][j - 1] + a[x] - a[x - t]);
}
cout << dp[k][q];
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
std::istream& in = cin;
vector<int> readInts(int n) {
vector<int> v;
v.reserve(n);
for (int i = 0; i < n; i++) {
int x;
in >> x;
v.push_back(x);
}
return v;
}
struct Key {
int largeBlocks;
int smallBlocks;
int pos;
bool isLess(const Key& other) const {
return pos < other.pos ||
pos == other.pos && smallBlocks < other.smallBlocks ||
pos == other.pos && smallBlocks == other.smallBlocks &&
largeBlocks < other.largeBlocks;
}
friend bool operator<(const Key& one, const Key& two) {
return one.isLess(two);
}
};
int f(vector<int>& nums, int k) {
std::sort(nums.begin(), nums.end());
int blockSize = nums.size() / k;
int numLargeBlocks = nums.size() % k;
vector<int> difSums = {0};
for (int i = 1; i < nums.size(); i++)
difSums.push_back(difSums[i - 1] + nums[i] - nums[i - 1]);
map<Key, int> q;
q[{numLargeBlocks, k - numLargeBlocks, 0}] = 0;
while (true) {
const Key& cur = q.begin()->first;
if (cur.pos == nums.size()) {
assert(cur.largeBlocks + cur.smallBlocks == 0);
break;
}
if (cur.smallBlocks > 0) {
Key next = cur;
next.smallBlocks--;
next.pos += blockSize;
int nextVal =
q.begin()->second + difSums[next.pos - 1] - difSums[cur.pos];
auto it = q.find(next);
if (it == q.end() || it->second > nextVal) q[next] = nextVal;
}
if (cur.largeBlocks > 0) {
Key next = cur;
next.largeBlocks--;
next.pos += blockSize + 1;
int nextVal =
q.begin()->second + difSums[next.pos - 1] - difSums[cur.pos];
auto it = q.find(next);
if (it == q.end() || it->second > nextVal) q[next] = nextVal;
}
q.erase(q.begin());
}
assert(q.size() == 1);
return q.begin()->second;
}
int main(int argc, char** argv) {
cin.sync_with_stdio(false);
cout.sync_with_stdio(false);
int n, k;
in >> n >> k;
vector<int> nums = readInts(n);
cout << f(nums, k) << "\n";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 300010;
int a[maxn];
const long long INF = 0x3f3f3f3f3f3f3f3fLL;
long long d[5010][5010];
int n1, n2, t1, t2;
long long dp(int i, int j) {
if (i == 0 && j == 0) return 0;
long long &ans = d[i][j];
if (ans != -1) return ans;
ans = INF;
if (i > 0)
ans = min(ans,
dp(i - 1, j) + a[i * t1 + j * t2] - a[(i - 1) * t1 + j * t2 + 1]);
if (j > 0)
ans = min(ans,
dp(i, j - 1) + a[i * t1 + j * t2] - a[i * t1 + (j - 1) * t2 + 1]);
return ans;
}
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] = 0;
n1 = n % k, n2 = k - n % k, t1 = n / k + 1, t2 = n / k;
memset(d, -1, sizeof d);
printf("%lld\n", dp(n1, n2));
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]; }
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;
}
}
dp[0][0] = 0;
for (int i = 0; i <= a1; ++i) {
for (int j = 0; j <= a2; ++j) {
if (i == 0 && j == 0) {
continue;
}
int poz = i * l1 + j * l2 - 1;
dp[i][j] = inf;
if (i) {
dp[i][j] = min(dp[i][j], dp[i - 1][j] + get_sum(poz - l1 + 1, poz));
}
if (j) {
dp[i][j] = min(dp[i][j], dp[i][j - 1] + get_sum(poz - l2 + 1, poz));
}
}
}
cout << dp[a1][a2] << endl;
return 0;
}
|
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:102400000,102400000")
using namespace std;
template <class T>
inline bool In(T &n) {
T x = 0, tmp = 1;
char c = getchar();
while ((c < '0' || c > '9') && c != '-' && c != EOF) c = getchar();
if (c == EOF) return false;
if (c == '-') c = getchar(), tmp = -1;
while (c >= '0' && c <= '9') x *= 10, x += (c - '0'), c = getchar();
n = x * tmp;
return true;
}
template <class T>
inline void Out(T n) {
if (n < 0) {
putchar('-');
n = -n;
}
int len = 0, data[20];
while (n) {
data[len++] = n % 10;
n /= 10;
}
if (!len) data[len++] = 0;
while (len--) putchar(data[len] + 48);
}
int n, k, ans = 0;
int a[300010];
int dp[5010][5010];
int main() {
In(n);
In(k);
for (int i = 0; i < n; i++) In(a[i]);
sort(a, a + n);
int y = n % k, x = n / k;
memset(dp, 127, sizeof(dp));
dp[0][0] = 0;
for (int i = 0; i <= k - y; i++) {
for (int j = 0; j <= y; j++) {
int p = i * x + j * (x + 1);
if (i) dp[i][j] = min(dp[i][j], dp[i - 1][j] + a[p - 1] - a[p - x]);
if (j) dp[i][j] = min(dp[i][j], dp[i][j - 1] + a[p - 1] - a[p - x - 1]);
}
}
Out(dp[k - y][y]);
return 0;
}
|
#include <bits/stdc++.h>
#pragma GCC optimize("Ofast,unroll-loops")
#pragma GCC target( \
"sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,avx2,tune=native")
using namespace std;
void itval(istream_iterator<string> it) {}
template <typename T, typename... Args>
void itval(istream_iterator<string> it, T a, Args... args) {
cerr << *it << " = " << a << endl;
itval(++it, args...);
}
const long long int MOD = 1e9 + 7;
template <typename T>
inline void print(T x) {
cout << x << "\n";
}
template <typename T>
inline void printvec(T x) {
for (auto a : x) cout << a << ' ';
cout << '\n';
}
struct custom {
bool operator()(const pair<long long int, long long int> &p1,
const pair<long long int, long long int> &p2) const {
return p1.first < p2.first;
}
};
long long int get_pow(long long int a, long long int b, long long int M = MOD) {
long long int res = 1;
while (b) {
if (b & 1) res = (res * a) % M;
a = (a * a) % M;
b >>= 1;
}
return res;
}
const long long int N = 2e6 + 5, inf = 4e18;
long long int dp[5002][5002];
void solve() {
long long int n, k;
cin >> n >> k;
vector<long long> v(n);
for (long long int i = (long long int)0; i < (long long int)(n); i++) {
cin >> v[i];
}
long long int big = n % k, small = k - n % k;
long long int big_size = n / k + 1, small_size = n / k;
for (long long int i = (long long int)0; i < (long long int)(5002); i++)
for (long long int j = (long long int)0; j < (long long int)(5002); j++)
dp[i][j] = inf;
dp[0][0] = 0;
sort(v.begin(), v.end());
for (long long int i = (long long int)0; i < (long long int)(big + 1); i++) {
for (long long int j = (long long int)0; j < (long long int)(small + 1);
j++) {
if (dp[i][j] == inf) continue;
int dx = j * small_size + i * big_size;
if (i < big) {
dp[i + 1][j] =
min(dp[i + 1][j], dp[i][j] + v[dx + big_size - 1] - v[dx]);
}
if (j < small) {
dp[i][j + 1] =
min(dp[i][j + 1], dp[i][j] + v[dx + small_size - 1] - v[dx]);
}
}
}
cout << dp[big][small] << '\n';
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
int test = 1;
clock_t z = clock();
for (long long int tes = (long long int)0; tes < (long long int)(test);
tes++) {
solve();
}
fprintf(stderr, "Total Time:%.4f\n", (double)(clock() - z) / CLOCKS_PER_SEC),
fflush(stderr);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int ofs[300005];
int cnt[300005];
vector<int> sol[300005];
int vals[300005];
int n, k;
int gr;
int main() {
scanf("%d%d", &n, &k);
for (int i = 1; i <= n; i++) scanf("%d", &vals[i]);
sort(vals + 1, vals + 1 + n);
for (int i = 1; i <= n; i++) {
ofs[i] = -1;
cnt[i] = 0;
}
ofs[0] = 0;
cnt[0] = 1;
sol[0].push_back(0);
gr = n / k;
for (int i = 0; i <= n; i++) {
if (ofs[i] == -1) continue;
if (i + gr > n) continue;
for (int j = 0; j < cnt[i]; j++) {
if (ofs[i] + j + 1 > k) continue;
for (int t = i + gr; t <= i + gr + (n % k > 0); t++) {
if (ofs[t] == -1) ofs[t] = ofs[i] + 1;
int ncn = ofs[i] + j + 2 - ofs[t];
for (int k = cnt[t]; k < ncn; k++) sol[t].push_back(((1 << 31) - 1));
cnt[t] = max(cnt[t], ncn);
sol[t][ofs[i] + j + 1 - ofs[t]] = min(
sol[t][ofs[i] + j + 1 - ofs[t]], sol[i][j] + vals[t] - vals[i + 1]);
}
}
}
printf("%d\n", sol[n][k - ofs[n]]);
}
|
#include <bits/stdc++.h>
using namespace std;
long long int a[300001], dp[5001][5001] = {0};
int main() {
int n, k;
scanf("%d%d", &n, &k);
for (int i = 0; i < n; i++) scanf("%lld", &a[i]);
sort(a, a + n);
int lan = n % k, smn = k - lan;
long long int sm = n / k, la = sm + 1;
for (int i = 0; i <= lan; i++) {
for (int j = 0; j <= smn; j++) {
if (i == 0 && j == 0) continue;
if (j == 0) {
int ind = (i - 1) * la;
dp[i][j] = dp[i - 1][0] + abs(a[ind + la - 1] - a[ind]);
} else if (i == 0) {
int ind = (j - 1) * sm;
dp[i][j] = dp[i][j - 1] + abs(a[ind + sm - 1] - a[ind]);
} else {
int ind = (i * la) + (j - 1) * sm;
long long int val1 = dp[i][j - 1] + abs(a[ind + sm - 1] - a[ind]);
ind = (i - 1) * la + (j * sm);
long long int val2 = dp[i - 1][j] + abs(a[ind + la - 1] - a[ind]);
dp[i][j] = min(val1, val2);
}
}
}
printf("%lld\n", dp[lan][smn]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long MAXN = 600005;
long long f[MAXN];
long long dp[5005][5005];
int main() {
long long n, k;
memset(dp, 0x3f, sizeof dp);
cin >> n >> k;
for (int i = 0; i < n; i++) cin >> f[i];
long long ans = 0;
sort(f, f + n);
long long a = n % k;
long long num = n / k;
dp[0][0] = 0;
for (long long i = 0; i <= a; i++) {
for (long long j = 0; j <= k - a; j++) {
long long pos = (num + 1) * i + num * j;
dp[i + 1][j] = min(dp[i + 1][j], dp[i][j] + f[pos + num] - f[pos]);
if (pos + num >= 1)
dp[i][j + 1] = min(dp[i][j + 1], dp[i][j] + f[pos + num - 1] - f[pos]);
else
dp[i][j + 1] = min(dp[i][j + 1], dp[i][j] - f[pos]);
}
}
printf("%I64d\n", dp[a][k - a]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
vector<int> vec;
int n, k, s, l, len, tot, mem[5005][5005];
int dp(int i, int j) {
if (i > s || j > l || i == s && j == l) return 0;
if (mem[i][j] != -1) return mem[i][j];
int idx = len * (i + j) - i + 1;
return mem[i][j] = vec[idx] - vec[idx - 1] + max(dp(i + 1, j), dp(i, j + 1));
}
int main() {
cin >> n >> k;
vec.resize(n + 1);
for (int i = 1; i <= n; i++) scanf("%d", &vec[i]);
sort(vec.begin() + 1, vec.end());
for (int i = 1; i <= n; i++) tot += vec[i] - vec[i - 1];
memset(mem, -1, sizeof mem);
len = (n - 1) / k + 1;
l = (n - 1) % k + 1;
s = (n - l * len) / (len - 1);
cout << tot - dp(0, 0) << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long N = 5e3 + 5, mod = 1e9 + 7, mod1 = 998244353, mod2 = 1e9 + 9,
inf = 1e18 + 7;
const long long infll = 1e18 + 7;
long long n, k, X, Y, Z;
long long a[(long long)3e5 + 5];
long long dp[N][N];
signed main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> n >> k;
Y = n % k;
X = k - Y;
Z = n / k;
for (long long i = 1; i <= n; i++) {
cin >> a[i];
}
sort(a + 1, a + 1 + n);
for (long long i = 0; i <= X; i++) {
for (long long j = 0; j <= Y; j++) {
if (i == 0 && j == 0) {
dp[i][j] = 0;
continue;
}
dp[i][j] = inf;
long long t = i * Z + j * (Z + 1);
if (i) {
dp[i][j] = min(dp[i][j], dp[i - 1][j] + a[t] - a[t - Z + 1]);
}
if (j) {
dp[i][j] = min(dp[i][j], dp[i][j - 1] + a[t] - a[t - Z]);
}
}
}
cout << dp[X][Y];
}
|
#include <bits/stdc++.h>
using namespace std;
int read() {
int re = 0;
char ch = '!';
while (ch < '0' || ch > '9') ch = getchar();
while (ch >= '0' && ch <= '9') {
re = re * 10 + ch - '0';
ch = getchar();
}
return re;
}
const int MAXN = 1e6 + 7;
int n, k, k1, k2, siz;
long long a[MAXN];
long long f[5001][5001];
int main() {
memset(f, 0x3f, sizeof(f));
cin >> n >> k;
for (int i = 1; i <= n; i++) cin >> a[i];
sort(a + 1, a + 1 + n);
k1 = n % k;
k2 = k - k1;
siz = n / k + 1;
f[0][0] = 0;
for (int i = 0; i <= k1; i++) {
for (int j = 0; j <= k2; j++) {
if (i)
f[i][j] = min(f[i][j], f[i - 1][j] + a[i * siz + j * (siz - 1)] -
a[(i - 1) * siz + j * (siz - 1) + 1]);
if (j)
f[i][j] = min(f[i][j], f[i][j - 1] + a[i * siz + j * (siz - 1)] -
a[i * siz + (j - 1) * (siz - 1) + 1]);
}
}
cout << f[k1][k2] << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
const int INF = 0x3f3f3f3f;
const long long LINF = 0x3f3f3f3f3f3f3f3fll;
const int MAXK = 5010;
const int MAXN = 3e5 + 10;
long long memo[MAXK][MAXK];
long long pref[MAXN];
long long query(int l, int r) {
if (l == r) return 0;
return pref[r] - pref[l];
}
int n, k, szgood, szbad;
long long dp(int done, int bad) {
int isbad = (k - n % k) - bad, isgood = done - isbad;
int pos = isbad * szbad + isgood * szgood;
if (pos > n or (pos == n and bad)) return LINF;
if (pos == n) return 0;
long long& p = memo[done][bad];
if (p != -1) return p;
long long ret = LINF;
ret = dp(done + 1, bad) + query(pos, pos + szgood - 1);
if (bad) ret = min(ret, dp(done + 1, bad - 1) + query(pos, pos + szbad - 1));
return p = ret;
}
int main() {
if (!false) ios_base::sync_with_stdio(0);
cin.tie(0);
cin >> n >> k;
vector<long long> v(n);
for (long long& i : v) cin >> i;
sort(v.begin(), v.end());
for (int i = 0; i < n; i++) {
if (i) pref[i] = pref[i - 1] + v[i] - v[i - 1];
}
szgood = (n + k - 1) / k, szbad = n / k;
memset(memo, -1, sizeof memo);
cout << dp(0, k - (n % k)) << '\n';
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 3e5 + 9;
const int DP_SIZE = 5e3 + 9;
int arr[MAXN];
long long dp[DP_SIZE][DP_SIZE];
int main(int argc, char const *argv[]) {
int n, k;
cin >> n >> k;
for (int i = 0; i < n; i++) {
scanf("%d", &arr[i]);
}
sort(arr, arr + n);
int totalBig = n % k, totalSmall = k - totalBig;
int smallSize = n / k, bigSize = smallSize + 1;
memset(dp, 0x3f, sizeof(dp));
dp[0][0] = 0;
for (int i = 0; i <= totalSmall; i++)
for (int j = 0; j <= totalBig; j++) {
int elementsTaken = smallSize * i + bigSize * j;
long long toAdd;
if (i < totalSmall) {
toAdd = arr[elementsTaken + smallSize - 1] - arr[elementsTaken];
dp[i + 1][j] = min(dp[i + 1][j], toAdd + dp[i][j]);
}
if (j < totalBig) {
toAdd = arr[elementsTaken + bigSize - 1] - arr[elementsTaken];
dp[i][j + 1] = min(dp[i][j + 1], toAdd + dp[i][j]);
}
}
cout << dp[totalSmall][totalBig] << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
void fast_io() {
cin.tie(0);
ios::sync_with_stdio(false);
}
long long n, k;
vector<long long> a;
long long sum = 0;
long long largest;
long long smallest;
long long num;
long long dp[5010][5010];
long long calc(long long large, long long small) {
if (large == 0 && small == 0) return 0;
if (large < 0 || small < 0) return INT_MIN;
if (dp[large][small] != -1) return dp[large][small];
long long &ret = dp[large][small];
int idx = num * (largest - large) + (num - 1) * (smallest - small);
long long ok = 0;
if (idx >= 1) {
if (a[idx] >= a[idx - 1])
ok = a[idx] - a[idx - 1];
else
ok = a[idx - 1] - a[idx];
}
ret = max(calc(large - 1, small), calc(large, small - 1));
if (ret == INT_MIN) return INT_MIN;
ret += ok;
return ret;
}
int main() {
scanf("%lld", &n);
scanf("%lld", &k);
a.resize(n);
memset(dp, -1, sizeof(dp));
for (long long i = 0; i <= n - 1; i++) {
scanf("%lld", &a[i]);
}
sort((a.begin()), (a.end()));
for (long long i = 0; i <= n - 1; i++) {
if (i >= 1) {
if (a[i] >= a[i - 1])
sum += a[i] - a[i - 1];
else
sum += a[i - 1] + a[i];
}
}
num = ((n - 1) / k);
long long idx = 1 + num * k;
largest = n - idx + 1;
smallest = k - largest;
num++;
cout << (sum - calc(largest, smallest));
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int INF = 0x3f3f3f3f;
const int MOD = 1000000007;
const int maxn = 100000 + 7;
const double eps = 1e-8;
const double PI = acos(-1.0);
long long a[3 * maxn];
long long dp[5050][5050];
int main() {
int n, k;
scanf("%d%d", &n, &k);
for (int i = 1; i <= n; i++) scanf("%lld", &a[i]);
sort(a + 1, a + 1 + n);
int l = n / k;
int num1 = n % k;
int num2 = k - n % k;
memset(dp, INF, sizeof(dp));
dp[0][0] = 0;
for (int i = 0; i <= num1; i++)
for (int j = 0; j <= num2; j++) {
int now = i * (l + 1) + j * l;
if (i) dp[i][j] = min(dp[i][j], dp[i - 1][j] + a[now] - a[now - l]);
if (j) dp[i][j] = min(dp[i][j], dp[i][j - 1] + a[now] - a[now - (l - 1)]);
}
printf("%lld\n", dp[num1][num2]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MN = 300005, MK = 5005, inf = 1000000005, mod = 1000000007;
const long long INF = 1000000000000000005LL;
long long dp[MK][MK];
int t[MN];
int main() {
int n, k;
scanf("%d%d", &n, &k);
for (int i = 1; i <= n; ++i) scanf("%d", &t[i]);
sort(t + 1, t + 1 + n);
int l1 = n / k + 1, l2 = l1 - 1;
int a = n % k, b = k - (n % k);
for (int i = 0; i <= a; ++i)
for (int j = 0; j <= b; ++j) dp[i][j] = INF;
dp[0][0] = 0LL;
for (int i = 0; i <= a; ++i)
for (int j = 0; j <= b; ++j) {
int idx = i * l1 + j * l2;
if (i) dp[i][j] = min(dp[i][j], dp[i - 1][j] + t[idx] - t[idx - l1 + 1]);
if (j) dp[i][j] = min(dp[i][j], dp[i][j - 1] + t[idx] - t[idx - l2 + 1]);
}
printf("%lld", dp[a][b]);
}
|
#include <bits/stdc++.h>
using namespace std;
void FastIO() {
ios_base::sync_with_stdio(0);
cin.tie(NULL);
cout.tie(NULL);
}
long long modpow(long long a, long long p, long long mod) {
long long ret = 1;
while (p) {
if (p & 1) ret = (ret * a) % mod;
a = (a * a) % mod;
p /= 2;
}
return ret;
}
long long power(long long a, long long p) {
long long ret = 1;
while (p) {
if (p & 1) ret = (ret * a);
a = (a * a);
p /= 2;
}
return ret;
}
int a[300010];
long long dp[5010][5010];
int main() {
FastIO();
long long n, k;
cin >> n >> k;
for (int i = 0; i < n; i++) cin >> a[i];
sort(a, a + n);
long long x = k - n % k, y = n % k, sz = n / k;
dp[0][0] = 0;
for (int i = 0; i < x; i++)
dp[i + 1][0] = dp[i][0] + a[(i + 1) * sz - 1] - a[i * sz];
for (int i = 0; i < y; i++)
dp[0][i + 1] = dp[0][i] + a[(i + 1) * (sz + 1) - 1] - a[i * (sz + 1)];
for (int i = 0; i < x; i++)
for (int j = 0; j < y; j++) {
long long add = a[(i + 1) * sz + (j + 1) * (sz + 1) - 1],
subs = a[i * sz + (j + 1) * (sz + 1)],
subl = a[(i + 1) * sz + j * (sz + 1)];
dp[i + 1][j + 1] =
min(dp[i][j + 1] + add - subs, dp[i + 1][j] + add - subl);
}
cout << dp[x][y] << '\n';
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int INF = 1000000003;
int a[300005];
int dp[5010][5003];
int main() {
int i, j, k, m, n;
scanf("%d%d", &n, &k);
for (int i = 1; i <= n; i++) scanf("%d", &a[i]);
sort(a + 1, a + 1 + n);
a[0] = a[1];
memset(dp, 0, sizeof(dp));
int x1 = n / k;
int x2 = x1 + 1;
int cnt2 = n - x1 * k;
int cnt1 = k - cnt2;
for (int i = 0; i <= cnt2; i++)
for (int j = 0; j <= cnt1; j++) {
if (i > 0)
dp[i][j] = max(dp[i][j], dp[i - 1][j] + a[(i - 1) * x2 + j * x1 + 1] -
a[(i - 1) * x2 + j * x1]);
if (j > 0)
dp[i][j] = max(dp[i][j], dp[i][j - 1] + a[i * x2 + (j - 1) * x1 + 1] -
a[i * x2 + (j - 1) * x1]);
}
printf("%d\n", a[n] - a[1] - dp[cnt2][cnt1]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 5e5;
const int INF = 2e9 + 5;
int n, k, a[N], cnt[N];
long long f[N], ff[N];
int main() {
scanf("%d%d", &n, &k);
for (int i = 0; i < n; i++) scanf("%d", &a[i]);
sort(a, a + n);
int d = n / k;
int e = n % k;
for (int i = 0; i <= n; i++) {
f[i] = INF;
ff[i] = INF;
}
ff[0] = 0;
for (int i = 0; i <= e; i++) {
for (int j = i; j <= n; j += d) {
f[j] = ff[j];
ff[j] = INF;
}
for (int j = i; j <= n - d; j += d) {
if (f[j] == INF) continue;
long long cur = f[j] - a[j];
if (cur + a[j + d - 1] < f[j + d]) f[j + d] = cur + a[j + d - 1];
if ((j + d + 1 <= n) && (cur + a[j + d] < ff[j + d + 1])) {
ff[j + d + 1] = cur + a[j + d];
}
}
if (i == e) break;
}
cout << f[n] << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, k;
long long arr[3 * 100005];
long long dp[5005][5005];
long long Sum(int in, int f) {
int lm = n / k;
if (f == 0) lm++;
return arr[in + lm - 1] - arr[in];
}
long long solve(int g1, int g2) {
if (g1 == 0 && g2 == 0) {
return 0;
}
if (dp[g1][g2] != -1) return dp[g1][g2];
long long sum1 = (1LL << 63) - 1;
long long sum2 = (1LL << 63) - 1;
int ci = n - (g1 * (n / k + 1) + g2 * (n / k));
if (g1 > 0) {
sum1 = Sum(ci, 0);
sum1 += solve(g1 - 1, g2);
}
if (g2 > 0) {
sum2 = Sum(ci, 1);
sum2 += solve(g1, g2 - 1);
}
return dp[g1][g2] = (sum2 <= sum1 ? sum2 : sum1);
}
int main() {
cin >> n >> k;
int md = n % k;
int g1 = md, g2 = k - md;
for (int i = 0; i < n; i++) cin >> arr[i];
sort(arr, arr + n);
memset((dp), -1, sizeof((dp)));
cout << solve(g1, g2) << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int dx[] = {0, 0, 1, -1};
int dy[] = {1, -1, 0, 0};
int arr[300004];
long long memo[5005][5005];
int S, L, c1, c2;
long long rec(int a, int b) {
if (a == S && b == L) return 0;
long long &res = memo[a][b];
if (~res) return res;
res = (1LL << 60);
int idx = a * c1 + b * c2;
if (a < S) res = min(res, rec(a + 1, b) + arr[idx + c1 - 1] - arr[idx]);
if (b < L) res = min(res, rec(a, b + 1) + arr[idx + c2 - 1] - arr[idx]);
return res;
}
int main() {
int n, k;
scanf("%d%d", &n, &k);
for (int i = (0); i < (n); i++) scanf("%d", arr + i);
sort(arr, arr + n);
c1 = n / k, c2 = c1 + 1;
L = n % k, S = k - L;
memset(memo, -1, sizeof(memo));
cout << rec(0, 0) << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int inf = 0x3f3f3f3f;
const double eps = 1e-8;
const double PI = acos(-1.0);
const int maxn = 3 * 100000;
const int maxk = 5000 + 10;
int A[maxn];
long long d[maxk][maxk];
int main() {
int n, k;
cin >> n >> k;
for (int i = 1; i <= n; i++) cin >> A[i];
sort(A + 1, A + 1 + n);
int big = n % k, small = k - n % k;
int bsz = n / k + 1, ssz = n / k;
memset(d, inf, sizeof(d));
d[0][0] = 0;
for (int i = 0; i <= big; i++) {
for (int j = 0; j <= small; j++) {
int id = i * bsz + j * ssz;
if (i >= 1) {
d[i][j] = min(d[i][j], d[i - 1][j] + A[id] - A[id - bsz + 1]);
}
if (j >= 1) {
d[i][j] = min(d[i][j], d[i][j - 1] + A[id] - A[id - ssz + 1]);
}
}
}
cout << d[big][small] << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long inf = 1e9 + 7, maxn = 1e6 + 100, mod = 998244353;
long long pref[maxn];
void solve() {
long long n, k;
cin >> n >> k;
vector<long long> a(n);
for (long long i = 0; i < n; ++i) cin >> a[i];
sort(a.begin(), a.end());
pref[0] = 0;
for (long long i = 1; i <= n; ++i) pref[i] = pref[i - 1] + a[i - 1];
long long x = n % k, y = k - (n % k), l = n / k;
vector<vector<long long> > dp(x + 1, vector<long long>(y + 1, 2 * inf));
dp[0][0] = 0;
for (long long i = 0; i <= x; ++i) {
for (long long j = 0; j <= y; ++j) {
if (i > 0)
dp[i][j] = min(dp[i][j], dp[i - 1][j] + a[i * (l + 1) + j * l - 1] -
a[(i - 1) * (l + 1) + j * l]);
if (j > 0)
dp[i][j] = min(dp[i][j], dp[i][j - 1] + a[i * (l + 1) + j * l - 1] -
a[i * (l + 1) + (j - 1) * l]);
}
}
cout << dp[x][y];
}
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
srand(100);
cout << fixed << setprecision(8);
long long t = 1;
while (t--) {
solve();
cout << "\n";
}
}
|
#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;
vector<vector<long long> > dp;
void Input() {
cin >> n >> k;
A.resize(n);
for (auto& x : A) cin >> x;
}
void Solve() {
sort(A.begin(), A.end());
long long Large = n / k + 1, Small = n / k;
long long LCnt = n % k, SCnt = k - LCnt;
dp.resize(LCnt + 1, vector<long long>(SCnt + 1, LINF));
dp[0][0] = 0;
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;
multiset<int> a;
int u[1000000];
int ar[1000000], dp[5002][5002];
int main() {
int n, k;
cin >> n >> k;
for (long long i = 0; i < n; i++) scanf("%d", &u[i]);
sort(u, u + n);
memset(ar, 0, sizeof(ar));
int l = n % k, sz = n / k;
dp[0][0] = 0;
for (long long i = 1; i < l + 1; i++)
dp[i][0] = u[i * (sz + 1) - 1] - u[(i - 1) * (sz + 1)] + dp[i - 1][0];
for (long long i = 1; i < k - l + 1; i++)
dp[0][i] = u[i * sz - 1] - u[(i - 1) * sz] + dp[0][i - 1];
for (long long i = 1; i < l + 1; i++)
for (long long j = 1; j < k - l + 1; j++)
dp[i][j] = min(dp[i - 1][j] - u[(i - 1) * (sz + 1) + j * sz],
dp[i][j - 1] - u[i * (sz + 1) + (j - 1) * sz]) +
u[i * (sz + 1) + j * sz - 1];
cout << dp[l][k - l] << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
const int INF = 2000000000;
struct debugger {
template <typename T>
debugger& operator,(const T& v) {
cerr << v << " ";
return *this;
}
} dbg;
int dp[5001][5001];
int main() {
int N, k;
scanf("%d", &N), scanf("%d", &k);
vector<int> A(N);
for (int i = 0; i < (N); i++) scanf("%d", &A[i]);
sort((A).begin(), (A).end());
int a = N % k, b = k - N % k;
for (int i = (0); i <= (a); i++)
for (int j = (0); j <= (b); j++) dp[i][j] = -INF;
dp[0][0] = 0;
for (int i = (0); i <= (a); i++)
for (int j = (0); j <= (b); j++) {
int n = i * (N / k + 1) + j * (N / k);
if (i > 0) {
dp[i][j] = max(dp[i][j], dp[i - 1][j] + (n < N ? A[n] - A[n - 1] : 0));
}
if (j > 0) {
dp[i][j] = max(dp[i][j], dp[i][j - 1] + (n < N ? A[n] - A[n - 1] : 0));
}
}
printf("%d\n", A[N - 1] - A[0] - dp[a][b]);
}
|
#include <bits/stdc++.h>
using namespace std;
const long long inf = 1100000000000000000;
void solve() {
long long n, k;
cin >> n >> k;
long long a[n];
for (long long i = 0; i < n; i++) cin >> a[i];
sort(a, a + n);
long long dp[k + 5][k + 5];
memset(dp, 0, sizeof(dp));
long long x = n % k, c = (n + k - 1) / k, s = n / k;
;
long long y = k - x;
for (long long i = 0; i <= x; i++)
for (long long j = 0; j <= y; j++) dp[i][j] = inf;
dp[0][0] = 0;
for (long long i = 0; i <= x; i++) {
if (i)
for (long long j = 0; j <= y; j++) {
long long idx = (i - 1) * c + s * j;
dp[i][j] = min(dp[i][j], abs(a[idx + c - 1] - a[idx]) + dp[i - 1][j]);
}
for (long long j = 1; j <= y; j++) {
long long idx = i * c + s * (j - 1);
dp[i][j] = min(dp[i][j], abs(a[idx + s - 1] - a[idx]) + dp[i][j - 1]);
}
}
cout << dp[x][y];
}
signed main() {
ios_base::sync_with_stdio(false), cin.tie(nullptr);
long long T = 1;
while (T--) {
solve();
cout << '\n';
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <class T>
void chmin(T &t, const T &f) {
if (t > f) t = f;
}
template <class T>
void chmax(T &t, const T &f) {
if (t < f) t = f;
}
long long int n, k, a[3 * 100005], dp[5005][5005];
int main() {
scanf("%I64d %I64d", &n, &k);
for (int i = 0; i < n; ++i) scanf("%I64d", &a[i]);
sort(a, a + n);
for (int i = 0; i < 5005; ++i) {
for (int j = 0; j < 5005; ++j) dp[i][j] = 1e14;
}
dp[0][0] = 0;
for (int i = 0; i < 5005; ++i) {
for (int j = 0; j < 5005; ++j) {
long long int st = i * (n / k + 1) + j * (n / k);
if (st >= n) continue;
long long int le = st + (n / k);
if (le < n) dp[i + 1][j] = min(dp[i + 1][j], dp[i][j] + a[le] - a[st]);
long long int se = st + (n / k) - 1;
if (se < n) dp[i][j + 1] = min(dp[i][j + 1], dp[i][j] + a[se] - a[st]);
}
}
long long int ale = n % k;
long long int ase = k - (n % k);
printf("%I64d", dp[ale][ase]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
vector<int> ar;
vector<vector<long long>> dp;
vector<vector<int>> vis;
int n, k, lenl, lens;
long long solve(int l, int s) {
if (vis[l][s] or !l and !s) return dp[l][s];
int last = l * lenl + s * lens - 1;
if (!s)
dp[l][s] = solve(l - 1, s) + ar[last] - ar[last - lenl + 1];
else if (!l)
dp[l][s] = solve(l, s - 1) + ar[last] - ar[last - lens + 1];
else
dp[l][s] = min(solve(l - 1, s) + ar[last] - ar[last - lenl + 1],
solve(l, s - 1) + ar[last] - ar[last - lens + 1]);
vis[l][s] = true;
return dp[l][s];
}
int main() {
ios::sync_with_stdio(false);
cin.tie(NULL);
cin >> n >> k;
lenl = n / k + 1;
lens = lenl - 1;
ar.resize(n);
for (auto &i : ar) cin >> i;
sort(ar.begin(), ar.end());
dp.resize(n % k + 1);
vis.resize(n % k + 1);
for (auto &i : dp) i.resize(k - n % k + 1);
for (auto &i : vis) i.resize(k - n % k + 1);
cout << solve(n % k, k - n % k) << '\n';
}
|
#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 = 0; j <= t; 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;
inline char skipwhitespace() {
char ch = getchar();
while (ch == ' ' || ch == '\n' || ch == '\r' || ch == '\t') ch = getchar();
return ch;
}
void gi(int &x) {
register int c = getchar();
x = 0;
int sn = 1;
for (; (c < 48 || c > 57); c = getchar())
if (c == '-') sn = -1;
for (; c > 47 && c < 58; c = getchar()) {
x = (x << 1) + (x << 3) + c - 48;
}
x *= sn;
}
void gii(long long int &x) {
register long long int c = getchar();
x = 0;
long long int sn = 1;
for (; (c < 48 || c > 57); c = getchar())
if (c == '-') sn = -1;
for (; c > 47 && c < 58; c = getchar()) {
x = (x << 1) + (x << 3) + c - 48;
}
x *= sn;
}
void wi(int n) {
int sign = n >= 0 ? 1 : -1;
n = n > 0 ? n : -n;
char buf[10];
int i = 9;
if (!n) buf[i--] = 48;
while (n) {
buf[i--] = n % 10 + 48;
n /= 10;
}
if (sign < 0) printf("%c", '-');
while (++i < 10) printf("%c", buf[i]);
}
void wii(long long int n) {
long long int sign = n >= 0 ? 1 : -1;
n = n > 0 ? n : -n;
char buf[25];
long long int i = 24;
if (!n) buf[i--] = 48;
while (n) {
buf[i--] = n % 10 + 48;
n /= 10;
}
if (sign < 0) printf("%c", '-');
while (++i < 25) printf("%c", buf[i]);
}
int gs(char *s) {
char ch = skipwhitespace();
int n = 0;
while ((ch != '\n' && ch != ' ' && ch != '\t')) {
s[n++] = ch;
ch = getchar();
}
s[n] = 0;
return n;
}
void ws(char *s) {
char *p = s;
while (*p) {
printf("%c", *p);
p++;
}
}
long long int a[1000006], dp[5055][5055];
int main() {
long long int n, k, x, y, tsz;
gii(n);
gii(k);
for (int i = 0; i < n; i++) gii(a[i]);
sort(a, a + n);
y = n % k;
x = k - y;
tsz = n / k;
for (int i = 0; i < x + 1; i++)
for (int j = 0; j < y + 1; j++) dp[i][j] = 1ll * 1 << 60;
dp[0][0] = 0;
for (int i = 0; i < x + 1; i++)
for (int j = 0; j < y + 1; j++) {
int z = (i + j) * tsz + j;
dp[i + 1][j] = min(dp[i + 1][j], dp[i][j] + a[z + tsz - 1] - a[z]);
dp[i][j + 1] = min(dp[i][j + 1], dp[i][j] + a[z + tsz] - a[z]);
}
wii(dp[x][y]);
printf("\n");
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int K = 5010;
const int N = (int)5e5;
const long long INF = (long long)1e18;
int n, k, a[N];
long long dp[K][K];
int main() {
scanf("%d %d", &n, &k);
for (int i = 0; i < n; i++) {
scanf("%d", &a[i]);
}
sort(a, a + n);
int s0 = n / k;
int s1 = s0 + 1;
int q1 = n % k;
int q0 = k - q1;
for (int i = 0; i <= q0; i++) {
for (int j = 0; j <= q1; j++) {
dp[i][j] = INF;
}
}
dp[0][0] = 0;
for (int i = 0; i <= q0; i++) {
for (int j = 0; j <= q1; j++) {
int u = i * s0 + j * s1;
if (i < q0) {
dp[i + 1][j] = min(dp[i + 1][j], dp[i][j] + a[u + s0 - 1] - a[u]);
}
if (j < q1) {
dp[i][j + 1] = min(dp[i][j + 1], dp[i][j] + a[u + s1 - 1] - a[u]);
}
}
}
printf("%I64d\n", dp[q0][q1]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using pii = pair<int, int>;
using pll = pair<ll, ll>;
using ld = long double;
const int mod = 1e9 + 7;
const ll inf = 1e9;
const ll INF = 2e18;
const int N = 2e6 + 66;
const int M = 5005;
ll a[N], dp[5005][5005];
void solve() {
int n, k;
cin >> n >> k;
for (int i = 0; i < n; ++i) {
cin >> a[i];
}
sort(a, a + n);
for (int i = 0; i <= k; ++i) {
for (int j = 0; j <= k; ++j) {
dp[i][j] = INF;
}
}
dp[0][0] = 0;
for (int i = 0; i <= k; ++i) {
for (int j = 0; j <= n % k; ++j) {
if (dp[i][j] == INF) continue;
int pos = i * (n / k) + j;
dp[i + 1][j] = min(dp[i + 1][j], dp[i][j] + a[pos + n / k - 1] - a[pos]);
dp[i + 1][j + 1] =
min(dp[i + 1][j + 1], dp[i][j] + a[pos + n / k] - a[pos]);
}
}
cout << dp[k][n % k];
}
int main() {
ios_base::sync_with_stdio(0), cin.tie(0), cout.tie(0);
;
int tt = 1;
while (tt--) {
solve();
cout << "\n";
}
}
|
#include <bits/stdc++.h>
using namespace std;
const long long Maxn = 3e5 + 20;
const long long Max = 5e3 + 7;
const long long Mod = 1e9 + 7;
const long long Inf = 1e9 + 7;
long long a[Maxn], b[Maxn], dp[Max][Max];
int main() {
ios_base::sync_with_stdio(false);
long long n, k, ans = 0;
cin >> n >> k;
for (long long i = 0; i < n; i++) cin >> a[i];
sort(a, a + n);
for (long long i = 1; i < n; i++) b[i] = a[i] - a[i - 1], ans += b[i];
long long t1 = n / k;
long long t2 = n / k + 1;
long long p2 = n % k;
long long p1 = k - p2;
for (long long i = 0; i <= p1; i++) {
for (long long j = 0; j <= p2; j++) {
long long p = i * t1 + j * t2;
if (i) dp[i][j] = dp[i - 1][j] + b[p - t1];
if (j) dp[i][j] = max(dp[i][j], dp[i][j - 1] + b[p - t2]);
}
}
cout << ans - dp[p1][p2] << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int N, K;
int A[300005];
int num[5005];
long long dp[5005][5005];
long long rec(int l, int r, int pos) {
if (l > r) return 0;
long long& ret = dp[l][r];
if (ret != -1) return ret;
if (num[l] == 0) return ret = rec(l + 1, r, pos);
if (num[r] == 0) return ret = rec(l, r - 1, pos);
ret = min(
rec(l + 1, r, pos + num[l]) + (long long)A[pos + num[l] - 1] - A[pos],
rec(l, r - 1, pos + num[r]) + (long long)A[pos + num[r] - 1] - A[pos]);
return ret;
}
int main() {
memset(dp, -1, sizeof dp);
scanf("%d%d", &N, &K);
for (int i = 0; i < N; i++) scanf("%d", A + i), num[i % K]++;
sort(A, A + N);
printf("%lld\n", rec(0, K - 1, 0));
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 5007;
const int maxc = 3e5 + 7;
long long dp[maxn][maxn];
long long ar[maxc];
int n, k, tp;
int main() {
cin >> n >> k;
for (int i = 1; i <= n; i++) scanf("%I64d", &ar[i]);
sort(ar + 1, ar + n + 1);
int sg = n / k;
int lg = sg + 1;
int ns = k - n % k;
int nl = n % k;
for (int i = 0; i <= ns; i++)
for (int j = 0; j <= nl; j++) dp[i][j] = 2e18;
dp[0][0] = 0;
for (int i = 0; i <= ns; i++)
for (int j = 0; j <= nl; j++) {
int tp = sg * (i - 1) + lg * j;
int td = sg * i + lg * (j - 1);
if (i) dp[i][j] = min(dp[i][j], dp[i - 1][j] + ar[tp + sg] - ar[tp + 1]);
if (j) dp[i][j] = min(dp[i][j], dp[i][j - 1] + ar[td + lg] - ar[td + 1]);
}
printf("%I64d\n", dp[ns][nl]);
return 0;
}
|
#include <bits/stdc++.h>
#pragma warning(disable : 4996)
using namespace std;
long long dyn[5001][5001];
int A[300000];
int main() {
int n, k;
scanf("%d", &(n));
scanf("%d", &(k));
for (int(i) = 0; (i) < n; (i)++) scanf("%d", &(A[i]));
sort(A, A + n);
int rem = n % k;
int q = n / k;
for (int i = 0; i <= k; i++) {
if (i == 0) {
dyn[0][0] = 0;
dyn[0][1] = -1;
continue;
}
int j = min(i, rem);
for (int t = 0; t <= j; t++) {
dyn[i][t] = 2000000000;
if (t > 0) {
dyn[i][t] = min(dyn[i][t], dyn[i - 1][t - 1] + A[i * q + t - 1] -
A[(i - 1) * q + t - 1]);
}
if (dyn[i - 1][t] != -1) {
dyn[i][t] = min(dyn[i][t],
dyn[i - 1][t] + A[i * q + t - 1] - A[(i - 1) * q + t]);
}
}
dyn[i][j + 1] = -1;
}
printf("%I64d", dyn[k][rem]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, k, A[300000];
long long done[5001][5001];
int main() {
cin >> n >> k;
for (int i = 0; i < n; i++) scanf("%d", &A[i]);
sort(A, A + n);
int x = n / k, y = n % k;
for (int i = 1; i < k + 1; i++)
for (int j = 0; j < min(y, i) + 1; j++) {
if (j == 0)
done[i][0] = done[i - 1][0] + A[x * i - 1] - A[x * (i - 1)];
else if (i == j)
done[i][j] =
done[i - 1][j - 1] + A[x * i + j - 1] - A[x * (i - 1) + j - 1];
else {
done[i][j] =
done[i - 1][j - 1] + A[x * i + j - 1] - A[x * (i - 1) + j - 1];
done[i][j] = min(
done[i][j], done[i - 1][j] + A[x * i + j - 1] - A[x * (i - 1) + j]);
}
}
cout << done[k][y];
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
inline int Readint() {
int ret = 0;
int f = 1;
char ch;
do {
ch = getchar();
if (ch == '-') f *= -1;
} while (ch >= 0 && (ch < '0' || ch > '9'));
while ('0' <= ch && ch <= '9') {
ret = ret * 10 + ch - '0';
ch = getchar();
}
return ret * f;
}
void open() {
freopen("B.in", "r", stdin);
freopen("B.out", "w", stdout);
}
void close() {
fclose(stdin);
fclose(stdout);
}
const int MAXN = 3E5 + 10;
int n, k;
int a[MAXN] = {0};
long long pre[MAXN] = {0};
long long dp[5005][5005] = {0};
void init() {
n = Readint(), k = Readint();
for (int i = 1, _END_ = n; i <= _END_; i++) a[i] = Readint();
sort(a + 1, a + 1 + n);
for (int i = 1, _END_ = n; i <= _END_; i++)
pre[i] = pre[i - 1] + a[i] - a[i - 1];
}
const long long inf = 1LL << 61;
void work() {
for (int i = 0, _END_ = k; i <= _END_; i++)
for (int j = 0, _END_ = k; j <= _END_; j++) dp[i][j] = 1LL << 61;
dp[0][0] = 0;
int d = n / k, dd = n % k;
for (int i = 0, _END_ = k - 1; i <= _END_; i++) {
for (int j = 0, _END_ = min(i, dd); j <= _END_; j++)
if (dp[i][j] != inf) {
dp[i + 1][j] = min(
dp[i + 1][j], dp[i][j] + pre[d * (i + 1) + j] - pre[d * i + 1 + j]);
if (j < dd)
dp[i + 1][j + 1] =
min(dp[i + 1][j + 1],
dp[i][j] + pre[d * (i + 1) + j + 1] - pre[d * i + 1 + j]);
}
}
printf("%I64d\n", dp[k][dd]);
}
int main() {
int _ = 0;
init();
work();
close();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long dyn[5007][5007];
long long A[300007];
int main() {
int N, K;
scanf("%d %d ", &N, &K);
;
for (int i = (0); i < (N); i++) cin >> A[i];
sort(A, A + N);
int len = (N - 1) / K + 1;
int shortsCnt = (K - N % K) % K;
for (int groups = (1); groups < (K); groups++) {
for (int shorts = (0); shorts < (min(groups, shortsCnt) + 1); shorts++) {
dyn[groups][shorts] = dyn[groups - 1][shorts];
if (shorts > 0)
dyn[groups][shorts] =
max(dyn[groups][shorts], dyn[groups - 1][shorts - 1]);
dyn[groups][shorts] +=
A[groups * len - shorts] - A[groups * len - shorts - 1];
}
}
long long saved = dyn[K - 1][shortsCnt];
if (shortsCnt > 0) saved = max(saved, dyn[K - 1][shortsCnt - 1]);
cout << A[N - 1] - A[0] - saved << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
struct _ {
ios_base::Init i;
_() {
cin.sync_with_stdio(0);
cin.tie(0);
}
} _;
int main(int argc, char** argv) {
int n, k;
cin >> n >> k;
vector<int> a(n);
for (int i = (0); i < (n); ++i) cin >> a[i];
sort(a.begin(), a.end());
int num_large = n % k;
int num_small = k - n % k;
long long** dp = new long long*[num_large + 1];
for (int i = (0); i < (num_large + 1); ++i) {
dp[i] = new long long[num_small + 1];
}
dp[0][0] = 0;
for (int i = (0); i < (num_large + 1); ++i) {
for (int j = (0); j < (num_small + 1); ++j) {
if (!i && !j) continue;
dp[i][j] = 1LL << 60;
int st, ed;
long long diff;
if (i > 0) {
st = (i - 1) * (n / k + 1) + j * (n / k);
ed = st + (n / k + 1) - 1;
diff = a[ed] - a[st];
dp[i][j] = min(dp[i][j], dp[i - 1][j] + diff);
}
if (j > 0) {
st = i * (n / k + 1) + (j - 1) * (n / k);
ed = st + n / k - 1;
diff = a[ed] - a[st];
dp[i][j] = min(dp[i][j], dp[i][j - 1] + diff);
}
}
}
cout << dp[num_large][num_small];
return 0;
}
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.