solution
stringlengths 11
983k
| difficulty
int64 0
21
| language
stringclasses 2
values |
|---|---|---|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e6 + 7;
const int inf = INT_MAX;
const long long inff = 1e18;
const long long mod = 1e9 + 7;
int dp[77][77];
int a[77], b[77];
int used[77];
int32_t main() {
ios::sync_with_stdio(0);
cin.tie(0);
int t;
cin >> t;
while (t--) {
int n, k;
cin >> n >> k;
for (int i = 1; i <= n; i++) cin >> a[i] >> b[i];
if (k == 1) {
int att = 0, mx = 0;
for (int i = 1; i <= n; i++)
if (a[i] > mx) mx = a[i], att = i;
cout << 1 << '\n' << att << '\n';
} else {
memset(dp, 0, sizeof(dp));
memset(used, 0, sizeof(used));
for (int i = 0; i <= n; i++)
for (int j = 1; j <= k; j++) dp[i][j] = -inf;
dp[0][0] = 0;
vector<int> v;
for (int i = 1; i <= n; i++) v.push_back(i);
sort((v).begin(), (v).end(), [&](int x, int y) { return b[x] < b[y]; });
for (int i = 1; i <= n; i++)
for (int j = 1; j <= min(i, k); j++) {
if (j - 1 <= i) dp[i][j] = dp[i - 1][j];
dp[i][j] = max(dp[i][j], dp[i - 1][j - 1] +
(a[v[i - 1]] - (k - j) * b[v[i - 1]]));
}
vector<int> vv;
int nowk = k;
for (int i = n; i >= 1; i--) {
if (nowk > 0 &&
dp[i - 1][nowk - 1] + (a[v[i - 1]] - (k - nowk) * b[v[i - 1]]) ==
dp[i][nowk]) {
used[v[i - 1]] = 1;
vv.push_back(v[i - 1]);
nowk--;
}
}
reverse((vv).begin(), (vv).end());
cout << 2 * n - k << '\n';
for (int i = 0; i < k - 1; i++) cout << vv[i] << ' ';
for (int i = 1; i <= n; i++)
if (!used[i]) cout << i << ' ' << -i << ' ';
cout << vv[k - 1] << '\n';
}
}
}
| 12 | CPP |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
int t;
cin >> t;
while (t--) {
int n, k;
cin >> n >> k;
vector<int> a(n);
vector<int> b(n);
for (int i = 0; i < n; i++) cin >> a[i] >> b[i];
if (n == k) {
vector<array<int, 2>> v(n);
for (int i = 0; i < n; i++) v[i] = {b[i], i};
sort(v.begin(), v.end());
cout << n << "\n";
for (int i = 0; i < n; i++) cout << v[i][1] + 1 << " \n"[i == n - 1];
continue;
}
vector<vector<int>> dp(n + 1, vector<int>(n + 1, -1));
vector<vector<bool>> p(n + 1, vector<bool>(n + 1, 0));
dp[0][0] = 0;
vector<array<int, 2>> v(n);
for (int i = 0; i < n; i++) v[i] = {b[i], i};
sort(v.begin(), v.end());
for (int i = 0; i < n; i++) {
int x = v[i][1];
for (int j = 0; j <= n; j++) {
if (dp[i][j] == -1) continue;
if (dp[i][j] + a[x] + j * b[x] > dp[i + 1][j + 1]) {
dp[i + 1][j + 1] = dp[i][j] + a[x] + j * b[x];
p[i + 1][j + 1] = 0;
}
if (dp[i][j] + (k - 1) * b[x] > dp[i + 1][j]) {
dp[i + 1][j] = dp[i][j] + (k - 1) * b[x];
p[i + 1][j] = 1;
}
}
}
vector<int> one;
vector<int> two;
int now = k;
for (int i = n; i >= 1; i--) {
int x = v[i - 1][1];
if (p[i][now] == 0) {
one.push_back(x);
now--;
} else
two.push_back(x);
}
reverse(one.begin(), one.end());
vector<int> res;
for (int i = 0; i < k - 1; i++) res.push_back(one[i] + 1);
for (int x : two) {
res.push_back(x + 1);
res.push_back(-(x + 1));
}
res.push_back(one[k - 1] + 1);
cout << res.size() << "\n";
for (int x : res) cout << x << " ";
cout << "\n";
}
return 0;
}
| 12 | CPP |
#include <bits/stdc++.h>
using namespace std;
int T, n, k;
struct card {
int a, b, id;
} A[105];
int f[105][105], fr[105][105];
int use[105], used[105], cnt, pos, num;
int cmp(card u, card v) { return u.b < v.b; }
int main() {
scanf("%d", &T);
while (T--) {
scanf("%d %d", &n, &k);
for (int i = 1; i <= n; i++) scanf("%d %d", &A[i].a, &A[i].b), A[i].id = i;
sort(A + 1, A + n + 1, cmp);
memset(f, 0, sizeof(f));
memset(used, 0, sizeof(used));
for (int i = 1; i <= n; i++) {
for (int j = 0; j < i; j++) {
if (f[i][j] < f[i - 1][j] + (k - 1) * A[i].b)
f[i][j] = f[i - 1][j] + (k - 1) * A[i].b, fr[i][j] = j;
if (f[i][j + 1] < f[i - 1][j] + A[i].a + j * A[i].b)
f[i][j + 1] = f[i - 1][j] + A[i].a + j * A[i].b, fr[i][j + 1] = j;
}
}
cnt = 0, pos = n, num = k;
while (pos) {
if (fr[pos][num] == num - 1) use[++cnt] = A[pos].id, used[A[pos].id] = 1;
num = fr[pos][num], pos--;
}
reverse(use + 1, use + cnt + 1);
printf("%d\n", 2 * n - k);
for (int i = 1; i < cnt; i++) printf("%d ", use[i]);
for (int i = 1; i <= n; i++)
if (!used[i]) printf("%d %d ", i, -i);
printf("%d\n", use[cnt]);
}
return 0;
}
| 12 | CPP |
#include <bits/stdc++.h>
using namespace std;
const long long N = 105;
long long n, k;
struct P {
long long x, y, id;
} a[N];
long long f[N][N], g[N][N];
bool maximize(long long &x, long long y) {
if (x < y) {
x = y;
return true;
}
return false;
}
void Main() {
cin >> n >> k;
for (long long i = 1, __c = n; i <= __c; ++i)
cin >> a[i].x >> a[i].y, a[i].id = i;
memset(f, -1, sizeof(f));
memset(g, 0, sizeof(g));
sort(a + 1, a + n + 1, [](P x, P y) { return x.y < y.y; });
f[0][0] = 0;
for (long long i = 0, __c = n - 1; i <= __c; ++i) {
for (long long j = 0, __c = k; j <= __c; ++j)
if (f[i][j] != -1) {
if (maximize(f[i + 1][j], f[i][j] + (k - 1) * a[i + 1].y))
g[i + 1][j] = 1;
if (j < k)
if (maximize(f[i + 1][j + 1], f[i][j] + j * a[i + 1].y + a[i + 1].x))
g[i + 1][j + 1] = 2;
}
}
vector<long long> pa;
vector<long long> nope;
long long now = k;
for (long long i = n, __c = 1; i >= __c; --i) {
if (g[i][now] == 2)
pa.push_back(a[i].id), now--;
else
nope.push_back(a[i].id);
}
reverse(begin(pa), end(pa));
now = pa.back();
pa.pop_back();
for (auto &i : nope) pa.push_back(i), pa.push_back(-i);
pa.push_back(now);
cout << pa.size() << '\n';
for (auto &v : pa) cout << v << ' ';
cout << '\n';
}
int32_t main() {
ios_base::sync_with_stdio(false), cin.tie(0), cout.tie(0);
if (fopen("TASK"
".inp",
"r"))
freopen(
"TASK"
".inp",
"r", stdin);
long long T;
cin >> T;
for (long long _ = 1, __c = T; _ <= __c; ++_) {
Main();
}
}
| 12 | CPP |
#include <bits/stdc++.h>
using namespace std;
long long mod = 998244353;
long long powmod(long long a, long long b) {
long long res = 1;
a %= mod;
assert(b >= 0);
for (; b; b >>= 1) {
if (b & 1) res = res * a % mod;
a = a * a % mod;
}
return res;
}
long long gcd(long long a, long long b) { return b ? gcd(b, a % b) : a; }
double PI = 3.14159265358979323846;
long double e = 2.71828182845904523536028747135266249775724709369995;
long long fill(vector<pair<pair<long long, long long>, long long> > &v,
vector<vector<long long> > &dp, long long idx, long long k,
long long n, long long realn) {
assert(idx >= 0 && k >= 0);
if (dp[idx][k] != -1) return dp[idx][k];
if (idx + 1 == k) {
if (idx == 0) {
dp[idx][k] = v[idx].first.second;
return dp[idx][k];
}
dp[idx][k] = v[idx].first.second + v[idx].first.first * (n) +
fill(v, dp, idx - 1, k - 1, n - 1, realn);
return dp[idx][k];
}
if (k == 0) {
if (idx == 0) {
dp[idx][k] = v[idx].first.first * (realn - 1);
return dp[idx][k];
}
long long a = fill(v, dp, idx - 1, k, n, realn);
dp[idx][k] = a + v[idx].first.first * (realn - 1);
return dp[idx][k];
}
long long a =
fill(v, dp, idx - 1, k, n, realn) + v[idx].first.first * (realn - 1);
long long b = fill(v, dp, idx - 1, k - 1, n - 1, realn) +
v[idx].first.second + v[idx].first.first * (n);
dp[idx][k] = max(a, b);
return dp[idx][k];
}
void solve() {
long long k, n;
cin >> n >> k;
vector<pair<pair<long long, long long>, long long> > v(n);
for (long long i = 0; i < n; i++) {
cin >> v[i].first.second >> v[i].first.first;
v[i].second = i + 1;
}
sort(v.begin(), v.end());
vector<vector<long long> > dp(n, vector<long long>(k + 1, -1));
fill(v, dp, n - 1, k, k - 1, k);
vector<long long> choose;
long long cnt = 0;
for (long long i = n - 1; i >= 0; i--) {
if (cnt == k) break;
if (i == 0) {
choose.push_back(i);
cnt++;
break;
}
if (dp[i][k - cnt] == dp[i - 1][k - cnt - 1] +
(k - 1 - cnt) * v[i].first.first +
v[i].first.second) {
cnt++;
choose.push_back(i);
} else {
continue;
}
}
assert(cnt == k);
cout << 2 * n - k << endl;
set<long long> s;
for (long long i = cnt - 1; i >= 1; i--) {
cout << v[choose[i]].second << " ";
s.insert(v[choose[i]].second);
}
for (long long i = 1; i <= n; i++) {
if (s.find(i) == s.end() && i != v[choose[0]].second)
cout << i << " " << -i << " ";
}
cout << v[choose[0]].second << endl;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.precision(20);
int t = 1;
cin >> t;
for (int i = 0; i < t; i++) {
solve();
}
return 0;
}
| 12 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int inf = 1023456789;
struct minion {
int a, b, i;
};
void solve_case() {
int N, K;
cin >> N >> K;
vector<minion> minions(N);
for (int i = 0; i < N; ++i) {
cin >> minions[i].a >> minions[i].b;
minions[i].i = i;
}
sort(minions.begin(), minions.end(),
[](const minion &x, const minion &y) { return x.b < y.b; });
vector<vector<int>> dp_score(N, vector<int>(K + 1, -inf));
vector<vector<bool>> dp_keep(N, vector<bool>(K + 1));
for (int i = 0; i < N; ++i) {
for (int j = 0; j <= min(i + 1, K); ++j) {
int score_keep_minion = j == 0 ? -inf
: ((i == 0 ? 0 : dp_score[i - 1][j - 1]) +
minions[i].a + (j - 1) * minions[i].b);
int score_destroy_minion =
j == i + 1
? -inf
: (i == 0 ? 0 : dp_score[i - 1][j]) + minions[i].b * (K - 1);
if (score_keep_minion > score_destroy_minion) {
dp_score[i][j] = score_keep_minion;
dp_keep[i][j] = true;
} else {
dp_score[i][j] = score_destroy_minion;
dp_keep[i][j] = false;
};
}
}
vector<int> keep;
vector<int> destroy;
int j = K;
for (int i = N - 1; i >= 0; --i) {
if (dp_keep[i][j]) {
keep.push_back(minions[i].i);
j--;
} else {
destroy.push_back(minions[i].i);
}
}
assert(j == 0);
assert(keep.size() == K);
reverse(keep.begin(), keep.end());
cout << (keep.size() + 2 * destroy.size()) << "\n";
for (int i = 0; i < K - 1; ++i) {
cout << (1 + keep[i]) << " ";
}
for (int i = 0; i < destroy.size(); ++i) {
cout << (1 + destroy[i]) << " ";
cout << -(1 + destroy[i]) << " ";
}
cout << (1 + keep[K - 1]) << "\n";
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
int T;
cin >> T;
for (int t = 0; t < T; ++t) {
solve_case();
}
return 0;
}
| 12 | CPP |
#include <bits/stdc++.h>
using namespace std;
const long long N = 80;
const long long INF = 1e18 + 239;
long long dp[N][N];
long long wr[N][N];
void init() {
for (long long i = 0; i < N; i++) {
for (long long j = 0; j < N; j++) {
dp[i][j] = -INF;
wr[i][j] = -1;
}
}
dp[0][0] = 0;
}
void solve(long long n, long long k, vector<long long> a, vector<long long> b,
vector<long long> tind, long long &ans, vector<long long> &res) {
vector<long long> ind(n);
iota(ind.begin(), ind.end(), 0);
sort(ind.begin(), ind.end(),
[&](long long i, long long j) { return b[i] < b[j]; });
init();
for (long long i = 0; i < n; i++) {
for (long long j = 0; j < n; j++) {
if (dp[i][j] == -INF) continue;
if (dp[i + 1][j] < dp[i][j] + (k)*b[ind[i]]) {
dp[i + 1][j] = dp[i][j] + (k)*b[ind[i]];
wr[i + 1][j] = 0;
}
if (j + 1 <= k) {
if (dp[i + 1][j + 1] < dp[i][j] + j * b[ind[i]] + a[ind[i]]) {
dp[i + 1][j + 1] = dp[i][j] + j * b[ind[i]] + a[ind[i]];
wr[i + 1][j + 1] = 1;
}
}
}
}
long long cans = dp[n][k];
long long wans = k;
ans = cans;
res.clear();
vector<long long> rv(n);
for (long long i = n; i > 0; i--) {
rv.push_back(wr[i][wans]);
if (wr[i][wans] == 1) wans--;
}
reverse(rv.begin(), rv.end());
for (long long i = 0; i < n; i++) {
if (rv[i] == 1) {
res.push_back((tind[ind[i]] + 1));
}
}
for (long long i = 0; i < n; i++) {
if (rv[i] != 1) {
res.push_back((tind[ind[i]] + 1));
res.push_back(-(tind[ind[i]] + 1));
}
}
}
void solve() {
long long n, k;
cin >> n >> k;
vector<long long> a(n);
vector<long long> b(n);
for (long long i = 0; i < n; i++) {
cin >> a[i] >> b[i];
}
vector<long long> ind(n);
iota(ind.begin(), ind.end(), 0);
sort(ind.begin(), ind.end(),
[&](long long i, long long j) { return b[i] > b[j]; });
long long ans = -INF;
vector<long long> res;
{
for (long long rs = 0; rs < n; rs++) {
vector<long long> na, nb;
vector<long long> tind;
for (long long i = 0; i < n; i++) {
if (i != rs) {
na.push_back(a[ind[i]]);
nb.push_back(b[ind[i]]);
tind.push_back(ind[i]);
}
}
long long tans = -INF;
vector<long long> tv;
solve(n - 1, k - 1, na, nb, tind, tans, tv);
tv.push_back((ind[rs] + 1));
tans += (k - 1) * b[ind[rs]];
tans += a[ind[rs]];
if (tans > ans) {
ans = tans;
res = tv;
}
}
}
cout << res.size() << endl;
for (auto t : res) {
cout << t << ' ';
}
cout << endl;
}
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
long long q;
cin >> q;
while (q--) {
solve();
}
}
| 12 | CPP |
#include <bits/stdc++.h>
#pragma GCC optimize("-O3")
#pragma GCC optimize("Ofast")
#pragma GCC optimize("unroll-loops")
using namespace std;
const long long MOD = 1e9 + 7;
const long long INF = 1e18;
const double E = 1e-8;
const double pi = acos(-1);
mt19937_64 rnd(time(0));
long long n, m, k, h, T;
long long dp[80][80];
bool tt[80][80];
pair<pair<long long, long long>, long long> a[1001];
long long binpow(long long h, long long r, long long md = MOD) {
long long l = 1;
while (r) {
if (r & 1) l *= h, l %= md;
h *= h;
h %= md;
r /= 2;
}
return l;
}
long long gcd(long long x, long long y) {
if (x < y) swap(x, y);
while (x && y) {
x %= y;
swap(x, y);
}
return x + y;
}
bool comp(pair<pair<long long, long long>, long long> x,
pair<pair<long long, long long>, long long> y) {
return x.first.second < y.first.second;
}
void solve() {
cin >> n >> m;
m = min(n, m);
for (int i = 1; i <= n; i++) {
cin >> a[i].first.first >> a[i].first.second;
a[i].second = i;
}
sort(a + 1, a + n + 1, comp);
for (int i = 0; i <= n; i++)
for (int j = 0; j <= m; j++) dp[i][j] = -1e18;
dp[0][0] = 0;
for (int i = 0; i < n; i++)
for (int j = 0; j <= m; j++) {
if (dp[i + 1][j] < dp[i][j] + a[i + 1].first.second * (m - 1)) {
dp[i + 1][j] =
max(dp[i + 1][j], dp[i][j] + a[i + 1].first.second * (m - 1));
tt[i + 1][j] = 0;
}
if (j < m && dp[i + 1][j + 1] < dp[i][j] + a[i + 1].first.first +
a[i + 1].first.second * j) {
dp[i + 1][j + 1] =
max(dp[i + 1][j + 1],
dp[i][j] + a[i + 1].first.first + a[i + 1].first.second * j);
tt[i + 1][j + 1] = 1;
}
}
long long p = m;
vector<long long> v, v2;
for (int i = n; i > 0; i--) {
if (tt[i][p] == 0) {
v2.push_back(a[i].second);
} else {
v.push_back(a[i].second);
p--;
}
}
reverse(v.begin(), v.end());
cout << v.size() + v2.size() * 2 << "\n";
for (int i = 0; i < v.size() - 1; i++) cout << v[i] << " ";
for (int i = 0; i < v2.size(); i++) cout << v2[i] << " -" << v2[i] << " ";
cout << v.back();
cout << "\n";
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
long long t;
cin >> t;
while (t--) {
solve();
}
return 0;
}
| 12 | CPP |
#include <bits/stdc++.h>
#pragma GCC optimize("Ofast")
using namespace std;
struct node {
long long id, add, val;
};
node p[100];
long long n, dp[100][100];
bool f[100];
bool cmp(node x, node y) { return x.add < y.add; }
deque<long long> ans;
void print(long long x, long long y) {
if (!y) return;
if (x && dp[x][y] == dp[x - 1][y - 1] + (x - 1) * p[y].add + p[y].val) {
ans.emplace_front(y);
print(x - 1, y - 1);
} else {
f[y] = 1;
print(x, y - 1);
}
}
void solve() {
long long k;
cin >> n >> k;
for (long long i = 1; i <= n; i++) cin >> p[i].val >> p[i].add, p[i].id = i;
memset(dp, 0, sizeof(dp));
sort(p + 1, p + n + 1, cmp);
for (long long i = 1; i <= k; i++) {
for (long long j = 0; j <= n; j++) dp[i][j] = -1e17;
}
dp[0][0] = 0;
for (long long i = 1; i <= n; i++)
dp[0][i] = dp[0][i - 1] + (k - 1) * p[i].add;
for (long long i = 1; i <= k; i++) {
for (long long j = i; j <= n; j++) {
dp[i][j] = max(dp[i - 1][j - 1] + (i - 1) * p[j].add + p[j].val,
dp[i][j - 1] + (k - 1) * p[j].add);
}
}
ans.clear();
memset(f, 0, sizeof(f));
print(k, n);
cout << n * 2 - k << '\n';
long long t = ans.back();
ans.pop_back();
for (auto u : ans) cout << p[u].id << ' ';
for (long long i = 1; i <= n; i++) {
if (f[i]) {
cout << p[i].id << ' ' << -p[i].id << ' ';
}
}
cout << p[t].id << ' ';
cout << '\n';
}
signed main() {
ios::sync_with_stdio(0);
cin.tie(0);
long long t;
cin >> t;
while (t--) solve();
return 0;
}
| 12 | CPP |
#include <bits/stdc++.h>
using namespace std;
const long long buf_size = 1e5 + 5;
char buf[buf_size], *S, *T;
inline char read_char() {
if (S == T) T = (S = buf) + fread(buf, 1, buf_size, stdin);
return S != T ? *(S++) : EOF;
}
inline long long read_int() {
long long x = 0, f = 1;
char c = read_char();
while (c < '0' || c > '9') {
if (c == '-') f = -1;
c = read_char();
}
while (c >= '0' && c <= '9') x = x * 10 + c - 48, c = read_char();
return x * f;
}
const long long N = 80;
long long t, n, k;
struct node {
long long a, b, id;
bool operator<(const node& x) const { return b < x.b; }
} a[N];
long long f[N][N];
bool g[N][N];
bool mark[N];
signed main() {
t = read_int();
while (t--) {
n = read_int(), k = read_int();
for (long long i = 1; i <= n; i++)
a[i].a = read_int(), a[i].b = read_int(), a[i].id = i;
sort(a + 1, a + n + 1);
for (long long i = 0; i <= n; i++)
for (long long j = 0; j <= k; j++) f[i][j] = -10000000000, g[i][j] = 0;
f[0][0] = 0;
for (long long i = 1; i <= n; i++) {
for (long long j = 0; j <= min(i, k); j++) {
if (f[i - 1][j] + a[i].b * (k - 1) > f[i][j])
f[i][j] = f[i - 1][j] + a[i].b * (k - 1);
if (j > 0 && f[i - 1][j - 1] + a[i].a + a[i].b * (j - 1) > f[i][j])
f[i][j] = f[i - 1][j - 1] + a[i].a + a[i].b * (j - 1), g[i][j] = 1;
}
}
for (long long i = n, j = k; i >= 1; i--) {
mark[a[i].id] = g[i][j];
j -= g[i][j];
}
printf("%lld\n", 2 * n - k);
long long p = 1;
for (long long i = 1; i <= n; i++) {
if (mark[a[i].id] && p < k) {
p++;
printf("%lld ", a[i].id);
}
}
for (long long i = 1; i <= n; i++) {
if (!mark[a[i].id]) printf("%lld %lld ", a[i].id, -a[i].id);
}
for (long long i = n; i >= 1; i--)
if (mark[a[i].id]) {
printf("%lld\n", a[i].id);
break;
}
}
return 0;
}
| 12 | CPP |
#include <bits/stdc++.h>
using namespace std;
inline int read() {
register int x = 0, f = 1;
register char ch = getchar();
while (!isdigit(ch)) {
if (ch == '-') f = 0;
ch = getchar();
}
while (isdigit(ch)) {
x = x * 10 + (ch ^ '0');
ch = getchar();
}
return f ? x : -x;
}
int n, k, f[80][80], w[80][80], c[80][80], ans, vis[80];
struct node {
int a, b, id;
} p[80];
vector<int> C[80][80], ansp;
int main() {
for (int T = (1), _ed = (read()); T <= _ed; ++T) {
memset(vis, 0, sizeof vis);
n = read(), k = read();
ans = 0;
ansp.clear();
for (int i = (1), _ed = (n); i <= _ed; ++i)
p[i] = (node){read(), read(), i};
sort(p + 1, p + n + 1, [&](node x, node y) { return x.b < y.b; });
for (int i = (1), _ed = (n); i <= _ed; ++i)
for (int j = (1), _ed = (k - 1); j <= _ed; ++j)
w[i][j] = -(k - j) * p[i].b + p[i].a;
for (int l = (1), _ed = (n); l <= _ed; ++l) {
memset(f, -0x3f, sizeof f);
f[0][0] = 0, C[0][0].clear();
int t = 0;
for (int i = (1), _ed = (n); i <= _ed; ++i) {
if (i == l) continue;
++t;
for (int j = (0), _ed = (min(t, k - 1)); j <= _ed; ++j) {
f[t][j] = f[t - 1][j];
C[t][j] = C[t - 1][j];
if (j) {
int tmp = f[t - 1][j - 1] + w[i][j];
if (f[t][j] < tmp) {
f[t][j] = tmp;
C[t][j] = C[t - 1][j - 1];
C[t][j].push_back(p[i].id);
}
}
}
}
int res = f[t][k - 1];
for (int i = (1), _ed = (n); i <= _ed; ++i) res += (k - 1) * p[i].b;
res += p[l].a;
C[t][k - 1].push_back(p[l].id);
if (ans < res) {
ans = res;
ansp = C[t][k - 1];
}
}
int m = (int)(ansp).size();
printf("%d\n", n + n - m);
for (int i = (0), _ed = (m - 2); i <= _ed; ++i)
printf("%d ", ansp[i]), vis[ansp[i]] = 1;
vis[ansp.back()] = 1;
for (int i = (1), _ed = (n); i <= _ed; ++i)
if (!vis[i]) printf("%d %d ", i, -i);
printf("%d\n", ansp.back());
}
return 0;
}
| 12 | CPP |
#include <bits/stdc++.h>
using namespace std;
struct Edge {
long long to, dis, next, cost;
} edge[24050];
long long num = -1;
bool vis[10010];
long long mincost;
long long pre[10010], head[10010], cost[10010], last[10010], flow[10010], n, k,
a[110], b[110], s, t, maxflow;
long long to[110];
void add(long long f, long long t, long long dis, long long cost) {
edge[++num].to = t;
edge[num].dis = dis;
edge[num].next = head[f];
edge[num].cost = cost;
head[f] = num;
edge[++num].to = f;
edge[num].dis = 0;
edge[num].cost = -cost;
edge[num].next = head[t];
head[t] = num;
}
queue<long long> q;
bool spfa(long long s, long long t) {
memset(cost, 0x3f3f3f3f, sizeof cost);
memset(flow, 0x3f3f3f3f, sizeof flow);
memset(vis, 0, sizeof vis);
q.push(s);
vis[s] = 1;
cost[s] = 0;
pre[t] = -1;
while (!q.empty()) {
long long nowp = q.front();
q.pop();
vis[nowp] = 0;
for (long long i = head[nowp]; i != -1; i = edge[i].next) {
if (edge[i].dis > 0 && cost[edge[i].to] > cost[nowp] + edge[i].cost) {
cost[edge[i].to] = cost[nowp] + edge[i].cost;
pre[edge[i].to] = nowp;
last[edge[i].to] = i;
flow[edge[i].to] = min(flow[nowp], edge[i].dis);
if (!vis[edge[i].to]) {
vis[edge[i].to] = 1;
q.push(edge[i].to);
}
}
}
}
return pre[t] != -1;
}
void MCMF(long long s, long long t) {
while (spfa(s, t)) {
long long now = t;
maxflow += flow[t];
mincost += flow[t] * cost[t];
while (now != s) {
edge[last[now]].dis -= flow[t];
edge[last[now] ^ 1].dis += flow[t];
now = pre[now];
}
}
}
signed main() {
long long T;
cin >> T;
while (T--) {
num = -1;
memset(to, -1, sizeof to);
memset(head, -1, sizeof head);
cin >> n >> k;
for (long long i = 1; i <= n; i++) cin >> a[i] >> b[i];
maxflow = mincost = 0;
s = 0;
t = 2 * n + 1;
for (long long i = 1; i <= n; i++) add(s, i, 1, 0), add(i + n, t, 1, 0);
for (long long i = 1; i <= n; i++) {
for (long long j = 1; j <= n; j++) {
long long nc = 0;
if (j <= k - 1)
nc = a[i] + b[i] * (j - 1ll);
else if (j != n)
nc = b[i] * (k - 1ll);
else
nc = a[i] + b[i] * (k - 1ll);
nc = 0x3f3f3f3f - nc;
add(i, j + n, 1, nc);
}
}
MCMF(s, t);
long long nowi = -1;
for (long long i = n * 4; i <= num; i += 2) {
nowi++;
if (edge[i].dis == 0) to[1 + nowi % n] = 1 + nowi / n;
}
cout << 2 * n - k << endl;
for (long long i = 1; i <= k - 1; i++) cout << to[i] << " ";
for (long long i = k; i < n; i++) cout << to[i] << " " << -to[i] << " ";
cout << to[n];
cout << endl;
}
return 0;
}
| 12 | CPP |
from sys import stdin, gettrace
from heapq import nlargest
if not gettrace():
def input():
return next(stdin)[:-1]
# def input():
# return stdin.buffer.readline()
INF = int(10E10)
def main():
def solve():
n, k = map(int, input().split())
mm = []
for i in range(1,n+1):
a,b = map(int, input().split())
mm.append((b, a, i))
mm.sort()
dp = [[(-1000000, False)] * min(i+1,k+1) for i in range(n+1)]
dp[1][0] = (mm[0][0] * (k-1), False)
dp[1][1] = (mm[0][1], True)
for j,(b,a,_) in enumerate(mm[1:],2):
dp[j][0] = (dp[j-1][0][0] + b * (k-1), False)
for l in range(1, min(j, k+1)):
v1 = dp[j-1][l][0] + b * (k-1)
v2 = dp[j-1][l-1][0] + a + b * (l-1)
if v1 > v2:
dp[j][l] = (v1, False)
else:
dp[j][l] = (v2, True)
if j <= k:
dp[j][j] = (dp[j-1][j-1][0] + a + b * (j-1), True)
g1 = []
g2 = []
l = k
for j in range(n, 0, -1):
_, _, i = mm[j-1]
if dp[j][l][1]:
g1.append(i)
l -= 1
else:
g2.append(i)
g2.append(-i)
g1.reverse()
res = g1[:k-1] + g2 + g1[k-1:]
print(len(res))
print(' '.join(map(str, res)))
q = int(input())
for _ in range(q):
solve()
if __name__ == "__main__":
main() | 12 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
const int INF = 1e9;
const int N = 6000, M = 3e4;
struct edge {
int to, nxt;
int w, c;
} e[M];
int TT, n, m, x, y, k, a[80], b[80];
int ans, S, T, i, tot = 1, head[N], d[N], path[N];
queue<int> Q;
bool v[N];
void add(int x, int y, int w, int c) {
e[++tot] = {y, head[x], w, c}, head[x] = tot;
e[++tot] = {x, head[y], 0, -c}, head[y] = tot;
}
bool spfa() {
for (int i = (0); i <= (N - 1); ++i) d[i] = INF;
memset(v, 0, sizeof v);
d[S] = 0, Q.push(S), v[S] = 1;
while (!Q.empty()) {
x = Q.front(), Q.pop(), v[x] = 0;
for (i = head[x]; i; i = e[i].nxt)
if (e[i].w && d[y = e[i].to] > d[x] + e[i].c) {
d[y] = d[x] + e[i].c, path[y] = i;
if (!v[y]) Q.push(y), v[y] = 1;
}
}
if (d[T] == INF) return false;
for (y = T; y != S; y = x) {
i = path[y], x = e[i ^ 1].to;
--e[i].w, ++e[i ^ 1].w;
}
ans += d[T];
return true;
}
int main() {
cin >> TT;
while (TT--) {
scanf("%d%d", &n, &k);
for (int i = (1); i <= (n); ++i) scanf("%d%d", a + i, b + i);
tot = 1, memset(head, 0, sizeof head);
S = 0, T = (k + 2) * n + 1;
add(S, 1, n - k, 0);
for (int i = (1); i <= (n); ++i) add(1, n + i, 1, a[i]);
for (int i = (2); i <= (k); ++i) {
add(S, i, 1, 0);
for (int j = (1); j <= (n); ++j) add(i, n + j, 1, (i - 1) * b[j]);
}
for (int j = (1); j <= (n); ++j) add(n + j, T, 1, 0);
while (spfa())
;
printf("%d\n", n * 2 - k);
memset(v, 0, sizeof v);
for (int q = (k); q >= (2); --q) {
for (i = head[q]; i; i = e[i].nxt)
if (e[i].to > n && !e[i].w) {
x = e[i].to - n;
printf("%d ", x), v[x] = true;
break;
}
}
for (i = head[1]; i; i = e[i].nxt)
if (e[i].to > n && !e[i].w) {
x = e[i].to - n;
printf("%d -%d ", x, x), v[x] = true;
}
for (int i = (1); i <= (n); ++i)
if (!v[i]) {
printf("%d\n", i);
break;
}
}
return 0;
}
| 12 | CPP |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
#pragma GCC optimize("O3")
#pragma GCC optimize("unroll-loops")
#pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,tune=native")
template <typename T>
ostream& operator<<(ostream& os, const vector<T>& v) {
for (ll i = 0; i < v.size(); ++i) os << v[i] << " ";
return os;
}
template <typename T>
ostream& operator<<(ostream& os, const set<T>& v) {
for (auto it : v) os << it << " ";
return os;
}
template <typename T, typename S>
ostream& operator<<(ostream& os, const pair<T, S>& v) {
os << v.first << " " << v.second;
return os;
}
const ll mod = 1e9 + 7;
const ll inf = 2e18;
const ll ninf = -2e18;
ll takemod(ll a) { return ((a % mod) + mod) % mod; }
ll pow(ll a, ll b, ll m) {
ll ans = 1;
a %= m;
while (b) {
if (b & 1) ans = (ans * a) % m;
b /= 2;
a = (a * a) % m;
}
return ans;
}
ll modinv(ll a) { return takemod(pow(takemod(a), mod - 2, mod)); }
const ll N = 100;
ll dp[N][N];
ll n, k;
struct minion {
ll a, b, ind;
minion(ll ad, ll bd, ll cd) {
a = ad;
b = bd;
ind = cd;
}
};
bool compa(minion m1, minion m2) { return m1.b < m2.b; }
void do_case() {
cin >> n >> k;
vector<minion> arr;
arr.push_back(minion(0, 0, 0));
for (ll i = 1; i <= n; i++) {
ll a, b;
cin >> a >> b;
arr.push_back(minion(a, b, i));
}
sort(arr.begin() + 1, arr.end(), compa);
memset(dp, -1, sizeof(dp));
dp[0][0] = 0;
for (ll i = 1; i <= n; i++) {
for (ll j = 0; j <= k; j++) {
if (j && dp[i - 1][j - 1] >= 0) {
dp[i][j] =
max(dp[i][j], dp[i - 1][j - 1] + arr[i].b * (j - 1) + arr[i].a);
}
if (dp[i - 1][j] >= 0)
dp[i][j] = max(dp[i][j], dp[i - 1][j] + (k - 1) * arr[i].b);
}
}
ll ans = dp[n][k];
ll it = k;
vector<ll> arr1;
vector<ll> arr2;
for (ll i = n; i >= 1; i--) {
if (it && dp[i - 1][it - 1] >= 0) {
if (dp[i][it] == dp[i - 1][it - 1] + arr[i].b * (it - 1) + arr[i].a) {
it--;
arr1.push_back(arr[i].ind);
continue;
}
}
if (dp[i - 1][it] >= 0 && dp[i][it] == dp[i - 1][it] + (k - 1) * arr[i].b)
arr2.push_back(arr[i].ind);
}
reverse(arr1.begin(), arr1.end());
cout << arr1.size() + 2 * arr2.size() << '\n';
for (ll i = 0; i < (ll)(arr1.size() - 1); i++) cout << arr1[i] << " ";
for (ll i = 0; i < (ll)arr2.size(); i++) {
cout << arr2[i] << " " << -arr2[i] << " ";
}
cout << arr1.back() << '\n';
}
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
time_t t1, t2;
t1 = clock();
ll t;
cin >> t;
while (t--) do_case();
t2 = clock();
cerr << '\n' << t2 - t1 << '\n';
return 0;
}
| 12 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int mxN = 80;
int N, K;
tuple<int, int, int> v[mxN];
int dp[mxN][mxN], pa[mxN][mxN];
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
int T;
cin >> T;
while (T--) {
cin >> N >> K;
for (int i = (1); i <= (N); ++i) {
int A, B;
cin >> A >> B;
v[i] = {B, A, i};
}
sort(v + 1, v + 1 + N);
memset(pa, -1, sizeof pa);
for (int i = (N); i >= (1); --i) {
auto& [B, A, id] = v[i];
for (int x = (0); x <= (K); ++x) {
int y = i - 1 - x;
dp[i][x] = -1;
if (x < K) {
int a = dp[i + 1][x + 1] + B * x + A;
if (a > dp[i][x]) {
dp[i][x] = a;
pa[i][x] = x + 1;
}
}
if (y < N - K) {
int a = dp[i + 1][x] + B * (K - 1);
if (a > dp[i][x]) {
dp[i][x] = a;
pa[i][x] = x;
}
}
}
}
vector<int> p, q;
cout << N + (N - K) << '\n';
for (int i = 1, x = 0; i <= N; x = pa[i++][x]) {
auto [B, A, id] = v[i];
if (pa[i][x] == x) {
q.push_back(id);
} else {
p.push_back(id);
}
}
for (int i = (0); i <= ((int)(p).size() - 2); ++i) {
cout << p[i] << ' ';
}
for (int i = (0); i <= ((int)(q).size() - 1); ++i) {
cout << q[i] << ' ' << -q[i] << ' ';
}
cout << p.back() << '\n';
}
}
| 12 | CPP |
#include <bits/stdc++.h>
using namespace std;
#pragma GCC optimize("Ofast")
#pragma GCC target("avx")
bool RELAXED = false;
template <int, typename T>
struct MINMAX {
T val;
MINMAX(T val) : val(val) {}
};
template <typename T>
MINMAX<1, T> MAX(T val) {
return MINMAX<1, T>(val);
};
template <typename T>
MINMAX<2, T> MIN(T val) {
return MINMAX<2, T>(val);
};
template <typename T, typename U>
inline T& operator|=(T& lhs, MINMAX<1, U> rhs) {
return lhs = (rhs.val > lhs ? (RELAXED = true, rhs.val)
: (RELAXED = false, lhs));
}
template <typename T, typename U>
inline T& operator|=(T& lhs, MINMAX<2, U> rhs) {
return lhs = (rhs.val < lhs ? (RELAXED = true, rhs.val)
: (RELAXED = false, lhs));
}
template <typename T, typename U>
istream& operator>>(istream& in, pair<T, U>& p) {
in >> p.first >> p.second;
return in;
}
template <typename T>
inline vector<T> READ(int n) {
vector<T> vec(n);
for (int i = 0; i < int(n); i++) cin >> vec[i];
return vec;
}
template <typename T>
using min_heap = priority_queue<T, vector<T>, greater<T> >;
const int MAXN = 1e5 + 5;
signed long long int dp[MAXN][80];
signed long long int bt[MAXN][80];
vector<pair<int, int> > minion;
int n, k;
map<pair<int, int>, vector<int> > ids;
int get_id(pair<int, int> minion) {
int id = ids[minion].back();
ids[minion].pop_back();
return id;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
cout.tie(nullptr);
cout << fixed << setprecision(12);
int T;
cin >> T;
while (T--) {
cin >> n >> k;
minion.clear();
minion.resize(n);
memset(dp, 0x80, sizeof dp);
memset(bt, 0, sizeof bt);
ids.clear();
for (int i = 0; i < int(n); i++) {
int a, b;
cin >> a >> b;
minion[i] = {a, b};
ids[{a, b}].push_back(i + 1);
}
sort((minion).begin(), (minion).end(),
[&](pair<int, int> a, pair<int, int> b) {
return a.second < b.second;
});
42;
dp[0][0] = 0;
for (int i = 0; i < int(n); i++) {
for (int j = 0; j < int(k + 1); j++) {
dp[i + 1][j] = dp[i][j] + (k - 1) * minion[i].second;
bt[i + 1][j] = false;
}
for (int j = 0; j < int(k); j++) {
dp[i + 1][j + 1] |=
MAX(dp[i][j] + minion[i].first + j * minion[i].second);
if (RELAXED) bt[i + 1][j + 1] = true;
}
}
vector<int> keep;
int lk = k;
for (int i = int(n); i >= int(0); --i) {
if (bt[i][lk]) {
keep.push_back(i - 1);
lk--;
}
if (lk < 0) break;
}
reverse((keep).begin(), (keep).end());
vector<int> actions;
for (int i = 0; i < int(k - 1); i++) {
pair<int, int> mi = minion[keep[i]];
actions.push_back(get_id(mi));
}
for (int i = 0; i < int(n); i++) {
pair<int, int> mi = minion[i];
if (count((keep).begin(), (keep).end(), i)) continue;
int id = get_id(mi);
actions.push_back(id);
actions.push_back(-id);
}
{
pair<int, int> mi = minion[keep.back()];
actions.push_back(get_id(mi));
}
42;
cout << actions.size() << endl;
for (auto x : actions) cout << x << ' ';
cout << endl;
}
}
| 12 | CPP |
#include <bits/stdc++.h>
using namespace std;
template <typename T>
void read(T &n) {
n = 0;
T f = 1;
char c = getchar();
while (!isdigit(c) && c != '-') c = getchar();
if (c == '-') f = -1, c = getchar();
while (isdigit(c)) n = n * 10 + c - '0', c = getchar();
n *= f;
}
template <typename T>
void write(T n) {
if (n < 0) putchar('-'), n = -n;
if (n > 9) write(n / 10);
putchar(n % 10 + '0');
}
int n, m, vis[105];
long long f[105][105], p[105][105];
struct node {
long long a, b;
int id;
friend bool operator<(node a, node b) { return a.b < b.b; }
} v[105];
int main() {
int T;
cin >> T;
while (T--) {
read(n), read(m);
for (int i = 1; i <= n; i++) {
read(v[i].a), read(v[i].b);
v[i].id = i;
}
sort(v + 1, v + n + 1);
memset(f, -0x3f, sizeof(f));
memset(p, 0, sizeof(p));
memset(vis, 0, sizeof(vis));
f[0][0] = 0;
for (int i = 1; i <= n; i++) {
for (int j = 0; j <= min(i, m); j++) {
f[i][j] = f[i - 1][j] + v[i].b * (m - 1);
if (j && f[i - 1][j - 1] + v[i].a + v[i].b * (j - 1) > f[i][j]) {
f[i][j] = f[i - 1][j - 1] + v[i].a + v[i].b * (j - 1);
p[i][j] = 1;
}
}
}
int t = m;
for (int i = n; i >= 1; i--) {
if (p[i][t]) {
vis[i] = 1;
t--;
}
}
printf("%d\n", m + (n - m) * 2);
int cnt = 0, x;
for (int i = 1; i <= n; i++) {
if (!vis[i]) continue;
cnt++;
if (cnt == m)
x = v[i].id;
else
printf("%d ", v[i].id);
}
for (int i = 1; i <= n; i++) {
if (!vis[i]) printf("%d %d ", v[i].id, -v[i].id);
}
printf("%d\n", x);
}
return 0;
}
| 12 | CPP |
#include <bits/stdc++.h>
using namespace std;
template <class T>
using pqg = priority_queue<T, vector<T>, greater<T>>;
template <class T>
T poll(pqg<T> &x) {
T y = x.top();
x.pop();
return y;
}
template <int SZ>
struct mcmf {
struct Edge {
int to, rev;
long long flow, cap;
long long cost;
};
vector<Edge> adj[SZ];
void addEdge(int u, int v, long long cap, long long cost) {
assert(cap >= 0);
Edge a{v, (int)adj[v].size(), 0, cap, cost},
b{u, (int)adj[u].size(), 0, 0, -cost};
adj[u].push_back(a), adj[v].push_back(b);
}
int N, second, t;
long long INF = 1e18;
pair<int, int> pre[SZ];
pair<long long, long long> cost[SZ];
long long totCost, curCost;
long long totFlow;
void reweight() {
for (int i = 0; i < N; i++)
for (auto &p : adj[i]) p.cost += cost[i].first - cost[p.to].first;
}
bool spfa() {
for (int i = 0; i < N; i++) cost[i] = make_pair(INF, 0);
cost[second] = make_pair(0, INF);
pqg<pair<long long, int>> todo;
todo.push({0, second});
while ((int)todo.size()) {
auto x = poll(todo);
if (x.first > cost[x.second].first) continue;
for (auto &a : adj[x.second])
if (x.first + a.cost < cost[a.to].first && a.flow < a.cap) {
pre[a.to] = {x.second, a.rev};
cost[a.to] = {x.first + a.cost,
min(a.cap - a.flow, cost[x.second].second)};
todo.push({cost[a.to].first, a.to});
}
}
curCost += cost[t].first;
return cost[t].second;
}
void backtrack() {
long long df = cost[t].second;
totFlow += df, totCost += curCost * df;
for (int x = t; x != second; x = pre[x].first) {
adj[x][pre[x].second].flow -= df;
adj[pre[x].first][adj[x][pre[x].second].rev].flow += df;
}
}
pair<long long, long long> calc(int _N, int _s, int _t) {
N = _N;
second = _s, t = _t;
totFlow = totCost = curCost = 0;
while (spfa()) {
reweight();
backtrack();
}
return {totFlow, totCost};
}
};
void solve() {
int n, k;
cin >> n >> k;
vector<pair<long long, long long>> minion;
for (int i = 0; i < n; i++) {
long long a, b;
cin >> a >> b;
minion.push_back(make_pair(a, b));
}
mcmf<160> G;
int second = n + k + 1;
int t = n + k + 2;
for (int i = 0; i < n; i++) G.addEdge(second, i, 1, 0);
for (int i = n; i < n + k; i++) G.addEdge(i, t, 1, 0);
G.addEdge(n + k, t, n - k, 0);
for (int i = 0; i < n; i++) {
for (int j = 0; j < k; j++) {
G.addEdge(i, j + n, 1, -(minion[i].first + j * minion[i].second));
}
}
for (int i = 0; i < n; i++)
G.addEdge(i, n + k, 1, -(k - 1) * minion[i].second);
pair<long long, long long> sol = G.calc(t + 1, second, t);
assert(sol.first == n);
vector<int> ans;
for (int i = n; i < n + k - 1; i++) {
for (auto &e : G.adj[i]) {
if (e.flow == -1) {
ans.push_back(e.to + 1);
}
}
}
for (auto &e : G.adj[n + k]) {
if (e.flow == -1) {
ans.push_back(e.to + 1);
ans.push_back(-(e.to + 1));
}
}
for (auto &e : G.adj[n + k - 1]) {
if (e.flow == -1) {
ans.push_back(e.to + 1);
}
}
cout << ans.size() << endl;
for (int i = 0; i < ans.size(); i++) cout << ans[i] << ' ';
cout << endl;
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
int t;
cin >> t;
for (int i = 0; i < t; i++) solve();
}
| 12 | CPP |
#include <bits/stdc++.h>
using namespace std;
inline char gc() {
static char buf[1 << 16], *p1 = buf, *p2 = buf;
if (p1 == p2) {
p2 = (p1 = buf) + fread(buf, 1, 1 << 16, stdin);
if (p2 == p1) return EOF;
}
return *p1++;
}
template <class t>
inline t read(t &x) {
char c = gc();
bool f = 0;
x = 0;
while (!isdigit(c)) f |= c == '-', c = gc();
while (isdigit(c)) x = (x << 1) + (x << 3) + (c ^ 48), c = gc();
if (f) x = -x;
return x;
}
template <class t>
inline void write(t x) {
if (x < 0)
putchar('-'), write(-x);
else {
if (x > 9) write(x / 10);
putchar('0' + x % 10);
}
}
const int N = 205, M = 1e4 + 5, P = 80;
int en = 1, mc, mf, h[N], dis[N], n, k, ans[P];
bool v[N];
struct edge {
int n, v, f, w;
} e[M << 1];
struct fafafa {
int fa, id;
} pre[N];
void add(int x, int y, int f, int w) {
e[++en] = (edge){h[x], y, f, w};
h[x] = en;
}
bool spfa(int s, int t) {
memset(v, 0, sizeof v);
memset(pre, 0, sizeof pre);
memset(dis, 0x3f, sizeof dis);
queue<int> q;
q.push(s);
v[s] = 1;
dis[s] = 0;
while (!q.empty()) {
int x = q.front();
q.pop();
for (int i = h[x]; i; i = e[i].n) {
int y = e[i].v;
if (e[i].f && dis[x] + e[i].w < dis[y]) {
dis[y] = dis[x] + e[i].w;
pre[y] = (fafafa){x, i};
if (!v[y]) {
v[y] = 1;
q.push(y);
}
}
}
v[x] = 0;
}
return dis[t] ^ 0x3f3f3f3f;
}
void mcmf(int s, int t) {
while (spfa(s, t)) {
int flow = INT_MAX;
for (int i = t; i ^ s; i = pre[i].fa) flow = min(flow, e[pre[i].id].f);
for (int i = t; i ^ s; i = pre[i].fa) {
e[pre[i].id].f -= flow;
e[pre[i].id ^ 1].f += flow;
}
mf += flow;
mc += flow * dis[t];
}
}
void exadd(int x, int y, int f, int w) {
add(x, y, f, w);
add(y, x, 0, -w);
}
void doit() {
read(n);
read(k);
for (int i = 1; i <= n; i++) exadd(0, i, 1, 0), exadd(i + n, n * 2 + 1, 1, 0);
for (int i = 1, a, b; i <= n; i++) {
read(a);
read(b);
for (int j = 1, val; j <= n; j++) {
if (j < k)
val = a + (j - 1) * b;
else if (j < n)
val = (k - 1) * b;
else
val = a + (k - 1) * b;
exadd(i, j + n, 1, -val);
}
}
mcmf(0, n * 2 + 1);
write(k + (n - k) * 2);
puts("");
for (int x = 1; x <= n; x++)
for (int i = h[x]; i; i = e[i].n) {
int y = e[i].v;
if (y <= n) continue;
if (!e[i].f) ans[y - n] = x;
}
for (int i = 1; i <= n; i++) {
write(ans[i]);
putchar(' ');
if (i >= k && i < n) write(-ans[i]), putchar(' ');
}
puts("");
en = 1;
mc = mf = 0;
for (int i = 0; i <= n * 2 + 1; i++) h[i] = 0;
}
signed main() {
int t;
read(t);
while (t--) doit();
}
| 12 | CPP |
#include <bits/stdc++.h>
using namespace std;
int t, n, k;
long long dp[80][80];
vector<pair<pair<int, int>, int> > v;
long long solve(int i, int rem) {
if (i == n) {
if (rem) return -1e15;
return 0;
}
long long &ans = dp[i][rem];
if (ans != -1) return ans;
if (rem)
ans = solve(i + 1, rem - 1) + (k - rem) * v[i].first.first +
v[i].first.second;
ans = max(ans, solve(i + 1, rem) + v[i].first.first * (k - 1));
return ans;
}
vector<int> v1, v2;
void build(int i, int rem) {
if (i == n) return;
long long ans1 =
solve(i + 1, rem - 1) + (k - rem) * v[i].first.first + v[i].first.second;
long long ans2 = solve(i + 1, rem) + v[i].first.first * (k - 1);
if (ans1 > ans2) {
v1.push_back(v[i].second);
build(i + 1, rem - 1);
return;
}
v2.push_back(v[i].second);
build(i + 1, rem);
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> t;
while (t--) {
cin >> n >> k;
for (int i = 0; i < n; i++) {
int x, y;
cin >> x >> y;
v.push_back({{y, x}, i + 1});
}
sort(v.begin(), v.end());
memset(dp, -1, sizeof dp);
solve(0, k);
build(0, k);
cout << v1.size() + v2.size() * 2 << "\n";
v2.push_back(v1.back());
v1.pop_back();
for (auto i : v1) cout << i << " ";
for (int i = 0; i < v2.size(); i++) {
if (i == v2.size() - 1)
cout << v2[i];
else
cout << v2[i] << " " << -v2[i] << " ";
}
cout << "\n";
v.clear();
v1.clear();
v2.clear();
}
}
| 12 | CPP |
#include <bits/stdc++.h>
using namespace std;
const long long inf = 1e9 + 7;
const long long INF = 1LL << 60;
const long long mod = 1e9 + 7;
const long double eps = 1e-8;
const long double pi = acos(-1.0);
template <class T>
inline bool chmax(T& a, T b) {
if (a < b) {
a = b;
return 1;
}
return 0;
}
template <class T>
inline bool chmin(T& a, T b) {
if (a > b) {
a = b;
return 1;
}
return 0;
}
void solve() {
long long n, k;
cin >> n >> k;
vector<long long> a(n), b(n);
vector<pair<pair<long long, long long>, long long> > c(n);
for (long long i = 0; i < n; i++) {
cin >> a[i] >> b[i];
c[i] = {{a[i], b[i]}, i};
}
sort(c.begin(), c.end(),
[&](pair<pair<long long, long long>, long long> x,
pair<pair<long long, long long>, long long> y) {
return x.first.second < y.first.second;
});
static long long dp[80][80];
for (long long i = 0; i < 80; i++) {
for (long long j = 0; j < 80; j++) {
dp[i][j] = -INF;
}
}
dp[0][0] = 0;
for (long long i = 0; i < n; i++) {
for (long long j = 0; j <= i; ++j) {
if (dp[i][j] != -INF)
chmax(dp[i + 1][j + 1],
dp[i][j] + c[i].first.first + j * c[i].first.second);
if (dp[i][j] != -INF)
chmax(dp[i + 1][j], dp[i][j] + (k - 1) * c[i].first.second);
}
}
long long cur = dp[n][k];
long long p = n, q = k;
vector<long long> s(n, -1);
for (long long i = n - 1; i >= 0; --i) {
if (p - 1 >= 0 && q - 1 >= 0) {
if (dp[p - 1][q - 1] + c[i].first.first + (q - 1) * c[i].first.second ==
cur) {
s[i] = 0;
p--;
q--;
cur = dp[p][q];
continue;
}
}
if (p - 1 >= 0) {
if (dp[p - 1][q] + (k - 1) * c[i].first.second == cur) {
s[i] = 1;
--p;
cur = dp[p][q];
}
}
}
vector<long long> ans, ba;
long long last = -1;
for (long long i = 0; i < n; i++) {
if (s[i] == 0) {
if ((long long)ans.size() < k - 1)
ans.push_back(c[i].second + 1);
else
last = c[i].second;
} else {
ba.push_back(c[i].second + 1);
}
}
for (long long x : ba) {
ans.push_back(x);
ans.push_back(-x);
}
ans.push_back(last + 1);
cout << (long long)ans.size() << endl;
for (long long i = 0; i < (long long)ans.size(); i++) {
if (i) cout << " ";
cout << ans[i];
}
cout << endl;
}
signed main() {
ios::sync_with_stdio(false);
cin.tie(0);
long long t;
cin >> t;
for (long long i = 0; i < t; i++) solve();
return 0;
}
| 12 | CPP |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using Vi = vector<int>;
using Pii = pair<int, int>;
int uplg(int n) { return 32 - __builtin_clz(n); }
int uplg(ll n) { return 64 - __builtin_clzll(n); }
void run();
int main() {
cin.sync_with_stdio(0);
cin.tie(0);
cout << fixed << setprecision(18);
run();
return 0;
}
ll dp[80][80];
bool take[80][80];
ll check(int k, const vector<Pii>& elems) {
for (int i = (0); i < (80); i++)
for (int j = (0); j < (80); j++) dp[i][j] = -1e12;
dp[0][0] = 0;
for (int pref = (1); pref < (int((elems).size()) + 1); pref++) {
auto e = elems[pref - 1];
for (int taken = (0); taken < (k + 1); taken++) {
dp[pref][taken] = dp[pref - 1][taken] + k * e.second;
take[pref][taken] = 0;
if (taken > 0) {
ll alt = dp[pref - 1][taken - 1] + e.first + (taken - 1) * e.second;
if (alt > dp[pref][taken]) {
dp[pref][taken] = alt;
take[pref][taken] = 1;
}
}
if (dp[pref][taken] < 0) {
dp[pref][taken] = -1e12;
}
}
}
return dp[int((elems).size())][k];
}
void solve() {
int n, k;
cin >> n >> k;
vector<pair<Pii, int>> elems(n);
for (int i = (0); i < (n); i++) elems[i].second = i;
for (auto& e : (elems)) cin >> e.first.first >> e.first.second;
sort((elems).begin(), (elems).end(), [](pair<Pii, int> l, pair<Pii, int> r) {
return l.first.second < r.first.second;
});
vector<Pii> tmp;
int bestI = -1;
ll ans = -1;
for (int i = (0); i < (n); i++) {
tmp.clear();
for (int j = (0); j < (n); j++)
if (j != i) tmp.push_back(elems[j].first);
ll alt = check(k - 1, tmp);
alt += elems[i].first.first + elems[i].first.second * (k - 1);
if (alt > ans) {
ans = alt;
bestI = i;
}
}
Vi ind;
tmp.clear();
for (int j = (0); j < (n); j++)
if (j != bestI)
tmp.push_back(elems[j].first), ind.push_back(elems[j].second);
ll alt = check(k - 1, tmp);
alt += elems[bestI].first.first + elems[bestI].first.second * (k - 1);
assert(alt == ans);
Vi toTake, toDel;
int pref = int((tmp).size()), taken = k - 1;
while (pref > 0) {
if (take[pref][taken]) {
toTake.push_back(ind[pref - 1]);
taken--;
} else {
toDel.push_back(ind[pref - 1]);
}
pref--;
}
reverse((toTake).begin(), (toTake).end());
reverse((toDel).begin(), (toDel).end());
Vi moves;
for (auto& t : (toTake)) moves.push_back(t + 1);
for (auto& t : (toDel)) {
moves.push_back(t + 1);
moves.push_back(-t - 1);
}
moves.push_back(elems[bestI].second + 1);
cout << int((moves).size()) << '\n';
for (auto& e : (moves)) cout << e << ' ';
cout << '\n';
}
void run() {
int t;
cin >> t;
while (t--) solve();
}
| 12 | CPP |
from operator import itemgetter
import sys
int1 = lambda x: int(x) - 1
p2D = lambda x: print(*x, sep="\n")
def II(): return int(sys.stdin.readline())
def MI(): return map(int, sys.stdin.readline().split())
def LI(): return list(map(int, sys.stdin.readline().split()))
def LLI(rows_number): return [LI() for _ in range(rows_number)]
def SI(): return sys.stdin.readline()[:-1]
def main():
inf = 10 ** 9
for _ in range(II()):
n, k = MI()
ab = [(a, b, i) for i, (a, b) in enumerate(LLI(n))]
dp = [[inf] * n for _ in range(k)]
log = [[[] for _ in range(n)] for _ in range(k)]
for e in range(n): dp[0][e] = -ab[e][0]
ab.sort(key=itemgetter(1))
for a, b, i in ab:
for j in range(k - 2, -1, -1):
for e in range(n):
if i==e:continue
pre = dp[j][e]
if pre==inf:continue
cur = pre + b * (k - 1 - j) - a
if cur < dp[j + 1][e]:
dp[j + 1][e] = cur
log[j+1][e]=log[j][e]+[i]
#print(ab)
#p2D(dp)
#p2D(log)
#print()
mn=mne=inf
for e in range(n):
cur=dp[-1][e]
if cur<mn:
mn=cur
mne=e
first=log[-1][mne]
use=[False]*n
use[mne]=True
ans=[]
for i in first:
ans.append(i+1)
use[i]=True
for i in range(n):
if use[i]:continue
ans.append(i+1)
ans.append(-i-1)
ans.append(mne+1)
print(len(ans))
print(*ans)
main()
| 12 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
const int inf = 2000000000;
char buffer[2000020], *p1, *p2;
template <class T>
void read(T& x) {
char ch = ((p1 == p2 &&
(p2 = (p1 = buffer) + fread(buffer, 1, 2000020, stdin), p1 == p2))
? EOF
: *p1++);
x = 0;
bool f = 1;
while (!('0' <= ch && ch <= '9') && ch != '-')
ch = ((p1 == p2 &&
(p2 = (p1 = buffer) + fread(buffer, 1, 2000020, stdin), p1 == p2))
? EOF
: *p1++);
if (ch == '-')
f = 0,
ch = ((p1 == p2 &&
(p2 = (p1 = buffer) + fread(buffer, 1, 2000020, stdin), p1 == p2))
? EOF
: *p1++);
while ('0' <= ch && ch <= '9')
x = (x << 1) + (x << 3) + ch - '0',
ch = ((p1 == p2 &&
(p2 = (p1 = buffer) + fread(buffer, 1, 2000020, stdin), p1 == p2))
? EOF
: *p1++);
x = (f) ? x : -x;
}
int _num[20];
template <class T>
void write(T x) {
if (!x) {
putchar('0'), putchar('\n');
return;
}
if (x < 0) putchar('-'), x = -x;
int c = 0;
while (x) _num[++c] = x % 10, x /= 10;
while (c) putchar('0' + _num[c--]);
putchar('\n');
}
int n, k, ti;
struct ele {
int b, a, id;
ele(int b, int a, int id) : b(b), a(a), id(id) {}
ele() {}
bool operator<(const ele y) const { return b < y.b; }
} p[85];
int vis[85][85];
int dp[85][85];
int DP(int pos, int rest) {
if (pos > n) {
if (rest == 0)
return 0;
else
return -inf;
}
if (vis[pos][rest] == ti) return dp[pos][rest];
vis[pos][rest] = ti;
int& ans = dp[pos][rest];
if (rest)
return ans = max(DP(pos + 1, rest - 1) + p[pos].a + p[pos].b * (k - rest),
DP(pos + 1, rest) + p[pos].b * (k - 1));
else
return ans = DP(pos + 1, rest) + p[pos].b * (k - 1);
}
int ans[85];
void find_ans(int pos, int rest) {
if (pos > n) return;
if (rest) {
int A = DP(pos + 1, rest - 1) + p[pos].a + p[pos].b * (k - rest);
int B = DP(pos + 1, rest) + p[pos].b * (k - 1);
if (A > B)
find_ans(pos + 1, rest - 1), ans[pos] = p[pos].id;
else
find_ans(pos + 1, rest), ans[pos] = -p[pos].id;
} else {
find_ans(pos + 1, rest);
ans[pos] = -p[pos].id;
}
}
int main() {
int T, x, y;
scanf("%d", &T);
while (T--) {
ti++;
scanf("%d%d", &n, &k);
for (register int i = 1; i <= n; i++)
scanf("%d%d", &x, &y), p[i] = ele(y, x, i);
sort(p + 1, p + 1 + n);
DP(1, k), find_ans(1, k);
int num = n;
for (register int i = 1; i <= n; i++)
if (ans[i] < 0) num++;
printf("%d\n", num);
for (register int i = 1; i <= n; i++) {
if (k > 1 && ans[i] > 0) printf("%d ", ans[i]), k--;
}
for (register int i = 1; i <= n; i++) {
if (ans[i] < 0) printf("%d %d ", -ans[i], ans[i]);
}
for (register int i = n; i >= 1; i--) {
if (ans[i] > 0) {
printf("%d\n", ans[i]);
break;
}
}
}
return 0;
}
| 12 | CPP |
#include <bits/stdc++.h>
#pragma GCC optimize("O3")
#pragma GCC optimize("unroll-loops")
const long long INF = 0x3f3f3f3f3f3f3f3f;
const long long llinf = (1LL << 62);
const int inf = (1 << 30);
const int nmax = 1e2 + 50;
const long long mod = 1e9 + 7;
using namespace std;
long long ts, i, j, n, f[nmax][nmax][2], k, k1, rs;
pair<pair<long long, long long>, long long> a[nmax];
vector<long long> del, add;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cerr.tie(0);
cout.tie(0);
cin >> ts;
while (ts--) {
cin >> n >> k;
for (i = 1; i <= n; i++) {
cin >> a[i].first.second >> a[i].first.first;
a[i].second = i;
}
sort(a + 1, a + n + 1);
for (i = 0; i <= n; i++)
for (j = 0; j <= k; j++) f[i][j][0] = f[i][j][1] = -inf;
f[0][0][0] = 0;
for (i = 1; i <= n; i++) {
for (j = 0; j <= min(k, i); j++) {
if (max(f[i - 1][j][0], f[i - 1][j][1]) != -inf)
f[i][j][0] =
max(f[i - 1][j][0], f[i - 1][j][1]) + (k - 1) * a[i].first.first;
if (j && max(f[i - 1][j - 1][0], f[i - 1][j - 1][1]) != -inf)
f[i][j][1] = max(f[i][j][1],
max(f[i - 1][j - 1][0], f[i - 1][j - 1][1]) +
a[i].first.second + (j - 1) * a[i].first.first);
}
}
rs = max(f[n][k][0], f[n][k][1]);
del.clear(), add.clear(), k1 = k;
for (i = n; i >= 1; i--) {
if (k && rs == f[i][k][1]) {
add.push_back(a[i].second);
rs -= a[i].first.second + (k - 1) * a[i].first.first;
k--;
} else {
del.push_back(a[i].second);
rs -= (k1 - 1) * a[i].first.first;
}
}
reverse(add.begin(), add.end());
cout << 2 * n - k1 << endl;
for (i = 0; i < (int)add.size() - 1; i++) cout << add[i] << " ";
for (i = 0; i < (int)del.size(); i++)
cout << del[i] << " " << -del[i] << " ";
cout << add.back() << endl;
}
return 0;
}
| 12 | CPP |
#include <bits/stdc++.h>
#pragma GCC optimize("O3")
using namespace std;
template <class T>
using pq = priority_queue<T>;
template <class T>
using pqg = priority_queue<T, vector<T>, greater<T>>;
int scan() { return getchar(); }
void scan(int& a) { cin >> a; }
void scan(long long& a) { cin >> a; }
void scan(char& a) { cin >> a; }
void scan(double& a) { cin >> a; }
void scan(long double& a) { cin >> a; }
void scan(char a[]) { scanf("%s", a); }
void scan(string& a) { cin >> a; }
template <class T>
void scan(vector<T>&);
template <class T, size_t size>
void scan(array<T, size>&);
template <class T, class L>
void scan(pair<T, L>&);
template <class T, size_t size>
void scan(T (&)[size]);
template <class T>
void scan(vector<T>& a) {
for (auto& i : a) scan(i);
}
template <class T>
void scan(deque<T>& a) {
for (auto& i : a) scan(i);
}
template <class T, size_t size>
void scan(array<T, size>& a) {
for (auto& i : a) scan(i);
}
template <class T, class L>
void scan(pair<T, L>& p) {
scan(p.first);
scan(p.second);
}
template <class T, size_t size>
void scan(T (&a)[size]) {
for (auto& i : a) scan(i);
}
template <class T>
void scan(T& a) {
cin >> a;
}
void IN() {}
template <class Head, class... Tail>
void IN(Head& head, Tail&... tail) {
scan(head);
IN(tail...);
}
string stin() {
string s;
cin >> s;
return s;
}
template <class T>
inline bool chmax(T& a, T b) {
if (a < b) {
a = b;
return 1;
}
return 0;
}
template <class T>
inline bool chmin(T& a, T b) {
if (a > b) {
a = b;
return 1;
}
return 0;
}
vector<int> iota(int n) {
vector<int> a(n);
iota(begin(a), end(a), 0);
return a;
}
template <class T>
void UNIQUE(vector<T>& x) {
sort(begin(x), end(x));
x.erase(unique(begin(x), end(x)), x.end());
}
int in() {
int x;
cin >> x;
return x;
}
long long lin() {
unsigned long long x;
cin >> x;
return x;
}
void print() { putchar(' '); }
void print(bool a) { cout << a; }
void print(int a) { cout << a; }
void print(long long a) { cout << a; }
void print(char a) { cout << a; }
void print(string& a) { cout << a; }
void print(double a) { cout << a; }
template <class T>
void print(const vector<T>&);
template <class T, size_t size>
void print(const array<T, size>&);
template <class T, class L>
void print(const pair<T, L>& p);
template <class T, size_t size>
void print(const T (&)[size]);
template <class T>
void print(const vector<T>& a) {
if (a.empty()) return;
print(a[0]);
for (auto i = a.begin(); ++i != a.end();) {
cout << " ";
print(*i);
}
cout << endl;
}
template <class T>
void print(const deque<T>& a) {
if (a.empty()) return;
print(a[0]);
for (auto i = a.begin(); ++i != a.end();) {
cout << " ";
print(*i);
}
}
template <class T, size_t size>
void print(const array<T, size>& a) {
print(a[0]);
for (auto i = a.begin(); ++i != a.end();) {
cout << " ";
print(*i);
}
}
template <class T, class L>
void print(const pair<T, L>& p) {
cout << '(';
print(p.first);
cout << ",";
print(p.second);
cout << ')';
}
template <class T, size_t size>
void print(const T (&a)[size]) {
print(a[0]);
for (auto i = a; ++i != end(a);) {
cout << " ";
print(*i);
}
}
template <class T>
void print(const T& a) {
cout << a;
}
int out() {
putchar('\n');
return 0;
}
template <class T>
int out(const T& t) {
print(t);
putchar('\n');
return 0;
}
template <class Head, class... Tail>
int out(const Head& head, const Tail&... tail) {
print(head);
putchar(' ');
out(tail...);
return 0;
}
long long gcd(long long a, long long b) {
while (b) {
long long c = b;
b = a % b;
a = c;
}
return a;
}
long long lcm(long long a, long long b) {
if (!a || !b) return 0;
return a * b / gcd(a, b);
}
vector<pair<long long, long long>> factor(long long x) {
vector<pair<long long, long long>> ans;
for (long long i = 2; i * i <= x; i++)
if (x % i == 0) {
ans.push_back({i, 1});
while ((x /= i) % i == 0) ans.back().second++;
}
if (x != 1) ans.push_back({x, 1});
return ans;
}
vector<int> divisor(int x) {
vector<int> ans;
for (int i = 1; i * i <= x; i++)
if (x % i == 0) {
ans.push_back(i);
if (i * i != x) ans.push_back(x / i);
}
return ans;
}
int popcount(long long x) { return __builtin_popcountll(x); }
mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
int rnd(int n) { return uniform_int_distribution<int>(0, n)(rng); }
template <class... T>
void err(const T&...) {}
template <typename Monoid>
struct SegmentTree {
using F = function<Monoid(Monoid, Monoid)>;
int sz;
vector<Monoid> seg;
const F f;
const Monoid M1;
SegmentTree(int n, const F f, const Monoid& M1) : f(f), M1(M1) {
sz = 1;
while (sz < n) sz <<= 1;
seg.assign(2 * sz, M1);
}
void set(int k, const Monoid& x) { seg[k + sz] = x; }
void build() {
for (int k = sz - 1; k > 0; k--) {
seg[k] = f(seg[2 * k + 0], seg[2 * k + 1]);
}
}
void update(int k, const Monoid& x) {
k += sz;
seg[k] += x;
while (k >>= 1) {
seg[k] = f(seg[2 * k + 0], seg[2 * k + 1]);
}
}
Monoid query(int a, int b) {
Monoid L = M1, R = M1;
for (a += sz, b += sz; a < b; a >>= 1, b >>= 1) {
if (a & 1) L = f(L, seg[a++]);
if (b & 1) R = f(seg[--b], R);
}
return f(L, R);
}
Monoid operator[](const int& k) const { return seg[k + sz]; }
template <typename C>
int find_subtree(int a, const C& check, Monoid& M, bool type) {
while (a < sz) {
Monoid nxt = type ? f(seg[2 * a + type], M) : f(M, seg[2 * a + type]);
if (check(nxt))
a = 2 * a + type;
else
M = nxt, a = 2 * a + 1 - type;
}
return a - sz;
}
template <typename C>
int find_first(int a, const C& check) {
Monoid L = M1;
if (a <= 0) {
if (check(f(L, seg[1]))) return find_subtree(1, check, L, false);
return -1;
}
int b = sz;
for (a += sz, b += sz; a < b; a >>= 1, b >>= 1) {
if (a & 1) {
Monoid nxt = f(L, seg[a]);
if (check(nxt)) return find_subtree(a, check, L, false);
L = nxt;
++a;
}
}
return -1;
}
template <typename C>
int find_last(int b, const C& check) {
Monoid R = M1;
if (b >= sz) {
if (check(f(seg[1], R))) return find_subtree(1, check, R, true);
return -1;
}
int a = sz;
for (b += sz; a < b; a >>= 1, b >>= 1) {
if (b & 1) {
Monoid nxt = f(seg[--b], R);
if (check(nxt)) return find_subtree(b, check, R, true);
R = nxt;
}
}
return -1;
}
void print(int n) {
for (int i = 0; i < n; i++) {
cerr << seg[i + sz] << " ";
}
cerr << '\n';
}
};
signed main() {
ios_base::sync_with_stdio(0), cin.tie(0), cout.tie(0);
cout << fixed << setprecision(15);
int T = in();
while (T--) {
int n = in(), k = in();
auto id = iota(n);
vector<long long> a, b;
for (long long i = 0; i < n; ++i) {
a.push_back(in()), b.push_back(in());
}
sort(begin(id), end(id), [&](int x, int y) { return b[x] < b[y]; });
long long dp[100][100] = {};
for (long long i = 0; i < n + 1; ++i)
for (long long j = 0; j < n + 1; ++j) dp[i][j] = -1e15;
dp[0][0] = 0;
int pre[100][100] = {};
int mem[100][100];
for (long long i = 0; i < n; ++i) {
int now = id[i];
for (long long j = 0; j < k + 1; ++j) {
if (chmax(dp[i + 1][j], dp[i][j] + b[now] * (k - 1))) pre[i + 1][j] = j;
if (chmax(dp[i + 1][j + 1], dp[i][j] + a[now] + b[now] * j))
pre[i + 1][j + 1] = j;
}
}
vector<int> ope;
int now = k;
for (long long i = n; i >= 1; --i) {
if (pre[i][now] != now) {
ope.emplace_back(id[i - 1]);
now--;
}
}
reverse(begin(ope), end(ope));
cout << n + (n - k) << '\n';
for (long long i = 0; i < k - 1; ++i) cout << ope[i] + 1 << " ";
vector<bool> used(n);
for (long long i = 0; i < k; ++i) used[ope[i]] = 1;
for (long long i = 0; i < n; ++i)
if (!used[i]) {
cout << i + 1 << " " << -(i + 1) << " ";
}
cout << ope[k - 1] + 1 << '\n';
}
}
| 12 | CPP |
#include <bits/stdc++.h>
using namespace std;
struct edge {
int toi, toj;
long long cost;
long long label;
};
int main() {
int T;
cin >> T;
for (int _ = 0; _ < T; _++) {
int n, k;
cin >> n >> k;
vector<vector<long long>> a;
for (int i = 0; i < n; i++) {
int x, y;
cin >> x >> y;
a.push_back({y, x, i});
}
sort(a.begin(), a.end());
vector<vector<long long>> dp(n + 1,
vector<long long>(k + 1, -10000000000000000));
dp[0][0] = 0;
vector<vector<vector<edge>>> E(n + 1,
vector<vector<edge>>(k + 1, vector<edge>()));
for (int i = 0; i < n; i++) {
for (int j = 0; j <= k; j++) {
if (dp[i][j] == -10000000000000000) continue;
dp[i + 1][j] = max(dp[i + 1][j], dp[i][j] + a[i][0] * (k - 1));
E[i + 1][j].push_back({i, j, a[i][0] * (k - 1), -(a[i][2] + 1)});
if (j != k) {
dp[i + 1][j + 1] =
max(dp[i + 1][j + 1], dp[i][j] + a[i][1] + a[i][0] * j);
E[i + 1][j + 1].push_back({i, j, a[i][1] + a[i][0] * j, a[i][2] + 1});
}
}
}
vector<int> ans_plus, ans_minus;
int ni = n, nj = k;
while (ni != 0 || nj != 0) {
for (int i = 0; i < E[ni][nj].size(); i++) {
auto &e = E[ni][nj][i];
if (dp[e.toi][e.toj] + e.cost == dp[ni][nj]) {
if (e.label > 0)
ans_plus.push_back(e.label);
else
ans_minus.push_back(-e.label);
ni = e.toi;
nj = e.toj;
break;
}
}
}
vector<int> ans;
while (ans_plus.size() != 1) {
ans.push_back(ans_plus.back());
ans_plus.pop_back();
}
for (int i = 0; i < ans_minus.size(); i++) {
int t = ans_minus[i];
ans.push_back(t);
ans.push_back(-t);
}
ans.push_back(ans_plus.back());
cout << ans.size() << endl;
for (int i = 0; i < ans.size(); i++) {
if (i != 0) cout << ' ';
cout << ans[i];
}
cout << endl;
}
return 0;
}
| 12 | CPP |
#include <bits/stdc++.h>
using namespace std;
int n, k;
struct pairab {
int a, b, idx;
};
bool compare(pairab i1, pairab i2) {
return (i1.b == i2.b) ? (i1.a < i2.a) : (i1.b < i2.b);
}
pairab in[80];
int inf = (int)1e9;
int memo[80][80];
int dp(int i, int takenInFirstK) {
if (takenInFirstK > k) return -inf;
if (i >= n) return (takenInFirstK == k) ? 0 : -inf;
if (memo[i][takenInFirstK] + 1) return memo[i][takenInFirstK];
int take = dp(i + 1, takenInFirstK + 1) + in[i].a + (in[i].b * takenInFirstK);
int takeAndDelete = dp(i + 1, takenInFirstK) + (in[i].b * (k - 1));
return memo[i][takenInFirstK] = max(take, takeAndDelete);
}
int chooseLast;
list<int> print, takeAndDel;
void trace(int i, int takenInFirstK) {
if (takenInFirstK > k) return;
if (i >= n) return;
int ans = dp(i, takenInFirstK);
int take = dp(i + 1, takenInFirstK + 1) + in[i].a + (in[i].b * takenInFirstK);
if (ans == take) {
if (takenInFirstK + 1 == k) {
chooseLast = in[i].idx;
} else {
print.push_back(in[i].idx);
}
trace(i + 1, takenInFirstK + 1);
} else {
takeAndDel.push_back(in[i].idx);
trace(i + 1, takenInFirstK);
}
}
int main() {
ios_base::sync_with_stdio(0), cin.tie(0), cout.tie(0);
;
int tc;
cin >> tc;
while (tc--) {
cin >> n >> k;
for (int i = 0; i < n; i++) {
int a, b;
cin >> a >> b;
in[i].a = a;
in[i].b = b;
in[i].idx = i + 1;
}
sort(in, in + n, compare);
for (int i = 0; i < n; i++) {
for (int j = 0; j <= k; j++) {
memo[i][j] = -1;
}
}
chooseLast = -1;
trace(0, 0);
while (takeAndDel.size()) {
int x = takeAndDel.front();
takeAndDel.pop_front();
print.push_back(x);
print.push_back(-x);
}
if (chooseLast + 1) {
print.push_back(chooseLast);
}
cout << print.size() << endl;
while (print.size()) {
int x = print.front();
print.pop_front();
cout << x << " ";
}
cout << endl;
}
return 0;
}
| 12 | CPP |
#include <bits/stdc++.h>
using namespace std;
int n, k;
long long aa[100], bb[100], ww[100];
int tt;
int dv[100][100][100];
long long dd[100][100][100];
int dt[100][100][100];
long long calc(int a, int b, int c) {
if (a == 0 && b == 0) return 0;
if (a == 0 || b < 0) return -999999999999999LL;
if (dv[a][b][c] == tt) return dd[a][b][c];
if (a == c) {
long long d = calc(a - 1, b, c) + aa[a] + (k - 1) * bb[a];
dd[a][b][c] = d;
dt[a][b][c] = 3;
} else {
long long d1 = calc(a - 1, b, c) + (k - 1) * bb[a];
long long d2 = calc(a - 1, b - 1, c) + aa[a] + (b - 1) * bb[a];
if (d1 >= d2) {
dd[a][b][c] = d1;
dt[a][b][c] = 1;
} else {
dd[a][b][c] = d2;
dt[a][b][c] = 2;
}
}
dv[a][b][c] = tt;
return dd[a][b][c];
}
void lol() {
cin >> n >> k;
for (int i = 1; i <= n; i++) {
cin >> aa[i] >> bb[i];
ww[i] = i;
}
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= n - 1; j++) {
if (bb[j] > bb[j + 1]) {
swap(aa[j], aa[j + 1]);
swap(bb[j], bb[j + 1]);
swap(ww[j], ww[j + 1]);
}
}
}
long long pp = 0;
int pi = 0;
for (int i = 1; i <= n; i++) {
long long uu = calc(n, k - 1, i);
if (uu >= pp) {
pp = uu;
pi = i;
}
}
vector<int> v1, v2;
int ak = k;
k--;
while (n >= 1) {
if (dt[n][k][pi] == 1) {
if (ak != 1) v1.push_back(ww[n]);
n--;
} else if (dt[n][k][pi] == 2) {
v2.push_back(ww[n]);
n--;
k--;
} else if (dt[n][k][pi] == 3) {
n--;
}
}
reverse(v2.begin(), v2.end());
cout << v1.size() * 2 + v2.size() + 1 << "\n";
for (auto x : v2) cout << x << " ";
for (auto x : v1) cout << x << " " << -x << " ";
cout << ww[pi] << "\n";
}
int main() {
int t;
cin >> t;
for (int i = 1; i <= t; i++) {
tt = i;
lol();
}
}
| 12 | CPP |
#include <bits/stdc++.h>
using namespace std;
const double PI = acos(-1);
const double eps = 1e-12;
const int inf = 2000000000;
const long long int infLL = (long long int)1e18;
long long int MOD = 1000000007;
int MOD1 = 1000000007;
int MOD2 = 1000000009;
inline bool checkBit(long long int n, long long int i) {
return n & (1LL << i);
}
inline long long int setBit(long long int n, long long int i) {
return n | (1LL << i);
;
}
inline long long int resetBit(long long int n, long long int i) {
return n & (~(1LL << i));
}
int dx[] = {0, 0, +1, -1};
int dy[] = {+1, -1, 0, 0};
inline bool EQ(double a, double b) { return fabs(a - b) < 1e-9; }
inline bool isLeapYear(long long int year) {
return (year % 400 == 0) || (year % 4 == 0 && year % 100 != 0);
}
inline void normal(long long int &a) {
a %= MOD;
(a < 0) && (a += MOD);
}
inline long long int modMul(long long int a, long long int b) {
a %= MOD, b %= MOD;
normal(a), normal(b);
return (a * b) % MOD;
}
inline long long int modAdd(long long int a, long long int b) {
a %= MOD, b %= MOD;
normal(a), normal(b);
return (a + b) % MOD;
}
inline long long int modSub(long long int a, long long int b) {
a %= MOD, b %= MOD;
normal(a), normal(b);
a -= b;
normal(a);
return a;
}
inline long long int modPow(long long int b, long long int p) {
long long int r = 1LL;
while (p) {
if (p & 1) r = modMul(r, b);
b = modMul(b, b);
p >>= 1LL;
}
return r;
}
inline long long int modDiv(long long int a, long long int b) {
return modMul(a, modPow(b, MOD - 2));
}
bool comp(const pair<long long int, pair<long long int, long long int> > &p1,
const pair<long long int, pair<long long int, long long int> > &p2) {
return p1.first > p2.first;
}
bool comp1(const pair<long long int, long long int> &p1,
const pair<long long int, long long int> &p2) {
if (p1.first == p2.first) {
return p1.second > p2.second;
}
return p1.first < p2.first;
}
long long int converter(string a) {
long long int i, mul = 1LL, r, t, ans = 0LL;
if (a.length() == 0) return 0;
for (i = a.length() - 1; i >= 0; i--) {
t = a[i] - '0';
r = t % 10;
ans += (mul * r);
mul = mul * 10;
}
return ans;
}
int msb(unsigned x) {
union {
double a;
int b[2];
};
a = x;
return (b[1] >> 20) - 1023;
}
const int MAX = 78;
int t, n, k;
pair<pair<long long int, long long int>, long long int> p[MAX];
long long int dp[MAX][MAX];
vector<long long int> good, bad;
long long int solve(int idx, int cnt) {
if (idx == n + 1) {
if (cnt != k) return -infLL;
return 0;
}
if (dp[idx][cnt] != -1) return dp[idx][cnt];
long long int ret = -infLL;
if (cnt + 1 <= k) {
ret = max(ret, cnt * p[idx].first.first + p[idx].first.second +
solve(idx + 1, cnt + 1));
}
ret = max(ret, ((k - 1) * p[idx].first.first) + solve(idx + 1, cnt));
return dp[idx][cnt] = ret;
}
void trace(int idx, int cnt) {
if (idx == n + 1) return;
long long int ret1 = -infLL, ret2 = -infLL;
if (cnt + 1 <= k)
ret1 = cnt * p[idx].first.first + p[idx].first.second +
solve(idx + 1, cnt + 1);
ret2 = ((k - 1) * p[idx].first.first) + solve(idx + 1, cnt);
if (ret1 >= ret2) {
good.push_back(p[idx].second);
trace(idx + 1, cnt + 1);
} else {
bad.push_back(p[idx].second);
trace(idx + 1, cnt);
}
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
;
cout.unsetf(ios::floatfield);
cout.precision(20);
cout.setf(ios::fixed, ios::floatfield);
;
cin >> t;
while (t--) {
good.clear();
bad.clear();
long long int maxi = 0, idx;
cin >> n >> k;
for (int i = 1; i <= n; ++i) {
cin >> p[i].first.second >> p[i].first.first;
p[i].second = i;
if (p[i].first.second >= maxi) maxi = p[i].first.second, idx = i;
}
if (k == 1) {
cout << 1 << '\n';
cout << idx << '\n';
continue;
}
sort(p + 1, p + n + 1);
memset(dp, -1, sizeof(dp));
long long int now = solve(1, 0);
trace(1, 0);
cout << good.size() + (2 * bad.size()) << '\n';
for (int i = 0; i < good.size() - 1; ++i) {
cout << good[i] << " ";
}
for (int i = 0; i < bad.size(); ++i) {
cout << bad[i] << " " << -1 * bad[i] << " ";
}
cout << good[good.size() - 1] << '\n';
}
return 0;
}
| 12 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int INF = 0x3f3f3f3f;
const long long INFLL = 1e18;
const int MOD = 1e9 + 7;
const int MAXN = 2e5 + 5;
tuple<int, int, int> minions[111];
bool picked[111];
long long dp[111][111];
int n, k;
vector<int> ans;
void mxze(long long &a, long long b) { a = max(a, b); }
long long solve(int i, int j) {
if (i == n) return 0;
if (dp[i][j] != -1) return dp[i][j];
long long ret = 0;
auto [b, a, id] = minions[i];
if (j < k) mxze(ret, b * j + a + solve(i + 1, j + 1));
if (n - i > k - j) mxze(ret, b * (k - 1) + solve(i + 1, j));
return dp[i][j] = ret;
}
int main() {
int t;
scanf("%d", &t);
while (t--) {
memset(dp, -1, sizeof(dp));
memset(picked, false, sizeof(picked));
ans.clear();
scanf("%d", &n), scanf("%d", &k);
for (int i = 0; i < (int)n; i++) {
int a, b;
scanf("%d", &a), scanf("%d", &b);
minions[i] = {b, a, i + 1};
}
sort(minions, minions + n);
int i = 0, j = 0;
while (i < n) {
auto [b, a, id] = minions[i];
if (j < k && solve(i, j) == b * j + a + solve(i + 1, j + 1)) {
picked[id] = true;
ans.push_back(id);
i++, j++;
} else
i++;
}
int lst = ans.back();
ans.pop_back();
for (int i = 1; i < (int)n + 1; i++)
if (!picked[i]) ans.push_back(i), ans.push_back(-i);
ans.push_back(lst);
printf("%zu\n", ans.size());
for (auto id : ans) printf("%d ", id);
printf("\n");
}
return 0;
}
| 12 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int inf = 1012345678;
vector<int> transform(int n, vector<int> arr, vector<int> perm) {
vector<int> res(n);
for (int i = 0; i < n; ++i) {
res[i] = arr[perm[i]];
}
return res;
}
int main() {
int Q;
cin >> Q;
while (Q--) {
int N, K;
cin >> N >> K;
vector<int> A(N), B(N);
for (int i = 0; i < N; ++i) {
cin >> A[i] >> B[i];
}
vector<int> perm(N);
for (int i = 0; i < N; ++i) {
perm[i] = i;
}
sort(perm.begin(), perm.end(), [&](int i, int j) { return B[i] < B[j]; });
A = transform(N, A, perm);
B = transform(N, B, perm);
int bsum = 0;
for (int i = 0; i < N; ++i) {
bsum += B[i] * (K - 1);
}
vector<vector<int> > dp(N + 1, vector<int>(K, -inf));
dp[0][0] = bsum;
for (int i = 0; i < N; ++i) {
for (int j = 0; j < K; ++j) {
dp[i + 1][j] = dp[i][j];
if (j >= 1) {
dp[i + 1][j] =
max(dp[i + 1][j], dp[i][j - 1] + A[i] - B[i] * (K - j));
}
}
}
int opt = -1, optval = -inf;
for (int i = 0; i < N; ++i) {
if (dp[i][K - 1] == -inf) continue;
int val = dp[i][K - 1];
int mx = *max_element(A.begin() + i, A.end());
val += mx;
if (optval < val) {
optval = val;
opt = i;
}
}
vector<int> seq;
int ptr = K - 1;
for (int i = opt - 1; i >= 0; --i) {
if (dp[i][ptr] != dp[i + 1][ptr]) {
seq.push_back(i);
--ptr;
}
}
reverse(seq.begin(), seq.end());
int last = max_element(A.begin() + opt, A.end()) - A.begin();
vector<int> ans;
for (int i : seq) {
ans.push_back(perm[i] + 1);
}
for (int i = 0; i < N; ++i) {
if (!binary_search(seq.begin(), seq.end(), i) && i != last) {
ans.push_back(perm[i] + 1);
ans.push_back(-(perm[i] + 1));
}
}
ans.push_back(perm[last] + 1);
cout << ans.size() << endl;
for (int i = 0; i < ans.size(); ++i) {
if (i) cout << ' ';
cout << ans[i];
}
cout << endl;
}
return 0;
}
| 12 | CPP |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using vi = vector<ll>;
const int maxn = 80;
ll n, dp[maxn][maxn], p[maxn][maxn];
vector<pair<ll, ll>> a;
vi used;
map<pair<ll, ll>, vi> idx;
vi ans;
void track(int n, int k) {
if (!n) return;
if (p[n][k] == 2) {
track(n - 1, k - 1);
used[idx[a[n - 1]].back()] = 1;
ans.push_back(idx[a[n - 1]].back());
idx[a[n - 1]].pop_back();
} else
track(n - 1, k);
}
void solve() {
int n, k;
cin >> n >> k;
memset(dp, -1, sizeof dp);
a = vector<pair<ll, ll>>(n);
dp[0][0] = 0;
for (auto &i : a) cin >> i.second >> i.first;
for (int i = 0; i < n; i++) idx[{a[i].second, a[i].first}].push_back(i + 1);
sort(a.begin(), a.end());
for (auto &i : a) swap(i.first, i.second);
for (int i = 0; i < n; i++) {
for (int j = 0; j <= k; j++) {
if (dp[i][j] < 0) continue;
dp[i + 1][j] = max(dp[i + 1][j], dp[i][j] + (k - 1) * a[i].second);
if (dp[i + 1][j] == dp[i][j] + (k - 1) * a[i].second) p[i + 1][j] = 1;
if (j < k) {
dp[i + 1][j + 1] =
max(dp[i + 1][j + 1], dp[i][j] + j * a[i].second + a[i].first);
if (dp[i + 1][j + 1] == dp[i][j] + j * a[i].second + a[i].first)
p[i + 1][j + 1] = 2;
}
}
}
used = vi(n + 1, 0);
ans.clear();
track(n, k);
int ab = ans.back();
ans.pop_back();
for (int i = 1; i <= n; i++)
if (!used[i]) ans.push_back(i), ans.push_back(-i);
ans.push_back(ab);
cout << ans.size() << '\n';
for (auto i : ans) cout << i << " ";
cout << '\n';
}
int main() {
cin.tie(0)->sync_with_stdio(0);
int t;
cin >> t;
while (t--) solve();
}
| 12 | CPP |
#include <bits/stdc++.h>
const int inf = 0x3f3f3f3f, Inf = 0x7fffffff;
const long long INF = 0x7fffffffffffffff;
__inline__ __attribute__((always_inline)) unsigned int rnd() {
static unsigned int seed = 416;
return seed ^= seed >> 5, seed ^= seed << 17, seed ^= seed >> 13;
}
template <typename _Tp>
_Tp gcd(const _Tp &a, const _Tp &b) {
return (!b) ? a : gcd(b, a % b);
}
template <typename _Tp>
__inline__ __attribute__((always_inline)) _Tp abs(const _Tp &a) {
return a >= 0 ? a : -a;
}
template <typename _Tp>
__inline__ __attribute__((always_inline)) _Tp max(const _Tp &a, const _Tp &b) {
return a < b ? b : a;
}
template <typename _Tp>
__inline__ __attribute__((always_inline)) _Tp min(const _Tp &a, const _Tp &b) {
return a < b ? a : b;
}
template <typename _Tp>
__inline__ __attribute__((always_inline)) void chmax(_Tp &a, const _Tp &b) {
(a < b) && (a = b);
}
template <typename _Tp>
__inline__ __attribute__((always_inline)) void chmin(_Tp &a, const _Tp &b) {
(b < a) && (a = b);
}
template <typename _Tp>
__inline__ __attribute__((always_inline)) void read(_Tp &x) {
char ch(getchar());
bool f(false);
while (ch < 48 || ch > 57) f |= ch == 45, ch = getchar();
x = ch & 15, ch = getchar();
while (ch >= 48 && ch <= 57)
x = (((x << 2) + x) << 1) + (ch & 15), ch = getchar();
if (f) x = -x;
}
template <typename _Tp, typename... Args>
__inline__ __attribute__((always_inline)) void read(_Tp &t, Args &...args) {
read(t);
read(args...);
}
__inline__ __attribute__((always_inline)) int read_str(char *s) {
char ch(getchar());
while (ch == ' ' || ch == '\r' || ch == '\n') ch = getchar();
char *tar = s;
*tar = ch, ch = getchar();
while (ch != ' ' && ch != '\r' && ch != '\n' && ch != EOF)
*(++tar) = ch, ch = getchar();
return tar - s + 1;
}
const int N = 85;
struct node {
long long a, b;
int id;
__inline__ __attribute__((always_inline)) bool operator<(
const node &o) const {
return b < o.b;
}
} a[N];
long long dp[N][N];
bool opt[N][N];
bool used[N];
void MAIN() {
memset(used, 0, sizeof(used));
int n, k;
read(n, k);
for (int i = 1; i <= n; ++i) {
read(a[i].a, a[i].b);
a[i].id = i;
}
std::sort(a + 1, a + n + 1);
if (k == n) {
printf("%d\n", n);
for (int i = 1; i <= n; ++i) printf("%d ", a[i].id);
printf("\n");
return;
}
auto solve = [&](int id) -> long long {
memset(dp, -63, sizeof(dp));
memset(opt, 0, sizeof(opt));
dp[0][0] = 0;
for (int i = 1; i <= n; ++i) {
if (i == id) {
for (int j = 0; j <= k; ++j) {
dp[i][j] = dp[i - 1][j] + a[i].a + a[i].b * (k - 1);
opt[i][j] = 0;
}
continue;
}
dp[i][0] = dp[i - 1][0] + (k - 1) * a[i].b;
opt[i][0] = 0;
for (int j = 1; j <= k; ++j) {
dp[i][j] = dp[i - 1][j] + (k - 1) * a[i].b;
opt[i][j] = 0;
long long tmp = dp[i - 1][j - 1] + a[i].a + (j - 1) * a[i].b;
if (tmp > dp[i][j]) {
dp[i][j] = tmp;
opt[i][j] = 1;
}
}
}
return dp[n][k - 1];
};
long long ans = 0;
int pos = 0;
for (int i = 1; i <= n; ++i) {
long long tmp = solve(i);
if (tmp > ans) {
ans = tmp;
pos = i;
}
}
solve(pos);
fprintf(stderr, "%lld %d\n", ans, pos);
pos = a[pos].id;
std::vector<int> v;
int cur = n, cnt = k - 1;
while (cur) {
if (opt[cur][cnt]) {
--cnt;
v.push_back(a[cur].id);
used[a[cur].id] = true;
}
--cur;
}
std::reverse(v.begin(), v.end());
std::vector<int> res;
for (auto it : v) res.push_back(it);
for (int i = 1; i <= n; ++i) {
if (!used[i] && i != pos) {
res.push_back(i);
res.push_back(-i);
}
}
res.push_back(pos);
printf("%d\n", ((int)res.size()));
for (auto it : res) printf("%d ", it);
printf("\n");
}
int main() {
int _;
read(_);
while (_--) MAIN();
return 0;
}
| 12 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int N_MAX = 77;
int t;
int n, k;
struct Minion {
int a, b;
int index;
};
bool operator<(const Minion &x, const Minion &y) { return x.b < y.b; }
Minion v[N_MAX];
int dp[N_MAX][N_MAX];
bool step[N_MAX][N_MAX];
bool lastk[N_MAX];
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cin >> t;
while (t--) {
cin >> n >> k;
for (int i = 1; i <= n; i++) {
cin >> v[i].a >> v[i].b;
v[i].index = i;
}
sort(v + 1, v + n + 1);
for (int j = 1; j <= k; j++) dp[0][j] = INT_MIN;
for (int i = 1; i <= n; i++) {
dp[i][0] = dp[i - 1][0] + (k - 1) * v[i].b;
step[i][0] = false;
for (int j = 1; j <= k; j++) {
dp[i][j] = max(dp[i - 1][j] + (k - 1) * v[i].b,
dp[i - 1][j - 1] + (j - 1) * v[i].b + v[i].a);
if (dp[i][j] == dp[i - 1][j] + (k - 1) * v[i].b)
step[i][j] = false;
else
step[i][j] = true;
}
}
for (int i = n, j = k; i > 0; i--)
if (step[i][j] == true) {
lastk[i] = true;
j--;
} else
lastk[i] = false;
cout << n + (n - k) << "\n";
int imaxb = -1;
for (int i = n; i >= 1; i--)
if (lastk[i] == true) {
imaxb = i;
break;
}
for (int i = 1; i <= n; i++)
if (lastk[i] == true && i != imaxb) cout << v[i].index << " ";
for (int i = 1; i <= n; i++)
if (lastk[i] == false) cout << v[i].index << " " << -v[i].index << " ";
cout << v[imaxb].index << "\n";
}
return 0;
}
| 12 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int inf = 1e9;
const long long inf_ll = 1e18;
const long long N = 100;
array<long long, 3> a[N];
long long dp[N][N], res[2 * N];
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
long long t;
cin >> t;
while (t--) {
long long n, k;
cin >> n >> k;
for (long long i = 0; i < n; i++) {
cin >> a[i][1] >> a[i][0];
a[i][2] = i + 1;
}
sort(a, a + n);
long long ans = 0;
for (long long r = 0; r < n; r++) {
fill(dp[0] + 1, dp[0] + k, -inf_ll);
dp[0][0] = 0;
for (long long i = 1; i <= n; i++)
for (long long j = 0; j < k; j++) {
if (i - 1 == r) {
dp[i][j] = dp[i - 1][j];
continue;
}
dp[i][j] = dp[i - 1][j] + a[i - 1][0] * (k - 1);
if (j > 0)
dp[i][j] = max(dp[i][j], dp[i - 1][j - 1] + a[i - 1][1] +
a[i - 1][0] * (j - 1));
}
long long c = dp[n][k - 1] + a[r][1] + a[r][0] * (k - 1);
if (c > ans) {
ans = c;
res[2 * n - k - 1] = a[r][2];
int p = k - 2, q = 2 * n - k - 2, j = k - 1;
for (int i = n; i > 0; i--) {
if (i - 1 == r) continue;
if (j == 0 ||
dp[i - 1][j] + a[i - 1][0] * (k - 1) >=
dp[i - 1][j - 1] + a[i - 1][1] + a[i - 1][0] * (j - 1)) {
res[q--] = -a[i - 1][2];
res[q--] = a[i - 1][2];
} else {
res[p--] = a[i - 1][2];
j--;
}
}
}
}
cout << 2 * n - k << "\n";
for (int i = 0; i < 2 * n - k; i++)
cout << res[i] << " \n"[i == 2 * n - k - 1];
}
}
| 12 | CPP |
#include <bits/stdc++.h>
using namespace std;
struct pt {
int a, b, ind;
pt() {}
pt(int a, int b, int ind) : a(a), b(b), ind(ind) {}
};
const int inf = 1e9;
int n, k;
void solve(int tc) {
scanf("%d", &n);
scanf("%d", &k);
vector<pt> ar(n);
for (int i = 0; i < n; ++i) {
int a, b;
scanf("%d", &a);
scanf("%d", &b);
ar[i] = pt(a, b, i + 1);
}
sort(ar.begin(), ar.end(), [](pt &x, pt &y) -> bool {
if (x.b == y.b) return x.a < y.a;
return x.b < y.b;
});
vector<vector<int> > dp(n + 1, vector<int>(k + 1, -inf));
vector<vector<int> > trace(n + 1, vector<int>(k + 1, -1));
dp[0][0] = 0;
for (int i = 1; i <= n; ++i) {
for (int j = 0; j <= min(k, n); ++j) {
if (j > 0 and
dp[i][j] < dp[i - 1][j - 1] + ar[i - 1].a + (j - 1) * ar[i - 1].b) {
dp[i][j] = dp[i - 1][j - 1] + ar[i - 1].a + (j - 1) * ar[i - 1].b;
trace[i][j] = 1;
}
if (dp[i][j] < dp[i - 1][j] + (k - 1) * ar[i - 1].b) {
dp[i][j] = dp[i - 1][j] + (k - 1) * ar[i - 1].b;
trace[i][j] = 0;
}
}
}
int moves = 2 * n - k;
cout << moves << "\n";
vector<int> ans[2];
while (n > 0) {
assert(trace[n][k] != -1);
int p = trace[n][k];
ans[p].emplace_back(ar[n - 1].ind);
k -= p;
--n;
}
reverse(ans[1].begin(), ans[1].end());
reverse(ans[0].begin(), ans[0].end());
for (int i = 0; i < (int)ans[1].size() - 1; ++i) {
cout << ans[1][i] << " ";
}
for (int it : ans[0]) {
cout << it << " " << -it << " ";
}
cout << ans[1].back() << "\n";
}
int main() {
int tt = 1;
scanf("%d", &tt);
for (int i = 1; i <= tt; ++i) {
solve(i);
}
return 0;
}
| 12 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 100 + 5;
struct node {
long long x, y;
int id;
bool operator<(const node &ope) const { return y < ope.y; }
} a[maxn];
bool vis[maxn][maxn];
long long dp[maxn][maxn];
bool vis2[maxn];
inline void init() {
memset(dp, -1, sizeof(dp));
memset(vis, false, sizeof(vis));
memset(vis2, false, sizeof(vis2));
}
void solve(int n, int k) {
init();
dp[0][0] = 0;
sort(a + 1, a + 1 + n);
for (int i = 1; i <= n; ++i) {
int t = ((i) < (k) ? (i) : (k));
for (int j = 0; j <= t; ++j) {
if (dp[i - 1][j] >= 0) dp[i][j] = dp[i - 1][j] + (k - 1) * 1ll * a[i].y;
if (j > 0 && dp[i - 1][j - 1] >= 0) {
if (dp[i][j] >= dp[i - 1][j - 1] + a[i].x + (j - 1) * 1ll * a[i].y)
continue;
dp[i][j] = dp[i - 1][j - 1] + a[i].x + (j - 1) * 1ll * a[i].y;
vis[i][j] = true;
}
}
}
}
void print(int n, int k) {
printf("%d\n", k + (n - k) * 2);
for (int i = n, j = k; i > 0 && j >= 0; --i) {
if (vis[i][j]) vis2[i] = true, --j;
}
int t = 0;
for (int i = 1; i <= n; ++i) {
if (!vis2[i]) continue;
if (++t == k) {
t = a[i].id;
break;
}
printf("%d ", a[i].id);
}
for (int i = 1; i <= n; ++i) {
if (!vis2[i]) printf("%d %d ", a[i].id, -a[i].id);
}
printf("%d\n", t);
}
int main() {
int T;
scanf("%d", &T);
while (T--) {
int n, k;
scanf("%d%d", &n, &k);
for (int i = 1; i <= n; ++i) {
scanf("%lld%lld", &a[i].x, &a[i].y);
a[i].id = i;
}
solve(n, k);
print(n, k);
}
return 0;
}
| 12 | CPP |
#include <bits/stdc++.h>
template <typename T>
inline void chkmin(T &x, T y) {
x = min(x, y);
}
template <typename T>
inline void chkmax(T &x, T y) {
x = max(x, y);
}
template <typename T>
inline void read(T &x) {
T f = 1;
x = 0;
char c = getchar();
for (; !isdigit(c); c = getchar())
if (c == '-') f = -f;
for (; isdigit(c); c = getchar()) x = (x << 3) + (x << 1) + c - '0';
x *= f;
}
const int N = 80;
int n, k;
struct Info {
int first, second;
int home;
bool operator<(const Info &o) const {
if (first != o.first)
return first < o.first;
else
return second < o.second;
}
} a[N];
int memo[N][N];
inline int dp(int on, int used) {
if (used > k) return -1e9;
int &ans = memo[on][used];
if (ans != -1) return ans;
if (on == n) {
return ans = used == k ? 0 : int(-1e9);
} else {
return ans = std::max(
dp(on + 1, used) + (k - 1) * a[on].first,
dp(on + 1, used + 1) + a[on].second + used * a[on].first);
}
}
int main() {
int T;
read(T);
while (T--) {
read(n);
read(k);
memset(memo, -1, sizeof(memo));
for (int i = 0; i < n; ++i) {
read(a[i].second);
read(a[i].first);
a[i].second = -a[i].second;
a[i].home = i + 1;
}
std ::sort(a, a + n);
for (int i = 0; i < n; ++i) a[i].second = -a[i].second;
std ::vector<int> bas;
std ::vector<bool> got(n + 1, false);
for (int i = 0, j = 0; i < n;) {
if (dp(i, j) == dp(i + 1, j) + (k - 1) * a[i].first) {
++i;
} else {
bas.push_back(a[i].home);
got[a[i].home] = true;
++i;
++j;
}
}
std ::vector<int> ans;
assert((int)bas.size() == k);
for (int i = 0; i + 1 < k; ++i) ans.push_back(bas[i]);
for (int i = 1; i <= n; ++i) {
if (!got[i]) {
ans.push_back(i);
ans.push_back(-i);
}
}
ans.push_back(bas.back());
printf("%d\n", (int)ans.size());
for (auto x : ans) printf("%d ", x);
printf("\n");
}
return 0;
}
| 12 | CPP |
#include <bits/stdc++.h>
using namespace std;
constexpr long double m_pi = 3.1415926535897932L;
constexpr long long MOD = 1000000007;
constexpr long long INF = 1LL << 61;
constexpr long double EPS = 1e-10;
template <typename T>
using vector2 = vector<vector<T>>;
template <typename T>
using vector3 = vector<vector2<T>>;
string operator*(const string& s, int k) {
if (k == 0) return "";
string p = (s + s) * (k / 2);
if (k % 2 == 1) p += s;
return p;
}
template <class T>
inline bool chmin(T& a, T b) {
if (a > b) {
a = b;
return true;
}
return false;
}
template <class T>
inline bool chmax(T& a, T b) {
if (a < b) {
a = b;
return true;
}
return false;
}
struct Edge {
int to, rev;
long long cap;
Edge(int _to, long long _cap, int _rev) {
to = _to;
cap = _cap;
rev = _rev;
}
};
void add_edge(vector<vector<Edge>>& G, int from, int to, long long cap,
bool revFlag, long long revCap) {
G[from].push_back(Edge(to, cap, (long long)G[to].size()));
if (revFlag)
G[to].push_back(Edge(from, revCap, (long long)G[from].size() - 1));
}
long long max_flow_dfs(vector<vector<Edge>>& G, long long v, long long t,
long long f, vector<bool>& used) {
if (v == t) return f;
used[v] = true;
for (int i = 0; i < G[v].size(); ++i) {
Edge& e = G[v][i];
if (!used[e.to] && e.cap > 0) {
long long d = max_flow_dfs(G, e.to, t, min(f, e.cap), used);
if (d > 0) {
e.cap -= d;
G[e.to][e.rev].cap += d;
return d;
}
}
}
return 0;
}
long long max_flow(vector<vector<Edge>>& G, long long s, long long t) {
long long flow = 0;
for (;;) {
vector<bool> used(G.size());
for (long long(i) = (long long)(0); i < (long long)(used.size()); i++)
used[i] = false;
long long f = max_flow_dfs(G, s, t, INF, used);
if (f == 0) {
return flow;
}
flow += f;
}
}
void BellmanFord(vector<vector<Edge>>& G, long long s, vector<long long>& d,
vector<long long>& negative) {
d.resize(G.size());
negative.resize(G.size());
for (long long(i) = (long long)(0); i < (long long)(d.size()); i++)
d[i] = INF;
for (long long(i) = (long long)(0); i < (long long)(d.size()); i++)
negative[i] = false;
d[s] = 0;
for (long long(k) = (long long)(0); k < (long long)(G.size() - 1); k++) {
for (long long(i) = (long long)(0); i < (long long)(G.size()); i++) {
for (long long(j) = (long long)(0); j < (long long)(G[i].size()); j++) {
if (d[i] != INF && d[G[i][j].to] > d[i] + G[i][j].cap) {
d[G[i][j].to] = d[i] + G[i][j].cap;
}
}
}
}
for (long long(k) = (long long)(0); k < (long long)(G.size() - 1); k++) {
for (long long(i) = (long long)(0); i < (long long)(G.size()); i++) {
for (long long(j) = (long long)(0); j < (long long)(G[i].size()); j++) {
if (d[i] != INF && d[G[i][j].to] > d[i] + G[i][j].cap) {
d[G[i][j].to] = d[i] + G[i][j].cap;
negative[G[i][j].to] = true;
}
if (negative[i] == true) negative[G[i][j].to] = true;
}
}
}
}
void Dijkstra(vector<vector<Edge>>& G, long long s, vector<long long>& d) {
d.resize(G.size());
for (long long(i) = (long long)(0); i < (long long)(d.size()); i++)
d[i] = INF;
d[s] = 0;
priority_queue<pair<long long, long long>, vector<pair<long long, long long>>,
greater<pair<long long, long long>>>
q;
q.push(make_pair(0, s));
while (!q.empty()) {
pair<long long, long long> a = q.top();
q.pop();
if (d[a.second] < a.first) continue;
for (long long(i) = (long long)(0); i < (long long)(G[a.second].size());
i++) {
Edge e = G[a.second][i];
if (d[e.to] > d[a.second] + e.cap) {
d[e.to] = d[a.second] + e.cap;
q.push(make_pair(d[e.to], e.to));
}
}
}
}
void WarshallFloyd(vector<vector<Edge>>& G, vector<vector<long long>>& d) {
d.resize(G.size());
for (long long(i) = (long long)(0); i < (long long)(d.size()); i++)
d[i].resize(G.size());
for (long long(i) = (long long)(0); i < (long long)(d.size()); i++) {
for (long long(j) = (long long)(0); j < (long long)(d[i].size()); j++) {
d[i][j] = ((i != j) ? INF : 0);
}
}
for (long long(i) = (long long)(0); i < (long long)(G.size()); i++) {
for (long long(j) = (long long)(0); j < (long long)(G[i].size()); j++) {
chmin(d[i][G[i][j].to], G[i][j].cap);
}
}
for (long long(i) = (long long)(0); i < (long long)(G.size()); i++) {
for (long long(j) = (long long)(0); j < (long long)(G.size()); j++) {
for (long long(k) = (long long)(0); k < (long long)(G.size()); k++) {
chmin(d[j][k], d[j][i] + d[i][k]);
}
}
}
}
bool tsort(vector<vector<Edge>>& graph, vector<long long>& order) {
int n = graph.size(), k = 0;
vector<long long> in(n);
for (auto& es : graph)
for (auto& e : es) in[e.to]++;
priority_queue<long long, vector<long long>, greater<long long>> que;
for (long long(i) = (long long)(0); i < (long long)(n); i++)
if (in[i] == 0) que.push(i);
while (que.size()) {
int v = que.top();
que.pop();
order.push_back(v);
for (auto& e : graph[v])
if (--in[e.to] == 0) que.push(e.to);
}
if (order.size() != n)
return false;
else
return true;
}
class Lca {
public:
const int n = 0;
const int log2_n = 0;
std::vector<std::vector<int>> parent;
std::vector<int> depth;
Lca() {}
Lca(const vector<vector<Edge>>& g, int root)
: n(g.size()),
log2_n(log2(n) + 1),
parent(log2_n, std::vector<int>(n)),
depth(n) {
dfs(g, root, -1, 0);
for (int k = 0; k + 1 < log2_n; k++) {
for (int v = 0; v < (int)g.size(); v++) {
if (parent[k][v] < 0)
parent[k + 1][v] = -1;
else
parent[k + 1][v] = parent[k][parent[k][v]];
}
}
}
void dfs(const vector<vector<Edge>>& g, int v, int p, int d) {
parent[0][v] = p;
depth[v] = d;
for (auto& e : g[v]) {
if (e.to != p) dfs(g, e.to, v, d + 1);
}
}
int get(int u, int v) {
if (depth[u] > depth[v]) std::swap(u, v);
for (int k = 0; k < log2_n; k++) {
if ((depth[v] - depth[u]) >> k & 1) {
v = parent[k][v];
}
}
if (u == v) return u;
for (int k = log2_n - 1; k >= 0; k--) {
if (parent[k][u] != parent[k][v]) {
u = parent[k][u];
v = parent[k][v];
}
}
return parent[0][u];
}
};
void visit(const vector<vector<Edge>>& g, int v, vector<vector<int>>& scc,
stack<int>& S, vector<int>& inS, vector<int>& low, vector<int>& num,
int& time) {
low[v] = num[v] = ++time;
S.push(v);
inS[v] = true;
for (decltype((g[v]).begin()) e = (g[v]).begin(); e != (g[v]).end(); ++e) {
int w = e->to;
if (num[w] == 0) {
visit(g, w, scc, S, inS, low, num, time);
low[v] = min(low[v], low[w]);
} else if (inS[w])
low[v] = min(low[v], num[w]);
}
if (low[v] == num[v]) {
scc.push_back(vector<int>());
while (1) {
int w = S.top();
S.pop();
inS[w] = false;
scc.back().push_back(w);
if (v == w) break;
}
}
}
void stronglyConnectedComponents(const vector<vector<Edge>>& g,
vector<vector<int>>& scc) {
const int n = g.size();
vector<int> num(n), low(n);
stack<int> S;
vector<int> inS(n);
int time = 0;
for (long long(u) = (long long)(0); u < (long long)(n); u++)
if (num[u] == 0) visit(g, u, scc, S, inS, low, num, time);
}
class UnionFind {
vector<int> data;
long long num;
public:
UnionFind(int size) : data(size, -1), num(size) {}
bool unite(int x, int y) {
x = root(x);
y = root(y);
if (x != y) {
if (data[y] < data[x]) swap(x, y);
data[x] += data[y];
data[y] = x;
}
num -= (x != y);
return x != y;
}
bool findSet(int x, int y) { return root(x) == root(y); }
int root(int x) { return data[x] < 0 ? x : data[x] = root(data[x]); }
long long size(int x) { return -data[root(x)]; }
long long numSet() { return num; }
};
template <typename T, typename F>
class SegmentTree {
private:
T identity;
F merge;
long long n;
vector<T> dat;
public:
SegmentTree(F f, T id, vector<T> v) : merge(f), identity(id) {
int _n = v.size();
n = 1;
while (n < _n) n *= 2;
dat.resize(2 * n - 1, identity);
for (long long(i) = (long long)(0); i < (long long)(_n); i++)
dat[n + i - 1] = v[i];
for (int i = n - 2; i >= 0; i--)
dat[i] = merge(dat[i * 2 + 1], dat[i * 2 + 2]);
}
SegmentTree(F f, T id, int _n) : merge(f), identity(id) {
n = 1;
while (n < _n) n *= 2;
dat.resize(2 * n - 1, identity);
}
void set_val(int i, T x) {
i += n - 1;
dat[i] = x;
while (i > 0) {
i = (i - 1) / 2;
dat[i] = merge(dat[i * 2 + 1], dat[i * 2 + 2]);
}
}
T query(int l, int r) {
T left = identity, right = identity;
l += n - 1;
r += n - 1;
while (l < r) {
if ((l & 1) == 0) left = merge(left, dat[l]);
if ((r & 1) == 0) right = merge(dat[r - 1], right);
l = l / 2;
r = (r - 1) / 2;
}
return merge(left, right);
}
};
template <typename T>
class FenwickTree {
vector<T> data;
int n;
int p;
public:
FenwickTree(int n) : n(n) {
data.resize(n + 1LL, 0);
p = 1;
while (p < data.size()) p *= 2;
}
T sum(int k) {
T ret = 0;
for (; k > 0; k -= k & -k) ret += data[k];
return (ret);
}
T sum(int a, int b) { return sum(b) - sum(a); }
void add(int k, T x) {
for (++k; k <= n; k += k & -k) data[k] += x;
}
int lower_bound(long long w) {
if (w <= 0) return -1;
int x = 0;
for (int k = p / 2; k > 0; k /= 2) {
if (x + k <= n && data[x + k] < w) w -= data[x + k], x += k;
}
return x;
}
};
void divisor(long long n, vector<long long>& ret) {
for (long long i = 1; i * i <= n; i++) {
if (n % i == 0) {
ret.push_back(i);
if (i * i != n) ret.push_back(n / i);
}
}
sort(ret.begin(), ret.end());
}
void prime_factorization(long long n, vector<pair<long long, long long>>& ret) {
for (long long i = 2; i * i <= n; i++) {
if (n % i == 0) {
ret.push_back({i, 0});
while (n % i == 0) {
n /= i;
ret[ret.size() - 1].second++;
}
}
}
if (n != 1) ret.push_back({n, 1});
}
long long mod_pow(long long x, long long n, long long mod) {
long long res = 1;
while (n > 0) {
if (n & 1) res = res * x % mod;
x = x * x % mod;
n >>= 1;
}
return res;
}
long long mod_inv(long long x, long long mod) {
return mod_pow(x, mod - 2, mod);
}
class Combination {
public:
vector<long long> fact;
vector<long long> inv;
long long mod;
long long mod_inv(long long x) {
long long n = mod - 2LL;
long long res = 1LL;
while (n > 0) {
if (n & 1) res = res * x % mod;
x = x * x % mod;
n >>= 1;
}
return res;
}
long long nCr(long long n, long long r) {
if (n < r) return 0;
if (n < mod) return ((fact[n] * inv[r] % mod) * inv[n - r]) % mod;
long long ret = 1;
while (n || r) {
long long _n = n % mod, _r = r % mod;
n /= mod;
r /= mod;
(ret *= nCr(_n, _r)) %= mod;
}
return ret;
}
long long nPr(long long n, long long r) {
return (fact[n] * inv[n - r]) % mod;
}
long long nHr(long long n, long long r) { return nCr(r + n - 1, r); }
Combination(long long _n, long long _mod) {
mod = _mod;
long long n = min(_n + 1, mod);
fact.resize(n);
fact[0] = 1;
for (long long(i) = (long long)(0); i < (long long)(n - 1); i++) {
fact[i + 1] = (fact[i] * (i + 1LL)) % mod;
}
inv.resize(n);
inv[n - 1] = mod_inv(fact[n - 1]);
for (int i = n - 1; i > 0; i--) {
inv[i - 1] = inv[i] * i % mod;
}
}
};
long long popcount(long long x) {
x = (x & 0x5555555555555555) + (x >> 1 & 0x5555555555555555);
x = (x & 0x3333333333333333) + (x >> 2 & 0x3333333333333333);
x = (x & 0x0F0F0F0F0F0F0F0F) + (x >> 4 & 0x0F0F0F0F0F0F0F0F);
x = (x & 0x00FF00FF00FF00FF) + (x >> 8 & 0x00FF00FF00FF00FF);
x = (x & 0x0000FFFF0000FFFF) + (x >> 16 & 0x0000FFFF0000FFFF);
x = (x & 0x00000000FFFFFFFF) + (x >> 32 & 0x00000000FFFFFFFF);
return x;
}
void solve() {
long long n, k;
cin >> n >> k;
using T = tuple<long long, long long, long long>;
vector<T> m(n);
for (long long(i) = (long long)(0); i < (long long)(n); i++) {
long long a, b;
cin >> a >> b;
m[i] = {b, a, i + 1};
}
sort((m).begin(), (m).end());
vector3<long long> dp(
n + 1, vector2<long long>(k + 1, vector<long long>(n - k + 1, -INF)));
dp[0][0][0] = 0;
for (long long(i) = (long long)(0); i < (long long)(n); i++) {
auto [b, a, num] = m[i];
for (long long(j) = (long long)(0); j < (long long)(k + 1); j++) {
for (long long(l) = (long long)(0); l < (long long)(n - k + 1); l++) {
if (dp[i][j][l] == -INF) continue;
if (l != n - k) chmax(dp[i + 1][j][l + 1], dp[i][j][l] + (k - 1) * b);
if (j != k) chmax(dp[i + 1][j + 1][l], dp[i][j][l] + j * b + a);
}
}
}
cout << 2 * n - k << "\n";
pair<long long, long long> now = {k, n - k};
vector<long long> s, t;
for (int i = n - 1; i >= 0; i--) {
auto [b, a, num] = m[i];
auto [j, l] = now;
if (l && dp[i + 1][j][l] == dp[i][j][l - 1] + (k - 1) * b) {
t.push_back(num);
now.second--;
} else {
s.push_back(num);
now.first--;
}
}
reverse((s).begin(), (s).end());
for (long long(i) = (long long)(0); i < (long long)(k - 1); i++)
cout << s[i] << " ";
for (long long(i) = (long long)(0); i < (long long)(n - k); i++)
cout << t[i] << " " << -1 * t[i] << " ";
cout << s.back() << "\n";
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
long long n;
cin >> n;
while (n--) solve();
return 0;
}
| 12 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int Maxn = 88, inf = 0x3f3f3f3f;
struct node {
int a, b, id;
} g[Maxn];
int f[Maxn][Maxn], s[Maxn];
bool flag[Maxn][Maxn], vis[Maxn];
int a[Maxn], b[Maxn], id[Maxn];
int n, m, cnt;
inline bool cmp(node x, node y) { return x.b < y.b; }
void init() {
for (int i = 0; i <= n; ++i)
for (int j = 0; j <= m; ++j) flag[i][j] = 0;
for (int i = 1; i <= n; ++i) s[i] = vis[i] = 0;
cnt = 0;
}
inline int read() {
int s = 0, w = 1;
char ch = getchar();
while (ch < '0' || ch > '9') {
if (ch == '-') w = -1;
ch = getchar();
}
while (ch >= '0' && ch <= '9')
s = (s << 3) + (s << 1) + (ch ^ 48), ch = getchar();
return s * w;
}
int main() {
int T = read();
while (T--) {
n = read(), m = read();
for (int i = 1; i <= n; ++i) g[i].a = read(), g[i].b = read(), g[i].id = i;
sort(g + 1, g + 1 + n, cmp);
for (int i = 1; i <= n; ++i) a[i] = g[i].a, b[i] = g[i].b, id[i] = g[i].id;
for (int i = 0; i <= n; ++i)
for (int j = 0; j <= m; ++j) f[i][j] = -inf;
f[0][0] = 0;
for (int i = 1; i <= n; ++i)
for (int j = 0; j <= min(i, m); ++j) {
f[i][j] = f[i - 1][j] + b[i] * (m - 1), flag[i][j] = 0;
if (j && f[i - 1][j - 1] + a[i] + b[i] * (j - 1) > f[i][j])
f[i][j] = f[i - 1][j - 1] + a[i] + b[i] * (j - 1), flag[i][j] = 1;
}
int i = n, j = m;
while (i) {
if (flag[i][j]) s[++cnt] = i, vis[i] = 1, --j;
--i;
}
printf("%d\n", (n << 1) - m);
for (int i = cnt; i > 1; --i) printf("%d ", id[s[i]]);
for (int i = 1; i <= n; ++i)
if (!vis[i]) printf("%d %d ", id[i], -id[i]);
printf("%d\n", id[s[1]]);
init();
}
return 0;
}
| 12 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int N = 100;
inline int Read(int &r) {
int b = 1, c = getchar();
r = 0;
while (c < '0' || '9' < c) b = c == '-' ? -1 : b, c = getchar();
while ('0' <= c && c <= '9')
r = (r << 1) + (r << 3) + (c ^ '0'), c = getchar();
return r *= b;
}
int n, m, ndel, cas, tra[N][N], rem[N], del[N];
long long f[N][N];
struct DATA {
int key, add, id;
DATA() {}
DATA(const int &_key, const int &_add, const int &_id)
: key(_key), add(_add), id(_id) {}
inline friend bool operator<(const DATA &A, const DATA &B) {
return A.add < B.add;
}
} da[N];
int main() {
Read(cas);
while (cas--) {
Read(n), Read(m);
for (int i = 1, key, add; i <= n; i++) {
Read(key), Read(add);
da[i] = DATA(key, add, i);
}
sort(da + 1, da + 1 + n);
memset(f, -0x3f, sizeof f);
f[0][0] = 0;
for (int i = 1; i <= n; i++)
for (int j = 0; j <= i && j <= m; j++) {
f[i][j] = f[i - 1][j] + 1ll * (m - 1) * da[i].add;
tra[i][j] = 0;
long long tmp = f[i - 1][j - 1] + (j - 1ll) * da[i].add + da[i].key;
if (j && f[i][j] <= tmp) f[i][j] = tmp, tra[i][j] = 1;
}
ndel = 0;
for (int i = n, j = m; i; j -= tra[i][j], i--)
if (tra[i][j])
rem[j] = da[i].id;
else
del[++ndel] = da[i].id;
printf("%d\n", m + 2 * ndel);
bool first = true;
for (int i = 1; i < m; i++) {
if (first)
first = false;
else
putchar(' ');
printf("%d", rem[i]);
}
for (int i = 1; i <= ndel; i++) {
if (first)
first = false;
else
putchar(' ');
printf("%d -%d", del[i], del[i]);
}
if (first)
first = false;
else
putchar(' ');
printf("%d\n", rem[m]);
}
return 0;
}
| 12 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int INF = 1e9;
int n, k, dp[76][76];
array<int, 3> a[75];
bool last[76][76];
void solve() {
cin >> n >> k;
for (int i = 0; i < n; ++i) cin >> a[i][1] >> a[i][0], a[i][2] = i;
sort(a, a + n);
for (int i = 1; i <= n; ++i) {
for (int j = 0; j <= i; ++j) {
dp[i][j] = (j < i ? dp[i - 1][j] : -INF) + (k - 1) * a[i - 1][0];
last[i][j] = 0;
if (j) {
int c = dp[i - 1][j - 1] + (j - 1) * a[i - 1][0] + a[i - 1][1];
if (c > dp[i][j]) {
dp[i][j] = c;
last[i][j] = 1;
}
}
}
}
vector<int> t, nt;
for (int i = n, j = k; i; --i) {
if (last[i][j]) {
t.push_back(a[i - 1][2]);
--j;
} else
nt.push_back(a[i - 1][2]);
}
assert(t.size() == k);
reverse(t.begin(), t.end());
cout << 2 * n - k << "\n";
for (int i = 0; i < k - 1; ++i) cout << t[i] + 1 << " ";
for (int i : nt) cout << i + 1 << " " << -(i + 1) << " ";
cout << t[k - 1] + 1 << "\n";
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
int t;
cin >> t;
while (t--) solve();
return 0;
}
| 12 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int N = 77;
int t, n, k, inv[N];
long long a[N], b[N], a2[N], b2[N], dp[N][N];
bool summon[N][N], s[N], ans[N][N];
long long solve() {
dp[0][0] = 0;
for (int i = (1); i < (n + 1); i++) {
for (int j = (0); j < (min(k, i) + 1); j++) {
dp[i][j] = -1;
summon[i][j] = true;
if (j > 0) {
dp[i][j] = dp[i - 1][j - 1] + a[i] + (j - 1) * b[i];
}
if (j < i && dp[i - 1][j] + b[i] * (k - 1) > dp[i][j]) {
summon[i][j] = false;
dp[i][j] = dp[i - 1][j] + b[i] * (k - 1);
}
}
}
return dp[n][k];
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cin >> t;
while (t--) {
cin >> n >> k;
vector<tuple<int, int, int>> ve;
for (int i = (1); i < (n + 1); i++) {
cin >> a[i] >> b[i];
ve.emplace_back(b[i], a[i], i);
}
sort((ve).begin(), (ve).end());
for (int i = (1); i < (n + 1); i++) {
tie(b[i], a[i], inv[i]) = ve[i - 1];
}
solve();
int i = n, j = k;
while (i > 0) {
if (summon[i][j]) {
j--;
s[i] = true;
} else {
s[i] = false;
}
i--;
}
int cnt = 0;
vector<int> v;
int last = 0;
for (int i = (1); i < (n + 1); i++) {
if (s[i]) {
if (cnt < k - 1) {
v.push_back(inv[i]);
cnt++;
} else {
last = inv[i];
}
}
}
for (int i = (1); i < (n + 1); i++) {
if (!s[i]) {
v.push_back(inv[i]);
v.push_back(-inv[i]);
}
}
v.push_back(last);
cout << ((int)(v).size()) << '\n';
for (int x : v) {
cout << x << ' ';
}
cout << '\n';
}
}
| 12 | CPP |
#include <bits/stdc++.h>
using namespace std;
int T, N, K, a, b;
int main(int argc, const char *argv[]) {
cin >> T;
for (int t = 0; t < T; t++) {
cin >> N >> K;
vector<pair<int, pair<int, int>>> minions;
for (int i = 1; i <= N; i++) {
cin >> a >> b;
minions.push_back(make_pair(b, make_pair(a, i)));
}
sort(minions.begin(), minions.end());
int memo[80][80] = {0};
int choose[80][80] = {0};
for (int i = 0; i < 80; i++) {
for (int j = 0; j < 80; j++) {
memo[i][j] = INT_MIN;
}
}
for (int i = N; i >= 0; i--)
for (int j = K; j >= 0; j--) {
if (i == N) {
memo[i][j] = j == 0 ? 0 : INT_MIN;
continue;
}
if (j > 0) {
int keep = minions[i].second.first + minions[i].first * (K - j) +
memo[i + 1][j - 1];
if (keep > memo[i][j]) {
memo[i][j] = keep;
choose[i][j] = 1;
}
}
int notKeep = minions[i].first * (K - 1) + memo[i + 1][j];
if (notKeep > memo[i][j]) {
memo[i][j] = notKeep;
choose[i][j] = 0;
}
}
vector<int> keep, notKeep;
int num = K;
for (int i = 0; i < N; i++) {
if (choose[i][num] == 1) {
keep.push_back(minions[i].second.second);
num--;
} else {
notKeep.push_back(minions[i].second.second);
}
}
vector<int> moves;
for (int i = 0; i < (int)keep.size() - 1; i++) moves.push_back(keep[i]);
for (int i = 0; i < (int)notKeep.size(); i++) {
moves.push_back(notKeep[i]);
moves.push_back(-notKeep[i]);
}
if ((int)keep.size() > 0) {
moves.push_back(keep[(int)keep.size() - 1]);
}
cout << moves.size() << endl;
for (int i = 0; i < (int)moves.size(); i++)
cout << moves[i] << (i == (int)moves.size() - 1 ? "\n" : " ");
}
return 0;
}
| 12 | CPP |
#include <bits/stdc++.h>
using namespace std;
namespace IO {
const int buffer_size = 1e5 + 5;
char buf[buffer_size], *S, *T;
bool flag_EOF;
inline char read_char() {
if (S == T) T = (S = buf) + fread(buf, 1, buffer_size, stdin);
return S != T ? *(S++) : EOF;
}
inline int read_int() {
int flag = 1;
char c = read_char();
while (c < '0' || c > '9') {
if (c == EOF) {
flag_EOF = true;
return 0;
}
flag = (c == '-' ? -1 : 1);
c = read_char();
}
int x = 0;
while (c >= '0' && c <= '9') {
x = x * 10 + (c ^ 48);
c = read_char();
}
return x * flag;
}
char st[13];
int _top;
inline void Write(int x) {
if (!x) {
putchar('0');
return;
}
if (x < 0) {
putchar('-');
x = -x;
}
while (x) {
st[++_top] = x % 10 + '0';
x /= 10;
}
while (_top > 0) putchar(st[_top--]);
}
} // namespace IO
const int max_n = 75 + 5;
int a[max_n], b[max_n];
struct node {
int a, b, id;
} p[max_n];
inline bool cmp(const node &x, const node &y) { return x.b < y.b; }
int f[max_n][max_n];
bool mark[max_n][max_n];
bool use[max_n];
vector<int> ans;
int st[max_n], _top;
int main() {
int T;
scanf("%d", &T);
while (T--) {
int n, k;
scanf("%d%d", &n, &k);
for (int i = 1; i <= n; ++i) scanf("%d%d", a + i, b + i);
int Ans = 0;
ans.clear();
for (int i = 1; i <= n; ++i) {
int now = a[i] + b[i] * (k - 1);
for (int j = 1; j <= n - 1; ++j)
p[j].a = a[j], p[j].b = b[j], p[j].id = j;
p[i].a = a[n], p[i].b = b[n], p[i].id = n;
sort(p + 1, p + n, cmp);
memset(f, 128, sizeof(f));
f[0][0] = 0;
for (int x = 1; x <= n - 1; ++x)
for (int y = 0; y <= k - 1 && y <= x; ++y) {
f[x][y] = f[x - 1][y] + p[x].b * (k - 1);
mark[x][y] = false;
if (y > 0) {
int v = f[x - 1][y - 1] + p[x].a + p[x].b * (y - 1);
if (v > f[x][y]) {
f[x][y] = v;
mark[x][y] = true;
}
}
}
now += f[n - 1][k - 1];
if (now > Ans) {
Ans = now;
ans.clear();
for (int j = 1; j <= n; ++j) use[j] = false;
int x_now = n - 1, y_now = k - 1;
while (x_now || y_now) {
if (mark[x_now][y_now]) {
use[p[x_now].id] = true;
st[++_top] = p[x_now].id;
--x_now, --y_now;
} else
--x_now;
}
while (_top > 0) ans.push_back(st[_top--]);
use[i] = true;
for (int j = 1; j <= n; ++j) {
if (!use[j]) {
ans.push_back(j);
ans.push_back(-j);
}
}
ans.push_back(i);
}
}
printf("%d\n", int(ans.size()));
for (int i = 0; i < int(ans.size()); ++i)
printf("%d%c", ans[i], i + 1 < int(ans.size()) ? ' ' : '\n');
}
return 0;
}
| 12 | CPP |
#include <bits/stdc++.h>
using namespace std;
long long inf;
const double eps = 1e-8;
const double pi = acos(-1.0);
template <class T, class T2>
long long chkmin(T &a, T2 b) {
return a > b ? a = b, 1 : 0;
}
template <class T, class T2>
long long chkmax(T &a, T2 b) {
return a < b ? a = b, 1 : 0;
}
template <class T>
T sqr(T a) {
return a * a;
}
template <class T, class T2>
T mmin(T a, T2 b) {
return a < b ? a : b;
}
template <class T, class T2>
T mmax(T a, T2 b) {
return a > b ? a : b;
}
template <class T>
T aabs(T a) {
return a < 0 ? -a : a;
}
template <class T>
long long dcmp(T a, T b) {
return a > b;
}
template <long long *a>
long long cmp_a(long long first, long long second) {
return a[first] < a[second];
}
struct __INIT__ {
__INIT__() { memset(&inf, 0x3f, sizeof(inf)); }
} __INIT___;
namespace io {
const long long SIZE = (1 << 21) + 1;
char ibuf[SIZE], *iS, *iT, obuf[SIZE], *oS = obuf, *oT = oS + SIZE - 1, c,
qu[55];
long long f, qr;
inline void flush() {
fwrite(obuf, 1, oS - obuf, stdout);
oS = obuf;
}
inline void putc(char first) {
*oS++ = first;
if (oS == oT) flush();
}
template <typename A>
inline bool read(A &first) {
for (f = 1, c = (iS == iT ? (iT = (iS = ibuf) + fread(ibuf, 1, SIZE, stdin),
(iS == iT ? EOF : *iS++))
: *iS++);
c < '0' || c > '9';
c = (iS == iT ? (iT = (iS = ibuf) + fread(ibuf, 1, SIZE, stdin),
(iS == iT ? EOF : *iS++))
: *iS++))
if (c == '-')
f = -1;
else if (c == EOF)
return 0;
for (first = 0; c <= '9' && c >= '0';
c = (iS == iT ? (iT = (iS = ibuf) + fread(ibuf, 1, SIZE, stdin),
(iS == iT ? EOF : *iS++))
: *iS++))
first = first * 10 + (c & 15);
first *= f;
return 1;
}
inline bool read(char &first) {
while ((first = (iS == iT ? (iT = (iS = ibuf) + fread(ibuf, 1, SIZE, stdin),
(iS == iT ? EOF : *iS++))
: *iS++)) == ' ' ||
first == '\n' || first == '\r')
;
return first != EOF;
}
inline bool read(char *first) {
while ((*first = (iS == iT ? (iT = (iS = ibuf) + fread(ibuf, 1, SIZE, stdin),
(iS == iT ? EOF : *iS++))
: *iS++)) == '\n' ||
*first == ' ' || *first == '\r')
;
if (*first == EOF) return 0;
while (!(*first == '\n' || *first == ' ' || *first == '\r' || *first == EOF))
*(++first) = (iS == iT ? (iT = (iS = ibuf) + fread(ibuf, 1, SIZE, stdin),
(iS == iT ? EOF : *iS++))
: *iS++);
*first = 0;
return 1;
}
template <typename A, typename... B>
inline bool read(A &first, B &...second) {
return read(first) && read(second...);
}
template <typename A>
inline bool write(A first) {
if (!first) putc('0');
if (first < 0) putc('-'), first = -first;
while (first) qu[++qr] = first % 10 + '0', first /= 10;
while (qr) putc(qu[qr--]);
return 0;
}
inline bool write(char first) {
putc(first);
return 0;
}
inline bool write(const char *first) {
while (*first) {
putc(*first);
++first;
}
return 0;
}
inline bool write(char *first) {
while (*first) {
putc(*first);
++first;
}
return 0;
}
template <typename A, typename... B>
inline bool write(A first, B... second) {
return write(first) || write(second...);
}
struct Flusher_ {
~Flusher_() { flush(); }
} io_flusher_;
} // namespace io
using io ::putc;
using io ::read;
using io ::write;
pair<pair<long long, long long>, long long> a[85];
long long sel[85];
long long f[85][85], las[85][85];
signed main() {
long long t;
read(t);
long long n, k;
for (; t; --t) {
read(n, k);
for (long long i = 1; i <= n; ++i) {
read(a[i].first.second, a[i].first.first);
a[i].second = i;
}
sort(a + 1, a + n + 1);
memset(f, -0x3f, sizeof(f));
long long w = 0;
for (long long i = 1; i <= n; ++i) w += a[i].first.first * (k - 1);
f[0][0] = w;
for (long long i = 0; i < n; ++i) {
for (long long j = 0; j <= i && j <= k; ++j) {
if (chkmax(f[i + 1][j + 1], f[i][j] +
a[i + 1].first.first * (j - k + 1) +
a[i + 1].first.second))
las[i + 1][j + 1] = 1;
if (chkmax(f[i + 1][j], f[i][j])) las[i + 1][j] = 0;
}
}
for (long long i = n, j = k; i; --i) {
if (las[i][j]) {
sel[i] = j;
--j;
} else
sel[i] = 0;
}
write(n + n - k, '\n');
for (long long i = 1; i <= n; ++i) {
if (sel[i] && sel[i] < k) write(a[i].second, ' ');
}
for (long long i = 1; i <= n; ++i)
if (!sel[i]) write(a[i].second, ' ', -a[i].second, ' ');
for (long long i = 1; i <= n; ++i)
if (sel[i] == k) write(a[i].second, '\n');
}
return 0;
}
| 12 | CPP |
#include <bits/stdc++.h>
using namespace std;
long long n, k, dp[100][100], tak[100][100];
pair<long long, pair<long long, long long> > a[100];
void solve() {
cin >> n >> k;
for (int i = 1; i <= n; i++) {
cin >> a[i].second.first >> a[i].first;
a[i].second.second = i;
}
for (int i = 1; i <= 75; i++)
for (int j = 0; j <= 75; j++) tak[i][j] = 0;
sort(a + 1, a + n + 1);
for (int i = 1; i <= n; i++) dp[0][i] = -9999999999999999;
for (int i = 1; i <= n; i++) {
for (int j = 0; j <= min(k, (long long)i); j++) {
long long ra1 = dp[i - 1][j] + a[i].first * (k - 1);
long long ra2 = -9999999999999999;
if (j) ra2 = dp[i - 1][j - 1] + a[i].second.first + a[i].first * (j - 1);
if (ra1 <= ra2) {
tak[i][j] = 1;
}
dp[i][j] = max(ra1, ra2);
}
for (int j = min(k, (long long)i) + 1; j <= n; j++)
dp[i][j] = -9999999999999999;
}
vector<long long> ans, las;
long long p = k;
for (int i = n; i >= 1; i--) {
if (tak[i][p]) {
p--;
ans.push_back(a[i].second.second);
} else {
las.push_back(a[i].second.second);
}
}
reverse(ans.begin(), ans.end());
cout << n + (int)las.size() << '\n';
for (int i = 0; i < (int)ans.size() - 1; i++) cout << ans[i] << " ";
for (int i = 0; i < las.size(); i++) {
cout << las[i] << " -" << las[i] << " ";
}
cout << ans[(int)ans.size() - 1] << '\n';
}
int main() {
ios::sync_with_stdio(false);
long long q;
cin >> q;
while (q--) solve();
return 0;
}
| 12 | CPP |
#include <bits/stdc++.h>
using namespace std;
bool cmp(pair<pair<long long, long long>, long long> a,
pair<pair<long long, long long>, long long> b) {
return a.first.second < b.first.second;
}
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
long long t;
cin >> t;
while (t--) {
long long n, k;
cin >> n >> k;
vector<pair<pair<long long, long long>, long long> > a(n);
for (long long i = 0; i < n; i++) {
cin >> a[i].first.first >> a[i].first.second;
a[i].second = i + 1;
}
sort(a.begin(), a.end(), cmp);
vector<vector<long long> > dp(n + 1, vector<long long>(k + 1, -1e18));
vector<vector<long long> > pred(n + 1, vector<long long>(k + 1, -1));
dp[0][0] = 0;
long long ans = 0;
for (long long i = 1; i <= n; i++) {
for (long long j = 0; j <= k; j++) {
if (j + 1 <= k &&
dp[i - 1][j] + j * a[i - 1].first.second + a[i - 1].first.first >=
dp[i][j + 1]) {
pred[i][j + 1] = 1;
dp[i][j + 1] =
max(dp[i][j + 1], dp[i - 1][j] + j * a[i - 1].first.second +
a[i - 1].first.first);
}
if (dp[i][j] < dp[i - 1][j] + (k - 1) * a[i - 1].first.second) {
dp[i][j] =
max(dp[i][j], dp[i - 1][j] + (k - 1) * a[i - 1].first.second);
pred[i][j] = 0;
}
}
}
long long st = k;
long long i = n;
if (dp[n][k - 1] > dp[n][k]) {
st = k - 1;
}
vector<long long> ans1, ans2;
while (i > 0) {
if (pred[i][st] == 1) {
ans1.push_back(i);
st--;
} else {
ans2.push_back(i);
}
i--;
}
reverse(ans1.begin(), ans1.end());
cout << ans1.size() + 2 * ans2.size() << "\n";
if (ans1.size() == k) {
for (long long i = 0; i < ans1.size() - 1; i++) {
cout << a[ans1[i] - 1].second << " ";
}
} else {
for (long long i = 0; i < ans1.size(); i++) {
cout << a[ans1[i] - 1].second << " ";
}
}
for (long long i = 0; i < ans2.size(); i++) {
cout << a[ans2[i] - 1].second << " ";
cout << -a[ans2[i] - 1].second << " ";
}
if (ans1.size() == k) {
cout << a[ans1.back() - 1].second << " ";
}
cout << "\n";
}
return 0;
}
| 12 | CPP |
#include <bits/stdc++.h>
using namespace std;
int n, k;
int dp[80][80];
bool included[80];
pair<pair<int, int>, int> A[80];
vector<int> ans;
bool byfise(pair<pair<int, int>, int> i, pair<pair<int, int>, int> j) {
return i.first.second < j.first.second;
}
void backtrack() {
int x = n, y = k;
while (x) {
if (y &&
dp[x - 1][y - 1] + A[x].first.first + (y - 1) * A[x].first.second ==
dp[x][y]) {
y--;
included[x] = 1;
}
x--;
}
}
int main() {
int t;
scanf("%d", &t);
while (t--) {
memset(included, 0, sizeof included);
memset(dp, -1, sizeof dp);
ans.clear();
scanf("%d %d", &n, &k);
for (int i = 1; i <= n; i++) {
scanf("%d %d", &A[i].first.first, &A[i].first.second);
A[i].second = i;
}
sort(A + 1, A + 1 + n, byfise);
dp[0][0] = 0;
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) {
if (dp[i][j] == -1) continue;
dp[i + 1][j] =
max(dp[i + 1][j], dp[i][j] + (k - 1) * A[i + 1].first.second);
dp[i + 1][j + 1] =
max(dp[i + 1][j + 1],
dp[i][j] + A[i + 1].first.first + j * A[i + 1].first.second);
}
}
backtrack();
for (int i = 1; i <= n; i++)
if (included[i]) {
ans.push_back(A[i].second);
}
int temp = ans.back();
ans.pop_back();
for (int i = 1; i <= n; i++) {
if (!included[i]) {
ans.push_back(A[i].second);
ans.push_back(-A[i].second);
}
}
ans.push_back(temp);
printf("%lu\n", ans.size());
for (int i = 0; i < ans.size(); i++)
printf("%d%c", ans[i], (i == ans.size() - 1) ? '\n' : ' ');
}
}
| 12 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int INF = int(1e9) + 7;
const int maxd = int(3e5) + 11;
const int maxe = int(3e5) + 11;
int tot = 0, topt = 0;
int head[maxd];
int S, T, e[210][210];
struct Edge {
int from, to, cap, cost, next;
Edge() {}
Edge(int x, int y, int a, int b, int c)
: from(x), to(y), cap(a), cost(b), next(c) {}
} eage[maxe * 2];
void add(int x, int y, int a, int b) {
e[x][y] = tot;
eage[tot] = Edge(x, y, a, b, head[x]), head[x] = tot++;
eage[tot] = Edge(y, x, 0, -b, head[y]), head[y] = tot++;
return;
}
bool used[maxd], vis[maxd];
int dis[maxd];
queue<int> que;
int ans = 0;
bool spfa() {
for (int i = 0; i < maxd; i++) used[i] = false, dis[i] = INF, vis[i] = false;
while (que.size()) que.pop();
que.push(S);
used[S] = true;
dis[S] = 0;
while (que.size()) {
int u = que.front();
que.pop();
used[u] = false;
for (int i = head[u]; ~i; i = eage[i].next)
if (eage[i].cap && dis[eage[i].to] > dis[u] + eage[i].cost) {
int v = eage[i].to;
dis[v] = dis[u] + eage[i].cost;
if (!used[v]) {
used[v] = true;
que.push(v);
}
}
}
return (dis[T] <= 0);
}
int dfs(int u, int flow) {
if (u == T) {
ans += dis[u] * flow;
return flow;
}
vis[u] = true;
int ret = 0;
for (int i = head[u]; ~i; i = eage[i].next)
if (!vis[eage[i].to] && eage[i].cap &&
dis[eage[i].to] == dis[u] + eage[i].cost) {
int v = eage[i].to;
int newf = dfs(v, min(flow, eage[i].cap));
eage[i].cap -= newf;
eage[i ^ 1].cap += newf;
ret += newf;
flow -= newf;
if (!flow) break;
}
if (!ret) dis[u] = -1;
return ret;
}
int MCMF() {
ans = 0;
while (spfa()) dfs(S, INF);
return ans;
}
int _, n, k, id[80], a[maxe], b[maxe], kid[80], aa[80];
void init() {
memset(head, -1, sizeof head);
memset(eage, 0, sizeof eage);
memset(id, 0, sizeof id);
memset(e, -1, sizeof e);
tot = 0;
topt = 0;
}
void solve() {
scanf("%d%d", &n, &k);
S = ++topt;
for (int i = 1; i <= n; i++) id[i] = ++topt;
for (int i = 1; i <= k + 1; i++) kid[i] = ++topt;
T = ++topt;
for (int i = 1; i <= n; i++) add(S, id[i], 1, 0);
for (int i = 1; i <= k; i++) add(kid[i], T, 1, 0);
add(kid[k + 1], T, n - k, 0);
for (int i = 1; i <= n; i++) scanf("%d%d", &a[i], &b[i]);
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= k; j++)
add(id[i], kid[j], 1, -(a[i] + b[i] * (j - 1)));
add(id[i], kid[k + 1], 1, -(b[i] * (k - 1)));
}
MCMF();
for (int i = 1; i <= n; i++)
for (int j = 1; j <= k; j++)
if (e[id[i]][kid[j]] != -1) {
if (eage[e[id[i]][kid[j]]].cap == 0) aa[j] = i;
}
printf("%d\n", n + (n - k));
for (int i = 1; i < k; i++) printf("%d ", aa[i]);
for (int i = 1; i <= n; i++)
if (eage[e[id[i]][kid[k + 1]]].cap == 0) printf("%d %d ", i, -i);
printf("%d\n", aa[k]);
return;
}
int main() {
scanf("%d", &_);
while (_--) init(), solve();
return 0;
}
| 12 | CPP |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using pii = pair<int, int>;
using pil = pair<int, ll>;
using pli = pair<ll, int>;
using pll = pair<ll, ll>;
const int MOD = 1000000007;
const int inf = (1 << 30) - 1;
const ll INF = (1LL << 60) - 1;
template <typename T>
bool chmax(T &x, const T &y) {
return (x < y) ? (x = y, true) : false;
};
template <typename T>
bool chmin(T &x, const T &y) {
return (x > y) ? (x = y, true) : false;
};
struct io_setup {
io_setup() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout << fixed << setprecision(15);
}
} io_setup;
int main() {
int T;
cin >> T;
while (T--) {
int N, K;
cin >> N >> K;
vector<pair<pll, int>> v;
for (int i = 0; i < N; i++) {
ll a, b;
cin >> a >> b;
v.emplace_back(pll(b, a), i);
}
sort(v.begin(), v.end());
vector<vector<pli>> dp(N + 1, vector<pli>(K + 1, pli(-INF, -1)));
dp[0][0] = pli(0, -1);
for (int i = 0; i < N; i++) {
for (int j = 0; j < K + 1; j++) {
auto [p, k] = dp[i][j];
if (p == -INF) continue;
ll np = p + v[i].first.first * (K - 1);
chmax(dp[i + 1][j], pli(np, k));
np = p + v[i].first.first * j + v[i].first.second;
if (j + 1 <= K) chmax(dp[i + 1][j + 1], pli(np, i));
}
}
vector<bool> used(N, false);
int ni = N, nj = K;
while (true) {
ni = dp[ni][nj].second;
if (ni == -1) break;
used[ni] = true;
nj--;
}
vector<int> rem;
for (int i = 0; i < N; i++)
if (used[i]) rem.emplace_back(i);
cout << 2 * N - K << '\n';
for (int i = 0; i < K - 1; i++) cout << v[rem[i]].second + 1 << ' ';
for (int i = 0; i < N; i++) {
if (!used[i]) cout << v[i].second + 1 << ' ' << -v[i].second - 1 << ' ';
}
cout << v[rem.back()].second + 1 << '\n';
}
}
| 12 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int N = 2e3 + 5;
int n, k;
struct node {
int id, a, b;
node(int i = 0, int _a = 0, int _b = 0) { id = i, a = _a, b = _b; }
bool operator<(const node& a) const { return b < a.b; }
} p[N];
long long dp[N][N];
int pre[N][N];
int main() {
int TTT;
cin >> TTT;
while (TTT--) {
cin >> n >> k;
long long ans = 0;
for (int i = (1); i < (n + 1); i++) {
cin >> p[i].a >> p[i].b;
p[i].id = i;
}
sort(p + 1, p + n + 1);
memset(dp, 0, sizeof(dp));
for (int i = (1); i < (n + 1); i++) {
dp[i][0] = dp[i - 1][0] + (long long)(k - 1) * p[i].b;
for (int j = (1); j < (i + 1); j++) {
long long x = dp[i - 1][j - 1] + (j - 1) * p[i].b + p[i].a;
long long y = 0;
if (i - 1 >= j) y = dp[i - 1][j] + (k - 1) * p[i].b;
dp[i][j] = max(x, y);
if (x > y)
pre[i][j] = j - 1;
else
pre[i][j] = j;
}
}
int u = k;
vector<int> p1, p2;
for (int i = n; i >= 1; --i) {
if (pre[i][u] == u) {
p2.push_back(p[i].id);
} else
u--, p1.push_back(p[i].id);
}
reverse(p1.begin(), p1.end());
reverse(p2.begin(), p2.end());
cout << (int)p1.size() + 2 * (int)p2.size() << "\n";
for (int i = (0); i < (k - 1); i++) cout << p1[i] << " ";
for (auto it : p2) cout << it << " " << -it << " ";
cout << p1[k - 1] << "\n";
}
return 0;
}
| 12 | CPP |
def read_int():
return int(input())
def read_ints():
return map(int, input().split(' '))
t = read_int()
for case_num in range(t):
n, k = read_ints()
p = []
for i in range(n):
ai, bi = read_ints()
p.append((bi, ai, i + 1))
p.sort()
dp = [[0 for j in range(k + 1)] for i in range(n + 1)]
use = [[False for j in range(k + 1)] for i in range(n + 1)]
for i in range(1, n + 1):
for j in range(min(i, k) + 1):
if i - 1 >= j:
dp[i][j] = dp[i - 1][j] + (k - 1) * p[i - 1][0]
if j > 0:
x = dp[i - 1][j - 1] + (j - 1) * p[i - 1][0] + p[i - 1][1]
if x > dp[i][j]:
dp[i][j] = x
use[i][j] = True
used = []
curr = k
for i in range(n, 0, -1):
if use[i][curr]:
used.append(p[i - 1][2])
curr -= 1
used.reverse()
seq = used[:-1]
st = set(used)
for i in range(1, n + 1):
if not i in st:
seq.append(i)
seq.append(-i)
seq.append(used[-1])
print(len(seq))
print(' '.join(map(str, seq)))
| 12 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
int f[80][80], g[80][80], n, m, is[80];
struct T {
int a, b, id;
} a[80];
void Solve() {
cin >> n >> m, memset(f, 0xc0, sizeof(f)), f[0][0] = 0;
for (int i = 1; i <= n; i++) cin >> a[i].a >> a[i].b, a[i].id = i, is[i] = 0;
sort(a + 1, a + n + 1, [](T i, T j) { return i.b < j.b; });
for (int i = 1; i <= n; i++) {
for (int j = 0; j <= m; j++) {
int t1 = (j ? f[i - 1][j - 1] + a[i].a + a[i].b * (j - 1) : -1e9),
t2 = f[i - 1][j] + a[i].b * (m - 1);
f[i][j] = max(t1, t2), g[i][j] = (t1 > t2);
}
}
for (int i = n, t = m; i && t; i--)
if (g[i][t]) is[i] = 1, t--;
cout << n * 2 - m << endl;
int pos = 0;
for (int i = 1, t = 0; i <= n; i++) {
if (!is[i]) continue;
if ((++t) == m) {
pos = a[i].id;
break;
}
cout << a[i].id << ' ';
}
for (int i = 1; i <= n; i++)
if (!is[i]) cout << a[i].id << ' ' << -a[i].id << ' ';
cout << pos << endl;
}
int main() {
int t;
cin >> t;
while (t--) Solve();
}
| 12 | CPP |
#include <bits/stdc++.h>
using namespace std;
template <class T>
ostream &operator<<(ostream &os, vector<T> V) {
os << "[ ";
for (auto v : V) os << v << " ";
os << "]";
return os;
}
template <class T>
ostream &operator<<(ostream &os, set<T> S) {
os << "{ ";
for (auto s : S) os << s << " ";
return os << "}";
}
template <class L, class R>
ostream &operator<<(ostream &os, map<L, R> M) {
os << "{ ";
for (auto m : M) os << "(" << m.first << ":" << m.second << ") ";
return os << "}";
}
template <class L, class R>
ostream &operator<<(ostream &os, pair<L, R> P) {
return os << "(" << P.first << "," << P.second << ")";
}
const long long N = 75;
long long n, k, dp[N][N], taken[N][N];
vector<pair<pair<long long, long long>, long long>> p;
vector<long long> v1, v2;
bool compare(pair<pair<long long, long long>, long long> &a,
pair<pair<long long, long long>, long long> &b) {
if (a.first.second != b.first.second) return a.first.second < b.first.second;
return a.first.first < b.first.first;
}
bool compare1(long long a, long long b) {
return p[a].first.first < p[b].first.first;
}
long long rec(long long in, long long done) {
if (in == n) {
if (done == k) return 0;
return -1e18;
}
if (dp[in][done] != -1) return dp[in][done];
long long x = (k - 1) * p[in].first.second + rec(in + 1, done);
taken[in][done] = 0;
if (done < k) {
if (done * p[in].first.second + p[in].first.first + rec(in + 1, done + 1) >
x)
taken[in][done] = 1,
x = done * p[in].first.second + p[in].first.first + rec(in + 1, done + 1);
}
return dp[in][done] = x;
}
void restore(long long in, long long done) {
if (in == n) return;
if (taken[in][done] == 1)
v1.push_back(in), restore(in + 1, done + 1);
else
v2.push_back(in), restore(in + 1, done);
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
long long t;
cin >> t;
while (t--) {
cin >> n >> k;
p.clear();
p.resize(n);
for (long long i = 0; i < n; i++)
cin >> p[i].first.first >> p[i].first.second, p[i].second = i + 1;
sort(p.begin(), p.end(), compare);
memset(dp, -1, sizeof(dp));
v1.clear(), v2.clear();
rec(0, 0);
restore(0, 0);
vector<long long> ans;
sort(v2.begin(), v2.end(), compare1);
for (long long i = 0; i < v1.size() - 1; i++)
ans.push_back(p[v1[i]].second);
if (v1.size() == 1) ans.push_back(p[v1[0]].second);
if (v1.size() > 1 || (v1.size() == 1 && k > 1))
for (long long i = 0; i < v2.size(); i++)
ans.push_back(p[v2[i]].second), ans.push_back(-p[v2[i]].second);
if (v1.size() > 1) ans.push_back(p[v1.back()].second);
cout << ans.size() << '\n';
for (auto it : ans) cout << it << ' ';
cout << '\n';
}
return 0;
}
| 12 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int N = 2 * 1e4 + 100, M = 81;
int T, n, k, a[M], b[M], ans, p[M], in[M];
int s, t, d[N], pe[N], pn[N], flow[N], vi[N];
int tot, first[N], nxt[N * 2], point[N * 2], data[N * 2], cost[N * 2];
inline int read() {
int f = 1, x = 0;
char s = getchar();
while (s < '0' || s > '9') {
if (s == '-') f = -1;
s = getchar();
}
while (s >= '0' && s <= '9') {
x = x * 10 + s - '0';
s = getchar();
}
return x * f;
}
inline void add_edge(int x, int y, int z, int h) {
nxt[++tot] = first[x], first[x] = tot;
point[tot] = y, data[tot] = z, cost[tot] = h;
nxt[++tot] = first[y], first[y] = tot;
point[tot] = x, data[tot] = 0, cost[tot] = -h;
}
bool spfa(int t) {
queue<int> q;
for (int i = 0; i <= t; i++) d[i] = 0x3f3f3f3f, flow[i] = 0;
d[s] = 0;
vi[s] = 1;
q.push(s);
flow[s] = 0x3f3f3f3f;
while (!q.empty()) {
int x = q.front();
q.pop();
vi[x] = 0;
for (int i = first[x]; i != -1; i = nxt[i]) {
int u = point[i];
if (data[i] && d[u] > d[x] + cost[i]) {
d[u] = d[x] + cost[i];
pn[u] = x, pe[u] = i, flow[u] = min(flow[x], data[i]);
if (!vi[u]) vi[u] = 1, q.push(u);
}
}
}
if (!flow[t]) return 0;
int x = t;
while (x != s) {
data[pe[x]] -= flow[t];
data[pe[x] ^ 1] += flow[t];
x = pn[x];
}
return 1;
}
signed main() {
T = read();
while (T--) {
tot = -1;
ans = 0;
memset(first, -1, sizeof(first));
n = read();
k = read();
for (int i = 1; i <= n; i++) a[i] = read(), b[i] = read();
s = 0;
t = n + k + 1;
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= k; j++) add_edge(i, j + n, 1, (k - j) * b[i] - a[i]);
}
for (int i = 1; i <= n; i++) add_edge(s, i, 1, 0);
for (int i = 1; i <= k; i++) add_edge(i + n, t, 1, 0);
while (spfa(t))
;
memset(p, 0, sizeof(p));
memset(in, 0, sizeof(in));
for (int i = 0; i <= tot; i += 2) {
if (point[i] == s || point[i] == t || point[i ^ 1] == s ||
point[i ^ 1] == t || data[i])
continue;
int u = point[i], v = point[i ^ 1];
if (u > v) swap(u, v);
v -= n;
p[v] = u;
in[u] = 1;
}
printf("%d\n", 2 * n - k);
for (int i = 1; i < k; i++) printf("%d ", p[i]);
for (int i = 1; i <= n; i++)
if (!in[i]) printf("%d %d ", i, -i);
printf("%d\n", p[k]);
}
}
| 12 | CPP |
#include <bits/stdc++.h>
using namespace std;
using lld = long long;
const int INF = 1e9;
const int MAXN = 75;
struct Minion {
int a, b;
int nr;
};
bool operator<(const Minion& a, const Minion& b) {
if (a.b != b.b) return a.b < b.b;
return a.nr < b.nr;
}
int dp[MAXN + 5][MAXN + 5];
void query(void) {
int n, k;
cin >> n >> k;
vector<Minion> t(n);
for (int i = 0; i < n; i++) {
cin >> t[i].a >> t[i].b;
t[i].nr = i + 1;
}
sort(t.begin(), t.end());
for (int i = 0; i <= n; i++)
for (int j = 0; j <= k; j++) dp[i][j] = -INF;
dp[0][0] = 0;
for (int i = 0; i < n; i++) {
for (int j = 0; j <= k; j++)
dp[i + 1][j] = max(dp[i + 1][j], dp[i][j] + t[i].b * (k - 1));
for (int j = 1; j <= k; j++)
dp[i + 1][j] =
max(dp[i + 1][j], dp[i][j - 1] + t[i].a + t[i].b * (j - 1));
}
vector<int> res, rem;
int x = n, y = k;
while (x > 0) {
if (y > 0 &&
dp[x][y] == dp[x - 1][y - 1] + t[x - 1].a + t[x - 1].b * (y - 1)) {
res.push_back(t[x - 1].nr);
x--, y--;
} else {
rem.push_back(t[x - 1].nr);
x--;
}
}
reverse(res.begin(), res.end());
cout << 2 * n - k << "\n";
for (int i = 0; i < k - 1; i++) cout << res[i] << " ";
for (int i : rem) cout << i << " " << -i << " ";
cout << res.back() << "\n";
}
int main(void) {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
int q;
cin >> q;
while (q--) query();
return 0;
}
| 12 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int N = 0, M = 0;
int read() {
char c;
int num, f = 1;
while (c = getchar(), !isdigit(c))
if (c == '-') f = -1;
num = c - '0';
while (c = getchar(), isdigit(c)) num = num * 10 + c - '0';
return num * f;
}
struct node {
int a, b, id;
} p[109];
int n, k, f[109][109], ans[109][109], vis[109];
bool cmp(node x, node y) { return x.b < y.b; }
void work() {
n = read();
k = read();
for (int i = 1; i <= n; i++) {
p[i].a = read();
p[i].b = read();
p[i].id = i;
}
sort(p + 1, p + 1 + n, cmp);
memset(f, 0x3f3f, sizeof(f));
f[0][0] = 0;
for (int i = 1; i <= n; i++) {
for (int j = 0; j <= i && j <= k; j++) {
if (f[i - 1][j] < f[i][j]) {
ans[i][j] = 0;
f[i][j] = f[i - 1][j];
}
if (j && f[i - 1][j - 1] + (k - j) * p[i].b - p[i].a < f[i][j]) {
ans[i][j] = 1;
f[i][j] = f[i - 1][j - 1] + (k - j) * p[i].b - p[i].a;
}
}
}
printf("%d\n", k + 2 * (n - k));
int sum = k;
for (int i = n; i; i--) {
vis[i] = ans[i][sum];
sum -= ans[i][sum];
}
for (int i = 1, now = 1; i < k; i++) {
while (!vis[now]) now++;
printf("%d ", p[now++].id);
}
for (int i = 1; i <= n; i++)
if (!vis[i]) printf("%d %d ", p[i].id, -p[i].id);
for (int i = n; i; i--)
if (vis[i]) {
printf("%d\n", p[i].id);
break;
}
}
int main() {
int Case = read();
while (Case--) work();
return 0;
}
| 12 | CPP |
#include <bits/stdc++.h>
using namespace std;
const double pi = 2 * acos(0.0);
const int dx[] = {-1, 0, 1, 0};
const int dy[] = {0, -1, 0, 1};
const int dx8[] = {-1, 0, 1, 0, 1, 1, -1, -1};
const int dy8[] = {0, -1, 0, 1, 1, -1, 1, -1};
long long min(long long a, long long b) {
if (a < b) return a;
return b;
}
long long max(long long a, long long b) {
if (a > b) return a;
return b;
}
long long ceil1(long long a, long long b) { return (a + b - 1) / b; }
template <class Cap, class Cost>
struct mcf_graph {
private:
int _n;
struct _edge {
int to, rev;
Cap cap;
Cost cost;
};
vector<pair<int, int>> pos;
vector<vector<_edge>> g;
vector<Cost> h;
vector<Cost> dist;
vector<int> pv, pe;
vector<bool> vis;
void norm(int s, int t) {
h.resize(_n, numeric_limits<Cost>::max());
h[s] = 0;
int ch = 1;
int it = _n;
while (ch-- && it--) {
for (int i = 0; i < _n; i++) {
if (h[i] == numeric_limits<Cost>::max()) continue;
for (auto e : g[i]) {
if (e.cap == 0) continue;
if (h[i] + e.cost < h[e.to]) {
h[e.to] = h[i] + e.cost;
ch = 1;
}
}
}
assert(it >= 0);
}
for (int i = 0; i < _n; i++) h[i] -= h[t];
}
bool dijkstra(int s, int t) {
pv.clear();
pe.clear();
vis.clear();
dist.clear();
dist.resize(_n, numeric_limits<Cost>::max());
pv.resize(_n, -1);
pe.resize(_n, -1);
vis.resize(_n, false);
priority_queue<pair<Cost, int>, vector<pair<Cost, int>>,
greater<pair<Cost, int>>>
pq;
pq.push({0, s});
dist[s] = 0;
while (!pq.empty()) {
int x = pq.top().second;
pq.pop();
if (vis[x]) continue;
vis[x] = true;
if (x == t) break;
for (int i = 0; i < int(g[x].size()); ++i) {
auto e = g[x][i];
if (vis[e.to] || e.cap == 0) continue;
Cost cost = e.cost + h[x] - h[e.to];
if (dist[e.to] <= dist[x] + cost) continue;
dist[e.to] = dist[x] + cost;
pv[e.to] = x;
pe[e.to] = i;
pq.push({dist[e.to], e.to});
}
}
if (vis[t] == false) return false;
for (int i = 0; i < _n; ++i) {
if (!vis[i]) continue;
h[i] -= dist[t] - dist[i];
}
return true;
}
public:
mcf_graph() {}
mcf_graph(int n) : _n(n), g(n) {}
int add_edge(int from, int to, Cap cap, Cost cost) {
assert(from >= 0 && from < _n);
assert(to >= 0 && to < _n);
int m = int(pos.size());
pos.push_back({from, int(g[from].size())});
int from_id = int(g[from].size());
int to_id = int(g[to].size());
if (from == to) to_id++;
g[from].push_back(_edge{to, to_id, cap, cost});
g[to].push_back(_edge{from, from_id, 0, -cost});
return m;
}
struct edge {
int from, to;
Cap cap, flow;
Cost cost;
};
edge get_edge(int i) {
int m = int(pos.size());
assert(0 <= i && i < m);
auto _e = g[pos[i].first][pos[i].second];
auto _re = g[_e.to][_e.rev];
return edge{
pos[i].first, _e.to, _e.cap + _re.cap, _re.cap, _e.cost,
};
}
vector<edge> edges() {
int m = int(pos.size());
vector<edge> result(m);
for (int i = 0; i < m; ++i) result[i] = get_edge(i);
return result;
}
pair<Cap, Cost> flow(int s, int t, bool neg = false) {
return flow(s, t, numeric_limits<Cap>::max(), neg);
}
pair<Cap, Cost> flow(int s, int t, Cap flow_limit, bool neg = false) {
return slope(s, t, flow_limit, neg).back();
}
vector<pair<Cap, Cost>> slope(int s, int t, bool neg = false) {
return slope(s, t, numeric_limits<Cap>::max(), neg);
}
vector<pair<Cap, Cost>> slope(int s, int t, Cap flow_limit,
bool neg = false) {
assert(s >= 0 && s < _n);
assert(t >= 0 && t < _n);
assert(s != t);
h.clear();
if (!neg)
h.resize(_n, 0);
else
norm(s, t);
Cap flow = 0;
Cost cost = 0, prev = -1;
vector<pair<Cap, Cost>> result;
result.push_back({flow, cost});
while (flow < flow_limit) {
if (dijkstra(s, t) == false) break;
Cap c = flow_limit - flow;
for (int i = t; i != s; i = pv[i]) {
c = min(c, g[pv[i]][pe[i]].cap);
}
for (int i = t; i != s; i = pv[i]) {
auto& e = g[pv[i]][pe[i]];
e.cap -= c;
g[e.to][e.rev].cap += c;
}
Cost d = -h[s];
flow += c;
cost += c * d;
if (prev == d) result.pop_back();
result.push_back({flow, cost});
prev = d;
}
return result;
}
};
void solve() {
int n, k;
cin >> n >> k;
vector<pair<long long, long long>> info;
for (long long i = 0; i < n; i++) {
long long x, y;
cin >> x >> y;
info.push_back({x, y});
}
vector<vector<long long>> arr(n, vector<long long>(n));
for (long long i = 0; i < n; i++) {
for (long long j = 0; j < n; j++) {
if (j < k)
arr[i][j] = info[i].first + j * info[i].second;
else
arr[i][j] = (k - 1) * info[i].second;
}
}
long long inf = INT_MAX / 10;
mcf_graph<long long, long long> g(2 * n + 2);
long long s = 2 * n, t = 2 * n + 1;
for (long long i = 0; i < n; i++) {
g.add_edge(s, i, 1, 0);
g.add_edge(i + n, t, 1, 0);
}
long long cur = 2 * n;
for (long long i = 0; i < n; i++)
for (long long j = 0; j < n; j++) g.add_edge(i, j + n, 1, inf - arr[i][j]);
auto x = g.flow(s, t);
auto edge = g.edges();
vector<long long> assignment(n);
for (long long i = 0; i < n; i++)
for (long long j = 0; j < n; j++) {
if (edge[cur].flow == 1) assignment[j] = i + 1;
cur++;
}
cout << 2 * n - k << '\n';
for (long long i = 0; i < k - 1; i++) cout << assignment[i] << " ";
for (long long i = k; i < n; i++)
cout << assignment[i] << " " << -1 * assignment[i] << " ";
cout << assignment[k - 1] << '\n';
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int t;
cin >> t;
while (t--) solve();
}
| 12 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int Maxn = 88;
struct node {
int a, b, id;
} g[Maxn];
int f[Maxn][Maxn], s[Maxn];
bool flag[Maxn][Maxn], vis[Maxn];
int a[Maxn], b[Maxn], id[Maxn];
int n, m, cnt;
inline bool cmp(node x, node y) { return x.b < y.b; }
void init() {
for (int i = 1; i <= n; ++i)
for (int j = 0; j <= m; ++j) f[i][j] = flag[i][j] = 0;
for (int i = 1; i <= n; ++i) s[i] = vis[i] = a[i] = b[i] = id[i] = 0;
cnt = n = m = 0;
}
inline int read() {
int s = 0, w = 1;
char ch = getchar();
while (ch < '0' || ch > '9') {
if (ch == '-') w = -1;
ch = getchar();
}
while (ch >= '0' && ch <= '9')
s = (s << 3) + (s << 1) + (ch ^ 48), ch = getchar();
return s * w;
}
int main() {
int T = read();
while (T--) {
n = read(), m = read();
for (int i = 1; i <= n; ++i) g[i].a = read(), g[i].b = read(), g[i].id = i;
sort(g + 1, g + 1 + n, cmp);
for (int i = 1; i <= n; ++i) a[i] = g[i].a, b[i] = g[i].b, id[i] = g[i].id;
memset(f, 0xcf, sizeof(f));
f[0][0] = 0;
for (int i = 1; i <= n; ++i)
for (int j = 0; j <= min(i, m); ++j) {
f[i][j] = f[i - 1][j] + b[i] * (m - 1), flag[i][j] = 0;
if (j && f[i - 1][j - 1] + a[i] + b[i] * (j - 1) > f[i][j])
f[i][j] = f[i - 1][j - 1] + a[i] + b[i] * (j - 1), flag[i][j] = 1;
}
int i = n, j = m;
while (i) {
if (flag[i][j]) s[++cnt] = i, vis[i] = 1, --j;
--i;
}
printf("%d\n", m - 1 + ((n - m) << 1) + 1);
int last = 0;
for (int i = 1; i <= n; ++i) {
if (!vis[i]) continue;
if (++last == m) {
last = i;
break;
}
printf("%d ", id[i]);
}
for (int i = 1; i <= n; ++i)
if (!vis[i]) printf("%d %d ", id[i], -id[i]);
printf("%d\n", id[last]);
init();
}
return 0;
}
| 12 | CPP |
#include <bits/stdc++.h>
using namespace std;
using vi = vector<long long>;
using vvi = vector<vi>;
using vvvi = vector<vvi>;
using vvvvi = vector<vvvi>;
using vp = vector<pair<long long, long long> >;
using vvp = vector<vp>;
using vb = vector<bool>;
using vvb = vector<vb>;
const long long inf = 1001001001001001001;
const long long INF = 1001001001;
const long long mod = 1000000007;
const double eps = 1e-10;
template <class T>
bool chmin(T& a, T b) {
if (a > b) {
a = b;
return true;
}
return false;
}
template <class T>
bool chmax(T& a, T b) {
if (a < b) {
a = b;
return true;
}
return false;
}
template <class T>
void out(T a) {
cout << a << '\n';
}
template <class T>
void outp(T a) {
cout << '(' << a.first << ',' << a.second << ')' << '\n';
}
template <class T>
void outvp(T v) {
for (long long i = 0; i < (long long)(v.size()); i++)
cout << '(' << v[i].first << ',' << v[i].second << ')';
cout << '\n';
}
template <class T>
void outvvp(T v) {
for (long long i = 0; i < (long long)(v.size()); i++) outvp(v[i]);
}
template <class T>
void outv(T v) {
for (long long i = 0; i < (long long)(v.size()); i++) {
if (i) cout << ' ';
cout << v[i];
}
cout << '\n';
}
template <class T>
void outvv(T v) {
for (long long i = 0; i < (long long)(v.size()); i++) outv(v[i]);
}
template <class T>
bool isin(T x, T l, T r) {
return (l) <= (x) && (x) <= (r);
}
template <class T>
void yesno(T b) {
if (b)
out("yes");
else
out("no");
}
template <class T>
void YesNo(T b) {
if (b)
out("Yes");
else
out("No");
}
template <class T>
void YESNO(T b) {
if (b)
out("YES");
else
out("NO");
}
template <class T>
void noyes(T b) {
if (b)
out("no");
else
out("yes");
}
template <class T>
void NoYes(T b) {
if (b)
out("No");
else
out("Yes");
}
template <class T>
void NOYES(T b) {
if (b)
out("NO");
else
out("YES");
}
void outs(long long a, long long b) {
if (a >= inf - 100)
out(b);
else
out(a);
}
long long gcd(long long a, long long b) {
if (b == 0) return a;
return gcd(b, a % b);
}
long long modpow(long long a, long long b) {
long long res = 1;
a %= mod;
while (b) {
if (b & 1) res = res * a % mod;
a = a * a % mod;
b >>= 1;
}
return res;
}
int main() {
long long t;
cin >> t;
for (long long tt = 0; tt < (long long)(t); tt++) {
long long n, k;
cin >> n >> k;
vp v(n);
for (long long i = 0; i < (long long)(n); i++)
cin >> v[i].first >> v[i].second;
vp s(n);
for (long long i = 0; i < (long long)(n); i++)
s[i] = pair<long long, long long>(v[i].second, i);
sort(s.begin(), s.end());
reverse(s.begin(), s.end());
if (k == 1) {
out(1);
long long res = 0;
for (long long i = 0; i < (long long)(n); i++) chmax(res, v[i].first);
for (long long i = 0; i < (long long)(n); i++)
if (v[i].first == res) {
out(i + 1);
break;
}
continue;
}
vvi dp(n + 1, vi(k + 1, -inf));
dp[0][0] = 0;
for (long long i = 0; i < (long long)(n); i++) {
long long id = s[i].second;
for (long long j = 0; j < (long long)(k + 1); j++) {
if (dp[i][j] == -inf) continue;
chmax(dp[i + 1][j], dp[i][j] + v[id].second * (k - 1));
if (j != k)
chmax(dp[i + 1][j + 1],
dp[i][j] + v[id].first + v[id].second * (k - 1 - j));
}
}
vi ans, b;
long long c;
long long t = k;
for (int i = n; i; i--) {
long long id = s[i - 1].second;
if (dp[i - 1][t] + v[id].second * (k - 1) == dp[i][t])
b.emplace_back(id + 1);
else {
if (t == 1)
c = id + 1;
else
ans.emplace_back(id + 1);
t--;
}
}
for (long long x : b) {
ans.emplace_back(x);
ans.emplace_back(-x);
}
ans.emplace_back(c);
out(ans.size());
outv(ans);
}
}
| 12 | CPP |
#include <bits/stdc++.h>
using namespace std;
int gcd(int a, int b) {
if (b == 0) return a;
return gcd(b, a % b);
}
int n, k, tab[75][75], d, linkx[75], linky[75], tx[75], ty[75];
bool visx[75], visy[75];
bool dfs(int x) {
visx[x] = true;
for (int i = 0; i < n; i++) {
if (!visy[i] && tx[x] + ty[i] == tab[x][i]) {
visy[i] = true;
if (linky[i] == -1 || dfs(linky[i])) {
linkx[x] = i, linky[i] = x;
return true;
}
}
}
return false;
}
void update() {
d = 1e7;
for (int i = 0; i < n; i++) {
if (!visx[i]) continue;
for (int j = 0; j < n; j++) {
if (visy[j]) continue;
d = min(d, tx[i] + ty[j] - tab[i][j]);
}
}
for (int i = 0; i < n; i++)
if (visx[i]) tx[i] -= d;
for (int i = 0; i < n; i++)
if (visy[i]) ty[i] += d;
return;
}
signed main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
int t;
cin >> t;
while (t--) {
cin >> n >> k;
pair<int, int> ar[n];
memset(linkx, -1, sizeof(linkx));
memset(linky, -1, sizeof(linky));
memset(ty, 0, sizeof(ty));
for (int i = 0; i < n; i++) cin >> ar[i].first >> ar[i].second;
for (int i = 0; i < k; i++) {
for (int j = 0; j < n; j++) {
tab[j][i] = ar[j].first + ar[j].second * i;
}
}
for (int i = 0; i < n; i++) tx[i] = tab[i][k - 1];
for (int i = k; i < n; i++) {
for (int j = 0; j < n; j++) tab[j][i] = ar[j].second * (k - 1);
}
for (int i = 0; i < n; i++) {
while (!dfs(i)) {
update();
memset(visx, 0, sizeof(visx));
memset(visy, 0, sizeof(visy));
}
}
int ans[75];
for (int i = 0; i < n; i++) {
ans[linkx[i]] = i;
}
cout << n * 2 - k << '\n';
for (int i = 0; i < k - 1; i++) cout << ans[i] + 1 << " ";
for (int i = k; i < n; i++) cout << ans[i] + 1 << " " << -ans[i] - 1 << " ";
cout << ans[k - 1] + 1 << '\n';
}
return 0;
}
| 12 | CPP |
#include <bits/stdc++.h>
using namespace std;
int a[75];
int b[75];
int order[75];
int main() {
cin.tie(0);
ios_base::sync_with_stdio(0);
int t;
cin >> t;
while (t--) {
int n, k;
cin >> n >> k;
for (int i = 0; i < n; ++i) cin >> a[i] >> b[i], order[i] = i;
sort(order, order + n, [&](int x, int y) {
if (b[x] == b[y])
return a[x] > a[y];
else
return b[x] < b[y];
});
vector<vector<int>> dp(n + 1, vector<int>(n + 1, -1e9));
dp[0][0] = 0;
for (int ii = 1; ii <= n; ++ii) {
int i = order[ii - 1];
for (int j = max(0, k - (n - ii)); j <= min(ii, k); ++j) {
dp[ii][j] = dp[ii - 1][j] + b[i] * (k - 1);
if (j)
dp[ii][j] = max(dp[ii][j], dp[ii - 1][j - 1] + a[i] + b[i] * (j - 1));
}
}
vector<int> ans;
int cur = k;
int last = -1;
for (int i = n; i >= 1; i--) {
if (cur &&
(dp[i - 1][cur - 1] + a[order[i - 1]] + b[order[i - 1]] * (cur - 1) >=
dp[i - 1][cur] + b[order[i - 1]] * (k - 1) ||
cur + (n - i) < k)) {
if (last == -1)
last = order[i - 1] + 1;
else
ans.push_back(order[i - 1] + 1);
cur--;
} else {
ans.push_back(-order[i - 1] - 1);
}
}
reverse(ans.begin(), ans.end());
vector<int> ans2;
for (auto q : ans)
if (q > 0) ans2.push_back(q);
for (auto q : ans)
if (q < 0) ans2.push_back(-q), ans2.push_back(q);
ans2.push_back(last);
cout << ans2.size() << endl;
for (auto q : ans2) cout << q << " ";
cout << endl;
}
return 0;
}
| 12 | CPP |
#include <bits/stdc++.h>
using namespace std;
void __print(int x) { cout << x; }
void __print(long x) { cout << x; }
void __print(long long x) { cout << x; }
void __print(unsigned x) { cout << x; }
void __print(unsigned long x) { cout << x; }
void __print(unsigned long long x) { cout << x; }
void __print(float x) { cout << x; }
void __print(double x) { cout << x; }
void __print(long double x) { cout << x; }
void __print(char x) { cout << '\'' << x << '\''; }
void __print(const char *x) { cout << '\"' << x << '\"'; }
void __print(const string &x) { cout << '\"' << x << '\"'; }
void __print(bool x) { cout << (x ? "true" : "false"); }
template <typename T, typename V>
void __print(const pair<T, V> &x) {
cout << '{';
__print(x.first);
cout << ',';
__print(x.second);
cout << '}';
}
template <typename T>
void __print(const T &x) {
int f = 0;
cout << '{';
for (auto &i : x) cout << (f++ ? "," : ""), __print(i);
cout << "}";
}
void _print() { cout << "]\n"; }
template <typename T, typename... V>
void _print(T t, V... v) {
__print(t);
if (sizeof...(v)) cout << ", ";
_print(v...);
}
long long mod = 1e9 + 7;
int main() {
cin.sync_with_stdio(0);
cin.tie(0);
int T = 1;
cin >> T;
while (T--) {
long long n, k;
cin >> n >> k;
vector<long long> a(n);
vector<pair<long long, long long> > b(n);
for (int i = 0; i < (n); i++) {
b[i].second = i;
cin >> a[i] >> b[i].first;
}
sort(b.begin(), b.end());
long long dp[n + 1][k + 1];
memset(dp, -1, sizeof(dp));
dp[0][0] = 0;
for (int i = (1); i <= (n); i++) {
dp[i][0] = dp[i - 1][0] + (k - 1) * b[i - 1].first;
for (int j = (1); j <= (k); j++) {
if (dp[i - 1][j] != -1)
dp[i][j] = dp[i - 1][j] + (k - 1) * b[i - 1].first;
if (dp[i - 1][j - 1] != -1)
dp[i][j] = max(dp[i][j], dp[i - 1][j - 1] + (j - 1) * b[i - 1].first +
a[b[i - 1].second]);
}
}
long long i = n, j = k;
vector<int> final, vis(n + 1, 0);
while (j > 0) {
if (dp[i][j] ==
dp[i - 1][j - 1] + (j - 1) * b[i - 1].first + a[b[i - 1].second]) {
final.push_back(b[i - 1].second + 1);
vis[b[i - 1].second + 1] = 1;
j--;
}
i--;
}
cout << k + (n - k) * 2 << '\n';
for (int i = 0; i < (k - 1); i++) cout << final[k - 1 - i] << " ";
for (int i = (1); i <= (n); i++)
if (!vis[i]) cout << i << " " << -i << " ";
cout << final[0] << '\n';
}
return 0;
}
| 12 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 80;
int n, m;
int a[maxn], b[maxn], id[maxn];
int f[maxn][maxn], g[maxn][maxn];
bool used[maxn];
inline int read() {
char c = getchar();
int res = 0, f = 1;
while (c < '0' || c > '9') {
if (c == '-') f = -1;
c = getchar();
}
while (c >= '0' && c <= '9') res = res * 10 + c - '0', c = getchar();
return res * f;
}
inline bool cmp(int x, int y) { return b[x] < b[y]; }
void dfs(int n, int m) {
if (!n) return;
if (g[n][m]) used[n] = 1, m--;
dfs(n - 1, m);
}
inline void solve() {
n = read(), m = read();
for (int i = 1; i <= n; i++) a[i] = read(), b[i] = read(), id[i] = i;
sort(id + 1, id + n + 1, cmp);
memset(f, 0xcf, sizeof(f));
memset(g, 0, sizeof(g));
f[0][0] = 0;
for (int i = 1; i <= n; i++)
for (int j = 0; j <= min(i, m); j++) {
f[i][j] = f[i - 1][j] + b[id[i]] * (m - 1), g[i][j] = 0;
if (j && f[i - 1][j - 1] + a[id[i]] + b[id[i]] * (j - 1) > f[i][j])
f[i][j] = f[i - 1][j - 1] + a[id[i]] + b[id[i]] * (j - 1), g[i][j] = 1;
}
memset(used, 0, sizeof(used));
dfs(n, m);
printf("%d\n", m - 1 + (n - m) * 2 + 1);
int last = 0;
for (int i = 1; i <= n; i++) {
if (!used[i]) continue;
last++;
if (last == m) {
last = id[i];
break;
}
printf("%d ", id[i]);
}
for (int i = 1; i <= n; i++) {
if (used[i]) continue;
printf("%d %d ", id[i], -id[i]);
}
printf("%d\n", last);
}
int main() {
int T = read();
while (T--) solve();
return 0;
}
| 12 | CPP |
#include <bits/stdc++.h>
const int MAXN = 105;
const long long INF = (long long)1e18 + 5;
using namespace std;
struct Mon {
long long a, b, id;
bool operator<(const Mon &m) const { return b < m.b; }
};
long long n;
Mon mon[MAXN];
long long dp[MAXN][MAXN], from[MAXN][MAXN];
vector<int> ans;
long long solve(int take) {
for (int i = 0; i <= n; i++) {
for (int j = 0; j <= n; j++) {
dp[i][j] = -INF;
}
}
dp[0][0] = 0;
for (long long i = 0; i < n; i++) {
for (long long j = 0; j <= n; j++) {
if (dp[i][j] == -INF) continue;
if (j < n) {
long long prof = dp[i][j] + mon[i + 1].a + j * mon[i + 1].b;
if (dp[i + 1][j + 1] < prof) {
dp[i + 1][j + 1] = prof;
from[i + 1][j + 1] = 1;
}
}
long long prof = dp[i][j] + (take - 1) * mon[i + 1].b;
if (dp[i + 1][j] < prof) {
dp[i + 1][j] = prof;
from[i + 1][j] = 0;
}
}
}
int cur = take;
vector<int> yes, no;
for (int i = n; i >= 1; i--) {
if (from[i][cur]) {
yes.push_back(mon[i].id);
cur--;
} else {
no.push_back(mon[i].id);
}
}
reverse(yes.begin(), yes.end());
ans.clear();
for (int i = 0; i < take - 1; i++) {
ans.push_back(yes[i]);
}
for (int x : no) {
ans.push_back(x);
ans.push_back(-x);
}
ans.push_back(yes.back());
return dp[n][take];
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
int tc;
cin >> tc;
while (tc--) {
int k;
cin >> n >> k;
for (int i = 1; i <= n; i++) {
int a, b;
cin >> a >> b;
mon[i] = {a, b, i};
}
long long best = 0, who = 0;
sort(mon + 1, mon + 1 + n);
for (int i = 1; i <= k; i++) {
long long val = solve(i);
if (val > best) {
best = val;
who = i;
}
}
solve(who);
cout << ans.size() << '\n';
for (int i = 0; i < ans.size(); i++) {
cout << ans[i] << " \n"[i + 1 == ans.size()];
}
}
}
| 12 | CPP |
#include <bits/stdc++.h>
using namespace std;
template <typename T>
inline bool cmax(T &x, T y) {
return x < y ? x = y, 1 : 0;
}
template <typename T>
inline bool cmin(T &x, T y) {
return y < x ? x = y, 1 : 0;
}
const int _ = 105;
struct node {
int a, b, i;
bool operator<(const node &t) const { return b < t.b; }
} w[_];
int T, N, K;
int f[_][_], s1[_], s2[_], n, m;
void work(int i, int j) {
if (i == 0) return;
if (f[i][j] == f[i - 1][j] + (K - 1) * w[i].b)
s2[++m] = w[i].i, work(i - 1, j);
else
s1[++n] = w[i].i, work(i - 1, j - 1);
}
int main() {
ios::sync_with_stdio(0), cin.tie(0);
cin >> T;
while (T--) {
cin >> N >> K;
for (int i(1), I(N); i <= I; ++i) cin >> w[i].a >> w[i].b, w[i].i = i;
sort(w + 1, w + N + 1);
memset(f, 0xf7, sizeof f), f[0][0] = 0;
for (int i(1), I(N); i <= I; ++i)
for (int j(0), I(min(i, K)); j <= I; ++j)
f[i][j] = max(j ? f[i - 1][j - 1] + w[i].a + (j - 1) * w[i].b : -1,
f[i - 1][j] + (K - 1) * w[i].b);
n = m = 0, work(N, K), reverse(s1 + 1, s1 + n + 1);
cout << (n + (m << 1)) << endl;
for (int i(1), I(n - 1); i <= I; ++i) cout << s1[i] << " ";
for (int i(1), I(m); i <= I; ++i) cout << s2[i] << " " << -s2[i] << " ";
cout << s1[n] << endl;
}
return 0;
}
| 12 | CPP |
#include <bits/stdc++.h>
using namespace std;
struct pii {
int first, second, id;
};
const int N = 76, INF = (int)1e9;
int n, k;
pii p[N];
int dp[N][N], tk[N][N];
int main() {
ios::sync_with_stdio(false);
cin.tie(NULL);
int T;
cin >> T;
while (T--) {
cin >> n >> k;
for (int i = 1; i < (n + 1); ++i)
cin >> p[i].first >> p[i].second, p[i].id = i;
sort(p + 1, p + n + 1,
[](const pii &p1, const pii &p2) { return p1.second < p2.second; });
for (int i = 0; i < (n + 1); ++i) fill(dp[i], dp[i] + n + 1, -INF);
dp[0][0] = 0;
for (int i = 1; i <= n; i++) {
for (int j = 0; j <= k; j++) {
if (j >= 1) {
int take_dp = dp[i - 1][j - 1] + (j - 1) * p[i].second + p[i].first;
if (take_dp > dp[i][j]) {
dp[i][j] = take_dp;
tk[i][j] = 1;
}
}
int not_dp = dp[i - 1][j] + (k - 1) * p[i].second;
if (not_dp > dp[i][j]) {
dp[i][j] = not_dp;
tk[i][j] = 0;
}
}
}
vector<int> take, not_take;
int cur = k;
for (int i = n; i >= 1; i--) {
(tk[i][cur] ? take : not_take).push_back(p[i].id);
cur -= tk[i][cur];
}
reverse(begin(take), end(take));
cout << take.size() + not_take.size() * 2 << '\n';
for (int i = 0; i < k - 1; i++) cout << take[i] << " ";
for (auto x : not_take) cout << x << " " << -x << " ";
cout << take[k - 1] << '\n';
}
}
| 12 | CPP |
#include <bits/stdc++.h>
using namespace std;
struct min_cost_flow {
static const int64_t INF = numeric_limits<int64_t>::max() >> 1;
int64_t n, s, t;
struct edge {
int64_t u, v, c, f, cost;
};
vector<edge> E;
vector<vector<int64_t>> graph;
vector<int64_t> dist, head;
vector<bool> inq;
min_cost_flow(int64_t n = 0, int64_t s = 0, int64_t t = 0)
: n(n), s(s), t(t) {
E.clear();
graph.assign(n + 1, vector<int64_t>());
}
int64_t add_edge(int64_t u, int64_t v, int64_t c, int64_t cost) {
int64_t res = E.size();
graph[u].push_back(E.size());
E.push_back({u, v, c, 0, cost});
graph[v].push_back(E.size());
E.push_back({v, u, 0, 0, -cost});
return res;
}
bool SPFA() {
head.assign(n + 1, -1);
dist.assign(n + 1, 1e9);
dist[s] = 0;
queue<pair<int64_t, int64_t>> wl;
wl.push({0, s});
while (not wl.empty()) {
int64_t d = wl.front().first, u = wl.front().second;
wl.pop();
if (d > dist[u]) continue;
for (int64_t i : graph[u]) {
if (dist[E[i].v] > d + E[i].cost && E[i].f < E[i].c) {
dist[E[i].v] = d + E[i].cost, head[E[i].v] = i;
wl.push({dist[E[i].v], E[i].v});
}
}
}
return (head[t] != -1);
}
int64_t dfs() {
int64_t delta = INF;
for (int64_t u = t; u != s; u = E[head[u]].u) {
int64_t i = head[u];
delta = min(delta, E[i].c - E[i].f);
}
for (int64_t u = t; u != s; u = E[head[u]].u) {
int64_t i = head[u];
E[i].f += delta, E[i ^ 1].f -= delta;
}
return delta;
}
int64_t max_flow() {
int64_t ans = 0, flow = 0;
while (SPFA()) {
int64_t det = dfs();
ans += dist[t] * det;
flow += det;
}
return ans;
}
};
void solve() {
int64_t n, k;
cin >> n >> k;
vector<int64_t> a(n), b(n);
for (int64_t i = 0; i < n; i++) cin >> a[i] >> b[i];
int64_t s = n * 2, t = n * 2 + 1;
min_cost_flow mcf(n * 2 + 2, s, t);
for (int64_t i = 0; i < n; i++) mcf.add_edge(s, i, 1, 0);
for (int64_t i = 0; i < n; i++) mcf.add_edge(i + n, t, 1, 0);
vector<vector<int64_t>> slot_to_minion(n, vector<int64_t>(n));
for (int64_t i = 0; i < n; i++)
for (int64_t j = 0; j < n; j++) {
if (j < k)
slot_to_minion[i][j] = mcf.add_edge(i, n + j, 1, -(a[i] + j * b[i]));
else
slot_to_minion[i][j] = mcf.add_edge(i, n + j, 1, -(k - 1) * b[i]);
}
mcf.max_flow();
cout << n + n - k << endl;
for (int64_t i = 0; i < k - 1; i++) {
for (int64_t j = 0; j < n; j++)
if (mcf.E[slot_to_minion[j][i]].f > 0) {
cout << (j + 1) << " ";
break;
}
}
for (int64_t i = k; i < n; i++) {
for (int64_t j = 0; j < n; j++)
if (mcf.E[slot_to_minion[j][i]].f > 0) {
cout << (j + 1) << " " << -(j + 1) << " ";
break;
}
}
for (int64_t j = 0; j < n; j++)
if (mcf.E[slot_to_minion[j][k - 1]].f > 0) {
cout << (j + 1) << "\n";
break;
}
}
signed main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
int64_t tc;
cin >> tc;
while (tc--) solve();
return 0;
}
| 12 | CPP |
#include <bits/stdc++.h>
using namespace std;
const long long maxn = 2e2 + 100;
const long long mod = 1e9 + 7;
const long long base = 1e18;
pair<pair<long long, long long>, long long> a[maxn];
long long dp[maxn][maxn];
bool par[maxn][maxn];
bool lf(pair<pair<long long, long long>, long long> a,
pair<pair<long long, long long>, long long> b) {
return a.first.second < b.first.second;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
if (fopen("TRIPLES.inp", "r")) {
freopen("TRIPLES.inp", "r", stdin);
freopen("TRIPLES.out", "w", stdout);
}
long long t;
cin >> t;
while (t--) {
long long n, k;
cin >> n >> k;
for (int i = 1; i <= n; i++) {
cin >> a[i].first.first >> a[i].first.second;
a[i].second = i;
}
sort(a + 1, a + n + 1, lf);
dp[0][0] = 0;
for (int j = 1; j <= k; j++) dp[0][j] = -base;
for (int i = 1; i <= n; i++) {
for (int j = 0; j <= k; j++) {
dp[i][j] = -base;
if (j) {
dp[i][j] = max(
dp[i - 1][j - 1] + a[i].first.first + a[i].first.second * (j - 1),
dp[i][j]);
if (dp[i][j] == dp[i - 1][j - 1] + a[i].first.first +
a[i].first.second * (j - 1)) {
par[i][j] = 1;
}
}
dp[i][j] = max(dp[i][j], dp[i - 1][j] + (k - 1) * a[i].first.second);
if (dp[i][j] == dp[i - 1][j] + (k - 1) * a[i].first.second) {
par[i][j] = 0;
}
}
}
pair<long long, long long> nw = make_pair(n, k);
vector<long long> vt;
vector<long long> vt1;
while (nw != make_pair(0ll, 0ll)) {
auto p = nw;
if (par[p.first][p.second])
vt.push_back(a[p.first].second);
else
vt1.push_back(a[p.first].second);
nw.second -= par[p.first][p.second];
nw.first--;
}
cout << k + (n - k) * 2 << "\n";
reverse(vt.begin(), vt.end());
for (int i = 0; i < vt.size() - 1; i++) cout << vt[i] << " ";
for (auto to : vt1) cout << to << " " << -to << " ";
cout << vt.back() << " ";
cout << "\n";
}
}
| 12 | CPP |
#include <bits/stdc++.h>
#pragma GCC optimize(3, "Ofast", "inline")
#pragma GCC target("avx")
using namespace std;
inline char gc() {
static char buf[1 << 16], *p1 = buf, *p2 = buf;
if (p1 == p2) {
p2 = (p1 = buf) + fread(buf, 1, 1 << 16, stdin);
if (p2 == p1) return EOF;
}
return *p1++;
}
template <class t>
inline t read(t &x) {
char c = gc();
bool f = 0;
x = 0;
while (!isdigit(c)) f |= c == '-', c = gc();
while (isdigit(c)) x = (x << 1) + (x << 3) + (c ^ 48), c = gc();
if (f) x = -x;
return x;
}
template <class t>
inline void write(t x) {
if (x < 0)
putchar('-'), write(-x);
else {
if (x > 9) write(x / 10);
putchar('0' + x % 10);
}
}
const int N = 205, M = 1e4 + 5, P = 80;
int en = 1, mc, mf, h[N], dis[N], n, k, ans[P];
bool v[N];
struct edge {
int n, v, f, w;
} e[M << 1];
struct fafafa {
int fa, id;
} pre[N];
void add(int x, int y, int f, int w) {
e[++en] = (edge){h[x], y, f, w};
h[x] = en;
}
bool spfa(int s, int t) {
memset(v, 0, sizeof v);
memset(pre, 0, sizeof pre);
memset(dis, 0x3f, sizeof dis);
queue<int> q;
q.push(s);
v[s] = 1;
dis[s] = 0;
while (!q.empty()) {
int x = q.front();
q.pop();
for (int i = h[x]; i; i = e[i].n) {
int y = e[i].v;
if (e[i].f && dis[x] + e[i].w < dis[y]) {
dis[y] = dis[x] + e[i].w;
pre[y] = (fafafa){x, i};
if (!v[y]) {
v[y] = 1;
q.push(y);
}
}
}
v[x] = 0;
}
return dis[t] ^ 0x3f3f3f3f;
}
void mcmf(int s, int t) {
while (spfa(s, t)) {
int flow = INT_MAX;
for (int i = t; i ^ s; i = pre[i].fa) flow = min(flow, e[pre[i].id].f);
for (int i = t; i ^ s; i = pre[i].fa) {
e[pre[i].id].f -= flow;
e[pre[i].id ^ 1].f += flow;
}
mf += flow;
mc += flow * dis[t];
}
}
void exadd(int x, int y, int f, int w) {
add(x, y, f, w);
add(y, x, 0, -w);
}
void doit() {
read(n);
read(k);
for (int i = 1; i <= n; i++) exadd(0, i, 1, 0), exadd(i + n, n * 2 + 1, 1, 0);
for (int i = 1, a, b; i <= n; i++) {
read(a);
read(b);
for (int j = 1, val; j <= n; j++) {
if (j < k)
val = a + (j - 1) * b;
else if (j < n)
val = (k - 1) * b;
else
val = a + (k - 1) * b;
exadd(i, j + n, 1, -val);
}
}
mcmf(0, n * 2 + 1);
write(k + (n - k) * 2);
puts("");
for (int x = 1; x <= n; x++)
for (int i = h[x]; i; i = e[i].n) {
int y = e[i].v;
if (y <= n) continue;
if (!e[i].f) ans[y - n] = x;
}
for (int i = 1; i <= n; i++) {
write(ans[i]);
putchar(' ');
if (i >= k && i < n) write(-ans[i]), putchar(' ');
}
puts("");
en = 1;
mc = mf = 0;
for (int i = 0; i <= n * 2 + 1; i++) h[i] = 0;
}
signed main() {
int t;
read(t);
while (t--) doit();
}
| 12 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int N = 75 + 10;
struct re {
int a, b, id;
} a[N];
long long f[N][N];
bool plan[N][N];
bool choose[N];
vector<int> actions;
void get_plan(int x, int y) {
if (x == 0) return;
if (plan[x][y]) choose[x] = true;
get_plan(x - 1, y - plan[x][y]);
}
int main() {
int T;
scanf("%d", &T);
while (T--) {
int n, k;
scanf("%d%d", &n, &k);
for (int i = 1; i <= n; ++i) {
scanf("%d%d", &a[i].a, &a[i].b);
a[i].id = i;
}
sort(a + 1, a + n + 1, [&](const re &a, const re &b) { return a.b < b.b; });
memset(f, -1, sizeof(f[0]) * (n + 3));
f[0][0] = 0;
for (int i = 1; i <= n; ++i) {
int upb = min(i - 1, k);
for (int j = 0; j <= upb; ++j) {
if (f[i - 1][j] == -1) continue;
long long tmp = f[i - 1][j] + (long long)(k - 1) * a[i].b;
if (tmp > f[i][j]) {
f[i][j] = tmp;
plan[i][j] = false;
}
tmp = f[i - 1][j] + a[i].a + (long long)j * a[i].b;
if (tmp > f[i][j + 1]) {
f[i][j + 1] = tmp;
plan[i][j + 1] = true;
}
}
}
memset(choose, 0, sizeof(choose[0]) * (n + 3));
get_plan(n, k);
actions.clear();
int cnt = 0;
for (int i = 1; i <= n && cnt < k - 1; ++i) {
if (!choose[i]) continue;
cnt++;
actions.push_back(a[i].id);
}
for (int i = 1; i <= n; ++i) {
if (choose[i]) continue;
actions.push_back(a[i].id);
actions.push_back(-a[i].id);
}
for (int i = n; i; --i) {
if (!choose[i]) continue;
actions.push_back(a[i].id);
break;
}
int actions_tot = actions.size();
printf("%d\n", actions_tot);
for (int i = 0; i < actions_tot; ++i)
printf("%d%c", actions[i], " \n"[i == actions_tot - 1]);
}
return 0;
}
| 12 | CPP |
#include <bits/stdc++.h>
using namespace std;
vector<pair<pair<int, int>, int>> v;
long long dp[80][80];
pair<int, int> from[80][80];
set<int> s;
int main() {
int t;
cin >> t;
while (t) {
t--;
int i, j, n, k;
cin >> n >> k;
v.clear();
s.clear();
for (i = 1; i <= n; i++) {
int a, b;
cin >> a >> b;
v.push_back({{b, a}, i});
s.insert(i);
}
sort(v.begin(), v.end());
for (i = 0; i <= n; i++) {
for (j = 0; j <= k; j++) {
dp[i][j] = -100000000000;
from[i][j] = {-1, -1};
}
}
dp[0][0] = 0;
for (i = 0; i < n; i++) {
int ind = v[i].second;
long long a = v[i].first.second, b = v[i].first.first;
for (j = 0; j <= k; j++) {
if (dp[i + 1][j] < dp[i][j] + (k - 1) * b) {
from[i + 1][j] = {ind, j};
dp[i + 1][j] = dp[i][j] + (k - 1) * b;
}
if (j > 0 && dp[i + 1][j] < dp[i][j - 1] + (j - 1) * b + a) {
from[i + 1][j] = {ind, j - 1};
dp[i + 1][j] = dp[i][j - 1] + (j - 1) * b + a;
}
}
}
vector<int> ans;
int nx = n, ny = k;
while (ny != 0) {
pair<int, int> p = from[nx][ny];
if (p.second != ny) {
ans.push_back(p.first);
s.erase(p.first);
}
nx--;
ny = p.second;
}
cout << 2 * n - k << endl;
for (i = k - 1; i > 0; i--) {
cout << ans[i] << " ";
}
for (int x : s) {
cout << x << " " << -x << " ";
}
cout << ans[0] << endl;
}
}
| 12 | CPP |
#include <bits/stdc++.h>
using namespace std;
template <class T>
struct rge {
T b, e;
};
template <class T>
rge<T> range(T i, T j) {
return rge<T>{i, j};
}
struct debug {
template <class T>
debug& operator<<(const T&) {
return *this;
}
};
using ll = long long;
template <typename T>
void min_self(T& a, T b) {
a = min(a, b);
}
template <typename T>
void max_self(T& a, T b) {
a = max(a, b);
}
int k;
template <typename flow_t, typename cost_t>
class MinCostFlow {
public:
MinCostFlow(int _n, int _source, int _sink)
: n(_n), source(_source), sink(_sink) {
g.resize(n);
cost.resize(n, vector<cost_t>(n));
cap.resize(n, vector<flow_t>(n));
}
void add_edge(int from, int to, cost_t weight, flow_t c) {
g[from].push_back(to);
g[to].push_back(from);
cost[to][from] = -weight;
cost[from][to] = weight;
cap[from][to] = c;
}
struct State {
cost_t dist;
int node;
bool operator<(const State& rhs) const { return dist > rhs.dist; }
};
void shortest_paths(vector<cost_t>& dist, vector<int>& par) {
dist.assign(n, COST_INF);
par.assign(n, -1);
dist[source] = 0;
priority_queue<State> pq;
pq.push({0LL, source});
while (!pq.empty()) {
State u = pq.top();
pq.pop();
if (u.dist > dist[u.node]) continue;
for (int v : g[u.node]) {
if (dist[v] > u.dist + cost[u.node][v] && cap[u.node][v] > 0) {
dist[v] = u.dist + cost[u.node][v];
par[v] = u.node;
pq.push({dist[v], v});
}
}
}
}
cost_t min_cost_flow() {
flow_t mf = 0;
cost_t total_cost = 0;
vector<cost_t> dist(n);
vector<int> par(n);
while (true) {
shortest_paths(dist, par);
if (dist[sink] == COST_INF) {
break;
}
flow_t f = FLOW_INF;
int cur = sink;
while (cur != source) {
f = min(f, cap[par[cur]][cur]);
cur = par[cur];
}
mf += f;
total_cost += dist[sink];
cur = sink;
while (cur != source) {
cap[par[cur]][cur] -= f;
cap[cur][par[cur]] += f;
cur = par[cur];
}
}
int m = (sink - 1) / 2;
cout << k + 2 * (m - k) << endl;
for (int i = 0; i < int(m); i++) {
int pos = i + m;
for (int j = 0; j < int(m); j++) {
if (cap[j][pos] == 0) {
if (i < k - 1 || i == m - 1) {
cout << j + 1 << ' ';
} else {
cout << (j + 1) << ' ' << -(j + 1) << ' ';
}
}
}
}
cout << endl;
return total_cost;
}
private:
const flow_t FLOW_INF = numeric_limits<flow_t>::max() / 2;
const cost_t COST_INF = numeric_limits<cost_t>::max() / 2;
vector<vector<int>> g;
vector<vector<flow_t>> cap;
vector<vector<cost_t>> cost;
int n, source, sink;
};
void test_case() {
int n;
cin >> n >> k;
vector<int> a(n), b(n);
for (int i = 0; i < int(n); i++) {
cin >> a[i] >> b[i];
}
int source = 2 * n, sink = 2 * n + 1;
MinCostFlow<int, int> graph(2 * n + 2, source, sink);
for (int i = 0; i < n; i++) {
graph.add_edge(source, i, 0, 1);
graph.add_edge(i + n, sink, 0, 1);
}
for (int i = 0; i < n; i++) {
for (int pos = 0; pos < n; pos++) {
int w = 0;
if (pos < k - 1) {
w = -(a[i] + pos * b[i]);
} else if (pos < n - 1) {
w = -(k - 1) * b[i];
} else {
w = -(a[i] + (k - 1) * b[i]);
}
graph.add_edge(i, pos + n, w, 1);
}
}
graph.min_cost_flow();
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
int tc;
cin >> tc;
while (tc--) {
test_case();
}
}
| 12 | CPP |
#include <bits/stdc++.h>
using namespace std;
const long double PI = acos(-1.0);
array<long long, 3> a[80];
long long dp[80][80];
long long par[80][80];
void solve() {
long long n, k;
cin >> n >> k;
for (long long i = 0; i < n; ++i) {
cin >> a[i][1] >> a[i][0];
a[i][2] = i + 1;
}
memset(dp, 0, sizeof dp);
sort(a, a + n);
for (long long i = 0; i < n; ++i) {
for (long long j = 0; j < k + 1; ++j) {
if (j > i) continue;
if (dp[i + 1][j] < dp[i][j] + (k - 1) * a[i][0]) {
dp[i + 1][j] = dp[i][j] + (k - 1) * a[i][0];
par[i + 1][j] = j;
}
if (j != k and dp[i + 1][j + 1] < dp[i][j] + a[i][1] + j * a[i][0]) {
dp[i + 1][j + 1] = dp[i][j] + a[i][1] + j * a[i][0];
par[i + 1][j + 1] = j;
}
}
}
vector<long long> taken;
vector<long long> not_taken;
long long cur = k;
for (long long i = n; i >= 1; --i) {
if (cur - par[i][cur] == 1) {
taken.push_back(a[i - 1][2]);
} else {
not_taken.push_back(a[i - 1][2]);
}
cur = par[i][cur];
}
reverse(taken.begin(), taken.end());
for (long long i : not_taken) {
long long idx = taken.size() - 1;
taken.insert(taken.begin() + idx, i);
++idx;
taken.insert(taken.begin() + idx, -i);
}
cout << (long long)taken.size() << '\n';
for (long long i : taken) {
cout << i << ' ';
}
cout << '\n';
}
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
long long t = 1;
cin >> t;
while (t--) {
solve();
}
return 0;
}
| 12 | CPP |
from typing import List
import sys
input = sys.stdin.readline
import math
############ ---- Input Functions ---- ############
def inp():
return(int(input()))
def inlt():
return(list(map(int,input().split())))
def insr():
s = input().strip()
return(list(s[:len(s)]))
def invr():
return(map(int,input().strip().split()))
def solve_hungarian(a: List[List[int]], n: int, m: int):
"""
Implementation of Hungarian algorithm in n^2 m
"""
# potentials
u = [0] * (n+1)
v = [0] * (m+1)
# pair row of each col
p = [0] * (m+1)
# for each col the number of prev col along the augmenting path
way = [0] * (m+1)
for i in range(1, n+1):
p[0] = i
j0 = 0
minv = [float('inf')] * (m+1)
used = [False] * (m+1)
# iterative Kun starts here
condition = True
while condition:
# mark the current col as reachable
used[j0] = True
i0 = p[j0]
delta = float('inf')
# determine which col will become reachable after next potential update
for j in range(1, m+1):
if not used[j]:
cur = a[i0][j] - u[i0]-v[j]
if cur < minv[j]:
minv[j] = cur
way[j] = j0
if minv[j] < delta:
delta = minv[j]
j1 = j
# j1 will hold the col with min
# way[j1] - the prev col in dfs
# update the potential
for j in range(0, m+1):
if used[j]: # if col j was discovered:
u[p[j]] += delta
v[j] -= delta
else: # not discovered - update min?
minv[j] -= delta
# j0 becomes the col on which the delta is achieved
j0 = j1
# p[j0] == 0 => j0 - a col not in matching
condition = p[j0] != 0
# the augmenting path was found - update the mapping
condition = True
while condition:
# j1 is the prev column of j0 in augmenting path
j1 = way[j0]
p[j0] = p[j1]
j0 = j1
condition = j0 != 0
ans = [0] * (n+1)
for j in range(1, m+1):
ans[p[j]] = j
return -v[0], ans
def solve(n, k, a, b):
A = [[0] * (n+1) for _ in range(n+1) ]
for i in range(1, n+1):
for j in range(1, k+1):
A[i][j] = a[i] + (j-1) * b[i]
for j in range(k+1, n+1):
A[i][j] = (k-1) * b[i]
# turn into a max problem
for i, row in enumerate(A):
M = max(row)
for j in range(n+1):
A[i][j] = M - A[i][j]
cost, match = solve_hungarian(A, n, n)
print(n + (n-k))
role_to_creature = list(zip(match, range(len(match))))
role_to_creature.sort()
res = []
for index in range(1, k):
res.append(role_to_creature[index][1])
for index in range(k+1, n+1):
res.append(role_to_creature[index][1])
res.append(-role_to_creature[index][1])
res.append(role_to_creature[k][1])
print(" ".join(map(str, res)))
def from_file(f):
return f.readline
# with open('test.txt') as f:
# input = from_file(f)
t = inp()
for _ in range(t):
n, k = invr()
a = [0]
b = [0]
for _ in range(n):
ai, bi = invr()
a.append(ai)
b.append(bi)
solve(n, k, a, b)
| 12 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
long long t, n, k, dp[80][80];
pair<pair<long long, long long>, long long> v[100];
long long f(int pos, long long num) {
if (dp[pos][num] != -1) return dp[pos][num];
if (pos == n) {
if (num != k)
return dp[pos][num] = -1000000000000000;
else
return dp[pos][num] = 0;
}
long long res = -1000000000000000;
res = max(res, f(pos + 1, num) + v[pos].first.first * (k - 1ll));
if (num < k) {
res = max(res, f(pos + 1, num + 1) + v[pos].first.first * num +
v[pos].first.second);
}
return dp[pos][num] = res;
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cin >> t;
while (t--) {
memset(dp, -1, sizeof(dp));
cin >> n >> k;
for (int i = 0; i < n; i++) {
cin >> v[i].first.second >> v[i].first.first;
v[i].second = i + 1;
}
sort(v, v + n);
f(0, 0);
int pos = 0, num = 0;
vector<int> us, notus;
while (pos < n) {
if (dp[pos + 1][num] != -1 &&
dp[pos + 1][num] + v[pos].first.first * (k - 1ll) == dp[pos][num]) {
notus.push_back(v[pos].second);
} else {
us.push_back(v[pos].second);
num++;
}
pos++;
}
cout << us.size() + notus.size() * 2 << "\n";
for (int i = 0; (i + 1) < us.size(); i++) {
cout << us[i] << " ";
}
for (auto i : notus) cout << i << " " << -i << " ";
cout << us[us.size() - 1] << "\n";
}
return 0;
}
| 12 | CPP |
#include <bits/stdc++.h>
using namespace std;
const long long inff = 0x3f3f3f3f3f3f3f3f;
const int N = 1e2 + 8;
int w[N][N], x[N], y[N], pop, n, k, lx, ly, a[N];
int px[N], py[N], sy[N], slack[N], par[N];
void adjust(int v) {
sy[v] = py[v];
if (px[sy[v]] != -2) adjust(px[sy[v]]);
}
bool fid(int v) {
for (int i(0); i <= (pop - 1); ++i)
if (py[i] == -1) {
if (slack[i] > x[v] + y[i] - w[v][i])
slack[i] = x[v] + y[i] - w[v][i], par[i] = v;
if (x[v] + y[i] == w[v][i]) {
py[i] = v;
if (sy[i] == -1) {
adjust(i);
return 1;
}
if (px[sy[i]] != -1) continue;
px[sy[i]] = i;
if (fid(sy[i])) return 1;
}
}
return 0;
}
void km() {
for (int i(0); i <= (pop - 1); ++i) sy[i] = -1, y[i] = 0;
for (int i(0); i <= (pop - 1); ++i) {
x[i] = 0;
for (int j(0); j <= (pop - 1); ++j) x[i] = max(x[i], w[i][j]);
}
int flag, m;
for (int i(0); i <= (pop - 1); ++i) {
for (int j(0); j <= (pop - 1); ++j)
px[j] = py[j] = -1, slack[j] = int(0x3f3f3f3f);
px[i] = -2;
if (fid(i)) continue;
flag = 0;
while (!flag) {
m = int(0x3f3f3f3f);
for (int j(0); j <= (pop - 1); ++j)
if (py[j] == -1) m = min(m, slack[j]);
for (int j(0); j <= (pop - 1); ++j) {
if (px[j] != -1) x[j] -= m;
if (py[j] != -1)
y[j] += m;
else
slack[j] -= m;
}
for (int j(0); j <= (pop - 1); ++j)
if (py[j] == -1 && !slack[j]) {
py[j] = par[j];
if (sy[j] == -1) {
adjust(j), flag = 1;
break;
}
px[sy[j]] = j;
if (fid(sy[j])) {
flag = 1;
break;
}
}
}
}
}
int main() {
cin.tie(0);
cout.tie(0);
int t;
cin >> t;
while (t--) {
cin >> n >> k;
pop = max(n, k);
for (int i(1); i <= (n); ++i) {
scanf("%d", &lx), scanf("%d", &ly);
for (int j(1); j <= (min(k, n)); ++j) w[i - 1][j - 1] = lx + ly * (j - 1);
for (int j(k + 1); j <= (n); ++j) w[i - 1][j - 1] = ly * (k - 1);
}
km();
if (k <= n)
cout << 2 * n - k << endl;
else
cout << n << endl;
for (int i(0); i <= (n - 1); ++i) {
sy[i]++;
if (i == min(n, k) - 1) continue;
if (i >= k)
cout << sy[i] << " " << -sy[i] << " ";
else
cout << sy[i] << " ";
}
cout << sy[min(n, k) - 1] << endl;
}
return 0;
}
| 12 | CPP |
#include <bits/stdc++.h>
struct E {
int a, b, rt;
} s[76];
int dp[76][76], ch[76][76], v[76];
int st[76];
bool mk[76];
void work() {
memset(dp, 0xAC, sizeof(dp));
memset(v, 0, sizeof(v));
memset(mk, 0, sizeof(mk));
int n, k;
scanf("%d%d", &n, &k);
for (int i = 1; i <= n; i++) {
s[i].rt = i;
scanf("%d%d", &s[i].a, &s[i].b);
s[i].a -= (k - 1) * s[i].b;
}
std::sort(s + 1, s + n + 1, [](E x, E y) { return x.b < y.b; });
dp[0][0] = 0;
for (int i = 1; i <= n; i++) {
for (int j = std::min(i, k); j >= 1; j--) {
ch[i][j] = v[j - 1];
dp[i][j] = dp[v[j - 1]][j - 1] + (j - 1) * s[i].b + s[i].a;
if (dp[i][j] > dp[v[j]][j]) v[j] = i;
}
}
int x = v[k], y = k;
while (y) {
st[y] = x;
mk[x] = true;
x = ch[x][y];
y--;
}
printf("%d\n", 2 * n - k);
for (int i = 1; i < k; i++) printf("%d ", s[st[i]].rt);
for (int i = 1; i <= n; i++)
if (!mk[i]) printf("%d %d ", s[i].rt, -s[i].rt);
printf("%d ", s[st[k]].rt);
puts("");
}
int main() {
int T;
scanf("%d", &T);
while (T--) work();
}
| 12 | CPP |
import sys
readline = sys.stdin.readline
read = sys.stdin.read
ns = lambda: readline().rstrip()
ni = lambda: int(readline().rstrip())
nm = lambda: map(int, readline().split())
nl = lambda: list(map(int, readline().split()))
prn = lambda x: print(*x, sep='\n')
def solve():
n, k = nm()
mini = [tuple(nl() + [i+1]) for i in range(n)]
mini.sort(key = lambda x: x[1])
# print(mini)
dp = [-1]*(k+1)
dp[0] = 0
f = [[0]*(k+1) for _ in range(n)]
for i in range(n):
if dp[k] > 0:
dp[k] += (k - 1) * mini[i][1]
for j in range(k-1, -1, -1):
if dp[j] >= 0:
if dp[j+1] < dp[j] + mini[i][0] + j * mini[i][1]:
dp[j+1] = dp[j] + mini[i][0] + j * mini[i][1]
f[i][j+1] = 1
dp[j] += (k - 1) * mini[i][1]
cx = k
a = list()
b = list()
for i in range(n-1, -1, -1):
if f[i][cx]:
a.append(mini[i][2])
cx -= 1
else:
b.append(mini[i][2])
com = list()
for x in a[:0:-1]:
com.append(x)
for x in b:
com.append(x)
com.append(-x)
com.append(a[0])
print(len(com))
print(*com)
return
T = ni()
for _ in range(T):
solve() | 12 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
vector<pair<pair<int, int>, int>> v;
long long dp[80][80];
pair<int, int> from[80][80];
set<int> s;
int main() {
int t;
cin >> t;
while (t) {
t--;
int i, j, n, k;
cin >> n >> k;
v.clear();
s.clear();
for (i = 1; i <= n; i++) {
int a, b;
cin >> a >> b;
v.push_back({{b, a - (k - 1) * b}, i});
s.insert(i);
}
sort(v.begin(), v.end());
for (i = 0; i <= n; i++) {
for (j = 0; j <= k; j++) {
dp[i][j] = -100000000000;
from[i][j] = {-1, -1};
}
}
dp[0][0] = 0;
for (i = 0; i < n; i++) {
int ind = v[i].second;
long long a = v[i].first.second, b = v[i].first.first;
for (j = 0; j <= k; j++) {
if (dp[i + 1][j] < dp[i][j]) {
from[i + 1][j] = {ind, j};
dp[i + 1][j] = dp[i][j];
}
if (j > 0 && dp[i + 1][j] < dp[i][j - 1] + (j - 1) * b + a) {
from[i + 1][j] = {ind, j - 1};
dp[i + 1][j] = dp[i][j - 1] + (j - 1) * b + a;
}
}
}
vector<int> ans;
int nx = n, ny = k;
while (ny != 0) {
pair<int, int> p = from[nx][ny];
if (p.second != ny) {
ans.push_back(p.first);
s.erase(p.first);
}
nx--;
ny = p.second;
}
cout << 2 * n - k << endl;
for (i = k - 1; i > 0; i--) {
cout << ans[i] << " ";
}
for (int x : s) {
cout << x << " " << -x << " ";
}
cout << ans[0] << endl;
}
}
| 12 | CPP |
#include <bits/stdc++.h>
using namespace std;
int f[505][505], g[505][505], a[505], b[505], id[505], xinyue, n, m, vis[505],
ed;
int cmp(int x, int y) { return b[x] < b[y]; }
void dfs(int n, int m) {
if (!n) return;
if (g[n][m] == 1) vis[n] = 1, m--;
dfs(n - 1, m);
}
int main() {
scanf("%d", &xinyue);
while (xinyue--) {
scanf("%d%d", &n, &m);
for (int i = 0; i <= n; i++) {
for (int t = 0; t <= m; t++) {
f[i][t] = -1;
}
}
f[0][0] = 0;
memset(g, 0, sizeof(g));
for (int i = 1; i <= n; i++) scanf("%d%d", &a[i], &b[i]), id[i] = i;
sort(id + 1, id + n + 1, cmp);
for (int i = 1; i <= n; i++) {
for (int t = 0; t <= min(i, m); t++) {
if (f[i - 1][t] != -1) f[i][t] = f[i - 1][t] + b[id[i]] * (m - 1);
g[i][t] = 0;
if (t && f[i - 1][t - 1] + a[id[i]] + b[id[i]] * (t - 1) > f[i][t] &&
f[i - 1][t - 1] != -1) {
f[i][t] = f[i - 1][t - 1] + a[id[i]] + b[id[i]] * (t - 1);
g[i][t] = 1;
}
}
}
memset(vis, 0, sizeof(vis));
dfs(n, m);
printf("%d\n", m + (n - m) * 2);
ed = 0;
for (int i = 1; i <= n; i++) {
if (vis[i]) {
ed++;
if (ed == m) {
ed = id[i];
break;
}
printf("%d ", id[i]);
}
}
for (int i = 1; i <= n; i++) {
if (!vis[i]) {
printf("%d %d ", id[i], -id[i]);
}
}
printf("%d\n", ed);
}
}
| 12 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int mod = 1000000007;
const int inf = 0x3f3f3f3f;
const long long int infl = 1e18;
long long int din[109][109];
int prv[109][109], t;
struct st {
int x, y, id;
};
st p[100];
int main() {
cin >> t;
while (t--) {
int n, k;
cin >> n >> k;
memset(din, -1, sizeof(din));
for (int i = 0; i < n; ++i) {
cin >> p[i].x >> p[i].y;
p[i].id = i;
}
sort(p, p + n, [](st a, st b) { return a.y < b.y; });
din[0][0] = 0;
for (int i = 0; i < n; ++i) {
for (int j = 0; j < k + 1; ++j) {
if (din[i][j] == -1) {
continue;
}
if (j + 1 <= k) {
long long int c = din[i][j] + p[i].x + p[i].y * j;
if (din[i + 1][j + 1] < c) {
prv[i + 1][j + 1] = j;
din[i + 1][j + 1] = c;
}
}
long long int c = din[i][j] + p[i].y * (k - 1);
if (din[i + 1][j] < c) {
prv[i + 1][j] = j;
din[i + 1][j] = c;
}
}
}
int nx = n, ny = k;
vector<int> A, B;
while (nx) {
if (prv[nx][ny] != ny) {
A.push_back(p[nx - 1].id);
} else {
B.push_back(p[nx - 1].id);
}
ny = prv[nx][ny];
nx--;
}
reverse(A.begin(), A.end());
reverse(B.begin(), B.end());
cout << A.size() + B.size() * 2 << "\n";
for (int i = 0; i < A.size() - 1; ++i) {
cout << A[i] + 1 << " ";
}
for (int i : B) {
cout << i + 1 << " " << -i - 1 << " ";
}
cout << A.back() + 1 << "\n";
}
}
| 12 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 75;
struct node {
int a, b, num;
} p[maxn + 11];
int f[maxn + 11][maxn + 11][2];
vector<int> v1, v2;
int main() {
ios_base::sync_with_stdio(0), cin.tie(0), cout.tie(0);
int t;
cin >> t;
for (int kase = 1; kase <= t; kase++) {
int n, k;
cin >> n >> k;
for (int i = 1; i <= n; i++) {
cin >> p[i].a >> p[i].b;
p[i].num = i;
}
sort(p + 1, p + 1 + n, [&](node a, node b) { return a.b < b.b; });
memset(f, 0, sizeof(f));
for (int i = 1; i <= n; i++) {
f[i][0][0] = f[i - 1][0][0] + p[i].b * (k - 1);
for (int j = 1; j <= min(k, i); j++) {
if (i > j)
f[i][j][0] = max(f[i - 1][j][0], f[i - 1][j][1]) + p[i].b * (k - 1);
f[i][j][1] = max(f[i - 1][j - 1][0], f[i - 1][j - 1][1]) +
p[i].b * (j - 1) + p[i].a;
}
}
v1.clear();
v2.clear();
int x = n;
int y = k;
while (x) {
if (f[x][y][0] >= f[x][y][1]) {
v2.emplace_back(x);
x--;
} else {
v1.emplace_back(x);
x--;
y--;
}
}
reverse(v1.begin(), v1.end());
int m = (int)v1.size() + 2 * (int)v2.size();
cout << m << endl;
for (int i = 0; i < v1.size() - 1; i++) cout << p[v1[i]].num << " ";
for (auto u : v2) cout << p[u].num << " " << -p[u].num << " ";
cout << p[v1.back()].num << endl;
}
}
| 12 | CPP |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using ull = unsigned long long;
using ld = long double;
template <typename T1, typename T2>
inline void chkmin(T1 &x, const T2 &y) {
if (x > y) x = y;
}
template <typename T1, typename T2>
inline void chkmax(T1 &x, const T2 &y) {
if (x < y) x = y;
}
struct fa {
int a, b, ind;
fa() {}
};
int n, k;
const int MAXN = 76;
fa a[MAXN];
const int INF = 1e9;
int dp[MAXN][MAXN][2];
int par[MAXN][MAXN][2];
void relax(int pref, int cnt, int ind, int val, int fpar) {
if (dp[pref][cnt][ind] >= val) return;
dp[pref][cnt][ind] = val;
par[pref][cnt][ind] = fpar;
}
void solve() {
cin >> n >> k;
for (int i = 0; i < n; i++) {
cin >> a[i].a >> a[i].b;
a[i].ind = i + 1;
}
sort(a, a + n, [&](fa i, fa j) { return i.b < j.b; });
if (k == 1) {
int pos = max_element(a, a + n, [&](fa i, fa j) { return i.a < j.a; }) - a;
cout << 1 << "\n" << a[pos].ind << "\n";
return;
}
if (k == n) {
cout << n << "\n";
for (int i = 0; i < n; i++) {
cout << a[i].ind << " ";
}
cout << "\n";
return;
}
for (int i = 0; i < MAXN; i++) {
for (int j = 0; j < MAXN; j++) {
for (int k = 0; k < 2; k++) {
dp[i][j][k] = -INF;
}
}
}
cerr << "a = " << endl;
for (int i = 0; i < n; i++) {
cerr << a[i].a << " " << a[i].b << endl;
}
dp[0][0][0] = 0;
for (int i = 0; i < n; i++) {
for (int cnt = 0; cnt <= k - 1; cnt++) {
for (int flag = 0; flag < 2; flag++) {
if (dp[i][cnt][flag] == -INF) continue;
if (cnt < k - 1)
relax(i + 1, cnt + 1, flag, dp[i][cnt][flag] + a[i].a + a[i].b * cnt,
1);
relax(i + 1, cnt, flag, dp[i][cnt][flag] + a[i].b * (k - 1), 2);
if (!flag) {
relax(i + 1, cnt, 1, dp[i][cnt][flag] + a[i].a + a[i].b * (k - 1), 3);
}
}
}
}
int pos = 0, cnt = 0, flag = 0;
for (int i = 0; i < MAXN; i++) {
if (dp[i][k - 1][1] > dp[pos][cnt][flag]) {
pos = i, cnt = k - 1, flag = 1;
}
}
cerr << "my_ans = " << dp[pos][cnt][flag] << endl;
vector<pair<int, int>> ans;
for (; pos >= 1; pos--) {
ans.push_back({par[pos][cnt][flag], pos});
int ncnt = cnt;
if (par[pos][cnt][flag] == 1) ncnt--;
int nflag = flag;
if (par[pos][cnt][flag] == 3) nflag--;
cnt = ncnt;
flag = nflag;
}
sort(ans.begin(), ans.end());
vector<int> fout;
for (auto i : ans) {
fout.push_back(i.second);
if (i.first == 2) {
fout.push_back(-i.second);
}
}
cout << fout.size() << "\n";
for (auto i : fout) {
cout << a[abs(i) - 1].ind * i / abs(i) << " ";
}
cout << "\n";
}
signed main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int t;
cin >> t;
while (t--) {
solve();
}
return 0;
}
| 12 | CPP |
#include <bits/stdc++.h>
using namespace std;
inline long long mod(long long n, long long m) {
long long ret = n % m;
if (ret < 0) ret += m;
return ret;
}
long long gcd(long long a, long long b) {
return (b == 0LL ? a : gcd(b, a % b));
}
long long exp(long long a, long long b, long long m) {
if (b == 0LL) return 1LL;
if (b == 1LL) return mod(a, m);
long long k = mod(exp(a, b / 2, m), m);
if (b & 1LL) {
return mod(a * mod(k * k, m), m);
} else
return mod(k * k, m);
}
const long long N = 80;
struct coisa {
long long a, b, id;
coisa() {}
coisa(long long A, long long B, long long C) { a = A, b = B, id = C; }
} v[N];
long long dp[N][N];
long long n, k;
long long solve(long long id, long long j) {
if (id == n + 1) {
if (j != k) return -1e9;
return 0;
}
long long& x = dp[id][j];
if (x != -1) return x;
long long nao = solve(id + 1, j) + (k - 1) * v[id].b;
if (j == k) return x = nao;
long long pega = solve(id + 1, j + 1) + v[id].b * (j) + v[id].a;
return x = max(pega, nao);
}
vector<long long> tira, col;
void rool(long long id, long long j) {
if (id == n + 1) return;
if (j == k) {
tira.push_back(id);
rool(id + 1, j);
return;
}
if (solve(id, j) == solve(id + 1, j) + (k - 1) * v[id].b) {
tira.push_back(id);
rool(id + 1, j);
return;
}
col.push_back(id);
rool(id + 1, j + 1);
return;
}
void solve() {
cin >> n >> k;
for (long long i = 1; i <= n; i++) {
long long a, b;
cin >> a >> b;
v[i] = coisa(a, b, i);
}
sort(v + 1, v + 1 + n, [&](coisa a, coisa b) { return a.b < b.b; });
if (k == 1) {
sort(v + 1, v + 1 + n, [&](coisa a, coisa b) { return a.a > b.a; });
cout << 1 << "\n";
cout << v[1].id << "\n";
return;
}
if (k == n) {
cout << n << "\n";
for (long long i = 1; i <= n; i++) {
cout << v[i].id << " ";
}
cout << "\n";
return;
}
memset(dp, -1, sizeof(dp));
tira.clear();
col.clear();
rool(1, 0);
vector<long long> ans;
for (long long i = 0; i < (long long)col.size() - 1; i++)
ans.push_back(v[col[i]].id);
for (long long x : tira) ans.push_back(v[x].id), ans.push_back(-v[x].id);
if ((long long)col.size() - 1 >= 0)
ans.push_back(v[col[(long long)col.size() - 1]].id);
cout << ans.size() << "\n";
for (long long x : ans) cout << x << " ";
cout << "\n";
}
int32_t main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
;
long long t;
cin >> t;
while (t--) {
solve();
}
}
| 12 | CPP |
#include <bits/stdc++.h>
using namespace std;
const long long INF = 1e18;
const int N = 100;
array<long long, 3> a[N];
long long dp[N][N];
int anc[N][N];
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int t;
cin >> t;
while (t--) {
int n, k;
cin >> n >> k;
for (int i = 0; i < n; i++) {
cin >> a[i][1] >> a[i][0];
a[i][2] = i;
}
sort(a, a + n);
for (int i = 0; i < N; i++) {
for (int j = 0; j < N; j++) {
dp[i][j] = -INF;
}
}
dp[0][0] = 0;
for (int i = 0; i < n; i++) {
for (int j = 0; j <= k; j++) {
if (dp[i][j] != -INF) {
if (dp[i + 1][j] < dp[i][j] + (k - 1) * a[i][0]) {
dp[i + 1][j] = dp[i][j] + (k - 1) * a[i][0];
anc[i + 1][j] = j;
}
if (dp[i + 1][j + 1] < dp[i][j] + a[i][1] + a[i][0] * j) {
dp[i + 1][j + 1] = dp[i][j] + a[i][1] + a[i][0] * j;
anc[i + 1][j + 1] = j;
}
}
}
}
vector<int> taken, killed;
int x = n, y = k;
while (x > 0) {
if (anc[x][y] == y)
killed.push_back(x - 1);
else
taken.push_back(x - 1);
y = anc[x][y];
x--;
}
reverse(taken.begin(), taken.end());
cout << taken.size() + killed.size() * 2 << "\n";
for (int i = 0; i + 1 < taken.size(); i++) {
cout << a[taken[i]][2] + 1 << " ";
}
for (int i = 0; i < killed.size(); i++) {
cout << (a[killed[i]][2] + 1) << " ";
cout << -(a[killed[i]][2] + 1) << " ";
}
cout << a[taken.back()][2] + 1 << "\n";
}
return 0;
}
| 12 | CPP |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using cd = complex<double>;
int main() {
ll t;
cin >> t;
while (t--) {
ll n, k;
cin >> n >> k;
pair<pair<ll, ll>, ll> ar[n];
for (ll i = 0; i < n; i++) {
cin >> ar[i].first.second >> ar[i].first.first;
ar[i].second = i + 1;
}
sort(ar, ar + n);
ll dp[n + 1][k + 1], ch[n + 1][k + 1];
for (ll i = 0; i <= n; i++) {
for (ll j = 0; j <= k; j++) {
dp[i][j] = -(ll)(1e18);
}
}
dp[0][0] = 0;
for (ll i = 0; i < n; i++) {
for (ll j = 0; j <= k; j++) {
ll& tar = dp[i + 1][j + 1];
ll v1 = dp[i][j] + j * ar[i].first.first + ar[i].first.second,
v2 = dp[i][j] + (k - 1) * ar[i].first.first;
if (j < k && v1 > tar) {
tar = v1;
ch[i + 1][j + 1] = j;
}
if (v2 > dp[i + 1][j]) {
dp[i + 1][j] = v2;
ch[i + 1][j] = j;
}
}
}
vector<ll> v1, v2;
ll x = n, y = k;
for (ll i = 0; i < n; i++) {
if (ch[x][y] == y) {
v2.push_back(ar[n - 1 - i].second);
} else {
v1.push_back(ar[n - 1 - i].second);
}
y = ch[x][y];
x--;
}
reverse(v1.begin(), v1.end());
cout << v1.size() + 2 * v2.size() << "\n";
ll last = v1.back();
v1.back();
v1.pop_back();
for (ll x : v1) {
cout << x << " ";
}
for (ll x : v2) {
cout << x << " " << -x << " ";
}
cout << last << "\n";
}
}
| 12 | CPP |
#include <bits/stdc++.h>
using namespace std;
template <typename T>
void r1(T &x) {
x = 0;
char c(getchar());
int f(1);
for (; c < '0' || c > '9'; c = getchar())
if (c == '-') f = -1;
for (; '0' <= c && c <= '9'; c = getchar()) x = (x * 10) + (c ^ 48);
x *= f;
}
template <typename T, typename... Args>
inline void r1(T &t, Args &...args) {
r1(t);
r1(args...);
}
const int maxn = 1e2 + 5;
const int maxm = maxn << 1;
const int mod = 1e9 + 7;
typedef int room[maxn];
template <int mod>
struct typemod {
int z;
typemod(int a = 0) : z(a) {}
inline int inc(int a, int b) const {
return a += b - mod, a + ((a >> 31) & mod);
}
inline int dec(int a, int b) const { return a -= b, a + ((a >> 31) & mod); }
inline int mul(int a, int b) const { return 1ll * a * b % mod; }
typemod<mod> operator+(const typemod<mod> &x) const {
return typemod(inc(z, x.z));
}
typemod<mod> operator-(const typemod<mod> &x) const {
return typemod(dec(z, x.z));
}
typemod<mod> operator*(const typemod<mod> &x) const {
return typemod(mul(z, x.z));
}
typemod<mod> &operator+=(const typemod<mod> &x) {
*this = *this + x;
return *this;
}
typemod<mod> &operator-=(const typemod<mod> &x) {
*this = *this - x;
return *this;
}
typemod<mod> &operator*=(const typemod<mod> &x) {
*this = *this * x;
return *this;
}
int operator==(const typemod<mod> &x) const { return x.z == z; }
int operator!=(const typemod<mod> &x) const { return x.z != z; }
};
int n, k;
int f[maxn][maxn];
struct Node {
int a, b, id;
int operator<(const Node &z) const { return b == z.b ? a > z.a : b < z.b; }
} a[maxn], tmp[maxn];
int used[maxn][maxn], visin[maxn];
int Out[maxn], In[maxn];
int ans1[maxn], ans2[maxn];
signed main() {
int i, j, t;
r1(t);
while (t--) {
int ans(0), last(0), C(0);
r1(n), r1(k);
for (i = 1; i <= n; ++i) r1(a[i].a), r1(a[i].b), a[i].id = i;
sort(a + 1, a + n + 1);
for (i = 1; i <= n; ++i) ans1[i] = ans2[i] = 0;
for (int st = 1; st <= n; ++st) {
memset(f, -0x3f, sizeof(f));
for (i = 1; i <= n; ++i) visin[i] = 0;
f[0][0] = 0;
for (i = 1; i <= n; ++i) {
for (j = 0; j <= k - 1; ++j) {
if (!j || i == st) {
used[i][j] = 0, f[i][j] = f[i - 1][j];
continue;
}
int tmp = a[i].b * (j - k);
if (f[i - 1][j] > f[i - 1][j - 1] + tmp + a[i].a)
f[i][j] = f[i - 1][j], used[i][j] = 0;
else
f[i][j] = f[i - 1][j - 1] + tmp + a[i].a, used[i][j] = 1;
}
}
i = n, j = k - 1;
while (i && j) {
if (!used[i][j])
--i;
else
In[j] = i, visin[i] = 1, --i, --j;
}
int cnt(0);
for (i = 1; i <= n; ++i)
if (!visin[i] && i != st) Out[++cnt] = i;
int ct1(0);
for (i = 1; i <= cnt; ++i) tmp[++ct1] = a[Out[i]];
sort(tmp + 1, tmp + ct1 + 1);
int res(0);
for (i = 1; i <= ct1; ++i) res += (k - 1) * tmp[i].b;
for (i = 1; i <= k - 1; ++i) res += a[In[i]].a + (i - 1) * a[In[i]].b;
res += a[st].a + (k - 1) * a[st].b;
if (res >= ans) {
ans = res, last = st;
C = cnt;
for (i = 1; i <= k - 1; ++i) ans1[i] = In[i];
for (i = 1; i <= cnt; ++i) ans2[i] = Out[i];
}
}
printf("%d\n", C * 2 + k);
for (i = 1; i <= k - 1; ++i) printf("%d ", a[ans1[i]].id);
for (i = 1; i <= C; ++i) printf("%d %d ", a[ans2[i]].id, -a[ans2[i]].id);
printf("%d\n", a[last].id);
}
return 0;
}
| 12 | CPP |
#include <bits/stdc++.h>
using namespace std;
long long mod = 1000000007;
long long inf = 1LL << 50;
const int N = 75;
int main() {
ios_base::sync_with_stdio(false), cin.tie(0), cout.tie(0);
cin.exceptions(cin.failbit);
int T;
cin >> T;
for (int z = 0; z < T; z++) {
int n, k;
cin >> n >> k;
vector<vector<pair<long long, vector<int>>>> dp(
n, vector<pair<long long, vector<int>>>(k + 1, {-inf, vector<int>()}));
vector<pair<int, pair<int, int>>> srted(n);
for (int i = 0; i < n; i++) {
int a, b;
cin >> a >> b;
srted[i].first = b;
srted[i].second.first = a;
srted[i].second.second = i;
}
sort(srted.begin(), srted.end());
dp[0][1].first = srted[0].second.first;
dp[0][1].second.push_back(srted[0].second.second);
dp[0][0].first = (k - 1) * srted[0].first;
for (int i = 1; i < n; i++) {
dp[i][0].first = dp[i - 1][0].first + srted[i].first * (k - 1);
for (int a = 1; a <= k; a++) {
if (dp[i - 1][a].first + srted[i].first * (k - 1) >
dp[i - 1][a - 1].first + srted[i].first * (a - 1) +
srted[i].second.first) {
dp[i][a].first = dp[i - 1][a].first + srted[i].first * (k - 1);
dp[i][a].second = dp[i - 1][a].second;
} else {
dp[i][a].first = dp[i - 1][a - 1].first + srted[i].first * (a - 1) +
srted[i].second.first;
dp[i][a].second = dp[i - 1][a - 1].second;
dp[i][a].second.push_back(srted[i].second.second);
}
}
}
cout << n + (n - k) << "\n";
vector<bool> visited(n, false);
for (int i = 0; i < dp[n - 1][k].second.size() - 1; i++) {
cout << dp[n - 1][k].second[i] + 1 << " ";
visited[dp[n - 1][k].second[i]] = true;
}
for (int i = 0; i < n; i++) {
if (!visited[i] && i != dp[n - 1][k].second.back()) {
cout << i + 1 << " " << -(i + 1) << " ";
}
}
cout << dp[n - 1][k].second.back() + 1 << '\n';
}
}
| 12 | CPP |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using ull = unsigned long long;
using ld = long double;
template <typename T1, typename T2>
inline void chkmin(T1 &x, const T2 &y) {
if (x > y) x = y;
}
template <typename T1, typename T2>
inline void chkmax(T1 &x, const T2 &y) {
if (x < y) x = y;
}
struct fa {
int a, b, ind;
fa() {}
};
int n, k;
const int MAXN = 76;
fa a[MAXN];
const int INF = 1e9;
int dp[MAXN][MAXN][2];
int par[MAXN][MAXN][2];
void relax(int pref, int cnt, int ind, int val, int fpar) {
if (dp[pref][cnt][ind] >= val) return;
dp[pref][cnt][ind] = val;
par[pref][cnt][ind] = fpar;
}
void solve() {
cin >> n >> k;
for (int i = 0; i < n; i++) {
cin >> a[i].a >> a[i].b;
a[i].ind = i + 1;
}
sort(a, a + n, [&](fa i, fa j) { return i.b < j.b; });
if (k == 1) {
int pos = max_element(a, a + n, [&](fa i, fa j) { return i.a < j.a; }) - a;
cout << 1 << "\n" << a[pos].ind << "\n";
return;
}
if (k == n) {
cout << n << "\n";
for (int i = 0; i < n; i++) {
cout << a[i].ind << " ";
}
cout << "\n";
return;
}
for (int i = 0; i < MAXN; i++) {
for (int j = 0; j < MAXN; j++) {
for (int k = 0; k < 2; k++) {
dp[i][j][k] = -INF;
}
}
}
dp[0][0][0] = 0;
for (int i = 0; i < n; i++) {
for (int cnt = 0; cnt <= k - 1; cnt++) {
for (int flag = 0; flag < 2; flag++) {
if (dp[i][cnt][flag] == -INF) continue;
if (cnt < k - 1)
relax(i + 1, cnt + 1, flag, dp[i][cnt][flag] + a[i].a + a[i].b * cnt,
1);
relax(i + 1, cnt, flag, dp[i][cnt][flag] + a[i].b * (k - 1), 2);
if (!flag) {
relax(i + 1, cnt, 1, dp[i][cnt][flag] + a[i].a + a[i].b * (k - 1), 3);
}
}
}
}
int pos = 0, cnt = 0, flag = 0;
for (int i = 0; i < MAXN; i++) {
if (dp[i][k - 1][1] > dp[pos][cnt][flag]) {
pos = i, cnt = k - 1, flag = 1;
}
}
vector<pair<int, int>> ans;
for (; pos >= 1; pos--) {
ans.push_back({par[pos][cnt][flag], pos});
int ncnt = cnt;
if (par[pos][cnt][flag] == 1) ncnt--;
int nflag = flag;
if (par[pos][cnt][flag] == 3) nflag--;
cnt = ncnt;
flag = nflag;
}
sort(ans.begin(), ans.end());
vector<int> fout;
for (auto i : ans) {
fout.push_back(i.second);
if (i.first == 2) {
fout.push_back(-i.second);
}
}
cout << fout.size() << "\n";
for (auto i : fout) {
cout << a[abs(i) - 1].ind * i / abs(i) << " ";
}
cout << "\n";
}
signed main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int t;
cin >> t;
while (t--) {
solve();
}
return 0;
}
| 12 | CPP |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
const ll MOD = 1000000007;
const int NINF = -1 * 1e9;
void print2d(vector<vector<int>> &v) {
for (int i = 0; i < (int)v.size(); i++) {
for (int j = 0; j < (int)v[i].size(); j++) {
cout << v[i][j] << " ";
}
cout << endl;
}
}
int watson(int n, int k, vector<tuple<int, int, int>> &v, vector<int> &inc,
vector<int> &exl) {
vector<vector<int>> dp(n + 1, vector<int>(k + 1, 0));
vector<vector<int>> par(n + 1, vector<int>(k + 1, 0));
for (int j = 1; j <= k; j++) {
dp[0][j] = NINF;
}
for (int i = 1; i <= n; i++) {
for (int j = 0; j <= k; j++) {
int a = get<1>(v[i - 1]);
int b = get<0>(v[i - 1]);
int x = NINF, y = NINF;
y = dp[i - 1][j] + b * 1LL * (k - 1);
if (j > 0) {
x = dp[i - 1][j - 1] + a + b * 1LL * (j - 1);
}
if (x > y) {
dp[i][j] = x;
par[i][j] = 1;
} else {
dp[i][j] = y;
par[i][j] = 0;
}
}
}
int j = k;
for (int i = n; i > 0; i--) {
int x = get<2>(v[i - 1]);
if (par[i][j] == 1) {
inc.push_back(x);
j -= 1;
} else if (par[i][j] == 0) {
exl.push_back(x);
}
}
reverse((inc).begin(), (inc).end());
int p = dp[n][k];
par.clear();
dp.clear();
return p;
}
void sherlock(int t) {
int n, k;
cin >> n >> k;
vector<tuple<int, int, int>> v(n), v1;
int a, b;
for (int i = 0; i < n; i++) {
cin >> a >> b;
v[i] = {b, a, i + 1};
}
sort((v).begin(), (v).end());
vector<int> inc, exl;
watson(n, k, v, inc, exl);
cout << inc.size() + 2 * exl.size() << endl;
for (int i = 0; i < k - 1; i++) {
cout << inc[i] << " ";
}
for (auto x : exl) {
cout << x << " " << -x << " ";
}
cout << inc.back() << endl;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
int tt;
cin >> tt;
for (int t = 1; t <= tt; t++) sherlock(t);
return 0;
}
| 12 | CPP |
#include <bits/stdc++.h>
using namespace std;
clock_t start;
mt19937_64 rng(chrono::system_clock::now().time_since_epoch().count());
template <typename T>
void _F(const char *name, T arg1) {
cerr << name << " = " << arg1 << '\n';
}
template <typename T, typename... Args>
void _F(const char *names, T arg1, Args... args) {
const char *name = strchr(names, ',');
cerr.write(names, name - names) << " = " << arg1 << '\n';
_F(name + 2, args...);
}
template <typename T1, typename T2>
istream &operator>>(istream &in, pair<T1, T2> &q) {
in >> q.first >> q.second;
return in;
}
template <typename T1, typename T2>
ostream &operator<<(ostream &out, pair<T1, T2> &q) {
out << q.first << " " << q.second;
return out;
}
template <typename T1, typename T2>
pair<T1, T2> operator+(pair<T1, T2> p1, pair<T1, T2> p2) {
return {p1.first + p2.first, p1.second + p2.second};
}
template <typename T1, typename T2>
pair<T1, T2> operator-(pair<T1, T2> p1, pair<T1, T2> p2) {
return {p1.first - p2.first, p1.second - p2.second};
}
const int N = 75 * 2 + 10;
struct MinCostFlow {
struct Edge {
int u, c, f;
Edge *nex;
Edge *rev;
Edge(int _u, int _c, int _f, Edge *_nex) : u(_u), c(_c), f(_f), nex(_nex) {}
};
std::vector<Edge *> g;
MinCostFlow() { g.resize(N); }
void AddEdge(int v, int u, int f, int c) {
g[v] = new Edge(u, c, f, g[v]);
g[u] = new Edge(v, -c, 0, g[u]);
g[v]->rev = g[u];
g[u]->rev = g[v];
}
pair<int, int> Flow(int src, int sink) {
int flow = 0, cost = 0;
while (true) {
std::vector<int> dis(N, (int)(2e9));
std::vector<bool> vis(N, 0);
std::vector<Edge *> par(N);
std::vector<int> mn(N, 0);
queue<int> q;
q.push(src);
vis[src] = 1;
mn[src] = (int)(2e9);
dis[src] = 0;
while (!q.empty()) {
int v = q.front();
q.pop();
vis[v] = 0;
for (auto e = g[v]; e; e = e->nex) {
if (e->f <= 0) continue;
if (dis[e->u] > dis[v] + e->c) {
dis[e->u] = dis[v] + e->c;
mn[e->u] = min(mn[v], e->f);
par[e->u] = e;
if (!vis[e->u]) {
vis[e->u] = 1;
q.push(e->u);
}
}
}
}
if (dis[sink] == (int)(2e9)) break;
cost += dis[sink];
int cur = sink;
flow += mn[sink];
while (cur != src) {
Edge *e = par[cur];
e->f -= mn[sink];
e->rev->f += mn[sink];
cur = e->rev->u;
}
}
return make_pair(flow, cost);
}
int Find(int x) {
for (auto e = g[x]; e; e = e->nex) {
if (e->f == 1) {
return e->u;
}
}
return -1;
}
void Erase() {
while ((int)((g).size())) g.pop_back();
g.resize(N);
}
} Mcf;
void solve() {
int n, k;
cin >> n >> k;
int a[n], b[n];
for (int i = 0; i < n; i++) {
cin >> a[i] >> b[i];
}
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) {
if (j < k - 1)
Mcf.AddEdge(n + i, j, 1, -a[i] - j * b[i]);
else if (j < n - 1)
Mcf.AddEdge(n + i, j, 1, -(k - 1) * b[i]);
else
Mcf.AddEdge(n + i, j, 1, -a[i] - (k - 1) * b[i]);
}
Mcf.AddEdge(i, N - 2, 1, 0);
Mcf.AddEdge(N - 1, i + n, 1, 0);
}
Mcf.Flow(N - 1, N - 2);
cout << k + (n - k) * 2 << '\n';
for (int i = 0; i < k - 1; i++) {
cout << Mcf.Find(i) - n + 1 << " ";
}
for (int i = k - 1; i < n - 1; i++) {
cout << Mcf.Find(i) - n + 1 << " ";
cout << -(Mcf.Find(i) - n + 1) << " ";
}
cout << (Mcf.Find(n - 1) - n + 1) << '\n';
Mcf.Erase();
}
signed main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int t = 1;
start = clock();
cout << fixed << setprecision(20);
cin >> t;
for (int i = 1; i <= t; ++i) {
solve();
}
return 0;
}
| 12 | CPP |
#include <bits/stdc++.h>
using namespace std;
struct Minion {
int ind;
long long a, b;
Minion(int ii = 0, long long ia = 0, long long ib = 0) {
ind = ii;
a = ia;
b = ib;
}
};
bool cmp(Minion a, Minion b) { return a.b < b.b; }
Minion a[100];
long long dp[100][100];
void solve() {
int n, k;
cin >> n >> k;
long long sum = 0;
for (int i = 1; i <= n; i++) {
int a, b;
cin >> a >> b;
::a[i] = Minion(i, a - k * b, b);
}
sort(a + 1, a + n + 1, cmp);
memset(dp, 0, sizeof(dp));
for (int i = 1; i <= n; i++) {
dp[0][i] = -1e14;
}
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= i; j++) {
dp[i][j] = max(dp[i - 1][j], dp[i - 1][j - 1] + a[i].a + j * a[i].b);
}
for (int j = i + 1; j <= n; j++) {
dp[i][j] = -1e14;
}
}
vector<int> ord;
set<int> st;
int ind = n, cnt = k;
while (ind > 0 && cnt > 0) {
if (dp[ind][cnt] == dp[ind - 1][cnt - 1] + a[ind].a + cnt * a[ind].b) {
ord.push_back(ind);
cnt--;
st.insert(ind);
}
ind--;
}
reverse(ord.begin(), ord.end());
vector<int> op;
for (int i = 0; i + 1 < ord.size(); i++) {
op.push_back(a[ord[i]].ind);
}
for (int i = 1; i <= n; i++) {
if (st.find(i) == st.end()) {
op.push_back(a[i].ind);
op.push_back(-a[i].ind);
}
}
op.push_back(a[ord.back()].ind);
cout << op.size() << '\n';
for (auto x : op) {
cout << x << " ";
}
cout << '\n';
}
int main() {
ios::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
cout << setprecision(32);
int t;
cin >> t;
while (t--) solve();
return 0;
}
| 12 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e2 + 10;
vector<int> del, add;
int n, k, dp[maxn][maxn], pre[maxn][maxn];
struct minion {
int a, b, id;
bool operator<(const minion &A) const { return b == A.b ? a < A.a : b < A.b; }
void read(int i) {
id = i;
scanf("%d%d", &a, &b);
}
} da[maxn];
int main() {
int t;
scanf("%d", &t);
while (t--) {
scanf("%d%d", &n, &k);
for (int i = 1; i <= n; ++i) da[i].read(i);
sort(da + 1, da + n + 1);
for (int i = 0; i <= n; ++i)
for (int j = 0; j <= n; ++j) dp[i][j] = -1;
dp[0][0] = 0;
add.clear();
del.clear();
for (int i = 0; i < n; ++i)
for (int j = 0; j <= k; ++j)
if (dp[i][j] >= 0) {
if (dp[i + 1][j] < dp[i][j]) {
dp[i + 1][j] = dp[i][j];
pre[i + 1][j] = 0;
}
if (j < k &&
dp[i + 1][j + 1] < dp[i][j] + da[i + 1].a + da[i + 1].b * j) {
dp[i + 1][j + 1] = dp[i][j] + da[i + 1].a + da[i + 1].b * j;
pre[i + 1][j + 1] = 1;
}
if (dp[i + 1][j] < dp[i][j] + da[i + 1].b * (k - 1)) {
dp[i + 1][j] = dp[i][j] + da[i + 1].b * (k - 1);
pre[i + 1][j] = 2;
}
}
for (int i = n, j = k; i; --i) {
if (!pre[i][j]) continue;
if (pre[i][j] == 1) {
--j;
add.push_back(da[i].id);
} else {
del.push_back(da[i].id);
}
}
printf("%d\n", add.size() + del.size() * 2);
for (int i = add.size() - 1; i; --i) printf("%d ", add[i]);
for (auto x : del) printf("%d %d ", x, -x);
printf("%d\n", add[0]);
}
return 0;
}
| 12 | CPP |
#include <bits/stdc++.h>
using namespace std;
int me[76][76];
int de[76][76];
int n, k;
int res[200];
const int INF = 1000000000;
vector<pair<int, pair<int, int> > > mv;
int dp(int ac, int ll) {
if (me[ac][ll] >= 0) return me[ac][ll];
if (ac == n) return me[ac][ll] = 0;
if (ll < k) {
me[ac][ll] = mv[ac].first * ll + dp(ac + 1, ll + 1) + mv[ac].second.first;
de[ac][ll] = 0;
}
if (n - ac - 1 + ll >= k) {
int can = mv[ac].first * (k - 1) + dp(ac + 1, ll);
if (can > me[ac][ll]) {
me[ac][ll] = can;
de[ac][ll] = 1;
}
}
return me[ac][ll];
}
int it;
void rec(int ac, int ll) {
if (ac == n) return;
if (de[ac][ll]) {
res[it++] = mv[ac].second.second + 1;
res[it++] = -mv[ac].second.second - 1;
rec(ac + 1, ll);
} else {
res[ll] = mv[ac].second.second + 1;
rec(ac + 1, ll + 1);
}
}
int main() {
cin.tie(0);
ios_base::sync_with_stdio(0);
int t;
cin >> t;
while (t--) {
cin >> n >> k;
mv.clear();
mv.resize(n);
for (int i = 0; i < n; i++) {
mv[i].second.second = i;
cin >> mv[i].second.first >> mv[i].first;
}
sort(mv.begin(), mv.end());
it = k;
memset(me, -1, sizeof me);
dp(0, 0);
rec(0, 0);
cout << it << endl;
for (int i = 0; i < k - 1; i++) cout << res[i] << ' ';
for (int i = k; i < it; i++) cout << res[i] << ' ';
cout << res[k - 1] << endl;
}
return 0;
}
| 12 | CPP |
#include <bits/stdc++.h>
using namespace std;
void solve() {
int n, k;
cin >> n >> k;
long long a1[n], b1[n];
for (int i = 0; i < n; i++) cin >> a1[i] >> b1[i];
long long dp[n][k];
vector<long long> a, b;
vector<pair<pair<long long, long long>, long long> > e;
vector<long long> ans;
long long mx = 0;
for (int p = 0; p < n; p++) {
a.clear();
b.clear();
e.clear();
for (int i = 0; i < n; i++)
if (i == p)
continue;
else
e.push_back(make_pair(make_pair(b1[i], a1[i]), i));
sort(e.begin(), e.end());
a.push_back(0);
b.push_back(0);
for (int i = 0; i < e.size(); i++) {
a.push_back(e[i].first.second);
b.push_back(e[i].first.first);
}
for (int i = 0; i < n; i++)
for (int j = 0; j < k; j++) dp[i][j] = -1e9;
dp[0][0] = 0;
for (int i = 1; i < n; i++)
for (int j = 0; j < k; j++) {
dp[i][j] = max(dp[i][j], dp[i - 1][j] + b[i] * (k - 1));
if (j > 0)
dp[i][j] = max(dp[i][j], dp[i - 1][j - 1] + b[i] * (j - 1) + a[i]);
}
if (mx < a1[p] + b1[p] * (k - 1) + dp[n - 1][k - 1]) {
mx = a1[p] + b1[p] * (k - 1) + dp[n - 1][k - 1];
vector<long long> x, bad;
int i = n - 1, j = k - 1;
while (dp[i][j] > 0) {
if (j > 0) {
if (dp[i - 1][j - 1] + b[i] * (j - 1) + a[i] == dp[i][j]) {
x.push_back(e[i - 1].second + 1);
i--;
j--;
} else {
bad.push_back(-e[i - 1].second - 1);
bad.push_back(e[i - 1].second + 1);
i--;
}
} else {
bad.push_back(-e[i - 1].second - 1);
bad.push_back(e[i - 1].second + 1);
i--;
}
}
reverse(x.begin(), x.end());
reverse(bad.begin(), bad.end());
for (int i = 0; i < bad.size(); i++) x.push_back(bad[i]);
x.push_back(p + 1);
ans = x;
}
}
cout << ans.size() << "\n";
for (int i = 0; i < ans.size(); i++) cout << ans[i] << ' ';
cout << "\n";
}
int main() {
ios::sync_with_stdio(0);
int q;
cin >> q;
while (q--) solve();
}
| 12 | CPP |
#include <bits/stdc++.h>
#pragma GCC optimize("Ofast")
using namespace std;
void *wmem;
char memarr[96000000];
template <class T>
inline void walloc1d(T **arr, int x, void **mem = &wmem) {
static int skip[16] = {0, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1};
(*mem) = (void *)(((char *)(*mem)) + skip[((unsigned long long)(*mem)) & 15]);
(*arr) = (T *)(*mem);
(*mem) = ((*arr) + x);
}
template <class T1, class T2>
void sortA_L(int N, T1 a[], T2 b[], void *mem = wmem) {
int i;
pair<T1, T2> *arr;
walloc1d(&arr, N, &mem);
for (i = (0); i < (N); i++) {
arr[i].first = a[i];
arr[i].second = b[i];
}
sort(arr, arr + N);
for (i = (0); i < (N); i++) {
a[i] = arr[i].first;
b[i] = arr[i].second;
}
}
template <class T1, class T2, class T3>
void sortA_L(int N, T1 a[], T2 b[], T3 c[], void *mem = wmem) {
int i;
pair<T1, pair<T2, T3> > *arr;
walloc1d(&arr, N, &mem);
for (i = (0); i < (N); i++) {
arr[i].first = a[i];
arr[i].second.first = b[i];
arr[i].second.second = c[i];
}
sort(arr, arr + N);
for (i = (0); i < (N); i++) {
a[i] = arr[i].first;
b[i] = arr[i].second.first;
c[i] = arr[i].second.second;
}
}
inline int my_getchar() {
static char buf[1048576];
static int s = 1048576;
static int e = 1048576;
if (s == e && e == 1048576) {
e = fread(buf, 1, 1048576, stdin);
s = 0;
}
if (s == e) {
return EOF;
}
return buf[s++];
}
inline void rd(int &x) {
int k;
int m = 0;
x = 0;
for (;;) {
k = my_getchar();
if (k == '-') {
m = 1;
break;
}
if ('0' <= k && k <= '9') {
x = k - '0';
break;
}
}
for (;;) {
k = my_getchar();
if (k < '0' || k > '9') {
break;
}
x = x * 10 + k - '0';
}
if (m) {
x = -x;
}
}
inline void rd(long long &x) {
int k;
int m = 0;
x = 0;
for (;;) {
k = my_getchar();
if (k == '-') {
m = 1;
break;
}
if ('0' <= k && k <= '9') {
x = k - '0';
break;
}
}
for (;;) {
k = my_getchar();
if (k < '0' || k > '9') {
break;
}
x = x * 10 + k - '0';
}
if (m) {
x = -x;
}
}
inline int rd_int(void) {
int x;
rd(x);
return x;
}
struct MY_WRITER {
char buf[1048576];
int s;
int e;
MY_WRITER() {
s = 0;
e = 1048576;
}
~MY_WRITER() {
if (s) {
fwrite(buf, 1, s, stdout);
}
}
};
MY_WRITER MY_WRITER_VAR;
void my_putchar(int a) {
if (MY_WRITER_VAR.s == MY_WRITER_VAR.e) {
fwrite(MY_WRITER_VAR.buf, 1, MY_WRITER_VAR.s, stdout);
MY_WRITER_VAR.s = 0;
}
MY_WRITER_VAR.buf[MY_WRITER_VAR.s++] = a;
}
inline void wt_L(char a) { my_putchar(a); }
inline void wt_L(int x) {
int s = 0;
int m = 0;
char f[10];
if (x < 0) {
m = 1;
x = -x;
}
while (x) {
f[s++] = x % 10;
x /= 10;
}
if (!s) {
f[s++] = 0;
}
if (m) {
my_putchar('-');
}
while (s--) {
my_putchar(f[s] + '0');
}
}
int N;
int K;
int ind[75];
long long A[75];
long long B[75];
long long dp[76][76];
int bk[76][76];
int use[75];
int fg[75];
int ress;
int res[150];
int main() {
int Lj4PdHRW;
wmem = memarr;
int KL2GvlyY = rd_int();
for (Lj4PdHRW = (0); Lj4PdHRW < (KL2GvlyY); Lj4PdHRW++) {
int i;
int j;
rd(N);
rd(K);
{
int cTE1_r3A;
for (cTE1_r3A = (0); cTE1_r3A < (N); cTE1_r3A++) {
rd(A[cTE1_r3A]);
rd(B[cTE1_r3A]);
}
}
for (i = (0); i < (N); i++) {
ind[i] = i + 1;
}
sortA_L(N, B, A, ind);
for (i = (0); i < (N); i++) {
fg[i] = 0;
}
for (i = (0); i < (N + 1); i++) {
for (j = (0); j < (N + 1); j++) {
dp[i][j] = -4611686016279904256LL;
}
}
dp[0][0] = 0;
for (i = (0); i < (N); i++) {
for (j = (0); j < (i + 1); j++) {
if (dp[i][j] > -4611686016279904256LL) {
if (dp[i + 1][j] < dp[i][j] + B[i] * (K - 1)) {
dp[i + 1][j] = dp[i][j] + B[i] * (K - 1);
bk[i + 1][j] = j;
}
if (dp[i + 1][j + 1] < dp[i][j] + A[i] + B[i] * j) {
dp[i + 1][j + 1] = dp[i][j] + A[i] + B[i] * j;
bk[i + 1][j + 1] = j;
}
}
}
}
j = K;
for (i = (N)-1; i >= (0); i--) {
if (bk[i + 1][j] == j) {
continue;
}
j--;
use[j] = i;
fg[i] = 1;
}
ress = 0;
for (i = (0); i < (K - 1); i++) {
res[ress++] = ind[use[i]];
}
for (i = (0); i < (N); i++) {
if (!fg[i]) {
res[ress++] = ind[i];
res[ress++] = -ind[i];
}
}
res[ress++] = ind[use[K - 1]];
wt_L(ress);
wt_L('\n');
{
int BUotOFBp;
if (ress == 0) {
wt_L('\n');
} else {
for (BUotOFBp = (0); BUotOFBp < (ress - 1); BUotOFBp++) {
wt_L(res[BUotOFBp]);
wt_L(' ');
}
wt_L(res[BUotOFBp]);
wt_L('\n');
}
}
}
return 0;
}
| 12 | CPP |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.