text stringlengths 49 983k |
|---|
#include <bits/stdc++.h>
using namespace std;
template <typename T>
void minimize(T &a, T b) {
a = min(a, b);
}
template <typename T>
void maximize(T &a, T b) {
a = max(a, b);
}
const long long INF = 0x3f3f3f3f3f3f3f3f;
const int N = 22;
int n, m;
long long c[N][N], sum[N][30];
long long dp[1 << N - 2], pos[1 << N - 2];
long long cost[N][30], mask[N][30], mx[N][30];
string str[N];
int main() {
ios::sync_with_stdio(0);
cin >> n >> m;
for (int i = 1; i <= n; ++i) {
cin >> str[i];
str[i] = ' ' + str[i];
}
for (int i = 1; i <= n; ++i)
for (int j = 1; j <= m; ++j) cin >> c[i][j];
for (int j = 1; j <= m; ++j) {
for (int i = 1; i <= n; ++i) {
cost[j][str[i][j] - 'a'] += c[i][j];
mask[j][str[i][j] - 'a'] ^= (1 << i - 1);
maximize(mx[j][str[i][j] - 'a'], c[i][j]);
}
for (int i = 'a'; i <= 'z'; ++i) cost[j][i - 'a'] -= mx[j][i - 'a'];
}
for (int msk = 0; msk < (1 << n); ++msk)
for (int j = 0; j < n; ++j)
if (!(msk >> j & 1)) {
pos[msk] = j;
break;
}
memset(dp, 0x3f, sizeof dp);
dp[0] = 0;
for (int msk = 0; msk < (1 << n); ++msk)
if (dp[msk] != INF) {
int idx = pos[msk];
for (int j = 1; j <= m; ++j) {
minimize(dp[msk | (1 << idx)], dp[msk] + c[idx + 1][j]);
minimize(dp[msk | mask[j][str[idx + 1][j] - 'a']],
dp[msk] + cost[j][str[idx + 1][j] - 'a']);
}
}
cout << dp[(1 << n) - 1];
}
|
#include <bits/stdc++.h>
using namespace std;
char str[110][110];
int num[110][110], sta[110][110], sum[110][110], f[2000010], n, m;
int main() {
scanf("%d%d", &n, &m);
for (int i = 1; i <= n; i++) scanf("%s", str[i] + 1);
for (int i = 1; i <= n; i++)
for (int j = 1; j <= m; j++) scanf("%d", &num[i][j]);
for (int i = 1; i <= n; i++)
for (int j = 1; j <= m; j++) {
int mx = 0;
for (int k = 1; k <= n; k++)
if (str[i][j] == str[k][j])
sta[i][j] |= 1 << (k - 1), mx = max(mx, num[k][j]),
sum[i][j] += num[k][j];
sum[i][j] -= mx;
}
for (int i = 1; i < (1 << n); i++) f[i] = 1000000000;
for (int i = 0; i < (1 << n); i++)
for (int j = 1; j <= n; j++)
if (!((i >> (j - 1)) & 1))
for (int k = 1; k <= m; k++) {
f[i | (1 << (j - 1))] = min(f[i | (1 << (j - 1))], f[i] + num[j][k]);
f[i | sta[j][k]] = min(f[i | sta[j][k]], f[i] + sum[j][k]);
}
printf("%d\n", f[(1 << n) - 1]);
}
|
#include <bits/stdc++.h>
using namespace std;
char s[21][21];
int w[21][21], sm[21][21], cs[21][21];
int dp[1 << 21], n, m;
void dispose() {
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
int al = 0, mx = 0;
for (int k = 0; k < n; k++) {
if (s[i][j] == s[k][j]) {
al += w[k][j];
mx = max(mx, w[k][j]);
sm[i][j] |= (1 << k);
}
}
cs[i][j] = al - mx;
}
}
memset(dp, 0x3f, sizeof dp);
dp[0] = 0;
for (int s = 0; s < (1 << n); s++) {
for (int i = 0; i < n; i++) {
if (!(s >> i & 1)) {
for (int j = 0; j < m; j++) {
dp[s | (1 << i)] = min(dp[s | (1 << i)], dp[s] + w[i][j]);
dp[s | sm[i][j]] = min(dp[s | sm[i][j]], dp[s] + cs[i][j]);
}
}
}
}
}
int main() {
cin >> n >> m;
for (int i = 0; i < n; i++) {
scanf("%s", s[i]);
}
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
scanf("%d", &w[i][j]);
}
}
dispose();
printf("%d\n", dp[(1 << n) - 1]);
return 0;
}
|
#include <bits/stdc++.h>
const int oo = 1e9;
int n, m, cost[22][22], cb[22][22], cc[22][22], d[1 << 20], lb;
char String[22][22];
int main(void) {
scanf("%d%d", &n, &m);
for (int i = 0; i < n; i++) {
scanf("%s", String[i]);
}
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) scanf("%d", &cost[i][j]);
}
for (int i = 0; i < n; i++) {
for (int k = 0; k < m; k++) {
int Max = 0;
for (int j = 0; j < n; j++) {
if (String[i][k] == String[j][k]) {
cb[i][k] |= (1 << j);
cc[i][k] += cost[j][k];
if (cost[j][k] > Max) Max = cost[j][k];
}
}
cc[i][k] -= Max;
}
}
for (int i = 0; i < (1 << n); i++) d[i] = oo;
d[0] = 0;
for (int i = 1; i < (1 << n); i++) {
for (int j = 0; j < n; j++)
if ((i >> j) & 1) {
lb = j;
break;
}
for (int j = 0; j < m; j++)
d[i] = ((((d[i]) > (d[i & (i ^ cb[lb][j])] + cc[lb][j])
? (d[i & (i ^ cb[lb][j])] + cc[lb][j])
: (d[i]))) > (d[i ^ (1 << lb)] + cost[lb][j])
? (d[i ^ (1 << lb)] + cost[lb][j])
: (((d[i]) > (d[i & (i ^ cb[lb][j])] + cc[lb][j])
? (d[i & (i ^ cb[lb][j])] + cc[lb][j])
: (d[i]))));
}
printf("%d", d[(1 << n) - 1]);
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m, dp[1501001], c[111][111], st[111][111], f[111][111];
char s[111][111];
int main() {
scanf("%d%d", &n, &m);
for (int i = 1; i <= n; i++) scanf("%s", s[i] + 1);
for (int i = 1; i <= n; i++)
for (int j = 1; j <= m; j++) scanf("%d", &c[i][j]);
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
int mx = 0;
for (int k = 1; k <= n; k++) {
if (s[i][j] != s[k][j]) continue;
mx = max(mx, c[k][j]);
st[i][j] |= 1 << (k - 1);
f[i][j] += c[k][j];
}
f[i][j] -= mx;
}
}
memset(dp, 0x7f, sizeof(dp));
int up = (1 << n) - 1;
dp[0] = 0;
for (int i = 0; i <= up; i++) {
for (int j = 1; j <= n; j++) {
if ((i >> (j - 1)) & 1) continue;
int x = 1 << (j - 1);
for (int k = 1; k <= m; k++) {
int b = st[j][k];
dp[i | x] = min(dp[i | x], dp[i] + c[j][k]);
dp[i | b] = min(dp[i | b], dp[i] + f[j][k]);
}
}
}
printf("%d", dp[up]);
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m, i, j, k, q;
int f[1100000], a[22][22], t[22][22], w[22][22];
char s[22][22];
int main() {
scanf("%d %d", &n, &m);
for (i = 1; i <= n; ++i) scanf("\n%s", s[i]);
for (i = 1; i <= n; ++i)
for (j = 1; j <= m; ++j) scanf("%d", &a[i][j]);
for (i = 1; i <= n; ++i)
for (j = 1; j <= m; ++j) {
q = 0;
for (k = 1; k <= n; ++k)
if (s[k][j - 1] == s[i][j - 1]) {
t[i][j] += (1 << (k - 1));
w[i][j] += a[k][j];
q = max(q, a[k][j]);
}
w[i][j] -= q;
}
for (k = 1; k < (1 << n); ++k) f[k] = 1e9;
for (k = 0; k + 1 < (1 << n); ++k) {
for (j = 1; j <= n; ++j)
if (((k >> (j - 1)) & 1) == 0) {
i = j;
break;
}
for (j = 1; j <= m; ++j) {
f[(k | (1 << (i - 1)))] = min(f[(k | (1 << (i - 1)))], f[k] + a[i][j]);
f[(k | t[i][j])] = min(f[(k | t[i][j])], f[k] + w[i][j]);
}
}
printf("%d", f[(1 << n) - 1]);
}
|
#include <bits/stdc++.h>
using namespace std;
char s[25][25];
int dp[(1 << 20) + 5], a[25][25], same[25][25];
int main() {
int n, m;
scanf("%d %d", &n, &m);
for (int i = (0); i < (n); ++i) scanf("%s", s[i]);
for (int i = (0); i < (n); ++i)
for (int j = (0); j < (m); ++j) scanf("%d", &a[i][j]);
for (int i = (0); i < (n); ++i)
for (int j = (0); j < (m); ++j) {
int S = 0;
for (int k = (0); k < (n); ++k)
if (s[k][j] == s[i][j]) S |= (1 << k);
same[i][j] = S;
}
for (int mask = (1 << n) - 2; mask >= 0; mask--) {
int k = 0;
for (int i = (0); i < (n); ++i)
if (!(mask & (1 << i))) {
k = i;
break;
}
dp[mask] = 1000000000;
for (int i = (0); i < (m); ++i) {
int S = same[k][i];
int maxi = -1000000000, sum = 0;
for (int j = (0); j < (n); ++j)
if (S & (1 << j)) sum += a[j][i], maxi = max(maxi, a[j][i]);
dp[mask] = min(dp[mask], sum - maxi + dp[mask | S]);
dp[mask] = min(dp[mask], a[k][i] + dp[mask | (1 << k)]);
}
}
printf("%d\n", dp[0]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
char str[25][25];
int a[25][25], cost[25][25];
int dp[1 << 21], mark[25][25];
int main() {
int i, j, k, n, m;
scanf("%d%d", &n, &m);
for (i = 0; i <= n - 1; i++) {
scanf("%s", str[i]);
}
for (i = 0; i <= n - 1; i++) {
for (j = 0; j <= m - 1; j++) {
scanf("%d", &a[i][j]);
}
}
memset(mark, 0, sizeof(mark));
for (i = 0; i <= n - 1; i++) {
for (k = 0; k <= m - 1; k++) {
int maxn = 0;
for (j = 0; j <= n - 1; j++) {
if (str[i][k] == str[j][k]) {
mark[i][k] |= (1 << j);
cost[i][k] += a[j][k];
maxn = max(maxn, a[j][k]);
}
}
cost[i][k] -= maxn;
}
}
int s = (1 << n);
for (i = 0; i <= s; i++) {
dp[i] = 0x3f3f3f3f;
}
int first;
dp[0] = 0;
for (k = 0; k <= s - 1; k++) {
for (first = 0; k & (1 << first); first++)
;
for (i = 0; i <= m - 1; i++) {
dp[k | (1 << first)] = min(dp[k | (1 << first)], dp[k] + a[first][i]);
dp[k | mark[first][i]] =
min(dp[k | mark[first][i]], dp[k] + cost[first][i]);
}
}
printf("%d ", dp[s - 1]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 5e5, maxl = 30, maxm = 1 << 21, oo = 1e9;
char s[maxl][maxl];
int f[maxm];
int a[maxl][maxl];
int w[maxl][maxl];
int num[maxl][maxl];
int d[maxl];
int n, m, i, j, k, M, u;
int main() {
scanf("%d%d", &n, &m);
d[0] = 1;
for (i = 1; i <= 25; i++) d[i] = d[i - 1] << 1;
for (i = 1; i <= n; i++) scanf("%s", s[i] + 1);
for (i = 1; i <= n; i++)
for (j = 1; j <= m; j++) scanf("%d", &a[i][j]);
for (i = 1; i <= n; i++)
for (j = 1; j <= m; j++) {
int &sum = w[i][j], &N = num[i][j], Max = 0;
N |= d[i - 1];
for (k = 1; k <= n; k++)
if (s[i][j] == s[k][j]) {
Max = max(Max, a[k][j]);
sum += a[k][j];
N |= d[k - 1];
}
sum -= Max;
}
M = 1 << n;
for (i = 1; i < M; i++) f[i] = oo;
for (u = 0; u < M; u++) {
int l = 0;
for (i = 1; i <= n; i++)
if (!(d[i - 1] & u)) {
l = i;
break;
}
for (i = 1; i <= m; i++)
f[u + d[l - 1]] = min(f[u + d[l - 1]], f[u] + a[l][i]);
for (i = 1; i <= m; i++) {
int nex = u | num[l][i];
f[nex] = min(f[nex], f[u] + w[l][i]);
}
}
printf("%d", f[M - 1]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 60;
const int INF = 1e9;
int n, m;
int cost[N][N];
pair<int, int> bitr[N][N];
int d[1 << 20];
vector<string> s;
map<int, int> pows;
int lazy(int mask) {
if (d[mask] == -1) {
d[mask] = INF;
int last = pows[mask - (mask & (mask - 1))];
for (int c = 0; c < m; c++) {
d[mask] = min(lazy(mask & ~(1 << last)) + cost[last][c], d[mask]);
d[mask] = min(bitr[last][c].second + lazy(mask & ~bitr[last][c].first),
d[mask]);
}
}
return d[mask];
}
int main() {
cin >> n >> m;
s.resize(n);
for (int i = 0; i < n; i++) {
cin >> s[i];
}
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
cin >> cost[i][j];
}
}
for (int i = 0; i < n; i++) {
for (int c = 0; c < m; c++) {
int M = 0;
for (int k = 0; k < n; k++) {
if (s[i][c] == s[k][c]) {
bitr[i][c].first += 1 << k;
bitr[i][c].second += cost[k][c];
M = max(M, cost[k][c]);
}
}
bitr[i][c].second -= M;
}
}
memset(d, 255, sizeof d);
pows[1] = 0;
d[0] = 0;
int val = 1;
for (int i = 0; i < 19; i++) {
val *= 2;
pows[val] = i + 1;
}
cout << lazy((1 << n) - 1);
}
|
#include <bits/stdc++.h>
using namespace std;
int Num;
char CH[20];
const int inf = 1 << 29;
inline long long read() {
int x = 0, f = 1;
char ch = getchar();
while (ch < '0' || ch > '9') {
if (ch == '-') f = -1;
ch = getchar();
}
while (ch >= '0' && ch <= '9') {
x = x * 10 + ch - '0';
ch = getchar();
}
return x * f;
}
inline void P(int x) {
Num = 0;
if (!x) {
putchar('0');
puts("");
return;
}
while (x > 0) CH[++Num] = x % 10, x /= 10;
while (Num) putchar(CH[Num--] + 48);
puts("");
}
int a[40][40];
string s[40];
int d[1 << 20];
int p[40];
int main() {
int n = read(), m = read();
for (int i = 0; i < n; i++) cin >> s[i];
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++) cin >> a[i][j];
for (int j = 0; j < 1 << n; j++) d[j] = inf;
d[0] = 0;
for (int i = 0; i < m; i++) {
for (int j = 0; j < 26; j++) p[j] = 0;
for (int j = 0; j < n; j++) p[s[j][i] - 'a'] |= 1 << j;
for (int j = 0; j < 26; j++) {
int t = 0, mx = 0;
for (int k = 0; k < n; k++) {
if (p[j] >> k & 1) {
for (int l = 0; l < 1 << n; l++)
d[l | (1 << k)] = min(d[l | (1 << k)], d[l] + a[k][i]);
t += a[k][i];
mx = max(mx, a[k][i]);
}
}
for (int l = 0; l < 1 << n; l++)
d[l | p[j]] = min(d[l | p[j]], d[l] + t - mx);
}
}
cout << d[(1 << n) - 1] << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
using lli = long long;
using ld = long double;
mt19937 rnd(time(nullptr));
const lli inf = 1e18;
lli Bit(lli mask, lli i) { return (mask >> i) & 1; }
inline void Solve() {
lli n = 0, m = 0;
cin >> n >> m;
vector<string> data(n);
for (auto &it : data) cin >> it;
vector<vector<lli>> cost(n, vector<lli>(m));
for (lli i = 0; i < n; i++) {
for (lli j = 0; j < m; j++) cin >> cost[i][j];
}
vector<vector<pair<lli, lli>>> buffer(n, vector<pair<lli, lli>>(m));
for (lli i = 0; i < n; i++) {
for (lli j = 0; j < m; j++) {
lli mx = 0;
for (lli k = 0; k < n; k++) {
if (data[i][j] == data[k][j]) {
buffer[i][j].first |= (1 << k);
buffer[i][j].second += cost[k][j];
mx = max(mx, cost[k][j]);
}
}
buffer[i][j].second -= mx;
}
}
vector<lli> dp((1 << n), inf);
dp[0] = 0;
for (lli mask = 0; mask < (1 << n); mask++) {
if ((dp[mask] == inf) || (mask == (1 << n) - 1)) continue;
lli id = -1;
for (lli i = n - 1; i >= 0; i--) {
if (Bit(mask, i) == 0) {
id = i;
break;
}
}
for (lli i = 0; i < m; i++) {
lli mask1 = buffer[id][i].first, value = buffer[id][i].second;
dp[mask | mask1] = min(dp[mask | mask1], dp[mask] + value);
dp[mask | (1 << id)] = min(dp[mask | (1 << id)], dp[mask] + cost[id][i]);
}
}
cout << dp.back();
}
signed main() {
cout << fixed << setprecision(20);
Solve();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int INF = 0x3f3f3f3f, MAXN = 20 + 10;
int dp[1 << 20];
int a[MAXN][MAXN], cost[MAXN][MAXN], to[MAXN][MAXN];
char s[MAXN][MAXN];
int main() {
int n, m;
while (~scanf("%d %d%*c", &n, &m)) {
for (int i = 0; i < n; i++) scanf("%s", s[i]);
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) scanf("%d%*c", &a[i][j]);
}
memset(to, 0, sizeof(to));
for (int j = 0; j < m; j++) {
for (int i = 0; i < n; i++) {
int mx = 0, sum = 0;
for (int k = 0; k < n; k++) {
if (s[i][j] == s[k][j]) {
to[i][j] |= 1 << k;
mx = max(mx, a[k][j]);
sum += a[k][j];
}
}
cost[i][j] = sum - mx;
}
}
memset(dp, 0x3f, sizeof(dp));
dp[0] = 0;
int ALL = (1 << n) - 1;
for (int s = 0; s < ALL; s++) {
if (INF == dp[s]) continue;
for (int i = 0; i < n; i++) {
if (0 == (s & (1 << i))) {
for (int j = 0; j < m; j++) {
dp[s | (1 << i)] = min(dp[s | (1 << i)], dp[s] + a[i][j]);
dp[s | to[i][j]] = min(dp[s | to[i][j]], dp[s] + cost[i][j]);
}
break;
}
}
}
printf("%d\n", dp[ALL]);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m;
char s[30][30];
int f[(1 << 20) + 10];
int cost[30][30], tot_cost[30][30];
int change[30][30];
void init() {
memset(tot_cost, 0, sizeof(tot_cost));
memset(change, 0, sizeof(change));
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++) {
int maxn = -1;
for (int k = 0; k < n; k++) {
if (s[i][j] == s[k][j]) {
change[i][j] += (1 << k);
tot_cost[i][j] += cost[k][j];
maxn = max(maxn, cost[k][j]);
}
}
tot_cost[i][j] -= maxn;
}
}
int main() {
while (scanf("%d %d", &n, &m) != EOF) {
getchar();
for (int i = 0; i < n; i++) gets(s[i]);
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++) scanf("%d", &cost[i][j]);
init();
memset(f, 0x1f1f1f, sizeof(f));
f[0] = 0;
for (int sta = 0; sta < (1 << n); sta++) {
for (int i = 0; i < n; i++)
if ((sta & (1 << i)) == 0) {
for (int j = 0; j < m; j++) {
f[sta | change[i][j]] =
min(f[sta | change[i][j]], f[sta] + tot_cost[i][j]);
f[sta | (1 << i)] = min(f[sta | (1 << i)], f[sta] + cost[i][j]);
}
}
}
printf("%d\n", f[(1 << n) - 1]);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int dp[20000005], v[55][55];
char s[55][55];
int main() {
int n, m;
scanf("%d%d", &n, &m);
for (int i = 1; i <= n; i++) {
scanf("%s", s[i] + 1);
}
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
scanf("%d", &v[i][j]);
}
}
int nn = (1 << n);
for (int i = 1; i < nn; i++) {
dp[i] = 1e9;
}
for (int k = 0; k < nn; k++) {
for (int i = 0; i < n; i++) {
if (((k >> i) & 1) == 0) {
for (int j = 1; j <= m; j++) {
dp[k + (1 << i)] = min(dp[k + (1 << i)], dp[k] + v[i + 1][j]);
int maxx = 0, ans = 0, c = 0;
for (int ii = 0; ii < n; ii++) {
if (s[ii + 1][j] == s[i + 1][j]) {
maxx = max(maxx, v[ii + 1][j]);
ans += v[ii + 1][j];
c += (1 << ii);
}
}
dp[k | c] = min(dp[k | c], dp[k] + ans - maxx);
}
break;
}
}
}
printf("%d\n", dp[nn - 1]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 20;
const int leng = 300;
string s[N];
int cost[N][leng], c[N][leng], sv[N][leng], a[N][leng];
int d[1 << N];
int main() {
int n, m;
cin >> n >> m;
for (int i = 0; i < int(n); i++) cin >> s[i];
for (int i = 0; i < int(n); i++)
for (int j = 0; j < int(m); j++) cin >> a[i][j];
for (int i = 0; i < int(n); i++) {
for (int j = 0; j < int(m); j++) {
int curv = 0;
for (int k = 0; k < int(n); k++) {
if (s[i][j] == s[k][j]) {
sv[i][j] |= (1 << k);
c[i][j] += a[k][j];
curv = max(curv, a[k][j]);
}
}
c[i][j] -= curv;
}
}
for (int i = 0; i < int(1 << n); i++) d[i] = 1000000000;
d[0] = 0;
for (int mask = 0; mask < int(1 << n); mask++) {
if (mask == 0) continue;
int lowbit = -1;
for (int i = 0; i < int(n); i++) {
if ((mask >> i) & 1) {
lowbit = i;
break;
}
}
for (int i = 0; i < int(m); i++) {
d[mask] = min(d[mask], d[mask & (mask ^ sv[lowbit][i])] + c[lowbit][i]);
d[mask] = min(d[mask], d[mask ^ (1 << lowbit)] + a[lowbit][i]);
}
}
printf("%d\n", d[(1 << n) - 1]);
}
|
#include <bits/stdc++.h>
using namespace std;
int dp[(1 << 20 | 7)];
int input[25][25];
char c[25][25];
int sum2[25][25];
int sum3[25][25];
int n, m, maxx;
int lowbit(int x) {
for (int i = 0; i < 32; i++) {
if (x & 1) return i;
x >>= 1;
}
return 0;
}
int main() {
scanf("%d%d", &n, &m);
for (int i = 0; i < n; i++)
for (int r = 0; r < m; r++) cin >> c[i][r];
for (int i = 0; i < n; i++)
for (int r = 0; r < m; r++) scanf("%d", &input[i][r]);
for (int i = 0; i < m; i++)
for (int r = 0; r < n; r++) {
int sum = 0, plk = 0;
maxx = 0;
for (int k = 0; k < n; k++)
if (c[r][i] == c[k][i]) {
sum += input[k][i];
maxx = max(maxx, input[k][i]);
plk += (1 << k);
}
sum2[r][i] = sum - maxx;
sum3[r][i] = plk;
}
memset(dp, 0X3f, sizeof(dp));
dp[(1 << n) - 1] = 0;
for (int plk = (1 << n) - 1; plk > 0; plk--) {
int pos = lowbit(plk);
int last = (1 << pos);
for (int r = 0; r < m; r++) {
dp[plk - last] = min(dp[plk - last], dp[plk] + input[pos][r]);
dp[plk & (~sum3[pos][r])] =
min(dp[plk & (~sum3[pos][r])], dp[plk] + sum2[pos][r]);
}
}
cout << dp[0];
}
|
#include <bits/stdc++.h>
using namespace std;
template <class T>
string ToString(T t) {
stringstream s;
s << t;
return s.str();
}
template <class T>
void ToOther(T &t, string a) {
stringstream s(a);
s >> t;
}
int n, m;
string a[22];
int c1[22][22];
int c2[22][22];
int c2_st[22][22];
int d[22][1 << 20];
void ckmin(int &x, int y) { x = min(x, y); }
int main() {
cin >> n >> m;
for (int i = 0; i < n; i++) cin >> a[i];
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++) cin >> c1[i][j];
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
c2_st[i][j] |= (1 << i);
for (int k = 0; k < n; k++)
if (i != k && a[i][j] == a[k][j]) {
c2[i][j] += c1[k][j];
c2_st[i][j] |= (1 << k);
}
}
}
memset(d, 63, sizeof(d));
int M = d[0][0];
int start = 0;
for (int k = 0; k < m; k++) {
for (int i = 0; i < n; i++) {
int cnt = 0;
for (int j = 0; j < n; j++)
if (a[i][k] == a[j][k]) cnt++;
if (cnt == 1) start |= (1 << i);
}
}
d[0][start] = 0;
for (int k = 0; k < n; k++) {
for (int st = 0; st < (1 << n); st++) {
ckmin(d[k + 1][st], d[k][st]);
if (!(st >> k & 1)) {
if (d[k][st] == M) continue;
for (int pos = 0; pos < m; pos++) {
ckmin(d[k + 1][st | (1 << k)], c1[k][pos] + d[k][st]);
int temp = c2[k][pos] + d[k][st];
ckmin(d[k + 1][st | c2_st[k][pos]], c2[k][pos] + d[k][st]);
}
}
}
}
int r = d[n][(1 << n) - 1];
if (r == M) r = -1;
cout << r << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
void chmin(int& a, int b) { a = min(a, b); }
int main() {
int N, M;
cin >> N >> M;
string S[20];
for (int i = 0; i < N; i++) cin >> S[i];
int A[20][20];
for (int i = 0; i < N; i++)
for (int j = 0; j < M; j++) cin >> A[i][j];
vector<int> cost(1 << 20, 1e9);
for (int j = 0; j < M; j++) {
map<char, vector<pair<int, int>>> mp;
for (int i = 0; i < N; i++) mp[S[i][j]].emplace_back(i, A[i][j]);
for (auto& pp : mp) {
auto& v = pp.second;
if (v.size() == 1) {
int i = v[0].first;
cost[1 << i] = 0;
continue;
}
int sum = 0, mx = 0, bit = 0;
for (auto& p : v) {
int i = p.first, c = p.second;
chmin(cost[1 << i], c);
sum += c;
mx = max(mx, c);
bit |= 1 << i;
}
chmin(cost[bit], sum - mx);
}
}
vector<pair<int, int>> cand;
for (int i = 0; i < (1 << N); i++)
if (cost[i] < 1e9) cand.emplace_back(i, cost[i]);
static int dp[1 << 20];
for (int i = 1; i < (1 << N); i++) dp[i] = 1e9;
for (int i = 0; i < (1 << N); i++)
for (auto& p : cand) {
chmin(dp[i | p.first], dp[i] + p.second);
}
cout << dp[(1 << N) - 1] << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int dp[(1 << 20) + 10], n, m;
char s[25][25];
int a[25][25];
int cost[25][30], zy[25][30], mxv[25][30];
int q[(1 << 20) + 10], id[(1 << 20) + 10];
inline bool is_only(int j, int x) {
int cnt = 0;
for (int i = 1; i <= n; i++) cnt += (s[i][j] == x);
return cnt == 1;
}
inline int updv(int &x, int p) { return x |= (1 << (p - 1)); }
inline int getv(int x, int p) { return (x & (1 << (p - 1))) >> (p - 1); }
inline int display(int x) {
for (int i = 1; i <= n; i++) cout << getv(x, i);
return 0;
}
int main() {
scanf("%d%d", &n, &m);
for (int i = 1; i <= n; i++) scanf("%s", s[i] + 1), s[i][0] = 'a' - 1;
for (int i = 1; i <= n; i++)
for (int j = 1; j <= m; j++) scanf("%d", &a[i][j]);
int all = (1 << n) - 1, init = 0;
for (int i = 1; i <= n; i++)
for (int j = 1; j <= m; j++)
if (is_only(j, s[i][j])) {
updv(init, i);
break;
}
int top = 0;
for (int i = 0; i <= all; i++)
if ((init & i) == init) q[++top] = i, id[i] = top;
for (int i = 1; i <= n; i++)
for (int j = 1; j <= m; j++) {
int y = (s[i][j] - 'a' + 1);
cost[j][y] += a[i][j];
mxv[j][y] = max(mxv[j][y], a[i][j]);
updv(zy[j][y], i);
}
dp[0] = 0;
for (int i = 1; i <= all; i++) {
int lb = 0;
dp[i] = (INT_MAX / 3 - 10);
for (int j = n; j; j--)
if (getv(i, j)) lb = j;
int S = i ^ (1 << (lb - 1));
for (int j = 1; j <= m; j++) {
int y = (s[lb][j] - 'a' + 1);
dp[i] = min(dp[i], dp[S] + a[lb][j]);
int x = S & (all ^ zy[j][y]);
dp[i] = min(dp[i], dp[x] + cost[j][y] - mxv[j][y]);
}
}
printf("%d\n", dp[all]);
return 0;
}
|
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:1024000000,1024000000")
using namespace std;
int n, m;
int dp[1 << 22];
string s[22];
int cost[22][22], mrk[22][22], a[22][22];
int main() {
scanf("%d%d", &n, &m);
for (int i = 0; i < n; ++i) cin >> s[i];
for (int i = 0; i < n; ++i)
for (int j = 0; j < m; ++j) scanf("%d", &a[i][j]);
for (int i = 0; i < n; ++i)
for (int j = 0; j < m; ++j) {
int maxn = 0;
for (int k = 0; k < n; ++k) {
if (s[i][j] == s[k][j]) {
mrk[i][j] |= (1 << k);
cost[i][j] += a[k][j];
maxn = max(maxn, a[k][j]);
}
}
cost[i][j] -= maxn;
}
int s = (1 << n);
for (int i = 0; i <= s; ++i) dp[i] = 1e9;
dp[0] = 0;
int first;
for (int i = 0; i < s; ++i) {
for (first = 0; i & (1 << first); first++)
;
for (int j = 0; j < m; ++j) {
dp[i | (1 << first)] = min(dp[i | (1 << first)], dp[i] + a[first][j]);
dp[i | mrk[first][j]] =
min(dp[i | mrk[first][j]], dp[i] + cost[first][j]);
}
}
cout << dp[s - 1] << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MOD = 1e9 + 7;
const int SIZE = 1e6 + 10;
const int INF = 0x3f3f3f3f;
int n, m;
char s[20][25];
int a[20][20];
int z[1 << 20], sv[20][20], c[20][20];
int main() {
if (0) {
freopen("in.txt", "r", stdin);
freopen("out.txt", "w", stdout);
}
while (scanf("%d%d", &(n), &(m)) == 2) {
for (int i = 0; i < (n); ++i) scanf("%s", (s[i]));
for (int i = 0; i < (n); ++i)
for (int j = 0; j < (m); ++j) scanf("%d", &(a[i][j]));
for (int i = 0; i < (n); ++i)
for (int j = 0; j < (m); ++j) {
int co = 0;
int ma = 0;
for (int k = 0; k < (n); ++k) {
if (s[i][j] == s[k][j]) {
sv[i][j] |= (1 << k);
co += a[k][j];
ma = max(ma, a[k][j]);
}
}
c[i][j] = co - ma;
}
for (int i = 0; i < (1 << n); ++i) z[i] = INF;
z[0] = 0;
for (int mask = (1); mask < ((1 << n)); ++mask) {
int lowbit = -1;
for (int i = 0; i < (n); ++i)
if (mask & (1 << i)) {
lowbit = i;
break;
}
for (int i = 0; i < (m); ++i) {
z[mask] = min(z[mask], z[mask & ~(sv[lowbit][i])] + c[lowbit][i]);
z[mask] = min(z[mask], z[mask & ~(1 << lowbit)] + a[lowbit][i]);
}
}
printf("%d\n", z[(1 << n) - 1]);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int mn = 21;
int n, m;
string s[mn];
int cost[mn][mn];
int co[mn][256];
int nu[mn][256];
int ns[mn][256];
int ma[mn][256];
void init() {
for (int p = 0; p < m; p++) {
for (int i = 0; i < n; i++) {
nu[p][s[i][p]]++;
co[p][s[i][p]] += cost[i][p];
ns[p][s[i][p]] = ns[p][s[i][p]] | (1 << i);
ma[p][s[i][p]] = max(ma[p][s[i][p]], cost[i][p]);
}
}
}
int dp[1 << mn];
int f(int st) {
if (st == (1 << n) - 1) return 0;
int nst, nco;
int res = 1e9;
for (int p = 0; p < m; p++) {
for (int i = 0; i < n; i++) {
if (st & (1 << i)) continue;
nst = st | ns[p][s[i][p]];
nco = co[p][s[i][p]] - ma[p][s[i][p]];
res = min(res, dp[nst] + nco);
res = min(res, dp[st | (1 << i)] + cost[i][p]);
}
}
return dp[st] = res;
}
int main() {
cin >> n >> m;
for (int i = 0; i < n; i++) {
cin >> s[i];
}
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
cin >> cost[i][j];
}
}
init();
for (int st = (1 << n) - 1; st >= 0; st--) {
dp[st] = f(st);
}
cout << dp[0] << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int N, M, dp[(1 << 20) + 5], mask[20][20], cost[20][20], a[20][20];
char s[20][21];
int solve() {
int MX = 1 << N;
for (int i = 1; i < (int)MX; i++) {
int x = i & -i, lowbit = -1;
while (x) x >>= 1, lowbit++;
int mi = 1 << 30;
for (int j = 0; j < (int)M; j++) {
int d1 = dp[i - (1 << lowbit)] + a[lowbit][j];
int msk = mask[j][lowbit] & i;
int d2 = dp[i - msk] + cost[j][lowbit];
mi = min(mi, min(d1, d2));
}
dp[i] = mi;
}
return dp[MX - 1];
}
int main() {
scanf("%d%d", &N, &M);
for (int i = 0; i < (int)N; i++) scanf("%s", s[i]);
for (int i = 0; i < (int)N; i++)
for (int j = 0; j < (int)M; j++) scanf("%d", &a[i][j]);
for (int i = 0; i < (int)M; i++)
for (int j = 0; j < (int)N; j++) {
int mx = 0;
for (int k = 0; k < (int)N; k++)
if (s[j][i] == s[k][i])
mask[i][j] |= (1 << k), cost[i][j] += a[k][i], mx = max(mx, a[k][i]);
cost[i][j] -= mx;
}
printf("%d\n", solve());
}
|
#include <bits/stdc++.h>
using namespace std;
const int INF = 0x3f3f3f3f;
const int MaxA = 20 + 7;
int n, m;
char str[MaxA][MaxA];
int arr[MaxA][MaxA];
int f[1 << 20];
int lowzero(int x) {
int res = 0;
while (x & 1) {
x >>= 1;
res++;
}
return res;
}
int main() {
while (~scanf("%d%d", &n, &m)) {
for (int i = 0; i < n; i++) {
scanf("%s", str[i]);
}
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
scanf("%d", &arr[i][j]);
}
}
memset(f, 0x3f, sizeof(f));
f[0] = 0;
int staNum = 1 << n;
for (int s = 0; s < staNum; s++) {
if (f[s] == INF) continue;
int r = lowzero(s);
if (r >= n) continue;
for (int j = 0; j < m; j++) {
f[s | (1 << r)] = min(f[s | (1 << r)], f[s] + arr[r][j]);
int bits = 0, sum = 0, mx = 0;
for (int i = 0; i < n; i++)
if (str[i][j] == str[r][j]) {
sum += arr[i][j];
mx = max(mx, arr[i][j]);
bits |= 1 << i;
}
f[s | bits] = min(f[s | bits], f[s] + sum - mx);
}
}
printf("%d\n", f[staNum - 1]);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
struct node {
int point, w;
} p[30][30];
int n, m;
int s[30][30], w[30][30], Min[30], f[3000000];
int Get() {
char c = getchar();
while (!isalpha(c)) c = getchar();
return c;
}
void init(int x, int y) {
int t1 = 0, t2 = 0, mx = 0;
for (int i = 1; i <= n; i++)
if (s[i][y] == s[x][y]) {
t1 |= 1 << (i - 1);
t2 += w[i][y];
mx = max(mx, w[i][y]);
}
p[x][y] = (node){t1, t2 - mx};
}
int Getlow(int x) {
for (int i = 0; i < n; i++)
if (!(x & (1 << i))) return i + 1;
}
int main() {
for (int i = 1; i <= 29; i++) Min[i] = 19240012;
for (int i = 1; i <= 3000000 - 1; i++) f[i] = 30000000;
cin >> n >> m;
for (int i = 1; i <= n; i++)
for (int j = 1; j <= m; j++) s[i][j] = Get();
for (int i = 1; i <= n; i++)
for (int j = 1; j <= m; j++) {
cin >> w[i][j];
Min[i] = min(Min[i], w[i][j]);
}
for (int i = 1; i <= n; i++)
for (int j = 1; j <= m; j++) init(i, j);
f[0] = 0;
for (int i = 0; i < (1 << n); i++) {
int p_ = Getlow(i);
f[i | (1 << (p_ - 1))] = min(f[i | (1 << (p_ - 1))], f[i] + Min[p_]);
for (int j = 1; j <= m; j++)
f[i | p[p_][j].point] = min(f[i | p[p_][j].point], f[i] + p[p_][j].w);
}
cout << f[(1 << n) - 1] << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
struct node {
int point, w;
} p[30][30];
int n, m;
int s[30][30], w[30][30], Min[30], f[3000000];
int Get() {
char c = getchar();
while (!isalpha(c)) c = getchar();
return c;
}
void init(int x, int y) {
int t1 = 0, t2 = 0, mx = 0;
for (int i = 1; i <= n; i++)
if (s[i][y] == s[x][y]) {
t1 |= 1 << (i - 1);
t2 += w[i][y];
mx = max(mx, w[i][y]);
}
p[x][y] = (node){t1, t2 - mx};
}
int Getlow(int x) {
int ss[200];
int num = 0;
if (x == 0) return 1;
while (x) {
ss[++num] = x % 2;
x /= 2;
}
ss[++num] = 0;
for (int i = 1; i <= num; i++)
if (ss[i] == 0) return i;
}
int main() {
for (int i = 1; i <= 29; i++) Min[i] = 19240012;
for (int i = 1; i <= 3000000 - 1; i++) f[i] = 30000000;
cin >> n >> m;
for (int i = 1; i <= n; i++)
for (int j = 1; j <= m; j++) s[i][j] = Get();
for (int i = 1; i <= n; i++)
for (int j = 1; j <= m; j++) {
cin >> w[i][j];
Min[i] = min(Min[i], w[i][j]);
}
for (int i = 1; i <= n; i++)
for (int j = 1; j <= m; j++) init(i, j);
f[0] = 0;
for (int i = 0; i < (1 << n); i++) {
int p_ = Getlow(i);
f[i | (1 << (p_ - 1))] = min(f[i | (1 << (p_ - 1))], f[i] + Min[p_]);
for (int j = 1; j <= m; j++)
f[i | p[p_][j].point] = min(f[i | p[p_][j].point], f[i] + p[p_][j].w);
}
cout << f[(1 << n) - 1] << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int A[20 + 5][20 + 5];
bool used[1 << 20];
long long memo[1 << 20];
int lower_bit[1 << 20];
int n, m;
int groups[20 + 5][20 + 5];
int ones(int mask) { return __builtin_popcount(mask); }
long long SUM[20 + 5][20 + 5], MAXI[20 + 5][20 + 5];
long long dp(int mask) {
if (mask == 0) return 0;
if (used[mask]) return memo[mask];
used[mask] = 1;
long long &dev = memo[mask] = (1LL << 40);
int i = lower_bit[mask];
for (int j = 0; j < m; ++j) {
dev = min(dev, A[i][j] + dp(mask ^ (1 << i)));
int inter = (mask & groups[i][j]);
dev = min(dev, SUM[i][j] - MAXI[i][j] + dp(mask ^ inter));
}
return dev;
}
char S[20 + 5][20 + 5];
int main() {
for (int i = 0; i < (1 << 20); ++i) lower_bit[i] = 31 - __builtin_clz(i);
while (scanf("%d", &n) == 1) {
scanf("%d", &m);
for (int i = 0; i < n; ++i) scanf("%s", S[i]);
for (int i = 0; i < n; ++i)
for (int j = 0; j < m; ++j) scanf("%d", &A[i][j]);
memset(SUM, 0, sizeof(SUM));
memset(MAXI, 0, sizeof(MAXI));
memset(groups, 0, sizeof(groups));
for (int j = 0; j < m; ++j) {
for (int i = 0; i < n; ++i) {
for (int k = 0; k < n; ++k)
if (S[i][j] == S[k][j]) {
SUM[i][j] += A[k][j];
MAXI[i][j] = max(MAXI[i][j], (long long)A[k][j]);
groups[i][j] ^= (1 << k);
}
}
}
memset(used, 0, sizeof(used));
printf("%d\n", (int)dp((1 << n) - 1));
}
}
|
#include <bits/stdc++.h>
using namespace std;
char str[22][22];
int dp[(1 << (20)) + 5], sets[22][22];
int a[22][22], b[22][22];
int main() {
int n, m;
while (scanf("%d%d", &n, &m) != EOF) {
for (int i = 0; i < n; i++) {
scanf("%s", str[i]);
}
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++) scanf("%d", &a[i][j]);
memset(sets, 0, sizeof sets);
memset(b, 0, sizeof b);
for (int i = 0; i < n; i++) {
for (int k = 0; k < m; k++) {
int mx = 0;
for (int j = 0; j < n; j++) {
if (str[i][k] == str[j][k]) {
b[i][k] += a[j][k];
mx = max(mx, a[j][k]);
sets[i][k] |= (1 << (j));
}
}
b[i][k] -= mx;
}
}
memset(dp, 0x3f, sizeof dp);
dp[0] = 0;
int full = (1 << (n)) - 1;
for (int s = 0; s <= full; s++) {
int i;
for (i = 0; s & (1 << (i)); i++)
;
if (i >= n) continue;
for (int j = 0; j < m; j++) {
dp[s | (1 << (i))] = min(dp[s | (1 << (i))], dp[s] + a[i][j]);
dp[s | sets[i][j]] = min(dp[s | sets[i][j]], dp[s] + b[i][j]);
}
}
printf("%d\n", dp[full]);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int d[2000000 + 10];
int a[100 + 10][100 + 10];
char s[100 + 10][100 + 10];
int cnt[100 + 10][100 + 10];
int price[100 + 10][100 + 10];
int n, m;
int main() {
scanf("%d%d", &n, &m);
for (int i = 0; i < n; i++) {
scanf("%s", s[i]);
for (int j = 0; j < m; j++) cnt[j][s[i][j] - 'a']++;
}
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++) scanf("%d", &a[i][j]);
memset(d, 0x3f, sizeof(d));
int st = 0;
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++)
if (cnt[j][s[i][j] - 'a'] == 1) st |= (1 << i);
d[st] = 0;
for (int i = 0; i < m; i++)
for (int j = 0; j < 26; j++) {
if (cnt[i][j] > 1) {
int t = 0, Max = 0, sum = 0;
for (int k = 0; k < n; k++)
if (s[k][i] - 'a' == j) {
for (int z = 0; z < (1 << n); z++)
d[z | (1 << k)] = min(d[z | (1 << k)], d[z] + a[k][i]);
t |= 1 << k;
sum += a[k][i];
Max = max(a[k][i], Max);
}
int price = sum - Max;
for (int z = 0; z < (1 << n); z++)
d[z | t] = min(d[z | t], d[z] + price);
}
}
printf("%d\n", d[(1 << n) - 1]);
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 21;
string s[maxn];
int a[maxn][maxn], n, m, t[maxn][maxn], b[maxn][maxn];
int dp[1 << maxn];
int main() {
scanf("%d%d", &n, &m);
for (int i = 0; i < n; ++i) cin >> s[i];
for (int i = 0; i < n; ++i)
for (int j = 0; j < m; ++j) scanf("%d", &a[i][j]);
for (int i = 0; i < n; ++i) {
for (int j = 0; j < m; ++j) {
int sum = 0, val = -(1 << 30);
for (int k = 0; k < n; ++k) {
if (s[k][j] == s[i][j]) {
sum += a[k][j];
val = max(val, a[k][j]);
t[i][j] |= (1 << k);
}
}
b[i][j] = sum - val;
}
}
memset(dp, 127 / 2, sizeof(dp));
dp[0] = 0;
for (int i = 0; i < (1 << n); ++i) {
for (int j = 0; j < n; ++j) {
if (!(i & (1 << j))) {
for (int k = 0; k < m; ++k) {
dp[i | (1 << j)] = min(dp[i | (1 << j)], dp[i] + a[j][k]);
dp[i | t[j][k]] = min(dp[i | t[j][k]], dp[i] + b[j][k]);
}
}
}
}
printf("%d\n", dp[(1 << n) - 1]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int A[25][25], N, M, D[1100000], l, n, t, h;
string S[25];
int main() {
cin >> N >> M;
for (int i = 0; i <= N - 1; i++) cin >> S[i];
for (int i = 0; i <= N - 1; i++)
for (int j = 0; j <= M - 1; j++) cin >> A[i][j];
for (int i = 1; i <= (1 << N) - 1; i++) D[i] = 50000000;
for (int m = 0; m <= (1 << N) - 1; m++) {
for (int b = 0; b <= N - 1; b++)
if (!(m & (1 << b))) {
l = b;
break;
}
for (int c = 0; c <= M - 1; c++) {
D[m + (1 << l)] = min(D[m + (1 << l)], D[m] + A[l][c]), n = m, t = 0,
h = 0;
for (int i = 0; i <= N - 1; i++)
if (S[l][c] == S[i][c]) n |= 1 << i, t += A[i][c], h = max(h, A[i][c]);
D[n] = min(D[n], D[m] + t - h);
}
}
cout << D[(1 << N) - 1];
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 20, maxm = 20, INF = 0x7f7f7f7f;
int n, m;
char s[maxn][maxm + 1];
int a[maxn][maxm];
int Min[maxn], state[maxn][maxm], cost[maxn][maxm];
int f[1 << maxn];
int main() {
scanf("%d%d", &n, &m);
for (int i = 0; i < n; ++i) scanf("%s", s[i]);
for (int i = 0; i < n; ++i)
for (int j = 0; j < m; ++j) scanf("%d", &a[i][j]);
memset(Min, 0x7f, sizeof(Min));
for (int i = 0; i < n; ++i)
for (int j = 0; j < m; ++j) {
if (a[i][j] < Min[i]) Min[i] = a[i][j];
int sum = 0, Max = 0, t = 0;
for (int k = 0; k < n; ++k)
if (s[i][j] == s[k][j]) {
t |= 1 << k;
sum += a[k][j];
if (a[k][j] > Max) Max = a[k][j];
}
state[i][j] = t;
cost[i][j] = sum - Max;
}
memset(f, 0x7f, sizeof(f));
f[0] = 0;
for (int i = 0, p = (1 << n) - 1; i < p; ++i)
if (f[i] < INF) {
int j;
for (j = 0; j < n; ++j)
if (!(i & (1 << j))) break;
f[i | (1 << j)] = min(f[i | (1 << j)], f[i] + Min[j]);
for (int k = 0; k < m; ++k)
f[i | state[j][k]] = min(f[i | state[j][k]], f[i] + cost[j][k]);
}
printf("%d\n", f[(1 << n) - 1]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int inf = 2000000005;
const int maxt = (1 << 20) + 5;
int all[maxt], dp[2][maxt];
int best[30], a[30][30];
int mask[30][30], cost[30][30];
char str[30][30];
int n, m;
int main() {
scanf("%d%d", &n, &m);
for (int i = 0; i < n; i++) scanf("%s", str[i]), best[i] = inf;
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++)
scanf("%d", &a[i][j]), best[i] = min(best[i], a[i][j]);
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
bool ok = true;
for (int k = 0; k < n; k++)
if (k != i && str[i][j] == str[k][j]) ok = false;
if (ok) best[i] = 0;
}
}
for (int j = 0; j < m; j++) {
for (int c = 0; c < 26; c++) {
mask[j][c] = 0;
cost[j][c] = 0;
int maxc = 0, cnt = 0;
for (int i = 0; i < n; i++)
if (str[i][j] - 'a' == c) {
mask[j][c] |= 1 << i;
cost[j][c] += a[i][j];
maxc = max(maxc, a[i][j]);
cnt++;
}
cost[j][c] -= maxc;
if (cnt < 2) mask[j][c] = -1;
}
}
for (int i = 0; i < 1 << n; i++) dp[0][i] = dp[1][i] = inf;
int nw = 0, ls = 1;
dp[nw][0] = 0;
for (int j = 0; j < m; j++)
for (int c = 0; c < 26; c++)
if (mask[j][c] != -1) {
swap(nw, ls);
memcpy(dp[nw], dp[ls], sizeof dp[ls]);
for (int i = 0; i < 1 << n; i++) {
dp[nw][i | mask[j][c]] =
min(dp[nw][i | mask[j][c]], dp[ls][i] + cost[j][c]);
}
}
for (int i = 0; i < 1 << n; i++) {
all[i] = 0;
for (int j = 0; j < n; j++)
if ((i >> j) & 1)
;
else
all[i] += best[j];
}
int ans = inf;
for (int i = 0; i < 1 << n; i++) ans = min(ans, all[i] + dp[nw][i]);
printf("%d\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int m, n;
int a[3010][3010];
int dp[(1 << 22)];
string s[100];
int ft[30], sb[30];
int main() {
while (cin >> n >> m) {
for (int i = 0; i < n; ++i) cin >> s[i];
for (int i = 0; i < n; ++i)
for (int j = 0; j < m; ++j) {
cin >> a[i][j];
}
memset(dp, -1, sizeof(dp));
dp[0] = 0;
for (int i = 0; i < (1 << n); ++i) {
if (dp[i] == -1) continue;
int now = 0;
for (now = 0; now < n; ++now) {
if (((1 << now) & i) == 0) {
break;
}
}
if (now == n) continue;
for (int j = 0; j < m; ++j) {
int x = 1 << now;
if (dp[i | x] == -1 || dp[i | x] > dp[i] + a[now][j]) {
dp[i | x] = dp[i] + a[now][j];
}
x = 0;
int max_sum = 0;
int sum = 0;
for (int k = 0; k < n; ++k) {
if (s[k][j] == s[now][j]) {
x |= (1 << k);
sum += a[k][j];
max_sum = max(max_sum, a[k][j]);
}
}
if (dp[i | x] == -1 || dp[i | x] > dp[i] + sum - max_sum) {
dp[i | x] = dp[i] + sum - max_sum;
}
}
}
cout << dp[(1 << n) - 1] << endl;
}
}
|
#include <bits/stdc++.h>
using namespace std;
int dp[1 << 22];
int cost[22][22], same[22][22], mcost[22][22];
char c[22][22];
int n, m;
int main() {
cin >> n >> m;
getchar();
for (int i = 0; i < n; i++) cin >> c[i];
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++) cin >> cost[i][j];
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
int maxc = -1, all = 0;
for (int k = 0; k < n; k++) {
if (c[i][j] == c[k][j]) {
same[i][j] += (1 << k);
maxc = max(maxc, cost[k][j]);
all += cost[k][j];
}
}
mcost[i][j] = all - maxc;
}
}
memset(dp, 0x3f3f, sizeof(dp));
dp[0] = 0;
for (int i = 1; i < (1 << n); i++) {
for (int j = 0; j <= n; j++)
if ((1 << j) & i) {
for (int k = 0; k < m; k++) {
dp[i] = min(dp[i], dp[i & (i ^ same[j][k])] + mcost[j][k]);
dp[i] = min(dp[i], dp[i ^ (1 << j)] + cost[j][k]);
}
}
}
cout << dp[(1 << n) - 1] << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int read_int() {
char c = getchar();
while ((c < '0' || c > '9') && c != '-') {
c = getchar();
}
bool sign = 0;
if (c == '-') {
sign = 1;
c = getchar();
}
int ret = 0;
while (c >= '0' && c <= '9') {
ret = 10 * ret + c - 48;
c = getchar();
}
if (sign) return -ret;
return ret;
}
int read_string(char *s) {
int n = 0;
char c = getchar();
while (c < 'a' || c > 'z') c = getchar();
while (c >= 'a' && c <= 'z') {
s[n] = c - 'a';
n++;
c = getchar();
}
return n;
}
int a[25][25];
int b[25][25];
int n, m;
int dp[1 << 20];
int go(int s) {
int &ret = dp[s];
if (ret < 0) {
ret = s ? 1e9 : 0;
if (s) {
for (int i = 0; i < n; i++) {
if ((s >> i) & 1) {
for (int j = 0; j < m; j++) {
ret = min(ret, b[i][j] + go(s ^ (1 << i)));
}
break;
}
}
for (int i = 0; i < n; i++) {
if ((s >> i) & 1) {
for (int j = 0; j < m; j++) {
int p2 = 0, p3 = -1, y = s;
for (int k = 0; k < n; k++) {
if (a[k][j] == a[i][j]) {
p2 += b[k][j];
p3 = max(p3, b[k][j]);
y = y & (~(1 << k));
}
}
ret = min(ret, p2 - p3 + go(y));
}
break;
}
}
}
}
return ret;
}
bool process() {
cin >> n >> m;
for (int i = 0; i < n; i++) {
string s;
cin >> s;
for (int j = 0; j < m; j++) {
a[i][j] = s[j] - 'a';
}
}
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
cin >> b[i][j];
}
}
memset(dp, -1, sizeof(dp));
cout << go((1 << n) - 1) << endl;
return 1;
}
int main() {
srand(time(NULL));
ios_base::sync_with_stdio(0);
int t = 1;
while (t-- > 0) {
if (!process()) break;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m;
char s[25][25];
int a[25][25], d[1 << 20], ma[25][25], c[25][25];
const int INF = 1e9;
int main() {
scanf("%d%d", &n, &m);
for (int i = 0; i < (int)(n); ++i) scanf("%s", s[i]);
for (int i = 0; i < (int)(n); ++i)
for (int j = 0; j < (int)(m); ++j) scanf("%d", a[i] + j);
for (int i = 0; i < (int)(n); ++i)
for (int j = 0; j < (int)(m); ++j) {
int &mask = ma[i][j], &cost = c[i][j], mx = 0;
for (int k = 0; k < (int)(n); ++k)
if (s[k][j] == s[i][j]) {
cost += a[k][j];
mask |= 1 << k;
mx = max(mx, a[k][j]);
}
cost -= mx;
}
for (int i = 0; i < (int)(1 << n); ++i) d[i] = INF;
d[0] = 0;
for (int mask = 0; mask < (int)((1 << n) - 1); ++mask) {
int i = 0;
while (mask & (1 << i)) ++i;
for (int j = 0; j < (int)(m); ++j) {
d[mask | ma[i][j]] = min(d[mask | ma[i][j]], d[mask] + c[i][j]);
d[mask | (1 << i)] = min(d[mask | (1 << i)], d[mask] + a[i][j]);
}
}
printf("%d\n", d[(1 << n) - 1]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long INF = 1E9 + 9;
char str[100][100];
int f[100][100], dp[1 << 21], sum[100][100], statu[100][100];
int main() {
int n, m, i, j, k;
scanf("%d%d", &n, &m);
for (i = 0; i < n; i++) scanf("%s", str[i]);
for (i = 0; i < n; i++)
for (j = 0; j < m; j++) scanf("%d", &f[i][j]);
for (i = 0; i < n; i++) {
for (j = 0; j < m; j++) {
int maxv = 0;
for (k = 0; k < n; k++)
if (str[i][j] == str[k][j]) {
sum[i][j] += f[k][j];
maxv = max(maxv, f[k][j]);
statu[i][j] |= (1 << k);
}
sum[i][j] -= maxv;
}
}
fill(dp, dp + (1 << 21), INF);
dp[0] = 0;
for (i = 0; i < (1 << n) - 1; i++) {
for (j = 0; j < n; j++)
if ((i & (1 << j)) == 0) {
int a = (1 << j);
for (k = 0; k < m; k++) {
int b = statu[j][k];
dp[i | a] = min(dp[i | a], dp[i] + f[j][k]);
dp[i | b] = min(dp[i | b], dp[i] + sum[j][k]);
}
}
}
printf("%d\n", dp[(1 << n) - 1]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int a[20][20], cst[20][20], dp[1 << 20], msks[20][20];
char c[20][20];
int main() {
int n, m;
cin >> n >> m;
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++) cin >> c[i][j];
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++) cin >> a[i][j];
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
int mx = 0;
for (int k = 0; k < n; k++) {
if (c[k][j] == c[i][j]) {
cst[i][j] += a[k][j];
mx = max(mx, a[k][j]);
}
}
cst[i][j] -= mx;
}
}
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
for (int k = 0; k < n; k++) {
if (c[i][j] == c[k][j]) msks[i][j] |= (1 << k);
}
}
}
for (int mask = 1; mask < (1 << n); mask++) {
int lowst_bit = 0;
for (int i = 0; i < n; i++) {
if (mask & (1 << i)) {
lowst_bit = i;
break;
}
}
dp[mask] = 100000000;
for (int j = 0; j < m; j++) {
dp[mask] =
min(dp[mask],
min(dp[mask ^ (mask & msks[lowst_bit][j])] + cst[lowst_bit][j],
dp[mask ^ (1 << lowst_bit)] + a[lowst_bit][j]));
}
}
cout << dp[(1 << n) - 1] << endl;
cin >> n;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int dp[1 << 20];
int cost[30][30], f[30][30], change[30][30];
int n, m;
char s[30][30];
inline void getCost() {
for (int k = 0; k < n; ++k) {
for (int i = 0; i < m; ++i) {
int sum = 0, mx = 0;
f[i][k] = 0x7fffffff;
for (int j = 0; j < n; ++j) {
if (s[j][i] == s[k][i]) {
change[i][k] |= 1 << j;
sum += cost[j][i];
mx = max(mx, cost[j][i]);
}
}
f[i][k] = min(f[i][k], sum - mx);
}
}
}
int main() {
ios::sync_with_stdio(0);
cin >> n >> m;
for (int i = 0; i < n; ++i) cin >> s[i];
for (int i = 0; i < n; ++i)
for (int j = 0; j < m; ++j) cin >> cost[i][j];
getCost();
memset(dp, 0x3f, sizeof dp);
dp[0] = 0;
for (int st = 0; st < (1 << n); ++st) {
for (int i = 0; i < n; ++i) {
if ((st & 1 << i) == 0) {
for (int j = 0; j < m; ++j) {
dp[st | change[j][i]] = min(dp[st | change[j][i]], dp[st] + f[j][i]);
dp[st | 1 << i] = min(dp[st | 1 << i], dp[st] + cost[i][j]);
}
break;
}
}
}
cout << dp[(1 << n) - 1] << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 21;
int n, m, a[N][N], dp[1 << N], se[N][N], co[N][N];
char s[N + 2][N + 2];
bool vis[26];
void upd(int &u, const int &v) { u == -1 ? u = v : u = min(u, v); }
int main() {
scanf("%d%d", &n, &m);
for (int i = 1; i <= n; i++) {
scanf("%s", s[i] + 1);
}
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
scanf("%d", &a[i][j]);
}
}
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
for (int k = 1; k <= n; k++)
if (s[i][j] == s[k][j]) {
se[i][j] ^= 1 << (k - 1);
if (i == k) continue;
co[i][j] += a[k][j];
}
}
}
fill(dp + 1, dp + (1 << n), -1);
dp[0] = 0;
for (int i = 0; i < (1 << n); i++) {
for (int j = 0; j < n; j++)
if (!(i >> j & 1)) {
for (int k = 1; k <= m; k++) {
upd(dp[i | (1 << j)], dp[i] + a[j + 1][k]);
upd(dp[i | se[j + 1][k]], dp[i] + co[j + 1][k]);
}
}
}
printf("%d\n", dp[(1 << n) - 1]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int gint() {
char c;
int f = 1;
while (c = getchar(), c < 48 || c > 57)
if (c == '-') f = -1;
int x = 0;
for (; c > 47 && c < 58; c = getchar()) {
x = x * 10 + c - 48;
}
return x * f;
}
int n, m, maxs, a[20][20], f[(1 << 20)], bin[(1 << 20)];
char s[20][20];
int main() {
n = gint(), m = gint();
for (int i = 0; i < n; ++i) scanf("%s", s + i);
for (int i = 0; i < n; ++i)
for (int j = 0; j < m; ++j) a[i][j] = gint();
maxs = 1 << n;
for (int i = 1; i < maxs; ++i) f[i] = 0x3f3f3f3f;
for (int i = 0; i < maxs; ++i)
for (int j = 0; j < 30; ++j)
if (!((i >> j) & 1)) {
bin[i] = j;
break;
}
for (int S = 0; S < maxs - 1; ++S) {
int i = bin[S];
for (int j = 0; j < m; ++j) {
f[S ^ (1 << i)] = min(f[S ^ (1 << i)], f[S] + a[i][j]);
int sum = 0, maxa = 0, ns = 0;
for (int k = 0; k < n; ++k) {
if (s[i][j] != s[k][j]) continue;
sum += a[k][j], maxa = max(maxa, a[k][j]);
ns ^= (1 << k);
}
f[S | ns] = min(f[S | ns], f[S] + sum - maxa);
}
}
return printf("%d\n", f[maxs - 1]), 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int dp[1100005], cost[25][25];
char s[25][25];
void Min(int &a, int b) {
if (a > b) a = b;
}
int n, m;
int find(int S) {
for (int i = 0; i < n; i++)
if (!(S & (1 << i))) return i;
return n - 1;
}
int main() {
scanf("%d %d", &n, &m);
for (int i = 0; i < n; i++) scanf("%s", s[i]);
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++) scanf("%d", &cost[i][j]);
for (int S = 1; S < 1 << n; S++) dp[S] = 2000000000;
for (int S = 0; S + 1 < 1 << n; S++) {
int had = find(S);
for (int c = 0; c < m; c++) {
Min(dp[S | (1 << had)], dp[S] + cost[had][c]);
int sum = 0, mx = 0, nw = 0;
for (int r = 0; r < n; r++)
if (s[had][c] == s[r][c]) {
sum += cost[r][c];
mx = max(mx, cost[r][c]);
nw |= 1 << r;
}
Min(dp[S | nw], dp[S] + sum - mx);
}
}
printf("%d", dp[(1 << n) - 1]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
typedef vector<int> vi;
typedef pair<int, int> ii;
int n, n2, m, dp[(1 << 21) + 5], a[21][21], cnt[26], sum[26], mx[26], b[21][21],
c[21][21];
char s[21][21];
int main() {
scanf("%d%d", &n, &m);
n2 = 1 << n;
for (int i = 0; i < n; ++i) scanf("%s", s[i]);
for (int i = 0; i < n; ++i)
for (int j = 0; j < m; ++j) scanf("%d", a[i] + j);
for (int j = 0; j < m; ++j) {
memset(cnt, 0, sizeof(cnt));
memset(sum, 0, sizeof(sum));
memset(mx, 0, sizeof(mx));
for (int i = 0; i < n; ++i) {
cnt[s[i][j] - 'a'] |= (1 << i);
sum[s[i][j] - 'a'] += a[i][j];
mx[s[i][j] - 'a'] = max(mx[s[i][j] - 'a'], a[i][j]);
}
for (int i = 0; i < n; ++i) {
b[i][j] = sum[s[i][j] - 'a'] - mx[s[i][j] - 'a'];
c[i][j] = cnt[s[i][j] - 'a'];
}
}
memset(dp, 63, sizeof(dp));
dp[0] = 0;
int lw;
for (int msk = 0; msk < n2; ++msk) {
for (lw = 0; lw < n; ++lw)
if (!(msk & 1 << lw)) break;
for (int j = 0; j < m; ++j) {
dp[msk | c[lw][j]] = min(dp[msk | c[lw][j]], dp[msk] + b[lw][j]);
dp[msk | 1 << lw] = min(dp[msk | 1 << lw], dp[msk] + a[lw][j]);
}
}
printf("%d\n", dp[n2 - 1]);
return 0;
}
|
#include <bits/stdc++.h>
#pragma comment(linker, "/stack:200000000")
#pragma GCC optimize("Ofast")
#pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,tune=native")
using namespace std;
const int N = 20;
const int inf = (int)1e9 + 1;
const long long big = (long long)1e18 + 1;
const int P = 239;
const int MOD = (int)1e9 + 7;
const int MOD1 = (int)1e9 + 9;
const double eps = 1e-9;
const double pi = atan2(0, -1);
const int ABC = 26;
inline void setmin(int &x, int y) {
if (y < x) x = y;
}
inline void setmax(int &x, int y) {
if (y > x) x = y;
}
inline void setmin(long long &x, long long y) {
if (y < x) x = y;
}
inline void setmax(long long &x, long long y) {
if (y > x) x = y;
}
string a[N];
int cost[N][N];
int sum[N][26];
int max_sum[N][26];
int bits[N][26];
int min_cost[N];
int dp[1 << N];
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.precision(20);
cout << fixed;
int n, m;
cin >> n >> m;
for (int i = 0; i < n; i++) cin >> a[i];
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++) cin >> cost[i][j];
for (int j = 0; j < m; j++)
for (int i = 0; i < n; i++) {
sum[j][a[i][j] - 'a'] += cost[i][j];
max_sum[j][a[i][j] - 'a'] = max(max_sum[j][a[i][j] - 'a'], cost[i][j]);
bits[j][a[i][j] - 'a'] |= (1 << i);
}
for (int i = 0; i < n; i++) {
min_cost[i] = inf;
for (int j = 0; j < m; j++) setmin(min_cost[i], cost[i][j]);
}
for (int mask = 0; mask < (1 << n); mask++) dp[mask] = inf;
dp[0] = 0;
for (int mask = 0; mask < (1 << n) - 1; mask++) {
int i = __builtin_ctz(~mask);
setmin(dp[mask | (1 << i)], dp[mask] + min_cost[i]);
for (int j = 0; j < m; j++)
setmin(dp[mask | bits[j][a[i][j] - 'a']],
dp[mask] + sum[j][a[i][j] - 'a'] - max_sum[j][a[i][j] - 'a']);
}
cout << dp[(1 << n) - 1] << "\n";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 25;
long long n, m, v[maxn][maxn], ans, dp[1 << 20], tot[maxn][26], bit[maxn][26],
cmax[maxn][26];
char s[maxn][maxn];
inline void up(int &x, int y) { x = min(x, y); }
int main() {
scanf("%lld%lld", &n, &m);
for (int i = 0; i < n; ++i) scanf("%s", s[i]);
for (int i = 0; i < n; ++i)
for (int j = 0; j < m; ++j) {
scanf("%lld", &v[i][j]);
int c = s[i][j] - 'a';
tot[j][c] += v[i][j];
cmax[j][c] = max(cmax[j][c], v[i][j]);
bit[j][c] |= (1 << i);
}
memset(dp, 0x7f, sizeof(long long) * (1 << n));
dp[0] = 0;
for (int i = 0; i < n; ++i)
for (int j = 0; j < m; ++j) {
int c = s[i][j] - 'a';
long long now_bit = bit[j][c], tot_cost = tot[j][c] - cmax[j][c];
for (int _ = 0; _ < (1 << n); ++_)
if (!((1 << i) & _)) {
dp[_ | (1 << i)] = min(dp[_ | (1 << i)], dp[_] + v[i][j]);
dp[_ | now_bit] = min(dp[_ | now_bit], dp[_] + tot_cost);
}
}
printf("%lld\n", dp[(1 << n) - 1]);
}
|
#include <bits/stdc++.h>
using namespace std;
int T[2][1 << 20];
char D[25][25];
int cost[25][25];
int main() {
int N, M, s = 0, e = 1;
scanf("%d%d", &N, &M);
for (int i = 0; i < N; i++) scanf("%s", D[i]);
for (int i = 0; i < N; i++) {
for (int j = 0; j < M; j++) {
scanf("%d", cost[i] + j);
}
}
for (int i = 0; i < 1 << N; i++) T[s][i] = 0x3fffffff;
T[s][0] = 0;
for (int j = 0; j < M; j++) {
for (int i = 0; i < N; i++) {
for (int k = 0; k < 1 << N; k++) T[e][k] = 0x3fffffff;
int msk = 0, add = 0;
for (int k = 0; k < N; k++) {
if (D[i][j] == D[k][j]) msk |= 1 << k, add += cost[k][j];
}
add -= cost[i][j];
for (int k = 0; k < 1 << N; k++) {
T[e][msk | k] = min(T[e][msk | k], T[s][k] + add);
T[e][k] = min(T[e][k], T[s][k]);
T[e][k | (1 << i)] = min(T[e][k | (1 << i)], T[s][k] + cost[i][j]);
}
swap(s, e);
}
}
printf("%d ", T[s][(1 << N) - 1]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 20, MAXB = 1 << MAXN;
int dp[MAXB], a[MAXN][MAXN];
int sum[46], mx[46], mv[46], dx[46];
char s[MAXN][MAXN + 1];
int sz;
int main() {
int n, m;
scanf("%d%d", &n, &m);
for (int i = 0; i < n; i++) scanf("%s", s[i]);
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++) scanf("%d", &a[i][j]);
memset(dp, 63, sizeof dp);
dp[0] = 0;
int MASK = 1 << n, lim = 26 + n;
for (int i = 0; i < m; i++) {
for (int j = 0; j < 26; j++) sum[j] = mx[j] = mv[j] = 0;
for (int j = 0; j < n; j++) {
dx[j + 26] = a[j][i];
mv[j + 26] = 1 << j;
int c = s[j][i] - 'a';
mv[c] |= (1 << j);
sum[c] += a[j][i];
mx[c] = max(mx[c], a[j][i]);
}
for (int j = 0; j < 26; j++) dx[j] = sum[j] - mx[j];
for (int mask = 0; mask < MASK; mask++)
for (int j = 0; j < 46; j++)
if (dp[mask | mv[j]] > dp[mask] + dx[j])
dp[mask | mv[j]] = dp[mask] + dx[j];
;
}
cout << dp[MASK - 1];
}
|
#include <bits/stdc++.h>
using namespace std;
const int INF = 0x3f3f3f3f;
const int maxn = 21;
const int maxs = 1 << 21;
int n, m;
int a[maxn][maxn];
char str[maxn][maxn];
int dp[maxs];
int lowzero(int s) {
for (int i = 0; i < maxn; ++i) {
if (!(s & (1 << i))) return i;
}
return maxn - 1;
}
int main() {
while (~scanf("%d%d", &n, &m)) {
for (int i = 0; i < n; ++i) {
scanf("%s", str[i]);
}
for (int i = 0; i < n; ++i) {
for (int j = 0; j < m; ++j) {
scanf("%d", &a[i][j]);
}
}
memset(dp, INF, sizeof(dp));
dp[0] = 0;
for (int s = 0; s < (1 << n); ++s) {
int bit = lowzero(s);
for (int j = 0; j < m; ++j) {
dp[s | (1 << bit)] = min(dp[s | (1 << bit)], dp[s] + a[bit][j]);
int sum = 0, bits = 0, mw = 0;
for (int i = 0; i < n; ++i) {
if (str[i][j] == str[bit][j]) {
sum += a[i][j];
mw = max(mw, a[i][j]);
bits |= 1 << i;
}
}
dp[s | bits] = min(dp[s | bits], dp[s] + sum - mw);
}
}
cout << dp[(1 << n) - 1] << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long n, m;
long long f, s;
long long tot;
long long maxn;
long long dp[1 << 22];
long long a[22][22];
char cost[22][22];
signed main() {
scanf("%lld%lld", &n, &m);
for (register long long i = 0; i < n; i++) cin >> cost[i];
for (register long long i = 0; i < n; i++)
for (register long long j = 0; j < m; j++) scanf("%lld", &a[i][j]);
memset(dp, 1e9 + 7, sizeof(dp));
dp[0] = 0;
for (register long long i = 0; i < (1 << n); i++) {
for (register long long j = 0; j < n; j++) {
if (!(i & (1 << j))) {
f = j;
break;
}
}
for (register long long j = 0; j < m; j++) {
dp[i + (1 << f)] = min(dp[i + (1 << f)], dp[i] + a[f][j]);
s = i, tot = maxn = 0;
for (register long long k = 0; k < n; k++) {
if (cost[k][j] == cost[f][j]) {
s |= (1 << k);
tot += a[k][j];
maxn = max(maxn, a[k][j]);
}
}
dp[s] = min(dp[s], dp[i] + tot - maxn);
}
}
printf("%lld", dp[(1 << n) - 1]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAX = 0x3f3f3f3f;
int dp[1 << 20];
string s[20];
int N, M;
int a[22][22];
int lowzero(int st) {
for (int i = 0; i < N; i++) {
if (st & (1 << i)) {
continue;
}
return i;
}
}
int main() {
cin >> N >> M;
for (int i = 0; i < N; i++) {
cin >> s[i];
}
for (int i = 0; i < N; i++) {
for (int j = 0; j < M; j++) {
cin >> a[i][j];
}
}
memset(dp, 0x3f, sizeof(dp));
dp[0] = 0;
for (int st = 0; st < (1 << N); st++) {
if (dp[st] == MAX) continue;
int t = lowzero(st);
for (int j = 0; j < M; j++) {
dp[st | (1 << t)] = min(dp[st | (1 << t)], dp[st] + a[t][j]);
int tempst = 0, tempsum = 0, tempmax = 0;
for (int i = 0; i < N; i++) {
if (s[i][j] == s[t][j]) {
tempst |= (1 << i);
tempsum += a[i][j];
tempmax = max(tempmax, a[i][j]);
}
}
dp[st | tempst] = min(dp[st | tempst], dp[st] + tempsum - tempmax);
}
}
cout << dp[(1 << N) - 1] << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int inf = 2e9;
const int maxn = 22;
int n, m;
char g[maxn][maxn];
int w[maxn][maxn];
int dp[1 << maxn];
int same[maxn][maxn], cost[maxn][maxn];
void solve() {
for (int i = 0; i < n; ++i) {
for (int j = 0; j < m; ++j) {
int sumc = 0, maxc = 0;
for (int k = 0; k < n; ++k) {
if (g[i][j] == g[k][j]) {
sumc += w[k][j];
maxc = max(maxc, w[k][j]);
same[i][j] |= 1 << k;
}
}
cost[i][j] = sumc - maxc;
}
}
fill(dp, dp + (1 << n), inf);
dp[0] = 0;
for (int s = 0; s < (1 << n); ++s) {
for (int i = 0; i < n; ++i) {
if (!(s >> i & 1)) {
for (int j = 0; j < m; ++j) {
dp[s | (1 << i)] = min(dp[s | (1 << i)], dp[s] + w[i][j]);
dp[s | same[i][j]] = min(dp[s | same[i][j]], dp[s] + cost[i][j]);
}
}
}
}
printf("%d\n", dp[(1 << n) - 1]);
}
int main() {
scanf("%d%d", &n, &m);
for (int i = 0; i < n; ++i) scanf("%s", &g[i]);
for (int i = 0; i < n; ++i)
for (int j = 0; j < m; ++j) scanf("%d", &w[i][j]);
solve();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
string st[21];
int cost[21][21], n, m, dp[(1 << 20)], cnt[26], sum[26], maxC[26], bit[26];
int num[(1 << 20)];
int main() {
cin >> n >> m;
for (int i = 0; i < n; i++) cin >> st[i];
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++) cin >> cost[i][j];
for (int i = 0; i < (1 << n); i++) dp[i] = 1 << 30;
for (int i = 0; i < n; i++) num[1 << i] = i;
dp[0] = 0;
for (int i = 0; i < m; i++) {
for (int k = 0; k < n; k++)
bit[st[k][i] - 'a'] = sum[st[k][i] - 'a'] = cnt[st[k][i] - 'a'] =
maxC[st[k][i] - 'a'] = 0;
for (int k = 0; k < n; k++) {
cnt[st[k][i] - 'a']++;
bit[st[k][i] - 'a'] += (1 << k);
sum[st[k][i] - 'a'] += cost[k][i];
maxC[st[k][i] - 'a'] = max(maxC[st[k][i] - 'a'], cost[k][i]);
}
for (int j = 0; j < (1 << n); j++)
if (dp[j] <= dp[(1 << n) - 1]) {
for (int k = 0; k < n; k++)
if (((1 << k) & j) == 0) {
int c = st[k][i] - 'a';
if (cnt[c] > 1)
dp[j + (1 << k)] = min(dp[j + (1 << k)], dp[j] + cost[k][i]);
else
dp[j + (1 << k)] = min(dp[j + (1 << k)], dp[j]);
if (cnt[c] > 1)
dp[j | bit[c]] = min(dp[j | bit[c]], dp[j] + sum[c] - maxC[c]);
}
}
}
cout << dp[(1 << n) - 1] << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 21;
const int M = 1 << 21;
const long long inf = (long long)1e18;
int n, m;
char str[N][N];
long long a[N][N];
long long f[M], g[N][N], h[N][N], mn[N];
int main() {
scanf("%d %d", &n, &m);
for (int i = 1; i <= n; i++) scanf("%s", str[i] + 1);
for (int i = 1; i <= n; i++)
for (int j = 1; j <= m; j++) scanf("%I64d", a[i] + j);
for (int i = 1; i <= n; i++)
for (int j = 1; j <= n; j++)
for (int k = 1; k <= m; k++)
if (str[i][k] == str[j][k]) g[i][k] |= (1 << (j - 1));
for (int i = 1; i < (1 << n); i++) f[i] = inf;
for (int i = 1; i <= n; i++)
for (int j = 1; j <= m; j++) {
int sta = g[i][j];
long long sum = 0, mx = 0;
for (int k = 1; k <= n; k++)
if ((sta >> (k - 1)) & 1) sum += a[k][j], mx = max(mx, a[k][j]);
h[i][j] = sum - mx;
}
for (int i = 1; i <= n; i++) {
mn[i] = a[i][1];
for (int j = 1; j <= m; j++) mn[i] = min(mn[i], a[i][j]);
}
for (int u = 0, v; u < (1 << n); u++) {
for (int i = 1; i <= n; i++)
if (!((u >> (i - 1)) & 1)) {
v = u | (1 << (i - 1));
f[v] = min(f[v], f[u] + mn[i]);
for (int j = 1; j <= m; j++) {
f[u | g[i][j]] = min(f[u | g[i][j]], f[u] + h[i][j]);
}
break;
}
}
printf("%I64d", f[(1 << n) - 1] == inf ? -1 : f[(1 << n) - 1]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int dp[1 << 21];
int cost[30][30], num[30][30];
int nex[30][30];
char s[30][30];
int n, m, all;
void init() {
all = (1 << n) - 1;
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
int val = all;
for (int k = 0; k < n; k++) {
if (s[i][j] == s[k][j]) {
val -= (1 << k);
if (i != k) cost[i][j] += num[k][j];
}
}
nex[i][j] = val;
}
}
}
int main() {
scanf("%d%d", &n, &m);
for (int i = 0; i < n; i++) {
scanf("%s", s[i]);
}
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
scanf("%d", &num[i][j]);
}
}
init();
int ret = all;
for (int i = 0; i < n; i++) {
int ok = 1;
for (int j = 0; j < m; j++) {
for (int k = 0; k < n; k++)
if (k != i) {
if (s[i][j] == s[k][j]) ok = 0;
}
}
if (ok) ret -= (1 << i);
}
memset(dp, 0x3f3f3f3f, sizeof(dp));
dp[ret] = 0;
for (int s = ret; s > 0; s--) {
for (int i = 0; i < n; i++) {
if ((s & (1 << i)) == 0) continue;
int s1 = s ^ (1 << i);
for (int j = 0; j < m; j++) {
dp[s1] = min(dp[s1], dp[s] + num[i][j]);
int s2 = s1 & nex[i][j];
dp[s2] = min(dp[s2], dp[s] + cost[i][j]);
}
}
}
printf("%d\n", dp[0]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int dp[1 << 25];
int n, m;
int a[30][30];
int qi[30][30];
int st[30][30];
char c[30][30];
int lowbit(int x) { return (x & (-x)); }
int main() {
scanf("%d", &n);
scanf("%d", &m);
for (int i = 1; i <= n; i++) scanf("%s", c[i] + 1);
for (int i = 1; i <= n; i++)
for (int j = 1; j <= m; j++) scanf("%d", &a[i][j]);
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
int it = -2e9, sum = 0;
for (int k = 1; k <= n; k++) {
if (c[k][j] == c[i][j]) {
st[i][j] |= (1 << (k - 1));
sum += a[k][j];
it = max(it, a[k][j]);
}
}
sum -= it;
qi[i][j] = sum;
}
}
for (int i = 0; i <= (1 << n) - 1; i++) dp[i] = 2e9;
dp[0] = 0;
for (int i = 0; i <= (1 << n) - 1; i++) {
int k;
for (k = 0; k <= n; k++)
if (!((1 << k) & i)) {
break;
}
for (int j = 1; j <= m; j++) {
dp[i | (1 << k)] = min(dp[i | (1 << k)], dp[i] + a[k + 1][j]);
dp[i | st[k + 1][j]] = min(dp[i] + qi[k + 1][j], dp[i | st[k + 1][j]]);
}
}
cout << dp[(1 << n) - 1] << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m;
char s[30][30];
int map1[30][30];
int dp[(1 << 21)];
int pre[30][30], cost[30][30];
void chuli(int sta, int low) {
int temp;
for (int i = 1; i <= m; ++i) {
dp[sta] = min(dp[sta], dp[sta ^ (1 << low)] + map1[low][i]);
dp[sta] = min(dp[sta], dp[sta & (~pre[low][i])] + cost[low][i]);
}
}
void init() {
int temp, sum, maxn;
for (int i = 0; i < n; ++i)
for (int j = 1; j <= m; ++j) {
temp = 0;
sum = 0;
maxn = 0;
for (int k = 0; k < n; ++k)
if (s[k][j] == s[i][j]) {
sum += map1[k][j];
maxn = max(maxn, map1[k][j]);
temp ^= (1 << k);
}
pre[i][j] = temp;
cost[i][j] = sum - maxn;
}
}
int main() {
scanf("%d %d", &n, &m);
for (int i = 0; i < n; ++i) scanf("%s", s[i] + 1);
for (int i = 0; i < n; ++i)
for (int j = 1; j <= m; ++j) scanf("%d", &map1[i][j]);
init();
memset(dp, 0x3f, sizeof(dp));
dp[0] = 0;
for (int i = 1; i < (1 << n); ++i)
for (int k = 0; k < n; ++k)
if (i & (1 << k)) {
chuli(i, k);
break;
}
printf("%d\n", dp[(1 << n) - 1]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
inline int toInt(string s) {
int v;
istringstream sin(s);
sin >> v;
return v;
}
template <class T>
inline string toString(T x) {
ostringstream sout;
sout << x;
return sout.str();
}
int n, m;
int A[30][30];
int DP[1 << 20];
int sum[20][26];
int getMsk[20][26];
int best[20][26];
vector<string> v;
int solve(int msk) {
if (msk == (1 << n) - 1) return 0;
int &ret = DP[msk];
if (ret != -1) return ret;
ret = 1 << 30;
for (int i = 0; i < n; ++i) {
if ((msk | (1 << i)) == msk) continue;
for (int j = 0; j < m; ++j) {
ret = min(ret, A[i][j] + solve(msk | (1 << i)));
int k = v[i][j] - 'a';
if ((msk | getMsk[j][k]) != msk)
ret = min(ret, sum[j][k] - best[j][k] + solve(msk | getMsk[j][k]));
}
break;
}
return ret;
}
int main() {
{
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
}
memset(DP, -1, sizeof(DP));
cin >> n >> m;
v.resize(n);
for (int i = 0; i < n; ++i) {
cin >> v[i];
}
for (int i = 0; i < n; ++i) {
for (int j = 0; j < m; ++j) {
cin >> A[i][j];
sum[j][v[i][j] - 'a'] += A[i][j];
getMsk[j][v[i][j] - 'a'] |= (1 << i);
best[j][v[i][j] - 'a'] = max(best[j][v[i][j] - 'a'], A[i][j]);
}
}
memset(DP, -1, sizeof(DP));
cout << solve(0);
}
|
#include <bits/stdc++.h>
long long gcd(long long x, long long y) {
return y % x == 0 ? x : gcd(y % x, x);
}
template <class T>
T my_abs(T a) {
if (a < 0) a = -a;
return a;
}
const int maxn = 30 + 7, inf = 0x3f3f3f3f;
int dp[1 << 20];
int n, m, a[maxn][maxn], c[maxn][maxn], sv[maxn][maxn];
char str[maxn];
std::string s[maxn];
int main() {
scanf("%d %d", &n, &m);
std::memset(dp, 0x3f, sizeof(dp));
for (int i = (int)(0); i <= (int)(n - 1); i++) scanf("%s", str), s[i] = str;
for (int i = (int)(0); i <= (int)(n - 1); i++)
for (int j = (int)(0); j <= (int)(m - 1); j++) scanf("%d", &a[i][j]);
for (int i = (int)(0); i <= (int)(n - 1); i++) {
for (int j = (int)(0); j <= (int)(m - 1); j++) {
int curv = 0;
for (int k = (int)(0); k <= (int)(n - 1); k++) {
if (s[i][j] == s[k][j]) {
sv[i][j] |= 1 << k;
c[i][j] += a[k][j];
curv = (curv > a[k][j] ? curv : a[k][j]);
}
}
c[i][j] -= curv;
}
}
dp[0] = 0;
for (int i = (int)(1); i <= (int)((1 << n) - 1); i++) {
int lowbit = -1;
for (int j = (int)(0); j <= (int)(n - 1); j++) {
if ((i >> j) & 1) {
lowbit = j;
break;
}
}
for (int j = (int)(0); j <= (int)(m - 1); j++) {
dp[i] = (dp[i] < dp[i & (i ^ sv[lowbit][j])] + c[lowbit][j]
? dp[i]
: dp[i & (i ^ sv[lowbit][j])] + c[lowbit][j]);
dp[i] = (dp[i] < dp[i ^ (1 << lowbit)] + a[lowbit][j]
? dp[i]
: dp[i ^ (1 << lowbit)] + a[lowbit][j]);
}
}
printf("%d\n", dp[(1 << n) - 1]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1 << 20;
int mi2[20], _mi2[maxn];
int n, m;
char s[21][21];
int a[21][21];
int sv[21][21], c[21][21];
int f[maxn];
int main() {
_mi2[mi2[0] = 1] = 0;
for (int i = (1); i <= (19); ++i) mi2[i] = mi2[i - 1] * 2, _mi2[mi2[i]] = i;
for (int i = 1, nn = 1 << 20; i < nn; ++i)
if (!_mi2[i]) _mi2[i] = _mi2[i - 1];
scanf("%d%d", &n, &m);
for (int i = (0); i <= (n - 1); ++i) scanf("%s", s[i]);
for (int i = (0); i <= (n - 1); ++i)
for (int j = (0); j <= (m - 1); ++j) scanf("%d", &a[i][j]);
for (int i = (0); i <= (n - 1); ++i)
for (int j = (0); j <= (m - 1); ++j) {
int mx = 0;
for (int k = (0); k <= (n - 1); ++k)
if (s[i][j] == s[k][j]) {
sv[i][j] |= mi2[k];
c[i][j] += a[k][j];
mx = max(mx, a[k][j]);
}
c[i][j] -= mx;
}
int nn = 1 << n;
--nn;
for (int _ = 1, u, ww; _ <= nn; ++_) {
f[_] = 0x7fffffff;
ww = _ & (-_);
u = _mi2[ww];
for (int i = (0); i <= (m - 1); ++i) {
f[_] = min(f[_], f[_ - ww] + a[u][i]);
f[_] = min(f[_], f[_ & (_ ^ sv[u][i])] + c[u][i]);
}
}
cout << f[nn] << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long n, m, f, s, tot, maxn;
long long dp[1 << 22];
long long a[22][22];
char mp[22][22];
signed main() {
scanf("%lld %lld", &n, &m);
for (long long i = 0; i < n; i++) cin >> mp[i];
for (long long i = 0; i < n; i++)
for (long long j = 0; j < m; j++) scanf("%lld", &a[i][j]);
memset(dp, 0x3f3f3f3f, sizeof(dp));
dp[0] = 0;
for (long long i = 0; i < (1 << n); i++) {
for (long long j = 0; j < n; j++)
if (!(i & (1 << j))) {
f = j;
break;
}
for (long long j = 0; j < m; j++) {
dp[i + (1 << f)] = min(dp[i + (1 << f)], dp[i] + a[f][j]);
s = i, tot = maxn = 0;
for (long long k = 0; k < n; k++)
if (mp[k][j] == mp[f][j])
s |= (1 << k), tot += a[k][j], maxn = max(maxn, a[k][j]);
dp[s] = min(dp[s], dp[i] + tot - maxn);
}
}
cout << dp[(1 << n) - 1] << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long inf = 1e17;
int n, m;
int num[22][22], a[22][22];
long long f[1 << 21], val[22][22];
char str[25][25];
int main() {
scanf("%d %d", &n, &m);
for (int i = 1; i <= n; i++) scanf("%s", str[i] + 1);
for (int i = 1; i <= n; i++)
for (int j = 1; j <= m; j++) scanf("%d", &a[i][j]);
for (int i = 1; i <= m; i++)
for (int j = 1; j <= n; j++) {
long long mx = 0, sum = 0;
for (int k = 1; k <= n; k++)
if (str[j][i] == str[k][i]) {
sum += a[k][i];
mx = max(mx, 1ll * a[k][i]);
num[j][i] |= (1 << k - 1);
}
val[j][i] = sum - mx;
}
for (int s = 0; s < (1 << n); s++) f[s] = inf;
f[0] = 0;
for (int s = 0; s < (1 << n); s++) {
int x = 0;
for (int i = 1; i <= n; i++)
if (!(s & (1 << i - 1))) {
x = i;
break;
}
if (!x) break;
for (int i = 1; i <= m; i++) {
f[s | (1 << x - 1)] = min(f[s | (1 << x - 1)], f[s] + a[x][i]);
f[s | num[x][i]] = min(f[s | num[x][i]], f[s] + val[x][i]);
}
}
printf("%d", f[(1 << n) - 1]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using pii = pair<int, int>;
using pll = pair<ll, ll>;
const ll inf = 1E17;
const ll mod = 1;
ll a[300010];
int n, k, chnk;
ll dp[5001][5001];
ll solve(int pos, int xtra, int l) {
if (pos == 0) {
if (xtra == 0) return 0;
return inf;
}
ll &ret = dp[pos][xtra];
if (ret != -1) return ret;
ret = a[l + chnk - 1] - a[l] + solve(pos - 1, xtra, l + chnk);
if (xtra)
ret = min(ret, a[l + chnk] - a[l] + solve(pos - 1, xtra - 1, l + chnk + 1));
return ret;
}
int main() {
ios_base::sync_with_stdio(false);
while (cin >> n >> k) {
for (int i = 1; i <= n; i++) {
cin >> a[i];
}
sort(a + 1, a + n + 1);
memset(dp, -1, sizeof dp);
chnk = n / k;
cout << solve(k, n % k, 1) << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, k;
int a[1 << 20];
int sz[1 << 20];
int cnt1, cnt2, sz1, sz2;
bool used[5124][5124];
long long state[5124][5124];
long long all;
long long diff[1 << 20];
long long recurse(int pos, int cnt1, int cnt2) {
if (pos >= n) return 0;
if (used[cnt1][cnt2]) return state[cnt1][cnt2];
long long ans = 0;
if (cnt1 > 0)
if (pos + sz1 - 1 >= pos)
ans = max(ans, a[pos + sz1] - a[pos + sz1 - 1] +
recurse(pos + sz1, cnt1 - 1, cnt2));
if (cnt2 > 0)
if (pos + sz2 - 1 >= pos)
ans = max(ans, a[pos + sz2] - a[pos + sz2 - 1] +
recurse(pos + sz2, cnt1, cnt2 - 1));
used[cnt1][cnt2] = true;
state[cnt1][cnt2] = ans;
return ans;
}
int main() {
int i;
scanf("%d %d", &n, &k);
for (i = 1; i <= n; i++) scanf("%d", &a[i]);
sort(a + 1, a + 1 + n);
for (i = 2; i <= n; i++) diff[i] = diff[i - 1] + a[i] - a[i - 1];
for (i = 2; i <= n; i++) all += a[i] - a[i - 1];
for (i = 1; i <= n; i++) {
sz[i % k]++;
}
sz1 = (n + k - 1) / k;
sz2 = sz1 - 1;
for (i = 0; i < k; i++) {
if (sz[i % k] == sz1)
cnt1++;
else
cnt2++;
}
printf("%I64d\n", all - recurse(1, cnt1, cnt2));
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, k;
long long a[500005];
long long dp[5005][5005];
int main() {
scanf("%d%d", &n, &k);
for (int i = 1; i <= n; i++) scanf("%I64d", &a[i]);
sort(a + 1, a + 1 + n);
int len1 = n / k + 1, num1 = n % k;
int len2 = n / k, num2 = k - n % k;
memset(dp, 0x3f, sizeof(dp));
dp[0][0] = 0;
for (int i = 0; i <= num1; i++) {
for (int j = 0; j <= num2; j++) {
if (i) {
int s = (i - 1) * len1 + j * len2 + 1;
int e = s + len1 - 1;
dp[i][j] = min(dp[i][j], dp[i - 1][j] + a[e] - a[s]);
}
if (j) {
int s = i * len1 + (j - 1) * len2 + 1;
int e = s + len2 - 1;
dp[i][j] = min(dp[i][j], dp[i][j - 1] + a[e] - a[s]);
}
}
}
printf("%I64d\n", dp[num1][num2]);
}
|
#include <bits/stdc++.h>
using namespace std;
const int OO = 2e9;
const int MOD = 1e9 + 7;
const double Pi = 3.141592653589793;
const int N = 3e5 + 5;
vector<long long> dp[5003];
int a[N], n, k, d0, d1, l0, l1, v0, v1, last;
int main() {
cin >> n >> k;
for (int i = (int)1; i <= (int)n; i++) scanf("%i", &a[i]);
sort(a + 1, a + n + 1);
d1 = n % k;
d0 = k - d1;
l0 = n / k;
l1 = l0 + 1;
for (int i = (int)0; i <= (int)d0; i++)
for (int j = (int)0; j <= (int)d1; j++) dp[i].push_back(0);
dp[0][0] = 0;
for (int i = (int)1; i <= (int)d1; i++)
dp[0][i] = dp[0][i - 1] + a[i * l1] - a[i * l1 - l1 + 1];
for (int i = (int)1; i <= (int)d0; i++) {
dp[i][0] = dp[i - 1][0] + a[i * l0] - a[i * l0 - l0 + 1];
for (int j = (int)1; j <= (int)d1; j++) {
last = i * l0 + j * l1;
v0 = dp[i - 1][j] + a[last] - a[last - l0 + 1];
v1 = dp[i][j - 1] + a[last] - a[last - l1 + 1];
dp[i][j] = min(v0, v1);
}
}
cout << dp[d0][d1];
}
|
#include <bits/stdc++.h>
using namespace std;
const int INF = 2e9;
const int MAX_n = 3e5 + 10, MAX_k = 5010;
int n, k;
int a[MAX_n];
int dp[MAX_k][MAX_k];
int abs(int x) { return max(x, -x); }
int main() {
ios_base::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 div = n / k, mod = n % k;
for (int i = 0; i <= mod; ++i) {
for (int j = 0; j <= k - mod; ++j) {
if (i + j == 0) continue;
int l = i * (div + 1) + j * (div);
dp[i][j] = INF;
if (i) {
dp[i][j] = min(dp[i][j], dp[i - 1][j] + a[l - 1] - a[l - div - 1]);
}
if (j) {
dp[i][j] = min(dp[i][j], dp[i][j - 1] + a[l - 1] - a[l - n / k]);
}
}
}
cout << dp[n % k][k - n % k] << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int max_n = 300 * 1000, max_k = 5000;
int ar[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", &ar[i]);
sort(ar, ar + n);
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(ar[cur + x] - ar[cur] + dp[i][j], dp[i + 1][j]);
if (j < b)
dp[i][j + 1] =
min(ar[cur + x - 1] - ar[cur] + dp[i][j], dp[i][j + 1]);
}
cout << dp[a][b] << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long a[300010], N, K, dp[5010][5010];
inline long long f(long long L, long long S) {
return L * (N / K + 1) + S * (N / K);
}
long long solve(long long L, long long S) {
if (dp[L][S] != -1) return dp[L][S];
if (S == 0 and L == 0) return dp[L][S] = 0;
if (S == 0 and L > 0)
return dp[L][S] = a[f(L, S)] - a[f(L, S) - N / K] + solve(L - 1, S);
if (S > 0 and L == 0)
return dp[L][S] = a[f(L, S)] - a[f(L, S) - N / K + 1] + solve(L, S - 1);
long long e1 = a[f(L, S)] - a[f(L, S) - N / K] + solve(L - 1, S);
long long e2 = a[f(L, S)] - a[f(L, S) - N / K + 1] + solve(L, S - 1);
return dp[L][S] = min(e1, e2);
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
memset(dp, -1, sizeof dp);
cin >> N >> K;
for (long long i = 1; i <= N; i++) cin >> a[i];
sort(a + 1, a + N + 1);
long long L = N % K;
long long S = K - L;
cout << solve(L, S) << '\n';
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
struct debug_t {
template <typename T>
debug_t& operator<<(const T& value) {
return *this;
}
} debug;
const int N = (int)3e5;
int n, k, gLen;
int a[N];
int d[N];
map<int, long long> dp[5001];
long long Dyn(int gr, int ls, int pos) {
if (pos > n) return 100LL * INT_MAX;
if (pos == n) return gr || ls ? 100LL * INT_MAX : 0;
auto it = dp[gr].find(pos);
if (it != dp[gr].end()) return it->second;
long long result = LLONG_MAX;
if (ls)
result = min(result,
d[pos + gLen - 2] - d[pos] + Dyn(gr, ls - 1, pos + gLen - 1));
if (gr)
result =
min(result, d[pos + gLen - 1] - d[pos] + Dyn(gr - 1, ls, pos + gLen));
dp[gr].emplace(pos, result);
return result;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
while (cin >> n >> k) {
int i;
for (i = 0; i < n; i++) cin >> a[i];
gLen = (n + k - 1) / k;
int gCount = n % k;
if (!gCount) gCount = k;
int lCount = gLen == 1 ? 0 : (n - gCount * gLen) / (gLen - 1);
sort(a, a + n);
adjacent_difference(a, a + n, d);
partial_sum(d + 1, d + n, d + 1);
d[0] = 0;
for (i = 0; i < n; i++) debug << d[i] << ' ';
debug << '\n' << gLen << ' ' << gCount << '\n';
for (auto& m : dp) m.clear();
cout << Dyn(gCount, lCount, 0) << '\n';
debug << '\n';
}
}
|
#include <bits/stdc++.h>
using namespace std;
const long long INF = 1000000000000000LL;
int a[300010];
long long dp[5010][5010];
int main() {
int n, k;
cin >> n >> k;
for (int i = 0; i < n; i++) {
scanf("%d", &a[i]);
}
sort(a, a + n);
int gsize = n / k;
int l = n % k;
int s = k - l;
for (int i = 0; i <= k; i++) {
for (int j = 0; j <= min(s, i); j++) {
dp[j][i - j] = INF;
}
}
long long ans = INF;
dp[0][0] = 0;
for (int i = 1; i <= k; i++) {
for (int j = 0; j <= min(s, i); j++) {
int pos = i * gsize + (i - j) - 1;
if (j > 0)
dp[j][i - j] =
min(dp[j][i - j], dp[j - 1][i - j] + a[pos] - a[pos - gsize + 1]);
if (i - j > 0)
dp[j][i - j] =
min(dp[j][i - j], dp[j][i - j - 1] + a[pos] - a[pos - gsize]);
if (i == k && s == j) {
ans = min(ans, dp[j][k - j]);
}
}
}
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 330000;
int a[N], m;
long long dp[5500][5500];
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int n, k;
cin >> n >> k;
for (int i = 1; i <= n; i++) cin >> a[i];
sort(a + 1, a + n + 1);
m = n / k;
int b = k - n % k, c = n % k;
for (int i = 0; i < 66; i++)
for (int j = 0; j < 66; j++) dp[i][j] = LLONG_MIN;
long long tot = 0;
for (int i = 1; i < n; i++) tot += abs(a[i + 1] - a[i]);
for (int i = 0; i <= b; i++) {
for (int j = 0; j <= c; j++) {
if (i == 0 && j == 0) {
dp[i][j] = 0;
continue;
}
if (i == 1 && j == 0) {
dp[i][j] = 0;
continue;
}
if (i == 0 && j == 1) {
dp[i][j] = 0;
continue;
}
if (i)
dp[i][j] =
max(dp[i][j], dp[i - 1][j] + abs(a[m * (i - 1) + (m + 1) * j] -
a[m * (i - 1) + (m + 1) * j + 1]));
if (j)
dp[i][j] =
max(dp[i][j], dp[i][j - 1] + abs(a[m * i + (m + 1) * (j - 1)] -
a[m * i + (m + 1) * (j - 1) + 1]));
}
}
cout << tot - dp[b][c] << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 3e5 + 1;
int n, k, x;
long long int a1[maxn];
long long int dp[5001][5001];
long long int com(int a, int b) {
int in = n - a * (x + 1) - b * x;
if (in == n) return 0;
if (dp[a][b] != -1) return dp[a][b];
long long int ans = 0;
if (b == 0) {
ans = com(a - 1, b);
ans += a1[in + x] - a1[in];
} else if (a == 0) {
ans = com(a, b - 1);
ans += a1[in + x - 1] - a1[in];
} else {
long long int t1, t2;
t1 = com(a, b - 1);
t1 += a1[in + x - 1] - a1[in];
t2 = com(a - 1, b);
t2 += a1[in + x] - a1[in];
ans = min(t1, t2);
}
dp[a][b] = ans;
return ans;
}
int main() {
cin >> n >> k;
for (int i = 0; i < n; ++i) {
cin >> a1[i];
}
sort(a1, a1 + n);
x = n / k;
long long int ct = k - n % k;
memset(dp, -1, sizeof(dp));
cout << com(n % k, ct) << "\n";
}
|
#include <bits/stdc++.h>
using namespace std;
int n, k, a[300005];
map<int, long long> dp[300005];
map<int, long long>::iterator it;
int main() {
cin >> n >> k;
for (int i = 1; i <= n; i++) scanf("%d", &a[i]);
sort(a + 1, a + n + 1);
dp[0][0] = 0;
int a1 = n / k + 1, a2 = n / k, b1 = n % k, b2 = n - n % k;
for (int i = a2; i <= n; i++) {
for (it = dp[i - a2].begin(); it != dp[i - a2].end(); it++) {
int k = (*it).first;
dp[i][k] = (*it).second + a[i] - a[i - a2 + 1];
}
if (i - a1 < 0) continue;
for (it = dp[i - a1].begin(); it != dp[i - a1].end(); it++) {
int k = (*it).first;
if (k + 1 <= b1) {
if (dp[i].find(k + 1) == dp[i].end())
dp[i][k + 1] = (*it).second + a[i] - a[i - a1 + 1];
else
dp[i][k + 1] = min(dp[i][k + 1], (*it).second + a[i] - a[i - a1 + 1]);
}
}
dp[i - a1].clear();
}
cout << dp[n][b1] << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int a[300005];
long long dp[5005][5005];
int main() {
int i, j, n, k, x, m;
cin >> n >> k;
for (i = 1; i <= n; i++) scanf("%d", &a[i]);
sort(a + 1, a + 1 + n);
m = (n - 1) / k + 1;
x = n % k;
if (x == 0) x = k;
for (i = 1; i <= k; i++) {
for (j = 0; j <= i; j++) {
dp[i][j] = (long long)1 << 60;
int x = m * j + (m - 1) * (i - j);
if (x <= n) {
if (j > 0) {
dp[i][j] =
dp[i - 1][j - 1] + a[x] - a[m * (j - 1) + (m - 1) * (i - j) + 1];
}
if (i != j) {
dp[i][j] = min(dp[i][j], dp[i - 1][j] + a[x] -
a[m * j + (m - 1) * (i - 1 - j) + 1]);
}
}
}
}
printf("%I64d\n", dp[k][x]);
}
|
#include <bits/stdc++.h>
using namespace std;
long long v[300000];
long long acc[300000];
long long pd[5001][5001];
int len_s, n_big, n_small;
long long solve(int ns, int nb) {
if (ns + nb == 0) {
return 0;
}
long long& ans = pd[ns][nb];
if (ans != -1) {
return ans;
}
int p = (n_small - ns) * len_s + (n_big - nb) * (len_s + 1);
ans = LLONG_MAX;
if (ns) {
ans = acc[p + len_s - 1] - acc[p] + solve(ns - 1, nb);
}
if (nb) {
ans = min(ans, acc[p + len_s] - acc[p] + solve(ns, nb - 1));
}
return ans;
}
int main() {
ios::sync_with_stdio(false);
int n, k;
cin >> n >> k;
for (int i = 0; i < n; ++i) {
cin >> v[i];
}
if (n < k) {
cout << 0 << endl;
return 0;
}
sort(v, v + n);
for (int i = 1; i < n; ++i) {
acc[i] = acc[i - 1] + v[i] - v[i - 1];
}
len_s = (n - 1) / k;
n_big = (n - 1 - len_s * k) + 1;
n_small = k - n_big;
memset(pd, -1, sizeof pd);
cout << solve(n_small, n_big) << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int A[300000 + 1];
bool used[5000 + 1][5000 + 1];
long long memo[5000 + 1][5000 + 1];
int n, K;
long long la, lb;
long long ga, gb;
long long dp(int a, int b) {
if (a == ga && b == gb) return 0;
if (used[a][b]) return memo[a][b];
used[a][b] = 1;
long long &dev = memo[a][b] = (1LL << 60);
int pos = a * la + b * lb;
if (a + 1 <= ga) dev = min(dev, A[pos + la - 1] - A[pos] + dp(a + 1, b));
if (b + 1 <= gb) dev = min(dev, A[pos + lb - 1] - A[pos] + dp(a, b + 1));
return dev;
}
int main() {
while (scanf("%d", &n) == 1) {
scanf("%d", &K);
for (int i = 0; i < n; i++) scanf("%d", &A[i]);
la = (n - 1) / K + 1;
lb = n / K;
ga = (n % K);
gb = K - (n % K);
sort(A, A + n);
memset(used, 0, sizeof(used));
cout << dp(0, 0) << '\n';
}
}
|
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:102400000,102400000")
using namespace std;
template <class T>
inline void scan_d(T &ret) {
char c;
int flag = 0;
ret = 0;
while (((c = getchar()) < '0' || c > '9') && c != '-')
;
if (c == '-') {
flag = 1;
c = getchar();
}
while (c >= '0' && c <= '9') ret = ret * 10 + (c - '0'), c = getchar();
if (flag) ret = -ret;
}
const int maxn = 5000 + 10;
int dp[maxn][maxn];
int a[300000 + 10];
int main() {
int n, k;
while (scanf("%d%d", &n, &k) == 2) {
for (int i = 1; i <= n; i++) scanf("%d", &a[i]);
sort(a + 1, a + 1 + n);
int t = n / k;
int big = n % k, sm = k - big;
dp[0][0] = 0;
for (int i = 0; i <= big; i++)
for (int j = 0; j <= sm; j++) {
if (i == 0 && j == 0) continue;
dp[i][j] = 2000000000;
if (i)
dp[i][j] = min(dp[i][j], dp[i - 1][j] + a[i * (t + 1) + j * t] -
a[(i - 1) * (t + 1) + j * t + 1]);
if (j)
dp[i][j] = min(dp[i][j], dp[i][j - 1] + a[i * (t + 1) + j * t] -
a[i * (t + 1) + (j - 1) * t + 1]);
}
printf("%d\n", dp[big][sm]);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long INF = 100000000000000000ll;
const int N = 300010;
int a[N];
long long sum[N];
long long dp[2][5010];
int k1, k2, w1, w2;
int n, k;
long long calc(int l, int r) {
int mid;
if (r < l) return 0;
return a[r] - a[l];
}
int main() {
scanf("%d%d", &n, &k);
int i, j;
for (i = 1; i <= n; i++) scanf("%d", &a[i]);
sort(a + 1, a + 1 + n);
for (i = 1; i <= n; i++) sum[i] = sum[i - 1] + a[i];
if (n % k == 0)
k2 = 0;
else
k2 = k - n % k;
k1 = k - k2;
w1 = n / k + (n % k != 0);
w2 = w1 - 1;
for (j = 0; j <= k1; j++) dp[0][j] = INF;
dp[0][0] = 0;
for (i = 0; i <= k1 + k2 - 1; i++) {
for (j = 0; j <= k1; j++) dp[i + 1 & 1][j] = INF;
for (j = 0; j <= k1; j++) {
dp[i + 1 & 1][j] = min(dp[i + 1 & 1][j],
dp[i & 1][j] + calc(w1 * j + w2 * (i - j) + 1,
w1 * j + w2 * (i - j) + w2));
if (j < k1)
dp[i + 1 & 1][j + 1] =
min(dp[i + 1 & 1][j + 1],
dp[i & 1][j] + calc(w1 * j + w2 * (i - j) + 1,
w1 * j + w2 * (i - j) + w1));
}
}
printf("%I64d\n", dp[(k1 + k2) & 1][k1]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long int t, i, j, k, l, n, m, a[300010], d[5010][5010];
int main() {
cin >> n >> m;
t = n / m;
l = n % m;
for (i = 0; i < n; i++) {
cin >> a[i];
}
sort(a, a + n);
for (i = 0; i <= m; i++) {
for (j = 0; j <= l; j++) {
d[i][j] = 9e18;
}
}
d[0][0] = 0;
for (i = 1; i <= m; i++) {
for (j = 0; j <= l; j++) {
d[i][j] = d[i - 1][j] + abs(a[t * i + j - 1] - a[t * i + j - t]);
if (j) {
d[i][j] = min(d[i][j], d[i - 1][j - 1] + abs(a[t * i + j - 1] -
a[t * i + j - t - 1]));
}
}
}
cout << d[m][n % m] << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 3e5 + 100;
const int MAXK = 5015;
int n, k;
int a[MAXN];
long long sum[MAXN];
long long d[MAXK][MAXK];
int main() {
scanf("%d%d", &n, &k);
for (int i = 0; i < (n); i++) scanf("%d", &a[i]);
sort(a, a + n);
int m = n % k, l = n / k;
for (int i = 0; i < (n - 1); i++) sum[i + 2] = sum[i + 1] + a[i + 1] - a[i];
for (int i = 0; i < (k + 1); i++)
for (int j = 0; j < (m + 1); j++) d[i][j] = 1e18;
d[0][0] = 0;
for (int i = 0; i < (k); i++) {
for (int j = 0; j < (m + 1); j++) {
d[i + 1][j] =
min(d[i + 1][j], d[i][j] + sum[i * l + j + l] - sum[i * l + j + 1]);
d[i + 1][j + 1] = min(d[i + 1][j + 1], d[i][j] + sum[i * l + j + l + 1] -
sum[i * l + j + 1]);
}
}
printf(
"%lld"
"\n",
d[k][m]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int N, K;
int A[714514];
long long dp[5100][5100];
int main() {
scanf("%d%d", &N, &K);
for (int(i) = 0; (i) < (N); (i)++) scanf("%d", &A[i]);
sort(A, A + N);
int p1 = N % K;
int p2 = K - p1;
int w = N / K;
for (int(i) = 0; (i) < (5100); (i)++)
for (int(j) = 0; (j) < (5100); (j)++) dp[i][j] = 1LL << 61;
dp[0][0] = 0;
for (int(i) = 0; (i) < (p1 + 1); (i)++)
for (int(j) = 0; (j) < (p2 + 1); (j)++) {
int cc = i * (w + 1) + j * w;
if (cc > N) continue;
dp[i + 1][j] = min(dp[i + 1][j], dp[i][j] + abs(A[cc] - A[cc + w]));
dp[i][j + 1] = min(dp[i][j + 1], dp[i][j] + abs(A[cc] - A[cc + w - 1]));
}
printf("%d\n", dp[p1][p2]);
}
|
#include <bits/stdc++.h>
using namespace std;
const long long maxN = 5e3 + 13, INF = 1e18 + 13;
long long n, k, dp[maxN][maxN];
vector<long long> vec;
int32_t main() {
cin >> n >> k;
for (long long i = 0; i < n; i++) {
long long a;
cin >> a;
vec.push_back(a);
}
memset(dp, 63, sizeof dp);
sort(vec.begin(), vec.end());
long long s = k - (n % k), l = n % k;
for (long long i = 0; i <= s; i++)
for (long long j = 0; j <= l; j++) {
if (i == 0 && j == 0)
dp[i][j] = 0;
else
dp[i][j] = min(
((i) ? dp[i - 1][j] +
vec[(i - 1) * (n / k) + j * (n / k + 1) + n / k - 1] -
vec[(i - 1) * (n / k) + j * (n / k + 1)]
: INF),
((j) ? dp[i][j - 1] +
vec[i * (n / k) + (j - 1) * (n / k + 1) + n / k] -
vec[i * (n / k) + (j - 1) * (n / k + 1)]
: INF));
}
cout << dp[s][l] << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long INF = 2e9;
const long long MOD = 1e9 + 7;
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());
vector<vector<long long>> dp(k + 1, vector<long long>(k + 1));
for (long long i = 0; i <= k; i++) {
for (long long j = 0; j <= k; j++) {
long long now = (n / k) * i + (n / k + 1) * j - 1;
if (now >= n || (!i && !j)) continue;
dp[i][j] = min(i ? dp[i - 1][j] + a[now] - a[now - n / k + 1] : INF,
j ? dp[i][j - 1] + a[now] - a[now - n / k] : INF);
}
}
cout << dp[k - n % k][n % k];
}
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
cout.tie(nullptr);
cout.precision(12);
solve();
}
|
#include <bits/stdc++.h>
using namespace std;
const int INF = 1e18;
const int maxk = 5005;
const int maxn = 3e5 + 10;
long long dp[maxk][maxk];
long long arr[maxn];
int main() {
int n, k;
cin >> n >> k;
for (int i = 0; i < n; i++) {
cin >> arr[i];
}
sort(arr, arr + n);
for (int i = 0; i < maxk; i++) {
for (int j = 0; j < maxk; j++) {
dp[i][j] = INF;
}
}
dp[0][0] = 0;
for (int i = 0; i <= k - (n % k); i++) {
for (int j = 0; j <= n % k; j++) {
int now = i * (n / k) + j * ((n + k - 1) / k) - 1;
if (i == 0 && j == 0) {
dp[i][j] = 0;
continue;
}
long long first = INF, second = INF;
if (i >= 1) {
first = arr[now] - arr[now - n / k + 1] + dp[i - 1][j];
}
if (j >= 1) {
second = arr[now] - arr[now - ((n + k - 1) / k) + 1] + dp[i][j - 1];
}
dp[i][j] = min(first, second);
}
}
cout << dp[k - (n % k)][n % k];
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long N = 3e5 + 10, K = 5000 + 10;
long long n, k, a[N];
long long dp[K][K];
long long solve(long long la, long long lb, long long ra, long long rb) {
long long l = lb * (n / k + 1) + (la - lb) * (n / k) + 1;
long long r = rb * (n / k + 1) + (ra - rb) * (n / k);
return dp[la][lb] + a[r] - a[l];
}
int main() {
scanf("%lld%lld", &n, &k);
for (long long i = 1; i <= n; i++) scanf("%lld", &a[i]);
sort(a + 1, a + n + 1);
memset(dp, 0x3f, sizeof(dp));
dp[0][0] = 0;
for (long long i = 1; i <= k; i++) {
long long tmp = min(i, n % k);
for (long long j = 0; j <= tmp; j++) {
if (j == 0)
dp[i][j] = solve(i - 1, j, i, j);
else
dp[i][j] = min(solve(i - 1, j - 1, i, j), solve(i - 1, j, i, j));
}
}
printf("%lld", dp[k][n % k]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long INF = 1e15, M = 5005;
long long dp[M][M];
int a[M * 60], n, k;
void Min(long long &a, long long b) {
if (a > b) a = b;
}
int main() {
scanf("%d%d", &n, &k);
for (int i = 0; i < n; i++) scanf("%d", a + i);
sort(a, a + n);
int len = n / k, res = n % k;
for (int i = 0; i < k + 1; i++)
for (int j = 0; j < k + 1; j++) dp[i][j] = INF;
dp[0][0] = 0;
for (int i = 0; i < k; i++) {
for (int j = 0; j < k; j++) {
if (dp[i][j] == INF) continue;
int nx = i * len + j;
if (nx + len < n) Min(dp[i + 1][j + 1], dp[i][j] + a[nx + len] - a[nx]);
if (nx + len - 1 < n)
Min(dp[i + 1][j], dp[i][j] + a[nx + len - 1] - a[nx]);
}
}
cout << dp[k][res];
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, k;
int d[300000];
long long c[5001][5001];
int main() {
scanf("%d%d", &n, &k);
for (int i = 0; i < n; i++) scanf("%d", &d[i]);
sort(d, d + n);
int lim = (n - 1) % k + 1, itv = (n - 1) / k;
memset(c, -1, sizeof(c));
c[0][0] = 0;
for (int s = 0; s < k; s++) {
for (int i = 0; i <= s; i++) {
int j = s - i;
if (c[i][j] == -1) continue;
if (i + 1 <= k - lim) {
int S = itv * (i + j) + j, E = itv * (i + j + 1) + j - 1;
if (c[i + 1][j] == -1 || c[i + 1][j] > c[i][j] + d[E] - d[S])
c[i + 1][j] = c[i][j] + d[E] - d[S];
}
if (j + 1 <= lim) {
int S = itv * (i + j) + j, E = itv * (i + j + 1) + (j + 1) - 1;
if (c[i][j + 1] == -1 || c[i][j + 1] > c[i][j] + d[E] - d[S])
c[i][j + 1] = c[i][j] + d[E] - d[S];
}
}
}
printf("%I64d", c[k - lim][lim]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long dp[5010][5010] = {0};
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
srand(time(NULL));
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());
for (int i = 2; i <= k; ++i) {
for (int j = 0; j <= min(i, n % k); ++j) {
int cell_num = j + n / k * i;
if (i > j)
dp[i][j] = max(dp[i][j], dp[i - 1][j] + A[cell_num - n / k] -
A[cell_num - n / k - 1]);
if (j) {
dp[i][j] = max(dp[i][j], dp[i - 1][j - 1] + A[cell_num - n / k - 1] -
A[cell_num - n / k - 2]);
}
}
}
cout << A.back() - A[0] - dp[k][n % k] << '\n';
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e6;
long long n, k, a[maxn], j, i, b[maxn], f[5007][5007], maxt, t;
long long res;
long long dp(int i, int t, int k) {
if (k == 0 && i > 0) return 1000000000000;
if (t > 0 && i <= 0) return 1000000000000;
if (i == 0) return 0;
if (f[k][t] == -1) {
if (i - maxt + 1 > 0)
f[k][t] = dp(i - maxt, t, k - 1) + abs(a[i] - a[i - maxt + 1]);
else
f[k][t] = 10000000000000;
if (t > 0 && i - maxt + 2 > 0)
f[k][t] = min(f[k][t], dp(i - maxt + 1, t - 1, k - 1) +
abs(a[i] - a[i - maxt + 2]));
}
return f[k][t];
}
int main() {
cin >> n >> k;
for (int i = 1; i <= n; ++i) {
scanf("%I64d", &a[i]);
}
sort(a + 1, a + n + 1);
maxt = (n - 1) / k;
for (int i = 1; i <= k; ++i)
if ((n - i) / k != maxt) t++;
maxt++;
for (int i = 0; i <= k; i++)
for (int j = 0; j <= k; ++j) f[i][j] = -1;
res = dp(n, t, k);
cout << res;
}
|
#include <bits/stdc++.h>
using namespace std;
int a[301000];
int main() {
int i, n, k;
scanf("%d %d", &n, &k);
for (i = 0; i < n; i++) {
scanf("%d", &a[i]);
}
sort(a, a + n);
int large = n % k, sz = n / k;
int **dp = (int **)malloc((large + 1) * sizeof(int *));
for (int i = 0; i <= large; i++)
dp[i] = (int *)malloc((k - large + 1) * sizeof(int));
for (int i = 0; i <= large; i++)
for (int j = 0; j <= k - large; j++) dp[i][j] = 2e9;
dp[0][0] = 0;
for (int i = 0; i <= large; i++) {
for (int j = 0; j <= k - large; j++) {
int nxt = i * (sz + 1) + j * sz;
if (i < large) {
dp[i + 1][j] = min(dp[i + 1][j], dp[i][j] + a[nxt + sz] - a[nxt]);
}
if (j < k - i) {
dp[i][j + 1] = min(dp[i][j + 1], dp[i][j] + a[nxt + sz - 1] - a[nxt]);
}
}
}
printf("%d\n", dp[large][k - large]);
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 3e5 + 10;
const int maxk = 5000 + 5;
int n, k;
int a[maxn];
long long d[maxk][maxk];
int main() {
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];
int num1 = n % k, len1 = n / k + 1;
int num2 = k - num1, len2 = n / k;
for (int i = 0; i <= num1; i++)
for (int j = 0; j <= num2; j++) {
if (i) {
int k = (i - 1) * len1 + j * len2;
d[i][j] = max(d[i][j], d[i - 1][j] + a[k + 1] - a[k]);
}
if (j) {
int k = i * len1 + (j - 1) * len2;
d[i][j] = max(d[i][j], d[i][j - 1] + a[k + 1] - a[k]);
}
}
printf("%I64d\n", a[n] - a[1] - d[num1][num2]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long INF = (int)1e9 + 70;
const long long MOD = 1e9 + 7;
const int MAXN = 300005;
int gcd(int k, int N) {
if (k == 0) return N;
return gcd(N % k, k);
}
int a[MAXN];
int sz;
int sp;
int k;
long long dp[5005][5005];
long long perform(int i, int j) {
if (j < 0) return -INF;
if (i == k - 1) {
if (j == 0 || j == 1) {
return 0;
} else
return -INF;
}
if (dp[i][j] != -1) return dp[i][j];
int start = sz * i + (sp - j);
long long option0 = perform(i + 1, j) + a[start + sz] - a[start + sz - 1];
long long option1 = perform(i + 1, j - 1) + a[start + sz + 1] - a[start + sz];
if (option0 > option1) {
dp[i][j] = option0;
return option0;
} else {
dp[i][j] = option1;
return option1;
}
}
int main() {
if (fopen("input.txt", "r")) freopen("input.txt", "r", stdin);
memset(dp, -1, sizeof(dp));
int(N);
scanf("%d", &N);
cin >> k;
sz = N / k;
sp = N % k;
for (int i = (0); i < (N); i++) {
scanf("%d", &(a[i]));
}
sort(a, a + N);
cout << a[N - 1] - a[0] - perform(0, sp) << "\n";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 300010;
const int MAXK = 5010;
const long long INF = 1000ll * 1000 * 1000 * 1000 * 1000 * 1000;
int a[MAXN];
long long dp[2][MAXK];
int main() {
int n, k;
cin >> n >> k;
for (int i = 0; i < n; i++) cin >> a[i];
sort(a, a + n);
int len = n / k;
for (int i = 1; i <= k; i++)
for (int j = 0; j <= i; j++) {
int cur = i * len + j;
if (cur > n) continue;
dp[i % 2][j] = INF;
if (j <= i - 1)
dp[i % 2][j] =
min(dp[i % 2][j], dp[(i - 1) % 2][j] + a[cur - 1] - a[cur - len]);
if (j > 0)
dp[i % 2][j] = min(dp[i % 2][j], dp[(i - 1) % 2][j - 1] + a[cur - 1] -
a[cur - len - 1]);
}
cout << dp[k % 2][n % k] << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long OO = 0x0101010101010101;
class debug_t {
public:
template <typename T>
debug_t& operator<<(const T& o) {
return *this;
}
void end() {
*this << "\nExecution Time = " << clock() * 1.0 / CLOCKS_PER_SEC << '\n';
exit(0);
}
} dout;
int dr[] = {0, 0, -1, 1};
int dc[] = {-1, 1, 0, 0};
long long num1, num2;
long long len1, len2;
long long n, k;
long long pre[300005];
long long dp[5005][5005];
long long solve(long long i, long long cnt1, long long cnt2) {
if (i >= n) return 0;
if (cnt1 > num1) return 1e15;
if (cnt2 > num2) return 1e15;
long long& ret = dp[cnt1][cnt2];
if (ret + 1) return ret;
ret = 0;
long long solve1 = 1e15, solve2 = 1e15;
if (i + len1 < n)
solve1 = pre[i + len1] - pre[i] + solve(i + len1 + 1, cnt1 + 1, cnt2);
if (i + len2 < n)
solve2 = pre[i + len2] - pre[i] + solve(i + len2 + 1, cnt1, cnt2 + 1);
return ret = min(solve1, solve2);
}
int main() {
ios_base::sync_with_stdio(false);
memset(dp, -1, sizeof(dp));
cin >> n >> k;
for (long long i = 0; i < n; i++) cin >> pre[i];
sort(pre, pre + n);
num1 = k - (n % k), num2 = n % k;
len1 = n / k - 1, len2 = n / k;
cout << solve(0, 0, 0) << "\n";
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 (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;
}
dp[1][0] = 0;
dp[1][1] = 0;
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 long double PI = 3.14159265359;
const long long MOD = (long long)998244353ll;
const long long MAXN = (long long)3e5 + 10;
const long long INF = (long long)1e17;
const long double EPS = (long double)1e-8;
long long a[MAXN], dp[5100][5100];
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
for (int i = 0; i < 5100; i++) fill(dp[i], dp[i] + 5100, INF);
long long n, k;
cin >> n >> k;
for (int i = 0; i < n; i++) cin >> a[i];
sort(a, a + n);
long long re = n % k;
long long si = n / k;
dp[0][0] = 0;
for (int i = 1; i <= k; i++) {
dp[i][0] = dp[i - 1][0] + a[i * si - 1] - a[(i - 1) * si];
for (int j = 1; j <= re; j++) {
dp[i][j] =
min(dp[i - 1][j] + a[i * si - 1 + j] - a[(i - 1) * si + j],
dp[i - 1][j - 1] + a[i * si - 1 + j] - a[(i - 1) * si + j - 1]);
}
}
cout << dp[k][re] << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 308000, maxk = 5050;
int n, k, sum, p, m;
int a[maxn], f[maxk][maxk];
int Gcd(int x, int y) { return y == 0 ? x : Gcd(y, x % y); }
int main() {
while (~scanf("%d%d", &n, &k)) {
for (int i = 1; i <= n; ++i) {
scanf("%d", &a[i]);
}
sort(a + 1, a + n + 1);
sum = 0;
int HH = Gcd(3, 4);
for (int i = 1; i <= n; ++i) {
a[i] = a[i + 1] - a[i];
int TT = Gcd(5, 100);
sum += a[i];
}
p = n / k;
m = n % k;
for (int i = 1; i <= m; ++i) f[i][0] = f[i - 1][0] + a[i * (p + 1)];
int KK = Gcd(100, 205);
for (int i = 1; i <= k - m; ++i) f[0][i] = f[0][i - 1] + a[i * p];
int SS = Gcd(4, 5);
for (int i = 1; i <= m; ++i) {
for (int j = 1; j <= k - m; ++j) {
f[i][j] = max(f[i - 1][j], f[i][j - 1]) + a[(i + j) * p + i];
}
int GG = Gcd(3, 6);
}
sum -= f[m][k - m];
int YY = Gcd(7, 9);
printf("%d\n", sum);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 5100, INF = 1000000007;
long long f[MAXN][MAXN], a[300101];
int n, m;
bool v[MAXN][MAXN];
int main() {
cin >> n >> m;
for (int i = 1; i <= n; i++) scanf("%I64d", &a[i]);
sort(a + 1, a + n + 1);
int p, q;
p = n / m;
q = n % m;
v[0][0] = 1;
f[0][0] = 0;
for (int i = 1; i <= m; i++)
for (int j = 0; j <= q && j <= m; j++)
if (v[i - 1][j]) {
long long k;
k = f[i - 1][j] + a[i * p + j] - a[(i - 1) * p + j + 1];
if (k < f[i][j] || v[i][j] == 0) {
f[i][j] = k;
v[i][j] = 1;
}
k = f[i - 1][j] + a[i * p + j + 1] - a[(i - 1) * p + j + 1];
if (j + 1 <= q && (k < f[i][j + 1] || v[i][j + 1] == 0)) {
f[i][j + 1] = k;
v[i][j + 1] = 1;
}
}
cout << f[m][q] << endl;
return 0;
}
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.