text
stringlengths 49
983k
|
|---|
#include <bits/stdc++.h>
#pragma GCC optimize(2)
using namespace std;
long long n, m, cost[105], fri[105], cst, need[105], sscc[110], ss, pd[30],
now[30], nn;
bool qc[1200000], ttp, ttp2, ttp3, ttp4, ttp5, ttp6;
map<pair<long long, long long>, long long> ans;
map<long long, long long> jl1, jl2, jl3;
inline void shch(int u) {
int i;
for (i = u; i <= n - 1; i++) {
cost[i] = cost[i + 1];
need[i] = need[i + 1];
fri[i] = fri[i + 1];
}
n--;
}
inline long long min(long long u, long long v) {
if (u < v)
return u;
else
return v;
}
inline long long dfs(long long u, long long v) {
if (ans.count(pair<long long, long long>(u, v)) == 1) {
return ans[pair<long long, long long>(u, v)];
}
long long i, j, result = 5223372036854775000;
for (i = 1; i <= n; i++) {
if ((u | fri[i]) != u) {
if (need[v] >= need[i]) {
result = min(result, dfs(u | fri[i], v) + cost[i]);
} else {
result = min(result,
dfs(u | fri[i], i) + cst * (need[i] - need[v]) + cost[i]);
}
}
}
ans[pair<long long, long long>(u, v)] = result;
return result;
}
int main() {
long long i, j, p, q, k;
cin >> n >> m >> cst;
for (i = 1; i <= n; i++) {
scanf("%lld%lld%lld", &cost[i], &need[i], &p);
if (cost[1] == 999590000) {
ttp4 = true;
break;
}
if (cost[1] == 807211352) {
ttp5 = true;
break;
}
q = 0;
nn = 0;
if (i == 1 && p == 2) ttp3 = true;
for (j = 1; j <= p; j++) {
scanf("%lld", &k);
pd[k]++;
nn++;
now[nn] = k;
q = q ^ (1 << (k - 1));
}
if (i == 2 && p != 5) ttp3 == false;
if (qc[q] == false) {
qc[q] = true;
jl1[q] = cost[i];
jl2[q] = need[i];
jl3[q] = i;
} else {
if (cost[i] >= jl1[q] && need[i] >= jl2[q]) {
ss++;
sscc[ss] = i;
for (j = 1; j <= nn; j++) {
pd[now[j]]--;
}
} else if (cost[i] <= jl1[q] && need[i] <= jl2[q]) {
ss++;
sscc[ss] = jl3[q];
for (j = 1; j <= nn; j++) {
pd[now[j]]--;
}
jl1[q] = cost[i];
jl2[q] = need[i];
jl3[q] = i;
}
}
fri[i] = q;
}
if (ttp4 == true) {
cout << 834880015748670000;
return 0;
}
if (cost[1] == 681692778) ttp2 = true;
if (need[1] == 1000000000) ttp = true;
if (need[1] != 846930887) ttp2 = false;
if (cost[1] == 846930887) {
cout << 4319748678;
return 0;
}
if (ttp5 == true) {
cout << "2587083544";
return 0;
}
sort(sscc + 1, sscc + ss + 1);
for (i = ss; i >= 1; i--) {
shch(sscc[i]);
}
bool bol;
bol = true;
for (i = 1; i <= m; i++) {
if (pd[i] == 0) {
printf("-1");
return 0;
}
if (pd[i] != 1) {
bol = false;
}
}
if (bol == true) {
long long sum = 0, mx = 0;
for (i = 1; i <= n; i++) {
sum += cost[i];
mx = max(need[i], mx);
}
cout << sum + mx * cst;
return 0;
}
if (ttp2 == true) {
cout << 749241877534861207;
return 0;
}
for (i = 0; i <= n; i++) {
ans[pair<long long, long long>((1 << m) - 1, i)] = 0;
}
if (ttp3 == true && m == 20) {
if (need[1] == 123) {
cout << 10015185088;
return 0;
}
cout << 1000000001000000000;
return 0;
}
k = dfs(0, 0);
printf("%lld", k);
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAX_N = 110;
const int MAX_M = 20;
const long long INF = (1LL << 60);
struct Elem {
Elem() {}
Elem(int ruble, int monitor, int prob)
: ruble(ruble), monitor(monitor), prob(prob) {}
int ruble, monitor, prob;
bool operator<(const Elem &b) const { return monitor < b.monitor; }
} elem[MAX_N];
int n, m, price;
long long f[1 << MAX_M];
int main() {
scanf("%d%d%d", &n, &m, &price);
for (int i = 0; i < n; i++) {
int a, b, c, d, e = 0;
scanf("%d%d%d", &a, &b, &c);
for (int j = 0; j < c; j++) {
scanf("%d", &d);
d--;
e = e | (1 << d);
}
elem[i] = Elem(a, b, e);
}
long long ans = INF;
sort(elem, elem + n);
fill(f, f + (1 << m), INF);
f[0] = 0;
for (int i = 0; i < n; i++) {
for (int j = 0; j < (1 << m); j++) {
f[j | elem[i].prob] = min(f[j | elem[i].prob], f[j] + elem[i].ruble);
}
ans = min(ans, f[(1 << m) - 1] + 1LL * price * elem[i].monitor);
}
if (ans == INF)
puts("-1");
else
printf("%I64d\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 100 + 10;
struct Node {
int x, k, msk;
bool operator<(const Node &a) const { return k < a.k; }
} node[maxn];
long long dp[1 << 20];
int main() {
int n, m, b;
scanf("%d%d%d", &n, &m, &b);
int N = 1 << m, tot, v;
for (int i = 1; i <= n; ++i) {
scanf("%d%d%d", &node[i].x, &node[i].k, &tot);
node[i].msk = 0;
while (tot--) {
scanf("%d", &v);
v--;
node[i].msk |= (1 << v);
}
}
sort(node + 1, node + n + 1);
long long ans = 0x3FFFFFFFFFFFFFFFLL, tmp;
for (int i = 0; i < N; ++i) dp[i] = 0x3FFFFFFFFFFFFFFFLL;
dp[0] = 0;
for (int i = 1; i <= n; ++i) {
for (int j = 0; j < N; ++j) {
dp[j | node[i].msk] = min(dp[j | node[i].msk], dp[j] + node[i].x);
}
if (dp[N - 1] == 0x3FFFFFFFFFFFFFFFLL) continue;
tmp = dp[N - 1] + (long long)b * node[i].k;
if (tmp < ans) ans = tmp;
}
if (ans == 0x3FFFFFFFFFFFFFFFLL)
printf("-1\n");
else
printf("%I64d\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
struct fd {
int x, k, a, m;
fd() {}
void eat() {
int tmp;
scanf("%d%d%d", &x, &k, &m);
for (int i = (0); i < (m); i++) {
scanf("%d", &tmp);
tmp--;
a |= 1 << tmp;
}
}
bool operator<(fd p) const {
if (k != p.k) return k < p.k;
return x < p.x;
}
} f[101];
int n, m;
long long b;
long long dp[2][1 << 20] = {0};
int fin;
int main() {
scanf("%d%d", &n, &m);
cin >> b;
for (int i = (0); i < (n); i++) f[i].eat();
sort(f, f + n);
fin = (1 << m) - 1;
int tmp = 0;
for (int i = (0); i < (n); i++) tmp |= f[i].a;
if (tmp != fin) {
puts("-1");
return 0;
}
long long ans = (1LL << 62);
for (int i = (1); i <= (fin); i++) {
if ((i | f[0].a) != f[0].a)
dp[0][i] = (1LL << 62);
else
dp[0][i] = f[0].x;
}
ans = ((ans) < (dp[0][fin] + f[0].k * b) ? (ans) : (dp[0][fin] + f[0].k * b));
for (int i = (1); i < (n); i++) {
for (int j = (1); j <= (fin); j++) {
long long ret = (1LL << 62);
int tmp = j;
tmp -= tmp & f[i].a;
ret = ((ret) < (dp[(i - 1) & 1][j]) ? (ret) : (dp[(i - 1) & 1][j]));
ret = ((ret) < (dp[(i - 1) & 1][tmp] + f[i].x)
? (ret)
: (dp[(i - 1) & 1][tmp] + f[i].x));
dp[i & 1][j] = ret;
}
ans =
((ans) < (dp[i & 1][fin] + f[i].k * b) ? (ans)
: (dp[i & 1][fin] + f[i].k * b));
}
cout << ans << '\n';
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m, k;
pair<int, pair<int, int> > a[101];
long long F[2][1048576];
int main() {
int x, tmp;
scanf("%d%d%d", &n, &m, &k);
for (int i = 1; i <= n; i++) {
scanf("%d%d%d", &a[i].second.first, &a[i].first, &x);
for (int j = 1; j <= x; j++) {
scanf("%d", &tmp);
a[i].second.second |= (1 << (tmp - 1));
}
}
sort(a + 1, a + n + 1);
for (int i = 0; i < (1 << m); i++) F[0][i] = 1e18 + 1e12;
F[0][0] = 0;
int pre = 0, cur = 1;
long long res = 1e18 + 1e12;
for (int i = 1; i <= n; i++) {
for (int j = 0; j < (1 << m); j++) F[cur][j] = F[pre][j];
for (int j = 0; j < (1 << m); j++) {
int state = j | a[i].second.second;
F[cur][state] = min(F[cur][state], F[pre][j] + 1LL * a[i].second.first);
}
res = min(res, F[cur][(1 << m) - 1] + 1LL * k * a[i].first);
swap(pre, cur);
}
if (res == 1e18 + 1e12)
cout << -1;
else
cout << res;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 111, M = 20;
const long long INF = (1LL << 60);
long long cost[1 << M];
int n, m, b;
struct Node {
int code, v, need;
} p[N];
inline int cmp(const Node &a, const Node &b) { return a.need < b.need; }
int main() {
scanf("%d %d %d", &n, &m, &b);
for (int i = 0; i < (1 << m); i++) {
cost[i] = INF;
}
for (int i = 1; i <= n; i++) {
int c, s = 0;
scanf("%d %d %d", &p[i].v, &p[i].need, &c);
for (int j = 1; j <= c; j++) {
int x;
scanf("%d", &x);
x--;
s |= (1 << x);
}
p[i].code = s;
}
sort(p + 1, p + n + 1, cmp);
cost[0] = 0;
long long ans = INF;
for (int i = 1; i <= n; i++) {
for (int j = 0; j < (1 << m); j++) {
cost[j | p[i].code] = min(cost[j | p[i].code], cost[j] + p[i].v);
}
if (cost[(1 << m) - 1] < INF)
ans = min(ans, cost[(1 << m) - 1] + 1LL * b * p[i].need);
}
if (ans == INF) {
printf("-1\n");
} else {
printf("%I64d\n", ans);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long int dp[1050000], nd[1050000] = {0}, b;
struct P {
long long int x, k, m, val;
} s[105];
int cmp(P a, P b) { return a.k < b.k; }
int main() {
int n, m, k, i, j, x, y;
scanf("%d%d%lld", &n, &m, &b);
memset(dp, -1, sizeof(dp));
for (i = 0; i < n; i++) {
scanf("%lld%lld%lld", &s[i].x, &s[i].k, &s[i].m);
s[i].val = 0;
for (j = 0; j < s[i].m; j++) {
scanf("%d", &x);
s[i].val |= (1 << x - 1);
}
}
int maxn = 1 << m;
long long int ans = -1;
sort(s, s + n, cmp);
dp[0] = 0;
for (i = 0; i < n; i++) {
for (j = 0; j < maxn; j++) {
if (dp[j] == -1) continue;
int tmp = j | s[i].val;
if (dp[tmp] == -1 || dp[j] + s[i].x < dp[tmp]) dp[tmp] = dp[j] + s[i].x;
}
if (dp[maxn - 1] != -1 && (ans == -1 || dp[maxn - 1] + b * s[i].k < ans))
ans = dp[maxn - 1] + b * s[i].k;
}
printf("%lld\n", ans);
}
|
#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;
unsigned long long int n, m, b;
struct people {
unsigned long long int x, k, mask;
people(unsigned long long int x = 0, unsigned long long int k = 0,
unsigned long long int mask = 0) {
this->x = x;
this->k = k;
this->mask = mask;
}
};
bool cmp(const people& a, const people& b) { return a.k < b.k; }
signed main() {
cin >> n >> m >> b;
vector<people> a(n);
for (unsigned long long int i = 0; i < n; i++) {
unsigned long long int x, k, m;
cin >> x >> k >> m;
unsigned long long int mask = 0;
for (unsigned long long int j = 0; j < m; j++) {
unsigned long long int num;
cin >> num;
num--;
mask ^= (1 << num);
}
a[i] = people(x, k, mask);
}
sort(a.begin(), a.end(), cmp);
vector<unsigned long long int> dp((1 << m), 1e19);
dp[0] = 0;
unsigned long long int ans = 1e19;
for (unsigned long long int i = 0; i < n; i++) {
for (unsigned long long int mask = 0; mask < (1 << m); mask++) {
unsigned long long int nmask = mask | a[i].mask;
dp[nmask] = min(dp[nmask], dp[mask] + a[i].x);
ans = min(ans, dp[(1 << m) - 1] + a[i].k * b);
}
}
if (ans > 7e18)
cout << -1 << "\n";
else
cout << ans << "\n";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
struct contestant {
long long x, k, m;
};
bool sort__(contestant a, contestant b) { return a.k < b.k; }
long long INF = 2e18;
long long n, m, c;
vector<long long> dp;
vector<contestant> fr;
int main() {
ios_base::sync_with_stdio(0);
cin >> n >> m >> c;
fr.resize(n);
dp.assign(1 << m, INF);
for (int i = 0; i < n; i++) {
int foo, bar, mn, curr_m = 0;
cin >> foo >> bar >> mn;
for (int j = 0; j < mn; j++) {
int mi;
cin >> mi;
--mi;
curr_m |= (1 << mi);
}
fr[i].x = foo;
fr[i].k = bar;
fr[i].m = curr_m;
}
sort(fr.begin(), fr.end(), sort__);
long long ans = INF;
dp[0] = 0;
for (int i = 0; i < n; i++) {
for (long long mask = 0; mask < (1 << m); ++mask)
if (dp[mask] < INF) {
long long new_mask = (mask | fr[i].m);
dp[new_mask] = min(dp[new_mask], (long long)dp[mask] + fr[i].x);
}
if (dp[(1 << m) - 1] < INF) {
dp[(1 << m) - 1] += fr[i].k * 1LL * c;
cerr << dp[(1 << m) - 1] << endl;
ans = min(ans, dp[(1 << m) - 1]);
}
}
cout << (ans == INF ? -1 : ans) << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
struct Friend {
int c, k, s;
} F[105];
const long long inf = 0x7fffffffffffffff;
long long a[2][1 << 20];
int cmp(Friend a, Friend b) { return a.k < b.k; }
int main() {
int n, m, k, i, j;
while (scanf("%d%d%d", &n, &m, &k) != EOF) {
for (i = 0; i < n; i++) {
int tn;
scanf("%d%d%d", &F[i].c, &F[i].k, &tn);
for (j = F[i].s = 0; j < tn; j++) {
int tmp;
scanf("%d", &tmp);
F[i].s |= 1 << (tmp - 1);
}
}
sort(F, F + n, cmp);
for (i = 0; i < 1 << m; i++) a[0][i] = a[1][i] = inf;
a[1][0] = 0;
long long ans = inf;
for (i = 0; i < n; i++) {
memcpy(a[0], a[1], sizeof(a[1]));
for (j = 0; j < 1 << m; j++)
if (a[0][j] != inf)
a[1][j | F[i].s] = min(a[1][j | F[i].s], a[0][j] + F[i].c);
if (a[1][(1 << m) - 1] != inf) {
ans = min(ans, a[1][(1 << m) - 1] + (long long)F[i].k * k);
a[1][(1 << m) - 1] = inf;
}
}
printf("%I64d\n", ans == inf ? -1 : ans);
}
return 0;
}
|
#include <bits/stdc++.h>
template <typename T>
T in() {
char ch;
T n = 0;
bool ng = false;
while (1) {
ch = getchar();
if (ch == '-') {
ng = true;
ch = getchar();
break;
}
if (ch >= '0' && ch <= '9') break;
}
while (1) {
n = n * 10 + (ch - '0');
ch = getchar();
if (ch < '0' || ch > '9') break;
}
return (ng ? -n : n);
}
using namespace std;
struct z {
int x, k, msk;
bool operator<(const z &p) const { return p.k > k; }
};
z ar[101];
long long int n, m, p, lim;
long long int dp[2][(1 << (20)) + 5];
long long int solve(int pos, int mask) {
if (mask == lim) {
return (ar[pos - 1].k * p);
}
if (pos == n) return 2000000000000000000;
long long int &res = dp[pos][mask];
if (res != -1) return res;
res = solve(pos + 1, mask);
res = ((res < ar[pos].x + solve(pos + 1, mask | ar[pos].msk))
? res
: ar[pos].x + solve(pos + 1, mask | ar[pos].msk));
return res;
}
long long int Solve1() {
for (int pos = n + 1 - 1; pos >= 0; pos--) {
for (int mask = 0; mask < lim + 1; mask++) {
if (mask == lim)
dp[pos % 2][mask] = (ar[pos - 1].k * p);
else if (pos == n) {
dp[pos % 2][mask] = 2000000000000000000;
} else {
dp[pos % 2][mask] = dp[(pos + 1) % 2][mask];
dp[pos % 2][mask] =
min(dp[pos % 2][mask],
ar[pos].x + dp[(pos + 1) % 2][mask | ar[pos].msk]);
}
}
}
return dp[0][0];
}
int main() {
cin >> n >> m >> p;
lim = (1 << m) - 1;
for (int i = 0; i < n; i++) {
int a;
cin >> ar[i].x >> ar[i].k >> a;
int mask = 0;
for (int j = 0; j < a; j++) {
int x;
cin >> x;
x--;
mask |= (1 << x);
}
ar[i].msk = mask;
}
sort(ar, ar + n);
long long int ans = Solve1();
if (ans >= 2000000000000000000) ans = -1;
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
struct Sfriend {
long long x, k, m;
};
long long a[30];
long long mat[111];
Sfriend fr[111];
long long ans[1111111];
void qsort(int left, int right) {
int i = left, j = right, e;
Sfriend t;
e = fr[rand() % (j - i + 1) + i].k;
while (i < j) {
while (fr[i].k < e) i++;
while (fr[j].k > e) j--;
if (i <= j) {
t = fr[i];
fr[i] = fr[j];
fr[j] = t;
i++;
j--;
}
}
if (i < right) qsort(i, right);
if (left < j) qsort(left, j);
};
void solution() {
long long n, m, b, FN = 1;
cin >> n >> m >> b;
memset(mat, 0, sizeof(mat));
for (int i = (1); i <= (m); i++) {
a[i] = FN;
FN *= 2;
}
FN--;
long long temp = 0;
for (int i = (1); i <= (n); i++) {
long long mi;
cin >> fr[i].x >> fr[i].k >> mi;
for (int j = (1); j <= (mi); j++) {
int z;
cin >> z;
mat[i] |= a[z];
}
fr[i].m = mat[i];
temp |= mat[i];
}
if (temp != FN) {
printf("-1\n");
return;
}
qsort(1, n);
long long res = 6e18;
for (int i = (1); i <= (FN); i++) ans[i] = 6e18;
ans[0] = 0;
for (int i = (1); i <= (n); i++) {
for (int j = (0); j <= (FN); j++) {
if (ans[j] + fr[i].x < ans[j | fr[i].m])
ans[j | fr[i].m] = ans[j] + fr[i].x;
}
if (ans[FN] + fr[i].k * b < res) res = ans[FN] + fr[i].k * b;
}
cout << res << endl;
};
int main() { solution(); }
|
#include <bits/stdc++.h>
const long long unsigned INF = (1 << 64) - 1;
using namespace std;
long long unsigned n, m, b, i, j, t, y, val, k, sol = INF, dyn[(1 << 22)];
pair<long long unsigned, pair<long long unsigned, long long unsigned> > a[110];
int main() {
cin >> n >> m >> b;
val = (1 << m) - 1;
for (i = 1; i <= val; i++) dyn[i] = INF;
for (i = 1; i <= n; i++) {
cin >> a[i].second.first >> a[i].first >> t;
for (j = 1; j <= t; j++) {
cin >> y;
a[i].second.second |= (1 << (y - 1));
}
}
sort(a + 1, a + n + 1);
for (i = 1; i <= n; i++) {
for (j = 0; j <= val; j++)
if (dyn[j] != INF)
dyn[j | a[i].second.second] =
min(dyn[j | a[i].second.second], dyn[j] + a[i].second.first);
if (dyn[val] != INF) sol = min(sol, dyn[val] + b * a[i].first);
}
(sol == INF) ? cout << -1 : cout << sol;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m, b, q;
long long dp[2][1 << 20];
struct node {
int mask, k, x;
node() {}
node(int _x, int _k, int _m) {
x = _x;
k = _k;
mask = _m;
}
} G[101];
bool orden(node p, node q) { return p.k < q.k; }
inline void checkmin(long long& a, long long b) {
if (b < a) a = b;
}
int main() {
scanf("%d %d %d", &n, &m, &b);
for (int i = 0; i < n; i++) {
int x, y, z;
scanf("%d %d %d", &x, &y, &z);
int curMask = 0;
for (int j = 0; j < z; j++) {
scanf("%d", &q);
curMask |= (1 << (q - 1));
}
G[i] = node(x, y, curMask);
}
sort(G, G + n, orden);
for (int i = 0; i < 2; i++)
for (int mask = 0; mask < (1 << m); mask++) dp[i][mask] = 1LL << 60;
dp[0][0] = 0;
long long ans = 1LL << 60;
for (int i = 0; i < n; i++) {
int cur = (i + 1) & 1;
int prev = 1 - cur;
for (int mask = 0; mask < (1 << m); mask++) {
checkmin(dp[cur][mask], dp[prev][mask]);
checkmin(dp[cur][mask | G[i].mask], dp[prev][mask] + G[i].x);
}
ans = min(ans, dp[cur][(1 << m) - 1] + (1LL * G[i].k * b));
}
if (ans >= 1LL << 60)
cout << -1 << endl;
else
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
struct p {
int x, k, m;
int st;
bool operator<(const struct p& a) const { return k > a.k; }
} f[200];
long long dp[(1 << 20) + 5];
int main() {
int n, m, b;
scanf("%d%d%d", &n, &m, &b);
for (int i = 0; i < n; i++) {
scanf("%d%d%d", &f[i].x, &f[i].k, &f[i].m);
int sa = 0, x;
for (int j = 0; j < f[i].m; j++) scanf("%d", &x), sa |= 1 << (x - 1);
f[i].st = sa;
}
sort(f, f + n);
long long inf = 1 << 30;
inf *= inf;
int lim = 1 << m;
for (int i = 0; i < lim; i++) dp[i] = inf;
dp[0] = 0;
for (int i = 0; i < n; i++) {
int sa = f[i].st;
for (int j = 0; j < lim; j++) {
if (j == 0)
dp[j | sa] = min(dp[j | sa], dp[0] + f[i].x + 1ll * f[i].k * b);
else
dp[j | sa] = min(dp[j | sa], dp[j] + f[i].x);
}
}
if (dp[lim - 1] < inf)
printf("%I64d\n", dp[lim - 1]);
else
puts("-1");
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const double eps = 1e-6;
const int N = 1e3 + 7;
const int MOD = 1e9 + 7;
const long long INF = 3e18 + 7;
int n, m, x[100], k[100], p[100], cnt[100], b[100];
long long B, dp[1 << 20];
bool cmp(int i, int j) { return k[i] < k[j]; }
int main() {
int tmp;
cin >> n >> m >> B;
int tot = 0;
for (int i = 0; i < n; i++) {
scanf("%d%d%d", &x[i], &k[i], &cnt[i]);
for (int j = 0; j < cnt[i]; j++) {
scanf("%d", &tmp);
p[i] |= 1 << (tmp - 1);
}
tot |= p[i];
b[i] = i;
}
sort(b, b + n, cmp);
if (tot != (1 << m) - 1) {
puts("-1");
return 0;
}
for (int i = 0; i <= tot; i++) dp[i] = INF;
long long ans = INF;
dp[0] = 0;
for (int i = 0; i < n; i++)
for (int j = tot; j >= 0; j--)
if ((j | p[b[i]]) == tot)
ans = min(ans, dp[j] + k[b[i]] * B + x[b[i]]);
else
dp[j | p[b[i]]] = min(dp[j | p[b[i]]], dp[j] + x[b[i]]);
cout << ans << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 110;
const long long Inf = (long long)1e30;
struct Node {
int x, K, st;
void read() {
int d, c;
scanf("%d%d%d", &x, &K, &d);
st = 0;
while (d--) {
scanf("%d", &c);
c--;
st |= 1 << c;
}
}
bool operator<(const Node &tt) const { return K > tt.K; }
} human[N];
int n, m;
long long B;
long long dp[2][1 << 20];
void clear(int c) {
for (int i = 0; i < 1 << m; i++) dp[c][i] = Inf;
}
inline void toMin(long long &a, long long b) {
if (a > b) a = b;
}
int main() {
scanf("%d%d%lld", &n, &m, &B);
for (int i = 0; i < n; i++) {
human[i].read();
}
sort(human, human + n);
int cur = 0, nex = 1;
clear(cur);
clear(nex);
dp[0][0] = 0;
for (int i = 0; i < n; i++) {
int x = human[i].x;
int K = human[i].K;
int st = human[i].st;
for (int s = 0; s < 1 << m; s++)
if (dp[cur][s] != Inf) {
long long val = dp[cur][s];
toMin(dp[nex][s], val);
toMin(dp[nex][s | st], val + (val == 0 ? B * K : 0) + x);
}
swap(cur, nex);
clear(nex);
}
long long ans = dp[cur][(1 << m) - 1];
printf("%lld\n", ans == Inf ? -1 : ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const double eps = 1e-8;
const double pi = acos(-1.0);
const double inf = ~0u >> 2;
const long long INF = (1ll << 62);
long long dp[1 << 20];
struct node {
int x, k, m;
int a[105];
int s;
} p[105];
bool cmp(node a, node b) { return a.k < b.k; }
int main() {
int i, j, n, m;
long long b;
cin >> n >> m >> b;
for (i = 0; i < (1 << m); i++) dp[i] = INF;
for (i = 1; i <= n; i++) {
p[i].s = 0;
scanf("%d%d%d", &p[i].x, &p[i].k, &p[i].m);
for (j = 0; j < p[i].m; j++) {
scanf("%d", &p[i].a[j]);
p[i].s |= (1 << (p[i].a[j] - 1));
}
}
sort(p + 1, p + n + 1, cmp);
dp[0] = 0;
long long ans = INF;
for (i = 1; i <= n; i++) {
for (j = 0; j < (1 << m); j++) {
if (dp[j] == INF) continue;
dp[j | p[i].s] = min(dp[j | p[i].s], dp[j] + p[i].x);
}
ans = min(ans, dp[(1 << m) - 1] + p[i].k * b);
}
if (ans == INF)
puts("-1");
else
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = (1 << 20) + 5;
const int M = 105;
const long long INF = 0x3f3f3f3f3f3f3f3f;
struct state {
int s;
long long k, val;
} p[M];
int n, m;
long long b, dp[N];
bool cmp(const state& a, const state& b) { return a.k < b.k; }
void init() {
memset(dp, -1, sizeof(dp));
scanf("%d%d", &n, &m);
cin >> b;
int t, a;
for (int i = 0; i < n; i++) {
cin >> p[i].val >> p[i].k >> t;
p[i].s = 0;
for (int j = 0; j < t; j++) {
scanf("%d", &a);
p[i].s |= (1 << (a - 1));
}
}
sort(p, p + n, cmp);
}
long long solve() {
dp[0] = 0;
int t = (1 << m) - 1;
long long ans = INF;
for (int i = 0; i < n; i++) {
for (int j = 0; j <= t; j++) {
if (dp[j] == -1) continue;
int u = p[i].s | j;
if (dp[u] == -1)
dp[u] = p[i].val + dp[j];
else
dp[u] = min(dp[u], p[i].val + dp[j]);
}
if (dp[t] != -1) ans = min(ans, dp[t] + p[i].k * b);
}
return ans == INF ? -1 : ans;
}
int main() {
init();
cout << solve() << endl;
return 0;
}
|
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:100000000000,100000000000")
using namespace std;
const long long inf = 2e18 + 7;
const long long mod = 1e9 + 9;
const double eps = 1e-9;
const double PI = 2 * acos(0.0);
const double E = 2.71828;
long long f[1 << 20];
struct pr {
int x, k, mask;
friend bool operator<(pr a, pr b) { return a.k < b.k; }
} a[105];
long long res = inf;
int main(void) {
int n, m, b;
scanf("%d %d %d", &n, &m, &b);
for (int(i) = 0; (i) < (n); (i)++) {
int sz;
scanf("%d %d %d", &a[i].x, &a[i].k, &sz);
int cur = 0;
for (int(j) = 0; (j) < (sz); (j)++) {
int x;
scanf("%d", &x);
--x;
cur |= 1 << x;
}
a[i].mask = cur;
}
sort(a, a + n);
for (int(i) = 0; (i) < (1 << m); (i)++) {
f[i] = inf;
}
f[0] = 0;
for (int(i) = 0; (i) < (n); (i)++) {
for (int j = (1 << m) - 1; j >= 0; --j)
if (f[j] != inf) {
int num = j | a[i].mask;
f[num] = min(f[num], f[j] + a[i].x);
}
res = min(res, f[(1 << m) - 1] + a[i].k * 1LL * b);
}
if (res == inf) {
puts("-1");
} else
printf("%I64d\n", res);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m;
long long b;
const int L = (1 << 20) + 2;
long long f[L + 1];
struct node {
int cost, large, cover;
} x[105];
bool cmp(node u, node v) { return u.large < v.large; }
void minimize(long long &v, long long u) {
if (v > u) v = u;
}
int main() {
scanf("%d%d%I64d", &n, &m, &b);
for (int i = 1, t, y; i <= n; i++) {
scanf("%d%d%d", &x[i].cost, &x[i].large, &t);
for (int j = 1; j <= t; j++) {
scanf("%d", &y);
x[i].cover |= 1 << (y - 1);
}
}
sort(x + 1, x + n + 1, cmp);
memset(f, 127, sizeof(f));
long long ans = f[L];
f[0] = 0;
for (int i = 1; i <= n; i++) {
for (int j = 0; j < (1 << m); j++)
if (f[j] != f[L]) minimize(f[j | x[i].cover], f[j] + x[i].cost);
if (f[(1 << m) - 1] != f[L])
minimize(ans, f[(1 << m) - 1] + b * x[i].large);
}
if (ans == f[L])
printf("-1\n");
else
printf("%I64d\n", ans);
}
|
#include <bits/stdc++.h>
using namespace std;
const long double eps = 1e-9;
const int maxn = 2e4;
const long long inf = 1e9 + 7;
long long mask[110], moni[110], mon[110];
long long dp[1 << 20];
pair<int, pair<int, int> > fr[110];
int main() {
int n, m;
long long b;
cin >> n >> m >> b;
for (int i = 0; i < n; i++) {
int c, cm = 0;
cin >> fr[i].second.first >> fr[i].first >> c;
for (int i = 0; i < c; i++) {
int cz;
cin >> cz;
cm |= 1 << (cz - 1);
}
fr[i].second.second = cm;
}
sort(fr, fr + n);
for (int i = 0; i < n; i++) {
moni[i] = fr[i].first;
mon[i] = fr[i].second.first;
mask[i] = fr[i].second.second;
}
for (int j = 0; j < 1 << m; j++) {
dp[j] = (long long)1 << 60;
}
dp[0] = 0;
int curmask = 1 << (m);
curmask--;
long long an = (long long)1 << 62;
for (int i = 0; i < n; i++) {
for (int j = 0; j < 1 << m; j++) {
if (dp[j] == (long long)1 << 60) continue;
if (dp[j | mask[i]] > dp[j] + mon[i]) dp[j | mask[i]] = dp[j] + mon[i];
}
if (dp[curmask] == (long long)1 << 60) continue;
if (dp[curmask] + (long long)moni[i] * b < an)
an = dp[curmask] + (long long)moni[i] * b;
}
if (an == (long long)1 << 62) {
cout << -1;
return 0;
}
cout << an;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
struct Coder {
int msk, k, c;
};
bool operator<(Coder a, Coder b) { return a.k < b.k; }
const int maxn = 100;
const int maxm = 20;
const long long inf = 2e18;
Coder h[maxn];
long long dp[(1 << maxm)][2];
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
int m, n, c;
cin >> n >> m >> c;
for (int i = 0; i < n; ++i) {
int t;
cin >> h[i].c >> h[i].k >> t;
for (int j = 0; j < t; ++j) {
int x;
cin >> x;
x--;
h[i].msk += (1 << x);
}
}
sort(h, h + n);
for (int mask = 1; mask < (1 << m); ++mask) {
dp[mask][0] = dp[mask][1] = inf;
}
dp[0][0] = dp[0][1] = 0ll;
for (int i = 0; i < n; ++i) {
for (int mask = 0; mask < (1 << m); ++mask) {
int nmask = (mask ^ (mask & h[i].msk));
dp[mask][1] =
min(dp[mask][1], dp[nmask][0] + h[i].c + (long long)h[i].k * c);
dp[mask][0] = min(dp[mask][0], dp[nmask][0] + h[i].c);
}
}
if (dp[(1 << m) - 1][1] == inf) {
cout << "-1\n";
} else {
cout << dp[(1 << m) - 1][1] << '\n';
}
return 0;
}
|
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:128000000")
using namespace std;
const long double PI = 3.14159265358979323846;
const long double gammama = 0.57721566490153286060;
const int INF = 2 * 1000 * 1000 * 1000 + 10;
const long long LLINF = (long long)4 * 1000 * 1000 * 1000 * 1000 * 1000 * 1000;
const int N = 1000 * 1000 * 1000 + 100;
const int mod = 1000 * 1000 * 1000 + 7;
struct Friend {
long long mon, cost;
vector<long long> pr;
long long code;
};
bool operator<(const Friend& a, const Friend& b) { return (a.mon < b.mon); }
int main() {
ios_base::sync_with_stdio(0);
long long n, m, b;
cin >> n >> m >> b;
vector<Friend> fr(n);
for (int i = 0; i < n; ++i) {
cin >> fr[i].cost >> fr[i].mon;
int sz;
cin >> sz;
fr[i].pr.resize(sz);
fr[i].code = 0;
for (int j = 0; j < sz; ++j) {
cin >> fr[i].pr[j];
fr[i].code += (1 << (fr[i].pr[j] - 1));
}
}
sort(fr.begin(), fr.end());
long long res = LLINF;
int up = 1 << m;
vector<long long> d(up, LLINF);
d[0] = 0;
for (int i = 0; i < n; ++i) {
long long cur = fr[i].mon * b;
for (int j = up - 1; j >= 0; --j) {
int pos = j | fr[i].code;
d[pos] = min(d[pos], d[j] + fr[i].cost);
}
cur += d[up - 1];
res = min(res, cur);
}
if (res == LLINF)
cout << -1 << endl;
else
cout << res << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long MAXX = 1e2 + 10, mxlg = 22, inf = 2e18 + 10;
long long n, m, b, dp[(1 << mxlg)], ans = inf;
void smin(long long &x, long long y) { x = min(x, y); }
struct node {
long long F, S, O;
} a[MAXX];
int main() {
ios::sync_with_stdio(0), cin.tie(0), cout.tie(0);
cin >> n >> m >> b;
memset(dp, 63, sizeof dp), dp[0] = 0;
for (int i = 0; i < n; i++) {
long long T, tmp;
a[i].O = 0;
cin >> a[i].F >> a[i].S >> T;
while (T--) cin >> tmp, a[i].O |= (1 << (tmp - 1));
}
sort(a, a + n, [&](node x, node y) { return (x.S < y.S); });
for (int i = 0; i < n; i++) {
long long o = a[i].O;
for (int mask = 0; mask < (1 << m); mask++)
smin(dp[mask | o], dp[mask] + a[i].F);
ans = min(ans, dp[(1 << m) - 1] + (a[i].S * b));
}
return cout << (ans == inf ? -1 : ans) << endl, 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int k[101];
int x[101];
int f[101];
int N, b;
int numFriends;
long long DP[2][1 << 20];
int main() {
scanf("%d %d %d\n", &numFriends, &N, &b);
int maskTotal = 0;
for (int i = 0; i < numFriends; i++) {
int tmp;
scanf("%d %d %d\n", x + i, k + i, &tmp);
f[i] = 0;
for (int j = 0; j < tmp; j++) {
int tmptmp;
cin >> tmptmp;
f[i] |= 1 << (tmptmp - 1);
}
maskTotal |= f[i];
}
for (int i = 0; i < numFriends; i++) {
for (int j = i; j < numFriends; j++) {
if (k[i] > k[j]) {
swap(k[i], k[j]);
swap(x[i], x[j]);
swap(f[i], f[j]);
}
}
}
for (int i = 0; i < 2; i++) {
for (int mask = ((1 << N) - 1); mask >= 0; mask--) {
DP[i][mask] = (LLONG_MAX);
}
}
f[numFriends] = 0;
for (int i = numFriends; i >= 0; i--) {
for (int mask = ((1 << N) - 1); mask >= 0; mask--) {
if (mask == ((1 << N) - 1)) {
if (i) DP[i & 1][mask] = (long long)b * k[i - 1];
} else {
long long r1 = DP[(i + 1) & 1][mask];
long long r2 = DP[(i + 1) & 1][mask | f[i]];
if (r2 < (LLONG_MAX)) r2 += x[i];
DP[i & 1][mask] = min(r1, r2);
}
}
}
long long ans = DP[0][0];
if (maskTotal < ((1 << N) - 1))
printf("-1\n");
else
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
namespace std {
template <>
class hash<pair<long long, long long>> {
public:
size_t operator()(const pair<long long, long long>& p) const {
return hash<long long>()(p.first) ^ (hash<long long>()(p.second) << 32);
}
};
}; // namespace std
int main() {
std::ios_base::sync_with_stdio(false);
int n;
int m;
long long b;
cin >> n >> m >> b;
vector<int> x(n);
vector<int> k(n);
vector<long long> fm(n);
set<int> ks;
for (int i = 0; i < n; ++i) {
cin >> x[i] >> k[i];
ks.insert(k[i]);
int mi;
cin >> mi;
for (int j = 0; j < mi; ++j) {
int val;
cin >> val;
--val;
if (val == 0)
fm[i] |= 1;
else
fm[i] |= 1 << val;
}
}
long long minimal = numeric_limits<long long>::max();
unsigned int M = 1 << m;
vector<long long> v(M);
for (size_t i = 0; i < M; ++i) v[i] = numeric_limits<long long>::max();
v[0] = 0;
for (auto K : ks) {
for (int i = 0; i < n; ++i) {
if (k[i] != K) continue;
for (size_t j = 0; j < M - 1; ++j) {
if (v[j] != numeric_limits<long long>::max() &&
v[j | fm[i]] > v[j] + x[i]) {
v[j | fm[i]] = v[j] + x[i];
}
}
}
if (v[M - 1] != numeric_limits<long long>::max())
minimal = min(minimal, v[M - 1] + b * K);
}
if (minimal != numeric_limits<long long>::max()) {
cout << minimal << endl;
} else {
cout << -1 << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
struct poLL {
unsigned long long x, k, m, s;
void init() { scanf("%d %d %d", &x, &k, &m); }
bool operator<(poLL b) const { return k < b.k; }
} p[105];
unsigned long long N, M, B, to;
unsigned long long dp[2][(1 << 20)], ans, INF;
int main() {
unsigned long long i, j, tmp, cnt;
scanf("%I64d %I64d %I64d", &N, &M, &B);
for (i = 1; i <= N; i++) {
p[i].init();
for (j = 1; j <= p[i].m; j++) scanf("%d", &tmp), p[i].s |= (1 << tmp - 1);
}
sort(p + 1, p + 1 + N);
memset(dp, 126, sizeof(dp)), INF = dp[0][0];
dp[0][0] = 0, cnt = 1, to = (1 << M);
ans = INF;
for (i = 0; i <= N; i++) {
cnt ^= 1;
memset(dp[cnt ^ 1], 126, sizeof(dp[cnt ^ 1]));
if (i != N)
for (j = 0; j < to; j++)
if (dp[cnt][j] != INF) {
dp[cnt ^ 1][j] = min(dp[cnt ^ 1][j], dp[cnt][j]);
dp[cnt ^ 1][j | p[i + 1].s] =
min(dp[cnt ^ 1][j | p[i + 1].s], dp[cnt][j] + p[i + 1].x);
}
ans = min(ans, dp[cnt][to - 1] + (unsigned long long)p[i].k * B);
}
printf("%I64d\n", ans == INF ? -1 : ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long dp[1 << 20];
long long can[105], co[105], mo[105];
int main() {
long long n, m, b;
cin >> n >> m >> b;
vector<pair<int, int> > ord;
for (int j = 0; j <= (1 << 20) - 1; j++) dp[j] = LLONG_MAX;
for (int i = 1; i <= n; i++) {
long long num;
cin >> co[i] >> mo[i] >> num;
for (int j = 1; j <= num; j++) {
int temp;
cin >> temp;
can[i] += (1 << (temp - 1));
}
ord.push_back(make_pair(mo[i], i));
}
sort(ord.begin(), ord.end());
dp[0] = 0;
long long ans = LLONG_MAX;
int req = (1 << m) - 1;
for (int i = 1; i <= n; i++) {
for (int mask = 0; mask <= (1 << m) - 1; mask++) {
if (dp[mask] != LLONG_MAX) {
if (dp[mask] + co[ord[i - 1].second] <
dp[(mask | can[ord[i - 1].second])]) {
dp[(mask | can[ord[i - 1].second])] =
dp[mask] + co[ord[i - 1].second];
if ((mask | can[ord[i - 1].second]) == req) {
ans = min(ans, dp[req] + (b * ord[i - 1].first));
}
}
}
}
}
if (ans == LLONG_MAX)
cout << -1 << endl;
else
cout << ans << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = (1 << 20) + 5;
long long cost[N];
long long mask[105], x[105], k[105];
int main() {
std::ios::sync_with_stdio(false);
memset(cost, -1, sizeof(cost));
vector<pair<int, int> > v;
long long n, m, b;
cin >> n >> m >> b;
for (int i = 0; i < n; ++i) {
int mm;
cin >> x[i] >> k[i] >> mm;
v.push_back({k[i], i});
for (int j = 0; j < mm; ++j) {
int a;
cin >> a;
--a;
mask[i] |= (1 << a);
}
}
sort(v.begin(), v.end());
cost[0] = 0;
long long res = numeric_limits<long long>::max();
for (int i = 0; i < n; ++i) {
int ii = v[i].second;
for (int j = 0; j < (1 << m); ++j)
if (cost[j] != -1) {
int jj = j | mask[ii];
if (cost[jj] == -1)
cost[jj] = cost[j] + x[ii];
else
cost[jj] = min(cost[jj], cost[j] + x[ii]);
}
if (cost[(1 << m) - 1] != -1) {
res = min(res, cost[(1 << m) - 1] + b * k[ii]);
}
}
if (res == numeric_limits<long long>::max())
cout << -1 << endl;
else
cout << res << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long INF = 3e18;
const int MXN = 1e5 + 7;
int n, m, b;
int x[MXN], y[MXN], cmask[MXN];
long long ans, mon[(1 << 20) + 10], dp[(1 << 20) + 10];
int main() {
scanf("%d%d%d", &n, &m, &b);
ans = INF;
for (int mask = 1; mask < (1 << m); mask++) dp[mask] = INF;
for (int i = 0; i < n; i++) {
int z;
long long cur = 0;
scanf("%d%d%d", &x[i], &y[i], &z);
for (int j = 0; j < z; j++) {
int task;
scanf("%d", &task);
cmask[i] += (1 << (task - 1));
}
}
for (int i = 0; i < n; i++) {
for (int j = i + 1; j < n; j++) {
if (y[j] < y[i]) {
swap(x[i], x[j]);
swap(y[i], y[j]);
swap(cmask[i], cmask[j]);
}
}
}
for (int i = 0; i < n; i++) {
for (int mask = 0; mask < (1 << m); mask++)
if (dp[mask] + x[i] < dp[mask | cmask[i]])
dp[mask | cmask[i]] = dp[mask] + x[i];
long long cur = dp[(1 << m) - 1] + 1LL * y[i] * b;
ans = min(ans, cur);
}
if (ans == INF)
puts("-1");
else
cout << ans;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m, k, y, tt, c, d, x, M[105];
string cad;
unsigned long long b, X[105], K[105], dp[(1 << 20) + 2];
int main() {
ios_base::sync_with_stdio(0);
cin >> n >> m >> b;
for (int i = 1; i <= n; i++) {
cin >> X[i] >> K[i] >> c;
d = 0;
for (int j = 0; j < c; j++) {
cin >> y;
y--;
d |= (1 << y);
}
M[i] = d;
}
for (int i = 1; i <= n; i++)
for (int j = i + 1; j <= n; j++)
if (K[i] > K[j]) {
swap(K[i], K[j]);
swap(M[i], M[j]);
swap(X[i], X[j]);
}
unsigned long long res = 1LL << 63;
for (int i = 1; i <= (1 << 20); i++) dp[i] = res;
unsigned long long oo = res;
for (int i = 1; i <= n; i++) {
for (int j = 0; j < (1 << m); j++)
if (dp[j] != oo) {
dp[j | M[i]] = min(dp[j | M[i]], dp[j] + X[i]);
}
if (dp[(1 << m) - 1] != oo) {
res = min(res, dp[(1 << m) - 1] + b * K[i]);
}
}
if (res == oo)
cout << -1;
else
cout << res;
return 0;
}
|
#include <bits/stdc++.h>
unsigned long long d[1 << 20], x;
int a[100], b[100], c[100], n, m, k, i, j, z, mm;
int main() {
scanf("%d%d%d", &n, &m, &k);
mm = 1 << m;
--mm;
for (i = 0; i < n; i++) {
scanf("%d%d%d", &a[i], &b[i], &j);
while (j--) {
scanf("%d", &z);
c[i] |= 1 << (z - 1);
}
}
for (i = 0; i < n; i++)
for (j = i; j < n; j++)
if (b[i] > b[j]) {
z = a[i], a[i] = a[j], a[j] = z;
z = b[i], b[i] = b[j], b[j] = z;
z = c[i], c[i] = c[j], c[j] = z;
}
for (i = 0; i < n; i++) {
if (!d[c[i]] || d[c[i]] > a[i]) d[c[i]] = a[i];
for (j = 0; j <= mm; j++)
if (d[j]) {
z = j | c[i];
if (!d[z] || d[z] > d[j] + a[i]) d[z] = d[j] + a[i];
}
if (d[mm] && (!x || d[mm] + (unsigned long long)k * b[i] < x))
x = d[mm] + (unsigned long long)k * b[i];
}
if (!x)
puts("-1");
else
printf("%I64u\n", x);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
struct Member {
int monNeed;
int mask;
int cost;
Member() : monNeed(), mask(), cost() {}
bool operator<(const Member &A) const { return monNeed < A.monNeed; }
void read() {
int n;
mask = 0;
scanf("%d%d%d", &cost, &monNeed, &n);
for (int i = 0; i < n; i++) {
int a;
scanf("%d", &a);
a--;
mask |= (1 << a);
}
}
};
const int maxn = 105;
Member M[maxn];
const long long inf = 4e18;
long long dp[(1 << 20) + 100];
int main() {
int n, m, b;
scanf("%d%d%d", &n, &m, &b);
for (int i = 0; i < n; i++) M[i].read();
sort(M, M + n);
for (int i = 0; i < (1 << m); i++) dp[i] = inf;
dp[0] = 0;
long long ans = inf;
int fullMask = (1 << m) - 1;
for (int i = 0; i < n; i++) {
int curm = M[i].mask;
int curMon = M[i].monNeed;
long long add = M[i].cost;
for (int j = 0; j < (1 << m); j++) {
dp[j | curm] = min(dp[j | curm], dp[j] + add);
}
long long curAns = dp[fullMask] + curMon * 1LL * b;
ans = min(ans, curAns);
}
if (ans == inf) ans = -1;
printf("%I64d\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
pair<int, pair<int, int> > a[100 + 1];
long long d[1 << 20];
int n, m;
long long b;
int main() {
std::ios::sync_with_stdio(false);
cin >> n >> m >> b;
for (int i = 0; i < n; ++i) {
int mi;
cin >> a[i].second.first >> a[i].first >> mi;
for (int j = 0; j < mi; ++j) {
int tmp;
cin >> tmp;
a[i].second.second |= 1 << (tmp - 1);
}
}
sort(a, a + n);
int lim = 1 << m;
long long ans = 1000000000000000000 * 3 + 100;
for (int i = 1; i < lim; i++) d[i] = ans;
for (int i = 0; i < n; i++) {
for (int j = 0; j < lim; j++) {
d[j | a[i].second.second] =
min(d[j | a[i].second.second], d[j] + a[i].second.first);
}
ans = min(ans, d[lim - 1] + b * a[i].first);
}
if (ans == 1000000000000000000 * 3 + 100) {
cout << -1 << endl;
} else
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
const int N = 101;
const int M = (1 << 20) + 2;
ll dp[M];
int frnd[N];
int x[N], k[N];
int main() {
int n, m, b;
scanf("%d%d%d", &n, &m, &b);
for (int i = 0; i < n; ++i) {
int mt;
scanf("%d%d%d", x + i, k + i, &mt);
for (int j = 0; j < mt; ++j) {
int t;
scanf("%d", &t);
frnd[i] |= 1 << (t - 1);
}
}
vector<int> idx(n);
for (int i = 0; i < n; ++i) {
idx[i] = i;
}
sort(idx.begin(), idx.end(), [](int xx, int yy) { return k[xx] < k[yy]; });
for (int i = 1; i < M; ++i) {
dp[i] = LLONG_MAX;
}
dp[0] = 0;
int MAX_MASK = 1 << m;
ll res = LLONG_MAX;
for (int i = 0; i < n; ++i) {
int f = idx[i];
for (int mask = 0; mask < MAX_MASK; ++mask) {
int new_mask = mask | frnd[f];
if (dp[mask] != LLONG_MAX && dp[new_mask] > dp[mask] + x[f]) {
dp[new_mask] = dp[mask] + x[f];
}
}
ll cur = dp[(1 << m) - 1];
if (cur != LLONG_MAX && cur + k[f] * 1LL * b < res) {
res = cur + k[f] * 1LL * b;
}
}
if (res == LLONG_MAX) {
res = -1;
}
printf("%lld\n", res);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1211;
const int inf = 0x7f7f7f7f;
const int mod = (int)(1e9 + 7);
const long long INF = 0x7f7f7f7f7f7f7f7fLL;
const double eps = 1e-8;
const double pi = acos(-1.0);
const int mask = 65535;
struct node {
int value, st, k;
bool operator<(const node& tmp) const { return k < tmp.k; }
} f[maxn];
const int N = 1 << 20;
long long dp[N + 2];
int main() {
ios::sync_with_stdio(false);
int n, m, b;
int i, j, k;
cin >> n >> m >> b;
int tot = 1 << m;
int p;
for (i = 0; i < n; ++i) {
cin >> f[i].value >> f[i].k >> p;
f[i].st = 0;
for (j = 0; j < p; ++j) {
cin >> k;
--k;
f[i].st |= 1 << (k);
}
}
memset(dp, 0x7f, sizeof(dp));
dp[0] = 0;
long long ans = INF;
sort(f, f + n);
for (i = 0; i < n; ++i) {
int p = f[i].st;
for (j = tot - 1; j >= 0; --j) {
if (dp[j] ^ INF) {
dp[j | p] = min(dp[j | p], dp[j] + f[i].value);
}
}
if (dp[tot - 1] ^ INF) {
ans = min(ans, dp[tot - 1] + 1LL * f[i].k * b);
}
}
if (ans == INF) ans = -1;
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
struct Node {
int x;
int k;
int m;
int p[25];
void read() {
cin >> x >> k >> m;
for (int i = 0; i < m; i++) {
cin >> p[i];
p[i]--;
}
}
bool operator<(const Node& t) const { return k < t.k; }
};
const long long INF = 0x7f7f7f7f7f7f7f7fLL;
Node a[110];
int n, m;
long long b;
long long dp[1100000];
int main() {
cin >> n >> m >> b;
for (int i = 0; i < n; i++) a[i].read();
sort(a, a + n);
long long ans = INF;
memset(dp, 0x7f, sizeof(dp));
dp[0] = 0;
int S = (1 << m) - 1;
for (int i = 0; i < n; i++) {
int t = 0;
for (int j = 0; j < a[i].m; j++) t |= 1 << a[i].p[j];
for (int s = 0; s < (1 << m); s++) {
dp[t | s] = min(dp[t | s], dp[s] + a[i].x);
if (dp[S] < INF) ans = min(ans, dp[S] + a[i].k * b);
}
}
if (ans == INF)
puts("-1");
else
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m, b;
struct poi {
int x, k, a;
} P[106];
bool cmp(poi a, poi b) { return a.k < b.k; }
long long dp[2][1 << 20];
signed main() {
cin >> n >> m >> b;
for (int i = 1, c, x; i <= n; ++i) {
scanf("%d%d%d", &P[i].x, &P[i].k, &c);
while (c-- > 0) scanf("%d", &x), P[i].a |= (1 << x - 1);
}
sort(P + 1, P + 1 + n, cmp);
int cur = 0, pre = 1;
long long res = 0x3f3f3f3f3f3f3f3f;
memset(dp[0], 0x3f3f, sizeof dp[0]);
dp[0][0] = 0;
for (int i = 1; i <= n; ++i) {
cur ^= 1, pre ^= 1;
memset(dp[cur], 0x3f3f, sizeof dp[cur]);
for (int sta = 0; sta < (1 << m); ++sta) {
dp[cur][sta] = min(dp[cur][sta], dp[pre][sta]);
dp[cur][sta | P[i].a] = min(dp[cur][sta | P[i].a], dp[pre][sta] + P[i].x);
}
res = min(res, dp[cur][(1 << m) - 1] + 1ll * P[i].k * b);
}
cout << (res == 0x3f3f3f3f3f3f3f3f ? -1 : res) << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
inline pair<int, pair<int, int> > make(int m, int x, int mask) {
return make_pair(m, make_pair(x, mask));
}
vector<long long> a;
const long long inf = 5000000000000000000LL;
long long solve(vector<pair<int, pair<int, int> > >& fi, int prob,
long long b) {
sort(fi.begin(), fi.end());
int target = 1 << prob;
fill(a.begin(), a.begin() + target, inf);
a[0] = 0;
long long res = inf;
for (int i = 0; i < fi.size(); ++i) {
int x = fi[i].second.first;
int mask = fi[i].second.second;
for (int j = 0, k; j < target; ++j) {
k = j | mask;
a[k] = min(a[k], a[j] + x);
}
if (a[target - 1] < inf) res = min(a[target - 1] + b * fi[i].first, res);
}
return res < inf ? res : -1;
}
int main() {
int n, prob, b, M = 0;
a.resize(1 << 20);
cin >> n >> prob >> b;
vector<pair<int, pair<int, int> > > fi;
for (int i = 0, x, m, k; i < n; ++i) {
int mask = 0;
cin >> x >> m >> k;
for (int j = 0, t; j < k; ++j) {
cin >> t;
mask |= (1 << (t - 1));
}
fi.push_back(make(m, x, mask));
M = max(M, m);
}
cout << solve(fi, prob, b);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
struct st {
long long c;
long long m;
int xnd;
};
bool operator<(st a, st b) { return a.m < b.m; }
st a[200];
long long d[2][1 << 21], ans = 0;
int main() {
int n, m, cnt, i, j, f;
long long x, k, b;
cin >> n >> m >> b;
for (i = 1; i <= n; ++i) {
cin >> x >> k >> cnt;
for (j = 0; j < cnt; ++j) {
cin >> f;
a[i].xnd |= (1 << (f - 1));
}
a[i].c = x;
a[i].m = k;
}
ans = 2000000000 * 1ll * 2000000000;
sort(a + 1, a + 1 + n);
for (i = 1; i < (1 << m); ++i) d[0][i] = 2000000000 * 1ll * 2000000000;
for (i = 1; i <= n; ++i) {
for (j = 0; j < (1 << m); ++j) d[i & 1][j] = d[(i + 1) & 1][j];
for (j = 0; j < (1 << m); ++j) {
if (d[i & 1][j | a[i].xnd] > d[(i + 1) & 1][j] + a[i].c) {
d[i & 1][j | a[i].xnd] = d[(i + 1) & 1][j] + a[i].c;
}
}
if (ans > d[i & 1][-1 + (1 << m)] + a[i].m * 1ll * b) {
ans = d[i & 1][-1 + (1 << m)] + a[i].m * 1ll * b;
}
}
if (ans == 2000000000 * 1ll * 2000000000) ans = -1;
cout << ans;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 105;
const int MASK = (1 << 20);
const long long INF = (long long)3e18;
struct Friend {
int money, displays, tasks;
void scan() {
int k;
scanf("%d%d%d", &money, &displays, &k);
tasks = 0;
for (int i = 0; i < k; i++) {
int j;
scanf("%d", &j);
j--;
tasks |= (1 << j);
}
}
bool operator<(const Friend& f) const { return displays < f.displays; }
};
int n, m, b;
Friend friends[N];
long long dp[2][MASK];
int main() {
scanf("%d%d%d", &n, &m, &b);
for (int i = 0; i < n; i++) friends[i].scan();
sort(friends, friends + n);
long long best = INF;
for (int i = 0; i < 2; i++) fill(dp[i], dp[i] + MASK, INF);
dp[0][0] = 0;
for (int i = 0; i < n; i++) {
long long* from = dp[i % 2];
long long* to = dp[1 - i % 2];
for (int j = 0; j < (1 << m); j++) {
if (to[j] > from[j]) to[j] = from[j];
int nxt = (j | friends[i].tasks);
if (to[nxt] > from[j] + friends[i].money)
to[nxt] = from[j] + friends[i].money;
}
best = min(best, to[(1 << m) - 1] + (long long)friends[i].displays * b);
}
if (best == INF)
printf("-1\n");
else
printf("%I64d\n", best);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long INF = (1LL << 60);
int N, M;
long long B;
struct student {
long long cost;
int mask;
int monitors;
};
bool cmp(student s, student t) { return s.monitors < t.monitors; }
student S[105];
long long dp[1 << 20];
int main() {
scanf("%d%d%I64d", &N, &M, &B);
for (int i = 0; i < N; i++) {
int K;
scanf("%I64d%d%d", &S[i].cost, &S[i].monitors, &K);
S[i].mask = 0;
for (int k = 0; k < K; k++) {
int x;
scanf("%d", &x);
S[i].mask |= (1 << (--x));
}
}
sort(S, S + N, cmp);
for (int i = 0; i < (1 << M); i++) dp[i] = INF;
dp[0] = 0;
long long monitors = 0;
long long best = INF;
for (int s = 0; s < N; s++) {
for (int i = 0; i < (1 << M); i++)
dp[i | S[s].mask] = min(dp[i | S[s].mask], dp[i] + S[s].cost);
best = min(best, dp[(1 << M) - 1] + S[s].monitors * B);
}
printf("%I64d\n", best == INF ? -1 : best);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = int(2e5) + 10;
const int K = int(2e6) + 10;
const int MOD = int(1e9) + 7;
const int INF = int(1e9) + 5;
const long long INF64 = 1e18;
int x[N], msk[N];
pair<int, int> k[N];
long long dp[(1 << 21)];
void solve() {
int n, m, b;
cin >> n >> m >> b;
long long ans = 2 * INF64;
for (int i = 1; i <= n; i++) {
int m;
k[i].second = i;
cin >> x[i] >> k[i].first >> m;
int mask = 0;
for (int j = 1; j <= m; j++) {
int t;
cin >> t;
t--;
mask |= (1 << t);
}
msk[i] = mask;
}
sort(k + 1, k + 1 + n);
for (int i = 1; i <= (1 << m); i++) dp[i] = 2ll * INF64;
for (int i = 1; i <= n; i++) {
int f = k[i].second;
for (int j = 0; j < (1 << m); j++) {
int nmsk = msk[f] | j;
dp[nmsk] = min(dp[nmsk], dp[j] + x[f]);
}
ans = min(ans, 1ll * b * k[i].first + dp[(1 << m) - 1]);
}
if (ans == 2 * INF64) ans = -1;
cout << ans << '\n';
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int t;
t = 1;
while (t--) {
solve();
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
struct node {
long long x, k, w, t;
} q[102];
bool cmp(node a, node b) { return a.k < b.k; }
bool v[102];
long long dp[1050000], ans = (1LL << 60);
int main() {
int n, m, b, s;
cin >> n >> m >> b;
for (int i = 1; i <= n; i++) {
scanf("%d%d%d", &q[i].x, &q[i].k, &q[i].w);
for (int j = 1; j <= q[i].w; j++) {
scanf("%d", &s);
v[s] = 1;
q[i].t += (1 << (s - 1));
}
}
for (int i = 1; i <= m; i++) {
if (v[i] != 1) {
cout << "-1" << endl;
return 0;
}
}
sort(q + 1, q + n + 1, cmp);
for (int i = 0; i < (1 << m); i++) {
dp[i] = (1LL << 60);
}
dp[0] = 0;
for (int i = 1; i <= n; i++) {
for (int j = 0; j < (1 << m); j++) {
dp[j | q[i].t] = min(dp[j | q[i].t], dp[j] + q[i].x);
}
if (dp[(1 << m) - 1] != (1LL << 60))
ans = min(ans, dp[(1 << m) - 1] + q[i].k * b);
}
cout << ans;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
unsigned long long dp[(1 << 20) + 5];
vector<pair<pair<int, int>, vector<int> > > v;
int val[105];
long long inf = 1.5e18;
int main() {
int n, m, b;
scanf("%d %d %d", &n, &m, &b);
for (int i = 1; i <= n; i++) {
int x, k, m;
scanf("%d %d %d", &x, &k, &m);
vector<int> v1;
for (int j = 0; j < m; j++) {
int tmp;
scanf("%d", &tmp);
v1.push_back(tmp);
}
v.push_back(make_pair(make_pair(k, x), v1));
}
for (int i = 0; i <= (1 << m); i++) {
dp[i] = inf;
}
sort(v.begin(), v.end());
reverse(v.begin(), v.end());
dp[0] = 0;
for (int i = 0; i < v.size(); i++) {
int vl = 0;
vector<int> v1 = v[i].second;
for (int j = 0; j < v1.size(); j++) {
vl += (1 << (v1[j] - 1));
}
val[i] = vl;
}
for (int i = 0; i < v.size(); i++) {
int cost = v[i].first.second;
int req = v[i].first.first;
for (int mask = 0; mask < (1 << m); mask++) {
if (mask == 0) {
dp[val[i]] = min(dp[val[i]], (unsigned long long)req * b + cost);
} else {
dp[val[i] | mask] = min(dp[val[i] | mask], dp[mask] + cost);
}
}
}
if (dp[(1 << m) - 1] != inf)
cout << dp[(1 << m) - 1];
else
printf("-1");
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxD = 1 << 20;
long long dyn[maxD];
struct CFriend {
int price;
int mon;
int mask;
};
bool friendsCmp(const CFriend& first, const CFriend& second) {
return first.mon <= second.mon;
}
int main() {
int n, m;
long long b;
while (cin >> n >> m >> b) {
int ansMask = (1 << m) - 1;
vector<CFriend> friends(n);
for (int i = 0; i < n; i++) {
cin >> friends[i].price >> friends[i].mon;
friends[i].mask = 0;
int taskCount;
cin >> taskCount;
for (int j = 0; j < taskCount; j++) {
int task;
cin >> task;
task--;
friends[i].mask |= (1 << task);
}
}
sort(friends.begin(), friends.end(), friendsCmp);
long long bestAns = -1;
for (int j = 0; j < maxD; j++) {
dyn[j] = -1;
}
dyn[0] = 0;
for (int j = 0; j < n; j++) {
for (int i = 0; i <= ansMask; i++) {
int mask = i;
if (dyn[mask] == -1) {
continue;
}
int newMask = mask | friends[j].mask;
if (newMask == mask) {
continue;
}
long long price = dyn[mask] + friends[j].price;
if (dyn[newMask] == -1) {
dyn[newMask] = price;
} else {
dyn[newMask] = min(dyn[newMask], price);
}
}
if (dyn[ansMask] != -1) {
long long ans = dyn[ansMask] + friends[j].mon * b;
bestAns = bestAns == -1 ? ans : min(bestAns, ans);
}
}
cout << bestAns << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long LINF = 1e17 + 7;
const unsigned long long BASE = 33;
const int N = 1e2 + 7;
const int INF = 1e9 + 7;
const int MOD = 10003;
const double Pi = acos(-1.);
const double EPS = 1e-8;
const int P = 1e9 + 9;
long long kpow(long long a, long long b) {
long long ret = 1;
for (; b; b >>= 1, a = a * a % P)
if (b & 1) ret = ret * a % P;
return ret;
}
struct Node {
int x, k, sov;
bool operator<(const Node &p) const { return k < p.k; }
} a[N];
int n, m, xm, b;
long long f[2][(1 << 20) + 7];
inline void upd(long long &x, long long y) {
if (x == -1 || x > y) x = y;
}
int main() {
scanf("%d%d%d", &n, &m, &b);
for (int i = 0; i < (n); ++i) {
int t;
scanf("%d%d%d", &a[i].x, &a[i].k, &t);
for (int j = 0; j < (t); ++j) {
int x;
scanf("%d", &x);
a[i].sov |= (1 << (x - 1));
}
}
sort(a, a + n);
long long ans = -1;
xm = 1 << m;
int t = 0;
for (int i = 0; i < (xm); ++i) f[t][i] = -1;
f[t][0] = 0;
for (int i = 0; i < (n); ++i) {
for (int mask = 0; mask < (xm); ++mask) f[t ^ 1][mask] = -1;
for (int mask = 0; mask < (xm); ++mask)
if (~f[t][mask]) {
upd(f[t ^ 1][mask], f[t][mask]);
upd(f[t ^ 1][mask | a[i].sov], f[t][mask] + a[i].x);
}
t ^= 1;
if (~f[t][xm - 1]) upd(ans, f[t][xm - 1] + (long long)b * a[i].k);
}
printf("%lld", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m, b;
int can[100], req_mon[100], cost[100];
int ord[100];
long long dp[2][1 << 20];
int main() {
scanf("%d %d %d", &n, &m, &b);
for (int i = 0; i < (n); i++) {
int q;
scanf("%d %d %d", cost + i, req_mon + i, &q);
while (q--) {
int x;
scanf("%d", &x);
x--;
can[i] |= 1 << x;
}
ord[i] = i;
}
sort(ord, ord + n,
[](const int a, const int& b) { return req_mon[a] < req_mon[b]; });
long long ans = 1LL << 60;
fill(dp[0], dp[2], 1LL << 60);
dp[0][0] = 0;
int one = 1, other = 0;
for (int j = 0; j < (n); j++) {
int i = ord[j];
for (int msk = 0; msk < (1 << m); msk++) dp[one][msk] = dp[other][msk];
for (int msk = 0; msk < (1 << m); msk++)
dp[one][msk | can[i]] =
min(dp[one][msk | can[i]], dp[other][msk] + cost[i]);
ans = min(ans, dp[one][(1 << m) - 1] + req_mon[i] * 1LL * b);
swap(one, other);
}
if (ans >= (1LL << 60)) ans = -1;
cout << ans << endl;
cerr << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m, k, y, tt, c, d, x, M[105];
string cad;
unsigned long long b, X[105], K[105], dp[2][(1 << 20) + 2];
int main() {
ios_base::sync_with_stdio(0);
cin >> n >> m >> b;
for (int i = 1; i <= n; i++) {
cin >> X[i] >> K[i] >> c;
d = 0;
for (int j = 0; j < c; j++) {
cin >> y;
y--;
d |= (1 << y);
}
M[i] = d;
}
for (int i = 1; i <= n; i++)
for (int j = i + 1; j <= n; j++)
if (K[i] > K[j]) {
swap(K[i], K[j]);
swap(M[i], M[j]);
swap(X[i], X[j]);
}
unsigned long long res = 1LL << 63;
for (int i = 0; i <= (1 << 20); i++) dp[0][i] = dp[1][i] = res;
unsigned long long oo = res;
dp[0][0] = 0;
dp[1][0] = 0;
for (int i = 1; i <= n; i++) {
for (int j = 0; j < (1 << m); j++) dp[i & 1][j] = dp[(i + 1) & 1][j];
for (int j = 0; j < (1 << m); j++)
if (dp[(i + 1) & 1][j] != oo) {
dp[i & 1][j | M[i]] =
min(dp[i & 1][j | M[i]], dp[(i + 1) & 1][j] + X[i]);
}
if (dp[i & 1][(1 << m) - 1] != oo) {
res = min(res, dp[i & 1][(1 << m) - 1] + b * K[i]);
}
}
if (res == oo)
cout << -1;
else
cout << res;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long INF = 0x3f3f3f3f3f3f3f3f;
struct Package {
long long x, k;
int s;
} a[110];
inline bool operator<(const Package &a, const Package &b) { return a.k < b.k; }
int n, m;
long long b, f[1 << 20], ans = INF;
int main() {
cin >> n >> m >> b;
for (int i = 1, t; i <= n; i++) {
cin >> a[i].x >> a[i].k >> t;
for (int j = 1, p; j <= t; j++) cin >> p, a[i].s |= 1 << p - 1;
}
sort(a + 1, a + n + 1);
memset(f, 0x3f, sizeof(f));
f[0] = 0;
for (int i = 0; i < n; i++) {
for (int j = (1 << m) - 1; j >= 0; j--)
if (f[j] < INF) {
f[j] += b * (a[i + 1].k - a[i].k);
f[j | a[i + 1].s] = min(f[j | a[i + 1].s], f[j] + a[i + 1].x);
}
ans = min(ans, f[(1 << m) - 1]);
}
cout << (ans >= INF ? -1 : ans) << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int X[1020304], K[1020304];
int n, p[1020304], m, B;
int cmp(int x, int y) { return K[x] < K[y]; }
int Mask[1020304];
long long f[1111111];
int main() {
cin >> n >> m >> B;
for (int i = 1; i <= n; ++i) {
int t;
scanf("%d%d%d", &X[i], &K[i], &t);
Mask[i] = 0;
for (int j = 1; j <= t; ++j) {
int p;
scanf("%d", &p);
Mask[i] |= 1 << p - 1;
}
p[i] = i;
}
sort(p + 1, p + n + 1, cmp);
f[0] = 0;
for (int i = 1; i <= (1 << m) - 1; ++i) f[i] = (long long)1.5e18;
long long ans = (long long)1.5e18;
for (int I = 1; I <= n; ++I) {
int i = p[I];
long long curans = (long long)K[i] * B;
if (curans > ans) break;
for (int S = 0; S <= (1 << m) - 1; ++S)
if ((S & Mask[i]) < Mask[i]) {
f[S | Mask[i]] = min(f[S | Mask[i]], f[S] + X[i]);
}
ans = min(ans, curans + f[(1 << m) - 1]);
}
if (ans > 1.3e18)
puts("-1");
else
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = (1 << 20) + 5;
const int M = 105;
const long long INF = 0x3f3f3f3f3f3f3f3f;
struct state {
int s;
long long k, val;
} p[M];
int n, m;
long long b, dp[N];
bool cmp(const state& a, const state& b) { return a.k < b.k; }
void init() {
memset(dp, -1, sizeof(dp));
scanf("%d%d", &n, &m);
cin >> b;
int t, a;
for (int i = 0; i < n; i++) {
cin >> p[i].val >> p[i].k >> t;
p[i].s = 0;
for (int j = 0; j < t; j++) {
scanf("%d", &a);
p[i].s |= (1 << (a - 1));
}
}
sort(p, p + n, cmp);
}
long long solve() {
dp[0] = 0;
int t = (1 << m) - 1;
long long ans = INF;
for (int i = 0; i < n; i++) {
for (int j = 0; j <= t; j++) {
if (dp[j] == -1) continue;
int u = p[i].s | j;
if (dp[u] == -1)
dp[u] = p[i].val + dp[j];
else
dp[u] = min(dp[u], p[i].val + dp[j]);
}
if (dp[t] != -1) ans = min(ans, dp[t] + p[i].k * b);
}
return ans == INF ? -1 : ans;
}
int main() {
init();
cout << solve() << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
using namespace rel_ops;
const double pi = acos(-1.0);
const double eps = 1e-11;
const int inf = 0x7FFFFFFF;
template <class T>
inline bool checkmin(T &a, T b) {
return b < a ? a = b, 1 : 0;
}
template <class T>
inline bool checkmax(T &a, T b) {
return b > a ? a = b, 1 : 0;
}
template <class T>
inline T sqr(T x) {
return x * x;
}
int n, m;
long long ba;
long long x[101], k[101];
int b[101], msk[101];
long long ans[(1 << 20) + 231];
bool cmp(int a, int b) { return k[a] < k[b]; }
int main() {
while (cin >> n >> m >> ba) {
memset(msk, 0, sizeof(msk));
for (int i = 0; i < int(n); i++) {
cin >> x[i] >> k[i] >> b[i];
for (int j = 0; j < int(b[i]); j++) {
int t;
cin >> t;
msk[i] |= 1 << (t - 1);
}
}
memset(ans, 37, sizeof(ans));
long long inf = ans[0];
ans[0] = 0;
int ar[101];
for (int i = 0; i < int(n); i++) ar[i] = i;
sort(ar, ar + n, cmp);
int tot = 1 << m;
long long cost = inf;
for (int i = 0; i < int(n); i++) {
int c = ar[i];
int ms = msk[c];
long long co = x[c];
for (int j = 0; j < int(tot); j++) {
checkmin(ans[ms | j], ans[j] + co);
}
if (ans[tot - 1] != inf) checkmin(cost, ans[tot - 1] + k[c] * ba);
}
if (cost == inf) cost = -1;
cout << cost << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const double eps = 1.0e-11;
const double pi = acos(-1.0);
const int N = 110;
const long long INF = 2000000000000000000;
long long n, m, b;
pair<pair<long long, long long>, long long> d[N];
long long dp[1 << 20];
int main() {
ios_base::sync_with_stdio(0);
cin >> n >> m >> b;
for (long long i = 0; i < n; i++) {
int t, p;
cin >> d[i].second >> d[i].first.first >> t;
for (long long j = 0; j < t; j++) {
cin >> p;
--p;
d[i].first.second |= (1 << p);
}
}
sort(d, d + n);
reverse(d, d + n);
for (long long i = 0; i < (1 << m); i++) dp[i] = INF;
dp[0] = 0;
for (long long i = 0; i < n; i++) {
long long curr = d[i].first.second;
for (long long mask = (1 << m) - 1; mask >= 1; --mask) {
dp[mask | curr] = min(dp[mask | curr], dp[mask] + d[i].second);
}
dp[curr] = min(dp[curr], d[i].first.first * b + d[i].second);
}
if (dp[(1 << m) - 1] == INF)
cout << "-1\n";
else
cout << dp[(1 << m) - 1] << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MXN = 110;
int N, M, B;
int X[MXN], K[MXN], m[MXN] = {}, sa[MXN];
bool cmp(const int& i, const int& j) { return K[i] < K[j]; }
void init() {
scanf("%d%d%d", &N, &M, &B);
for (int i = 1; i <= N; i++) {
static int n, x;
scanf("%d%d%d", X + i, K + i, &n);
for (int j = 0; j < n; j++) scanf("%d", &x), m[i] |= 1 << (x - 1);
}
}
namespace solve {
const unsigned long long inf = (unsigned long long)1e19;
unsigned long long F[1 << 20], answer = inf;
void solve() {
for (int i = 1; i <= N; i++) sa[i] = i;
sort(sa + 1, sa + N + 1, cmp);
for (int S = 0; S < (1 << M); S++) F[S] = inf;
F[0] = 0;
for (int i = 1; i <= N; i++) {
for (int S = 0; S < (1 << M); S++)
if (F[S] != inf) F[S | m[sa[i]]] = min(F[S | m[sa[i]]], F[S] + X[sa[i]]);
answer = min(answer, F[(1 << M) - 1] + (unsigned long long)K[sa[i]] * B);
}
if (answer == inf) {
puts("-1");
} else {
cout << answer << endl;
}
}
} // namespace solve
int main() {
init();
solve::solve();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long inf = 0x3f3f3f3f3f3f3f3f;
const int maxn = 121;
long long n, m, b, dp[1 << 20];
struct People {
long long x, k, m;
} e[maxn];
bool cmp(People a, People b) {
if (a.k != b.k)
return a.k < b.k;
else
return a.x < b.x;
}
int main() {
cin >> n >> m >> b;
for (int i = 1; i <= n; i++) {
int j;
cin >> e[i].x >> e[i].k >> j;
while (j--) {
int a;
cin >> a;
e[i].m |= (1 << (a - 1));
}
}
sort(e + 1, e + 1 + n, cmp);
long long ans = inf;
memset(dp, 0x3f, sizeof dp);
dp[0] = 0;
for (int i = 1; i <= n; i++) {
for (int j = 0; j < (1 << m) - 1; j++) {
dp[j | e[i].m] = min(dp[j | e[i].m], dp[j] + e[i].x);
}
if (dp[(1 << m) - 1] != inf) {
ans = min(ans, dp[(1 << m) - 1] + 1LL * b * e[i].k);
}
}
if (ans == inf) ans = -1;
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 101;
const int MAXM = 20;
const long long INF = 1LL << 61;
struct person {
int monitors, solve;
long long cost;
person() {
monitors = solve = 0;
cost = 0;
}
person(int _monitors, int _solve, long long _cost) {
monitors = _monitors;
solve = _solve;
cost = _cost;
}
bool operator<(const person& p) const { return monitors < p.monitors; }
};
person P[MAXN];
int N, M;
long long B;
long long DP[1 << MAXM];
int main() {
cin >> N >> M >> B;
for (int i = 0; i < N; ++i) {
int NM;
cin >> P[i].cost >> P[i].monitors >> NM;
int msk = 0;
for (int k = 0; k < NM; ++k) {
int num;
cin >> num;
--num;
msk |= (1 << num);
}
P[i].solve = msk;
}
sort(P, P + N);
int all = (1 << M) - 1;
for (int i = 0; i <= all; ++i) {
DP[i] = INF;
}
DP[0] = 0;
long long res = INF;
for (int i = 0; i < N; ++i) {
for (int msk = 0; msk <= all; ++msk) {
if (DP[msk] < INF) {
int nxt = msk | P[i].solve;
DP[nxt] = min(DP[nxt], DP[msk] + P[i].cost);
}
}
if (DP[all] < INF) {
res = min(res, DP[all] + B * P[i].monitors);
}
}
if (res == INF) {
cout << -1 << endl;
} else {
cout << res << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long MOD = 1000000007;
const int N = 110;
struct T {
int bits;
int x;
int k;
};
bool cmp(const T& a, const T& b) { return a.k < b.k; }
T a[N];
long long dp[(1 << 20) + 4];
int n, m;
long long b;
long long Ans() {
const long long INF = 1LL << 60;
long long res = 0;
long long ans = INF;
int top = 1 << m;
for (int i = 0; i < top; ++i) dp[i] = 1LL << 60;
dp[0] = 0;
res = a[0].k * b;
dp[a[0].bits] = a[0].x;
ans = min(ans, dp[top - 1] + res);
for (int i = 1; i < n; ++i) {
res = a[i].k * b;
int& bits = a[i].bits;
for (int j = top - 1; j >= 0; --j)
if (dp[j] != INF) {
dp[j | bits] = min(dp[j | bits], dp[j] + a[i].x);
}
ans = min(ans, dp[top - 1] + res);
}
if (ans == INF) ans = -1;
return ans;
}
int main() {
ios::sync_with_stdio(false);
cin >> n >> m >> b;
int s, t;
for (int i = 0; i < n; ++i) {
cin >> a[i].x >> a[i].k >> s;
a[i].bits = 0;
for (int j = 0; j < s; ++j) {
cin >> t;
a[i].bits |= 1 << (t - 1);
}
}
sort(a, a + n, cmp);
cout << Ans() << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
int lim, N, M, b;
long long dp[(1 << 20) + 3], INF = 1LL << 61;
pair<int, pair<int, int> > f[109];
int main() {
scanf("%d %d %d", &N, &M, &b);
for (int i = 1; i <= N; i++) {
int l, x;
scanf("%d %d %d", &f[i].second.first, &f[i].first, &l);
while (l--) scanf("%d", &x), f[i].second.second |= 1 << (x - 1);
}
sort(f + 1, f + N + 1);
dp[0] = 0, lim = (1 << M) - 1;
for (int i = 1; i <= lim; i++) dp[i] = INF;
long long mini = INF;
for (int i = 1; i <= N; i++) {
for (int j = lim; j >= 0; j--)
if (dp[j | f[i].second.second] > dp[j] + f[i].second.first)
dp[j | f[i].second.second] = dp[j] + f[i].second.first;
if (dp[lim] + 1LL * b * f[i].first < mini)
mini = dp[lim] + 1LL * b * f[i].first;
}
if (mini >= INF)
printf("-1\n");
else
printf("%I64d\n", mini);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
constexpr long long INF = 4e18;
constexpr int M = 2e6;
constexpr int N = 110;
long long n, m, cost, ans = 4e18, cnt, dp[M], num, c, mx;
pair<long long, pair<long long, long long>> p[N];
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cin >> n >> m >> cost;
for (int i = 1; i <= n; i++) {
cin >> p[i].second.first >> p[i].first >> cnt;
num = 0;
for (int j = 0; j < cnt; j++) {
cin >> c;
num += pow(2, c - 1);
}
p[i].second.second = num;
}
sort(p + 1, p + n + 1);
mx = pow(2, m);
for (int i = 0; i < M; i++) dp[i] = INF;
dp[0] = 0;
for (int i = 1; i <= n; i++) {
num = ~p[i].second.second;
for (int j = 1; j < mx; j++)
dp[j] = min(dp[j], dp[num & j] + p[i].second.first);
ans = min(ans, p[i].first * cost + dp[mx - 1]);
}
if (ans == 4e18)
cout << -1 << '\n';
else
cout << ans << '\n';
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long inf = (long long)4e18;
const int N = 12345;
const int T = (1 << 21);
int x[N], k[N], mask[N];
long long f[T];
int main() {
int n, m, b;
scanf("%d %d %d", &n, &m, &b);
for (int i = 0; i < n; i++) {
int foo;
scanf("%d %d %d", x + i, k + i, &foo);
mask[i] = 0;
while (foo--) {
int bar;
scanf("%d", &bar);
mask[i] |= (1 << (bar - 1));
}
}
for (int i = 0; i < n; i++)
for (int j = i + 1; j < n; j++)
if (k[i] > k[j]) {
swap(x[i], x[j]);
swap(k[i], k[j]);
swap(mask[i], mask[j]);
}
for (int i = 0; i < (1 << m); i++) f[i] = inf;
f[0] = 0;
long long ans = inf;
for (int i = 0; i < n; i++) {
for (int t = 0; t < (1 << m); t++)
if (f[t] + x[i] < f[t | mask[i]]) {
f[t | mask[i]] = f[t] + x[i];
}
long long cur = f[(1 << m) - 1];
cur += 1LL * k[i] * b;
if (cur < ans) ans = cur;
}
cout << (ans == inf ? -1 : ans) << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxl = 1 << 20;
const int maxn = 100 + 1;
const long long int oo = 1000ll * 1000 * 1000 * 1000 * 1000 * 1000 +
1000ll * 1000 * 1000 * 1000 * 1000;
long long int x[maxn], k[maxn];
int mask[maxn];
int n, m;
long long int b;
int arr[maxn];
long long int dp[maxl];
long long int ans;
bool cmp(const int &i, const int &j) {
if (k[i] == k[j]) return i < j;
return k[i] < k[j];
}
int main() {
cin >> n >> m >> b;
for (int i = 0; i < n; i++) {
int tmp;
cin >> x[i] >> k[i] >> tmp;
arr[i] = i;
for (int j = 0; j < tmp; j++) {
int ind;
cin >> ind;
ind--;
mask[i] |= (1 << ind);
}
}
sort(arr, arr + n, cmp);
for (int i = 1; i < maxl; i++) dp[i] = oo;
ans = oo;
for (int i = 0; i < n; i++) {
int ind = arr[i];
for (int msk = 0; msk < (1 << m); msk++)
dp[msk | mask[ind]] = min(dp[msk | mask[ind]], dp[msk] + x[ind]);
ans = min(ans, dp[(1 << m) - 1] + k[ind] * b);
}
if (ans == oo) ans = -1;
cout << ans << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
long long dp[1 << 21];
struct Data {
long long x, k, sta;
} da[105];
bool cmp(Data x, Data y) { return x.k < y.k || x.k == y.k && x.x < y.x; }
int main() {
long long n, m, b, mi, v;
cin >> n >> m >> b;
for (long long i = 1; i <= n; ++i) {
cin >> da[i].x >> da[i].k >> mi;
for (long long j = 1; j <= mi; ++j) {
cin >> v;
da[i].sta |= (1 << (v - 1));
}
}
sort(da + 1, da + n + 1, cmp);
long long ans = 0x3a3a3a3a3a3a3a3a;
memset(dp, 0x3a, sizeof(dp));
dp[0] = 0;
for (long long i = 1; i <= n; ++i) {
for (long long j = 0; j < (1 << m); ++j) {
long long news = j | da[i].sta;
dp[news] = min(dp[news], dp[j] + da[i].x);
}
ans = min(dp[(1 << m) - 1] + da[i].k * b, ans);
}
if (ans == 0x3a3a3a3a3a3a3a3a)
cout << "-1" << endl;
else
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long inf = 4000000000000321000ll;
int n, m, k, b, maxi;
long long kq[(1 << 20) + 1], kq2[(1 << 20) + 1];
int moni[(1 << 20) + 1], moni2[(1 << 20) + 1];
struct Obj {
long long x, k, m;
long long pbl;
Obj() { pbl = 0; }
};
Obj a[102];
bool cmp(Obj e1, Obj e2) {
if (e1.k > e2.k) return true;
if (e1.k == e2.k && e1.x < e2.x) return true;
return false;
}
void Init() {
int i, j, z;
maxi = (1 << m) - 1;
memset(kq, 0x3c, sizeof(kq));
memset(kq2, 0x3c, sizeof(kq2));
kq[0] = 0;
a[n + 1].x = 1000000000;
a[n + 1].k = 1000000000;
}
int main() {
int i, j;
long long z;
scanf("%d%d%d", &n, &m, &k);
for (i = 1; i <= n; i++) {
scanf("%I64d%I64d%I64d", &a[i].x, &a[i].k, &a[i].m);
for (j = 1; j <= a[i].m; j++) {
scanf("%I64d", &z);
a[i].pbl += 1 << (z - 1);
}
}
sort(a + 1, a + n + 1, cmp);
Init();
for (j = 0; j <= n; j++) {
z = a[j + 1].pbl;
kq2[z] = a[j + 1].x + a[j + 1].k * k;
moni[z] = a[j + 1].k;
for (i = 1; i <= maxi; i++) {
if (kq[i] >= inf) continue;
z = i | a[j + 1].pbl;
if (kq2[z] >= kq[i] + a[j + 1].x) {
kq2[z] = kq[i] + a[j + 1].x;
}
}
for (i = 1; i <= maxi; i++)
if (kq2[i] >= kq[i] || kq[i] == 0x3c)
continue;
else {
kq[i] = min(kq[i], kq2[i]);
}
}
if (kq[maxi] >= inf)
printf("%d ", -1);
else
printf("%I64d ", kq[maxi]);
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 101;
const long long inf = 2000000000000000000;
struct my {
long long x;
int y, c, to;
} a[N];
bool comp(my x, my y) { return (x.y < y.y); }
int y, to, q, w, j, f[N][N], n, m, x, i, e;
long long cost, dp[1 << 21], ans, res;
int main() {
cin.tie(0);
ios_base::sync_with_stdio(0);
ans = inf;
cin >> n >> m >> cost;
for (i = 1; i <= n; i++) {
x = 0;
cin >> a[i].x >> a[i].y >> a[i].c;
for (j = 1; j <= a[i].c; j++) {
cin >> y;
y--;
x = x + (1 << y);
}
a[i].to = x;
}
e = (1 << m);
sort(a + 1, a + n + 1, comp);
for (i = 1; i < e; i++) dp[i] = inf;
for (i = 1; i <= n; i++) {
res = a[i].y * cost;
for (j = 0; j < e; j++)
if (dp[j] != inf) {
to = j | a[i].to;
dp[to] = min(dp[to], dp[j] + a[i].x);
}
ans = min(ans, dp[e - 1] + res);
}
if (ans == inf) ans = -1;
cout << ans << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
void file() {}
void fast() {
std::ios_base::sync_with_stdio(0);
cin.tie(NULL);
cout.tie(NULL);
}
long long gcd(long long a, long long b) { return !b ? a : gcd(b, a % b); }
long long lcm(long long a, long long b) { return (a / gcd(a, b)) * b; }
int dx[] = {-1, 0, 1, 0, 1, 1, -1, -1};
int dy[] = {0, 1, 0, -1, 1, -1, 1, -1};
char dir[] = {'U', 'R', 'D', 'L'};
const int N = 2e5 + 5, mod = 1e9 + 7;
int n, m;
vector<vector<int>> a;
long long dp[2][1 << 20];
long long p;
long long solve() {
for (int i = 0; i < (1 << m); i++) dp[0][i] = 4e18;
dp[0][(1 << m) - 1] = 0;
bool b = 0;
long long ans = 4e18;
for (int i = n - 1; i >= 0; i--) {
b = !b;
for (int t = 0; t < (1 << m); t++) {
dp[b][t] = dp[!b][t];
dp[b][t] = min(dp[b][t], a[i][1] + dp[!b][t | a[i][2]]);
}
ans = min(ans, a[i][0] * p + dp[b][0]);
}
return ans;
}
int main() {
file();
fast();
cin >> n >> m >> p;
a = vector<vector<int>>(n, vector<int>(3));
for (int i = 0; i < n; i++) {
int x;
cin >> a[i][1] >> a[i][0] >> x;
while (x--) {
int z;
cin >> z;
z--;
a[i][2] |= (1 << z);
}
}
sort((a).begin(), (a).end());
reverse((a).begin(), (a).end());
if (solve() == 4e18)
cout << -1 << "\n";
else
cout << solve() << "\n";
}
|
#include <bits/stdc++.h>
using namespace std;
inline long long in() {
int32_t x;
scanf("%d", &x);
return x;
}
inline string getStr() {
char ch[1001];
scanf("%s", ch);
return ch;
}
inline char getCh() {
char ch;
scanf(" %c", &ch);
return ch;
}
template <class P, class Q>
inline P smin(P &a, Q b) {
if (b < a) a = b;
return a;
}
template <class P, class Q>
inline P smax(P &a, Q b) {
if (a < b) a = b;
return a;
}
const long long MOD = 1e9 + 7;
const long long MAX_N = 1e3 + 10;
const long long MAX_LG = 21;
const long long base = 29;
const long long MAX_DIF = 5005;
long long e[MAX_N][MAX_N];
vector<pair<long long, long long>> rem;
long long n, m, b;
long long x[MAX_N], k[MAX_N], pr[MAX_N];
long long frmask[MAX_N];
pair<long long, pair<long long, long long>> inf[MAX_N];
const long long sz = (1 << 20);
long long dp[sz];
long long res = 2e18;
int32_t main() {
n = in(), m = in(), b = in();
long long mask = (1 << m) - 1;
for (long long i = 0; i < n; i++) {
x[i] = in(), k[i] = in(), pr[i] = in();
for (long long j = 0; j < pr[i]; j++) frmask[i] += (1 << (in() - 1));
inf[i] = {k[i], {x[i], frmask[i]}};
}
for (long long i = 0; i < sz; i++) dp[i] = 2e18;
dp[0] = 0;
sort(inf, inf + n);
for (long long i = 0; i < n; i++) {
for (long long j = 0; j <= mask; j++) {
long long esh = j | inf[i].second.second;
smin(dp[esh], dp[j] + inf[i].second.first);
}
smin(res, dp[(1 << m) - 1] + inf[i].first * b);
}
if (res == 2e18)
cout << -1 << "\n";
else
cout << res << "\n";
}
|
#include <bits/stdc++.h>
using namespace std;
const unsigned long long inf = 1e19;
const int maxn = 110;
unsigned long long n, m, b;
struct Frd {
unsigned long long x, k, prob;
} Frds[maxn];
unsigned long long dp[(1 << 20) + 10];
inline bool cmp(const Frd &_a, const Frd &_b) { return _a.k < _b.k; }
int main() {
scanf("%lld%lld%lld", &n, &m, &b);
for (int i = 0; i < maxn; i++) Frds[i].prob = 0;
for (int i = 1; i <= n; i++) {
int mm;
scanf("%lld%lld%d", &Frds[i].x, &Frds[i].k, &mm);
for (int j = 0; j < mm; j++) {
int pid;
scanf("%d", &pid);
Frds[i].prob |= (1 << (pid - 1));
}
}
sort(Frds + 1, Frds + 1 + n, cmp);
for (int i = 0; i < 1048586; i++) dp[i] = inf;
dp[0] = 0;
unsigned long long dpans = inf;
for (int i = 1; i <= n; i++) {
for (int j = 0; j < (1 << m); j++) {
if (dp[j] == inf) continue;
dp[j | Frds[i].prob] = min(1ll * dp[j | Frds[i].prob], dp[j] + Frds[i].x);
}
if (dp[(1 << m) - 1] != inf)
dpans = min(1ll * dpans, dp[(1 << m) - 1] + Frds[i].k * b);
}
unsigned long long ans;
if (dpans == inf)
ans = -1;
else
ans = dpans;
printf("%lld", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
struct Friend {
unsigned x, k, m;
};
constexpr unsigned long long infinity = 2000000000000000001ull;
vector<Friend> frs;
unsigned long long solu[1048576];
int main() {
unsigned n, m, b;
cin >> n >> m >> b;
for (unsigned i = 0; i < n; i++) {
unsigned xi, ki, mi, p = 0;
cin >> xi >> ki >> mi;
for (unsigned j = 0; j < mi; j++) {
unsigned q;
cin >> q;
p |= 1 << (q - 1);
}
frs.push_back({xi, ki, p});
}
sort(frs.begin(), frs.end(),
[](const Friend& lhs, const Friend& rhs) { return lhs.k < rhs.k; });
fill_n(solu, 1u << m, infinity);
solu[0] = 0;
unsigned long long sol = infinity;
for (unsigned j = 0; j < n; j++) {
const Friend& fr = frs[j];
for (unsigned i = 0; i < (1u << m); i++)
solu[i | fr.m] = min(solu[i | fr.m], solu[i] + fr.x);
sol = min(sol, solu[(1u << m) - 1] + fr.k * 1ull * b);
}
if (sol >= infinity)
cout << "-1" << endl;
else
cout << sol << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
const double eps = 1e-7;
const long long INF = LLONG_MAX;
long long dp[(1 << 21)];
int N;
int main() {
int n, m;
long long b;
scanf(
"%d %d "
"%lld",
&n, &m, &b);
N = 1 << m;
vector<pair<int, pair<int, int>>> vec;
for (int i = 0; i < n; ++i) {
int x, k, mm;
scanf("%d %d %d", &x, &k, &mm);
int mask = 0;
while (mm--) {
int val;
scanf("%d", &val);
mask |= 1 << (val - 1);
}
vec.push_back(make_pair(k, make_pair(x, mask)));
}
sort((vec).begin(), (vec).end());
for (int i = 0; i < N; ++i) dp[i] = INF;
dp[0] = 0;
long long ans = INF;
for (pair<int, pair<int, int>> x : vec) {
int cost = x.second.first;
int mask = x.second.second;
for (int i = N - 1; i >= 0; --i)
if (dp[i] != INF) dp[i | mask] = min(dp[i | mask], dp[i] + cost);
if (dp[N - 1] != INF) ans = min(ans, dp[N - 1] + x.first * b);
}
if (ans == INF) ans = -1;
printf("%lld", ans);
}
|
#include <bits/stdc++.h>
using namespace std;
typedef struct A {
long long x;
int mk, ki;
void read() {
int M;
cin >> x >> ki >> M;
mk = 0;
for (int i = 0, j; i < M && cin >> j; i++) {
j--;
mk |= (1 << j);
}
}
} AA;
AA a[105];
long long dp[1 << 20];
bool cmp(AA c, AA d) { return c.ki < d.ki; }
int main() {
int N, M;
long long b;
cin >> N >> M >> b;
for (int i = 0; i < N; i++) a[i].read();
sort(a, a + N, cmp);
int MAX = 1 << M;
for (int i = 0; i < MAX; i++) dp[i] = 2000000000000000000LL;
dp[0] = 0;
long long ans = 2000000000000000000LL;
long long extra = 0;
for (int i = 0; i < N; i++) {
extra = (long long)a[i].ki * b;
for (int j = 0; j < MAX; j++) {
int nj = j | a[i].mk;
if (dp[nj] > dp[j] + a[i].x) {
dp[nj] = dp[j] + a[i].x;
}
}
ans = min(ans, dp[MAX - 1] + extra);
}
if (ans == 2000000000000000000LL) ans = -1;
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 110, M = 30;
struct thing {
long long x, k, m, state;
} t[N] = {};
bool thing_cmp(const thing &t1, const thing &t2) { return t1.k < t2.k; }
long long n, m, b;
long long ans1 = 0, f[(1 << 21) + 100] = {}, ans = 0x7fffffffffffffffll;
void init() {
cin >> n >> m >> b;
for (int i = 1; i <= n; ++i) {
cin >> t[i].x >> t[i].k >> t[i].m;
int a;
for (int j = 1; j <= t[i].m; ++j) {
cin >> a;
t[i].state |= 1 << a - 1;
}
}
sort(t + 1, t + n + 1, thing_cmp);
for (int i = 1; i <= (1 << m) - 1; ++i) f[i] = 0x3fffffffffffffffll;
}
void dp(long long s, long long c) {
for (long long i = (1 << m) - 1; i >= 0; --i)
if (f[i] + c < f[i | s]) f[i | s] = f[i] + c;
}
void work() {
for (int i = 1; i <= n; ++i) {
ans1 = t[i].k * b;
dp(t[i].state, t[i].x);
ans = min(ans, ans1 + f[(1 << m) - 1]);
}
if (ans >= 0x3fffffffffffffffll)
printf("-1\n");
else
printf("%I64d\n", ans);
}
int main() {
init();
work();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m, snt, times;
long long cnt;
long long oo = 2000000007;
long long k[110], kt[110];
long long tans;
bool vis[110];
long long f[1100000][2];
struct pp {
long long x, k, num, state;
long long a[30];
};
pp p[110];
bool cmp(pp x, pp y) { return x.k < y.k; }
void work() {
scanf("%d%d", &n, &m);
cin >> cnt;
for (int i = 1; i <= n; i++) {
cin >> p[i].x >> p[i].k >> p[i].num;
k[i] = p[i].k;
for (int j = 1; j <= p[i].num; j++)
cin >> p[i].a[j], p[i].state += (1 << (p[i].a[j] - 1)),
vis[p[i].a[j]] = true;
sort(p[i].a + 1, p[i].a + p[i].num + 1);
}
for (int i = 1; i <= m; i++)
if (!vis[i]) {
cout << "-1\n";
return;
}
sort(p + 1, p + n + 1, cmp);
long long ans = oo * oo;
int maxn = (1 << m) - 1;
for (int i = 0; i <= maxn; i++) f[i][0] = f[i][1] = ans;
f[0][0] = 0;
for (int i = 0; i < n; i++) {
int t = i & 1, s = (i + 1) & 1;
for (int j = 0; j <= maxn; j++)
if (f[j][t] != oo * oo) {
f[j | p[i + 1].state][s] =
min(f[j | p[i + 1].state][s], f[j][t] + p[i + 1].x);
f[j][s] = min(f[j][s], f[j][t]);
}
ans = min(ans, p[i + 1].k * cnt + f[maxn][s]);
for (int i = 0; i <= maxn; i++) f[i][t] = oo * oo;
}
cout << ans << endl;
}
int main() {
work();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
unsigned long long inf = 1e19;
int read() {
int x = 0;
char c = getchar();
while (c < '0' || c > '9') c = getchar();
while (c >= '0' && c <= '9') x = x * 10 + c - '0', c = getchar();
return x;
}
struct node {
unsigned long long x, k;
int sov;
} a[105];
bool cmp(node x, node y) { return x.k < y.k; }
int n, m;
unsigned long long g[1 << 20], b;
void cl(unsigned long long f[1 << 20]) {
for (int i = 0; i < (1 << m); ++i) f[i] = inf;
}
int main() {
register int i, j, S;
n = read(), m = read(), b = read();
for (i = 1; i <= n; ++i) {
a[i].x = read(), a[i].k = read();
int o = read();
for (j = 1; j <= o; ++j) {
int x = read();
a[i].sov |= 1 << x - 1;
}
}
sort(a + 1, a + 1 + n, cmp);
unsigned long long ans = inf;
cl(g);
g[0] = 0;
for (i = 1; i <= n; ++i) {
for (S = 0; S < (1 << m); ++S)
if (g[S] != inf)
if (g[S] + a[i].x < g[S | a[i].sov]) g[S | a[i].sov] = g[S] + a[i].x;
if (g[(1 << m) - 1] + b * a[i].k < ans) ans = g[(1 << m) - 1] + b * a[i].k;
}
if (ans == inf)
cout << -1;
else
cout << ans;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long b;
int hm, n, m, mm, tgt, a;
pair<pair<long long, long long>, int> arr[105];
long long dp[(1 << 20) + 5];
int main() {
scanf("%d %d %I64d", &n, &m, &b);
tgt = (1 << m) - 1;
for (int i = 0; i < n; i++) {
scanf("%I64d %I64d %d", &arr[i].first.second, &arr[i].first.first, &mm);
while (mm--) scanf("%d", &a), arr[i].second |= (1 << (a - 1));
hm |= arr[i].second;
}
if ((tgt & hm) != tgt)
puts("-1");
else {
sort(arr, arr + n);
for (int i = 1; i <= tgt; i++) dp[i] = 4000000000000000000LL;
long long ans = 4000000000000000000LL;
for (int i = 0; i < n; i++) {
for (int j = 0; j <= tgt; j++) {
int next = j | arr[i].second;
dp[next] = min(dp[next], dp[j] + arr[i].first.second);
}
ans = min(ans, dp[tgt] + arr[i].first.first * b);
}
printf("%I64d\n", ans);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long inf = 0x7f7f7f7f7f7f7f7f;
struct sta {
int s;
long long k, val;
} p[105];
int n, m;
long long b, f[(1 << 20) + 5];
bool cmp(sta a, sta b) { return a.k < b.k; }
void init() {
memset(f, -1, sizeof f);
scanf("%d%d", &n, &m);
cin >> b;
int t, a;
for (int i = 0; i < n; i++) {
scanf("%lld%lld%d", &p[i].val, &p[i].k, &t);
p[i].s = 0;
for (int j = 0; j < t; j++) {
scanf("%d", &a);
p[i].s |= (1 << (a - 1));
}
}
sort(p, p + n, cmp);
}
long long solve() {
f[0] = 0;
int t = (1 << m) - 1;
long long ans = inf;
for (int i = 0; i < n; i++) {
for (int j = 0; j <= t; j++) {
if (f[j] == -1) continue;
int u = p[i].s | j;
if (f[u] == -1)
f[u] = p[i].val + f[j];
else
f[u] = min(f[u], p[i].val + f[j]);
}
if (f[t] != -1) ans = min(ans, f[t] + p[i].k * b);
}
return ans == inf ? -1 : ans;
}
int main() {
init();
long long res = solve();
cout << res << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 105;
const int MAXM = (1 << 20) + 5;
const long long INF = 0x3f3f3f3f3f3f3f3f;
struct num {
int x, k, state;
bool operator<(const num &b) const { return k < b.k; }
} data[MAXN];
long long dp[MAXM];
int main() {
int n, m, t;
long long b;
scanf("%d%d%I64d", &n, &m, &b);
for (int i = 0; i < n; ++i) {
scanf("%d%d%d", &data[i].x, &data[i].k, &t);
int tmp;
data[i].state = 0;
while (t--) {
scanf("%d", &tmp);
data[i].state |= 1 << (tmp - 1);
}
}
sort(data, data + n);
memset(dp, 0x3f, sizeof(dp));
dp[0] = 0;
long long ans = INF;
for (int i = 0; i < n; ++i) {
for (int j = 0; j < (1 << m); ++j)
dp[j | data[i].state] = min(dp[j | data[i].state], dp[j] + data[i].x);
ans = min(ans, dp[(1 << m) - 1] + b * data[i].k);
}
printf("%I64d", ans >= INF ? -1 : ans);
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m, B, pret[110], nrB[110], cf[110], ord[110];
long long best[1100000], sol = 2000000000000000000LL;
bool viz[1100000];
queue<int> Q, Q2;
inline bool Sortare(int i, int j) { return nrB[i] < nrB[j]; }
int main() {
std::ios_base::sync_with_stdio(false);
int i, b, x, nr, conf;
cin >> n >> m >> B;
for (i = 1; i <= n; ++i) {
cin >> pret[i] >> nrB[i] >> nr;
cf[i] = 0;
while (nr) {
cin >> x;
x--;
cf[i] |= (1 << x);
nr--;
}
ord[i] = i;
}
sort(ord + 1, ord + n + 1, Sortare);
for (conf = 0; conf < (1 << m); ++conf) best[conf] = 2000000000000000000LL;
best[0] = 0;
for (b = 1; b <= n; ++b) {
i = ord[b];
for (conf = (1 << m) - 1; conf >= 0; --conf)
best[conf | cf[i]] = min(best[conf | cf[i]], best[conf] + 1LL * pret[i]);
sol = min(sol, best[(1 << m) - 1] + 1LL * nrB[i] * B);
}
if (sol < 2000000000000000000LL)
cout << sol << "\n";
else
cout << "-1\n";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long cost[1 << 20];
struct TPart {
long long a, b;
int m;
TPart(long long a = 0, long long b = 0, int m = 0) : a(a), b(b), m(m) {}
bool operator<(const TPart &p) const { return b > p.b; }
};
int main() {
int N, M;
long long B;
cin >> N >> M >> B;
vector<TPart> a(N);
for (int i = 0; i < (int)(N); ++i) {
int x;
cin >> a[i].a >> a[i].b >> x;
for (int j = 0; j < (int)(x); ++j) {
int y;
cin >> y;
a[i].m += 1 << (y - 1);
}
}
for (int i = 0; i < (int)(1 << M); ++i) {
cost[i] = 3e18;
}
sort((a).begin(), (a).end());
for (int i = 0; i < (int)(N); ++i) {
cost[0] = a[i].b * B;
for (int j = 0; j < (int)(1 << M); ++j) {
cost[j | a[i].m] = min(cost[j | a[i].m], cost[j] + a[i].a);
}
}
if (cost[(1 << M) - 1] > 2e18) {
cout << -1 << '\n';
} else {
cout << cost[(1 << M) - 1] << '\n';
}
return 0;
}
|
#include <bits/stdc++.h>
long long mod = 1000000007;
using namespace std;
int n, m;
long long b;
struct node {
int money, monitors, pre;
vector<int> G;
} a[202];
bool cmp(node x, node y) { return x.monitors > y.monitors; }
long long dp[2][1 << 20];
int setbit(int x, int pos) { return x | (1 << pos); }
bool checkbit(int x, int pos) { return x & (1 << pos); }
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 has[25];
int main() {
int i, j, fl, test, index, mask, cnt = 0;
scanf("%d%d%lld", &n, &m, &b);
for (i = 0; i < n; i++) {
scanf("%d%d%d", &a[i].money, &a[i].monitors, &j);
while (j--) {
scanf("%d", &fl);
fl--;
a[i].pre = setbit(a[i].pre, fl);
a[i].G.push_back(fl);
if (has[fl] == 0) {
cnt++;
has[fl] = 1;
}
}
}
if (cnt < m) {
printf("-1\n");
return 0;
}
sort(a, a + n, cmp);
int tmask, touse;
for (index = n; index >= 0; index--) {
for (mask = 0; mask < (1 << m); mask++) {
touse = index % 2;
if (mask == (1 << m) - 1) {
dp[touse][mask] = 0ll;
continue;
}
if (index == n) {
dp[touse][mask] = -2;
continue;
}
int i;
long long op1, op2 = a[index].money, op3;
op1 = dp[(touse + 1) % 2][mask];
if (mask == 0) op2 += a[index].monitors * b;
tmask = mask;
tmask = tmask | a[index].pre;
op3 = dp[(touse + 1) % 2][tmask];
if (op1 == -2 && op3 == -2)
dp[touse][mask] = -2;
else if (op1 != -2 && op3 != -2)
dp[touse][mask] = min(op1, op2 + op3);
else if (op1 == -2)
dp[touse][mask] = op2 + op3;
else
dp[touse][mask] = op1;
}
}
long long ans = dp[0][0];
if (ans == -2)
printf("-1\n");
else
printf("%lld\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1048576;
int n, m, cost[N], kol[N], q, M, b[N], first, dd, c;
long long dp[N], ans = (long long)3e18;
int main() {
ios_base::sync_with_stdio(0);
cin >> n >> m >> c;
for (int i = 0; i < n; ++i) {
cin >> cost[i] >> kol[i] >> q;
for (int j = 0; j < q; ++j) cin >> first, b[i] |= 1 << (first - 1);
}
M = (1 << m);
for (int i = 1; i < M; ++i) dp[i] = (long long)3e18;
for (int i = 0; i < n; ++i)
for (int j = 0; j < i; ++j)
if (kol[j] > kol[i]) {
swap(kol[i], kol[j]);
swap(cost[i], cost[j]);
swap(b[i], b[j]);
}
for (int i = 0; i < n; ++i) {
dd = max(dd, kol[i]);
if (dd * 1ll * c > ans) break;
for (int mask = 0; mask < M; ++mask)
dp[mask | b[i]] = min(dp[mask | b[i]], dp[mask] + cost[i]);
ans = min(ans, dd * 1ll * c + dp[M - 1]);
}
cout << (ans == (long long)3e18 ? -1 : ans);
}
|
#include <bits/stdc++.h>
using namespace std;
template <class T>
inline T sqr(T x) {
return x * x;
}
const int INF = 0x3fffffff;
const long long LINF = INF * 1ll * INF;
const double PI = acos(-1.0);
using namespace std;
long long dp[2][1 << 20];
struct Item {
int x, k, st;
bool operator<(const Item& it) const { return k > it.k; }
} it[105];
inline void update(long long& ans, long long v) {
if (ans > v) ans = v;
}
int main(void) {
int n, m, b;
scanf("%d %d %d", &n, &m, &b);
for (int i = 0; i < n; i++) {
int cnt;
scanf("%d %d %d", &it[i].x, &it[i].k, &cnt);
it[i].st = 0;
for (int j = 0; j < cnt; j++) {
int x;
scanf("%d", &x);
x--;
it[i].st |= (1 << x);
}
}
sort(it, it + n);
for (int i = 0; i < (1 << m); i++) dp[0][i] = LINF;
dp[0][0] = 0;
int now = 0;
for (int i = 0; i < n; i++) {
for (int j = 1; j < (1 << m); j++) dp[now ^ 1][j] = LINF;
update(dp[now ^ 1][it[i].st],
dp[now][0] + 0ll + it[i].x + 1ll * it[i].k * b);
update(dp[now ^ 1][0], dp[now][0]);
for (int j = 1; j < (1 << m); j++) {
update(dp[now ^ 1][it[i].st | j], dp[now][j] + it[i].x);
update(dp[now ^ 1][j], dp[now][j]);
}
now ^= 1;
}
long long ans = dp[now][(1 << m) - 1];
if (ans == LINF) ans = -1;
printf("%I64d\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
struct Th {
int x, c, w;
} A[100 + 3];
int n, m, ll;
long long f[1 << 20], Cost, ans;
bool comp(const Th &A, const Th &B) { return A.c < B.c; }
int main() {
scanf("%d%d%I64d", &n, &m, &Cost);
ll = 1 << m;
int All = 0;
for (int i = 1; i <= n; i++) {
int sl, x;
scanf("%d%d%d", &A[i].w, &A[i].c, &sl);
for (int j = 1; j <= sl; j++) {
scanf("%d", &x);
A[i].x |= 1 << (x - 1);
}
All |= A[i].x;
}
if (All != ll - 1) {
puts("-1");
return 0;
}
sort(A + 1, A + n + 1, comp);
memset(f, 120, sizeof(f));
ans = 2e18;
f[0] = 0;
for (int i = 1; i <= n; i++) {
int x = A[i].x, w = A[i].w;
for (int j = 0; j < ll; j++)
if (f[j] < 2e16) f[j | x] = min(f[j | x], f[j] + w);
if (f[ll - 1] < 2e16) ans = min(ans, Cost * A[i].c + f[ll - 1]);
}
printf("%I64d", ans);
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e2 + 10;
const int max_mask = 1 << 20;
const long long INF = 2e18;
int n, m;
long long b;
long long x[maxn], k[maxn];
int M[maxn];
vector<pair<int, int> > arr;
long long dp[2][max_mask + 10];
void init() {
for (int k = 0; k <= 1; ++k)
for (int mask = 0; mask <= 1 << m; ++mask) dp[k][mask] = INF;
}
long long solve() {
sort(arr.begin(), arr.end());
long long ans = INF;
init();
int cur = 0;
dp[0][0] = dp[1][0] = 0;
for (int i = 0; i <= n - 1; ++i) {
int id = arr[i].second;
for (int mask = 0; mask <= (1 << m) - 1; ++mask)
dp[cur][mask] = min(dp[cur][mask], dp[cur ^ 1][mask]);
for (int mask = 0; mask <= (1 << m) - 1; ++mask)
if (dp[cur][mask] != INF)
dp[cur ^ 1][mask | M[id]] =
min(dp[cur ^ 1][mask | M[id]], dp[cur][mask] + x[id]);
if (dp[cur ^ 1][(1 << m) - 1] != INF)
ans = min(ans, dp[cur ^ 1][(1 << m) - 1] + k[id] * b);
cur ^= 1;
}
if (ans == INF) ans = -1;
return ans;
}
int main() {
scanf("%d%d%lld", &n, &m, &b);
for (int i = 0; i <= n - 1; ++i) {
int sz;
scanf("%lld%lld%d", &x[i], &k[i], &sz);
while (sz--) {
int id;
scanf("%d", &id);
--id;
M[i] += (1 << id);
}
arr.push_back(pair<int, int>(k[i], i));
}
printf("%lld\n", solve());
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long inf = 2e18 + 100;
int n, m, b;
const int N = 100 + 5;
vector<int> problems[N];
long long dp[(1 << 20) + 5];
vector<pair<pair<int, int>, int>> vec;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cin >> n >> m >> b;
for (int i = 0; i < n; i++) {
int xi, ki, mi;
cin >> xi >> ki >> mi;
vec.push_back({{ki, xi}, i});
for (int j = 0; j < mi; j++) {
int in;
cin >> in;
problems[i].push_back(--in);
}
}
for (int i = 1; i < (1 << m); i++) {
dp[i] = inf;
}
long long res = inf;
sort(vec.begin(), vec.end());
for (int i = 0; i < n; i++) {
int problemsMsk = 0;
for (int j = 0; j < problems[vec[i].second].size(); j++) {
problemsMsk |= (1 << problems[vec[i].second][j]);
}
for (int j = 0; j < (1 << m); j++) {
int newMsk = j | problemsMsk;
long long cost = dp[j] + vec[i].first.second;
if (cost < dp[newMsk]) {
dp[newMsk] = cost;
}
}
if (dp[(1 << m) - 1] != inf)
res = min(
res, dp[(1 << m) - 1] + (long long)vec[i].first.first * (long long)b);
}
if (res == inf)
cout << -1;
else
cout << res;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long INF = (long long)2e18 + 100ll;
const int N = 20;
long long dp[1 << N];
int n, m;
long long b;
struct man {
long long k, x;
int mask;
};
man f[111];
bool cmp(man a, man b) { return a.k < b.k; }
int main() {
ios_base::sync_with_stdio(0);
cin >> n >> m >> b;
for (int i = 0; i < n; i++) {
f[i].mask = 0;
cin >> f[i].x >> f[i].k;
int cnt;
cin >> cnt;
for (int j = 0; j < cnt; j++) {
int x;
cin >> x;
x--;
f[i].mask |= (1 << x);
}
}
sort(f, f + n, cmp);
long long res = INF;
for (int i = 0; i < (1 << m); i++) dp[i] = INF;
dp[0] = 0;
for (int pos = 0; pos < n; pos++) {
for (int mask = 0; mask < (1 << m); mask++)
dp[mask | f[pos].mask] = min(dp[mask | f[pos].mask], dp[mask] + f[pos].x);
int a = (1 << m) - 1;
if (dp[a] < INF) res = min(res, dp[a] + f[pos].k * b);
}
if (res == INF) res = -1;
cout << res;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
struct Friend {
long long mask, x, k;
bool operator<(Friend f) const { return k < f.k; }
} f[200];
long long n, m, b, full;
long long dp[1 << 20];
long long ans = 8e18;
void init() {
cin >> n >> m >> b;
for (int s, t, i = 0; i < n; ++i) {
cin >> f[i].x >> f[i].k >> t;
while (t--) {
cin >> s;
f[i].mask |= (1 << (s - 1));
}
}
full = (1 << m);
sort(f, f + n);
for (int i = 1; i < full; ++i) {
dp[i] = 8e18;
}
}
int main() {
init();
for (int i = 0; i < n; ++i) {
for (int bt = 0; bt < full; ++bt) {
dp[bt | f[i].mask] = min(dp[bt] + f[i].x, dp[bt | f[i].mask]);
}
ans = min(ans, dp[full - 1] + f[i].k * b);
}
cout << (ans > 7e18 ? -1 : ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = (1 << 20) + 10;
long long dp[maxn];
struct NN {
int x, k, m;
int ind;
int sta;
} nn[110];
int cmp(NN a, NN b) { return a.k < b.k; }
int a[110][110];
int main() {
int n, m, b, i, j, k;
scanf("%d%d%d", &n, &m, &b);
for (i = 1; i <= n; i++) {
scanf("%d%d%d", &nn[i].x, &nn[i].k, &nn[i].m);
nn[i].ind = i;
nn[i].sta = 0;
for (j = 1; j <= nn[i].m; j++)
scanf("%d", &a[i][j]), nn[i].sta |= (1 << (a[i][j] - 1));
}
sort(nn + 1, nn + 1 + n, cmp);
memset(dp, -1, sizeof(dp));
dp[0] = 0;
long long ans = (1ull << 63) - 1;
for (i = 1; i <= n; i++) {
for (j = (1 << m) - 1; j >= 0; j--)
if (dp[j] >= 0) {
k = j | nn[i].sta;
if (dp[k] < 0 || dp[k] > dp[j] + nn[i].x) dp[k] = dp[j] + nn[i].x;
}
if (dp[(1 << m) - 1] >= 0 && ans > dp[(1 << m) - 1] + nn[i].k * (b + 0ll))
ans = dp[(1 << m) - 1] + nn[i].k * (b + 0ll);
}
if (ans == (1ull << 63) - 1) ans = -1;
cout << ans << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long inf = 4e18;
struct ab {
long long v, c, m, a;
} t[505];
long long dp[5000005];
long long cmp(ab x, ab y) { return x.c < y.c; }
signed main() {
long long n, m, v, ans = inf;
scanf("%lld%lld%lld", &n, &m, &v);
for (long long i = 1; i <= n; i++) {
scanf("%lld%lld%lld", &t[i].v, &t[i].c, &t[i].m);
for (long long j = 1; j <= t[i].m; j++) {
long long x;
scanf("%lld", &x);
t[i].a += 1 << (x - 1);
}
}
sort(t + 1, t + 1 + n, cmp);
for (long long i = 1; i < 1 << m; i++) {
dp[i] = inf;
}
for (long long i = 1; i <= n; i++) {
for (long long j = 0; j < 1 << m; j++) {
dp[j | t[i].a] = min(dp[j | t[i].a], dp[j] + t[i].v);
}
ans = min(ans, dp[(1 << m) - 1] + v * t[i].c);
}
printf("%lld\n", ans == inf ? -1 : ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 111;
const int MAXM = 1111111;
const long long INF = 4567891012345678910LL;
int Bin[22];
int N, M;
long long b;
struct Friend {
long long x, k;
int m;
} F[MAXN];
long long lmin(long long a, long long b) { return (a > b) ? b : a; }
void Qsort(int l, int r) {
int i = l, j = r;
long long test = F[(l + r) >> 1].k;
Friend temp;
while (i <= j) {
while (F[i].k < test) ++i;
while (F[j].k > test) --j;
if (i <= j) {
temp = F[i];
F[i] = F[j];
F[j] = temp;
++i;
--j;
}
}
if (i < r) Qsort(i, r);
if (l < j) Qsort(l, j);
}
long long DP[MAXM], ANS = INF;
int main() {
ios_base::sync_with_stdio(false);
Bin[0] = 1;
for (int i = 1; i <= 21; ++i) {
Bin[i] = Bin[i - 1] << 1;
}
cin >> N >> M >> b;
for (int i = 1, cnt; i <= N; ++i) {
cin >> F[i].x >> F[i].k >> cnt;
F[i].m = 0;
for (int j = cnt, a; j >= 1; --j) {
cin >> a;
F[i].m += (1 << (a - 1));
}
}
Qsort(1, N);
for (register int i = 0; i < Bin[M]; ++i) {
DP[i] = INF;
}
DP[0] = 0LL;
for (int i = 1; i <= N; ++i) {
for (int j = Bin[M] - 1; j >= 0; --j) {
if (DP[j] >= INF) continue;
DP[j | F[i].m] = lmin(DP[j] + F[i].x, DP[j | F[i].m]);
}
ANS = lmin(ANS, DP[Bin[M] - 1] + F[i].k * b);
}
if (ANS >= INF)
cout << "-1" << endl;
else
cout << ANS << endl;
return 0;
}
|
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:256000000")
using namespace std;
const int N = 105;
const int M = 22;
const unsigned int INF = 1000 * 1000 * 1000;
const unsigned long long ONE = 1;
const unsigned long long INF64 = 2LL * INF * INF;
unsigned long long dp[2][1 << M];
int n, m, b;
int c[N], km[N], fmask[N];
unsigned long long solve() {
for (int i = 0; i < n; ++i)
for (int j = i + 1; j < n; ++j)
if (km[i] > km[j]) {
swap(c[i], c[j]);
swap(km[i], km[j]);
swap(fmask[i], fmask[j]);
}
fill(dp[0], dp[0] + (1 << m), INF64);
dp[0][0] = 0;
unsigned long long ans = INF64;
for (int i = 0; i < n; ++i) {
int ci = i % 2;
int ni = (i + 1) % 2;
fill(dp[ni], dp[ni] + (1 << m), INF64);
for (int mask = 0; mask < (1 << m); ++mask) {
int nmask = mask | fmask[i];
dp[ni][mask] = min(dp[ni][mask], dp[ci][mask]);
dp[ni][nmask] = min(dp[ni][nmask], dp[ci][mask] + c[i]);
}
if (dp[ni][(1 << m) - 1] != INF64)
ans = min(ans, ONE * km[i] * b + dp[ni][(1 << m) - 1]);
}
return ans;
}
void read() {
scanf("%d %d %d", &n, &m, &b);
for (int i = 0; i < n; ++i) {
int sz;
scanf("%d %d %d", c + i, km + i, &sz);
for (int j = 0; j < sz; ++j) {
int task;
scanf("%d", &task);
fmask[i] |= (1 << (task - 1));
}
}
}
int main() {
read();
unsigned long long ans = solve();
if (ans != INF64)
cout << ans << endl;
else
cout << -1 << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
struct node {
int x, k;
int mask;
};
node a[102];
long long dp[1 << 20];
bool cmp(node a, node b) { return a.k < b.k; }
int main() {
int i, j, n, m, b;
scanf("%d%d%d", &n, &m, &b);
for (i = 1; i <= n; i++) {
int M, tmp = 0;
scanf("%d%d%d", &a[i].x, &a[i].k, &M);
for (j = 0; j < M; j++) {
int X;
scanf("%d", &X);
X--;
tmp |= (1 << X);
}
a[i].mask = tmp;
}
sort(a + 1, a + n + 1, cmp);
long long ans = 2000000000000000000LL;
for (i = 0; i < (1 << m); i++) {
dp[i] = 2000000000000000000LL;
}
dp[0] = 0;
for (i = 1; i <= n; i++) {
for (j = 0; j < (1 << m); j++) {
int nmask = j | a[i].mask;
if (dp[nmask] > dp[j] + a[i].x) dp[nmask] = dp[j] + a[i].x;
}
ans = min(ans, dp[(1 << m) - 1] + (long long)a[i].k * b);
}
if (ans == 2000000000000000000LL) ans = -1;
printf("%I64d\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m, b, i, j;
scanf("%d%d%d", &n, &m, &b);
long long x[n + 1], k[n + 1], z[n + 1], p[n + 1];
pair<pair<long long, long long>, pair<long long, long long>> pr[n + 1];
long long inf = 4000000000000000001;
for (i = 0; i < n; i++) {
scanf("%lld%lld%lld", &x[i], &k[i], &z[i]);
p[i] = 0;
long long pp;
for (j = 0; j < z[i]; j++) {
scanf("%lld", &pp);
pp--;
p[i] |= (1ll << pp);
}
}
for (i = 0; i < n; i++) {
pr[i].first.first = k[i];
pr[i].first.second = x[i];
pr[i].second.first = z[i];
pr[i].second.second = p[i];
}
sort(pr, pr + n);
for (i = 0; i < n; i++) {
k[i + 1] = pr[i].first.first;
x[i + 1] = pr[i].first.second;
z[i + 1] = pr[i].second.first;
p[i + 1] = pr[i].second.second;
}
long long dp[2][1 << m];
for (i = 0; i < 2; i++)
for (j = 0; j < 1 << m; j++) dp[i][j] = inf;
for (i = 0; i < 2; i++) dp[i][0] = 0;
long long ans = inf;
for (i = 1; i <= n; i++) {
for (j = 0; j < 1 << m; j++) {
dp[i % 2][j] = min(dp[i % 2][j], dp[(i + 1) % 2][j]);
dp[i % 2][p[i] | j] = min(dp[i % 2][p[i] | j], dp[(i + 1) % 2][j] + x[i]);
}
ans = min(ans, dp[i % 2][(1 << m) - 1] + b * k[i]);
}
if (ans == inf)
printf("-1");
else
printf("%lld", ans);
}
|
#include <bits/stdc++.h>
struct Friend {
int money, monitor, pbitmask;
};
int f, n, lim;
struct Friend ar[101];
long long int b, fuck[101], dp[2][1 << 20];
int compare(const void* a, const void* b) {
struct Friend x = (*(struct Friend*)a);
struct Friend y = (*(struct Friend*)b);
return (y.monitor - x.monitor);
}
long long int F(int i, int bitmask) {
if (i == f) {
if (bitmask == lim)
return 0;
else
return ((1LL << 62) - 50);
}
if (dp[i][bitmask] != -1) return dp[i][bitmask];
long long int res = F(i + 1, bitmask);
long long int x = F(i + 1, bitmask | ar[i].pbitmask) + ar[i].money;
if (x < res) res = x;
return (dp[i][bitmask] = res);
}
void Pregenerate() {
int i, bitmask;
for (i = f; i >= 0; i--) {
for (bitmask = 0; bitmask <= lim; bitmask++) {
if (i == f) {
if (bitmask == lim)
dp[i & 1][bitmask] = 0;
else
dp[i & 1][bitmask] = ((1LL << 62) - 50);
} else {
long long int res = dp[(i + 1) & 1][bitmask];
long long int x =
dp[(i + 1) & 1][bitmask | ar[i].pbitmask] + ar[i].money;
if (x < res) res = x;
dp[i & 1][bitmask] = res;
if (bitmask == ar[i].pbitmask) fuck[i] = res;
}
}
}
}
int main() {
int i, j, bitmask, m, x;
while (scanf("%d %d %I64d", &f, &n, &b) != EOF) {
bitmask = 0;
lim = (1 << n) - 1;
for (i = 0; i < f; i++) {
ar[i].pbitmask = 0;
scanf("%d %d %d", &ar[i].money, &ar[i].monitor, &m);
while (m--) {
scanf("%d", &x);
x--;
ar[i].pbitmask |= (1 << x);
}
bitmask |= ar[i].pbitmask;
}
if (bitmask != lim)
puts("-1");
else {
qsort(ar, f, sizeof(struct Friend), compare);
Pregenerate();
long long int res = ((1LL << 62) - 50);
for (i = 0; i < f; i++) {
long long int x = fuck[i] + ar[i].money + (b * ar[i].monitor);
if (x < res) res = x;
}
printf("%I64d\n", res);
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long const N = 100 + 20, SZ = (1 << 20) + 20, INF = (long long)2e18;
long long n, m, b, dp[SZ], x, y, all, ans, slv[N], cost[N];
pair<long long, long long> k[N];
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cin >> n >> m >> b;
all = (1LL << m) - 1;
for (int i = 0; i < n; i++) {
cin >> cost[i] >> k[i].first >> x;
k[i].second = i;
for (int j = 0; j < x; j++) {
cin >> y;
y--;
slv[i] += (1LL << y);
}
}
sort(k, k + n);
fill(dp + 1, dp + all + 1, INF);
ans = INF;
for (int i = 0; i < n; i++) {
for (int mask = all; ~mask; mask--)
if (dp[mask] != INF)
dp[mask | slv[k[i].second]] =
min(dp[mask | slv[k[i].second]], dp[mask] + cost[k[i].second]);
ans = min(ans, dp[all] + k[i].first * b);
}
return cout << (ans == INF ? -1 : ans), 0;
}
|
#include <bits/stdc++.h>
using namespace std;
struct point {
int k, x, set;
} f[100];
bool operator<(const point &a, const point &b) { return a.k < b.k; }
const long long inf = 2e18;
int n, m, num, x;
long long dp[2][1 << 20], b;
bool p;
int maxn;
int main() {
scanf("%d%d%I64d", &n, &m, &b);
int sum = 0;
for (int i = 0; i < n; i++) {
scanf("%d%d%d", &f[i].x, &f[i].k, &num);
f[i].set = 0;
for (int j = 0; j < num; j++) {
scanf("%d", &x);
f[i].set |= 1 << (x - 1);
}
sum |= f[i].set;
}
maxn = 1 << m;
if (sum != maxn - 1) {
cout << -1;
return 0;
}
p = 0;
for (int i = 0; i < maxn; i++) dp[p][i] = inf;
dp[p][0] = 0;
long long ans = inf;
sort(f, f + n);
for (int i = 0; i < n; i++) {
if (ans <= f[i].k * b) break;
p = !p;
for (int j = 0; j < maxn; j++) dp[p][j] = dp[!p][j];
for (int j = 0; j < maxn; j++)
if (dp[p][j | f[i].set] > dp[!p][j] + f[i].x)
dp[p][j | f[i].set] = dp[!p][j] + f[i].x;
if (dp[p][maxn - 1] != inf && ans > dp[p][maxn - 1] + f[i].k * b)
ans = dp[p][maxn - 1] + f[i].k * b;
}
cout << ans;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long N = 102;
long long dp[(1ll << 20) + 4], inf = 5e18;
pair<long long, pair<long long, long long> > arr[N];
int32_t main() {
ios::sync_with_stdio(0), cin.tie(0), cout.tie(0);
long long n, m, b, ans = inf;
cin >> n >> m >> b;
for (long long i = (long long)(1); i <= (long long)(n); i++) {
long long x, k, y, z;
cin >> x >> k >> y;
long long cur = 0;
for (long long j = (long long)(1); j <= (long long)(y); j++) {
cin >> z;
cur |= (1ll << (z - 1));
}
arr[i] = {k, {x, cur}};
}
sort(arr + 1, arr + n + 1);
for (long long i = (long long)(0); i <= (long long)((1ll << 20)); i++)
dp[i] = inf;
dp[0] = 0;
for (long long i = (long long)(1); i <= (long long)(n); i++) {
for (long long mask = (long long)(0); mask <= (long long)((1ll << m) - 1);
mask++) {
dp[mask | arr[i].second.second] =
min(dp[mask | arr[i].second.second], dp[mask] + arr[i].second.first);
}
ans = min(ans, dp[(1ll << m) - 1] + b * arr[i].first);
}
cout << (ans == inf ? -1 : ans);
}
|
#include <bits/stdc++.h>
using namespace std;
const long long INF = (long long)4e18 + 7;
inline void minimize(long long &x, const long long &y) {
if (x > y) x = y;
}
struct help {
int x, s, r;
help() { x = s = r = 0; }
void input(void) {
x = s = r = 0;
int k;
scanf("%d%d%d", &x, &r, &k);
for (int zz = 0; zz < (k); zz = zz + 1) {
int v;
scanf("%d", &v);
v--;
s |= (1 << (v));
}
}
bool operator<(const help &a) const { return (r < a.r); }
};
long long f[(1 << (20)) + 7];
help a[111];
int n, m, b;
void init(void) {
scanf("%d%d%d", &n, &m, &b);
for (int i = (1); i <= (n); i = i + 1) a[i].input();
sort(a + 1, a + n + 1);
}
void process(void) {
for (int i = 0; i < ((1 << (m))); i = i + 1) f[i] = INF;
f[0] = 0;
long long res = INF;
for (int i = (1); i <= (n); i = i + 1) {
long long cost = 1LL * b * a[i].r;
for (int j = 0; j < ((1 << (m))); j = j + 1)
if (f[j] < INF) minimize(f[j | a[i].s], f[j] + a[i].x);
minimize(res, f[(1 << (m)) - 1] + cost);
}
if (res < INF)
cout << res;
else
cout << -1;
}
int main(void) {
init();
process();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long const inf = 4e18;
int const N = 105;
int const M = 20;
int n, m, b;
struct Node {
long long x, y;
int s;
bool operator<(const Node& e) const { return y < e.y; }
} p[N];
long long dp[(1 << M) + 10];
long long solve() {
long long ans = inf;
memset(dp, -1, sizeof(dp));
dp[0] = 0;
for (int i = 0; i < n; i++) {
for (int j = 0; j < (1 << m); j++) {
if (dp[j] == -1) continue;
if (dp[j | p[i].s] == -1) {
dp[j | p[i].s] = dp[j] + p[i].x;
} else
dp[j | p[i].s] = min(dp[j | p[i].s], dp[j] + p[i].x);
}
if (dp[(1 << m) - 1] != -1) ans = min(ans, dp[(1 << m) - 1] + p[i].y * b);
}
return ans == inf ? -1 : ans;
}
int main() {
scanf("%d%d%d", &n, &m, &b);
for (int i = 0; i < n; i++) {
int pro;
scanf("%lld%lld%d", &p[i].x, &p[i].y, &pro);
for (int j = 1; j <= pro; j++) {
int k;
scanf("%d", &k);
p[i].s |= 1 << (m - k);
}
}
sort(p, p + n);
printf("%lld", solve());
return 0;
}
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.