text
stringlengths 49
983k
|
|---|
#include <bits/stdc++.h>
using namespace std;
template <class T>
void _R(T &x) {
cin >> x;
}
void _R(int &x) { scanf("%d", &x); }
void _R(long long &x) { scanf("%lld", &x); }
void _R(double &x) { scanf("%lf", &x); }
void _R(char &x) { scanf(" %c", &x); }
void _R(char *x) { scanf("%s", x); }
void R() {}
template <class T, class... U>
void R(T &head, U &...tail) {
_R(head);
R(tail...);
}
template <class T>
void _W(const T &x) {
cout << x;
}
void _W(const int &x) { printf("%d", x); }
void _W(const long long &x) { printf("%lld", x); }
void _W(const double &x) { printf("%.16f", x); }
void _W(const char &x) { putchar(x); }
void _W(const char *x) { printf("%s", x); }
template <class T, class U>
void _W(const pair<T, U> &x) {
_W(x.first);
putchar(' ');
_W(x.second);
}
template <class T>
void _W(const vector<T> &x) {
for (auto i = x.begin(); i != x.end(); _W(*i++))
if (i != x.cbegin()) putchar(' ');
}
void W() {}
template <class T, class... U>
void W(const T &head, const U &...tail) {
_W(head);
putchar(sizeof...(tail) ? ' ' : '\n');
W(tail...);
}
int MOD = 1e9 + 7;
void ADD(long long &x, long long v) {
x = (x + v) % MOD;
if (x < 0) x += MOD;
}
const int SIZE = 1e6 + 10;
long long dp[2][10];
template <class T>
void maa(T &x, T y) {
if (x < y) x = y;
}
template <class T>
void mii(T &x, T y) {
if (x > y) x = y;
}
int main() {
int n;
R(n);
memset((dp), -1, sizeof((dp)));
dp[0][0] = 0;
int now = 0, nxt = 1;
while (n--) {
int k;
R(k);
memcpy(dp[nxt], dp[now], sizeof(dp[now]));
vector<long long> AA[4];
for (int j = 0; j < (k); ++j) {
int x, y;
R(x, y);
AA[x].push_back(y);
}
for (int j = (1); j <= (3); ++j)
sort((AA[j]).begin(), (AA[j]).end(), greater<long long>());
for (int i = 0; i < (10); ++i) {
if (dp[now][i] == -1) continue;
for (int j = (1); j <= (3); ++j) {
if (((int)(AA[j]).size()) > 0)
maa(dp[nxt][(i + 1) % 10],
dp[now][i] + (AA[j][0] * (1 + ((i + 1) == 10))));
}
if (((int)(AA[1]).size()) >= 3) {
maa(dp[nxt][(i + 3) % 10], dp[now][i] +
AA[1][0] * (1 + ((i + 3) >= 10)) +
AA[1][1] + AA[1][2]);
}
if (((int)(AA[1]).size()) >= 2) {
maa(dp[nxt][(i + 2) % 10],
dp[now][i] + AA[1][0] * (1 + ((i + 2) >= 10)) + AA[1][1]);
}
if (((int)(AA[1]).size()) >= 1 && ((int)(AA[2]).size()) >= 1) {
maa(dp[nxt][(i + 2) % 10],
dp[now][i] + max(AA[1][0], AA[2][0]) * ((i + 2) >= 10) + AA[1][0] +
AA[2][0]);
}
}
swap(now, nxt);
}
long long an = 0;
for (int i = 0; i < (10); ++i) an = max(an, dp[now][i]);
W(an);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long MAXN = 2e5 + 5;
long long dp[MAXN][11];
long long dp2[5][2];
vector<long long> cards[MAXN][5];
int main() {
long long n;
cin >> n;
for (long long i = 0; i <= n; i++) {
for (long long j = 0; j < 10; j++) {
dp[i][j] = -1e18;
}
}
dp[0][0] = 0;
for (long long i = 0; i < n; i++) {
long long k;
cin >> k;
for (long long j = 0; j < k; j++) {
long long x, y;
cin >> x >> y;
cards[i][x].push_back(y);
}
}
for (long long i = 0; i < n; i++) {
for (long long j = 1; j <= 3; j++) {
long long s;
if (j == 1) {
s = 3;
} else {
s = 1;
}
sort(cards[i][j].begin(), cards[i][j].end());
reverse(cards[i][j].begin(), cards[i][j].end());
while (cards[i][j].size() > s) {
cards[i][j].pop_back();
}
}
}
for (long long i = 0; i < n; i++) {
for (long long j = 0; j < 4; j++) {
for (long long k = 0; k < 2; k++) {
dp2[j][k] = -1e18;
}
}
dp2[0][0] = 0;
vector<pair<long long, long long>> curr;
for (long long j = 1; j <= 3; j++) {
for (auto x : cards[i][j]) {
curr.push_back(make_pair(j, x));
}
}
sort(curr.begin(), curr.end());
do {
long long lim = 3;
long long score = 0;
long long mx = 0;
long long cnt = 0;
for (auto x : curr) {
cnt++;
if (lim < x.first) {
break;
}
lim -= x.first;
mx = max(mx, x.second);
score += x.second;
dp2[cnt][0] = max(dp2[cnt][0], score);
dp2[cnt][1] = max(dp2[cnt][1], score + mx);
}
} while (next_permutation(curr.begin(), curr.end()));
for (long long j = 0; j < 10; j++) {
for (long long k = 0; k <= 3; k++) {
long long nxt = (j + k) % 10;
long long f = 0;
if (j + k >= 10) {
f = 1;
}
dp[i + 1][nxt] = max(dp[i + 1][nxt], dp[i][j] + dp2[k][f]);
}
}
}
long long ans = 0;
for (long long i = 0; i < 10; i++) {
ans = max(ans, dp[n][i]);
}
cout << ans << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
long long n, m, k, y, z, l, i, j, x, r, x2, y2;
long long a[100500], b[500500], c[100500];
long long binpow(long long x, long long y) {
if (y == 0) {
return 1;
}
long long tmp = binpow(x, y / 2);
tmp = tmp * tmp % 998244353;
if (y % 2) {
return x * tmp % 998244353;
}
return tmp;
}
long long inv(long long x) { return binpow(x, 998244353 - 2); }
long long mulg(long long x, long long y) { return x * y % 998244353; }
void add(long long& x, long long y) {
x += y;
if (x >= 998244353) {
x -= 998244353;
}
}
long long dp[200500][11];
vector<long long> g[5];
long long dpr[4];
pair<long long, long long> tmp[4];
long long pos;
int main() {
cin >> n;
for (int i = 0; i <= n; i++) {
for (int j = 0; j <= 10; j++) {
dp[i][j] = -(long long)1e+18;
}
}
dp[0][0] = 0;
for (int i = 0; i < n; i++) {
for (int j = 1; j <= 3; j++) {
g[j].clear();
}
int k;
scanf("%d", &k);
for (int j = 0; j < k; j++) {
int x, y;
scanf("%d %d", &x, &y);
g[x].push_back(y);
}
vector<pair<long long, long long> > pool;
for (int j = 1; j <= 3; j++) {
sort(g[j].begin(), g[j].end());
reverse(g[j].begin(), g[j].end());
if (j == 1) {
for (int k = 0; k < 3 && k < g[j].size(); k++) {
pool.push_back(make_pair(g[j][k], j));
}
} else {
for (int k = 0; k < 1 && k < g[j].size(); k++) {
pool.push_back(make_pair(g[j][k], j));
}
}
}
for (int j = 1; j <= 10; j++) {
dpr[0] = 0;
for (int k = 1; k <= 3; k++) {
dpr[k] = -(long long)1e+18;
}
long long sz = pool.size();
for (int i1 = 0; i1 < sz; i1++) {
tmp[0] = pool[i1];
pos = 1;
for (int i2 = 0; i2 <= sz; i2++) {
if (i2 != sz && i2 != i1) {
tmp[pos++] = pool[i2];
}
for (int i3 = 0; i3 <= sz; i3++) {
if (i3 != sz && i3 != i2 && i3 != i1) {
tmp[pos++] = pool[i3];
}
long long cur_val = 0, cur_w = 0;
for (int k = 0; k < pos; k++) {
if (k + 1 == j) {
cur_val += 2 * tmp[k].first;
} else {
cur_val += tmp[k].first;
}
cur_w += tmp[k].second;
}
if (cur_w <= 3) {
dpr[pos] = max(dpr[pos], cur_val);
}
if (i3 != sz && i3 != i2 && i3 != i1) {
pos--;
}
}
if (i2 != sz && i2 != i1) {
pos--;
}
}
}
for (int k = 0; k <= 3; k++) {
long long cur = dpr[k];
dp[i + 1][(10 - j + k) % 10] =
max(dp[i + 1][(10 - j + k) % 10], dp[i][10 - j] + cur);
}
}
}
long long ans = 0;
for (int i = 0; i < 10; i++) {
ans = max(ans, dp[n][i]);
}
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long inf = 1e17;
void solve() {
int n;
cin >> n;
vector<long long> dp(10, -inf);
dp[0] = 0;
while (n--) {
int k;
cin >> k;
vector<vector<long long>> store(4);
for (int i = 0; i < k; i++) {
int c, d;
cin >> c >> d;
store[c].push_back(d);
}
for (int i = 1; i <= 3; i++)
sort(store[i].begin(), store[i].end(), greater<long long>());
vector<long long> ndp = dp;
for (int rem = 0; rem <= 9; rem++) {
int mul = (rem == 9) ? 2 : 1;
if (store[1].size())
ndp[(rem + 1) % 10] =
max(ndp[(rem + 1) % 10], dp[rem] + mul * store[1][0]);
if (store[2].size())
ndp[(rem + 1) % 10] =
max(ndp[(rem + 1) % 10], dp[rem] + mul * store[2][0]);
if (store[3].size())
ndp[(rem + 1) % 10] =
max(ndp[(rem + 1) % 10], dp[rem] + mul * store[3][0]);
mul = (rem == 8 || rem == 9) ? 2 : 1;
if (store[1].size() > 1)
ndp[(rem + 2) % 10] =
max(ndp[(rem + 2) % 10], dp[rem] + mul * store[1][0] + store[1][1]);
if (store[1].size() && store[2].size())
ndp[(rem + 2) % 10] =
max(ndp[(rem + 2) % 10], dp[rem] + mul * store[1][0] + store[2][0]);
if (store[1].size() && store[2].size())
ndp[(rem + 2) % 10] =
max(ndp[(rem + 2) % 10], dp[rem] + mul * store[2][0] + store[1][0]);
mul = (rem >= 7 && rem <= 9) ? 2 : 1;
if (store[1].size() > 2)
ndp[(rem + 3) % 10] =
max(ndp[(rem + 3) % 10],
dp[rem] + mul * store[1][0] + store[1][1] + store[1][2]);
}
dp.swap(ndp);
}
cout << *max_element(dp.begin(), dp.end()) << "\n";
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
;
cout << fixed << setprecision(20);
;
int t = 1;
for (int i = 1; i <= t; i++) {
solve();
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int next_x[8] = {0, 1, -1, 0, 1, 1, -1, -1};
const int next_y[8] = {1, 0, 0, -1, 1, -1, -1, 1};
const int inf = 2147483647;
const long long linf = 1e15;
int read() {
int t = 0, f = 1;
char ch = getchar();
while (ch < '0' || ch > '9') {
if (ch == '-') f = -1;
ch = getchar();
}
while (ch >= '0' && ch <= '9') {
t = t * 10 + ch - '0';
ch = getchar();
}
return t * f;
}
extern const int MAXN = 200005;
extern const int N = 500000;
bool cmp(long long a, long long b) { return a > b; }
int n, m, k;
long long a[MAXN][4], f[MAXN][10];
long long b[MAXN][4];
int work() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
vector<long long> t[4];
int k;
long long c, d;
scanf("%d", &k);
for (int j = 1; j <= k; j++) scanf("%lld%lld", &c, &d), t[c].push_back(d);
for (int j = 1; j <= 3; j++)
if (!t[j].empty()) sort(t[j].begin(), t[j].end(), cmp);
a[i][0] = 0;
a[i][1] = -1;
for (int j = 1; j <= 3; j++)
if (!t[j].empty()) a[i][1] = max(a[i][1], t[j].front());
a[i][2] = -1;
if (t[1].size() >= 2) a[i][2] = max(a[i][2], t[1][0] + t[1][1]);
if (t[1].size() >= 1 && t[2].size() >= 1)
a[i][2] = max(a[i][2], t[1][0] + t[2][0]);
a[i][3] = -1;
if (t[1].size() >= 3) a[i][3] = t[1][0] + t[1][1] + t[1][2];
b[i][1] = -1;
for (int j = 1; j <= 3; j++)
if (!t[j].empty()) b[i][1] = max(b[i][1], t[j].front() * 2);
b[i][2] = -1;
if (t[1].size() >= 2) b[i][2] = max(b[i][2], t[1][0] * 2 + t[1][1]);
if (t[1].size() >= 1 && t[2].size() >= 1)
b[i][2] = max(b[i][2], max(t[1][0], t[2][0]) * 2 + min(t[1][0], t[2][0]));
b[i][3] = -1;
if (t[1].size() >= 3) b[i][3] = t[1][0] * 2 + t[1][1] + t[1][2];
}
memset(f, -1, sizeof(f)), f[0][0] = 0;
for (int i = 1; i <= n; i++) {
for (int j = 3; j < 10; j++) {
for (int k = 0; k <= 3; k++) {
int pre = (j - k + 10) % 10;
if (f[i - 1][pre] == -1 || a[i][k] == -1) continue;
f[i][j] = max(f[i][j], f[i - 1][pre] + a[i][k]);
}
}
for (int j = 0; j < 3; j++) {
for (int k = 0; k <= j; k++) {
int pre = (j - k + 10) % 10;
if (f[i - 1][pre] == -1 || a[i][k] == -1) continue;
f[i][j] = max(f[i][j], f[i - 1][pre] + a[i][k]);
}
for (int k = j + 1; k <= 3; k++) {
int pre = (j - k + 10) % 10;
if (f[i - 1][pre] == -1 || b[i][k] == -1) continue;
f[i][j] = max(f[i][j], f[i - 1][pre] + b[i][k]);
}
}
}
long long ans = 0;
for (int i = 0; i < 10; i++) ans = max(ans, f[n][i]);
return printf("%lld\n", ans);
}
int main() {
ios::sync_with_stdio(false);
work();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
vector<long long int> vi[5];
vector<pair<int, long long int> > take;
void init() {
if (vi[1].size() >= 1) take.push_back(make_pair(1, vi[1][0]));
if (vi[1].size() >= 2) take.push_back(make_pair(1, vi[1][1]));
if (vi[1].size() >= 3) take.push_back(make_pair(1, vi[1][2]));
if (vi[2].size() >= 1) take.push_back(make_pair(2, vi[2][0]));
if (vi[3].size() >= 1) take.push_back(make_pair(3, vi[3][0]));
}
long long int dp[200200][10];
long long int dp1[5], dp2[5];
int main() {
int n, i, j, k, x, ans, m, curr;
long long int y;
scanf("%d", &n);
for (i = 0; i < n; i++)
for (j = 0; j < 10; j++) dp[i][j] = -1e18;
dp[0][0] = 0;
int it = 1;
int temp = n;
while (n--) {
scanf("%d", &m);
for (i = 1; i <= 3; i++) vi[i].clear();
for (i = 1; i <= m; i++) {
scanf("%d %lld", &x, &y);
vi[x].push_back(y);
}
for (i = 1; i <= 3; i++)
sort(vi[i].begin(), vi[i].end(), greater<long long int>());
take.clear();
init();
for (i = 0; i <= 3; i++) {
dp1[i] = -1e18;
dp2[i] = -1e18;
}
dp1[0] = dp2[0] = 0;
sort(take.begin(), take.end());
do {
int turns = 3;
long long int maxi = 0;
long long int sum = 0;
int play = 0;
for (auto x : take) {
if (x.first <= turns) {
play++;
turns -= x.first;
maxi = max(maxi, x.second);
sum += x.second;
dp1[play] = max(dp1[play], sum);
dp2[play] = max(dp2[play], sum + maxi);
}
}
} while (next_permutation(take.begin(), take.end()));
for (i = 0; i < 10; i++) {
for (j = 0; j <= 3; j++) {
int next = (i + j) % 10;
if (i + j > 9) {
dp[it][next] = max(dp[it][next], dp[it - 1][i] + dp2[j]);
} else {
dp[it][next] = max(dp[it][next], dp[it - 1][i] + dp1[j]);
}
}
}
it++;
}
long long int rose = -1e18;
for (i = 0; i < 10; i++) rose = max(rose, dp[temp][i]);
cout << rose << "\n";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, k, c[200010], d[200010];
long long f[200010][12], ans, g[5][5], h[12];
int main() {
memset(f, 0xc0, sizeof f);
f[0][0] = 0;
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
scanf("%d", &k);
memset(g, 0xc0, sizeof g);
memset(h, 0xc0, sizeof h);
for (int j = 1; j <= k; j++) {
scanf("%d%d", &c[j], &d[j]);
if (c[j] == 1) {
if (d[j] > g[1][1]) {
g[1][3] = g[1][2];
g[1][2] = g[1][1];
g[1][1] = d[j];
} else if (d[j] > g[1][2]) {
g[1][3] = g[1][2];
g[1][2] = d[j];
} else if (d[j] > g[1][3])
g[1][3] = d[j];
} else if (c[j] == 2) {
if (d[j] > g[2][1]) g[2][1] = d[j];
} else {
if (d[j] > g[3][1]) g[3][1] = d[j];
}
for (int l = 0; l < 10; l++) {
if (f[i - 1][l] < 0) continue;
if (g[1][1] > 0) {
if (g[1][2] > 0) {
if (g[1][3] > 0) {
if (l > 6)
h[l - 7] = max(
h[l - 7], f[i - 1][l] + (g[1][1] << 1) + g[1][2] + g[1][3]);
else
h[l + 3] =
max(h[l + 3], f[i - 1][l] + g[1][1] + g[1][2] + g[1][3]);
}
if (l > 7)
h[l - 8] = max(h[l - 8], f[i - 1][l] + (g[1][1] << 1) + g[1][2]);
else
h[l + 2] = max(h[l + 2], f[i - 1][l] + g[1][1] + g[1][2]);
}
if (g[2][1] > 0) {
if (l > 7)
h[l - 8] = max(h[l - 8], f[i - 1][l] + g[1][1] + g[2][1] +
max(g[1][1], g[2][1]));
else
h[l + 2] = max(h[l + 2], f[i - 1][l] + g[1][1] + g[2][1]);
}
if (l > 8)
h[l - 9] = max(h[l - 9], f[i - 1][l] + (g[1][1] << 1));
else
h[l + 1] = max(h[l + 1], f[i - 1][l] + g[1][1]);
}
if (g[2][1] > 0) {
if (l > 8)
h[l - 9] = max(h[l - 9], f[i - 1][l] + (g[2][1] << 1));
else
h[l + 1] = max(h[l + 1], f[i - 1][l] + g[2][1]);
}
if (g[3][1] > 0) {
if (l > 8)
h[l - 9] = max(h[l - 9], f[i - 1][l] + (g[3][1] << 1));
else
h[l + 1] = max(h[l + 1], f[i - 1][l] + g[3][1]);
}
}
}
for (int j = 0; j < 10; j++) {
f[i][j] = max(h[j], f[i - 1][j]);
}
}
for (int i = 0; i < 10; i++) ans = max(ans, f[n][i]);
printf("%lld\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, k;
long long t[5][5], f1[11], f2[11], maxx[5][5];
bool cmp(long long u, long long v) { return u > v; }
int main() {
cin >> n;
memset(f1, -1, sizeof(f1));
memset(f2, -1, sizeof(f2));
f1[0] = 0;
while (n--) {
cin >> k;
vector<long long> a[5];
memset(t, -1, sizeof(t));
for (int i = 1; i <= k; ++i) {
int cost;
long long dam;
cin >> cost >> dam;
a[cost].push_back(dam);
}
for (int i = 1; i <= 3; ++i) sort(a[i].begin(), a[i].end(), cmp);
if (a[1].size() >= 1) {
t[1][1] = a[1][0];
maxx[1][1] = a[1][0];
}
if (a[2].size() >= 1) {
t[2][1] = a[2][0];
maxx[2][1] = a[2][0];
}
if (a[1].size() >= 2) {
t[2][2] = a[1][0] + a[1][1];
maxx[2][2] = a[1][0];
}
if (a[3].size() >= 1) {
t[3][1] = a[3][0];
maxx[3][1] = a[3][0];
}
if (a[1].size() >= 1 && a[2].size() >= 1) {
t[3][2] = a[1][0] + a[2][0];
maxx[3][2] = max(a[1][0], a[2][0]);
}
if (a[1].size() >= 3) {
t[3][3] = a[1][0] + a[1][1] + a[1][2];
maxx[3][3] = a[1][0];
}
for (int i = 0; i <= 9; ++i) {
if (f1[i] == -1) continue;
for (int j = 1; j <= 3; ++j) {
for (int ii = 1; ii <= 3; ++ii) {
if (t[j][ii] == -1) continue;
int numcard = i + ii;
if (numcard >= 10)
f2[numcard % 10] =
max(f2[numcard % 10], f1[i] + t[j][ii] + maxx[j][ii]);
else
f2[numcard] = max(f2[numcard], f1[i] + t[j][ii]);
}
}
}
for (int i = 0; i <= 9; ++i) {
f1[i] = max(f1[i], f2[i]);
f2[i] = -1;
}
}
long long ans = 0;
for (int i = 0; i <= 9; ++i) ans = max(ans, f1[i]);
cout << ans;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long int mod = 1000000007;
vector<pair<long long int, long long int> > moves[200010];
long long int dp[200010][11];
int main() {
ios_base::sync_with_stdio(0);
cin.tie(NULL);
cout.tie(NULL);
long long int n, k, c, p;
cin >> n;
for (long long int i = 0; i < n + 1; i++)
for (long long int j = 0; j < 11; j++) dp[i][j] = -1;
for (long long int i = 0; i < n; i++) {
cin >> k;
for (long long int j = 0; j < k; j++) {
cin >> c >> p;
moves[i].push_back({c, p});
}
}
dp[0][0] = 0;
for (long long int i = 0; i < n; i++) {
vector<long long int> turn_move[3];
for (auto it : moves[i]) turn_move[(it.first - 1) % 3].push_back(it.second);
for (long long int j = 0; j < 3; j++)
sort(turn_move[j].begin(), turn_move[j].end(), greater<long long int>());
for (long long int j = 0; j <= 3; j++) {
for (long long int k = 0; k <= 3; k++) {
for (long long int l = 0; l <= 3; l++) {
if (j + 2 * k + 3 * l > 3 or turn_move[0].size() < j or
turn_move[1].size() < k or turn_move[2].size() < l)
continue;
vector<long long int> avail;
long long int sum = 0, card_count = j + k + l;
for (long long int m = 0; m < j; m++) {
sum += turn_move[0][m];
avail.push_back(turn_move[0][m]);
}
for (long long int m = 0; m < k; m++) {
sum += turn_move[1][m];
avail.push_back(turn_move[1][m]);
}
for (long long int m = 0; m < l; m++) {
sum += turn_move[2][m];
avail.push_back(turn_move[2][m]);
}
sort(avail.begin(), avail.end(), greater<long long int>());
for (long long int m = 0; m < 10; m++) {
dp[i][card_count] = max(dp[i][card_count], sum);
if (i) {
if (dp[i - 1][m] != -1) {
if (card_count + m >= 10) {
sum += avail[0];
avail[0] *= 2;
}
dp[i][(card_count + m) % 10] =
max(dp[i - 1][m] + sum, dp[i][(card_count + m) % 10]);
if (card_count + m >= 10) {
avail[0] /= 2;
sum -= avail[0];
}
}
}
}
}
}
}
}
long long int ans = 0;
for (long long int j = 0; j < 11; j++) {
for (long long int i = 0; i < n; i++) {
ans = max(ans, dp[i][j]);
}
}
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long dp[200005][10], dp2[6][2];
int main() {
memset(dp, 0xcf, sizeof(dp));
dp[0][0] = 0;
int n;
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
memset(dp2, 0xcf, sizeof(dp2));
dp2[0][0] = 0;
int k, c, d;
scanf("%d", &k);
vector<int> v[4];
vector<pair<int, int> > v2;
for (int j = 1; j <= k; j++) {
scanf("%d%d", &c, &d);
v[c].push_back(d);
}
for (int j = 1; j <= 3; j++) {
sort(v[j].begin(), v[j].end());
reverse(v[j].begin(), v[j].end());
int s = (j == 1 ? 3 : 1);
while (v[j].size() > s) v[j].pop_back();
}
for (int j = 1; j <= 3; j++)
for (int k = 0; k < v[j].size(); k++) v2.push_back(make_pair(j, v[j][k]));
do {
int now = 3, cnt = 0;
long long mx = 0, sum = 0;
for (int j = 0; j < v2.size(); j++) {
cnt++;
if (now < v2[j].first) break;
now -= v2[j].first;
sum += v2[j].second;
mx = max(mx, (long long)v2[j].second);
dp2[cnt][0] = max(dp2[cnt][0], sum);
dp2[cnt][1] = max(dp2[cnt][1], sum + mx);
}
} while (next_permutation(v2.begin(), v2.end()));
for (int j = 0; j < 10; j++) {
for (int k = 0; k <= 3; k++)
dp[i][(j + k) % 10] = max(dp[i][(j + k) % 10],
dp[i - 1][j] + dp2[k][j + k >= 10 ? 1 : 0]);
}
}
long long ans = 0;
for (int j = 0; j < 10; j++) ans = max(ans, dp[n][j]);
printf("%lld\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int inf = 0x3f3f3f3f;
const int _inf = 0xc0c0c0c0;
const long long INF = 0x3f3f3f3f3f3f3f3f;
const long long _INF = 0xc0c0c0c0c0c0c0c0;
const long long mod = (int)1e9 + 7;
long long gcd(long long a, long long b) { return b ? gcd(b, a % b) : a; }
long long ksm(long long a, long long b, long long mod) {
int ans = 1;
while (b) {
if (b & 1) ans = (ans * a) % mod;
a = (a * a) % mod;
b >>= 1;
}
return ans;
}
long long inv2(long long a, long long mod) { return ksm(a, mod - 2, mod); }
void exgcd(long long a, long long b, long long &x, long long &y, long long &d) {
if (!b) {
d = a;
x = 1;
y = 0;
} else {
exgcd(b, a % b, y, x, d);
y -= x * (a / b);
}
}
const int MAX_N = 200025;
long long dp[MAX_N][10];
priority_queue<long long> q[15];
long long k[200025], tmp[15], maxx[15];
int main() {
int n;
scanf("%d", &n);
memset(dp, -1, sizeof(dp));
dp[0][0] = 0;
for (int i = 1; i <= n; ++i) {
int c, d;
while (!q[1].empty()) q[1].pop();
while (!q[2].empty()) q[2].pop();
while (!q[3].empty()) q[3].pop();
scanf("%d", &k[i]);
for (int j = 1; j <= k[i]; ++j) {
scanf("%d%d", &c, &d);
q[c].push(d);
}
for (int j = 0; j < 10; ++j) dp[i][j] = dp[i - 1][j];
for (int j = 1; j <= 6; ++j) tmp[j] = -inf;
if (!q[1].empty()) tmp[1] = q[1].top();
if (!q[2].empty()) tmp[2] = q[2].top();
if (!q[3].empty()) tmp[3] = q[3].top();
if (q[1].size() >= 2) {
long long now = q[1].top();
q[1].pop();
tmp[4] = q[1].top() + now;
maxx[4] = max(q[1].top(), now);
q[1].push(now);
}
if (!q[1].empty() && !q[2].empty()) {
maxx[5] = max(q[1].top(), q[2].top());
tmp[5] = q[1].top() + q[2].top();
}
if (q[1].size() >= 3) {
maxx[6] = 0;
tmp[6] = q[1].top();
maxx[6] = max(maxx[6], q[1].top());
q[1].pop();
tmp[6] += q[1].top();
maxx[6] = max(maxx[6], q[1].top());
q[1].pop();
tmp[6] += q[1].top();
maxx[6] = max(maxx[6], q[1].top());
q[1].pop();
}
if (tmp[1] != -inf) {
for (int j = 1; j <= 9; ++j)
if (dp[i - 1][j - 1] != -1)
dp[i][j] = max(dp[i][j], dp[i - 1][j - 1] + tmp[1]);
if (dp[i - 1][9] != -1)
dp[i][0] = max(dp[i][0], dp[i - 1][9] + tmp[1] * 2);
}
if (tmp[2] != -inf) {
for (int j = 1; j <= 9; ++j)
if (dp[i - 1][j - 1] != -1)
dp[i][j] = max(dp[i][j], dp[i - 1][j - 1] + tmp[2]);
if (dp[i - 1][9] != -1)
dp[i][0] = max(dp[i][0], dp[i - 1][9] + tmp[2] * 2);
}
if (tmp[3] != -inf) {
for (int j = 1; j <= 9; ++j)
if (dp[i - 1][j - 1] != -1)
dp[i][j] = max(dp[i][j], dp[i - 1][j - 1] + tmp[3]);
if (dp[i - 1][9] != -1)
dp[i][0] = max(dp[i][0], dp[i - 1][9] + tmp[3] * 2);
}
if (tmp[4] != -inf) {
for (int j = 2; j <= 9; ++j)
if (dp[i - 1][j - 2] != -1)
dp[i][j] = max(dp[i][j], dp[i - 1][j - 2] + tmp[4]);
if (dp[i - 1][9] != -1)
dp[i][1] = max(dp[i][1], dp[i - 1][9] + tmp[4] + maxx[4]);
if (dp[i - 1][8] != -1)
dp[i][0] = max(dp[i][0], dp[i - 1][8] + tmp[4] + maxx[4]);
}
if (tmp[5] != -inf) {
for (int j = 2; j <= 9; ++j)
if (dp[i - 1][j - 2] != -1)
dp[i][j] = max(dp[i][j], dp[i - 1][j - 2] + tmp[5]);
if (dp[i - 1][9] != -1)
dp[i][1] = max(dp[i][1], dp[i - 1][9] + tmp[5] + maxx[5]);
if (dp[i - 1][8] != -1)
dp[i][0] = max(dp[i][0], dp[i - 1][8] + tmp[5] + maxx[5]);
}
if (tmp[6] != -inf) {
for (int j = 3; j <= 9; ++j)
if (dp[i - 1][j - 3] != -1)
dp[i][j] = max(dp[i][j], dp[i - 1][j - 3] + tmp[6]);
if (dp[i - 1][9] != -1)
dp[i][2] = max(dp[i][2], dp[i - 1][9] + tmp[6] + maxx[6]);
if (dp[i - 1][8] != -1)
dp[i][1] = max(dp[i][1], dp[i - 1][8] + tmp[6] + maxx[6]);
if (dp[i - 1][7] != -1)
dp[i][0] = max(dp[i][0], dp[i - 1][7] + tmp[6] + maxx[6]);
}
}
long long ans = 0;
for (int i = 0; i < 10; ++i) ans = max(ans, dp[n][i]);
printf("%lld\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const double eps = 1e-8;
const double PI = acos(-1.0);
const int Mod = 1000000007;
const int INF = 0x3f3f3f3f;
const long long LL_INF = 0x3f3f3f3f3f3f3f3f;
const int maxn = 2e5 + 10;
long long dp[maxn][10];
vector<int> v[4];
int main() {
int n, num;
scanf("%d", &n);
memset(dp, -1, sizeof(dp));
dp[0][0] = 0;
for (int i = 1; i <= n; i++) {
scanf("%d", &num);
for (int j = 1; j <= 3; j++) v[j].clear();
for (int j = 1; j <= num; j++) {
int x, y;
scanf("%d%d", &x, &y);
v[x].push_back(y);
}
for (int j = 1; j <= 3; j++) sort(v[j].begin(), v[j].end(), greater<int>());
for (int j = 0; j <= 9; j++) {
dp[i][j] = dp[i - 1][j];
if (dp[i - 1][(j - 1 + 10) % 10] != -1 && (int)v[3].size() >= 1) {
if (j == 0)
dp[i][j] =
max(dp[i][j], dp[i - 1][(j - 1 + 10) % 10] + 2LL * v[3][0]);
else
dp[i][j] = max(dp[i][j], dp[i - 1][(j - 1 + 10) % 10] + v[3][0]);
}
if (dp[i - 1][(j - 1 + 10) % 10] != -1 && (int)v[1].size() >= 1) {
if (j == 0)
dp[i][j] =
max(dp[i][j], dp[i - 1][(j - 1 + 10) % 10] + 2LL * v[1][0]);
else
dp[i][j] = max(dp[i][j], dp[i - 1][(j - 1 + 10) % 10] + v[1][0]);
}
if (dp[i - 1][(j - 1 + 10) % 10] != -1 && (int)v[2].size() >= 1) {
if (j == 0)
dp[i][j] =
max(dp[i][j], dp[i - 1][(j - 1 + 10) % 10] + 2LL * v[2][0]);
else
dp[i][j] = max(dp[i][j], dp[i - 1][(j - 1 + 10) % 10] + v[2][0]);
}
if (dp[i - 1][(j - 2 + 10) % 10] != -1 && (int)v[1].size() >= 1 &&
(int)v[2].size() >= 1) {
if (j == 0 || j == 1)
dp[i][j] =
max(dp[i][j], dp[i - 1][(j - 2 + 10) % 10] +
max(v[1][0], v[2][0]) + v[1][0] + v[2][0]);
else
dp[i][j] =
max(dp[i][j], dp[i - 1][(j - 2 + 10) % 10] + v[1][0] + v[2][0]);
}
if (dp[i - 1][(j - 2 + 10) % 10] != -1 && (int)v[1].size() >= 2) {
if (j == 0 || j == 1)
dp[i][j] = max(
dp[i][j], dp[i - 1][(j - 2 + 10) % 10] + 2LL * v[1][0] + v[1][1]);
else
dp[i][j] =
max(dp[i][j], dp[i - 1][(j - 2 + 10) % 10] + v[1][0] + v[1][1]);
}
if (dp[i - 1][(j - 3 + 10) % 10] != -1 && (int)v[1].size() >= 3) {
if (j == 0 || j == 1 || j == 2)
dp[i][j] = max(dp[i][j], dp[i - 1][(j - 3 + 10) % 10] +
2LL * v[1][0] + v[1][1] + v[1][2]);
else
dp[i][j] = max(dp[i][j], dp[i - 1][(j - 3 + 10) % 10] + v[1][0] +
v[1][1] + v[1][2]);
}
}
}
long long ans = 0;
for (int i = 0; i <= 9; i++) ans = max(ans, dp[n][i]);
printf("%lld\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
constexpr int MOD = 1e9 + 7;
constexpr int MAXN = 2e6 + 10;
using ll = long long;
int N, M, K, T;
ll f[MAXN][10];
struct Rounds {
vector<pair<int, int>> cards;
} rnds[MAXN];
void Extract(int r, vector<vector<int>>& v) {
multiset<int> s[4];
for (auto& p : rnds[r].cards) {
s[p.first].emplace(p.second);
}
int t = 0;
if (!s[1].empty()) t = max(t, *s[1].rbegin());
if (!s[2].empty()) t = max(t, *s[2].rbegin());
if (!s[3].empty()) t = max(t, *s[3].rbegin());
v[1].emplace_back(t);
if (!s[1].empty()) {
if (s[1].size() >= 2) {
int a = *(++s[1].rbegin()), b = *s[1].rbegin();
if (!s[2].empty()) {
int c = *s[2].rbegin();
if (c > a) {
v[2].emplace_back(min(b, c));
v[2].emplace_back(max(b, c));
} else {
v[2].emplace_back(a);
v[2].emplace_back(b);
}
} else {
v[2].emplace_back(a);
v[2].emplace_back(b);
}
} else {
if (!s[2].empty()) {
int a = *s[1].rbegin(), b = *s[2].rbegin();
v[2].emplace_back(min(a, b));
v[2].emplace_back(max(a, b));
}
}
}
if (s[1].size() >= 3) {
auto it = s[1].rbegin();
int c = *it++;
int b = *it++;
int a = *it++;
v[3].emplace_back(a);
v[3].emplace_back(b);
v[3].emplace_back(c);
}
}
ll Solution() {
memset(f, -1, sizeof(f));
f[0][0] = 0;
for (int i = (int)0; i < (int)N; ++i) {
memcpy(f[i + 1], f[i], sizeof(f[i]));
vector<vector<int>> choices(4);
Extract(i, choices);
for (int j = (int)0; j < (int)10; ++j) {
if (f[i][j] == -1) continue;
for (int k = (int)1; k < (int)4; ++k) {
if (!choices[k].empty()) {
ll g = accumulate(choices[k].begin(), choices[k].end(), 0LL);
int t = j + k;
if (t >= 10) {
t %= 10;
g += choices[k].back();
}
f[i + 1][t] = max(f[i + 1][t], f[i][j] + g);
}
}
}
}
ll ans = *max_element(f[N], f[N] + 10);
return ans;
}
int main() {
ios::sync_with_stdio(false);
cin.tie(nullptr), cout.tie(nullptr);
while (cin >> N) {
int c, d;
for (int i = (int)0; i < (int)N; ++i) {
cin >> M;
for (int j = (int)0; j < (int)M; ++j) {
cin >> c >> d;
rnds[i].cards.emplace_back(c, d);
}
}
cout << Solution() << '\n';
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <class T>
void PVecPrint(vector<T>& v) {
for (int i = 0; i < (int)v.size(); i++)
cout << v[i].first << "," << v[i].second << ' ';
cout << '\n';
}
template <class T>
void VecPrint(vector<T>& v) {
for (int i = 0; i < v.size(); i++) cout << v[i] << ' ';
cout << '\n';
}
vector<pair<long long int, long long int> > func(vector<pair<int, int> >& c) {
vector<pair<long long int, long long int> > ans;
vector<vector<int> > v(4);
for (int i = 0; i < c.size(); i++) v[c[i].first].push_back(c[i].second);
for (int i = 1; i < 4; i++) sort(v[i].begin(), v[i].end(), greater<int>());
long long int p1 = 0 * 1LL;
for (int i = 1; i < 4; i++) {
if (v[i].size() > 0) p1 = max(p1, v[i][0] * 1LL);
}
ans.push_back({p1, 2 * 1LL * p1});
vector<int> t;
for (int i = 0; i < min(2, (int)v[1].size()); i++) t.push_back(v[1][i]);
if (v[2].size() > 0) t.push_back(v[2][0]);
if (t.size() > 1) {
sort(t.begin(), t.end(), greater<int>());
long long int p2 = t[0] * 1LL + t[1], p21 = 2 * 1LL * t[0] + t[1];
ans.push_back({p2, p21});
} else
ans.push_back({-1, -1});
if (v[1].size() > 2) {
long long int p3 = v[1][0] * 1LL + v[1][1] + v[1][2];
long long int p31 = 2 * 1LL * v[1][0] + v[1][1] + v[1][2];
ans.push_back({p3, p31});
} else
ans.push_back({-1, -1});
return ans;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
;
int n;
cin >> n;
vector<vector<pair<int, int> > > v(n);
for (int i = 0; i < n; i++) {
int k;
cin >> k;
v[i].resize(k);
for (int j = 0; j < k; j++) cin >> v[i][j].first >> v[i][j].second;
}
vector<vector<pair<long long int, long long int> > > imp(n);
for (int i = 0; i < n; i++) imp[i] = func(v[i]);
long long int dp[n + 1][10];
for (int i = 0; i <= n; i++)
for (int j = 0; j < 10; j++) dp[i][j] = -1;
dp[0][0] = 0;
for (int i = 1; i <= n; i++) {
for (int j = 0; j < 10; j++) {
if (dp[i - 1][j] == -1) continue;
for (int k = 0; k < imp[i - 1].size(); k++) {
if (imp[i - 1][k].first == -1) continue;
long long int t = j + k + 1 >= 10 ? dp[i - 1][j] + imp[i - 1][k].second
: dp[i - 1][j] + imp[i - 1][k].first;
int ind = (j + k + 1) % 10;
dp[i][ind] = max(dp[i][ind], t);
}
}
for (int j = 0; j < 10; j++) dp[i][j] = max(dp[i][j], dp[i - 1][j]);
}
long long int ans = 0;
for (int i = 0; i < 10; i++) ans = max(ans, dp[n][i]);
cout << ans << '\n';
}
|
#include <bits/stdc++.h>
using namespace std;
const long long inf = 10000000000000000ll;
int n;
long long f[4][2], dp[200009][10];
vector<long long> c[4];
bool cmp(long long i, long long j) { return i > j; }
int main() {
scanf("%d", &n);
memset(dp, -0x3f, sizeof(dp));
dp[0][0] = 0;
for (int i = 1; i <= n; ++i) {
int m, x, y;
scanf("%d", &m);
for (int j = 1; j <= 3; ++j) c[j].clear();
for (int j = 1; j <= m; ++j) {
scanf("%d%d", &x, &y);
c[x].push_back(1ll * y);
}
for (int j = 1; j <= 3; ++j) sort(c[j].begin(), c[j].end(), cmp);
memset(f, -0x3f, sizeof(f));
if (c[3].empty()) c[3].push_back(-inf);
if (c[2].empty()) c[2].push_back(-inf);
while (c[1].size() < 3) c[1].push_back(-inf);
f[1][0] = max(c[3][0], max(c[2][0], c[1][0]));
f[1][1] = max(c[3][0], max(c[2][0], c[1][0])) << 1;
f[2][0] = max(c[2][0] + c[1][0], c[1][0] + c[1][1]);
f[2][1] = max(max(c[2][0], c[1][0]) * 2 + min(c[2][0], c[1][0]),
c[1][0] * 2 + c[1][1]);
f[3][0] = c[1][0] + c[1][1] + c[1][2];
f[3][1] = c[1][0] * 2 + c[1][1] + c[1][2];
f[0][0] = 0;
for (int mod = 0; mod <= 9; ++mod) {
for (int j = 0; j <= 3; ++j) {
int nex = (mod + j) % 10, flag = 0;
if (nex < mod) flag = 1;
dp[i][nex] = max(dp[i][nex], dp[i - 1][mod] + f[j][flag]);
}
}
}
long long ans = 0;
for (int i = 0; i < 10; ++i) ans = max(ans, dp[n][i]);
printf("%lld\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
long long n, i, j, k, a, b, x, t, c, d, dmax, id, ans;
cin >> n;
vector<vector<tuple<long long, long long, long long>>> plist(n + 1);
for (i = 1; i <= n; i++) {
cin >> x;
vector<vector<long long>> clist(4);
for (j = 0; j < x; j++) {
cin >> c >> d;
clist[c].push_back(d);
}
for (j = 1; j <= 3; j++) sort(clist[j].rbegin(), clist[j].rend());
plist[i].push_back({0, 0, 0});
if (clist[1].size() > 0) plist[i].push_back({1, clist[1][0], clist[1][0]});
if (clist[2].size() > 0) plist[i].push_back({1, clist[2][0], clist[2][0]});
if (clist[3].size() > 0) plist[i].push_back({1, clist[3][0], clist[3][0]});
if ((clist[1].size() > 0) && (clist[2].size() > 0))
plist[i].push_back(
{2, clist[1][0] + clist[2][0], max(clist[1][0], clist[2][0])});
if (clist[1].size() > 1)
plist[i].push_back(
{2, clist[1][0] + clist[1][1], max(clist[1][0], clist[1][1])});
if (clist[1].size() > 2)
plist[i].push_back({3, clist[1][0] + clist[1][1] + clist[1][2],
max(clist[1][0], max(clist[1][1], clist[1][2]))});
}
vector<vector<long long>> dp(n + 1, vector<long long>(10, -(1LL << 60)));
dp[0][0] = 0;
for (i = 0; i < n; i++) {
for (j = 0; j < 10; j++) {
for (auto p : plist[i + 1]) {
tie(c, d, dmax) = p;
x = dp[i][j] + d;
if (j + c >= 10) x += dmax;
id = (j + c) % 10;
dp[i + 1][id] = max(dp[i + 1][id], x);
}
}
}
ans = 0;
for (i = 0; i < 10; i++) ans = max(ans, dp[n][i]);
cout << ans << "\n";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long int n, md[200010][10], td[200010][10], cnt[10], memo[200010][10];
long long int dp(long long int pos, long long int kartu) {
long long int ret, temp;
if (pos == n) return 0;
if (memo[pos][kartu] != -1) return memo[pos][kartu];
ret = dp(pos + 1, kartu);
for (long long int p = 0; p < 6; p++) {
if (md[pos][p] < 1) continue;
temp = dp(pos + 1, (kartu + cnt[p]) % 10) + td[pos][p];
if (kartu + cnt[p] > 9) temp += md[pos][p];
ret = max(ret, temp);
}
memo[pos][kartu] = ret;
return ret;
}
using namespace std;
int main() {
long long int k, c, d, ans, x, y, z;
vector<long long int> dam[5];
scanf("%lld", &n);
for (long long int i = 0; i < n; i++) {
scanf("%lld", &k);
for (long long int j = 1; j < 4; j++) dam[j].clear();
for (long long int j = 0; j < k; j++) {
scanf("%lld %lld", &c, &d);
dam[c].push_back(d);
}
for (long long int j = 1; j < 4; j++) sort(dam[j].rbegin(), dam[j].rend());
md[i][0] = md[i][1] = md[i][2] = md[i][3] = md[i][4] = md[i][5] = 0;
x = dam[1].size();
y = dam[2].size();
z = dam[3].size();
if (x > 0) td[i][0] = md[i][0] = dam[1][0];
if (x > 1) {
md[i][1] = dam[1][0];
td[i][1] = dam[1][0] + dam[1][1];
}
if (x > 2) {
md[i][2] = dam[1][0];
td[i][2] = dam[1][0] + dam[1][1] + dam[1][2];
}
if (y > 0) td[i][3] = md[i][3] = dam[2][0];
if ((y > 0) && (x > 0)) {
td[i][4] = dam[1][0] + dam[2][0];
md[i][4] = max(dam[1][0], dam[2][0]);
}
if (z > 0) td[i][5] = md[i][5] = dam[3][0];
}
cnt[0] = cnt[3] = cnt[5] = 1;
cnt[1] = cnt[4] = 2;
cnt[2] = 3;
memset(memo, -1, sizeof memo);
ans = dp(0, 0);
printf("%lld\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
vector<pair<long long, long long> > ev[200005];
bool cmp(long long a, long long b) { return a > b; }
long long n;
void init() {
scanf("%lld", &n);
for (long long turns = 1; turns <= n; ++turns) {
vector<long long> G[5];
long long c;
scanf("%lld", &c);
while (c--) {
long long types;
long long attack;
scanf("%lld %lld", &types, &attack);
G[types].push_back(attack);
}
for (long long i = 1; i <= 3; ++i) sort(G[i].begin(), G[i].end(), cmp);
for (long long i = 0; i < min(3LL, (long long)G[1].size()); ++i)
ev[turns].push_back(make_pair(1, G[1][i]));
for (long long i = 0; i < min(1LL, (long long)G[2].size()); ++i)
ev[turns].push_back(make_pair(2, G[2][i]));
for (long long i = 0; i < min(1LL, (long long)G[3].size()); ++i)
ev[turns].push_back(make_pair(3, G[3][i]));
}
}
long long dp[200005][10];
long long cal(long long turns, long long ith) {
if (turns == 0) {
if (ith == 0)
return 0;
else
return -0x3f3f3f3f3f3f3f3f;
}
if (dp[turns][ith] != -1) return dp[turns][ith];
long long ret = -0x3f3f3f3f3f3f3f3f;
long long sz = ev[turns].size();
for (long long i = 0; i < (1 << sz); ++i) {
long long fees = 0;
long long attack = 0;
long long num = 0;
long long mx = 0;
for (long long j = 0; j < sz; ++j) {
if (i & (1 << j)) {
++num;
fees += ev[turns][j].first;
attack += ev[turns][j].second;
mx = max(mx, ev[turns][j].second);
}
}
if (fees > 3) continue;
if (ith - num < 0) attack += mx;
ret = max(ret, cal(turns - 1, (ith - num + 10) % 10) + attack);
}
dp[turns][ith] = ret;
return ret;
}
int32_t main() {
memset(dp, -1, sizeof(dp));
init();
long long ans = -0x3f3f3f3f3f3f3f3f;
for (long long ith = 0; ith < 10; ++ith) ans = max(ans, cal(n, ith));
printf("%lld\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long int max(long long int a, long long int b) {
if (a > b)
return a;
else
return b;
}
long long int min(long long int a, long long int b) {
if (a < b)
return a;
else
return b;
}
const int dx[4] = {-1, 1, 0, 0};
const int dy[4] = {0, 0, -1, 1};
int XX[] = {-1, -1, -1, 0, 0, 1, 1, 1};
int YY[] = {-1, 0, 1, -1, 1, -1, 0, 1};
vector<vector<pair<long long int, long long int> > > vec;
long long int c, d;
long long int dp[500005][12];
long long int func(long long int ind, long long int c2) {
if (ind >= vec.size()) return 0;
if (dp[ind][c2] != -1) return dp[ind][c2];
long long int count = -9000000000000000000;
count = max(count, func(ind + 1, c2));
long long int maxi = -9000000000000000000;
for (int k = 0; k < vec[ind].size(); k++) {
if (vec[ind][k].first == 1) maxi = max(maxi, vec[ind][k].second);
}
if (maxi != -9000000000000000000) {
if (c2 == 9) {
count = max(count, maxi * 2 + func(ind + 1, 0));
} else
count = max(count, maxi + func(ind + 1, c2 + 1));
}
long long int maxi1 = -9000000000000000000, maxi2 = -9000000000000000000;
long long int maxi3 = -9000000000000000000, maxi7 = -9000000000000000000;
vector<long long int> vec7;
for (int k = 0; k < vec[ind].size(); k++) {
if (vec[ind][k].first == 1) {
vec7.push_back(vec[ind][k].second);
if (vec[ind][k].second > maxi1) {
maxi2 = maxi1;
maxi1 = vec[ind][k].second;
} else if (vec[ind][k].second > maxi2) {
maxi2 = vec[ind][k].second;
}
}
if (vec[ind][k].first == 2) {
maxi3 = max(maxi3, vec[ind][k].second);
}
if (vec[ind][k].first == 3) maxi7 = max(maxi7, vec[ind][k].second);
}
if (vec7.size() >= 3) {
sort(vec7.begin(), vec7.end());
reverse(vec7.begin(), vec7.end());
if (c2 == 7) {
count = max(count, vec7[0] * 2 + vec7[1] + vec7[2] + func(ind + 1, 0));
} else if (c2 == 8) {
count = max(count, vec7[0] * 2 + vec7[1] + vec7[2] + func(ind + 1, 1));
} else if (c2 == 9)
count = max(count, vec7[0] * 2 + vec7[1] + vec7[2] + func(ind + 1, 2));
else
count = max(count, vec7[0] + vec7[1] + vec7[2] + func(ind + 1, c2 + 3));
}
if (maxi7 != -9000000000000000000) {
if (c2 == 9) {
count = max(count, maxi7 * 2 + func(ind + 1, 0));
} else
count = max(count, maxi7 + func(ind + 1, c2 + 1));
}
if (maxi1 != -9000000000000000000 && maxi2 != -9000000000000000000) {
if (c2 == 8) {
count = max(count, maxi1 * 2 + maxi2 + func(ind + 1, 0));
} else if (c2 == 9) {
count = max(count, maxi1 * 2 + maxi2 + func(ind + 1, 1));
} else {
count = max(count, maxi1 + maxi2 + func(ind + 1, c2 + 2));
}
}
if (maxi3 != -9000000000000000000) {
if (c2 == 9) {
count = max(count, maxi3 * 2 + func(ind + 1, 0));
} else
count = max(count, maxi3 + func(ind + 1, c2 + 1));
}
if (maxi != -9000000000000000000 && maxi3 != -9000000000000000000) {
long long int maxi5 = max(maxi, maxi3), maxi6 = min(maxi, maxi3);
if (c2 == 8) {
count = max(count, maxi5 * 2 + maxi6 + func(ind + 1, 0));
} else if (c2 == 9) {
count = max(count, maxi5 * 2 + maxi6 + func(ind + 1, 1));
} else
count = max(count, maxi5 + maxi6 + func(ind + 1, c2 + 2));
}
return dp[ind][c2] = count;
}
int main() {
memset(dp, -1, sizeof(dp));
ios_base::sync_with_stdio(false), cin.tie(NULL), cout.tie(NULL);
long long int t, n, i, j, k;
cin >> n;
for (i = 0; i < n; i++) {
vector<pair<long long int, long long int> > vec2;
cin >> k;
for (j = 0; j < k; j++) {
cin >> c >> d;
vec2.push_back(make_pair(c, d));
}
vec.push_back(vec2);
}
long long int ans = func(0, 0);
cout << ans;
}
|
#include <bits/stdc++.h>
using namespace std;
const int inf = 0x3f3f3f3f;
const int _inf = 0xc0c0c0c0;
const long long INF = 0x3f3f3f3f3f3f3f3f;
const long long _INF = 0xc0c0c0c0c0c0c0c0;
const long long mod = (int)1e9 + 7;
long long gcd(long long a, long long b) { return b ? gcd(b, a % b) : a; }
long long ksm(long long a, long long b, long long mod) {
int ans = 1;
while (b) {
if (b & 1) ans = (ans * a) % mod;
a = (a * a) % mod;
b >>= 1;
}
return ans;
}
long long inv2(long long a, long long mod) { return ksm(a, mod - 2, mod); }
void exgcd(long long a, long long b, long long &x, long long &y, long long &d) {
if (!b) {
d = a;
x = 1;
y = 0;
} else {
exgcd(b, a % b, y, x, d);
y -= x * (a / b);
}
}
const int MAX_N = 200025;
long long dp[MAX_N][10];
priority_queue<long long> q[15];
long long k[200025], tmp[15], maxx[15];
int main() {
int n;
scanf("%d", &n);
memset(dp, -1, sizeof(dp));
dp[0][0] = 0;
for (int i = 1; i <= n; ++i) {
int c, d;
while (!q[1].empty()) q[1].pop();
while (!q[2].empty()) q[2].pop();
while (!q[3].empty()) q[3].pop();
scanf("%d", &k[i]);
for (int j = 1; j <= k[i]; ++j) {
scanf("%d%d", &c, &d);
q[c].push(d);
}
for (int j = 0; j < 10; ++j) dp[i][j] = dp[i - 1][j];
for (int j = 1; j <= 6; ++j) tmp[j] = -inf;
if (!q[1].empty()) tmp[1] = q[1].top();
if (!q[2].empty()) tmp[2] = q[2].top();
if (!q[3].empty()) tmp[3] = q[3].top();
if (q[1].size() >= 2) {
long long now = q[1].top();
q[1].pop();
tmp[4] = q[1].top() + now;
maxx[4] = max(q[1].top(), now);
q[1].push(now);
}
if (!q[1].empty() && !q[2].empty()) {
maxx[5] = max(q[1].top(), q[2].top());
tmp[5] = q[1].top() + q[2].top();
}
if (q[1].size() >= 3) {
maxx[6] = 0;
tmp[6] = q[1].top();
maxx[6] = max(maxx[6], q[1].top());
q[1].pop();
tmp[6] += q[1].top();
maxx[6] = max(maxx[6], q[1].top());
q[1].pop();
tmp[6] += q[1].top();
maxx[6] = max(maxx[6], q[1].top());
q[1].pop();
}
if (tmp[1] != -inf) {
for (int j = 1; j <= 9; ++j)
if (dp[i - 1][j - 1] != -1)
dp[i][j] = max(dp[i][j], dp[i - 1][j - 1] + tmp[1]);
if (dp[i - 1][9] != -1)
dp[i][0] = max(dp[i][0], dp[i - 1][9] + tmp[1] * 2);
}
if (tmp[2] != -inf) {
for (int j = 1; j <= 9; ++j)
if (dp[i - 1][j - 1] != -1)
dp[i][j] = max(dp[i][j], dp[i - 1][j - 1] + tmp[2]);
if (dp[i - 1][9] != -1)
dp[i][0] = max(dp[i][0], dp[i - 1][9] + tmp[2] * 2);
}
if (tmp[3] != -inf) {
for (int j = 1; j <= 9; ++j)
if (dp[i - 1][j - 1] != -1)
dp[i][j] = max(dp[i][j], dp[i - 1][j - 1] + tmp[3]);
if (dp[i - 1][9] != -1)
dp[i][0] = max(dp[i][0], dp[i - 1][9] + tmp[3] * 2);
}
if (tmp[4] != -inf) {
for (int j = 2; j <= 9; ++j)
if (dp[i - 1][j - 2] != -1)
dp[i][j] = max(dp[i][j], dp[i - 1][j - 2] + tmp[4]);
if (dp[i - 1][9] != -1)
dp[i][1] = max(dp[i][1], dp[i - 1][9] + tmp[4] + maxx[4]);
if (dp[i - 1][8] != -1)
dp[i][0] = max(dp[i][0], dp[i - 1][8] + tmp[4] + maxx[4]);
}
if (tmp[5] != -inf) {
for (int j = 2; j <= 9; ++j)
if (dp[i - 1][j - 2] != -1)
dp[i][j] = max(dp[i][j], dp[i - 1][j - 2] + tmp[5]);
if (dp[i - 1][9] != -1)
dp[i][1] = max(dp[i][1], dp[i - 1][9] + tmp[5] + maxx[5]);
if (dp[i - 1][8] != -1)
dp[i][0] = max(dp[i][0], dp[i - 1][8] + tmp[5] + maxx[5]);
}
if (tmp[6] != -inf) {
for (int j = 3; j <= 9; ++j)
if (dp[i - 1][j - 3] != -1)
dp[i][j] = max(dp[i][j], dp[i - 1][j - 3] + tmp[6]);
if (dp[i - 1][9] != -1)
dp[i][2] = max(dp[i][2], dp[i - 1][9] + tmp[6] + maxx[6]);
if (dp[i - 1][8] != -1)
dp[i][1] = max(dp[i][1], dp[i - 1][8] + tmp[6] + maxx[6]);
if (dp[i - 1][7] != -1)
dp[i][0] = max(dp[i][0], dp[i - 1][7] + tmp[6] + maxx[6]);
}
}
long long ans = 0;
for (int i = 0; i < 10; ++i) ans = max(ans, dp[n][i]);
printf("%lld\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
vector<long long> ms(10, -1e18);
ms[0] = 0;
for (int k, i = 0; i < n; i++) {
vector<long long> nms(10, -1e18);
cin >> k;
multiset<int> d1;
int d2 = 0, d3 = 0;
int c, d;
for (int j = 0; j < k; j++) {
cin >> c >> d;
if (c == 1) {
d1.insert(d);
if (d1.size() > 3) d1.erase(d1.begin());
} else if (c == 2)
d2 = max(d2, d);
else
d3 = max(d3, d);
}
vector<pair<int, int> > bestd;
for (int x : d1) bestd.push_back(make_pair(1, x));
if (d2 > 0) bestd.push_back(make_pair(2, d2));
if (d3 > 0) bestd.push_back(make_pair(3, d3));
for (int j = 0; j < 10; j++) {
nms[j] = max(nms[j], ms[j]);
for (int i1 = 0; i1 < bestd.size(); i1++)
nms[(j + 1) % 10] = max(nms[(j + 1) % 10],
ms[j] + bestd[i1].second * ((j >= 9) ? 2 : 1));
for (int i1 = 0; i1 < bestd.size(); i1++) {
for (int i2 = i1 + 1; i2 < bestd.size(); i2++) {
if (bestd[i1].first + bestd[i2].first <= 3)
nms[(j + 2) % 10] = max(
nms[(j + 2) % 10], ms[j] + bestd[i1].second + bestd[i2].second +
max(bestd[i1].second, bestd[i2].second) *
((j >= 8) ? 1 : 0));
}
}
for (int i1 = 0; i1 < bestd.size(); i1++) {
for (int i2 = i1 + 1; i2 < bestd.size(); i2++) {
for (int i3 = i2 + 1; i3 < bestd.size(); i3++) {
if (bestd[i1].first + bestd[i2].first + bestd[i3].first <= 3)
nms[(j + 3) % 10] =
max(nms[(j + 3) % 10],
ms[j] + bestd[i1].second + bestd[i2].second +
bestd[i3].second +
max(bestd[i1].second,
max(bestd[i2].second, bestd[i3].second)) *
((j >= 7) ? 1 : 0));
}
}
}
}
for (int j = 0; j < 10; j++) ms[j] = nms[j];
}
long long ans = 0;
for (int j = 0; j < 10; j++) ans = max(ans, ms[j]);
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n;
vector<int> card[200005][4];
long long dp[200005][10], dp2[4][2], ans;
int main() {
for (int i = 0; i < 200005; i++)
for (int j = 0; j < 10; j++) dp[i][j] = -1e18;
dp[0][0] = 0;
scanf("%d", &n);
for (int i = 0; i < n; i++) {
int k;
scanf("%d", &k);
for (int j = 1; j <= k; j++) {
int c, d;
scanf("%d%d", &c, &d);
card[i][c].push_back(d);
}
}
for (int i = 0; i < n; i++) {
for (int j = 1; j <= 3; j++) {
int s = (j == 1 ? 3 : 1);
sort(card[i][j].begin(), card[i][j].end());
reverse(card[i][j].begin(), card[i][j].end());
while (card[i][j].size() > s) card[i][j].pop_back();
}
}
for (int i = 0; i < n; i++) {
for (int j = 0; j <= 3; j++)
for (int k = 0; k < 2; k++) dp2[j][k] = -1e18;
dp2[0][0] = 0;
vector<pair<int, int> > cur;
for (int j = 1; j <= 3; j++) {
int sz = card[i][j].size();
for (int k = 0; k < sz; k++) cur.push_back(make_pair(j, card[i][j][k]));
}
sort(cur.begin(), cur.end());
do {
int mana = 3;
long long score = 0, mx = 0;
int cnt = 0;
int sz = cur.size();
for (int j = 0; j < sz; j++) {
pair<int, int> x = cur[j];
cnt++;
if (mana < x.first) break;
mana -= x.first;
mx = max(mx, (long long)x.second);
score += x.second;
dp2[cnt][0] = max(dp2[cnt][0], score);
dp2[cnt][1] = max(dp2[cnt][1], score + mx);
}
} while (next_permutation(cur.begin(), cur.end()));
for (int j = 0; j < 10; j++) {
for (int k = 0; k <= 3; k++) {
int nxt = (j + k) % 10;
int f = (j + k >= 10 ? 1 : 0);
dp[i + 1][nxt] = max(dp[i + 1][nxt], dp[i][j] + dp2[k][f]);
}
}
}
for (int i = 0; i <= 9; i++) ans = max(ans, dp[n][i]);
printf("%lld\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
constexpr int inf = 1e9 + 7;
constexpr ll longinf = 1LL << 60;
constexpr ll mod = 1e9 + 7;
ll dp[202020][10];
int main() {
cin.tie(nullptr);
ios::sync_with_stdio(false);
int n;
cin >> n;
dp[0][0] = 0;
for (int i = (int)(0); i < (int)(9); ++i) dp[0][i + 1] = -longinf;
for (int i = (int)(0); i < (int)(n); ++i) {
int k;
cin >> k;
vector<ll> v1(3, -longinf), v2(1, -longinf), v3(1, -longinf);
for (int j = (int)(0); j < (int)(k); ++j) {
int c, d;
cin >> c >> d;
if (c == 1) v1.push_back(d);
if (c == 2) v2.push_back(d);
if (c == 3) v3.push_back(d);
}
sort(v1.rbegin(), v1.rend());
sort(v2.rbegin(), v2.rend());
sort(v3.rbegin(), v3.rend());
for (int j = (int)(0); j < (int)(10); ++j) {
dp[i + 1][j] = dp[i][j];
}
for (int j = (int)(0); j < (int)(10); ++j) {
dp[i + 1][(j + 1) % 10] =
max(dp[i + 1][(j + 1) % 10],
dp[i][j] + (j == 9 ? 2 : 1) * max({v3[0], v2[0], v1[0]}));
}
for (int j = (int)(0); j < (int)(10); ++j) {
dp[i + 1][(j + 2) % 10] =
max(dp[i + 1][(j + 2) % 10],
dp[i][j] + v1[0] + v1[1] + (j >= 8 ? v1[0] : 0));
dp[i + 1][(j + 2) % 10] =
max(dp[i + 1][(j + 2) % 10],
dp[i][j] + v1[0] + v2[0] + (j >= 8 ? max(v1[0], v2[0]) : 0));
}
for (int j = (int)(0); j < (int)(10); ++j) {
dp[i + 1][(j + 3) % 10] =
max(dp[i + 1][(j + 3) % 10],
dp[i][j] + v1[0] + v1[1] + v1[2] + (j >= 7 ? v1[0] : 0));
}
}
ll ans = 0;
for (int i = (int)(0); i < (int)(10); ++i) ans = max(ans, dp[n][i]);
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int d4i[4] = {-1, 0, 1, 0}, d4j[4] = {0, 1, 0, -1};
const int d8i[8] = {-1, -1, 0, 1, 1, 1, 0, -1},
d8j[8] = {0, 1, 1, 1, 0, -1, -1, -1};
void DBG() { cout << "]" << endl; }
template <class H, class... T>
void DBG(H h, T... t) {
cout << to_string(h);
if (sizeof...(t)) cout << ", ";
DBG(t...);
}
template <class T>
bool umin(T& a, const T& b) {
return b < a ? a = b, 1 : 0;
}
template <class T>
bool umax(T& a, const T& b) {
return a < b ? a = b, 1 : 0;
}
int n;
vector<pair<long long, long long>> cards[(long long)(200002)],
need[(long long)(200002)];
vector<array<long long, 3>> valid[(long long)(200002)];
void prepare() {
for (int i = (1), _c = (n); i <= _c; ++i) {
vector<int> cnt(4, 0);
sort((cards[i]).begin(), (cards[i]).end(),
[](pair<long long, long long> a, pair<long long, long long> b) {
return a.first < b.first ||
(a.first == b.first && a.second > b.second);
});
for (auto j : cards[i]) {
if (j.first == 1 && cnt[j.first] >= 3) continue;
if (j.first == 2 && cnt[j.first] >= 1) continue;
if (j.first == 3 && cnt[j.first] >= 1) continue;
need[i].push_back(j);
++cnt[j.first];
}
}
for (int i = (1), _c = (n); i <= _c; ++i) {
for (int j = (0), _c = ((1ll << (((int)((need[i]).size())))) - 1); j <= _c;
++j) {
long long cost = 0, ma = 0, dame = 0;
for (int k = (0), _c = (((int)((need[i]).size())) - 1); k <= _c; ++k) {
if ((((j) >> (k)) & 1ll)) {
cost += need[i][k].first;
dame += need[i][k].second;
umax(ma, need[i][k].second);
}
}
if (cost <= 3) {
int bonus = __builtin_popcountll(j);
valid[i].push_back({bonus, dame, ma});
}
}
}
}
long long dp[(long long)(200002)][11];
void test_case() {
cin >> n;
for (int i = (1), _c = (n); i <= _c; ++i) {
int k;
cin >> k;
cards[i].assign(k, {0, 0});
for (int j = (0), _c = (k - 1); j <= _c; ++j)
cin >> cards[i][j].first >> cards[i][j].second;
}
prepare();
for (auto i : valid[1]) umax(dp[1][i[0]], i[1]);
for (int i = (1), _c = (n - 1); i <= _c; ++i)
for (int j = (0), _c = (10); j <= _c; ++j)
if (dp[i][j] || j == 0) {
for (auto k : valid[i + 1]) {
int nxtNum = j + k[0];
if (nxtNum < 10)
umax(dp[i + 1][nxtNum], dp[i][j] + k[1]);
else
umax(dp[i + 1][nxtNum % 10], dp[i][j] + k[1] + k[2]);
}
}
long long ans = 0;
for (int i = (0), _c = (10); i <= _c; ++i) umax(ans, dp[n][i]);
cout << ans << "\n";
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
auto time = clock();
int test = 1;
while (test--) {
test_case();
}
cerr << "[It took " << fixed << setprecision(3)
<< double(clock() - time) / CLOCKS_PER_SEC << "s]"
<< "\n";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long inf = 4e18;
int n;
long long dp[2][10];
vector<long long> a[3];
int main() {
ios_base::sync_with_stdio(false);
cout.tie(0);
cin.tie(0);
cin >> n;
for (int i = 1; i < 10; ++i) dp[0][i] = -inf;
for (int i = 0; i < n; ++i) {
int k;
cin >> k;
for (int i = 0; i < 3; ++i) a[i].clear();
for (int i = 0; i < k; ++i) {
int c;
long long d;
cin >> c >> d;
--c;
a[c].push_back(d);
}
a[0].push_back(0);
a[0].push_back(0);
a[1].push_back(0);
a[2].push_back(0);
for (int i = 0; i < 3; ++i)
sort(a[i].begin(), a[i].end(), greater<long long>());
for (int j = 0; j < 10; ++j) dp[i & 1 ^ 1][j] = dp[i & 1][j];
long long dmg1, dmg2, dmg3;
dmg1 = max({a[0][0], a[1][0], a[2][0]});
for (int j = 0; j < 9; ++j)
dp[i & 1 ^ 1][j + 1] = max(dp[i & 1 ^ 1][j + 1], dp[i & 1][j] + dmg1);
dp[i & 1 ^ 1][0] = max(dp[i & 1 ^ 1][0], dp[i & 1][9] + 2 * dmg1);
if (a[0].size() - 2 + a[1].size() - 1 >= 2 && a[0].size() - 2 >= 1) {
dmg1 = max(a[0][0], a[1][0]);
dmg2 = max(min(a[0][0], a[1][0]), a[0][1]);
for (int j = 0; j < 8; ++j)
dp[i & 1 ^ 1][j + 2] =
max(dp[i & 1 ^ 1][j + 2], dp[i & 1][j] + dmg1 + dmg2);
dp[i & 1 ^ 1][0] = max(dp[i & 1 ^ 1][0], dp[i & 1][8] + 2 * dmg1 + dmg2);
dp[i & 1 ^ 1][1] = max(dp[i & 1 ^ 1][1], dp[i & 1][9] + 2 * dmg1 + dmg2);
}
if (a[0].size() - 2 >= 3) {
dmg1 = a[0][0];
dmg2 = a[0][1];
dmg3 = a[0][2];
for (int j = 0; j < 7; ++j)
dp[i & 1 ^ 1][j + 3] =
max(dp[i & 1 ^ 1][j + 3], dp[i & 1][j] + dmg1 + dmg2 + dmg3);
dp[i & 1 ^ 1][0] =
max(dp[i & 1 ^ 1][0], dp[i & 1][7] + 2 * dmg1 + dmg2 + dmg3);
dp[i & 1 ^ 1][1] =
max(dp[i & 1 ^ 1][1], dp[i & 1][8] + 2 * dmg1 + dmg2 + dmg3);
dp[i & 1 ^ 1][2] =
max(dp[i & 1 ^ 1][2], dp[i & 1][9] + 2 * dmg1 + dmg2 + dmg3);
}
}
long long ans = dp[n & 1][0];
for (int i = 1; i < 10; ++i) ans = max(ans, dp[n & 1][i]);
cout << ans << '\n';
}
|
#include <bits/stdc++.h>
using namespace std;
const long long N = 2e5 + 7;
const long long M = 15;
const long long xinc[] = {0, 0, 1, -1};
const long long yinc[] = {1, -1, 0, 0};
const long double PI = acos(-1.0);
long long n, dp[N][M], k, c, d;
void comp(long long k, vector<long long>& one, vector<long long>& two,
vector<long long>& thr, long long& m1, vector<long long>& m2,
vector<long long>& m3) {
m1 = -1;
if (k >= 1) {
m1 = max(!thr.empty() ? thr[0] : -1, m1);
m1 = max(!two.empty() ? two[0] : -1, m1);
m1 = max(!one.empty() ? one[0] : -1, m1);
}
if (k >= 2) {
if (two.size() > 0) {
vector<long long> tmp;
tmp.push_back(two[0]);
if (one.size() >= 1) tmp.push_back(one[0]);
if (one.size() >= 2) tmp.push_back(one[1]);
sort((tmp).begin(), (tmp).end(), greater<long long>());
if (tmp.size() >= 2) m2.push_back(tmp[0]), m2.push_back(tmp[1]);
} else {
if (one.size() >= 2) m2.push_back(one[0]), m2.push_back(one[1]);
}
}
if (k >= 3) {
if (one.size() >= 3) {
m3.push_back(one[0]), m3.push_back(one[1]), m3.push_back(one[2]);
}
}
}
void solve() {
memset(dp, -1, sizeof dp);
cin >> n;
dp[0][0] = 0;
for (long long i = 1; i <= n; i++) {
cin >> k;
vector<long long> v[4], m2, m3;
for (long long i = 0; i < k; i++) {
cin >> c >> d;
v[c].push_back(d);
}
for (long long i = 1; i <= 3; i++)
sort((v[i]).begin(), (v[i]).end(), greater<long long>());
long long m1;
comp(k, v[1], v[2], v[3], m1, m2, m3);
if (m1 != -1) {
for (long long j = 0; j <= 9; j++)
if (dp[i - 1][j] != -1) {
dp[i][(j + 1) % 10] = dp[i - 1][j] + ((j + 1 != 10) ? m1 : 2 * m1);
}
}
if (m2.size() == 2) {
for (long long j = 0; j <= 9; j++)
if (dp[i - 1][j] != -1) {
long long last = dp[i][(j + 2) % 10];
dp[i][(j + 2) % 10] = dp[i - 1][j] + m2[0] + m2[1];
if (j + 1 == 10 || j + 2 == 10) dp[i][(j + 2) % 10] += m2[0];
dp[i][(j + 2) % 10] = max(last, dp[i][(j + 2) % 10]);
}
}
if (m3.size() == 3) {
for (long long j = 0; j <= 9; j++)
if (dp[i - 1][j] != -1) {
long long last = dp[i][(j + 3) % 10];
dp[i][(j + 3) % 10] = dp[i - 1][j] + m3[0] + m3[1] + m3[2];
if (j + 1 == 10 || j + 2 == 10 || j + 3 == 10)
dp[i][(j + 3) % 10] += m3[0];
dp[i][(j + 3) % 10] = max(last, dp[i][(j + 3) % 10]);
}
}
for (long long j = 0; j <= 9; j++) {
dp[i][j] = max(dp[i][j], dp[i - 1][j]);
}
}
long long ans = 0;
for (long long i = 0; i <= 9; i++) ans = max(ans, dp[n][i]);
cout << ans << '\n';
}
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
long long t;
t = 1;
while (t--) solve();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
array<vector<ll>, 4> a[200000];
ll bst[200000][4];
ll dp[200000][10];
ll crd[200000][4];
int n;
ll f(int i, int t) {
if (i == n) return 0;
ll& sol = dp[i][t];
if (sol != -1) return sol;
sol = f(i + 1, t);
for (int j = 1; j <= 3; ++j) {
if (bst[i][j]) {
ll c = 0;
if (t + j >= 10) c = crd[i][j];
sol = max(sol, c + bst[i][j] + f(i + 1, (t + j) % 10));
}
}
return sol;
}
int main() {
cin >> n;
for (int i = 0; i < n; ++i) {
int k;
cin >> k;
for (int j = 0; j < k; ++j) {
int c, d;
cin >> c >> d;
a[i][c].push_back(d);
}
}
for (int i = 0; i < n; ++i) {
for (int j = 1; j <= 3; ++j)
sort(begin(a[i][j]), end(a[i][j]), greater<ll>());
if (a[i][1].size() >= 1) {
bst[i][1] = a[i][1][0];
crd[i][1] = a[i][1][0];
}
if (a[i][1].size() >= 2) {
bst[i][2] = a[i][1][0] + a[i][1][1];
crd[i][2] = max(a[i][1][0], a[i][1][1]);
}
if (a[i][1].size() >= 3) {
bst[i][3] = a[i][1][0] + a[i][1][1] + a[i][1][2];
crd[i][3] = max(a[i][1][0], max(a[i][1][1], a[i][1][2]));
}
if (a[i][2].size() >= 1) {
ll nc = a[i][2][0];
if (nc > bst[i][1]) {
bst[i][1] = nc;
crd[i][1] = a[i][2][0];
}
}
if (a[i][1].size() >= 1 && a[i][2].size() >= 1) {
ll nc = a[i][1][0] + a[i][2][0];
if (nc > bst[i][2]) {
bst[i][2] = nc;
crd[i][2] = max(a[i][1][0], a[i][2][0]);
;
}
}
if (a[i][3].size() >= 1) {
ll nc = a[i][3][0];
if (nc > bst[i][1]) {
bst[i][1] = nc;
crd[i][1] = a[i][3][0];
}
}
}
memset(dp, -1, sizeof dp);
cout << f(0, 0);
}
|
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
int T;
cin >> T;
vector<ll> B(10, -1);
B[0] = 0;
while (T--) {
int N;
cin >> N;
ll a1 = 0, a2 = 0, a3 = 0, a4 = 0, b = 0, c = 0;
for (int i = 0; i < N; i++) {
ll x, y;
cin >> x >> y;
if (x == 1) {
a4 = y;
if (a3 < a4) swap(a3, a4);
if (a2 < a3) swap(a2, a3);
if (a1 < a2) swap(a1, a2);
} else if (x == 2)
b = max(b, y);
else
c = max(c, y);
}
ll x1 = max({a1, b, c}), y1 = x1;
ll x3 = (a3 > 0) * (a1 + a2 + a3), y3 = a1;
ll x2 = 0, y2 = 0;
if (a2) x2 = a1 + a2, y2 = a1;
if (a1 && a2 < b) x2 = a1 + b, y2 = max(a1, b);
vector<ll> C = B;
for (int i = 0; i < 10; i++)
if (B[i] >= 0) {
C[(i + 1) % 10] =
max(C[(i + 1) % 10], B[i] + (x1) + (i + 1 >= 10) * (y1));
if (x2)
C[(i + 2) % 10] =
max(C[(i + 2) % 10], B[i] + (x2) + (i + 2 >= 10) * (y2));
if (x3)
C[(i + 3) % 10] =
max(C[(i + 3) % 10], B[i] + (x3) + (i + 3 >= 10) * (y3));
}
B = C;
}
cout << *max_element(begin(B), end(B));
}
|
#include <bits/stdc++.h>
using namespace std;
const int INF = 0x3f3f3f3f;
template <class T>
void read(T &val) {
T x = 0;
T bz = 1;
char c;
for (c = getchar(); (c < '0' || c > '9') && c != '-'; c = getchar())
;
if (c == '-') {
bz = -1;
c = getchar();
}
for (; c >= '0' && c <= '9'; c = getchar()) x = x * 10 + c - 48;
val = x * bz;
}
const int mod = 998244353;
const int maxn = 1e6 + 10;
int n, m, a[maxn], q, t, k;
long long dp[maxn][11];
void mx(long long &x, long long y) {
if (x < y) x = y;
}
int main() {
read(n);
memset(dp, -1, sizeof(dp));
dp[0][0] = 0;
for (int i = 1; i <= n; i++) {
int k;
read(k);
vector<int> c[4];
for (int j = 1; j <= k; j++) {
int x, y;
read(x);
read(y);
c[x].push_back(y);
}
for (int j = 1; j <= 3; j++) {
sort(c[j].begin(), c[j].end());
reverse(c[j].begin(), c[j].end());
}
long long d[10][4];
memset(d, -1, sizeof(d));
int sz1 = min(int(c[1].size()), 3);
for (int j = 0; j <= 9; j++) {
if (dp[i - 1][j] == -1) continue;
if (sz1 >= 1)
mx(d[j][1], dp[i - 1][j] + c[1][0] + ((j + 1) > 9 ? c[1][0] : 0));
if (sz1 >= 2)
mx(d[j][2],
dp[i - 1][j] + c[1][0] + c[1][1] + ((j + 2) > 9 ? c[1][0] : 0));
if (sz1 >= 3)
mx(d[j][3], dp[i - 1][j] + c[1][0] + c[1][1] + c[1][2] +
((j + 3) > 9 ? c[1][0] : 0));
if (c[2].size())
mx(d[j][1], dp[i - 1][j] + c[2][0] + ((j + 1) > 9 ? c[2][0] : 0));
if (c[3].size())
mx(d[j][1], dp[i - 1][j] + c[3][0] + ((j + 1) > 9 ? c[3][0] : 0));
if (sz1 && c[2].size())
mx(d[j][2], dp[i - 1][j] + c[1][0] + c[2][0] +
((j + 2) > 9 ? max(c[2][0], c[1][0]) : 0));
mx(d[j][0], dp[i - 1][j]);
}
for (int j = 0; j <= 9; j++) {
if (dp[i - 1][j] == -1) continue;
for (int k = 0; k <= 3; k++) {
if (d[j][k] == -1) continue;
mx(dp[i][(j + k) % 10], d[j][k]);
}
}
}
long long ans = 0;
for (int i = 0; i <= 9; i++) mx(ans, dp[n][i]);
printf("%lld\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long n, k, c, d, ans, dp[1000005][10];
multiset<long long> s[5];
multiset<long long>::iterator it;
int main() {
scanf("%lld", &n);
dp[0][0] = 0;
for (long long i = 1; i < 10; i++) dp[0][i] = -100000000000000007;
for (long long i = 1; i <= n; i++) {
scanf("%lld", &k);
for (long long i = 1; i <= 3; i++) s[i].clear();
for (long long j = 1; j <= k; j++) {
scanf("%lld %lld", &c, &d);
s[c].insert(d);
if ((int)s[c].size() > 3) s[c].erase(s[c].find(*s[c].begin()));
}
for (int j = 0; j < 10; j++) dp[i][j] = dp[i - 1][j];
long long mx = 0;
if (!s[3].empty()) mx = max(mx, *s[3].rbegin());
if (!s[2].empty()) mx = max(mx, *s[2].rbegin());
if (!s[1].empty()) mx = max(mx, *s[1].rbegin());
for (long long j = 0; j < 10; j++)
dp[i][(j + 1) % 10] =
max(dp[i][(j + 1) % 10], dp[i - 1][j] + mx + mx * (j + 1 >= 10));
long long cvp = 0, sum = 0;
if ((int)s[1].size() >= 2) {
long long top = 0, amk = 0;
it = s[1].end();
it--;
top += *it;
amk = *it;
it--;
top += *it;
amk += top;
cvp = max(cvp, amk);
sum = max(sum, top);
}
if (!s[1].empty() and !s[2].empty()) {
long long top = 0, amk = 0;
top = *s[1].rbegin() + *s[2].rbegin();
amk = top + max(*s[1].rbegin(), *s[2].rbegin());
sum = max(sum, top);
cvp = max(cvp, amk);
}
if (sum)
for (long long j = 0; j < 10; j++)
dp[i][(j + 2) % 10] =
max(dp[i][(j + 2) % 10],
dp[i - 1][j] + sum + (-sum + cvp) * (j + 2 >= 10));
if ((int)s[1].size() >= 3) {
long long amk = 0, sum = 0;
it = s[1].end();
it--;
amk = *it;
sum = amk;
it--;
sum += *it;
it--;
sum += *it;
amk += sum;
for (long long j = 0; j < 10; j++)
dp[i][(j + 3) % 10] =
max(dp[i][(j + 3) % 10],
dp[i - 1][j] + sum + (-sum + amk) * (j + 3 >= 10));
}
}
for (long long i = 0; i < 10; i++) ans = max(ans, dp[n][i]);
printf("%lld\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
long long dp[10] = {};
for (int i = 0; i < n; ++i) {
int k;
cin >> k;
long long item1[3] = {}, item2 = 0, item3 = 0;
for (int j = 0; j < k; ++j) {
int c;
long long d;
cin >> c >> d;
if (c == 1) {
item1[0] = max(item1[0], d);
sort(item1, item1 + 3);
} else if (c == 2)
item2 = max(item2, d);
else
item3 = max(item3, d);
}
int s1 = 0;
for (auto it : item1)
if (it) s1++;
vector<long long> cards;
if (s1 >= 1 || item2 || item3)
cards.push_back(max(item2, max(item3, item1[2])));
if (s1 >= 2 || (item2 && s1 >= 1))
cards.push_back(item1[2] + max(item2, item1[1]));
if (s1 == 3) cards.push_back(item1[0] + item1[1] + item1[2]);
int c = cards.size();
long long temp[10];
copy(dp, dp + 10, temp);
for (int p = 0; p <= 9; ++p) {
if (p == 0 || dp[p]) {
if (p == 9 && c >= 1)
temp[(p + 1) % 10] = max(temp[(p + 1) % 10], 2 * cards[0] + dp[p]);
else if (c >= 1)
temp[(p + 1) % 10] = max(temp[(p + 1) % 10], cards[0] + dp[p]);
if (p >= 8 && c >= 2)
temp[(p + 2) % 10] =
max(temp[(p + 2) % 10], max(item2, item1[2]) + cards[1] + dp[p]);
else if (c >= 2)
temp[(p + 2) % 10] = max(temp[(p + 2) % 10], cards[1] + dp[p]);
if (p >= 7 && c == 3)
temp[(p + 3) % 10] =
max(temp[(p + 3) % 10], item1[2] + cards[2] + dp[p]);
else if (c == 3)
temp[(p + 3) % 10] = max(temp[(p + 3) % 10], cards[2] + dp[p]);
}
}
copy(temp, temp + 10, dp);
}
long long mV = 0;
for (auto x : dp) {
mV = max(mV, x);
}
cout << mV;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
double const EPS = 1e-12, PI = acos(-1);
const int N = 2e5 + 9, M = 1e7 + 9, OO = 1e9 + 7, MOD = 1e9 + 7,
MOD2 = 998244353;
const long long inf = 1e18;
vector<long long> v[N][4];
long long mem[N][11];
int n;
long long solve(int idx, int cards) {
if (idx > n) return 0ll;
long long& ret = mem[idx][cards];
if (~ret) return ret;
ret = 0;
ret = solve(idx + 1, cards);
long long c1 = 0, c2 = 0, c3 = 0, c4 = 0;
if (!v[idx][3].empty()) {
c1 += v[idx][3][0];
if (cards + 1 >= 10) c1 += v[idx][3][0];
c1 += solve(idx + 1, (cards + 1) % 10);
}
if (!v[idx][2].empty()) {
c2 += v[idx][2][0];
if (cards + 1 >= 10) c2 += v[idx][2][0];
c2 += solve(idx + 1, (cards + 1) % 10);
}
if (!v[idx][2].empty() && !v[idx][1].empty()) {
c3 += v[idx][2][0] + v[idx][1][0];
if (cards + 2 >= 10) c3 += max(v[idx][2][0], v[idx][1][0]);
c3 += solve(idx + 1, (cards + 2) % 10);
}
long long total = 0;
for (int i = 0, done = 0; i < (int)v[idx][1].size(); ++i) {
if (cards + i + 1 >= 10 && !done) {
total += v[idx][1][0];
done = 1;
}
total += v[idx][1][i];
c4 = max(c4, total + solve(idx + 1, (cards + i + 1) % 10));
}
ret = max({ret, c1, c2, c3, c4});
return ret;
}
int main() {
cout << fixed << setprecision(12), ios::sync_with_stdio(false),
cin.tie(nullptr), cout.tie(nullptr);
int c, d;
cin >> n;
for (int i = 1, k; i <= n; ++i) {
vector<long long> vv[4];
cin >> k;
for (int j = 0; j < k; ++j) {
cin >> c >> d;
vv[c].push_back(d);
}
for (int j = 0; j < 4; ++j)
sort(((vv[j]).begin()), ((vv[j]).end()), greater<long long>());
for (int j = 0; j < (int)vv[1].size() && j < 3; ++j)
v[i][1].push_back(vv[1][j]);
for (int j = 0; j < (int)vv[2].size() && j < 1; ++j)
v[i][2].push_back(vv[2][j]);
for (int j = 0; j < (int)vv[3].size() && j < 1; ++j)
v[i][3].push_back(vv[3][j]);
}
memset(mem, -1, sizeof mem);
cout << solve(1, 0);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long INF = (1ll << 62);
vector<pair<int, long long> > a;
int n, k[200010];
long long dp[200010][11], t1[200010], s1[200010][4], s2[200010], s3[200010],
md[5][2], ans = 0;
bool cmp(int _, int __) { return _ > __; }
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
int cnt = 0, l1 = 0, l2 = 0, l3 = 0;
scanf("%d", &k[i]);
s1[i][1] = -1ll;
s1[i][2] = -1ll;
s1[i][3] = -1ll;
s2[i] = -1ll;
s3[i] = -1ll;
for (int j = 1; j <= k[i]; j++) {
int c;
long long d;
scanf("%d %I64d", &c, &d);
switch (c) {
case 1:
t1[++cnt] = d;
break;
case 2:
s2[i] = max(s2[i], d);
l2 = 1;
break;
case 3:
s3[i] = max(s3[i], d);
l3 = 1;
break;
}
}
sort(t1 + 1, t1 + cnt + 1, cmp);
if (cnt >= 1) {
s1[i][1] = t1[1];
l1++;
}
if (cnt >= 2) {
s1[i][2] = t1[2];
l1++;
}
if (cnt >= 3) {
s1[i][3] = t1[3];
l1++;
}
}
for (int i = 0; i <= n; i++)
for (int j = 0; j <= 9; j++) dp[i][j] = -INF;
dp[0][0] = 0;
for (int i = 1; i <= n; i++) {
for (int j = 0; j <= 3; j++) {
md[j][0] = -INF;
md[j][1] = -INF;
}
md[0][0] = 0;
a.clear();
if (s1[i][3] != -1ll) a.push_back(make_pair(1, s1[i][3]));
if (s1[i][2] != -1ll) a.push_back(make_pair(1, s1[i][2]));
if (s1[i][1] != -1ll) a.push_back(make_pair(1, s1[i][1]));
if (s2[i] != -1ll) a.push_back(make_pair(2, s2[i]));
if (s3[i] != -1ll) a.push_back(make_pair(3, s3[i]));
do {
long long tot = 0, mx = 0;
int cnt = 0, ccnt = 0;
for (int j = 0; j < a.size(); j++) {
pair<int, long long> tmp = a[j];
if (cnt + tmp.first > 3) break;
cnt += tmp.first;
ccnt++;
tot += tmp.second;
mx = max(mx, tmp.second);
md[ccnt][0] = max(md[ccnt][0], tot);
md[ccnt][1] = max(md[ccnt][1], tot + mx);
}
} while (next_permutation(a.begin(), a.end()));
for (int j = 0; j <= 9; j++)
for (int kk = 0; kk <= 3; kk++) {
int f = (j + kk >= 10 ? 1 : 0);
dp[i][(j + kk) % 10] =
max(dp[i][(j + kk) % 10], dp[i - 1][j] + md[kk][f]);
}
}
for (int i = 0; i <= 9; i++) ans = max(ans, dp[n][i]);
printf("%I64d", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long inf = 1e18;
const int mod = 1e9 + 7;
const int maxn = 1e6 + 10;
int n;
long long c[maxn], d[maxn];
long long f[22], p[22], mx[5], b[5];
long long ans = 0;
void dp() {
for (int i = 0; i <= 9; i++) {
for (int j = 1; j <= 3; j++) {
if (i + j < 10)
f[i + j] = max(f[i + j], p[i] + mx[j]);
else
f[i + j - 10] = max(f[i + j - 10], p[i] + mx[j] + b[j]);
}
}
}
int main() {
ios::sync_with_stdio(false);
cin >> n;
for (int i = 1; i <= 9; i++) f[i] = -inf;
for (int i = 1, m; i <= n; i++) {
cin >> m;
for (int i = 1; i <= 3; i++) mx[i] = -inf;
memset(b, 0, sizeof(b));
memcpy(p, f, sizeof(p));
for (int j = 1; j <= m; j++) {
cin >> c[j] >> d[j];
mx[1] = max(d[j], mx[1]);
b[1] = max(d[j], b[1]);
}
dp();
long long mx1 = -inf, mx2 = -inf, mx3 = -inf;
for (int j = 1; j <= m; j++) {
if (c[j] == 1) {
if (d[j] > mx1) {
mx2 = mx1;
mx1 = d[j];
} else if (d[j] > mx2) {
mx2 = d[j];
}
} else if (c[j] == 2) {
mx3 = max(mx3, d[j]);
}
}
if (mx1 != -inf && mx2 != -inf) {
mx[2] = mx1 + mx2;
b[2] = mx1;
dp();
}
if (mx1 != -inf && mx3 != -inf) {
mx[2] = mx1 + mx3;
b[2] = max(mx1, mx3);
dp();
}
mx1 = mx2 = mx3 = -inf;
for (int j = 1; j <= m; j++) {
if (c[j] == 1) {
if (d[j] > mx1) {
mx3 = mx2;
mx2 = mx1;
mx1 = d[j];
} else if (d[j] > mx2) {
mx3 = mx2;
mx2 = d[j];
} else if (d[j] > mx3) {
mx3 = d[j];
}
}
}
if (mx1 != -inf && mx2 != -inf && mx3 != -inf) {
mx[3] = mx1 + mx2 + mx3;
b[3] = mx1;
dp();
}
}
for (int i = 0; i <= 9; i++) {
ans = max(ans, f[i]);
}
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long n, m, k, y, z, l, i, j, x, r, x2, y2;
long long a[100500], b[500500], c[100500];
long long binpow(long long x, long long y) {
if (y == 0) {
return 1;
}
long long tmp = binpow(x, y / 2);
tmp = tmp * tmp % 998244353;
if (y % 2) {
return x * tmp % 998244353;
}
return tmp;
}
long long inv(long long x) { return binpow(x, 998244353 - 2); }
long long mulg(long long x, long long y) { return x * y % 998244353; }
void add(long long& x, long long y) {
x += y;
if (x >= 998244353) {
x -= 998244353;
}
}
long long dp[200500][11];
vector<long long> g[5];
long long dpr[4];
int main() {
cin >> n;
for (int i = 0; i <= n; i++) {
for (int j = 0; j <= 10; j++) {
dp[i][j] = -(long long)1e+18;
}
}
dp[0][0] = 0;
for (int i = 0; i < n; i++) {
for (int j = 1; j <= 3; j++) {
g[j].clear();
}
int k;
scanf("%d", &k);
for (int j = 0; j < k; j++) {
int x, y;
scanf("%d %d", &x, &y);
g[x].push_back(y);
}
vector<pair<long long, long long> > pool;
for (int j = 1; j <= 3; j++) {
sort(g[j].begin(), g[j].end());
reverse(g[j].begin(), g[j].end());
if (j == 1) {
for (int k = 0; k < 3 && k < g[j].size(); k++) {
pool.push_back(make_pair(g[j][k], j));
}
} else {
for (int k = 0; k < 1 && k < g[j].size(); k++) {
pool.push_back(make_pair(g[j][k], j));
}
}
}
for (int j = 1; j <= 10; j++) {
dpr[0] = 0;
for (int k = 1; k <= 3; k++) {
dpr[k] = -(long long)1e+18;
}
for (int i1 = 0; i1 < pool.size(); i1++) {
vector<pair<long long, long long> > tmp;
tmp.push_back(pool[i1]);
for (int i2 = 0; i2 <= pool.size(); i2++) {
if (i2 != pool.size() && i2 != i1) {
tmp.push_back(pool[i2]);
}
for (int i3 = 0; i3 <= pool.size(); i3++) {
if (i3 != pool.size() && i3 != i2 && i3 != i1) {
tmp.push_back(pool[i3]);
}
long long cur_val = 0, cur_w = 0;
for (int k = 0; k < tmp.size(); k++) {
if (k + 1 == j) {
cur_val += 2 * tmp[k].first;
} else {
cur_val += tmp[k].first;
}
cur_w += tmp[k].second;
}
if (cur_w <= 3) {
dpr[tmp.size()] = max(dpr[tmp.size()], cur_val);
}
if (i3 != pool.size() && i3 != i2 && i3 != i1) {
tmp.pop_back();
}
}
if (i2 != pool.size() && i2 != i1) {
tmp.pop_back();
}
}
}
for (int k = 0; k <= 3; k++) {
long long cur = dpr[k];
dp[i + 1][(10 - j + k) % 10] =
max(dp[i + 1][(10 - j + k) % 10], dp[i][10 - j] + cur);
}
}
}
long long ans = 0;
for (int i = 0; i < 10; i++) {
ans = max(ans, dp[n][i]);
}
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int mod = 1e9 + 7;
const long long MAX = 1e18;
const long long MIN = -1e18;
using namespace std;
int main() {
int turns;
cin >> turns;
long long dp[turns + 1][10];
for (int i = 0; i <= turns; i++)
for (int j = 0; j < 10; j++) dp[i][j] = MIN;
dp[0][0] = 0;
int T = 0;
while (T < turns) {
int n;
cin >> n;
vector<pair<int, long long> > card;
for (int i = 1; i <= n; i++) {
int c, d;
cin >> c >> d;
card.push_back({c, d});
}
vector<long long> temp[4];
vector<pair<int, long long> > curr;
for (int i = 0; i < n; i++) temp[card[i].first].push_back(card[i].second);
for (int i = 1; i <= 3; i++) sort(temp[i].rbegin(), temp[i].rend());
if (temp[3].size() >= 1) curr.push_back({3, temp[3][0]});
if (temp[2].size() >= 1) curr.push_back({2, temp[2][0]});
for (int i = 0; i < min(3, (int)temp[1].size()); i++)
curr.push_back({1, temp[1][i]});
long long val[4][2];
for (int i = 0; i < 4; i++) val[i][0] = MIN, val[i][1] = MIN;
val[0][0] = 0;
sort(curr.begin(), curr.end());
do {
int mana = 3;
long long score = 0;
long long mx = 0;
int cnt = 0;
for (auto x : curr) {
cnt++;
if (mana < x.first) break;
mana -= x.first;
mx = max(mx, (long long)(x.second));
score += x.second;
val[cnt][0] = max(val[cnt][0], score);
val[cnt][1] = max(val[cnt][1], score + mx);
}
} while (next_permutation(curr.begin(), curr.end()));
for (int y = 0; y < 10; y++) {
for (int x = 0; x <= 3; x++)
dp[T + 1][(x + y) % 10] = max(dp[T + 1][(y + x) % 10],
dp[T][y] + val[x][x + y >= 10 ? 1 : 0]);
}
T++;
}
long long mx = 0;
for (int i = 0; i < 10; i++) mx = max(mx, dp[turns][i]);
cout << mx;
}
|
#include <bits/stdc++.h>
using namespace std;
int turn;
long long max_dame[200005][10];
int mana_cost[4][200005], mem[4];
long long moves[4];
void process(int pos) {
int amount;
scanf("%d", &amount);
mem[1] = 2, mem[2] = 1, mem[3] = 1;
for (int i = 1; i <= amount; i++) {
int mana, damage;
scanf("%d %d", &mana, &damage);
mana_cost[mana][++mem[mana]] = damage;
}
for (int i = 1; i <= 3; i++)
sort(mana_cost[i] + 1, mana_cost[i] + mem[i] + 1);
moves[1] =
max({mana_cost[1][mem[1]], mana_cost[2][mem[2]], mana_cost[3][mem[3]]});
if (mem[1] >= 4 || (mem[1] >= 3 && mem[2] >= 2))
moves[2] = mana_cost[1][mem[1]] +
max(mana_cost[1][mem[1] - 1], mana_cost[2][mem[2]]);
else
moves[2] = -(long long)1e18;
if (mem[1] >= 5)
moves[3] = (long long)mana_cost[1][mem[1]] + mana_cost[1][mem[1] - 1] +
mana_cost[1][mem[1] - 2];
else
moves[3] = -(long long)1e18;
for (int remain = 0; remain <= 9; remain++) {
max_dame[pos][remain] = max_dame[pos - 1][remain];
long long one = moves[1];
int pre = (remain - 1 + 10) % 10;
if (remain < 1) one *= 2;
max_dame[pos][remain] =
max(max_dame[pos][remain], max_dame[pos - 1][pre] + one);
long long two = moves[2];
pre = (remain - 2 + 10) % 10;
if (remain < 2) two += max(mana_cost[1][mem[1]], mana_cost[2][mem[2]]);
max_dame[pos][remain] =
max(max_dame[pos][remain], max_dame[pos - 1][pre] + two);
long long three = moves[3];
pre = (remain - 3 + 10) % 10;
if (remain < 3) three += mana_cost[1][mem[1]];
max_dame[pos][remain] =
max(max_dame[pos][remain], max_dame[pos - 1][pre] + three);
}
}
void solve() {
for (int i = 0; i <= turn; i++)
for (int j = 0; j < 10; j++) max_dame[i][j] = -(long long)1e18;
max_dame[0][0] = 0;
for (int i = 1; i <= turn; i++) process(i);
int res = 0;
for (int remain = 0; remain < 10; remain++)
if (max_dame[turn][remain] > max_dame[turn][res]) res = remain;
printf("%lld", max_dame[turn][res]);
}
int main() {
scanf("%d", &turn);
solve();
}
|
#include <bits/stdc++.h>
using namespace std;
set<long long int> s[100005];
long long int d[100005];
vector<char> prime(100000 + 1, true);
void sieve(long long int n) {
prime[0] = prime[1] = false;
for (long long int i = 2; i <= n; ++i) {
if (prime[i]) {
s[i].insert(i);
for (long long int j = 2 * i; j <= n; j += i) {
prime[j] = false;
s[j].insert(i);
}
}
}
}
void init(long long int ar[], long long int n, long long int val) {
long long int i;
for (i = 0; i < n; i++) {
ar[i] = val;
}
}
long long int search1(vector<long long int> &v, long long int f) {
long long int left = 0;
long long int right = v.size() - 1;
while (left < right) {
long long int mid = left + (right - left + 1) / 2;
if (v[mid] <= f) {
left = mid;
} else
right = mid - 1;
}
return left;
}
int main() {
long long int n, k, i, j;
cin >> n;
long long int dp[n + 1][10];
for (i = 0; i <= n; i++) {
for (j = 0; j < 10; j++) {
dp[i][j] = -1000000000000000000;
}
}
dp[0][0] = 0;
long long int t = n;
for (i = 1; i <= n; i++) {
cin >> k;
long long int c1, d;
long long int a1 = 0, a2 = 0, a3 = 0, b = 0, c = 0;
for (j = 0; j < k; j++) {
cin >> c1 >> d;
if (c1 == 2) {
b = max(b, d);
} else if (c1 == 3) {
c = max(c, d);
} else {
if (d >= a1) {
a3 = a2;
a2 = a1;
a1 = d;
} else if (d >= a2) {
a3 = a2;
a2 = d;
} else if (d >= a3) {
a3 = d;
}
}
}
long long int maxs = max(a1, b);
long long int mins = min(a1, b);
if (i == 1) {
dp[1][0] = 0;
if (c != 0) {
dp[1][1] = max(c, dp[1][1]);
}
if (a1 != 0) {
dp[1][1] = max(dp[1][1], a1);
}
if (b != 0) {
dp[1][1] = max(dp[1][1], b);
}
if (a1 != 0 && b != 0) {
dp[1][2] = max(dp[1][2], maxs + mins);
}
if (a2 != 0) {
dp[1][2] = max(a1 + a2, dp[1][2]);
}
if (a3 != 0) {
dp[1][3] = a1 + a2 + a3;
}
continue;
}
for (j = 0; j < 10; j++) {
dp[i][j] = max(dp[i][j], dp[i - 1][j]);
long long int val = c;
if (j == 0) val += c;
if (c != 0) dp[i][j] = max(dp[i][j], val + dp[i - 1][(j - 1 + 10) % 10]);
if (a3 != 0) {
val = a1 + a2 + a3;
if (j < 3) val += a1;
dp[i][j] = max(dp[i][j], val + dp[i - 1][(j - 3 + 10) % 10]);
}
if (a2 != 0) {
val = a1 + a2;
if (j < 2) val += a1;
dp[i][j] = max(dp[i][j], val + dp[i - 1][(j - 2 + 10) % 10]);
}
if (a1 != 0) {
val = a1;
if (j < 1) val += a1;
dp[i][j] = max(dp[i][j], val + dp[i - 1][(j - 1 + 10) % 10]);
}
if (b != 0) {
val = b;
if (j < 1) val += b;
dp[i][j] = max(dp[i][j], val + dp[i - 1][(j - 1 + 10) % 10]);
}
if (maxs != 0 && mins != 0) {
val = maxs + mins;
if (j < 2) val += maxs;
dp[i][j] = max(dp[i][j], val + dp[i - 1][(j - 2 + 10) % 10]);
}
}
}
cout << *max_element(dp[n], dp[n] + 10) << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
void fast() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
}
const long long INFll = 1ll * 1000000000 * 1000000000;
const long double PI =
3.141592653589793238462643383279502884197169399375105820974944;
int mul(int a, int b, int mod = 1000000007) { return int(a * 1ll * b % mod); }
int norm(int a, int mod = 1000000007) {
while (a >= mod) a -= mod;
while (a < 0) a += mod;
return a;
}
int powmod(int x, int y, int mod = 1000000007) {
int res = 1;
while (y > 0) {
if (y & 1) res = mul(res, x, mod);
x = mul(x, x, mod);
y = y >> 1;
}
return res;
}
int inv(int a, int mod = 1000000007) { return powmod(a, mod - 2); }
long long dp[200005][11];
int main() {
fast();
int n;
cin >> n;
vector<vector<pair<long long, long long>>> mpr(
n + 1, vector<pair<long long, long long>>(4, {0, 0}));
for (int i = 1; i <= n; i++) {
int k;
cin >> k;
vector<long long> v[4];
for (int j = 0; j < k; j++) {
int c, d;
cin >> c >> d;
v[c].push_back(d);
}
for (int j = 1; j < 4; j++) sort(v[j].rbegin(), v[j].rend());
if (v[1].size() >= 1) {
mpr[i][1].first = v[1][0];
mpr[i][1].second = 2 * v[1][0];
}
if (v[2].size() >= 1) {
mpr[i][1].first = max(mpr[i][1].first, v[2][0]);
mpr[i][1].second = max(mpr[i][1].second, 2 * v[2][0]);
}
if (v[3].size() >= 1) {
mpr[i][1].first = max(mpr[i][1].first, v[3][0]);
mpr[i][1].second = max(mpr[i][1].second, 2 * v[3][0]);
}
if (v[1].size() >= 2) {
mpr[i][2].first = v[1][0] + v[1][1];
mpr[i][2].second = 2 * v[1][0] + v[1][1];
}
if (v[2].size() >= 1 && v[1].size() >= 1) {
mpr[i][2].first = max(mpr[i][2].first, v[2][0] + v[1][0]);
mpr[i][2].second = max(mpr[i][2].second,
max(2 * v[2][0] + v[1][0], v[2][0] + 2 * v[1][0]));
}
if (v[1].size() >= 3) {
mpr[i][3].first = v[1][0] + v[1][1] + v[1][2];
mpr[i][3].second = 2 * v[1][0] + v[1][1] + v[1][2];
}
}
for (int i = 1; i <= n; i++) {
for (int j = 0; j <= 9; j++) dp[i][j] = dp[i - 1][j];
for (int j = 0; j <= 9; j++) {
for (int k = 1; k <= 3; k++) {
if (mpr[i][k].first != 0) {
if (j - k == 0) {
dp[i][j] = max(dp[i][j], dp[i - 1][0] + mpr[i][k].first);
} else if ((j - k) < 0) {
if (dp[i - 1][10 + (j - k)] > 0)
dp[i][j] =
max(dp[i][j], dp[i - 1][10 + (j - k)] + mpr[i][k].second);
} else if ((j - k) > 0) {
if (dp[i - 1][j - k] > 0)
dp[i][j] = max(dp[i][j], dp[i - 1][j - k] + mpr[i][k].first);
}
}
}
}
}
long long ans = 0;
for (int i = 0; i <= 9; i++) ans = max(ans, dp[n][i]);
cout << ans;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long fc(int d, int k) { return (k == 9 ? d << 1 : d); }
long long dp[200000][10];
int n;
multiset<int, greater<int> > A[200000][3];
vector<int> ing(int ind, int d) {
vector<int> a;
for (auto i : A[ind][0]) {
if (a.size() == d) break;
a.push_back(i);
}
reverse(a.begin(), a.end());
return a;
}
long long f(int i, int k) {
if (i >= n) return 0;
if (k > 9) return f(i, k - 10);
if (dp[i][k] > -1) return dp[i][k];
long long mx = f(i + 1, k);
vector<int> a = ing(i, 3);
if (a.size() == 3) do {
mx = max(mx, f(i + 1, k + 3) + fc(a[0], k) + fc(a[1], k + 1) +
fc(a[2], k + 2));
} while (next_permutation(a.begin(), a.end()));
a = ing(i, 2);
if (a.size() == 2) do {
mx = max(mx, f(i + 1, k + 2) + fc(a[0], k) + fc(a[1], k + 1));
} while (next_permutation(a.begin(), a.end()));
a = ing(i, 1);
if (a.size() == 1) {
mx = max(mx, f(i + 1, k + 1) + fc(a[0], k));
if (!A[i][1].empty()) {
int rx = *A[i][1].begin();
mx = max(mx, f(i + 1, k + 2) + fc(a[0], k) + fc(rx, k + 1));
mx = max(mx, f(i + 1, k + 2) + fc(rx, k) + fc(a[0], k + 1));
}
}
if (!A[i][1].empty()) mx = max(mx, f(i + 1, k + 1) + fc(*A[i][1].begin(), k));
if (!A[i][2].empty()) mx = max(mx, f(i + 1, k + 1) + fc(*A[i][2].begin(), k));
return dp[i][k] = mx;
}
int main() {
cin.tie(NULL)->sync_with_stdio(false);
cin >> n;
memset(dp, -1, sizeof dp);
for (int i = 0; i < n; ++i) {
int k;
cin >> k;
int u, v;
while (k--) {
cin >> u >> v;
A[i][u - 1].insert(v);
}
}
cout << f(0, 0);
return 0;
}
|
#include <bits/stdc++.h>
void print_array(int *a, int n) {
printf("#");
for (int i = 0; i < n; i++) printf("%d%c", a[i], i == n - 1 ? '\n' : ' ');
}
using namespace std;
const double EPS = 1e-8;
const long long INF = 0x3f3f3f3f3f3f3f3f;
const int sz = 3e5 + 9;
int m;
vector<long long> card[5];
void init() {
for (int i = 1; i < 4; ++i) {
card[i].clear();
}
}
long long max3(long long a, long long b, long long c) {
return max(a, max(b, c));
}
long long get_best(int cnt, bool doub) {
long long ans = -1;
if (cnt == 0)
return 0;
else if (cnt == 1) {
if (card[1].size() >= 1) ans = max(ans, card[1][0] * (1 + doub));
if (card[2].size() >= 1) ans = max(ans, card[2][0] * (1 + doub));
if (card[3].size() >= 1) ans = max(ans, card[3][0] * (1 + doub));
} else if (cnt == 2) {
if (card[1].size() >= 2)
ans = max(ans,
card[1][0] + card[1][1] + doub * max(card[1][0], card[1][1]));
if (card[1].size() >= 1 && card[2].size() >= 1)
ans = max(ans,
card[1][0] + card[2][0] + doub * max(card[1][0], card[2][0]));
} else if (cnt == 3) {
if (card[1].size() >= 3)
ans = max(ans, card[1][0] + card[1][1] + card[1][2] +
doub * max3(card[1][0], card[1][1], card[1][2]));
}
return ans;
}
long long dp[sz][15];
void solve() {
for (int i = 0; i < m + 4; ++i)
for (int j = 0; j < 10; ++j) dp[i][j] = -INF;
dp[0][0] = 0;
for (int I = 1; I < m + 1; ++I) {
init();
int n;
cin >> n;
for (int i = 0; i < n; ++i) {
int c, x;
scanf("%d%d", &c, &x);
card[c].push_back(x);
}
for (int i = 1; i < 4; ++i) {
sort(card[i].begin(), card[i].end(), [](int a, int b) { return a > b; });
}
for (int lastnum = 0; lastnum < 10; ++lastnum) {
for (int choose = 0; choose < 4; ++choose) {
int num = lastnum + choose;
long long best = get_best(choose, num >= 10);
if (best >= 0)
dp[I][num % 10] = max(dp[I][num % 10], dp[I - 1][lastnum] + best);
}
}
}
long long ans = 0;
for (int i = 0; i < 10; ++i) {
ans = max(ans, dp[m][i]);
}
cout << ans << endl;
}
int main() {
cin >> m;
solve();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long dp[200005][10], mx1, mx2, mx3, mx4, mx5;
int n, m;
int main() {
memset(dp, -60, sizeof(dp));
dp[0][0] = 0;
scanf("%d", &n);
for (int i = 1; i <= n; ++i) {
scanf("%d", &m);
mx1 = mx2 = mx3 = mx4 = mx5 = 0;
for (int j = 1; j <= m; ++j) {
int opt;
long long v;
scanf("%d%lld", &opt, &v);
if (opt == 1) {
if (v >= mx1)
mx3 = mx2, mx2 = mx1, mx1 = v;
else if (v >= mx2)
mx3 = mx2, mx2 = v;
else if (v >= mx3)
mx3 = v;
} else if (opt == 2)
mx4 = max(mx4, v);
else if (opt == 3)
mx5 = max(mx5, v);
}
for (int j = 0; j <= 9; ++j) dp[i][j] = dp[i - 1][j];
for (int j = 1; j <= 3; ++j) {
for (int k = 0; k <= 9; ++k) {
if (j == 1 && dp[i - 1][k] >= 0) {
if (mx1)
dp[i][(k + 1) % 10] =
max(dp[i][(k + 1) % 10], dp[i - 1][k] + mx1 * (1 + (k == 9)));
} else if (j == 2 && dp[i - 1][k] >= 0) {
if (mx1 && mx2) {
dp[i][(k + 2) % 10] = max(
dp[i][(k + 2) % 10], dp[i - 1][k] + mx1 * (1 + (k >= 8)) + mx2);
}
if (mx4) {
dp[i][(k + 1) % 10] =
max(dp[i][(k + 1) % 10], dp[i - 1][k] + mx4 * (1 + (k == 9)));
}
} else if (j == 3 && dp[i - 1][k] >= 0) {
if (mx1 && mx2 && mx3) {
dp[i][(k + 3) % 10] =
max(dp[i][(k + 3) % 10],
dp[i - 1][k] + mx1 * (1 + (k >= 7)) + mx2 + mx3);
}
if (mx1 && mx4) {
dp[i][(k + 2) % 10] = max(
dp[i][(k + 2) % 10],
dp[i - 1][k] + max(mx1, mx4) * (1 + (k >= 8)) + min(mx1, mx4));
}
if (mx5) {
dp[i][(k + 1) % 10] =
max(dp[i][(k + 1) % 10], dp[i - 1][k] + mx5 * (1 + (k >= 9)));
}
}
}
}
}
long long ans = 0;
for (int i = 0; i <= 9; ++i) ans = max(ans, dp[n][i]);
printf("%lld\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
#pragma GCC target("avx2")
#pragma GCC optimization("O3")
#pragma GCC optimization("unrolled-loops")
using namespace std;
const long long mod = 1e9 + 7;
const long long INF = 1e16;
int test = 1;
void CNH_Tourist() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
}
const int N = 200200;
const int D = 3;
int n;
vector<long long> dmg[N][D + 1];
const int MOD = 10;
long long dp[N][MOD];
vector<long long> sort_top_3(const vector<long long>& v) {
priority_queue<long long, vector<long long>, greater<long long> > q;
int k = v.size();
for (int i = 0; i < k; i++) {
q.push(v[i]);
if (i >= 3) q.pop();
}
vector<long long> res;
while (!q.empty()) {
res.push_back(q.top());
q.pop();
}
reverse(res.begin(), res.end());
return res;
}
void dp_cal(int i, int r, vector<long long> cur_dmg) {
int s = cur_dmg.size();
int new_r = (r + s) % MOD;
sort(cur_dmg.begin(), cur_dmg.end());
long long sum = 0;
for (int j = 0; j < cur_dmg.size(); j++) sum += cur_dmg[j];
long long mx = cur_dmg.back();
long long new_dmg = sum;
if (r + s >= MOD) new_dmg += mx;
dp[i + 1][new_r] = max(dp[i + 1][new_r], dp[i][r] + new_dmg);
}
long long solve() {
for (int i = 0; i < MOD; i++) dp[0][i] = -INF;
dp[0][0] = 0;
for (int i = 0; i < n; i++) {
vector<long long> d1 = sort_top_3(dmg[i][1]), d2 = sort_top_3(dmg[i][2]),
d3 = sort_top_3(dmg[i][3]);
for (int r = 0; r < MOD; r++) {
dp[i + 1][r] = dp[i][r];
}
for (int r = 0; r < MOD; r++) {
if (d1.size() >= 3) {
vector<long long> dd;
dd.push_back(d1[0]);
dd.push_back(d1[1]);
dd.push_back(d1[2]);
dp_cal(i, r, dd);
}
if (d1.size() >= 2) {
vector<long long> dd;
dd.push_back(d1[0]);
dd.push_back(d1[1]);
dp_cal(i, r, dd);
}
if (d1.size() >= 1 && d2.size() >= 1) {
vector<long long> dd;
dd.push_back(d1[0]);
dd.push_back(d2[0]);
dp_cal(i, r, dd);
}
if (d1.size() >= 1) {
vector<long long> dd;
dd.push_back(d1[0]);
dp_cal(i, r, dd);
}
if (d2.size() >= 1) {
vector<long long> dd;
dd.push_back(d2[0]);
dp_cal(i, r, dd);
}
if (d3.size() >= 1) {
vector<long long> dd;
dd.push_back(d3[0]);
dp_cal(i, r, dd);
}
}
}
long long result = -INF;
for (int r = 0; r < MOD; r++) {
result = max(result, dp[n][r]);
}
return result;
}
int32_t main() {
CNH_Tourist();
cin >> n;
for (int i = 0; i < n; i++) {
int k;
cin >> k;
for (int j = 1; j <= k; j++) {
int c, d;
cin >> c >> d;
dmg[i][c].push_back(d);
}
}
long long ans = solve();
cout << ans << '\n';
}
|
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
const ll LINF = 1001002003004005006ll;
int dx[] = {1, 0, -1, 0};
int dy[] = {0, 1, 0, -1};
ll gcd(ll a, ll b) { return b ? gcd(b, a % b) : a; }
template <class T>
bool chmax(T &a, const T &b) {
if (a < b) {
a = b;
return 1;
}
return 0;
}
template <class T>
bool chmin(T &a, const T &b) {
if (b < a) {
a = b;
return 1;
}
return 0;
}
signed main() {
cin.tie(0);
ios::sync_with_stdio(0);
int n;
cin >> n;
vector<ll> DP(10, -1);
DP[0] = 0;
for (int _ = 0; _ < n; _++) {
int k;
cin >> k;
vector<ll> ones;
ll d2 = -1, d3 = -1;
for (int i = 0; i < k; i++) {
ll c, d;
cin >> c >> d;
if (c == 1)
ones.push_back(d);
else if (c == 2)
chmax(d2, d);
else
chmax(d3, d);
}
sort(ones.begin(), ones.end());
reverse(ones.begin(), ones.end());
vector<ll> v2, v3;
ll dp[4] = {};
for (int i = 0; i < 3; i++) dp[i + 1] = -1;
if (!ones.empty()) chmax(dp[1], ones[0]);
if (ones.size() >= 2)
if (chmax(dp[2], ones[0] + ones[1])) {
v2.clear();
v2.push_back(ones[0]);
v2.push_back(ones[1]);
}
if (ones.size() >= 3)
if (chmax(dp[3], ones[0] + ones[1] + ones[2])) {
v3.clear();
for (int i = 0; i < 3; i++) v3.push_back(ones[i]);
}
if (d2 >= 0) chmax(dp[1], d2);
if (d2 >= 0 and (!ones.empty()))
if (chmax(dp[2], d2 + ones[0])) {
v2.clear();
v2.push_back(ones[0]);
v2.push_back(d2);
}
if (d3 >= 0) chmax(dp[1], d3);
vector<ll> new_DP(10);
for (int i = 0; i < 10; i++) {
new_DP[i] = DP[i];
}
if (dp[1] >= 0) {
for (int i = 0; i < 10; i++)
if (DP[i] >= 0) {
ll point = dp[1];
if (i == 9) point *= 2;
chmax(new_DP[(i + 1) % 10], DP[i] + point);
}
}
if (dp[2] >= 0) {
sort(v2.begin(), v2.end());
reverse(v2.begin(), v2.end());
for (int i = 0; i < 10; i++)
if (DP[i] >= 0) {
ll point = dp[2];
if (i == 9 or i == 8) point += v2[0];
chmax(new_DP[(i + 2) % 10], DP[i] + point);
}
}
if (dp[3] >= 0) {
sort(v3.begin(), v3.end());
reverse(v3.begin(), v3.end());
for (int i = 0; i < 10; i++)
if (DP[i] >= 0) {
ll point = dp[3];
if (i == 9 or i == 8 or i == 7) point += v3[0];
chmax(new_DP[(i + 3) % 10], DP[i] + point);
}
}
swap(DP, new_DP);
}
ll ans = 0;
for (int i = 0; i < 10; i++) chmax(ans, DP[i]);
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, k;
long long int dp[200000 + 3][10];
vector<pair<int, int> > cards[200000 + 3];
long long int solve(int turn, int takenSoFar) {
if (turn == n) return 0;
if (dp[turn][takenSoFar] != -1) return dp[turn][takenSoFar];
int nCard = (int)cards[turn].size();
long long int result = -1e18;
for (int mask = 0; mask < (1 << nCard); mask++) {
int numTaken = 0;
int totalCost = 0;
long long int totalDamage = 0;
int maxDamage = 0;
for (int i = 0; i < nCard; i++) {
if (mask & (1 << i)) {
numTaken += 1;
totalCost += cards[turn][i].first;
totalDamage += cards[turn][i].second;
maxDamage = max(maxDamage, cards[turn][i].second);
}
}
if (totalCost <= 3) {
if (takenSoFar + numTaken >= 10) {
result = max(result, totalDamage + maxDamage +
solve(turn + 1, takenSoFar + numTaken - 10));
} else {
result =
max(result, totalDamage + solve(turn + 1, takenSoFar + numTaken));
}
}
}
return dp[turn][takenSoFar] = result;
}
int main() {
scanf("%d", &n);
for (int turn = 0; turn < n; turn++) {
scanf("%d", &k);
vector<int> cardsWithCost[4];
for (int i = 1; i <= k; i++) {
int c, d;
scanf("%d%d", &c, &d);
cardsWithCost[c].push_back(d);
}
for (int c = 1; c <= 3; c++) {
sort(cardsWithCost[c].begin(), cardsWithCost[c].end());
if (c == 1) {
for (int i = cardsWithCost[c].size() - 1;
i >= max(0, (int)cardsWithCost[c].size() - 3); i--)
cards[turn].push_back({c, cardsWithCost[c][i]});
} else {
if (!cardsWithCost[c].empty())
cards[turn].push_back({c, cardsWithCost[c].back()});
}
}
}
memset(dp, -1, sizeof(dp));
printf("%lld\n", solve(0, 0));
}
|
#include <bits/stdc++.h>
using namespace std;
const long long N = 3e5 + 15, INF = 1e9;
long long n;
long long dp[N][10];
vector<vector<long long>> a[N];
long long solve(long long i, long long j) {
if (i == n) return 0;
if (dp[i][j] != -1) return dp[i][j];
long long res = solve(i + 1, j);
for (auto v : a[i]) {
for (long long i = 1; i < ((long long)(v).size()); i++)
assert(v[i] <= v[i - 1]);
long long acum = j + ((long long)(v).size()), gain = 0;
for (long long j : v) gain += j;
assert(gain > 0);
if (acum >= 10) {
acum -= 10;
gain += v[0];
}
assert(acum < 10);
res = max(res, gain + solve(i + 1, acum));
}
return dp[i][j] = res;
}
int main() {
ios::sync_with_stdio(false);
memset(dp, -1, sizeof(dp));
cin >> n;
for (long long i = 0; i < n; i++) {
vector<long long> g[3];
for (long long j = 0; j < 3; j++)
g[j].push_back(-INF), g[j].push_back(-INF), g[j].push_back(-INF);
long long x;
cin >> x;
while (x--) {
long long l, r;
cin >> l >> r;
g[l - 1].push_back(r);
}
for (long long j = 0; j < 3; j++) sort(g[j].rbegin(), g[j].rend());
if (g[0][2] > 0) a[i].push_back({g[0][0], g[0][1], g[0][2]});
a[i].push_back({max({g[0][0], g[1][0], g[2][0]})});
long long l = g[0][0] + g[0][1], r = g[0][0] + g[1][0];
if (l >= r && l > 0) {
a[i].push_back({g[0][0], g[0][1]});
} else if (r >= l && r > 0) {
pair<long long, long long> tmp = {g[0][0], g[1][0]};
if (tmp.second > tmp.first) swap(tmp.second, tmp.first);
a[i].push_back({tmp.first, tmp.second});
}
}
cout << solve(0, 0) << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 2e5 + 10;
long long q, m;
long long dp[maxn][10];
int main() {
scanf("%I64d", &q);
memset(dp, -1, sizeof(dp));
dp[0][0] = 0;
long long mmax = 0;
int n;
for (int i = 1; i <= q; i++) {
scanf("%d", &n);
if (n == 1) {
int w, v;
scanf("%d%d", &v, &w);
for (int j = 0; j < 10; j++) {
dp[i][j] = dp[i - 1][j];
if (j == 0) {
if (dp[i - 1][9] == -1) continue;
dp[i][j] = max(dp[i][j], dp[i - 1][9] + 2 * w);
} else {
if (dp[i - 1][j - 1] == -1) continue;
dp[i][j] = max(dp[i][j], dp[i - 1][j - 1] + w);
}
mmax = max(mmax, dp[i][j]);
}
continue;
}
long long d[2][4][4];
memset(d, -1, sizeof(d));
d[0][0][0] = 0;
for (int k = 0; k < n; k++) {
long long v, w;
scanf("%I64d%I64d", &v, &w);
for (int k1 = 2; k1 >= 0; k1--) {
for (int k2 = 3 - v; k2 >= 0; k2--) {
if (d[0][k1][k2] != -1) {
d[0][k1 + 1][k2 + v] = max(d[0][k1 + 1][k2 + v], d[0][k1][k2] + w);
d[1][k1 + 1][k2 + v] =
max(d[1][k1 + 1][k2 + v], d[0][k1][k2] + 2 * w);
}
if (d[1][k1][k2] != 1) {
d[1][k1 + 1][k2 + v] = max(d[1][k1 + 1][k2 + v], d[1][k1][k2] + w);
}
}
}
}
for (int k = 0; k < 4; k++) {
for (int j = 1; j < 4; j++) {
d[0][k][0] = max(d[0][k][0], d[0][k][j]);
d[1][k][0] = max(d[1][k][0], d[1][k][j]);
}
}
for (int j = 0; j < 10; j++) {
for (int l = 0; l <= min(3, n); l++) {
int u = (j - l + 10) % 10;
if (dp[i - 1][u] == -1) continue;
if (u > j) {
dp[i][j] = max(dp[i][j], dp[i - 1][u] + d[1][l][0]);
} else {
dp[i][j] = max(dp[i][j], dp[i - 1][u] + d[0][l][0]);
}
}
mmax = max(mmax, dp[i][j]);
}
}
printf("%I64d\n", mmax);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
vector<long long int> c[3];
long long int f(long long int x, long long int y) {
if (c[x].size() < y) return -1e18;
long long int ans = 0;
for (long long int i = 0; i < y; i++) ans += c[x][i];
return ans;
}
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
long long int n;
cin >> n;
long long int ct = 1;
long long int dp[10];
long long int ans = 0;
long long int dpp[10];
for (long long int i = 0; i < 10; i++) dpp[i] = dp[i] = -1e18;
dp[0] = 0;
dpp[0] = 0;
while (n--) {
long long int k;
cin >> k;
c[0].clear();
c[1].clear();
c[2].clear();
for (long long int i = 0; i < k; i++) {
long long int co;
cin >> co;
long long int d;
cin >> d;
co--;
c[co].push_back(d);
}
long long int ma1, ma2, ma3;
sort(c[0].begin(), c[0].end(), greater<long long int>());
sort(c[1].begin(), c[1].end(), greater<long long int>());
sort(c[2].begin(), c[2].end(), greater<long long int>());
long long int one = max({f(0, 1), f(1, 1), f(2, 1)});
long long int two = max({f(0, 2), f(0, 1) + f(1, 1)});
long long int three = f(0, 3);
ma1 = one;
if (f(0, 2) > f(0, 1) + f(1, 1) && f(0, 2) > 0)
ma2 = c[0][0];
else if (f(0, 1) + f(1, 1) > 0)
ma2 = max(c[0][0], c[1][0]);
else
ma2 = -1e18;
if (three > 0)
ma3 = f(0, 1);
else
ma3 = -1e18;
dpp[2] = max(dpp[2], dp[9] + three + ma3);
dpp[1] = max(dpp[1], dp[9] + two + ma2);
dpp[0] = max(dpp[0], dp[9] + one + ma1);
dpp[1] = max(dpp[1], dp[8] + three + ma3);
dpp[0] = max(dpp[0], dp[8] + two + ma2);
dpp[0] = max(dpp[0], dp[7] + three + ma3);
for (long long int i = 0; i < 10; i++) {
if (i + 1 < 10) dpp[i + 1] = max(dpp[i + 1], dp[i] + one);
if (i + 2 < 10) dpp[i + 2] = max(dpp[i + 2], dp[i] + two);
if (i + 3 < 10) dpp[i + 3] = max(dpp[i + 3], dp[i] + three);
}
for (long long int i = 0; i < 10; i++) {
if (dpp[i] < 0) dpp[i] = -1e18;
dp[i] = dpp[i];
}
}
for (long long int i = 0; i < 10; i++) ans = max(ans, dp[i]);
cout << ans << '\n';
cerr << "Time : " << 1000 * (long double)clock() / (long double)CLOCKS_PER_SEC
<< "ms\n";
;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, k, a, b;
int one, two, three;
long long dp[200010][10];
vector<pair<int, pair<long long, long long> > > turn[200010];
long long solution(int pos, int r) {
if (pos > n) return 0;
long long &ret = dp[pos][r];
if (ret != -1) return ret;
ret = 0;
for (pair<int, pair<long long, long long> > card : turn[pos + 1]) {
if ((card.first + r) >= 10) {
long long cost = card.second.second;
ret = max(ret, card.second.first + cost +
solution(pos + 1, (r + (card.first)) % 10));
} else {
ret = max(ret,
card.second.first + solution(pos + 1, (r + (card.first)) % 10));
}
}
ret = max(ret, solution(pos + 1, r));
return ret;
}
int main() {
memset(dp, -1, sizeof(dp));
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
scanf("%d", &k);
vector<int> card[4];
for (int j = 0; j < k; j++) {
scanf("%d %d", &a, &b);
card[a].push_back(b);
}
for (int j = 1; j <= 3; j++) {
sort(card[j].rbegin(), card[j].rend());
}
pair<long long, long long> cost[4] = {};
long long sum = 0;
for (int i = 0; i < card[1].size(); i++) {
sum += card[1][i];
if (i <= 2) {
cost[i + 1] = {sum, card[1][0]};
} else
break;
}
if (!card[2].empty()) {
if (cost[1].first < card[2][0]) {
cost[1].first = card[2][0];
cost[1].second = card[2][0];
}
if (!card[1].empty()) {
if (cost[2].first < card[1][0] + card[2][0]) {
cost[2].first = card[1][0] + card[2][0];
cost[2].second = max(card[1][0], card[2][0]);
}
}
}
if (!card[3].empty()) {
if (cost[1].first < card[3][0]) {
cost[1].first = card[3][0];
cost[1].second = card[3][0];
}
}
for (int j = 1; j <= 3; j++) {
if (cost[j].first != 0) {
turn[i].push_back({j, cost[j]});
}
}
}
printf("%lld\n", solution(0, 0));
}
|
#include <bits/stdc++.h>
using namespace std;
int n, k;
bool mark[10][200010];
long long memo[10][200010];
vector<int> t[4][200010];
long long dp(int turn, int cards) {
if (turn == n) return 0;
long long& ans = memo[cards][turn];
if (mark[cards][turn]) return ans;
mark[cards][turn] = true;
ans = dp(turn + 1, cards);
long long dmg;
if (t[3][turn].size()) {
dmg = t[3][turn][0];
if (cards == 9) dmg *= 2LL;
ans = max(ans, dp(turn + 1, (cards + 1) % 10) + dmg);
}
if (t[1][turn].size()) {
int l = t[1][turn].size();
dmg = t[1][turn][0];
if (cards == 9) dmg *= 2LL;
ans = max(ans, dp(turn + 1, (cards + 1) % 10) + dmg);
if (l >= 2) {
dmg = t[1][turn][0];
if (cards >= 8) dmg *= 2LL;
ans = max(ans, dp(turn + 1, (cards + 2) % 10) + dmg + t[1][turn][1]);
}
if (l >= 3) {
dmg = t[1][turn][0];
if (cards >= 7) dmg *= 2LL;
ans = max(ans, dp(turn + 1, (cards + 3) % 10) + dmg + t[1][turn][1] +
t[1][turn][2]);
}
}
if (t[2][turn].size()) {
dmg = t[2][turn][0];
if (cards == 9) dmg *= 2LL;
ans = max(ans, dp(turn + 1, (cards + 1) % 10) + dmg);
if (t[1][turn].size()) {
long long a = t[2][turn][0], b = t[1][turn][0];
if (cards >= 8 && a > b) {
a *= 2LL;
} else if (cards >= 8) {
b *= 2LL;
}
dmg = a + b;
ans = max(ans, dp(turn + 1, (cards + 2) % 10) + dmg);
}
}
return ans;
}
int main() {
scanf("%d", &n);
for (int i = 0; i < n; i++) {
scanf("%d", &k);
for (int j = 0; j < k; j++) {
int ci, di;
scanf("%d %d", &ci, &di);
t[ci][i].push_back(di);
}
for (int j = 1; j <= 3; j++)
sort(t[j][i].begin(), t[j][i].end(), greater<int>());
}
printf("%lld\n", dp(0, 0));
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int mod = 1000000007;
const int base = 311;
const int N = 2e5 + 5;
int n;
long long dp[2][15];
vector<int> v[5];
void umax(long long &a, long long b) { a = max(a, b); }
void solved() {
cin >> n;
for (int i = 0; i <= 9; ++i) dp[0][i] = dp[1][i] = -1e15;
dp[0][0] = 0;
for (int i = 1; i <= n; ++i) {
int num;
cin >> num;
for (int j = 1; j <= 3; ++j) v[j].clear();
for (int j = 1; j <= num; ++j) {
int cost, st;
cin >> cost >> st;
v[cost].push_back(st);
}
for (int j = 1; j <= 3; ++j)
sort((v[j]).begin(), (v[j]).end(), greater<int>());
for (int j = 0; j <= 9; ++j) {
if (dp[0][j] < 0) continue;
umax(dp[1][j], dp[0][j]);
long long val = 0;
for (int k = 1; k <= min(3, int((v[1]).size())); ++k) {
int c = (k + j) % 10;
val += v[1][k - 1];
if (!c) val += v[1][0];
umax(dp[1][c], dp[0][j] + val);
}
if (int((v[2]).size())) {
long long val = v[2][0];
if (j + 1 == 10) val *= 2;
umax(dp[1][(j + 1) % 10], dp[0][j] + val);
}
if (int((v[1]).size()) && int((v[2]).size())) {
long long val = v[2][0] + v[1][0];
if (j + 2 >= 10) val += max(v[2][0], v[1][0]);
umax(dp[1][(j + 2) % 10], dp[0][j] + val);
}
if (int((v[3]).size())) {
long long val = v[3][0];
if (j + 1 == 10) val *= 2;
umax(dp[1][(j + 1) % 10], dp[0][j] + val);
}
}
for (int j = 0; j <= 9; ++j) dp[0][j] = dp[1][j], dp[1][j] = -1e15;
}
long long ans = 0;
for (int i = 0; i <= 9; ++i) ans = max(ans, dp[0][i]);
cout << ans;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
if (fopen("codeforces"
".inp",
"r")) {
freopen(
"codeforces"
".inp",
"r", stdin);
freopen(
"codeforces"
".out",
"w", stdout);
}
solved();
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int n;
cin >> n;
long long dp[10];
dp[0] = 0;
for (int i = 1; i < 10; ++i) {
dp[i] = -1e18;
}
while (n-- > 0) {
int k;
cin >> k;
multiset<long long> us[3];
for (int i = 0; i < k; ++i) {
long long a, b;
cin >> a >> b;
--a;
b = -b;
us[a].insert(b);
}
long long temp[10];
for (int i = 0; i < 10; ++i) {
temp[i] = dp[i];
}
if (us[2].size()) {
for (int i = 0; i < 10; ++i) {
if (dp[i] == -1e18) continue;
int to = (i + 1) % 10;
if (to) {
temp[to] = max(temp[to], dp[i] - *us[2].begin());
} else {
temp[to] = max(temp[to], dp[i] - (*us[2].begin()) * (long long)2);
}
}
}
if (us[1].size()) {
for (int i = 0; i < 10; ++i) {
if (dp[i] == -1e18) continue;
int to = (i + 1) % 10;
if (to) {
temp[to] = max(temp[to], dp[i] - *us[1].begin());
} else {
temp[to] = max(temp[to], dp[i] - (*us[1].begin()) * (long long)2);
}
}
}
if (us[1].size() && us[0].size()) {
long long kek = 0;
kek -= *us[1].begin();
kek -= *us[0].begin();
long long mx = max(-*us[1].begin(), -*us[0].begin());
for (int i = 0; i < 10; ++i) {
if (dp[i] == -1e18) continue;
int to = (i + 2) % 10;
if (to > i) {
temp[to] = max(temp[to], dp[i] + kek);
} else {
temp[to] = max(temp[to], dp[i] + kek + mx);
}
}
}
if (us[0].size()) {
if (us[0].size() >= 1) {
long long kek = -*us[0].begin();
long long mx = kek;
for (int i = 0; i < 10; ++i) {
if (dp[i] == -1e18) continue;
int to = (i + 1) % 10;
if (to) {
temp[to] = max(temp[to], dp[i] + kek);
} else {
temp[to] = max(temp[to], dp[i] + kek + mx);
}
}
}
if (us[0].size() >= 2) {
long long kek = -*us[0].begin();
long long mx = kek;
long long last = *us[0].begin();
us[0].erase(us[0].begin());
kek -= *us[0].begin();
mx = max(mx, -*us[0].begin());
for (int i = 0; i < 10; ++i) {
if (dp[i] == -1e18) continue;
int to = (i + 2) % 10;
if (to > i) {
temp[to] = max(temp[to], dp[i] + kek);
} else {
temp[to] = max(temp[to], dp[i] + kek + mx);
}
}
us[0].insert(last);
}
if (us[0].size() >= 3) {
long long kek = -*us[0].begin();
long long mx = kek;
us[0].erase(us[0].begin());
kek -= *us[0].begin();
mx = max(mx, -*us[0].begin());
us[0].erase(us[0].begin());
kek -= *us[0].begin();
mx = max(mx, -*us[0].begin());
for (int i = 0; i < 10; ++i) {
if (dp[i] == -1e18) continue;
int to = (i + 3) % 10;
if (to > i) {
temp[to] = max(temp[to], dp[i] + kek);
} else {
temp[to] = max(temp[to], dp[i] + kek + mx);
}
}
}
}
for (int i = 0; i < 10; ++i) {
dp[i] = temp[i];
}
}
long long ans = -1e18;
for (int i = 0; i < 10; ++i) {
ans = max(ans, dp[i]);
}
cout << ans << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
const double EPS = 1e-9;
const long long MOD = 998244353;
const int inf = 1 << 30;
const long long linf = 1LL << 60;
const double PI = 3.14159265358979323846;
int n;
int ho = 0, ge = 1;
long long dp[2][10];
long long len[3];
long long num[3][200000];
int main() {
scanf("%d", &n);
for (int i = 1; i < 10; i++) dp[ho][i] = -linf;
for (int i = 0; i < n; i++) {
int k;
scanf("%d", &k);
for (int j = 0; j < 3; j++) len[j] = 0;
for (int j = 0; j < k; j++) {
int c, d;
scanf("%d%d", &c, &d);
c--;
num[c][len[c]++] = d;
}
for (int j = 0; j < 3; j++)
sort(num[j], num[j] + len[j], greater<long long>());
for (int j = 0; j < 10; j++) dp[ge][j] = dp[ho][j];
for (int j = 0; j < 9; j++) {
if (len[0] == 0) continue;
dp[ge][j + 1] = max(dp[ge][j + 1], dp[ho][j] + num[0][0]);
}
if (len[0] != 0) dp[ge][0] = max(dp[ge][0], dp[ho][9] + num[0][0] * 2);
for (int j = 0; j < 9; j++) {
if (len[1] == 0) continue;
dp[ge][j + 1] = max(dp[ge][j + 1], dp[ho][j] + num[1][0]);
}
if (len[1] != 0) dp[ge][0] = max(dp[ge][0], dp[ho][9] + num[1][0] * 2);
for (int j = 0; j < 8; j++) {
if (len[0] <= 1) continue;
dp[ge][j + 2] = max(dp[ge][j + 2], dp[ho][j] + num[0][0] + num[0][1]);
}
if (len[0] > 1)
dp[ge][0] = max(dp[ge][0], dp[ho][8] + num[0][0] * 2 + num[0][1]);
if (len[0] > 1)
dp[ge][1] = max(dp[ge][1], dp[ho][9] + num[0][0] * 2 + num[0][1]);
for (int j = 0; j < 9; j++) {
if (len[2] == 0) continue;
dp[ge][j + 1] = max(dp[ge][j + 1], dp[ho][j] + num[2][0]);
}
if (len[2] != 0) dp[ge][0] = max(dp[ge][0], dp[ho][9] + num[2][0] * 2);
for (int j = 0; j < 8; j++) {
if (len[0] == 0 || len[1] == 0) continue;
dp[ge][j + 2] = max(dp[ge][j + 2], dp[ho][j] + num[0][0] + num[1][0]);
}
if (len[0] != 0 && len[1] != 0)
dp[ge][0] = max(dp[ge][0], dp[ho][8] + num[0][0] + num[1][0] +
max(num[0][0], num[1][0]));
if (len[0] != 0 && len[1] != 0)
dp[ge][1] = max(dp[ge][1], dp[ho][9] + num[0][0] + num[1][0] +
max(num[0][0], num[1][0]));
for (int j = 0; j < 7; j++) {
if (len[0] <= 2) continue;
dp[ge][j + 3] =
max(dp[ge][j + 3], dp[ho][j] + num[0][0] + num[0][1] + num[0][2]);
}
if (len[0] > 2)
dp[ge][0] =
max(dp[ge][0], dp[ho][7] + num[0][0] * 2 + num[0][1] + num[0][2]);
if (len[0] > 2)
dp[ge][1] =
max(dp[ge][1], dp[ho][8] + num[0][0] * 2 + num[0][1] + num[0][2]);
if (len[0] > 2)
dp[ge][2] =
max(dp[ge][2], dp[ho][9] + num[0][0] * 2 + num[0][1] + num[0][2]);
swap(ho, ge);
}
long long ans = 0;
for (int i = 0; i < 10; i++) ans = max(ans, dp[ho][i]);
printf("%lld\n", ans);
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 2e5 + 5;
inline int read() {
char c = getchar();
int t = 0, f = 1;
while (!isdigit(c)) {
if (c == '-') f = -1;
c = getchar();
}
while (isdigit(c)) {
t = (t << 3) + (t << 1) + (c ^ 48);
c = getchar();
}
return t * f;
}
int n;
struct node {
int c, d;
} a[maxn];
bool cmp(node a, node b) { return a.c == b.c ? a.d > b.d : a.c < b.c; }
long long g[maxn][7], a1[maxn][4], a2[maxn][3], a3[maxn][2];
long long f[maxn][10];
int main() {
n = read();
memset(g, ~0x3f, sizeof(g));
for (int i = 1; i <= n; i++) {
int k = read();
for (int j = 1; j <= k; j++) {
a[j].c = read(), a[j].d = read();
}
int tmp1 = 0, tmp2 = 0, tmp3 = 0;
sort(a + 1, a + 1 + k, cmp);
for (int j = 1; j <= k; j++) {
if (tmp1 < 3 && a[j].c == 1) {
a1[i][++tmp1] = a[j].d;
}
if (tmp2 < 1 && a[j].c == 2) {
a2[i][++tmp2] = a[j].d;
}
if (tmp3 < 1 && a[j].c == 3) {
a3[i][++tmp3] = a[j].d;
}
}
if (tmp1 > 0) g[i][1] = a1[i][1];
if (tmp1 > 1) g[i][2] = a1[i][1] + a1[i][2];
if (tmp1 > 2) g[i][3] = g[i][2] + a1[i][3];
if (tmp2 > 0) g[i][4] = a2[i][1];
if (tmp2 > 0 && tmp1 > 0) g[i][5] = a2[i][1] + a1[i][1];
if (tmp3 > 0) g[i][6] = a3[i][1];
}
memset(f, ~0x3f, sizeof(f));
f[0][0] = 0;
for (int i = 1; i <= n; i++) {
for (int j = 0; j <= 9; j++) f[i][j] = f[i - 1][j];
for (int j = 0; j <= 9; j++) {
f[i][(j + 1) % 10] =
max(f[i][(j + 1) % 10],
f[i - 1][j] + g[i][1] + ((j + 1) >= 10 ? a1[i][1] : 0));
f[i][(j + 2) % 10] =
max(f[i][(j + 2) % 10],
f[i - 1][j] + g[i][2] + ((j + 2) >= 10 ? a1[i][1] : 0));
f[i][(j + 3) % 10] =
max(f[i][(j + 3) % 10],
f[i - 1][j] + g[i][3] + ((j + 3) >= 10 ? a1[i][1] : 0));
f[i][(j + 1) % 10] =
max(f[i][(j + 1) % 10],
f[i - 1][j] + g[i][4] + ((j + 1) >= 10 ? a2[i][1] : 0));
f[i][(j + 2) % 10] =
max(f[i][(j + 2) % 10],
f[i - 1][j] + g[i][5] +
((j + 2) >= 10 ? max(a1[i][1], a2[i][1]) : 0));
f[i][(j + 1) % 10] =
max(f[i][(j + 1) % 10],
f[i - 1][j] + g[i][6] + ((j + 1) >= 10 ? a3[i][1] : 0));
}
}
long long ans = 0;
for (int i = 0; i <= 9; i++) {
ans = max(ans, f[n][i]);
}
printf("%lld\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 2e5 + 10;
const long long mod = 998244353;
const int inf = 0x3f3f3f3f;
const long long INF = 0x3f3f3f3f3f3f3f3f;
const double eps = 1e-7;
inline long long read() {
long long X = 0, w = 0;
char ch = 0;
while (!isdigit(ch)) {
w |= ch == '-';
ch = getchar();
}
while (isdigit(ch)) X = (X << 3) + (X << 1) + (ch ^ 48), ch = getchar();
return w ? -X : X;
}
struct node {
long long c11 = 0, c12 = 0, c13 = 0;
long long c2 = 0;
long long c3 = 0;
long long num1 = 0, num2 = 0, num3 = 0;
} arr[maxn];
long long dp[maxn][15];
int main() {
long long n = read();
memset(dp, -1, sizeof(dp));
dp[0][0] = 0;
for (int i = 1; i <= n; ++i) {
long long k = read();
for (int j = 1; j <= k; ++j) {
long long c = read(), d = read();
if (c == 1) {
arr[i].num1++;
if (d >= arr[i].c11) {
arr[i].c13 = arr[i].c12;
arr[i].c12 = arr[i].c11;
arr[i].c11 = d;
} else if (d >= arr[i].c12) {
arr[i].c13 = arr[i].c12;
arr[i].c12 = d;
} else if (d >= arr[i].c13) {
arr[i].c13 = d;
}
} else if (c == 2) {
arr[i].num2 = 1;
arr[i].c2 = max(arr[i].c2, d);
} else if (c == 3) {
arr[i].num3 = 1;
arr[i].c3 = max(arr[i].c3, d);
}
}
}
for (int i = 1; i <= n; ++i) {
for (int j = 0; j < 10; ++j) dp[i][j] = dp[i - 1][j];
for (int j = 0; j < 10; ++j) {
if (dp[i - 1][j] == -1) continue;
if (arr[i].num1 + arr[i].num2 + arr[i].num3 >= 1) {
dp[i][(j + 1) % 10] =
max(dp[i][(j + 1) % 10],
dp[i - 1][j] + max(arr[i].c11, max(arr[i].c2, arr[i].c3)) +
(j >= 9) * max(arr[i].c11, max(arr[i].c2, arr[i].c3)));
}
if (arr[i].num1 + arr[i].num2 >= 2) {
long long tmp1 = arr[i].c11, tmp2 = arr[i].c12;
if (arr[i].c2 > tmp1) {
tmp2 = tmp1;
tmp1 = arr[i].c2;
} else if (arr[i].c2 > tmp2) {
tmp2 = arr[i].c2;
}
dp[i][(j + 2) % 10] = max(dp[i][(j + 2) % 10],
dp[i - 1][j] + tmp1 + tmp2 + (j >= 8) * tmp1);
}
if (arr[i].num1 >= 3) {
dp[i][(j + 3) % 10] =
max(dp[i][(j + 3) % 10], dp[i - 1][j] + arr[i].c11 + arr[i].c12 +
arr[i].c13 + (j >= 7) * arr[i].c11);
}
}
}
long long ans = -1;
for (int i = 0; i < 10; ++i) {
ans = max(dp[n][i], ans);
}
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long inf = 1.1e9 * 1LL * 1.1e9;
const int MX = 1e7;
int main() {
int n;
cin >> n;
vector<vector<long long>> dp(n + 1, vector<long long>(10, -inf));
dp[0][0] = 0;
for (int i = 0; i < n; i++) {
int k;
cin >> k;
vector<pair<int, int>> bst(k);
for (auto &x : bst) cin >> x.first >> x.second;
sort(bst.begin(), bst.end());
vector<vector<vector<long long>>> pd(
2, vector<vector<long long>>(4, vector<long long>(4, -inf)));
pd[0][0][0] = 0;
for (auto [c, d] : bst) {
auto pd2 = pd;
for (int i = 0; i < 3; i++) {
for (int j = 0; j < 3; j++) {
if (j + c <= 3) {
if (pd[0][i][j] != -inf) {
pd2[0][i + 1][j + c] = max(pd2[0][i + 1][j + c], pd[0][i][j] + d);
pd2[1][i + 1][j + c] =
max(pd2[1][i + 1][j + c], pd[0][i][j] + 2 * d);
}
if (pd[1][i][j] != -inf) {
pd2[1][i + 1][j + c] = max(pd2[1][i + 1][j + c], pd[1][i][j] + d);
}
}
}
}
pd = pd2;
}
for (int ost = 0; ost < 10; ost++) {
for (int cnt = 0; cnt <= 3; cnt++) {
for (int qq = 0; qq <= 3; qq++) {
dp[i + 1][(ost + cnt) % 10] =
max(dp[i + 1][(ost + cnt) % 10],
dp[i][ost] + pd[ost + cnt >= 10][cnt][qq]);
}
}
}
}
cout << *max_element(dp[n].begin(), dp[n].end()) << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
long long power(long long a, long long n) {
a %= 1000000007;
if (n == 1) return a;
if (n == 0) return 1;
if (n % 2)
return (a * (power((a * a) % 1000000007, n / 2) % 1000000007)) % 1000000007;
return power((a * a) % 1000000007, n / 2) % 1000000007;
}
const long long inf = (long long)1e18;
long long inverse(long long x) { return power(x, 1000000007 - 2) % 1000000007; }
long long n, dp[200005][15];
vector<long long> adj[200005][4];
long long solve2(long long pos, long long taken) {
if (pos > n) return 0;
long long &ans = dp[pos][taken];
if (ans != -1) return ans;
ans = 0;
if (!adj[pos][3].empty()) {
if (taken == 9)
ans = max(ans, 2 * adj[pos][3][0] + solve2(pos + 1, 0));
else
ans = max(ans, adj[pos][3][0] + solve2(pos + 1, taken + 1));
}
if (!adj[pos][2].empty()) {
if (taken == 9)
ans = max(ans, 2 * adj[pos][2][0] + solve2(pos + 1, 0));
else
ans = max(ans, adj[pos][2][0] + solve2(pos + 1, taken + 1));
if (!adj[pos][1].empty()) {
if (taken >= 8)
ans = max(ans, adj[pos][2][0] + adj[pos][1][0] +
max(adj[pos][2][0], adj[pos][1][0]) +
solve2(pos + 1, (taken + 2) % 10));
else
ans = max(ans,
adj[pos][2][0] + adj[pos][1][0] + solve2(pos + 1, taken + 2));
}
}
if (!adj[pos][1].empty()) {
if (taken == 9)
ans = max(ans, 2 * adj[pos][1][0] + solve2(pos + 1, 0));
else
ans = max(ans, adj[pos][1][0] + solve2(pos + 1, taken + 1));
if ((long long)adj[pos][1].size() > 1) {
if (taken >= 8)
ans = max(ans, 2 * adj[pos][1][0] + adj[pos][1][1] +
solve2(pos + 1, (taken + 2) % 10));
else
ans = max(ans,
adj[pos][1][0] + adj[pos][1][1] + solve2(pos + 1, taken + 2));
}
if ((long long)adj[pos][1].size() > 2) {
if (taken >= 7)
ans = max(ans, 2 * adj[pos][1][0] + adj[pos][1][1] + adj[pos][1][2] +
solve2(pos + 1, (taken + 3) % 10));
else
ans = max(ans, adj[pos][1][0] + adj[pos][1][1] + adj[pos][1][2] +
solve2(pos + 1, taken + 3));
}
}
ans = max(ans, solve2(pos + 1, taken));
return ans;
}
void solve() {
cin >> n;
for (long long i = 1; i < n + 1; ++i) {
long long k;
cin >> k;
for (long long j = 1; j < k + 1; ++j) {
long long c, d;
cin >> c >> d;
adj[i][c].push_back(d);
sort(adj[i][c].begin(), adj[i][c].end(), greater<long long>());
if (c == 3 || c == 2) {
while ((long long)adj[i][c].size() > 1) adj[i][c].pop_back();
} else
while ((long long)adj[i][c].size() > 3) adj[i][c].pop_back();
}
}
memset(dp, -1, sizeof dp);
cout << solve2(1, 0) << "\n";
}
signed main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
;
long long T = 1;
for (long long t = 1; t < T + 1; ++t) {
solve();
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
vector<vector<long long>> memo(2e5 + 10, vector<long long>(11, -1));
long long ks(vector<vector<vector<long long>>> &v, long long n, long long c) {
if (n >= v.size()) return 0;
if (memo[n][c] != -1) return memo[n][c];
long long n11, n12, n13, n2, n21, n3;
sort(v[n][1].rbegin(), v[n][1].rend());
sort(v[n][2].rbegin(), v[n][2].rend());
sort(v[n][3].rbegin(), v[n][3].rend());
n11 = n12 = n13 = n2 = n21 = n3 = 0;
if (v[n][1].size() >= 1) {
n11 = v[n][1][0] + ks(v, n + 1, (c + 1) % 10);
if (c + 1 >= 10) n11 += v[n][1][0];
}
if (v[n][1].size() >= 2) {
n12 = v[n][1][0] + v[n][1][1] + ks(v, n + 1, (c + 2) % 10);
if (c + 2 >= 10) n12 += v[n][1][0];
}
if (v[n][1].size() >= 3) {
n13 = v[n][1][0] + v[n][1][1] + v[n][1][2] + ks(v, n + 1, (c + 3) % 10);
if (c + 3 >= 10) n13 += v[n][1][0];
}
if (v[n][2].size() >= 1) {
n2 = v[n][2][0] + ks(v, n + 1, (c + 1) % 10);
if (c + 1 >= 10) n2 += v[n][2][0];
}
if (v[n][2].size() >= 1 && v[n][1].size() >= 1) {
n21 = v[n][2][0] + ks(v, n + 1, (c + 2) % 10) + v[n][1][0];
if (c + 2 >= 10) n21 += max(v[n][2][0], v[n][1][0]);
}
if (v[n][3].size() >= 1) {
n3 = v[n][3][0] + ks(v, n + 1, (c + 1) % 10);
if (c + 1 >= 10) n3 += v[n][3][0];
}
long long no = ks(v, n + 1, c);
memo[n][c] = max(n11, n12);
memo[n][c] = max(memo[n][c], n13);
memo[n][c] = max(memo[n][c], n2);
memo[n][c] = max(memo[n][c], n21);
memo[n][c] = max(memo[n][c], n3);
memo[n][c] = max(memo[n][c], no);
return memo[n][c];
}
signed main() {
long long n;
cin >> n;
vector<vector<vector<long long>>> v(n, vector<vector<long long>>(4));
for (long long i = 0; i < n; i++) {
long long k;
cin >> k;
for (long long j = 0; j < k; j++) {
long long a, b;
cin >> a >> b;
v[i][a].push_back(b);
}
}
cout << ks(v, 0, 0);
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 1000005;
long long N;
long long nk[MAXN];
long long c1_tmp[MAXN], c1[MAXN][4], c2[MAXN], c3[MAXN];
long long dp[MAXN][11], z[7][3];
bool cmp(long long a, long long b) { return a > b; }
int main() {
scanf("%I64d", &N);
int tyf;
for (int i = 1; i <= N; i++) {
int ccnt = 0, len = 0, len2 = 0, len3 = 0;
c2[i] = -1;
c3[i] = -1;
scanf("%I64d", &nk[i]);
for (int j = 1; j <= nk[i]; j++) {
long long cst, cx;
scanf("%I64d%I64d", &cst, &cx);
if (cst == 1) c1_tmp[++ccnt] = cx;
if (cst == 2) c2[i] = max(c2[i], cx), len2 = 1;
if (cst == 3) c3[i] = max(c3[i], cx), len3 = 1;
}
sort(c1_tmp + 1, c1_tmp + ccnt + 1, cmp);
c1[i][1] = c1[i][2] = c1[i][3] = -1;
if (ccnt >= 1) c1[i][1] = c1_tmp[1], ++len;
if (ccnt >= 2) c1[i][2] = c1_tmp[2], ++len;
if (ccnt >= 3) c1[i][3] = c1_tmp[3], ++len;
if (i == 1) tyf = len + len2 + len3;
}
for (int i = 0; i <= N; i++) {
for (int j = 0; j <= 9; j++) {
dp[i][j] = -1e18;
}
}
dp[0][0] = 0;
for (int i = 1; i <= N; i++) {
vector<pair<long long, long long> > vm;
for (int j = 0; j <= 3; j++) z[j][0] = z[j][1] = -1e18;
z[0][0] = 0;
if (c1[i][3] != -1) vm.push_back(make_pair(1, c1[i][3]));
if (c1[i][2] != -1) vm.push_back(make_pair(1, c1[i][2]));
if (c1[i][1] != -1) vm.push_back(make_pair(1, c1[i][1]));
if (c2[i] != -1) vm.push_back(make_pair(2, c2[i]));
if (c3[i] != -1) vm.push_back(make_pair(3, c3[i]));
do {
long long cnt = 0, res = 0, mx = 0, nums = 0;
for (int j = 0; j < vm.size(); j++) {
pair<long long, long long> cur = vm[j];
if (cnt + cur.first > 3) break;
cnt += cur.first;
++nums;
res += cur.second;
mx = max(mx, cur.second);
z[nums][0] = max(z[nums][0], res);
z[nums][1] = max(z[nums][1], res + mx);
}
} while (next_permutation(vm.begin(), vm.end()));
for (int j = 0; j < 10; j++) {
for (int k = 0; k <= 3; k++) {
int fg = 0;
if (j + k >= 10) fg = 1;
dp[i][(j + k) % 10] = max(dp[i][(j + k) % 10], dp[i - 1][j] + z[k][fg]);
}
}
vm.clear();
}
long long ans = 0;
for (int j = 0; j <= 9; j++) ans = max(ans, dp[N][j]);
printf("%I64d\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
void __print(int x) { cerr << x; }
void __print(long x) { cerr << x; }
void __print(long long x) { cerr << x; }
void __print(unsigned x) { cerr << x; }
void __print(unsigned long x) { cerr << x; }
void __print(unsigned long long x) { cerr << x; }
void __print(float x) { cerr << x; }
void __print(double x) { cerr << x; }
void __print(long double x) { cerr << x; }
void __print(char x) { cerr << '\'' << x << '\''; }
void __print(const char *x) { cerr << '\"' << x << '\"'; }
void __print(const string &x) { cerr << '\"' << x << '\"'; }
void __print(bool x) { cerr << (x ? "true" : "false"); }
template <typename T, typename V>
void __print(const pair<T, V> &x) {
cerr << '{';
__print(x.first);
cerr << ',';
__print(x.second);
cerr << '}';
}
template <typename T>
void __print(const T &x) {
int f = 0;
cerr << '{';
for (auto &i : x) cerr << (f++ ? "," : ""), __print(i);
cerr << "}";
}
void _print() { cerr << "]\n"; }
template <typename T, typename... V>
void _print(T t, V... v) {
__print(t);
if (sizeof...(v)) cerr << ", ";
_print(v...);
}
long long binpow(long long x, long long y) {
long long res = 1;
while (y > 0) {
if (y & 1) res = (res * x);
y = y >> 1;
x = (x * x);
}
return res;
}
long long binpowmod(long long x, long long y, long long p) {
long long res = 1;
x = x % p;
while (y > 0) {
if (y & 1) res = (res * x) % p;
y = y >> 1;
x = (x * x) % p;
}
return res;
}
long long mod_inverse(long long n, long long p) {
return binpowmod(n, p - 2, p);
}
long long gcd(long long x, long long y) {
if (y == 0) return x;
return gcd(y, x % y);
}
bool comp_pairs_by_s(pair<long long, long long> &x,
pair<long long, long long> &y) {
return x.second < y.second;
}
bool isPowerOfTwo(long long x) { return x && (!(x & (x - 1))); }
class cmp {
public:
bool operator()(pair<int, int> A, pair<int, int> B) {
if (abs(A.first - A.second) == abs(B.first - B.second))
return A.first > B.first;
return abs(A.first - A.second) < abs(B.first - B.second);
}
};
void swap(int &x, int &y) {
int temp = x;
x = y;
y = temp;
}
unsigned int onesComplement(unsigned int n) {
int number_of_bits = floor(log2(n)) + 1;
return ((1 << number_of_bits) - 1) ^ n;
}
bool comp1(pair<int, int> x, pair<int, int> y) { return x.second < y.second; }
void solve() {
int n;
cin >> n;
vector<long long> dp(10, -100000000000000);
dp[0] = 0;
long long ans = 0;
while (n--) {
int k;
cin >> k;
vector<long long> card[3];
for (int i = 0; i < 3; ++i) card[i].clear();
for (int i = 0; i < k; ++i) {
long long c, d;
cin >> c >> d;
card[--c].push_back(d);
}
for (int i : {0, 1, 2})
sort(card[i].begin(), card[i].end(), greater<long long>());
vector<long long> tmpdp(10, -100000000000000);
tmpdp[0] = dp[0];
auto updDP = [&](long long maxd, long long last, int cnt) {
for (int i = 0; i < 10; ++i) {
if ((i + cnt) >= 10 and dp[i] != -100000000000000)
tmpdp[(i + cnt) % 10] =
max(tmpdp[(i + cnt) % 10], dp[i] + maxd + last);
else if (dp[i] != -100000000000000)
tmpdp[(i + cnt) % 10] = max(tmpdp[(i + cnt) % 10], dp[i] + maxd);
}
};
updDP(0, 0, 0);
if (card[0].size()) updDP(card[0][0], card[0][0], 1);
if (card[1].size()) updDP(card[1][0], card[1][0], 1);
if (card[2].size()) updDP(card[2][0], card[2][0], 1);
if (card[0].size() >= 2) updDP(card[0][0] + card[0][1], card[0][0], 2);
if (card[0].size() and card[1].size())
updDP(card[0][0] + card[1][0], max(card[0][0], card[1][0]), 2);
if (card[0].size() >= 3)
updDP(card[0][0] + card[0][1] + card[0][2], card[0][0], 3);
dp = tmpdp;
for (int i = 0; i < 10; ++i) ans = max(ans, dp[i]);
;
}
cout << ans;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout << fixed << setprecision(15);
solve();
}
|
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
const ll mod = 1000000007;
const ll INF = 1001001001001001001;
const int MAX = 1e5 + 5;
template <class T>
inline bool chmax(T& a, T b) {
if (a < b) {
a = b;
return true;
}
return false;
}
ll dp[10][200005];
int main() {
int n;
cin >> n;
for (int i = 0; i < 10; i++) {
for (int j = 0; j < 200005; j++) {
dp[i][j] = -INF;
}
}
for (int i = 1; i <= n; i++) {
int k;
cin >> k;
vector<ll> c1(3, 0);
ll c2 = 0, c3 = 0;
for (int j = 0; j < k; j++) {
ll a, b;
cin >> a >> b;
if (a == 1) c1.push_back(b);
if (a == 2) c2 = max(c2, b);
if (a == 3) c3 = max(c3, b);
}
sort(c1.begin(), c1.end(), greater<ll>());
vector<vector<ll>> m(4, vector<ll>(2, 0));
m[1][0] = max(c2, max(c3, c1[0]));
m[1][1] = 2 * m[1][0];
m[2][0] = max(c2 + c1[0], c1[0] + c1[1]);
if (m[2][0] == c2 || m[2][0] == c1[0]) m[2][0] = 0;
m[2][1] = max(c2 + 2 * c1[0], max(2 * c2 + c1[0], 2 * c1[0] + c1[1]));
m[3][0] = c1[0] + c1[1] + c1[2];
if (c1[0] == 0 || c1[1] == 0 || c1[2] == 0) m[3][0] = 0;
m[3][1] = 2 * c1[0] + c1[2] + c1[1];
dp[0][0] = 0;
for (int j = 0; j < 10; j++) {
for (int k = 0; k <= 3; k++) {
if (j + k < 10) {
if (k == 0 || m[k][0] != 0)
chmax(dp[j + k][i], dp[j][i - 1] + m[k][0]);
} else {
if (m[k][0] != 0) chmax(dp[(j + k) % 10][i], dp[j][i - 1] + m[k][1]);
}
}
}
}
ll ans = 0;
for (int i = 0; i < 10; i++) {
ans = max(dp[i][n], ans);
}
cout << ans << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
template <class c>
struct rge {
c b, e;
};
template <class c>
rge<c> range(c i, c j) {
return rge<c>{i, j};
}
template <class c>
auto dud(c* x) -> decltype(cerr << *x, 0);
template <class c>
char dud(...);
struct debug {
template <class c>
debug& operator<<(const c&) {
return *this;
}
};
long long INF64 = 1e18;
long long mod = 1e9 + 7;
int INF = 1e9;
long long fastpow(long long a, long long b, long long m) {
a %= m;
long long res = 1;
while (b > 0) {
if (b & 1) res = res * a % m;
a = a * a % m;
b >>= 1;
}
return res;
}
void test_case(int tnum) {
int n, m;
cin >> n;
vector<vector<long long>> dp(n + 1, vector<long long>(11, -INF64));
for (int i = 0; i <= n; i++) {
dp[i][0] = 0;
}
for (int i = 1; i <= n; i++) {
vector<vector<long long>> c(3);
cin >> m;
for (int j = 0; j < m; j++) {
long long cost, dam;
cin >> cost >> dam;
--cost;
c[cost].push_back(dam);
}
for (int j = 0; j <= 10; j++) {
dp[i][j] = dp[i - 1][j];
}
for (int j = 0; j < 3; j++) {
for (int k = 0; k < 3; k++) {
c[j].push_back(-INF64);
}
sort(begin(c[j]), end(c[j]), greater<long long>());
}
vector<vector<long long>> mx(3);
mx[2] = {c[0][0], c[0][1], c[0][2]};
mx[1] = {c[0][0], max(c[0][1], c[1][0])};
mx[0] = {max({c[0][0], c[1][0], c[2][0]})};
for (int j = 0; j < 3; j++) {
sort(begin(mx[j]), end(mx[j]), greater<long long>());
}
for (int rem = 0; rem < 3; rem++) {
for (int play = 1; play <= 3; play++) {
if (10 - play + rem >= 10 or dp[i - 1][10 - play + rem] < 0) continue;
long long sum = 0;
for (int j = 1; j < play; j++) {
sum += mx[play - 1][j];
}
dp[i][rem] = max(dp[i][rem], dp[i - 1][10 - play + rem] + sum +
(2 * mx[play - 1][0]));
}
}
for (int rounds = 1; rounds < 10; rounds++) {
for (int play = 1; play <= 3; play++) {
if (rounds - play < 0 or dp[i - 1][rounds - play] < 0) continue;
long long sum = 0;
for (int j = 0; j < play; j++) {
sum += mx[play - 1][j];
}
dp[i][rounds] = max(dp[i][rounds], dp[i - 1][rounds - play] + sum);
}
}
debug() << " ["
<< "dp[i]"
": "
<< (dp[i])
<< "] "
" ["
<< "i"
": "
<< (i) << "] ";
}
long long ans = 0;
for (int i = 0; i <= 10; i++) {
ans = max(ans, dp[n][i]);
}
cout << ans << '\n';
}
int main(void) {
cin.tie(0);
ios_base::sync_with_stdio(false);
int t = 1;
for (int test = 1; test <= t; test++) {
test_case(test);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
vector<long long> dp(10, INT64_MIN / 16), tp(10, 0);
dp[0] = 0;
for (int i = 0; i < n; i++) {
int k;
cin >> k;
long long m11 = INT64_MIN / 4, m12 = INT64_MIN / 4, m13 = INT64_MIN / 4,
m20 = INT64_MIN / 4, m30 = INT64_MIN / 4;
for (int j = 0; j < k; j++) {
long long cost, damage;
cin >> cost >> damage;
if (cost == 1 && damage > m11) {
m13 = m12;
m12 = m11;
m11 = damage;
} else if (cost == 1 && damage > m12) {
m13 = m12;
m12 = damage;
} else if (cost == 1 && damage > m13)
m13 = damage;
else if (cost == 2)
m20 = max(m20, damage);
else if (cost == 3)
m30 = max(m30, damage);
}
long long d1 = max(m11, max(m20, m30)), d2 = max(m11 + m12, m11 + m20),
d3 = m11 + m12 + m13;
long long b1 = d1, b2 = max(m11, m20), b3 = m11;
tp = vector<long long>(dp);
for (int j = 0; j < 10; j++) {
if (d1 > 0)
dp[(j + 1) % 10] =
max(dp[(j + 1) % 10], d1 + tp[j] + (j + 1 >= 10 ? b1 : 0));
if (d2 > 0)
dp[(j + 2) % 10] =
max(dp[(j + 2) % 10], d2 + tp[j] + (j + 2 >= 10 ? b2 : 0));
if (d3 > 0)
dp[(j + 3) % 10] =
max(dp[(j + 3) % 10], d3 + tp[j] + (j + 3 >= 10 ? b3 : 0));
}
}
cout << *max_element(dp.begin(), dp.end()) << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 200000;
long long dp[N][10];
int n;
vector<vector<long long> > arr[N];
long long solve(int i, int mod) {
if (i == n) return 0;
if (dp[i][mod]) return dp[i][mod];
long long ans = solve(i + 1, mod);
if (arr[i][3].size())
ans = max(ans,
solve(i + 1, (mod + 1) % 10) + arr[i][3][0] * (mod == 9 ? 2 : 1));
if (arr[i][2].size())
ans = max(ans,
solve(i + 1, (mod + 1) % 10) + arr[i][2][0] * (mod == 9 ? 2 : 1));
if (arr[i][1].size())
ans = max(ans,
solve(i + 1, (mod + 1) % 10) + arr[i][1][0] * (mod == 9 ? 2 : 1));
if (arr[i][1].size() && arr[i][2].size()) {
int maxi = max(arr[i][1][0], arr[i][2][0]);
int mini = min(arr[i][1][0], arr[i][2][0]);
ans = max(ans,
solve(i + 1, (mod + 2) % 10) + mini + maxi * (mod >= 8 ? 2 : 1));
}
if (arr[i][1].size() >= 2) {
ans = max(ans, solve(i + 1, (mod + 2) % 10) + arr[i][1][1] +
arr[i][1][0] * (mod >= 8 ? 2 : 1));
}
if (arr[i][1].size() >= 3) {
ans = max(ans, solve(i + 1, (mod + 3) % 10) + arr[i][1][2] + arr[i][1][1] +
arr[i][1][0] * (mod >= 7 ? 2 : 1));
}
return dp[i][mod] = ans;
}
int main() {
scanf("%d", &n);
for (int i = 0; i < n; i++) {
int m;
scanf("%d", &m);
vector<vector<long long> > cards(4);
while (m--) {
long long x, y;
scanf("%lld%lld", &x, &y);
cards[x].push_back(y);
}
sort(cards[1].rbegin(), cards[1].rend());
sort(cards[2].rbegin(), cards[2].rend());
sort(cards[3].rbegin(), cards[3].rend());
arr[i] = cards;
}
printf("%lld", solve(0, 0));
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long int dp[int(2e5 + 100)][10];
long long int sz[] = {0, 3, 1, 1};
int main() {
long long int n, k, c, d, sum, m;
vector<long long int> v[4];
cin >> n;
for (long long int j = 1; j < 10; j++) dp[0][j] = INT_MIN;
for (long long int i = 1; i <= n; i++) {
cin >> k;
for (long long int j = 0; j < 10; j++) dp[i][j] = dp[i - 1][j];
while (k--) {
cin >> c >> d;
v[c].push_back(d);
}
for (long long int j = 1; j <= 3; j++) {
sort(v[j].begin(), v[j].end(), greater<long long int>());
while (v[j].size() > sz[j]) v[j].pop_back();
}
if (v[1].size() == 3) {
sum = v[1][0] + v[1][1] + v[1][2];
m = v[1][0];
for (long long int j = 0; j < 10; j++) {
if (dp[i - 1][j] == INT_MIN) continue;
if (j + 3 < 10)
dp[i][j + 3] = max(dp[i][j + 3], sum + dp[i - 1][j]);
else
dp[i][(j + 3) % 10] =
max(dp[i][(j + 3) % 10], sum + dp[i - 1][j] + m);
}
}
if (v[1].size() > 1 || (v[2].size() == 1 && v[1].size())) {
sum = m = 0;
if (v[2].size() == 1 && v[1].size()) {
sum = v[2][0] + v[1][0];
m = max(v[2][0], v[1][0]);
}
if (v[1].size() > 1 && sum < v[1][0] + v[1][1]) {
sum = v[1][0] + v[1][1];
m = v[1][0];
}
for (long long int j = 0; j < 10; j++) {
if (dp[i - 1][j] == INT_MIN) continue;
if (j + 2 < 10)
dp[i][j + 2] = max(dp[i][j + 2], sum + dp[i - 1][j]);
else
dp[i][(j + 2) % 10] =
max(dp[i][(j + 2) % 10], sum + dp[i - 1][j] + m);
}
}
if (v[3].size() || v[2].size() || v[1].size()) {
sum = max(((v[1].size() == 0) ? 0 : v[1][0]),
max(((v[2].size() == 0) ? 0 : v[2][0]),
((v[3].size() == 0) ? 0 : v[3][0])));
m = sum;
for (long long int j = 0; j < 10; j++) {
if (dp[i - 1][j] == INT_MIN) continue;
if (j + 1 < 10)
dp[i][j + 1] = max(dp[i][j + 1], sum + dp[i - 1][j]);
else
dp[i][(j + 1) % 10] =
max(dp[i][(j + 1) % 10], sum + dp[i - 1][j] + m);
}
}
for (long long int j = 1; j <= 3; j++) v[j].clear();
}
cout << *max_element(dp[n], dp[n] + 10) << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 205001;
const long double PI = acos(-1);
int n;
long long dp[N][15];
struct b {
long long t = -100000000000000000, tt = -100000000000000000;
vector<long long> o;
void done() {
sort(o.begin(), o.end());
reverse(o.begin(), o.end());
while (o.size() > 3) o.pop_back();
while (o.size() < 3) o.push_back(-100000000000000000);
sort(o.begin(), o.end());
reverse(o.begin(), o.end());
}
} a[N];
long long calc(int idx, int tc) {
if (idx == n) return 0;
long long& ret = dp[idx][tc];
if (ret != -1) return ret;
ret = calc(idx + 1, tc);
vector<long long>& o = a[idx].o;
if (tc >= 7) {
if (o[2] > -100000000000000000)
ret = max(ret, calc(idx + 1, (tc + 3) % 10) + a[idx].o[0] + a[idx].o[0] +
a[idx].o[1] + a[idx].o[2]);
}
if (tc >= 9) {
if (a[idx].t > -100000000000000000)
ret = max(ret, calc(idx + 1, (tc + 1) % 10) + a[idx].t + a[idx].t);
if (a[idx].tt > -100000000000000000)
ret = max(ret, calc(idx + 1, (tc + 1) % 10) + a[idx].tt + a[idx].tt);
if (o[0] > -100000000000000000)
ret = max(ret, calc(idx + 1, (tc + 1) % 10) + o[0] + o[0]);
}
if (tc >= 8) {
if (a[idx].t > -100000000000000000 && o[0] > -100000000000000000)
ret = max(ret, calc(idx + 1, (tc + 2) % 10) + a[idx].t + a[idx].o[0] +
max(a[idx].t, a[idx].o[0]));
if (o[0] > -100000000000000000)
ret = max(ret, calc(idx + 1, (tc + 2) % 10) + a[idx].o[0] + a[idx].o[0] +
a[idx].o[1]);
}
if (a[idx].t > -100000000000000000 && tc != 9)
ret = max(ret, calc(idx + 1, (tc + 1) % 10) + a[idx].t);
if (a[idx].tt > -100000000000000000 && tc != 9)
ret = max(ret, calc(idx + 1, (tc + 1) % 10) + a[idx].tt);
if (o[0] > -100000000000000000 && tc != 9)
ret = max(ret, calc(idx + 1, (tc + 1) % 10) + a[idx].o[0]);
if (a[idx].t > -100000000000000000 && o[0] > -100000000000000000 && tc != 8)
ret = max(ret, calc(idx + 1, (tc + 2) % 10) + a[idx].t + a[idx].o[0]);
if (o[1] > -100000000000000000 && tc != 8)
ret = max(ret, calc(idx + 1, (tc + 2) % 10) + a[idx].o[1] + a[idx].o[0]);
if (o[2] > -100000000000000000 && tc != 7)
ret = max(ret, calc(idx + 1, (tc + 3) % 10) + a[idx].o[1] + a[idx].o[2] +
a[idx].o[0]);
return ret;
}
signed main() {
cin >> n;
for (long long i = 0, k, x, y; i < n; i++) {
cin >> k;
for (int j = 0; j < k; j++) {
scanf("%lld%lld", &x, &y);
if (x == 1) a[i].o.push_back(y);
if (x == 2) a[i].t = max(a[i].t, y);
if (x == 3) a[i].tt = max(a[i].tt, y);
}
a[i].done();
}
memset(dp, -1, sizeof dp);
cout << calc(0, 0) << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
struct note {
int c, d;
} g[200100];
int cmp(note a, note b) { return a.d < b.d; }
int n, m;
long long F[2][10], ans;
void update(int id, int len, long long val, int tar) {
for (int i = 0; i <= 9 - len; i++)
if (~F[id][i]) F[id ^ 1][i + len] = max(F[id ^ 1][i + len], F[id][i] + val);
for (int i = 9 - len + 1; i <= 9; i++)
if (~F[id][i])
F[id ^ 1][(i + len) % 10] =
max(F[id ^ 1][(i + len) % 10], F[id][i] + val + tar);
}
int main() {
scanf("%d", &n), memset(F[0], 0xff, sizeof F[0]), F[0][0] = 0;
for (int i = 1; i <= n; i++) {
scanf("%d", &m);
for (int j = 1; j <= m; j++) scanf("%d %d", &g[j].c, &g[j].d);
sort(g + 1, g + 1 + m, cmp);
for (int j = 0; j < 10; j++) F[i & 1][j] = F[i & 1 ^ 1][j];
int mx1[2] = {-1, -1}, mx2 = -1;
for (int j = 1; j <= m; j++) {
if (g[j].c == 1) {
int val = max(mx1[0], mx2);
if (val != -1) update(i & 1 ^ 1, 2, (long long)val + g[j].d, g[j].d);
if (mx1[0] != -1 && mx1[1] != -1)
update(i & 1 ^ 1, 3, (long long)mx1[0] + mx1[1] + g[j].d, g[j].d);
mx1[1] = mx1[0], mx1[0] = g[j].d;
}
if (g[j].c == 2) {
if (mx1[0] != -1)
update(i & 1 ^ 1, 2, (long long)mx1[0] + g[j].d, g[j].d);
mx2 = g[j].d;
}
}
update(i & 1 ^ 1, 1, (long long)g[m].d, g[m].d);
}
for (int i = 0; i < 10; i++) ans = max(ans, F[n & 1][i]);
printf("%lld\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n;
cin >> n;
vector<vector<long long> > foo(n);
for (long long i = 0; i < n; i++) {
long long k;
cin >> k;
vector<long long> bar[3];
for (long long j = 0; j < k; j++) {
long long c, d;
cin >> c;
cin >> d;
bar[c - 1].push_back(d);
}
if (!bar[0].empty()) sort(bar[0].rbegin(), bar[0].rend());
if (!bar[1].empty()) bar[1][0] = *max_element(bar[1].begin(), bar[1].end());
if (!bar[2].empty()) bar[2][0] = *max_element(bar[2].begin(), bar[2].end());
bar[0].resize(min((long long)bar[0].size(), 3ll));
bar[1].resize(min((long long)bar[1].size(), 1ll));
bar[2].resize(min((long long)bar[2].size(), 1ll));
bar[0].push_back(0);
bar[1].push_back(0);
bar[2].push_back(0);
foo[i].push_back(0);
foo[i].push_back(max(bar[0][0], max(bar[1][0], bar[2][0])));
if (bar[0][0]) {
long long temp = 0;
if (bar[0][1]) temp = bar[0][0] + bar[0][1];
if (bar[1][0] != 0) temp = max(temp, bar[0][0] + bar[1][0]);
if (temp) foo[i].push_back(temp);
}
if (bar[0].size() == 4) foo[i].push_back(bar[0][0] + bar[0][1] + bar[0][2]);
foo[i].push_back(0);
foo[i].push_back(foo[i][1]);
foo[i].push_back(max(bar[0][0], bar[1][0]));
foo[i].push_back(bar[0][0]);
}
long long dp[n + 5][11];
memset(dp, -1, sizeof dp);
for (long long i = 0; i < foo[0].size() - 4; i++) dp[0][i] = foo[0][i];
for (long long i = 1; i < n; i++) {
for (long long j = 0; j < 10; j++) {
if (dp[i - 1][j] != -1) {
for (long long k = 0; k < foo[i].size() - 4; k++) {
if ((j + k) < 10)
dp[i][(j + k) % 10] =
max(dp[i][(j + k) % 10], dp[i - 1][j] + foo[i][k]);
else
dp[i][(j + k) % 10] =
max(dp[i][(j + k) % 10],
dp[i - 1][j] + foo[i][k] + foo[i][k + foo[i].size() - 4]);
}
}
}
}
long long ans = 0;
for (long long i = 0; i < 10; i++) {
ans = max(ans, dp[n - 1][i]);
}
cout << ans << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
int const MAXN = 200001;
ll dp[10][MAXN]{};
ll NINF = -(1LL << 60);
ll dp2[2][4];
int n, k;
vector<pair<int, int>> cards[MAXN];
int main() {
cin >> n;
for (int i = 0; i < n; i++) {
cin >> k;
vector<int> v[4];
for (int j = 0; j < k; j++) {
int c, d;
cin >> c >> d;
v[c].push_back(d);
}
for (int j = 1; j < 4; j++) {
sort(v[j].rbegin(), v[j].rend());
}
for (int j = 1; j < 4; j++) {
v[j].resize(min((int)v[j].size(), (j == 1 ? 3 : 1)));
}
for (int j = 1; j < 4; j++) {
for (auto x : v[j]) {
cards[i].push_back({j, x});
}
}
}
for (int i = 0; i < 10; i++) {
for (int j = 0; j < MAXN; j++) {
dp[i][j] = NINF;
}
}
dp[0][0] = 0;
for (int i = 0; i < n; i++) {
sort(cards[i].begin(), cards[i].end());
for (int j = 0; j < 2; j++)
for (int k = 0; k < 4; k++) dp2[j][k] = NINF;
dp2[0][0] = 0;
dp2[1][0] = 0;
do {
int mana = 3;
int cnt = 0;
ll damage = 0;
ll MAX = 0;
for (auto card : cards[i]) {
if (mana - card.first >= 0) {
mana -= card.first;
MAX = max(MAX, (ll)card.second);
cnt++;
damage += card.second;
dp2[0][cnt] = max(dp2[0][cnt], damage);
dp2[1][cnt] = max(dp2[1][cnt], MAX);
} else {
break;
}
}
} while (next_permutation(cards[i].begin(), cards[i].end()));
for (int j = 0; j < 10; j++) {
if (dp[j][i] == NINF) continue;
for (int k = 0; k < 4; k++) {
if (dp2[0][k] == NINF) continue;
dp[(j + k) % 10][i + 1] =
max(dp[(j + k) % 10][i + 1],
dp[j][i] + dp2[0][k] + (j + k >= 10 ? dp2[1][k] : 0));
}
}
}
ll ans = 0;
for (int i = 0; i < 10; i++) {
ans = max(ans, dp[i][n]);
}
cout << ans;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long double eps = 1e-9;
const long long mod = 1e9 + 7;
pair<long long, long long> dir[8] = {{-1, 0}, {1, 0}, {0, -1}, {0, 1},
{1, 1}, {-1, -1}, {-1, 1}, {1, -1}};
const long long nn = 2e5 + 5;
long long n, damage[nn][4], maxi[nn][4];
bool can[nn][4];
long long dp[nn][11];
long long fun(long long cur, long long cards) {
if (cur > n) return 0;
long long& ans = dp[cur][cards];
if (ans != -1) return ans;
long long mx = 0;
for (long long i = 0; i <= 3; i++) {
if (can[cur][i]) {
long long here = 0;
if (cards + i < 10) {
here = damage[cur][i];
mx = max(mx, here + fun(cur + 1, cards + i));
} else {
here = damage[cur][i] + maxi[cur][i];
mx = max(mx, here + fun(cur + 1, (cards + i) % 10));
}
}
}
return ans = mx;
}
void robin() {
cin >> n;
for (long long ii = 1; ii <= n; ii++) {
long long k;
cin >> k;
vector<long long> v[4];
for (long long i = 0; i < k; i++) {
long long c, d;
cin >> c >> d;
v[c].push_back(d);
}
for (long long i = 1; i <= 3; i++) {
sort(v[i].rbegin(), v[i].rend());
}
for (long long cards = 1; cards <= 3; cards++) {
long long mx = 0;
if (cards == 1) {
for (long long i = 1; i <= 3; i++) {
if (((long long)(v[i]).size())) mx = max(mx, v[i][0]);
}
can[ii][0] = can[ii][1] = 1;
damage[ii][1] = mx;
maxi[ii][1] = mx;
} else if (cards == 2) {
long long mxx = 0;
if (((long long)(v[1]).size()) >= 2) {
mx = v[1][0] + v[1][1];
mxx = v[1][0];
}
if (((long long)(v[1]).size()) and ((long long)(v[2]).size())) {
mx = max(mx, v[1][0] + v[2][0]);
mxx = max(v[1][0], v[2][0]);
}
if (mx) {
can[ii][2] = 1;
damage[ii][2] = mx;
maxi[ii][2] = mxx;
}
} else {
if (((long long)(v[1]).size()) >= 3) {
can[ii][3] = 1;
damage[ii][3] = v[1][0] + v[1][1] + v[1][2];
maxi[ii][3] = v[1][0];
}
}
}
}
memset(dp, -1, sizeof dp);
cout << fun(1, 0);
}
int32_t main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
long long T = 1;
for (long long tc = 1; tc <= T; tc++) {
robin();
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 2000005;
const double pi = acos(-1.0);
const long long mod = 1000000007;
int n;
long long dp[2][15] = {0};
int a[3], b, c;
int main() {
int i, j;
scanf("%d", &n);
int cur = 0, ct;
memset(dp, -1, sizeof(dp));
dp[0][0] = 0;
for (i = 0; i < n; i++) {
int m;
scanf("%d", &m);
ct = 1 - cur;
a[0] = a[1] = a[2] = b = c = 0;
for (j = 0; j < 10; j++) dp[ct][j] = dp[cur][j];
for (j = 0; j < m; j++) {
int x, y;
scanf("%d %d", &x, &y);
if (x == 2)
b = max(b, y);
else if (x == 3)
c = max(c, y);
else {
if (a[0] <= y)
a[2] = a[1], a[1] = a[0], a[0] = y;
else if (a[1] <= y)
a[2] = a[1], a[1] = y;
else if (a[2] <= y)
a[2] = y;
}
}
for (j = 0; j < 10; j++) {
if (dp[cur][j] == -1) continue;
if (j == 9) {
dp[ct][(j + 1) % 10] =
max(dp[ct][(j + 1) % 10], dp[cur][j] + 2 * max(a[0], max(b, c)));
} else {
dp[ct][(j + 1) % 10] =
max(dp[ct][(j + 1) % 10], dp[cur][j] + max(a[0], max(b, c)));
}
if (j == 8 || j == 9) {
if (a[1] > 0)
dp[ct][(j + 2) % 10] =
max(dp[ct][(j + 2) % 10], dp[cur][j] + a[0] * 2 + a[1]);
if (a[0] > 0 && b > 0)
dp[ct][(j + 2) % 10] =
max(dp[ct][(j + 2) % 10],
dp[cur][j] + max(a[0], b) * 2 + min(a[0], b));
} else {
if (a[1] > 0)
dp[ct][(j + 2) % 10] =
max(dp[ct][(j + 2) % 10], dp[cur][j] + a[0] + a[1]);
if (a[0] > 0 && b > 0)
dp[ct][(j + 2) % 10] =
max(dp[ct][(j + 2) % 10], dp[cur][j] + a[0] + b);
}
if (j == 7 || j == 8 || j == 9) {
if (a[2] > 0)
dp[ct][(j + 3) % 10] =
max(dp[ct][(j + 3) % 10], dp[cur][j] + a[0] * 2 + a[1] + a[2]);
} else {
if (a[2] > 0)
dp[ct][(j + 3) % 10] =
max(dp[ct][(j + 3) % 10], dp[cur][j] + a[0] + a[1] + a[2]);
}
}
cur = ct;
}
long long ans = 0;
for (i = 0; i < 10; i++) ans = max(ans, dp[cur][i]);
printf("%I64d\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
inline long long read() {
long long sum = 0, nega = 1;
char ch = getchar();
while (ch > '9' || ch < '0') {
if (ch == '-') nega = -1;
ch = getchar();
}
while (ch <= '9' && ch >= '0') sum = sum * 10 + ch - '0', ch = getchar();
return sum * nega;
}
const long long N = 2e5 + 9, INF = 1e15 + 7;
long long n, dp[N][12], cnt1[N], max2, max3, c, d;
long long k, len1;
signed main() {
n = read();
memset(dp, -INF, sizeof(dp));
dp[0][0] = 0;
for (long long i = 1; i <= n; i++) {
k = read();
max2 = 0, max3 = 0;
len1 = 0;
for (long long j = 1; j <= k; j++) {
c = read(), d = read();
if (c == 1)
cnt1[++len1] = d;
else if (c == 2)
max2 = max(max2, d);
else
max3 = max(max3, d);
}
sort(cnt1, cnt1 + len1 + 1);
for (long long j = 0; j < 10; j++) {
long long p = j;
dp[i][j] = dp[i - 1][j];
p = (p + 9) % 10;
if (j == 0) {
dp[i][j] =
max(dp[i - 1][p] + 2 * max(max(max2, max3), cnt1[len1]), dp[i][j]);
} else {
dp[i][j] =
max(dp[i - 1][p] + max(max(max2, max3), cnt1[len1]), dp[i][j]);
}
p = (p + 9) % 10;
if (len1 >= 2) {
if (j <= 1)
dp[i][j] =
max(dp[i][j], dp[i - 1][p] + cnt1[len1] * 2 + cnt1[len1 - 1]);
else
dp[i][j] = max(dp[i][j], dp[i - 1][p] + cnt1[len1] + cnt1[len1 - 1]);
}
if (len1 >= 1 && max2 != 0) {
if (j <= 1)
dp[i][j] = max(dp[i][j], dp[i - 1][p] + cnt1[len1] + max2 +
max(max2, cnt1[len1]));
else
dp[i][j] = max(dp[i][j], dp[i - 1][p] + cnt1[len1] + max2);
}
p = (p + 9) % 10;
if (len1 >= 3) {
if (j <= 2)
dp[i][j] = max(dp[i][j], dp[i - 1][p] + cnt1[len1] * 2 +
cnt1[len1 - 1] + cnt1[len1 - 2]);
else
dp[i][j] = max(dp[i][j], dp[i - 1][p] + cnt1[len1] + cnt1[len1 - 1] +
cnt1[len1 - 2]);
}
}
}
long long ans = 0;
for (long long i = 0; i < 10; i++) ans = max(ans, dp[n][i]);
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long LEN = (long long)2e5;
int n;
array<long long, 5> a;
array<long long, 10> dp, dpn;
array<array<long long, 2>, 4> z;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
cin >> n;
for (int I = 0; I < n; I++) {
int k;
cin >> k;
fill(a.begin(), a.end(), 0);
for (auto& i : z) fill(i.begin(), i.end(), 0);
while (k--) {
long long c, d;
cin >> c >> d;
if (c == 1) {
auto& ch = *min_element(a.begin(), a.begin() + 3);
ch = max(ch, d);
} else
a[c + 1] = max(a[c + 1], d);
}
sort(a.begin(), a.begin() + 3);
z[1][0] = *max_element(a.begin(), a.end());
z[1][1] = 2LL * z[1][0];
for (int i = 1; i < 4; i += 2)
if (a[2] && a[i]) {
z[2][0] = max(z[2][0], a[2] + a[i]);
z[2][1] = max(z[2][1], a[2] + a[i] + max(a[2], a[i]));
}
if (a[0]) {
z[3][0] = a[0] + a[1] + a[2];
z[3][1] = z[3][0] + *max_element(a.begin(), a.begin() + 3);
}
for (int j = 0; j <= 9; j++)
for (int q = 1; q <= 3; q++) {
int k = j - q, w = 0;
if (k < 0) {
k += 10;
w = 1;
}
if ((z[q][w] > 0) && ((dp[k] > 0) || (k == 0)))
dpn[j] = max(dpn[j], dp[k] + z[q][w]);
}
copy(dpn.begin(), dpn.end(), dp.begin());
;
;
;
;
;
;
;
;
;
;
}
cout << *max_element(dp.begin(), dp.end());
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MOD = 10;
string to_string(string s) { return '"' + s + '"'; }
string to_string(char s) { return string(1, s); }
string to_string(const char *s) { return to_string((string)s); }
string to_string(bool b) { return (b ? "true" : "false"); }
template <typename A>
string to_string(A);
template <typename A, typename B>
string to_string(pair<A, B> p) {
return "(" + to_string(p.first) + ", " + to_string(p.second) + ")";
}
template <typename A>
string to_string(A v) {
bool f = 1;
string r = "{";
for (const auto &x : v) {
if (!f) r += ", ";
f = 0;
r += to_string(x);
}
return r + "}";
}
void debug_out() { cout << endl; }
template <typename Head, typename... Tail>
void debug_out(Head H, Tail... T) {
cout << " " << to_string(H);
debug_out(T...);
}
inline long long add(long long a, long long b) {
a += b;
if (a >= MOD) a -= MOD;
return a;
}
inline long long sub(long long a, long long b) {
a -= b;
if (a < 0) a += MOD;
return a;
}
inline long long mul(long long a, long long b) {
return (long long)((long long)a * b % MOD);
}
inline long long binpow(long long a, long long b) {
long long res = 1;
while (b > 0) {
if (b & 1) res = mul(res, a);
a = mul(a, a);
b /= 2;
}
return res;
}
inline long long inv(long long a) { return binpow(a, MOD - 2); }
long long gcd(long long a, long long b, long long &x, long long &y) {
if (a == 0) {
x = 0, y = 1;
return b;
}
long long x1, y1;
long long d = gcd(b % a, a, x1, y1);
x = y1 - (b / a) * x1;
y = x1;
return d;
}
const long long N = 2e5 + 5, INF = 1e16;
long long n, dp[N][10], two[N], three[N];
vector<long long> one[N];
long long find(long long id, long long d) {
if (id == 0) return (d == 0) ? 0 : -INF;
if (dp[id][d] != -1) return dp[id][d];
long long val;
dp[id][d] = find(id - 1, d);
if (three[id] != 0) {
val = three[id];
if (d == 0) val += three[id];
dp[id][d] = max(dp[id][d], val + find(id - 1, sub(d, 1)));
}
if (two[id] != 0) {
if (!one[id].empty()) {
val = one[id][0] + two[id];
if (d == 0 || d == 1) val += max(one[id][0], two[id]);
dp[id][d] = max(dp[id][d], val + find(id - 1, sub(d, 2)));
}
val = two[id];
if (d == 0) val += two[id];
dp[id][d] = max(dp[id][d], val + find(id - 1, sub(d, 1)));
}
if (!one[id].empty()) {
val = 0;
for (long long j = 0; j < one[id].size() && j < 3; ++j) {
if (d == j) val += one[id][0];
val += one[id][j];
dp[id][d] = max(dp[id][d], val + find(id - 1, sub(d, j + 1)));
}
}
return dp[id][d];
}
int32_t main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> n;
memset(dp, -1, sizeof dp);
for (long long i = 1; i <= n; ++i) {
long long k;
cin >> k;
vector<long long> vec;
for (long long j = 1; j <= k; ++j) {
long long c, d;
cin >> c >> d;
if (c == 2)
two[i] = max(two[i], d);
else if (c == 3)
three[i] = max(three[i], d);
else
one[i].push_back(d);
}
sort((one[i]).begin(), (one[i]).end(), greater<long long>());
}
long long ans = 0;
for (long long i = 0; i < 10; ++i) ans = max(ans, find(n, i));
cout << ans << "\n";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long dp[12];
signed main() {
long long n;
cin >> n;
for (long long i = 1; i <= 9; i++) {
dp[i] = -100000000000000000;
}
for (long long ii = 1; ii <= n; ii++) {
long long cnt;
cin >> cnt;
vector<long long> a[4];
for (long long i = 1; i <= cnt; i++) {
long long u, v;
cin >> u >> v;
a[u].push_back(v);
}
for (long long i = 1; i <= 3; i++) {
sort(a[i].begin(), a[i].end());
}
long long dp1[12];
for (long long i = 0; i <= 9; i++) dp1[i] = -1000000000000000;
long long sm1 = 0, mx1 = 0;
for (long long t1 = 0; t1 <= a[1].size(); t1++) {
if (t1 > 3) break;
if (t1 > 0) {
sm1 += a[1][a[1].size() - t1];
mx1 = max(mx1, a[1][a[1].size() - t1]);
}
long long sm2 = 0, mx2 = 0;
for (long long t2 = 0; t2 <= a[2].size(); t2++) {
if (t1 + 2 * t2 > 3) break;
if (t2 > 0) {
sm2 += a[2][a[2].size() - t2];
mx2 = max(mx2, a[2][a[2].size() - t2]);
}
long long sm3 = 0, mx3 = 0;
for (long long t3 = 0; t3 <= a[3].size(); t3++) {
if (t1 + 2 * t2 + 3 * t3 > 3) break;
if (t3 > 0) {
sm3 += a[3][a[3].size() - t3];
mx3 = max(mx3, a[3][a[3].size() - t3]);
}
for (long long j = 0; j <= 9; j++) {
long long nxt = (j + t1 + t2 + t3) % 10;
if (nxt < j)
dp1[nxt] = max(dp1[nxt],
dp[j] + sm1 + sm2 + sm3 + max(mx1, max(mx2, mx3)));
else
dp1[nxt] = max(dp1[nxt], dp[j] + sm1 + sm2 + sm3);
}
}
}
}
for (long long i = 0; i <= 9; i++) {
dp[i] = dp1[i];
}
}
long long ans = 0;
for (long long i = 0; i <= 9; i++) {
ans = max(ans, dp[i]);
}
cout << ans;
}
|
#include <bits/stdc++.h>
using namespace std;
const int nax = 2e5;
long long int dp[nax + 5][10];
int n;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cin >> n;
for (int i = 0; i < nax; i++) {
for (int j = 0; j < 10; j++) {
dp[i][j] = -1;
}
}
dp[0][0] = 0;
vector<long long int> a;
vector<long long int> b;
vector<long long int> c;
for (int i = 1; i <= n; i++) {
a.clear();
b.clear();
c.clear();
int k;
cin >> k;
for (int j = 0; j < k; j++) {
int x, y;
cin >> x >> y;
if (x == 1)
a.push_back(y);
else if (x == 2)
b.push_back(y);
else
c.push_back(y);
}
sort(a.begin(), a.end());
sort(b.begin(), b.end());
sort(c.begin(), c.end());
reverse(a.begin(), a.end());
reverse(b.begin(), b.end());
reverse(c.begin(), c.end());
for (int j = 0; j < 10; j++) {
dp[i][j] = max(dp[i][j], dp[i - 1][j]);
if (a.size() >= 3) {
int pos = (j + 10 - 3) % 10;
if (dp[i - 1][pos] != -1) {
if (pos > j) {
dp[i][j] = max(dp[i][j], dp[i - 1][pos] + 2 * a[0] + a[1] + a[2]);
} else {
dp[i][j] = max(dp[i][j], dp[i - 1][pos] + a[0] + a[1] + a[2]);
}
}
}
if (a.size() >= 1) {
int pos = (j + 10 - 1) % 10;
if (dp[i - 1][pos] != -1) {
if (pos > j) {
dp[i][j] = max(dp[i][j], dp[i - 1][pos] + 2 * a[0]);
} else {
dp[i][j] = max(dp[i][j], dp[i - 1][pos] + a[0]);
}
}
}
if (b.size() >= 1) {
int pos = (j + 10 - 1) % 10;
if (dp[i - 1][pos] != -1) {
if (pos > j) {
dp[i][j] = max(dp[i][j], dp[i - 1][pos] + 2 * b[0]);
} else {
dp[i][j] = max(dp[i][j], dp[i - 1][pos] + b[0]);
}
}
}
if (c.size() >= 1) {
int pos = (j + 10 - 1) % 10;
if (dp[i - 1][pos] != -1) {
if (pos > j) {
dp[i][j] = max(dp[i][j], dp[i - 1][pos] + 2 * c[0]);
} else {
dp[i][j] = max(dp[i][j], dp[i - 1][pos] + c[0]);
}
}
}
if (a.size() >= 2) {
int pos = (j + 10 - 2) % 10;
if (dp[i - 1][pos] != -1) {
if (pos > j) {
dp[i][j] = max(dp[i][j], dp[i - 1][pos] + 2 * a[0] + a[1]);
} else {
dp[i][j] = max(dp[i][j], dp[i - 1][pos] + a[0] + a[1]);
}
}
}
if (a.size() >= 1 && b.size() >= 1) {
int pos = (j + 10 - 2) % 10;
long long int t1 = max(a[0], b[0]);
long long int t2 = min(a[0], b[0]);
if (dp[i - 1][pos] != -1) {
if (pos > j) {
dp[i][j] = max(dp[i][j], dp[i - 1][pos] + 2 * t1 + t2);
} else {
dp[i][j] = max(dp[i][j], dp[i - 1][pos] + t1 + t2);
}
}
}
}
}
long long int res = 0;
for (int i = 0; i < 10; i++) res = max(res, dp[n][i]);
cout << res;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using ld = long double;
const int N = 2e5 + 10;
vector<int> data[N][3];
ll dp[N][10];
int n;
ll solve(int i, int k) {
if (i == n) return 0;
ll &dp = ::dp[i][k];
if (dp != -1) return dp;
dp = 0;
if (data[i][0].size() >= 3) {
dp = max(dp, solve(i + 1, (k + 3) % 10) + data[i][0].end()[-3] +
data[i][0].end()[-2] +
data[i][0].end()[-1] * (k >= 7 ? 2 : 1));
dp = max(dp, solve(i + 1, (k + 2) % 10) + data[i][0].end()[-2] +
data[i][0].end()[-1] * (k >= 8 ? 2 : 1));
dp = max(dp, solve(i + 1, (k + 1) % 10) +
data[i][0].end()[-1] * (k == 9 ? 2 : 1));
} else if (data[i][0].size() >= 2) {
dp = max(dp, solve(i + 1, (k + 2) % 10) + data[i][0].end()[-2] +
data[i][0].end()[-1] * (k >= 8 ? 2 : 1));
dp = max(dp, solve(i + 1, (k + 1) % 10) +
data[i][0].end()[-1] * (k == 9 ? 2 : 1));
} else if (data[i][0].size() == 1) {
dp = max(dp, solve(i + 1, (k + 1) % 10) +
data[i][0].end()[-1] * (k == 9 ? 2 : 1));
}
if (data[i][1].size() >= 1) {
if (!data[i][0].empty()) {
int mx = max(data[i][0].back(), data[i][1].back());
dp = max(dp, solve(i + 1, (k + 2) % 10) + data[i][0].back() +
data[i][1].back() - mx + mx * (k >= 8 ? 2 : 1));
}
dp = max(dp,
solve(i + 1, (k + 1) % 10) + data[i][1].back() * (k == 9 ? 2 : 1));
}
if (data[i][2].size() >= 1)
dp = max(dp,
solve(i + 1, (k + 1) % 10) + data[i][2].back() * (k == 9 ? 2 : 1));
dp = max(dp, solve(i + 1, k));
return dp;
}
int main(int argc, char const *argv[]) {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
cout.precision(10);
cout << fixed;
cin >> n;
for (int i = 0; i < n; ++i) {
int k;
cin >> k;
while (k--) {
int c, d;
cin >> c >> d;
data[i][c - 1].push_back(d);
}
for (int j = 0; j < 3; ++j) sort(data[i][j].begin(), data[i][j].end());
}
memset(dp, -1, sizeof(dp));
cout << solve(0, 0) << '\n';
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cout.tie(NULL);
cin.tie(NULL);
long long n;
cin >> n;
vector<vector<long long>> dp(n + 1, vector<long long>(10, -1));
dp[0][0] = 0;
for (int i = 1; i <= n; i += 1) {
for (int j = 0; j < 10; j += 1) {
dp[i][j] = dp[i - 1][j];
}
long long k;
cin >> k;
vector<pair<long long, long long>> v1[3];
for (int j = 0; j < k; j += 1) {
int a, b;
cin >> a >> b;
v1[a - 1].push_back({a, b});
}
for (int j = 0; j < 3; j += 1) {
sort(v1[j].rbegin(), v1[j].rend());
}
vector<pair<long long, long long>> p;
for (int j = 0; j < min((int)v1[0].size(), 3); j += 1) {
p.push_back(v1[0][j]);
}
if (v1[1].size()) {
p.push_back(v1[1][0]);
}
if (v1[2].size()) {
p.push_back(v1[2][0]);
}
for (int j = 0; j < 10; j += 1) {
if (dp[i - 1][j] == -1) {
continue;
}
long long val = dp[i - 1][j], cnt = 0;
for (int ii = 0; ii < p.size(); ii += 1) {
long long maxi = p[ii].second;
val += p[ii].second;
cnt += p[ii].first;
if (j == 9) {
dp[i][0] = max(dp[i][0], val + maxi);
} else {
dp[i][j + 1] = max(dp[i][j + 1], val);
}
for (int jj = ii + 1; jj < p.size(); jj += 1) {
long long pre = maxi;
maxi = max(maxi, p[jj].second);
val += p[jj].second;
cnt += p[jj].first;
if (cnt <= 3) {
if (j == 8) {
dp[i][0] = max(dp[i][0], val + maxi);
} else if (j == 9) {
dp[i][1] = max(dp[i][1], val + maxi);
} else {
dp[i][j + 2] = max(dp[i][j + 2], val);
}
}
for (int kk = jj + 1; kk < p.size(); kk += 1) {
long long pree = maxi;
maxi = max(maxi, p[kk].second);
val += p[kk].second;
cnt += p[kk].first;
if (cnt <= 3) {
if (j == 7) {
dp[i][0] = max(dp[i][0], val + maxi);
} else if (j == 8) {
dp[i][1] = max(dp[i][1], val + maxi);
} else if (j == 9) {
dp[i][2] = max(dp[i][2], val + maxi);
} else {
dp[i][j + 3] = max(dp[i][j + 3], val);
}
}
val -= p[kk].second;
cnt -= p[kk].first;
maxi = pree;
}
val -= p[jj].second;
cnt -= p[jj].first;
maxi = pre;
}
val -= p[ii].second;
cnt -= p[ii].first;
}
}
}
long long ans = 0;
for (int i = 0; i < 10; i += 1) {
ans = max(ans, dp[n][i]);
}
cout << ans;
}
|
#include <bits/stdc++.h>
using namespace std;
mt19937 rng(time(0));
uniform_int_distribution<int> uid(-1e9, 1e9);
long long d1[10], d2[10];
signed main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int n;
long long res = 0;
cin >> n;
fill(d1 + 1, d1 + 10, -1e18);
fill(d2 + 1, d2 + 10, -1e18);
while (n--) {
int k, x, y;
map<int, vector<int>> mp;
vector<vector<vector<long long>>> p(
4, vector<vector<long long>>(4, {(long long)-1e18, (long long)-1e18}));
cin >> k;
p[0][0] = {0, 0};
while (k--) cin >> x >> y, mp[x].push_back(y);
for (auto& i : mp)
sort((i.second).begin(), (i.second).end()),
reverse((i.second).begin(), (i.second).end());
for (auto& i : mp)
while (i.second.size() > 4 - i.first) i.second.pop_back();
for (auto& j : mp)
for (auto& k : j.second)
for (int i = 3; i >= j.first; --i)
for (int ii = 3; ii >= 1; --ii) {
if (p[i - j.first][ii - 1][0] >= 0)
p[i][ii][0] = max(p[i - j.first][ii - 1][0] + k, p[i][ii][0]);
if (p[i - j.first][ii - 1][1] >= 0)
p[i][ii][1] = max({p[i - j.first][ii - 1][1] + k, p[i][ii][1],
p[i - j.first][ii - 1][0] + 2 * k});
}
for (int i = 0; i < 10; ++i) {
for (int j = 0; j < 4; ++j) {
for (int k = 0; k < 4; ++k) {
d2[(i + k) % 10] =
max({d2[(i + k) % 10], d1[(i + k) % 10],
d1[i] + (i + k >= 10 ? p[j][k][1] : p[j][k][0])});
res = max(res, d2[(i + k) % 10]);
}
}
}
swap(d1, d2);
}
cout << res;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 2 * 100 * 1000 + 10;
long long dp[12][N];
int main() {
int n;
cin >> n;
for (int i = 1; i < 10; i++) dp[i][0] = -1LL * 1e18;
long long ans = 0;
for (int i = 1; i < n + 1; i++) {
int t;
cin >> t;
vector<long long> vec[3];
for (int j = 0; j < t; j++) {
int a, b;
cin >> a >> b;
vec[a - 1].push_back(b);
}
for (int j = 0; j < 3; j++)
sort(vec[j].begin(), vec[j].end(), greater<long long>());
for (int j = 0; j < 10; j++) {
dp[j][i] = dp[j][i - 1];
for (int k = 0; k < 3; k++)
if ((int)vec[k].size()) {
if (j != 0)
dp[j][i] =
max(dp[j][i], (i ? dp[(j + 9) % 10][i - 1] : 0) + vec[k][0]);
else
dp[j][i] = max(dp[j][i],
(i ? dp[(j + 9) % 10][i - 1] : 0) + 2 * vec[k][0]);
}
if ((int)vec[0].size() >= 3) {
if (j > 2)
dp[j][i] = max(dp[j][i], (i ? dp[(j + 7) % 10][i - 1] : 0) +
vec[0][0] + vec[0][1] + vec[0][2]);
else
dp[j][i] = max(dp[j][i], (i ? dp[(j + 7) % 10][i - 1] : 0) +
2 * vec[0][0] + vec[0][1] + vec[0][2]);
}
if ((int)vec[0].size() >= 2) {
if (j > 1)
dp[j][i] = max(dp[j][i], (i ? dp[(j + 8) % 10][i - 1] : 0) +
vec[0][0] + vec[0][1]);
else
dp[j][i] = max(dp[j][i], (i ? dp[(j + 8) % 10][i - 1] : 0) +
2 * vec[0][0] + vec[0][1]);
}
if ((int)vec[0].size() && (int)vec[1].size()) {
if (j > 1)
dp[j][i] = max(dp[j][i], (i ? dp[(j + 8) % 10][i - 1] : 0) +
vec[0][0] + vec[1][0]);
else
dp[j][i] =
max(dp[j][i], (i ? dp[(j + 8) % 10][i - 1] : 0) + vec[0][0] +
vec[1][0] + max(vec[0][0], vec[1][0]));
}
ans = max(ans, dp[j][i]);
}
}
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
using lint = long long;
using ulint = unsigned long long;
const int T = 10;
lint dp[T], nxt[T];
void relax(lint &x, lint y) { x = max(x, y); }
int main(void) {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
fill(begin(dp), end(dp), -1);
fill(begin(nxt), end(nxt), -1);
int n;
cin >> n;
dp[0] = 0;
while (n--) {
int k;
cin >> k;
vector<lint> cards[4];
for (int i = 0; i < k; i++) {
int c, d;
cin >> c >> d;
cards[c].push_back(d);
}
for (auto &vec : cards) {
sort(vec.begin(), vec.end(), greater<lint>());
}
for (int i = 0; i < T; i++) {
if (dp[i] == -1) continue;
bool flag1 = i + 1 >= T;
bool flag2 = i + 2 >= T;
bool flag3 = i + 3 >= T;
relax(nxt[i], dp[i]);
if (cards[1].size() >= 1)
relax(nxt[(i + 1) % T], dp[i] + cards[1][0] * (flag1 + 1));
if (cards[2].size() >= 1)
relax(nxt[(i + 1) % T], dp[i] + cards[2][0] * (flag1 + 1));
if (cards[3].size() >= 1)
relax(nxt[(i + 1) % T], dp[i] + cards[3][0] * (flag1 + 1));
if (cards[1].size() >= 2)
relax(nxt[(i + 2) % T],
dp[i] + cards[1][0] * (flag2 + 1) + cards[1][1]);
if (cards[1].size() >= 1 && cards[2].size() >= 1)
relax(nxt[(i + 2) % T], dp[i] + cards[1][0] + cards[2][0] +
max(cards[1][0], cards[2][0]) * flag2);
if (cards[1].size() >= 3)
relax(nxt[(i + 3) % T],
dp[i] + cards[1][0] * (flag3 + 1) + cards[1][1] + cards[1][2]);
}
copy(begin(nxt), end(nxt), begin(dp));
}
cout << *max_element(begin(dp), end(dp)) << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, k, a, b;
int one, two, three;
long long dp[200010][4][10];
vector<pair<int, pair<long long, long long> > > turn[200010];
long long solution(int pos, int selected, int r) {
if (pos > n) return 0;
long long &ret = dp[pos][selected][r];
if (ret != -1) return ret;
ret = 0;
for (pair<int, pair<long long, long long> > card : turn[pos + 1]) {
if ((card.first + r) >= 10) {
long long cost = card.second.second;
ret =
max(ret, card.second.first + cost +
solution(pos + 1, card.first, (r + (card.first)) % 10));
} else {
ret = max(ret, card.second.first + solution(pos + 1, card.first,
(r + (card.first)) % 10));
}
}
ret = max(ret, solution(pos + 1, 0, r));
return ret;
}
int main() {
memset(dp, -1, sizeof(dp));
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
scanf("%d", &k);
vector<int> card[4];
for (int j = 0; j < k; j++) {
scanf("%d %d", &a, &b);
card[a].push_back(b);
}
for (int j = 1; j <= 3; j++) {
sort(card[j].rbegin(), card[j].rend());
}
pair<long long, long long> cost[4] = {};
long long sum = 0;
for (int i = 0; i < card[1].size(); i++) {
sum += card[1][i];
if (i <= 2) {
cost[i + 1] = {sum, card[1][0]};
} else
break;
}
if (!card[2].empty()) {
if (cost[1].first < card[2][0]) {
cost[1].first = card[2][0];
cost[1].second = card[2][0];
}
if (!card[1].empty()) {
if (cost[2].first < card[1][0] + card[2][0]) {
cost[2].first = card[1][0] + card[2][0];
cost[2].second = max(card[1][0], card[2][0]);
}
}
}
if (!card[3].empty()) {
if (cost[1].first < card[3][0]) {
cost[1].first = card[3][0];
cost[1].second = card[3][0];
}
}
for (int j = 1; j <= 3; j++) {
if (cost[j].first != 0) {
turn[i].push_back({j, cost[j]});
}
}
}
printf("%lld\n", solution(0, 0, 0));
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 200005, M = 105;
const long long MOD = 1e9 + 7;
const double eps = 1e-6;
const double PI = acos(-1.0);
const int oo = 2e9;
int n;
pair<long long, long long> mx[N][4];
long long dp[N][11];
long long calc(int turn, int card_number) {
if (turn == n) return 0;
long long& ret = dp[turn][card_number];
if (ret != -1) return ret;
ret = calc(turn + 1, card_number);
for (int cards = 1; cards <= 3; cards++) {
if (mx[turn][cards].first == -1) continue;
long long cur = mx[turn][cards].first;
if (card_number + cards >= 10) cur += mx[turn][cards].second;
cur += calc(turn + 1, (card_number + cards) % 10);
ret = max(ret, cur);
}
return ret;
}
int main() {
scanf("%d", &n);
for (int i = 0; i < n; i++) {
int k, c, d;
scanf("%d", &k);
map<int, vector<pair<int, int> > > v;
for (int j = 0; j < k; j++) {
scanf("%d%d", &c, &d);
for (int l = 1; l <= 3; l++)
if (l >= c) v[l].push_back(make_pair(d, c));
}
for (int l = 1; l <= 3; l++) {
int cards = 4 - l;
sort(v[l].begin(), v[l].end());
reverse(v[l].begin(), v[l].end());
mx[i][cards] = make_pair(0, -1);
int cost = 0, cards_taken = 0;
for (int j = 0; j < v[l].size() && cards_taken < cards; j++) {
if (v[l][j].second + cost <= 3) {
mx[i][cards].second = max(mx[i][cards].second, 1ll * v[l][j].first);
mx[i][cards].first += v[l][j].first;
cost += v[l][j].second;
cards_taken++;
}
}
if (cards_taken != cards) mx[i][cards] = make_pair(-1, -1);
}
}
memset(dp, -1, sizeof dp);
printf("%lld\n", calc(0, 0));
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 2e5 + 7;
const int inf = INT_MAX;
const long long inff = 1e18;
const long long mod = 1e9 + 7;
long long n;
long long dp[maxn][12], k, x, y;
vector<long long> _1, _2, _3;
int32_t main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> n;
for (long long i = 0; i <= n; i++) {
for (long long j = 0; j <= 9; j++) dp[i][j] = -inff;
}
dp[0][0] = 0;
for (long long i = 1; i <= n; i++) {
cin >> k;
_1.clear();
_2.clear();
_3.clear();
for (long long j = 1; j <= k; j++) {
cin >> x >> y;
if (x == 1)
_1.push_back(y);
else if (x == 2)
_2.push_back(y);
else
_3.push_back(y);
}
sort((_1).begin(), (_1).end());
sort((_2).begin(), (_2).end());
sort((_3).begin(), (_3).end());
reverse((_1).begin(), (_1).end());
reverse((_2).begin(), (_2).end());
reverse((_3).begin(), (_3).end());
for (long long j = 0; j <= 9; j++) {
dp[i][j] = dp[i - 1][j];
if (((long long)(_1).size()) > 0) {
if (j == 0)
dp[i][j] = max(dp[i][j], dp[i - 1][(j + 10 - 1) % 10] + _1[0] * 2);
else
dp[i][j] = max(dp[i][j], dp[i - 1][(j + 10 - 1) % 10] + _1[0]);
}
if (((long long)(_2).size()) > 0) {
if (j <= 0)
dp[i][j] = max(dp[i][j], dp[i - 1][(j + 10 - 1) % 10] + _2[0] * 2);
else
dp[i][j] = max(dp[i][j], dp[i - 1][(j + 10 - 1) % 10] + _2[0]);
}
if (((long long)(_1).size()) >= 2) {
if (j <= 1)
dp[i][j] =
max(dp[i][j], dp[i - 1][(j + 10 - 2) % 10] + _1[0] * 2 + _1[1]);
else
dp[i][j] =
max(dp[i][j], dp[i - 1][(j + 10 - 2) % 10] + _1[0] + _1[1]);
}
if (((long long)(_3).size()) >= 1) {
if (j <= 0)
dp[i][j] = max(dp[i][j], dp[i - 1][(j + 10 - 1) % 10] + _3[0] * 2);
else
dp[i][j] = max(dp[i][j], dp[i - 1][(j + 10 - 1) % 10] + _3[0]);
}
if (((long long)(_1).size()) >= 1 && ((long long)(_2).size()) >= 1) {
if (j <= 1)
dp[i][j] = max(dp[i][j], dp[i - 1][(j + 10 - 2) % 10] + _1[0] +
_2[0] + max(_1[0], _2[0]));
else
dp[i][j] =
max(dp[i][j], dp[i - 1][(j + 10 - 2) % 10] + _1[0] + _2[0]);
}
if (((long long)(_1).size()) >= 3) {
if (j <= 2)
dp[i][j] = max(dp[i][j], dp[i - 1][(j + 10 - 3) % 10] + _1[0] * 2 +
_1[1] + _1[2]);
else
dp[i][j] = max(dp[i][j],
dp[i - 1][(j + 10 - 3) % 10] + _1[0] + _1[1] + _1[2]);
}
}
}
long long maxx = -1;
for (long long i = 0; i <= 9; i++) maxx = max(maxx, dp[n][i]);
cout << maxx << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long INF = 1e18 + 7;
const long long mod = 998244353;
const int maxn = 2e5 + 7;
long long dp[4][2];
long long dp2[maxn][10];
void solve() {
int n;
cin >> n;
for (int i = 0; i <= n; i++) {
for (int j = 0; j < 10; j++) {
dp2[i][j] = -INF;
}
}
dp2[0][0] = 0;
for (int iter = 1; iter <= n; iter++) {
int ki;
cin >> ki;
vector<long long> cards[4];
for (int i = 0; i < ki; i++) {
int cj;
long long dj;
cin >> cj >> dj;
cards[cj].push_back(dj);
}
for (int i = 1; i <= 3; i++) {
sort(cards[i].rbegin(), cards[i].rend());
}
vector<pair<int, long long>> turn_cards;
for (int i = 0; i < min(3, (int)cards[1].size()); i++) {
turn_cards.push_back({1, cards[1][i]});
}
if (cards[2].size()) {
turn_cards.push_back({2, cards[2][0]});
}
if (cards[3].size()) {
turn_cards.push_back({3, cards[3][0]});
}
for (int i = 0; i < 4; i++) {
for (int j = 0; j < 2; j++) {
dp[i][j] = -INF;
}
}
dp[0][0] = 0;
sort(turn_cards.begin(), turn_cards.end());
do {
long long max_dmg = 0;
long long mana = 3;
long long sum = 0;
for (int i = 0; i < turn_cards.size(); i++) {
if (turn_cards[i].first > mana) {
break;
}
mana -= turn_cards[i].first;
max_dmg = max(max_dmg, turn_cards[i].second);
sum += turn_cards[i].second;
dp[i + 1][0] = max(dp[i + 1][0], sum);
dp[i + 1][1] = max(dp[i + 1][1], sum + max_dmg);
}
} while (next_permutation(turn_cards.begin(), turn_cards.end()));
for (int j = 0; j <= 9; j++) {
for (int k = 0; k <= 3; k++) {
int next = j + k;
int id = 0;
if (next >= 10) {
next -= 10;
id++;
}
dp2[iter][next] = max(dp2[iter][next], dp2[iter - 1][j] + dp[k][id]);
}
}
}
long long ans = 0;
for (int j = 0; j <= 9; j++) {
ans = max(ans, dp2[n][j]);
}
cout << ans;
}
int main() {
cin.tie(0);
cout.tie(0);
ios_base::sync_with_stdio(false);
solve();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 2e5 + 70;
const int INF = 2.1e9;
const long long inf = 9e18;
const int MOD = 1e9 + 7;
const double eps = 1e-7;
const double PI = acos(-1.0);
int n, m, k;
long long dp[2][10];
int main() {
while (cin >> n) {
bool t = 0;
dp[t][0] = 0;
for (int i = 1; i < 10; i++) dp[t][i] = -inf;
for (int i = 0; i < n; i++) {
scanf("%d", &k);
vector<int> V[4];
while (k--) {
int c, d;
scanf("%d %d", &c, &d);
V[c].push_back(d);
}
for (int j = 1; j <= 3; j++) {
sort((V[j]).begin(), (V[j]).end());
reverse((V[j]).begin(), (V[j]).end());
}
memcpy(dp[t ^ 1], dp[t], sizeof(dp[t]));
int d = 0;
for (int j = 1; j <= 3; j++)
if (V[j].size()) d = max(d, V[j][0]);
for (int j = 0; j < 10; j++) {
dp[t ^ 1][(j + 1) % 10] =
max(dp[t ^ 1][(j + 1) % 10], dp[t][j] + d * (j == 9 ? 2 : 1));
}
if (V[1].size() >= 2) {
int d1 = V[1][0], d2 = V[1][1];
for (int j = 0; j < 10; j++) {
dp[t ^ 1][(j + 2) % 10] =
max(dp[t ^ 1][(j + 2) % 10],
dp[t][j] + d1 * ((j == 9 || j == 8) ? 2 : 1) + d2);
}
}
if (V[1].size() && V[2].size()) {
int d1 = V[1][0], d2 = V[2][0];
if (d1 < d2) swap(d1, d2);
for (int j = 0; j < 10; j++) {
dp[t ^ 1][(j + 2) % 10] =
max(dp[t ^ 1][(j + 2) % 10],
dp[t][j] + d1 * ((j == 9 || j == 8) ? 2 : 1) + d2);
}
}
if (V[1].size() >= 3) {
int d1 = V[1][0], d2 = V[1][1], d3 = V[1][2];
for (int j = 0; j < 10; j++) {
dp[t ^ 1][(j + 3) % 10] = max(
dp[t ^ 1][(j + 3) % 10],
dp[t][j] + d1 * ((j == 9 || j == 8 || j == 7) ? 2 : 1) + d2 + d3);
}
}
t ^= 1;
}
long long ans = 0;
for (int i = 0; i < 10; i++) {
ans = max(ans, dp[t][i]);
}
printf("%lld\n", ans);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int inf = 0x3f3f3f3f, mod = 1000000007;
const long long INF = 0x3f3f3f3f3f3f3f3fLL;
const double pi = acosl(-1.), eps = 1e-9;
inline int power(int a, int b, int m = mod, int ans = 1) {
for (; b; b >>= 1, a = 1LL * a * a % m)
if (b & 1) ans = 1LL * ans * a % m;
return ans;
}
const int NN = 202020;
long long dp[NN][12];
template <typename U, typename V>
inline void smax(U& a, V b) {
if (a < b) a = b;
}
void update(vector<long long>& a, int i) {
for (int j = 0; j < 10; j++)
if (~dp[i - 1][j]) {
long long mx = 0, sum = 0;
for (auto r : a) mx = max(mx, r), sum += r;
for (int r = a.size(); r; r--) {
if ((j + r) % 10 == 0) {
sum += mx;
break;
}
}
smax(dp[i][(j + a.size()) % 10], dp[i - 1][j] + sum);
}
}
int main() {
memset(dp, -1, sizeof dp);
int n;
scanf("%d", &n);
dp[0][0] = 0;
vector<vector<long long> > tmp;
vector<long long> v[10];
for (int i = 1, j, k, m; i <= n; i++) {
scanf("%d", &m);
for (j = 1; j <= 3; j++) v[j].clear();
tmp.clear();
while (m--) {
scanf("%d%d", &j, &k);
v[j].push_back(k);
}
for (int j = 1; j <= 3; j++) {
sort(v[j].begin(), v[j].end(),
[](long long a, long long b) { return a > b; });
}
if (v[1].size() >= 3) {
v[1].resize(3);
tmp.push_back(v[1]);
}
if (v[2].size() >= 1 && v[1].size() >= 1) {
tmp.push_back(vector<long long>{v[1][0], v[2][0]});
}
if (v[3].size() >= 1) {
v[3].resize(1);
tmp.push_back(v[3]);
}
if (v[2].size() >= 1) {
v[2].resize(1);
tmp.push_back(v[2]);
}
if (v[1].size() >= 2) {
v[1].resize(2);
tmp.push_back(v[1]);
}
if (v[1].size() >= 1) {
v[1].resize(1);
tmp.push_back(v[1]);
}
for (auto r : tmp) update(r, i);
for (int j = 0; j < 10; j++) {
smax(dp[i][j], dp[i - 1][j]);
}
}
long long ans = 0;
for (int i = 0; i < 10; i++) {
ans = max(dp[n][i], ans);
}
printf("%I64d\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long N = 2e5 + 100, M = 10, inF = 1e17;
long long n, k, c, d, dp[N][M];
vector<long long> vec[M];
vector<pair<long long, long long> > help;
void _max(long long &a, long long b) { a = max(a, b); }
int main() {
ios::sync_with_stdio(false), cin.tie(0);
cin >> n;
for (int i = 0; i < N; i++) fill(dp[i], dp[i] + M, -inF);
dp[0][0] = 0;
for (int i = 0; i < n; i++) {
for (int j = 1; j <= 3; j++) vec[j].clear();
cin >> k;
while (k--) {
cin >> c >> d;
vec[c].push_back(d);
}
help.clear();
for (int j = 1; j <= 3; j++) {
sort(vec[j].begin(), vec[j].end());
for (int dex = 0; dex < (int)vec[j].size() && (dex + 1) * j <= 3; dex++)
help.push_back(
pair<long long, long long>(j, vec[j][vec[j].size() - dex - 1]));
}
for (int mask = 0; mask < (1 << help.size()); mask++) {
long long s = 0, maxi = 0, used = 0, cnt = 0;
for (int i = 0; i < help.size(); i++)
if (mask & (1 << i))
s += help[i].second, maxi = max(maxi, help[i].second),
used += help[i].first, cnt++;
if (used > 3) continue;
for (int j = 0; j < M; j++)
if (j + cnt >= M)
_max(dp[i + 1][(j + cnt) - M], dp[i][j] + s + maxi);
else
_max(dp[i + 1][j + cnt], dp[i][j] + s);
}
}
cout << *max_element(dp[n], dp[n] + M);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long N = 2e5 + 12;
const long long S = 30;
const double EPS = 1e-12;
const int INF = 1e9 + 10;
const int MOD = 998244353;
const double PI = acos(-1);
vector<map<int, vector<long long> > > a;
long long dp[10][N], z[2][3];
void getZ(int i) {
for (int j = 0; j < 2; j++)
for (int k = 0; k < 3; k++) z[j][k] = 0;
if (a[i][1].size() > 2) {
for (int j = 0; j < 3; j++) z[0][2] += a[i][1][j];
for (int j = 0; j < 3; j++)
if (!j)
z[1][2] += a[i][1][j] * (long long)2;
else
z[1][2] += a[i][1][j];
}
if (a[i][1].size() > 0 && a[i][2].size() > 0) {
z[0][1] = a[i][1][0] + a[i][2][0];
z[1][1] = max(a[i][1][0], a[i][2][0]) * (long long)2 +
min(a[i][1][0], a[i][2][0]);
}
if (a[i][1].size() > 1) {
z[0][1] = max(z[0][1], a[i][1][0] + a[i][1][1]);
z[1][1] = max(z[1][1], a[i][1][0] * (long long)2 + a[i][1][1]);
}
if (a[i][2].size() > 0) {
z[0][0] = max(z[0][0], a[i][2][0]);
z[1][0] = max(z[1][0], a[i][2][0] * (long long)2);
}
if (a[i][1].size() > 0) {
z[0][0] = max(z[0][0], a[i][1][0]);
z[1][0] = max(z[1][0], a[i][1][0] * (long long)2);
}
if (a[i][3].size() > 0) {
z[0][0] = max(z[0][0], a[i][3][0]);
z[1][0] = max(z[1][0], a[i][3][0] * (long long)2);
}
}
int main() {
long long t, n, m, c, d;
cin >> n;
for (int i = 0; i < n; i++)
for (int j = 0; j < 10; j++) dp[j][i] = -1;
for (int i = 0; i < n; i++) {
cin >> m;
map<int, vector<long long> > buf;
for (int j = 0; j < m; j++) {
cin >> c >> d;
buf[c].push_back(d);
}
sort(buf[1].begin(), buf[1].end());
reverse(buf[1].begin(), buf[1].end());
sort(buf[2].begin(), buf[2].end());
reverse(buf[2].begin(), buf[2].end());
sort(buf[3].begin(), buf[3].end());
reverse(buf[3].begin(), buf[3].end());
a.push_back(buf);
}
for (int i = 0; i < n; i++) {
getZ(i);
if (!i) {
dp[0][i] = 0;
if (z[0][0] > 0) dp[1][i] = z[0][0];
if (z[0][1] > 0) dp[2][i] = z[0][1];
if (z[0][2] > 0) dp[3][i] = z[0][2];
continue;
}
for (int j = 0; j < 10; j++) {
if (dp[j][i - 1] == -1) continue;
dp[j][i] = max(dp[j][i - 1], dp[j][i]);
for (int k = 0; k < 3; k++) {
if (j + k + 1 < 10 && z[0][k] > 0)
dp[(j + k + 1) % 10][i] =
max(dp[(j + k + 1) % 10][i], dp[j][i - 1] + z[0][k]);
if (j + k + 1 >= 10 && z[1][k] > 0)
dp[(j + k + 1) % 10][i] =
max(dp[(j + k + 1) % 10][i], dp[j][i - 1] + z[1][k]);
}
}
}
long long ans = 0;
for (int i = 0; i < 10; i++) ans = max(ans, dp[i][n - 1]);
cout << ans << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
pair<int, int> cards[200010];
long long dp[200010][10];
int main(void) {
int N;
cin >> N;
for (int i = 1; i < 10; i++) dp[0][i] = -1;
for (int t = 0; t < N; t++) {
int K;
cin >> K;
for (int i = 0; i < K; i++) {
int c, d;
cin >> c >> d;
cards[i] = make_pair(d, c);
}
sort(cards, cards + K);
int one = cards[K - 1].first;
int twoflag = -1;
pair<int, int> two = make_pair(-1, -1);
int three[3];
three[0] = -1;
three[1] = -1;
three[2] = -1;
for (int i = K - 1; i >= 0; i--) {
if (cards[i].second == 3) continue;
if (cards[i].second == 2 && twoflag < 0) twoflag = 1;
if (twoflag < 0) twoflag = 0;
if (two.first == -1)
two.first = cards[i].first;
else if (two.second == -1 && (!twoflag || cards[i].second == 1))
two.second = cards[i].first;
if (cards[i].second != 1) continue;
if (three[0] == -1)
three[0] = cards[i].first;
else if (three[1] == -1)
three[1] = cards[i].first;
else if (three[2] == -1)
three[2] = cards[i].first;
}
for (int i = 0; i < 10; i++) dp[t + 1][i] = -1;
for (int i = 0; i < 10; i++) {
if (dp[t][i] == -1) continue;
dp[t + 1][i] = max(dp[t + 1][i], dp[t][i]);
if (i < 9)
dp[t + 1][i + 1] = max(dp[t + 1][i + 1], dp[t][i] + one);
else
dp[t + 1][0] = max(dp[t + 1][0], dp[t][i] + one * 2);
if (two.second != -1) {
if (i < 8)
dp[t + 1][i + 2] =
max(dp[t + 1][i + 2], dp[t][i] + two.first + two.second);
else
dp[t + 1][i - 8] =
max(dp[t + 1][i - 8], dp[t][i] + two.first * 2 + two.second);
}
if (three[2] != -1) {
if (i < 7)
dp[t + 1][i + 3] =
max(dp[t + 1][i + 3], dp[t][i] + three[0] + three[1] + three[2]);
else
dp[t + 1][i - 7] = max(dp[t + 1][i - 7],
dp[t][i] + three[0] * 2 + three[1] + three[2]);
}
}
}
long long ans = 0;
for (int i = 0; i < 10; i++) ans = max(ans, dp[N][i]);
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long MAX_N = 2 * 1E5 + 1, INF = 1e16;
long long dp[MAX_N][10];
void init_dp() {
dp[0][9] = 0;
for (long long i = 0; i < 9; i++) dp[0][i] = -INF;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
init_dp();
long long n, k, price, damage, ans = 0;
cin >> n;
for (long long each = 1; each <= n; each++) {
cin >> k;
long long two = -INF, three = -INF;
vector<long long> one(3, -INF);
for (long long j = 0; j < k; j++) {
cin >> price >> damage;
if (price == 1) {
if (damage > one[0]) {
one[2] = one[1];
one[1] = one[0];
one[0] = damage;
} else if (damage > one[1]) {
one[2] = one[1];
one[1] = damage;
} else if (damage > one[2])
one[2] = damage;
} else if (price == 2)
two = max(two, damage);
else
three = max(three, damage);
}
for (long long r = 0; r < 10; r++) {
dp[each][r] = dp[each - 1][(r + 3) % 10];
if (r == 8 || r == 9 || r == 7)
dp[each][r] += one[0] * 2 + one[1] + one[2];
else
dp[each][r] += one[0] + one[1] + one[2];
long long x = dp[each][r];
dp[each][r] = dp[each - 1][(r + 2) % 10];
if (r == 9 || r == 8)
dp[each][r] +=
max(one[0], max(two, one[1])) * 2 + min(one[0], max(two, one[1]));
else
dp[each][r] += one[0] + max(two, one[1]);
long long y = dp[each][r];
dp[each][r] = dp[each - 1][(r + 1) % 10];
long long f = max(one[0], max(two, three));
if (r == 9)
dp[each][r] += f * 2;
else
dp[each][r] += f;
long long z = dp[each][r];
dp[each][r] = max(x, max(y, max(z, dp[each - 1][r])));
}
}
for (long long j = 0; j < 10; j++) ans = max(ans, dp[n][j]);
cout << ans << "\n";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int INF = 1e9 + 7;
const int mod = 1e9 + 7;
long long int powmod(long long int a, long long int b) {
long long int res = 1;
a %= mod;
assert(b >= 0);
for (; b; b >>= 1) {
if (b & 1) res = res * a % mod;
a = a * a % mod;
}
return res;
}
int nxt() {
int x;
scanf("%d", &x);
return x;
}
void max_self(long long int &a, long long int b) { a = max(a, b); }
int main() {
int n = nxt();
vector<long long int> dp(10);
for (int i = 0; i < 10; i++) dp[i] = LLONG_MIN;
dp[0] = 0;
for (int i = 0; i < n; i++) {
vector<long long int> tmp = dp;
int k = nxt();
vector<int> a[3];
long long int best = 0;
for (int _ = 0; _ < k; _++) {
int c = nxt(), d = nxt();
c--;
a[c].push_back(d);
max_self(best, d);
}
for (int j = 0; j < 3; j++)
sort((a[j]).begin(), (a[j]).end(), greater<int>());
for (int j = 0; j < 10; j++) {
max_self(tmp[(j + 1) % 10], dp[j] + best * (j == 9 ? 2 : 1));
}
if (a[0].size() >= 2) {
long long int tt = 1LL * a[0][0] + a[0][1];
long long int t2 = a[0][0];
for (int j = 0; j < 10; j++) {
max_self(tmp[(j + 2) % 10], dp[j] + tt + (j >= 8 ? t2 : 0));
}
}
if (a[0].size() && a[1].size()) {
long long int tt = 1LL * a[0][0] + a[1][0];
long long int t2 = max(a[0][0], a[1][0]);
for (int j = 0; j < 10; j++) {
max_self(tmp[(j + 2) % 10], dp[j] + tt + (j >= 8 ? t2 : 0));
}
}
if (a[0].size() >= 3) {
long long int tt = 1LL * a[0][0] + a[0][1] + a[0][2];
long long int t2 = a[0][0];
for (int j = 0; j < 10; j++) {
max_self(tmp[(j + 3) % 10], dp[j] + tt + (j >= 7 ? t2 : 0));
}
}
dp = tmp;
}
printf("%lld\n", *max_element((dp).begin(), (dp).end()));
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int max_n = 200005;
int n;
long long dp[2][11];
vector<int> v[4];
vector<int> opt[4];
int nf = 0;
int main() {
scanf("%d", &n);
for (int i = 1; i <= 9; i++) dp[0][i] = -1;
dp[0][0] = 0;
nf = 0;
while (n--) {
int k;
scanf("%d", &k);
for (int i = 1; i <= 3; i++) v[i].clear(), opt[i].clear();
while (k--) {
int c, d;
scanf("%d%d", &c, &d);
v[c].push_back(d);
}
for (int i = 1; i <= 3; i++) sort(v[i].begin(), v[i].end(), greater<int>());
if (v[1].size() >= 3)
for (int i = 0; i < 3; i++) opt[3].push_back(v[1][i]);
vector<int> t;
for (int i = 0; i < min(2, (int)v[1].size()); i++) t.push_back(v[1][i]);
for (int i = 0; i < min(1, (int)v[2].size()); i++) t.push_back(v[2][i]);
sort(t.begin(), t.end(), greater<int>());
if (t.size() >= 2)
for (int i = 0; i < 2; i++) opt[2].push_back(t[i]);
int mx = 0;
for (int i = 1; i <= 3; i++)
if (!v[i].empty()) mx = max(mx, v[i][0]);
opt[1].push_back(mx);
nf ^= 1;
for (int i = 0; i <= 10; i++) dp[nf][i] = dp[nf ^ 1][i];
for (int i = 0; i <= 9; i++) {
if (dp[nf ^ 1][i] == -1) continue;
for (int j = 1; j <= 3; j++) {
if (opt[j].empty()) continue;
int b = (i + 1) % 10, e = (i + j) % 10;
long long x = 0;
for (auto y : opt[j]) x += y;
if (i + 1 <= 10 && i + j >= 10) x += opt[j][0];
dp[nf][e] = max(dp[nf][e], dp[nf ^ 1][i] + x);
}
}
}
long long ans = 0;
for (int i = 0; i <= 10; i++) ans = max(ans, dp[nf][i]);
printf("%lld\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 2e5 + 5;
long long inf = 0x3f3f3f3f3f3f3f3f;
int n, m, t;
long long f[maxn][15];
long long g[maxn][5][5][2];
int read() {
int x;
scanf("%d", &x);
return x;
}
int main() {
int i, j, k, l, r;
long long x, y;
n = read();
for (i = 0; i <= n; i++) {
for (j = 0; j <= 10; j++) {
f[i][j] = -inf;
}
}
f[0][0] = 0;
for (i = 1; i <= n; i++) {
m = read();
for (l = 0; l <= 3; l++) {
for (r = 0; r <= 3; r++) {
g[0][l][r][0] = g[0][l][r][1] = -inf;
}
}
g[0][0][0][0] = 0;
for (j = 1; j <= m; j++) {
x = read();
y = read();
for (l = 0; l <= 3; l++) {
for (r = 0; r <= 3; r++) {
g[j][l][r][0] = g[j - 1][l][r][0];
g[j][l][r][1] = g[j - 1][l][r][1];
}
}
for (l = 0; l <= 2; l++) {
for (r = 0; r <= 3 - x; r++) {
g[j][l + 1][r + x][0] =
max(g[j][l + 1][r + x][0], g[j - 1][l][r][0] + y);
g[j][l + 1][r + x][1] =
max(g[j][l + 1][r + x][1],
max(g[j - 1][l][r][0] + 2 * y, g[j - 1][l][r][1] + y));
}
}
}
for (j = 0; j < 10; j++) {
for (k = 0; k <= 3; k++) {
long long maxa = -inf;
long long maxb = -inf;
for (l = 0; l <= 3; l++) {
maxa = max(maxa, g[m][k][l][0]);
maxb = max(maxb, g[m][k][l][1]);
}
if (j + k >= 10) {
f[i][(j + k) % 10] = max(f[i][(j + k) % 10], f[i - 1][j] + maxb);
} else {
f[i][j + k] = max(f[i][j + k], f[i - 1][j] + maxa);
}
}
}
}
long long ans = -inf;
for (i = 0; i < 10; i++) {
ans = max(ans, f[n][i]);
}
printf("%lld\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long N, dp[2][10], K[200005], X, Y;
vector<long long> card[200005][4];
vector<pair<long long, long long> > opt[200005];
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cin >> N;
for (int i = 1; i <= N; ++i) {
cin >> K[i];
for (int j = 1; j <= K[i]; ++j) {
cin >> X >> Y;
card[i][X].push_back(Y);
}
for (int j = 1; j < 4; ++j) {
sort(card[i][j].begin(), card[i][j].end());
reverse(card[i][j].begin(), card[i][j].end());
while (card[i][j].size() > (3 / j)) {
card[i][j].pop_back();
}
for (auto it : card[i][j]) {
opt[i].push_back(pair<long long, long long>(j, it));
}
}
}
for (int i = 0; i < 2; ++i) {
for (int k = 0; k < 10; ++k) {
dp[i][k] = -1e18;
}
}
dp[0][0] = 0;
for (int i = 1; i <= N; ++i) {
for (int j = 0; j < 10; ++j) dp[i & 1][j] = -1e18;
for (int mask = 0; mask < (1 << (int)opt[i].size()); ++mask) {
long long totc = 0;
vector<long long> dmg;
for (int j = 0; j < opt[i].size(); ++j) {
if (mask & (1 << j)) {
totc += opt[i][j].first;
dmg.push_back(opt[i][j].second);
}
}
if (totc > 3) continue;
sort(dmg.begin(), dmg.end());
do {
for (int m = 0; m < 10; ++m) {
long long totd = 0;
for (int j = 0; j < dmg.size(); ++j) {
int c_count = (m + j + 1) % 10;
totd += (c_count == 0 ? 2 * dmg[j] : dmg[j]);
}
dp[i & 1][(m + dmg.size()) % 10] =
max(dp[i & 1][(m + dmg.size()) % 10], dp[(i - 1) & 1][m] + totd);
}
} while (next_permutation(dmg.begin(), dmg.end()));
}
}
long long ans = 0;
for (int m = 0; m < 10; ++m) {
ans = max(ans, dp[N & 1][m]);
}
cout << ans << '\n';
}
|
#include <bits/stdc++.h>
const int N = 2e5 + 2;
using namespace std;
int n, sl;
long long st[4][N];
int top[4];
long long dp[10], Pre[10];
bool ss(int x, int y) { return x > y; }
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> n;
for (int i = 1; i <= 9; i++) Pre[i] = -1e18;
for (int i = 1; i <= n; i++) {
cin >> sl;
top[1] = top[2] = top[3] = 0;
for (int j = 1; j <= sl; j++) {
int x, y;
cin >> x >> y;
st[x][++top[x]] = y;
}
sort(st[1] + 1, st[1] + top[1] + 1, ss);
sort(st[2] + 1, st[2] + top[2] + 1, ss);
sort(st[3] + 1, st[3] + top[3] + 1, ss);
for (int j = 0; j <= 9; j++) dp[j] = -1e18;
for (int j = 0; j <= 9; j++) {
long long val;
dp[j] = max(dp[j], Pre[j]);
val = -1e18;
if (top[1]) val = max(val, st[1][1]);
if (top[2]) val = max(val, st[2][1]);
if (top[3]) val = max(val, st[3][1]);
if (j < 9)
dp[j + 1] = max(dp[j + 1], Pre[j] + val);
else
dp[0] = max(dp[0], Pre[j] + 2ll * val);
if (j < 8) {
val = -1e18;
if (top[1] > 1) val = max(val, st[1][1] + st[1][2]);
if (top[1] && top[2]) val = max(val, st[1][1] + st[2][1]);
dp[j + 2] = max(dp[j + 2], Pre[j] + val);
} else {
val = -1e18;
if (top[1] > 1)
val =
max(val, 2ll * max(st[1][1], st[1][2]) + min(st[1][1], st[1][2]));
if (top[1] && top[2])
val =
max(val, 2ll * max(st[1][1], st[2][1]) + min(st[1][1], st[2][1]));
dp[j - 8] = max(dp[j - 8], Pre[j] + val);
}
if (top[1] > 2) {
if (j < 7)
dp[j + 3] = max(dp[j + 3], Pre[j] + st[1][1] + st[1][2] + st[1][3]);
else {
long long mx = max(st[1][1], max(st[1][2], st[1][3]));
long long mi = min(st[1][1], min(st[1][2], st[1][3]));
long long en = st[1][1] + st[1][2] + st[1][3] - mx - mi;
dp[j - 7] = max(dp[j - 7], Pre[j] + mi + 2ll * mx + en);
}
}
}
for (int j = 0; j <= 9; j++) Pre[j] = dp[j];
}
long long res = -1e18;
for (int j = 0; j <= 9; j++) res = max(res, dp[j]);
cout << res;
}
|
#include <bits/stdc++.h>
using namespace std;
const int INF = 0x3f3f3f3f;
const long long LINF = 0x3f3f3f3f3f3f3f3fll;
long long dp[200001][11];
vector<vector<vector<long long> > > turnos;
long long n, turno;
long long solve2(long long pegas, long long dobro) {
long long resp, ma1, ma2, segMa1, terMa1;
if (pegas == 1) {
resp = -LINF;
for (long long el : turnos[turno][0]) {
resp = max(resp, el);
}
for (long long el : turnos[turno][1]) {
resp = max(resp, el);
}
for (long long el : turnos[turno][2]) {
resp = max(resp, el);
}
if (resp == -LINF) {
return resp;
}
if (dobro) {
return 2 * resp;
}
return resp;
}
if (pegas == 2) {
ma1 = -LINF, segMa1 = -LINF, ma2 = -LINF;
if (turnos[turno][0].size() >= 1) {
ma1 = turnos[turno][0][0];
}
if (turnos[turno][0].size() >= 2) {
segMa1 = turnos[turno][0][1];
}
if (turnos[turno][1].size() >= 1) {
ma2 = turnos[turno][1][0];
}
if (ma1 + segMa1 > ma1 + ma2) {
if (ma1 == -LINF || segMa1 == -LINF) {
return -LINF;
}
if (dobro) {
return ma1 + segMa1 + max(ma1, segMa1);
}
return ma1 + segMa1;
} else {
if (ma1 == -LINF || ma2 == -LINF) {
return -LINF;
}
if (dobro) {
return ma1 + ma2 + max(ma1, ma2);
}
return ma1 + ma2;
}
}
if (pegas == 3) {
ma1 = -LINF, segMa1 = -LINF;
terMa1 = -LINF;
if (turnos[turno][0].size() >= 1) {
ma1 = turnos[turno][0][0];
}
if (turnos[turno][0].size() >= 2) {
segMa1 = turnos[turno][0][1];
}
if (turnos[turno][0].size() >= 3) {
terMa1 = turnos[turno][0][2];
}
if (ma1 == -LINF || segMa1 == -LINF || terMa1 == -LINF) {
return -LINF;
}
if (dobro) {
return ma1 + segMa1 + terMa1 + max({ma1, segMa1, terMa1});
}
return ma1 + segMa1 + terMa1;
}
return 0;
}
long long solve(long long at, long long jogadas) {
if (at == n) {
return 0;
}
if (dp[at][jogadas] != -1) {
return dp[at][jogadas];
}
long long resp = 0;
for (long long I = 0; I <= 3; I++) {
long long dobro = 0;
if (jogadas + I >= 10) {
dobro = 1;
}
turno = at;
long long ganho = solve2(I, dobro);
if (ganho != -LINF) {
resp = max(resp, ganho + solve(at + 1, (jogadas + I) % 10));
}
}
return dp[at][jogadas] = resp;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cin >> n;
turnos.resize(n, vector<vector<long long> >(3));
for (long long I = 0; I < n; I++) {
long long k;
cin >> k;
map<long long, multiset<long long, greater<long long> > > mapa;
for (long long J = 0; J < k; J++) {
long long c, d;
cin >> c >> d;
mapa[c].insert(d);
}
auto it = mapa[1].begin();
if (it != mapa[1].end()) {
turnos[I][0].push_back(*it);
it++;
}
if (it != mapa[1].end()) {
turnos[I][0].push_back(*it);
it++;
}
if (it != mapa[1].end()) {
turnos[I][0].push_back(*it);
}
it = mapa[2].begin();
if (it != mapa[2].end()) {
turnos[I][1].push_back(*it);
}
it = mapa[3].begin();
if (it != mapa[3].end()) {
turnos[I][2].push_back(*it);
}
}
memset(dp, -1, sizeof(dp));
cout << solve(0, 0) << '\n';
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 10;
long long dp[N][10];
long long num1[N][3], cnt1[N];
long long num2[N];
long long num3[N];
int k[N];
bool vis[N][10];
int main() {
int n;
scanf("%d", &n);
memset(num1, 0, sizeof(num1));
memset(num2, 0, sizeof(num2));
memset(num3, 0, sizeof(num3));
memset(cnt1, 0, sizeof(cnt1));
memset(dp, 0, sizeof(dp));
memset(vis, 0, sizeof(vis));
for (int i = 1; i <= n; i++) {
scanf("%d", &k[i]);
for (int j = 1; j <= k[i]; j++) {
int c, d;
scanf("%d%d", &c, &d);
if (c == 1) {
if (d >= num1[i][0]) {
num1[i][2] = num1[i][1];
num1[i][1] = num1[i][0];
num1[i][0] = d;
cnt1[i]++;
} else if (d >= num1[i][1]) {
num1[i][2] = num1[i][1];
num1[i][1] = d;
cnt1[i]++;
} else if (d >= num1[i][2]) {
num1[i][2] = d;
cnt1[i]++;
}
} else if (c == 2) {
if (d > num2[i]) num2[i] = d;
} else if (c == 3) {
if (d > num3[i]) num3[i] = d;
}
if (cnt1[i] > 3) cnt1[i] = 3;
}
}
vis[0][0] = true;
for (int i = 0; i < n; i++) {
for (int j = 0; j <= 9; j++) {
if (!vis[i][j]) continue;
dp[i + 1][j] = max(dp[i + 1][j], dp[i][j]);
vis[i + 1][j] = true;
if (num3[i + 1] != 0) {
if (j == 9)
dp[i + 1][0] = max(dp[i + 1][0], dp[i][j] + 2 * num3[i + 1]);
else
dp[i + 1][j + 1] = max(dp[i + 1][j + 1], dp[i][j] + num3[i + 1]);
vis[i + 1][(j + 1) % 10] = true;
}
if (num2[i + 1] != 0) {
if (j == 9)
dp[i + 1][0] = max(dp[i + 1][0], dp[i][j] + 2 * num2[i + 1]);
else
dp[i + 1][j + 1] = max(dp[i + 1][j + 1], dp[i][j] + num2[i + 1]);
vis[i + 1][(j + 1) % 10] = true;
}
if (cnt1[i + 1] > 0) {
if (j == 9)
dp[i + 1][0] = max(dp[i + 1][0], dp[i][j] + 2 * num1[i + 1][0]);
else
dp[i + 1][j + 1] = max(dp[i + 1][j + 1], dp[i][j] + num1[i + 1][0]);
vis[i + 1][(j + 1) % 10] = true;
}
if (num2[i + 1] != 0 && num1[i + 1][0] != 0) {
int maxx = max(num2[i + 1], num1[i + 1][0]);
if (j >= 8)
dp[i + 1][(j + 2) % 10] =
max(dp[i + 1][(j + 2) % 10],
dp[i][j] + maxx + num2[i + 1] + num1[i + 1][0]);
else
dp[i + 1][(j + 2) % 10] =
max(dp[i + 1][j + 2], dp[i][j] + num2[i + 1] + num1[i + 1][0]);
vis[i + 1][(j + 2) % 10] = true;
}
if (cnt1[i + 1] > 1) {
if (j >= 8)
dp[i + 1][(j + 2) % 10] =
max(dp[i + 1][(j + 2) % 10],
dp[i][j] + 2 * num1[i + 1][0] + num1[i + 1][1]);
else
dp[i + 1][j + 2] =
max(dp[i + 1][j + 2], dp[i][j] + num1[i + 1][0] + num1[i + 1][1]);
vis[i + 1][(j + 2) % 10] = true;
}
if (cnt1[i + 1] > 2) {
if (j >= 7)
dp[i + 1][(j + 3) % 10] =
max(dp[i + 1][(j + 3) % 10], dp[i][j] + 2 * num1[i + 1][0] +
num1[i + 1][1] + num1[i + 1][2]);
else
dp[i + 1][(j + 3) % 10] =
max(dp[i + 1][(j + 3) % 10],
dp[i][j] + num1[i + 1][0] + num1[i + 1][1] + num1[i + 1][2]);
vis[i + 1][(j + 3) % 10] = true;
}
}
}
long long ans = 0;
for (int i = 0; i < 10; i++) ans = max(ans, dp[n][i]);
printf("%lld\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
bool isrange(int second, int first, int n, int m) {
if (0 <= second && second < n && 0 <= first && first < m) return true;
return false;
}
int dy[4] = {1, 0, -1, 0}, dx[4] = {0, 1, 0, -1},
ddy[8] = {1, 0, -1, 0, 1, 1, -1, -1}, ddx[8] = {0, 1, 0, -1, 1, -1, 1, -1};
bool tmr(long long int a, long long int b) { return a > b; }
const int MAX = 202020;
long long int dp[MAX][10];
int lim = 0;
int main(void) {
int n;
scanf("%d", &n);
memset(dp, -1, sizeof(dp));
dp[0][0] = 0;
for (int e = 1; e <= n; e++) {
int k;
scanf("%d", &k);
vector<long long int> v[4];
for (int p = 0; p < k; p++) {
int c, d;
scanf("%d%d", &c, &d);
v[c].push_back((long long int)d);
}
for (int e = 1; e <= 3; e++) sort(v[e].begin(), v[e].end(), tmr);
pair<long long int, long long int> vv[4][4];
for (int e = 0; e < 4; e++) {
for (int p = 1; p < 4; p++) vv[e][p] = make_pair(-1, -1);
}
for (int e = 1; e <= 3; e++) {
if ((int)v[e].size()) {
vv[1][e] = make_pair(v[e][0], v[e][0]);
}
}
if ((int)v[1].size() >= 2) {
vv[2][1] = make_pair(v[1][0] + v[1][1], v[1][0]);
}
if ((int)v[1].size() && (int)v[2].size()) {
vv[2][2] = make_pair(v[1][0] + v[2][0], max(v[1][0], v[2][0]));
}
if ((int)v[1].size() >= 3) {
vv[3][1] = make_pair(v[1][0] + v[1][1] + v[1][2], v[1][0]);
}
for (int p = 0; p < 10; p++) dp[e][p] = dp[e - 1][p];
for (int p = 1; p <= 3; p++) {
for (int q = 1; q <= 3; q++) {
if (vv[p][q].first == -1) continue;
for (int r = 0; r < 10; r++) {
if (dp[e - 1][r] == -1) continue;
if (r + p >= 10) {
dp[e][(r + p) % 10] =
max(dp[e][(r + p) % 10],
dp[e - 1][r] + vv[p][q].first + vv[p][q].second);
} else {
dp[e][r + p] = max(dp[e][r + p], dp[e - 1][r] + vv[p][q].first);
}
}
}
}
}
long long int ans = -1;
for (int e = 0; e < 10; e++) ans = max(ans, dp[n][e]);
printf("%lld\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long _abs(long long x) { return (x > 0 ? x : -x); }
const int N = 2e5 + 5;
int n, k, cost, damage;
vector<long long> d[N][4];
long long dp[N][12];
bool comp(long long a, long long b) { return a > b; }
long long solve(int i, int nc) {
if (i == n) return 0;
long long& r = dp[i][nc];
if (r != -1) return r;
long long best[4];
for (int cost = 1; cost <= 3; cost++)
best[cost] = (d[i][cost].size()) ? d[i][cost][0] : 0ll;
long long o9 = 1 + (nc == 9), o8 = 1 + (nc >= 8), o7 = 1 + (nc >= 7);
r = max(r,
o9 * max({best[1], best[2], best[3]}) + solve(i + 1, (nc + 1) % 10));
if (best[1] && best[2])
r = max(r, o8 * max(best[1], best[2]) + min(best[1], best[2]) +
solve(i + 1, (nc + 2) % 10));
if (d[i][1].size() >= 2)
r = max(r, o8 * d[i][1][0] + d[i][1][1] + solve(i + 1, (nc + 2) % 10));
if (d[i][1].size() >= 3)
r = max(r, o7 * d[i][1][0] + d[i][1][1] + d[i][1][2] +
solve(i + 1, (nc + 3) % 10));
r = max(r, solve(i + 1, nc));
return r;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
memset(dp, -1, sizeof dp);
cin >> n;
for (int i = 0; i < n; i++) {
cin >> k;
while (k--) {
cin >> cost >> damage;
d[i][cost].push_back(damage);
}
sort(d[i][1].begin(), d[i][1].end(), comp);
sort(d[i][2].begin(), d[i][2].end(), comp);
sort(d[i][3].begin(), d[i][3].end(), comp);
}
cout << solve(0, 0) << endl;
}
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.