text stringlengths 49 983k |
|---|
#include <bits/stdc++.h>
using namespace std;
const long long mod = 1000000007;
long long powmod(long long a, long long b) {
long long res = 1;
a %= mod;
for (; b; b >>= 1) {
if (b & 1) res = res * a % mod;
a = a * a % mod;
}
return res;
}
int n, m;
vector<string> input;
int dp[1 << 20];
int cost[20][20];
int search(int idx) {
int& ret = dp[idx];
if (ret != -1) return ret;
if (idx == 0) return 0;
int ret2 = INT_MAX;
int idx1 = idx;
int nIdx1 = 0;
for (int i = 20; i >= 0; i--) {
if (idx1 & (1 << i)) {
nIdx1 = i;
idx1 -= (1 << i);
break;
}
}
int idx2 = idx & ~(1 << nIdx1);
int ret1 = search(idx2);
for (int i = 0; i < (int)m; i++) {
idx2 = idx & ~(1 << nIdx1);
ret2 = min(ret2, cost[nIdx1][i] + ret1);
int sum = 0, maxV = 0;
for (int j = 0; j < (int)n; j++)
if (input[j][i] == input[nIdx1][i]) {
sum += cost[j][i];
idx2 &= ~(1 << j);
maxV = max(maxV, cost[j][i]);
}
ret2 = min(ret2, sum - maxV + search(idx2));
}
return ret = ret2;
}
int main() {
memset(dp, -1, sizeof(dp));
cin >> n >> m;
for (int i = 0; i < (int)n; i++) {
string s;
cin >> s;
input.push_back(s);
}
for (int i = 0; i < (int)n; i++)
for (int j = 0; j < (int)m; j++) cin >> cost[i][j];
cout << search((1 << n) - 1) << endl;
int a = 3;
}
|
#include <bits/stdc++.h>
using namespace std;
const int inf = 1e9;
char s[505][505];
int dp[1 << 21];
int a[202][202], bit[30][30], cost[40][40];
int main() {
int n, m;
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++) cin >> a[i][j];
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++) {
int ans = 0;
int maxn = -inf;
for (int k = 0; k < n; k++)
if (s[i][j] == s[k][j]) {
ans += a[k][j];
maxn = max(maxn, a[k][j]);
bit[i][j] |= 1 << k;
}
ans -= maxn;
cost[i][j] = ans;
}
for (int i = 1; i < (1 << n); i++) dp[i] = inf;
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 | bit[j][k]] = min(dp[i | bit[j][k]], dp[i] + cost[j][k]);
}
}
}
cout << dp[(1 << n) - 1] << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 25;
const int maxmask = (1 << 21) + 5;
const int inf = 1e9;
int ans[maxmask];
char p[maxn][maxn];
int curmask[30];
int sumcost[30];
int maxcost[30];
int a[maxn][maxn];
int n, m;
void upd(int &a, int b) { a = min(a, b); }
int main() {
scanf("%d%d", &n, &m);
for (int i = 0; i < n; i++) {
scanf("%s", p[i]);
}
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) scanf("%d", &a[i][j]);
}
int km = 1 << n;
for (int mask = 0; mask < km; mask++) ans[mask] = inf;
ans[0] = 0;
for (int i = 0; i < m; i++) {
for (int c = 0; c < 26; c++) {
curmask[c] = 0;
sumcost[c] = 0;
maxcost[c] = 0;
}
for (int j = 0; j < n; j++) {
curmask[p[j][i] - 'a'] |= (1 << j);
sumcost[p[j][i] - 'a'] += a[j][i];
maxcost[p[j][i] - 'a'] = max(maxcost[p[j][i] - 'a'], a[j][i]);
}
for (int mask = 0; mask < km; mask++) {
for (int c = 0; c < 26; c++)
if (curmask[c] != 0) {
upd(ans[mask | curmask[c]], ans[mask] + sumcost[c] - maxcost[c]);
}
for (int j = 0; j < n; j++) {
upd(ans[mask | (1 << j)], ans[mask] + a[j][i]);
}
}
}
cout << ans[km - 1] << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 20;
int n, m, val[MAXN][MAXN], d[1 << MAXN], mx[30][30], sm[30][30], mask[30][30];
string s[MAXN];
int main() {
cin >> n >> m;
for (int i = 0; i < n; i++) {
cin >> s[i];
for (int j = 0; j < m; j++) mask[j][s[i][j] - 'a'] |= 1 << i;
}
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++) {
cin >> val[i][j];
int &temp = mx[j][s[i][j] - 'a'];
temp = max(temp, val[i][j]);
sm[j][s[i][j] - 'a'] += val[i][j];
}
memset(d, 63, sizeof(d));
d[0] = 0;
for (int ms = 1; ms < 1 << n; ms++) {
int v = __builtin_ctz(ms & -ms);
for (int j = 0; j < m; j++) {
d[ms] = min(d[ms], d[ms ^ 1 << v] + val[v][j]);
int ch = s[v][j] - 'a';
d[ms] = min(d[ms], d[(ms ^ mask[j][ch]) & ms] + sm[j][ch] - mx[j][ch]);
}
}
cout << d[(1 << n) - 1] << "\n";
return 0;
}
|
#include <bits/stdc++.h>
const long long mod = 1000000007ll;
const double pi = acos(-1.0);
using namespace std;
long long n, m;
string str[25];
long long cost[25][25];
long long dp[1 << 21];
vector<long long> samechar[25][25];
long long solve(long long mask) {
if (mask == (1 << n) - 1) {
return 0;
}
long long &mem = dp[mask];
if (mem != -1) return mem;
long long ans = 100000000000;
long long cur = 0;
for (long long i = 0; i < n; i++) {
if (!(mask & (1 << i))) {
cur = i;
break;
}
}
long long maxcst, samecharind = 0, totalcost;
long long newmask = mask;
for (long long j = 0; j < m; j++) {
totalcost = 0;
maxcst = -1;
newmask = mask;
ans = min(ans, cost[cur][j] + solve(mask ^ (1 << cur)));
for (long long k = 0; k < samechar[cur][j].size(); k++) {
samecharind = samechar[cur][j][k];
totalcost += cost[samecharind][j];
maxcst = max(maxcst, cost[samecharind][j]);
newmask |= (1 << samecharind);
}
totalcost -= maxcst;
ans = min(ans, totalcost + solve(newmask));
}
return mem = ans;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cin >> n >> m;
for (long long i = 0; i < n; i++) cin >> str[i];
for (long long i = 0; i < n; i++) {
for (long long j = 0; j < m; j++) {
cin >> cost[i][j];
}
}
for (long long s = 0; s < n; s++) {
for (long long j = 0; j < m; j++) {
for (long long i = 0; i < n; i++) {
if (str[i][j] == str[s][j]) {
samechar[s][j].push_back(i);
}
}
}
}
memset(dp, -1, sizeof(dp));
cout << solve(0) << "\n";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int SIZE = 25;
const int MOD = 1E9 + 7;
const long double EPS = 1e-14;
const int INF = 0x3f3f3f3f;
string s[SIZE];
int custo[SIZE][SIZE];
int custoTotal[SIZE][SIZE];
int maskChar[SIZE][SIZE];
int pd[1 << 20];
int n, m;
int melhor(int mask) {
if (~pd[mask]) return pd[mask];
int first = -1;
for (int i = 0; i < n; i++) {
if (!(mask & (1 << i))) {
first = i;
break;
}
}
if (first == -1) {
return pd[mask] = 0;
}
int best = INF;
for (int i = 0; i < m; i++) {
best = min(best, custo[first][i] + melhor(mask | (1 << first)));
best = min(best, custoTotal[first][i] + melhor(mask | maskChar[first][i]));
}
return pd[mask] = best;
}
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 >> custo[i][j];
}
}
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
int maior = 0;
for (int k = 0; k < n; k++) {
if (s[i][j] == s[k][j]) {
maior = max(maior, custo[k][j]);
custoTotal[i][j] += custo[k][j];
maskChar[i][j] |= 1 << k;
}
}
custoTotal[i][j] -= maior;
}
}
memset(pd, -1, sizeof(pd));
cout << melhor(0) << endl;
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++) {
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;
const int MAX_COUNT = 21;
string words[MAX_COUNT];
int prices[MAX_COUNT][MAX_COUNT];
int toChange[MAX_COUNT][MAX_COUNT];
int bits[MAX_COUNT][MAX_COUNT];
int d[1 << MAX_COUNT];
int main() {
int rows, cols;
scanf("%d%d", &rows, &cols);
for (int i = 0; i < rows; i++) cin >> words[i];
for (int i = 0; i < rows; i++)
for (int j = 0; j < cols; j++) scanf("%d", &prices[i][j]);
for (int i = 0; i < rows; i++)
for (int j = 0; j < cols; j++) {
char cur = words[i][j];
int mxprice = prices[i][j];
for (int u = 0; u < rows; u++)
if (words[u][j] == cur) {
toChange[i][j] += prices[u][j];
bits[i][j] |= (1 << u);
mxprice = max(mxprice, prices[u][j]);
}
toChange[i][j] -= mxprice;
}
for (int i = 0; i < 1 << rows; i++) d[i + 1] = 1000000000;
for (int mask = 1; mask < (1 << rows); mask++) {
int fRow = 0;
for (int u = 0; u < rows; u++)
if (mask & (1 << u)) {
fRow = u;
break;
}
for (int j = 0; j < cols; j++) {
d[mask] =
min(d[mask], d[mask & (mask ^ bits[fRow][j])] + toChange[fRow][j]);
d[mask] = min(d[mask], d[mask ^ (1 << fRow)] + prices[fRow][j]);
}
}
cout << d[(1 << rows) - 1] << endl;
cin.get();
cin.get();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m;
char ss[120][120];
int dp[1 << 20], cv[120][120], a[120][120], co[120][120];
int main() {
scanf("%d %d", &n, &m);
for (int i = 1; i <= n; i++) {
scanf("%s", ss[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 tmp = 0;
for (int k = 1; k <= n; k++) {
if (ss[i][j] == ss[k][j]) {
co[i][j] += a[k][j];
cv[i][j] += (1 << (k - 1));
tmp = max(tmp, a[k][j]);
}
}
co[i][j] -= tmp;
}
}
for (int i = 1; i < (1 << n); i++) {
dp[i] = 100000000;
int lowbit;
for (int j = 1; j <= n; j++) {
if (((1 << (j - 1)) & i) != 0) lowbit = j;
}
for (int j = 1; j <= m; j++) {
dp[i] = min(dp[i], dp[i & (i ^ cv[lowbit][j])] + co[lowbit][j]);
dp[i] = min(dp[i], dp[i ^ (1 << (lowbit - 1))] + a[lowbit][j]);
}
}
printf("%d\n", dp[(1 << n) - 1]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 20 + 1, INF = 1e9;
char s[maxn][maxn];
int n, m, Max, nn, x, y;
int d[1 << maxn], a[maxn][maxn], b[maxn][maxn], same[maxn][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]);
}
}
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
Max = 0;
for (int k = 0; k < n; k++) {
if (s[i][j] != s[k][j]) {
continue;
}
same[i][j] |= (1 << k);
Max = max(Max, a[k][j]);
b[i][j] += a[k][j];
}
b[i][j] -= Max;
}
}
nn = 1 << n;
fill(d, d + nn, INF);
d[0] = 0;
for (int i = 0; i < nn; i++) {
for (int j = 0; j < n; j++) {
x = 1 << j;
if (x & i) {
continue;
}
for (int k = 0; k < m; k++) {
int y = same[j][k];
d[i | x] = min(d[i | x], d[i] + a[j][k]);
d[i | y] = min(d[i | y], d[i] + b[j][k]);
}
break;
}
}
printf("%d\n", d[nn - 1]);
return 0;
}
|
#include <bits/stdc++.h>
#pragma warning(disable : 4996)
using namespace std;
const int IT_MAX = 32768;
const int MOD = 1000000007;
const int INF = 1234567891;
const long long LL_INF = 1234567890123456789ll;
char in[25][25];
long long dp[1200000];
long long val[25][25];
long long same_val[25][25];
int same_bit[25][25];
int main() {
int N, M, i, j, k;
scanf("%d %d", &N, &M);
for (i = 0; i < N; i++) scanf("%s", in[i]);
for (i = 0; i < N; i++)
for (j = 0; j < M; j++) scanf("%lld", &val[i][j]);
for (i = 0; i < N; i++) {
for (j = 0; j < M; j++) {
long long sum = 0, mx = 0;
for (k = 0; k < N; k++) {
if (in[i][j] == in[k][j]) {
same_bit[i][j] += (1 << k);
sum += val[k][j];
mx = max(mx, val[k][j]);
}
}
same_val[i][j] = sum - mx;
}
}
dp[0] = 0;
for (i = 1; i < (1 << N); i++) dp[i] = LL_INF;
for (i = 1; i < (1 << N); i++) {
int t = i, lb;
for (lb = 0;; lb++, t /= 2)
if (t % 2 == 1) break;
t = i & (~(1 << lb));
for (j = 0; j < M; j++) {
dp[i] = min(dp[i], dp[t] + val[lb][j]);
}
for (j = 0; j < M; j++) {
t = i & (~same_bit[lb][j]);
dp[i] = min(dp[i], dp[t] + same_val[lb][j]);
}
}
printf("%lld", dp[(1 << N) - 1]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int INF = 100000000;
int main() {
int n, m;
cin >> n >> m;
vector<string> s(n);
vector<int> tmp(m);
vector<vector<int> > a(n, tmp);
vector<vector<int> > similar(n, tmp), cost(n, tmp);
vector<int> dp(1 << n, INF);
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 i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
int opt = 0;
for (int g = 0; g < n; g++) {
if (s[i][j] == s[g][j]) {
similar[i][j] |= (1 << g);
cost[i][j] += a[g][j];
opt = max(opt, a[g][j]);
}
}
cost[i][j] -= opt;
}
}
int pow = 1 << n;
dp[0] = 0;
for (int i = 1; i < pow; i++) {
int hb;
for (int j = 0; j < n; j++) {
if ((i & (1 << j)) != 0) {
hb = j;
break;
}
}
for (int j = 0; j < m; j++) {
dp[i] = min(dp[i], dp[i & (i ^ similar[hb][j])] + cost[hb][j]);
dp[i] = min(dp[i], dp[i ^ (1 << hb)] + a[hb][j]);
}
}
cout << dp[pow - 1];
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int a[21][21], f[1 << 21];
string s[21];
int n, m;
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];
for (int i = 0; i < 1 << n; i++) f[i] = 1e9;
f[0] = 0;
for (int i = 0; i < (1 << n) - 1; i++) {
if (f[i] == 1e9) continue;
int p;
for (p = 0; p < n; p++)
if (!(i & (1 << p))) break;
int cur = i | (1 << p);
int sum, maxx, np;
for (int j = 0; j < m; j++) {
f[cur] = min(f[cur], f[i] + a[p][j]);
sum = maxx = 0;
np = cur;
for (int k = 0; k < n; k++)
if (s[k][j] == s[p][j]) {
np |= 1 << k;
maxx = max(maxx, a[k][j]);
sum += a[k][j];
}
f[np] = min(f[np], f[i] + sum - maxx);
}
}
cout << f[(1 << n) - 1] << endl;
return 0;
return 0;
}
|
#include <bits/stdc++.h>
#pragma GCC optimize("Ofast,inline")
#pragma GCC target( \
"sse,sse2,sse3,ssse3,sse4,sse4.1,sse4.2,popcnt,abm,mmx,avx,avx2,tune=native")
#pragma GCC optimize(1)
#pragma G++ optimize(1)
#pragma GCC optimize(2)
#pragma G++ optimize(2)
#pragma GCC optimize(3)
#pragma G++ optimize(3)
#pragma GCC optimize("-funsafe-loop-optimizations")
#pragma GCC optimize("-funroll-loops")
#pragma GCC optimize("-fwhole-program")
#pragma GCC optimize("-fthread-jumps")
#pragma GCC optimize("-falign-functions")
#pragma GCC optimize("-falign-jumps")
#pragma GCC optimize("-falign-loops")
#pragma GCC optimize("-falign-labels")
#pragma GCC optimize("-fcaller-saves")
#pragma GCC optimize("-fcrossjumping")
#pragma GCC optimize("-fcse-follow-jumps")
#pragma GCC optimize("-fcse-skip-blocks")
#pragma GCC optimize("-fdelete-null-pointer-checks")
#pragma GCC optimize("-fexpensive-optimizations")
#pragma GCC optimize("-fgcse")
#pragma GCC optimize("-fgcse-lm")
#pragma GCC optimize("-finline-small-functions")
#pragma GCC optimize("-findirect-inlining")
#pragma GCC optimize("-foptimize-sibling-calls")
#pragma GCC optimize("-fpeephole2")
#pragma GCC optimize("-freorder-blocks")
#pragma GCC optimize("-freorder-functions")
#pragma GCC optimize("-frerun-cse-after-loop")
#pragma GCC optimize("-fsched-interblock")
#pragma GCC optimize("-fsched-spec")
#pragma GCC optimize("-fschedule-insns")
#pragma GCC optimize("-fschedule-insns2")
#pragma GCC optimize("-fstrict-aliasing")
#pragma GCC optimize("-fstrict-overflow")
#pragma GCC optimize("-ftree-switch-conversion")
#pragma GCC optimize("-ftree-pre")
#pragma GCC optimize("-ftree-vrp")
using namespace std;
inline void rdl(long long &val) {
long long x = 0;
int f = 1;
char ch = getchar();
while ((ch < '0' or ch > '9') and ch != '-') ch = getchar();
if (ch == '-') {
f = -1;
ch = getchar();
}
while (ch >= '0' and ch <= '9') {
x = (x << 3) + (x << 1) + ch - '0';
ch = getchar();
}
val = x * f;
}
inline void rdi(int &val) {
int x = 0;
int f = 1;
char ch = getchar();
while ((ch < '0' or ch > '9') and ch != '-') ch = getchar();
if (ch == '-') {
f = -1;
ch = getchar();
}
while (ch >= '0' and ch <= '9') {
x = (x << 3) + (x << 1) + ch - '0';
ch = getchar();
}
val = x * f;
}
inline long long rdl() {
long long x = 0;
int f = 1;
char ch = getchar();
while ((ch < '0' or ch > '9') and ch != '-') ch = getchar();
if (ch == '-') {
f = -1;
ch = getchar();
}
while (ch >= '0' and ch <= '9') {
x = (x << 3) + (x << 1) + ch - '0';
ch = getchar();
}
return x * f;
}
inline int rdi() {
int x = 0;
int f = 1;
char ch = getchar();
while ((ch < '0' or ch > '9') and ch != '-') ch = getchar();
if (ch == '-') {
f = -1;
ch = getchar();
}
while (ch >= '0' and ch <= '9') {
x = (x << 3) + (x << 1) + ch - '0';
ch = getchar();
}
return x * f;
}
inline void write(int x) {
if (x < 0) putchar('-'), x = -x;
if (x > 9) write(x / 10);
putchar(x % 10 + '0');
}
inline void _write(int x) {
write(x);
putchar(' ');
}
inline void print(int x) {
write(x);
putchar('\n');
}
inline void write(long long x) {
if (x < 0) putchar('-'), x = -x;
if (x > 9) write(x / 10);
putchar(x % 10 + '0');
}
inline void _write(long long x) {
write(x);
putchar(' ');
}
inline void print(long long x) {
write(x);
putchar('\n');
}
const int mxn = 21;
int a[mxn][mxn], N, M, dp[1 << mxn], l, n, m, t, h, b, c;
char s[mxn][10 * mxn];
int main() {
int i, j;
scanf("%d%d", &N, &M);
for (i = 0; i < N; ++i) scanf("%s", s[i]);
for (i = 0; i < N; ++i)
for (j = 0; j < M; ++j) scanf("%d", &a[i][j]);
memset(dp, 63, sizeof(dp));
dp[0] = 0;
for (m = 0; m < (1 << N); ++m) {
for (b = 0; b < N; ++b)
if (!(m & (1 << b))) {
l = b;
break;
}
for (c = 0; c < M; ++c) {
dp[m + (1 << l)] = min(dp[m + (1 << l)], dp[m] + a[l][c]);
n = m, t = 0, h = 0;
for (i = 0; i < N; ++i)
if (s[i][c] == s[l][c])
n |= (1 << i), t += a[i][c], h = max(h, a[i][c]);
dp[n] = min(dp[n], dp[m] + t - h);
}
}
printf("%d\n", dp[(1 << N) - 1]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 25;
int f[1 << 20], a[maxn][maxn], S[maxn][maxn], cost[maxn][maxn];
int n, m, low;
char s[maxn][maxn];
void init() {
int sum, best, Set;
for (int i = 1; i <= n; i++)
for (int j = 1; j <= m; j++) {
sum = best = Set = 0;
for (int k = 1; k <= n; k++)
if (s[i][j] == s[k][j]) {
sum += a[k][j];
best = max(best, a[k][j]);
Set |= 1 << (k - 1);
}
S[i][j] = Set;
cost[i][j] = sum - best;
}
}
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]);
init();
memset(f, 0x3f, sizeof f);
f[0] = 0;
for (int i = 0; i < (1 << n) - 1; i++) {
for (low = 0; i >> low & 1; low++)
;
for (int j = 1; j <= m; j++) {
f[i | (1 << low)] = min(f[i | (1 << low)], f[i] + a[low + 1][j]);
f[i | S[low + 1][j]] = min(f[i | S[low + 1][j]], f[i] + cost[low + 1][j]);
}
}
printf("%d\n", f[(1 << n) - 1]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
using namespace std;
const int N = 20;
const int len = 300;
string s[N];
int c[N][len], sv[N][len], a[N][len];
int d[1 << N];
int main() {
int n, m;
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];
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++) {
int curv = 0;
for (int k = 0; k < n; k++)
if (s[i][j] == s[k][j]) {
sv[i][j] |= (1 << k);
c[i][j] += a[k][j];
if (a[k][j] > curv) curv = a[k][j];
}
c[i][j] -= curv;
}
for (int i = 0; i < 1 << n; i++) d[i] = 1000000000;
d[0] = 0;
for (int mask = 0; mask < 1 << n; mask++) {
if (mask == 0) continue;
int lowbit = -1;
for (int i = 0; i < n; i++)
if ((mask >> i) & 1) {
lowbit = i;
break;
}
for (int k = 0; k < m; k++) {
d[mask] = min(d[mask], d[mask & (mask ^ sv[lowbit][k])] + c[lowbit][k]);
d[mask] = min(d[mask], d[mask ^ (1 << lowbit)] + a[lowbit][k]);
}
}
cout << d[(1 << n) - 1];
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAX_COUNT = 21;
string words[MAX_COUNT];
int prices[MAX_COUNT][MAX_COUNT];
int toChange[MAX_COUNT][MAX_COUNT];
int bits[MAX_COUNT][MAX_COUNT];
int d[1 << MAX_COUNT];
int main() {
int rows, cols;
scanf("%d%d", &rows, &cols);
for (int i = 0; i < rows; i++) cin >> words[i];
for (int i = 0; i < rows; i++)
for (int j = 0; j < cols; j++) scanf("%d", &prices[i][j]);
for (int i = 0; i < rows; i++)
for (int j = 0; j < cols; j++) {
char cur = words[i][j];
int mxprice = prices[i][j];
for (int u = 0; u < rows; u++)
if (words[u][j] == cur) {
toChange[i][j] += prices[u][j];
bits[i][j] |= (1 << u);
mxprice = max(mxprice, prices[u][j]);
}
toChange[i][j] -= mxprice;
}
for (int i = 0; i < 1 << rows; i++) d[i + 1] = 1000000000;
for (int mask = 1; mask < (1 << rows); mask++) {
int fRow = 0;
for (int u = 0; u < rows; u++)
if (mask & (1 << u)) {
fRow = u;
break;
}
for (int j = 0; j < cols; j++) {
d[mask] =
min(d[mask], d[mask & (mask ^ bits[fRow][j])] + toChange[fRow][j]);
d[mask] = min(d[mask], d[mask & (mask ^ (1 << fRow))] + prices[fRow][j]);
}
}
cout << d[(1 << rows) - 1] << endl;
cin.get();
cin.get();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 21;
int cost[N][N];
set<int, greater<int>> st;
int dp[1 << 20];
bool used[N];
string ar[N];
pair<vector<int>, int> prec[N][256];
int main() {
int n, m;
cin >> n >> m;
for (int i = 0; i < n; ++i) cin >> ar[i];
for (int i = 0; i < n; ++i) {
for (int j = 0; j < m; ++j) cin >> cost[i][j];
}
for (int i = 0; i < m; ++i) {
for (int j = 0; j < n; ++j) {
prec[i][ar[j][i]].first.push_back(j);
prec[i][ar[j][i]].second = max(prec[i][ar[j][i]].second, cost[j][i]);
}
}
for (int i = 0; i < 1 << n; ++i) dp[i] = 1e9;
dp[(1 << n) - 1] = 0;
st.insert((1 << n) - 1);
while (true) {
int cur = *(st.begin());
if (!cur) break;
st.erase(st.begin());
memset(used, false, N);
int higher = 0, pw = 1 << n - 1, ind = n - 1, t = cur;
while (t) {
if (pw <= t) {
t -= pw;
higher = max(higher, ind);
used[ind] = true;
}
pw >>= 1;
--ind;
}
int was = cur;
cur -= 1 << higher;
st.insert(cur);
for (int i = 0; i < m; ++i) {
dp[cur] = min(dp[cur], cost[higher][i] + dp[was]);
int sum = 0, tmp = was;
for (auto &x : prec[i][ar[higher][i]].first) {
if (used[x]) tmp -= 1 << x;
sum += cost[x][i];
}
sum -= prec[i][ar[higher][i]].second;
dp[tmp] = min(dp[tmp], dp[was] + sum);
st.insert(tmp);
}
}
cout << dp[0];
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = (1 << 21) + 10;
const int maxn = 20;
long long dp[N];
int c[110][110];
char s[110][110];
int lowzero(int s) {
int i;
for (i = 0; i <= 20; i++) {
if ((1 << i) > s) break;
if (((1 << i) & s) == 0) return i;
}
return i;
}
int main() {
int n, m;
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", &c[i][j]);
int size = (1 << n) - 1;
for (int i = size; i > 0; i--) dp[i] = 1e8;
dp[0] = 0;
for (int j = 0; j <= size; j++) {
int k = lowzero(j);
for (int i = 0; i < m; i++) {
dp[j | (1 << k)] = min(dp[j | (1 << k)], dp[j] + c[k][i]);
int hehe = 0, mx = 0, co = 0;
for (int p = 0; p < n; p++)
if (s[p][i] == s[k][i]) {
hehe |= (1 << p);
mx = max(mx, c[p][i]);
co += c[p][i];
}
co -= mx;
dp[j | hehe] = min(dp[j | hehe], dp[j] + co);
}
}
long long ans = dp[size];
printf("%I64d\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
inline int read() {
int x = 0;
char ch = getchar();
while (ch < '0' || ch > '9') ch = getchar();
while (ch >= '0' && ch <= '9') x = x * 10 + ch - '0', ch = getchar();
return x;
}
int n, m, mx[55][55], tot[55][55], s[55][55], a[25][25], f[1 << 20];
char st[25][25];
inline void R(int& x, int y) { y < x ? x = y : 0; }
int main() {
n = read();
m = read();
memset(f, 40, sizeof(f));
for (int i = 1; i <= n; ++i) scanf("%s", st[i] + 1);
for (int i = 1; i <= n; ++i)
for (int j = 1; j <= m; ++j) a[i][j] = read();
for (int i = 1; i <= m; ++i) {
for (int j = 1; j <= n; ++j)
s[i][st[j][i] - 'a'] |= 1 << j - 1,
mx[i][st[j][i] - 'a'] = max(mx[i][st[j][i] - 'a'], a[j][i]),
tot[i][st[j][i] - 'a'] += a[j][i];
}
f[0] = 0;
for (int i = 0; i < (1 << n) - 1; ++i) {
int j = 1;
for (; i & (1 << j - 1); ++j)
;
for (int k = 1; k <= m; ++k)
R(f[i | s[k][st[j][k] - 'a']],
f[i] + tot[k][st[j][k] - 'a'] - mx[k][st[j][k] - 'a']),
R(f[i | (1 << j - 1)], f[i] + a[j][k]);
}
printf("%d\n", f[(1 << n) - 1]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
char s[21][21] = {0};
int c2[21][21] = {0};
int c1[21][21] = {0};
int lul[21][21] = {0};
int dp[(1 << 20)] = {0};
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int n, m;
cin >> n >> m;
for (int i = 0; i < (1 << n); i++) {
dp[i] = INT_MAX;
}
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
cin >> s[i][j];
}
}
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++) {
int mxcur = 0;
c2[i][j] = 0;
for (int k = 0; k < n; k++) {
if (s[i][j] != s[k][j]) continue;
lul[i][j] |= (1 << k);
mxcur = max(mxcur, c1[k][j]);
c2[i][j] += c1[k][j];
}
c2[i][j] -= mxcur;
}
}
dp[0] = 0;
for (int msk = 1; msk < (1 << n); msk++) {
int cand;
for (int i = 0; i < n; i++)
if (msk & (1 << i)) {
cand = i;
break;
}
for (int j = 0; j < m; j++) {
dp[msk] = min(dp[msk], dp[msk & (msk ^ lul[cand][j])] + c2[cand][j]);
dp[msk] = min(dp[msk], dp[msk & (msk ^ (1 << cand))] + c1[cand][j]);
}
}
cout << dp[(1 << n) - 1] << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m, a[100][100], f[2000000], p;
char s[30][30];
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(f, 0x3f, sizeof(f));
f[0] = 0;
for (int i = 0; i <= (1 << n) - 2; i++) {
for (int j = 0; j < n; j++)
if (!(i & (1 << j))) {
p = j;
break;
}
for (int j = 0; j < m; j++) {
int sum = 0, l = 0, mx = 0;
f[i | (1 << p)] = min(f[i | (1 << p)], f[i] + a[p][j]);
for (int k = 0; k < n; k++)
if (s[k][j] == s[p][j]) {
sum = sum + a[k][j];
mx = max(mx, a[k][j]);
l = l | (1 << k);
}
f[i | l] = min(f[i | l], f[i] + sum - mx);
}
}
return printf("%d", f[(1 << n) - 1]), 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m, dp[1 << 20], a[20][20], c[20][26], v[20][26], mx[20][26], mn[20];
char s[20][26];
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++) {
mn[i] = 1e9;
for (int j = 0; j < m; j++) {
scanf("%d", a[i] + j);
mn[i] = min(mn[i], a[i][j]);
int x = s[i][j] - 'a';
mx[j][x] = max(mx[j][x], a[i][j]);
v[j][x] ^= (1 << i);
c[j][x] += a[i][j];
}
}
for (int i = 0; i < m; i++)
for (int j = 0; j < 26; j++) c[i][j] -= mx[i][j];
dp[0] = 0;
int k = (1 << n);
for (int i = 1; i < k; i++) {
int x = __builtin_ctz(i);
dp[i] = dp[i ^ (1 << x)] + mn[x];
for (int j = 0; j < m; j++) {
int y = s[x][j] - 'a';
dp[i] = min(dp[i], dp[(i | v[j][y]) ^ v[j][y]] + c[j][y]);
}
}
printf("%d\n", dp[k - 1]);
}
|
#include <bits/stdc++.h>
using namespace std;
const int INF = 0x3f3f3f3f;
int n, m, val[25][25], dp[1 << 21];
char mp[25][25];
int main() {
memset(dp, INF, sizeof(dp));
scanf("%d %d", &n, &m);
for (int i = 1; i <= n; i++) {
scanf("%s", mp[i] + 1);
}
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
scanf("%d", &val[i][j]);
}
}
dp[0] = 0;
for (int i = 0; i < (1 << n); i++) {
for (int j = 1; j <= n; j++) {
if (!(i & (1 << (j - 1)))) {
for (int k = 1; k <= m; k++) {
dp[i | (1 << (j - 1))] =
min(dp[i | (1 << (j - 1))], dp[i] + val[j][k]);
int sum = 0, maxv = 0, cnt = 0;
for (int r = 1; r <= n; r++) {
if (mp[r][k] == mp[j][k]) {
sum += val[r][k];
cnt = cnt | (1 << (r - 1));
maxv = max(maxv, val[r][k]);
}
}
dp[cnt | i] = min(dp[cnt | i], dp[i] + sum - maxv);
}
break;
}
}
}
printf("%d\n", dp[(1 << n) - 1]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 20;
int n, m, cost[N][N], c[N][N], dp[1 << N], b[N][N];
char a[N][N];
int main() {
ios_base::sync_with_stdio(0);
cin >> n >> m;
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) cin >> cost[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 (a[i][j] == a[k][j]) {
b[i][j] |= (1 << k);
c[i][j] += cost[k][j];
mx = max(mx, cost[k][j]);
}
c[i][j] -= mx;
}
for (int mask = 0; mask < (1 << n); ++mask) dp[mask] = (int)1e9;
dp[0] = 0;
for (int mask = 0; mask < (1 << n); ++mask) {
int bit = 0;
for (int i = 0; i < n; ++i)
if ((1 << i) & mask)
;
else {
bit = i;
break;
}
for (int i = 0; i < m; ++i) {
dp[mask | (1 << bit)] =
min(dp[mask | (1 << bit)], dp[mask] + cost[bit][i]);
dp[mask | b[bit][i]] = min(dp[mask | b[bit][i]], dp[mask] + c[bit][i]);
}
}
cout << dp[(1 << n) - 1];
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 22;
string s[N];
int a[N][N], n, m;
pair<int, int> jump[N][N];
inline void minimize(int &a, int b) { a = min(a, b); }
int main() {
scanf("%d%d\n", &n, &m);
for (int i = 0; i < n; i++) {
getline(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 p = 0; p < m; p++) {
int total = 0, maxCost = 0, mask = 0;
for (int j = 0; j < n; j++)
if (s[i][p] == s[j][p]) {
mask |= 1 << j;
total += a[j][p];
maxCost = max(maxCost, a[j][p]);
}
jump[i][p] = make_pair(mask, total - maxCost);
}
vector<int> dp(1 << n, 1e9);
dp[0] = 0;
for (int mask = 0; mask + 1 < 1 << n; mask++) {
int i;
for (i = 0; mask & (1 << i); i++)
;
for (int p = 0; p < m; p++) {
dp[mask | (1 << i)] = min(dp[mask | (1 << i)], dp[mask] + a[i][p]);
dp[mask | jump[i][p].first] =
min(dp[mask | jump[i][p].first], dp[mask] + jump[i][p].second);
}
}
printf("%d", dp.back());
}
|
#include <bits/stdc++.h>
using namespace std;
const int inf = 1e9 + 7;
const int N = 20;
const int E = 1 << 20;
int n, m, a[N][N], c[N][N], maxst;
int t[E], an, lb[E], f[E];
vector<int> to[N];
int main() {
scanf("%d%d", &n, &m);
for (int i = 0; i < n; ++i)
for (int j = 0; j < m; ++j) {
char c;
c = getchar();
while (c < 'a' || c > 'z') c = getchar();
a[i][j] = c - 'a';
}
for (int i = 0; i < n; ++i)
for (int j = 0; j < m; ++j) scanf("%d", &c[i][j]);
maxst = 1 << n;
for (int i = 0; i < maxst; ++i) t[i] = inf;
for (int i = 0; i < m; ++i) {
for (int j = 0; j < 26; ++j) {
int sum = 0, mx = 0, st = 0;
for (int k = 0; k < n; ++k)
if (a[k][i] == j) {
sum += c[k][i];
mx = max(mx, c[k][i]);
st |= 1 << k;
}
sum -= mx;
t[st] = min(t[st], sum);
}
}
for (int i = 0; i < n; ++i) {
int st = 1 << i;
for (int j = 0; j < m; ++j) t[st] = min(t[st], c[i][j]);
}
an = 0;
for (int i = 0; i < maxst; ++i)
if (t[i] != inf)
for (int j = 0; j < n; ++j)
if ((i >> j) & 1) to[j].push_back(i);
for (int i = 0; i < maxst; ++i)
for (int j = 0; j < n; ++j)
if (((i >> j) & 1) == 0) {
lb[i] = j;
break;
}
for (int i = 1; i < maxst; ++i) f[i] = inf;
f[0] = 0;
for (int i = 0, ub = maxst - 1; i < ub; ++i)
for (int j = 0, ub1 = to[lb[i]].size(); j < ub1; ++j) {
int st = to[lb[i]][j];
f[i | st] = min(f[i | st], f[i] + t[st]);
}
printf("%d\n", f[maxst - 1]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MaxN = (int)22;
string s[MaxN];
int cost[MaxN][MaxN];
int f[1 << MaxN];
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int n, m;
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];
}
}
memset(f, 0x3f, sizeof(f));
f[0] = 0;
int Lim = 1 << n;
for (int i = 0; i < Lim; i++) {
int bit = -1;
for (int j = 0; j < MaxN && bit == -1; j++)
if (!((i >> j) & 1)) {
bit = j;
}
if (bit == -1) bit = i - 1;
for (int c = 0; c < m; c++) {
f[i | (1 << bit)] = min(f[i | (1 << bit)], f[i] + cost[bit][c]);
int sum = 0, mw = 0, bits = 0;
for (int r = 0; r < n; r++)
if (s[bit][c] == s[r][c]) {
sum += cost[r][c];
mw = max(mw, cost[r][c]);
bits |= 1 << r;
}
f[i | bits] = min(f[i | bits], f[i] + sum - mw);
}
}
cout << f[Lim - 1] << "\n";
}
|
#include <bits/stdc++.h>
using namespace std;
const int P = 1e9 + 7;
inline int add(int a, int b) {
if ((a += b) >= P) a -= P;
return a;
}
inline int sub(int a, int b) {
if ((a -= b) < 0) a += P;
return a;
}
inline int mul(int a, int b) { return 1ll * a * b % P; }
inline int kpow(int a, int b) {
int r = 1;
for (; b; b >>= 1, a = mul(a, a)) {
if (b & 1) r = mul(r, a);
}
return r;
}
const int N = 21, M = 1 << N;
int n, m;
char s[N][N];
int LOG[M];
int same[N][N], cost[N][M];
int f[M];
int val[N][N];
int main() {
for (int i = (2); i < (M); i++) LOG[i] = LOG[i >> 1] + 1;
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", val[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 (s[i][j] == s[k][j]) {
same[i][j] |= 1 << k;
cost[i][j] += val[k][j];
mx = max(mx, val[k][j]);
}
cost[i][j] -= mx;
}
for (int i = (0); i < (M); i++) f[i] = 1e9;
f[0] = 0;
int up = 1 << n;
for (int msk = (1); msk < (up); msk++) {
int lb = LOG[msk & -msk];
for (int i = (0); i < (m); i++) {
f[msk] = min(f[msk], f[msk & (msk ^ same[lb][i])] + cost[lb][i]);
f[msk] = min(f[msk], f[msk ^ (1 << lb)] + val[lb][i]);
}
}
printf("%d\n", f[up - 1]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int two[25], a[24][24], sam[24][24], w[24][24], w2[24][24], f[1 << 20];
int main() {
char ch;
int i, j, k, s, n, m, ax;
scanf("%d %d\n", &n, &m);
two[0] = 1;
for (i = 1; i <= 20; ++i) two[i] = two[i - 1] << 1;
for (i = 1; i <= n; ++i) {
for (j = 1; j <= m; ++j) {
scanf("%c", &ch);
a[i][j] = ch - 'a' + 1;
}
scanf("\n");
}
for (i = 1; i <= n; ++i)
for (j = 1; j <= m; ++j) scanf("%d", &w[i][j]);
for (i = 1; i <= n; ++i)
for (j = 1; j <= m; ++j) {
ax = w[i][j];
for (k = 1; k <= n; ++k) {
if (a[i][j] == a[k][j]) {
sam[i][j] |= two[k - 1];
w2[i][j] += w[k][j];
ax = max(ax, w[k][j]);
}
}
w2[i][j] -= ax;
}
memset(f, 0x3f, sizeof(f));
f[0] = 0;
for (s = 0; s < two[n]; ++s)
for (i = 1; i <= n; ++i)
if (!(s & two[i - 1]))
for (j = 1; j <= m; ++j) {
f[s | two[i - 1]] = min(f[s | two[i - 1]], f[s] + w[i][j]);
f[s | sam[i][j]] = min(f[s | sam[i][j]], f[s] + w2[i][j]);
}
printf("%d\n", f[two[n] - 1]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int inf = 1000000000;
int d[1100010], v[25][25], sum[25][25], poz[25][25];
char sir[25][25];
int main() {
int n, m;
scanf("%d%d", &n, &m);
for (int i = 1; i <= n; i++) scanf("\n%s", sir[i] + 1);
for (int i = 1; i <= n; i++)
for (int j = 1; j <= m; j++) scanf("%d", &v[i][j]);
for (int i = 1; i <= n; i++)
for (int j = 1; j <= m; j++) {
poz[i][j] = 1 << (i - 1);
for (int q = 1; q <= n; q++)
if (sir[q][j] == sir[i][j] && q != i) {
sum[i][j] += v[q][j];
poz[i][j] += 1 << (q - 1);
}
}
int lim = 1 << n;
for (int i = 1; i < lim; i++) {
d[i] = inf;
for (int j = 0; j < n; j++)
if (i & (1 << j))
for (int q = 1; q <= m; q++) {
d[i] = min(d[i], v[j + 1][q] + d[i ^ (1 << j)]);
d[i] = min(d[i], sum[j + 1][q] + d[i ^ (i & poz[j + 1][q])]);
}
}
printf("%d", d[lim - 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 (0 == ((i >> j) & 1)) {
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;
const int Nmax = 22;
int n, m, i, j, lowbit, cost_total, most_expensive, mask;
int cost[Nmax][Nmax], minim[Nmax];
int D[1 << Nmax];
char A[Nmax][Nmax];
int main() {
scanf("%d %d\n", &n, &m);
for (i = 1; i <= n; ++i) gets(A[i] + 1);
memset(minim, 0x3f3f3f3f, sizeof(minim));
for (i = 1; i <= n; ++i)
for (j = 1; j <= m; ++j) {
scanf("%d", &cost[i][j]);
minim[i] = min(minim[i], cost[i][j]);
}
memset(D, 0x3f3f3f3f, sizeof(D));
for (D[0] = 0, i = 1; i < (1 << n); ++i) {
for (lowbit = 0; lowbit < n && ((i >> lowbit & 1) == 0); ++lowbit)
;
for (int col = 1; col <= m; ++col) {
most_expensive = 0;
cost_total = 0;
mask = 0;
for (j = 1; j <= n; ++j)
if (A[lowbit + 1][col] == A[j][col]) {
mask ^= (1 << (j - 1));
cost_total += cost[j][col];
most_expensive = max(most_expensive, cost[j][col]);
}
D[i] = min(D[i], D[i & (i ^ mask)] + cost_total - most_expensive);
D[i] = min(D[i], D[i ^ (1 << lowbit)] + minim[lowbit + 1]);
}
}
printf("%d\n", D[(1 << n) - 1]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m, a[20][20];
int sch[20][26] = {0}, mch[20][26] = {0}, ich[20][26] = {0};
int dp[(1 << 20)];
string strs[20];
int main() {
ios::sync_with_stdio(false);
cin >> n >> m;
for (int i = 0; i < n; i++) cin >> strs[i];
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++) {
cin >> a[i][j];
int ch = strs[i][j] - 'a';
sch[j][ch] += a[i][j];
mch[j][ch] = max(mch[j][ch], a[i][j]);
ich[j][ch] |= (1 << i);
}
fill(dp, dp + (1 << 20), 100000000);
dp[0] = 0;
for (int s = 0; s < (1 << n) - 1; s++) {
if (dp[s] == 100000000) continue;
int inds = 0;
for (; inds < n; inds++)
if (~s >> inds & 1) break;
for (int j = 0; j < m; j++) {
int ch = strs[inds][j] - 'a';
dp[s | 1 << inds] = min(dp[s | 1 << inds], dp[s] + a[inds][j]);
dp[s | ich[j][ch]] =
min(dp[s | ich[j][ch]], dp[s] + sch[j][ch] - mch[j][ch]);
}
}
printf("%d\n", dp[(1 << n) - 1]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 21;
int n, m, ii, h, i, j, jj, mk, tot, mx;
int addMask[MAXN][MAXN], cost[MAXN][MAXN], addCost[MAXN][MAXN];
int dp[(1 << (MAXN + 1))];
char s[MAXN][MAXN];
int main() {
scanf("%d %d", &n, &m);
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", &cost[i][j]);
}
}
for (i = 1; i <= n; i++) {
for (j = 1; j <= m; j++) {
mk = tot = mx = 0;
for (ii = 1; ii <= n; ii++) {
if (s[i][j] == s[ii][j]) {
mk |= (1 << (ii - 1));
tot += cost[ii][j];
mx = max(mx, cost[ii][j]);
}
}
addMask[i][j] = mk;
addCost[i][j] = tot - mx;
}
}
h = (1 << n) - 1;
for (i = 0; i <= h; i++) {
dp[i] = (int)1e9;
}
dp[0] = 0;
for (i = 0; i < h; i++) {
for (j = 1; (i & (1 << (j - 1))); j++)
;
for (jj = 1; jj <= m; jj++) {
dp[i ^ (1 << (j - 1))] = min(dp[i ^ (1 << (j - 1))], dp[i] + cost[j][jj]);
dp[i | addMask[j][jj]] =
min(dp[i | addMask[j][jj]], dp[i] + addCost[j][jj]);
}
}
printf("%d\n", dp[h]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
char s[20][20];
int c[20][20];
int dp[1 << 20];
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", &c[i][j]);
}
memset(dp, 0x3f, sizeof dp);
dp[0] = 0;
for (int i = 0; i + 1 < 1 << n; i++) {
if (dp[i] == 0x3f3f3f3f) continue;
int r;
for (r = 0; r < n; r++) {
if (!(((i) >> (r)) & 1)) break;
}
int id = i | (1 << r);
for (int j = 0; j < m; j++) {
dp[id] = min(dp[id], dp[i] + c[r][j]);
int jd = i, v = 0, mx = 0;
for (int k = 0; k < n; k++) {
if (s[k][j] == s[r][j]) {
v += c[k][j];
jd |= (1 << k);
mx = max(mx, c[k][j]);
}
}
dp[jd] = min(dp[jd], dp[i] + v - mx);
}
}
printf("%d\n", dp[(1 << n) - 1]);
}
|
#include <bits/stdc++.h>
using namespace std;
int dp[1500000], n, m, value[25][25];
char str[25][25];
int solve(int now) {
if (dp[now] != -1) return dp[now];
int last_bit = __builtin_ctz(now);
int i, j;
dp[now] = 1000000000;
for (i = 0; i < m; i++)
dp[now] = min(dp[now], solve(now ^ (1 << last_bit)) + value[last_bit][i]);
for (i = 0; i < m; i++) {
int temp = value[last_bit][i], tt = 0, sum = 0;
for (j = 0; j < n; j++) {
if (str[last_bit][i] != str[j][i]) continue;
temp = max(temp, value[j][i]);
tt |= (1 << j);
sum += value[j][i];
}
sum -= temp;
temp = 0;
for (j = 0; j < n; j++)
if (((1 << j) & now) && !((1 << j) & tt)) temp |= (1 << j);
dp[now] = min(dp[now], solve(temp) + sum);
}
return dp[now];
}
int main() {
int i, j;
scanf("%d", &n);
scanf("%d", &m);
getchar();
for (i = 0; i < n; i++) gets(str[i]);
for (i = 0; i < n; i++)
for (j = 0; j < m; j++) scanf("%d", &value[i][j]);
for (i = 0; i < 1500000; i++) dp[i] = -1;
dp[0] = 0;
cout << solve((1 << n) - 1) << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MX = (1 << 21);
int n, m, a[20][20], mk, dp[MX], p[MX];
int sum[256][20], mask[256][20];
string s[20];
void precal() {
for (int i = 0; i < mk; i++)
for (int j = 0; j < n; j++)
if (!(i & (1 << j))) {
p[i] = j;
break;
}
for (int i = 'a'; i <= 'z'; i++) {
for (int j = 0; j < m; j++) {
int mx = 0;
for (int k = 0; k < n; k++) {
if (s[k][j] == char(i)) {
sum[i][j] += a[k][j];
mx = max(mx, a[k][j]);
mask[i][j] |= (1 << k);
}
}
sum[i][j] -= mx;
}
}
}
int obtRes(int k) {
int &res = dp[k], i = p[k];
if (res != -1) return res;
res = 1e9;
for (int j = 0; j < m; j++)
res = min({res, obtRes(k | (1 << i)) + a[i][j],
obtRes(k | mask[s[i][j]][j]) + sum[s[i][j]][j]});
return res;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cin >> n >> m;
mk = (1 << n) - 1;
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 i = 0; i < mk; i++) dp[i] = -1;
dp[mk] = 0;
precal();
cout << obtRes(0) << '\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]);
assert(v[i][j] <= 1000000);
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>
const int MOD = 9973;
const int INF = 99999999;
using namespace std;
int n, m;
char s[25][25];
int a[25][25];
int cost[25][25];
int bit[25][25];
int dp[1 << 20];
int main() {
while (~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(bit, 0, sizeof(bit));
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
int sum = 0;
int max_cost = -1;
for (int k = 0; k < n; k++) {
if (s[i][j] == s[k][j]) {
sum += a[k][j];
max_cost = max(max_cost, a[k][j]);
bit[i][j] |= (1 << k);
}
}
sum -= max_cost;
cost[i][j] = sum;
}
}
for (int i = 0; i < (1 << n); i++) dp[i] = INF;
dp[0] = 0;
for (int k = 0; k < m; k++) {
for (int i = 0; i < (1 << n); i++) {
for (int j = 0; j < n; j++) {
if (i & (1 << j)) continue;
dp[i | (1 << j)] = min(dp[i | (1 << j)], dp[i] + a[j][k]);
dp[i | bit[j][k]] = min(dp[i | bit[j][k]], dp[i] + cost[j][k]);
}
}
}
printf("%d\n", dp[(1 << n) - 1]);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
char s[25][25];
int a[25][25], n, m, sum[25][25], val[25][25];
int dp[1 << 21];
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++) {
int sm = 0, tmp = -INT_MAX;
for (int k = 1; k <= n; k++)
if (s[k][j] == s[i][j]) {
sm += a[k][j];
tmp = max(tmp, a[k][j]);
sum[i][j] |= (1 << k - 1);
}
val[i][j] = sm - tmp;
}
memset(dp, 0x3f, sizeof(dp));
dp[0] = 0;
for (int i = 0, j; i < (1 << n) - 1; i++) {
for (j = 0; j < n; j++)
if (!(i & (1 << j))) break;
for (int k = 0; k < m; k++)
dp[i | (1 << j)] = min(dp[i | (1 << j)], dp[i] + a[j + 1][k + 1]),
dp[i | sum[j + 1][k + 1]] = min(dp[i | sum[j + 1][k + 1]],
dp[i] + val[j + 1][k + 1]);
}
return printf("%d\n", dp[(1 << n) - 1]), 0;
}
|
#include <bits/stdc++.h>
int f[1200000], g[30][30], h[30][30], o[30], p[30], q[30][30];
char c[30][30];
int i, j, k, l, m, n, t, u, v;
int main() {
scanf("%d%d", &n, &m);
for (i = 1; i <= n; i++) scanf("%s", c[i] + 1);
for (i = 1; i <= n; i++)
for (j = 1; j <= m; j++) c[i][j] = c[i][j] - 96;
memset(o, 12, sizeof(o));
for (i = 1; i <= n; i++)
for (j = 1; j <= m; j++) {
scanf("%d", &g[i][j]);
if (g[i][j] < o[i]) o[i] = g[i][j];
}
for (i = 1; i <= m; i++)
for (j = 1; j <= 26; j++) {
for (k = 1, l = 0, u = 0, v = 0; k <= n; k++)
if (c[k][i] == j) {
l = l | (1 << (k - 1));
u = u + g[k][i];
if ((!v) || (g[v][i] < g[k][i])) v = k;
}
h[i][j] = l, q[i][j] = u - g[v][i];
}
for (i = 1; i <= n; i++) p[i] = 1 << (i - 1);
t = (1 << n) - 1;
memset(f, 12, sizeof(f));
f[0] = 0;
for (i = 1; i <= m; i++) {
for (k = 1; k <= 26; k++)
if (h[i][k]) {
for (j = t; j > 0; j--)
if (((j | h[i][k]) == j) && (f[j] > f[j - h[i][k]] + q[i][k]))
f[j] = f[j - h[i][k]] + q[i][k];
for (j = t; j > 0; j--)
if (((j | h[i][k]) != j) && (f[j]))
for (l = t ^ j; l != 0; l = l - (l & (-l)))
if (f[j] > f[j + (l & (-l))]) f[j] = f[j + (l & (-l))];
}
}
for (k = 1; k <= 20; k++)
for (j = t; j > 0; j--)
if ((j & p[k]) && (f[j] > f[j - p[k]] + o[k])) f[j] = f[j - p[k]] + o[k];
printf("%d", f[(1 << n) - 1]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m;
char a[22][22];
int cost[22][22];
pair<int, int> moves[26][22];
int main() {
gets(a[0]);
sscanf(a[0], "%d%d", &n, &m);
for (int i(0), _B_i(n); i < _B_i; ++i) gets(a[i]);
vector<pair<int, int> > moves;
for (int i(0), _B_i(n); i < _B_i; ++i) {
int s = -1u / 2;
for (int j(0), _B_j(m); j < _B_j; ++j) {
scanf("%d", &cost[i][j]);
s = min(s, cost[i][j]);
}
moves.push_back({1 << i, s});
}
for (int j(0), _B_j(m); j < _B_j; ++j) {
vector<pair<int, int> > t(26);
for (int i(0), _B_i(n); i < _B_i; ++i) {
int c = a[i][j] - 'a';
t[c].first |= 1 << i;
t[c].second = min(t[c].second, -cost[i][j]);
}
for (int i(0), _B_i(n); i < _B_i; ++i)
t[a[i][j] - 'a'].second += cost[i][j];
for (int i(0), _B_i(26); i < _B_i; ++i)
if (t[i].first) moves.push_back(t[i]);
}
vector<int> f(1 << n, -1u / 4);
f[0] = 0;
for (auto move : moves)
for (int p = (1 << n); p-- > 0;)
f[p | move.first] = min(f[p | move.first], f[p] + move.second);
printf("%d\n", f.back());
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m;
char A[100][100];
int val[100][100];
long long dp[1 << 24];
long long bit[100][100];
long long cost[100][100];
void deal() {
int i, j, k, maxval, maxn, sum, st;
for (i = 1; i <= n; i++) {
for (j = 1; j <= m; j++) {
st = 0;
maxval = -1;
maxn = -1;
sum = 0;
for (k = 1; k <= n; k++) {
if (A[k][j] == A[i][j]) {
if (val[k][j] > maxval) {
maxval = val[k][j];
maxn = k;
}
sum += val[k][j];
st |= (1 << (k - 1));
}
}
sum -= val[maxn][j];
cost[i][j] = sum;
bit[i][j] = st;
}
}
}
long long MIN(long long a, long long b) { return a < b ? a : b; }
void solve() {
int st, j, k;
for (st = 0; st <= (1 << n) - 1; st++) {
dp[st] = 999999999;
}
dp[0] = 0;
for (st = 0; st <= (1 << n) - 1; st++) {
for (j = 1; j <= n; j++) {
if (((1 << (j - 1)) & st) == 0) {
for (k = 1; k <= m; k++) {
dp[st | (1 << (j - 1))] =
MIN(dp[st | (1 << (j - 1))], dp[st] + val[j][k]);
dp[st | bit[j][k]] = MIN(dp[st | bit[j][k]], dp[st] + cost[j][k]);
}
}
}
}
}
int main() {
int i, j;
scanf("%d%d", &n, &m);
for (i = 1; i <= n; i++) {
scanf("%s", A[i] + 1);
}
for (i = 1; i <= n; i++) {
for (j = 1; j <= m; j++) {
scanf("%d", &val[i][j]);
}
}
deal();
solve();
cout << dp[(1 << n) - 1] << endl;
return 0;
}
|
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:1024000000,1024000000")
using namespace std;
int dp[1 << 20], a[22][22], c[22][22], f[22][22];
char s[22][22];
int main() {
int T, i, j, k, m, n;
scanf("%d%d", &n, &m);
for (i = 0; i < n; i++) scanf("%s", s[i]);
for (i = 0; i < n; i++)
for (j = 0; j < m; j++) scanf("%d", &a[i][j]);
for (i = 0; i < n; i++)
for (j = 0; j < m; j++) {
int mx = 0;
for (k = 0; k < n; k++) {
if (s[k][j] == s[i][j]) {
f[i][j] |= (1 << k);
c[i][j] += a[k][j];
mx = max(mx, a[k][j]);
}
}
c[i][j] -= mx;
}
memset(dp, 63, sizeof(dp));
dp[0] = 0;
for (i = 1; i < 1 << n; i++) {
for (j = 0; j < n; j++)
if (i >> j & 1) break;
for (k = 0; k < m; k++) {
dp[i] = min(dp[i], dp[i ^ (1 << j)] + a[j][k]);
dp[i] = min(dp[i], dp[i & (i ^ f[j][k])] + c[j][k]);
}
}
printf("%d\n", dp[(1 << n) - 1]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int cost[22][22];
int f[1 << 20];
int m, n;
bool v[22][22];
string s[22];
vector<vector<pair<int, int> > > g;
int main(int argc, char *argv[]) {
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];
int N = 1 << n;
for (int i = 1; i < N; ++i) f[i] = 100000000;
for (int j = 0; j < m; ++j) {
for (int i = 0; i < n; ++i)
if (!v[i][j]) {
v[i][j] = true;
vector<pair<int, int> > ng;
ng.push_back(make_pair(i, cost[i][j]));
for (int ii = i + 1; ii < n; ++ii)
if (s[i][j] == s[ii][j]) {
v[ii][j] = true;
ng.push_back(make_pair(ii, cost[ii][j]));
}
g.push_back(ng);
}
}
for (vector<pair<int, int> > v : g) {
int sum = 0, mx = 0, bits = 0;
for (pair<int, int> pr : v) {
sum += pr.second;
mx = max(pr.second, mx);
bits |= 1 << pr.first;
}
for (int i = 0; i < N; ++i) {
int ni = i | bits;
f[ni] = min(f[ni], f[i] + sum - mx);
for (pair<int, int> pr : v) {
int ni = i | (1 << pr.first);
f[ni] = min(f[ni], f[i] + pr.second);
}
}
}
cout << f[N - 1] << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 3e3 + 10, mod = 998244353;
int n, m, cost[22][22], c[1 << 20], need[22][22], dp[1 << 20];
char s[22][22];
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 i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
for (int k = 0; k < n; k++) {
if (i == k) continue;
need[i][j] ^= ((s[i][j] == s[k][j]) << k);
}
}
}
for (int mask = 0; mask < (1 << n); mask++) c[mask] = dp[mask] = (1 << 30);
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
c[1 << i] = min(c[1 << i], (need[i][j] ? cost[i][j] : 0));
int sum = cost[i][j], mx = cost[i][j];
for (int k = 0; k < n; k++) {
if ((need[i][j] >> k) & 1) {
sum += cost[k][j];
mx = max(mx, cost[k][j]);
}
}
if (need[i][j]) {
c[(1 << i) | need[i][j]] = min(c[(1 << i) | need[i][j]], sum - mx);
}
}
}
vector<int> nex;
for (int mask = 0; mask < (1 << n); mask++) {
if (c[mask] != (1 << 30)) nex.push_back(mask);
}
dp[0] = 0;
for (int mask = 0; mask < (1 << n); mask++) {
for (int x : nex) {
dp[mask | x] = min(dp[mask | x], dp[mask] + c[x]);
}
}
printf("%d\n", dp[(1 << n) - 1]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
char s[21][21];
int cost[21][21];
int dp[1 << 21];
int xh[21][21][2];
int change[21][21][2];
bool fh[21];
const int INF = 0x3f3f3f3f;
int main() {
int n, m;
int begin = 0;
scanf("%d%d", &n, &m);
memset(dp, 0x3f, sizeof(dp));
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 i = 0; i < n; i++) {
bool flag = false;
for (int j = 0; j < m && !flag; j++) {
bool flag1 = true;
for (int k = 0; k < n && flag1; k++) {
if (j == k) continue;
if (s[i][j] == s[k][j]) flag1 = false;
}
if (flag1) flag = true;
}
if (flag) fh[i] = true;
}
for (int i = 0; i < n; i++) {
if (fh[i]) continue;
for (int j = 0; j < m; j++) {
int cnt = 0;
for (int k = 0; k < n; k++) {
if (k == i) continue;
if (s[i][j] == s[k][j]) {
change[i][j][1] = change[i][j][1] | (1 << k);
cnt++;
xh[i][j][1] += cost[k][j];
}
}
if (cnt == 1)
change[i][j][0] = change[i][j][1];
else
change[i][j][0] = 0;
xh[i][j][0] = cost[i][j];
}
}
for (int i = 0; i < n; i++)
if (fh[i]) begin = begin | (1 << i);
dp[begin] = 0;
for (int i = begin; i < (1 << n); i++)
if (dp[i] != INF)
for (int j = 0; j < n; j++)
if (!((1 << j) & i)) {
for (int k = 0; k < m; k++) {
for (int t = 0; t < 2; t++) {
int next = i | (1 << j);
next = next | change[j][k][t];
dp[next] = min(dp[next], dp[i] + xh[j][k][t]);
}
}
}
printf("%d\n", dp[(1 << n) - 1]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
inline int 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;
}
int dp[(1 << 20) + 100];
char s[30][30];
int a[30][30], b[30][30];
int st[30][30];
int n, m;
inline void upd(int &x, int y) {
if (x > y) x = y;
}
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]);
int S = (1 << n);
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 (s[i][j] != s[k][j]) continue;
b[i][j] += a[k][j];
mx = max(mx, a[k][j]);
st[i][j] |= (1 << k);
}
b[i][j] -= mx;
}
}
for (int i = 0; i < S; i++) dp[i] = 1e9;
dp[0] = 0;
for (int i = 0; i < S; i++) {
for (int j = 0; j < n; j++) {
if (i & (1 << j)) continue;
int p = (1 << j);
for (int k = 0; k < m; k++) {
int q = st[j][k];
upd(dp[i | p], dp[i] + a[j][k]);
upd(dp[i | q], dp[i] + b[j][k]);
}
break;
}
}
printf("%d\n", dp[S - 1]);
return 0;
}
|
#include <bits/stdc++.h>
int n, m;
char str[(21)][(21)];
int a[(21)][(21)], dp[1 << (21)], logdown[1 << ((21) + 1)];
int main() {
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]);
}
}
for (int i = 2; i < 1 << ((21) + 1); ++i) {
logdown[i] = logdown[i >> 1] + 1;
}
memset(dp, 0x3f, sizeof(dp));
dp[0] = 0;
for (int mask = 0; mask < (1 << n) - 1; ++mask) {
int sit = logdown[((~mask) & (-(~mask)))];
for (int j = 0; j < m; ++j) {
if (sit < n) {
dp[mask ^ (1 << sit)] =
std::min(dp[mask ^ (1 << sit)], dp[mask] + a[sit][j]);
}
int sum = 0, mxx = INT_MIN, _mask = mask;
for (int i = 0; i < n; ++i) {
if (str[i][j] == str[sit][j]) {
sum += a[i][j];
mxx = std::max(mxx, a[i][j]);
_mask |= 1 << i;
}
}
dp[_mask] = std::min(dp[_mask], dp[mask] + sum - mxx);
}
}
printf("%d\n", dp[(1 << n) - 1]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
vector<string> s;
int n, m, a[25][25];
int dp[(1 << 21)];
int go(int msk) {
if (msk == (1 << n) - 1) return 0;
if (dp[msk] != -1) return dp[msk];
int i;
for (i = 0; i < n && (msk & (1 << i)); i++)
;
int ret = 1e9;
for (int j = 0; j < m; j++) {
ret = min(ret, a[i][j] + go(msk | (1 << i)));
int sum = 0, mx = 0, nmsk = msk;
for (int k = 0; k < n; k++) {
if (s[k][j] == s[i][j]) {
nmsk |= (1 << k);
sum += a[k][j];
mx = max(mx, a[k][j]);
}
}
ret = min(ret, sum - mx + go(nmsk));
}
return dp[msk] = ret;
}
int main() {
while (cin >> n >> m) {
memset(dp, -1, sizeof dp);
s.resize(n);
for (int i = 0; i < n; cin >> s[i++])
;
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++) cin >> a[i][j];
cout << go(0) << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int INF = 1e9;
char ch[30][30];
int d[1500000], a[30][30], bit[30][30], cost[30][30];
int main() {
int n, m;
cin >> n >> m;
for (int i = 1; i <= n; ++i)
for (int j = 1; j <= m; ++j) cin >> ch[i][j];
for (int i = 1; i <= n; ++i)
for (int j = 1; j <= m; ++j) cin >> a[i][j];
for (int i = 1; i <= n; ++i)
for (int j = 1; j <= m; ++j) {
int Max = 0;
for (int k = 1; k <= n; ++k)
if (ch[i][j] == ch[k][j]) {
cost[i][j] += a[k][j];
Max = max(Max, a[k][j]);
bit[i][j] |= (1 << k - 1);
}
cost[i][j] -= Max;
}
int e = (1 << n);
for (int i = 1; i < e; ++i) d[i] = INF;
for (int i = 0; i < e - 1; ++i) {
if (d[i] >= INF) continue;
int k;
for (int j = 0; j < n; ++j)
if ((i & (1 << j)) == 0) {
k = j;
break;
}
for (int j = 1; j <= m; ++j) {
d[i | (1 << k)] = min(d[i | (1 << k)], d[i] + a[k + 1][j]);
d[i | bit[k + 1][j]] = min(d[i | bit[k + 1][j]], d[i] + cost[k + 1][j]);
}
}
cout << d[e - 1] << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1100000;
const int INF = 1000000005;
int n, m;
char c[22][22];
int a[22][22], sm[22][22], Tm[22][22], mn[22];
int dp[N], mp[N];
int main() {
for (int i = 1; i < N; i++) dp[i] = INF;
scanf("%d%d", &n, &m);
int tmp = 1;
while (mp[tmp] < 20) {
mp[tmp * 2] = mp[tmp] + 1;
tmp *= 2;
}
for (int i = 0; i < n; i++) scanf("%s", c + i);
for (int i = 0; i < n; i++) {
mn[i] = INF;
for (int j = 0; j < m; j++) {
scanf("%d", &a[i][j]);
mn[i] = min(mn[i], a[i][j]);
}
}
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 (c[i][k] == c[j][k]) {
sm[i][k] |= 1 << j;
mx = max(mx, a[j][k]);
Tm[i][k] += a[j][k];
}
Tm[i][k] -= mx;
}
for (int i = 1; i < (1 << n); i++) {
int lb = i & (i - 1) ^ i;
int mmp = mp[lb];
if (dp[i ^ lb] != INF) dp[i] = min(dp[i], dp[i ^ lb] + mn[mmp]);
for (int j = 0; j < m; j++)
dp[i] = min(dp[i], dp[i & (i ^ sm[mmp][j])] + Tm[mmp][j]);
}
printf("%d\n", dp[(1 << n) - 1]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
char s[25][25];
int n, m, dp[1100000], num[25][25], INF = 1e9, MAXS;
int POW[25], MS[25][25], cost[25][25];
void init() {
int i, j, k, S;
for (i = 1; i <= n; i++)
for (j = 1; j <= m; j++) {
MS[i][j] = MAXS;
for (k = 1; k <= n; k++)
if (s[i][j] == s[k][j]) {
MS[i][j] -= POW[k];
if (k != i) cost[i][j] += num[k][j];
}
}
}
int main() {
int i, j, k, ret, S, S2;
bool flag;
scanf("%d%d", &n, &m);
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", &num[i][j]);
POW[1] = 1;
for (i = 2; i <= 23; i++) POW[i] = POW[i - 1] * 2;
MAXS = POW[n + 1] - 1;
init();
ret = MAXS;
for (i = 1; i <= n; i++) {
for (j = 1; j <= m; j++) {
flag = true;
for (k = 1; k <= n; k++)
if (s[i][j] == s[k][j] && i != k) flag = false;
if (flag) {
ret -= POW[i];
break;
}
}
}
dp[ret] = 0;
for (S = 0; S < ret; S++) dp[S] = INF;
for (S = ret; S > 0; S--)
if (dp[S] < INF) {
for (i = 1; i <= n; i++)
if (S & POW[i]) {
for (j = 1; j <= m; j++) {
S2 = S - POW[i];
dp[S2] = min(dp[S2], dp[S] + num[i][j]);
S2 = S & MS[i][j];
dp[S2] = min(dp[S2], dp[S] + cost[i][j]);
}
}
}
printf("%d\n", dp[0]);
}
|
#include <bits/stdc++.h>
using namespace std;
int dp[1 << 20], w[25][25];
string s[25];
pair<int, int> alph[25][26];
int ma[25][26];
int cost[1 << 20];
vector<pair<int, int> > rco;
int main() {
int n, m;
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 >> w[i][j];
}
fill(cost, cost + (1 << 20), (int)1e9);
cost[0] = 0;
for (int i = 0; i < m; i++) {
for (int j = 0; j < n; j++) {
cost[1 << j] = min(cost[1 << j], w[j][i]);
alph[i][(s[j][i] - 'a')].first |= (1 << j);
alph[i][(s[j][i] - 'a')].second += w[j][i];
ma[i][s[j][i] - 'a'] = max(ma[i][s[j][i] - 'a'], w[j][i]);
}
for (int j = 0; j < 26; j++) {
alph[i][j].second -= ma[i][j];
cost[alph[i][j].first] = min(cost[alph[i][j].first], alph[i][j].second);
}
}
for (int i = 1; i < (1 << 20); i++) {
if (cost[i] != (int)1e9) rco.push_back(make_pair(i, cost[i]));
}
fill(dp, dp + (1 << n), (int)1e9);
dp[0] = 0;
for (int i = 0; i < rco.size(); i++) {
const int mask = rco[i].first, co = rco[i].second;
for (int j = 0; j < (1 << n); j++) {
dp[j | mask] = min(dp[j | mask], dp[j] + co);
}
}
cout << dp[(1 << n) - 1];
}
|
#include <bits/stdc++.h>
using namespace std;
void Print() { cout << endl; }
template <typename T1, typename... T>
void Print(const T1 &t1, const T &...t) {
cout << t1 << " ";
Print(t...);
}
template <typename T1, typename T2>
ostream &operator<<(ostream &os, const pair<T1, T2> &p) {
os << "(" << p.first << ", " << p.second << ")";
return os;
}
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() {
ios_base::sync_with_stdio(false), cin.tie(0), cout.tie(0);
int n, m;
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];
for (int i = 0; i < n; ++i)
for (int j = 0; j < m; ++j) {
int curv = 0;
for (int k = 0; k < 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 < 1 << n; ++i) d[i] = 1000000000;
d[0] = 0;
for (int mask = 1; mask < 1 << n; ++mask) {
int lowbit = -1;
for (int i = 0; i < n; ++i)
if ((mask >> i) & 1) {
lowbit = i;
break;
}
for (int i = 0; i < 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]);
}
}
cout << d[(1 << n) - 1] << endl;
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, tem = 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];
tem = max(tem, cost[j][i]);
}
}
f[i][k] = min(f[i][k], sum - tem);
}
}
}
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;
string s[25];
int n, m;
int msk[25][128], dp[21][1 << 21], arr[25][25];
int sum[25][128];
void solve() {
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 >> arr[i][j];
sum[j][s[i][j]] += arr[i][j];
msk[j][s[i][j]] |= (1 << (i));
}
}
for (int i = m; i >= 0; i--) {
for (int mask = ((1 << n) - 1); mask >= 0; mask--) {
if (i == m) {
if (mask == ((1 << n) - 1))
dp[i][mask] = 0;
else
dp[i][mask] = 100000000;
} else {
dp[i][mask] = 100000000;
for (int j = 0; j < n; j++) {
if (!(mask & (1 << j))) {
int cur = arr[j][i] + dp[i][mask | (1 << j)];
cur = min(cur, sum[i][s[j][i]] - arr[j][i] +
dp[i][mask | (msk[i][s[j][i]])]);
dp[i][mask] = min(dp[i][mask], cur);
}
}
dp[i][mask] = min(dp[i][mask], dp[i + 1][mask]);
}
}
}
cout << dp[0][0] << '\n';
}
int32_t main() {
ios::sync_with_stdio(false);
cin.tie(0);
int t = 1;
while (t--) {
solve();
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 20;
const int SCOPE = 26;
int dp[1 << N];
int penalty[N][N];
char strings[N][N];
int main() {
int n, m;
scanf("%d %d", &n, &m);
for (int i = 0; i < n; i++) {
scanf("%s", strings[i]);
}
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
scanf("%d", &penalty[i][j]);
}
}
int total = (1 << n);
memset(dp, 0x3f, sizeof(dp));
dp[0] = 0;
for (int j = 0; j < m; j++) {
for (int mask = 0; mask < total; mask++) {
for (int i = 0; i < n; i++) {
dp[mask | (1 << i)] =
min(dp[mask | (1 << i)], dp[mask] + penalty[i][j]);
}
}
for (int ch = 0; ch < SCOPE; ch++) {
int local_cost = 0, max_cost = 0;
int cur_mask = 0;
for (int i = 0; i < n; i++) {
if (strings[i][j] == ch + 'a') {
cur_mask |= (1 << i);
local_cost += penalty[i][j];
max_cost = max(max_cost, penalty[i][j]);
}
}
if (cur_mask != 0) {
for (int mask = 0; mask < total; mask++) {
dp[mask | cur_mask] =
min(dp[mask | cur_mask], dp[mask] + local_cost - max_cost);
}
}
}
}
printf("%d\n", dp[total - 1]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 20;
const int M = 1048576;
const int FILL = 505290270;
int n, m, limit, turn;
int same[N][N], cost[N][N], modify[N][N], e[N], f[M];
char b[N][N];
void pre() {
int maxi;
for (int j = 0; j < m; j++)
for (int i = 0; i < n; i++) {
maxi = 0;
for (int k = 0; k < n; k++)
if (b[i][j] == b[k][j]) {
same[i][j] |= e[k];
maxi = max(maxi, modify[k][j]);
cost[i][j] += modify[k][j];
}
cost[i][j] -= maxi;
}
}
void solve() {
memset(f, 30, sizeof(f));
f[0] = 0;
for (int j = 0; j < limit; j++)
for (int i = 0; i < n; i++)
if ((j & e[i]) == 0)
for (int k = 0; k < m; k++) {
f[j | e[i]] = min(f[j | e[i]], f[j] + modify[i][k]);
f[j | same[i][k]] = min(f[j | same[i][k]], f[j] + cost[i][k]);
}
printf("%d\n", f[limit - 1]);
}
int main() {
scanf("%d%d", &n, &m);
limit = 1 << n;
scanf("%s", b[0]);
e[0] = 1;
for (int i = 1; i < n; i++) {
scanf("%s", b[i]);
e[i] = e[i - 1] << 1;
}
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++) scanf("%d", &modify[i][j]);
pre();
solve();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int inf = 1e9 + 5;
const long long linf = 1e18 + 5;
const int N = 20 + 5;
const int M = 26 + 5;
const int MAX = (1 << 20) + 5;
int n, m, a[N][N], mx[N][M], sum[N][M], on[N][M], add[N][N], mask[N][N],
dp[MAX];
char s[N][N];
int main() {
cin >> 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++) cin >> a[i][j];
for (int j = 1; j <= m; j++)
for (int i = 'a'; i <= 'z'; i++)
for (int k = 1; k <= n; k++)
if (s[k][j] == i) {
mx[j][i - 'a'] = max(mx[j][i - 'a'], a[k][j]);
sum[j][i - 'a'] += a[k][j];
on[j][i - 'a'] |= 1 << k - 1;
}
for (int i = 1; i <= n; i++)
for (int j = 1; j <= m; j++) {
add[i][j] = sum[j][s[i][j] - 'a'] - mx[j][s[i][j] - 'a'];
mask[i][j] = on[j][s[i][j] - 'a'];
}
for (int i = (1 << n) - 2; i >= 0; i--) {
int x;
for (int j = 1; j <= n; j++)
if (~i & 1 << j - 1) {
x = j;
break;
}
dp[i] = inf;
for (int j = 1; j <= m; j++) {
dp[i] = min(dp[i], dp[i | 1 << x - 1] + a[x][j]);
dp[i] = min(dp[i], dp[i | mask[x][j]] + add[x][j]);
}
}
cout << dp[0] << '\n';
return 0;
}
|
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:128000000")
using namespace std;
void solve();
void precalc();
clock_t start;
bool doing = true;
int main() {
int t = 1;
cout.sync_with_stdio(0);
cin.tie(0);
precalc();
cout.precision(10);
cout << fixed;
start = clock();
int testNum = 1;
while (t--) {
solve();
}
return 0;
}
void precalc() {}
int binpow(int q, int w, int mod) {
if (!w) return 1;
if (w & 1) return q * binpow(q, w - 1, mod) % mod;
return binpow(q * q % mod, w / 2, mod);
}
int gcd(int q, int w) {
while (w) {
q %= w;
swap(q, w);
}
return q;
}
void solve() {
int n, m;
cin >> n >> m;
vector<string> s(n);
for (int i = 0; i < n; ++i) {
cin >> s[i];
}
vector<vector<int>> a(n, vector<int>(m));
for (int i = 0; i < n; ++i) {
for (int j = 0; j < m; ++j) {
cin >> a[i][j];
}
}
vector<pair<int, int>> masks;
int uniqMask = 0;
for (int j = 0; j < m; ++j) {
vector<pair<char, int>> letters;
for (int i = 0; i < n; ++i) {
letters.push_back(make_pair(s[i][j], i));
}
sort(letters.begin(), letters.end());
for (int i = 0; i < letters.size();) {
int r = i;
while (r < letters.size() && letters[r].first == letters[i].first) {
++r;
}
if (r == i + 1) {
uniqMask |= (1 << letters[i].second);
i = r;
continue;
}
vector<int> costs;
int sum = 0;
int curMask = 0;
for (int k = i; k < r; ++k) {
costs.push_back(a[letters[k].second][j]);
curMask |= (1 << letters[k].second);
sum += a[letters[k].second][j];
masks.push_back(
make_pair(1 << letters[k].second, a[letters[k].second][j]));
}
sort(costs.begin(), costs.end());
sum -= costs.back();
masks.push_back(make_pair(curMask, sum));
i = r;
}
}
long long INF = 1000000000000000000LL;
vector<long long> dp(1 << n, INF);
dp[uniqMask] = 0;
for (auto item : masks) {
int addMask = item.first;
int cost = item.second;
for (int mask = 0; mask < (1 << n); ++mask) {
if (dp[mask] == INF) continue;
if (dp[mask] + cost < dp[mask | addMask]) {
dp[mask | addMask] = dp[mask] + cost;
}
}
}
cout << dp[(1 << n) - 1] << "\n";
}
|
#include <bits/stdc++.h>
using namespace std;
const int INF = std::numeric_limits<int>::max() / 3;
int gcd(int a, int b) { return b == 0 ? a : gcd(b, a % b); }
int lcm(int a, int b) { return a * (b / gcd(a, b)); }
string w[22];
int a[22][22], cv[22][22], c[22][22];
int main() {
int n, m;
cin >> n >> m;
for (int i = 0; i < n; ++i) cin >> w[i];
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) {
c[i][j] = 0;
cv[i][j] = 0;
int maxc = 0;
for (int k = 0; k < n; ++k) {
if (w[i][j] == w[k][j]) {
cv[i][j] |= (1 << k);
c[i][j] += a[k][j];
maxc = ((maxc) > (a[k][j]) ? (maxc) : (a[k][j]));
}
}
c[i][j] -= maxc;
}
int dp[1 << n];
for (int i = 0; i < (1 << n); ++i) dp[i] = INF;
int mask;
dp[0] = 0;
for (mask = 1; mask < (1 << n); ++mask) {
int lowbit = -1;
for (int i = 0; i < n; ++i)
if ((mask >> i) & 1) {
lowbit = i;
break;
}
for (int i = 0; i < m; ++i) {
dp[mask] =
((dp[mask]) < (dp[mask & (mask ^ cv[lowbit][i])] + c[lowbit][i])
? (dp[mask])
: (dp[mask & (mask ^ cv[lowbit][i])] + c[lowbit][i]));
dp[mask] = ((dp[mask]) < (dp[(mask ^ (1 << lowbit))] + a[lowbit][i])
? (dp[mask])
: (dp[(mask ^ (1 << lowbit))] + a[lowbit][i]));
}
}
cout << dp[(1 << n) - 1] << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 20;
string s[maxn];
int a[maxn][maxn];
int dp[1 << maxn];
int main() {
ios_base::sync_with_stdio(false);
int n, m;
cin >> n >> m;
for (int _n(n), i(0); i < _n; i++) {
cin >> s[i];
}
for (int _n(n), i(0); i < _n; i++)
for (int _n(m), j(0); j < _n; j++) cin >> a[i][j];
vector<pair<int, int> > vals;
int start = 0;
for (int _n(m), j(0); j < _n; j++) {
for (char c = 'a'; c <= 'z'; ++c) {
int cnt = 0;
int mask = 0;
int mx = 0;
int sum = 0;
for (int _n(n), i(0); i < _n; i++) {
if (s[i][j] != c) continue;
++cnt;
mask |= 1 << i;
mx = max(mx, a[i][j]);
sum += a[i][j];
}
if (cnt == 0) continue;
if (cnt == 1) {
start |= mask;
continue;
}
vals.push_back(make_pair(mask, sum - mx));
}
}
for (int _n(n), i(0); i < _n; i++) {
int mn = 1011111111;
for (int _n(m), j(0); j < _n; j++) mn = min(mn, a[i][j]);
vals.push_back(make_pair(1 << i, mn));
}
for (int _n(1 << n), i(0); i < _n; i++) dp[i] = 1011111111;
dp[start] = 0;
for (const pair<int, int> &p : vals) {
const int &mask = p.first;
const int &val = p.second;
for (int _n(1 << n), s(0); s < _n; s++) {
dp[s | mask] = min(dp[s | mask], dp[s] + val);
}
}
cout << dp[(1 << n) - 1] << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int x[26], y[26], z[26], q[26];
int p[1 << 20];
int n, m;
char s[26][26];
int g[26][26];
int mi[26];
int a, b, c, d;
int dy[1 << 20];
inline void qmi(int &a, int b) {
if (a > b) a = b;
}
inline void qma(int &a, int b) {
if (a < b) a = b;
}
int main() {
scanf("%d%d", &n, &m);
for (int i = 1; i <= n; ++i) dy[1 << (i - 1)] = i;
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", &g[i][j]);
for (int i = 1; i <= (1 << n) - 1; ++i) p[i] = 1000000000;
for (int i = 1; i <= n; ++i) {
a = g[i][1];
for (int j = 2; j <= m; ++j) qmi(a, g[i][j]);
mi[i] = a;
}
for (int j = 1; j <= m; ++j) {
for (int i = 0; i <= 25; ++i) x[i] = y[i] = z[i] = 0;
for (int i = 1; i <= n; ++i) {
x[s[i][j] - 'a'] += g[i][j];
qma(y[s[i][j] - 'a'], g[i][j]);
z[s[i][j] - 'a'] |= 1 << (i - 1);
}
for (int i = 0; i <= 25; ++i) x[i] -= y[i];
for (int i = 0; i <= 25; ++i) {
if (z[i] == 0) continue;
if (dy[z[i]]) {
qmi(mi[dy[z[i]]], x[i]);
continue;
}
for (int k = 0; k <= (1 << n) - 1; ++k) qmi(p[k | z[i]], p[k] + x[i]);
}
}
for (int k = 0; k <= (1 << n) - 1; ++k)
for (int i = 1; i <= n; ++i) qmi(p[k | (1 << (i - 1))], p[k] + mi[i]);
printf("%d\n", p[(1 << n) - 1]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int inf = 1e9 + 7;
const int maxn = 21;
char s[maxn][maxn];
int dp[1 << maxn], a[maxn][maxn], cost[maxn][maxn], same[maxn][maxn];
int main() {
int n, m;
ios::sync_with_stdio(false);
cin >> n >> m;
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++) cin >> s[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 sum = 0, ma = 0;
for (int k = 0; k < n; k++) {
if (s[i][j] == s[k][j]) {
sum += a[k][j];
ma = max(ma, a[k][j]);
same[i][j] |= (1 << k);
}
}
cost[i][j] = sum - ma;
}
}
for (int i = 1; i < (1 << n); i++) dp[i] = inf;
for (int i = 0; i < (1 << n); i++) {
for (int j = 0; j < n; j++) {
for (int k = 0; k < m; k++) {
dp[i | (1 << j)] = min(dp[i | (1 << j)], dp[i] + a[j][k]);
dp[i | same[j][k]] = min(dp[i | same[j][k]], dp[i] + cost[j][k]);
}
}
}
cout << dp[(1 << n) - 1] << endl;
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;
}
}
memset(dp, 127, sizeof(dp));
dp[0] = 0;
for (int i = 0; i <= (1 << n) - 1; i++) {
for (int k = 0; k < n; k++)
if (!((1 << k) & i))
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 a[30][30];
int sum[30][30];
int sta[30][30];
int dp[1 << 21];
int bul(int state) {
if (state == (1 << n) - 1) return 0;
int &ret = dp[state];
if (ret != -1) return ret;
ret = 1000000007LL;
for (long long int i = 1; i <= n; i++)
if (!(state & (1 << i - 1))) {
for (long long int j = 1; j <= m; j++)
ret = min(ret, min(bul(state | (1 << i - 1)) + a[i][j],
bul(state | sta[i][j]) + sum[i][j]));
return ret;
}
}
int main() {
cin >> n >> m;
for (long long int i = 1; i <= n; i++)
for (long long int j = 1; j <= m; j++) cin >> s[i][j];
for (long long int i = 1; i <= n; i++)
for (long long int j = 1; j <= m; j++) cin >> a[i][j];
for (long long int i = 1; i <= n; i++)
for (long long int j = 1; j <= m; j++) {
int maxi = 0;
for (long long int k = 1; k <= n; k++)
if (s[i][j] == s[k][j]) {
sum[i][j] += a[k][j];
sta[i][j] |= (1 << k - 1);
maxi = max(maxi, a[k][j]);
}
sum[i][j] -= maxi;
}
memset(dp, -1, sizeof dp);
cout << bul(0) << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 22;
const int M = 22;
const int INF = 1e9;
int n, m;
int dp[1 << N];
char str[N][M];
int val[N][M], cst[N][M], msk[N][M];
int main() {
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", &val[i][j]);
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
int total = 0;
int maxn = 0;
for (int k = 0; k < n; k++) {
if (str[i][j] == str[k][j]) {
msk[i][j] |= (1 << k);
total += val[k][j];
maxn = max(maxn, val[k][j]);
}
}
cst[i][j] = total - maxn;
}
}
for (int i = 1; i < (1 << n); i++) dp[i] = INF;
dp[0] = 0;
for (int i = 1; i < (1 << n); i++) {
int first = 0;
while ((i & (1 << first)) == 0) first++;
for (int j = 0; j < m; j++) {
dp[i] = min(dp[i], dp[i ^ (1 << first)] + val[first][j]);
dp[i] = min(dp[i], dp[i & (i ^ msk[first][j])] + cst[first][j]);
}
}
printf("%d\n", dp[(1 << n) - 1]);
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m;
char s[20][21];
int a[20][20];
int g[20][20], cost[20][20];
int dp[1 << 20];
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(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 >> 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 (s[i][j] == s[k][j]) {
g[i][j] |= 1 << k;
cost[i][j] += a[k][j];
mx = max(mx, a[k][j]);
}
}
cost[i][j] -= mx;
}
memset(dp, 0x3f, sizeof(dp));
dp[0] = 0;
for (int s = 0; s < 1 << n; s++) {
int lb = -1;
for (int i = 0; i < n; i++)
if (s >> i & 1 ^ 1) {
lb = i;
break;
}
if (lb != -1)
for (int i = 0; i < m; i++) {
dp[s | 1 << lb] = min(dp[s | 1 << lb], dp[s] + a[lb][i]);
dp[s | g[lb][i]] = min(dp[s | g[lb][i]], dp[s] + cost[lb][i]);
}
}
cout << dp[(1 << n) - 1] << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int N, M, cost[20][20], dp[1 << 20];
char sd[20][21];
int sv(int bs) {
int& ans = dp[bs];
if (ans == -1) {
ans = INT_MAX;
int n = __builtin_ffs(bs) - 1;
for (int m = 0; m < int(M); m++) {
int nbs = bs & ~(1 << n);
ans = min(ans, cost[n][m] + sv(nbs));
int rc = 0, mc = 0;
for (int n2 = 0; n2 < int(N); n2++)
if (sd[n2][m] == sd[n][m]) {
rc += cost[n2][m];
nbs &= ~(1 << n2);
mc = max(mc, cost[n2][m]);
}
ans = min(ans, rc - mc + sv(nbs));
}
}
return ans;
}
int main() {
scanf("%d%d", &N, &M);
for (int n = 0; n < int(N); n++) scanf("%s", sd[n]);
for (int n = 0; n < int(N); n++)
for (int m = 0; m < int(M); m++) scanf("%d", &cost[n][m]);
memset(dp, -1, sizeof dp);
dp[0] = 0;
printf("%d\n", sv((1 << N) - 1));
}
|
#include <bits/stdc++.h>
using namespace std;
const int inf = 1e9 + 7;
const int N = 20;
const int E = 1 << 20;
int n, m, a[N][N], c[N][N], maxst;
int t[E], avl[E], an, f[E];
int main() {
scanf("%d%d", &n, &m);
for (int i = 0; i < n; ++i)
for (int j = 0; j < m; ++j) {
char c;
c = getchar();
while (c < 'a' || c > 'z') c = getchar();
a[i][j] = c - 'a';
}
for (int i = 0; i < n; ++i)
for (int j = 0; j < m; ++j) scanf("%d", &c[i][j]);
maxst = 1 << n;
for (int i = 0; i < maxst; ++i) t[i] = inf;
for (int i = 0; i < m; ++i) {
for (int j = 0; j < 26; ++j) {
int sum = 0, mx = 0, st = 0;
for (int k = 0; k < n; ++k)
if (a[k][i] == j) {
sum += c[k][i];
mx = max(mx, c[k][i]);
st |= 1 << k;
}
sum -= mx;
t[st] = min(t[st], sum);
}
}
for (int i = 0; i < n; ++i) {
int st = 1 << i;
for (int j = 0; j < m; ++j) t[st] = min(t[st], c[i][j]);
}
an = 0;
for (int i = 0; i < maxst; ++i)
if (t[i] != inf) {
avl[an++] = i;
}
for (int i = 1; i < maxst; ++i) f[i] = inf;
f[0] = 0;
for (int i = 0; i < maxst; ++i)
for (int j = 0; j < an; ++j) {
int st = avl[j];
f[i | st] = min(f[i | st], f[i] + t[st]);
}
printf("%d\n", f[maxst - 1]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int dp[1 << 21], cost[21][21], v[21][21], n, m, val[21][21], _max;
char str[21][21];
int main() {
while (~scanf("%d %d", &n, &m)) {
getchar();
memset(val, 0, sizeof(val));
memset(v, 0, sizeof(v));
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", &cost[i][j]);
}
for (int j = 0; j < m; j++) {
for (int i = 0; i < n; i++) {
_max = 0;
for (int k = 0; k < n; k++) {
if (str[i][j] == str[k][j]) {
val[i][j] |= (1 << k);
_max = max(_max, cost[k][j]);
v[i][j] += cost[k][j];
}
}
v[i][j] -= _max;
}
}
_max = (1 << n);
memset(dp, 0x3f3f3f3f, sizeof(dp));
dp[0] = 0;
for (int i = 0; i < _max; i++) {
for (int j = 0; j < n; j++) {
if ((i & (1 << j)) == 0) {
for (int lie = 0; lie < m; lie++) {
dp[i | (1 << j)] = min(dp[i | (1 << j)], dp[i] + cost[j][lie]);
dp[i | val[j][lie]] = min(dp[i | val[j][lie]], dp[i] + v[j][lie]);
}
}
}
}
printf("%d\n", dp[_max - 1]);
}
}
|
#include <bits/stdc++.h>
using namespace std;
char s[(1 << 5)][(1 << 5)];
vector<int> f[1 << 7];
int n, m, a[(1 << 5)][(1 << 5)], dp[1 << 20], g[1 << 20];
int main() {
cin >> 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", &a[i][j]);
for (int i = 1; i < 1 << n; i++) dp[i] = (1 << 29);
dp[0] = 0;
for (int i = 1; i <= m; i++) {
for (int j = 0; j < 1 << 7; j++) f[j].clear();
for (int j = 0; j < n; j++) f[s[j][i]].push_back(j);
for (int j = 0; j < 1 << 7; j++) {
if (!f[j].size()) continue;
int sum = 0, mx = 0, st = 0;
for (int k = 0; k < 1 << n; k++) g[k] = dp[k];
for (int k = 0; k < f[j].size(); k++) {
int x = f[j][k], w = a[x][i];
sum += w, mx = max(mx, w), st |= (1 << x);
for (int r = (1 << n) - 1; r >= 0; r--)
if (r & (1 << x)) dp[r] = min(dp[r], dp[r ^ (1 << x)] + a[x][i]);
}
sum -= mx;
for (int r = 0; r < 1 << n; r++) dp[r | st] = min(dp[r | st], g[r] + sum);
}
}
cout << dp[(1 << n) - 1] << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int Inf = numeric_limits<int>::max() / 2;
int main() {
int N, M;
cin >> N >> M;
vector<string> S(N);
for (int i = 0; i < N; ++i) {
cin >> S[i];
}
vector<vector<int>> A(N, vector<int>(M));
for (int i = 0; i < N; ++i) {
for (int j = 0; j < M; ++j) {
cin >> A[i][j];
}
}
vector<vector<int>> ST(N, vector<int>(M));
vector<vector<int>> Sum(N, vector<int>(M));
for (int i = 0; i < M; ++i) {
for (int j = 0; j < N; ++j) {
int Max = 0;
for (int k = 0; k < N; ++k) {
if (S[k][i] == S[j][i]) {
ST[j][i] |= 1 << k;
Sum[j][i] += A[k][i];
Max = max(Max, A[k][i]);
}
}
Sum[j][i] -= Max;
}
}
vector<int> dp(1 << N, Inf);
dp[0] = 0;
for (int S = 0; S < 1 << N; ++S) {
int P = -1;
for (int i = N - 1; i >= 0; --i) {
if (!(S >> i & 1)) {
P = i;
}
}
if (P != -1) {
for (int i = 0; i < M; ++i) {
dp[S | (1 << P)] = min(dp[S | (1 << P)], dp[S] + A[P][i]);
dp[S | ST[P][i]] = min(dp[S | ST[P][i]], dp[S] + Sum[P][i]);
}
}
}
cout << dp.back() << '\n';
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 21, maxm = 26;
int n, m, c[maxn][maxm], id[maxn], f[1 << maxn];
char str[maxn][maxm], que[maxn];
bool cmp(const int &x, const int &y) { return que[x] < que[y]; }
int main() {
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", c[i] + j);
memset(f, 0x3f, sizeof f);
f[0] = 0;
for (int i = 0; i < m; ++i) {
for (int j = 0; j < n; ++j) {
que[j] = str[j][i];
id[j] = j;
}
sort(id, id + n, cmp);
for (int j = 0, k; j < n; j = k) {
for (k = j + 1; k < n && que[id[k - 1]] == que[id[k]]; ++k)
;
int w = 0, tmp = 0, o = 0;
for (int t = j; t < k; ++t) {
w += c[id[t]][i];
if (tmp < c[id[t]][i]) tmp = c[id[t]][i];
o |= 1 << id[t];
}
w -= tmp;
for (int s = 0; s < 1 << n; ++s)
if (f[s | o] > f[s] + w) f[s | o] = f[s] + w;
for (int t = j; t < k; ++t) {
w = c[id[t]][i];
o = 1 << id[t];
for (int s = 0; s < 1 << n; ++s)
if (f[s | o] > f[s] + w) f[s | o] = f[s] + w;
}
}
}
printf("%d\n", f[(1 << n) - 1]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int v[25][25], dp[(1 << 21)];
string s[25];
int main() {
int n, m;
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 >> v[i][j];
}
}
for (int i = 1; i <= (1 << n) - 1; i++) {
dp[i] = 50000000;
}
for (int i = 0; i <= (1 << n) - 1; i++) {
int last = 0;
for (int j = 0; j < n; j++) {
if (!(i & (1 << j))) {
last = j;
break;
}
}
for (int j = 0; j < m; j++) {
dp[i + (1 << last)] = min(dp[i + (1 << last)], dp[i] + v[last][j]);
int poz = i, sum = 0, ma = 0;
for (int k = 0; k < n; k++) {
if (s[last][j] == s[k][j]) {
poz |= 1 << k;
sum += v[k][j];
ma = max(ma, v[k][j]);
}
}
dp[poz] = min(dp[poz], dp[i] + sum - ma);
}
}
cout << dp[(1 << n) - 1];
return 0;
}
|
#include <bits/stdc++.h>
using ll = long long;
const ll mod = 1e9 + 7;
const ll N = 30;
const int base = 400;
using ull = unsigned long long;
using namespace std;
ll n, m, t, k, T, a[N][N], c[N][N], ans, u, tong, v, dp[(1 << 21)], b[N][N],
lab[N], cnt;
vector<ll> kq, adj[N];
string s[N];
ll pw(ll k, ll n) {
ll total = 1;
for (; n; n >>= 1) {
if (n & 1) total = (total * k) % mod;
k = (k * k) % mod;
}
return total;
}
void sol() {
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];
for (int l = 0; l < n; l++) {
for (int j = 0; j < m; j++) {
ll mx = 0;
for (int r = 0; r < n; r++) {
if (s[l][j] == s[r][j]) {
b[l][j] += a[r][j];
c[l][j] |= (1 << r);
mx = max(mx, a[r][j]);
}
}
b[l][j] -= mx;
}
}
for (int i = 1; i < (1 << n); i++) {
dp[i] = mod;
for (int l = 0; l < n; l++) {
if ((i >> l) & 1) {
for (int j = 0; j < m; j++) {
dp[i] = min(dp[i], dp[(i ^ (1 << l))] + a[l][j]);
dp[i] = min(dp[i], dp[(i & (((1 << n) - 1) ^ c[l][j]))] + b[l][j]);
}
break;
}
}
}
cout << dp[(1 << n) - 1];
}
int main() {
if (fopen("pieaters"
".inp",
"r")) {
freopen(
"pieaters"
".inp",
"r", stdin);
freopen(
"pieaters"
".out",
"w", stdout);
}
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int ntest;
ntest = 1;
while (ntest-- > 0) sol();
}
|
#include <bits/stdc++.h>
template <class T>
inline bool cmax(T& a, const T& b) {
return a < b ? a = b, 1 : 0;
}
template <class T>
inline bool cmin(T& a, const T& b) {
return a > b ? a = b, 1 : 0;
}
using namespace std;
const int N = 25, L = (1 << 20) + 5, inf = 0x3f3f3f3f;
char s[N][N];
int f[L], a[N][N], n, m, lim;
int main() {
scanf("%d%d", &n, &m);
for (register int i = (0), I = (n - 1) + 1; i < I; ++i) scanf("%s", s[i]);
for (register int i = (0), I = (n - 1) + 1; i < I; ++i)
for (register int j = (0), I = (m - 1) + 1; j < I; ++j)
scanf("%d", &a[i][j]);
memset(f, 0x3f, sizeof(f));
lim = (1 << n) - 1, f[0] = 0;
for (int i = 0; i < lim; i++)
for (int j = 0; j < n; j++)
if (!((i >> j) & 1)) {
for (int k = 0; k < m; k++) {
f[i | (1 << j)] = min(f[i | (1 << j)], f[i] + a[j][k]);
int add = 0;
int maxx = 0;
int change = 0;
for (int l = 0; l < n; l++) {
if (s[j][k] == s[l][k]) {
add += a[l][k];
maxx = max(maxx, a[l][k]);
change |= (1 << l);
}
}
f[i | change] = min(f[i | change], f[i] + add - maxx);
}
break;
}
printf("%d\n", f[lim]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m;
char a[25][25];
int cost[30][30], val[30][30], p, d[1 << 20], hap[30][30], maxi[30][30];
int main() {
int i, j, s;
scanf("%d %d", &n, &m);
for (i = 0; i < n; i++) {
scanf("%s", a[i]);
}
for (i = 0; i < n; i++) {
for (j = 0; j < m; j++) {
scanf("%d", &cost[i][j]);
val[j][a[i][j] - 'a' + 1] += (1 << i);
hap[j][a[i][j] - 'a' + 1] += cost[i][j];
maxi[j][a[i][j] - 'a' + 1] = max(maxi[j][a[i][j] - 'a' + 1], cost[i][j]);
}
}
for (i = 1; i < (1 << n); i++) {
if (i == (1 << n) - 1) {
d[i] = 2147483647;
}
d[i] = 2147483647;
for (j = n - 1; j >= 0; j--) {
if ((1 << j) & i) {
p = j;
break;
}
}
for (j = 0; j < m; j++) {
s = i & val[j][a[p][j] - 'a' + 1];
if ((i & s) == s) {
d[i] = min(d[i], d[i ^ s] + hap[j][a[p][j] - 'a' + 1] -
maxi[j][a[p][j] - 'a' + 1]);
}
d[i] = min(d[i], d[i - (1 << p)] + cost[p][j]);
}
}
printf("%d", d[(1 << n) - 1]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 25;
int a[N][N];
char s[N][N];
int rev[1 << N];
int dp[N];
int cost[N][N], st[N][N];
int lowbit(int x) { return x & (-x); }
void update(int &x, int y) {
if (x == -1)
x = y;
else
x = min(x, y);
}
int main() {
for (int i = 0; i < N; i++) rev[1 << i] = i;
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 mx = 0;
for (int k = 0; k < n; k++) {
if (s[i][j] == s[k][j]) {
mx = max(mx, a[k][j]);
st[i][j] |= (1 << k);
cost[i][j] += a[k][j];
}
}
cost[i][j] -= mx;
}
for (int i = 1; i < (1 << n); i++) dp[i] = 1000000000;
for (int i = 0; i < (1 << n) - 1; i++) {
if (dp[i] == -1) continue;
for (int pos = 0; pos < n; pos++) {
for (int j = 0; j < m; j++) {
update(dp[i | st[pos][j]], dp[i] + cost[pos][j]);
update(dp[i | (1 << pos)], dp[i] + a[pos][j]);
}
}
}
cout << dp[(1 << n) - 1] << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int INF = (int)2e9;
int main() {
int n, m;
scanf("%d %d ", &n, &m);
vector<string> mst(n);
for (auto &i : mst) cin >> i;
vector<vector<int>> a(n, vector<int>(m));
for (auto &i : a)
for (auto &j : i) scanf("%d", &j);
vector<int> dp(1 << n, INF);
int alreadysep = 0;
for (int i = 0; i < m; i++) {
for (int j = 0; j < n; j++) {
bool f = true;
for (int k = 0; k < n; k++) {
if (k == j) continue;
if (mst[j][i] == mst[k][i]) {
f = false;
break;
}
}
if (f) alreadysep |= (1 << j);
}
}
dp[alreadysep] = 0;
for (int mask = 0; mask < (1 << n); mask++) {
if ((mask & alreadysep) != alreadysep) continue;
int ind;
for (int j = 0; j < n; j++) {
if (!(mask & (1 << j))) {
ind = j;
break;
}
}
if (dp[mask] == INF) continue;
for (int col = 0; col < m; col++) {
int sm = 0, mx = 0, cnt = 0, orv = 0;
for (int which = 0; which < n; which++) {
if (mst[which][col] == mst[ind][col]) {
if (a[which][col] > mx) {
sm += mx;
mx = a[which][col];
} else {
sm += a[which][col];
}
cnt++;
orv |= (1 << which);
}
}
if (cnt > 1) {
dp[mask | orv] = min(dp[mask | orv], dp[mask] + sm);
dp[mask | (1 << ind)] =
min(dp[mask | (1 << ind)], dp[mask] + a[ind][col]);
} else {
dp[mask | (1 << ind)] = min(dp[mask | (1 << ind)], dp[mask]);
}
}
}
printf("%d\n", dp[(1 << n) - 1]);
}
|
#include <bits/stdc++.h>
using namespace std;
int d[1 << 20], sv[30][30], a[30][30], c[30][30];
char str[30][30];
int main() {
int n, m, i, j, k, x, y, lim, mask;
cin >> n >> m;
for (i = 0; i < n; ++i) cin >> str[i];
for (i = 0; i < n; ++i)
for (j = 0; j < m; ++j) cin >> a[i][j];
for (i = 0; i < n; ++i) {
for (j = 0; j < m; ++j) {
x = 0;
for (k = 0; k < n; ++k) {
if (str[i][j] == str[k][j]) {
sv[i][j] |= (1 << k);
c[i][j] += a[k][j];
x = max(x, a[k][j]);
}
}
c[i][j] -= x;
}
}
lim = (1 << n) - 1;
for (i = 0; i <= lim; ++i) d[i] = 1000000007;
d[0] = 0;
for (mask = 1; mask <= lim; ++mask) {
x = 0;
for (i = 0; i < n; ++i) {
if (mask & (1 << i)) {
x = i;
break;
}
}
for (i = 0; i < m; ++i) {
d[mask] = min(d[mask], d[mask & (mask ^ sv[x][i])] + c[x][i]);
d[mask] = min(d[mask], d[mask ^ (1 << x)] + a[x][i]);
}
}
cout << d[lim] << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int max_n = 22, inf = 1111111111;
int n, m, dp[1 << max_n], a[max_n][max_n], nmask[max_n][max_n],
res[max_n][max_n];
string s[max_n];
bool get_bit(int x, int poz) { return (bool)(x & (1 << poz)); }
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];
}
}
for (int poz = 0; poz < n; ++poz) {
for (int i = 0; i < m; ++i) {
int mx = 0;
for (int j = 0; j < n; ++j) {
if (s[poz][i] == s[j][i]) {
res[poz][i] += a[j][i];
mx = max(mx, a[j][i]);
nmask[poz][i] |= (1 << j);
}
}
res[poz][i] -= mx;
}
}
dp[0] = 0;
for (int mask = 1; mask < (1 << n); ++mask) {
int poz;
for (int i = 0; i < n; ++i) {
if (get_bit(mask, i)) {
poz = i;
}
}
dp[mask] = inf;
for (int i = 0; i < m; ++i) {
dp[mask] = min(dp[mask], a[poz][i] + dp[mask ^ (1 << poz)]);
dp[mask] = min(dp[mask], res[poz][i] + dp[mask ^ (mask & nmask[poz][i])]);
}
}
cout << dp[(1 << n) - 1] << endl;
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 = n - 1; i >= 0; i--) {
if ((mask & (1 << i)) != 0) {
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;
const int inf = 1e8;
const int maxn = 20;
int d[1 << (maxn + 1)], a[maxn][maxn];
string s[maxn];
int lowzero(int S) {
for (int i = 0; i < maxn; i++)
if (!((S >> i) & 1)) return i;
return maxn - 1;
}
int main(int argc, char const *argv[]) {
int n, m;
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];
for (int i = (1 << n) - 1; i > 0; i--) d[i] = inf;
d[0] = 0;
int M = 1 << n;
for (int S = 0; S < M; S++) {
int bit = lowzero(S);
for (int c = 0; c < m; c++) {
d[S | (1 << bit)] = min(d[S | (1 << bit)], d[S] + a[bit][c]);
int sum = 0, mw = 0, bits = 0;
for (int r = 0; r < n; r++)
if (s[bit][c] == s[r][c]) {
sum += a[r][c];
mw = max(mw, a[r][c]);
bits |= 1 << r;
}
d[S | bits] = min(d[S | bits], d[S] + sum - mw);
}
}
cout << d[M - 1] << endl;
}
return 0;
}
|
#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]);
}
break;
}
}
}
}
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>
using namespace std;
int n, len;
string s[20];
int cost[21][21];
int c[(1 << 20) + 8];
int mask[21][26];
int sum[21][26];
vector<int> idx[21][26];
void set_min(int& a, int b) { a = min(a, b); }
int main() {
cin >> n >> len;
for (int i = 0; i < n; ++i) {
cin >> s[i];
for (int j = 0; j < len; ++j) {
idx[j][s[i][j] - 'a'].push_back(i);
mask[j][s[i][j] - 'a'] |= (1 << i);
}
}
for (int i = 0; i < n; ++i)
for (int j = 0; j < len; ++j) {
cin >> cost[i][j];
sum[j][s[i][j] - 'a'] += cost[i][j];
}
map<int, int> choices;
auto add_choice = [&](int mask, int cost) {
if (choices.count(mask))
set_min(choices[mask], cost);
else
choices[mask] = cost;
};
for (int i = 0; i < n; ++i)
for (int j = 0; j < len; ++j) {
int c = s[i][j] - 'a';
add_choice(mask[j][c], sum[j][c] - cost[i][j]);
add_choice(1 << i, cost[i][j]);
}
for (int i = 0; i < (1 << n) + 8; ++i) c[i] = 987654321;
c[0] = 0;
for (int handled = 0; handled < (1 << n) - 1; ++handled) {
for (const auto& mask_cost : choices) {
set_min(c[handled | mask_cost.first], c[handled] + mask_cost.second);
}
}
printf("%d\n", c[(1 << n) - 1]);
}
|
#include <bits/stdc++.h>
using namespace std;
const int INF = 0x3f3f3f3f;
char str[100][100];
int f[100][100], dp[1 << 21], sum[100][100];
int statu[100][100];
int main() {
int n, m;
cin >> n >> m;
for (int i = 0; i < n; i++) cin >> str[i];
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++) cin >> f[i][j];
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
int maxv = 0;
for (int 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 (int i = 0; i < (1 << n) - 1; i++) {
for (int j = 0; j < n; j++) {
if ((i & (1 << j)) == 0) {
int a = (1 << j);
for (int 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]);
}
}
}
}
cout << dp[(1 << n) - 1] << endl;
return 0;
}
|
#include <bits/stdc++.h>
#pragma GCC optimize("Ofast", "inline")
using namespace std;
template <class T>
inline void read(T &x) {
int ch = 0, f = 0;
x = 0;
for (; !isdigit(ch); ch = getchar())
if (ch == '-') f = 1;
for (; isdigit(ch); ch = getchar()) x = x * 10 + ch - 48;
if (f) x = -x;
}
const int N = 1 << 20;
char str[21][21];
int a[21][21], B[21][26], sum[21][26], mx[21][26], mn[21], f[N], n, m;
int main() {
read(n), read(m);
for (int i = 1; i <= n; i++) {
scanf("%s", str[i] + 1);
for (int j = 1; j <= m; j++) B[j][str[i][j] - 'a'] |= (1 << (i - 1));
}
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) read(a[i][j]);
mn[i] = a[i][1];
for (int j = 2; j <= m; j++) mn[i] = min(mn[i], a[i][j]);
for (int j = 1; j <= m; j++) {
sum[j][str[i][j] - 'a'] += a[i][j];
mx[j][str[i][j] - 'a'] = max(mx[j][str[i][j] - 'a'], a[i][j]);
}
}
for (int i = 1; i <= m; i++)
for (int j = 0; j < 26; j++) sum[i][j] -= mx[i][j];
memset(f, 0x3f, sizeof(f));
f[0] = 0;
for (int s = 1; s < (1 << n); s++) {
for (int i = 0; i < n; i++)
if ((1 << i) & s) f[s] = min(f[s], f[s ^ (1 << i)] + mn[i + 1]);
for (int i = 1; i <= m; i++)
for (int j = 0; j < 26; j++)
if ((s & B[i][j])) f[s] = min(f[s], f[s ^ (s & B[i][j])] + sum[i][j]);
}
cout << f[(1 << n) - 1];
}
|
#include <bits/stdc++.h>
using namespace std;
const long long mod = 1000000007;
long long dp[(1 << 20)];
int msk;
int cnt[21][30];
long long c[21][30];
long long mxc[21][30];
int chMsk[21][30];
long long g[21][21];
int sm[(1 << 20)];
int main() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
int N, M;
cin >> N >> M;
vector<string> a(N);
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 >> g[i][j];
for (int i = (1 << N) - 1; i >= 0; i--) {
for (int j = 0; j < N; j++) {
if (!(i & (1 << j))) {
sm[i] = j;
break;
}
}
}
for (int i = 0; i < M; i++) {
for (int j = 0; j < N; j++) {
cnt[i][a[j][i] - 'a']++;
chMsk[i][a[j][i] - 'a'] |= (1 << j);
c[i][a[j][i] - 'a'] += g[j][i];
mxc[i][a[j][i] - 'a'] = max(mxc[i][a[j][i] - 'a'], g[j][i]);
}
}
dp[(1 << N) - 1] = 0;
for (int i = (1 << N) - 2; i >= 0; i--) {
dp[i] = INT_MAX;
int k = sm[i];
for (int j = 0; j < M; j++) {
dp[i] = min(dp[i], g[k][j] + dp[i | (1 << k)]);
dp[i] = min(dp[i], c[j][a[k][j] - 'a'] - mxc[j][a[k][j] - 'a'] +
dp[i | chMsk[j][a[k][j] - 'a']]);
}
}
cout << dp[0] << '\n';
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const double pi = acos(-1.0);
const double eps = 1e-11;
void fastIO() {
std::ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
}
char mat[22][22];
int c[22][22];
int tc[22][22];
int cellMask[22][22];
long long dp[1 << 22];
int main() {
fastIO();
int n, m, mxCost, lsb, cnt;
cin >> n >> m;
for (int i = 0; i < (1 << 22); i++) dp[i] = 1000000000;
dp[0] = 0;
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++) cin >> mat[i][j];
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++) {
mxCost = 0;
for (int k = 0; k < n; k++) {
if (mat[i][j] == mat[k][j]) {
mxCost = max(mxCost, c[k][j]);
cellMask[i][j] |= (1 << k);
tc[i][j] += c[k][j];
}
}
tc[i][j] -= mxCost;
}
}
for (int msk = 1; msk < (1 << n); msk++) {
cnt = 0;
lsb = __builtin_ctz(msk);
for (int j = 0; j < m; j++) {
dp[msk] = min(dp[msk], dp[msk ^ (1 << lsb)] + c[lsb][j]);
dp[msk] = min(dp[msk], dp[msk & (msk ^ cellMask[lsb][j])] + tc[lsb][j]);
}
}
cout << dp[(1 << n) - 1] << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int inf = 2e9;
int n, m, w[22][22], dp[1 << 22], same[22][22], cost[22][22];
char g[22][22];
int main() {
scanf("%d%d", &n, &m);
for (register int i = 0; i <= (1 << n); i++) dp[i] = inf;
dp[0] = 0;
for (register int i = 0; i < n; ++i) scanf("%s", &g[i]);
for (register int i = 0; i < n; ++i)
for (register int j = 0; j < m; ++j) scanf("%d", &w[i][j]);
for (register int i = 0; i < n; ++i)
for (register int j = 0; j < m; ++j) {
int sumc = 0, maxc = 0;
for (register 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;
}
for (register int s = 0; s < (1 << n); ++s)
for (register int i = 0; i < n; ++i)
if (!(s >> i & 1))
for (register 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]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int dp[1 << 21], cost[21][21], n, m, cost2[21][21], id[21][21];
char str[21][21];
int main() {
int i, j, k, ans, N, lowbit;
while (scanf("%d%d", &n, &m) != EOF) {
N = 1 << n;
memset(cost2, 0, sizeof(cost2));
memset(id, 0, sizeof(id));
for (i = 0; i < n; i++) scanf("%s", str[i]);
for (i = 0; i < n; i++)
for (j = 0; j < m; j++) scanf("%d", &cost[i][j]);
for (i = 0; i < n; i++)
for (j = 0; j < m; j++) {
int mx = 0;
for (k = 0; k < n; k++)
if (str[i][j] == str[k][j]) {
cost2[i][j] += cost[k][j];
id[i][j] += (1 << k);
mx = max(mx, cost[k][j]);
}
cost2[i][j] -= mx;
}
for (i = 1; i < N; i++) {
dp[i] = 2100000000;
for (j = 0; j < n; j++)
if ((1 << j) & i) {
lowbit = j;
break;
}
for (j = 0; j < m; j++) {
dp[i] = min(dp[i], dp[i ^ (1 << lowbit)] + cost[lowbit][j]);
dp[i] = min(dp[i], dp[i ^ id[lowbit][j] & i] + cost2[lowbit][j]);
}
}
printf("%d\n", dp[N - 1]);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = (1 << 20) + 5, MAXM = 2e6 + 10;
const int INF = INT_MAX, SINF = 0x3f3f3f3f;
const long long llINF = LLONG_MAX;
const int MOD = 1e9 + 7, mod = 998244353;
const int inv2 = 5e8 + 4;
int n, m;
char s[25][25];
long long dp[MAXN], st[25][25], a[25][25], sum[25][25];
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("%lld", &a[i][j]);
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
long long maxn = 0;
for (int k = 1; k <= n; k++) {
if (s[i][j] != s[k][j]) continue;
sum[i][j] += a[k][j];
maxn = max(maxn, a[k][j]);
st[i][j] |= (1 << (k - 1));
}
sum[i][j] -= maxn;
}
}
memset(dp, 0x3f, sizeof(dp));
dp[0] = 0;
for (int sta = 0; sta < (1 << n); sta++) {
for (int i = 1; i <= n; i++)
if (!((1 << (i - 1)) & sta)) {
for (int j = 1; j <= m; j++) {
int tmp1 = (1 << (i - 1)), tmp2 = st[i][j];
dp[sta | tmp1] = min(dp[sta | tmp1], dp[sta] + a[i][j]);
dp[sta | tmp2] = min(dp[sta | tmp2], dp[sta] + sum[i][j]);
}
}
}
printf("%lld", dp[(1 << n) - 1]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
struct fastIO {
inline fastIO operator>>(int& num) {
num = 0;
char c = getchar();
while (c != '-' && (c < '0' || c > '9')) c = getchar();
bool foo = 0;
if (c == '-') {
foo = 1;
c = getchar();
}
while (c >= '0' && c <= '9') {
num = (num << 3) + (num << 1) + c - '0';
c = getchar();
}
if (foo) num = -num;
return *this;
}
inline fastIO operator>>(long long& num) {
num = 0;
char c = getchar();
while (c != '-' && (c < '0' || c > '9')) c = getchar();
bool foo = 0;
if (c == '-') {
foo = 1;
c = getchar();
}
while (c >= '0' && c <= '9') {
num = (num << 3) + (num << 1) + c - '0';
c = getchar();
}
if (foo) num = -num;
return *this;
}
inline fastIO operator>>(float& num) {
scanf("%f", &num);
return *this;
}
inline fastIO operator>>(double& num) {
scanf("%lf", &num);
return *this;
}
inline fastIO operator>>(long double& num) {
scanf("%Lf", &num);
return *this;
}
inline fastIO operator>>(char& num) {
num = getchar();
while (num == ' ' || num == '\n') num = getchar();
return *this;
}
inline fastIO operator>>(char* num) {
int cnt = 0;
char c = getchar();
while (c == ' ' || c == '\n') c = getchar();
while (c != ' ' && c != '\n') {
num[cnt++] = c;
c = getchar();
}
num[cnt] = 0;
return *this;
}
inline fastIO operator>>(string& num) {
cin >> num;
return *this;
}
inline void printInt(const int& num) {
if (num < 10) {
putchar(num + '0');
return;
}
printInt(num / 10);
putchar((num % 10) + '0');
}
inline void printINT(const long long& num) {
if (num < 10) {
putchar(num + '0');
return;
}
printINT(num / 10);
putchar((num % 10) + '0');
}
inline fastIO operator<<(const int& num) {
if (num < 0)
putchar('-'), printInt(-num);
else
printInt(num);
return *this;
}
inline fastIO operator<<(const long long& num) {
if (num < 0)
putchar('-'), printINT(-num);
else
printINT(num);
return *this;
}
inline fastIO operator<<(const float& num) {
printf("%.10f", num);
return *this;
}
inline fastIO operator<<(const double& num) {
printf("%.16lf", num);
return *this;
}
inline fastIO operator<<(const long double& num) {
printf("%.20Lf", num);
return *this;
}
inline fastIO operator<<(const char& num) {
putchar(num);
return *this;
}
inline fastIO operator<<(const char* num) {
for (int i = 0; num[i]; i++) putchar(num[i]);
return *this;
}
inline fastIO operator<<(const string& num) {
cout << num;
return *this;
}
} fio;
int chs[(1 << (21))];
vector<int> hv;
int n, m;
char s[25][25];
int a[25][25];
int dp[(1 << (21))];
int main() {
fio >> n >> m;
for (int i = 0; i < n; i++) {
fio >> s[i];
}
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
fio >> a[i][j];
}
}
memset((void*)chs, 0x3f, sizeof(chs));
for (int i = 0; i < n; i++) {
hv.push_back((1 << (i)));
for (int j = 0; j < m; j++) {
chs[(1 << (i))] = min(chs[(1 << (i))], a[i][j]);
}
}
for (int i = 0; i < m; i++) {
for (int j = 0; j < 26; j++) {
int num = 0, maxx = 0, sum = 0;
for (int k = 0; k < n; k++) {
if (s[k][i] == j + 'a') {
num |= (1 << (k));
maxx = max(maxx, a[k][i]);
sum += a[k][i];
}
}
if (!num) {
continue;
}
if (chs[num] == ((int)0x3f3f3f3f)) {
hv.push_back(num);
}
chs[num] = min(chs[num], sum - maxx);
}
}
memset((void*)dp, 0x3f, sizeof(dp));
dp[0] = 0;
for (int i = 0; i < (1 << (n)) - 1; i++) {
for (int j = 0; j < ((int)(hv).size()); j++) {
dp[i | hv[j]] = min(dp[i | hv[j]], dp[i] + chs[hv[j]]);
}
}
fio << dp[(1 << (n)) - 1] << '\n';
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int pct(int x) { return __builtin_popcount(x); }
int pct(long long x) { return __builtin_popcountll(x); }
int bt(int x) { return 31 - __builtin_clz(x); }
int bt(long long x) { return 63 - __builtin_clzll(x); }
int cdiv(int a, int b) { return a / b + !(a < 0 || a % b == 0); }
long long cdiv(long long a, long long b) {
return a / b + !(a < 0 || a % b == 0);
}
int nxt_C(int x) {
int c = x & -x, r = x + c;
return (((r ^ x) >> 2) / c) | r;
}
long long nxt_C(long long x) {
long long c = x & -x, r = x + c;
return (((r ^ x) >> 2) / c) | r;
}
vector<int> get_bits(int mask) {
vector<int> bb;
while (mask) {
int b = bt(mask);
bb.push_back(b);
mask ^= (1 << b);
}
reverse(bb.begin(), bb.end());
return bb;
}
int get_mask(vector<int> v) {
int mask = 0;
for (int x : v) {
mask ^= (1 << x);
}
return mask;
}
template <typename T>
void uniq(vector<T> &v) {
sort(v.begin(), v.end());
v.resize(unique(v.begin(), v.end()) - v.begin());
}
template <typename T>
void leftShift(vector<T> &v, long long k) {
k %= (int)v.size();
if (k < 0) k += (int)v.size();
rotate(v.begin(), v.begin() + k, v.end());
}
template <typename T>
void rightShift(vector<T> &v, long long k) {
leftShift(v, (int)v.size() - k);
}
mt19937_64 rng(chrono::steady_clock::now().time_since_epoch().count());
long long rand(long long l, long long r) {
uniform_int_distribution<long long> uid(l, r);
return uid(rng);
}
void sc() {}
template <typename Head, typename... Tail>
void sc(Head &H, Tail &...T) {
cin >> H;
sc(T...);
}
string to_string(__int128 x) {
string s = "";
bool neg = 0;
if (x < 0) {
s += "-";
neg = 1;
x = -x;
}
if (!x) s += '0';
while (x) {
int rem = x % 10;
s += to_string(rem);
x /= 10;
}
reverse(s.begin() + neg, s.end());
return s;
}
const int mod = 1e9 + 7;
int pwr(int a, int b) {
int ans = 1;
while (b) {
if (b & 1) ans = (ans * 1LL * a) % mod;
a = (a * 1LL * a) % mod;
b >>= 1;
}
return ans;
}
const int N = 21;
int dp[2][1 << N];
char a[N][N];
int c[N][N];
int cost[N][N];
int maxi[N][N];
int gmask[N][N];
int lg2[1 << N];
void solve() {
int n, m;
sc(n, m);
for (int i = 0; i <= n - 1; i++) {
for (int j = 0; j <= m - 1; j++) {
sc(a[i][j]);
}
}
for (int i = 0; i <= n - 1; i++) {
for (int j = 0; j <= m - 1; j++) {
sc(c[i][j]);
maxi[j][a[i][j] - 'a'] = max(maxi[j][a[i][j] - 'a'], c[i][j]);
gmask[j][a[i][j] - 'a'] ^= (1 << i);
cost[j][a[i][j] - 'a'] += c[i][j];
}
}
int tot = (1 << n) - 1;
for (int mask = 0; mask <= tot; mask++) {
lg2[mask] = bt(mask);
dp[0][mask] = 1e9;
}
char ch;
int b, cmask, val;
dp[0][0] = 0;
for (int i = 0; i <= m - 1; i++) {
int i1 = i & 1, i2 = i1 ^ 1;
for (int j = 0; j <= tot; j++) dp[i2][j] = 1e9;
for (int mask = 0; mask <= tot; mask++) {
cmask = tot ^ mask;
val = dp[i1][mask];
if (val == 1e9) continue;
dp[i2][mask] = min(dp[i2][mask], val);
while (cmask) {
b = lg2[cmask];
cmask ^= (1 << b);
dp[i1][mask | (1 << b)] = min(dp[i1][mask | (1 << b)], val + c[b][i]);
ch = a[b][i];
dp[i1][mask | gmask[i][ch - 'a']] =
min(dp[i1][mask | gmask[i][ch - 'a']],
val + cost[i][ch - 'a'] - maxi[i][ch - 'a']);
}
}
}
cout << dp[(m - 1) & 1][tot] << '\n';
}
signed main() {
ios ::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int t = 1;
for (int tt = 1; tt <= t; tt++) {
solve();
}
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 && (i & (1 << j)); j++)
;
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;
const int N = 22;
int n, m, a[N][N], b[N][N], qwq[N][N], f[1 << N];
char s[N][1000010];
void chkmx(int &x, int y) { (x < y) ? x = y : x = x; }
void chkmn(int &x, int y) { (x > y) ? x = y : x = x; }
int main() {
scanf("%d", &n);
;
scanf("%d", &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++) {
int sum = 0, val = -1;
for (int k = 1; k <= n; k++) {
if (s[i][j] == s[k][j])
sum += a[k][j], chkmx(val, a[i][j]), qwq[i][j] |= (1 << (k - 1));
}
b[i][j] = sum - val;
}
memset(f, 0x3f, sizeof(f));
f[0] = 0;
for (int i = 0; i <= (1 << n) - 1; i++)
for (int j = 1; j <= n; j++)
if (!(i & (1 << (j - 1))))
for (int k = 1; k <= m; k++) {
chkmn(f[i | (1 << (j - 1))], f[i] + a[j][k]),
chkmn(f[i | qwq[j][k]], f[i] + b[j][k]);
}
printf("%d\n", f[(1 << n) - 1]);
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;
}
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.