text
stringlengths 49
983k
|
|---|
#include <bits/stdc++.h>
using namespace std;
const int inf = ((1 << 30) - 1);
const long long linf = ((1ll << 62) - 1);
const int N = 200;
const int M = 20;
int n, m;
long long b;
long long x[N], k[N];
int mask[N];
int s[N];
inline bool cmp(int a, int b) { return k[a] < k[b]; }
long long dp[1 << M];
int main() {
cin >> n >> m >> b;
for (int i = 0; i < n; i++) {
int c;
cin >> x[i] >> k[i] >> c;
for (int j = 0; j < c; j++) {
int t;
cin >> t;
t--;
mask[i] |= 1 << t;
}
}
for (int i = 0; i < n; i++) s[i] = i;
sort(s, s + n, cmp);
fill_n(dp, 1 << m, linf);
dp[0] = 0;
long long ans = linf;
for (int i = 0; i < n; i++) {
for (int j = 0; j < (1 << m); j++)
dp[j | mask[s[i]]] = min(dp[j | mask[s[i]]], dp[j] + x[s[i]]);
ans = min(ans, dp[(1 << m) - 1] + b * k[s[i]]);
}
if (ans < linf)
cout << ans << '\n';
else
cout << -1 << '\n';
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <class T, class U>
T &ctmax(T &x, const U &y) {
return x = max<T>(x, y);
}
template <class T, class U>
T &ctmin(T &x, const U &y) {
return x = min<T>(x, y);
}
int main() {
cin.tie(0)->sync_with_stdio(0);
cin.exceptions(ios::badbit | ios::failbit);
int n, m, cost;
cin >> n >> m >> cost;
vector<array<int, 3>> a(n);
for (auto i = 0; i < n; ++i) {
int money, monitors, k, mask = 0;
cin >> money >> monitors >> k;
for (auto j = 0; j < k; ++j) {
int p;
cin >> p, --p;
mask |= 1 << p;
}
a[i] = {monitors, money, mask};
}
sort(a.begin(), a.end());
vector<long long> dp(1 << m, numeric_limits<long long>::max() / 2);
dp[0] = 0;
long long res = numeric_limits<long long>::max() / 2;
for (auto [monitors, money, nmask] : a) {
if (dp[nmask] > money) {
for (auto mask = 0; mask < 1 << m; ++mask) {
if ((mask & nmask) == mask) {
ctmin(dp[mask], money);
}
}
for (auto mask = 0; mask < 1 << m; ++mask) {
ctmin(dp[mask], dp[mask ^ (mask & nmask)] + money);
}
}
ctmin(res, dp.back() + 1LL * cost * monitors);
}
if (res < numeric_limits<long long>::max() / 2) {
cout << res << "\n";
} else {
cout << "-1\n";
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long n, m, b;
vector<pair<long long, long long> > v;
long long mask[105], cost[105], monitors[105];
long long dp[1 << 21];
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cin >> n >> m >> b;
for (int i = 0; i <= 100; i++) mask[i] = (1ll << 30) - 1;
for (long long i = 0; i < n; i++) {
long long temp;
cin >> cost[i] >> monitors[i] >> temp;
for (long long j = 0; j < temp; j++) {
long long val;
cin >> val;
mask[i] -= (1ll << (val - 1));
}
v.push_back(make_pair(monitors[i], i));
}
sort(v.begin(), v.end());
for (long long i = 1; i < (1ll << 21) - 2; i++) dp[i] = 1ll << 60;
long long ans = 1ll << 60;
for (long long i = 0; i < n; i++) {
long long pt = v[i].second;
for (long long j = 1; j < (1 << m); j++) {
dp[j] = min(dp[j], dp[j & mask[pt]] + cost[pt]);
}
ans = min(ans, dp[(1 << m) - 1] + v[i].first * b);
}
if (ans < 1ll << 60)
cout << ans << "\n";
else
cout << "-1\n";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long dp[1 << 20];
const long long inf = 4000000000LL * 1000000000LL;
struct triple {
long long a, b, c;
triple() {}
triple(int a, int b, int c) : a(a), b(b), c(c) {}
bool operator<(const triple& B) const { return b < B.b; }
};
triple T[100];
int main() {
int n, m;
long long b;
scanf("%d%d%lld", &n, &m, &b);
for (int i = 0; i < n; i++) {
int k;
scanf("%lld%lld%d", &T[i].a, &T[i].b, &k);
while (k--) {
int a;
scanf("%d", &a);
T[i].c += (1 << (a - 1));
}
}
long long ans = inf;
for (int i = 1; i < (1 << m); i++) dp[i] = inf;
sort(T, T + n);
for (int i = 0; i < n; i++) {
for (int j = 0; j < (1 << m); j++)
dp[j | T[i].c] = min(dp[j | T[i].c], dp[j] + T[i].a);
ans = min(ans, dp[(1 << m) - 1] + T[i].b * b);
}
printf("%lld\n", ans >= inf ? -1LL : ans);
return 0;
}
|
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:16777216")
using namespace std;
const int INF = (1 << 29);
const long long LINF = 1000000097999999903LL;
long long memo[1 << 20 + 1];
long long cost[102];
long long monitor[102];
int solvedMask[102];
int N, M;
long long B;
int main() {
int cases, caseno = 0;
scanf("%d %d %I64d", &N, &M, &B);
memset(solvedMask, 0, sizeof(solvedMask));
for (int i = 0; i < N; i++) {
int noOfprob, probId;
scanf("%I64d %I64d %d", &cost[i], &monitor[i], &noOfprob);
while (noOfprob--) {
scanf("%d", &probId);
solvedMask[i] |= (1 << (probId - 1));
}
}
for (int i = 0; i < N; i++) {
for (int j = i + 1; j < N; j++) {
if (monitor[i] < monitor[j]) {
swap(cost[i], cost[j]);
swap(monitor[i], monitor[j]);
swap(solvedMask[i], solvedMask[j]);
}
}
}
for (int i = 0; i < (1 << M); i++) {
memo[i] = LINF;
}
memo[0] = 0;
long long ret = LINF;
for (int i = 0; i < N; i++) {
for (int j = (1 << M) - 1; j >= 0; j--) {
int solvedProblem = solvedMask[i] | j;
long long costz = memo[j] + cost[i];
if (!j) {
costz += monitor[i] * B;
}
memo[solvedProblem] = min(memo[solvedProblem], costz);
}
}
ret = memo[(1 << M) - 1];
if (ret < LINF) {
printf("%I64d\n", ret);
} else {
printf("-1\n");
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
struct Friend {
int x, k, m;
bool operator<(const Friend &a) const { return k < a.k; }
} F[105];
const long long INF = 1LL << 60;
long long cost[1 << 20];
int main() {
int N, M, B;
long long ans = INF;
scanf("%d%d%d", &N, &M, &B);
for (int i = 1; i <= N; ++i) {
int num, a;
scanf("%d%d%d", &F[i].x, &F[i].k, &num);
F[i].m = 0;
for (int j = 0; j < num; ++j) {
scanf("%d", &a);
F[i].m |= 1 << (a - 1);
}
}
sort(F + 1, F + N + 1);
for (int j = 1; j < 1 << M; ++j) cost[j] = INF;
for (int i = 1; i <= N; ++i) {
for (int j = (1 << M) - 1; j >= 0; --j) {
int k = j | F[i].m;
cost[k] = min(cost[k], cost[j] + F[i].x);
}
ans = min(ans, cost[(1 << M) - 1] + (long long)F[i].k * B);
}
printf("%lld\n", ans == INF ? -1 : ans);
}
|
#include <bits/stdc++.h>
using namespace std;
long long dp[1 << 20];
int a[110], c[110], d[110], s[110];
void ck(long long &a, long long b) {
if (a == -1 || a > b) {
a = b;
}
}
int r[110];
bool cmp(int x, int y) { return c[x] < c[y]; }
int main() {
int n, m, b;
scanf("%d%d%d", &n, &m, &b);
for (int i = 0; i < n; i++) {
scanf("%d%d%d", &a[i], &c[i], &d[i]);
s[i] = 0;
for (int j = 0; j < d[i]; j++) {
int x;
scanf("%d", &x);
x--;
s[i] |= (1 << x);
}
r[i] = i;
}
sort(r, r + n, cmp);
memset(dp, -1, sizeof(dp));
dp[0] = 0;
int ms = 0;
long long cst = 0;
long long ans = -1;
for (int ii = 0; ii < n; ii++) {
int i = r[ii];
cst = (long long)c[i] * b;
for (int j = 0; j < (1 << m); j++) {
if (dp[j] == -1) continue;
ck(dp[j | s[i]], dp[j] + a[i]);
}
if (dp[(1 << m) - 1] != -1) ck(ans, dp[(1 << m) - 1] + cst);
}
printf("%I64d\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
struct A {
int nm;
int cost;
int prb;
} bm[101];
int PArr[100];
long long Min[1048576];
bool cmp(const A &fs, const A &sn) { return fs.nm < sn.nm; }
int main() {
int n, m, b;
PArr[0] = 1;
for (int i = 1; i < 25; i++) {
PArr[i] = PArr[i - 1] * 2;
}
while (scanf("%d %d %d", &n, &m, &b) != EOF) {
memset(Min, -1, sizeof(Min));
for (int i = 0; i < n; i++) {
int slv;
cin >> bm[i].cost >> bm[i].nm >> slv;
bm[i].prb = 0;
for (int j = 0; j < slv; j++) {
int d;
cin >> d;
bm[i].prb |= PArr[d - 1];
}
}
Min[0] = 0;
sort(bm, bm + n, cmp);
for (int i = 0; i < n; i++) {
for (int j = PArr[m] - 1; j >= 0; j--) {
if (Min[j] != -1) {
if ((j | bm[i].prb) != j) {
int xx = j | bm[i].prb;
if ((Min[xx] == -1 || Min[xx] > Min[j] + bm[i].cost) &&
xx != PArr[m] - 1) {
Min[xx] = Min[j] + bm[i].cost;
} else if (xx == PArr[m] - 1) {
long long t1 = bm[i].nm;
t1 *= b;
t1 += Min[j] + bm[i].cost;
if (Min[xx] == -1) {
Min[xx] = t1;
} else if (Min[xx] > t1) {
Min[xx] = t1;
}
}
}
}
}
}
cout << Min[PArr[m] - 1] << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 105;
const int M = 20;
const long long inf = 8e18;
struct frie {
long long money;
int monitors;
int can_solve;
};
frie friends[N];
long long dp[1 << M];
int n, m;
long long b;
template <typename T>
void umin(T &a, T b) {
a = min(a, b);
}
int main() {
ios_base::sync_with_stdio(0), cin.tie(0), cout.tie(0), cout.precision(15);
cin >> n >> m >> b;
for (int i = (0); i <= ((n)-1); i += (+1)) {
int k, id;
cin >> friends[i].money >> friends[i].monitors >> k;
while (k--) {
cin >> id;
id--;
friends[i].can_solve |= (1 << id);
}
}
sort(friends, friends + n,
[&](frie a, frie b) { return a.monitors < b.monitors; });
long long ans = inf;
for (int solved = (0); solved <= (((1 << m)) - 1); solved += (+1)) {
dp[solved] = inf;
}
dp[0] = 0LL;
for (int i = (0); i <= ((n)-1); i += (+1)) {
for (int solved = ((1 << m) - 1); solved >= (0); solved += (-1))
if (dp[solved] != inf) {
umin(dp[solved | friends[i].can_solve], dp[solved] + friends[i].money);
}
umin(ans, dp[(1 << m) - 1] + friends[i].monitors * b);
}
if (ans == inf) {
ans = -1;
}
cout << ans << '\n';
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++) {
if (dp[prev][mask] != 1LL << 60) {
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;
vector<pair<pair<long long, long long>, int> > V;
long long dp[1 << 20];
int main() {
int n, m;
long long b;
cin >> n >> m >> b;
for (int i = 0; i < (1 << m); i++) dp[i] = (4 * 1000000000000000000);
dp[0] = 0;
for (int i = 1; i <= n; i++) {
long long x, k, pr;
cin >> x >> k >> pr;
V.push_back(make_pair(make_pair(k, x), 0));
int idx = V.size() - 1;
for (int j = 0; j < pr; j++) {
int a;
cin >> a;
V[idx].second |= (1 << (a - 1));
}
}
sort(V.begin(), V.end());
long long last = 0;
long long res = (4 * 1000000000000000000);
for (int i = 0; i < V.size(); i++) {
long long need = V[i].first.first;
for (int j = 0; j < (1 << m); j++) {
dp[j] = dp[j] + (b * (need - last));
}
last = need;
int mask = V[i].second;
long long cost = V[i].first.second;
for (int j = 0; j < (1 << m); j++) {
dp[j | mask] = min(dp[j | mask], dp[j] + cost);
}
res = min(res, dp[(1 << m) - 1]);
}
if (res >= (4 * 1000000000000000000))
cout << -1 << endl;
else
cout << res << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
struct rec {
long long co, val, d;
} E[3000005];
bool cmp(const rec &i, const rec &j) { return i.val < j.val; }
long long sum, now, pre, n, m;
long long dp[2][3000005], cost, res, ans;
int main() {
scanf("%I64d%I64d%I64d", &n, &m, &cost);
for (long long i = 1; i <= n; i++) {
long long x, y;
scanf("%I64d%I64d%I64d", &E[i].co, &E[i].val, &x);
for (long long j = 1; j <= x; j++) {
scanf("%I64d", &y);
E[i].d |= 1 << y - 1;
}
}
sort(E + 1, E + 1 + n, cmp);
sum = 1;
for (long long i = 1; i <= m; i++) sum <<= 1;
sum--;
for (long long i = 0; i <= sum; i++) dp[now][i] = 2000000000000000000LL;
dp[now][sum] = 0;
ans = 2000000000000000000LL;
for (long long k = 1; k <= n; k++) {
res += cost * (E[k].val - E[k - 1].val);
pre = now;
now ^= 1;
for (long long i = 0; i <= sum; i++) dp[now][i] = dp[pre][i];
for (long long i = 0; i <= sum; i++) {
long long x = i - (i & E[k].d);
dp[now][x] = min(dp[now][x], dp[pre][i] + E[k].co);
}
ans = min(ans, dp[now][0] + res);
}
if (ans == 2000000000000000000LL) ans = -1;
printf("%I64d\n", ans);
}
|
#include <bits/stdc++.h>
using namespace std;
const long double PI = acos(-1), EPS = 1e-8;
const int mod = 1000000007;
const int dr[]{-1, -1, 0, 1, 1, 1, 0, -1};
const int dc[]{0, 1, 1, 1, 0, -1, -1, -1};
void run() {
ios::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
}
int main() {
run();
int n, m;
long long b;
cin >> n >> m >> b;
vector<vector<int>> v(n, vector<int>(3));
for (auto& it : v) {
int x;
cin >> it[0] >> it[1] >> x;
while (x--) {
int a;
cin >> a;
a--;
it[2] |= (1 << a);
}
}
sort(v.begin(), v.end(),
[](const vector<int>& a, vector<int>& b) { return a[1] < b[1]; });
vector<long long> dp[2];
dp[0] = dp[1] = vector<long long>(1 << m, 0x3f3f3f3f3f3f3f3fLL);
dp[n & 1][(1 << m) - 1] = 0;
for (int idx = n - 1; idx >= 0; idx--)
for (int mask = 0; mask < (1 << m); mask++) {
long long& rt = dp[idx & 1][mask];
rt = dp[(idx + 1) & 1][mask];
if ((mask | v[idx][2]) == (1 << m) - 1)
rt = min(rt, v[idx][0] + v[idx][1] * b);
else
rt = min(rt, v[idx][0] + dp[(idx + 1) & 1][mask | v[idx][2]]);
}
long long rt = dp[0][0];
if (rt >= 0x3f3f3f3f3f3f3f3fLL) rt = -1;
cout << rt << "\n";
;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 2 * 1e6 + 69;
struct data {
int cost, monitor, status;
data() { cost = monitor = status = 0; }
bool operator<(const data &oth) const { return monitor < oth.monitor; }
} a[105];
long long f[N], g[N], oo = 1e15, n, m, b;
int main() {
cin >> n >> m >> b;
for (int i = 1; i <= n; i++) {
int k, v;
cin >> a[i].cost >> a[i].monitor >> k;
for (int j = 1; j <= k; j++) {
cin >> v;
a[i].status += 1 << (v - 1);
}
}
sort(a + 1, a + n + 1);
for (int i = 1; i < (1 << m); i++) f[i] = g[i] = oo;
long long res = LONG_LONG_MAX, check = 0;
for (int i = 1; i <= n; i++) {
for (int j = 0; j < (1 << m); j++)
g[j | a[i].status] = min(g[j | a[i].status], f[j] + a[i].cost);
for (int j = 1; j < (1 << m); j++) f[j] = g[j];
if (f[(1 << m) - 1] != oo) {
check = 1;
res = min(res, f[(1 << m) - 1] + a[i].monitor * b);
}
}
if (!check)
cout << -1;
else
cout << res;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAX_N = 105;
const int MAX_M = 20;
const long long INFINITE = 1LL << 62;
struct Friend {
int computers, conf;
long long cost;
inline bool operator<(const Friend& other) const {
return computers < other.computers;
}
} a[MAX_N];
long long dp[1 << MAX_M];
int main() {
int n, m, nr;
long long b;
cin >> n >> m >> b;
for (int i = 1; i <= n; ++i) {
cin >> a[i].cost >> a[i].computers >> nr;
for (int j = 1; j <= nr; ++j) {
int ind;
cin >> ind;
a[i].conf |= (1 << (ind - 1));
}
}
sort(a + 1, a + n + 1);
dp[0] = 0LL;
for (int i = 1; i < (1 << m); ++i) {
dp[i] = INFINITE;
}
long long answer = INFINITE;
for (int i = 1; i <= n; ++i) {
for (int j = 0; j < (1 << m); ++j) {
if (dp[j] != INFINITE) {
dp[j | a[i].conf] = min(dp[j | a[i].conf], dp[j] + a[i].cost);
}
}
answer = min(answer, dp[(1 << m) - 1] + 1LL * b * a[i].computers);
}
cout << (answer == INFINITE ? -1 : answer) << "\n";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long INF = (long long)2e18;
const int M = (1 << 20);
const int N = 200;
long long dp[M];
int x[N], k[N], pr[N];
int mask[N];
int perm[N];
bool cmp(int a, int b) { return k[a] < k[b]; }
int main() {
int n, m, b;
scanf("%d%d%d", &n, &m, &b);
for (int i = 0; i < n; i++) {
scanf("%d%d%d", &x[i], &k[i], &pr[i]);
for (int s = 0; s < pr[i]; s++) {
int t;
scanf("%d", &t);
mask[i] |= (1 << (t - 1));
}
}
for (int i = 0; i < n; i++) perm[i] = i;
sort(perm, perm + n, cmp);
int maxM = (1 << m);
fill(dp, dp + maxM, INF);
dp[0] = 0;
long long ans = INF;
for (int i = 0; i < n; i++) {
int ind = perm[i];
for (int s = maxM - 1; s >= 0; s--) {
dp[s | mask[ind]] = min(dp[s | mask[ind]], dp[s] + x[ind]);
if ((s | mask[ind]) == maxM - 1) {
ans = min(ans, (long long)k[ind] * (long long)b + dp[s] + x[ind]);
}
}
}
if (ans == INF)
cout << -1;
else
cout << ans;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long f[1 << 20];
int main() {
vector<pair<pair<int, int>, int> > v;
int n, m, x, k, i, j, t, o;
long long b, sum = (1LL << 60);
cin >> n >> m >> b;
for (i = 0; i < n; ++i) {
cin >> k >> t;
cin >> o;
j = 0;
while (o--) {
cin >> x;
j |= (1 << (x - 1));
}
v.push_back(make_pair(pair<int, int>(t, k), j));
}
int bit = (1 << m);
for (i = 0; i < bit; ++i) f[i] = (1LL << 60);
f[0] = 0;
sort(v.begin(), v.end());
for (i = 0; i < n; ++i) {
for (j = 0; j < bit; ++j)
f[j | v[i].second] = min(f[j | v[i].second], f[j] + v[i].first.second);
sum = min(sum, f[bit - 1] + b * v[i].first.first);
}
if (sum == (1LL << 60)) sum = -1;
cout << sum;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m;
long long int b;
long long int xx[200], kk[200], cc[200];
int indice[200];
bool compara(int i1, int i2) { return kk[i1] < kk[i2]; }
const long long int infinito = 2000000000000000000LL;
long long int sol = infinito;
long long int coste[1 << 20];
int main() {
cin >> n >> m >> b;
for (int i = 0; i < n; i++) {
indice[i] = i;
int amount;
cin >> xx[i] >> kk[i] >> amount;
for (int j = 0; j < amount; j++) {
int b;
cin >> b;
cc[i] |= 1 << (b - 1);
}
}
for (int c = 0; c < 1 << m; c++) coste[c] = infinito;
coste[0] = 0;
sort(indice, indice + n, compara);
for (int cas = 0; cas < n; cas++) {
int i = indice[cas];
for (int c = (1 << m) - 1; c >= 0; c--)
coste[c | cc[i]] = min(coste[c | cc[i]], coste[c] + xx[i]);
sol = min(sol, coste[(1 << m) - 1] + kk[i] * b);
}
if (sol != infinito)
cout << sol << endl;
else
cout << -1 << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m;
long long b;
long long dy[(1 << 20) + 5], sum = 2e18;
struct Friend {
long long x, k;
int m;
int p;
} a[100 + 5];
bool compare(Friend x, Friend y) { return (x.k < y.k); }
void process() {
int i;
for (int i = 1; i < (1 << m); i++) dy[i] = 2e18;
for (int i = 1; i <= n; i++) {
for (int j = 0; j < (1 << m); j++) {
int state = j | a[i].p;
dy[state] = min(dy[state], dy[j] + a[i].x);
}
sum = min(sum, dy[(1 << m) - 1] + b * a[i].k);
}
if (sum == 2e18)
printf("-1");
else
printf("%I64d", sum);
}
int main() {
scanf("%d %d %I64d", &n, &m, &b);
for (int i = 1; i <= n; i++) {
scanf("%I64d %I64d %d", &a[i].x, &a[i].k, &a[i].m);
for (int j = 1; j <= a[i].m; j++) {
int pn;
scanf("%d", &pn);
a[i].p |= (1 << (pn - 1));
}
}
sort(a + 1, a + n + 1, compare);
process();
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 use[100 + 3];
bool comp(const Th &A, const Th &B) {
if (A.c == B.c) return A.w < B.w;
return A.c < B.c;
}
void Work(int x, int w) {
for (int i = 0; i < ll; i++)
if (f[i] < 2e16) f[i | x] = min(f[i | x], f[i] + w);
}
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);
for (int i = 1; i <= n; i++)
for (int j = 1; j < i; j++)
if ((A[j].x | A[i].x) == A[j].x && A[i].w > A[j].w) use[i] = 1;
memset(f, 120, sizeof(f));
ans = 2e18;
f[0] = 0;
for (int i = 1; i <= n; i++)
if (!use[i]) {
if (Cost * (A[i].c - A[i - 1].c) >= f[ll - 1]) break;
Work(A[i].x, A[i].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 INF = 0x3f3f3f3f;
const long long LINF = 0x3f3f3f3f3f3f3f3fLL;
const double eps = 1E-6;
const int LEN = 21;
long long dp[1 << 21];
struct F {
int cost, mon, st;
} f[101];
bool cmp(F a, F b) { return a.mon < b.mon; }
int main() {
int n, m, b, tn, tc, tm, tmp;
while (scanf("%d%d%d", &n, &m, &b) != EOF) {
for (int i = 0; i < n; i++) {
scanf("%d%d%d", &f[i].cost, &f[i].mon, &tn);
f[i].st = 0;
for (int j = 0; j < tn; j++) {
scanf("%d", &tmp);
f[i].st |= (1 << (tmp - 1));
}
}
sort(f, f + n, cmp);
for (int i = 0; i < (1 << 21); i++) dp[i] = LINF;
dp[0] = 0;
long long ans = LINF;
for (int i = 0; i < n; i++) {
for (int j = (1 << m) - 1; j >= 0; j--) {
dp[j | f[i].st] = min(dp[j | f[i].st], dp[j] + f[i].cost);
}
ans = min(dp[(1 << m) - 1] + (long long)f[i].mon * (long long)b, ans);
}
if (ans == LINF)
printf("-1\n");
else
printf("%I64d\n", ans);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
struct node {
long long cost, need;
int zt;
} a[111];
long long dp[1 << 20];
bool operator<(node a, node b) { return a.need < b.need; }
int main() {
int n, m, k;
long long b, ans;
int i, j;
cin >> n >> m >> b;
for (i = 0; i < n; ++i) {
cin >> a[i].cost >> a[i].need >> k;
a[i].zt = 0;
while (k--) {
cin >> j;
j--;
a[i].zt |= (1 << j);
}
}
sort(a, a + n);
memset(dp, -1, sizeof(dp));
dp[0] = 0;
ans = -1;
for (i = 0; i < n; ++i) {
for (j = 0; j < (1 << m); ++j) {
if (dp[j] == -1) continue;
if (dp[j | a[i].zt] == -1 || dp[j | a[i].zt] > dp[j] + a[i].cost)
dp[j | a[i].zt] = dp[j] + a[i].cost;
}
if (dp[(1 << m) - 1] != -1) {
if (ans == -1 || dp[(1 << m) - 1] + b * a[i].need < ans)
ans = dp[(1 << m) - 1] + b * a[i].need;
}
}
cout << ans << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
long long d[1048576];
int main() {
int N, M, B;
cin >> N >> M >> B;
int x[100], k[100], g[100] = {};
for (int i = 0; i < N; ++i) {
int u, v, w;
cin >> u >> v >> w;
x[i] = u;
k[i] = v;
for (int j = 0; j < w; ++j) {
int y;
cin >> y;
g[i] |= (1 << (y - 1));
}
}
for (int i = 0; i < N; ++i) {
for (int j = 0; j < N - 1; ++j) {
if (k[j] > k[j + 1]) {
swap(x[j], x[j + 1]);
swap(k[j], k[j + 1]);
swap(g[j], g[j + 1]);
}
}
}
long long rf = 4e18;
for (int j = 0; j < (1 << M); ++j) d[j] = 4e18;
d[0] = 0;
for (int i = 0; i < N; ++i) {
for (int j = 0; j < (1 << M); ++j) {
d[j | g[i]] = min(d[j | g[i]], d[j] + x[i]);
}
rf = min(rf, d[(1 << M) - 1] + (long long)k[i] * B);
}
cout << (rf == 4e18 ? -1 : rf) << '\n';
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
struct node {
long long x, k, pr;
node(long long X = 0, long long K = 0, long long PR = 0) {
x = X;
pr = PR;
k = K;
}
};
bool cmp(node a, node b) { return a.k < b.k; }
const long long INF = 1000ll * 1000 * 1000 * 1000 * 1000 * 1000 * 3;
long long dp[(1 << 21)][2];
int main() {
ios_base::sync_with_stdio(0);
cin.tie(NULL);
long long n, m, b;
cin >> n >> m >> b;
vector<node> V;
V.resize(n);
for (int i = 0; i < n; i++) {
long long x, k, M;
cin >> x >> k >> M;
V[i].x = x;
V[i].k = k;
long long tmp = 0;
for (int j = 0; j < M; j++) {
int pp;
cin >> pp;
pp--;
tmp |= (1 << pp);
}
V[i].pr = tmp;
}
sort(V.begin(), V.end(), cmp);
long long ans = INF;
for (int i = 0; i < (1 << m); i++) dp[i][0] = dp[i][1] = INF;
dp[0][0] = dp[0][1] = 0;
for (int i = 0; i < n; i++) {
long long B = V[i].k;
for (int mask = 0; mask < (1 << m); mask++) {
dp[mask][1] = dp[mask][0];
if (mask & V[i].pr) {
long long tmp = (mask ^ V[i].pr) & (~(V[i].pr));
dp[mask][1] = min(dp[mask][0], dp[tmp][0] + V[i].x);
}
}
if (dp[(1 << m) - 1][1] != INF) {
ans = min(ans, dp[(1 << m) - 1][1] + B * b);
}
for (int mask = 0; mask < (1 << m); mask++) dp[mask][0] = dp[mask][1];
}
if (ans >= INF)
cout << -1 << endl;
else
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m, B, x[110], K[110], p[110], y, z, ord[110], A;
long long f[2][1048580], inf = 3000000000000000000LL, ans;
void read(int &x) {
char ch = getchar();
int mark = 1;
for (; ch != '-' && (ch < '0' || ch > '9'); ch = getchar())
;
if (ch == '-') mark = -1, ch = getchar();
for (x = 0; ch >= '0' && ch <= '9'; ch = getchar()) x = x * 10 + ch - 48;
x *= mark;
}
inline bool cmp(int a, int b) { return K[a] < K[b]; }
int main() {
read(n);
read(m);
read(B);
for (int i = 1; i <= n; i++) {
read(x[i]);
read(K[i]);
read(z);
p[i] = 0;
for (int j = 1; j <= z; j++) read(y), p[i] |= (1 << (y - 1));
ord[i] = i;
}
sort(ord + 1, ord + n + 1, cmp);
ans = inf;
A = 0;
for (int j = 0; j < (1 << m); j++) f[0][j] = inf;
f[0][0] = 0;
for (int i = 1; i <= n; i++) {
A ^= 1;
int now = ord[i];
for (int j = 0; j < (1 << m); j++) f[A][j] = f[A ^ 1][j];
for (int j = 0; j < (1 << m); j++)
if (f[A ^ 1][j] != inf) {
int k = j | p[now];
f[A][k] = min(f[A][k], f[A ^ 1][j] + x[now]);
if (k == ((1 << m) - 1))
ans = min(ans, f[A][k] + (long long)B * K[now]);
}
}
if (ans == inf)
printf("-1\n");
else
printf("%I64d\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
const long long LIM = (long long)2000000000 * 1000000000;
using namespace std;
struct Friend {
int x, k, m;
} frd[101];
int n, m;
long long res, money[1050000], b;
void Upbit(int &x, int i) { x |= (1 << i); }
bool compare(struct Friend x, struct Friend y) { return x.k < y.k; }
int main() {
ios::sync_with_stdio(0);
cin >> n >> m >> b;
int mm, x;
for (int i = (0), _b = (n); i < _b; i++) {
cin >> frd[i].x >> frd[i].k >> mm;
for (int j = (0), _b = (mm); j < _b; j++) {
cin >> x;
Upbit(frd[i].m, x - 1);
}
}
mm = (1 << m);
res = LIM;
sort(frd, frd + n, compare);
fill(money + 1, money + mm, LIM);
for (int i = (0), _b = (n); i < _b; i++) {
for (int j = (0), _b = (mm - 1); j < _b; j++) {
x = j | frd[i].m;
money[x] = min(money[x], money[j] + frd[i].x);
}
res = min(res, money[mm - 1] + b * frd[i].k);
}
if (res == LIM)
cout << -1;
else
cout << res;
return 0;
}
|
#include <bits/stdc++.h>
const int maxn = 110;
const int maxm = 20;
const long long inf = 0x3f3f3f3f3f3f3f3fll;
long long f[1 << maxm];
struct peo {
int x, k, s;
bool inline operator<(const peo &rhs) const { return k < rhs.k; }
} a[maxn];
int main() {
memset(f, 0x3f, sizeof f);
int n, m, v, l, t;
static long long ans = inf;
scanf("%d%d%d", &n, &m, &v);
for (int i = 1; i <= n; ++i) {
scanf("%d%d%d", &a[i].x, &a[i].k, &l);
for (int j = 1; j <= l; ++j) {
scanf("%d", &t);
a[i].s |= 1 << (t - 1);
}
}
std::sort(a + 1, a + n + 1);
f[0] = 0;
for (int i = 1; i <= n; ++i) {
for (int j = 0; j < 1 << m; ++j) {
if (f[j] != inf) {
f[j | a[i].s] = std::min(f[j | a[i].s], f[j] + a[i].x);
}
}
ans = std::min(ans, f[(1 << m) - 1] + 1ll * a[i].k * v);
}
printf("%I64d\n", ans == inf ? -1 : ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int N, M, B;
long long cost[111];
int k[111], mask[111];
int p[111];
bool comp(int c1, int c2) { return k[c1] < k[c2]; }
long long dp[(1 << 21)];
int main() {
scanf("%d%d%d", &N, &M, &B);
for (int i = 0; i < N; ++i) {
int n;
scanf("%d%d%d", &cost[i], &k[i], &n);
for (int j = 0; j < n; ++j) {
int t;
scanf("%d", &t);
t--;
mask[i] |= (1 << t);
}
p[i] = i;
}
sort(p, p + N, comp);
long long ans = 4e18;
for (int i = 0; i < (1 << M); ++i) dp[i] = -1;
dp[0] = 0;
for (int _i = 0; _i < N; _i++) {
int i = p[_i];
for (int msk = 0; msk < (1 << M); ++msk) {
if (dp[msk] == -1) continue;
int nmask = msk | mask[i];
if (dp[nmask] == -1 || dp[nmask] > dp[msk] + cost[i]) {
dp[nmask] = dp[msk] + cost[i];
}
}
if (dp[(1 << M) - 1] != -1)
ans = min(ans, dp[(1 << M) - 1] + 1ll * k[i] * B);
}
if (ans == 4e18) ans = -1;
cout << ans;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long i, j, k, l, n, m, s, an, sum, tot = 1, S, T, off, d, M, V;
const long long N = 210;
long long oo = 2147483647;
class arr {
public:
long long x, k, m, v;
} a[N];
long long f[1 << 20], g[1 << 20];
bool com(const arr &o, const arr &p) { return o.k < p.k; }
int main() {
scanf("%I64d%I64d%I64d", &n, &m, &V);
M = 1 << m;
oo = oo * oo;
long long s = 0;
for (long long i = 1; i <= n; i++) {
scanf("%I64d%I64d%I64d", &a[i].x, &a[i].k, &a[i].m);
long long x;
for (long long j = 1; j <= a[i].m; j++)
scanf("%I64d", &x), a[i].v |= (1 << (x - 1));
s |= a[i].v;
}
if (s != M - 1) {
printf("-1\n");
return 0;
}
sort(&a[1], &a[n + 1], com);
for (int i = 0; i < M; i++) f[i] = oo;
f[0] = 0;
an = oo;
for (long long i = 1; i <= n; i++) {
memcpy(g, f, sizeof(g));
for (long long j = 0; j < M; j++)
if (f[j] != oo) g[j | a[i].v] = min(g[j | a[i].v], f[j] + a[i].x);
memcpy(f, g, sizeof(f));
if (f[M - 1] != oo) an = min(an, f[M - 1] + a[i].k * V);
}
printf("%I64d\n", an);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
struct fri {
int xi, bi, opt;
int operator<(const fri &a) const { return bi < a.bi; }
} a[200];
long long f[2][1 << 20];
void swap(int &a, int &b) {
int t = a;
a = b;
b = t;
}
int main() {
int n, m, B;
scanf("%d%d%d", &n, &m, &B);
for (int i = 1; i <= n; ++i) {
int K;
scanf("%d%d%d", &a[i].xi, &a[i].bi, &K);
a[i].opt = 0;
while (K--) {
int x;
scanf("%d", &x);
--x;
a[i].opt |= 1 << x;
}
}
sort(a + 1, a + 1 + n);
int cur = 0, nex = 1;
memset(f, 63, sizeof(f));
long long ans = f[0][0], inf = f[0][0];
f[0][0] = 0;
for (int i = 1; i <= n; ++i) {
memcpy(f[nex], f[cur], sizeof(f[nex]));
for (int opt = 0; opt < (1 << m); ++opt)
f[nex][opt | a[i].opt] =
min(f[nex][opt | a[i].opt], f[cur][opt] + a[i].xi);
swap(cur, nex);
ans = min(ans, f[cur][(1 << m) - 1] + (long long)a[i].bi * B);
}
if (ans >= inf)
puts("-1");
else
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1048577;
const long long maxN = 1000000100000000007;
int n, m, cs[105], cnt[105], state[105];
long long b, x[105], k[105], dp[2][maxn];
bool cmp(int a, int b) { return (k[a] < k[b]); }
int batbit(int a, int i) { return ((1 << (i - 1)) | a); }
int main() {
int i, j, a, t;
long long res = maxN;
cin >> n >> m >> b;
for (i = 1; i <= n; i++) {
cin >> x[i] >> k[i] >> cnt[i];
cs[i] = i;
for (j = 1; j <= cnt[i]; j++) {
cin >> a;
state[i] = batbit(state[i], a);
}
}
for (i = 0; i <= n; i++)
for (j = 0; j < (1 << m); j++) dp[0][j] = dp[1][j] = maxN;
sort(cs + 1, cs + n + 1, cmp);
dp[0][0] = 0;
t = 1;
for (i = 1; i <= n; i++) {
for (j = 0; j < (1 << m); j++) {
dp[t][j] = min(dp[t][j], dp[1 - t][j]);
dp[t][j | state[cs[i]]] =
min(dp[t][j | state[cs[i]]], dp[1 - t][j] + x[cs[i]]);
}
res = min(res, dp[t][(1 << m) - 1] + k[cs[i]] * b);
for (j = 0; j < (1 << m); j++) dp[1 - t][j] = maxN;
t = 1 - t;
}
if (res < maxN)
cout << res;
else
cout << -1;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long INF = LONG_LONG_MAX;
struct str {
long long mask, monit, fee;
str() {}
str(long long mask, long long monit, long long fee)
: mask(mask), monit(monit), fee(fee) {}
};
bool operator<(const str& a, const str& b) { return a.monit > b.monit; }
long long a, b, c, d, e, n, prob, B, mxmask;
str coin[109];
long long dp[(1 << 20)];
int main() {
cin >> n >> prob >> B;
for (long long j = 1; j <= n; j++) {
cin >> a >> b >> c;
d = 0;
while (c--) {
cin >> e;
e--;
d |= (1 << e);
}
coin[j] = str(d, b, a);
}
sort(coin + 1, coin + 1 + n);
mxmask = (1 << prob);
for (long long j = 0; j < mxmask; j++) dp[j] = INF;
dp[0] = 0;
long long nmask, Z = 0, fee;
for (long long j = 1; j <= n; j++) {
for (long long mask = 0; mask < mxmask; mask++) {
if (dp[mask] == INF) continue;
nmask = mask | coin[j].mask;
fee = coin[j].fee;
if (mask == 0) fee += coin[j].monit * B;
dp[nmask] = min(dp[nmask], dp[mask] + fee);
}
}
if (dp[mxmask - 1] == INF)
puts("-1");
else
cout << dp[mxmask - 1] << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
struct node {
long long int val, mo, nro1, bits;
bool operator<(node p) const { return mo < p.mo; }
} arr[101];
long long int n, m, b;
long long int DP[(1 << 20)];
int main() {
long long int ma, x;
scanf("%I64d %I64d %I64d", &n, &m, &b);
for (int i = 0; i < n; i++) {
ma = 0;
scanf("%I64d %I64d %I64d", &arr[i].val, &arr[i].mo, &arr[i].nro1);
for (int j = 0; j < arr[i].nro1; j++) {
scanf("%I64d", &x);
ma |= (1 << (x - 1));
}
arr[i].bits = ma;
}
sort(arr, arr + n);
DP[0] = 0;
for (int i = 1; i < (1 << m); i++) DP[i] = (((1LL << 61) - 1) << 1) + 1;
long long int sol = (((1LL << 61) - 1) << 1) + 1;
for (int i = 0; i < n; i++) {
for (int j = 0; j < (1 << m); j++)
DP[j | arr[i].bits] = min(DP[j | arr[i].bits], DP[j] + arr[i].val);
sol = min(sol, DP[(1 << m) - 1] + arr[i].mo * b);
}
printf("%I64d\n", (sol >= (((1LL << 61) - 1) << 1) + 1) ? -1 : sol);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m, cb;
int cost[105], comp[105], cov[105], ord[105];
long long dp[5 + (1 << 20)], ret;
bool cmp(int x, int y) { return comp[x] < comp[y]; }
int main() {
scanf("%d%d%d", &n, &m, &cb);
for (int i = (0); i < (n); i++) {
int t, x;
scanf("%d%d%d", &cost[i], &comp[i], &t);
cov[i] = 0;
while (t--) scanf("%d", &x), cov[i] += (1 << (x - 1));
ord[i] = i;
}
sort(ord, ord + n, cmp);
for (int j = (0); j < (1 << m); j++) dp[j] = 1LL << 60;
dp[0] = 0;
ret = (1LL << 60);
for (int i = (0); i < (n); i++) {
int t = ord[i];
for (int j = (0); j < (1 << m); j++)
dp[j | cov[t]] = min(dp[j | cov[t]], dp[j] + cost[t]);
ret = min(ret, dp[(1 << m) - 1] + comp[t] * 1LL * cb);
}
printf("%I64d\n", ret >= (1LL << 60) ? -1 : ret);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long inf = 1LL << 60;
long long res = inf;
long long dp[2][(1 << 20) + 1];
long long n, m, b;
struct data {
long long x, k, mask;
data(long long x, long long k, long long mask) : x(x), k(k), mask(mask) {}
data() { x = k = mask = 0; }
bool operator<(const data &d) const {
if (k != d.k) return k < d.k;
return x < d.x;
}
};
vector<data> ve;
long long solve() {
for (int i = 0; i <= 1; i++)
for (int j = (1 << m) - 1; j >= 0; j--) dp[i][j] = inf;
bool roll = 0;
for (int i = n - 1; i >= 0; i--) {
for (int j = (1 << m) - 1; j >= 0; j--) {
if (j == (1 << m) - 1) {
dp[roll ^ 1][j] = ve[i].k * b;
continue;
}
dp[roll][j] =
min(dp[roll ^ 1][j], ve[i].x + dp[roll ^ 1][j | ve[i].mask]);
}
roll = !roll;
}
res = dp[!roll][0];
return (res == inf ? -1 : res);
}
int main() {
scanf("%lld%lld%lld", &n, &m, &b);
for (int i = 0; i < n; i++) {
int x, k, sz;
scanf("%d%d%d", &x, &k, &sz);
int mask = 0;
for (int j = 0; j < sz; j++) {
int p;
scanf("%d", &p);
p--;
mask |= (1 << p);
}
ve.push_back(data(x, k, mask));
}
sort(ve.begin(), ve.end());
printf("%lld\n", solve());
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m, cb;
int cost[105], comp[105], cov[105], ord[105];
long long dp[5 + (1 << 20)], buf[5 + (1 << 20)], ret;
bool cmp(int x, int y) { return comp[x] < comp[y]; }
int main() {
scanf("%d%d%d", &n, &m, &cb);
for (int i = (0); i < (n); i++) {
int t, x;
scanf("%d%d%d", &cost[i], &comp[i], &t);
cov[i] = 0;
while (t--) scanf("%d", &x), cov[i] += (1 << (x - 1));
ord[i] = i;
}
sort(ord, ord + n, cmp);
for (int j = (0); j < (1 << m); j++) dp[j] = 1LL << 60;
dp[0] = 0;
ret = (1LL << 60);
for (int i = (0); i < (n); i++) {
int t = ord[i];
for (int j = (0); j < (1 << m); j++) buf[j] = dp[j];
for (int j = (0); j < (1 << m); j++)
buf[j | cov[t]] = min(buf[j | cov[t]], dp[j] + cost[t]);
for (int j = (0); j < (1 << m); j++) dp[j] = buf[j];
ret = min(ret, dp[(1 << m) - 1] + comp[t] * 1LL * cb);
}
printf("%I64d\n", ret >= (1LL << 60) ? -1 : ret);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long INF = 2e18;
long long b, ans, dp[2 << 21];
pair<int, pair<int, int>> p[101];
int main() {
int n, m, x, y;
cin >> n >> m >> b;
for (int i = 0; i < n; ++i) {
cin >> p[i].second.first >> p[i].first >> x;
for (int j = 0; j < x; ++j) {
cin >> y;
p[i].second.second |= 1 << (y - 1);
}
}
sort(p, p + n);
for (int i = 1; i < (1 << m) + 1; ++i) dp[i] = INF;
ans = INF;
for (int i = 0; i < n; ++i) {
for (int j = 0; j < (1 << m); j++) {
if ((j ^ p[i].second.second) & p[i].second.second) {
int k;
k = j | p[i].second.second;
dp[k] = min(dp[k], dp[j] + p[i].second.first);
}
}
if (dp[(1 << m) - 1] < INF)
ans = min(ans, dp[(1 << m) - 1] + p[i].first * b);
}
cout << (ans >= INF ? -1 : ans) << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
struct Friend {
long long x, k;
int mask;
bool operator<(const Friend &a) const { return (k > a.k); }
};
Friend f[108];
long long price[1048576] = {0}, b;
int n, m, maskNum, i, bit[20], N, j, newMask, pr;
bool mark[1048576] = {0};
inline void ucitaj() {
scanf("%d %d %I64d", &n, &m, &b);
maskNum = 1 << m;
for (i = 0; i < m; i++) bit[i] = 1 << i;
for (i = 1; i <= n; i++) {
scanf("%I64d %I64d %d", &f[i].x, &f[i].k, &N);
f[i].mask = 0;
for (j = 1; j <= N; j++) {
scanf("%d", &pr);
f[i].mask += bit[pr - 1];
}
}
}
inline void resi() {
for (i = 1; i <= n; i++) {
for (j = 0; j < maskNum; j++) {
if (mark[j]) {
newMask = j | f[i].mask;
if (!mark[newMask] || price[newMask] > price[j] + f[i].x) {
price[newMask] = price[j] + f[i].x;
mark[newMask] = 1;
}
}
}
if (!mark[f[i].mask] || price[f[i].mask] > f[i].x + b * f[i].k) {
price[f[i].mask] = f[i].x + b * f[i].k;
mark[f[i].mask] = 1;
}
}
}
int main() {
ucitaj();
sort(f + 1, f + n + 1);
resi();
if (price[maskNum - 1])
printf("%I64d\n", price[maskNum - 1]);
else
printf("-1\n");
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
struct Friend {
int x, k, m;
void init() {
int n;
m = 0;
scanf("%d%d%d", &x, &k, &n);
while (n--) {
int p;
scanf("%d", &p);
m |= (1 << (p - 1));
}
}
} f[128];
const long long inf = 1LL << 60;
bool cmp(const Friend& f1, const Friend& f2) { return f1.k < f2.k; }
int nf, np, b;
void solve(int ncase) {
scanf("%d%d%d", &nf, &np, &b);
for (int i = 0; i < nf; i++) {
f[i].init();
}
sort(f, f + nf, cmp);
long long sum = 0;
long long ans = inf;
vector<long long> dp(1 << np, inf);
dp[0] = 0;
for (int i = 0; i < nf; i++) {
for (int k = (1 << np) - 1; k >= 0; k--) {
if (dp[k] < inf) {
dp[k | f[i].m] = min(dp[k | f[i].m], dp[k] + f[i].x);
}
}
if (dp[(1 << np) - 1] < inf) {
ans = min(ans, dp[(1 << np) - 1] + f[i].k * 1LL * b);
}
}
if (ans == inf) {
cout << -1 << endl;
} else {
cout << ans << endl;
}
}
int main() {
int T = 1;
int ncase = 0;
while (T--) {
solve(++ncase);
}
}
|
#include <bits/stdc++.h>
using namespace std;
const long long inf = 1000000000ll;
const long long inf64 = inf * inf;
const long long N = 100100;
bool solve() {
long long n, m, b;
cin >> n >> m >> b;
vector<pair<pair<long long, long long>, pair<long long, long long> > > f(n);
for (int i(0); i < n; i++) {
cin >> f[i].first.second >> f[i].first.first >> f[i].second.first;
f[i].second.second = 0;
for (long long x, j(0); j < f[i].second.first; j++) {
cin >> x;
f[i].second.second |= (1 << (x - 1));
}
}
sort((f).begin(), (f).end());
vector<long long> dp(1ll << m, inf64 * 4);
dp[0] = 0;
long long ans = inf64 * 4;
for (int i(0); i < n; i++) {
for (int j(0); j < (1 << m); j++) {
if (dp[j] + f[i].first.second < dp[j | f[i].second.second])
dp[j | f[i].second.second] = dp[j] + f[i].first.second;
long long tmp = dp[(1 << m) - 1] + f[i].first.first * b;
ans = min(ans, tmp);
}
}
cout << (ans == inf64 * 4 ? -1 : ans) << '\n';
return true;
}
int main() {
solve();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int inf = 0x3f3f3f3f;
int n;
struct st {
int x, k, mask;
st() {}
st(long long x, long long k, long long mask) : x(x), k(k), mask(mask) {}
bool operator<(const st& s) const { return k < s.k; }
} A[111];
long long pd[2][1 << 20];
int main() {
int m, b;
scanf("%d %d %d", &n, &m, &b);
for (int i = (0); i < (n); ++i) {
int qtd;
scanf("%d %d %d", &A[i].x, &A[i].k, &qtd);
for (int j = (0); j < (qtd); ++j) {
int x;
scanf("%d", &x);
--x;
A[i].mask |= (1 << x);
}
}
sort(A, A + n);
memset((pd), (0x7F), sizeof(pd));
long long best = pd[0][0];
long long fail = best;
pd[0][0] = 0;
int act = 1, last = 0;
for (int i = (0); i < (n); ++i) {
for (int mask = (0); mask < (1 << m); ++mask) {
pd[act][mask] = min(pd[act][mask], pd[last][mask]);
int nmask = mask | A[i].mask;
pd[act][nmask] = min(pd[act][nmask], (long long)A[i].x + pd[last][mask]);
}
if (pd[act][(1 << m) - 1] < fail) {
long long cust = pd[act][(1 << m) - 1] + (long long)A[i].k * b;
best = min(best, cust);
}
swap(act, last);
}
if (best < fail)
printf("%I64d\n", best);
else
printf("-1\n");
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long n, m, b, cost[111], need[111], ans, cur, solve, prob, fmask[111],
dp[1 << 22], id;
vector<int> fri[111];
pair<long long, int> screen[111];
long long solvee(int cap) {
for (int mask = 1; mask < 1 << m; mask++) {
id = screen[cap].second;
dp[mask] = min(dp[mask], cost[id] + dp[mask & (~fmask[id])]);
}
return dp[(1 << m) - 1];
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
ans = (1ll << 60);
memset(fmask, 0, sizeof(fmask));
cin >> n >> m >> b;
for (int i = 0; i < 1 << m; i++) dp[i] = (1ll << 60);
dp[0] = 0;
for (int i = 0; i < n; i++) {
cin >> cost[i] >> need[i] >> solve;
while (solve--) {
cin >> prob;
prob--;
fri[i].push_back(prob);
fmask[i] |= 1 << prob;
}
screen[i] = {need[i], i};
}
sort(screen, screen + n);
for (int i = 0; i < n; i++) ans = min(ans, solvee(i) + b * screen[i].first);
if (ans == (1ll << 60))
cout << -1;
else
cout << ans;
}
|
#include <bits/stdc++.h>
using namespace std;
template <class T>
T Mul(T x, T y, T P) {
T F1 = 0;
while (y) {
if (y & 1) {
F1 += x;
if (F1 < 0 || F1 >= P) F1 -= P;
}
x <<= 1;
if (x < 0 || x >= P) x -= P;
y >>= 1;
}
return F1;
}
template <class T>
T Pow(T x, T y, T P) {
T F1 = 1;
x %= P;
while (y) {
if (y & 1) {
F1 = Mul(F1, x, P);
}
x = Mul(x, x, P);
y >>= 1;
}
return F1;
}
template <class T>
T Gcd(T x, T y) {
if (y == 0) return x;
T z;
while (z = x % y) {
x = y, y = z;
}
return y;
}
template <class T>
void UpdateMin(T &x, T y) {
if (y < x) {
x = y;
}
}
template <class T>
void UpdateMax(T &x, T y) {
if (x < y) {
x = y;
}
}
template <class T>
T Sqr(const T x) {
return x * x;
}
template <class T>
T Abs(const T x) {
return x < 0 ? -x : x;
}
class ReadBuffer {
private:
char buff[20000000];
char *buf;
public:
void init(int size = 20000000) {
fread(buff, 1, size, stdin);
buf = buff;
}
template <class T>
bool readInteger(T &x) {
x = 0;
while (*buf && isspace(*buf)) ++buf;
if (*buf == 0) return false;
static bool flag;
flag = 0;
if (*buf == '-')
flag = true;
else
x = *buf - '0';
while (isdigit(*++buf)) x = x * 10 + *buf - '0';
if (flag) x = -x;
return true;
}
template <class T>
bool readFloat(T &x) {
long double nowpos = 0.1;
x = 0;
while (*buf && isspace(*buf)) ++buf;
if (*buf == 0) return false;
static bool flag, decimal;
decimal = flag = 0;
if (*buf == '-')
flag = true, ++buf;
else if (*buf == '.')
decimal = true;
while (isdigit(*buf) || *buf == '.') {
if (*buf == '.')
decimal = true;
else {
if (decimal) {
x += nowpos * (*buf - '0');
nowpos *= 0.1;
} else {
x = x * 10 + *buf - '0';
}
}
++buf;
}
return true;
}
bool readChar(char c) {
if (*buf == 0) return 0;
return c = *buf++, 1;
}
bool readString(char *s) {
while (*buf && isspace(*buf)) ++buf;
if (!*buf) return false;
while (!isspace(*buf)) *s++ = *buf++;
*s++ = 0;
return true;
}
int countSpacetonext() {
int total = 0;
while (*buf && *buf == ' ') ++total, ++buf;
return total;
}
bool splitBycharactor(char *s, char Split = '\n') {
while (*buf && *buf != Split) *s++ = *buf++;
*s++ = 0;
return *buf != 0;
}
};
struct EDGE {
int T;
EDGE *Nxt;
};
long long dp[1048580];
struct Friend {
int x, k, opt;
void init() {
int m;
scanf("%d%d%d", &x, &k, &m);
opt = 0;
while (m--) {
int x;
scanf("%d", &x);
opt |= 1 << (x - 1);
}
}
bool operator<(const Friend &y) const { return k < y.k; }
} F[201];
int n, m, b;
int main() {
memset(dp, 63, sizeof(dp));
long long ans = dp[0];
dp[0] = 0;
scanf("%d%d%d", &n, &m, &b);
for (int i = 0; i < n; ++i) F[i].init();
sort(F, F + n);
for (int i = 0; i < (n); ++i) {
for (int j = 0; j < ((1 << m)); ++j) {
UpdateMin(dp[j | F[i].opt], dp[j] + F[i].x);
}
UpdateMin(ans, dp[(1 << m) - 1] + (long long)F[i].k * b);
}
if (ans == dp[1048578]) ans = -1;
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 105;
const long long inf = 4e18 + 5;
int n, m, b;
int koje[maxn];
long long dp[(1 << 20)];
array<int, 3> niz[maxn];
bool cmp(array<int, 3> s1, array<int, 3> s2) { return s1[1] < s2[1]; }
int main() {
ios::sync_with_stdio(false);
cin.tie(nullptr);
cout.tie(nullptr);
cin >> n >> m >> b;
for (int i = 1; i <= n; i++) {
int x, y, z;
cin >> x >> y >> z;
for (int j = 0; j < z; j++) {
int a;
cin >> a;
koje[i] ^= (1 << (a - 1));
}
niz[i] = {x, y, koje[i]};
}
sort(niz + 1, niz + n + 1, cmp);
for (int mask = 0; mask < (1 << m); mask++) dp[mask] = inf;
dp[0] = 0;
long long rez = inf;
for (int i = 1; i <= n; i++) {
for (int mask = 0; mask < (1 << m); mask++)
dp[mask | niz[i][2]] =
min(dp[mask | niz[i][2]], dp[mask] + (long long)niz[i][0]);
rez = min(rez, dp[(1 << m) - 1] + (long long)niz[i][1] * b);
}
cout << (rez == inf ? -1 : rez) << 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 a, t;
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;
const unsigned long long N = 105, M = 21;
unsigned long long n, m, v, x, now, tot, max_statue, inf, ans;
unsigned long long add[N], f[1 << M];
struct number {
unsigned long long c, need, add;
} num[N];
inline bool cmp(number a, number b) { return a.need < b.need; }
signed main() {
scanf("%lld%lld%lld", &n, &m, &v);
for (register unsigned long long i = 1; i <= n; ++i) {
scanf("%lld%lld%lld", &num[i].c, &num[i].need, &x);
while (x--) {
scanf("%lld", &now);
num[i].add |= 1ll << (now - 1);
}
}
sort(num + 1, num + n + 1, cmp);
ans = -1;
max_statue = (1ll << m) - 1;
for (register unsigned long long p = 0; p <= max_statue; ++p) f[p] = 1e19;
inf = f[0];
f[0] = 0;
for (register unsigned long long i = 1; i <= n; ++i) {
for (register unsigned long long p = 0; p < max_statue; ++p)
f[p | num[i].add] = min(f[p | num[i].add], f[p] + num[i].c);
if (f[max_statue] != inf) {
if (ans == -1ll)
ans = f[max_statue] + num[i].need * v;
else
ans = min(ans, f[max_statue] + num[i].need * v);
}
}
printf("%lld\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:500000000")
using namespace std;
int X[109], K[109], M[109], Mask[109];
long long dp[2][1 << 20];
int main() {
int n, m, b, i, k, j, a;
scanf("%d %d %d", &n, &m, &b);
for (i = 0; i < n; i++) {
scanf("%d %d %d", &X[i], &K[i], &M[i]);
for (j = 0; j < M[i]; j++) {
scanf("%d", &a);
a--;
Mask[i] |= 1 << a;
}
}
for (i = 0; i < n; i++) {
for (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]);
swap(Mask[i], Mask[j]);
}
}
}
long long inf = 1ll << 62ll;
long long res = inf;
for (i = 0; i < 2; i++)
for (j = 0; j < (1 << 20); j++) dp[i][j] = inf;
dp[1][0] = 0;
int mask;
for (i = 0; i < n; i++) {
for (mask = 0; mask < (1 << m); mask++) {
long long &d = dp[i & 1][mask];
d = dp[(i + 1) & 1][mask];
int msk = (mask & Mask[i]) ^ mask;
d = min(d, dp[(i + 1) & 1][msk] + X[i]);
}
res = min(res, dp[i & 1][mask - 1] + K[i] * (long long)b);
}
if (res >= inf) res = -1;
cout << res << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
template <class T>
ostream& operator<<(ostream& os, vector<T> V) {
os << "[ ";
for (auto v : V) os << v << " ";
return os << "]";
}
template <class L, class R>
ostream& operator<<(ostream& os, pair<L, R> P) {
return os << "(" << P.first << "," << P.second << ")";
}
const unsigned long long INF = 1e19 + 7;
const int N = 105;
const int M = 22;
pair<unsigned long long, pair<unsigned long long, unsigned long long> > X[N];
unsigned long long n, b, m;
unsigned long long dp[1 << 22];
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> n >> m >> b;
for (int i = 0; i < n; i++) {
int mi;
cin >> X[i].second.first >> X[i].first >> mi;
int curr = 0, no;
for (int j = 0; j < mi; j++) {
cin >> no;
no--;
curr += (1 << no);
}
X[i].second.second = curr;
}
sort(X, X + n);
for (int j = 0; j < (1 << m); j++) dp[j] = INF;
dp[0] = 0;
unsigned long long res = INF;
for (int i = 0; i < n; i++) {
for (int j = 0; j < (1 << m); j++) {
if (dp[j] < INF)
dp[j | (X[i].second.second)] =
min(dp[j | X[i].second.second], dp[j] + X[i].second.first);
if (dp[(1 << m) - 1] < INF) {
res = min(res, dp[(1 << m) - 1] + b * X[i].first);
}
}
}
if (res == INF)
cout << -1 << endl;
else
cout << res << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = -1;
const int maxM = 100 + 5;
const long long inf = 2e18;
struct Person {
int x, k, mask;
};
long long dp[2][1 << 20];
Person b[maxM];
bool cmp(Person a, Person b) { return a.k < b.k; }
int main() {
int n, m, cnt, x;
long long B;
long long ans = inf;
scanf("%d%d", &m, &n);
cin >> B;
for (int i = 0; i < m; i++) {
scanf("%d%d%d", &b[i].x, &b[i].k, &cnt);
b[i].mask = 0;
for (int j = 0; j < cnt; j++) {
scanf("%d", &x);
x--;
b[i].mask |= (1 << x);
}
}
sort(b, b + m, cmp);
memset(dp, 63, sizeof(dp));
dp[0][0] = 0;
for (int i = 0; i < m; i++) {
memset(dp[1], 63, sizeof(dp[1]));
for (int mask = 0; mask < (1 << n); mask++) {
if (dp[0][mask] > inf) continue;
dp[1][mask] = min(dp[1][mask], dp[0][mask]);
dp[1][mask | b[i].mask] =
min(dp[1][mask | b[i].mask], dp[0][mask] + b[i].x);
}
ans = min(ans, dp[1][(1 << n) - 1] + b[i].k * B);
for (int mask = 0; mask < (1 << n); mask++) dp[0][mask] = dp[1][mask];
}
if (ans == inf)
cout << "-1\n";
else
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m;
long long price;
scanf("%d%d%I64d", &n, &m, &price);
int k[n], mask[n];
long long x[n];
for (int i = 0; i < n; i++) {
int sz;
scanf("%I64d%d%d", &x[i], &k[i], &sz);
mask[i] = 0;
while (sz--) {
int tmp;
scanf("%d", &tmp);
tmp--;
mask[i] |= 1 << tmp;
}
}
for (int i = 0; i < n; i++)
for (int j = i + 1; j < n; j++) {
if (k[i] < k[j]) continue;
swap(k[i], k[j]);
swap(mask[i], mask[j]);
swap(x[i], x[j]);
}
vector<long long> dp(1 << m, 2e18);
dp[0] = 0;
long long ans = 2e18;
for (int i = 0; i < n; i++) {
int mask1 = mask[i];
for (int j = 0; j < 1 << m; j++) {
if (dp[j] == -1) continue;
dp[j | mask1] = min(dp[j | mask1], dp[j] + x[i]);
}
long long tmp = dp[(1 << m) - 1];
tmp += k[i] * price;
ans = min(ans, tmp);
}
printf("%I64d", ans == 2e18 ? -1 : ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long N = (1 << 20) + 10;
long long dp[N];
void solve() {
long long n, m, b;
cin >> n >> m >> b;
vector<array<long long, 3>> info;
for (long long i = 0; i < n; ++i) {
long long x, k, p;
cin >> x >> k >> p;
long long val = 0;
while (p--) {
long long task;
cin >> task;
--task;
val |= (1 << task);
}
info.push_back({k, x, val});
}
memset(dp, 0x3f, sizeof dp);
sort(info.begin(), info.end());
long long ans = 2e18;
dp[0] = 0;
for (long long i = 0; i < n; ++i) {
for (long long j = 0; j < (1 << m); ++j) {
long long mask = info[i][2] | j;
dp[mask] = min(dp[mask], dp[j] + info[i][1]);
}
ans = min(ans, dp[(1 << m) - 1] + info[i][0] * b);
}
if (ans == 2e18) ans = -1;
cout << ans << '\n';
}
signed main() {
ios::sync_with_stdio(false);
cin.tie(NULL);
;
long long t;
t = 1;
while (t--) solve();
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m, b;
int x[105], k[106], g[105], s[105];
pair<long long, pair<long long, long long> > f[105];
long long dp[2000005];
int p[2000005];
int main() {
scanf("%d%d%d", &n, &m, &b);
for (int i = 0; i < n; i++) {
scanf("%d%d%d", &x[i], &k[i], &g[i]);
int t;
for (int j = 0; j < g[i]; j++) {
scanf("%d", &t);
s[i] += (1 << (t - 1));
}
}
for (int i = 1; i <= n; i++)
f[i] = make_pair(k[i - 1], make_pair(x[i - 1], s[i - 1]));
sort(f + 1, f + n + 1);
dp[0] = 0;
p[0] = 1;
long long tmp = 0, ans = -1;
for (int i = 1; i <= n; i++) {
if (f[i].first != f[i - 1].first) tmp += (f[i].first - f[i - 1].first) * b;
for (int j = 0; j < (1 << m); j++)
if (p[j]) {
int now = f[i].second.second | j;
if (p[now])
dp[now] = min(dp[now], dp[j] + f[i].second.first);
else
dp[now] = dp[j] + f[i].second.first, p[now] = 1;
}
if (p[(1 << m) - 1])
if (ans == -1)
ans = dp[(1 << m) - 1] + tmp;
else
ans = min(ans, dp[(1 << m) - 1] + tmp);
}
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m, b;
vector<pair<int, pair<int, int> > > vec;
int x, k, mx;
long long ans[105];
long long dp[1 << 20][2];
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cin >> n >> m >> b;
for (int i = 0; i < n; i++) {
cin >> x >> k >> mx;
int mask = 0;
for (int j = 0, a; j < mx; j++) {
cin >> a;
a--;
mask |= (1 << a);
}
vec.push_back(make_pair(k, make_pair(x, mask)));
}
sort(vec.rbegin(), vec.rend());
dp[(1 << m) - 1][n & 1] = 0;
for (int i = 0; i < (1 << m) - 1; i++) dp[i][n & 1] = 2e18;
for (int i = n - 1; i >= 0; i--) {
long long c = vec[i].second.first;
int mask = vec[i].second.second;
for (int j = 0; j <= (1 << m) - 1; j++) {
long long &ret = dp[j][i & 1];
ret = dp[j][!(i & 1)];
ret = min(ret, dp[j | mask][!(i & 1)] + c);
}
ans[i] = dp[0][i & 1];
}
long long res = 3e18;
for (int i = 0; i < n; i++) {
long long x = vec[i].first;
res = min(res, ans[i] + x * 1ll * b);
}
if (res >= 2e18) res = -1;
cout << res << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long mod = 1e9 + 7;
const unsigned long long inf = 1e19;
struct my {
unsigned long long m, k, cost;
my(unsigned long long m = 0, unsigned long long msk = 0,
unsigned long long c = 0) {
m = msk, k = m, cost = c;
}
my(unsigned long long _cost, unsigned long long _k,
vector<unsigned long long>& a) {
m = 0, cost = _cost, k = _k;
for (unsigned long long x : a) m |= (1ll << x);
}
bool operator<(const my b) const { return k < b.k; }
};
int main() {
cin.tie(0), cout.tie(0), ios_base::sync_with_stdio(0);
int n, m, b;
cin >> n >> m >> b;
vector<my> a(n + 1);
for (int i = 1; i <= n; ++i) {
unsigned long long x, k, cnt;
cin >> x >> k >> cnt;
vector<unsigned long long> b(cnt);
for (unsigned long long& y : b) {
cin >> y, --y;
}
a[i] = my(x, k, b);
}
sort(a.begin(), a.end());
vector<unsigned long long> dp(1ll << m, inf);
dp[0] = 0;
unsigned long long ans = inf;
for (int i = 1; i <= n; ++i) {
for (int prof = 0; prof < (1 << m); ++prof) {
dp[prof | a[i].m] = min(dp[prof | a[i].m], dp[prof] + a[i].cost);
ans = min(ans, dp[(1 << m) - 1] + a[i].k * b);
}
}
if (ans >= inf)
cout << -1;
else
cout << ans;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 256;
const long long INF = 4e18;
struct dot {
long long x, k, bm;
};
bool operator<(dot a, dot b) {
if (a.k == b.k) return (a.x == b.x) ? a.bm < b.bm : a.x < b.x;
return a.k < b.k;
}
long long n, m, b, dist[1 << 21];
dot P[MAXN];
int main() {
while (scanf("%lld%lld%lld", &n, &m, &b) >= 1) {
for (int i = (0); i < (int)(n); i++) {
long long x, k, r, t, bm = 0;
scanf("%lld%lld%lld", &x, &k, &r);
for (int j = (0); j < (int)(r); j++) {
scanf("%lld", &t);
--t;
bm ^= (1LL << t);
}
P[i] = {x, k, bm};
}
sort(P, P + n);
long long ans = INF;
for (int bm = (0); bm < (int)(1 << m); bm++) dist[bm] = INF;
dist[0] = 0;
for (int i = (0); i < (int)(n); i++) {
for (int bm = (0); bm < (int)(1 << m); bm++) {
dist[bm | P[i].bm] = min(dist[bm | P[i].bm], dist[bm] + P[i].x);
}
ans = min(ans, P[i].k * b + dist[(1 << m) - 1]);
}
printf("%lld\n", ans != INF ? ans : -1);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
struct F {
int x, k, v;
bool operator<(const F &first) const { return k < first.k; }
} first[110];
int n, m, b;
long long dp[1 << 21], ans;
int main() {
scanf("%d%d%d", &n, &m, &b);
for (int i = 0; i < n; i++) {
first[i].v = 0;
int t;
scanf("%d%d%d", &first[i].x, &first[i].k, &t);
for (int j = 0; j < t; j++) {
int v;
scanf("%d", &v);
first[i].v |= (1 << (v - 1));
}
}
sort(first, first + n);
ans = ((long long)(4e18));
memset(dp, 0x3f, sizeof(dp));
dp[0] = 0;
int M = (1 << m);
for (int i = 0; i < n; i++) {
for (int j = M - 1; j >= 0; j--) {
if (dp[j] < ((long long)(4e18)))
dp[j | first[i].v] = min(dp[j | first[i].v], dp[j] + first[i].x);
}
ans = min(ans, dp[M - 1] + (long long)b * (long long)first[i].k);
}
if (ans == ((long long)(4e18)))
puts("-1");
else
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long INF = 4e18;
long long dp[(1 << 20) + 100];
struct M {
int cost;
int nd;
int mask;
void read() {
mask = 0;
int n;
cin >> cost >> nd >> n;
for (int i = 1; i <= n; i++) {
int x;
cin >> x;
x--;
mask = mask | (1 << x);
}
}
bool operator<(const M &a) const { return nd < a.nd; }
};
int main() {
for (int i = 0; i < (1 << 20); i++) dp[i] = INF;
long long n, m, b;
cin >> n >> m >> b;
M mm[n];
for (int i = 0; i < n; i++) mm[i].read();
sort(mm, mm + n);
long long ans = INF;
dp[0] = 0;
for (int i = 0; i < n; i++) {
long long currm = mm[i].mask;
long long currc = mm[i].cost;
long long currb = mm[i].nd;
for (int j = 0; j < (1 << m); j++) {
dp[j | currm] = min(dp[j | currm], dp[j] + currc);
}
ans = min(ans, dp[(1 << m) - 1] + b * currb);
}
if (ans == INF) {
cout << "-1";
} else {
cout << ans;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
vector<pair<int, pair<int, int> > > v;
const int maxN = (1 << 20) + 100;
const long long inf = 2e18;
int n, m, b;
long long dp[maxN];
long long ans = 2e18;
int vis[maxN] = {-1};
inline int gt() {
int x;
cin >> x;
int cur = 0;
for (int(i) = (0); (i) < (int)(x); ++(i)) {
int c;
cin >> c;
c--;
cur |= (1 << c);
}
return cur;
}
void InIt() {
cin >> n >> m >> b;
for (int i = 0; i < n; i++) {
int x, k;
cin >> x >> k;
int d = gt();
v.push_back(make_pair(k, make_pair(x, d)));
}
}
inline void add(int ind, int pos) {
int nxt = v[ind].second.second | pos;
if (nxt != pos and dp[nxt] < inf and vis[nxt] != ind) add(ind, nxt);
vis[nxt] = ind;
dp[nxt] = min(dp[nxt], (long long)v[ind].second.first + dp[pos]);
}
long long Solve() {
sort(v.begin(), v.end());
for (int i = 0; i < (1 << m); i++) dp[i] = inf;
dp[0] = 0;
for (int(i) = (0); (i) < (int)(n); ++(i)) {
for (int(j) = (0); (j) < (int)((1 << m)); ++(j)) {
if (vis[j] != i and dp[j] < inf) add(i, j);
}
ans = min(ans, dp[(1 << m) - 1] + (long long)b * (long long)v[i].first);
}
return (ans < inf) ? ans : -1;
}
int main() {
ios_base::sync_with_stdio(false);
InIt();
cout << Solve() << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 105, POWM = 2000 * 1000 + 5;
const long long INF = 2000ll * 1000 * 1000 * 1000 * 1000 * 1000 + 5;
pair<pair<int, int>, int> a[MAXN];
long long dp[POWM];
int main() {
ios_base::sync_with_stdio(false);
int n, m, b;
cin >> n >> m >> b;
for (int i = 0; i < n; i++) {
int mi;
cin >> a[i].first.second >> a[i].first.first >> mi;
for (int j = 0; j < mi; j++) {
int pr;
cin >> pr;
a[i].second |= (1 << (pr - 1));
}
}
sort(a, a + n);
int pm = (1 << m);
for (int i = 0; i < pm; i++) dp[i] = INF;
dp[0] = 0;
long long ans = INF;
for (int i = 0; i < n; i++) {
for (int j = 0; j < pm; j++) {
if (dp[j] == INF) continue;
int to = a[i].second | j;
if (to != j && dp[to] > dp[j] + a[i].first.second)
dp[to] = dp[j] + a[i].first.second;
}
if (dp[pm - 1] < INF)
ans = min(ans, dp[pm - 1] + (long long)a[i].first.first * b);
}
if (ans == INF)
cout << -1 << '\n';
else
cout << ans << '\n';
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long dp[1 << 20];
struct people {
long long cost, req, problem;
};
people arr[120];
int comp(people a, people b) { return a.req < b.req; }
int main() {
int n, m, k;
cin >> n >> m >> k;
for (int i = 1; i <= n; i++) {
int x, k, mn;
cin >> arr[i].cost >> arr[i].req >> mn;
int temp;
for (int j = 0; j < mn; j++) {
cin >> temp;
arr[i].problem |= 1 << (temp - 1);
}
}
sort(arr + 1, arr + n + 1, comp);
long long mn = 1LL << 61;
for (int mask = 1; mask < 1 << m; mask++) dp[mask] = 1LL << 61;
for (int i = 1; i <= n; i++) {
for (int mask = 0; mask < (1 << m); mask++)
if (dp[mask] < (1LL << 61)) {
dp[mask | arr[i].problem] =
(dp[mask] + arr[i].cost * 1LL) > (dp[mask | arr[i].problem])
? (dp[mask | arr[i].problem])
: (dp[mask] + arr[i].cost * 1LL);
long long temp = dp[mask | arr[i].problem];
}
if (dp[(1 << m) - 1] < (1LL << 61)) {
mn = (mn) > (dp[(1 << m) - 1] + arr[i].req * k)
? (dp[(1 << m) - 1] + arr[i].req * k)
: (mn);
}
}
if (mn != (1LL << 61))
cout << mn << endl;
else
cout << -1 << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int Mod = 1e9 + 7;
const int N = 1e5 + 4;
inline int FIX(int a) { return (a % Mod + Mod) % Mod; }
int x[128], msk[128], a[128];
long long k[128], dp[(1 << 20) + 5];
void update(long long &det, long long v) {
if (det == -1)
det = v;
else
det = min(det, v);
}
int main() {
ios::sync_with_stdio(0);
int n, m, b;
cin >> n >> m >> b;
for (int i = 0; i < n; i++) {
cin >> x[i] >> k[i];
int tmp, curm = 0;
cin >> tmp;
for (int j = 0; j < tmp; j++) {
int x;
cin >> x;
x--;
curm += (1 << (x));
}
msk[i] = curm;
a[i] = i;
}
sort(a, a + n, [](const int &A, const int &B) { return k[A] < k[B]; });
memset(dp, -1, sizeof(dp));
dp[0] = 0;
long long res = -1;
for (int i = 0; i < n; i++) {
int idx = a[i];
for (int j = 0; j < (1 << (m)); j++) {
if (dp[j] == -1) continue;
update(dp[j | msk[idx]], dp[j] + x[idx]);
}
if (dp[(1 << (m)) - 1] != -1) {
update(res, dp[(1 << (m)) - 1] + k[idx] * b);
}
}
cout << res << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long inf = (long long)2e18;
int n, m, cost;
long long f[(1 << 21)];
int x[111], k[111], M[111], bits[(1 << 21)];
int cnt(int i) {
int result = 0;
while (i) {
result += (i % 2);
i >>= 1;
}
return result;
}
int main() {
ios_base::sync_with_stdio(false);
cin >> n >> m >> cost;
for (int i = 0; i < n; i++) {
int foo;
cin >> x[i] >> k[i] >> foo;
for (int j = 0; j < foo; ++j) {
int s;
cin >> s;
--s;
M[i] ^= (1 << s);
}
}
for (int i = 0; i < (1 << m); ++i) {
f[i] = inf;
}
for (int i = 0; i < n; i++) {
for (int j = i + 1; j < n; ++j) {
if (k[j] > k[i]) {
swap(k[i], k[j]);
swap(M[i], M[j]);
swap(x[i], x[j]);
}
}
}
f[0] = 0;
for (int i = 0; i < n; i++) {
f[M[i]] = min(f[M[i]], 1LL * (x[i] + k[i] * 1LL * cost));
for (int mask = 1; mask < (1 << m); ++mask) {
int new_mask = (mask | M[i]);
f[new_mask] = min(f[new_mask], (long long)(f[mask] + x[i]));
}
}
cout << (f[(1 << m) - 1] == inf ? -1 : f[(1 << m) - 1]) << '\n';
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m;
unsigned long long b;
unsigned long long masks[1001], x[1001], k[1001];
unsigned long long ans = 0, f[1 << 21], ff[1 << 21];
int p[10001];
bool cmp(int x, int y) { return k[x] < k[y]; }
int main() {
ios_base::sync_with_stdio(0);
cin >> n >> m >> b;
for (int i = 1; i <= n; ++i) {
int cnt;
cin >> x[i] >> k[i] >> cnt;
for (int j = 1; j <= cnt; ++j) {
int id;
cin >> id;
--id;
masks[i] = masks[i] | (1 << id);
}
}
for (int i = 1; i <= n; ++i) p[i] = i;
sort(p + 1, p + n + 1, cmp);
for (int i = 0; i < (1 << m); ++i) f[i] = ff[i] = 18446744073709551614ULL;
f[0] = 0;
for (int i = 1; i <= n; ++i) {
for (int mask = 0; mask < (1 << m); ++mask) ff[mask] = f[mask];
for (int mask = 0; mask < (1 << m); ++mask) {
if (f[mask] == 18446744073709551614ULL) continue;
ff[mask | masks[p[i]]] = min(ff[mask | masks[p[i]]], f[mask] + x[p[i]]);
}
if (ff[(1 << m) - 1] != 18446744073709551614ULL) {
if (ans == 0)
ans = ff[(1 << m) - 1] + k[p[i]] * b;
else
ans = min(ans, ff[(1 << m) - 1] + k[p[i]] * b);
}
for (int mask = 0; mask < (1 << m); ++mask) f[mask] = ff[mask];
}
if (ans == 0)
cout << -1;
else
cout << ans;
return 0;
}
|
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:128000000")
using namespace std;
void solve();
clock_t start;
int main() {
int t = 1;
cout.precision(10);
cout << fixed;
start = clock();
while (t--) {
solve();
}
return 0;
}
struct man {
long long x, k;
long long mask;
man() {}
void scan() {
cin >> x >> k;
mask = 0;
long long num;
cin >> num;
for (long long i = 0; i < num; ++i) {
long long cur;
cin >> cur;
--cur;
mask |= (1 << cur);
}
}
bool operator<(const man& other) const { return k < other.k; }
};
long long n, m, b;
man friends[200];
long long dp[2][1 << 22];
void solve() {
cin >> n >> m >> b;
for (long long i = 0; i < n; ++i) friends[i].scan();
sort(friends, friends + n);
for (long long i = 0; i < (1 << m); ++i) dp[0][i] = dp[1][i] = 4e18;
long long ans = 4e18;
long long w = 0;
dp[w][0] = 0;
for (long long i = 0; i < n; ++i) {
for (long long i = 0; i < (1 << m); ++i) dp[w ^ 1][i] = dp[w][i];
for (long long mask = 0; mask < (1 << m); ++mask) {
long long newMask = mask | friends[i].mask;
dp[w ^ 1][newMask] = min(dp[w ^ 1][newMask], dp[w][mask] + friends[i].x);
if (newMask + 1 == (1 << m))
ans = min(ans, dp[w ^ 1][newMask] + b * friends[i].k);
}
w ^= 1;
}
if (ans + 1 < 4e18)
cout << ans;
else
cout << -1;
}
|
#include <bits/stdc++.h>
using namespace std;
template <class T>
T inline sqr(T x) {
return x * x;
}
const long double pi = 3.1415926535897932384626433832795;
const long double eps = 1e-8;
const int N = 110, M = 20;
int n, m;
int x[N], k[N], tasks[N];
long long d[(1 << M)];
const long long INF = 2e18;
bool cmp(int i, int j) { return k[i] < k[j]; }
int tmp[N];
void apply(vector<int> p, int x[]) {
for (int i = 0; i < (int)(n); ++i) tmp[i] = x[i];
for (int i = 0; i < (int)(n); ++i) x[i] = tmp[p[i]];
}
int main() {
long long b;
cin >> n >> m >> b;
vector<int> allK;
for (int i = 0; i < (int)(n); ++i) {
int m;
cin >> x[i] >> k[i] >> m;
for (int j = 0; j < (int)(m); ++j) {
int t;
cin >> t;
--t;
tasks[i] |= (1 << t);
}
}
vector<int> p(n);
for (int i = 0; i < (int)(n); ++i) p[i] = i;
sort((p).begin(), (p).end(), cmp);
apply(p, tasks);
apply(p, x);
apply(p, k);
for (int i = 0; i < (int)((1 << m)); ++i) d[i] = INF;
d[0] = 0;
long long ans = INF;
for (int i = 0; i < (int)(n); ++i) {
for (int msk = (int)((1 << m)) - 1; msk >= 0; --msk)
d[msk | tasks[i]] = min(d[msk | tasks[i]], d[msk] + x[i]);
ans = min(ans, d[(1 << m) - 1] + b * k[i]);
}
if (ans == INF) ans = -1;
cout << ans << "\n";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long int n, m, b;
long long int dp[(1 << 20) + 10];
struct FD {
long long int x, k, pb;
} fd[120];
bool cmp(FD a, FD b) { return a.k < b.k; }
int main() {
scanf("%d%d%d", &n, &m, &b);
for (int i = 0; i < n; i++) {
long long int xi, ki, mi, problem = 0;
cin >> xi >> ki >> mi;
for (int j = 0; j < mi; j++) {
int a;
scanf("%d", &a);
a--;
problem |= (1 << a);
}
fd[i] = (FD){xi, ki, problem};
}
sort(fd, fd + n, cmp);
int state = (1 << m) - 1;
for (int i = 0; i <= state; i++) dp[i] = (long long int)(1LL << 60);
dp[0] = 0;
long long int ans = (long long int)(1LL << 60);
for (int i = 0; i < n; i++) {
for (int j = 0; j <= state; j++) {
dp[j | fd[i].pb] = min(dp[j | fd[i].pb], dp[j] + fd[i].x);
}
ans = min(ans, dp[state] + fd[i].k * b);
}
if (ans == (long long int)(1LL << 60)) ans = -1;
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
bool cmp(pair<pair<int, int>, int> a, pair<pair<int, int>, int> b) {
return a.first.second < b.first.second;
}
const int maxn = 1e2 + 10, mmask = (1 << 20) + 10;
const long long oo = 4e18;
pair<pair<int, int>, int> p[maxn];
long long dp[mmask], b, ans;
int n, m;
int main() {
memset(dp, 63, sizeof(dp));
cin >> n >> m >> b;
for (int i = 0; i < n; ++i) {
int q, k;
cin >> p[i].first.first >> p[i].first.second >> q;
while (q--) {
cin >> k;
--k;
p[i].second |= (1 << k);
}
}
dp[0] = 0;
sort(p, p + n, cmp);
int lim = 1 << m;
ans = oo;
for (int i = 0; i < n; ++i) {
for (int j = 1; j < lim; ++j)
if (j & p[i].second) {
int mask = j & (~p[i].second);
if (dp[mask] + p[i].first.first < dp[j])
dp[j] = dp[mask] + p[i].first.first;
}
ans = min(ans, dp[lim - 1] + b * p[i].first.second);
}
if (ans == oo) ans = -1;
cout << ans << '\n';
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
struct Friend {
int price, canSolve, monitors;
bool operator<(const Friend &other) const {
return monitors > other.monitors;
}
};
const int N = 105, M = 1 << 20;
int n, m, b;
Friend info[N];
ll dp[2][M];
int main() {
scanf("%d%d%d", &n, &m, &b);
int mi, ind;
for (int i = 0; i < n; i++) {
scanf("%d %d %d", &info[i].price, &info[i].monitors, &mi);
while (mi--) {
scanf("%d", &ind);
info[i].canSolve |= (1 << (ind - 1));
}
}
sort(info, info + n);
for (int i = 0; i < M; i++)
if (i != (1 << m) - 1) dp[0][i] = LLONG_MAX / 2;
bool turn = 1;
for (int i = n - 1; i >= 0; i--) {
for (int solved = 0; solved < M; solved++) {
ll mon = solved ? 0 : b * 1ll * info[i].monitors;
dp[turn][solved] =
min(dp[!turn][solved],
dp[!turn][solved | info[i].canSolve] + info[i].price + mon);
}
turn = !turn;
}
if (dp[!turn][0] == LLONG_MAX / 2)
puts("-1");
else
printf("%lld", dp[!turn][0]);
}
|
#include <bits/stdc++.h>
using namespace std;
const long long INF = 4e18;
struct node {
int x, k, s;
} f[105];
long long dp[(1 << 20) + 10];
inline bool cmp(node a, node b) { return a.k < b.k; }
int main() {
int t, n, m, b, x;
memset(dp, -1, sizeof(dp));
scanf("%d%d%d", &n, &m, &b);
for (int i = 0; i < n; i++) {
scanf("%d%d", &f[i].x, &f[i].k);
scanf("%d", &t);
while (t--) scanf("%d", &x), f[i].s |= 1 << (x - 1);
}
sort(f, f + n, cmp);
int limit = (1 << m) - 1;
long long ans = INF;
dp[0] = 0;
for (int i = 0; i < n; i++) {
for (int st = 0; st <= limit; st++) {
if (dp[st] == -1) continue;
t = st | f[i].s;
if (dp[t] != -1)
dp[t] = min(dp[t], dp[st] + f[i].x);
else
dp[t] = dp[st] + f[i].x;
}
if (dp[limit] != -1) ans = min(ans, dp[limit] + 1LL * f[i].k * b);
}
printf("%I64d\n", ans == INF ? -1 : ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
#pragma comment(linker, "/STACK:256000000")
template <class T>
T sqr(T a) {
return a * a;
}
int n, m, b;
long long a[1 << 20];
int was[1 << 20];
struct dr {
int mon, pl, zad;
int mask;
const bool operator<(dr a) const {
if (mon < a.mon)
return true;
else
return false;
}
};
dr fr[100];
void init() {
scanf("%d%D%D", &n, &m, &b);
for (int i = 0; i < n; ++i) {
scanf("%d%d%D", &fr[i].pl, &fr[i].mon, &fr[i].zad);
for (int j = 0; j < fr[i].zad; ++j) {
int t;
scanf("%D", &t);
t--;
fr[i].mask |= 1 << t;
}
}
sort(fr, fr + n);
}
int q = 0;
long long ot = -1, ma = 1e18, co;
void solve() {
was[0] = 1;
for (int i = 0; i < (1 << m); ++i) a[i] = 1e18;
a[0] = 0;
for (int i = 0; i < n; ++i) {
co = fr[i].mon;
int t = fr[i].mask;
for (int j = (1 << m) - 1; j >= 0; --j) {
if (!was[j]) continue;
was[j | t] = 1;
a[j | t] = min(a[j | t], a[j] + fr[i].pl);
}
if (!was[(1 << m) - 1]) continue;
if (ot == -1)
ot = a[(1 << m) - 1] + co * (long long)b;
else
ot = min(ot, a[(1 << m) - 1] + co * (long long)b);
}
cout << ot;
}
int main() {
init();
solve();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1000 * 1000 * 2 + 10;
const long long int mod = 1e9 + 7;
const long long int inf = 4e18;
long long int dp[2][N], c[2][N];
vector<pair<int, pair<int, int>>> vec;
vector<int> M;
int main() {
ios_base::sync_with_stdio(false), cin.tie(0), cout.tie(0);
int n, m, t;
cin >> n >> m >> t;
long long int p = (1 << m) - 1;
for (int i = 0; i < n; i++) {
long long int x, k, y, b = p;
cin >> x >> k >> y;
while (y--) {
long long int d;
cin >> d;
d--;
b ^= (1 << d);
}
vec.push_back({k, {x, b}});
}
sort(vec.begin(), vec.end());
for (int i = 0; i <= p; i++) {
M.push_back(i);
if (i != 0) {
dp[0][i] = inf;
dp[1][i] = inf;
c[0][i] = inf;
c[1][i] = inf;
}
}
int i = 0;
for (auto it : vec) {
long long int k = it.first, x = it.second.first, b = it.second.second;
for (auto mask : M) {
int mask2 = mask & b;
dp[i][mask] = min(dp[1 - i][mask], min(inf, c[1 - i][mask2] + x) + k * t);
c[i][mask] = min(c[1 - i][mask], x + c[1 - i][mask2]);
}
i = 1 - i;
}
if (dp[1 - i][p] == inf) dp[1 - i][p] = -1;
cout << dp[1 - i][p] << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
typedef long long arr[(1 << 20) + 10];
long long i, j, k, p, n, m, ans, B, cur;
arr f[2], g[2];
struct Person {
long long x, k, S;
} a[105];
void Init() {
scanf(
"%I64d"
"%I64d"
"%I64d"
"\n",
&n, &m, &B);
for (i = 1; i <= n; ++i) {
scanf(
"%I64d"
"%I64d"
"%I64d"
"\n",
&a[i].x, &a[i].k, &k);
long long u = 0;
for (j = 1; j <= k; ++j) scanf("%I64d", &p), u |= (1 << (p - 1));
a[i].S = u;
}
}
bool cmp(Person a, Person b) { return a.k < b.k; }
void Work() {
long long T = 1 << m;
sort(a + 1, a + n + 1, cmp);
ans = (1LL << 62) + 10000LL;
for ((i) = (0); (i) <= (T - 1); ++(i)) f[1][(i)] = ((1LL << 62) + 10000LL);
for ((i) = (0); (i) <= (T - 1); ++(i)) f[0][(i)] = ((1LL << 62) + 10000LL);
f[0][0] = 0;
cur = 0;
for (i = 1; i <= n; ++i) {
cur ^= 1;
for (j = 0; j < T; ++j) {
f[cur][j] =
((f[cur][j]) < (f[cur ^ 1][j]) ? (f[cur][j]) : (f[cur ^ 1][j]));
f[cur][j | a[i].S] = ((f[cur][j | a[i].S]) < (f[cur ^ 1][j] + a[i].x)
? (f[cur][j | a[i].S])
: (f[cur ^ 1][j] + a[i].x));
}
ans = ((ans) < (f[cur][T - 1] + a[i].k * B) ? (ans)
: (f[cur][T - 1] + a[i].k * B));
}
}
int main() {
Init();
Work();
if (ans < (1LL << 62) + 10000LL)
printf(
"%I64d"
"\n",
ans);
else
printf("-1\n");
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 21;
const long long inf = 4e18 + 5;
int n, m;
long long b;
pair<long long, long long> niz[105];
long long dp[(1 << maxn)];
int koje[105];
int main() {
ios::sync_with_stdio(false);
cin.tie(nullptr);
cout.tie(nullptr);
cin >> n >> m >> b;
for (int i = 0; i < n; i++) {
int len;
cin >> niz[i].first >> niz[i].second >> len;
for (int j = 0; j < len; j++) {
int x;
cin >> x;
koje[i] ^= (1 << (x - 1));
}
}
for (int i = 0; i < n; i++) {
for (int j = i + 1; j < n; j++) {
if (niz[j].second < niz[i].second) {
swap(niz[i], niz[j]);
swap(koje[i], koje[j]);
}
}
}
for (int mask = 0; mask < (1 << m); mask++) dp[mask] = inf;
long long rez = inf;
dp[0] = 0;
for (int i = 0; i < n; i++) {
for (int mask = 0; mask < (1 << m); mask++)
dp[mask | koje[i]] = min(dp[mask | koje[i]], dp[mask] + niz[i].first);
long long kol = dp[(1 << m) - 1] + 1LL * niz[i].second * b;
rez = min(rez, kol);
}
cout << (rez == inf ? -1 : rez) << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int N, M, B;
long long Ans, F[2000005];
struct Nod {
int x, k, s;
} A[105];
bool Cmp(Nod a, Nod b) { return a.k < b.k; }
int main() {
scanf("%d%d%d", &N, &M, &B);
for (int i = 1, t; i <= N; i++) {
scanf("%d%d%d", &A[i].x, &A[i].k, &t);
for (int x; t--;) scanf("%d", &x), A[i].s |= 1 << x - 1;
}
sort(A + 1, A + N + 1, Cmp);
int U = 1 << M;
Ans = (1ll << 60);
for (int i = 1; i < U; i++) F[i] = (1ll << 60);
for (int i = 1; i <= N; i++) {
for (int j = 0; j < U; j++)
if (F[j] != (1ll << 60))
F[j | A[i].s] = min(F[j | A[i].s], F[j] + A[i].x);
if (F[U - 1] != (1ll << 60)) Ans = min(Ans, F[U - 1] + 1ll * A[i].k * B);
}
printf("%I64d\n", Ans == (1ll << 60) ? -1 : Ans);
}
|
#include <bits/stdc++.h>
using namespace std;
typedef struct fr {
unsigned long long x, k;
int m;
long p;
} fr;
fr A[120];
int n, m;
unsigned long long b;
inline bool frsort(fr a, fr b) { return a.k < b.k; }
int main() {
scanf("%d %d %I64d", &n, &m, &b);
for (int i = (1); i <= (n); i++) {
scanf("%I64d %I64d %d", &A[i].x, &A[i].k, &A[i].m);
A[i].p = 0;
int p;
for (int j = (1); j <= (A[i].m); j++) {
scanf("%d", &p);
p--;
A[i].p |= (1 << p);
}
}
sort(A + 1, A + n + 1, frsort);
unsigned long long ans = ULLONG_MAX;
int lim = (1 << m) - 1;
int c = 0;
unsigned long long dp[2][lim + 3];
for (int i = (0); i <= (lim); i++) dp[c][i] = (i == lim) ? 0 : ULLONG_MAX;
for (int i = (1); i <= (n); i++) {
for (int j = (0); j <= (lim); j++) {
unsigned long long x = dp[c][j];
unsigned long long y = dp[c][j | A[i].p];
if (y < ULLONG_MAX) y += A[i].x;
dp[1 - c][j] = (((x) < (y)) ? (x) : (y));
}
c = 1 - c;
if (dp[c][0] < ULLONG_MAX)
ans =
(((ans) < (dp[c][0] + A[i].k * b)) ? (ans) : (dp[c][0] + A[i].k * b));
}
if (ans < ULLONG_MAX) {
cout << ans << endl;
} else {
cout << (-1) << endl;
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 200;
const long long INF = 2 * 1e18;
int n, m, soal[maxn], pool[maxn], x, a;
pair<long long, int> moni[maxn];
long long dp[1100000], b, ans = INF;
int main() {
cin >> n >> m >> b;
for (int i = 1; i <= n; i++) {
cin >> pool[i] >> moni[i].first >> x;
moni[i].second = i;
for (int j = 0; j < x; j++) {
cin >> a;
soal[i] += (1 << (a - 1));
}
}
sort(moni + 1, moni + n + 1);
for (int i = 1; i < (1 << m); i++) dp[i] = INF;
for (int i = 0; i < n; i++) {
for (int j = 0; j < (1 << m); j++)
dp[j | soal[moni[i + 1].second]] = min(dp[j | soal[moni[i + 1].second]],
dp[j] + pool[moni[i + 1].second]);
ans = min(ans, dp[(1 << m) - 1] + 1ll * b * moni[i + 1].first);
}
if (ans == INF)
cout << -1;
else
cout << ans;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long N = ((1 << 20) + 10), INF = 0x3f3f3f3f3f3f3f3f, mod = 1e9 + 7;
struct node {
long long x, k, sta;
bool operator<(const node &next) const & { return k < next.k; }
} a[100 + 10];
long long dp[N];
signed main() {
ios::sync_with_stdio(false);
cin.tie(0), cout.tie(0);
long long n, m, b;
cin >> n >> m >> b;
for (long long i = 1; i <= n; i++) {
cin >> a[i].x >> a[i].k;
long long cnt, tmp;
cin >> cnt;
while (cnt--) {
cin >> tmp;
a[i].sta |= (1 << (tmp - 1));
}
}
memset(dp, 0x3f, sizeof dp);
long long ans = INF;
dp[0] = 0;
sort(a + 1, a + 1 + n);
for (long long i = 1; i <= n; i++) {
for (long long j = 0, up = (1 << m); j < up; j++) {
dp[j | a[i].sta] = min(dp[j | a[i].sta], dp[j] + a[i].x);
if ((j | a[i].sta) == up - 1) ans = min(ans, dp[up - 1] + a[i].k * b);
}
}
if (ans == INF) ans = -1;
cout << ans;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m;
long long b;
struct PP {
int x, k, m;
int y, id;
} p[110];
long long f[1 << 21];
const long long inf = (1ll << 62);
bool cmp(PP a, PP b) {
if (a.k == b.k) return a.id < b.id;
return a.k < b.k;
}
int main() {
cin >> n >> m >> b;
for (int i = 0; i < n; i++) {
scanf("%d%d%d", &p[i].x, &p[i].k, &p[i].m);
p[i].id = i;
p[i].y = 0;
for (int j = 0; j < p[i].m; j++) {
int t;
scanf("%d", &t);
t--;
p[i].y += (1 << t);
}
}
sort(p, p + n, cmp);
int ma = (1 << m);
long long ans = inf;
for (int i = 0; i < ma; i++) f[i] = inf;
f[0] = 0;
for (int i = 0; i < n; i++) {
for (int j = ma - 1; j >= 0; j--)
if (f[j] != inf) {
f[j | p[i].y] = min(f[j | p[i].y], f[j] + p[i].x);
}
if (f[ma - 1] != inf) ans = min(ans, f[ma - 1] + (long long)p[i].k * b);
}
if (ans == inf)
printf("-1\n");
else
cout << ans << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
void RD(int &x) { scanf("%d", &x); }
void RD(long long &x) { scanf("%I64d", &x); }
void RD(double &x) { scanf("%lf", &x); }
void RD(int &x, int &y) { scanf("%d%d", &x, &y); }
void RD(long long &x, long long &y) { scanf("%I64d%I64d", &x, &y); }
void RD(double &x, double &y) { scanf("%lf%lf", &x, &y); }
void RD(char *s) { scanf("%s", s); }
void RD(char &s) { scanf("%c", &s); }
void RD(string &s) { cin >> s; }
void PR(int x) { printf("%d\n", x); }
void PR(int x, int y) { printf("%d %d\n", x, y); }
void PR(long long x) { printf("%I64d\n", x); }
void PR(char x) { printf("%c\n", x); }
void PR(char *x) { printf("%s\n", x); }
void PR(string x) { cout << x << endl; }
const long long inf = 1e18;
const long long mod = 1LL;
struct data {
long long cost, monitors, problem;
};
data frend[110];
bool comp(data p, data q) { return p.monitors < q.monitors; }
long long dp[(1 << 20) + 10];
int main() {
long long n, m, b, k, i, j, p, ans, lim;
while (scanf("%I64d %I64d %I64d", &n, &m, &b) == 3) {
for ((i) = 0; (i) < (int)(n); (i)++) {
RD(frend[i].cost, frend[i].monitors);
RD(k);
frend[i].problem = 0;
for ((j) = 0; (j) < (int)(k); (j)++) {
RD(p);
frend[i].problem |= 1 << (p - 1);
}
}
stable_sort(frend, frend + n, comp);
lim = (1 << m);
memset(dp, -1, sizeof(dp));
dp[0] = 0;
ans = -1;
for ((i) = 0; (i) < (int)(n); (i)++) {
for ((j) = 0; (j) < (int)(lim); (j)++)
if (~dp[j]) {
if (~dp[j | frend[i].problem])
dp[j | frend[i].problem] =
min(dp[j | frend[i].problem], dp[j] + frend[i].cost);
else
dp[j | frend[i].problem] = dp[j] + frend[i].cost;
}
if (~dp[lim - 1]) {
if (~ans)
ans = min(ans, dp[lim - 1] + b * frend[i].monitors);
else
ans = dp[lim - 1] + b * frend[i].monitors;
}
}
PR(ans);
}
return 0;
}
|
#include <bits/stdc++.h>
inline unsigned long long read() {
unsigned long long ans = 0;
char last = ' ', ch = getchar();
while (ch < '0' || ch > '9') last = ch, ch = getchar();
while (ch >= '0' && ch <= '9')
ans = (ans << 3) + (ans << 1) + ch - '0', ch = getchar();
if (last == '-') ans = -ans;
return ans;
}
const unsigned long long INF = 1e19;
const int N = 105;
unsigned long long n, m, b;
struct Friend {
unsigned long long mon;
unsigned long long nums;
unsigned long long prob;
} p[N];
bool cmp(const Friend &a, const Friend &b) { return a.nums < b.nums; }
unsigned long long f[1 << 21];
unsigned long long ans = INF;
int main() {
n = read(), m = read(), b = read();
int num, x;
for (int i = 0; i <= n - 1; ++i) {
p[i].mon = read(), p[i].nums = read();
num = read();
for (int j = 1; j <= num; ++j) {
x = read();
p[i].prob |= 1 << (x - 1);
}
}
std::sort(p, p + n, cmp);
for (int i = 0; i < (1 << m); ++i) {
f[i] = INF;
}
f[0] = 0;
for (int i = 0; i < n; ++i) {
for (int j = 0; j < (1 << m); ++j) {
if (f[j] == INF) continue;
f[j | p[i].prob] =
((f[j | p[i].prob]) < (f[j] + p[i].mon) ? (f[j | p[i].prob])
: (f[j] + p[i].mon));
}
if (f[(1 << m) - 1] != INF)
ans = ((ans) < (f[(1 << m) - 1] + p[i].nums * b)
? (ans)
: (f[(1 << m) - 1] + p[i].nums * b));
}
if (ans != INF)
printf("%I64d\n", ans);
else
printf("-1\n");
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m;
int L[(110 * 110)], R[(110 * 110)], U[(110 * 110)], D[(110 * 110)], cnt;
int row[(110 * 110)], col[(110 * 110)];
int N[110], use[110], head[110];
int monitor[110];
int B;
void init() {
memset(head, -1, sizeof(head));
memset(N, 0, sizeof(N));
for (int i = 0; i <= m; ++i) {
L[i] = i - 1, R[i] = i + 1;
U[i] = D[i] = i;
row[i] = 0, col[i] = i;
}
L[0] = m, R[m] = 0;
cnt = m;
}
void remove(int x) {
for (int i = D[x]; i != x; i = D[i]) L[R[i]] = L[i], R[L[i]] = R[i];
}
void resume(int x) {
for (int i = D[x]; i != x; i = D[i]) L[R[i]] = R[L[i]] = i;
}
int low() {
int mi = 110, idx = 0;
for (int i = R[0]; i; i = R[i])
if (N[i] < mi) mi = N[i], idx = i;
return idx;
}
void link(int r, int c) {
++N[c], ++cnt;
row[cnt] = r, col[cnt] = c;
U[cnt] = U[c], D[cnt] = c;
U[D[cnt]] = D[U[cnt]] = cnt;
if (head[r] == -1)
head[r] = L[cnt] = R[cnt] = cnt;
else {
L[cnt] = L[head[r]];
R[cnt] = head[r];
L[R[cnt]] = R[L[cnt]] = cnt;
}
}
int cost[110];
long long best;
int micost[110];
long long cost2() {
long long ret = 0;
bool del[(110 * 110)];
memset(del, false, sizeof(del));
for (int c = R[0]; c; c = R[c]) {
if (!del[c]) {
del[c] = true;
ret += micost[c];
for (int i = D[c]; i != c; i = D[i])
for (int j = R[i]; j != i; j = R[j]) del[col[j]] = true;
}
}
return ret;
}
void dance(int dep, long long val, int mak) {
if (R[0] == 0) {
best = min(best, val + (long long)mak * B);
return;
}
int c = low();
if (c == 0 || val + (long long)mak * B >= best) return;
if (val + (long long)mak * B + cost2() >= best) return;
for (int i = D[c]; i != c; i = D[i]) {
use[dep] = i;
remove(i);
for (int j = R[i]; j != i; j = R[j]) remove(j);
dance(dep + 1, val + cost[row[i]], max(mak, monitor[row[i]]));
for (int j = L[i]; j != i; j = L[j]) resume(j);
resume(i);
}
}
int main() {
while (~scanf("%d%d%d", &n, &m, &B)) {
init();
memset(micost, 0x3f, sizeof(micost));
best = 0;
int mam = 0;
for (int i = 1; i <= n; ++i) {
int tmp, tmp2;
scanf("%d%d%d", cost + i, monitor + i, &tmp);
best += cost[i];
mam = max(mam, monitor[i]);
for (int j = 0; j < tmp; ++j) {
scanf("%d", &tmp2);
link(i, tmp2);
micost[tmp2] = min(micost[tmp2], cost[i]);
}
}
best += (long long)mam * B;
for (int i = 1; i <= m; ++i)
if (!N[i]) {
N[1] = 0;
break;
}
if (!N[1]) {
puts("-1");
continue;
}
dance(0, 0, 0);
printf("%I64d\n", best);
}
return 0;
}
void data() {
freopen("in.txt", "w", stdout);
puts("20 100");
for (int i = 0; i < 100; ++i) printf("%d %d %d\n", 998, 1, i % 20 + 1);
}
|
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:16777216")
using namespace std;
struct data {
long long x, k;
int msk;
};
long long dp[1 << 20] = {0};
bool cmp(data a, data b) { return a.k < b.k; }
int main() {
int n, m, mm, num;
long long b, ans = 1000000000 * 9ll * 1000000000;
data v[101];
scanf("%d%d%I64d", &n, &m, &b);
memset((dp), (-1), sizeof(dp));
for (int(i) = (1); (i) <= (n); ++(i)) {
scanf("%I64d%I64d%d", &v[i].x, &v[i].k, &mm);
v[i].msk = 0;
for (int(j) = 0; (j) < (mm); ++(j)) {
scanf("%d", &num);
v[i].msk += 1 << (num - 1);
}
}
sort(v + 1, v + n + 1, cmp);
dp[0] = 0;
int MAX = 1 << m;
for (int(i) = (1); (i) <= (n); ++(i)) {
for (int(j) = 0; (j) < (MAX); ++(j))
if (dp[j] != -1) {
int next = j | v[i].msk;
long long cur = v[i].x + dp[j];
if (dp[next] == -1 || dp[next] > cur) dp[next] = cur;
}
if (dp[MAX - 1] != -1) ans = min(ans, dp[MAX - 1] + b * v[i].k);
}
if (ans == 1000000000 * 9ll * 1000000000)
puts("-1");
else
printf("%I64d\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <class T>
inline T bigmod(T p, T e, T M) {
long long ret = 1;
for (; e > 0; e >>= 1) {
if (e & 1) ret = (ret * p) % M;
p = (p * p) % M;
}
return (T)ret;
}
template <class T>
inline T gcd(T a, T b) {
if (b == 0) return a;
return gcd(b, a % b);
}
template <class T>
inline T lcm(T a, T b) {
return (a / gcd(a, b)) * b;
}
template <class T>
inline T modinverse(T a, T M) {
return bigmod(a, M - 2, M);
}
template <class T>
inline T bpow(T p, T e) {
long long ret = 1;
for (; e > 0; e >>= 1) {
if (e & 1) ret = (ret * p);
p = (p * p);
}
return (T)ret;
}
struct data {
long long e1, e2, e3;
data() {}
data(int a, int b, int c) { e1 = a, e2 = b, e3 = c; }
bool friend operator<(data a, data b) { return a.e2 < b.e2; }
};
int n, m, k;
long long N, M, K;
data a[105];
long long dp[3][(1 << 20) + 3];
int fnd;
int main() {
int t, tc = 1;
scanf("%d %d %d", &n, &m, &k);
int z = k;
for (int i = 1; i <= n; i++) {
long long x, y;
scanf("%lld %lld", &x, &y);
scanf("%d", &k);
int fnd = 0;
for (int i = 1; i <= k; i++) {
int p;
scanf("%d", &p);
p--;
fnd = fnd | (1 << p);
}
a[i] = data(x, y, fnd);
}
sort(a + 1, a + n + 1);
for (int i = n + 1; i >= 1; i--) {
for (int j = 0; j < (1 << m); j++) {
if (j == (1 << m) - 1)
dp[i % 2][j] = a[i - 1].e2 * z;
else if (i == n + 1) {
dp[i % 2][j] = 3000000000000000000;
} else {
dp[i % 2][j] = dp[(i + 1) % 2][j];
dp[i % 2][j] =
min(dp[i % 2][j], dp[(i + 1) % 2][j | a[i].e3] + a[i].e1);
}
}
}
if (dp[1][0] == 3000000000000000000) dp[1][0] = -1;
printf("%lld\n", dp[1][0]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const unsigned long long maxn = 20, Maxn = 100 + 10;
const unsigned long long inf = 1e19 + 10;
unsigned long long dp[2][(1 << maxn)];
unsigned long long x[Maxn], k[Maxn], mm[Maxn], mas[Maxn];
pair<unsigned long long, unsigned long long> a[Maxn];
int32_t main() {
ios::sync_with_stdio(0), cin.tie(0), cout.tie(0);
unsigned long long n, m, b;
cin >> n >> m >> b;
for (unsigned long long i = 0; i < n; i++) {
cin >> x[i] >> k[i] >> mm[i];
for (unsigned long long j = 0; j < mm[i]; j++) {
unsigned long long y;
cin >> y;
y--;
mas[i] += (1 << y);
}
a[i] = make_pair(k[i], i);
}
unsigned long long ans = inf;
sort(a, a + n);
unsigned long long msk = (1 << m) - 1;
for (unsigned long long mask = 1; mask < (1 << m); mask++)
dp[1][mask] = dp[0][mask] = inf;
for (unsigned long long mask = 1; mask < (1 << m); mask++) {
if ((mask & mas[a[0].second]) == mask) {
dp[0][mask] = x[a[0].second];
if (mask == msk) ans = dp[0][mask] + a[0].first * b;
}
}
unsigned long long j = 1;
for (unsigned long long i = 1; i < n; i++) {
for (unsigned long long mask = 1; mask < (1 << m); mask++)
dp[j][mask] =
min(dp[1 - j][mask],
dp[1 - j][mask ^ (mask & mas[a[i].second])] + x[a[i].second]);
ans = min(ans, dp[j][msk] + a[i].first * b);
j = 1 - j;
}
if (ans == inf)
cout << -1 << "\n";
else
cout << ans << "\n";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <class A, class B>
ostream& operator<<(ostream& o, pair<A, B>& p) {
return o << "(" << p.first << ", " << p.second << ")";
}
template <class T>
ostream& operator<<(ostream& o, const vector<T>& v) {
o << "{";
for (typeof((v).begin()) it = (v).begin(); it != (v).end(); it++)
o << *it << ", ";
return o << "}";
}
struct debugger {
ostream& out;
bool first;
void start() { first = true; }
debugger(ostream& out) : out(out) { start(); }
void nl() {
out << endl;
start();
}
template <class T>
debugger& operator,(T& v) {
if (first)
first = false;
else
out << ", ";
out << v;
return *this;
}
template <class T>
debugger& operator,(pair<T*, int> arr) {
out << "{";
for (typeof((arr.second) - 1) i = (0); i <= ((arr.second) - 1); i++) {
out << arr.first[i] << ", ";
}
out << "}";
return *this;
}
} dbg(cerr);
long long mem[1 << 20][2];
long long n, m, b;
vector<pair<long long, pair<long long, int> > > v;
long long dp() {
for (int ind = n; ind >= 0; ind--) {
for (int msk = 0; msk < (1 << m); msk++) {
if (ind == n) {
if (msk == (1 << m) - 1)
mem[msk][ind & 1] = 0;
else
mem[msk][ind & 1] = 4000000000000000000LL;
continue;
}
long long& ret = mem[msk][ind & 1];
ret = mem[msk][(ind + 1) & 1];
if (msk == 0) {
ret = min(ret, v[ind].first * b + v[ind].second.first +
mem[msk | v[ind].second.second][(ind + 1) & 1]);
} else
ret = min(ret, v[ind].second.first +
mem[msk | v[ind].second.second][(ind + 1) & 1]);
}
}
return mem[0][0];
}
long long solve(int msk, int ind) {
if (ind == n) {
if (msk == (1 << m) - 1)
return 0;
else
return 4000000000000000000LL;
} else if (mem[msk][ind] != -1)
return mem[msk][ind];
long long& ret = mem[msk][ind];
ret = solve(msk, ind + 1);
if (msk == 0) {
ret = min(ret, v[ind].first * b + v[ind].second.first +
solve(msk | v[ind].second.second, ind + 1));
} else
ret = min(ret,
v[ind].second.first + solve(msk | v[ind].second.second, ind + 1));
return ret;
}
int main() {
cin >> n >> m >> b;
for (typeof((n)-1) i = (0); i <= ((n)-1); i++) {
long long a, d, c, x;
int e = 0;
cin >> a >> d >> c;
for (typeof((c)-1) j = (0); j <= ((c)-1); j++) {
cin >> x;
e |= 1 << (x - 1);
}
v.push_back(
pair<long long, pair<long long, int> >(d, pair<long long, int>(a, e)));
}
sort((v).begin(), (v).end());
reverse((v).begin(), (v).end());
long long d = dp();
if (d == 4000000000000000000LL)
cout << -1 << endl;
else
cout << d << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long dp[(1 << 20) + 5];
struct friends {
int cost, maxv, mask;
bool operator<(const friends& f) const { return maxv < f.maxv; }
};
int main() {
srand((unsigned int)time(NULL));
fill(dp, dp + (1 << 20) + 5, 2e18);
dp[0] = 0;
int n, m, c;
cin >> n >> m >> c;
vector<friends> vec;
for (int i = 0; i < n; i++) {
int cost, nes, sol;
cin >> cost >> nes >> sol;
int mask = 0;
for (int i = 0; i < sol; i++) {
int f;
cin >> f;
mask |= (1 << (f - 1));
}
vec.push_back((friends){cost, nes, mask});
}
sort(vec.begin(), vec.end());
long long res = 2e18;
for (int i = 0; i < vec.size(); i++) {
for (int j = 0; j < 1 << m; j++) {
if (dp[j] == 2e18) continue;
dp[j | vec[i].mask] = min(dp[j | vec[i].mask], dp[j] + vec[i].cost);
}
res = min(res, dp[(1 << m) - 1] + 1LL * c * vec[i].maxv);
}
cout << (res == 2e18 ? -1 : res) << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m, b;
struct fd {
int c, t, s;
bool operator<(const fd& R) const { return t < R.t; }
} a[105];
long long f[2][1 << 20];
void work() {
int i, j, k;
scanf("%d%d%d", &n, &m, &b);
for (i = 0; i < n; ++i) {
scanf("%d%d%d", &a[i].c, &a[i].t, &j);
while (j--) scanf("%d", &k), a[i].s |= 1 << k - 1;
}
long long ans = 1LL << 61;
sort(a, a + n);
int cur = 0, nxt = 1;
for (i = 0; i < 1 << m; ++i) f[0][i] = 1LL << 61;
f[0][0] = 0;
for (i = 0; i < n; ++i) {
for (j = 0; j < 1 << m; ++j) f[nxt][j] = 1LL << 61;
for (j = 0; j < 1 << m; ++j) {
if (f[cur][j] < 1LL << 61) {
f[nxt][j] = min(f[nxt][j], f[cur][j]);
f[nxt][j | a[i].s] = min(f[nxt][j | a[i].s], f[cur][j] + a[i].c);
}
}
ans = min(ans, f[nxt][(1 << m) - 1] + (long long)a[i].t * b);
swap(nxt, cur);
}
if (ans == 1LL << 61) ans = -1;
cout << ans << endl;
}
int main() {
work();
return 0;
}
|
#include <bits/stdc++.h>
#pragma GCC optimize("Ofast,unroll-loops")
using namespace std;
unsigned long long maxi = 1e19;
struct node {
unsigned long long x, k;
int s;
} a[100];
unsigned long long dp[(1 << 20)], b;
bool cmp(node u, node v) { return u.k < v.k; }
unsigned long long ans = maxi;
int n, m;
int main() {
cin >> n >> m >> b;
int t, len;
for (int i = 0; i < n; i++) {
cin >> a[i].x >> a[i].k >> len;
a[i].k *= b;
for (int j = 0; j < len; j++) {
cin >> t;
a[i].s |= (1 << (t - 1));
}
}
sort(a, a + n, cmp);
for (int i = 1; i < (1 << m); i++) dp[i] = maxi;
for (int i = 0; i < n; i++) {
for (int j = (1 << m) - 1;; j--) {
dp[j | a[i].s] = min(dp[j | a[i].s], dp[j] + a[i].x);
if (j == 0) break;
}
if (dp[(1 << m) - 1] < maxi) ans = min(ans, dp[(1 << m) - 1] + a[i].k);
}
if (ans == maxi)
cout << -1;
else
cout << ans;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
struct People {
int mask;
long long money, nMonitor;
} people[111];
bool operator<(const People &a, const People &b) {
return a.nMonitor < b.nMonitor;
}
int nPeople, nProb, monitorCost;
long long f[2][(1 << (20))];
void update(long long &x, long long val) {
if (val < 0) return;
if (x < 0)
x = val;
else
x = min(x, val);
}
int main() {
ios ::sync_with_stdio(false);
cin.tie(NULL);
cout << (fixed) << setprecision(6);
while (cin >> nPeople >> nProb >> monitorCost) {
for (int i = (1), _b = (nPeople); i <= _b; i++) {
people[i].mask = 0;
int can;
cin >> people[i].money >> people[i].nMonitor >> can;
while (can--) {
int u;
cin >> u;
people[i].mask |= (1 << (u - 1));
}
}
sort(people + 1, people + nPeople + 1);
memset(f, -1, sizeof f);
f[0][0] = 0;
long long cur = 0, res = -1;
for (int i = (1), _b = (nPeople); i <= _b; i++) {
for (int mask = 0, _a = ((1 << (nProb))); mask < _a; mask++)
if (f[cur][mask] >= 0) {
update(f[1 - cur][mask | people[i].mask],
f[cur][mask] + people[i].money);
update(f[1 - cur][mask], f[cur][mask]);
}
int mask = (1 << (nProb)) - 1;
if (f[1 - cur][mask] >= 0) {
update(res, f[1 - cur][mask] + people[i].nMonitor * monitorCost);
}
cur = 1 - cur;
}
cout << res << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long m[1 << 22];
int N, M, B;
struct XD {
long long x, k;
int slv;
};
int mm;
bool cmp(const XD &a, const XD &b) { return a.k < b.k; }
vector<XD> p;
int main() {
int c;
scanf(" %d %d %d", &N, &M, &B);
p.resize(N);
for (int i = 0; i < N; i++) {
scanf(" %I64d %I64d %d", &p[i].x, &p[i].k, &mm);
int tmp = 0;
while (mm--) {
scanf(" %d", &c);
tmp |= (1 << (c - 1));
}
p[i].slv = tmp;
}
sort(p.begin(), p.end(), cmp);
memset(m, -1, sizeof(m));
m[0] = 0;
long long ans = -1;
for (int i = 0; i < N; i++) {
for (int S = 0; S < (1 << M); S++) {
if (m[S] != -1) {
if (m[S | p[i].slv] == -1 || m[S | p[i].slv] > m[S] + p[i].x)
m[S | p[i].slv] = m[S] + p[i].x;
}
}
if (m[(1 << M) - 1] != -1)
if (ans == -1 || m[(1 << M) - 1] + B * p[i].k < ans)
ans = m[(1 << M) - 1] + B * p[i].k;
}
printf("%I64d\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long inf = (1LL << 60);
long long dp[1 << 22];
struct node {
int x, k, p;
} f[110];
int cmp(node x, node y) { return x.k < y.k; }
long long ans;
int main() {
int n, m, b;
scanf("%d%d%d", &n, &m, &b);
int l = 1 << m;
for (int i = 1; i <= l; i++) {
dp[i] = inf;
}
int cnt;
for (int i = 1; i <= n; i++) {
f[i].p = 0;
int x;
scanf("%d%d%d", &f[i].x, &f[i].k, &cnt);
for (int j = 0; j < cnt; j++) {
scanf("%d", &x);
f[i].p |= (1 << (x - 1));
}
}
ans = inf;
sort(f + 1, f + n + 1, cmp);
for (int i = 1; i <= n; i++) {
for (int j = 0; j < l; ++j) {
dp[j | f[i].p] = min(dp[j] + f[i].x, dp[j | f[i].p]);
}
ans = min(ans, dp[l - 1] + (long long)f[i].k * b);
}
if (ans >= inf) {
printf("-1\n");
} else {
printf("%lld", ans);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
struct node {
int x, k, mask;
} e[105];
long long dp[2][1 << 20];
int cmp(const node &a, const node &b) { return a.k > b.k; }
int main() {
int i, j, n, m, b, c, x;
while (scanf("%d %d %d", &n, &m, &b) != EOF) {
for (i = 1; i <= n; i++) {
scanf("%d %d %d", &e[i].x, &e[i].k, &c);
e[i].mask = 0;
for (j = 1; j <= c; j++) {
scanf("%d", &x);
e[i].mask |= 1 << x - 1;
}
sort(e + 1, e + n + 1, cmp);
}
for (j = 0; j < (1 << m); j++) dp[0][j] = 1LL << 62;
dp[0][0] = 0;
for (i = 1; i <= n; i++) {
for (j = 0; j < (1 << m); j++) dp[i & 1][j] = dp[(i - 1) & 1][j];
for (j = 0; j < (1 << m); j++)
if (dp[(i - 1) & 1][j] != 1LL << 62) {
long long cost = dp[(i - 1) & 1][j] + e[i].x +
(j == 0 ? (long long)b * e[i].k : 0);
dp[i & 1][j | e[i].mask] = min(dp[i & 1][j | e[i].mask], cost);
}
}
long long ans = dp[n & 1][(1 << m) - 1];
if (ans == 1LL << 62)
printf("-1\n");
else
printf("%I64d\n", ans);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const unsigned long long INF = (unsigned long long)1e19;
const int MAX_N = 100 + 20, MAX_M = (1 << 20) + 20;
unsigned long long dp[MAX_M];
unsigned long long ans;
pair<int, pair<int, int> > xHeK[MAX_N];
int n, m, d;
int main() {
ios::sync_with_stdio(false);
cerr << (long long)1e19 << endl;
cin >> n >> m >> d;
for (int i(0); i < int(n); i++) {
int xi, ki, mi, res = 0;
cin >> xi >> ki >> mi;
for (int j(0); j < int(mi); j++) {
int pi;
cin >> pi;
res |= (1 << (pi - 1));
}
xHeK[i] = make_pair(ki, make_pair(xi, res));
}
sort(xHeK, xHeK + n);
ans = INF;
for (int i(0); i < int((1 << m)); i++) dp[i] = INF;
dp[(1 << m) - 1] = 0;
for (int i(0); i < int(n); i++) {
int xi = xHeK[i].second.first, ki = xHeK[i].first,
val = xHeK[i].second.second;
for (int j((1 << m) - 1); j >= int(0); j--)
dp[j] = min(dp[j | val] + xi, dp[j]);
ans = min(ans, dp[0] + (long long)d * ki);
}
if (ans == INF)
cout << -1;
else
cout << ans;
cout << endl;
return 0;
}
|
#include <bits/stdc++.h>
#pragma GCC optimize("O3")
using namespace std;
const long long inf = 2147383647;
const double pi = 2 * acos(0.0);
const double eps = 1e-9;
struct debugger {
template <typename T>
debugger &operator,(const T &v) {
cerr << v << " ";
return *this;
}
} dbg;
inline long long gcd(long long a, long long b) {
a = ((a) < 0 ? -(a) : (a));
b = ((b) < 0 ? -(b) : (b));
while (b) {
a = a % b;
swap(a, b);
}
return a;
}
long long ext_gcd(long long A, long long B, long long *X, long long *Y) {
long long x2, y2, x1, y1, x, y, r2, r1, q, r;
x2 = 1;
y2 = 0;
x1 = 0;
y1 = 1;
for (r2 = A, r1 = B; r1 != 0;
r2 = r1, r1 = r, x2 = x1, y2 = y1, x1 = x, y1 = y) {
q = r2 / r1;
r = r2 % r1;
x = x2 - (q * x1);
y = y2 - (q * y1);
}
*X = x2;
*Y = y2;
return r2;
}
inline long long modInv(long long a, long long m) {
long long x, y;
ext_gcd(a, m, &x, &y);
if (x < 0) x += m;
return x;
}
inline long long power(long long a, long long p) {
long long res = 1, x = a;
while (p) {
if (p & 1) res = (res * x);
x = (x * x);
p >>= 1;
}
return res;
}
inline long long bigmod(long long a, long long p, long long m) {
long long res = 1 % m, x = a % m;
while (p) {
if (p & 1) res = (res * x) % m;
x = (x * x) % m;
p >>= 1;
}
return res;
}
using namespace std;
template <typename T>
ostream &operator<<(ostream &out, vector<T> v) {
out << "[ ";
for (int i = 0; i < (((int)(v).size())); i++) {
if (i) out << ", ";
out << v[i];
}
out << " ]";
return out;
}
template <typename T1, typename T2>
ostream &operator<<(ostream &out, pair<T1, T2> p) {
out << "( " << p.first << ", " << p.second << ")";
return out;
}
template <typename T>
ostream &operator,(ostream &out, T x) {
out << x << " ";
return out;
}
struct Person {
long long reqMonitor;
long long reqMoney;
int mask;
bool operator<(const Person &other) const {
return reqMonitor < other.reqMonitor;
}
};
int finalMask;
int N, M;
long long monitorCost;
Person friends[107];
long long dpA[1 << 21], dpB[1 << 21];
long long solve() {
sort(friends, friends + N);
finalMask = (1 << M) - 1;
for (int i = 0; i <= finalMask; i++) {
dpA[i] = (1LL << 62);
}
long long *curDPptr = dpA;
long long *nxtDPptr = dpB;
for (int i = N - 1; i >= 0; i--) {
swap(curDPptr, nxtDPptr);
for (int mask = 0; mask <= finalMask; mask++) {
curDPptr[i] = (1LL << 62);
}
for (int mask = 0; mask < finalMask; mask++) {
int newMask = mask | friends[i].mask;
if (newMask == finalMask) {
curDPptr[mask] =
friends[i].reqMoney + friends[i].reqMonitor * monitorCost;
} else {
curDPptr[mask] = friends[i].reqMoney + nxtDPptr[newMask];
}
curDPptr[mask] = ((curDPptr[mask]) < (nxtDPptr[mask]) ? (curDPptr[mask])
: (nxtDPptr[mask]));
}
}
long long ret = curDPptr[0];
if (ret == (1LL << 62)) return -1;
return ret;
}
int main() {
scanf("%d %d %lld", &N, &M, &monitorCost);
int k, x;
for (int i = 0; i < (N); i++) {
scanf("%lld %lld %d", &friends[i].reqMoney, &friends[i].reqMonitor, &k);
friends[i].mask = 0;
while (k--) {
scanf("%d", &x);
x--;
friends[i].mask |= (1 << x);
}
}
printf("%lld\n", solve());
return 0;
}
|
#include <bits/stdc++.h>
const int MAX_N = 100 + 5;
const int MAX_M = 30;
const int MAX_POW_M = (1 << 20) + 10;
const int INF = 0x3f3f3f3f;
const long long INFLL = ((long long)INF << 32) + INF;
long long dp[MAX_POW_M];
struct P {
int money;
int monitor;
int can;
};
P p[MAX_N];
struct CMP_P {
bool operator()(const P& a, const P& b) { return a.monitor < b.monitor; }
};
int main(int argc, char const* argv[]) {
int n, m, b;
scanf("%d %d %d", &n, &m, &b);
for (int i = 1; i <= n; ++i) {
int xi, ki, mi;
scanf("%d %d %d", &xi, &ki, &mi);
int can = 0;
for (int j = 0; j < mi; ++j) {
int cani;
scanf("%d", &cani);
cani -= 1;
can |= (1 << cani);
}
p[i].money = xi;
p[i].monitor = ki;
p[i].can = can;
}
int pow_m = (1 << m);
for (int i = 0; i < pow_m; ++i) {
dp[i] = INFLL;
}
dp[0] = 0;
std::sort(p + 1, p + 1 + n, CMP_P());
long long answer = INFLL;
for (int i = 1; i <= n; ++i) {
int can = p[i].can;
int money = p[i].money;
for (int j = 0; j < pow_m; ++j) {
dp[j] = std::min(dp[j], dp[j & (j ^ can)] + money);
}
answer = std::min(answer, dp[pow_m - 1] + (long long)p[i].monitor * b);
}
if (answer == INFLL) {
answer = -1;
}
printf("%I64d\n", answer);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
struct Node {
int val, num, sta;
} st[110];
int a, b, tot, rest, n, m, c;
bool cmp(const Node &a, const Node &b) { return a.num < b.num; }
unsigned long long dp[1050000], ans;
int main() {
cin >> n >> m >> c;
for (int i = 1; i <= n; i++) {
cin >> st[i].val >> st[i].num >> a;
st[i].sta = 0;
for (int j = 1; j <= a; j++) {
cin >> b;
st[i].sta |= (1 << (b - 1));
}
}
tot = (1 << m) - 1;
sort(st + 1, st + n + 1, cmp);
memset(dp, 0x3f, sizeof(dp));
ans = dp[0];
dp[0] = 0;
for (int i = 1; i <= n; i++) {
for (int sta = 0; sta <= tot; sta++)
dp[sta | st[i].sta] = min(dp[sta | st[i].sta], dp[sta] + st[i].val);
ans = min(ans, dp[tot] + (unsigned long long)st[i].num * c);
}
if (ans == dp[tot + 1])
puts("-1");
else
cout << ans << endl;
return 0;
}
|
#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;
long long int dp[1 << 20][2];
long long int sol[101][20];
long long int mark[101];
long long int inf = 5e18;
bool flag = 0;
struct node {
long long int c, m, k;
int mask;
};
bool comp(node a, node b) { return a.k < b.k; }
node cost[101];
long long int N, M, b;
int main() {
ios_base::sync_with_stdio(0);
long long int i, j, k;
scanf("%lld", &N);
scanf("%lld", &M);
scanf("%lld", &b);
long long int ans = inf;
long long int last = (1 << M);
for (i = 1; i <= N; i++) {
scanf("%lld", &cost[i].c);
scanf("%lld", &cost[i].k);
scanf("%lld", &cost[i].m);
cost[i].mask = 0;
for (j = 0; j < cost[i].m; j++) {
int x;
scanf("%d", &x);
cost[i].mask += (1 << (x - 1));
}
}
sort(cost + 1, cost + N + 1, comp);
for (j = 0; j < last; j++) dp[j][0] = dp[j][1] = inf;
dp[0][0] = 0;
for (i = 1; i <= N; i++) {
dp[0][0] = 0;
for (j = 0; j < last; j++) {
int mask = j | cost[i].mask;
dp[mask][1] = min(dp[mask][1], dp[j][0] + cost[i].c);
}
ans = min(ans, dp[last - 1][1] + cost[i].k * b);
for (j = 0; j < last; j++) dp[j][0] = dp[j][1];
}
if (ans >= inf)
cout << "-1\n";
else
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 105;
int n, m, i, j, k, p, q, x;
pair<int, pair<int, int> > a[N];
long long dp[(1 << 20) + 2], ok[(1 << 20) + 2], cur, b, op;
int main() {
scanf("%d%d", &n, &m);
cin >> b;
for (i = 1; i <= n; i++) {
scanf("%d%d%d", &a[i].second.first, &a[i].first, &k);
for (j = 1; j <= k; j++) {
scanf("%d", &x);
x--;
a[i].second.second |= (1 << x);
}
}
sort(a + 1, a + n + 1);
for (j = 1; j < (1 << m); j++) dp[j] = ok[j] = 2000000000000000000ll;
for (i = 1; i <= n; i++) {
for (j = 0; j < (1 << m) - 1; j++)
if (ok[j] != 2000000000000000000ll) {
x = (j | a[i].second.second);
op = ok[j] + a[i].second.first;
cur = op + b * a[i].first;
dp[x] = ((dp[x]) < (cur) ? (dp[x]) : (cur));
ok[x] = ((ok[x]) < (op) ? (ok[x]) : (op));
}
}
if (dp[(1 << m) - 1] == 2000000000000000000ll)
cout << -1 << endl;
else
cout << dp[(1 << m) - 1] << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
void WA() {
printf("-1\n");
exit(0);
}
struct Friend {
int mask, x, k;
Friend() {}
};
bool operator<(Friend fr1, Friend fr2) { return fr1.k < fr2.k; }
Friend readFriend() {
Friend fr;
int m;
scanf("%d%d%d", &fr.x, &fr.k, &m);
fr.mask = 0;
for (int i = 0; i < m; ++i) {
int v;
scanf("%d", &v);
fr.mask += (1 << (v - 1));
}
return fr;
}
const long long INF = 2000000000000004000ll;
int n, m, b;
Friend frs[200];
long long d[1 << 20];
long long ans;
void updMin(long long &x, long long y) {
if (x > y) x = y;
}
int main() {
scanf("%d%d%d", &n, &m, &b);
for (int i = 0; i < n; ++i) frs[i] = readFriend();
sort(frs, frs + n);
for (int i = 1; i < (1 << m); ++i) d[i] = INF;
d[0] = 0;
ans = INF;
long long dop = 0;
for (int i = 0; i < n; ++i) {
dop = frs[i].k * (long long)b;
if (dop >= ans) break;
for (int j = 0; j < (1 << m); ++j)
updMin(d[j | frs[i].mask], d[j] + frs[i].x);
ans = min(ans, d[(1 << m) - 1] + dop);
}
if (ans == INF) ans = -1;
cout << ans << "\n";
return 0;
}
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.