text stringlengths 49 983k |
|---|
#include <bits/stdc++.h>
using namespace std;
const int N = 131420;
int n, k, x;
vector<int> rem[N];
bool Gao(vector<int> &arr, int lid, int rid, int lv, int rv) {
int s = rid - lid + 1, h = s >> 1;
long long vd = rv - 1LL - lv;
if (s == 0) {
return lv < rv;
}
if (vd < s) {
return 0;
}
if (lv < -h && h < rv) {
for (int i = lid, j = -h; i <= rid; ++i, ++j) {
arr[i] = j;
}
} else {
if (lv >= -h) {
for (int i = lid, j = lv + 1; i <= rid; ++i, ++j) {
arr[i] = j;
}
} else {
for (int i = rid, j = rv - 1; i >= lid; --i, --j) {
arr[i] = j;
}
}
}
return 1;
}
bool Gao(vector<int> &arr) {
int last = 0, value = INT_MIN;
for (int i = 0; i < int(arr.size()); ++i) {
if (arr[i] != INT_MAX) {
if (Gao(arr, last, i - 1, value, arr[i])) {
} else {
return 0;
}
last = i + 1;
value = arr[i];
}
}
if (last < int(arr.size())) {
if (Gao(arr, last, int(arr.size()) - 1, value, INT_MAX)) {
} else {
return 0;
}
}
return 1;
}
int Run() {
while (cin >> n >> k) {
string buff;
assert(n >= k);
for (int i = 0; i < n; ++i) {
cin >> buff;
if (buff[0] == '?') {
rem[i % k].push_back(INT_MAX);
} else {
sscanf(buff.c_str(), "%d", &x);
rem[i % k].push_back(x);
}
}
bool ok = 1;
for (int i = 0; ok && i < k; ++i) {
ok &= Gao(rem[i]);
}
if (ok) {
for (int i = 0; i < n; ++i) {
cout << rem[i % k][i / k] << ' ';
}
cout << endl;
} else {
cout << "Incorrect sequence" << endl;
}
}
return 0;
}
int main() {
ios::sync_with_stdio(0);
return Run();
}
|
#include <bits/stdc++.h>
using namespace std;
int n, k;
int mark[111111 << 2], num[4 * 111111], add;
char str[11];
int getnum(char str[]) {
int ret = 0, neg = -1, i = 1;
if (str[0] != '-') neg = 1, i = 0;
for (; str[i]; i++) {
ret = ret * 10 + str[i] - '0';
}
ret *= neg;
return ret;
}
void init() {
for (int i = 1; i <= add; i++) {
num[i] = -1010000000 + i;
num[add + n + i] = 1010000000 + i;
}
}
int main() {
scanf("%d%d", &n, &k);
add = k;
for (int i = 1; i <= n; i++) {
scanf("%s", str);
if (str[0] == '?')
mark[i + add] = 1;
else
num[i + add] = getnum(str);
}
init();
int flag = 0;
for (int i = 1; i <= k; i++) {
if (flag) break;
int negid = -1, posid = -1;
int lastval = num[i];
for (int j = i + k; j <= n + 2 * add; j += k) {
if (mark[j]) continue;
if (num[j] <= lastval) {
flag = 1;
break;
}
lastval = num[j];
}
if (flag) break;
for (int j = i; j <= n + 2 * add; j += k) {
if (posid == -1 && !mark[j] && num[j] >= 0) {
posid = j;
break;
}
}
for (int j = posid; j >= 1; j -= k) {
if (negid == -1 && !mark[j] && num[j] < 0) {
negid = j;
break;
}
}
for (int j = posid + k; j <= n + 2 * add; j += k) {
int lastid = j - k;
if (!mark[j]) {
if (num[lastid] >= num[j]) flag = 1;
continue;
}
if (flag) break;
mark[j] = 0;
num[j] = num[lastid] + 1;
}
if (flag) break;
for (int j = negid - k; j >= 1; j -= k) {
int lastid = j + k;
if (!mark[j]) {
if (num[j] >= num[lastid]) flag = 1;
continue;
}
if (flag) break;
mark[j] = 0;
num[j] = num[lastid] - 1;
}
int midlen = (posid - negid) / k - 1;
if (midlen > num[posid] - num[negid]) {
flag = 1;
break;
}
int left = -((midlen - 1) / 2);
int right = (midlen) / 2;
if (num[posid] <= right) {
int dis = right - num[posid] + 1;
right -= dis;
left -= dis;
}
if (num[negid] >= left) {
int dis = num[negid] - left + 1;
right += dis;
left += dis;
}
for (int j = negid + k; j < posid; j += k) {
num[j] = left;
left += 1;
}
}
if (flag)
puts("Incorrect sequence");
else {
for (int i = k + 1; i <= k + n; i++) printf("%d ", num[i]);
puts("");
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <typename T>
inline void mx(T& x, const T& y) {
if (x < y) x = y;
}
template <typename T>
inline void mn(T& x, const T& y) {
if (y < x) x = y;
}
template <typename T>
inline int sz(const T& x) {
return (int)x.size();
}
const int UNDEF = 1e9 + 1e7;
const int MAX = 1e9 + 1e6;
const long long INF = 1e18 + 1e6;
long long sum(long long r) {
if (r <= 0) {
return 0;
}
long long l = r + 1;
if (l & 1) {
r >>= 1;
} else {
l >>= 1;
}
return l * r;
}
long long score(long long l, long long r) {
if (l < 0 && r > 0) {
return score(l, 0) + score(0, r);
}
if (l < 0) {
return score(-r, -l);
}
return sum(r) - sum(l - 1);
}
void gen(int l, int r, int count, vector<int>::iterator out) {
if (count % 2 == 1) {
int half = count / 2;
int left = -half;
int right = half;
if (l < left && right < r) {
for (int i = 0; i < (count); ++i) {
*(out++) = left + i;
}
return;
}
} else {
int half = count / 2;
int left1 = -half;
int right1 = half - 1;
if (l < left1 && right1 < r) {
for (int i = 0; i < (count); ++i) {
*(out++) = left1 + i;
}
return;
}
int left2 = -(half - 1);
int right2 = half;
if (l < left2 && right2 < r) {
for (int i = 0; i < (count); ++i) {
*(out++) = left2 + i;
}
return;
}
}
long long way1 = score(l + 1, l + count);
long long way2 = score(r - count, r - 1);
long long minWay = min(way1, way2);
if (way1 == minWay) {
for (int i = 0; i < (count); ++i) {
*(out++) = l + 1 + i;
}
return;
}
if (way2 == minWay) {
for (int i = 0; i < (count); ++i) {
*(out++) = r - count + i;
}
return;
}
}
int main() {
ios_base::sync_with_stdio(false);
int n, k;
cin >> n >> k;
vector<int> a(n);
for (int i = 0; i < (n); ++i) {
string s;
cin >> s;
if (s == "?") {
a[i] = UNDEF;
} else {
a[i] = atoi(s.c_str());
}
}
for (int i = 0; i < (k); ++i) {
vector<int> b;
for (int j = i; j < n; j += k) {
b.push_back(a[j]);
}
b.insert(b.begin(), -MAX);
b.push_back(+MAX);
for (int l = 0; l + 1 < sz(b);) {
int r = l + 1;
while (r < sz(b) && b[r] == UNDEF) {
r++;
}
if (b[r] - b[l] < r - l) {
cout << "Incorrect sequence" << endl;
return 0;
}
gen(b[l], b[r], r - l - 1, b.begin() + l + 1);
l = r;
}
b.erase(b.begin());
b.pop_back();
for (int j = 0; j < (sz(b)); ++j) {
a[i + j * k] = b[j];
}
}
for (int x : a) {
cout << x << ' ';
}
cout << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long INF = (long long)1e10;
void no_ans() {
cout << "Incorrect sequence\n";
exit(0);
}
signed main() {
ios::sync_with_stdio(false);
cin.tie(nullptr);
cout.tie(nullptr);
long long n, k;
cin >> n >> k;
vector<string> arr(n);
for (auto &x : arr) {
cin >> x;
}
vector<long long> res(n);
for (long long i = 0; i < k; i++) {
vector<long long> boba;
for (long long j = i; j < n; j += k) {
if (arr[j] == "?") {
boba.push_back(INF);
} else {
boba.push_back(stoi(arr[j]));
}
}
boba.push_back(INF + 1);
vector<long long> now_res;
long long m = boba.size();
long long prev = -1;
for (long long j = 0; j < m; j++) {
if (boba[j] == INF) {
continue;
}
long long len = j - prev - 1;
long long a = (prev == -1 ? -INF : boba[prev]);
long long b = boba[j];
if (b - a - 1 < len) {
no_ans();
}
if (a <= 0 && b <= 0) {
for (long long r = b - len; r < b; r++) {
now_res.push_back(r);
}
} else if (a >= 0 && b >= 0) {
for (long long r = a + 1; r < a + 1 + len; r++) {
now_res.push_back(r);
}
} else if (len > 0) {
long long l = -((len - 1) / 2);
long long r = len / 2;
while (a >= l) {
l++;
r++;
}
while (b <= r) {
r--;
l--;
}
for (long long t = l; t <= r; t++) {
now_res.push_back(t);
}
}
now_res.push_back(b);
prev = j;
}
long long cnt = 0;
for (long long j = i; j < n; j += k) {
res[j] = now_res[cnt];
cnt++;
}
}
for (auto x : res) {
cout << x << " ";
}
cout << '\n';
}
|
#include <bits/stdc++.h>
using namespace std;
long long v[100100], s[100100];
int n, k, len, a[100100], b[100100];
char second[30];
int main() {
cin >> n >> k;
for (int i = 1; i <= n; ++i) {
cin >> second;
if (second[0] == '?')
b[i] = 1;
else {
int r = strlen(second);
int semn = 1;
for (register int j = 0; j < r; ++j) {
if (j == 0 && second[j] == '-') {
semn = -1;
continue;
}
v[i] = v[i] * 10 + second[j] - '0';
}
v[i] *= semn;
}
}
for (int i = 1; i <= k; ++i) {
int t = 0;
for (int j = i; j <= n; j += k) {
++t;
a[t] = 0;
if (b[j]) a[t] = b[j];
s[t] = v[j];
}
int p = 1;
long long mi = -1100000001;
for (int j = 1; j <= t; ++j) {
int p = j;
while (a[j] && j <= t) ++j;
if (j == t + 1 && a[j - 1]) {
--j;
if (mi < 0) {
len = j - p + 1;
len /= 2;
len = -len;
if (mi + 1 > len) len = mi + 1;
for (int k = p; k <= j; ++k) s[k] = len++;
} else
for (int k = p; k <= j; ++k) s[k] = ++mi;
break;
}
if (j == p) {
mi = s[j];
continue;
}
if (s[j] >= 0) {
if (mi >= 0) {
for (int k = p; k <= j - 1; ++k) s[k] = ++mi;
} else {
len = j - 1 - p + 1;
len /= 2;
len = -len;
if (mi + 1 > len) len = mi + 1;
if (len + j - 1 - p >= s[j]) len -= len + j - 1 - p - s[j] + 1;
for (int k = p; k <= j - 1; ++k) s[k] = len++;
}
mi = s[j];
} else {
len = j - 1 - p + 1;
mi = s[j] - len - 1;
for (int k = p; k <= j - 1; ++k) s[k] = ++mi;
mi = s[j];
}
}
t = 0;
for (int j = i; j <= n; j += k) {
++t;
v[j] = s[t];
}
}
for (int i = k + 1; i <= n; ++i)
if (v[i] <= v[i - k]) {
cout << "Incorrect sequence";
return 0;
}
for (int i = 1; i <= n; ++i) cout << v[i] << " ";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
ostream& operator<<(ostream& out, vector<int> v) {
for (auto a : v) out << a << " ";
return out;
}
ostream& operator<<(ostream& out, pair<int, int> d) {
out << d.first << ", " << d.second << " ";
return out;
}
pair<int, int> operator-(pair<int, int> A, pair<int, int> B) {
return make_pair((A.first - B.first), (A.second - B.second));
}
pair<int, int> operator+(pair<int, int> A, pair<int, int> B) {
return make_pair((A.first + B.first), (A.second + B.second));
}
bool is_valid(vector<int>& v) {
int n = v.size();
vector<pair<int, int> > d;
for (int i = 0; i < n; i++) {
if (v[i] != 2 * (1e9)) {
d.push_back(make_pair((i), (v[i])));
}
}
for (int i = 1; i < d.size(); i++) {
pair<int, int> L = d[i - 1];
pair<int, int> R = d[i];
int diff = R.first - L.first;
if (L.second + diff > R.second) {
return false;
}
}
int m = d.size();
if (m == 0) {
vector<int> t;
t.push_back(0);
if (t.size() < n) {
for (int i = 1;; i++) {
t.push_back(-i);
if (t.size() == n) break;
t.push_back(i);
if (t.size() == n) break;
}
}
sort((t).begin(), (t).end());
copy((t).begin(), (t).end(), v.begin());
return true;
}
if (d[0].first > 0) {
if (d[0].second > 0) {
int count = d[0].first;
vector<int> t;
t.push_back(0);
if (t.size() < count) {
for (int i = 1;; i++) {
t.push_back(-i);
if (t.size() == count) break;
if (i < d[0].second) t.push_back(i);
if (t.size() == count) break;
}
}
sort((t).begin(), (t).end());
copy((t).begin(), (t).end(), v.begin());
} else {
int val = d[0].second - 1;
for (int i = d[0].first - 1; i >= 0; i--) {
v[i] = val--;
}
}
}
if (d[m - 1].first < n - 1) {
if (d[m - 1].second < 0) {
int count = n - d[m - 1].first - 1;
vector<int> t;
t.push_back(0);
if (t.size() < count) {
for (int i = 1;; i++) {
if (d[m - 1].second < -i) t.push_back(-i);
if (t.size() == count) break;
t.push_back(i);
if (t.size() == count) break;
}
}
sort((t).begin(), (t).end());
copy((t).begin(), (t).end(), v.begin() + d[m - 1].first + 1);
} else {
int val = d[m - 1].second + 1;
for (int i = d[m - 1].first + 1; i < n; i++) {
v[i] = val++;
}
}
}
for (int i = 1; i < d.size(); i++) {
pair<int, int> L = d[i - 1];
pair<int, int> R = d[i];
if (L.first + 1 == R.first) continue;
if (0 <= L.second) {
int val = L.second + 1;
for (int j = L.first + 1; j < R.first; j++) {
v[j] = val++;
}
} else if (R.second <= 0) {
int val = R.second - 1;
for (int j = R.first - 1; j > L.first; j--) {
v[j] = val--;
}
} else {
int count = R.first - L.first - 1;
vector<int> t;
t.push_back(0);
if (t.size() < count) {
for (int i = 1;; i++) {
if (L.second < -i) t.push_back(-i);
if (t.size() == count) break;
if (i < R.second) t.push_back(i);
if (t.size() == count) break;
}
}
sort((t).begin(), (t).end());
copy((t).begin(), (t).end(), v.begin() + L.first + 1);
}
}
return true;
}
bool is_valid(vector<vector<int> >& v) {
for (auto& a : v) {
if (!is_valid(a)) return false;
}
return true;
}
int main() {
int n, k;
cin >> n >> k;
vector<vector<int> > v(k);
for (int i = 0; i < n; i++) {
string s;
cin >> s;
if (s == "?")
v[i % k].push_back(2 * (1e9));
else {
stringstream ss(s);
int a;
ss >> a;
v[i % k].push_back(a);
}
}
if (!is_valid(v)) {
cout << "Incorrect sequence" << endl;
} else {
for (int i = 0; i < n; i++) {
cout << v[i % k][i / k] << " ";
}
cout << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int INF = 0x3f3f3f3f;
const int maxn = 21;
const int maxs = 1 << 21;
int n, m;
int a[maxn][maxn];
char str[maxn][maxn];
int dp[maxs];
int lowzero(int s) {
for (int i = 0; i < maxn; ++i) {
if (!(s & (1 << i))) return i;
}
return maxn - 1;
}
int main() {
while (~scanf("%d%d", &n, &m)) {
for (int i = 0; i < n; ++i) {
scanf("%s", str[i]);
}
for (int i = 0; i < n; ++i) {
for (int j = 0; j < m; ++j) {
scanf("%d", &a[i][j]);
}
}
memset(dp, 0xff, sizeof(dp));
dp[0] = 0;
int M = 1 << n;
for (int s = 0; s < M; ++s) {
if (dp[s] == -1) continue;
int bit = lowzero(s);
for (int j = 0; j < m; ++j) {
if (dp[s | (1 << bit)] == -1 ||
dp[s | (1 << bit)] > dp[s] + a[bit][j]) {
dp[s | (1 << bit)] = dp[s] + a[bit][j];
}
int sum = 0, bits = 0, mw = 0;
for (int i = 0; i < n; ++i) {
if (str[i][j] == str[bit][j]) {
sum += a[i][j];
mw = max(mw, a[i][j]);
bits |= 1 << i;
}
}
if (dp[s | bits] == -1 || dp[s | bits] > dp[s] + sum - mw) {
dp[s | bits] = dp[s] + sum - mw;
}
}
}
printf("%d\n", dp[M - 1]);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 20 + 2;
const int INF = 0x3f3f3f3f;
int n, m;
int a[maxn][maxn];
string str[maxn];
int dp[1 << maxn];
void DP() {
memset(dp, INF, sizeof(dp));
dp[0] = 0;
for (int i = 0; i < (1 << n); i++) {
int pos;
for (int j = 0; j < n; j++)
if (!((i >> j) & 1)) {
pos = j;
break;
}
for (int j = 0; j < m; j++) {
int cur = i + (1 << pos);
dp[cur] = min(dp[cur], dp[i] + a[pos][j]);
int now = cur, sum = 0, mx = 0;
for (int k = 0; k < n; k++)
if (str[pos][j] == str[k][j]) {
now |= 1 << k;
sum += a[k][j];
mx = max(mx, a[k][j]);
}
dp[now] = min(dp[now], dp[i] + sum - mx);
}
}
}
int main() {
scanf("%d%d", &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++) scanf("%d", &a[i][j]);
DP();
printf("%d", dp[(1 << n) - 1]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m;
char s[25][25];
int c[25][25];
int chs[1 << 21];
int dp[1 << 21];
vector<int> hv;
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", c[i] + j);
}
}
memset(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], c[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, c[k][i]);
sum += c[k][i];
}
}
if (!num) {
continue;
}
if (chs[num] == 0x3f3f3f3f) {
hv.push_back(num);
}
chs[num] = min(chs[num], sum - maxx);
}
}
memset(dp, 0x3f, sizeof(dp));
dp[0] = 0;
for (int i = 0; i < (1 << n) - 1; ++i) {
for (int j : hv) {
dp[i | j] = min(dp[i | j], dp[i] + chs[j]);
}
}
printf("%d\n", dp[(1 << n) - 1]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int M = 1 << 20, INF = 2e9;
int dp[M], n, m, cost[25][25];
char s[25][25];
void Min(int &a, int b) {
if (a > b) a = b;
}
void rd(int &res) {
char c;
res = 0;
while (c = getchar(), !isdigit(c))
;
do res = (res << 3) + (res << 1) + (c ^ 48);
while (c = getchar(), isdigit(c));
}
int find(int string) {
for (int i = 0; i < n; i++)
if (!(string & (1 << i))) return i;
return n - 1;
}
int main() {
rd(n);
rd(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++) rd(cost[i][j]);
for (int string = 1; string < 1 << n; string++) dp[string] = INF;
for (int string = 0; string + 1 < 1 << n; string++) {
int had = find(string);
for (int c = 0; c < m; c++) {
Min(dp[string | (1 << had)], dp[string] + cost[had][c]);
int sum = 0, mx = 0, nw = 0;
for (int r = 0; r < n; r++)
if (s[had][c] == s[r][c]) {
sum += cost[r][c];
mx = max(mx, cost[r][c]);
nw |= 1 << r;
}
Min(dp[string | nw], dp[string] + sum - mx);
}
}
printf("%d", dp[(1 << n) - 1]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
char str[110][110];
int num[110][110], sta[110][110], sum[110][110], f[2000010], n, m;
int main() {
scanf("%d%d", &n, &m);
for (int i = 1; i <= n; i++) scanf("%s", str[i] + 1);
for (int i = 1; i <= n; i++)
for (int j = 1; j <= m; j++) scanf("%d", &num[i][j]);
for (int i = 1; i <= n; i++)
for (int j = 1; j <= m; j++) {
int mx = 0;
for (int k = 1; k <= n; k++)
if (str[i][j] == str[k][j])
sta[i][j] |= 1 << (k - 1), mx = max(mx, num[k][j]),
sum[i][j] += num[k][j];
sum[i][j] -= mx;
}
for (int i = 1; i < (1 << n); i++) f[i] = 1000000000;
for (int i = 0; i < (1 << n); i++)
for (int j = 1; j <= n; j++)
if (!((i >> (j - 1)) & 1))
for (int k = 1; k <= m; k++) {
f[i | (1 << (j - 1))] = min(f[i | (1 << (j - 1))], f[i] + num[j][k]);
f[i | sta[j][k]] = min(f[i | sta[j][k]], f[i] + sum[j][k]);
}
printf("%d\n", f[(1 << n) - 1]);
}
|
#include <bits/stdc++.h>
using namespace std;
inline int in() {
int x;
scanf("%d", &x);
return x;
}
const int N = 21;
const int M = (1 << 21);
const int MOD = 1e9 + 7;
const long double eps = 1e-12;
int dp[M], n, m;
string s[N];
int a[N][N], c[N][N], mask[N][N];
int main() {
n = in(), m = in();
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]) {
c[i][j] += a[k][j];
mask[i][j] |= (1 << k);
mx = max(mx, a[k][j]);
}
}
c[i][j] -= mx;
}
for (int i = 0; i < M; i++) dp[i] = MOD;
dp[0] = 0;
for (int i = 1; i < (1 << n); i++) {
int f = 0;
for (int j = 0; j < n; j++)
if ((1 << j) & i) {
f = j;
break;
}
for (int j = 0; j < m; j++) {
dp[i] = min(dp[i], dp[i ^ (mask[f][j] & i)] + c[f][j]);
dp[i] = min(dp[i], dp[i ^ (1 << f)] + a[f][j]);
}
}
cout << dp[(1 << n) - 1];
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m;
string s[29];
long long cost[29][29];
long long dp[22][(1 << 20)];
long long bt(int i, int mask) {
if (mask + 1 == (1 << n)) return 0;
if (i == n) return 1e13;
if (dp[i][mask] != -1) return dp[i][mask];
if (mask & (1 << i)) return dp[i][mask] = bt(i + 1, mask);
long long ret = 1e13;
for (int f = 0; f < m; f++) {
ret = min(ret, cost[i][f] + bt(i + 1, mask | (1 << i)));
int temp = mask;
long long co = 0, maxi = 0;
for (int f1 = 0; f1 < n; f1++) {
if (s[i][f] != s[f1][f]) continue;
temp |= (1 << f1);
maxi = max(maxi, cost[f1][f]);
co += cost[f1][f];
}
ret = min(ret, co - maxi + bt(i + 1, temp));
}
return dp[i][mask] = ret;
}
int main() {
memset(dp, -1, sizeof dp);
cin >> n >> m;
for (int f = 0; f < n; f++) cin >> s[f];
for (int f = 0; f < n; f++)
for (int f1 = 0; f1 < m; f1++) cin >> cost[f][f1];
int mask = 0;
for (int f = 0; f < m; f++) {
for (int f1 = 0; f1 < n; f1++) {
bool flag = 0;
for (int f2 = 0; f2 < n; f2++) {
if (f1 == f2) continue;
if (s[f1][f] == s[f2][f]) flag = 1;
}
if (!flag) mask |= (1 << f1);
}
}
cout << bt(0, mask) << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
int cost[22][27];
int occ[22][27];
int keep[22][27];
int mem[(1 << 22) + 10];
int N, M;
char str[22][22];
int A[22][22];
int min_cost(int sel) {
int &val = mem[sel];
if (val >= 0) return val;
int i, k;
val = 0;
if (sel >= (1 << N) - 1) return 0;
val = (1e9);
for (k = 0; k < N; ++k)
if (!(sel & (1 << k))) break;
for (i = 0; i < M; ++i) {
val = min(val, min_cost(sel | occ[i][str[k][i] - 'a']) +
cost[i][str[k][i] - 'a'] - keep[i][str[k][i] - 'a']);
val = min(val, min_cost(sel | (1 << k)) + A[k][i]);
}
return val;
}
int main() {
int i;
scanf("%d%d", &N, &M);
for (i = 0; i < N; ++i) {
scanf("%s", str[i]);
}
int j;
for (i = 0; i < N; ++i) {
for (j = 0; j < M; ++j) {
scanf("%d", &A[i][j]);
cost[j][str[i][j] - 'a'] += A[i][j];
occ[j][str[i][j] - 'a'] |= (1 << i);
keep[j][str[i][j] - 'a'] = max(keep[j][str[i][j] - 'a'], A[i][j]);
}
}
memset(mem, -1, sizeof(mem));
printf("%d\n", min_cost(0));
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int INF = int(1e9);
const long long INFll = 1ll * INF * INF;
const int MOD = 1000000007;
char a[50][50];
int cost[50][50];
int f[1048700];
int cnt[50][50];
int mask[50][50];
int main() {
cin.tie(0);
ios_base::sync_with_stdio(0);
int n, m;
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 = 1; i < (1 << n); ++i) f[i] = INF;
for (int i = 0; i < m; ++i) {
for (int c = 0; c < 26; ++c) {
int tmp = -1;
for (int j = 0; j < n; ++j)
if (a[j][i] - 'a' == c)
mask[i][c] |= (1 << j), cnt[i][c] += cost[j][i],
tmp = max(tmp, cost[j][i]);
cnt[i][c] -= tmp;
}
}
for (int i = 0; i < (1 << n) - 1; ++i) {
int num = -1;
for (int j = 0; j < n; ++j)
if (!(i & (1 << j))) {
num = j;
break;
}
for (int j = 0; j < m; ++j) {
f[i | (1 << num)] = min(f[i | (1 << num)], f[i] + cost[num][j]);
f[i | mask[j][a[num][j] - 'a']] =
min(f[i | mask[j][a[num][j] - 'a']], f[i] + cnt[j][a[num][j] - 'a']);
}
}
cout << f[(1 << n) - 1];
;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
inline long long int modadd(long long int n, long long int m,
long long int p = 1000000007) {
return ((n + m) % p + p) % p;
}
inline long long int modsub(long long int n, long long int m,
long long int p = 1000000007) {
return ((n - m + p) % p + p) % p;
}
inline long long int modpro(long long int n, long long int m,
long long int p = 1000000007) {
return (((n % p) * (m % p)) % p + p) % p;
}
unsigned long long int powe(long long int first, long long int second) {
unsigned long long int res = 1;
while (second > 0) {
if (second & 1) res = res * first;
second = second >> 1;
first = first * first;
}
return res;
}
long long int modpow(long long int first, long long int second,
long long int p = 1000000007) {
long long int res = 1;
while (second > 0) {
if (second & 1) res = modpro(res, first, p);
second = second >> 1;
first = modpro(first, first, p);
}
return res;
}
inline long long int modInverse(long long int n, long long int p = 1000000007) {
if (n == 1) return 1;
return modpow(n, p - 2, p);
}
inline long long int moddiv(long long int n, long long int m,
long long int p = 1000000007) {
return modpro(n, modInverse(m, p), p);
}
inline long long int modadd3(long long int first, long long int second,
long long int z, long long int p = 1000000007) {
return modadd(modadd(first, second, p), z, p);
}
inline long long int modadd4(long long int first, long long int second,
long long int z, long long int w,
long long int p = 1000000007) {
return modadd(modadd(first, second, p), modadd(z, w, p), p);
}
inline long long int modnCr(long long int fac[], int n, int r,
long long int p = 1000000007) {
if (r == 0) return 1;
return modpro(fac[n], modInverse(modpro(fac[r], fac[n - r], p), p), p);
}
template <typename T>
inline T max3(T first, T second, T z) {
return max(max(first, second), z);
}
template <typename T>
inline T max4(T first, T second, T z, T w) {
return max(max3(first, second, w), z);
}
template <typename T>
inline T min3(T first, T second, T z) {
return min(min(first, second), z);
}
template <typename T>
inline T min4(T first, T second, T z, T w) {
return min(min3(first, second, w), z);
}
template <typename T>
void printArr(T *arr, int s, int n) {
for (int i = s; i <= n; i++) {
cout << arr[i] << " ";
}
cout << endl;
}
long long int dp[(1 << 20)];
long long int a[22][22];
string s[22];
long long int mm[22][22], c[22][22];
int main() {
std::ios::sync_with_stdio(false);
cin.tie(NULL);
int erer = 1;
for (int erer2 = (1); erer2 < (erer + 1); erer2++) {
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 < (m); i++) {
for (int j = (0); j < (n); j++) {
long long int big = -1;
for (int k = (0); k < (n); k++) {
if (s[j][i] == s[k][i]) {
c[j][i] += a[k][i];
big = max(big, a[k][i]);
mm[j][i] |= (1 << k);
}
}
c[j][i] -= big;
}
}
for (int mask = (0); mask < ((1 << n)); mask++) dp[mask] = INT_MAX;
dp[0] = 0;
for (int mask = (1); mask < ((1 << n)); mask++) {
int mi = -1;
for (int i = (0); i < (n); i++) {
if (mask & (1 << i)) {
mi = i;
break;
}
}
for (int i = (0); i < (m); i++) {
dp[mask] = min(dp[mask], dp[mask ^ (1 << mi)] + a[mi][i]);
dp[mask] = min(dp[mask], dp[mask & (mask ^ mm[mi][i])] + c[mi][i]);
}
}
cout << dp[(1 << n) - 1];
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long OO = 1e8;
const long long OOL = 1e18;
const long long MOD = 1e9 + 7;
const double EPS = (1e-7);
int dcmp(double x, double y) { return fabs(x - y) <= EPS ? 0 : x < y ? -1 : 1; }
unsigned long long gcd(unsigned long long a, unsigned long long b) {
return (b == 0 ? a : gcd(b, a % b));
}
unsigned long long lcm(unsigned long long a, unsigned long long b) {
return (a * (b / gcd(a, b)));
}
unsigned long long power(unsigned long long a, unsigned long long b) {
if (b == 0) return 1;
unsigned long long ans = power(a, b / 2);
ans = ans * ans;
if (b % 2 != 0) ans *= a;
return ans;
}
int n, m;
string s[20];
int memo[1 << 20];
pair<int, int> same[20][20];
int arr[20][20];
int memo2[1 << 20];
int firstbit(int mask) {
int &ret = memo2[mask];
if (ret != -1) return ret;
for (int i = 0; i < (int)(n); ++i)
if (!(mask & (1 << i))) return ret = i;
return 0;
}
int dp(int mask) {
if (mask == ((1 << n) - 1)) return 0;
int &ret = memo[mask];
if (ret != -1) return ret;
int mini = OO;
int i = firstbit(mask);
for (int c = 0; c < (int)(m); ++c) {
mini = min(mini, same[i][c].first + dp(mask | same[i][c].second));
mini = min(mini, arr[i][c] + dp(mask | (1 << i)));
}
return ret = mini;
}
int main() {
ios::sync_with_stdio(false);
memset(memo, -1, sizeof(memo));
memset(memo2, -1, sizeof(memo2));
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 >> arr[i][j];
for (int i = 0; i < (int)(n); ++i) {
for (int j = 0; j < (int)(m); ++j) {
vector<int> v;
int cnt = 0;
int mask = 0;
for (int k = 0; k < (int)(n); ++k) {
if (s[i][j] == s[k][j]) {
v.push_back(arr[k][j]);
cnt += arr[k][j];
mask |= (1 << k);
}
}
sort(((v).begin()), ((v).end()));
same[i][j] = make_pair(cnt - v.back(), mask);
}
}
cout << dp(0) << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int cost[21][21], dp[1 << 21];
string a[21];
int main() {
memset(dp, 0x3f, sizeof(dp));
int n, m, i, j, k;
cin >> n >> m;
for (i = 0; i < n; ++i) cin >> a[i];
for (i = 0; i < n; ++i)
for (j = 0; j < m; ++j) cin >> cost[i][j];
dp[0] = 0;
for (i = 0; i < (1 << n) - 1; ++i) {
if (dp[i] >= 0x3f3f3f3f) continue;
int x, cur, sum, maxi, nex;
for (x = 0; x < n; ++x)
if (!(i & (1 << x))) break;
cur = i + (1 << x);
for (j = 0; j < m; ++j) {
dp[cur] = min(dp[cur], dp[i] + cost[x][j]);
sum = 0, maxi = 0;
nex = cur;
for (k = 0; k < n; ++k)
if (a[k][j] == a[x][j]) {
nex |= 1 << k;
maxi = max(maxi, cost[k][j]);
sum += cost[k][j];
}
dp[nex] = min(dp[nex], dp[i] + sum - maxi);
}
}
cout << dp[(1 << n) - 1] << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
template <class T, class L>
bool smax(T& x, L y) {
return x < y ? (x = y, 1) : 0;
}
template <class T, class L>
bool smin(T& x, L y) {
return x > y ? (x = y, 1) : 0;
}
const int maxn = 20;
int dp[1 << maxn], n, m, cost[maxn][maxn];
string s[maxn];
int gang[maxn][maxn], co[maxn][maxn];
int main() {
ios::sync_with_stdio(0), cin.tie(0);
memset(dp, 63, sizeof dp);
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];
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++) {
int all = 0, big = 0;
for (int k = 0; k < n; k++)
if (s[i][j] == s[k][j])
gang[i][j] |= 1 << k, all += cost[k][j], smax(big, cost[k][j]);
co[i][j] = all - big;
}
dp[0] = 0;
for (int mask = 1; mask < 1 << n; mask++) {
int idx = __builtin_ctz(mask);
for (int i = 0; i < m; i++)
smin(dp[mask], min(cost[idx][i] + dp[mask ^ (1 << idx)],
co[idx][i] + dp[mask ^ (mask & gang[idx][i])]));
}
cout << dp[(1 << n) - 1] << '\n';
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m, Sum;
int cost[50][50], f[1 << 20], to[50][50], sum[50][50];
char s[50][50];
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", &cost[i][j]);
for (int i = 1; i <= n; i++)
for (int j = 1; j <= m; j++) {
to[i][j] = 1 << (i - 1);
for (int k = 1; k <= n; k++)
if (i != k && s[i][j] == s[k][j])
to[i][j] |= 1 << (k - 1), sum[i][j] += cost[k][j];
}
memset(f, 0x7f, sizeof(f));
f[0] = 0;
Sum = 1 << n;
for (int j = 1; j <= m; j++)
for (int now = 0; now < Sum; now++)
if (f[now] != 0x7f7f7f7f)
for (int i = 1; i <= n; i++)
f[now | 1 << (i - 1)] =
min(f[now | 1 << (i - 1)], f[now] + cost[i][j]),
f[now | to[i][j]] =
min(f[now | to[i][j]], f[now] + sum[i][j]);
printf("%d", f[Sum - 1]);
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAX = 20;
const int INF = 0x3f3f3f3f;
int n, m;
int a[30][30];
char s[30][30];
int dp[1 << (MAX + 1)];
int I(int S) {
for (int i = 0; i < MAX; i++)
if (!((S >> i) & 1)) return i;
return MAX - 1;
}
int main() {
scanf("%d%d", &n, &m);
for (int i = 0; i < n; i++) scanf("%s", s[i]);
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++) scanf("%d", &a[i][j]);
memset(dp, 0x3f, sizeof(dp));
dp[0] = 0;
for (int S = 0; S < 1 << n; S++) {
int bit = I(S);
for (int j = 0; j < m; j++) {
dp[S | 1 << bit] = min(dp[S | 1 << bit], dp[S] + a[bit][j]);
int sum = 0, bits = 0, mx = -1;
for (int i = 0; i < n; i++) {
if (s[bit][j] == s[i][j]) {
sum += a[i][j];
mx = max(mx, a[i][j]);
bits |= 1 << i;
}
}
dp[S | bits] = min(dp[S | bits], dp[S] + sum - mx);
}
}
printf("%d\n", dp[(1 << n) - 1]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int INF = 0x3f3f3f3f;
const int maxn = 21;
const int maxs = 1 << 21;
int n, m;
int a[maxn][maxn];
char str[maxn][maxn];
int dp[maxs];
int lowzero(int s) {
for (int i = 0; i < maxn; ++i) {
if (!(s & (1 << i))) return i;
}
return maxn - 1;
}
int main() {
while (~scanf("%d%d", &n, &m)) {
for (int i = 0; i < n; ++i) {
scanf("%s", str[i]);
}
for (int i = 0; i < n; ++i) {
for (int j = 0; j < m; ++j) {
scanf("%d", &a[i][j]);
}
}
memset(dp, INF, sizeof(dp));
dp[0] = 0;
int M = 1 << n;
for (int s = 0; s < M; ++s) {
int bit = lowzero(s);
for (int j = 0; j < m; ++j) {
dp[s | (1 << bit)] = min(dp[s | (1 << bit)], dp[s] + a[bit][j]);
int sum = 0, bits = 0, mw = 0;
for (int i = 0; i < n; ++i) {
if (str[i][j] == str[bit][j]) {
sum += a[i][j];
mw = max(mw, a[i][j]);
bits |= 1 << i;
}
}
dp[s | bits] = min(dp[s | bits], dp[s] + sum - mw);
}
}
printf("%d\n", dp[M - 1]);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 29, oo = (1 << 30) - 1;
int f[1 << 20], A[N][N], M[N][N], C[N][N], Lg[1 << 20];
int n, m;
char s[N][N];
int main() {
scanf("%d%d", &n, &m);
for (int i = 0; i < n; i++) Lg[1 << i] = i;
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 &m = M[i][j], &c = C[i][j], Max = 0;
for (int k = 0; k < n; k++)
if (s[i][j] == s[k][j])
m |= 1 << k, c += A[k][j], Max = max(Max, A[k][j]);
c -= Max;
}
memset(f, 64, sizeof(f));
f[0] = 0;
for (int i = 0; i < m; i++)
for (int t = 0; t < (1 << n) - 1; t++)
if (f[t] < oo)
for (int x = 0; x < n; x++)
if (!(t >> x & 1))
f[t | 1 << x] = min(f[t | 1 << x], f[t] + A[x][i]),
f[t | M[x][i]] = min(f[t | M[x][i]], f[t] + C[x][i]);
printf("%d\n", f[(1 << n) - 1]);
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 21;
const int M = 1e6 + 50;
const int INF = 0x3f3f3f3f;
double eps = 1e-6;
char str[N][N];
int a[N][N], s[N][N], c[N][N];
int dp[1 << N];
int 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", &a[i][j]);
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++) {
int maxv = -1;
for (int k = 0; k < n; k++)
if (str[i][j] == str[k][j]) {
maxv = max(maxv, a[k][j]);
s[i][j] |= 1 << k;
c[i][j] += a[k][j];
}
c[i][j] -= maxv;
}
memset(dp, INF, sizeof(dp));
dp[0] = 0;
for (int st = 0; st < (1 << n); st++) {
for (int j = 0; j < n; j++)
if (!(st & (1 << j))) {
for (int i = 0; i < m; i++) {
dp[st | (1 << j)] = min(dp[st | (1 << j)], dp[st] + a[j][i]);
dp[st | s[j][i]] = min(dp[st | s[j][i]], dp[st] + c[j][i]);
}
}
}
printf("%d\n", dp[(1 << n) - 1]);
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, bb, 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];
bb = (1 << b);
cmask ^= bb;
dp[i1][mask | bb] = min(dp[i1][mask | bb], 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 int Maxn = 22, INF = INT_MAX >> 1;
int n, m, a[Maxn][Maxn], d[1 << Maxn];
char s[Maxn][Maxn];
int findlowzero(int x) {
int i;
for (i = 0; i < Maxn; i++)
if (!((x >> i) & 1)) return i;
return 19;
}
int main(int argc, const char* argv[]) {
ios::sync_with_stdio(0);
int i, j, k;
cin >> n >> m;
for (i = 0; i < n; i++) cin >> s[i];
for (i = 0; i < n; i++)
for (j = 0; j < m; j++) cin >> a[i][j];
int Max = 1 << n;
for (i = 1; i < Max; i++) d[i] = INF;
for (i = 0; i < Max; i++) {
int tmp = findlowzero(i);
for (j = 0; j < m; j++) {
d[i | (1 << tmp)] = min(d[i | (1 << tmp)], d[i] + a[tmp][j]);
int sum = 0, mx = 0, bits = 0;
for (k = 0; k < n; k++)
if (s[tmp][j] == s[k][j]) {
sum += a[k][j];
mx = max(mx, a[k][j]);
bits |= (1 << k);
}
d[i | bits] = min(d[i | bits], d[i] + sum - mx);
}
}
cout << d[(1 << n) - 1] << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
inline void solve();
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
solve();
}
int dp[1 << 20];
string s[int(25)];
int a[int(25)][int(25)];
int gr[int(25)][int(25)];
int c[int(25)][int(25)];
void solve() {
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 mx = 0;
for (int k = 0; k < n; k++) {
if (s[i][j] == s[k][j]) {
c[i][j] += a[k][j];
mx = max(mx, a[k][j]);
gr[i][j] |= (1 << k);
}
}
c[i][j] -= mx;
}
for (int i = 1; i < (1 << n); i++) dp[i] = int(1e9);
for (int mask = 1; mask < (1 << n); mask++) {
int i = -1;
for (int j = 0; j < n; j++)
if ((mask >> j) & 1) {
i = j;
break;
}
for (int j = 0; j < m; j++) {
dp[mask] = min(dp[mask], dp[mask ^ (1 << i)] + a[i][j]);
dp[mask] = min(dp[mask], dp[mask & (mask ^ gr[i][j])] + c[i][j]);
}
}
cout << dp[(1 << n) - 1];
}
|
#include <bits/stdc++.h>
using namespace std;
using namespace std;
const int N = 20;
const int leng = 300;
string s[N];
int cost[N][leng], c[N][leng], sv[N][leng], a[N][leng];
int d[1 << N];
int main() {
int n, m;
cin >> n >> m;
for (int i = 0; i < int(n); i++) cin >> s[i];
for (int i = 0; i < int(n); i++)
for (int j = 0; j < int(m); j++) cin >> a[i][j];
for (int i = 0; i < int(n); i++) {
for (int j = 0; j < int(m); j++) {
int curv = 0;
for (int k = 0; k < int(n); k++) {
if (s[i][j] == s[k][j]) {
sv[i][j] |= (1 << k);
c[i][j] += a[k][j];
curv = max(curv, a[k][j]);
}
}
c[i][j] -= curv;
}
}
for (int i = 0; i < int(1 << n); i++) d[i] = 1000000000;
d[0] = 0;
for (int mask = 0; mask < int(1 << n); mask++) {
if (mask == 0) continue;
int lowbit = -1;
for (int i = 0; i < int(n); i++) {
if ((mask >> i) & 1) {
lowbit = i;
}
}
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;
string s[30];
int memo[1 << 20];
int mat[30][30], mask[30][30], cost[30][30];
int n, m;
int dp(int msk) {
if (msk == ((1 << n) - 1)) return 0;
int &ans = memo[msk];
if (ans != -1) return ans;
ans = 1e9;
for (int i = 0; i < n; i++) {
if ((msk >> i) & 1) continue;
for (int j = 0; j < m; j++) {
ans = min(ans, mat[i][j] + dp(msk | (1 << i)));
ans = min(ans, cost[i][j] + dp(msk | mask[i][j]));
}
break;
}
return ans;
}
int main() {
memset(memo, -1, sizeof memo);
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 >> mat[i][j];
}
}
for (int j = 0; j < m; j++) {
for (char ch = 'a'; ch <= 'z'; ch++) {
int ma = 0, mmask = 0, sum = 0;
for (int i = 0; i < n; i++) {
if (s[i][j] == ch) {
mmask |= (1 << i);
sum += mat[i][j];
ma = max(ma, mat[i][j]);
}
}
for (int i = 0; i < n; i++) {
if (s[i][j] == ch) {
cost[i][j] = sum - ma;
mask[i][j] = mmask;
}
}
}
}
cout << dp(0) << "\n";
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m;
char s[25][25];
int a[25][25], sum[25][25], l[25][25];
int f[2000001];
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]);
memset(f, 0x7f, sizeof(f));
f[0] = 0;
for (int i = 1; i <= n; i++)
for (int j = 1; j <= m; j++) {
int sumx = 0, lx = 0, max0 = 0;
for (int k = 1; k <= n; k++)
if (s[k][j] == s[i][j]) {
sumx += a[k][j];
max0 = max(max0, a[k][j]);
lx |= (1 << (k - 1));
}
sum[i][j] = sumx - max0;
l[i][j] = lx;
}
for (int i = 0; i <= (1 << n) - 2; i++) {
if (f[i] > 1e9) continue;
int k;
for (int j = 0; j < n; j++)
if (((1 << j) & i) == 0) {
k = j + 1;
break;
}
for (int j = 1; j <= m; j++) {
f[i | (1 << (k - 1))] = min(f[i | (1 << (k - 1))], f[i] + a[k][j]);
f[i | l[k][j]] = min(f[i | l[k][j]], f[i] + sum[k][j]);
}
}
printf("%d\n", f[(1 << n) - 1]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m, dp[1 << 21], a[21][21], sum[21][21], b[21][21];
char M[21][21];
int solve(int s) {
if (dp[s] != -1) return dp[s];
dp[s] = 1 << 30;
for (int i = 0; i < n; i++)
if (s & (1 << i)) {
int state = s ^ (1 << i), t = 1 << 30;
for (int j = 0; j < m; j++)
dp[s] = min(dp[s], solve(s & (~b[i][j])) + sum[i][j]);
for (int j = 0; j < m; j++) t = min(t, a[i][j]);
dp[s] = min(dp[s], solve(state) + t);
}
return dp[s];
}
int main() {
while (cin >> n >> m) {
for (int i = 0; i < n; i++) scanf("%s", M[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 ma = 0;
sum[i][j] = b[i][j] = 0;
for (int k = 0; k < n; k++)
if (M[i][j] == M[k][j]) {
sum[i][j] += a[k][j];
ma = max(ma, a[k][j]);
b[i][j] |= (1 << k);
}
sum[i][j] -= ma;
}
memset(dp, -1, sizeof(dp));
dp[0] = 0;
printf("%d\n", solve((1 << n) - 1));
}
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
int n, m;
cin >> n >> m;
vector<string> s(n);
int a[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];
int c[n][m];
fill((int*)c, (int*)c + n * m, 0);
int flag[n][m];
fill((int*)flag, (int*)flag + n * m, 0);
for (int i = 0; i < (n); i++) {
for (int j = 0; j < (m); j++) {
int ma = 0;
for (int k = 0; k < (n); k++) {
if (s[i][j] == s[k][j]) {
c[i][j] += a[k][j];
flag[i][j] |= (1 << k);
ma = max(ma, a[k][j]);
}
}
c[i][j] -= ma;
}
}
int d[1 << n];
fill(d, d + (1 << n), 1 << 30);
d[0] = 0;
for (int mask = 0; mask < (1 << n); mask++) {
if (mask == 0) continue;
int low = -1;
for (int i = 0; i < (n); i++)
if ((mask >> i) & 1) {
low = i;
break;
}
for (int i = 0; i < (m); i++) {
d[mask] = min(d[mask], d[mask & (mask ^ flag[low][i])] + c[low][i]);
d[mask] = min(d[mask], d[mask ^ (1 << low)] + a[low][i]);
}
}
cout << d[(1 << n) - 1] << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
char s[25][25];
int v[25][25];
int p[25][25];
int sump[25][25];
int maxp[25][25];
int bits[25][25];
int dp[1 << 21];
int main() {
int n, m;
scanf("%d%d", &n, &m);
for (int i = 1; i <= n; i++) scanf("%s", s[i] + 1);
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
scanf("%d", &v[i][j]);
p[i][j] = i;
sump[i][j] += v[i][j];
bits[i][j] |= (1 << (i - 1));
maxp[i][j] = v[i][j];
}
}
for (int i = 1; i <= m; i++) {
for (int j = 1; j <= n; j++) {
if (p[j][i] == j) {
for (int k = j + 1; k <= n; k++) {
if (p[k][i] == k) {
if (s[j][i] == s[k][i]) {
p[k][i] = j;
sump[j][i] += v[k][i];
maxp[j][i] = max(maxp[j][i], v[k][i]);
bits[j][i] |= (1 << (k - 1));
}
}
}
}
}
}
for (int i = 0; i < (1 << n); i++) dp[i] = 2000000000;
dp[0] = 0;
for (int i = 1; i < (1 << n); i++) {
int cbit;
for (int j = 1; j <= n; j++) {
if (i & (1 << (j - 1))) {
cbit = j;
break;
}
}
for (int j = 1; j <= m; j++) {
dp[i] = min(dp[i], dp[i & (i ^ (bits[p[cbit][j]][j]))] +
sump[p[cbit][j]][j] - maxp[p[cbit][j]][j]);
dp[i] = min(dp[i], dp[i & (i ^ (1 << (cbit - 1)))] + v[cbit][j]);
}
}
printf("%d\n", dp[(1 << n) - 1]);
}
|
#include <bits/stdc++.h>
const int MaxN = 1 << 20;
using namespace std;
int dp[MaxN + 5];
char s[30][30];
int a[30][30], cost[30][30];
int bit[30][30];
int n, m;
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]);
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
int Max = 0, tmp = 0;
bit[i][j] = 0;
for (int k = 0; k < n; k++) {
if (s[k][j] == s[i][j]) {
Max = max(Max, a[k][j]);
tmp += a[k][j];
bit[i][j] |= (1 << k);
}
}
cost[i][j] = tmp - Max;
}
}
for (int i = 0; i < (1 << n); i++) dp[i] = 1 << 29;
dp[0] = 0;
for (int i = 0; i < (1 << n); i++) {
for (int j = 0; j < n; j++) {
if ((i & (1 << j)) == 0) {
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]);
}
}
}
}
printf("%d\n", dp[(1 << n) - 1]);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long n, m;
long long dp[1 << 21], ditu[25][25], vis[25][25], st[25][25];
char s[25][25];
signed main() {
scanf("%lld%lld", &n, &m);
for (long long i = 0; i < n; i++) {
scanf("%s", s[i]);
}
for (long long i = 0; i < n; i++) {
for (long long j = 0; j < m; j++) {
scanf("%lld", &ditu[i][j]);
}
}
long long maxst = (1 << n) - 1;
for (long long i = 0; i < n; i++) {
for (long long k = 0; k < m; k++) {
long long maxn = 0;
for (long long j = 0; j < n; j++) {
if (s[i][k] != s[j][k]) {
continue;
}
vis[i][k] += ditu[j][k];
maxn = max(ditu[j][k], maxn);
st[i][k] |= 1 << j;
}
vis[i][k] -= maxn;
}
}
memset(dp, 0x3f3f3f3f, sizeof(dp));
dp[0] = 0;
for (long long i = 0; i < maxst; i++) {
for (long long j = 0;; j++) {
if (!((i >> j) & 1)) {
long long cnt = 1 << j;
for (long long k = 0; k < m; k++) {
long long opt = st[j][k];
dp[i | cnt] = min(dp[i | cnt], dp[i] + ditu[j][k]);
dp[i | opt] = min(dp[i | opt], dp[i] + vis[j][k]);
}
break;
}
}
}
printf("%lld\n", dp[maxst]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int INF = 0x3f3f3f3f, MAXN = 20 + 10;
int dp[1 << 20];
int a[MAXN][MAXN], cost[MAXN][MAXN], to[MAXN][MAXN];
char s[MAXN][MAXN];
int main() {
int n, m;
while (~scanf("%d %d%*c", &n, &m)) {
for (int i = 0; i < n; i++) scanf("%s", s[i]);
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) scanf("%d%*c", &a[i][j]);
}
memset(to, 0, sizeof(to));
for (int j = 0; j < m; j++) {
for (int i = 0; i < n; i++) {
int mx = 0, sum = 0;
for (int k = 0; k < n; k++) {
if (s[i][j] == s[k][j]) {
to[i][j] |= 1 << k;
mx = max(mx, a[k][j]);
sum += a[k][j];
}
}
cost[i][j] = sum - mx;
}
}
memset(dp, 0x3f, sizeof(dp));
dp[0] = 0;
int ALL = (1 << n) - 1;
for (int s = 0; s < ALL; s++) {
for (int i = 0; i < n; i++) {
if (0 == (s & (1 << i))) {
for (int j = 0; j < m; j++) {
dp[s | (1 << i)] = min(dp[s | (1 << i)], dp[s] + a[i][j]);
dp[s | to[i][j]] = min(dp[s | to[i][j]], dp[s] + cost[i][j]);
}
break;
}
}
}
printf("%d\n", dp[ALL]);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
char s[30][30];
int a[30][30];
int bit[30][30], cost[30][30], dp[(1 << 21) + 1];
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 ans = 0, mx = -1;
for (int k = 0; k < n; k++) {
if (s[i][j] == s[k][j]) {
ans += a[k][j];
mx = max(mx, a[k][j]);
bit[i][j] |= (1 << k);
}
}
cost[i][j] = ans - mx;
}
memset(dp, 0x3f, sizeof(dp));
dp[0] = 0;
for (int i = 0; i < (1 << n); i++) {
for (int j = 0; j < n; j++) {
if ((i & (1 << j)) == 0) {
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>
#pragma warning(disable : 4786)
#pragma comment(linker, "/STACK:26777216")
using namespace std;
const long long MOD = 100000007;
const long long LINF = 1000000097999999903LL;
long long boundz = 10000000001LL;
const int INF = (1 << 29);
int N, M;
char crr[22][22];
int costz[22][1048576];
int arr[22][22];
int ret[1048576];
int matchedMask[22][1048576];
void reset() {
memset(arr, 0, sizeof(arr));
memset(crr, 0, sizeof(crr));
memset(costz, 0, sizeof(costz));
memset(ret, 0, sizeof(ret));
}
int main() {
reset();
scanf("%d %d", &N, &M);
for (int i = (0); i <= (N - 1); i++) {
scanf("%s", &crr[i]);
}
for (int i = (0); i <= (N - 1); i++) {
for (int j = (0); j <= (M - 1); j++) {
scanf("%d", &arr[i][j]);
}
}
int maxColCost = 0;
for (int i = (0); i <= (N - 1); i++) {
for (int j = (0); j <= (M - 1); j++) {
maxColCost = 0;
int mask = 0;
for (int k = (0); k <= (N - 1); k++) {
if (crr[i][j] != crr[k][j]) continue;
mask |= (1 << k);
costz[i][j] += arr[k][j];
maxColCost = max(maxColCost, arr[k][j]);
}
costz[i][j] -= maxColCost;
matchedMask[i][j] = mask;
}
}
int upto = (1 << N) - 1;
for (int i = (0); i <= (upto); i++) {
ret[i] = 20000001;
}
ret[0] = 0;
for (int mask = (0); mask <= (upto); mask++) {
int whom = 0;
for (int i = (0); i <= (N - 1); i++) {
if (mask & (1 << i)) {
whom = i;
break;
}
}
for (int j = (0); j <= (M - 1); j++) {
ret[mask] = min(ret[mask], ret[mask & (mask ^ matchedMask[whom][j])] +
costz[whom][j]);
ret[mask] =
min(ret[mask], ret[mask & (mask ^ (1 << whom))] + arr[whom][j]);
}
}
printf("%d\n", ret[upto]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
char s[25][25];
int a[25][25];
int dp[3000000];
int cheapest[25];
int main() {
int n, m;
scanf("%d%d", &n, &m);
for (int i = (0); i < int(n); ++i) {
scanf("%s", s[i]);
}
for (int i = (0); i < int(n); ++i) {
cheapest[i] = 100000000;
for (int j = (0); j < int(m); ++j) {
scanf("%d", a[i] + j);
cheapest[i] = min(cheapest[i], a[i][j]);
}
}
for (int i = (0); i < int(3000000); ++i) dp[i] = 1000000000;
dp[(1 << n) - 1] = 0;
for (int j = (0); j < int(m); ++j) {
vector<int> v[256];
for (int i = (0); i < int(n); ++i) v[s[i][j]].push_back(i);
for (int k = (0); k < int(256); ++k) {
if (v[k].empty()) continue;
int sum = 0;
int Max = 0;
int bit = 0;
for (int i = (0); i < int(v[k].size()); ++i) {
bit |= (1 << v[k][i]);
Max = max(Max, a[v[k][i]][j]);
sum += a[v[k][i]][j];
}
int cost = sum - Max;
for (int i = 0; i < (1 << n); ++i)
if (dp[i | bit] + cost < dp[i]) dp[i] = dp[i | bit] + cost;
}
}
int ans = 1000000000;
for (int i = (0); i < int((1 << n)); ++i) {
int tot = dp[i];
for (int j = (0); j < int(n); ++j) {
if (!(i & (1 << j))) continue;
tot += cheapest[j];
}
ans = min(ans, tot);
}
printf("%d\n", ans);
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m;
string s[28];
int a[28][28];
int M1[28][28];
int val1[28][28];
int val2[28][28];
int M2[28][28];
int dp[(1 << 20) + 8];
int lowbit(int x) { return x & (-x); }
int main() {
scanf("%d%d", &n, &m);
for (int i = 1; i <= n; i++) {
cin >> s[i];
}
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++) {
val1[i][j] = a[i][j];
int mask = (1 << (i - 1));
M1[i][j] = mask;
int ttt = 0;
int _mask = (1 << (i - 1));
for (int k = 1; k <= n; k++) {
if (s[k][j - 1] == s[i][j - 1] && k != i) {
ttt += a[k][j];
_mask |= (1 << (k - 1));
}
}
val2[i][j] = ttt;
M2[i][j] = _mask;
}
}
for (int i = 0; i < (1 << n); i++) dp[i] = 1e9;
dp[0] = 0;
for (int mask = 0; mask < (1 << n); mask++) {
for (int j = 1; j <= m; j++) {
for (int k = 1; k <= n; k++) {
dp[mask | M1[k][j]] = min(dp[mask | M1[k][j]], dp[mask] + val1[k][j]);
dp[mask | M2[k][j]] = min(dp[mask | M2[k][j]], dp[mask] + val2[k][j]);
}
}
}
cout << dp[(1 << n) - 1] << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long N = 1000006, INF = 1e18, MOD = 1e9 + 7;
long long n, w, nn, m, a[20][20], b[N], f[20][26], c[20], dp[1 << 20], d[20],
e[20], x, y, t, u, o, h, ans, Ans = INF;
pair<int, pair<int, int> > p[20];
string second;
vector<string> s;
vector<long long> v[N];
vector<pair<int, int> > q;
int main() {
cin >> n >> m;
nn = n;
for (int i = 0; i < n; i++) {
cin >> second;
s.push_back(second);
for (int j = 0; j < m; j++) f[j][s[i][j] - 'a']++;
}
for (int i = 0; i < n; i++) {
u = 0;
for (int j = 0; j < m; j++)
if (f[j][s[i][j] - 'a'] < 2) u = 1;
if (u) w |= (1 << i);
}
for (int i = 0; i < n; i++) {
b[i] = INF;
for (int j = 0; j < m; j++) cin >> a[i][j], b[i] = min(a[i][j], b[i]);
}
for (int i = 0; i < (1 << n); i++)
if ((i & w) != i) dp[i] = INF;
for (int i = 0; i < m; i++) {
q.clear();
for (int j = 0; j < n; j++) p[j] = {s[j][i] - 'a', {-a[j][i], j}};
sort(p, p + n);
for (int j = 0; j < n; j++) {
t = x = y = 0;
x |= (1 << p[j].second.second);
while (j + 1 < n && p[j + 1].first == p[j].first)
j++, x |= (1 << p[j].second.second), y -= p[j].second.first, t++;
if (t) q.push_back({x, y});
}
for (int j = 0; j < q.size(); j++)
for (int r = 0; r < (1 << n); r++)
dp[r | q[j].first] = min(dp[r | q[j].first], dp[r] + q[j].second);
}
for (int r = 0; r < (1 << n); r++) {
x = r;
ans = 0;
o = n;
while (o--) ans += (x & 1 ^ 1) * b[n - o - 1], x = (x >> 1);
Ans = min(Ans, ans + dp[r]);
}
cout << Ans;
}
|
#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++) {
if (d[S] == inf) continue;
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[30][30];
int data[30][30], common[30][30], b[30][30], dp[(1 << 22)], n, m;
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", &data[i][j]);
for (int i = 0; i < n; ++i)
for (int j = 0; j < m; ++j) {
int sum = 0, x = -(1 << 22);
for (int k = 0; k < n; ++k) {
if (s[k][j] == s[i][j]) {
sum += data[k][j], x = max(x, data[k][j]);
common[i][j] |= (1 << k);
}
}
b[i][j] = sum - x;
}
memset(dp, 0x3f, sizeof(dp)), dp[0] = 0;
int re = (1 << n);
for (int i = 0; i < re; ++i)
for (int j = 0; j < n; ++j)
if ((i & (1 << j)) == 0) {
for (int k = 0; k < m; ++k) {
dp[i | (1 << j)] = min(dp[i | (1 << j)], dp[i] + data[j][k]);
dp[i | common[j][k]] = min(dp[i | common[j][k]], dp[i] + b[j][k]);
}
}
printf("%d\n", dp[re - 1]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
string s[100];
int n, m;
int a[100][100];
int d[3000000];
int sv[100][100];
int c[300][300];
int main() {
cin >> n >> m;
for (int i = 1; i <= n; i++) cin >> s[i];
for (int i = 1; i <= n; i++)
for (int j = 0; j < m; j++) cin >> a[i][j];
for (int i = 1; i <= n; i++)
for (int j = 0; j < m; j++) {
int all = 0;
int cost = 0;
for (int k = 1; k <= n; k++) {
if (s[i][j] == s[k][j]) {
all += a[k][j];
cost = max(cost, a[k][j]);
sv[i][j] |= (1 << (k - 1));
}
}
all -= cost;
c[i][j] = all;
}
int M = 1 << (n);
for (int i = 1; i < M; i++) d[i] = 1000000000;
for (int mask = 1; mask < M; mask++) {
for (int i = 1; i <= n; i++)
if (mask & (1 << (i - 1))) {
int lowbit = i;
for (int i = 0; i < m; i++) {
d[mask] = min(d[mask], a[lowbit][i] + d[mask ^ (1 << (lowbit - 1))]);
d[mask] =
min(d[mask], c[lowbit][i] + d[mask & (mask ^ (sv[lowbit][i]))]);
}
}
}
cout << d[M - 1];
}
|
#include <bits/stdc++.h>
const int N = 3010;
using namespace std;
int n, m, org;
int val[N][N], cgb[N][N], cst[N][N], chg[N][N], f[1 << 22];
char a[N][N];
void READ() {
scanf("%d%d", &n, &m);
for (int i = 1; i <= n; i++) {
scanf("\n");
for (int j = 1; j <= m; j++) scanf("%c", &a[i][j]);
}
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) scanf("%d", &val[i][j]);
}
}
void INIT() {
org = 0;
for (int j = 1; j <= m; j++) {
for (int i = 1; i <= n; i++) {
int cnt = 0, mx = val[i][j];
cst[i][j] = val[i][j];
chg[i][j] = cgb[i][j] = 1 << (i - 1);
for (int k = 1; k <= n; k++) {
if (k == i) continue;
if (a[i][j] == a[k][j]) {
cnt++;
mx = max(mx, val[k][j]);
cst[i][j] += val[k][j];
cgb[i][j] |= (1 << (k - 1));
}
}
cst[i][j] -= mx;
if (cnt == 0) org |= 1 << (i - 1);
if (cnt == 1) chg[i][j] = cgb[i][j];
}
}
}
void SOLVE() {
int maxn = (1 << n) - 1;
for (int num = 0; num <= maxn; num++) f[num] = -1;
f[org] = 0;
for (int num = 0; num <= maxn; num++) {
if (f[num] == -1) continue;
for (int i = 1; i <= n; i++) {
if (num & (1 << (i - 1))) continue;
for (int j = 1; j <= m; j++) {
int num1 = num | chg[i][j];
if (f[num1] == -1 || f[num1] > f[num] + val[i][j]) {
f[num1] = f[num] + val[i][j];
}
num1 = num | cgb[i][j];
if (f[num1] == -1 || f[num1] > f[num] + cst[i][j]) {
f[num1] = f[num] + cst[i][j];
}
}
break;
}
}
printf("%d\n", f[maxn]);
}
int main() {
READ();
INIT();
SOLVE();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
void read(int &tmp) {
char ch = getchar();
tmp = 0;
int sgn = 1;
while (ch != EOF && (ch < '0' || ch > '9') && ch != '-') ch = getchar();
if (ch == '-') sgn = -1, ch = getchar();
while (ch != EOF && ch >= '0' && ch <= '9')
tmp = tmp * 10 + ch - 48, ch = getchar();
tmp *= sgn;
}
const int maxn = 50;
int n, m;
int a[maxn][maxn];
char s[maxn][maxn];
pair<int, int> C[1000];
int totc;
int D[(1 << 20) + 10], totd;
int F[(1 << 20) + 10];
bool vis[(1 << 20) + 10];
pair<int, int> T[1000];
bool Free[maxn];
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]);
totc = 0;
for (int i = 1; i <= m; i++) {
for (int j = 1; j <= n; j++) T[j] = make_pair(s[j][i], j);
sort(T + 1, T + 1 + n);
for (int l = 1, r; l <= n; l = r + 1) {
for (r = l; r + 1 <= n && T[r].first == T[r + 1].first; r++)
;
if (l == r) {
if (!Free[T[l].second]) {
Free[T[l].second] = 1;
C[++totc] = (make_pair(0, 1 << (T[l].second - 1)));
}
} else {
int sum = 0, red = 0, mask = 0;
for (int k = l; k <= r; k++) {
if (!Free[T[k].second])
C[++totc] = (make_pair(a[T[k].second][i], 1 << (T[k].second - 1)));
sum += a[T[k].second][i];
red = ((red) > (a[T[k].second][i]) ? (red) : (a[T[k].second][i]));
mask |= 1 << (T[k].second - 1);
}
C[++totc] = (make_pair(sum - red, mask));
}
}
}
memset(F, 0x7d, sizeof F);
memset(vis, 0, sizeof vis);
F[0] = 0;
vis[0] = 1;
D[totd = 1] = 0;
int r, mask;
for (int i = 1; i <= totc; i++) {
r = totd;
for (int j = 1; j <= r; j++) {
if ((D[j] | C[i].second) > D[j]) {
mask = C[i].second | D[j];
if (!vis[mask])
vis[mask] = 1, D[++totd] = (mask), F[mask] = F[D[j]] + C[i].first;
else
F[mask] =
((F[mask]) < (F[D[j]] + C[i].first) ? (F[mask])
: (F[D[j]] + C[i].first));
}
}
}
printf("%d\n", F[(1 << n) - 1]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int dp[1 << 20];
char s[20][21];
int c[20][20];
int mn[20];
vector<pair<int, int> > g[26];
const int inf = 1000000000;
int main() {
int n, m;
scanf("%d %d", &n, &m);
for (int i = 0; i < n; i++) scanf("%s", s[i]);
int N = 1 << n;
for (int i = 1; i < N; i++) dp[i] = inf;
for (int i = 0; i < n; i++) {
mn[i] = inf;
for (int j = 0; j < m; j++) {
scanf("%d", &c[i][j]);
mn[i] = min(mn[i], c[i][j]);
}
}
for (int i = 0; i < m; i++) {
for (int j = 0; j < n; j++)
g[s[j][i] - 'a'].push_back(make_pair(c[j][i], j));
for (int j = 0; j < 26; j++) {
if (g[j].empty()) continue;
sort(g[j].begin(), g[j].end());
int sum = 0, mask = 1 << g[j].back().second;
for (int k = 0; k < g[j].size() - 1; k++) {
sum += g[j][k].first;
mask |= 1 << g[j][k].second;
}
for (int k = 0; k < N; k++) dp[k | mask] = min(dp[k | mask], dp[k] + sum);
g[j].clear();
}
}
int ans = inf;
for (int i = 0; i < N; i++) {
int sum = dp[i];
for (int j = 0; j < n; j++)
if ((i & (1 << j)) == 0) sum += mn[j];
ans = min(ans, sum);
}
printf("%d\n", ans);
}
|
#include <bits/stdc++.h>
using namespace std;
const int INF = 1 << 30;
inline void read(int &x) {
x = 0;
char c = getchar();
while (c >= '0' && c <= '9') {
x = (x << 3) + (x << 1) + (c ^ 48), c = getchar();
}
}
int n, m;
string s[25];
int a[25][25];
int cl[25][25];
int maxn[25][25];
int minn[25];
int l[25][25];
long long dp[1100000];
vector<int> v;
int main(void) {
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 j = 0; j < m; j++) {
for (int i = 0; i < n; i++) {
l[s[i][j] - 'a'][j] |= (1 << i);
cl[s[i][j] - 'a'][j] += a[i][j];
maxn[s[i][j] - 'a'][j] = max(maxn[s[i][j] - 'a'][j], a[i][j]);
v.push_back(s[i][j] - 'a');
}
}
sort(v.begin(), v.end());
memset(minn, 127, sizeof(minn));
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++) minn[i] = min(minn[i], a[i][j]);
v.erase(unique(v.begin(), v.end()), v.end());
for (int i = 0; i < (int)v.size(); i++) {
for (int j = 0; j < m; j++) cl[v[i]][j] -= maxn[v[i]][j];
}
memset(dp, 127, sizeof(dp));
dp[0] = 0;
for (int mask = 0; mask < (1 << n); mask++) {
for (int i = 0; i < n; i++)
if ((mask & (1 << i)) == 0) {
dp[mask | (1 << i)] = min(dp[mask | (1 << i)], dp[mask] + minn[i]);
for (int j = 0; j < m; j++)
dp[mask | l[s[i][j] - 'a'][j]] =
min(dp[mask | l[s[i][j] - 'a'][j]],
(long long)dp[mask] + cl[s[i][j] - 'a'][j]);
}
}
cout << dp[(1 << n) - 1];
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int INF = 0x3f3f3f3f, MAXN = 20 + 10;
int dp[1 << 20];
int a[MAXN][MAXN], cost[MAXN][MAXN], to[MAXN][MAXN];
char s[MAXN][MAXN];
int main() {
int n, m;
while (~scanf("%d %d%*c", &n, &m)) {
for (int i = 0; i < n; i++) scanf("%s", s[i]);
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) scanf("%d%*c", &a[i][j]);
}
memset(to, 0, sizeof(to));
for (int j = 0; j < m; j++) {
for (int i = 0; i < n; i++) {
int mx = 0, sum = 0;
for (int k = 0; k < n; k++) {
if (s[i][j] == s[k][j]) {
to[i][j] |= 1 << k;
mx = max(mx, a[k][j]);
sum += a[k][j];
}
}
cost[i][j] = sum - mx;
}
}
memset(dp, 0x3f, sizeof(dp));
dp[0] = 0;
int ALL = (1 << n) - 1;
for (int s = 0; s < ALL; s++) {
for (int i = 0; i < n; i++) {
if (0 == (s & (1 << i))) {
for (int j = 0; j < m; j++) {
dp[s | (1 << i)] = min(dp[s | (1 << i)], dp[s] + a[i][j]);
dp[s | to[i][j]] = min(dp[s | to[i][j]], dp[s] + cost[i][j]);
}
}
}
}
printf("%d\n", dp[ALL]);
}
return 0;
}
|
#include <bits/stdc++.h>
#pragma GCC optimize(2)
#pragma GCC optimize("Ofast", "-funroll-loops", "-fdelete-null-pointer-checks")
#pragma GCC target("ssse3", "sse3", "sse2", "sse", "avx2", "avx")
using namespace std;
const long long inf = 0x7f7f7f7f7f7f;
long long read() {
long long x = 0, f = 1;
char c = getchar();
while (!isdigit(c)) {
if (c == '-') f = -1;
c = getchar();
}
while (isdigit(c)) {
x = (x << 3) + (x << 1) + (c ^ 48);
c = getchar();
}
return x * f;
}
const long long N = 23;
const long long M = (1 << N);
long long n, m;
long long dp[M];
long long cross[N][N];
long long w[N][N];
char s[N][N];
long long a[N][N];
inline void check_max(long long &x, long long y) {
if (x < y) x = y;
}
inline void check_min(long long &x, long long y) {
if (x > y) x = y;
}
signed main() {
n = read(), m = read();
for (long long i = 0; i < n; i++) {
scanf("%s", s[i]);
}
for (long long i = 0; i < n; i++)
for (long long j = 0; j < m; j++) a[i][j] = read();
for (long long i = 0; i < n; i++) {
for (long long j = 0; j < m; j++) {
long long sum_w = 0, max_wei = -inf;
for (long long k = 0; k < n; k++) {
if (s[k][j] == s[i][j]) {
cross[i][j] |= (1 << k);
sum_w += a[k][j];
check_max(max_wei, a[k][j]);
}
w[i][j] = sum_w - max_wei;
}
}
}
long long tmp = (1 << n);
fill(dp, dp + tmp, inf);
dp[0] = 0;
for (long long mask = 0; mask < tmp; mask++) {
long long i = 0;
for (; i < n; i++)
if ((mask & (1 << i)) == 0) break;
for (long long j = 0; j < m; j++) {
check_min(dp[mask | (1 << i)], dp[mask] + a[i][j]);
check_min(dp[mask | cross[i][j]], dp[mask] + w[i][j]);
}
}
printf("%lld", dp[tmp - 1]);
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m;
char mp[25][25];
int val[25][25];
int st[25][25];
int cost[25][25];
int dp[1200000];
int main() {
cin >> n >> m;
for (int i = 0; i < n; i++) cin >> mp[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++)
for (int k = 0; k < n; k++)
if (mp[i][j] == mp[k][j]) {
st[i][j] += (1 << k);
if (k != i) cost[i][j] += val[k][j];
}
for (int i = 1; i < (1 << n); i++) dp[i] = 1000000000;
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] + val[j][k], dp[i + (1 << j)]);
dp[i | st[j][k]] = min(dp[i | st[j][k]], dp[i] + cost[j][k]);
}
}
cout << dp[(1 << n) - 1] << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long MX = 3e5 + 9, inf = 1e14 + 6;
long long n, m, a[30][30], dp[(1 << 21)], N;
string s[30];
long long bit(long long mask) {
for (int i = 0; i < n; i++)
if (mask & (1 << i)) return i;
}
long long solve(long long mask) {
long long &ret = dp[mask];
if (ret != -1) return ret;
if (!mask) return 0;
ret = inf;
long long x = bit(mask);
for (int i = 0; i < m; i++) {
char c = s[x][i];
long long mask1 = mask;
long long mx = 0;
long long cost = 0;
for (int j = 0; j < n; j++) {
if (s[j][i] == c) {
mx = max(mx, a[j][i]);
cost += a[j][i];
if (mask1 & (1 << j)) mask1 ^= (1 << j);
}
}
ret = min(ret, cost - mx + solve(mask1));
ret = min(ret, a[x][i] + solve(mask ^ (1 << x)));
}
return ret;
}
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];
}
}
N = (1 << n) - 1;
memset(dp, -1, sizeof(dp));
cout << solve(N) << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
int dp[1 << 21];
string A[21];
int mask[21][21], sumi[21][21], c[21][21], maxi[21][21];
int main() {
ios::sync_with_stdio(false);
cin.tie(NULL);
int n, m;
cin >> n >> m;
for (int i = 0; i < n; i++) cin >> A[i];
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++) cin >> c[i][j];
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++) {
for (int k = 0; k < n; k++)
if (A[i][j] == A[k][j]) {
sumi[i][j] += c[k][j];
maxi[i][j] = max(maxi[i][j], c[k][j]);
mask[i][j] |= (1 << k);
}
}
for (int mk = 0; mk < (1 << n); mk++) dp[mk] = 1e9;
dp[0] = 0;
for (int mk = 0; mk < (1 << n); mk++)
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++) {
if (!(mk & (1 << i))) {
dp[mk | mask[i][j]] =
min(dp[mk | mask[i][j]], dp[mk] + sumi[i][j] - maxi[i][j]);
dp[mk | (1 << i)] = min(dp[mk | (1 << i)], dp[mk] + c[i][j]);
}
}
cout << dp[(1 << n) - 1] << '\n';
}
|
#include <bits/stdc++.h>
using namespace std;
const int mod = 1e9 + 7;
const int inf = 1e9;
long long powm(long long a, long long p, long long m) {
long long r = 1 % m;
while (p) {
if (p & 1) r = r * a % m;
p >>= 1;
a = a * a % m;
}
return r;
}
int n, m, dp[1 << 20], a[20][20], masks[20][20], sums[20][20];
char t[20][21];
int calc(int mask) {
int &res = dp[mask];
if (res != -1) return res;
res = inf;
for (int i = 0; i < (n); ++i)
if (mask & (1 << i)) {
int nmask = mask - (1 << i);
for (int j = 0; j < (m); ++j) {
if (sums[i][j] == 0)
res = min(res, calc(nmask));
else
res = min(res, min(a[i][j] + calc(nmask),
sums[i][j] + calc(nmask & (~masks[i][j]))));
}
}
return res;
}
int main() {
scanf("%d%d", &n, &m);
for (int i = 0; i < (n); ++i) scanf("%s", t[i]);
for (int i = 0; i < (n); ++i)
for (int j = 0; j < (m); ++j) scanf("%d", a[i] + j);
memset(dp, -1, sizeof(dp));
dp[0] = 0;
int mask = 0;
for (int i = 0; i < (n); ++i) {
int cnt = 0;
for (int j = 0; j < (m); ++j) {
for (int k = 0; k < (n); ++k) cnt += k != i && t[i][j] == t[k][j];
if (cnt) {
mask |= 1 << i;
break;
}
}
}
for (int i = 0; i < (n); ++i)
for (int j = 0; j < (m); ++j)
for (int k = 0; k < (n); ++k)
if (i != k && t[i][j] == t[k][j]) {
sums[i][j] += a[k][j];
masks[i][j] |= 1 << k;
}
printf("%d\n", calc((1 << n) - 1));
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <class T>
inline bool rd(T &ret) {
char c;
int sgn;
if (c = getchar(), c == EOF) return 0;
while (c != '-' && (c < '0' || c > '9')) c = getchar();
sgn = (c == '-') ? -1 : 1;
ret = (c == '-') ? 0 : (c - '0');
while (c = getchar(), c >= '0' && c <= '9') ret = ret * 10 + (c - '0');
ret *= sgn;
return 1;
}
template <class T>
inline void pt(T x) {
if (x < 0) {
putchar('-');
x = -x;
}
if (x > 9) pt(x / 10);
putchar(x % 10 + '0');
}
const int inf = 1e9;
const int N = 21;
int n, m;
char s[N][N];
int a[N][N];
int dp[1 << N];
int bit[N][N], cost[N][N];
int main() {
rd(n);
rd(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++) rd(a[i][j]);
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++) {
int ans = 0, 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)) == 0) {
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]);
}
}
}
pt(dp[(1 << n) - 1]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <class T>
int getbit(int i, T X) {
return (X & (1 << (i - 1)));
}
template <class T>
T onbit(int i, T X) {
return (X | (1 << (i - 1)));
}
template <class T>
T offbit(int i, T X) {
return (X | (1 << (i - 1)) - (1 << (i - 1)));
}
template <class T>
T sqr(T x) {
return (x * x);
}
template <class T>
T cube(T x) {
return (x * x * x);
}
template <class T>
T gcd(T a, T b) {
T r;
while (b != 0) {
r = a % b;
a = b;
b = r;
}
return a;
}
template <class T>
T lcm(T a, T b) {
return a / gcd(a, b) * b;
}
int csx[4] = {0, 0, -1, 1};
int csy[4] = {-1, 1, 0, 0};
const int MOD = 1000000007;
const int maxn = 21;
const int infi = (int)(1e9);
int n, m, a[maxn + 5][maxn + 5];
string s[maxn + 5];
int dp[(1 << 20) + 5], sum[maxn + 5][30], maxx[maxn + 5][30],
mask[maxn + 5][30];
void enter() {
cin >> n >> m;
for (typeof(n) i = 1; i <= n; i++) {
cin >> s[i];
s[i] = " " + s[i];
}
for (typeof(n) i = 1; i <= n; i++)
for (typeof(m) j = 1; j <= m; j++) cin >> a[i][j];
}
void init() {
memset(mask, 0, sizeof(mask));
memset(maxx, -1, sizeof(maxx));
memset(sum, 0, sizeof(sum));
for (typeof(m) i = 1; i <= m; i++) {
for (typeof(n) j = 1; j <= n; j++) {
int c = s[j][i] - 'a';
sum[i][c] += a[j][i];
maxx[i][c] = max(maxx[i][c], a[j][i]);
mask[i][c] = onbit(j, mask[i][c]);
}
}
}
void solve() {
for (typeof((1 << n) - 1) i = 0; i <= (1 << n) - 1; i++) dp[i] = infi;
dp[0] = 0;
for (typeof(m) i = 1; i <= m; i++) {
for (typeof((1 << n) - 1) X = 0; X <= (1 << n) - 1; X++) {
for (typeof(n) j = 1; j <= n; j++) {
int Y = onbit(j, X);
dp[Y] = min(dp[Y], dp[X] + a[j][i]);
}
for (typeof(25) j = 0; j <= 25; j++) {
int Y = X | mask[i][j];
if (!mask[i][j]) continue;
dp[Y] = min(dp[Y], dp[X] + sum[i][j] - maxx[i][j]);
}
}
}
cout << dp[(1 << n) - 1];
}
int main() {
enter();
init();
solve();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 20, maxal = 26, maxmask = 1 << maxn;
int dp[maxmask], a[maxn][maxn], cost[maxn], MAX[maxal], COS[maxal], MASK[maxal];
vector<pair<int, int> > chng;
string s[maxn];
int n, m;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cin >> n >> m;
for (int i = 0; i < n; i++) cin >> s[i];
memset(cost, 63, sizeof cost);
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++) {
cin >> a[i][j];
((cost[i]) = min((cost[i]), (a[i][j])));
}
for (int j = 0; j < m; j++) {
memset(MAX, 0, sizeof MAX);
memset(COS, 0, sizeof COS);
memset(MASK, 0, sizeof MASK);
for (int i = 0; i < n; i++) {
((MAX[s[i][j] - 'a']) = max((MAX[s[i][j] - 'a']), (a[i][j])));
COS[s[i][j] - 'a'] += a[i][j];
MASK[s[i][j] - 'a'] += 1 << i;
}
for (int i = 0; i < 26; i++)
if (MASK[i]) chng.push_back(make_pair(MASK[i], COS[i] - MAX[i]));
}
memset(dp, 63, sizeof dp);
dp[0] = 0;
for (int mask = 0; mask < (1 << n); mask++) {
for (auto e : chng)
((dp[mask | e.first]) = min((dp[mask | e.first]), (dp[mask] + e.second)));
for (int i = 0; i < n; i++)
((dp[mask | (1 << i)]) =
min((dp[mask | (1 << i)]), (dp[mask] + cost[i])));
}
cout << dp[(1 << n) - 1] << '\n';
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int dp[(1 << 20)], inp[30][30], all[30][30] = {0}, share[30][30] = {0};
char s[22][22];
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 >> inp[i][j];
for (int i = 0; i < m; i++)
for (int j = 0; j < n; j++) {
share[j][i] |= (1 << j);
for (int k = 0; k < n; k++)
if (s[j][i] == s[k][i] && j != k)
share[j][i] |= (1 << k), all[j][i] += inp[k][i];
}
for (int i = 0; i < (1 << n); i++) dp[i] = INT_MAX / 3;
dp[0] = 0;
for (int i = 0; i < m; i++)
for (int j = 0; j < n; j++)
for (int k = 0; k < (1 << n); k++) {
dp[k | (1 << j)] = min(dp[k | (1 << j)], dp[k] + inp[j][i]);
dp[k | share[j][i]] = min(dp[k | share[j][i]], dp[k] + all[j][i]);
}
cout << dp[(1 << n) - 1] << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
template <class T>
void read(T &x) {
x = 0;
bool flag = 0;
char ch = getchar();
for (; ch < '0' || ch > '9'; ch = getchar()) flag |= ch == '-';
for (; ch >= '0' && ch <= '9'; ch = getchar()) x = x * 10 + ch - 48;
flag ? x = 0 - x : 0;
}
char s[21][21];
int a[21][21], same[21][21], cost[21][21], f[1 << 21 - 1];
int main() {
int n, m;
read(n), read(m);
for (auto i = (1); i <= (n); ++i) cin >> s[i] + 1;
for (auto i = (1); i <= (n); ++i)
for (auto j = (1); j <= (m); ++j) read(a[i][j]);
for (auto i = (1); i <= (n); ++i)
for (auto j = (1); j <= (m); ++j) {
int mx = 0;
for (auto k = (1); k <= (n); ++k)
s[i][j] == s[k][j] ? mx = max(mx, a[k][j]), same[i][j] |= 1 << k - 1,
cost[i][j] += a[k][j] : 0;
cost[i][j] -= mx;
}
memset(f, 0x3f, sizeof f);
f[0] = 0;
for (auto S = (0); S <= ((1 << n) - 2); ++S)
if (f[S] != 0x3f3f3f3f) {
int k;
for (auto i = (1); i <= (n); ++i)
if (!(S & 1 << i - 1)) {
k = i;
break;
}
for (auto j = (1); j <= (m); ++j) {
f[S | 1 << k - 1] = min(f[S | 1 << k - 1], f[S] + a[k][j]);
f[S | same[k][j]] = min(f[S | same[k][j]], f[S] + cost[k][j]);
}
}
printf("%d", f[(1 << n) - 1]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int INF = 1e9;
int n, m, cost[22][22], bit[22][22], dp[1 << 21], e, maxx, a[22][22];
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", &a[i][j]);
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++) {
maxx = -INF;
for (int k = 0; k < n; k++)
if (s[i][j] == s[k][j]) {
cost[i][j] += a[k][j];
maxx = max(maxx, a[k][j]);
bit[i][j] |= 1 << k;
}
cost[i][j] -= maxx;
}
e = (1 << n);
for (int i = 1; i < e; i++) dp[i] = INF;
for (int i = 0; i < e; i++) {
for (int j = 0; j < n; j++)
if ((i & (1 << j)) == 0) {
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]);
}
}
}
printf("%d", dp[e - 1]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int M = 1 << 20, INF = 2e9;
int dp[M], n, m, cost[25][25];
char s[25][25];
void Min(int &a, int b) {
if (a > b) a = b;
}
void rd(int &res) {
char c;
res = 0;
while (c = getchar(), !isdigit(c))
;
do res = (res << 3) + (res << 1) + (c ^ 48);
while (c = getchar(), isdigit(c));
}
int find(int string) {
for (int i = 0; i < n; i++)
if (!(string & (1 << i))) return i;
return n - 1;
}
int main() {
rd(n);
rd(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++) rd(cost[i][j]);
for (int string = 1; string < 1 << n; string++) dp[string] = INF;
for (int string = 0; string < 1 << n; string++) {
int had = find(string);
for (int c = 0; c < m; c++) {
Min(dp[string | (1 << had)], dp[string] + cost[had][c]);
int sum = 0, mx = 0, nw = 0;
for (int r = 0; r < n; r++)
if (s[had][c] == s[r][c]) {
sum += cost[r][c];
mx = max(mx, cost[r][c]);
nw |= 1 << r;
}
Min(dp[string | nw], dp[string] + sum - mx);
}
}
printf("%d", dp[(1 << n) - 1]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
inline long long getint() {
long long _x = 0, _tmp = 1;
char _tc = getchar();
while ((_tc < '0' || _tc > '9') && _tc != '-') _tc = getchar();
if (_tc == '-') _tc = getchar(), _tmp = -1;
while (_tc >= '0' && _tc <= '9') _x *= 10, _x += (_tc - '0'), _tc = getchar();
return _x * _tmp;
}
long long mypow(long long _a, long long _x, long long _mod) {
if (_x == 0) return 1ll;
long long _tmp = mypow(_a, _x / 2, _mod);
_tmp = (_tmp * _tmp) % _mod;
if (_x & 1) _tmp = (_tmp * _a) % _mod;
return _tmp;
}
inline long long add(long long _x, long long _y,
long long _mod = 1000000007ll) {
long long _ = _x + _y;
if (_ >= _mod) _ -= _mod;
return _;
}
inline long long sub(long long _x, long long _y,
long long _mod = 1000000007ll) {
long long _ = _x - _y;
if (_ < 0) _ += _mod;
return _;
}
inline long long mul(long long _x, long long _y,
long long _mod = 1000000007ll) {
long long _ = _x * _y;
if (_ >= _mod) _ %= _mod;
return _;
}
inline bool equal(double _x, double _y) {
return _x > _y - 1e-9 && _x < _y + 1e-9;
}
int __ = 1, cs;
void build() {}
int n, m;
char c[22][22];
int a[22][22];
int b[22][22];
int bm[22][22];
void init() {
n = getint();
m = getint();
for (int i = 0; i < n; i++) scanf("%s", c[i] + 1);
for (int i = 0; i < n; i++)
for (int j = 1; j <= m; j++) a[i][j] = getint();
for (int i = 0; i < n; i++)
for (int j = 1; j <= m; j++) {
int tcst = 0, tmx = 0, tmsk = 0;
for (int k = 0; k < n; k++)
if (c[i][j] == c[k][j]) {
tmsk |= (1 << k);
tcst += a[k][j];
tmx = max(tmx, a[k][j]);
}
b[i][j] = tcst - tmx;
bm[i][j] = tmsk;
}
}
int dp[1 << 22];
void solve() {
for (int i = 1; i < (1 << n); i++) {
int lb = round(log2(i & -i));
dp[i] = 1023456789ll;
for (int j = 1; j <= m; j++) {
dp[i] = min(dp[i], dp[i & (~bm[lb][j])] + b[lb][j]);
dp[i] = min(dp[i], dp[i ^ (1 << lb)] + a[lb][j]);
}
}
printf("%d\n", dp[(1 << n) - 1]);
}
int main() {
build();
while (__--) {
init();
solve();
}
}
|
#include <bits/stdc++.h>
using namespace std;
char str[25][25];
int cost[25][25];
const int maxc = 1 << 20;
int dp[maxc];
int main() {
int n, m;
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", &cost[i][j]);
}
int total = (1 << n) - 1;
memset(dp, -1, sizeof(dp));
dp[0] = 0;
for (int i = 0; i < total; i++) {
if (dp[i] == -1) continue;
int j = 0;
while (((i >> j) & 1) == 1) j++;
for (int k = 0; k < m; k++) {
int cnt = 0, sumc = 0, maxc = 0, tmp = 0;
for (int z = 0; z < n; z++) {
if (str[z][k] == str[j][k]) {
cnt++;
sumc += cost[z][k];
maxc = max(maxc, cost[z][k]);
tmp |= (1 << z);
}
}
if (cnt == 1) {
if (dp[i | (1 << j)] == -1)
dp[i | (1 << j)] = dp[i];
else
dp[i | (1 << j)] = min(dp[i | (1 << j)], dp[i]);
} else {
if (dp[i | (1 << j)] == -1)
dp[i | (1 << j)] = dp[i] + cost[j][k];
else
dp[i | (1 << j)] = min(dp[i | (1 << j)], dp[i] + cost[j][k]);
if (dp[i | tmp] == -1)
dp[i | tmp] = dp[i] + sumc - maxc;
else
dp[i | tmp] = min(dp[i | tmp], dp[i] + sumc - maxc);
}
}
}
printf("%d\n", dp[total]);
return 0;
}
|
#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 maxn = 0;
for (int k = 0; k < n; k++) {
if (str[i][j] == str[k][j]) {
msk[i][j] |= (1 << k);
cst[i][j] += val[k][j];
maxn = max(maxn, val[k][j]);
}
}
cst[i][j] -= 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;
constexpr int top = 1 << 20;
int dp[top];
int a[20][20];
pair<int, int> opts[220];
bool ok[20];
int main() {
ios::sync_with_stdio(false);
cin.tie(nullptr);
string s[20];
int n;
unsigned m;
cin >> n >> m;
if (0 > n || n > 20) {
cout << "too many strings\n";
return 0;
}
for (int i = 0; i < n; ++i) {
cin >> s[i];
if (s[i].size() != m) {
cout << "bad format\n";
return 0;
}
for (unsigned j = 0; j < m; ++j)
if ('a' > s[i][j] || s[i][j] > 'z') {
cout << "illegal character\n";
return 0;
}
}
for (int i = 0; i < n; ++i)
for (unsigned j = 0; j < m; ++j) cin >> a[i][j];
int nOpts = 0;
for (unsigned j = 0; j < m; ++j) {
int seens[26];
int last[26];
for (int c = 0; c < 26; ++c) seens[c] = 0, last[c] = -1;
for (int i = 0; i < n; ++i) {
int c = s[i][j] - 'a';
seens[c] += 1 << i;
last[c] = i;
}
for (int c = 0; c < 26; ++c) {
int sc = seens[c];
if (sc) {
if (sc == (sc & -sc))
ok[last[c]] = true;
else {
int cost = 0;
int maxc = 0;
for (int i = 0; i < n; ++i) {
if (0 == (sc & (1 << i))) continue;
cost += a[i][j];
maxc = max(maxc, a[i][j]);
}
opts[nOpts++] = pair<int, int>(sc, cost - maxc);
}
}
}
}
for (int i = 0; i < n; ++i) {
if (ok[i]) continue;
int minc = (-1u >> 1);
for (unsigned j = 0; j < m; ++j) minc = min(minc, a[i][j]);
opts[nOpts++] = pair<int, int>(1 << i, minc);
}
int start = 0;
int last = (1 << n) - 1;
int lastBit = (1 << (n - 1));
for (int i = 0; i < n; ++i)
if (ok[i]) start += 1 << i;
dp[start] = 1;
for (int on = 0; on < nOpts; ++on) {
pair<int, int> copt = opts[on];
int res = start | copt.first;
if (dp[res])
dp[res] = min(dp[res], 1 + copt.second);
else
dp[res] = 1 + copt.second;
}
for (int cs = lastBit; cs < last; ++cs) {
int cc = dp[cs];
if (cc == 0) continue;
for (int on = 0; on < nOpts; ++on) {
pair<int, int> copt = opts[on];
int res = cs | copt.first;
if (dp[res])
dp[res] = min(dp[res], cc + copt.second);
else
dp[res] = cc + copt.second;
}
}
cout << (dp[last] - 1) << "\n";
;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int inf = 0x3f3f3f3f;
int n, m, val[24][24], dp[1 << 21], Max, cost[24][24], sta[24][24];
char s[24][24];
void init() {
Max = 1 << n;
memset(dp, inf, sizeof(dp));
memset(val, -1, sizeof(val));
memset(cost, 0, sizeof(cost));
memset(sta, 0, sizeof(sta));
}
int main() {
while (~scanf("%d%d", &n, &m)) {
init();
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 tMax = -1, sum = 0;
for (int k = 0; k < n; k++) {
if (s[i][j] != s[k][j]) continue;
sta[i][j] |= (1 << k);
sum += val[k][j];
tMax = max(tMax, val[k][j]);
}
cost[i][j] = sum - tMax;
}
}
dp[0] = 0;
for (int now = 0; now < Max; now++) {
for (int i = 0; i < n; i++) {
if (now & (1 << i)) continue;
for (int j = 0; j < m; j++) {
dp[now | (1 << i)] = min(dp[now | (1 << i)], dp[now] + val[i][j]);
dp[now | sta[i][j]] = min(dp[now | sta[i][j]], dp[now] + cost[i][j]);
}
}
}
printf("%d\n", dp[Max - 1]);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long PR = 1000000009;
int main() {
ios::sync_with_stdio(false);
int c1[21][21], c2[21][21], mask[21][21];
int n, m;
cin >> n >> m;
char A[30][30];
for (int i = 0; i < n; ++i) {
cin >> A[i];
}
for (int i = 0; i < n; ++i) {
for (int j = 0; j < m; ++j) {
cin >> c1[i][j];
}
}
for (int i = 0; i < n; ++i) {
for (int j = 0; j < m; ++j) {
c2[i][j] = mask[i][j] = 0;
int max1 = 0, sum1 = 0;
for (int k = 0; k < n; ++k) {
if (A[i][j] == A[k][j]) {
sum1 += c1[k][j];
max1 = max(max1, c1[k][j]);
mask[i][j] |= (1 << k);
}
}
c2[i][j] = sum1 - max1;
}
}
int ans[1 << 20];
for (int i = 0; i < (1 << 20); ++i) ans[i] = 1e9 + 9;
ans[0] = 0;
for (int i = 1; i < (1 << n); ++i) {
int lsone = i & (-i), pl = 0;
while (lsone >> pl + 1) pl++;
for (int j = 0; j < m; ++j) {
ans[i] = min(ans[i], ans[i ^ lsone] + c1[pl][j]);
ans[i] = min(ans[i], ans[i & (i ^ mask[pl][j])] + c2[pl][j]);
}
}
cout << ans[(1 << n) - 1] << '\n';
return 0;
};
|
#include <bits/stdc++.h>
using namespace std;
template <typename T, typename U>
std::istream& operator>>(std::istream& i, pair<T, U>& p) {
i >> p.first >> p.second;
return i;
}
template <typename T>
std::istream& operator>>(std::istream& i, vector<T>& t) {
for (auto& v : t) {
i >> v;
}
return i;
}
template <typename T, typename U>
std::ostream& operator<<(std::ostream& o, const pair<T, U>& p) {
o << p.first << ' ' << p.second;
return o;
}
template <typename T>
std::ostream& operator<<(std::ostream& o, const vector<T>& t) {
if (t.empty()) o << '\n';
for (size_t i = 0; i < t.size(); ++i) {
o << t[i] << " \n"[i == t.size() - 1];
}
return o;
}
template <typename T>
using minheap = priority_queue<T, vector<T>, greater<T>>;
template <typename T>
using maxheap = priority_queue<T, vector<T>, less<T>>;
template <typename T>
bool in(T a, T b, T c) {
return a <= b && b < c;
}
unsigned int logceil(int first) {
return 8 * sizeof(int) - __builtin_clz(first);
}
namespace std {
template <typename T, typename U>
struct hash<pair<T, U>> {
hash<T> t;
hash<U> u;
size_t operator()(const pair<T, U>& p) const {
return t(p.first) ^ (u(p.second) << 7);
}
};
} // namespace std
template <typename T, typename F>
T bsh(T l, T h, const F& f) {
T r = -1, m;
while (l <= h) {
m = (l + h) / 2;
if (f(m)) {
l = m + 1;
r = m;
} else {
h = m - 1;
}
}
return r;
}
template <typename F>
double bshd(double l, double h, const F& f, double p = 1e-9) {
unsigned int r = 3 + (unsigned int)log2((h - l) / p);
while (r--) {
double m = (l + h) / 2;
if (f(m)) {
l = m;
} else {
h = m;
}
}
return (l + h) / 2;
}
template <typename T, typename F>
T bsl(T l, T h, const F& f) {
T r = -1, m;
while (l <= h) {
m = (l + h) / 2;
if (f(m)) {
h = m - 1;
r = m;
} else {
l = m + 1;
}
}
return r;
}
template <typename F>
double bsld(double l, double h, const F& f, double p = 1e-9) {
unsigned int r = 3 + (unsigned int)log2((h - l) / p);
while (r--) {
double m = (l + h) / 2;
if (f(m)) {
h = m;
} else {
l = m;
}
}
return (l + h) / 2;
}
template <typename T>
T gcd(T a, T b) {
if (a < b) swap(a, b);
return b ? gcd(b, a % b) : a;
}
template <typename T>
class vector2 : public vector<vector<T>> {
public:
vector2() {}
vector2(size_t a, size_t b, T t = T())
: vector<vector<T>>(a, vector<T>(b, t)) {}
};
template <typename T>
class vector3 : public vector<vector2<T>> {
public:
vector3() {}
vector3(size_t a, size_t b, size_t c, T t = T())
: vector<vector2<T>>(a, vector2<T>(b, c, t)) {}
};
template <typename T>
class vector4 : public vector<vector3<T>> {
public:
vector4() {}
vector4(size_t a, size_t b, size_t c, size_t d, T t = T())
: vector<vector3<T>>(a, vector3<T>(b, c, d, t)) {}
};
template <typename T>
class vector5 : public vector<vector4<T>> {
public:
vector5() {}
vector5(size_t a, size_t b, size_t c, size_t d, size_t e, T t = T())
: vector<vector4<T>>(a, vector4<T>(b, c, d, e, t)) {}
};
class rememberingstrings {
public:
void solve(istream& cin, ostream& cout) {
int N, M;
cin >> N >> M;
vector<string> I(N);
cin >> I;
vector2<int> A(N, M);
cin >> A;
vector<int> L(N, 1e9);
vector2<int> S(M, 26, 0), H(M, 26, 0), T(M, 26, 0);
for (int i = 0; i < M; ++i) {
for (int j = 0; j < N; ++j) {
L[j] = min(L[j], A[j][i]);
int k = I[j][i] - 'a';
H[i][k] = max(H[i][k], A[j][i]);
S[i][k] += A[j][i];
T[i][k] |= (1 << j);
}
}
vector<int> D(1 << N, 0);
for (int i = 0; i < (1 << N); ++i) {
for (int j = 0; j < N; ++j) {
if (i & (1 << j)) {
D[i] += L[j];
}
}
}
for (int i = 0; i < M; ++i) {
for (int k = 0; k < 26; ++k) {
if (T[i][k] == 0) continue;
vector<int> E(1 << N, 1e9);
for (int j = 0; j < (1 << N); ++j) {
if (D[j] == 1e9) continue;
E[j] = min(E[j], D[j]);
E[j | T[i][k]] = min(E[j | T[i][k]], D[j] + S[i][k] - H[i][k]);
}
swap(E, D);
}
}
cout << D.back() << endl;
}
};
int main() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
cout.tie(nullptr);
rememberingstrings solver;
std::istream& in(std::cin);
std::ostream& out(std::cout);
solver.solve(in, out);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
constexpr int inf = 1e9;
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>> cost(m, vector<int>(n, inf));
vector<vector<int>> mask(m, vector<int>(n));
for (int i = 0; i < m; ++i) {
for (int j = 0; j < n; ++j) {
vector<int> cs;
int msk = 0;
for (int k = 0; k < n; ++k) {
if (s[j][i] == s[k][i]) {
cs.push_back(a[k][i]);
msk |= (1 << k);
}
}
sort(begin(cs), end(cs));
cost[i][j] = accumulate(begin(cs), end(cs) - 1, 0);
mask[i][j] = msk;
}
}
vector<int> dp(1 << n, inf);
dp[0] = 0;
for (int S = 0; S < (1 << n) - 1; ++S) {
int lb = 0;
while (S & (1 << lb)) ++lb;
for (int i = 0; i < m; ++i) {
dp[S | (1 << lb)] = min(dp[S | (1 << lb)], dp[S] + a[lb][i]);
dp[S | mask[i][lb]] = min(dp[S | mask[i][lb]], dp[S] + cost[i][lb]);
}
}
cout << dp.back() << endl;
}
|
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:640000000")
using namespace std;
const double eps = 1e-9;
const double pi = acos(-1.0);
const int inf = (int)1e9;
string s[22];
int sum[22][33];
int sub[22][33];
int ma[22][33];
int dp[1 << 20];
vector<pair<int, int> > val[22];
int a[22][22];
int A[22];
int main() {
int n, m;
cin >> n >> m;
for (int i = 0; i < n; i++) {
cin >> s[i];
A[i] = inf;
}
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
cin >> a[i][j];
A[i] = min(A[i], a[i][j]);
}
}
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
s[i][j] -= 'a';
sum[j][s[i][j]] += a[i][j];
ma[j][s[i][j]] = max(ma[j][s[i][j]], a[i][j]);
sub[j][s[i][j]] |= (1 << i);
}
}
for (int i = 0; i < m; i++) {
for (int j = 0; j < 26; j++) {
sum[i][j] -= ma[i][j];
for (int k = 0; k < n; k++)
if (sub[i][j] & (1 << k)) {
val[k].push_back(make_pair(sub[i][j], sum[i][j]));
}
}
}
for (int mask = 0; mask < (1 << n); mask++) {
dp[mask] = inf;
}
dp[0] = 0;
for (int mask = 0; mask < (1 << n) - 1; mask++) {
int low = 0;
while (mask & (1 << low)) low++;
dp[mask | (1 << low)] = min(dp[mask | (1 << low)], dp[mask] + A[low]);
for (int i = 0; i < (int)(val[low]).size(); i++) {
dp[mask | val[low][i].first] =
min(dp[mask | val[low][i].first], dp[mask] + val[low][i].second);
}
}
cout << dp[(1 << n) - 1] << endl;
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 & (msk ^ cellMask[lsb][j])] + tc[lsb][j]);
dp[msk] = min(dp[msk], dp[msk ^ (1 << lsb)] + c[lsb][j]);
}
}
cout << dp[(1 << n) - 1] << endl;
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 int N = 26, MOD = 1e9 + 7;
int a[N][N], tmp[N], mx[N], sum[N], dp[1 << (N - 6)];
string s[N];
int32_t main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
memset(dp, 63, sizeof(dp));
dp[0] = 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];
dp[(1 << i)] = min(dp[(1 << i)], a[i][j]);
for (int msk = 0; msk < (1 << n); msk++)
dp[msk | (1 << i)] = min(dp[msk | (1 << i)], a[i][j] + dp[msk]);
}
for (int j = 0; j < m; j++) {
memset(tmp, 0, sizeof(tmp));
memset(sum, 0, sizeof(sum));
memset(mx, 0, sizeof(mx));
for (int i = 0; i < n; i++) {
tmp[s[i][j] - 'a'] |= (1 << i);
sum[s[i][j] - 'a'] += a[i][j];
mx[s[i][j] - 'a'] = max(mx[s[i][j] - 'a'], a[i][j]);
}
for (int i = 0; i < 26; i++) {
if (!tmp[i]) continue;
int S = sum[i] - mx[i];
for (int msk = 0; msk < (1 << n); msk++)
dp[msk | tmp[i]] = min(dp[msk | tmp[i]], S + dp[msk]);
}
}
cout << dp[(1 << n) - 1];
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m, mp[22][22], same[22][22], cost[22][22], dp[(1 << 20) + 5];
char s[22][22];
int main() {
scanf("%d%d", &n, &m);
for (int i = 1; i <= n; i++) cin >> s[i] + 1;
for (int i = 1; i <= n; i++)
for (int j = 1; j <= m; j++) scanf("%d", mp[i] + j);
for (int i = 1; i <= n; i++)
for (int j = 1; j <= m; j++) {
int sum = 0, maxx = 0;
for (int k = 1; k <= n; k++)
if (s[i][j] == s[k][j]) {
sum += mp[k][j];
maxx = max(maxx, mp[k][j]);
same[i][j] |= (1 << (k - 1));
}
cost[i][j] = sum - maxx;
}
memset(dp, 127, sizeof(dp));
dp[0] = 0;
for (int state = 0; state < (1 << n); state++) {
for (int i = 1; i <= n; i++) {
if (state & (1 << (i - 1))) continue;
for (int j = 1; j <= m; j++) {
dp[state | (1 << (i - 1))] =
min(dp[state | (1 << (i - 1))], dp[state] + mp[i][j]);
dp[state | same[i][j]] =
min(dp[state | same[i][j]], dp[state] + cost[i][j]);
}
}
}
printf("%d", dp[(1 << n) - 1]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m;
string a[21];
int c[21][21];
int dp[(1 << 21)];
int sm[21][27];
int mx[21][27];
int mask[21][27];
void input() {
cin >> n >> m;
for (int i = 0; i < n; ++i) {
cin >> a[i];
}
for (int i = 0; i < n; ++i) {
for (int j = 0; j < m; ++j) {
cin >> c[i][j];
}
}
for (int j = 0; j < m; ++j) {
for (int i = 0; i < n; ++i) {
int id = (a[i][j] - 'a');
sm[j][id] += c[i][j];
mx[j][id] = max(mx[j][id], c[i][j]);
mask[j][id] += (1 << i);
}
}
}
void solve() {
dp[0] = 0;
int lim = (1 << n);
for (int i = 1; i < lim; ++i) {
int x = 0;
while ((i & (1 << x)) == 0) {
++x;
}
dp[i] = 1000000007;
for (int j = 0; j < m; ++j) {
dp[i] = min(dp[i], dp[i - (1 << x)] + c[x][j]);
int id = (a[x][j] - 'a');
dp[i] = min(dp[i], dp[i & (i ^ mask[j][id])] + sm[j][id] - mx[j][id]);
}
}
cout << dp[(1 << n) - 1] << "\n";
}
int main() {
ios_base ::sync_with_stdio(false);
cin.tie(NULL);
input();
solve();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 20 + 1;
const int maxm = 20 + 1;
const int INF = (1 << 30);
int cost[maxn][maxm], dp[(1 << maxn)], same[maxn][maxm], most[maxn][maxm],
mostcost[maxn][maxm];
char s[maxn][maxm];
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", &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 (s[i][j] == s[k][j]) {
same[i][j] |= (1 << k);
most[i][j] = max(most[i][j], cost[k][j]);
mostcost[i][j] += cost[k][j];
}
mostcost[i][j] -= most[i][j];
}
for (int S = (1 << n) - 1; S >= 0; S--) dp[S] = INF;
dp[(1 << n) - 1] = 0;
for (int S = (1 << n) - 1; S >= 0; S--) {
for (int i = 0; i < n; i++) {
if (!(S & (1 << i))) continue;
for (int j = 0; j < m; j++) {
dp[S ^ (1 << i)] = min(dp[S ^ (1 << i)], dp[S] + cost[i][j]);
dp[S ^ (S & same[i][j])] =
min(dp[S ^ (S & same[i][j])], dp[S] + mostcost[i][j]);
}
break;
}
}
printf("%d\n", dp[0]);
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 25, inf = 0x3f3f3f3f;
int n, m;
int dp[1 << 22], cst[maxn][maxn], sme[maxn][maxn], a[maxn][maxn];
char s[maxn][maxn];
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++) {
sme[i][j] = 0;
int mx = a[i][j];
for (int k = 1; k <= n; k++)
if (s[k][j] == s[i][j]) {
mx = max(mx, a[k][j]);
sme[i][j] |= 1 << k - 1;
cst[i][j] += a[k][j];
}
cst[i][j] -= mx;
}
memset(dp, inf, sizeof(dp));
dp[0] = 0;
for (int i = 0; i < (1 << n); i++)
for (int j = 1; j <= n; j++)
if (((1 << j - 1) & i) == 0)
for (int k = 1; k <= m; k++) {
dp[i | sme[j][k]] = min(dp[i | sme[j][k]], dp[i] + cst[j][k]);
dp[i | (1 << j - 1)] = min(dp[i | (1 << j - 1)], dp[i] + a[j][k]);
}
printf("%d", dp[(1 << n) - 1]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int INF = 1e9;
int n, m;
char s[22][22];
int a[22][22];
int cost[22][26], diff[22][26];
int dp[1 << 21];
int low[1 << 21];
int mn[22];
int main() {
ios::sync_with_stdio(false);
cin >> n >> m;
for (int i = 0; i < (n); ++i) cin >> s[i];
for (int i = 0; i < (n); ++i) mn[i] = INF;
for (int i = 0; i < (n); ++i)
for (int j = 0; j < (m); ++j) {
cin >> a[i][j];
mn[i] = min(mn[i], a[i][j]);
}
for (int j = 0; j < (m); ++j)
for (int c = 0; c < (26); ++c) {
int sum = 0, mx = 0;
for (int i = 0; i < (n); ++i)
if (s[i][j] - 'a' == c) {
sum += a[i][j], mx = max(mx, a[i][j]), diff[j][c] |= 1 << i;
}
cost[j][c] = sum - mx;
}
for (int mask = 0; mask < (1 << n); ++mask)
dp[mask] = INF, low[mask] = (mask & 1 ? low[mask >> 1] + 1 : 0);
dp[0] = 0;
for (int mask = 0; mask < (1 << n); ++mask) {
int i = low[mask];
dp[mask | (1 << i)] = min(dp[mask | (1 << i)], dp[mask] + mn[i]);
for (int j = 0; j < (m); ++j)
dp[mask | diff[j][s[i][j] - 'a']] = min(
dp[mask | diff[j][s[i][j] - 'a']], dp[mask] + cost[j][s[i][j] - 'a']);
}
cout << dp[(1 << n) - 1] << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 20;
const int INF = 0x3f3f3f3f;
char s[MAXN][MAXN + 5];
int a[MAXN][MAXN], v[MAXN][MAXN], c[MAXN][MAXN], dp[1 << MAXN];
int main() {
int n, m;
scanf("%d%d", &n, &m);
for (int i = 0; i < n; i++) scanf("%s", s[i]);
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++) scanf("%d", &a[i][j]);
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++) {
int mx = 0;
for (int k = 0; k < n; k++)
if (s[k][j] == s[i][j]) {
v[i][j] |= (1 << k);
c[i][j] += a[k][j];
mx = max(mx, a[k][j]);
}
c[i][j] -= mx;
}
memset(dp, INF, sizeof(dp));
dp[(1 << n) - 1] = 0;
for (int mask = (1 << n) - 1; mask > 0; mask--)
for (int i = 0; i < n; i++) {
if (~mask & (1 << i)) continue;
for (int j = 0; j < m; j++) {
dp[mask ^ (1 << i)] = min(dp[mask ^ (1 << i)], dp[mask] + a[i][j]);
dp[mask & (mask ^ v[i][j])] =
min(dp[mask & (mask ^ v[i][j])], dp[mask] + c[i][j]);
}
break;
}
return 0 * printf("%d", dp[0]);
}
|
#include <bits/stdc++.h>
using namespace std;
template <typename T>
T gcd(T first, T second) {
while (second > 0) {
first %= second;
swap(first, second);
}
return first;
}
template <class _T>
inline _T sqr(const _T &first) {
return first * first;
}
template <class _T>
inline string tostr(const _T &a) {
ostringstream os("");
os << a;
return os.str();
}
const long double PI = 3.1415926535897932384626433832795L;
template <typename T>
inline void input(T &a) {
static int ed;
a = 0;
while (!isdigit(ed = getchar()) && ed != '-') {
}
char neg = 0;
if (ed == '-') {
neg = 1;
ed = getchar();
}
while (isdigit(ed)) {
a = 10 * a + ed - '0';
ed = getchar();
}
if (neg) a = -a;
}
template <typename T = int>
inline T nxt() {
T res;
input(res);
return res;
}
mt19937 generator;
const int N = 3000;
int dist[N][N];
vector<int> g[N];
int n;
void calc(int v) {
int *d = dist[v];
memset(d, 0x3f, n * sizeof(int));
d[v] = 0;
queue<int> q;
q.push(v);
while (!q.empty()) {
int z = q.front();
q.pop();
for (int to : g[z]) {
if (d[to] > n) {
d[to] = d[z] + 1;
q.push(to);
}
}
}
}
int main() {
int n = nxt();
int m = nxt();
string s[n];
for (int i = 0; i < n; ++i) {
cin >> s[i];
}
int cost[n][m];
for (int i = 0; i < n; ++i) {
for (int j = 0; j < m; ++j) {
cost[i][j] = nxt();
}
}
vector<pair<int, int> > delta;
for (int i = 0; i < n; ++i) {
int best = INT_MAX;
for (int j = 0; j < m; ++j) {
best = min(best, cost[i][j]);
}
delta.push_back({1 << i, best});
}
int ids[n];
for (int j = 0; j < n; ++j) {
ids[j] = j;
}
for (int i = 0; i < m; ++i) {
sort(ids, ids + n, [&](int u, int v) { return s[u][i] < s[v][i]; });
int sum[n + 1];
sum[0] = 0;
for (int j = 0; j < n; ++j) {
sum[j + 1] = sum[j] + cost[ids[j]][i];
}
for (int j = 0; j < n; ++j) {
int k = j;
int mask = 0;
while (k < n && s[ids[k]][i] == s[ids[j]][i]) {
mask |= 1 << ids[k];
++k;
}
int best = INT_MAX;
for (int l = j; l < k; ++l) {
best = min(best, sum[k] - sum[j] - cost[ids[l]][i]);
}
delta.push_back({mask, best});
j = k - 1;
}
}
int dp[1 << n];
memset(dp, 0x3f, sizeof(dp));
dp[0] = 0;
for (int i = 0; i < (1 << n); ++i) {
for (auto z : delta) {
dp[i | z.first] = min(dp[i | z.first], dp[i] + z.second);
}
}
cout << dp[(1 << n) - 1] << "\n";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
string s[25];
int a[25][25];
int n, m;
vector<int> groups, costs;
int mem[1 << 20];
int best[20];
bool v[1 << 20];
int solve(int msk) {
if (msk == (1 << n) - 1) return 0;
if (v[msk]) return mem[msk];
v[msk] = true;
int ans = 1e9;
;
for (int i = 0; i < n; i++)
if (!(msk & (1 << i))) ans = min(ans, best[i] + solve(msk | (1 << i)));
for (int i = 0; i < int(groups.size()); i++) {
int group = groups[i];
int cost = costs[i];
if ((msk | group) == msk) continue;
ans = min(ans, cost + solve(msk | group));
}
return mem[msk] = ans;
}
bool easy(int ind) {
for (int col = 0; col < m; col++) {
bool valid = true;
for (int i = 0; i < n; i++) {
if (i == ind) continue;
if (s[i][col] == s[ind][col]) valid = false;
}
if (valid) return true;
}
return false;
}
int main() {
ios::sync_with_stdio(false);
cin >> n >> m;
for (int i = 0; i < n; i++) cin >> s[i];
for (int i = 0; i < n; i++) {
best[i] = 1e9;
;
for (int j = 0; j < m; j++) {
cin >> a[i][j];
best[i] = min(best[i], a[i][j]);
}
}
for (int col = 0; col < m; col++) {
for (int c = 0; c < 26; c++) {
int msk = 0;
int cost = 0;
int maxCost = 0;
int cnt = 0;
for (int i = 0; i < n; i++) {
if (s[i][col] != c + 'a') continue;
msk |= (1 << i);
cost += a[i][col];
maxCost = max(maxCost, a[i][col]);
cnt++;
}
if (cnt > 1) groups.push_back(msk), costs.push_back(cost - maxCost);
}
}
int msk = 0;
for (int i = 0; i < n; i++)
if (easy(i)) msk |= (1 << i);
cout << solve(msk) << endl;
return 0;
}
|
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:102400000,102400000")
using namespace std;
struct NODE {
int sta;
int num;
} nodes[25][25];
int dp[1 << 20], n, m;
int num[25][25];
char str[25][25];
int main() {
while (~scanf("%d%d", &n, &m)) {
for (int i = 0; i < n; i++) {
scanf("%s", str[i]);
}
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
scanf("%d", &num[i][j]);
}
}
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
int max1 = 0;
for (int k = 0; k < n; k++) {
if (str[i][j] == str[k][j]) {
nodes[i][j].sta |= (1 << k);
nodes[i][j].num += num[k][j];
max1 = max(max1, num[k][j]);
}
}
nodes[i][j].num -= max1;
}
}
int sta = 1 << n;
for (int i = 0; i < sta; i++) {
dp[i] = 99999999;
}
dp[0] = 0;
for (int i = 1; i < sta; i++) {
int re = i, cnt = 0;
while (re) {
if (re & 1) {
for (int j = 0; j < m; j++) {
int sta1 = i & (i ^ nodes[cnt][j].sta);
dp[i] = min(dp[i], dp[sta1] + nodes[cnt][j].num);
dp[i] = min(dp[i], dp[i ^ (1 << cnt)] + num[cnt][j]);
}
}
re >>= 1;
cnt++;
}
}
printf("%d\n", dp[sta - 1]);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
using Int = long long;
template <typename T1, typename T2>
inline void chmin(T1 &a, T2 b) {
if (a > b) a = b;
}
template <typename T1, typename T2>
inline void chmax(T1 &a, T2 b) {
if (a < b) a = b;
}
const Int MAX = 22;
Int as[MAX][MAX];
signed main() {
Int n, m;
cin >> n >> m;
vector<string> ss(n);
for (Int i = 0; i < n; i++) cin >> ss[i];
for (Int i = 0; i < n; i++)
for (Int j = 0; j < m; j++) cin >> as[i][j];
using P = pair<Int, Int>;
vector<P> vp;
for (Int j = 0; j < m; j++) {
vector<Int> used(n, 0);
for (Int i = 0; i < n; i++) {
vp.emplace_back(1 << i, as[i][j]);
if (used[i]) continue;
vector<Int> vs;
for (Int k = 0; k < n; k++)
if (ss[i][j] == ss[k][j]) vs.emplace_back(k);
Int bit = 0, sum = 0, res = as[i][j];
for (Int v : vs) {
bit |= 1 << v;
sum += as[v][j];
chmax(res, as[v][j]);
used[v] = 1;
}
vp.emplace_back(bit, sum - res);
}
}
map<Int, Int> mp;
for (auto p : vp) mp[p.first] = p.second;
for (auto p : vp) chmin(mp[p.first], p.second);
vp.clear();
for (auto p : mp) vp.emplace_back(p);
const Int INF = 1e15;
Int s = 1 << n;
vector<Int> dp(s, INF);
dp[0] = 0;
for (auto p : vp)
for (Int b = 0; b < s; b++) chmin(dp[b | p.first], dp[b] + p.second);
cout << dp[s - 1] << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MN = 22;
int cost[MN][MN];
char str[MN][MN];
int dp[1 << MN];
int rem[MN];
int main() {
int n, m;
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 k = 0; k < m; ++k) scanf("%d", &cost[i][k]);
for (int i = 1; i < (1 << n); ++i) dp[i] = 1 << 28;
for (int i = 0; i < m; ++i) {
for (char a = 'a'; a <= 'z'; ++a) {
int maxi = -(1 << 28), sum = 0;
int mask = 0;
for (int k = 0; k < n; ++k)
if (str[k][i] == a) {
maxi = max(maxi, cost[k][i]);
sum += cost[k][i];
mask |= 1 << k;
}
if (mask) {
sum -= maxi;
for (int medit = 0; medit < (1 << n); ++medit)
dp[medit] = min(dp[medit], sum + dp[medit & ~mask]);
}
}
}
for (int i = 0; i < n; ++i) {
rem[i] = 1 << 28;
for (int k = 0; k < m; ++k) rem[i] = min(rem[i], cost[i][k]);
}
int res = 1 << 28;
for (int mask = 0; mask < (1 << n); ++mask) {
int val = dp[mask];
for (int i = 0; i < n; ++i)
if ((mask & (1 << i)) == 0) val += rem[i];
res = min(res, val);
}
printf("%d\n", res);
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m, a[25][25];
char s[25][25];
int nho[1500000], dp[1500000];
int mask[25][25], cp[25][25];
int calc(int x) {
if (x == 0) return 0;
if (nho[x]) return dp[x];
nho[x] = 1;
dp[x] = 2000000000;
int k = 0;
while ((x & (1 << k)) == 0) k++;
for (int j = 0; j < m; j++) {
dp[x] = min(dp[x], calc(x ^ (1 << k)) + a[k + 1][j]);
dp[x] = min(dp[x], calc(x & (x ^ mask[k + 1][j])) + cp[k + 1][j]);
}
return dp[x];
}
int main() {
scanf("%d%d\n", &n, &m);
for (int i = 1; i <= n; i++) gets(s[i]);
for (int i = 1; i <= n; i++)
for (int j = 0; j < m; j++) scanf("%d", &a[i][j]);
for (int i = 1; i <= n; i++)
for (int j = 0; j < m; j++) {
mask[i][j] = 0;
cp[i][j] = 0;
int cpmax = 0;
for (int k = 1; k <= n; k++)
if (s[i][j] == s[k][j]) {
mask[i][j] |= (1 << (k - 1));
cp[i][j] += a[k][j];
cpmax = max(cpmax, a[k][j]);
}
cp[i][j] -= cpmax;
}
memset(nho, 0, sizeof(nho));
int ans = calc((1 << n) - 1);
printf("%d", ans);
}
|
#include <bits/stdc++.h>
const int MAX = 1 << 21;
const int MAX_V = 1e3 + 5;
const int INF = 1e9 + 5;
const long long INF2 = 4e18 + 5;
const double M = 4e18;
using namespace std;
const int MOD = 1e9 + 7;
const double eps = 0.000000001;
int n, m;
int dp[MAX], cost[25][25], Max;
int col[25][25], st[25][25];
char a[25][25];
int main() {
scanf("%d%d", &n, &m);
for (int i = 0; i < n; i++) scanf("%s", a[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++) {
Max = 0;
for (int s = 0; s < n; s++) {
if (a[i][j] == a[s][j]) {
Max = max(Max, cost[s][j]);
col[i][j] += cost[s][j];
st[i][j] |= (1 << s);
}
}
col[i][j] -= Max;
}
}
Max = (1 << n) - 1;
fill(dp, dp + (1 << n), INF);
dp[0] = 0;
for (int i = 0; i < Max; i++) {
for (int j = 0; j < n; ++j) {
if (!((i >> j) & 1)) {
int now = 1 << j;
for (int s = 0; s < m; s++) {
dp[i | now] = min(dp[i | now], dp[i] + cost[j][s]);
dp[i | st[j][s]] = min(dp[i | st[j][s]], dp[i] + col[j][s]);
}
}
}
}
printf("%d\n", dp[Max]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int inf = 1e9, maxn = 22;
int n, m;
char g[maxn][maxn];
int w[maxn][maxn];
int dp[1 << maxn];
int same[maxn][maxn], cost[maxn][maxn];
int main() {
scanf("%d%d", &n, &m);
for (int i = 0; i < n; i++) scanf("%s", &g[i]);
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++) scanf("%d", &w[i][j]);
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
int sumc = 0, maxc = 0;
for (int k = 0; k < n; k++)
if (g[i][j] == g[k][j]) {
sumc += w[k][j];
maxc = max(maxc, w[k][j]);
same[i][j] |= 1 << k;
}
cost[i][j] = sumc - maxc;
}
}
for (int i = 0; i < (1 << n); i++) dp[i] = inf;
dp[0] = 0;
for (int s = 0; s < (1 << n); s++) {
for (int i = 0; i < n; i++) {
if (!(s >> i & 1)) {
for (int j = 0; j < m; j++) {
dp[s | (1 << i)] = min(dp[s | (1 << i)], dp[s] + w[i][j]);
dp[s | same[i][j]] = min(dp[s | same[i][j]], dp[s] + cost[i][j]);
}
}
}
}
printf("%d", dp[(1 << n) - 1]);
return 0;
}
|
#include <bits/stdc++.h>
#pragma comment(linker, "/stack:200000000")
#pragma GCC optimize("Ofast")
#pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,tune=native")
using namespace std;
const int N = 20;
const int inf = (int)1e9 + 1;
const long long big = (long long)1e18 + 1;
const int P = 239;
const int MOD = (int)1e9 + 7;
const int MOD1 = (int)1e9 + 9;
const double eps = 1e-9;
const double pi = atan2(0, -1);
const int ABC = 26;
inline void upd(int &x, int y) { y < x ? x = y : 0; }
string a[N];
int cost[N][N];
int sum[N][26];
int max_sum[N][26];
int bits[N][26];
vector<int> var[N][26];
int dp[2][2][1 << N];
set<int> diff[N];
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.precision(20);
cout << fixed;
int n, m;
cin >> n >> m;
for (int i = 0; i < n; i++) cin >> a[i];
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++) cin >> cost[i][j];
for (int j = 0; j < m; j++)
for (int i = 0; i < n; i++) {
sum[j][a[i][j] - 'a'] += cost[i][j];
max_sum[j][a[i][j] - 'a'] = max(max_sum[j][a[i][j] - 'a'], cost[i][j]);
bits[j][a[i][j] - 'a'] |= (1 << i);
var[j][a[i][j] - 'a'].push_back(i);
diff[j].insert(a[i][j] - 'a');
}
int p = 0, p1 = 0;
for (int mask = 0; mask < (1 << n); mask++) dp[p][p1][mask] = inf;
dp[p][p1][0] = 0;
for (int j = 0; j < m; j++) {
for (int c : diff[j]) {
for (int mask = 0; mask < (1 << n); mask++) dp[p][p1 ^ 1][mask] = inf;
for (int mask = 0; mask < (1 << n); mask++) {
if (dp[p][p1][mask] == inf) continue;
upd(dp[p][p1 ^ 1][mask], dp[p][p1][mask]);
int v = sum[j][c] - max_sum[j][c];
upd(dp[p][p1 ^ 1][mask | bits[j][c]], dp[p][p1][mask] + v);
for (int &i : var[j][c])
upd(dp[p][p1][mask | (1 << i)], dp[p][p1][mask] + cost[i][j]);
}
p1 ^= 1;
}
for (int mask = 0; mask < (1 << n); mask++)
dp[p ^ 1][0][mask] = dp[p][p1][mask];
p ^= 1;
p1 = 0;
}
cout << dp[p][p1][(1 << n) - 1] << "\n";
return 0;
}
|
#include <bits/stdc++.h>
int a[22][22];
int f[1 << 20];
int cost[22][22];
int state[22][22];
char s[22][22];
void Min(int &x, int y) {
if (x == -1 || y < x) {
x = y;
}
}
int main() {
int n, m;
scanf("%d%d", &n, &m);
for (int i = 0; i < n; i++) {
scanf("%s", s[i]);
}
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
scanf("%d", &a[i][j]);
}
}
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
int sum = 0, mx = 0;
for (int k = 0; k < n; k++)
if (s[k][j] == s[i][j]) {
if (a[k][j] > mx) {
mx = a[k][j];
}
sum += a[k][j];
state[i][j] |= 1 << k;
}
cost[i][j] = sum - mx;
}
}
memset(f, -1, sizeof(f));
f[0] = 0;
for (int i = 0; i < (1 << n); i++)
if (f[i] != -1) {
int id = -1;
for (int j = 0; j < n; j++)
if (!(i >> j & 1)) {
id = j;
break;
}
if (id == -1) {
break;
}
for (int k = 0; k < m; k++) {
Min(f[i | (1 << id)], f[i] + a[id][k]);
Min(f[i | state[id][k]], f[i] + cost[id][k]);
}
}
printf("%d\n", f[(1 << n) - 1]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m;
string s[30];
int c[30][30];
int c2[30][30];
int c3[30][30];
long long dp[1 << 21];
inline int lowbit(int x) {
for (int i = 0; i < 32; i++) {
if (x & 1) return i;
x >>= 1;
}
return 0;
}
void printstg(int s) {
for (int i = 0; i < n; i++) {
cout << (bool)(s & (1 << i)) << " ";
}
}
int main() {
cin >> n >> m;
for (int i = 0; i < n; i++) cin >> s[i];
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
scanf("%d", &c[i][j]);
}
}
for (int i = 0; i < m; i++) {
for (int j = 0; j < n; j++) {
int maxx = 0, sum = 0, mask = 0;
for (int k = 0; k < n; k++) {
if (s[j][i] == s[k][i]) {
mask += (1 << k);
maxx = max(c[k][i], maxx);
sum += c[k][i];
}
}
c2[j][i] = sum - maxx;
c3[j][i] = mask;
}
}
memset(dp, 0x3f, sizeof dp);
dp[(1 << n) - 1] = 0;
for (int stg = (1 << n) - 1; stg > 0; stg--) {
int u = lowbit(stg);
for (int w = 0; w < m; w++) {
int dif1 = (1 << u);
if (dif1 > stg) return 1;
long long &val = dp[stg - dif1];
val = min(val, dp[stg] + c[u][w]);
int dif2 = 0, cost = 0, maxx = 0;
long long &val2 = dp[stg & (~c3[u][w])];
val2 = min(val2, dp[stg] + c2[u][w]);
}
}
cout << dp[0] << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long mod = 1000000007;
long long powmod(long long a, long long b) {
long long res = 1;
a %= mod;
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 N = 20;
const int M = 30;
char s[N][M];
int a[N][M], t[N][M], c[N][M];
int dp[(1 << N) + 5];
int main() {
int n, m;
scanf("%d%d", &n, &m);
for (int i = 0; i < n; ++i) scanf("%s", s + i);
for (int i = 0; i < n; ++i)
for (int j = 0; j < m; ++j) scanf("%d", &a[i][j]);
for (int i = 0; i < n; ++i)
for (int j = 0; j < m; ++j) {
int maxc = 0;
for (int k = 0; k < n; ++k)
if (s[i][j] == s[k][j]) {
t[i][j] |= (1 << k);
c[i][j] += a[k][j];
maxc = max(maxc, a[k][j]);
}
c[i][j] -= maxc;
}
memset(dp, 0x3f, sizeof(dp));
dp[0] = 0;
for (int mk = 1; mk < (1 << n); ++mk) {
int lowbit;
for (int i = 0; i < n; ++i)
if (mk & (1 << i)) {
lowbit = i;
break;
}
for (int i = 0; i < m; ++i) {
dp[mk] = min(dp[mk], dp[mk & (mk ^ t[lowbit][i])] + c[lowbit][i]);
dp[mk] = min(dp[mk], dp[mk ^ (1 << lowbit)] + a[lowbit][i]);
}
}
printf("%d\n", dp[(1 << n) - 1]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int a[23][23];
char s[23][23];
int dp[1 << 23];
int n, m;
int cost[23][23];
int st[23][23];
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++) {
int mx = -0x3f3f3f3f;
int ans = 0;
for (int k = 0; k < n; k++) {
if (s[i][j] == s[k][j]) {
ans += a[k][j];
mx = max(mx, a[k][j]);
st[i][j] |= 1 << k;
}
}
ans -= mx;
cost[i][j] = ans;
}
for (int i = 1; i < (1 << n); i++) dp[i] = 0x3f3f3f3f;
dp[0] = 0;
for (int i = 0; i < (1 << n); i++)
for (int j = 0; j < n; j++)
if ((i & (1 << j)) == 0) {
for (int k = 0; k < m; k++) {
dp[i | (1 << j)] = min(dp[i | (1 << j)], dp[i] + a[j][k]);
dp[i | st[j][k]] = min(dp[i | st[j][k]], dp[i] + cost[j][k]);
}
}
printf("%d\n", dp[(1 << n) - 1]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 21;
long long a[N][N], f[1 << N], inf;
int n, m;
char str[N][N];
int lowb(int s) {
for (int i = 0; i < n; ++i)
if (s & (1 << i)) return i;
}
void Min(long long &a, const long long &b) {
if (b < a) a = b;
}
long long dp(int s) {
if (f[s] < inf) return f[s];
int v = lowb(s);
for (int j = 0; j < m; ++j) {
long long Max = 0, sum = 0, tmp = s;
for (int i = 0; i < n; ++i)
if (str[i][j] == str[v][j]) {
Max = max(Max, a[i][j]);
sum += a[i][j];
if (tmp & (1 << i)) tmp ^= 1 << i;
}
Min(f[s], sum - Max + dp(tmp));
Min(f[s], a[v][j] + dp(s ^ (1 << v)));
}
return f[s];
}
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("%lld", a[i] + j);
memset(f, 63, sizeof(f));
inf = f[0];
f[0] = 0;
printf("%lld\n", dp((1 << n) - 1));
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 20;
typedef int array[maxn];
int n, m, top;
char s[maxn][maxn];
int a[maxn][maxn], mina[maxn];
int f[1 << maxn], g[maxn * maxn], v[maxn * maxn];
int cnt[maxn][26], sum[maxn][26], maxv[maxn][26], S[maxn][26];
int main() {
cin >> n >> m;
for (int i = 0; i < n; i++) cin >> s[i];
for (int i = 0; i < n; i++) {
mina[i] = INT_MAX;
for (int j = 0; j < m; j++) {
cin >> a[i][j];
mina[i] = min(mina[i], a[i][j]);
}
}
for (int j = 0; j < m; j++) {
for (int i = 0; i < n; i++) {
cnt[j][s[i][j] - 'a']++;
sum[j][s[i][j] - 'a'] += a[i][j];
maxv[j][s[i][j] - 'a'] = max(maxv[j][s[i][j] - 'a'], a[i][j]);
S[j][s[i][j] - 'a'] |= (1 << i);
}
for (int i = 0; i < 26; i++)
if (cnt[j][i] > 1) {
top++;
g[top] = S[j][i];
v[top] = sum[j][i] - maxv[j][i];
}
}
int S = 0;
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++)
if (cnt[j][s[i][j] - 'a'] == 1) S |= (1 << i);
for (int i = 0; i < (1 << n); i++) f[i] = INT_MAX;
f[S] = 0;
for (int i = S; i < (1 << n); i++)
if (f[i] != INT_MAX) {
for (int j = 1; j <= top; j++)
f[i | g[j]] = min(f[i | g[j]], f[i] + v[j]);
for (int j = 0; j < n; j++)
f[i | (1 << j)] = min(f[i | (1 << j)], f[i] + mina[j]);
}
cout << f[(1 << n) - 1] << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int inf = 0x3f3f3f3f, mod = 1e9 + 7;
const int maxn = 2e6 + 100, mxn = 5e5 + 100;
const long double PI = acos(-1.0);
long long gcd(long long a, long long b) { return (a ? gcd(b % a, a) : b); }
void exgcd(long long a, long long b, long long& d, long long& x, long long& y) {
if (!b) {
d = a;
x = 1;
y = 0;
} else {
exgcd(b, a % b, d, y, x);
y -= x * (a / b);
}
}
long long power(long long a, long long n) {
long long p = 1;
while (n > 0) {
if (n % 2) {
p = p * a;
}
n >>= 1;
a *= a;
}
return p;
}
long long power(long long a, long long n, long long mod) {
long long p = 1;
while (n > 0) {
if (n % 2) {
p = p * a;
p %= mod;
}
n >>= 1;
a *= a;
a %= mod;
}
return p % mod;
}
int n, m;
int dp[maxn], va[25][25], voil[25][25], sv[25][25];
char s[25][25];
vector<int> con;
int po[30];
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", &va[i][j]);
for (int i = 0; i <= 20; i++) po[i] = (1 << i);
memset(dp, 0, sizeof dp);
memset(voil, 0, sizeof voil);
memset(sv, 0, sizeof sv);
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++) {
int mm = 0;
for (int k = 0; k < n; k++)
if (s[k][j] == s[i][j]) {
voil[i][j] += po[k];
mm = max(mm, va[k][j]);
sv[i][j] += va[k][j];
}
sv[i][j] -= mm;
}
for (int i = 1; i < 1 << n; i++) {
int cur = 0, g = i;
con.clear();
while (g % 2 == 0) {
cur++;
g = g >> 1;
}
g = 1 << cur;
g = i - g;
int gg = g;
int minn = inf;
for (int j = 0; j < m; j++) {
minn = min(minn, dp[i & (i ^ voil[cur][j])] + sv[cur][j]);
minn = min(minn, dp[gg] + va[cur][j]);
}
dp[i] = minn;
}
cout << dp[(1 << n) - 1] << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 21, MAXN = (1 << N);
int n, m, dp[MAXN];
int a[N][N];
char s[N][N];
int ss[N][N], ms[N][N];
void init() {
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++) {
ss[i][j] = (1 << (i - 1));
ms[i][j] = a[i][j];
int sum = a[i][j];
for (int k = 1; k <= n; k++)
if (i != k) {
if (s[i][j] == s[k][j]) {
ss[i][j] |= (1 << (k - 1));
ms[i][j] = max(a[k][j], ms[i][j]);
sum += a[k][j];
}
}
ms[i][j] = sum - ms[i][j];
}
}
}
int dfs(int S) {
if (dp[S] < 0x3f3f3f3f) return dp[S];
if (S == (1 << n) - 1) return 0;
int ans = 0x3f3f3f3f, low;
for (int i = 1; i <= n; i++) {
if ((S & (1 << (i - 1))) == 0) {
low = i;
break;
}
}
for (int j = 1; j <= m; j++) {
ans = min(ans, min(dfs(S | (1 << (low - 1))) + a[low][j],
dfs(S | ss[low][j]) + ms[low][j]));
}
return dp[S] = ans;
}
int main() {
init();
memset(dp, 0x3f, sizeof(dp));
printf("%d\n", dfs(0));
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long maxn = 25, maxs = 1048576 + 10;
long long n, m, INF;
char a[maxn][maxn];
long long cost[maxn][maxn], ss[maxn][maxn], sc[maxn][maxn];
long long f[maxs];
inline long long read() {
long long ret = 0, f = 1;
char ch = getchar();
while (ch < '0' || ch > '9') {
if (ch == '-') f = -1;
ch = getchar();
}
while (ch >= '0' && ch <= '9') ret = ret * 10 + ch - '0', ch = getchar();
return ret * f;
}
signed main() {
n = read();
m = read();
for (long long i = 0; i < n; i++) scanf("%s+1", a[i]);
for (long long i = 0; i < n; i++) {
for (long long j = 0; j < m; j++) cost[i][j] = read();
}
memset(f, 63, sizeof(f));
INF = f[0];
long long init_s = 0;
for (long long i = 0; i < n; i++) {
for (long long j = 0; j < m; j++) {
bool flg = true;
for (long long k = 0; k < n; k++)
if (k != i && a[i][j] == a[k][j]) {
flg = false;
break;
}
if (flg) {
init_s += 1 << i;
break;
}
}
}
for (long long i = 0; i < n; i++) {
for (long long j = 0; j < m; j++) {
for (long long k = 0; k < n; k++)
if (k != i && a[i][j] == a[k][j]) {
ss[i][j] += 1 << k;
sc[i][j] += cost[k][j];
}
}
}
f[init_s] = 0;
long long alls = 1 << n;
for (long long s = 0; s < alls; s++)
if (f[s] != INF) {
for (long long i = 0; i < n; i++)
if ((s & (1 << i)) == 0) {
long long nxt_s = s + (1 << i);
for (long long j = 0; j < m; j++) {
f[nxt_s] = min(f[nxt_s], f[s] + cost[i][j]);
}
for (long long j = 0; j < m; j++) {
nxt_s = (s + (1 << i)) | ss[i][j];
f[nxt_s] = min(f[nxt_s], f[s] + sc[i][j]);
}
}
}
printf("%lld\n", f[alls - 1]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m;
char mapp[25][25];
int cost[25][25];
vector<int> comb[200];
int rowc[25];
int cbcnt[200];
int top;
int rout[25] = {};
map<long long, int> f;
int make(int k, int *out) {
vector<int> &v = comb[k];
int len = v.size();
int cnt = 0;
for (int i = 0; i < len; ++i) {
if (!out[v[i]]) {
out[v[i]] = 1;
cnt += rowc[v[i]];
}
}
return cnt;
}
int dfs(int k, int *out, int lf) {
int res = lf;
int i, j;
int *nout = new int[25];
int nlf;
int cnt;
int t;
for (i = k; i < top; ++i) {
memcpy(nout, out, 25 * sizeof(int));
cnt = make(i, nout);
if (cbcnt[i] < cnt) {
t = dfs(i + 1, nout, lf - cnt);
res = min(res, t + cbcnt[i]);
}
}
return res;
}
void init() {
int i, j;
int t;
for (i = 0; i < n; ++i) {
t = cost[i][0];
for (j = 0; j < m; ++j) t = min(t, cost[i][j]);
rowc[i] = t;
}
vector<int> s;
int sum, maxx;
for (j = 0; j < m; ++j) {
s.clear();
for (char c = 'a'; c <= 'z'; ++c) {
sum = 0;
maxx = 0;
for (i = 0; i < n; ++i) {
if (mapp[i][j] == c) {
s.push_back(i);
sum += cost[i][j];
maxx = max(maxx, cost[i][j]);
}
}
if (s.size() > 1) {
s.swap(comb[top]);
cbcnt[top] = sum - maxx;
++top;
} else if (s.size() == 1) {
rout[s[0]] = 1;
}
}
}
}
int main() {
cin >> n >> m;
for (int i = 0; i < n; ++i) {
cin >> mapp[i];
}
int i, j;
for (i = 0; i < n; ++i)
for (j = 0; j < m; ++j) cin >> cost[i][j];
init();
int lf = 0;
for (i = 0; i < n; ++i) {
if (!rout[i]) lf += rowc[i];
}
int res = dfs(0, rout, lf);
cout << res << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 3e5 + 10;
const long long MOD = 1e9 + 9;
inline long long in() {
long long x = 0, flag = 1;
char ch = getchar();
while (ch < '0' || ch > '9') {
if (ch == '-') flag = -1;
ch = getchar();
}
while (ch >= '0' && ch <= '9')
x = (x << 3) + (x << 1) + (ch ^ 48), ch = getchar();
return x * flag;
}
inline char incha() {
char ch = getchar();
while (ch < 'a' || ch > 'z') ch = getchar();
return ch;
}
int n, m;
char ch[23][23];
int cost[23][23];
int getdif() {
int ret = 0;
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
int cnt = 0;
for (int k = 1; k <= n; k++) cnt += (ch[i][j] != ch[k][j]);
if (cnt == n - 1) ret |= (1 << (i - 1));
}
}
return ret;
}
int low0(int x) {
for (int i = 1; i <= n; i++)
if ((x & (1 << (i - 1))) == 0) return i;
return 0;
}
struct Trans {
int sta, cos;
} g[23][23][2];
int f[1 << 21];
int main() {
n = in(), m = in();
for (int i = 1; i <= n; i++)
for (int j = 1; j <= m; j++) ch[i][j] = incha();
for (int i = 1; i <= n; i++)
for (int j = 1; j <= m; j++) cost[i][j] = in();
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
g[i][j][0] = (Trans){1 << (i - 1), cost[i][j]};
int mx = 0, sum = 0, sta = 0;
for (int k = 1; k <= n; k++)
if (ch[i][j] == ch[k][j])
sum += cost[k][j], mx = max(mx, cost[k][j]), sta |= (1 << (k - 1));
g[i][j][1] = (Trans){getdif() | sta, sum - mx};
}
}
memset(f, 0x3f, sizeof f);
f[0] = 0;
for (int i = 0; i < (1 << n); i++) {
int pos = low0(i);
for (int j = 1; j <= m; j++) {
for (int k = 0; k <= 1; k++) {
int nex = i | g[pos][j][k].sta;
f[nex] = min(f[nex], f[i] + g[pos][j][k].cos);
}
}
}
cout << f[(1 << n) - 1] << endl;
return 0;
}
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.