text
stringlengths 49
983k
|
|---|
#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;
long long 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(long long int idx, long long 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(long long int idx, long long 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) {
trace(idx + 1, cnt + 1);
good.push_back(p[idx].second);
} else {
trace(idx + 1, cnt);
bad.push_back(p[idx].second);
}
}
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);
for (int i = 1; i <= n; ++i) {
;
}
memset(dp, -1, sizeof(dp));
long long int now = solve(1, 0);
;
trace(1, 0);
reverse((good).begin(), (good).end());
reverse((bad).begin(), (bad).end());
if (good.size() == 0) {
string ss = "";
ss += to_string(n);
ss += '#';
ss += to_string(k);
ss += '#';
for (int i = 1; i <= n; ++i) {
ss += to_string(p[i].first.first);
ss += '#';
ss += to_string(p[i].first.second);
ss += '&';
}
cout << ss << '\n';
continue;
}
cout << good.size() + (2 * bad.size()) << '\n';
for (int i = 0; i < (int)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;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 80;
struct minion {
int a, b, ind;
bool operator<(const minion &other) const { return b < other.b; }
} minions[N];
int n, k;
int memo[N][N], vis[N][N], vid;
int solve(int i, int cnt) {
if (i == n) return cnt == k ? 0 : -1e9;
int &ret = memo[i][cnt];
if (vis[i][cnt] == vid) return ret;
vis[i][cnt] = vid;
ret = solve(i + 1, cnt) + minions[i].b * (k - 1);
if (cnt < k)
ret = max(ret, solve(i + 1, cnt + 1) + minions[i].a + minions[i].b * cnt);
return ret;
}
vector<int> keep, dest;
void path(int i, int cnt) {
if (i == n) return;
if (solve(i + 1, cnt) + minions[i].b * (k - 1) == solve(i, cnt)) {
dest.push_back(minions[i].ind);
return path(i + 1, cnt);
}
keep.push_back(minions[i].ind);
path(i + 1, cnt + 1);
}
void run() {
cin >> n >> k;
for (int i = 0; i < n; i++) {
cin >> minions[i].a >> minions[i].b;
minions[i].ind = i + 1;
}
sort(minions, minions + n);
++vid;
keep.clear();
dest.clear();
path(0, 0);
cout << keep.size() + dest.size() * 2 << '\n';
for (int i = 0; i + 1 < keep.size(); i++) cout << keep[i] << ' ';
for (int x : dest) cout << x << ' ' << -x << ' ';
cout << keep.back() << '\n';
}
int main() {
ios::sync_with_stdio(0), cin.tie(0), cout.tie(0);
int t;
cin >> t;
while (t--) run();
}
|
#include <bits/stdc++.h>
using namespace std;
const int mod = 998244353;
const int inf = 1e9;
const int N = 5005;
const int mf[] = {0, 0, 1, -1}, mc[] = {1, -1, 0, 0};
const double eps = 1e-9;
const double pi = acos(-1);
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
int t;
cin >> t;
while (t--) {
int n, k;
cin >> n >> k;
vector<pair<pair<int, int>, int>> v(n);
for (int i = 0; i < n; i++) {
cin >> v[i].first.first >> v[i].first.second;
v[i].second = i + 1;
}
sort((v).begin(), (v).end(),
[&](pair<pair<int, int>, int> i, pair<pair<int, int>, int> j) {
return i.first.second < j.first.second;
});
vector<vector<int>> dp(n + 1, vector<int>(k + 1, -inf));
dp[0][0] = 0;
for (int i = 1; i <= n; i++) {
int a = v[i - 1].first.first;
int b = v[i - 1].first.second;
dp[i][0] = dp[i - 1][0] + (k - 1) * b;
for (int j = 1; j <= k; j++)
dp[i][j] =
max(dp[i - 1][j] + (k - 1) * b, dp[i - 1][j - 1] + a + (j - 1) * b);
}
vector<bool> mark(n + 1);
vector<int> stay;
int j = k;
for (int i = n; i >= 1; i--) {
int a = v[i - 1].first.first;
int b = v[i - 1].first.second;
int id = v[i - 1].second;
if (dp[i][j] == dp[i - 1][j - 1] + a + (j - 1) * b) {
mark[id] = true;
stay.push_back(id);
j--;
}
}
vector<int> ans;
for (int i = k - 1; i > 0; i--) ans.push_back(stay[i]);
for (int i = 1; i <= n; i++)
if (!mark[i]) {
ans.push_back(i);
ans.push_back(-i);
}
ans.push_back(stay[0]);
cout << k + 2 * (n - k) << '\n';
for (int &i : ans) cout << i << " \n"[&i == &ans.back()];
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const pair<long long, long long> IMPOSSIBLE =
make_pair(-999999999999999999, -1);
class Minion {
public:
long long a, b;
int minionId;
bool operator<(const Minion& that) const { return b < that.b; }
Minion(int ma, int mb, int mid) : a(ma), b(mb), minionId(mid) {}
Minion() {}
};
vector<int> getMaximumPowerSequence(int n, int k, vector<Minion> minions) {
sort(minions.begin(), minions.end());
pair<long long, long long> dp[n + 2][k + 1];
for (int i = 0; i <= k; i++) dp[n + 1][i] = IMPOSSIBLE;
dp[n + 1][0] = make_pair(0, -1);
for (int oi = 0; oi < n; oi++) {
pair<long long, long long>* olddp = dp[n + 1];
if (oi > 0) olddp = dp[oi - 1];
pair<long long, long long>* newdp = dp[oi];
for (int i = 0; i <= k; i++) newdp[i] = IMPOSSIBLE;
long long NOT_CHOSEN_BONUS = (long long)(k - 1) * minions[oi].b;
for (int i = 0; i <= k; i++) {
newdp[i] = max(newdp[i], make_pair(olddp[i].first + NOT_CHOSEN_BONUS,
olddp[i].second));
if (i + 1 <= k) {
long long CHOSEN_BONUS = minions[oi].b * i + minions[oi].a;
newdp[i + 1] =
max(newdp[i + 1],
make_pair(olddp[i].first + CHOSEN_BONUS, (long long)oi));
}
}
}
int currentStanding = n - 1;
int toSelect = k;
stack<int> selectedMinion;
vector<bool> isSelected(n + 1, false);
while (toSelect > 0) {
int nextOffer = dp[currentStanding][toSelect].second;
selectedMinion.push(minions[nextOffer].minionId);
isSelected[minions[nextOffer].minionId] = true;
currentStanding = nextOffer - 1;
toSelect--;
}
vector<int> ans;
while (selectedMinion.size() > 1) {
int cm = selectedMinion.top();
selectedMinion.pop();
ans.push_back(cm);
}
for (int i = 1; i <= n; i++) {
if (!isSelected[i]) {
ans.push_back(i);
ans.push_back(-i);
}
}
while (selectedMinion.size() > 0) {
int cm = selectedMinion.top();
selectedMinion.pop();
ans.push_back(cm);
}
return ans;
}
int main() {
int tc;
scanf("%d", &tc);
while (tc--) {
int n, k;
scanf("%d%d", &n, &k);
vector<Minion> minions;
for (int i = 1; i <= n; i++) {
int a, b;
scanf("%d%d", &a, &b);
minions.push_back(Minion(a, b, i));
}
vector<int> answer_sequence = getMaximumPowerSequence(n, k, minions);
printf("%d\n", answer_sequence.size());
for (int v : answer_sequence) printf("%d ", v);
printf("\n");
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <typename T>
T &read(T &x) {
x = 0;
bool f = 0;
char ch = getchar();
while (ch < '0' || ch > '9') {
if (ch == '-') {
f = 1;
}
ch = getchar();
}
while (ch >= '0' && ch <= '9') {
x = (x << 1) + (x << 3) + (ch ^ 48);
ch = getchar();
}
if (f) {
x = -x;
}
return x;
}
const double eps = 1e-8;
inline int sgn(double x) {
if (x < -eps) {
return -1;
}
return x > eps;
}
void fp() {
freopen(".in", "r", stdin);
freopen(".out", "w", stdout);
}
struct pai {
int a, b, num;
} c[80];
inline bool cmp(pai a, pai b) { return a.b < b.b; }
int f[80][80], g[80][80], ans1[155], ans2[155];
int main() {
int t = read(t);
while (t--) {
int n = read(n), k = read(k), i, j;
for (i = 1; i <= n; i++) {
read(c[i].a);
read(c[i].b);
c[i].num = i;
}
sort(c + 1, c + n + 1, cmp);
for (i = 1; i <= n; i++) {
for (j = 0; j <= min(k, i); j++) {
if (j == i) {
f[i][j] = f[i - 1][j - 1] + c[i].a + c[i].b * (j - 1);
g[i][j] = 2;
continue;
}
if (!j) {
f[i][j] = f[i - 1][j] + c[i].b * (k - 1);
g[i][j] = 1;
continue;
}
if (f[i - 1][j - 1] + c[i].a + c[i].b * (j - 1) <
f[i - 1][j] + c[i].b * (k - 1)) {
f[i][j] = f[i - 1][j] + c[i].b * (k - 1);
g[i][j] = 1;
} else {
f[i][j] = f[i - 1][j - 1] + c[i].a + c[i].b * (j - 1);
g[i][j] = 2;
}
}
}
printf("%d\n", 2 * n - k);
int nowx = n, nowy = k, cnt1 = 0, cnt2 = 0;
for (i = 1; i <= n; i++) {
if (g[nowx][nowy] == 1) {
ans1[++cnt1] = -c[nowx].num;
ans1[++cnt1] = c[nowx].num;
nowx--;
} else {
nowx--;
nowy--;
}
}
nowx = n;
nowy = k;
for (i = 1; i <= n; i++) {
if (g[nowx][nowy] == 1) {
nowx--;
} else {
ans2[++cnt2] = c[nowx].num;
nowx--;
nowy--;
}
}
for (i = cnt2; i >= 2; i--) {
printf("%d ", ans2[i]);
}
for (i = cnt1; i; i--) {
printf("%d ", ans1[i]);
}
printf("%d ", ans2[1]);
puts("");
}
return 0;
}
|
#include <bits/stdc++.h>
#pragma GCC optimize("O3")
#pragma GCC target("sse4")
using namespace std;
const double PI = acos(-1.0);
mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
long long MinCostMatching(const vector<vector<long long>> &cost,
vector<long long> &Lmate, vector<long long> &Rmate) {
long long n = (long long)(cost.size());
vector<long long> u(n);
vector<long long> v(n);
for (long long i = 0; i < n; i++) {
u[i] = cost[i][0];
for (long long j = 1; j < n; j++) {
u[i] = min(u[i], cost[i][j]);
}
}
for (long long j = 0; j < n; j++) {
v[j] = cost[0][j] - u[0];
for (long long i = 1; i < n; i++) {
v[j] = min(v[j], cost[i][j] - u[i]);
}
}
Lmate = vector<long long>(n, -1);
Rmate = vector<long long>(n, -1);
long long mated = 0;
for (long long i = 0; i < n; i++) {
for (long long j = 0; j < n; j++) {
if (Rmate[j] != -1) {
continue;
}
if (abs(cost[i][j] - u[i] - v[j]) == 0) {
Lmate[i] = j;
Rmate[j] = i;
mated++;
break;
}
}
}
vector<long long> dist(n);
vector<long long> dad(n);
vector<long long> seen(n);
while (mated < n) {
long long s = 0;
while (Lmate[s] != -1) {
s++;
}
fill(dad.begin(), dad.end(), -1);
fill(seen.begin(), seen.end(), 0);
for (long long k = 0; k < n; k++) {
dist[k] = cost[s][k] - u[s] - v[k];
}
long long j = 0;
while (true) {
j = -1;
for (long long k = 0; k < n; k++) {
if (seen[k]) {
continue;
}
if (j == -1 || dist[k] < dist[j]) {
j = k;
}
}
seen[j] = 1;
if (Rmate[j] == -1) {
break;
}
const long long i = Rmate[j];
for (long long k = 0; k < n; k++) {
if (seen[k]) {
continue;
}
const long long new_dist = dist[j] + cost[i][k] - u[i] - v[k];
if (dist[k] > new_dist) {
dist[k] = new_dist;
dad[k] = j;
}
}
}
for (long long k = 0; k < n; k++) {
if (k == j || !seen[k]) {
continue;
}
const long long i = Rmate[k];
v[k] += dist[k] - dist[j];
u[i] -= dist[k] - dist[j];
}
u[s] += dist[j];
while (dad[j] >= 0) {
const long long d = dad[j];
Rmate[j] = Rmate[d];
Lmate[Rmate[j]] = j;
j = d;
}
Rmate[j] = s;
Lmate[s] = j;
mated++;
}
long long value = 0;
for (long long i = 0; i < n; i++) {
value += cost[i][Lmate[i]];
}
return value;
}
int32_t main() {
ios::sync_with_stdio(0);
cin.tie(0);
long long t;
cin >> t;
while (t--) {
long long n, k;
cin >> n >> k;
long long a[n + 5], b[n + 5];
for (long long i = 0; i < n; i++) {
cin >> a[i] >> b[i];
}
vector<vector<long long>> mat(n, vector<long long>(n, 0));
for (long long i = 0; i < (k - 1); i++) {
for (long long j = 0; j < n; j++) {
long long pft = a[j] + min(i, k - 1) * b[j];
mat[i][j] = -pft;
}
}
for (long long i = k - 1; i < n - 1; i++) {
for (long long j = 0; j < n; j++) {
long long pft = min(i, k - 1) * b[j];
mat[i][j] = -pft;
}
}
for (long long j = 0; j < n; j++) {
long long i = n - 1;
long long pft = a[j] + min(i, k - 1) * b[j];
mat[i][j] = -pft;
}
vector<long long> l, r;
long long pft = -MinCostMatching(mat, l, r);
cerr << "pft"
<< "=" << pft << "\n";
cout << k + 2 * (n - k) << "\n";
for (long long i = 0; i < k - 1; i++) {
cout << l[i] + 1 << " ";
}
for (long long i = k - 1; i < n - 1; i++) {
cout << l[i] + 1 << " ";
cout << -l[i] - 1 << " ";
}
cout << l[n - 1] + 1 << " ";
cout << "\n";
}
}
|
#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();
}
|
#include <bits/stdc++.h>
using namespace std;
template <typename T>
inline void read(T &x) {
static char _c;
static bool _f;
x = 0;
_f = 0;
_c = getchar();
while (_c < '0' || '9' < _c) {
if (_c == '-') _f = true;
_c = getchar();
}
while ('0' <= _c && _c <= '9') {
x = (x << 1) + (x << 3) + (_c & 15);
_c = getchar();
}
if (_f) x = -x;
}
template <typename T, typename... Args>
inline void read(T &x, Args &...args) {
read(x);
read(args...);
}
template <typename T>
inline void Min(T &x, T y) {
if (y < x) x = y;
}
template <typename T>
inline void Max(T &x, T y) {
if (x < y) x = y;
}
const int INF = 0x3f3f3f3f;
const long long LINF = 0x3f3f3f3f3f3f3f3f;
const double pi = (double)acos(-1.0);
const double eps = (double)1e-8;
const int e5 = (int)1e5 + 5;
const int MOD = (int)1000000007;
template <typename T0, typename T1>
inline void depair(T0 &x, T1 &y, pair<T0, T1> &p) {
x = p.first, y = p.second;
}
inline int sig(double x) { return x < -eps ? -1 : eps < x; }
long long fp(long long a, long long n, long long mod = MOD) {
if (n < 0) a = fp(a, mod - 2, mod), n = -n;
long long res = 1;
for (; n; n >>= 1, a = a * a % mod)
if (n & 1) res = res * a % mod;
return res;
}
struct Mint {
int x;
Mint() { x = 0; }
Mint(int _x) : x(_x) {
if (x < 0 || x >= MOD) x = (x % MOD + MOD) % MOD;
}
Mint(long long _x) : x(_x) {
if (x < 0 || x >= MOD) x = (x % MOD + MOD) % MOD;
}
Mint operator-() const { return Mint(MOD - x); }
Mint operator+(const Mint &rhs) const {
return Mint(x + rhs.x >= MOD ? x + rhs.x - MOD : x + rhs.x);
}
Mint operator-(const Mint &rhs) const {
return Mint(x - rhs.x < 0 ? x - rhs.x + MOD : x - rhs.x);
}
Mint operator*(const Mint &rhs) const {
return Mint((long long)x * rhs.x % MOD);
}
Mint operator/(const Mint &rhs) const {
return Mint(x * fp(rhs.x, -1) % MOD);
}
Mint &operator+=(const Mint &rhs) {
x += rhs.x;
if (x >= MOD) x -= MOD;
return *this;
}
Mint &operator*=(const Mint &rhs) {
x = ((long long)x * rhs.x) % MOD;
return *this;
}
bool operator==(const Mint &rhs) const { return x == rhs.x; }
bool operator!=(const Mint &rhs) const { return x != rhs.x; }
friend ostream &operator<<(ostream &out, const Mint &rhs) {
return out << rhs.x;
}
friend istream &operator>>(istream &in, Mint &rhs) { return in >> rhs.x; }
};
const int maxn = (int)2e5 + 20;
const int maxm = (int)1e6 + 20;
void work() {
int n, k;
cin >> n >> k;
vector<tuple<int, int, int> > a(n);
for (int i = 0; i < n; i++) {
int x, y;
cin >> x >> y;
a[i] = make_tuple(x, y, i);
}
sort(a.begin(), a.end(),
[](tuple<int, int, int> lhs, tuple<int, int, int> rhs) {
return get<1>(lhs) < get<1>(rhs);
});
vector<vector<int> > dp(n + 1, vector<int>(k + 1, -INF));
dp[0][0] = 0;
for (int i = 0; i < n; i++) {
int x, y, id;
tie(x, y, id) = a[i];
for (int j = 0; j <= k; j++) {
Max(dp[i + 1][j], dp[i][j] + (k - 1) * y);
if (j != k) Max(dp[i + 1][j + 1], dp[i][j] + x + j * y);
}
}
vector<int> sta(n, -1);
int ni = n, nj = k;
int cnt = k;
while (ni) {
int x, y, id;
tie(x, y, id) = a[ni - 1];
if (nj && dp[ni - 1][nj - 1] + (nj - 1) * y + x == dp[ni][nj]) {
sta[id] = cnt--;
nj--;
}
ni--;
}
vector<int> opt;
for (int i = 1; i <= k; i++) {
if (i == k) {
for (int j = 0; j < n; j++)
if (sta[j] == -1) opt.push_back(j + 1), opt.push_back(-j - 1);
}
for (int j = 0; j < n; j++)
if (sta[j] == i) opt.push_back(j + 1);
}
cout << opt.size() << endl;
for (int i = 0; i < opt.size(); i++) {
cout << opt[i];
if (i != opt.size() - 1) cout << " ";
}
cout << endl;
}
int main(int argc, char **argv) {
int tc = 1;
read(tc);
for (int ca = 1; ca <= tc; ca++) {
work();
}
return 0;
}
|
#include <bits/stdc++.h>
#pragma GCC optimize("Ofast, unroll-loops", "omit-frame-pointer", "inline")
#pragma GCC option("arch=native", "tune=native", "no-zero-upper")
#pragma GCC target( \
"sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,tune=native,avx2")
using namespace std;
using ll = long long;
using ull = unsigned long long;
using ld = long double;
mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
int getrnd(int l, int r) { return uniform_int_distribution<int>(l, r)(rng); }
ll getrndll(ll l, ll r) { return uniform_int_distribution<ll>(l, r)(rng); }
template <typename T1, typename T2>
inline bool relax(T1& a, const T2& b) {
if (a > b) {
a = b;
return 1;
}
return 0;
}
template <typename T1, typename T2>
inline bool strain(T1& a, const T2& b) {
if (a < b) {
a = b;
return 1;
}
return 0;
}
void solve() {
int n, k;
cin >> n >> k;
vector<pair<int, pair<int, int>>> a(n);
for (int i = 0; i < n; ++i)
cin >> a[i].second.first >> a[i].first, a[i].second.second = i;
sort(a.begin(), a.end());
vector<int> dp(k + 1, -1e9);
vector<vector<int>> from(n, vector<int>(k + 1));
dp[0] = 0;
for (int i = 0; i < n; ++i) {
vector<int> ndp(k + 1, -1e9);
for (int j = 0; j <= min(i, k); ++j) {
if (strain(ndp[j], dp[j] + (k - 1) * a[i].first)) from[i][j] = 0;
if (j + 1 <= k &&
strain(ndp[j + 1], dp[j] + a[i].second.first + a[i].first * j))
from[i][j + 1] = 1;
}
dp.swap(ndp);
}
int cur = k;
vector<int> have;
for (int i = n - 1; i >= 0; --i) {
if (from[i][cur]) {
have.push_back(a[i].second.second);
--cur;
}
}
assert(cur == 0);
reverse(have.begin(), have.end());
vector<int> ans;
for (int i = 0; i < k - 1; ++i) ans.push_back(have[i] + 1);
for (int i = 0; i < n; ++i)
if (count(have.begin(), have.end(), i) == 0)
ans.push_back(i + 1), ans.push_back(-(i + 1));
ans.push_back(have.back() + 1);
cout << ans.size() << '\n';
for (int x : ans) cout << x << ' ';
cout << '\n';
}
int main() {
ios::sync_with_stdio(0);
cin.tie(nullptr);
cout.tie(nullptr);
srand(time(0));
int t = 1;
cin >> t;
while (t--) solve();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <typename T>
void __read(T &a) {
cin >> a;
}
template <typename T, typename... Args>
void __read(T &a, Args &...args) {
cin >> a;
__read(args...);
}
constexpr long long M7 = 1000000007ll;
constexpr long long M9 = 1000000009ll;
constexpr long long MFFT = 998244353ll;
template <class T>
void outv(T &a) {
for (auto &x : a) cout << x << ' ';
}
static mt19937 rnd(static_cast<unsigned>(
chrono::steady_clock::now().time_since_epoch().count()));
auto __fast_io__ = (ios_base::sync_with_stdio(false), cin.tie(nullptr));
int32_t main() {
int t;
__read(t);
while (t--) {
int n, k;
__read(n, k);
vector<pair<int, int>> a(n);
for (auto &[l, r] : a) {
cin >> l >> r;
}
vector<int> ind(n);
iota((ind).begin(), (ind).end(), 0);
sort((ind).begin(), (ind).end(),
[&](int i, int j) { return a[i].second < a[j].second; });
vector<vector<int>> dp(n + 1, vector<int>(k + 1, -1));
vector<vector<int>> pr(n + 1, vector<int>(k + 1, -1));
dp[0][0] = 0;
for (int i = 0; i < n; ++i) {
auto &[l, r] = a[ind[i]];
for (int j = 0; j <= k; ++j) {
if (dp[i][j] == -1) {
continue;
}
if (j + 1 <= k) {
if (dp[i + 1][j + 1] < dp[i][j] + l + r * j) {
dp[i + 1][j + 1] = dp[i][j] + l + r * j;
pr[i + 1][j + 1] = j;
}
}
if (dp[i + 1][j] < dp[i][j] + r * (k - 1)) {
dp[i + 1][j] = dp[i][j] + r * (k - 1);
pr[i + 1][j] = j;
}
}
}
vector<int> g, b;
int j = k;
for (int i = n - 1; i >= 0; --i) {
if (pr[i + 1][j] == j) {
b.push_back(ind[i]);
} else {
g.push_back(ind[i]);
}
j = pr[i + 1][j];
}
reverse((g).begin(), (g).end());
reverse((b).begin(), (b).end());
cout << b.size() * 2 + g.size() << '\n';
for (int i = 0; i + 1 < g.size(); ++i) {
cout << g[i] + 1 << ' ';
}
for (auto &i : b) {
cout << i + 1 << ' ' << -(i + 1) << ' ';
}
cout << g.back() + 1 << '\n';
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
using uint = unsigned int;
using ll = long long;
using ld = long double;
using ull = unsigned long long;
using pii = pair<int, int>;
using pll = pair<ll, ll>;
void debug_out() { cerr << endl; }
template <typename Head, typename... Tail>
void debug_out(Head H, Tail... T) {
cerr << " " << H;
debug_out(T...);
}
template <typename T1, typename T2>
ostream &operator<<(ostream &out, const pair<T1, T2> &item) {
out << '(' << item.first << ", " << item.second << ')';
return out;
}
template <typename T>
ostream &operator<<(ostream &out, const vector<T> &v) {
for (const auto &item : v) out << item << ' ';
return out;
}
const int N = 80;
struct Minion {
int id, a, b;
bool operator<(const Minion &o) const { return b < o.b; }
};
ll s[N];
bool ok[N];
int prv[N][N];
ll dp[N][N];
Minion v[N];
int main() {
ios_base::sync_with_stdio(false);
int t, n, k;
for (cin >> t; t; --t) {
cin >> n >> k;
for (int i = 1; i <= n; ++i) cin >> v[i].a >> v[i].b, v[i].id = i;
sort(v + 1, v + n + 1);
for (int i = 1; i <= n; ++i) s[i] = s[i - 1] + v[i].b;
memset(dp, -1, sizeof dp);
dp[0][0] = 0;
int lst = -1;
ll ans = 0;
for (int i = 1; i <= n; ++i)
for (int nr = 1; nr <= i && nr <= k; ++nr) {
for (int j = 0; j < i; ++j) {
if (dp[j][nr - 1] < 0) continue;
ll val = dp[j][nr - 1] + v[i].a + 1LL * v[i].b * (nr - 1) +
1LL * (s[i - 1] - s[j]) * (k - 1);
if (val > dp[i][nr]) dp[i][nr] = val, prv[i][nr] = j;
}
if (dp[i][k] >= 0) {
ll val = dp[i][k] + 1LL * (s[n] - s[i]) * (k - 1);
if (val > ans) ans = val, lst = i;
}
}
memset(ok, 0, sizeof ok);
for (int i = lst, nr = k; nr; i = prv[i][nr], --nr) ok[i] = true;
cout << 2 * n - k << '\n';
for (int i = 1, nr = 0; nr < k - 1; ++i)
if (ok[i]) cout << v[i].id << ' ', ++nr;
for (int i = 1; i <= n; ++i)
if (!ok[i]) cout << v[i].id << ' ' << -v[i].id << ' ';
cout << v[lst].id << '\n';
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int INF = 2e9;
int g[80][80];
int n, k, a[80], b[80];
int job[80];
int u[80], v[80];
bool used[80];
int dist[80];
int par[80];
void hungarian() {
for (int i = 1; i <= n; i++) {
job[0] = i;
int j0 = 0;
for (int l = 0; l < 80; l++) {
used[l] = 0;
dist[l] = INF;
par[l] = 79;
}
while (job[j0]) {
used[j0] = 1;
int i0 = job[j0], d = INF, j1 = 79;
for (int j = 1; j <= n; j++) {
if (used[j]) continue;
int w = g[i0][j] - u[i0] - v[j];
if (w < dist[j]) {
dist[j] = w;
par[j] = j0;
}
if (dist[j] < d) {
d = dist[j];
j1 = j;
}
}
for (int j = 0; j <= n; j++) {
if (used[j]) {
u[job[j]] += d;
v[j] -= d;
} else
dist[j] -= d;
}
j0 = j1;
}
while (j0) {
int j1 = par[j0];
job[j0] = job[j1];
j0 = j1;
}
}
}
void solve() {
memset(g, 0, sizeof(g));
memset(u, 0, sizeof(u));
memset(v, 0, sizeof(v));
memset(job, 0, sizeof(job));
cin >> n >> k;
for (int i = 1; i <= n; i++) {
cin >> a[i] >> b[i];
}
for (int i = 1; i <= n; i++) {
g[1][i] = a[i] + b[i] * (k - 1);
for (int j = 2; j <= k; j++) {
g[j][i] = a[i] + (j - 2) * b[i];
}
for (int j = k + 1; j <= n; j++) {
g[j][i] = b[i] * (k - 1);
}
}
for (int i1 = 1; i1 <= n; i1++)
for (int i2 = 1; i2 <= n; i2++) {
g[i1][i2] = -g[i1][i2];
}
hungarian();
vector<int> ans;
for (int idx = 2; idx <= k; idx++) {
for (int i = 1; i <= n; i++) {
if (job[i] == idx) ans.push_back(i);
}
}
for (int idx = k + 1; idx <= n; idx++) {
for (int i = 1; i <= n; i++) {
if (job[i] == idx) {
ans.push_back(i);
ans.push_back(-i);
}
}
}
for (int i = 1; i <= n; i++) {
if (job[i] == 1) {
ans.push_back(i);
}
}
cout << ans.size() << endl;
for (auto xd : ans) cout << xd << " ";
cout << endl;
}
int main() {
int t;
cin >> t;
while (t--) solve();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <typename T>
using minpq = priority_queue<T, vector<T>, greater<T>>;
int n, k, a, b;
long long t;
vector<long long> ve[2][2];
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cin >> n >> k;
for (int i = (0); i < (n); i++) {
cin >> t >> a >> b;
ve[a][b].push_back(t);
}
sort((ve[0][1]).begin(), (ve[0][1]).end());
sort((ve[1][0]).begin(), (ve[1][0]).end());
vector<long long> sums;
for (long long x : ve[1][1]) sums.push_back(x);
for (int i = 0; i < min(((int)(ve[0][1]).size()), ((int)(ve[1][0]).size()));
i++) {
sums.push_back(ve[0][1][i] + ve[1][0][i]);
}
sort((sums).begin(), (sums).end());
if (((int)(sums).size()) < k) {
cout << "-1\n";
return 0;
}
cout << accumulate(sums.begin(), sums.begin() + k, 0LL) << '\n';
}
|
#include <bits/stdc++.h>
using namespace std;
const int INF = 1e9;
const long long INFLL = 0x3f3f3f3f3f3f3f3f;
const int MOD = 1e9 + 7;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int n, k;
cin >> n >> k;
vector<int> alice, bobo, osdois;
for (int i = 0; i < n; i++) {
bool a, b;
int t;
cin >> t >> a >> b;
if (a and b) {
osdois.push_back(t);
} else if (a) {
alice.push_back(t);
} else if (b) {
bobo.push_back(t);
}
}
sort(alice.begin(), alice.end());
sort(bobo.begin(), bobo.end());
sort(osdois.begin(), osdois.end());
queue<int> al, bb, ab;
for (auto num : alice) al.push(num);
for (auto num : bobo) bb.push(num);
for (auto num : osdois) ab.push(num);
int ans = 0;
int cont = 0;
while (cont < k) {
if (ab.empty()) {
if (bb.empty() or al.empty()) break;
ans += bb.front();
ans += al.front();
bb.pop();
al.pop();
cont++;
continue;
}
if (al.empty() or bb.empty()) {
ans += ab.front();
cont++;
ab.pop();
} else {
if (al.front() + bb.front() < ab.front()) {
ans += al.front() + bb.front();
al.pop();
bb.pop();
cont++;
} else {
ans += ab.front();
cont++;
ab.pop();
}
}
}
if (cont != k) {
cout << -1 << endl;
return 0;
}
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, k, res = 0;
cin >> n >> k;
vector<int> arrAB;
vector<int> arrA;
vector<int> arrB;
for (int i = 0; i < n; i++) {
int time, a, b;
cin >> time >> a >> b;
if (a == 1 && b == 1) {
arrAB.push_back(time);
} else if (a == 1) {
arrA.push_back(time);
} else if (b == 1) {
arrB.push_back(time);
}
}
sort(arrA.begin(), arrA.end());
sort(arrB.begin(), arrB.end());
for (int i = 0; i < arrA.size() && i < arrB.size(); i++) {
arrAB.push_back(arrA[i] + arrB[i]);
}
sort(arrAB.begin(), arrAB.end());
if (arrAB.size() < k)
cout << "-1" << endl;
else {
for (int i = 0; i < k; i++) res += arrAB[i];
cout << res << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
#pragma GCC optimize("O3")
#pragma GCC optimize("Ofast")
#pragma GCC optimize("unroll-loops")
using namespace std;
const long long maxn = 15e5 + 10;
const long long inf = 1e14;
long long n, m, k, t;
long long cur1, cur2;
long long C[maxn];
vector<long long> ANS;
vector<pair<long long, long long> > X[4];
void add(vector<long long> good) {
long long mn = inf + 1, mni = 3;
for (long long q = 0; q < 4; q++) {
if (!good[q]) {
continue;
}
if (X[q].back().first < mn) {
mn = X[q].back().first;
mni = q;
}
}
ANS.push_back(X[mni].back().second);
X[mni].pop_back();
if (mni / 2 == 1) {
cur2 = max(0LL, cur2 - 1);
}
if (mni % 2 == 1) {
cur1 = max(0LL, cur1 - 1);
}
}
void add1() { add({0, 1, 0, 1}); }
void add2() { add({0, 0, 1, 1}); }
void add0() { add({1, 1, 1, 1}); }
void add3() { add({0, 0, 0, 1}); }
void add_def() {
long long q, w, e;
vector<long long> mni = {0, 1};
long long mn = inf;
for (q = 0; q < 4; q++) {
for (w = q + 1; w < 4; w++) {
if ((q | w) != 3) {
continue;
}
vector<long long> dmni = {q, w};
long long dmn = X[q].back().first + X[w].back().first;
if (dmn < mn) {
mn = dmn;
mni = dmni;
}
}
}
for (auto i : mni) {
ANS.push_back(X[i].back().second);
X[i].pop_back();
if (i / 2 == 1) {
cur2 = max(cur2 - 1, 0LL);
}
if (i % 2 == 1) {
cur2 = max(cur2 - 1, 0LL);
}
}
}
bool used[maxn];
long long I[maxn];
int main() {
ios_base ::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
;
long long q, w, e, a, b, c;
cin >> n >> m >> k;
cur1 = cur2 = k;
vector<pair<long long, long long> > ALL;
for (q = 0; q < n; q++) {
cin >> a >> b >> c;
C[q] = a;
long long i = b * 2 + c;
X[i].push_back(make_pair(a, q));
ALL.push_back(make_pair(a, q));
}
for (q = 0; q < n; q++) {
for (w = 0; w < 4; w++) {
X[w].push_back(make_pair(inf, n + q * 4 + w));
ALL.push_back(make_pair(inf, n + q * 4 + w));
}
}
long long alln = n + n * 4;
sort(ALL.begin(), ALL.end());
for (q = 0; q < 4; q++) {
sort(X[q].begin(), X[q].end());
}
long long mn = 1e18, mni = 0;
long long cur = 0;
for (q = 0; q < k; q++) {
cur += X[3][q].first;
used[X[3][q].second] = 1;
}
for (q = 0; q < ALL.size(); q++) {
I[ALL[q].second] = q;
}
long long cnt = 0;
for (q = 0; cnt < m - k; q++) {
if (used[ALL[q].second]) {
continue;
}
cur += ALL[q].first;
cnt++;
}
long long iall = q - 1;
if (cur < mn) {
mn = cur;
mni = k;
}
for (q = k - 1; q >= 0; q--) {
if (q + 2 * (k - q) > m) {
break;
}
used[X[3][q].second] = 0;
cur -= X[3][q].first;
if (I[X[3][q].second] <= iall) {
cur -= ALL[iall].first;
cur += X[3][q].first;
iall--;
while (iall >= 0 && used[ALL[iall].second]) {
iall--;
}
}
long long i1 = k - q - 1;
used[X[2][i1].second] = 1;
cur += X[2][i1].first;
if (I[X[2][i1].second] <= iall) {
cur -= X[2][i1].first;
iall++;
while (used[ALL[iall].second]) {
iall++;
}
cur += ALL[iall].first;
}
used[X[1][i1].second] = 1;
cur += X[1][i1].first;
if (I[X[1][i1].second] <= iall) {
cur -= X[1][i1].first;
iall++;
while (used[ALL[iall].second]) {
iall++;
}
cur += ALL[iall].first;
}
cur -= ALL[iall].first;
iall--;
while (iall >= 0 && used[ALL[iall].second]) {
iall--;
}
if (cur < mn) {
mn = cur;
mni = q;
}
}
for (q = 0; q < alln; q++) {
used[q] = 0;
}
for (q = 0; q < mni; q++) {
ANS.push_back(X[3][q].second);
used[X[3][q].second] = 1;
}
for (q = 0; q < k - mni; q++) {
ANS.push_back(X[1][q].second);
used[X[1][q].second] = 1;
ANS.push_back(X[2][q].second);
used[X[2][q].second] = 1;
}
cnt = 0;
for (q = 0; cnt < m - mni - 2 * (k - mni); q++) {
if (!used[ALL[q].second]) {
ANS.push_back(ALL[q].second);
cnt++;
}
}
for (auto i : ANS) {
if (i >= n) {
cout << -1;
return 0;
}
}
cout << mn << endl;
for (q = 0; q < ANS.size(); q++) {
cout << ANS[q] + 1 << " ";
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int solve() {
int n, k;
cin >> n >> k;
int a, b, ans;
ans = a = b = 0;
priority_queue<int> x, y, z;
while (n--) {
int t, u, v;
cin >> t >> u >> v;
t *= -1;
if (u && v) {
z.push(t);
} else if (u) {
x.push(t);
} else if (v) {
y.push(t);
}
}
while (!x.empty() && !y.empty() && !z.empty() && a < k) {
int u, v, w;
u = -x.top();
v = -y.top();
w = -z.top();
if (u + v < w) {
ans += u + v;
x.pop();
y.pop();
} else {
ans += w;
z.pop();
}
++a;
++b;
}
while (a < k && !z.empty() && x.empty()) {
ans += -z.top();
z.pop();
++a;
++b;
}
while (b < k && !z.empty() && y.empty()) {
ans += -z.top();
z.pop();
++a;
++b;
}
while (a < k && !x.empty() && !z.empty()) {
int u = -x.top();
int w = -z.top();
if (u < w) {
ans += u;
++a;
x.pop();
} else {
ans += w;
++a;
++b;
z.pop();
}
}
while (a < k && !x.empty()) {
ans += -x.top();
x.pop();
++a;
}
while (b < k && !y.empty() && !z.empty()) {
int u = -y.top();
int w = -z.top();
if (u < w) {
ans += u;
++b;
y.pop();
} else {
ans += w;
++a;
++b;
z.pop();
}
}
while (b < k && !y.empty()) {
ans += -y.top();
y.pop();
++b;
}
if (a < k || b < k)
cout << "-1\n";
else
cout << ans << '\n';
return 0;
}
int main() {
cin.tie(0)->sync_with_stdio(0);
int t = 1;
while (t--) solve();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
inline long long read() {
long long r = 0, f = 0;
char c;
while (!isdigit(c = getchar())) f |= (c == '-');
while (isdigit(c)) r = (r << 1) + (r << 3) + (c ^ 48), c = getchar();
return f ? -r : r;
}
inline long long min(long long a, long long b) { return a < b ? a : b; }
struct Book {
long long t, a, b;
bool operator<(const Book &book) const {
return t ^ book.t ? t < book.t : (a & b) > (book.a & book.b);
}
} b[202202];
long long n, k, sum, ans, cnt[2], size[2], s[2][202202];
inline void work() {
n = read(), k = read();
for (long long i = 1; i <= n; i++) {
b[i].t = read();
b[i].a = read();
b[i].b = read();
if (b[i].a | b[i].b) sum += b[i].t;
cnt[0] += b[i].a;
cnt[1] += b[i].b;
}
if (cnt[0] < k || cnt[1] < k) {
puts("-1");
return;
}
sort(b + 1, b + 1 + n);
for (long long i = n; i >= 1; i--)
if (b[i].a && !b[i].b) {
s[0][size[0] + 1] = s[0][size[0]];
size[0]++;
s[0][size[0]] += b[i].t;
}
for (long long i = size[0] + 1; i <= n; i++) s[0][i] = s[0][size[0]];
for (long long i = n; i >= 1; i--)
if (b[i].b && !b[i].a) {
s[1][size[1] + 1] = s[1][size[1]];
size[1]++;
s[1][size[1]] += b[i].t;
}
for (long long i = size[1] + 1; i <= n; i++) s[1][i] = s[1][size[1]];
ans = sum - s[0][cnt[0] - k] - s[1][cnt[1] - k];
for (long long i = n; i >= 1; i--) {
if (cnt[0] == k || cnt[1] == k) break;
if (!(b[i].a & b[i].b)) continue;
cnt[0]--, cnt[1]--;
sum -= b[i].t;
ans = min(ans, sum - s[0][cnt[0] - k] - s[1][cnt[1] - k]);
}
printf("%lld", ans);
}
signed main() {
work();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long INF = 1e18;
namespace BF {
long long solve(int N, int M, int K, const vector<int>& T, const vector<int>& A,
const vector<int>& B) {
long long res = INF;
for (int mask = 0, _n = (1 << N); mask < _n; ++mask) {
if ((__builtin_popcount((mask))) != M) continue;
int cntA = 0, cntB = 0;
long long cur = 0;
for (int i = 0, _n = (N); i < _n; ++i) {
if (mask & (1 << i)) {
if (A[i]) cntA++;
if (B[i]) cntB++;
cur += T[i];
}
}
if (cntA >= K && cntB >= K) res = min(res, cur);
}
return res < INF ? res : -1;
}
} // namespace BF
struct Item {
int id, value;
bool operator<(const Item i) const {
if (value != i.value) return value < i.value;
return id < i.id;
}
bool operator>(const Item i) const {
if (value != i.value) return value > i.value;
return id > i.id;
}
};
ostream& operator<<(ostream& out, Item const& item) {
return out << "(" << item.id << ':' << item.value << ")";
}
class MBest {
long long best_sum;
multiset<int, greater<int> > le;
multiset<int> gt;
void transfer_gt_to_le() {
assert(!gt.empty());
auto it = gt.begin();
le.insert(*it);
best_sum += *it;
gt.erase(it);
}
void transfer_le_to_gt() {
assert(!le.empty());
auto it = le.begin();
gt.insert(*it);
best_sum -= *it;
le.erase(it);
}
public:
MBest() : best_sum(0) {}
int getM() const { return le.size(); }
long long query_best_sum() const { return best_sum; }
void add(int x) {
le.insert(x);
best_sum += x;
transfer_le_to_gt();
}
void remove(int x) {
auto it_gt = gt.find(x);
if (it_gt != gt.end()) {
gt.erase(it_gt);
return;
}
auto it_le = le.find(x);
assert(it_le != le.end());
le.erase(it_le);
best_sum -= x;
transfer_gt_to_le();
}
void increaseM() { transfer_gt_to_le(); }
};
vector<long long> get_psum(const vector<Item>& V) {
vector<long long> res(int((V).size()));
for (int i = (1), _b = (int((V).size()) - 1); i <= _b; ++i)
res[i] = res[i - 1] + V[i].value;
return res;
}
long long solve(int N, int M, int K, const vector<int>& T, const vector<int>& A,
const vector<int>& B) {
MBest mb;
vector<Item> alice, bob, both;
for (int i = 0, _n = (N); i < _n; ++i) {
Item item = {i + 1, T[i]};
if (A[i] && B[i])
both.push_back(item);
else if (A[i])
alice.push_back(item);
else if (B[i])
bob.push_back(item);
else
mb.add(item.value);
}
int minj = min(int((alice).size()), int((bob).size()));
if (minj + int((both).size()) < K) {
cout << "-1" << '\n';
return -1;
}
sort(alice.begin(), alice.end());
sort(bob.begin(), bob.end());
sort(both.begin(), both.end());
minj = min(minj, K);
for (int j = (minj), _b = (int((alice).size()) - 1); j <= _b; ++j)
mb.add(alice[j].value);
alice.erase(alice.begin() + minj, alice.end());
alice.insert(alice.begin(), {0, 0});
for (int j = (minj), _b = (int((bob).size()) - 1); j <= _b; ++j)
mb.add(bob[j].value);
bob.erase(bob.begin() + minj, bob.end());
bob.insert(bob.begin(), {0, 0});
both.insert(both.begin(), {0, 0});
for (int k = (K - minj), _b = (int((both).size()) - 1); k <= _b; ++k)
mb.add(both[k].value);
vector<long long> psum_alice = get_psum(alice);
vector<long long> psum_bob = get_psum(bob);
vector<long long> psum_both = get_psum(both);
long long res = INF;
int bestj = -1;
for (int j = minj; j >= 0; --j) {
int k = K - j;
if (k >= int((both).size())) break;
mb.remove(both[k].value);
int nbooks = K + j;
if (nbooks <= M) {
int nmissing = M - nbooks;
while (mb.getM() < nmissing) mb.increaseM();
long long best_other = mb.query_best_sum();
long long cur = psum_alice[j] + psum_bob[j] + psum_both[k] + best_other;
if (res > cur) {
bestj = j;
res = cur;
}
}
if (j > 0) {
mb.add(alice[j].value);
mb.add(bob[j].value);
}
}
if (bestj < 0) {
cout << "-1\n";
return -1;
}
set<Item> avail;
for (int i = 0, _n = (N); i < _n; ++i) avail.insert({i + 1, T[i]});
vector<int> best_books;
for (int j = (1), _b = (bestj); j <= _b; ++j) {
Item item = alice[j];
avail.erase(item);
best_books.push_back(item.id);
}
for (int j = (1), _b = (bestj); j <= _b; ++j) {
Item item = bob[j];
avail.erase(item);
best_books.push_back(item.id);
}
for (int k = (1), _b = (K - bestj); k <= _b; ++k) {
Item item = both[k];
avail.erase(item);
best_books.push_back(item.id);
}
assert(int((best_books).size()) <= M);
while (int((best_books).size()) < M) {
auto it = avail.begin();
best_books.push_back(it->id);
avail.erase(it);
}
cout << res << '\n';
long long sum = 0;
for (int id : best_books) {
cout << id << ' ';
sum += T[id - 1];
}
cout << '\n';
return res;
}
int main(int argc, char* argv[]) {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
int N, M, K;
cin >> N >> M >> K;
vector<int> T(N), A(N), B(N);
for (int i = 0, _n = (N); i < _n; ++i) cin >> T[i] >> A[i] >> B[i];
solve(N, M, K, T, A, B);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
class Solve {
public:
void updateSt(set<pair<int, int>> &st, set<pair<int, int>> &fr, int &sum,
int need) {
need = max(need, 0);
while (true) {
bool useful = false;
while (st.size() > need) {
sum -= st.rbegin()->first;
fr.insert(*st.rbegin());
st.erase(prev(st.end()));
useful = true;
}
while (st.size() < need && fr.size() > 0) {
sum += fr.begin()->first;
st.insert(*fr.begin());
fr.erase(fr.begin());
useful = true;
}
while (!st.empty() && !fr.empty() &&
fr.begin()->first < st.rbegin()->first) {
sum -= st.rbegin()->first;
sum += fr.begin()->first;
fr.insert(*st.rbegin());
st.erase(prev(st.end()));
st.insert(*fr.begin());
fr.erase(fr.begin());
useful = true;
}
if (!useful) break;
}
}
void main() {
const int INF = 10e9;
int n, m, k;
cin >> n >> m >> k;
vector<pair<int, int>> times[4];
vector<int> sums[4];
for (int i = 0; i < n; ++i) {
int t, a, b;
cin >> t >> a >> b;
times[a * 2 + b].push_back({t, i});
}
for (int i = 0; i < 4; ++i) {
sort(times[i].begin(), times[i].end());
sums[i].push_back(0);
for (auto it : times[i]) {
sums[i].push_back(sums[i].back() + it.first);
}
}
int ans = INF;
int pos = INF;
set<pair<int, int>> st;
set<pair<int, int>> fr;
int sum = 0;
vector<int> res;
for (int iter = 0; iter < 2; ++iter) {
st.clear();
fr.clear();
sum = 0;
int start = 0;
while (k - start >= sums[1].size() || k - start >= sums[2].size() ||
m - start - (k - start) * 2 < 0) {
++start;
}
if (start >= sums[3].size()) {
cout << -1 << endl;
return;
}
int need = m - start - (k - start) * 2;
for (int i = 0; i < 3; ++i) {
for (int p = times[i].size() - 1; p >= (i == 0 ? 0 : k - start); --p) {
fr.insert(times[i][p]);
}
}
updateSt(st, fr, sum, need);
for (int cnt = start; cnt < (iter == 0 ? sums[3].size() : pos); ++cnt) {
if (k - cnt >= 0) {
if (cnt + (k - cnt) * 2 + st.size() == m) {
if (ans >
sums[3][cnt] + sums[1][k - cnt] + sums[2][k - cnt] + sum) {
ans = sums[3][cnt] + sums[1][k - cnt] + sums[2][k - cnt] + sum;
pos = cnt + 1;
}
}
} else {
if (cnt + st.size() == m) {
if (ans > sums[3][cnt] + sum) {
ans = sums[3][cnt] + sum;
pos = cnt + 1;
}
}
}
if (iter == 1 && cnt + 1 == pos) break;
need -= 1;
if (k - cnt > 0) {
need += 2;
fr.insert(times[1][k - cnt - 1]);
fr.insert(times[2][k - cnt - 1]);
}
updateSt(st, fr, sum, need);
}
if (iter == 1) {
for (int i = 0; i + 1 < pos; ++i) res.push_back(times[3][i].second);
for (int i = 0; i <= k - pos; ++i) {
res.push_back(times[1][i].second);
res.push_back(times[2][i].second);
}
for (auto [value, position] : st) res.push_back(position);
}
}
cout << ans << endl;
for (auto it : res) cout << it + 1 << " ";
cout << endl;
return;
}
};
int main(int argc, const char *argv[]) {
Solve s;
s.main();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int32_t main() {
int n, m, k;
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cin >> n >> m >> k;
vector<pair<int, int> > ab;
vector<pair<int, int> > a;
vector<pair<int, int> > b;
vector<pair<int, int> > non;
for (int i = 0; i < n; i++) {
int t, a1, b1;
cin >> t >> a1 >> b1;
if (a1 && b1) {
ab.push_back({t, i});
} else if (a1) {
a.push_back({t, i});
} else if (b1) {
b.push_back({t, i});
} else {
non.push_back({t, i});
}
}
sort(ab.begin(), ab.end());
sort(a.begin(), a.end());
sort(b.begin(), b.end());
sort(non.begin(), non.end());
int l = -1;
for (int i = 0; i <= min(k, (int)ab.size()); i++) {
if (k - i <= (int)a.size() && k - i <= (int)b.size() &&
((k - i) * 2 + i <= m)) {
l = i;
break;
}
}
if (l == -1) {
cout << -1;
return 0;
}
set<pair<int, int> > curr;
set<pair<int, int> > all;
int r1 = l, r2 = k - l;
long long ans;
long long curr_sum = 0;
int ans_r1 = r1, ans_r2 = r2;
int curr_el = r2 * 2 + r1;
for (int i = 0; i < r2; i++) {
curr_sum += a[i].first;
curr_sum += b[i].first;
}
for (int i = 0; i < r1; i++) {
curr_sum += ab[i].first;
}
for (int i = r2; i < a.size(); i++) {
all.insert(a[i]);
}
for (int i = r2; i < b.size(); i++) {
all.insert(b[i]);
}
for (int i = 0; i < non.size(); i++) {
all.insert(non[i]);
}
for (int i = r1; i < ab.size(); i++) {
all.insert(ab[i]);
}
int add = 0;
while (curr.size() < (m - curr_el)) {
curr_sum += (*all.begin()).first;
curr.insert(*all.begin());
all.erase(all.begin());
}
ans = curr_sum;
for (int i = l; i < min(k, (int)ab.size()); i++) {
curr_sum -= a[r2 - 1].first;
curr_sum -= b[r2 - 1].first;
curr_sum += ab[r1].first;
all.insert(a[r2 - 1]);
all.insert(b[r2 - 1]);
r2--;
if (all.find(ab[r1]) != all.end()) {
all.erase(ab[r1]);
}
if (curr.find(ab[r1]) != curr.end()) {
curr_sum -= ab[r1].first;
curr.erase(ab[r1]);
}
r1++;
curr_el = r2 * 2 + r1;
while (curr.size() < (m - curr_el)) {
curr_sum += (*all.begin()).first;
curr.insert(*all.begin());
all.erase(all.begin());
}
if (!curr.empty() && !all.empty()) {
auto curr_last = curr.end();
curr_last--;
while (!all.empty() && *curr_last > *all.begin()) {
curr_sum -= (*curr_last).first;
curr_sum += (*all.begin()).first;
all.insert(*curr_last);
curr.erase(curr_last);
curr.insert(*all.begin());
all.erase(all.begin());
curr_last = curr.end();
curr_last--;
}
}
if (curr_sum < ans) {
ans = curr_sum;
ans_r1 = r1;
ans_r2 = r2;
}
}
r1 = ans_r1;
r2 = ans_r2;
cout << ans << "\n";
for (int i = 0; i < r1; i++) {
cout << ab[i].second + 1 << " ";
}
for (int i = 0; i < r2; i++) {
cout << a[i].second + 1 << " ";
cout << b[i].second + 1 << " ";
}
set<pair<int, int> > free;
for (int i = r2; i < a.size(); i++) {
free.insert(a[i]);
}
for (int i = r2; i < b.size(); i++) {
free.insert(b[i]);
}
for (int i = 0; i < non.size(); i++) {
free.insert(non[i]);
}
for (int i = r1; i < ab.size(); i++) {
free.insert(ab[i]);
}
curr_el = r2 * 2 + r1;
for (int i = 0; i < (m - curr_el); i++) {
cout << (*free.begin()).second + 1 << " ";
free.erase(free.begin());
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int mpow(int base, int exp);
void ipgraph(int n, int m);
void dfs(int u, int par);
const int mod = 1e9 + 7;
struct cmp {
bool operator()(const int& lhs, const int& rhs) const { return lhs < rhs; }
};
int mpow(int base, int exp) {
base %= mod;
int result = 1;
while (exp > 0) {
if (exp & 1) result = ((long long)result * base) % mod;
base = ((long long)base * base) % mod;
exp >>= 1;
}
return result;
}
bool isPrime(int n) {
if (n <= 1) return false;
if (n <= 3) return true;
if (n % 2 == 0 || n % 3 == 0) return false;
for (int i = 5; i * i <= n; i = i + 6)
if (n % i == 0 || n % (i + 2) == 0) return false;
return true;
}
void solve() {
long long n, k, time;
bool l1, l2;
cin >> n >> k;
vector<int> a1, a2, a3;
for (int i = 0; i < n; i++) {
cin >> time;
cin >> l1 >> l2;
if (l1 & l2) {
a1.push_back(time);
} else if (l1) {
a2.push_back(time);
} else if (l2) {
a3.push_back(time);
}
}
if (a1.size() + a2.size() < k || a1.size() + a3.size() < k) {
cout << -1;
return;
}
sort(a1.begin(), a1.end());
sort(a2.begin(), a2.end());
sort(a3.begin(), a3.end());
int p1 = 0, p2 = 0, p3 = 0;
int cnt = 0, res = 0;
int s1 = a1.size(), s2 = a2.size(), s3 = a3.size();
while (cnt < k && p1 < s1 && p2 < s2 && p3 < s3) {
if (a1[p1] < a2[p2] + a3[p3]) {
res += a1[p1];
p1++;
} else {
res += a2[p2] + a3[p3];
p2++;
p3++;
}
cnt++;
}
while (cnt < k && p1 < s1) {
res += a1[p1];
p1++;
cnt++;
}
while (cnt < k && p2 < s2 && p3 < s3) {
res += a2[p2] + a3[p3];
p2++;
p3++;
cnt++;
}
cout << res;
}
int main() {
ios_base::sync_with_stdio(0), cin.tie(0), cout.tie(0);
int t = 1;
solve();
cout << "\n";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, k;
cin >> n >> k;
vector<pair<int, pair<int, int>>> v;
for (int i = 0; i < n; i++) {
int t, a, b;
cin >> t >> a >> b;
v.push_back({t, {a, b}});
}
vector<int> f;
vector<pair<int, pair<int, int>>> l;
vector<pair<int, pair<int, int>>> r;
for (auto xx : v) {
if ((xx.second.second == 1) && (xx.second.first == 1)) {
f.push_back(xx.first);
}
if ((xx.second.second == 0) && (xx.second.first == 1)) {
l.push_back(xx);
}
if ((xx.second.second == 1) && (xx.second.first == 0)) {
r.push_back(xx);
}
}
sort(l.begin(), l.end());
sort(r.begin(), r.end());
int id1 = 0, id2 = 0;
while ((id1 < l.size()) && (id2 < r.size())) {
f.push_back(l[id1].first + r[id2].first);
id1++, id2++;
}
sort(f.begin(), f.end());
long long sum = 0;
if (f.size() < k) {
cout << "-1"
<< "\n";
return 0;
}
for (int i = 0; i < k; i++) {
sum += f[i];
}
cout << sum << "\n";
}
|
#include <bits/stdc++.h>
#pragma GCC optimize("02")
#pragma G++ optimize("03")
using namespace std;
const int N = 2e5 + 5;
int n, k, type1[N], type2[N], type3[N];
int main() {
scanf("%d%d", &n, &k);
int cnt1 = 0, cnt2 = 0, cnt3 = 0;
for (int i = 1; i <= n; i++) {
int val, a, b;
scanf("%d%d%d", &val, &a, &b);
if (!a && !b) continue;
if (a && b) type1[++cnt1] = val;
if (a && !b) type2[++cnt2] = val;
if (!a && b) type3[++cnt3] = val;
}
sort(type1 + 1, type1 + 1 + cnt1);
sort(type2 + 1, type2 + 1 + cnt2);
sort(type3 + 1, type3 + 1 + cnt3);
for (int i = 1; i <= min(cnt2, cnt3); i++)
type1[++cnt1] = type2[i] + type3[i];
sort(type1 + 1, type1 + 1 + cnt1);
if (cnt1 < k)
puts("-1");
else {
int res = 0;
for (int i = 1; i <= k; i++) res += type1[i];
printf("%d\n", res);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
using lint = long long int;
using pint = pair<int, int>;
using plint = pair<lint, lint>;
struct fast_ios {
fast_ios() {
cin.tie(0);
ios::sync_with_stdio(false);
cout << fixed << setprecision(20);
};
} fast_ios_;
template <typename T>
istream &operator>>(istream &is, vector<T> &vec) {
for (auto &v : vec) is >> v;
return is;
}
template <typename T>
bool chmax(T &m, const T q) {
if (m < q) {
m = q;
return true;
} else
return false;
}
template <typename T>
bool chmin(T &m, const T q) {
if (q < m) {
m = q;
return true;
} else
return false;
}
mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
template <class c>
struct rge {
c b, e;
};
template <class c>
rge<c> range(c i, c j) {
return rge<c>{i, j};
}
template <class c>
auto dud(c *x) -> decltype(cerr << *x, 0);
template <class c>
char dud(...);
struct deb {
~deb() { cerr << endl; }
template <class c>
typename enable_if<sizeof dud<c>(0) != 1, deb &>::type operator<<(c i) {
cerr << boolalpha << i;
return *this;
}
template <class c>
typename enable_if<sizeof dud<c>(0) == 1, deb &>::type operator<<(c i) {
return *this << range(begin(i), end(i));
}
template <class c, class b>
deb &operator<<(pair<b, c> d) {
return *this << "(" << d.first << ", " << d.second << ")";
}
template <class c>
deb &operator<<(rge<c> d) {
*this << "[";
for (auto it = d.b; it != d.e; ++it) *this << ", " + 2 * (it == d.b) << *it;
return *this << "]";
}
};
void err(istream_iterator<string> it) { return; }
template <typename T, typename... Args>
void err(istream_iterator<string> it, T a, Args... args) {
cerr << *it << " = " << a << endl;
err(++it, args...);
}
void solve() {
lint n, k;
cin >> n >> k;
vector<lint> time(n);
vector<lint> alice(n);
vector<lint> bob(n);
priority_queue<int, vector<int>, greater<int>> abra;
priority_queue<int, vector<int>, greater<int>> cadabra;
priority_queue<int, vector<int>, greater<int>> mixed;
for (int i = (0), i_end_ = (n); i < i_end_; i++) {
lint t, a, b;
cin >> t >> a >> b;
time[i] = t;
alice[i] = a;
bob[i] = b;
if (a == 1 && b == 1) {
mixed.push(t);
} else if (a == 1) {
abra.push(t);
} else if (b == 1) {
cadabra.push(t);
}
}
lint ret = 0;
lint cc = 2 * k;
lint s1 = accumulate(begin(alice), end(alice), 0LL);
lint s2 = accumulate(begin(bob), end(bob), 0LL);
if (s1 <= k - 1 || s2 <= k - 1) {
cout << -1 << '\n';
return;
}
while (cc) {
bool ok = 0;
int f = 0;
lint t = INT_MAX;
if (mixed.size() > 0) {
t = mixed.top();
ok = 1;
}
lint t1 = INT_MAX;
lint t2 = INT_MAX;
if (abra.size()) {
t1 = abra.top();
++f;
}
if (cadabra.size()) {
t2 = cadabra.top();
++f;
}
if (!ok && f <= 1) break;
if (t <= t1 + t2) {
ret += t;
mixed.pop();
} else {
ret += t1 + t2;
abra.pop();
cadabra.pop();
}
cc -= 2;
}
cout << ret << '\n';
}
int main() {
int T = 1;
for (int tt = 1; tt <= T; ++tt) {
solve();
}
return 0;
}
lint pow_mod(lint base, lint expo) {
lint ret = 1;
for (; expo;) {
if (expo & 1) ret = (ret * base) % 1000000007;
expo = (expo >> 1);
base = (base * base) % 1000000007;
}
return ret;
}
|
#include <bits/stdc++.h>
using namespace std;
inline long long gcd(long long a, long long b) {
while (b != 0) {
long long c = a % b;
a = b;
b = c;
}
return a < 0 ? -a : a;
}
inline long long lowbit(long long x) { return x & (-x); }
const double PI = 3.14159265358979323846;
const int inf = 0x3f3f3f3f;
const long long INF = 0x3f3f3f3f3f3f3f3f;
const long long mod = 998244353;
inline long long rd() {
long long x = 0, f = 1;
char ch = getchar();
while (ch < '0' || ch > '9') {
if (ch == '-') f = -1;
ch = getchar();
}
while (ch >= '0' && ch <= '9') {
x = (x << 3) + (x << 1) + (ch ^ 48);
ch = getchar();
}
return x * f;
}
const double eps = 1e-6;
const int M = 1e6 + 10;
const int N = 1e6 + 10;
struct MM {
int id, val;
bool friend operator<(const MM& m1, const MM& m2) { return m1.val < m2.val; }
};
MM a[N], b[N], c[N], d[N];
int x1 = 0, x2 = 0, x3 = 0, x4 = 0;
int n, m, k;
vector<int> ans;
MM pp[N];
long long f(int x) {
ans.clear();
long long sum = 0;
if (x > x3 || x + x1 < k || x + x2 < k || 2 * k - x > m) return INF;
for (int i = 1; i <= x; i++) {
sum += c[i].val;
ans.push_back(c[i].id);
}
for (int i = 1; i <= k - x; i++) {
sum += a[i].val;
ans.push_back(a[i].id);
}
for (int i = 1; i <= k - x; i++) {
sum += b[i].val;
ans.push_back(b[i].id);
}
int cnt = 0;
for (int i = max(k - x + 1, 1); i <= x1; i++) {
pp[++cnt] = a[i];
}
for (int i = max(k - x + 1, 1); i <= x2; i++) {
pp[++cnt] = b[i];
}
for (int i = x + 1; i <= x3; i++) {
pp[++cnt] = c[i];
}
for (int i = 1; i <= x4; i++) {
pp[++cnt] = d[i];
}
int res = m - (2 * k - x);
sort(pp + 1, pp + 1 + cnt);
for (int i = 1; i <= res; i++) {
ans.push_back(pp[i].id);
sum += pp[i].val;
}
return sum;
}
int main() {
n = rd(), m = rd(), k = rd();
for (int i = 1; i <= n; i++) {
int t = rd(), aa = rd(), bb = rd();
if (aa && bb)
c[++x3] = {i, t};
else if (aa)
a[++x1] = {i, t};
else if (bb)
b[++x2] = {i, t};
else
d[++x4] = {i, t};
}
sort(a + 1, a + 1 + x1);
sort(b + 1, b + 1 + x2);
sort(c + 1, c + 1 + x3);
sort(d + 1, d + 1 + x4);
if (x3 + x1 < k || x3 + x2 < k) {
cout << -1 << endl;
return 0;
}
int l = 0, r = x3;
int an = l;
while (l + 10 < r) {
int lmid = l + (r - l) / 3, rmid = r - (r - l) / 3;
if (f(lmid) < f(rmid)) {
an = lmid;
r = rmid - 1;
} else {
an = rmid;
l = lmid + 1;
}
}
for (int i = l; i <= r; i++) {
if (f(i) < f(an)) an = i;
}
long long aa = f(an);
if (aa == INF) {
cout << -1 << endl;
return 0;
}
cout << aa << endl;
for (auto& x : ans) {
printf("%d ", x);
}
cout << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
struct books {
int t, i;
};
bool cmp(books a, books b) {
if (a.t != b.t) return (a.t < b.t);
return (a.i < b.i);
}
int main() {
int n, m, o, x, y, i, j, t, s, k, l, p = 0, q, e[200001], f[200001];
books a[200001], b[200001], c[200001], d[200001];
long long ans;
cin >> n >> o >> m;
i = 0;
j = 0;
k = 0;
l = 0;
for (q = 1; q <= n; q++) {
cin >> t >> x >> y;
if (x == 1 && y == 1) {
c[k].t = t;
c[k++].i = q;
} else if (x == 1) {
a[i].t = t;
a[i++].i = q;
} else if (y == 1) {
b[j].t = t;
b[j++].i = q;
} else {
d[l].t = t;
d[l++].i = q;
}
}
sort(a, a + i, cmp);
sort(b, b + j, cmp);
sort(c, c + k, cmp);
sort(d, d + l, cmp);
x = 0;
y = 0;
t = 0;
s = 0;
ans = 0;
o -= m;
while (m > 0) {
if (x < i && y < j && t < k) {
if (a[x].t + b[y].t <= c[t].t && o > 0) {
ans += a[x].t + b[y].t;
e[p++] = a[x].i;
e[p++] = b[y].i;
x++;
y++;
o--;
} else {
ans += c[t].t;
e[p++] = c[t].i;
t++;
}
m--;
} else if ((x == i || y == j) && t < k) {
ans += c[t].t;
e[p++] = c[t].i;
t++;
m--;
} else if (t == k && x < i && y < j && o > 0) {
ans += a[x].t + b[y].t;
e[p++] = a[x].i;
e[p++] = b[y].i;
x++;
y++;
m--;
o--;
} else
break;
}
if (m == 0) {
q = 0;
while (o--) {
m = 10001;
if (x < i && a[x].t < m) m = a[x].t;
if (y < j && b[y].t < m) m = b[y].t;
if (t < k && c[t].t < m) m = c[t].t;
if (s < l && d[s].t < m) m = d[s].t;
if (t > 0 && x < i && y < j && c[t - 1].t + m > a[x].t + b[y].t) {
ans += a[x].t + b[y].t;
e[p++] = a[x].i;
e[p++] = b[y].i;
x++;
y++;
ans -= c[t - 1].t;
f[q++] = c[t - 1].i;
t--;
} else {
ans += m;
if (x < i && a[x].t == m) {
e[p++] = a[x].i;
x++;
} else if (y < j && b[y].t == m) {
e[p++] = b[y].i;
y++;
} else if (t < k && c[t].t == m) {
e[p++] = c[t].i;
t++;
} else if (s < l && d[s].t == m) {
e[p++] = d[s].i;
s++;
}
}
}
cout << ans << endl;
sort(e, e + p);
sort(f, f + q);
y = 0;
for (x = 0; x < p; x++) {
if (y < q && e[x] == f[y])
y++;
else
cout << e[x] << " ";
}
cout << endl;
} else
cout << -1 << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e6 + 7;
long long poww(long long a, long long b, long long mod) {
long long ans = 1;
while (b) {
if (b & 1) ans = (ans * a) % mod;
a = (a * a) % mod;
b >>= 1;
}
return ans % mod;
}
int main() {
int n, k;
cin >> n >> k;
vector<int> a;
vector<int> b;
vector<int> c;
vector<int> d;
for (int i = 0; i < n; i++) {
int z, x, y;
cin >> z >> x >> y;
if (x == 1 && y == 1) {
a.push_back(z);
} else if (x == 1) {
b.push_back(z);
} else if (y == 1) {
c.push_back(z);
}
}
if (a.size() + min(b.size(), c.size()) < k) {
cout << -1 << endl;
return 0;
}
sort(b.begin(), b.end());
sort(c.begin(), c.end());
for (int i = 0; i < b.size() && i < c.size(); i++) {
int z = b[i] + c[i];
a.push_back(z);
}
sort(a.begin(), a.end());
int sum = 0;
for (int i = 0; i < k; i++) {
sum += a[i];
}
cout << sum << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long INF = 1e18;
const long long MAX = 1e5 + 10;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
int n, k;
cin >> n >> k;
vector<long long> a, b, ab;
ab.push_back(0);
a.push_back(0);
b.push_back(0);
for (int i = 0; i < n; i++) {
long long t, A, B;
cin >> t >> A >> B;
if (A == 1 && B == 1)
ab.push_back(t);
else if (A == 1)
a.push_back(t);
else if (B == 1)
b.push_back(t);
}
sort(a.begin(), a.end());
sort(b.begin(), b.end());
sort(ab.begin(), ab.end());
long long ans = INF;
for (int i = 1; i < ab.size(); i++) ab[i] += ab[i - 1];
for (int i = 1; i < a.size(); i++) a[i] += a[i - 1];
for (int i = 1; i < b.size(); i++) b[i] += b[i - 1];
for (int i = 0; i < min((int)ab.size(), k + 1); i++) {
if (a.size() > k - i && b.size() > k - i)
ans = min(ans, ab[i] + a[k - i] + b[k - i]);
}
if (ans != INF)
cout << ans << "\n";
else
cout << -1 << "\n";
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAX = 200005;
long long INF = 1e10;
vector<long long> books[3];
int type(int a, int b) {
if (a && b) return 0;
if (a) return 1;
return 2;
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
int n, k, t, x, y;
cin >> n >> k;
for (int i = 0; i < n; i++) {
cin >> t >> x >> y;
if (!x && !y) continue;
books[type(x, y)].push_back(t);
}
for (int i = 0; i < 3; i++) {
sort(books[i].begin(), books[i].end());
for (int j = books[i].size(); j < k; j++) {
books[i].push_back(INF);
}
}
long long ans, aux;
ans = aux = 0;
for (int i = 0; i < k; i++) aux += books[0][i];
ans = aux;
for (int i = 0; i < k; i++) {
aux -= books[0][k - i - 1];
aux += books[1][i];
aux += books[2][i];
ans = min(aux, ans);
}
if (ans >= INF)
cout << "-1" << '\n';
else
cout << ans << '\n';
}
|
#include <bits/stdc++.h>
const int maxn = 2e6 + 1;
const int maxm = 1e5 + 10;
const long long int mod = 1e9 + 7;
const long long int INF = 1e18 + 100;
const int inf = 0x3f3f3f3f;
const double pi = acos(-1.0);
const double eps = 1e-8;
using namespace std;
multiset<long long int> va, vb, vall;
int main() {
int n, m;
scanf("%d %d", &n, &m);
for (int i = 1; i <= n; i++) {
long long int t;
int a, b;
scanf("%lld %d %d", &t, &a, &b);
if (a == 0 && b == 0)
continue;
else if (a == 1 && b == 0)
va.insert(t);
else if (a == 0 && b == 1)
vb.insert(t);
else
vall.insert(t);
}
long long int ans = 0;
while (m--) {
if ((int)vall.size() != 0 && (int)va.size() != 0 && (int)vb.size() != 0) {
if (*vall.begin() > *va.begin() + *vb.begin()) {
ans += *va.begin() + *vb.begin();
va.erase(va.begin());
vb.erase(vb.begin());
} else {
ans += *vall.begin();
vall.erase(vall.begin());
}
} else if ((int)vall.size() != 0)
ans += *vall.begin(), vall.erase(vall.begin());
else if ((int)va.size() != 0 && (int)vb.size() != 0) {
ans += *va.begin() + *vb.begin();
va.erase(va.begin());
vb.erase(vb.begin());
} else
break;
}
if (m >= 0)
puts("-1");
else
printf("%lld\n", ans);
}
|
#include <bits/stdc++.h>
using namespace std;
int32_t main() {
long long int n, k;
cin >> n >> k;
vector<long long int> v1;
vector<long long int> v2;
vector<long long int> v;
for (long long int i = 0; i < n; i++) {
long long int t, a, b;
cin >> t >> a >> b;
if (a == 1 && b == 1) {
v.push_back(t);
} else if (a == 0 && b == 1) {
v2.push_back(t);
} else if (a == 1 && b == 0) {
v1.push_back(t);
}
}
if (v1.size() + v.size() < k || v2.size() + v.size() < k) {
cout << -1 << "\n";
} else {
long long int m1 = v1.size();
long long int m2 = v2.size();
long long int m = v.size();
if (m1 != 0) sort(v1.begin(), v1.end());
if (m2 != 0) sort(v2.begin(), v2.end());
if (m != 0) sort(v.begin(), v.end());
vector<long long int> ans;
if (m1 == 0 || m2 == 0) {
for (long long int i = 0; i < m; i++) {
ans.push_back(v[i]);
}
} else {
long long int p = 0;
for (long long int i = 0; i < m1; i++) {
if (p < m2) {
ans.push_back(v1[i] + v2[p]);
p++;
}
}
for (long long int i = 0; i < m; i++) {
ans.push_back(v[i]);
}
}
sort(ans.begin(), ans.end());
long long int final = 0;
for (long long int i = 0; i < k; i++) {
final = final + ans[i];
}
cout << final << "\n";
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int m_x[] = {-1, 0, 0, 1};
const int m_y[] = {0, -1, 1, 0};
template <typename T, typename S>
ostream& operator<<(ostream& output, const pair<T, S>& to_print) {
output << to_print.first << ":" << to_print.second;
return output;
}
template <typename T, typename S>
ostream& operator<<(ostream& output, const map<T, S>& to_print) {
for (typename map<T, S>::const_iterator it = to_print.begin();
it != to_print.end(); it++)
output << *it << endl;
return output;
}
template <typename T>
ostream& operator<<(ostream& output, const vector<T>& to_print) {
for (typename vector<T>::const_iterator it = to_print.begin();
it != to_print.end(); it++)
output << *it << " ";
return output;
}
template <typename T>
ostream& operator<<(ostream& output, const set<T>& to_print) {
for (typename set<T>::const_iterator it = to_print.begin();
it != to_print.end(); it++)
output << *it << " ";
return output;
}
int main() {
ios::sync_with_stdio(false);
cin.tie(nullptr);
int n, m, k;
cin >> n >> m >> k;
set<pair<int, int> > sets[4];
for (int i = 0; i < n; i++) {
int t, a, b;
cin >> t >> a >> b;
if (a == 1 && b == 1)
sets[0].insert(make_pair(t, i + 1));
else if (a == 1 && b == 0)
sets[1].insert(make_pair(t, i + 1));
else if (a == 0 && b == 1)
sets[2].insert(make_pair(t, i + 1));
else
sets[3].insert(make_pair(t, i + 1));
}
{
bool flag_possible = true;
int x = sets[0].size(), y = min(sets[1].size(), sets[2].size());
int no_of_likes = x + y;
if (no_of_likes < k) flag_possible = false;
int m_copy = m - x, k_copy = k - x;
if (k_copy > 0) {
if (m_copy < 2 * k_copy) flag_possible = false;
}
if (!flag_possible) {
cout << "-1\n";
return 0;
}
}
vector<pair<int, int> > sol, sol2, sol3;
int ava = m - k;
long long ans = 0;
bool flag_cmp = true, flag_cmp2 = true;
while (true) {
if (k == 0) break;
if (sets[1].size() == 0 || sets[2].size() == 0) flag_cmp2 = false;
if (sets[0].size() == 0) flag_cmp = false;
if (flag_cmp && flag_cmp2 && ava) {
pair<int, int> s1 = *sets[0].begin(), s2 = *sets[1].begin(),
s3 = *sets[2].begin();
if (s1.first <= s2.first + s3.first) {
sets[0].erase(sets[0].begin());
ans += s1.first;
k--;
m--;
sol.push_back(s1);
} else if (s1.first > s2.first + s3.first) {
sets[1].erase(sets[1].begin());
sets[2].erase(sets[2].begin());
ans += s2.first + s3.first;
k--;
m -= 2;
sol2.push_back(s2);
sol2.push_back(s3);
ava--;
}
} else if (flag_cmp) {
vector<set<pair<int, int> >::iterator> arr;
for (set<pair<int, int> >::iterator it = sets[0].begin();
it != sets[0].end() && k; it++) {
sol.push_back(*it);
ans += it->first;
k--;
m--;
arr.push_back(it);
}
for (int i = 0; i < arr.size(); i++) sets[0].erase(arr[i]);
break;
} else if (flag_cmp2) {
vector<set<pair<int, int> >::iterator> arr;
for (set<pair<int, int> >::iterator it = sets[1].begin(),
it2 = sets[2].begin();
it != sets[1].end() && it2 != sets[2].end() && k; it++, it2++) {
sol2.push_back(*it);
sol2.push_back(*it2);
ans += it->first + it2->first;
k--;
m -= 2;
arr.push_back(it);
arr.push_back(it2);
}
for (int i = 0; i < arr.size(); i++)
if (i % 2 == 0)
sets[1].erase(arr[i]);
else
sets[2].erase(arr[i]);
break;
}
}
if (m > 0) {
set<pair<int, int> >::iterator it[4] = {sets[0].begin(), sets[1].begin(),
sets[2].begin(), sets[3].begin()};
while (m--) {
vector<pair<pair<int, int>, int> > to_sort;
for (int i = 0; i < 4; i++)
if (it[i] != sets[i].end()) to_sort.push_back(make_pair(*(it[i]), i));
sort(to_sort.begin(), to_sort.end());
bool flag = false;
if (to_sort[0].second == 3 && sol.size() > 0 && it[2] != sets[2].end() &&
it[1] != sets[1].end()) {
pair<int, int> last = *(--sol.end()), cur1 = *it[1], cur2 = *it[2];
if (last.first + to_sort[0].first.first > cur1.first + cur2.first) {
sol.erase(--sol.end());
sets[0].insert(last);
it[0] = sets[0].begin();
sol2.push_back(cur1);
sol2.push_back(cur2);
ans -= last.first;
ans += cur1.first + cur2.first;
sets[1].erase(sets[1].begin());
sets[2].erase(sets[2].begin());
it[1] = sets[1].begin();
it[2] = sets[2].begin();
flag = true;
}
}
if (!flag) {
int ind = to_sort[0].second;
sets[ind].erase(sets[ind].begin());
it[ind] = sets[ind].begin();
ans += to_sort[0].first.first;
sol3.push_back(to_sort[0].first);
}
}
}
cout << ans << "\n";
for (int i = 0; i < sol.size(); i++) cout << sol[i].second << " ";
for (int i = 0; i < sol2.size(); i++) cout << sol2[i].second << " ";
for (int i = 0; i < sol3.size(); i++) cout << sol3[i].second << " ";
cout << "\n";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long n, k, t, a, b, boths, alices, bobs, cnt[2], ans;
vector<int> both, alice, bob;
int main() {
ios::sync_with_stdio(false), cin.tie(NULL), cout.tie(NULL);
cin >> n >> k;
for (int i = 0; i < n; i++) {
cin >> t >> a >> b;
if (a && b)
both.push_back(t);
else if (a)
alice.push_back(t);
else if (b)
bob.push_back(t);
}
boths = both.size();
alices = alice.size();
bobs = bob.size();
sort(both.begin(), both.end());
sort(alice.begin(), alice.end());
sort(bob.begin(), bob.end());
while (k) {
int s1 = 1 << 30, s2 = 1 << 30;
if (boths <= cnt[0]) break;
if (boths > cnt[0]) s1 = both[cnt[0]];
if (cnt[1] < min(alices, bobs)) s2 = alice[cnt[1]] + bob[cnt[1]];
if (s1 < s2)
ans += s1, cnt[0]++, k--;
else
ans += s2, cnt[1]++, k--;
}
while (k--) {
if (cnt[1] < min(alices, bobs))
ans += alice[cnt[1]] + bob[cnt[1]], cnt[1]++;
else
return cout << "-1\n", 0;
}
cout << ans << '\n';
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
using ll = long long int;
using dl = double;
const int N = 2e5 + 10;
ll aarray[200000 + 10];
ll magic[101][101];
vector<ll> primes;
bool prime[1000001];
int main() {
ios_base::sync_with_stdio(false);
string str;
ll c, d, e, f, x, y, k, a, b, t, A = 0, mod, B = 0, L, j, i, l, r, m, n,
C = 0, ans = 0, sum = 0, sum1 = 0;
vector<pair<ll, ll>> v, v1;
queue<ll> qu;
cin >> n >> k;
multiset<ll> alice;
multiset<ll> bob;
multiset<ll> both;
ll al = 0;
ll bl = 0;
for (i = 1; i <= n; i++) {
cin >> t >> a >> b;
if (a && b) {
both.insert(t);
al++;
bl++;
} else if (a) {
alice.insert(t);
al++;
} else if (b) {
bob.insert(t);
bl++;
}
}
if (al < k || bl < k) {
cout << -1 << endl;
return 0;
}
al = k, bl = k;
auto ita = alice.begin();
auto itb = bob.begin();
auto itbt = both.begin();
while (al > 0 || bl > 0) {
if (al > 0 && bl > 0) {
if (ita == alice.end() || itb == bob.end()) {
ans += *itbt;
itbt++;
al--;
bl--;
} else {
if (itbt != both.end()) {
if (*ita + *itb < *itbt) {
ans += *ita + *itb;
ita++;
itb++;
al--;
bl--;
} else {
ans += *itbt;
itbt++;
al--;
bl--;
}
} else {
ans += *ita + *itb;
ita++;
itb++;
al--;
bl--;
}
}
} else if (al > 0) {
if (ita == alice.end()) {
ans += *itbt;
itbt++;
al--;
bl--;
} else if (itbt == both.end()) {
ans += *ita;
ita++;
al--;
} else {
if (*ita < *itbt) {
ans += *ita;
ita++;
al--;
} else {
ans += *itbt;
itbt++;
al--;
bl--;
}
}
} else if (bl > 0) {
if (itb == bob.end()) {
ans += *itbt;
itbt++;
bl--;
al--;
} else if (itbt == both.end()) {
ans += *itb;
itb++;
bl--;
} else {
if (*itb < *itbt) {
ans += *itb;
itb++;
bl--;
} else {
ans += *itbt;
itbt++;
bl--;
al--;
}
}
}
}
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long dif(long long a, long long b) {
if (a > b)
return a - b;
else
return b - a;
}
long long gcd(long long a, long long b) {
if (b == 0) return a;
return gcd(b, a % b);
}
int32_t main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL), cout.tie(NULL);
long long n, k;
cin >> n >> k;
long long arr[n][3], a = 0, b = 0, c = k, d = k, ans = 0;
vector<long long> p, q, r;
for (long long i = 0; i < n; i++) {
cin >> arr[i][0] >> arr[i][1] >> arr[i][2];
if (arr[i][1] == 1) a++;
if (arr[i][2] == 1) b++;
if (arr[i][1] == 1 && arr[i][2] == 1) {
p.push_back(arr[i][0]);
} else if (arr[i][1] == 1)
q.push_back(arr[i][0]);
else if (arr[i][2] == 1)
r.push_back(arr[i][0]);
}
if (a < k || b < k) {
cout << -1;
return 0;
}
sort(q.begin(), q.end());
sort(r.begin(), r.end());
for (long long i = 0; i < min(q.size(), r.size()); i++) {
p.push_back(q[i] + r[i]);
}
sort(p.begin(), p.end());
for (long long i = 0; i < k; i++) ans += p[i];
cout << ans << "\n";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long mod = 1e9 + 7;
const long long inf = 922337203685477;
const long long mininf = -922337203685477;
const long long nax = 2e5 + 5;
long long n, k, t, x, y;
priority_queue<long long, vector<long long>, greater<long long>> pq[5];
long long val(long long x) {
if (!pq[x].empty()) {
return pq[x].top();
} else {
return inf;
}
}
void ers(long long x) {
if (!pq[x].empty()) {
pq[x].pop();
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
cin >> n >> k;
for (long long i = 1; i <= n; i++) {
cin >> t >> x >> y;
if (x && y) {
pq[3].push(t);
} else if (x) {
pq[1].push(t);
} else if (y) {
pq[2].push(t);
}
}
if (pq[1].size() + pq[3].size() >= k && pq[2].size() + pq[3].size() >= k) {
long long ans = 0;
long long x = 0, y = 0;
while (x < k || y < k) {
if (val(3) <= val(1) + val(2)) {
x++;
y++;
ans += val(3);
ers(3);
} else {
ans += val(1);
ans += val(2);
x++;
y++;
ers(1), ers(2);
}
}
cout << ans << '\n';
} else {
cout << -1 << '\n';
}
}
|
#include <bits/stdc++.h>
using namespace std;
const long long int INF = (long long int)1e18;
const long long int MOD = 1000 * 1000 * 1000 + 7;
const long long int maxn = (long long int)1e5 + 10, L = 23;
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
long long int T = 1;
while (T--) {
long long int n, k;
cin >> n >> k;
vector<vector<long long int>> tp(3);
for (long long int i = 0; i < n; ++i) {
long long int t, a, b;
cin >> t >> a >> b;
if (!a && !b) continue;
if (!a && b) tp[0].push_back(t);
if (a && !b) tp[1].push_back(t);
if (a && b) tp[2].push_back(t);
}
for (long long int i = 0; i < 3; ++i) sort(tp[i].begin(), tp[i].end());
vector<long long int> dp(tp[2].size(), 0);
for (long long int i = 0; i < tp[2].size(); ++i) {
dp[i] = (!i ? tp[2][i] : dp[i - 1] + tp[2][i]);
}
long long int ans = INF, mn = min({k, (long long int)tp[0].size(),
(long long int)tp[1].size()});
if (dp.size() >= k) {
ans = dp[k - 1];
}
long long int a = 0, b = 0;
for (long long int i = 0; i < mn; ++i) {
a += tp[0][i];
b += tp[1][i];
long long int want = k - i - 2;
if (want >= dp.size()) continue;
ans = min(ans, (want >= 0 ? dp[want] : 0ll) + a + b);
}
if (ans == INF) ans = -1;
cout << ans << '\n';
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
signed main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
long long n, k;
cin >> n >> k;
vector<long long> first, second, z;
while (n--) {
long long t, a, b;
cin >> t >> a >> b;
if (a)
if (b)
first.push_back(t);
else
second.push_back(t);
else if (b)
z.push_back(t);
}
sort(second.begin(), second.end());
sort(z.begin(), z.end());
for (long long i = 0; i < min(second.size(), z.size()); i++)
first.push_back(second[i] + z[i]);
sort(first.begin(), first.end());
if (first.size() >= k)
cout << accumulate(first.begin(), first.begin() + k, 0ll) << "\n";
else
cout << -1 << "\n";
}
|
#include <bits/stdc++.h>
#pragma GCC optimize("O3")
using namespace std;
const int N = 2e5 + 5;
long long t[N], a[N], b[N];
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int n, m, k;
cin >> n >> m >> k;
int cnta = 0, cntb = 0;
set<pair<long long, long long> > ab, aa, bb;
for (int i = 1; i <= n; ++i) {
cin >> t[i] >> a[i] >> b[i];
cnta += a[i], cntb += b[i];
if (a[i] && b[i]) ab.insert({t[i], i});
if (a[i] && !b[i]) aa.insert({t[i], i});
if (!a[i] && b[i]) bb.insert({t[i], i});
}
if (cnta < k || cntb < k) cout << -1, exit(0);
long long ans = 0;
int taken = 0;
vector<pair<long long, long long> > checkab, checka, checkb;
while (k--) {
if (!aa.size() || !bb.size())
checkab.push_back(*ab.begin()), ans += (ab.begin()->first), taken++,
ab.erase(ab.begin());
else if (ab.size() &&
(ab.begin()->first) < (aa.begin()->first) + (bb.begin()->first)) {
checkab.push_back(*ab.begin()), ans += (ab.begin()->first), taken++,
ab.erase(ab.begin());
} else {
checka.push_back(*aa.begin()), checkb.push_back(*bb.begin()),
ans += (aa.begin()->first) + (bb.begin()->first), taken += 2,
aa.erase(aa.begin()), bb.erase(bb.begin());
}
}
if (taken <= m) {
m -= taken;
set<pair<long long, long long> > can;
vector<bool> used(n + 5, 0);
for (pair<long long, long long> cur : checkab) used[cur.second] = true;
for (pair<long long, long long> cur : checka) used[cur.second] = true;
for (pair<long long, long long> cur : checkb) used[cur.second] = true;
for (int i = 1; i <= n; ++i) {
if (!used[i]) can.insert({t[i], i});
}
int mn = min((int)aa.size(), (int)bb.size());
vector<int> dop;
while (m && can.size()) {
bool ok = false;
if (!aa.size() || !bb.size() || !checkab.size()) {
pair<long long, long long> cur = *can.begin();
ans += cur.first;
dop.push_back(cur.second);
can.erase(can.begin());
ok = 1;
} else if ((aa.begin()->first) + (bb.begin()->first) -
checkab.back().first <=
(can.begin()->first)) {
ans -= checkab.back().first;
can.insert(checkab.back());
checkab.pop_back();
ans += (aa.begin()->first) + (bb.begin()->first);
can.erase(*aa.begin());
can.erase(*bb.begin());
checka.push_back(*aa.begin()), checkb.push_back(*bb.begin());
aa.erase(aa.begin()), bb.erase(bb.begin());
ok = 1;
} else {
pair<long long, long long> cur = *can.begin();
ans += cur.first;
dop.push_back(cur.second);
if (aa.count(cur)) aa.erase(cur);
if (bb.count(cur)) bb.erase(cur);
can.erase(can.begin());
ok = 1;
}
if (ok) {
m--;
continue;
}
break;
}
if (m) cout << -1, exit(0);
cout << ans << "\n";
for (pair<long long, long long> cur : checkab) cout << cur.second << " ";
for (pair<long long, long long> cur : checka) cout << cur.second << " ";
for (pair<long long, long long> cur : checkb) cout << cur.second << " ";
for (int cur : dop) cout << cur << " ";
exit(0);
}
m = taken - m;
if (min((int)checka.size(), (int)ab.size() - (int)checkab.size()) < m)
cout << -1, exit(0);
while (m--) {
ans -= (checka.back().first + checkb.back().first);
ans += (ab.begin()->first);
checka.pop_back(), checkb.pop_back(), checkab.push_back(*ab.begin()),
ab.erase(ab.begin());
}
cout << ans << "\n";
for (pair<long long, long long> cur : checkab) cout << cur.second << " ";
for (pair<long long, long long> cur : checka) cout << cur.second << " ";
for (pair<long long, long long> cur : checkb) cout << cur.second << " ";
}
|
#include <bits/stdc++.h>
using namespace std;
const int inf = 1 << 30;
const long long mod = 1e9 + 7;
const long long linf = 1LL << 62;
const double EPS = 1e-7;
template <class T>
void chmin(T& x, T y) {
if (x > y) x = y;
}
template <class T>
void chmax(T& x, T y) {
if (x < y) x = y;
}
int n, k;
priority_queue<long long, vector<long long>, greater<long long>> pq[3];
int main() {
cin >> n >> k;
for (int i = 0; i < n; i++) {
int t, a, b;
cin >> t >> a >> b;
if (a == 1 && b == 1) {
pq[0].push(t);
} else if (a == 1) {
pq[1].push(t);
} else if (b == 1) {
pq[2].push(t);
}
}
if (pq[0].size() + min(pq[1].size(), pq[2].size()) < k) {
cout << -1 << endl;
return 0;
}
for (int i = 0; i < 3; i++) pq[i].push(inf);
long long ans = 0;
while (k--) {
long long t1 = pq[0].top(), t2 = pq[1].top() + pq[2].top();
if (t1 < t2) {
ans += t1;
pq[0].pop();
} else {
ans += t2;
pq[1].pop();
pq[2].pop();
}
}
cout << ans << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
int month[] = {31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31};
string lowerCase = "abcdefghijklmnopqrstuvwxyz";
string upperCase = "ABCDEFGHIJKLMNOPQRSTUVWXYZ";
const int fx8[] = {+1, +1, +0, -1, -1, -1, +0, +1};
const int fy8[] = {+0, +1, +1, +1, +0, -1, -1, -1};
const int fx4[] = {+1, 0, -1, 0};
const int fy4[] = {0, +1, 0, -1};
int tc, t, a, b, c, m, n, k, cnt, cnt2;
vector<int> oo, zo, oz, v;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
tc = 1;
while (tc--) {
cin >> n >> k;
for (int i = 1; i <= n; i++) {
cin >> t >> a >> b;
if (a && b)
oo.push_back(t), v.push_back(t);
else if (a)
oz.push_back(t);
else if (b)
zo.push_back(t);
}
int x = min(oz.size(), zo.size());
if (x + oo.size() < k) {
cout << -1 << '\n';
continue;
}
sort(oo.begin(), oo.end());
sort(oz.begin(), oz.end());
sort(zo.begin(), zo.end());
for (int i = 0; i < x; i++) {
v.push_back(oz[i] + zo[i]);
}
sort(v.begin(), v.end());
long long sum = 0;
for (int i = 0; i < k; i++) {
sum += v[i];
}
cout << sum << '\n';
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
vector<int> both, alice, bob;
int both_size = 0, alice_size = 0, bob_size = 0;
int main(int argc, char const *argv[]) {
cin.sync_with_stdio(false);
int N, k;
cin >> N >> k;
int min_, a, b;
for (int i = 0; i < N; i++) {
cin >> min_ >> a >> b;
if (a == 1 and b == 1) {
both.push_back(min_);
both_size++;
} else if (a == 1 and b == 0) {
alice.push_back(min_);
alice_size++;
} else if (a == 0 and b == 1) {
bob.push_back(min_);
bob_size++;
}
}
sort(alice.begin(), alice.end());
sort(bob.begin(), bob.end());
int m = min(alice_size, bob_size);
both_size += m;
if (both_size < k) {
cout << "-1\n";
return 0;
}
for (int i = 0; i < m; i++) {
both.push_back(alice[i] + bob[i]);
}
sort(both.begin(), both.end());
int ans = 0;
for (int i = 0; i < k; i++) {
ans += both[i];
}
cout << ans;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
void scan() {}
template <class T, class... A>
void scan(T& t, A&... a) {
cin >> t, scan(a...);
}
void print() {}
template <class T, class... A>
void print(T t, A... a) {
cout << t, print(a...);
}
const int MV = 2e5;
int n, m, k, ans = INT_MAX, idx, posTake, posRem;
vector<pair<int, int> > alice, bob, both, none, merged;
vector<int> ai, bi;
int main() {
cin.sync_with_stdio(0);
cin.tie(0);
scan(n, m, k);
alice.push_back({0, 0});
bob.push_back({0, 0});
both.push_back({0, 0});
none.push_back({0, 0});
for (int i = 1, t, a, b; i <= n; i++) {
scan(t, a, b);
if (a && b)
both.push_back({t, i});
else if (a)
alice.push_back({t, i});
else if (b)
bob.push_back({t, i});
else
none.push_back({t, i});
}
sort(both.begin(), both.end());
sort(alice.begin(), alice.end());
sort(bob.begin(), bob.end());
sort(none.begin(), none.end());
int a = 1, b = 1, c = 1;
merged.push_back({0, 0});
ai.push_back(0);
bi.push_back(0);
bob.push_back({INT_MAX, 0});
alice.push_back({INT_MAX, 0});
none.push_back({INT_MAX, 0});
while (true) {
if (a == (int)alice.size() - 1 && b == (int)bob.size() - 1 &&
c == (int)none.size() - 1)
break;
if (bob[b].first <= alice[a].first && bob[b].first <= none[c].first) {
merged.push_back({bob[b].first, bob[b].second});
bi.push_back(bi[(int)bi.size() - 1] + 1);
ai.push_back(ai[(int)ai.size() - 1]);
b++;
} else if (alice[a].first <= bob[b].first &&
alice[a].first <= none[c].first) {
merged.push_back({alice[a].first, alice[a].second});
bi.push_back(bi[(int)bi.size() - 1]);
ai.push_back(ai[(int)ai.size() - 1] + 1);
a++;
} else {
merged.push_back({none[c].first, none[c].second});
bi.push_back(bi[(int)bi.size() - 1]);
ai.push_back(ai[(int)ai.size() - 1]);
c++;
}
}
bob.pop_back();
alice.pop_back();
for (int i = 1; i < (int)both.size(); i++) both[i].first += both[i - 1].first;
for (int i = 1; i < (int)alice.size(); i++)
alice[i].first += alice[i - 1].first;
for (int i = 1; i < (int)bob.size(); i++) bob[i].first += bob[i - 1].first;
for (int i = 1; i < (int)merged.size(); i++)
merged[i].first += merged[i - 1].first;
for (int i = 0; i < min(m + 1, (int)both.size()); i++) {
int take = max(0, k - i), rem = m - i - 2 * take;
if ((int)bob.size() - 1 < k - i || (int)alice.size() - 1 < k - i || rem < 0)
continue;
int low = 0, high = (int)merged.size() - 1, target = -1;
while (low <= high) {
int mid = (low + high) / 2,
cnt = mid - min(ai[mid], take) - min(bi[mid], take);
if (cnt == rem) {
target = mid;
break;
} else if (cnt < rem)
low = mid + 1;
else
high = mid - 1;
}
if (target != -1) {
int sum = both[i].first + bob[take].first + alice[take].first +
merged[target].first - bob[min(bi[target], take)].first -
alice[min(ai[target], take)].first;
if (ans > sum) {
ans = sum;
idx = i;
posTake = take;
posRem = target;
}
}
}
if (ans == INT_MAX)
print(-1);
else {
print(ans, '\n');
set<int> s;
for (int i = 1; i <= idx; i++) print(both[i].second, ' ');
for (int i = 1; i <= posTake; i++) {
s.insert(alice[i].second);
s.insert(bob[i].second);
}
for (int i = 1; i <= posRem; i++) {
s.insert(merged[i].second);
}
for (int i : s) print(i, ' ');
}
}
|
#include <bits/stdc++.h>
using namespace std;
void solve() {
long long n, k;
cin >> n >> k;
long long i, j;
vector<long long> a, b, c;
for (i = 1; i <= n; i++) {
long long x, y, z;
cin >> x >> y >> z;
if (y == 1 && z == 1) {
c.push_back(x);
} else if (y == 1) {
a.push_back(x);
} else if (z == 1) {
b.push_back(x);
}
}
sort(a.begin(), a.end());
sort(b.begin(), b.end());
sort(c.begin(), c.end());
long long x = a.size();
long long y = b.size();
long long z = c.size();
for (i = 1; i < x; i++) a[i] += a[i - 1];
for (i = 1; i < y; i++) b[i] += b[i - 1];
for (i = 1; i < z; i++) c[i] += c[i - 1];
long long ans = 2e18;
for (i = 0; i <= k; i++) {
long long take = i;
long long atake = k - i;
long long btake = k - i;
if (take > z || atake > x || btake > y) continue;
long long temp = 0;
if (take) temp += c[take - 1];
if (atake) temp += a[atake - 1];
if (btake) temp += b[btake - 1];
ans = min(ans, temp);
}
if (ans == 2e18) ans = -1;
cout << ans << '\n';
}
int32_t main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
long long tt;
tt = 1;
while (tt--) {
solve();
}
}
|
#include <bits/stdc++.h>
using namespace std;
using lint = long long int;
struct fast_io {
fast_io() {
cout << fixed << setprecision(20);
ios_base::sync_with_stdio(0);
cin.tie(nullptr);
cout.tie(nullptr);
}
} _fast_io;
void run_case() {
int n, k;
cin >> n >> k;
int ret = INT_MAX;
vector<int> type01;
vector<int> type10;
vector<int> type11;
for (int i = 0; i < n; ++i) {
int t, a, b;
cin >> t >> a >> b;
if (a == 1 && b == 0) {
type10.push_back(t);
} else if (a == 1 && b == 1) {
type11.push_back(t);
} else if (a == 0 && b == 1) {
type01.push_back(t);
}
}
vector<int> t01((int)type01.size() + 1, 0);
vector<int> t10((int)type10.size() + 1, 0);
vector<int> t11((int)type11.size() + 1, 0);
if ((int)type01.size()) sort(type01.begin(), type01.end());
if ((int)type10.size()) sort(type10.begin(), type10.end());
if ((int)type11.size()) sort(type11.begin(), type11.end());
for (int i = 0; i < (int)type01.size(); ++i) {
t01[i + 1] += t01[i] + type01[i];
}
for (int i = 0; i < (int)type10.size(); ++i) {
t10[i + 1] += t10[i] + type10[i];
}
for (int i = 0; i < (int)type11.size(); ++i) {
t11[i + 1] += t11[i] + type11[i];
}
for (int cnt = 0; cnt <= min(k, (int)t11.size() - 1); ++cnt) {
if (k - cnt <= (int)t01.size() - 1 && k - cnt <= (int)t10.size() - 1) {
int op = t11[cnt] + t10[k - cnt] + t01[k - cnt];
ret = min(ret, op);
}
}
if (ret == INT_MAX) {
cout << -1 << '\n';
} else {
cout << ret << '\n';
}
}
int main() {
ios::sync_with_stdio(false);
cin.tie(nullptr);
int tests = 1;
for (int i = 1; i <= tests; ++i) {
run_case();
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <typename T>
ostream &operator<<(ostream &os, const vector<T> &v) {
os << '{';
string sep;
for (const auto &x : v) os << sep << x, sep = ", ";
return os << '}';
}
template <typename T, size_t size>
ostream &operator<<(ostream &os, const array<T, size> &arr) {
os << '{';
string sep;
for (const auto &x : arr) os << sep << x, sep = ", ";
return os << '}';
}
template <typename A, typename B>
ostream &operator<<(ostream &os, const pair<A, B> &p) {
return os << '(' << p.first << ", " << p.second << ')';
}
void dbg_out() { cerr << endl; }
template <typename Head, typename... Tail>
void dbg_out(Head H, Tail... T) {
cerr << ' ' << H;
dbg_out(T...);
}
using splay_key = int;
struct splay_node {
splay_node *parent = nullptr, *child[2] = {nullptr, nullptr};
splay_key key;
int size = 1;
int64_t sum = 0;
static int get_size(splay_node *x) { return x == nullptr ? 0 : x->size; }
static int64_t get_sum(splay_node *x) { return x == nullptr ? 0 : x->sum; }
int parent_index() const {
if (parent == nullptr) return -1;
return this == parent->child[0] ? 0 : 1;
}
void set_child(int index, splay_node *x) {
child[index] = x;
if (x != nullptr) x->parent = this;
}
void join() {
size = get_size(child[0]) + get_size(child[1]) + 1;
sum = get_sum(child[0]) + get_sum(child[1]) + key;
}
};
auto random_address = [] {
char *p = new char;
delete p;
return uint64_t(p);
};
mt19937_64 splay_rng(chrono::steady_clock::now().time_since_epoch().count() *
(random_address() | 1));
int64_t splay_count = 0;
struct splay_tree {
static const int POOL_SIZE = 10000;
static vector<splay_node *> node_pool;
static vector<splay_node *> pointers_to_delete;
static splay_node *new_node(const splay_key &key) {
if (node_pool.empty()) {
splay_node *ptr = new splay_node[POOL_SIZE];
pointers_to_delete.push_back(ptr);
for (int i = POOL_SIZE - 1; i >= 0; i--) node_pool.push_back(ptr + i);
}
splay_node *node = node_pool.back();
node_pool.pop_back();
node->key = key;
node->sum = key;
return node;
}
static void _delete_pointers() {
static bool deleted = false;
if (!deleted) {
for (splay_node *node : pointers_to_delete) delete[] node;
deleted = true;
}
}
splay_node *root = nullptr;
splay_tree() { atexit(_delete_pointers); }
bool empty() const { return root == nullptr; }
int size() const { return root == nullptr ? 0 : root->size; }
splay_node *set_root(splay_node *x) {
if (x != nullptr) x->parent = nullptr;
return root = x;
}
void rotate_up(splay_node *x, bool x_join = true) {
splay_node *p = x->parent, *gp = p->parent;
int index = x->parent_index();
if (gp == nullptr)
set_root(x);
else
gp->set_child(p->parent_index(), x);
p->set_child(index, x->child[!index]);
x->set_child(!index, p);
p->join();
if (x_join) x->join();
}
void splay(splay_node *x) {
splay_count++;
while (x != root) {
splay_node *p = x->parent;
if (p != root)
rotate_up(x->parent_index() == p->parent_index() ? p : x, false);
rotate_up(x, false);
}
x->join();
}
static constexpr double SPLAY_RNG_RANGE = double(splay_rng.max()) + 1.0;
static constexpr double LOG_CONSTANT = 2.0;
static constexpr double SPLAY_PROBABILITY = 0.25;
static const int SIZE_CUTOFF = 100;
void check_splay(splay_node *x, int depth) {
int n = size(), log_n = 32 - __builtin_clz(n);
if (depth > LOG_CONSTANT * log_n ||
(n < SIZE_CUTOFF &&
double(splay_rng()) < SPLAY_PROBABILITY * SPLAY_RNG_RANGE))
splay(x);
}
pair<splay_node *, int> insert(const splay_key &key,
bool require_unique = false) {
return insert(new_node(key), require_unique);
}
pair<splay_node *, int> insert(splay_node *x, bool require_unique = false) {
if (root == nullptr) return {set_root(x), 0};
splay_node *current = root, *prev = nullptr;
int below = 0, depth = 0;
while (current != nullptr) {
prev = current;
depth++;
if (current->key < x->key) {
below += splay_node::get_size(current->child[0]) + 1;
current = current->child[1];
} else {
if (require_unique && !(x->key < current->key)) {
below += splay_node::get_size(current->child[0]);
check_splay(current, depth);
return {current, below};
}
current = current->child[0];
}
}
prev->set_child(prev->key < x->key ? 1 : 0, x);
check_splay(x, depth);
for (splay_node *node = x; node != nullptr; node = node->parent)
node->join();
return {x, below};
}
splay_node *begin() {
if (root == nullptr) return nullptr;
splay_node *x = root;
int depth = 0;
while (x->child[0] != nullptr) {
x = x->child[0];
depth++;
}
check_splay(x, depth);
return x;
}
splay_node *successor(splay_node *x) const {
if (x == nullptr) return nullptr;
if (x->child[1] != nullptr) {
x = x->child[1];
while (x->child[0] != nullptr) x = x->child[0];
return x;
}
while (x->parent_index() == 1) x = x->parent;
return x->parent;
}
splay_node *predecessor(splay_node *x) const {
if (x == nullptr) return nullptr;
if (x->child[0] != nullptr) {
x = x->child[0];
while (x->child[1] != nullptr) x = x->child[1];
return x;
}
while (x->parent_index() == 0) x = x->parent;
return x->parent;
}
splay_node *last() {
if (root == nullptr) return nullptr;
splay_node *x = root;
int depth = 0;
while (x->child[1] != nullptr) {
x = x->child[1];
depth++;
}
check_splay(x, depth);
return x;
}
void clear() {
vector<splay_node *> nodes;
nodes.reserve(size());
for (splay_node *node = begin(); node != nullptr; node = successor(node))
nodes.push_back(node);
for (splay_node *node : nodes) {
*node = splay_node();
node_pool.push_back(node);
}
set_root(nullptr);
}
void erase(splay_node *x) {
splay_node *new_x = nullptr, *fix_node = nullptr;
if (x->child[0] == nullptr || x->child[1] == nullptr) {
new_x = x->child[x->child[0] == nullptr ? 1 : 0];
fix_node = x->parent;
} else {
splay_node *next = successor(x);
assert(next != nullptr && next->child[0] == nullptr);
new_x = next;
fix_node = next->parent == x ? next : next->parent;
next->parent->set_child(next->parent_index(), next->child[1]);
next->set_child(0, x->child[0]);
next->set_child(1, x->child[1]);
}
if (x == root)
set_root(new_x);
else
x->parent->set_child(x->parent_index(), new_x);
int depth = 0;
for (splay_node *node = fix_node; node != nullptr; node = node->parent) {
node->join();
depth++;
}
if (fix_node != nullptr) check_splay(fix_node, depth);
*x = splay_node();
node_pool.push_back(x);
}
pair<splay_node *, int> lower_bound(const splay_key &key) {
splay_node *current = root, *prev = nullptr, *answer = nullptr;
int below = 0, depth = 0;
while (current != nullptr) {
prev = current;
depth++;
if (current->key < key) {
below += splay_node::get_size(current->child[0]) + 1;
current = current->child[1];
} else {
answer = current;
current = current->child[0];
}
}
if (prev != nullptr) check_splay(prev, depth);
return make_pair(answer, below);
}
bool contains(const splay_key &key) {
splay_node *node = lower_bound(key).first;
return node != nullptr && node->key == key;
}
bool erase(const splay_key &key) {
splay_node *x = lower_bound(key).first;
if (x == nullptr || x->key != key) return false;
erase(x);
return true;
}
splay_node *node_at_index(int index) {
if (index < 0 || index >= size()) return nullptr;
splay_node *current = root;
int depth = 0;
while (current != nullptr) {
int left_size = splay_node::get_size(current->child[0]);
depth++;
if (index == left_size) {
check_splay(current, depth);
return current;
}
if (index < left_size) {
current = current->child[0];
} else {
current = current->child[1];
index -= left_size + 1;
}
}
assert(false);
}
splay_node *query_prefix_key(const splay_key &key) {
splay_node *node = lower_bound(key).first;
if (node == nullptr) return root;
splay(node);
return node->child[0];
}
splay_node *query_prefix_count(int prefix) {
if (prefix <= 0) return nullptr;
if (prefix >= size()) return root;
splay_node *node = node_at_index(prefix);
splay(node);
return node->child[0];
}
splay_node *query_suffix_key(const splay_key &key) {
splay_node *node = lower_bound(key).first;
if (node == nullptr) return nullptr;
node = predecessor(node);
if (node == nullptr) return root;
splay(node);
return node->child[1];
}
splay_node *query_suffix_count(int suffix) {
if (suffix <= 0) return root;
if (suffix >= size()) return nullptr;
splay_node *node = node_at_index(suffix - 1);
splay(node);
return node->child[1];
}
};
vector<splay_node *> splay_tree::node_pool;
vector<splay_node *> splay_tree::pointers_to_delete;
void print_tree(splay_node *x, int depth = 0) {
if (x == nullptr) return;
for (int i = 0; i < depth; i++) cerr << ' ';
cerr << x->key << " (" << x->size << ", " << x->sum << ")\n";
print_tree(x->child[0], depth + 1);
print_tree(x->child[1], depth + 1);
}
template <typename T1, typename T2>
bool maximize(T1 &a, const T2 &b) {
if (a < b) {
a = b;
return true;
}
return false;
}
template <typename T1, typename T2>
bool minimize(T1 &a, const T2 &b) {
if (b < a) {
a = b;
return true;
}
return false;
}
template <typename T>
void output_vector(const vector<T> &v, bool add_one = false, int start = -1,
int end = -1) {
if (start < 0) start = 0;
if (end < 0) end = int(v.size());
for (int i = start; i < end; i++)
cout << v[i] + (add_one ? 1 : 0) << (i < end - 1 ? ' ' : '\n');
}
const int64_t INF64 = int64_t(2e18) + 5;
int main() {
ios::sync_with_stdio(false);
cin.tie(nullptr);
int N, M, K;
cin >> N >> M >> K;
vector<pair<int, int>> A, B, both, neither;
for (int i = 0; i < N; i++) {
int t, a, b;
cin >> t >> a >> b;
if (a + b == 2)
both.emplace_back(t, i);
else if (a == 1)
A.emplace_back(t, i);
else if (b == 1)
B.emplace_back(t, i);
else
neither.emplace_back(t, i);
}
sort(A.begin(), A.end());
sort(B.begin(), B.end());
sort(both.begin(), both.end());
sort(neither.begin(), neither.end());
vector<int64_t> A_sum(A.size() + 1, 0);
vector<int64_t> B_sum(B.size() + 1, 0);
for (int i = 0; i < int(A.size()); i++) A_sum[i + 1] = A_sum[i] + A[i].first;
for (int i = 0; i < int(B.size()); i++) B_sum[i + 1] = B_sum[i] + B[i].first;
splay_tree tree;
for (int i = K + 1; i < int(A.size()); i++) tree.insert(A[i].first);
for (int i = K + 1; i < int(B.size()); i++) tree.insert(B[i].first);
for (auto &pr : neither) tree.insert(pr.first);
int64_t best = INF64;
int best_x = -1;
int64_t sum = 0;
for (int x = 0; x <= int(both.size()); x++) {
if (x > 0) sum += both[x - 1].first;
int need = K - x;
if (need >= 0 && need < int(A.size())) tree.insert(A[need].first);
if (need >= 0 && need < int(B.size())) tree.insert(B[need].first);
need = max(need, 0);
if (int(A.size()) >= need && int(B.size()) >= need && x + 2 * need <= M) {
int remain = M - (x + 2 * need);
if (remain <= tree.size()) {
int64_t extra = splay_node::get_sum(tree.query_prefix_count(remain));
if (minimize(best, sum + A_sum[need] + B_sum[need] + extra)) best_x = x;
}
}
}
if (best_x < 0) {
cout << -1 << '\n';
return 0;
}
cout << best << '\n';
vector<int> books;
for (int i = 0; i < best_x; i++) books.push_back(both[i].second);
int need = max(K - best_x, 0);
for (int i = 0; i < need; i++) {
books.push_back(A[i].second);
books.push_back(B[i].second);
}
vector<pair<int, int>> everything_else;
for (int i = need; i < int(A.size()); i++) everything_else.push_back(A[i]);
for (int i = need; i < int(B.size()); i++) everything_else.push_back(B[i]);
for (auto &pr : neither) everything_else.push_back(pr);
int remain = M - int(books.size());
nth_element(everything_else.begin(), everything_else.begin() + remain,
everything_else.end());
for (int i = 0; i < remain; i++) books.push_back(everything_else[i].second);
output_vector(books, true);
}
|
#include <bits/stdc++.h>
using namespace std;
int main(int argc, char **argv) {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int n, m, k;
cin >> n >> m >> k;
vector<int> cnt(5, 0), mark(4, 0), as;
vector<pair<long long, long long> > v[4];
long long ret = 1e18, ans = 0;
for (int i = 0; i < n; i++) {
int x, y, z;
cin >> x >> y >> z;
v[2 * y + z].push_back({x, i});
}
if (min((int)(v[1].size()), (int)(v[2].size())) + (int)(v[3].size()) < k ||
((int)(v[3].size()) < k &&
(int)(v[3].size()) + 2 * (k - (int)(v[3].size())) > m)) {
cout << -1 << endl;
return 0;
}
int hi = min(min((int)(v[1].size()), (int)(v[2].size())), k),
lo = max(0, k - (int)(v[3].size()));
mark[0] = 0, mark[1] = mark[2] = hi, mark[3] = k - hi;
for (int i = 0; i < 4; i++)
v[i].push_back({2 * 1000000007, n + i}), sort(v[i].begin(), v[i].end());
for (int i = 0; i < 4; i++)
for (int j = 0; j < mark[i]; j++) ans += v[i][j].first;
while (hi + k > m) {
ans -= v[1][hi - 1].first + v[2][hi - 1].first - v[3][k - hi].first, hi--;
mark[1] = mark[2] = hi, mark[3] = k - hi;
}
for (int i = 0; i < 4; i++) cnt[i] = mark[i];
for (int i = 0; i < m - (hi + k); i++) {
int qw = 2 * 1000000007, in;
for (int j = 0; j < 4; j++)
if (qw > v[j][cnt[j]].first) qw = v[j][cnt[j]].first, in = j;
ans += qw, cnt[in]++;
}
ret = min(ret, ans), as = cnt;
for (int i = hi - 1; i >= lo; i--) {
int temp = 0;
if (mark[1]-- == cnt[1]) cnt[1]--, temp--, ans -= v[1][cnt[1]].first;
if (mark[2]-- == cnt[2]) cnt[2]--, temp--, ans -= v[2][cnt[2]].first;
while (temp < 0) {
int qw = 2 * 1000000007, in;
for (int j = 0; j < 4; j++)
if (qw > v[j][cnt[j]].first) qw = v[j][cnt[j]].first, in = j;
ans += qw, cnt[in]++, temp++;
}
if (mark[3]++ == cnt[3]) {
int qw = 0, in = 4;
for (int j = 0; j < 4; j++)
if (cnt[j] > mark[j] && qw < v[j][cnt[j] - 1].first)
qw = v[j][cnt[j] - 1].first, in = j;
ans -= qw, cnt[in]--;
ans += v[3][cnt[3]].first, cnt[3]++;
}
if (ret > ans) as = cnt, ret = ans;
}
cout << ret << endl;
for (int i = 0; i < 4; i++)
for (int j = 0; j < as[i]; j++) cout << v[i][j].second + 1 << " ";
cout << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
void takeFrom(vector<long long> &x, long long &cnt, long long &ans) {
ans += x.back();
x.pop_back();
cnt++;
}
void takeFrom(vector<long long> &x, long long &cntA, long long &cntB,
long long &ans) {
ans += x.back();
x.pop_back();
cntA++;
cntB++;
}
signed main() {
ios::sync_with_stdio(false);
cin.tie(nullptr);
cout.tie(nullptr);
long long n, k;
cin >> n >> k;
vector<long long> a, b, ab;
long long countAlice = 0, countBob = 0;
for (long long i = 0; i < n; i++) {
long long tym, alice, bob;
cin >> tym >> alice >> bob;
if (alice > 0 && bob > 0) {
ab.push_back(tym);
countAlice++;
countBob++;
} else if (alice) {
a.push_back(tym);
countAlice++;
} else if (bob) {
b.push_back(tym);
countBob++;
}
}
if (countAlice < k || countBob < k) return cout << -1, 0;
sort(a.begin(), a.end());
reverse(a.begin(), a.end());
sort(b.begin(), b.end());
reverse(b.begin(), b.end());
sort(ab.begin(), ab.end());
reverse(ab.begin(), ab.end());
long long ans = 0;
countAlice = countBob = 0;
while (countAlice < k || countBob < k) {
if (countAlice < k && countBob < k) {
if (!a.empty() && !b.empty()) {
if (ab.empty()) {
takeFrom(a, countAlice, ans);
takeFrom(b, countBob, ans);
} else {
if (a.back() + b.back() < ab.back()) {
takeFrom(a, countAlice, ans);
takeFrom(b, countBob, ans);
} else {
takeFrom(ab, countAlice, countBob, ans);
}
}
} else {
takeFrom(ab, countAlice, countBob, ans);
}
} else if (countAlice < k) {
if (a.empty()) {
takeFrom(ab, countAlice, countBob, ans);
} else {
if (ab.empty()) {
takeFrom(a, countAlice, ans);
} else {
if (a.back() < ab.back()) {
takeFrom(a, countAlice, ans);
} else {
takeFrom(ab, countAlice, countBob, ans);
}
}
}
} else if (countBob < k) {
if (b.empty()) {
takeFrom(ab, countAlice, countBob, ans);
} else {
if (ab.empty()) {
takeFrom(b, countBob, ans);
} else {
if (b.back() < ab.back()) {
takeFrom(b, countBob, ans);
} else {
takeFrom(ab, countAlice, countBob, ans);
}
}
}
}
}
cout << ans << '\n';
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
int n, k;
cin >> n >> k;
vector<int> v0, v1, v2;
for (int i = 0; i < n; i += 1) {
int x, y, z;
cin >> x >> y >> z;
if (y == 1 && z == 1)
v0.push_back(x);
else if (y != 1 && z == 1)
v2.push_back(x);
else if (y == 1 && z != 1)
v1.push_back(x);
}
sort(v0.begin(), v0.end());
sort(v1.begin(), v1.end());
sort(v2.begin(), v2.end());
int k1 = 0, k2 = 0, x = 0, y = 0, z = 0, sum = 0, done = 0, n0 = v0.size(),
n1 = v1.size(), n2 = v2.size();
while (k1 != k) {
if (x >= n0) {
if (y >= n1 || z >= n2) {
done = 1;
cout << -1 << "\n";
break;
} else {
sum += v1[y] + v2[z];
y++;
z++;
k1++;
k2++;
}
} else {
if (y >= n1 || z >= n2) {
sum += v0[x];
x++;
k1++;
k2++;
} else {
if (v0[x] > v1[y] + v2[z]) {
sum += v1[y] + v2[z];
y++;
z++;
k1++;
k2++;
} else {
sum += v0[x];
x++;
k1++;
k2++;
}
}
}
}
if (!done) {
cout << sum << "\n";
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
const long long N = 2e5 + 5;
long long n, m, k;
vector<pair<long long, long long>> type[2][2];
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cin >> n >> m >> k;
for (long long i = 1; i <= n; ++i) {
long long a, x, y;
cin >> a >> x >> y;
type[x][y].emplace_back(a, i);
}
for (long long i = 0; i <= 1; ++i)
for (long long j = 0; j <= 1; ++j) sort(begin(type[i][j]), end(type[i][j]));
long long ans = INT_MAX;
set<long long> trace;
for (long long _ = 0; _ < 2; ++_) {
long long tot = 0;
set<long long> s2;
priority_queue<pair<long long, long long>> pq;
priority_queue<pair<long long, long long>,
vector<pair<long long, long long>>,
greater<pair<long long, long long>>>
pq1;
for (long long i = 0; i <= 1; ++i) {
for (long long j = 0; j <= 1; ++j) {
if ((i == 0 && j) or (j == 0 && i)) {
for (long long p = 0; p < min(k, (long long)type[i][j].size()); ++p) {
tot += type[i][j][p].first;
s2.insert(type[i][j][p].second);
}
for (long long p = k; p < (long long)(type[i][j].size()); ++p) {
tot += type[i][j][p].first;
s2.insert(type[i][j][p].second);
pq.push(type[i][j][p]);
}
}
}
}
for (auto &v : type[0][0]) {
tot += v.first;
s2.insert(v.second);
pq.push(v);
}
for (long long i = 0; i <= type[1][1].size(); ++i) {
if (i) {
tot += type[1][1][i - 1].first;
s2.insert(type[1][1][i - 1].second);
for (long long __ = 0; __ <= 1; ++__) {
for (long long j = 0; j <= 1; ++j)
if ((__ == 0 && j) or (j == 0 && __)) {
if ((long long)(type[__][j].size()) > k - i && k - i >= 0)
pq.push(type[__][j][k - i]);
}
}
}
if (pq1.size()) {
pq.push(pq1.top());
tot += pq1.top().first;
s2.insert(pq1.top().second);
pq1.pop();
}
while (pq.size() && pq.size() > m - i - 2 * max(k - i, 0ll)) {
tot -= pq.top().first;
s2.erase(pq.top().second);
pq1.push(pq.top());
pq.pop();
}
if (pq.size() == m - i - 2 * max(k - i, 0ll) && type[1][1].size() >= i &&
type[1][0].size() >= k - i && type[0][1].size() >= k - i && tot < ans)
ans = tot;
if (_ == 1 && tot == ans && trace.empty()) trace = s2;
}
}
if (ans == INT_MAX) ans = -1;
cout << ans << '\n';
if (ans != -1)
for (auto v : trace) cout << v << ' ';
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m, k;
scanf("%d%d%d", &n, &m, &k);
vector<pair<int, int>> a, b, c, z;
a.reserve(n);
b.reserve(n);
c.reserve(n);
z.reserve(n);
for (int i = 0; i < n; ++i) {
int t, xa, xb;
scanf("%d%d%d", &t, &xa, &xb);
if (xa == 1 && xb == 1) {
z.push_back(make_pair(t, i + 1));
} else if (xa == 1 && xb == 0) {
a.push_back(make_pair(t, i + 1));
} else if (xa == 0 && xb == 1) {
b.push_back(make_pair(t, i + 1));
} else if (xa == 0 && xb == 0) {
c.push_back(make_pair(t, i + 1));
}
}
sort(a.begin(), a.end());
sort(b.begin(), b.end());
sort(c.begin(), c.end());
sort(z.begin(), z.end());
if (min(a.size(), b.size()) + z.size() < k) {
printf("-1\n");
return 0;
}
int cz = min<int>(z.size(), k);
int ca = k - cz;
int cb = k - cz;
int cc = 0;
if (cz + ca + cb > m) {
printf("-1\n");
return 0;
}
while (ca < a.size() && cb < b.size() && cz > 0) {
if (z[cz - 1].first > a[ca].first + b[cb].first) {
if (cz + ca + cb + 1 > m) {
break;
}
cz--;
ca++;
cb++;
} else {
break;
}
}
while (ca + cb + cc + cz < m) {
int tm = 1000000001;
if (ca < a.size()) {
tm = min<int>(tm, a[ca].first);
}
if (cb < b.size()) {
tm = min<int>(tm, b[cb].first);
}
if (cc < c.size()) {
tm = min<int>(tm, c[cc].first);
}
if (cz < z.size()) {
tm = min<int>(tm, z[cz].first);
}
if (ca < a.size() && tm == a[ca].first) {
ca++;
if (cz > 0 && cb < b.size()) {
if (z[cz - 1].first > b[cb].first) {
cz--;
cb++;
}
}
} else if (cb < b.size() && tm == b[cb].first) {
cb++;
if (cz > 0 && ca < a.size()) {
if (z[cz - 1].first > a[ca].first) {
cz--;
ca++;
}
}
} else if (cc < c.size() && tm == c[cc].first) {
cc++;
} else if (cz < z.size() && tm == z[cz].first) {
cz++;
}
}
long long int answer = 0;
vector<int> ans;
ans.reserve(n);
for (int i = 0; i < cz; ++i) {
answer += z[i].first;
ans.push_back(z[i].second);
}
for (int i = 0; i < ca; ++i) {
answer += a[i].first;
ans.push_back(a[i].second);
}
for (int i = 0; i < cb; ++i) {
answer += b[i].first;
ans.push_back(b[i].second);
}
for (int i = 0; i < cc; ++i) {
answer += c[i].first;
ans.push_back(c[i].second);
}
printf("%lld\n", answer);
sort(ans.begin(), ans.end());
for (int i = 0; i < ans.size(); ++i) {
printf("%d", ans[i]);
if (i < ans.size() - 1) {
printf(" ");
} else {
printf("\n");
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int32_t main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int64_t n, k, ac = 0, bc = 0;
cin >> n >> k;
vector<int64_t> main;
vector<int64_t> a_array;
vector<int64_t> b_array;
while (n--) {
int64_t t, a, b;
cin >> t >> a >> b;
if (a == 1) ac += 1;
if (b == 1) bc += 1;
if (a == 1 && b == 1)
main.push_back(t);
else {
if (a == 1) a_array.push_back(t);
if (b == 1) b_array.push_back(t);
}
}
if (ac >= k && bc >= k) {
int64_t i, ans = 0;
sort(main.begin(), main.end());
sort(a_array.begin(), a_array.end());
sort(b_array.begin(), b_array.end());
int64_t l = 0, m = 0, n = 0;
int64_t aSize = a_array.size();
int64_t bSize = b_array.size();
int64_t mSize = main.size();
for (i = 1; i <= k; i++) {
if (aSize >= 1 && bSize >= 1) {
if (mSize >= 1) {
if ((a_array[l] + b_array[m]) <= main[n]) {
ans = ans + a_array[l] + b_array[m];
l += 1;
m += 1;
aSize -= 1;
bSize -= 1;
} else {
ans += main[n];
n += 1;
mSize -= 1;
}
} else {
ans = ans + a_array[l] + b_array[m];
l += 1;
m += 1;
aSize -= 1;
bSize -= 1;
}
} else {
ans += main[n];
n += 1;
mSize -= 1;
}
}
cout << ans;
} else
cout << -1;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
void solution() {
int n, k;
cin >> n >> k;
vector<int> zero, one, two;
for (int i = 0; i < n; i++) {
int t1, t2, t3;
cin >> t1 >> t2 >> t3;
if (t2 == 0 && t3 == 1) {
one.push_back(t1);
} else if (t2 == 1 && t3 == 0) {
zero.push_back(t1);
} else if (t2 == 1 && t3 == 1) {
two.push_back(t1);
}
}
sort(zero.begin(), zero.end());
sort(one.begin(), one.end());
sort(two.begin(), two.end());
int last = 0;
int output = -1;
for (int i = 1; i < min(one.size(), zero.size()); i++) {
one[i] += one[i - 1];
zero[i] += zero[i - 1];
}
for (int i = 0; i <= min(k, (int)two.size()); i++) {
last += (i > 0 ? two[i - 1] : 0);
if (k - i > min(zero.size(), one.size())) {
continue;
}
int t_output = last + (k - i > 0 ? one[k - i - 1] + zero[k - i - 1] : 0);
if (t_output < output || output == -1) {
output = t_output;
}
}
cout << output << endl;
return;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int count, counter = 0;
count = 1;
while (counter++ < count) {
solution();
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
using Int = int64_t;
vector<Int> csum(vector<Int>& v) {
vector<Int> r(v.size());
copy(v.begin(), v.end(), r.begin());
for (int i = 1; i < r.size(); ++i) r[i] += r[i - 1];
return r;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
cout.tie(nullptr);
Int N, K;
cin >> N >> K;
vector<Int> v, u, cmn;
while (N--) {
Int a, b, c;
cin >> c >> a >> b;
if (a + b == 0) continue;
;
if (a + b == 2)
cmn.emplace_back(c);
else if (a == 1)
v.emplace_back(c);
else
u.emplace_back(c);
}
sort(v.begin(), v.end());
sort(u.begin(), u.end());
sort(cmn.begin(), cmn.end());
auto cv = csum(v);
auto cu = csum(u);
auto ccmn = csum(cmn);
Int ans = 1LL << 60;
if (v.size() >= K && u.size() >= K) {
ans = cv[K - 1] + cu[K - 1];
}
if (cmn.size() >= K) ans = min(ans, ccmn[K - 1]);
for (int i = 0; i < cmn.size(); ++i) {
if (K - i - 2 < 0) continue;
if (v.size() > K - i - 2 && u.size() > K - 2 - i) {
ans = min(ans, cv[K - i - 2] + cu[K - i - 2] + ccmn[i]);
}
}
cout << (ans == 1LL << 60 ? -1 : ans) << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m, k;
struct Node {
int id, t, a, b;
bool friend operator<(Node a, Node b) { return a.t < b.t; }
};
vector<Node> v[5];
int sz[5];
int pos[5], anspos[5];
int ans;
int main() {
cin >> n >> m >> k;
for (int i = 1; i <= n; i++) {
int t, a, b;
cin >> t >> a >> b;
v[a * 2 + b].push_back(Node{i, t, a, b});
}
for (int i = 0; i <= 3; i++) sort(v[i].begin(), v[i].end());
for (int i = 0; i <= 3; i++) sz[i] = v[i].size();
ans = -1;
int tmp = 0;
for (auto x : v[3]) tmp += x.t;
pos[3] = sz[3];
for (int i = sz[3]; i >= 0; i--) {
while (pos[1] + pos[3] < k && pos[1] < sz[1]) {
tmp += v[1][pos[1]].t;
pos[1]++;
}
while (pos[2] + pos[3] < k && pos[2] < sz[2]) {
tmp += v[2][pos[2]].t;
pos[2]++;
}
int last = m - pos[1] - pos[2] - pos[3] - pos[0];
while (last < 0 && pos[0] > 0) {
pos[0]--;
tmp -= v[0][pos[0]].t;
last++;
}
while (last > 0) {
int fuck = -1;
for (int i = 0; i < 4; i++)
if (pos[i] < sz[i]) {
if (fuck == -1 || v[i][pos[i]].t < v[fuck][pos[fuck]].t) fuck = i;
}
if (fuck == -1) break;
tmp += v[fuck][pos[fuck]].t;
pos[fuck]++;
last--;
}
if (last == 0 && pos[1] + pos[3] >= k && pos[2] + pos[3] >= k) {
if (ans == -1 || tmp < ans) {
ans = tmp;
memcpy(anspos, pos, sizeof(pos));
}
}
pos[3]--;
if (pos[3] >= 0) tmp -= v[3][pos[3]].t;
}
printf("%d\n", ans);
if (ans == -1) return 0;
vector<int> res;
for (int i = 0; i < 4; ++i) {
for (int j = 0; j < anspos[i]; ++j) {
res.push_back(v[i][j].id);
}
}
for (auto y : res) printf("%d ", y);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
void err(istream_iterator<string> it) {}
template <typename T, typename... Args>
void err(istream_iterator<string> it, T a, Args... args) {
cout << *it << " = " << a << endl;
err(++it, args...);
}
void solve() {
int n, k;
cin >> n >> k;
vector<int> a, b, c;
for (int i = 0; i < n; i++) {
int t, al, bo;
cin >> t >> al >> bo;
pair<int, int> temp = make_pair(al, bo);
if (temp == make_pair(1, 0)) {
a.push_back(t);
} else if (temp == make_pair(0, 1)) {
b.push_back(t);
} else if (temp == make_pair(1, 1)) {
c.push_back(t);
}
}
sort(a.begin(), a.end());
sort(b.begin(), b.end());
sort(c.begin(), c.end());
int x1 = 0, x2 = 0, ans = 0;
int i = 0, j = 0;
bool ok = true;
while (x1 < k || x2 < k) {
if (i == c.size() && j == min(((int)(a).size()), ((int)(b).size()))) {
ok = false;
break;
}
if (j == min(((int)(a).size()), ((int)(b).size())) ||
(i != ((int)(c).size()) && c[i] <= (a[j] + b[j]))) {
ans += c[i++];
x1++;
x2++;
} else {
ans += (a[j] + b[j]);
j++;
x1++;
x2++;
}
}
cout << (ok ? ans : -1) << endl;
}
int main() {
ios::sync_with_stdio(0);
cin.tie(NULL);
cout.tie(NULL);
int T = 1;
while (T--) solve();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int M = 1e2 + 100;
const int N = 2e3 + 100;
const int INF = 0x3f3f3f3f;
const int mod = 1e9 + 7;
long long n, m, t, k, x, y;
vector<long long> ab, bb, abb;
void slove() {
scanf("%lld%lld", &n, &k);
ab.clear(), bb.clear(), abb.clear();
for (int i = 0; i < n; i++) {
long long t, a, b;
scanf("%lld%lld%lld", &t, &a, &b);
if (a && b)
abb.push_back(t);
else if (a)
ab.push_back(t);
else if (b)
bb.push_back(t);
}
sort(ab.begin(), ab.end(), greater<int>());
sort(bb.begin(), bb.end(), greater<int>());
long long ans = 0;
while (ab.size() && bb.size()) {
abb.push_back(ab.back() + bb.back());
ab.pop_back(), bb.pop_back();
}
sort(abb.begin(), abb.end());
if (abb.size() < k)
ans = -1;
else
for (int i = 0; i < k; i++) ans += abb[i];
printf("%lld\n", ans);
return;
}
int main() {
int T = 1;
while (T--) {
slove();
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int t[200005], a[200005], b[200005];
pair<int, int> aa[200005], bb[200005], ab[200005];
int sumaa[200005], sumbb[200005], sumab[200005];
int BITcnt[10005], BITsum[10005];
int anss[200005], ccc;
vector<int> v[10005];
bool f[200005];
int lowbit(int x) { return x & (-x); }
void updatecnt(int x, int d) {
while (x <= 10000) {
BITcnt[x] += d;
x += lowbit(x);
}
}
void updatesum(int x, int d) {
while (x <= 10000) {
BITsum[x] += d;
x += lowbit(x);
}
}
int querycnt(int x) {
int ret = 0;
while (x) {
ret += BITcnt[x];
x -= lowbit(x);
}
return ret;
}
int querysum(int x) {
int ret = 0;
while (x) {
ret += BITsum[x];
x -= lowbit(x);
}
return ret;
}
bool check(int x, int c) { return querycnt(x) < c; }
int binarysearch(int l, int r, int c) {
if (l == r)
return l;
else if (r - l == 1) {
if (check(r, c)) return r;
return l;
}
int mid = (l + r) / 2;
if (check(mid, c))
return binarysearch(mid, r, c);
else
return binarysearch(l, mid - 1, c);
}
int main() {
int n, m, k, cnta, cntb, cntab, ans, now, p, pp, qq, ansi;
scanf("%d%d%d", &n, &m, &k);
for (int i = 1; i <= n; i++) scanf("%d%d%d", &t[i], &a[i], &b[i]);
cnta = 0;
cntb = 0;
cntab = 0;
for (int i = 1; i <= n; i++)
if (a[i] && b[i])
ab[++cntab] = make_pair(t[i], i);
else if (a[i])
aa[++cnta] = make_pair(t[i], i);
else if (b[i])
bb[++cntb] = make_pair(t[i], i);
sort(ab + 1, ab + cntab + 1);
sort(aa + 1, aa + cnta + 1);
sort(bb + 1, bb + cntb + 1);
for (int i = 1; i <= cntab; i++) sumab[i] = sumab[i - 1] + ab[i].first;
for (int i = 1; i <= cnta; i++) sumaa[i] = sumaa[i - 1] + aa[i].first;
for (int i = 1; i <= cntb; i++) sumbb[i] = sumbb[i - 1] + bb[i].first;
for (int i = 1; i <= cntab; i++) {
updatecnt(ab[i].first, 1);
updatesum(ab[i].first, ab[i].first);
}
for (int i = k + 1; i <= cnta; i++) {
updatecnt(aa[i].first, 1);
updatesum(aa[i].first, aa[i].first);
}
for (int i = k + 1; i <= cntb; i++) {
updatecnt(bb[i].first, 1);
updatesum(bb[i].first, bb[i].first);
}
for (int i = 1; i <= n; i++)
if (!a[i] && !b[i]) {
updatecnt(t[i], 1);
updatesum(t[i], t[i]);
}
ans = 0x7fffffff;
for (int i = 0; i <= cntab; i++) {
pp = max(0, k - i);
qq = max(0, k - i);
if (cnta < k - i || cntb < k - i) {
if (i < cntab) {
updatecnt(ab[i + 1].first, -1);
updatesum(ab[i + 1].first, -ab[i + 1].first);
}
if (pp > 0 && pp <= cnta) {
updatecnt(aa[pp].first, 1);
updatesum(aa[pp].first, aa[pp].first);
}
if (qq > 0 && qq <= cntb) {
updatecnt(bb[qq].first, 1);
updatesum(bb[qq].first, bb[qq].first);
}
continue;
}
if (i + pp + qq > m) {
if (i < cntab) {
updatecnt(ab[i + 1].first, -1);
updatesum(ab[i + 1].first, -ab[i + 1].first);
}
if (pp) {
updatecnt(aa[pp].first, 1);
updatesum(aa[pp].first, aa[pp].first);
}
if (qq) {
updatecnt(bb[qq].first, 1);
updatesum(bb[qq].first, bb[qq].first);
}
continue;
}
if (i + pp + qq == m) {
if (sumab[i] + sumaa[pp] + sumbb[qq] < ans) {
ans = sumab[i] + sumaa[pp] + sumbb[qq];
ansi = i;
}
} else {
p = binarysearch(0, 10000, m - i - pp - qq);
if (sumab[i] + sumaa[pp] + sumbb[qq] + querysum(p) +
(m - i - pp - qq - querycnt(p)) * (p + 1) <
ans) {
ans = sumab[i] + sumaa[pp] + sumbb[qq] + querysum(p) +
(m - i - pp - qq - querycnt(p)) * (p + 1);
ansi = i;
}
}
if (i < cntab) {
updatecnt(ab[i + 1].first, -1);
updatesum(ab[i + 1].first, -ab[i + 1].first);
}
if (pp) {
updatecnt(aa[pp].first, 1);
updatesum(aa[pp].first, aa[pp].first);
}
if (qq) {
updatecnt(bb[qq].first, 1);
updatesum(bb[qq].first, bb[qq].first);
}
}
if (ans == 0x7fffffff)
printf("-1\n");
else {
printf("%d\n", ans);
for (int i = 0; i <= 10000; i++) BITcnt[i] = 0;
for (int i = 0; i <= 10000; i++) BITsum[i] = 0;
for (int i = 1; i <= ansi; i++) {
anss[ccc++] = ab[i].second;
f[ab[i].second] = true;
}
for (int i = 1; i <= k - ansi; i++) {
anss[ccc++] = aa[i].second;
f[aa[i].second] = true;
}
for (int i = 1; i <= k - ansi; i++) {
anss[ccc++] = bb[i].second;
f[bb[i].second] = true;
}
for (int i = 1; i <= n; i++)
if (!f[i]) {
updatecnt(t[i], 1);
updatesum(t[i], t[i]);
v[t[i]].push_back(i);
}
if (ccc != m) {
p = binarysearch(0, 10000, m - ccc);
int tt = m - ccc - querycnt(p);
for (int i = 1; i <= p; i++)
for (int j = 0; j < v[i].size(); j++) anss[ccc++] = v[i][j];
for (int i = 0; i < tt; i++) anss[ccc++] = v[p + 1][i];
}
for (int i = 0; i < ccc; i++)
if (i != ccc - 1)
printf("%d ", anss[i]);
else
printf("%d\n", anss[i]);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long mod = 1e9 + 7;
const long long mod2 = 998244353;
const long long INF = 1000000001;
const long long N = 100001;
const long double PI = 3.141593;
long double powm(long long base, long long exp) {
long long ans = 1;
while (exp) {
if (exp & 1) ans = (ans * base) % mod;
exp >>= 1, base = (base * base) % mod;
}
return ans;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
long long n, k;
cin >> n >> k;
priority_queue<long long, vector<long long>, greater<long long>> A, B, C;
for (long long i = 0; i < n; i++) {
long long t, a, b;
cin >> t >> a >> b;
if (a == 1 && b == 1)
C.push(t);
else if (a == 1 && b == 0)
A.push(t);
else if (a == 0 && b == 1)
B.push(t);
}
if (A.size() + C.size() < k || B.size() + C.size() < k) {
cout << "-1" << endl;
return 0;
}
long long a = 0, b = 0, fa = 0;
while (a < k || b < k) {
if (A.size() == 0 && a < k) {
a++;
b++;
fa += C.top();
C.pop();
} else if (C.size() == 0 && a < k) {
a++;
fa += A.top();
A.pop();
} else if (B.size() == 0 && b < k) {
a++;
b++;
fa += C.top();
C.pop();
} else if (C.size() == 0 && b < k) {
b++;
fa += B.top();
B.pop();
} else if (A.top() + B.top() > C.top()) {
a++;
b++;
fa += C.top();
C.pop();
} else {
a++;
b++;
fa += A.top();
fa += B.top();
A.pop();
B.pop();
}
}
cout << fa << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long MAX = 3e5;
long long fen[MAX], cnt[MAX], sum[MAX];
deque<pair<long long, long long> > a, b, s, d, v;
multiset<pair<long long, long long> > sol;
void add(long long t, long long cur, long long val) {
if (cur > 2e4) return;
if (t == cur) cnt[t] += val;
if (cur == 0) {
cur++;
add(t, cur, val);
return;
}
sum[cur] += val * t;
fen[cur] += val;
add(t, cur + (cur & -cur), val);
}
long long psum(long long n) {
if (n == 0) return 0;
return sum[n] + psum(n - (n & -n));
}
long long pfen(long long n) {
if (n == 0) return cnt[0];
return fen[n] + pfen(n - (n & -n));
}
long long bin(long long cur, long long l = 0, long long r = 2e4) {
if (r < l) return -1;
long long mid = (l + r) / 2;
if (mid == 0) {
if (cnt[mid] >= cur) return 0;
return -1;
}
long long x = psum(mid - 1), y = pfen(mid - 1);
if (y >= cur) return bin(cur, l, mid - 1);
if (y + cnt[mid] >= cur) return x + (cur - y) * mid;
return bin(cur, mid + 1, r);
}
int main() {
long long n, m, k;
cin >> n >> m >> k;
for (long long i = 0; i < n; i++) {
long long x, y, z;
cin >> x >> y >> z;
add(x, x, 1);
if (y == 1 && z == 1)
s.push_back({x, i});
else if (y == 0 && z == 0)
v.push_back({x, i});
else if (y == 1)
a.push_back({x, i});
else if (z == 1)
b.push_back({x, i});
}
long long t = min((long long)a.size(), min((long long)b.size(), k));
sort(s.begin(), s.end());
sort(a.begin(), a.end());
sort(b.begin(), b.end());
while (s.size() > k) v.push_back(s.back()), s.pop_back();
while (a.size() > t) v.push_back(a.back()), a.pop_back();
while (b.size() > t) v.push_back(b.back()), b.pop_back();
long long ad = 0;
long long sum = 0, c = 0, bk = 0;
for (auto i : s) add(i.first, i.first, -1), sum += i.first, bk++, c++, ad++;
while (c < k && a.size()) {
c++;
bk += 2;
sum += a[0].first;
sum += b[0].first;
d.push_back(a[0]);
d.push_back(b[0]);
add(a[0].first, a[0].first, -1);
add(b[0].first, b[0].first, -1);
a.pop_front();
b.pop_front();
}
if (c != k) {
cout << -1;
return 0;
}
if (bin(m - bk) != -1) sol.insert({sum + bin(m - bk), ad});
for (long long i = s.size() - 1; i > -1; i--) {
ad--;
sum -= s[i].first;
add(s[i].first, s[i].first, 1);
if (a.size()) {
bk++;
sum += a[0].first;
sum += b[0].first;
d.push_back(a[0]);
d.push_back(b[0]);
add(a[0].first, a[0].first, -1);
add(b[0].first, b[0].first, -1);
a.pop_front();
b.pop_front();
if (c != k || bk > m) continue;
if (bin(m - bk) == -1) continue;
sol.insert({sum + bin(m - bk), ad});
}
}
while (sol.size() && (*sol.begin()).first == -1) sol.erase(sol.begin());
if (!sol.size()) {
cout << -1;
return 0;
}
c = 0;
vector<long long> pr;
t = (*sol.begin()).second;
if (s.size() < t) {
cout << -1;
return 0;
}
while (t--) {
pr.push_back(s[0].second);
s.pop_front();
}
t = k - pr.size();
if (d.size() < 2 * t) {
cout << -1;
return 0;
}
while (t--) {
pr.push_back(d[0].second);
d.pop_front();
pr.push_back(d[0].second);
d.pop_front();
}
for (auto i : d) v.push_back(i);
for (auto i : s) v.push_back(i);
for (auto i : a) v.push_back(i);
for (auto i : b) v.push_back(i);
sort(v.begin(), v.end());
t = m - pr.size();
if (v.size() < t) {
cout << -1;
return 0;
}
while (t--) pr.push_back(v[0].second), v.pop_front();
cout << (*sol.begin()).first << endl;
for (auto i : pr) cout << i + 1 << " ";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
namespace IO {
const int BUFFER_SIZE = 1 << 15;
char input_buffer[BUFFER_SIZE];
size_t input_pos = 0, input_len = 0;
char output_buffer[BUFFER_SIZE];
int output_pos = 0;
char number_buffer[100];
uint8_t lookup[100];
void _update_input_buffer() {
input_len = fread(input_buffer, sizeof(char), BUFFER_SIZE, stdin);
input_pos = 0;
if (input_len == 0) input_buffer[0] = EOF;
}
inline char next_char(bool advance = true) {
if (input_pos >= input_len) _update_input_buffer();
return input_buffer[advance ? input_pos++ : input_pos];
}
inline bool isspace(char c) {
return (unsigned char)(c - '\t') < 5 || c == ' ';
}
inline void read_char(char &c) {
while (isspace(next_char(false))) next_char();
c = next_char();
}
template <typename T>
inline void read_int(T &number) {
bool negative = false;
number = 0;
while (!isdigit(next_char(false)))
if (next_char() == '-') negative = true;
do {
number = 10 * number + (next_char() - '0');
} while (isdigit(next_char(false)));
if (negative) number = -number;
}
template <typename T, typename... Args>
inline void read_int(T &number, Args &...args) {
read_int(number);
read_int(args...);
}
inline void read_str(string &str) {
while (isspace(next_char(false))) next_char();
str.clear();
do {
str += next_char();
} while (!isspace(next_char(false)));
}
void _flush_output() {
fwrite(output_buffer, sizeof(char), output_pos, stdout);
output_pos = 0;
}
inline void write_char(char c) {
if (output_pos == BUFFER_SIZE) _flush_output();
output_buffer[output_pos++] = c;
}
template <typename T>
inline void write_int(T number, char after = '\0') {
if (number < 0) {
write_char('-');
number = -number;
}
int length = 0;
while (number >= 10) {
uint8_t lookup_value = lookup[number % 100];
number /= 100;
number_buffer[length++] = char((lookup_value & 15) + '0');
number_buffer[length++] = char((lookup_value >> 4) + '0');
}
if (number != 0 || length == 0) write_char(char(number + '0'));
for (int i = length - 1; i >= 0; i--) write_char(number_buffer[i]);
if (after) write_char(after);
}
inline void write_str(const string &str, char after = '\0') {
for (char c : str) write_char(c);
if (after) write_char(after);
}
void init() {
bool exit_success = atexit(_flush_output) == 0;
assert(exit_success);
for (int i = 0; i < 100; i++) lookup[i] = uint8_t((i / 10 << 4) + i % 10);
}
} // namespace IO
void solution() {
IO::init();
int n, m, k;
IO::read_int(n, m, k);
vector<pair<int, int>> both, a, b, non;
both.push_back({0, 0});
a = both;
b = both;
non = both;
both.pop_back();
for (int i = 1; i <= n; i++) {
int t, x, y;
IO::read_int(t, x, y);
if (x && y)
both.emplace_back(t, i);
else if (x)
a.emplace_back(t, i);
else if (y)
b.emplace_back(t, i);
else
non.emplace_back(t, i);
}
sort(both.begin(), both.end());
sort(a.begin(), a.end());
sort(b.begin(), b.end());
sort(non.begin(), non.end());
int sza = a.size() - 1, szb = b.size() - 1, szn = non.size() - 1;
vector<int> sa(a.size()), sb(b.size()), sn(non.size());
for (int i = 1; i < a.size(); i++) sa[i] = sa[i - 1] + a[i].first;
for (int i = 1; i < b.size(); i++) sb[i] = sb[i - 1] + b[i].first;
for (int i = 1; i < non.size(); i++) sn[i] = sn[i - 1] + non[i].first;
int kz;
auto check = [&](int val, int nums) {
if (nums < 0) return pair<bool, int>{false, 0};
int ita = upper_bound(a.begin(), a.end(), pair<int, int>{val, LONG_MAX}) -
a.begin();
ita--;
int itb = upper_bound(b.begin(), b.end(), pair<int, int>{val, LONG_MAX}) -
b.begin();
itb--;
int itn =
upper_bound(non.begin(), non.end(), pair<int, int>{val, LONG_MAX}) -
non.begin();
itn--;
int sum = 0;
if (ita > kz) sum += sa[ita] - sa[kz];
if (itb > kz) sum += sb[itb] - sb[kz];
ita = max(0, ita - kz);
itb = max(0, itb - kz);
int use = ita + itb + itn;
if (use < nums) return pair<bool, int>{false, 0};
int excess = use - nums;
sum += sn[itn] - val * excess;
return pair<bool, int>{true, sum};
};
int sum_both = 0;
tuple<int, int, int> ans = {LONG_MAX, -1, -1};
for (int i = 0; i <= both.size(); i++) {
if (i > 0) sum_both += both[i - 1].first;
kz = max(0, k - i);
if (kz > sza || kz > szb) continue;
if (kz + kz + i > m) continue;
if (i + sza + szb + szn < m) continue;
int l = 1, r = 10000, pv = -1, temp = -1;
while (l <= r) {
int mid = (l + r) >> 1;
pair<bool, int> ck = check(mid, m - kz * 2 - i);
if (ck.first)
r = mid - 1, pv = mid, temp = ck.second;
else
l = mid + 1;
}
if (pv == -1) continue;
ans = min(ans, make_tuple(sum_both + sa[kz] + sb[kz] + temp, i, pv));
}
if (get<1>(ans) == -1)
cout << -1;
else {
IO::write_int(get<0>(ans), '\n');
for (int i = 0; i < get<1>(ans); i++) IO::write_int(both[i].second, ' ');
kz = k - get<1>(ans);
kz = max(0, kz);
for (int i = 1; i <= kz; i++) {
IO::write_int(a[i].second, ' ');
IO::write_int(b[i].second, ' ');
}
vector<pair<int, int>> v;
for (int i = kz + 1; i < a.size(); i++) v.push_back(a[i]);
for (int i = kz + 1; i < b.size(); i++) v.push_back(b[i]);
for (int i = 1; i < non.size(); i++) v.push_back(non[i]);
sort(v.begin(), v.end());
for (int i = 0; i < m - kz * 2 - get<1>(ans); i++)
IO::write_int(v[i].second, ' ');
}
}
signed main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
int tc = 1;
while (tc--) {
solution();
}
}
|
#include <bits/stdc++.h>
using namespace std;
int lim[4];
vector<pair<int, int> > t[4];
int get() {
vector<pair<int, int> > tmp;
for (int i = 0; i <= 2; i++) {
if (lim[i] != t[i].size()) {
tmp.push_back({t[i][lim[i]].first, i});
}
}
if (tmp.empty()) return 0;
sort(tmp.begin(), tmp.end());
lim[tmp[0].second]++;
return tmp[0].first;
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
int n, m, k;
cin >> n >> m >> k;
for (int i = 1; i <= n; i++) {
int tmp, a, b;
cin >> tmp >> a >> b;
t[(a << 1) | b].push_back({tmp, i});
}
for (int i = 0; i <= 3; i++) sort(t[i].begin(), t[i].end());
for (int i = int(t[3].size()) - 1; i >= k; i--) {
t[0].push_back(t[3][i]);
t[3].pop_back();
}
sort(t[0].begin(), t[0].end());
lim[3] = t[3].size();
lim[2] = lim[1] = k - lim[3];
lim[0] = 0;
int cnt = m - (lim[1] + lim[2] + lim[3]);
if (cnt < 0) {
cout << -1 << endl;
return 0;
}
int ans = 0;
for (auto val : t[3]) ans += val.first;
for (int i = 0; i < lim[1]; i++) {
if (i == t[1].size() || i == t[2].size()) {
cout << -1 << endl;
return 0;
}
ans += t[1][i].first + t[2][i].first;
}
for (int i = 0; i < cnt; i++) {
int tmp = get();
if (tmp)
ans += tmp;
else {
cout << -1 << endl;
return 0;
}
}
int minn = ans, pos[4];
for (int i = 0; i <= 3; i++) pos[i] = lim[i];
for (lim[3]--; lim[3] >= 0; lim[3]--) {
ans -= t[3][lim[3]].first;
int now = k - lim[3];
if (now == t[1].size() + 1 || now == t[2].size() + 1) break;
if (now <= lim[1] && now <= lim[2]) {
int tmp = get();
if (tmp)
ans += tmp;
else
break;
} else {
if (now > lim[1]) {
ans += t[1][now - 1].first;
}
if (now > lim[2]) {
ans += t[2][now - 1].first;
}
if (now > lim[1] && now > lim[2]) {
if (lim[0] == 0) break;
ans -= (t[0][--lim[0]].first);
}
lim[1] = max(lim[1], now);
lim[2] = max(lim[2], now);
}
if (minn > ans) {
minn = ans;
for (int i = 0; i <= 3; i++) pos[i] = lim[i];
}
}
lim[3]++;
cout << minn << endl;
for (int i = 0; i <= 3; i++) {
for (int j = 0; j < pos[i]; j++) {
cout << t[i][j].second << " ";
}
}
cout << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
template <class T>
inline bool chmax(T &a, T b) {
if (a < b) {
a = b;
return true;
}
return false;
}
template <class T>
inline bool chmin(T &a, T b) {
if (a > b) {
a = b;
return true;
}
return false;
}
const long long INF = 1e11;
vector<long long> v[2][2];
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
long long N, K;
cin >> N >> K;
for (int i = 0; i < N; i++) {
long long t, a, b;
cin >> t >> a >> b;
v[a][b].push_back(t);
}
long long ans = INF;
for (int i = 0; i <= 1; i++) {
for (int j = 0; j <= 1; j++) {
for (int k = 0; k <= K; k++) {
v[i][j].push_back(INF);
}
sort(v[i][j].begin(), v[i][j].end());
}
}
long long now = 0;
for (int i = 0; i < K; i++) {
now += v[1][1][i];
}
chmin(ans, now);
for (int i = 0; i < K; i++) {
now -= v[1][1][K - 1 - i];
now += v[0][1][i];
now += v[1][0][i];
chmin(ans, now);
}
if (ans >= INF) ans = -1;
cout << ans << "\n";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int const MAXN = 2e5 + 10;
int n, m, T, k;
vector<pair<int, int>> a, b, ab, other;
vector<int> ans;
int check(int mid) {
if ((int)a.size() < k - mid) return 2e9 + 1;
if ((int)b.size() < k - mid) return 2e9 + 1;
if (mid + max(0, k - mid) * 2 > m) return 2e9 + 1;
int nd = m - mid, res = 0;
ans.clear();
vector<pair<int, int>> vec;
for (int i = 0; i < mid; i++) res += ab[i].first, ans.push_back(ab[i].second);
for (int i = mid; i < ab.size(); i++) vec.push_back(ab[i]);
for (int i = 0; i < k - mid; i++)
res += a[i].first + b[i].first, nd -= 2, ans.push_back(a[i].second),
ans.push_back(b[i].second);
for (int i = max(0, k - mid); i < a.size(); i++) vec.push_back(a[i]);
for (int i = max(0, k - mid); i < b.size(); i++) vec.push_back(b[i]);
for (int i = 0; i < other.size(); i++) vec.push_back(other[i]);
sort(vec.begin(), vec.end());
for (int i = 0; i < nd && i < vec.size(); i++)
res += vec[i].first, ans.push_back(vec[i].second);
return res;
}
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cin >> n >> m >> k;
for (int i = 1, x1, x2, x3; i <= n; ++i) {
cin >> x1 >> x2 >> x3;
if (x2 && x3)
ab.push_back({x1, i});
else if (x2)
a.push_back({x1, i});
else if (x3)
b.push_back({x1, i});
else
other.push_back({x1, i});
}
sort(a.begin(), a.end()), sort(b.begin(), b.end()),
sort(ab.begin(), ab.end()), sort(other.begin(), other.end());
int l = 0, r = min((int)ab.size(), m);
while (r - l > 10) {
int midl = l + (r - l) / 3, midr = r - (r - l) / 3;
if (check(midl) >= check(midr))
l = midl;
else
r = midr;
}
int res = 2e9 + 1, Min_idx = -1;
for (int i = l; i <= r; i++) {
int tmp = check(i);
if (tmp < res) res = tmp, Min_idx = i;
}
if (Min_idx == -1) return puts("-1"), 0;
cout << check(Min_idx) << endl;
for (auto a : ans) cout << a << " ";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long n, k, t, a, b, it1, it2, score, tim, f, s;
vector<long long> vec[4];
int main() {
cin >> n >> k;
for (int i = 1; i <= n; i++) {
cin >> t >> a >> b;
if (a == 1) f++;
if (b == 1) s++;
if (a == 0 && b == 0) continue;
if (a == 1 && b == 1) {
vec[1].push_back(t);
continue;
}
if (a == 1) vec[2].push_back(t);
if (b == 1) vec[3].push_back(t);
}
if (f < k || s < k) {
cout << -1 << endl;
} else {
for (int i = 1; i <= 3; i++) {
sort(vec[i].begin(), vec[i].end());
}
it1 = 0;
it2 = 0;
tim = 0;
score = 0;
while (score < k) {
if (it1 == vec[1].size()) {
tim += vec[2][it2] + vec[3][it2];
it2++;
score++;
continue;
}
if (it2 == vec[2].size() || it2 == vec[3].size()) {
tim += vec[1][it1];
score++;
it1++;
continue;
}
if (vec[1][it1] < vec[2][it2] + vec[3][it2]) {
tim += vec[1][it1];
score++;
it1++;
} else {
tim += vec[2][it2] + vec[3][it2];
it2++;
score++;
}
}
cout << tim << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int INF = 2147483640;
const int MAXN = 2e5 + 5;
const int R = 1e4 + 5;
int n, m, k;
int tot[10];
struct node {
int t, i;
} A[MAXN], B[MAXN], C[MAXN], D[MAXN], E[MAXN << 2];
bool cmp(node x, node y) { return x.t < y.t; }
struct tree {
int sum, w;
} tr[R << 2];
void modify(int x, int l, int r, int pos, int k) {
if (l == r) {
tr[x].sum += k * l;
tr[x].w += k;
return;
}
int mid = (l + r) / 2;
if (pos <= mid) modify(x * 2, l, mid, pos, k);
if (pos > mid) modify(x * 2 + 1, mid + 1, r, pos, k);
tr[x].sum = tr[x * 2].sum + tr[x * 2 + 1].sum;
tr[x].w = tr[x * 2].w + tr[x * 2 + 1].w;
}
int query(int x, int l, int r, int kth) {
int ans = 0;
if (kth == tr[x].w) return tr[x].sum;
if (l == r) return kth * l;
int mid = (l + r) / 2;
if (tr[x * 2].w < kth)
ans = tr[x * 2].sum + query(x * 2 + 1, mid + 1, r, kth - tr[x * 2].w);
else
ans = query(x * 2, l, mid, kth);
return ans;
}
int main() {
scanf("%d%d%d", &n, &m, &k);
for (int i = 1; i <= n; i++) {
int t, a, b;
scanf("%d%d%d", &t, &a, &b);
if (a == 1 && b == 1) A[++tot[1]] = (node){t, i};
if (a == 0 && b == 1) B[++tot[2]] = (node){t, i};
if (a == 1 && b == 0) C[++tot[3]] = (node){t, i};
if (a == 0 && b == 0) D[++tot[4]] = (node){t, i};
}
if (min(tot[2], tot[3]) + tot[1] < k) {
printf("-1");
return 0;
}
sort(A + 1, A + tot[1] + 1, cmp);
sort(B + 1, B + tot[2] + 1, cmp);
sort(C + 1, C + tot[3] + 1, cmp);
sort(D + 1, D + tot[4] + 1, cmp);
int cost = 0, num = 0;
for (int i = 1; i <= min(m, tot[1]); i++) cost += A[i].t, num++;
int now = 0;
for (int i = 1; i <= k - tot[1]; i++)
now++, cost += (B[now].t + C[now].t), num += 2;
for (int i = m + 1; i <= tot[1]; i++) modify(1, 1, R, A[i].t, 1);
for (int i = now + 1; i <= tot[2]; i++) modify(1, 1, R, B[i].t, 1);
for (int i = now + 1; i <= tot[3]; i++) modify(1, 1, R, C[i].t, 1);
for (int i = 1; i <= tot[4]; i++) modify(1, 1, R, D[i].t, 1);
if (num > m) {
printf("-1");
return 0;
}
int minn = INF, ans_A = 0, ans_B = 0;
for (int i = min(m, tot[1]); i >= 0; i--) {
if (num > m) break;
int ans = cost + query(1, 1, R, m - num);
if (ans < minn) minn = ans, ans_A = i, ans_B = now;
modify(1, 1, R, A[i].t, 1);
cost -= A[i].t;
num--;
if (now > min(tot[2], tot[3])) break;
if (i <= k) {
num += 2;
now++;
if (now > min(tot[2], tot[3])) break;
modify(1, 1, R, B[now].t, -1);
modify(1, 1, R, C[now].t, -1);
cost += (B[now].t + C[now].t);
}
}
int ans = 0;
printf("%d\n", minn);
for (int i = 1; i <= ans_A; i++) ans += A[i].t;
for (int i = 1; i <= ans_B; i++) ans += (B[i].t + C[i].t);
int cnt = 0;
for (int i = ans_A + 1; i <= min(m, tot[1]); i++) E[++cnt] = A[i];
for (int i = ans_B + 1; i <= tot[2]; i++) E[++cnt] = B[i];
for (int i = ans_B + 1; i <= tot[3]; i++) E[++cnt] = C[i];
for (int i = 1; i <= tot[4]; i++) E[++cnt] = D[i];
sort(E + 1, E + cnt + 1, cmp);
for (int i = 1; i <= ans_A; i++) printf("%d ", A[i].i);
for (int i = 1; i <= ans_B; i++) printf("%d %d ", B[i].i, C[i].i);
for (int i = 1; i <= m - ans_A - ans_B * 2; i++) printf("%d ", E[i].i);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <typename T>
void print1d(vector<T> &a) {
for (long long int i = 0; i < a.size(); i++) {
cout << a[i] << " ";
}
cout << endl;
}
vector<long long int> divisor(long long int n) {
vector<long long int> a;
for (long long int i = 1; i * i <= n; i++) {
if (n % i == 0) {
if (n / i == i)
a.push_back(i);
else {
a.push_back(i);
a.push_back(n / i);
}
}
}
return a;
}
long long int K = 1E9;
bool sortsecond(const pair<long long int, long long int> &a,
const pair<long long int, long long int> &b) {
return a.second < b.second;
}
bool sortmake(const pair<long long int, long long int> &a,
const pair<long long int, long long int> &b) {
if (a.first < b.first)
return true;
else if (a.first > b.first)
return false;
else {
if (a.second < b.second)
return false;
else
return true;
}
}
bool isPrime(long long int n) {
for (long long int i = 2; i * i <= n; i++) {
if (n % i == 0) return false;
}
return true;
}
int32_t main() {
ios_base::sync_with_stdio(false), cin.tie(0), cout.tie(0);
;
long long int n, k;
cin >> n >> k;
vector<long long int> a, b, c;
long long int x, y, z;
for (long long int i = 0; i < n; i++) {
cin >> x >> y >> z;
if (y == 1 && z == 1)
a.push_back(x);
else if (y == 1)
b.push_back(x);
else if (z == 1)
c.push_back(x);
}
long long int an = a.size();
long long int bn = b.size();
long long int cn = c.size();
if (an + min(bn, cn) < k) {
cout << -1 << endl;
return 0;
}
sort(a.begin(), a.end());
sort(b.begin(), b.end());
sort(c.begin(), c.end());
long long int dn = min(bn, cn);
long long int ans = 0;
long long int i = 0, j = 0;
for (long long int q = 0; q < k; q++) {
if (i < an && j < dn) {
if (a[i] <= b[j] + c[j]) {
ans += a[i];
i++;
} else {
ans += b[j] + c[j];
j++;
}
} else if (i >= an) {
ans += b[j] + c[j];
j++;
} else if (j >= dn) {
ans += a[i];
i++;
}
}
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 10;
int n, k;
struct Book {
int t, a, b;
bool operator<(const Book &w) const { return t < w.t; }
} books[N];
vector<int> a, b;
bool st[N];
int main() {
cin >> n >> k;
for (int i = 0; i < n; i++) {
cin >> books[i].t >> books[i].a >> books[i].b;
}
sort(books, books + n);
int cnta = 0, cntb = 0;
for (int i = 0; i < n; i++) {
int t = books[i].t, x = books[i].a, y = books[i].b;
if (!x && !y) {
continue;
} else if (x && y) {
if (cnta < k && cntb < k) {
cnta++, cntb++;
st[i] = true;
} else if (cnta < k && cntb >= k) {
cnta++;
st[i] = true;
int c = b[b.size() - 1];
b.pop_back();
st[c] = false;
} else if (cnta >= k && cntb < k) {
cntb++;
st[i] = true;
int c = a[a.size() - 1];
a.pop_back();
st[c] = false;
} else {
if (!a.size() || !b.size()) {
break;
}
int t1 = books[a[a.size() - 1]].t, t2 = books[b[b.size() - 1]].t;
if (t < t1 + t2) {
st[i] = true;
int c = b[b.size() - 1];
b.pop_back();
st[c] = false;
c = a[a.size() - 1];
a.pop_back();
st[c] = false;
} else {
break;
}
}
} else if (x && !y && cnta < k) {
cnta++;
a.push_back(i);
st[i] = true;
} else if (!x && y && cntb < k) {
cntb++;
b.push_back(i);
st[i] = true;
}
}
if (cnta < k || cntb < k) {
cout << -1 << endl;
} else {
int res = 0;
for (int i = 0; i < n; i++) {
if (st[i]) {
res += books[i].t;
}
}
cout << res << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
long long int n, m;
cin >> n >> m;
vector<long long int> aa, bb, cc;
vector<long long int> a(n + 5);
vector<long long int> b(n + 5);
vector<long long int> c(n + 5);
for (long long int i = 1; i <= n; i++) {
cin >> a[i] >> b[i] >> c[i];
if (b[i] && c[i])
cc.push_back(a[i]);
else if (b[i])
aa.push_back(a[i]);
else if (c[i])
bb.push_back(a[i]);
}
sort(aa.begin(), aa.end());
sort(bb.begin(), bb.end());
sort(cc.begin(), cc.end());
vector<long long int> vc1(n + 5), vc2(n + 5);
for (long long int i = 0; i <= (long long int)aa.size() - 1; i++) {
if (!i) {
int gg = 0;
} else {
vc1[i] = vc1[i - 1];
}
vc1[i] += aa[i];
}
for (long long int j = 0; j <= (long long int)bb.size() - 1; j++) {
if (!j) {
int hh = 0;
} else {
vc2[j] = vc2[j - 1];
}
vc2[j] += bb[j];
}
long long int mxx = INT_MAX, s = 0;
for (long long int k = 0; k <= cc.size(); k++) {
if (!k) {
int hg = 0;
} else {
m--;
s += cc[k - 1];
}
if (aa.size() < m) {
continue;
}
if (bb.size() < m) {
continue;
}
if (m > 0) {
mxx = min(mxx, s + vc1[m - 1] + vc2[m - 1]);
} else
mxx = min(mxx, s);
}
if (mxx != INT_MAX) {
int yy = 0;
} else
mxx = -1;
cout << mxx << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
template <typename T>
ostream &operator<<(ostream &os, const vector<T> &v) {
os << "{";
for (typename vector<T>::const_iterator vi = v.begin(); vi != v.end(); ++vi) {
if (vi != v.begin()) os << ", ";
os << *vi;
}
os << "}";
return os;
}
template <typename A, typename B>
ostream &operator<<(ostream &os, const pair<A, B> &p) {
os << '(' << p.first << ", " << p.second << ')';
return os;
}
mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
long long T, N, M, K;
long long qtd11, minAns;
vector<pair<int, int> > v[4];
int nums[200010];
int menor(vector<int> &ptr) {
pair<int, int> ans(0x3f3f3f3f, 0x3f3f3f3f);
int pos = -1;
for (int i = 0; i < 4; i++) {
if (ptr[i] < v[i].size() && ans >= v[i][ptr[i]]) {
ans = v[i][ptr[i]];
pos = i;
}
}
return pos;
}
void imp() {
cout << -1 << "\n";
exit(0);
}
pair<int, int> p(pair<int, int> a) {
return pair<int, int>(-a.first, -a.second);
}
void melhor() {
for (int i = 0; i < 4; i++) sort(v[i].begin(), v[i].end());
vector<pair<int, int> > resp[4];
vector<int> ptr(4, 0);
long long ans = 0, l11 = max(0LL, 2 * M - K), l01;
l01 = M - l11;
if (v[0].size() < l11) imp();
for (; ptr[0] < l11; ptr[0]++) {
resp[0].push_back(v[0][ptr[0]]);
ans += v[0][ptr[0]].first;
}
while (ptr[0] < v[0].size() && (v[1].size() < l01 || v[2].size() < l01)) {
l01--;
resp[0].push_back(v[0][ptr[0]]);
ans += v[0][ptr[0]].first;
ptr[0]++;
}
while (ptr[0] < v[0].size() &&
ptr[0] + v[1].size() + v[2].size() + v[3].size() < K) {
l01--;
resp[0].push_back(v[0][ptr[0]]);
ans += v[0][ptr[0]].first;
ptr[0]++;
}
if (v[1].size() < l01 || v[2].size() < l01) imp();
for (; ptr[1] < l01; ptr[1]++, ptr[2]++) {
resp[1].push_back(v[1][ptr[1]]);
resp[2].push_back(v[2][ptr[2]]);
ans += v[1][ptr[1]].first;
ans += v[2][ptr[2]].first;
}
priority_queue<pair<int, int> > sob, others;
for (int i = 1; i < 4; i++) {
for (int j = ptr[i]; j < v[i].size(); j++) {
sob.push(p(v[i][j]));
}
}
while (!sob.empty() && ptr[0] + ptr[1] + ptr[2] + others.size() < K) {
ans += -sob.top().first;
others.push(p(sob.top()));
sob.pop();
}
minAns = ans;
qtd11 = ptr[0];
for (; ptr[1] && ptr[0] < v[0].size(); ptr[0]++) {
ptr[1]--, ptr[2]--;
sob.push(p(resp[1][ptr[1]]));
ans -= resp[1][ptr[1]].first;
resp[1].pop_back();
sob.push(p(resp[2][ptr[2]]));
ans -= resp[2][ptr[2]].first;
resp[2].pop_back();
resp[0].push_back(v[0][ptr[0]]);
ans += v[0][ptr[0]].first;
pair<int, int> u = p(sob.top());
sob.pop();
others.push(u);
ans += u.first;
while (others.top() > p(sob.top())) {
pair<int, int> aux = others.top();
pair<int, int> aux2 = p(sob.top());
ans -= aux.first;
ans += aux2.first;
others.pop();
sob.pop();
others.push(aux2);
sob.push(p(aux));
}
if (ans < minAns) {
qtd11 = resp[0].size();
minAns = ans;
}
}
}
void construir() {
vector<pair<int, int> > resp;
vector<int> ptr(4, 0);
long long ans = 0;
for (; ptr[0] < qtd11; ptr[0]++) {
resp.push_back(v[0][ptr[0]]);
ans += v[0][ptr[0]].first;
}
for (int i = qtd11; i < M; i++, ptr[1]++, ptr[2]++) {
resp.push_back(v[1][ptr[1]]);
resp.push_back(v[2][ptr[2]]);
ans += v[1][ptr[1]].first;
ans += v[2][ptr[2]].first;
}
while (resp.size() < K) {
int pos = menor(ptr);
ans += v[pos][ptr[pos]].first;
resp.push_back(v[pos][ptr[pos]]);
ptr[pos]++;
}
cout << ans << "\n";
for (int i = 0; i < resp.size(); i++) {
if (!i)
cout << resp[i].second + 1;
else
cout << " " << resp[i].second + 1;
}
cout << "\n";
}
void solve() {
melhor();
construir();
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
;
cin >> N >> K >> M;
for (int i = 0; i < N; i++) {
int a, b, t;
cin >> t >> a >> b;
if (a && b) {
v[0].push_back(pair<int, int>(t, i));
} else if (a) {
v[1].push_back(pair<int, int>(t, i));
} else if (b) {
v[2].push_back(pair<int, int>(t, i));
} else {
v[3].push_back(pair<int, int>(t, i));
}
nums[i] = t;
}
solve();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long gcd(long long a, long long b) {
if (b == 0) return a;
return gcd(b, a % b);
}
long long lcm(long long a, long long b) { return (a * b) / gcd(a, b); }
void print(vector<long long> a) {
for (int i = 0; i < a.size(); i++) {
cout << a[i] << ' ';
}
cout << endl;
}
vector<long long> inp(int n) {
vector<long long> a;
long long x;
for (int i = 0; i < n; i++) {
cin >> x;
a.push_back(x);
}
return a;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
long long t, n, i, j, k, l, c1, cnt, flag, m1, m, m2, maxi, mini, x, y, z;
vector<long long> a, b, c;
string s, s1, s2;
cin >> n >> k;
for (i = 0; i < n; i++) {
cin >> x >> y >> z;
if (y + z == 2) {
c.push_back(x);
} else {
if (y == 1) {
a.push_back(x);
}
if (z == 1) {
b.push_back(x);
}
}
}
sort(a.begin(), a.end());
sort(b.begin(), b.end());
sort(c.begin(), c.end());
cnt = 0;
if (c.size() + a.size() >= k && c.size() + b.size() >= k) {
i = 0, j = 0, l = 0;
while (i != k) {
if (j < a.size() && j < b.size()) {
if (l < c.size()) {
if (a[j] + b[j] < c[l]) {
cnt = cnt + a[j] + b[j];
j++;
} else {
cnt = cnt + c[l];
l++;
}
} else {
cnt = cnt + a[j] + b[j];
j++;
}
} else {
cnt = cnt + c[l];
l++;
}
i++;
}
cout << cnt << endl;
} else {
cout << -1 << endl;
}
}
|
#include <bits/stdc++.h>
using namespace std;
void test_case() {
long long int n, k;
cin >> n >> k;
vector<long long int> as, bs, cs;
for (long long int i = 0; i < n; i++) {
long long int t, a, b;
cin >> t >> a >> b;
if (a + b == 2)
cs.push_back(t);
else if (a == 1)
as.push_back(t);
else if (b == 1)
bs.push_back(t);
}
if (as.size() + cs.size() < k) {
cout << -1;
return;
}
if (bs.size() + cs.size() < k) {
cout << -1;
return;
}
sort(as.begin(), as.end());
sort(bs.begin(), bs.end());
sort(cs.begin(), cs.end());
long long int a, b, c, done = 0, res = 0;
a = b = c = 0;
while (c < cs.size() && c < k) res += cs[c++];
while (a + c < k) res += as[a++];
while (b + c < k) res += bs[b++];
while (a < as.size() && b < bs.size() && c > 0 && as[a] + bs[b] <= cs[c - 1])
res += (as[a++] + bs[b++] - cs[--c]);
cout << res;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
long long int t = 1;
for (long long int i = 0; i < t; i++) {
test_case();
cout << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long inf = 1e9;
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
long long n, k;
cin >> n >> k;
vector<long long> l;
vector<long long> m;
vector<long long> r;
for (long long i = 0; i < n; ++i) {
long long a, b, c;
cin >> a >> b >> c;
if (b == 1 && c == 1) {
m.push_back(a);
} else if (b == 1 && c == 0) {
l.push_back(a);
} else if (b == 0 && c == 1) {
r.push_back(a);
}
}
sort(l.begin(), l.end());
sort(r.begin(), r.end());
sort(m.begin(), m.end());
auto it1 = l.begin();
auto it2 = m.begin();
auto it3 = r.begin();
long long ans = 0;
long long x = 0, y = 0;
while ((x < k && y < k) &&
(((it1 != l.end()) && (it3 != r.end())) || (it2 != m.end()))) {
if ((it2 == m.end()) ||
(it1 != l.end() && it3 != r.end() && *it1 + *it3 < *it2)) {
ans += (*it1 + *it3);
it1++;
it3++;
} else if ((it2 != m.end()) || ((it1 == l.end() || (it3 == r.end())))) {
ans += *it2;
it2++;
}
x++;
y++;
}
if (x == k && y == k)
cout << ans << "\n";
else
cout << -1 << "\n";
}
|
#include <bits/stdc++.h>
using namespace std;
long long mod = 1000000007;
long long dx[] = {1, -1, 0, 0};
long long dy[] = {0, 0, 1, -1};
void solve() {
long long n, k;
cin >> n >> k;
vector<long long> arr1, arr2, v;
for (long long i = 0; i < n; i++) {
long long x, a, b;
cin >> x >> a >> b;
if (a && b)
v.push_back(x);
else if (a)
arr1.push_back(x);
else if (b)
arr2.push_back(x);
}
sort((arr1).begin(), (arr1).end());
sort((arr2).begin(), (arr2).end());
for (long long i = 0; i < min(arr1.size(), arr2.size()); i++)
v.push_back(arr1[i] + arr2[i]);
sort((v).begin(), (v).end());
if (v.size() < k)
cout << -1 << '\n';
else {
long long ans = 0;
for (long long i = 0; i < k; i++) ans += v[i];
cout << ans << '\n';
}
}
int32_t main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
long long test;
test = 1;
long long x = 1;
while (test--) {
solve();
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAX_INT = numeric_limits<int>::max();
const int MAX_UINT = numeric_limits<unsigned int>::max();
void get_acum(const vector<int>& v, vector<int>& acum) {
int sum = 0;
for (unsigned int i = 0; i < v.size(); ++i) {
acum.push_back(sum);
sum += v[i];
}
acum.push_back(sum);
}
int solve(vector<int>& A, vector<int>& B, vector<int>& X, unsigned int k) {
if (A.size() + X.size() < k || B.size() + X.size() < k) {
return -1;
} else {
sort(A.begin(), A.end());
sort(B.begin(), B.end());
sort(X.begin(), X.end());
vector<int> A_acum, B_acum, X_acum;
get_acum(A, A_acum);
get_acum(B, B_acum);
get_acum(X, X_acum);
int res = MAX_INT;
unsigned int max_i = min((unsigned int)X.size(), k);
for (unsigned int i = 0; i < max_i + 1; ++i) {
if (k - i < A_acum.size() && k - i < B_acum.size()) {
int total = A_acum[k - i] + B_acum[k - i] + X_acum[i];
if (total < res) res = total;
}
}
return res;
}
}
int main() {
ios::sync_with_stdio(false);
cin.tie(NULL);
unsigned int n, k;
cin >> n >> k;
vector<int> A;
vector<int> B;
vector<int> X;
for (unsigned int i = 0; i < n; ++i) {
unsigned int ti;
bool ai, bi;
cin >> ti >> ai >> bi;
if (ai && bi)
X.push_back(ti);
else if (ai)
A.push_back(ti);
else if (bi)
B.push_back(ti);
}
cout << solve(A, B, X, k);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
vector<int> va;
vector<int> vb;
vector<int> vab;
int n, k, a, b, t;
cin >> n >> k;
for (int p = 0; p < n; p++) {
cin >> t >> a >> b;
if (a == 1 && b == 1)
vab.push_back(t);
else if (a == 0 && b == 1)
vb.push_back(t);
else if (a == 1 && b == 0)
va.push_back(t);
}
sort(va.begin(), va.end());
int na = va.size();
sort(vb.begin(), vb.end());
int nb = vb.size();
int nab = vab.size();
sort(vab.begin(), vab.end());
int ans = 0;
int p = 0;
int ai = 0;
int bi = 0;
int abi = 0;
while (p < k) {
if (ai < na && bi < nb && abi < nab) {
if (va[ai] + vb[bi] <= vab[abi]) {
ans = ans + va[ai] + vb[bi];
ai++;
bi++;
} else {
ans = ans + vab[abi];
abi++;
}
p++;
} else if (ai < na && bi < nb && abi >= nab) {
ans = ans + va[ai] + vb[bi];
ai++;
bi++;
p++;
} else if ((ai >= na || bi >= nb) && abi < nab) {
ans = ans + vab[abi];
abi++;
p++;
} else
break;
}
if (p == k)
cout << ans;
else
cout << -1;
}
|
#include <bits/stdc++.h>
using namespace std;
template <typename T>
void read(T &r) {
static char c;
r = 0;
for (c = getchar(); c > '9' || c < '0'; c = getchar())
;
for (; c >= '0' && c <= '9';
r = (r << 1) + (r << 3) + (c ^ 48), c = getchar())
;
}
const int maxn = 2e5 + 100;
int n, m, k;
struct node {
int t, id;
bool operator<(const node &b) const { return t == b.t ? id < b.id : t < b.t; }
} A[4][maxn];
int num[4];
long long sums[4][maxn];
inline void init() {
read(n), read(m), read(k);
for (int i = 1; i <= n; ++i) {
int t, a, b, p;
read(t), read(a), read(b), p = a * 2 + b;
A[p][++num[p]].id = i, A[p][num[p]].t = t;
}
for (int i = 0; i < 4; ++i) sort(A[i] + 1, A[i] + 1 + num[i]);
for (int i = 0; i < 4; ++i)
for (int j = 1; j <= num[i]; ++j) sums[i][j] = sums[i][j - 1] + A[i][j].t;
}
set<node> all, choose;
int sum, need;
inline void update() {
if (need < 0) need = 0;
set<node>::iterator it;
bool flag;
begin:
flag = true;
while (choose.size() > need)
it = --choose.end(), sum -= it->t, all.insert(*it), choose.erase(it),
flag = false;
while (choose.size() < need && !all.empty())
sum += (it = all.begin())->t, choose.insert(*it), all.erase(it),
flag = false;
while (!choose.empty() && !all.empty() &&
(it = --choose.end())->t > all.begin()->t) {
sum -= it->t, sum += all.begin()->t;
all.insert(*it), choose.erase(it);
choose.insert(*all.begin()), all.erase(all.begin());
flag = false;
}
if (!flag) goto begin;
}
int main() {
init();
int start = 0;
while (start <= num[3] && (k - start > num[1] || k - start > num[2] ||
m - start - (k - start) * 2 < 0))
++start;
if (start == num[3] + 1) {
puts("-1");
return 0;
}
need = m - k * 2 + start;
for (int i = 0; i < 3; ++i)
for (int j = num[i]; j > (i == 0 ? 0 : k - start); --j) all.insert(A[i][j]);
long long ans = 1ll << 60;
int ansp = -1;
update();
for (int i = start; i <= num[3]; ++i) {
int res = sums[3][i] + sum;
if (k - i >= 0) res += sums[1][k - i] + sums[2][k - i];
if (res < ans && ((k - i >= 0) ? (i + 2 * (k - i) + choose.size() == m)
: (i + choose.size() == m)))
ans = res, ansp = i;
--need;
if (k - i > 0) need += 2, all.insert(A[1][k - i]), all.insert(A[2][k - i]);
update();
}
printf("%lld\n", ans);
all.clear(), choose.clear();
need = m - k * 2 + start;
for (int i = 0; i < 3; ++i)
for (int j = num[i]; j > (i == 0 ? 0 : k - start); --j) all.insert(A[i][j]);
update();
for (int i = start; i <= num[3]; ++i) {
if (i == ansp) {
for (int j = 1; j <= i; ++j) printf("%d ", A[3][j].id);
if (k - i > 0)
for (int j = 1; j <= k - i; ++j)
printf("%d %d ", A[1][j].id, A[2][j].id);
for (set<node>::iterator it = choose.begin(); it != choose.end(); ++it)
printf("%d ", it->id);
return 0;
}
--need;
if (k - i > 0) need += 2, all.insert(A[1][k - i]), all.insert(A[2][k - i]);
update();
}
puts("-1");
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long N = 1e9 + 5;
bool col2(pair<long long, long long> p1, pair<long long, long long> p2) {
if (p1.first == p2.first)
return p2.second < p1.second;
else
return p1.first < p2.first;
}
struct comp {
bool operator()(long long const &x, long long const &y) { return x > y; }
};
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
;
long long n, k;
cin >> n >> k;
vector<long long> a;
vector<long long> b;
vector<long long> both;
for (long long i = 0; i < n; i++) {
long long x, y, z;
cin >> x >> y >> z;
if (y == 1 && z == 1)
both.push_back(x);
else if (y == 1 && z != 1)
a.push_back(x);
else if (y != 1 && z == 1)
b.push_back(x);
}
sort(a.begin(), a.end());
sort(b.begin(), b.end());
for (long long i = 0; i < min((long long)a.size(), (long long)b.size()); i++)
both.push_back(a[i] + b[i]);
sort(both.begin(), both.end());
long long ans1 = 0;
for (long long i = 0; i < (long long)both.size(); i++) {
if (k <= 0) break;
ans1 += both[i];
k--;
}
if (k > 0)
cout << -1 << endl;
else
cout << ans1 << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, k, ans;
multiset<int> alice, bob, both;
int main() {
cin >> n >> k;
for (int i = 0; i < n; i++) {
int t, a, b;
cin >> t >> a >> b;
if (a + b == 2)
both.insert(t);
else if (a)
alice.insert(t);
else if (b)
bob.insert(t);
}
if (alice.size() + both.size() < k || bob.size() + both.size() < k)
return cout << -1, 0;
while (k && !both.empty() && !alice.empty() && !bob.empty()) {
int fromAlice = *alice.begin(), fromBob = *bob.begin(),
fromBoth = *both.begin();
if (fromBoth > fromAlice + fromBob) {
alice.erase(alice.begin());
bob.erase(bob.begin());
ans += fromAlice + fromBob;
} else {
both.erase(both.begin());
ans += fromBoth;
}
k--;
}
while (k && !both.empty()) {
ans += *both.begin();
both.erase(both.begin());
k--;
}
while (k && !alice.empty() && !bob.empty()) {
ans += *alice.begin() + *bob.begin();
alice.erase(alice.begin());
bob.erase(bob.begin());
k--;
}
cout << ans;
}
|
#include <bits/stdc++.h>
using namespace std;
using pi = pair<long long, long long>;
const long long inf = (long long)2e9 + 5;
signed main() {
ios::sync_with_stdio(false);
cin.tie(0);
long long n, m, k;
cin >> n >> m >> k;
vector<pi> w[2][2];
for (long long i = 0; i < n; i++) {
long long t, a, b;
cin >> t >> a >> b;
w[a][b].emplace_back(t, i);
}
if (((long long)(w[1][1]).size()) +
min(((long long)(w[0][1]).size()), ((long long)(w[1][0]).size())) <
k) {
cout << -1 << '\n';
return 0;
}
long long res = inf, id[2][2];
long long cur[2][2], pt[2][2], z[2][2];
for (long long a : {0, 1}) {
for (long long b : {0, 1}) {
id[a][b] = -1;
cur[a][b] = pt[a][b] = 0;
while (((long long)(w[a][b]).size()) < m + 5) {
w[a][b].emplace_back(inf, -1);
}
z[a][b] = ((long long)(w[a][b]).size());
sort((w[a][b]).begin(), (w[a][b]).end());
}
}
long long want[2][2];
for (long long i = k; i >= 0; i--) {
want[0][0] = 0;
want[0][1] = want[1][0] = k - i;
want[1][1] = i;
for (long long a : {0, 1}) {
for (long long b : {0, 1}) {
while (pt[a][b] < want[a][b]) {
cur[a][b] += w[a][b][pt[a][b]++].first;
}
}
}
while (pt[1][1] + pt[1][0] + pt[0][1] + pt[0][0] < m) {
cur[1][1] += w[1][1][pt[1][1]++].first;
}
while (pt[0][0] + pt[0][1] + pt[1][0] + pt[1][1] > m) {
bool found = false;
for (long long a : {0, 1}) {
for (long long b : {0, 1}) {
if (pt[a][b] > want[a][b]) {
cur[a][b] -= w[a][b][--pt[a][b]].first;
found = true;
break;
}
}
if (found) {
break;
}
}
if (!found) {
break;
}
}
while (true) {
pair<long long, pi> add = {inf, {-1, -1}}, rem = {-inf, {-1, -1}};
for (long long a : {0, 1}) {
for (long long b : {0, 1}) {
add = min(add, make_pair(w[a][b][pt[a][b]].first, make_pair(a, b)));
if (pt[a][b] > want[a][b]) {
rem = max(rem,
make_pair(w[a][b][pt[a][b] - 1].first, make_pair(a, b)));
}
}
}
if (add.first < rem.first) {
long long a = add.second.first, b = add.second.second;
cur[a][b] += w[a][b][pt[a][b]++].first;
a = rem.second.first, b = rem.second.second;
cur[a][b] -= w[a][b][--pt[a][b]].first;
} else {
break;
}
}
if (pt[1][1] + min(pt[0][1], pt[1][0]) >= k &&
pt[1][1] + pt[1][0] + pt[0][1] + pt[0][0] == m) {
long long val = cur[0][0] + cur[1][0] + cur[0][1] + cur[1][1];
if (val < res) {
res = val;
for (long long a : {0, 1}) {
for (long long b : {0, 1}) {
id[a][b] = pt[a][b];
}
}
}
}
--pt[1][1];
if (pt[1][1] >= 0) {
cur[1][1] -= w[1][1][pt[1][1]].first;
}
}
if (res == inf) {
cout << -1 << '\n';
return 0;
}
cout << res << '\n';
for (long long a : {0, 1}) {
for (long long b : {0, 1}) {
for (long long i = 0; i < id[a][b]; i++) {
cout << w[a][b][i].second + 1 << ' ';
}
}
}
cout << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 200005;
long long t, n, m, k, q, a, b, x, y, ans, arr[N];
long long mod = 998244353;
string s;
int main() {
ios_base::sync_with_stdio(0), cin.tie(0), cout.tie(0);
;
t = 1;
while (t--) {
cin >> n >> k;
ans = 0, x = 0, y = 0;
priority_queue<int, vector<int>, greater<int>> alice, bob, both;
for (int i = 0; i < n; ++i) {
cin >> m >> a >> b;
x += a;
y += b;
if (a && b)
both.push(m);
else if (a)
alice.push(m);
else if (b)
bob.push(m);
}
if (x < k || y < k) {
cout << -1 << endl;
continue;
}
while (k--) {
if (!both.empty() && !alice.empty() && !bob.empty()) {
if (both.top() <= alice.top() + bob.top())
ans += both.top(), both.pop();
else
ans += alice.top() + bob.top(), alice.pop(), bob.pop();
} else if (both.empty())
ans += alice.top() + bob.top(), alice.pop(), bob.pop();
else
ans += both.top(), both.pop();
}
cout << ans << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
vector<long long int> v, a1, b1;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
long long int n, k;
cin >> n >> k;
pair<long long int, pair<long long int, long long int> > p[n];
for (long long int i = 0; i < n; i++) {
long long int t, a, b;
cin >> t >> a >> b;
p[i] = {t, {a, b}};
}
sort(p, p + n);
long long int ans = 0;
for (long long int i = 0; i < n; i++) {
if (p[i].second.first == 1 && p[i].second.second == 1) {
ans += p[i].first;
v.push_back(p[i].first);
k--;
}
if (k == 0) break;
}
long long int flaga = 0;
long long int temp = 0;
for (long long int i = 0; i < n; i++) {
if (flaga == k) temp = 1;
if (p[i].second.first == 1 && p[i].second.second == 0) {
if (temp == 1)
a1.push_back(p[i].first);
else {
ans += p[i].first;
flaga++;
}
}
}
long long int flagb = 0;
temp = 0;
for (long long int i = 0; i < n; i++) {
if (flagb == k) temp = 1;
if (p[i].second.first == 0 && p[i].second.second == 1) {
if (temp == 1)
b1.push_back(p[i].first);
else {
ans += p[i].first;
flagb++;
}
}
}
long long int q = v.size() - 1;
if (v.size() == 0) q = -1;
for (long long int i = 0; i < a1.size() && i < b1.size() && q >= 0; i++) {
if (a1[i] + b1[i] < v[q]) {
ans += (a1[i] + b1[i] - v[q--]);
} else
break;
}
if (flaga == k && flagb == k)
cout << ans << "\n";
else
cout << -1 << "\n";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
void solve() {
long long n, k;
cin >> n >> k;
vector<long long> v1, v2;
vector<long long> v;
for (long long i = 0; i < n; i++) {
long long t1, a, b;
cin >> t1 >> a >> b;
if (a == 1) {
if (b == 1)
v.push_back(t1);
else
v1.push_back(t1);
} else if (b == 1) {
v2.push_back(t1);
}
}
if ((v1.size() + v.size() < k) || (v2.size() + v.size() < k)) {
cout << "-1";
return;
}
sort(v1.begin(), v1.end());
sort(v2.begin(), v2.end());
sort(v.begin(), v.end());
long long t = 0, cnt = 0, i = 0, j = 0;
while (cnt < k) {
if (i < v1.size() && i < v2.size()) {
if (j < v.size()) {
if (v1[i] + v2[i] >= v[j]) {
t += v[j];
cnt++;
j++;
} else {
t += v1[i];
t += v2[i];
cnt++;
i++;
}
} else {
long long c = cnt, p = i;
while (c < k) {
t += v1[i];
i++;
c++;
}
while (cnt < k) {
t += v2[p];
p++;
cnt++;
}
}
} else {
while (cnt < k) {
t += v[j];
cnt++;
j++;
}
}
}
cout << t;
}
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
long long t = 1;
while (t--) {
solve();
}
}
|
#include <bits/stdc++.h>
using namespace std;
bool comp(pair<int, pair<int, int> > a, pair<int, pair<int, int> > b) {
return a.first < b.first;
}
int main() {
int n, k;
cin >> n >> k;
vector<pair<int, pair<int, int> > > book;
for (int i = 0; i < n; i++) {
pair<int, pair<int, int> > temp;
cin >> temp.first >> temp.second.first >> temp.second.second;
book.push_back(temp);
}
stack<int> alice, bob, both;
sort(book.begin(), book.end(), comp);
for (int i = 0; i < n; i++) {
int t = book[i].first;
bool a = book[i].second.first;
bool b = book[i].second.second;
if (a && b) {
int t1 = 0, t2 = 0;
if (!alice.empty()) {
t1 = alice.top();
}
if (!bob.empty()) {
t2 = bob.top();
}
if (t1 + t2 >= t) {
both.push(t);
if (alice.size() + both.size() > k) {
alice.pop();
}
if (bob.size() + both.size() > k) {
bob.pop();
}
} else {
if (alice.size() + bob.size() + 2 * both.size() < 2 * k) {
both.push(t);
}
if (alice.size() + both.size() > k) {
alice.pop();
}
if (bob.size() + both.size() > k) {
bob.pop();
}
}
} else if (a) {
if (alice.size() + both.size() < k) {
alice.push(t);
}
} else if (b) {
if (bob.size() + both.size() < k) {
bob.push(t);
}
}
}
if (alice.size() + bob.size() + 2 * both.size() < 2 * k) {
cout << -1 << endl;
} else {
int ans = 0;
while (!alice.empty()) {
ans += alice.top();
alice.pop();
}
while (!bob.empty()) {
ans += bob.top();
bob.pop();
}
while (!both.empty()) {
ans += both.top();
both.pop();
}
cout << ans << endl;
}
}
|
#include <bits/stdc++.h>
using namespace std;
long long n, m, d, nn = 0, ttl = 0, fq[4], sm = 0, dd, sq[200069], zs = 0,
inf = 1e18;
pair<long long, long long> a[4][200069];
multiset<pair<long long, long long>> ms[2];
multiset<pair<long long, long long>>::iterator it;
void blc() {
for (; nn < dd && !ms[1].empty(); nn++) {
it = ms[1].begin();
ms[0].insert(*it);
sm += (*it).first;
ms[1].erase(it);
}
for (; nn > dd && !ms[0].empty(); nn--) {
it = ms[0].end();
it--;
ms[1].insert(*it);
sm -= (*it).first;
ms[0].erase(it);
}
}
void ins(pair<long long, long long> x) {
ms[0].insert(x);
nn++;
sm += x.first;
blc();
}
void ers(pair<long long, long long> x) {
it = ms[0].find(x);
if (it != ms[0].end()) {
ms[0].erase(it);
nn--;
sm -= x.first;
} else {
ms[1].erase(ms[1].find(x));
}
blc();
}
int main() {
long long i, j, ii, k, w, mk, mn, e;
pair<long long, long long> z = {inf, -1};
scanf("%lld%lld%lld", &n, &m, &d);
for (i = 1; i <= n; i++) {
scanf("%lld%lld", &w, &k);
mk = k * 2;
scanf("%lld", &k);
mk |= k;
fq[mk]++;
a[mk][fq[mk]] = {w, i};
}
mn = min(min(fq[1], fq[2]), d);
if (fq[3] + mn < d) {
printf("-1\n");
return 0;
}
for (i = 0; i < 4; i++) {
sort(a[i] + 1, a[i] + fq[i] + 1);
}
dd = m - d - mn;
for (i = 0; i < 4; i++) {
k = (i < 3 ? mn : d - mn) * !!i;
for (j = 1; j <= fq[i]; j++) {
if (j <= k) {
ttl += a[i][j].first;
} else {
ins(a[i][j]);
}
}
}
for (i = d - mn; i <= min(d, fq[3]); i++) {
if (dd >= 0) {
z = min(z, {ttl + sm, i});
}
if (i < min(d, fq[3])) {
dd++;
blc();
for (ii = 1; ii <= 2; ii++) {
ttl -= a[ii][d - i].first;
ins(a[ii][d - i]);
}
ttl += a[3][i + 1].first;
ers(a[3][i + 1]);
}
}
if (z.first == inf) {
printf("-1\n");
return 0;
}
e = z.second;
ttl = 0;
for (ii = 0; ii < 2; ii++) {
ms[ii].clear();
}
nn = 0;
sm = 0;
dd = m - (d * 2 - e);
for (i = 0; i < 4; i++) {
k = (i < 3 ? d - e : e) * !!i;
for (j = 1; j <= fq[i]; j++) {
if (j <= k) {
zs++;
sq[zs] = a[i][j].second;
} else {
ins(a[i][j]);
}
}
}
for (; !ms[0].empty(); ms[0].erase(it)) {
it = ms[0].begin();
zs++;
sq[zs] = (*it).second;
}
printf("%lld\n", z.first);
for (i = 1; i <= zs; i++) {
printf("%lld%c", sq[i], " \n"[i == zs]);
}
}
|
#include <bits/stdc++.h>
const int INF = 2e9 + 1;
int main() {
std::ios::sync_with_stdio(false);
std::cin.tie(NULL);
int n, k;
std::cin >> n >> k;
std::vector<int> t(n), a(n), b(n);
std::vector<int> v[2][2];
for (int i = 0; i < n; i++) {
std::cin >> t[i] >> a[i] >> b[i];
v[a[i]][b[i]].push_back(t[i]);
}
long long answer = INF;
for (int i = 0; i < 2; i++) {
for (int j = 0; j < 2; j++) {
for (int K = 0; K < k; ++K) {
v[i][j].push_back(INF);
}
std::sort(v[i][j].begin(), v[i][j].end());
}
}
long long now = 0;
for (int i = 0; i < k; i++) {
now += v[1][1][i];
}
answer = std::min(answer, now);
for (int i = 0; i < k; i++) {
now -= v[1][1][k - i - 1];
now += v[1][0][i];
now += v[0][1][i];
answer = std::min(answer, now);
}
if (answer < INF)
std::cout << answer << '\n';
else
std::cout << -1 << '\n';
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int INF = 0x3f3f3f3f, MAXN = 2e6 + 50;
const long long LINF = 2e9 + 1000, MOD = 998244353;
const double Pi = acos(-1), EPS = 1e-6;
void test() { cerr << "\n"; }
template <typename T, typename... Args>
void test(T x, Args... args) {
cerr << x << " ";
test(args...);
}
inline long long qpow(long long a, long long b) {
return b ? ((b & 1) ? a * qpow(a * a % MOD, b >> 1) % MOD
: qpow(a * a % MOD, b >> 1)) %
MOD
: 1;
}
inline long long qpow(long long a, long long b, long long c) {
return b ? ((b & 1) ? a * qpow(a * a % c, b >> 1) % c
: qpow(a * a % c, b >> 1)) %
c
: 1;
}
inline long long gcd(long long a, long long b) { return b ? gcd(b, a % b) : a; }
inline long long cede(long long a, long long b) {
if (b < 0) return cede(-a, -b);
if (a < 0) return a / b;
return (a + b - 1) / b;
}
inline long long flde(long long a, long long b) {
if (b < 0) return flde(-a, -b);
if (a < 0) return (a - b + 1) / b;
return a / b;
}
inline int sign(double x) { return x < -EPS ? -1 : x > EPS; }
inline int dbcmp(double l, double r) { return sign(l - r); }
namespace Fast_IO {
const int MAXL((1 << 18) + 1);
int iof, iotp;
char ioif[MAXL], *ioiS, *ioiT, ioof[MAXL],
*iooS = ioof, *iooT = ioof + MAXL - 1, ioc, iost[55];
char Getchar() {
if (ioiS == ioiT) {
ioiS = ioif;
ioiT = ioiS + fread(ioif, 1, MAXL, stdin);
return (ioiS == ioiT ? EOF : *ioiS++);
} else
return (*ioiS++);
}
void Write() {
fwrite(ioof, 1, iooS - ioof, stdout);
iooS = ioof;
}
void Putchar(char x) {
*iooS++ = x;
if (iooS == iooT) Write();
}
inline int read() {
int x = 0;
for (iof = 1, ioc = Getchar(); ioc < '0' || ioc > '9';)
iof = ioc == '-' ? -1 : 1, ioc = Getchar();
for (x = 0; ioc <= '9' && ioc >= '0'; ioc = Getchar())
x = (x << 3) + (x << 1) + (ioc ^ 48);
return x * iof;
}
inline long long read_ll() {
long long x = 0;
for (iof = 1, ioc = Getchar(); ioc < '0' || ioc > '9';)
iof = ioc == '-' ? -1 : 1, ioc = Getchar();
for (x = 0; ioc <= '9' && ioc >= '0'; ioc = Getchar())
x = (x << 3) + (x << 1) + (ioc ^ 48);
return x * iof;
}
template <class Int>
void Print(Int x, char ch = '\0') {
if (!x) Putchar('0');
if (x < 0) Putchar('-'), x = -x;
while (x) iost[++iotp] = x % 10 + '0', x /= 10;
while (iotp) Putchar(iost[iotp--]);
if (ch) Putchar(ch);
}
void Getstr(char *s, int &l) {
for (ioc = Getchar(); ioc < 'a' || ioc > 'z';) ioc = Getchar();
for (l = 0; ioc <= 'z' && ioc >= 'a'; ioc = Getchar()) s[l++] = ioc;
s[l] = 0;
}
void Putstr(const char *s) {
for (int i = 0, n = strlen(s); i < n; ++i) Putchar(s[i]);
}
} // namespace Fast_IO
using namespace Fast_IO;
vector<pair<int, int> > a, b, c;
int prea[MAXN], preb[MAXN], prec[MAXN];
int cnt[MAXN], sum[MAXN];
int lowbit(int x) { return x & -x; }
const int MAXT = 1e4 + 50;
void add(int *tree, int x, int val) {
while (x <= MAXT) {
tree[x] += val;
x += lowbit(x);
}
}
int ask(int *tree, int x) {
int ans = 0;
while (x) {
ans += tree[x];
x -= lowbit(x);
}
return ans;
}
void UPD(int i, int k) {
if (i > 0 && i < a.size())
add(cnt, a[i].first, -1), add(sum, a[i].first, -a[i].first);
i--;
if (k - i > 0 && k - i < b.size())
add(cnt, b[k - i].first, 1), add(sum, b[k - i].first, b[k - i].first);
if (k - i > 0 && k - i < c.size())
add(cnt, c[k - i].first, 1), add(sum, c[k - i].first, c[k - i].first);
}
void work() {
int n, k, m;
scanf("%d%d%d", &n, &m, &k);
a.push_back({0, 0});
b.push_back({0, 0});
c.push_back({0, 0});
int cnta = 0, cntb = 0;
set<pair<int, int> > st;
for (int i = 1; i <= n; i++) {
int t, x, y;
scanf("%d%d%d", &t, &x, &y);
st.insert({t, i});
cnta += x;
cntb += y;
if (x && y) {
a.push_back({t, i});
add(cnt, t, 1);
add(sum, t, t);
} else if (x && !y)
b.push_back({t, i});
else if (y && !x)
c.push_back({t, i});
else {
add(cnt, t, 1);
add(sum, t, t);
}
}
sort(a.begin(), a.end());
sort(b.begin(), b.end());
sort(c.begin(), c.end());
for (int i = k + 2; i < b.size(); i++)
add(cnt, b[i].first, 1), add(sum, b[i].first, b[i].first);
for (int i = k + 2; i < c.size(); i++)
add(cnt, c[i].first, 1), add(sum, c[i].first, c[i].first);
if (cnta < k || cntb < k) {
printf("-1");
return;
}
for (int i = 1; i < a.size(); i++) prea[i] = prea[i - 1] + a[i].first;
for (int i = 1; i < b.size(); i++) preb[i] = preb[i - 1] + b[i].first;
for (int i = 1; i < c.size(); i++) prec[i] = prec[i - 1] + c[i].first;
int ans = LINF;
int maxi = 0, maxl = 0;
for (int i = 0; i < a.size(); i++) {
UPD(i, k);
if (k - i >= b.size() || k - i >= c.size() || i + k - i + k - i > m) {
continue;
}
if (k - i < 0) break;
int lef = m - (i + k - i + k - i);
if (lef < 0) {
continue;
}
int l = 0, r = MAXT;
while (l < r) {
int mid = l + r >> 1;
if (ask(cnt, mid) >= lef)
r = mid;
else
l = mid + 1;
}
if (r == MAXT) {
continue;
}
int tmp;
if (l == 0)
tmp = 0;
else
tmp = ask(sum, l - 1) + l * (lef - ask(cnt, l - 1));
if (ans > prea[i] + preb[k - i] + prec[k - i] + tmp) {
ans = prea[i] + preb[k - i] + prec[k - i] + tmp;
maxi = i;
maxl = l;
}
}
if (ans == LINF) {
printf("-1\n");
return;
}
printf("%d\n", ans);
for (int i = 1; i <= maxi; i++)
printf("%d ", a[i].second), st.erase({a[i].first, a[i].second});
for (int i = 1; i <= k - maxi; i++)
printf("%d %d ", b[i].second, c[i].second),
st.erase({b[i].first, b[i].second}),
st.erase({c[i].first, c[i].second});
for (int i = 1; i <= m - (maxi + k - maxi + k - maxi); i++)
printf("%d ", (*st.begin()).second), st.erase(st.begin());
}
int main() { work(); }
|
#include <bits/stdc++.h>
using namespace std;
const long long MOD = (long long)1e9 + 7;
const double PI = acos(-1.0);
void __print(long long x) { cerr << x; }
void __print(int32_t x) { cerr << x; }
void __print(double x) { cerr << x; }
void __print(long double x) { cerr << x; }
void __print(char x) { cerr << '\'' << x << '\''; }
void __print(const char *x) { cerr << '\"' << x << '\"'; }
void __print(const string &x) { cerr << '\"' << x << '\"'; }
template <typename T, typename V>
void __print(const pair<T, V> &x) {
cerr << '{';
__print(x.first);
cerr << ',';
__print(x.second);
cerr << '}';
}
template <typename T>
void __print(const T &x) {
long long f = 0;
cerr << '{';
for (auto &i : x) cerr << (f++ ? "," : ""), __print(i);
cerr << "}";
}
void _print() { cerr << "]\n"; }
template <typename T, typename... V>
void _print(T t, V... v) {
__print(t);
if (sizeof...(v)) cerr << ", ";
_print(v...);
}
int32_t main() {
long long n, k;
cin >> n >> k;
multiset<long long> a, b, c;
for (long long i = 0; i < n; i++) {
long long t, p, q;
cin >> t >> p >> q;
if (p && q) {
c.insert(t);
} else if (p) {
a.insert(t);
} else if (q) {
b.insert(t);
}
}
if ((long long)a.size() + (long long)c.size() < k ||
(long long)b.size() + (long long)c.size() < k) {
cout << -1 << '\n';
return 0;
}
long long cnt1 = a.size(), cnt2 = b.size();
long long ans = 0;
for (auto x : a) ans += x;
for (auto x : b) ans += x;
multiset<long long> aa, bb;
while (cnt1 < k || cnt2 < k) {
long long cur = *c.begin();
aa.insert(cur);
bb.insert(cur);
ans += cur;
cnt1++;
cnt2++;
c.erase(c.begin());
}
while (cnt1 > k && a.size()) {
ans -= *a.rbegin();
a.erase(--a.end());
cnt1--;
}
while (cnt2 > k && b.size()) {
ans -= *b.rbegin();
b.erase(--b.end());
cnt2--;
}
while (c.size() && (a.size() || b.size())) {
if (a.size() && b.size()) {
if (*c.begin() < *a.rbegin() + *b.rbegin()) {
ans -= *a.rbegin();
ans -= *b.rbegin();
ans += *c.begin();
a.erase(--a.end());
b.erase(--b.end());
c.erase(c.begin());
} else {
break;
}
} else if (a.size()) {
if (*c.begin() < *a.rbegin()) {
ans -= *a.rbegin();
ans += *c.begin();
a.erase(--a.end());
c.erase(c.begin());
} else {
break;
}
} else {
if (*c.begin() < *b.rbegin()) {
ans -= *b.rbegin();
ans += *c.begin();
b.erase(--b.end());
c.erase(c.begin());
} else {
break;
}
}
}
cout << ans << '\n';
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
static bool comp(long long int a, long long int b) { return (a > b); }
int32_t main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
long long int n, k;
cin >> n >> k;
vector<long long int> A, B, BB;
for (long long int i = 0; i < n; i++) {
long long int t, a, b;
cin >> t >> a >> b;
if (a == 0 and b == 0) continue;
if (a == 1 and b == 1) {
BB.push_back(t);
} else if (a == 1) {
A.push_back(t);
} else if (b == 1) {
B.push_back(t);
}
}
sort(A.begin(), A.end());
sort(B.begin(), B.end());
for (long long int i = 0; i < min(A.size(), B.size()); i++)
BB.push_back(A[i] + B[i]);
sort(BB.begin(), BB.end());
if (BB.size() < k)
cout << "-1\n";
else {
long long int s = 0;
for (long long int i = 0; i < k; i++) s += BB[i];
cout << s << '\n';
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 5;
const int mod = 1e9 + 7;
long long a[N], a1 = 0, b[N], b1 = 0, c[N], c1 = 0, d, dis;
char o;
pair<int, int> p;
bool mark = true;
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
long long t, n, m, mx, k, ans = 0, sum = 0, x, y, l, r;
string s;
cin >> n >> k;
for (int i = 0; i < n; i++) {
cin >> l >> m >> t;
if (m == 1 && t == 1) {
c[c1++] = l;
}
if (m == 1 && t == 0) {
a[a1++] = l;
}
if (m == 0 && t == 1) {
b[b1++] = l;
}
}
sort(a, a + a1);
sort(b, b + b1);
sort(c, c + c1);
long long a2 = 0, b2 = 0, c2 = 0;
m = min(a1, b1);
m = k - m;
if (c1 < m)
cout << -1 << endl;
else {
c2 = max(c2, m);
for (int i = 0; i < m; i++) {
ans += c[i];
}
m = min(a1, b1);
if (m > k) m = k;
for (int i = 0; i < m; i++) {
if (c2 < c1 && a[a2] + b[b2] >= c[c2])
ans += c[c2++];
else {
ans += a[a2++];
ans += b[b2++];
}
}
cout << ans;
}
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, k, t, a, b, sum = 0, cnt = 0;
vector<int> A, B, C;
cin >> n >> k;
for (int i = 1; i <= n; i++) {
cin >> t >> a >> b;
if (a != b) {
if (a == 1) {
A.push_back(t);
} else {
B.push_back(t);
}
} else {
if (a == 1) {
C.push_back(t);
}
}
}
sort(A.begin(), A.end());
sort(B.begin(), B.end());
sort(C.begin(), C.end());
if (A.size() + C.size() < k) {
cout << -1;
return 0;
} else if (B.size() + C.size() < k) {
cout << -1;
return 0;
} else {
int i = 0, j = 0, l = 0;
while (i < A.size() && j < B.size() && l < C.size() && cnt < k) {
if (A[i] + B[j] < C[l]) {
sum += A[i] + B[j];
i++;
j++;
cnt++;
} else {
sum += C[l];
l++;
cnt++;
}
}
if (cnt < k) {
if (l == C.size()) {
l = cnt;
while (l < k) {
sum += A[i];
i++;
l++;
}
l = cnt;
while (l < k) {
sum += B[j];
j++;
l++;
}
} else {
i = cnt;
while (i < k) {
sum += C[l];
l++;
i++;
}
}
}
}
cout << sum;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
using Int = int64_t;
vector<Int> csum(vector<Int> v) {
vector<Int> r;
r = v;
for (int i = 1; i < r.size(); ++i) r[i] += r[i - 1];
return r;
}
int main() {
Int N, K;
cin >> N >> K;
vector<Int> v, u, cmn;
while (N--) {
Int a, b, c;
cin >> c >> a >> b;
if (a + b == 0) continue;
;
if (a + b == 2)
cmn.emplace_back(c);
else if (a == 1)
v.emplace_back(c);
else
u.emplace_back(c);
}
sort(v.begin(), v.end());
sort(u.begin(), u.end());
sort(cmn.begin(), cmn.end());
auto cv = csum(v);
auto cu = csum(u);
auto ccmn = csum(cmn);
Int ans = 1LL << 60;
if (v.size() >= K && u.size() >= K) {
ans = cv[K - 1] + cu[K - 1];
}
if (cmn.size() >= K) ans = min(ans, ccmn[K - 1]);
for (int i = 0; i < cmn.size(); ++i) {
if (K - i - 2 < 0) continue;
if (v.size() > K - i - 2 && u.size() > K - 2 - i) {
ans = min(ans, cv[K - i - 2] + cu[K - i - 2] + ccmn[i]);
}
}
cout << (ans == 1LL << 60 ? -1 : ans) << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
long long int solve() {
long long int n, k;
cin >> n >> k;
vector<long long int> first, second, both;
int av = 0, bv = 0;
while (n--) {
long long int t, a, b;
cin >> t >> a >> b;
if (a && b)
both.push_back(t), av++, bv++;
else if (a)
first.push_back(t), av++;
else if (b)
second.push_back(t), bv++;
}
if (av < k || bv < k) return -1;
sort(first.begin(), first.end());
sort(second.begin(), second.end());
sort(both.begin(), both.end());
av = k, bv = k;
int ia = 0, is = 0, ib = 0, sf = first.size(), ss = second.size(),
sb = both.size();
long long int ans = 0;
while (av > 0 && bv > 0) {
if (ib < sb and
((ia >= sf || is >= ss) || both[ib] < first[ia] + second[is])) {
ans += both[ib++];
av--;
bv--;
} else {
ans += first[ia++] + second[is++];
av--;
bv--;
}
}
return ans;
}
int main() { cout << solve(); }
|
#include <bits/stdc++.h>
using namespace std;
struct edge {
long long int t;
long long int a;
long long int b;
};
vector<edge> grp1;
vector<edge> grp2;
vector<edge> grp3;
bool cmp(edge A, edge B) { return A.t < B.t; }
int main() {
edge get;
long long int n, k, i, j, temp, aa, bb, tt, cnt1, cnt2, len1, len2, len3, res,
dd;
cnt1 = 0;
res = 0;
cnt2 = 0;
cin >> n >> dd;
for (i = 0; i < n; i++) {
cin >> tt >> aa >> bb;
if (aa == 1) cnt1++;
if (bb == 1) cnt2++;
get.t = tt;
get.a = aa;
get.b = bb;
if (aa == 1 && bb == 1) {
grp3.push_back(get);
} else if (aa == 1 && bb == 0) {
grp1.push_back(get);
} else if (aa == 0 && bb == 1) {
grp2.push_back(get);
}
}
if (cnt1 < dd || cnt2 < dd)
cout << -1 << endl;
else {
sort(grp1.begin(), grp1.end(), cmp);
sort(grp2.begin(), grp2.end(), cmp);
sort(grp3.begin(), grp3.end(), cmp);
len1 = grp1.size();
len2 = grp2.size();
len3 = grp3.size();
i = 0;
j = 0;
k = 0;
cnt1 = 0;
cnt2 = 0;
while (1) {
if (i < len1 && j < len2 && k < len3) {
temp = grp3[k].t;
aa = grp1[i].t;
bb = grp2[j].t;
if (temp <= (aa + bb)) {
res += temp;
k++;
cnt1++;
cnt2++;
} else {
res += (aa + bb);
i++;
j++;
cnt1++;
cnt2++;
}
if (cnt1 == dd && cnt2 == dd) break;
} else if (i < len1 && j < len2) {
aa = grp1[i].t;
bb = grp2[j].t;
res += (aa + bb);
cnt1++;
cnt2++;
i++;
j++;
if (cnt1 == dd && cnt2 == dd) break;
} else {
temp = grp3[k].t;
res += temp;
cnt1++;
cnt2++;
k++;
if (cnt1 == dd && cnt2 == dd) break;
}
}
cout << res << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
#pragma GCC target("sse4.2")
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
long long int n, k;
cin >> n >> k;
vector<long long int> v[4];
vector<long long int> pref[4];
for (long long int i = 0; i < (long long int)n; i++) {
long long int t, a, b;
cin >> t >> a >> b;
v[2 * a + b].push_back(t);
}
for (long long int i = 0; i < (long long int)4; i++) {
sort(v[i].begin(), v[i].end());
pref[i].push_back(0ll);
for (long long int j = 0; j < (long long int)v[i].size(); j++)
pref[i].push_back(pref[i].back() + v[i][j]);
}
long long int ans = INT_MAX;
for (long long int i = 0; i < min(k + 1, (long long int)pref[3].size());
i++) {
if (k - i < pref[1].size() && k - i < pref[2].size()) {
ans = min(ans, pref[3][i] + pref[1][k - i] + pref[2][k - i]);
}
}
if (ans == INT_MAX)
cout << "-1\n";
else
cout << ans << "\n";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n, K;
cin >> n >> K;
long long a, b, c;
long long x[n], x2[n], x3[n];
long long k = 0, k2 = 0, k3 = 0, ans = 0;
for (long long i = 0; i < n; i++) {
cin >> a >> b >> c;
if (b == c && b == 1) {
x[k] = a;
k++;
} else if (b == 0 && c == 1) {
x2[k2] = a;
k2++;
} else if (b == 1 && c == 0) {
x3[k3] = a;
k3++;
}
}
sort(x, x + k);
sort(x2, x2 + k2);
sort(x3, x3 + k3);
if (k2 > k3) k2 = k3;
for (long long i = 0; i < k2; i++) {
x2[i] += x3[i];
}
sort(x2, x2 + k2);
for (long long i = k; i < k + k2; i++) {
x[i] = x2[i - k];
}
sort(x, x + k + k2);
if (K > k + k2) {
cout << "-1" << endl;
} else {
for (long long i = 0; i < K; i++) ans += x[i];
cout << ans << endl;
}
}
|
#include <bits/stdc++.h>
using namespace std;
void solve() {
long long n, k, ans = 1e10;
cin >> n >> k;
vector<long long> alice, bob, both, prb, pra, prboth;
for (long long i = 1; i <= n; i++) {
long long t, a, b;
cin >> t >> a >> b;
if (a && b)
both.push_back(t);
else if (a)
alice.push_back(t);
else if (b)
bob.push_back(t);
}
sort(alice.begin(), alice.end());
sort(bob.begin(), bob.end());
sort(both.begin(), both.end());
for (long long i = 0; i < signed(bob.size()); i++) {
if (!i)
prb.push_back(bob[i]);
else
prb.push_back(prb.back() + bob[i]);
}
for (long long i = 0; i < signed(alice.size()); i++) {
if (!i)
pra.push_back(alice[i]);
else
pra.push_back(pra.back() + alice[i]);
}
for (long long i = 0; i < signed(both.size()); i++) {
if (!i)
prboth.push_back(both[i]);
else
prboth.push_back(prboth.back() + both[i]);
}
if (signed(alice.size()) >= k && signed(bob.size()) >= k)
ans = min(ans, prb[k - 1] + pra[k - 1]);
for (long long i = 0; i < k && i < signed(both.size()); i++) {
long long x = k - i - 1;
if (signed(alice.size()) >= x && signed(bob.size()) >= x && x > 0)
ans = min(ans, prboth[i] + pra[x - 1] + prb[x - 1]);
if (i == k - 1) ans = min(ans, prboth[i]);
}
cout << ((ans == 1e10) ? -1 : ans) << "\n";
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
;
long long t = 1;
while (t--) solve();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
signed main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
int n, k;
while (cin >> n >> k) {
vector<int> both, alice, bob;
for (int i = 0; i < n; ++i) {
int t, a, b;
cin >> t >> a >> b;
if (a && b)
both.push_back(t);
else if (a)
alice.push_back(t);
else if (b)
bob.push_back(t);
}
sort(both.begin(), both.end());
sort(alice.begin(), alice.end());
sort(bob.begin(), bob.end());
vector<int> asum(alice.size() + 1);
for (int i = 0; i < alice.size(); ++i) {
asum[1 + i] = asum[i] + alice[i];
}
vector<int> bsum(bob.size() + 1);
for (int i = 0; i < bob.size(); ++i) {
bsum[1 + i] = bsum[i] + bob[i];
}
const int INF = 2e9 + 10;
int res = INF;
for (int i = 0, csum = 0; i <= min<int>(k, both.size()); ++i) {
if (alice.size() + i >= k && bob.size() + i >= k) {
int cur = asum[k - i] + bsum[k - i] + csum;
res = min(res, cur);
}
if (i < both.size()) {
csum += both[i];
}
}
cout << (res == INF ? -1 : res) << "\n";
}
}
|
#include <bits/stdc++.h>
using namespace std;
int A[1000000], B[1000000], C[1000000];
int main() {
int n, k, t, a, b;
cin >> n >> k;
int num1 = 0, num2 = 0, num3 = 0;
for (int i = 1; i <= n; i++) {
cin >> t >> a >> b;
if (a == 1 && b != 1) A[++num1] = t;
if (a == 0 && b == 1) B[++num2] = t;
if (a == 1 && b == 1) C[++num3] = t;
}
if (num1 + num3 < k || num2 + num3 < k) {
cout << -1;
return 0;
}
sort(A + 1, A + num1 + 1);
sort(B + 1, B + num2 + 1);
sort(C + 1, C + num3 + 1);
int i = 1, j = 1;
int num = 0;
int sum = 0;
while (num < k) {
if ((i > num1 && num1 < k) || (i > num2 && num2 < k)) {
sum += C[j];
j++;
num++;
continue;
}
if (A[i] + B[i] <= C[j] || j > num3) {
sum += (A[i] + B[i]);
i++;
} else {
sum += C[j];
j++;
}
num++;
}
cout << sum << endl;
return 0;
}
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.