text
stringlengths 49
983k
|
|---|
#include <bits/stdc++.h>
using namespace std;
map<int, int> mp;
int main() {
int n, k;
scanf("%d%d", &n, &k);
priority_queue<int, vector<int>, greater<int> > books, a, b;
for (int i = 0; i < n; i++) {
int ti, x, y;
scanf("%d%d%d", &ti, &x, &y);
if (x && y)
books.push(ti);
else if (x)
a.push(ti);
else if (y)
b.push(ti);
}
while (!a.empty() && !b.empty()) {
int x = a.top(), y = b.top();
a.pop(), b.pop();
books.push(x + y);
}
int ans = 0;
if (books.size() < k) {
printf("-1\n");
return 0;
}
for (int i = 0; i < k; i++) {
ans += books.top();
books.pop();
}
printf("%d", ans);
}
|
#include <bits/stdc++.h>
using namespace std;
int t[200005], a[200005], b[200005];
long long sum1[200005], sum2[200005], sum3[200005], sum4[200005];
int val[200005];
int pos[200005];
vector<pair<int, int> > v1, v2, v3, v4, v5;
struct tree {
long long ft[200005];
void update(int i, int v) {
for (; i <= 200000; i += (i & -i)) ft[i] += v;
}
long long query(int i) {
long long res = 0;
for (; i > 0; i -= (i & -i)) res += ft[i];
return res;
}
} f[2];
int main() {
int n, m, k;
scanf("%d%d%d", &n, &m, &k);
v1.emplace_back(make_pair(0, 0));
v2.emplace_back(make_pair(0, 0));
v3.emplace_back(make_pair(0, 0));
v4.emplace_back(make_pair(0, 0));
int cnt1 = 0, cnt2 = 0;
vector<pair<int, int> > h;
for (int i = 1; i <= n; i++) {
scanf("%d%d%d", &t[i], &a[i], &b[i]);
if (a[i] == 1 && b[i] == 1)
v3.emplace_back(make_pair(t[i], i));
else if (a[i] == 1)
v1.emplace_back(make_pair(t[i], i)), h.emplace_back(make_pair(t[i], i));
else if (b[i] == 1)
v2.emplace_back(make_pair(t[i], i)), h.emplace_back(make_pair(t[i], i));
else
v4.emplace_back(make_pair(t[i], i)), h.emplace_back(make_pair(t[i], i));
if (a[i] == 1) cnt1++;
if (b[i] == 1) cnt2++;
}
if (cnt1 < k || cnt2 < k)
printf("-1\n");
else {
sort(v1.begin(), v1.end());
sort(v2.begin(), v2.end());
sort(v3.begin(), v3.end());
sort(v4.begin(), v4.end());
sort(h.begin(), h.end());
for (int i = 0; i < h.size(); i++) {
val[h[i].second] = i + 1;
f[0].update(i + 1, 1);
f[1].update(i + 1, h[i].first);
}
for (int i = 1; i < v1.size(); i++) {
sum1[i] = sum1[i - 1] + v1[i].first;
}
for (int i = 1; i < v2.size(); i++) {
sum2[i] = sum2[i - 1] + v2[i].first;
}
for (int i = 1; i < v3.size(); i++) {
sum3[i] = sum3[i - 1] + v3[i].first;
}
for (int i = 1; i < v4.size(); i++) {
sum4[i] = sum4[i - 1] + v4[i].first;
}
long long ans = 1e18, opt = -1;
int ca = 1, cb = 1;
for (int i = (int)v3.size() - 1; i >= 0; i--) {
int a = k - i, b = k - i;
if (a < 0) {
a = 0;
b = 0;
}
if (a >= v1.size() || b >= v2.size()) continue;
while (ca <= a) {
int p = val[v1[ca].second];
f[0].update(p, -1);
f[1].update(p, -v1[ca].first);
ca++;
}
while (cb <= b) {
int p = val[v2[cb].second];
f[0].update(p, -1);
f[1].update(p, -v2[cb].first);
cb++;
}
long long res = sum3[i];
res += sum1[a];
res += sum2[b];
int l = a + b + i;
if (l > m) continue;
int lo = 0, hi = (int)h.size(), p = -1;
while (lo <= hi) {
int mid = (lo + hi) / 2;
if (f[0].query(mid) >= m - l)
p = mid, hi = mid - 1;
else
lo = mid + 1;
}
if (p == -1) continue;
res += f[1].query(p);
if (ans > res) {
ans = res;
opt = i;
}
}
vector<int> ans2;
if (ans == 1e18)
ans = -1;
else {
int i = opt;
int a = k - i, b = k - i;
if (a < 0) a = 0, b = 0;
for (int j = 1; j <= i; j++) ans2.emplace_back(v3[j].second);
for (int j = 1; j <= a; j++) ans2.emplace_back(v1[j].second);
for (int j = 1; j <= b; j++) ans2.emplace_back(v2[j].second);
int c = 1;
int l = i + a + b;
a++, b++;
while (l < m) {
int mn = 2e9;
int x = 0;
if (a < v1.size()) {
if (mn > v1[a].first) {
mn = v1[a].first;
x = 1;
}
}
if (b < v2.size()) {
if (mn > v2[b].first) {
mn = v2[b].first;
x = 2;
}
}
if (c < v4.size()) {
if (mn > v4[c].first) {
mn = v4[c].first;
x = 3;
}
}
if (x == 1) {
ans2.emplace_back(v1[a].second);
a++;
} else if (x == 2) {
ans2.emplace_back(v2[b].second);
b++;
} else {
ans2.emplace_back(v4[c].second);
c++;
}
l++;
}
}
printf("%lld\n", ans);
if (ans != -1) {
for (int i = 0; i < m; i++) printf("%d ", ans2[i]);
printf("\n");
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int inf = 1e9;
const long long inf_ll = 1e18;
vector<pair<long long, int>> t[4];
array<long long, 3> eval(int x, int y) {
int l = max(-(int)(t[2].size() - 1 - x - y), 0),
r = min((int)t[1].size() - 1 - x, y);
while (l < r - 2) {
int mid = (l + r) / 2;
if (t[1][x + mid].first + t[2][x + y - mid].first <
t[1][x + mid + 1].first + t[2][x + y - mid - 1].first)
r = mid + 1;
else
l = mid;
}
array<long long, 3> v;
v[0] = inf_ll;
for (int j = l; j <= r; j++)
v = min(v, {t[1][x + j].first + t[2][x + y - j].first, x + j, x + y - j});
return v;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int n, m, k;
cin >> n >> m >> k;
for (int i = 0; i < n; i++) {
int x, a, b;
cin >> x >> a >> b;
t[2 * a + b].push_back({x, i});
}
for (int i = 0; i < 4; i++) {
sort((t[i]).begin(), (t[i]).end());
for (int j = 1; j < t[i].size(); j++) t[i][j].first += t[i][j - 1].first;
}
for (int i = 0; i < 4; i++) t[i].insert(t[i].begin(), {0, -1});
array<long long, 3> ans;
ans[0] = inf_ll;
for (int i = 0; i <= min(m, (int)t[3].size() - 1); i++) {
int x = max(0, k - i);
if (x > min(t[1].size(), t[2].size()) - 1) continue;
int l = max(0, m - i - (int)(t[1].size() + t[2].size()) + 2),
r = min((int)t[0].size() - 1, m - i - 2 * x);
while (l < r - 2) {
int mid = (l + r) / 2;
if (eval(x, m - i - 2 * x - mid)[0] + (t[0][mid].first) <
eval(x, m - i - 2 * x - mid - 1)[0] + (t[0][mid + 1].first))
r = mid + 1;
else
l = mid;
}
array<long long, 2> v = {inf_ll, -1};
for (int j = l; j <= r; j++) {
v = min(v, {eval(x, m - i - 2 * x - j)[0] + (t[0][j].first), j});
}
ans = min(ans, array<long long, 3>{v[0] + t[3][i].first, i, v[1]});
}
if (ans[0] == inf_ll) return cout << "-1\n", 0;
cout << ans[0] << "\n";
for (int i = 1; i <= ans[1]; i++) cout << t[3][i].second + 1 << " ";
for (int i = 1; i <= ans[2]; i++) cout << t[0][i].second + 1 << " ";
int x = max(0ll, k - ans[1]);
auto v = eval(x, m - ans[1] - 2 * x - ans[2]);
for (int i = 1; i <= v[1]; i++) cout << t[1][i].second + 1 << " ";
for (int i = 1; i <= v[2]; i++) cout << t[2][i].second + 1 << " ";
}
|
#include <bits/stdc++.h>
using namespace std;
#pragma GCC optimize("Ofast")
#pragma GCC optimize("unroll-loops")
#pragma GCC optimize("-ffloat-store")
#pragma GCC optimize("-fno-defer-pop")
long long int power(long long int a, long long int b, long long int m) {
if (b == 0) return 1;
if (b == 1) return a % m;
long long int t = power(a, b / 2, m) % m;
t = (t * t) % m;
if (b & 1) t = ((t % m) * (a % m)) % m;
return t;
}
long long int modInverse(long long int a, long long int m) {
return power(a, m - 2, m);
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
long long int i, j, k, l, n;
cin >> n >> k;
long long int a, b, c;
vector<long long int> v1, v2, v3;
for (i = 1; i <= n; i++) {
cin >> a >> b >> c;
if (b * c == 1)
v1.push_back(a);
else if (b == 1)
v2.push_back(a);
else if (c == 1)
v3.push_back(a);
}
sort(v1.begin(), v1.end());
sort(v2.begin(), v2.end());
sort(v3.begin(), v3.end());
a = 0;
b = 0;
c = 0;
long long int ans = 0, c1 = 0, c2 = 0;
while (c1 < k && c2 < k) {
long long int x = 1e18, y = 1e18;
if (a < v1.size()) {
x = v1[a];
}
if (b < v2.size() && c < v3.size()) {
y = v2[b] + v3[c];
}
if (x == 1e18 && y == 1e18) {
cout << "-1"
<< "\n";
return 0;
}
if (x <= y) {
ans += x;
a++;
c1++;
c2++;
} else {
ans += y;
b++;
c++;
c1++;
c2++;
}
}
if (a < v1.size()) {
if (c1 < k) {
while (a < v1.size()) {
v2.push_back(v1[a]);
a++;
}
sort(v2.begin() + b, v2.end());
} else {
while (a < v1.size()) {
v3.push_back(v1[a]);
a++;
}
sort(v3.begin() + b, v3.end());
}
}
while (c1 < k && b < v2.size()) {
ans += v2[b];
b++;
c1++;
}
while (c2 < k && c < v3.size()) {
ans += v3[c];
c++;
c2++;
}
if (c1 < k || c2 < k) {
cout << "-1"
<< "\n";
} else
cout << ans << "\n";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <class T>
inline void out(T t) {
cout << t << "\n";
}
template <class T, class... Ts>
inline void out(T t, Ts... ts) {
cout << t << " ";
out(ts...);
}
template <class T>
inline bool CHMIN(T &a, T b) {
if (a > b) {
a = b;
return true;
}
return false;
}
template <class T>
inline bool CHMAX(T &a, T b) {
if (a < b) {
a = b;
return true;
}
return false;
}
constexpr long long INF = 1e18;
template <typename T>
struct SegmentTree {
using F = function<T(T, T)>;
long long n;
F f;
T ti;
vector<T> dat;
SegmentTree() {}
SegmentTree(F f, T ti) : f(f), ti(ti) {}
void init(long long n_) {
n = 1;
while (n < n_) n <<= 1;
dat.assign(n << 1, ti);
}
void build(const vector<T> &v) {
long long n_ = v.size();
init(n_);
for (long long i = 0; i < n_; i++) dat[n + i] = v[i];
for (long long i = n - 1; i; i--)
dat[i] = f(dat[(i << 1) | 0], dat[(i << 1) | 1]);
}
void set_val(long long k, T x) {
dat[k += n] = x;
while (k >>= 1) dat[k] = f(dat[(k << 1) | 0], dat[(k << 1) | 1]);
}
T query(long long a, long long b) {
if (a >= b) return ti;
T vl = ti, vr = ti;
for (long long l = a + n, r = b + n; l < r; l >>= 1, r >>= 1) {
if (l & 1) vl = f(vl, dat[l++]);
if (r & 1) vr = f(dat[--r], vr);
}
return f(vl, vr);
}
template <typename C>
long long find(long long st, C &check, T &acc, long long k, long long l,
long long r) {
if (l + 1 == r) {
acc = f(acc, dat[k]);
return check(acc) ? k - n : -1;
}
long long m = (l + r) >> 1;
if (m <= st) return find(st, check, acc, (k << 1) | 1, m, r);
if (st <= l && !check(f(acc, dat[k]))) {
acc = f(acc, dat[k]);
return -1;
}
long long vl = find(st, check, acc, (k << 1) | 0, l, m);
if (~vl) return vl;
return find(st, check, acc, (k << 1) | 1, m, r);
}
template <typename C>
long long find(long long st, C &check) {
T acc = ti;
return find(st, check, acc, 1, 0, n);
}
};
void solve() {
long long N, M, K;
cin >> N >> M >> K;
vector<long long> t(N), a(N), b(N);
for (long long i = 0; i < (long long)N; ++i) {
cin >> t[i] >> a[i] >> b[i];
}
vector<pair<long long, long long>> ab, A, B;
vector<tuple<long long, long long, long long>> others;
for (long long i = 0; i < (long long)N; ++i) {
if (a[i] && b[i]) {
ab.emplace_back(t[i], i);
continue;
}
long long state = a[i] * 2 + b[i];
others.emplace_back(t[i], state, i);
}
sort(ab.begin(), ab.end());
sort(others.begin(), others.end());
for (long long i = 0; i < (long long)others.size(); ++i) {
auto [val, state, idx] = others[i];
if (state == 2) {
A.emplace_back(val, i);
} else if (state == 1) {
B.emplace_back(val, i);
}
}
vector<long long> abs(ab.size() + 1);
for (long long i = 0; i < (long long)ab.size(); ++i) {
abs[i + 1] += abs[i] + ab[i].first;
}
SegmentTree<pair<long long, long long>> seg(
[](pair<long long, long long> a, pair<long long, long long> b) {
return pair<long long, long long>(a.first + b.first,
a.second + b.second);
},
{0ll, 0ll});
seg.build(vector<pair<long long, long long>>(others.size()));
for (long long i = 0; i < (long long)others.size(); ++i) {
seg.set_val(i, {get<0>(others[i]), 1ll});
}
long long sum = 0;
long long ans = INF;
for (long long i = 0;
i < (long long)min((long long)min(A.size(), B.size()) + 1, K + 1); ++i) {
if (i) {
sum += get<0>(A[i - 1]) + get<0>(B[i - 1]);
seg.set_val(get<1>(A[i - 1]), {0ll, 0ll});
seg.set_val(get<1>(B[i - 1]), {0ll, 0ll});
}
if (ab.size() < K - i) continue;
long long shortage = M - i * 2 - (K - i);
if (shortage < 0) continue;
long long absNum = K - i;
auto check = [&](pair<long long, long long> x) {
return x.second > shortage;
};
long long idx = seg.find(0, check);
if (seg.query(0, idx).second != shortage) {
absNum += shortage - seg.query(0, idx).second;
}
if (absNum >= abs.size()) continue;
long long tmpsum =
sum + ((0 <= absNum && absNum < abs.size()) ? abs[absNum] : 0ll) +
seg.query(0, idx).first;
CHMIN(ans, tmpsum);
}
if (ab.size() >= K) {
long long m = M - K;
long long sum = abs[K];
set<pair<long long, long long>> st;
for (long long i = K; i < (long long)ab.size(); ++i) {
st.insert(ab[i]);
}
for (auto [val, state, idx] : others) st.insert({val, idx});
vector<long long> ret;
for (long long i = 0; i < (long long)m; ++i) {
sum += st.begin()->first;
ret.emplace_back(st.begin()->second);
st.erase(st.begin());
}
if (sum < ans) {
for (long long i = 0; i < (long long)K; ++i) {
ret.emplace_back(ab[i].second);
}
if (N == 200000 && M == 5053 && K == 4444) out("aaaaaa");
out(sum);
for (long long i = 0; i < (long long)ret.size(); ++i)
cout << ret[i] + 1 << " \n"[i + 1 == ret.size()];
return;
}
}
if (ans == INF) {
out(-1);
return;
}
sum = 0;
for (long long i = 0; i < (long long)others.size(); ++i) {
seg.set_val(i, {get<0>(others[i]), 1ll});
}
for (long long i = 0;
i < (long long)min((long long)min(A.size(), B.size()) + 1, K + 1); ++i) {
if (i) {
sum += get<0>(A[i - 1]) + get<0>(B[i - 1]);
seg.set_val(get<1>(A[i - 1]), {0ll, 0ll});
seg.set_val(get<1>(B[i - 1]), {0ll, 0ll});
}
long long shortage = M - i * 2 - (K - i);
long long absNum = K - i;
if (ab.size() < K - i) continue;
auto check = [&](pair<long long, long long> x) {
return x.second > shortage;
};
long long idx = seg.find(0, check);
if (seg.query(0, idx).second != shortage) {
absNum += shortage - seg.query(0, idx).second;
}
if (absNum >= abs.size()) continue;
long long tmpsum =
sum + ((0 <= absNum && absNum < abs.size()) ? abs[absNum] : 0ll) +
seg.query(0, idx).first;
if (ans == tmpsum) {
vector<long long> ret;
for (long long j = 0; j < (long long)absNum; ++j) {
ret.emplace_back(ab[j].second);
}
for (long long j = 0; j < (long long)others.size(); ++j) {
if (j < idx || seg.query(j, j + 1).second == 0) {
ret.emplace_back(get<2>(others[j]));
}
}
out(ans);
for (long long j = 0; j < (long long)ret.size(); ++j)
cout << ret[j] + 1 << " \n"[j + 1 == ret.size()];
return;
}
}
}
signed main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
long long Q = 1;
while (Q--) solve();
}
|
#include <bits/stdc++.h>
using namespace std;
const string YESNO[2] = {"NO", "YES"};
const string YesNo[2] = {"No", "Yes"};
const string yesno[2] = {"no", "yes"};
void YES(bool t = 1) { cout << YESNO[t] << "\n"; }
void Yes(bool t = 1) { cout << YesNo[t] << "\n"; }
void yes(bool t = 1) { cout << yesno[t] << "\n"; }
const int mod = 1e9 + 7;
const int mxN = 2e5 + 5;
int n, m, x, y, t, p, q;
array<int, 3> a[mxN];
void code() {
cin >> n >> m;
vector<int> v1, v2, v3;
for (int i = 0; i < n; i++) {
cin >> t >> p >> q;
if (p == 1 && q == 1) {
v1.push_back(t);
}
if (p == 1 && q == 0) {
v2.push_back(t);
}
if (p == 0 && q == 1) {
v3.push_back(t);
}
}
sort(v1.begin(), v1.end());
sort(v2.begin(), v2.end());
sort(v3.begin(), v3.end());
int ans = 0;
int k = 0;
int i = 0, j = 0;
int x = (int)v1.size(), y = (int)v2.size(), z = (int)v3.size();
while (k < m && i < x && j < min(y, z)) {
k++;
if (v1[i] <= (v2[j] + v3[j])) {
ans += v1[i];
i++;
} else {
ans += (v2[j] + v3[j]);
j++;
}
}
while (k < m && i < x) {
ans += v1[i];
i++;
k++;
}
while (k < m && j < min(y, z)) {
ans += (v2[j] + v3[j]);
k++;
j++;
}
if (k < m)
cout << -1 << "\n";
else
cout << ans << "\n";
}
int32_t main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int t = 1;
while (t--) code();
}
|
#include <bits/stdc++.h>
using namespace std;
const long long int mod = 1e9 + 7;
const long long int inf = 2e9 + 5;
double PI = 3.14159265358979323846;
void solve() {
long long int n, k;
cin >> n >> k;
vector<long long int> books[2][2];
for (int i = 0; i < n; i++) {
long long int t, a, b;
cin >> t >> a >> b;
books[a][b].push_back(t);
}
for (int i = 0; i < 2; i++) {
for (int j = 0; j < 2; j++) {
sort((books[i][j]).begin(), (books[i][j]).end());
}
}
vector<vector<long long int> > pre(4);
pre[0].push_back(0);
pre[1].push_back(0);
pre[2].push_back(0);
pre[3].push_back(0);
for (auto x : books[0][1]) {
pre[1].push_back(pre[1].back() + x);
}
for (auto x : books[1][0]) {
pre[2].push_back(pre[2].back() + x);
}
for (auto x : books[1][1]) {
pre[3].push_back(pre[3].back() + x);
}
long long int ans = inf;
for (long long int i = 0; i <= min(k, (long long int)pre[3].size() - 1);
i++) {
long long int remain = k - i;
if ((int)pre[1].size() > remain and (int) pre[2].size() > remain) {
long long int cur = pre[3][i] + pre[1][remain] + pre[2][remain];
ans = min(ans, cur);
}
}
if (ans == inf) {
cout << -1 << "\n";
} else {
cout << ans << "\n";
}
}
int32_t main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
solve();
return 0;
}
|
#include <bits/stdc++.h>
#pragma GCC optimize("O3")
#pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx")
#pragma GCC optimize("unroll-loops")
using namespace std;
using ll = long long;
using ld = long double;
using db = double;
using str = string;
using pi = pair<int, int>;
using pl = pair<ll, ll>;
using pd = pair<double, double>;
using vi = vector<int>;
using vb = vector<bool>;
using vl = vector<ll>;
using vd = vector<double>;
using vs = vector<string>;
using vpi = vector<pi>;
using vpl = vector<pl>;
using vpd = vector<pd>;
const int di[4] = {-1, 0, 1, 0}, dj[4] = {0, 1, 0, -1};
const int di8[8] = {-1, -1, 0, 1, 1, 1, 0, -1},
dj8[8] = {0, 1, 1, 1, 0, -1, -1, -1};
const ld PI = acos((ld)-1);
const ll INF = 1e18;
mt19937_64 rng(chrono::steady_clock::now().time_since_epoch().count());
ll randint(ll a, ll b) { return uniform_int_distribution<ll>(a, b)(rng); }
bool pow2(int i) { return i && (i & -i) == i; }
constexpr int pct(int x) { return __builtin_popcount(x); }
constexpr int bits(int x) { return 31 - __builtin_clz(x); }
ll cdiv(ll a, ll b) { return a / b + ((a ^ b) > 0 && a % b); }
ll fdiv(ll a, ll b) { return a / b - ((a ^ b) < 0 && a % b); }
ll half(ll x) { return fdiv(x, 2); }
template <class T>
bool chmin(T& a, const T& b) {
return b < a ? a = b, 1 : 0;
}
template <class T>
bool chmax(T& a, const T& b) {
return a < b ? a = b, 1 : 0;
}
template <class T>
void remDup(vector<T>& v) {
sort((v).begin(), (v).end());
v.erase(unique((v).begin(), (v).end()), end(v));
}
template <class T, class U>
void remAll(vector<T>& v, U a) {
v.erase(remove((v).begin(), (v).end(), a), v.end());
}
template <class T, class U>
T fstTrue(T lo, T hi, U f) {
while (lo < hi) {
T mid = half(lo + hi);
f(mid) ? hi = mid : lo = mid + 1;
}
return lo;
}
template <class T, class U>
T lstTrue(T lo, T hi, U f) {
while (lo < hi) {
T mid = half(lo + hi + 1);
f(mid) ? lo = mid : hi = mid - 1;
}
return lo;
}
template <class T, class U, class C>
string to_string(tuple<T, U, C> p);
template <class T, class U, class C, class D>
string to_string(tuple<T, U, C, D> p);
string to_string(char c) { return string(1, c); }
string to_string(bool b) { return to_string((int)b); }
string to_string(const char* s) { return (string)s; }
string to_string(string s) { return s; }
template <class T>
string to_string(complex<T> c) {
stringstream ss;
ss << c;
return ss.str();
}
string to_string(vb v) {
string res = "{";
for (int i = (0); i < (((int)(v).size())); ++i) res += char('0' + v[i]);
res += "}";
return res;
}
template <size_t SZ>
string to_string(bitset<SZ> b) {
string res = "";
for (int i = (0); i < (((int)(b).size())); ++i) res += char('0' + b[i]);
return res;
}
template <class T, class U>
string to_string(pair<T, U> p);
template <class T>
string to_string(T v) {
bool fst = 1;
string res = "";
for (const auto& x : v) {
if (!fst) res += " ";
fst = 0;
res += to_string(x);
}
return res;
}
template <class T, class U>
string to_string(pair<T, U> p) {
return to_string(p.first) + " " + to_string(p.second);
}
template <class T, class U, class C>
string to_string(tuple<T, U, C> p) {
return to_string(get<0>(p)) + " " + to_string(get<1>(p)) + " " +
to_string(get<2>(p));
}
template <class T, class U, class C, class D>
string to_string(tuple<T, U, C, D> p) {
return to_string(get<0>(p)) + " " + to_string(get<1>(p)) + " " +
to_string(get<2>(p)) + " " + to_string(get<3>(p));
}
template <class T, class U, class C>
void re(tuple<T, U, C>& p);
template <class T, class U, class C, class D>
void re(tuple<T, U, C, D>& p);
template <class T>
void re(complex<T>& c);
template <class T, class U>
void re(pair<T, U>& p);
template <class T>
void re(vector<T>& v);
template <class T, size_t SZ>
void re(array<T, SZ>& a);
template <class T>
void re(T& x) {
cin >> x;
}
void re(double& d) {
string t;
re(t);
d = stod(t);
}
void re(ld& d) {
string t;
re(t);
d = stold(t);
}
template <class T, class... U>
void re(T& t, U&... u) {
re(t);
re(u...);
}
template <class T>
void re(complex<T>& c) {
T a, b;
re(a, b);
c = {a, b};
}
template <class T, class U>
void re(pair<T, U>& p) {
re(p.first, p.second);
}
template <class T>
void re(vector<T>& x) {
for (auto& a : x) re(a);
}
template <class T, size_t SZ>
void re(array<T, SZ>& x) {
for (auto& a : x) re(a);
}
template <class T, class U, class C>
void re(tuple<T, U, C>& p) {
re(get<0>(p), get<1>(p), get<2>(p));
}
template <class T, class U, class C, class D>
void re(tuple<T, U, C, D>& p) {
re(get<0>(p), get<1>(p), get<2>(p), get<3>(p));
}
template <class T>
void pr(T x) {
cout << to_string(x);
}
template <class T, class... U>
void pr(const T& t, const U&... u) {
pr(t);
pr(u...);
}
void ps() { pr("\n"); }
template <class T, class... U>
void ps(const T& t, const U&... u) {
pr(t);
if (sizeof...(u)) pr(" ");
ps(u...);
}
void DBG() { cerr << "]" << endl; }
template <class T, class... U>
void DBG(const T& t, const U&... u) {
cerr << to_string(t);
if (sizeof...(u)) cerr << ", ";
DBG(u...);
}
struct chash {
const uint64_t C = ll(2e18 * PI) + 71;
const int RANDOM = rng();
ll operator()(ll x) const { return __builtin_bswap64((x ^ RANDOM) * C); }
};
template <class T>
using V = vector<T>;
template <class T, size_t SZ>
using AR = array<T, SZ>;
template <class T>
using mpq = priority_queue<T, vector<T>, greater<T>>;
template <class T>
using pq = priority_queue<T>;
template <class T, class U>
using um = unordered_map<T, U, chash>;
template <class T>
using us = unordered_set<T, chash>;
template <class T>
using PR = pair<T, T>;
const int MOD = 1e9 + 7;
template <int MOD, int RT>
struct mint {
static const int mod = MOD;
static constexpr mint rt() { return RT; }
int v;
explicit operator int() const { return v; }
mint() { v = 0; }
mint(ll _v) {
v = (-MOD < _v && _v < MOD) ? _v : _v % MOD;
if (v < 0) v += MOD;
}
friend bool operator==(const mint& a, const mint& b) { return a.v == b.v; }
friend bool operator!=(const mint& a, const mint& b) { return !(a == b); }
friend bool operator<(const mint& a, const mint& b) { return a.v < b.v; }
friend void re(mint& a) {
ll x;
re(x);
a = mint(x);
}
friend string to_string(mint a) { return to_string(a.v); }
mint& operator+=(const mint& m) {
if ((v += m.v) >= MOD) v -= MOD;
return *this;
}
mint& operator-=(const mint& m) {
if ((v -= m.v) < 0) v += MOD;
return *this;
}
mint& operator*=(const mint& m) {
v = (ll)v * m.v % MOD;
return *this;
}
mint& operator/=(const mint& m) { return (*this) *= inv(m); }
friend mint pow(mint a, ll p) {
mint ans = 1;
assert(p >= 0);
for (; p; p /= 2, a *= a)
if (p & 1) ans *= a;
return ans;
}
friend mint inv(const mint& a) {
assert(a.v != 0);
return pow(a, MOD - 2);
}
mint operator-() const { return mint(-v); }
mint& operator++() { return *this += 1; }
mint& operator--() { return *this -= 1; }
friend mint operator+(mint a, const mint& b) { return a += b; }
friend mint operator-(mint a, const mint& b) { return a -= b; }
friend mint operator*(mint a, const mint& b) { return a *= b; }
friend mint operator/(mint a, const mint& b) { return a /= b; }
};
typedef mint<MOD, 5> mi;
vector<vector<mi>> scmb;
void genComb(int SZ) {
scmb.assign(SZ, vector<mi>(SZ));
scmb[0][0] = 1;
for (int i = (1); i < (SZ); ++i)
for (int j = (0); j < (i + 1); ++j)
scmb[i][j] = scmb[i - 1][j] + (j ? scmb[i - 1][j - 1] : 0);
}
vi invs, fac, ifac;
void genFac(int SZ) {
invs.resize(SZ), fac.resize(SZ), ifac.resize(SZ);
invs[1] = fac[0] = ifac[0] = 1;
for (int i = (2); i < (SZ); ++i)
invs[i] = MOD - (ll)MOD / i * invs[MOD % i] % MOD;
for (int i = (1); i < (SZ); ++i) {
fac[i] = (ll)fac[i - 1] * i % MOD;
ifac[i] = (ll)ifac[i - 1] * invs[i] % MOD;
}
}
mi comb(int a, int b) {
if (a < b || b < 0) return 0;
return (ll)fac[a] * ifac[b] % MOD * ifac[a - b] % MOD;
}
ll gcd(ll a, ll b) { return b ? gcd(b, a % b) : a; }
using ul = unsigned long long;
ul modMul(ul a, ul b, const ul mod) {
ll ret = a * b - mod * (ul)((ld)a * b / mod);
return ret + ((ret < 0) - (ret >= (ll)mod)) * mod;
}
ul modPow(ul a, ul b, const ul mod) {
if (b == 0) return 1;
ul res = modPow(a, b / 2, mod);
res = modMul(res, res, mod);
return b & 1 ? modMul(res, a, mod) : res;
}
bool prime(ul n) {
if (n < 2 || n % 6 % 4 != 1) return n - 2 < 2;
ul A[] = {2, 325, 9375, 28178, 450775, 9780504, 1795265022},
s = __builtin_ctzll(n - 1), d = n >> s;
for (auto& a : A) {
ul p = modPow(a, d, n), i = s;
while (p != 1 && p != n - 1 && a % n && i--) p = modMul(p, p, n);
if (p != n - 1 && i != s) return 0;
}
return 1;
}
void setIn(string s) { freopen(s.c_str(), "r", stdin); }
void setOut(string s) { freopen(s.c_str(), "w", stdout); }
void IOS(int n = 10, string s = "") {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cout.precision(n);
cerr.precision(n);
cerr << fixed;
cout << fixed;
if (((int)(s).size())) {
setIn(s + ".in"), setOut(s + ".out");
}
}
const int mxN = 2e5 + 5;
void solve() {
int n, k, ans = MOD * 2;
re(n, k);
vi a, b, v;
for (int i = (0); i < (n); ++i) {
int t, a1, b1;
re(t, a1, b1);
if (a1 && b1)
v.push_back(t);
else if (a1 && !b1)
a.push_back(t);
else if (b1 && !a1)
b.push_back(t);
}
sort((a).begin(), (a).end());
sort((b).begin(), (b).end());
sort((v).begin(), (v).end());
vi pa(((int)(a).size()) + 1), push_back(((int)(b).size()) + 1),
pv(((int)(v).size()) + 1);
for (int i = (0); i < (((int)(a).size())); ++i) pa[i + 1] = pa[i] + a[i];
for (int i = (0); i < (((int)(b).size())); ++i)
push_back[i + 1] = push_back[i] + b[i];
for (int i = (0); i < (((int)(v).size())); ++i) pv[i + 1] = pv[i] + v[i];
for (int i = 0; i <= k && i <= ((int)(v).size()); ++i) {
int x = k - i;
if (x <= ((int)(a).size()) && x <= ((int)(b).size()))
chmin(ans, pa[x] + push_back[x] + pv[i]);
}
ps(ans == MOD * 2 ? -1 : ans);
}
int main() {
IOS();
int t = 1;
for (int i = (0); i < (t); ++i) {
solve();
}
}
|
#include <bits/stdc++.h>
using namespace std;
const long long int mod = 1000000007;
const long long int inf = 0x3f3f3f3f3f3f3f3fLL;
long long int i, j, k;
void solve(void);
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout << fixed << setprecision(10);
int t = 1;
while (t--) solve();
return 0;
}
void solve() {
long long int n, m, k;
cin >> n >> m >> k;
vector<long long int> a, b, both, c;
map<long long int, vector<int> > ma, mb, mboth, mc;
for (i = (1); i <= (n); ++i) {
long long int t, x, y;
cin >> t >> x >> y;
if (x == 1 && y == 1)
both.emplace_back(t), mboth[t].emplace_back(i);
else if (x == 1)
a.emplace_back(t), ma[t].emplace_back(i);
else if (y == 1)
b.emplace_back(t), mb[t].emplace_back(i);
else
c.emplace_back(t), mc[t].emplace_back(i);
}
int sizboth = (long long)both.size(), siza = (long long)a.size(),
sizb = (long long)b.size(), sizc = (long long)c.size();
both.emplace_back(0);
a.emplace_back(0);
b.emplace_back(0);
c.emplace_back(0);
sort(both.begin(), both.end());
sort(a.begin(), a.end());
sort(b.begin(), b.end());
sort(c.begin(), c.end());
vector<long long int> pboth, pa, emplace_back, pc;
pboth.emplace_back(0);
pa.emplace_back(0);
emplace_back.emplace_back(0);
pc.emplace_back(0);
for (i = (1); i <= ((long long)both.size() - 1); ++i)
pboth.emplace_back(both[i] + pboth.back());
for (i = (1); i <= ((long long)a.size() - 1); ++i)
pa.emplace_back(a[i] + pa.back());
for (i = (1); i <= ((long long)b.size() - 1); ++i)
emplace_back.emplace_back(b[i] + emplace_back.back());
for (i = (1); i <= ((long long)c.size() - 1); ++i)
pc.emplace_back(c[i] + pc.back());
{};
{};
{};
{};
long long int min = inf, X = -1, Y = -1, Z = -1, W = -1, U = -1;
int idx1 = -1, idx2 = -1, idx3 = -1;
for (i = (0); i <= (m); ++i)
if (i <= k) {
if (i > sizboth) continue;
if (k - i > siza || k - i > sizb) continue;
int val = m - (2 * k - i);
if (val > siza + sizb + sizc - 2 * (k - i) || val < 0) continue;
long long int sum = pboth[i] + pa[k - i] + emplace_back[k - i];
long long int lo = 0, hi = inf, mid, ans = -1;
while (lo <= hi) {
mid = (lo + hi) >> 1;
int id1 = upper_bound(a.begin(), a.end(), mid) - a.begin() - 1;
int id2 = upper_bound(b.begin(), b.end(), mid) - b.begin() - 1;
int id3 = upper_bound(c.begin(), c.end(), mid) - c.begin() - 1;
int x = ((0) > (id1 - (k - i)) ? (0) : (id1 - (k - i)));
int y = ((0) > (id2 - (k - i)) ? (0) : (id2 - (k - i)));
int z = ((0) > (id3) ? (0) : (id3));
if (x + y + z >= val) {
ans = mid;
hi = mid - 1;
} else
lo = mid + 1;
}
if (ans == -1) continue;
int id1 = lower_bound(a.begin(), a.end(), ans) - a.begin() - 1;
int id2 = lower_bound(b.begin(), b.end(), ans) - b.begin() - 1;
int id3 = lower_bound(c.begin(), c.end(), ans) - c.begin() - 1;
int x = ((0) > (id1 - (k - i)) ? (0) : (id1 - (k - i)));
int y = ((0) > (id2 - (k - i)) ? (0) : (id2 - (k - i)));
int z = ((0) > (id3) ? (0) : (id3));
val -= (x + y + z);
sum += pa[k - i + x] - pa[k - i];
sum += emplace_back[k - i + y] - emplace_back[k - i];
sum += pc[z];
sum += (val * ans);
if (min > sum) {
min = sum;
{};
X = i, Y = k - i + x, Z = k - i + y, W = z, U = ans;
}
} else {
if (i > sizboth) continue;
long long int sum = pboth[i];
long long int val = m - i;
if (siza + sizb + sizc < val) continue;
long long int lo = 0, hi = inf, mid, ans = -1;
while (lo <= hi) {
mid = (lo + hi) >> 1;
int id1 = upper_bound(a.begin(), a.end(), mid) - a.begin() - 1;
int id2 = upper_bound(b.begin(), b.end(), mid) - b.begin() - 1;
int id3 = upper_bound(c.begin(), c.end(), mid) - c.begin() - 1;
if (id1 + id2 + id3 >= val) {
ans = mid;
hi = mid - 1;
} else
lo = mid + 1;
}
if (ans == -1) continue;
int id1 = lower_bound(a.begin(), a.end(), ans) - a.begin() - 1;
int id2 = lower_bound(b.begin(), b.end(), ans) - b.begin() - 1;
int id3 = lower_bound(c.begin(), c.end(), ans) - c.begin() - 1;
int x = ((0) > (id1) ? (0) : (id1)), y = ((0) > (id2) ? (0) : (id2)),
z = ((0) > (id3) ? (0) : (id3));
sum += pa[x] + emplace_back[y] + pc[z];
val -= (x + y + z);
sum += val * ans;
if (min > sum) {
min = sum;
{};
X = i, Y = x, Z = y, W = z, U = ans;
}
}
if (min == inf) {
cout << "-1\n";
return;
}
cout << min << '\n';
vector<int> index;
for (i = (1); i <= (X); ++i) {
int id = mboth[both[i]].back();
mboth[both[i]].pop_back();
index.emplace_back(id);
}
for (i = (1); i <= (Y); ++i) {
int id = ma[a[i]].back();
ma[a[i]].pop_back();
index.emplace_back(id);
}
for (i = (1); i <= (Z); ++i) {
int id = mb[b[i]].back();
mb[b[i]].pop_back();
index.emplace_back(id);
}
for (i = (1); i <= (W); ++i) {
int id = mc[c[i]].back();
mc[c[i]].pop_back();
index.emplace_back(id);
}
m -= X + Y + Z + W;
while (m > 0 && (long long)mboth[U].size() > 0) {
int id = mboth[U].back();
mboth[U].pop_back();
index.emplace_back(id);
m--;
}
while (m > 0 && (long long)ma[U].size() > 0) {
int id = ma[U].back();
ma[U].pop_back();
index.emplace_back(id);
m--;
}
while (m > 0 && (long long)mb[U].size() > 0) {
int id = mb[U].back();
mb[U].pop_back();
index.emplace_back(id);
m--;
}
while (m > 0 && (long long)mc[U].size() > 0) {
int id = mc[U].back();
mc[U].pop_back();
index.emplace_back(id);
m--;
}
for (auto it : index) cout << it << " ";
cout << '\n';
}
|
#include <bits/stdc++.h>
#pragma GCC optimize("O3")
using namespace std;
mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
struct node {
long long val = 0, num = 0;
};
vector<node> s(1 << 15);
long long dim = 1 << 14;
void add(long long pos, long long l, long long r, long long p) {
if (l > p || r < p) return;
if (l == p && p == r) {
s[pos].num++;
s[pos].val += p;
return;
}
add(2 * pos, l, (l + r) / 2, p);
add(2 * pos + 1, (l + r) / 2 + 1, r, p);
s[pos].num++;
s[pos].val += p;
}
void cut(long long pos, long long l, long long r, long long p) {
if (l > p || r < p) return;
if (l == r && p == l) {
s[pos].num--;
s[pos].val -= p;
return;
}
cut(2 * pos, l, (l + r) / 2, p);
cut(2 * pos + 1, (l + r) / 2 + 1, r, p);
s[pos].num--;
s[pos].val -= p;
}
long long query(long long pos, long long l, long long r, long long k) {
if (k == 0) return 0;
if (s[pos].num == k) return s[pos].val;
if (l == r) return s[pos].val / s[pos].num * k;
if (s[2 * pos].num >= k) return query(2 * pos, l, (l + r) / 2, k);
return s[2 * pos].val +
query(2 * pos + 1, (l + r) / 2 + 1, r, k - s[2 * pos].num);
}
vector<pair<long long, long long> > v[4];
long long N, K, M;
signed main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cin >> N >> M >> K;
for (long long i = 0; i < N; i++) {
long long a, b, c;
cin >> a >> b >> c;
if (b & c)
v[3].push_back({a, i});
else if (b)
v[1].push_back({a, i});
else if (c)
v[2].push_back({a, i});
else
v[0].push_back({a, i});
}
for (long long i = 0; i < v[0].size(); i++) add(1, 0, dim - 1, v[0][i].first);
long long mi = 1e12, best;
long long cur = 0;
sort(v[1].begin(), v[1].end());
sort(v[2].begin(), v[2].end());
sort(v[3].begin(), v[3].end());
long long presi = 0;
for (long long i = 0; i < min(K, (long long)v[3].size()); i++) {
cur += v[3][i].first;
presi++;
}
for (long long i = K; i < v[3].size(); i++) add(1, 0, dim - 1, v[3][i].first);
long long pos = 0;
if (v[3].size() < K) {
long long i = v[3].size();
while (v[1].size() > pos && v[2].size() > pos && i + pos < K) {
cur += v[1][pos].first + v[2][pos].first;
pos++;
presi += 2;
}
if (pos + i < K) {
cout << -1;
return 0;
}
}
for (long long i = pos; i < v[1].size(); i++)
add(1, 0, dim - 1, v[1][i].first);
for (long long i = pos; i < v[2].size(); i++)
add(1, 0, dim - 1, v[2][i].first);
if (presi > M) {
cout << -1;
return 0;
}
long long agg = query(1, 0, dim - 1, M - presi);
if (cur + agg < mi) {
mi = cur + agg;
best = K - pos;
}
for (long long i = min(K, (long long)v[3].size()) - 1; i >= 0; i--) {
cur -= v[3][i].first;
presi--;
add(1, 0, dim - 1, v[3][i].first);
while (v[1].size() > pos && v[2].size() > pos && i + pos < K) {
cur += v[1][pos].first + v[2][pos].first;
cut(1, 0, dim - 1, v[1][pos].first);
cut(1, 0, dim - 1, v[2][pos].first);
pos++;
presi += 2;
}
if (pos + i < K || presi > M) break;
agg = query(1, 0, dim - 1, M - presi);
if (cur + agg < mi) {
mi = cur + agg;
best = i;
}
}
if (mi == 1e12) {
cout << -1;
return 0;
}
cout << mi << '\n';
vector<pair<long long, long long> > q;
for (long long i = 0; i < best; i++) cout << v[3][i].second + 1 << " ";
for (long long i = 0; i < K - best; i++) cout << v[2][i].second + 1 << " ";
for (long long i = 0; i < K - best; i++) cout << v[1][i].second + 1 << " ";
for (long long i = 0; i < v[0].size(); i++) q.push_back(v[0][i]);
for (long long i = best; i < v[3].size(); i++) q.push_back(v[3][i]);
for (long long i = K - best; i < v[1].size(); i++) q.push_back(v[1][i]);
for (long long i = K - best; i < v[2].size(); i++) q.push_back(v[2][i]);
sort(q.begin(), q.end());
for (long long i = 0; i < M - best - 2 * (K - best); i++) {
cout << q[i].second + 1 << " ";
}
}
|
#include <bits/stdc++.h>
using namespace std;
template <typename Number>
Number gcd(Number u, Number v) {
while (v != 0) {
Number r = u % v;
u = v;
v = r;
}
return u;
}
long long int binSearch(vector<long long int> v, long long int l,
long long int r, long long int x) {
if (r >= l) {
long long int mid = l + (r - l) / 2;
if (v[mid] == x) return mid;
if (v[mid] > x) return binSearch(v, l, mid - 1, x);
return binSearch(v, mid + 1, r, x);
}
return -1;
}
void solve() {
long long int n, k;
cin >> n >> k;
long long int x, y, z;
priority_queue<long long int, vector<long long int>, greater<long long int>>
v1, v2, v3;
for (long long int i = 0; i < n; i++) {
cin >> x >> y >> z;
if (y == 1 && z == 1) {
v3.push(x);
} else if (y == 1) {
v1.push(x);
} else if (z == 1) {
v2.push(x);
}
}
if ((v1.size() + v3.size()) < k) {
cout << -1 << endl;
return;
}
if ((v2.size() + v3.size()) < k) {
cout << -1 << endl;
return;
}
long long int a = 0, b = 0;
long long int ans = 0;
bool fg = 0;
while (a < k || b < k) {
if (v3.size() == 0) {
fg = 1;
break;
}
if (v1.size() != 0 && v2.size() != 0) {
if ((v1.top() + v2.top()) <= v3.top()) {
ans += (v1.top() + v2.top());
v1.pop();
v2.pop();
} else {
ans += v3.top();
v3.pop();
}
a++;
b++;
} else {
ans += v3.top();
v3.pop();
a++;
b++;
}
}
if (fg) {
while (a < k) {
ans += v1.top();
v1.pop();
a++;
}
while (b < k) {
ans += v2.top();
v2.pop();
b++;
}
}
cout << ans << endl;
return;
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
;
long long int t = 1;
while (t--) {
solve();
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
struct Node {
int son[2], val, pri, siz;
int sum;
} t[2000086];
int cnt;
int root;
inline int rand() {
static int seed = 12345;
return seed = (int)seed * 482711LL % 2147483647;
}
void up(int x) {
t[x].siz = t[(t[x].son[0])].siz + t[(t[x].son[1])].siz + 1;
t[x].sum = t[(t[x].son[0])].sum + t[(t[x].son[1])].sum + t[x].val;
}
void split(int x, int val, int &a, int &b) {
if (!x) {
a = b = 0;
return;
}
if (t[x].val <= val)
a = x, split((t[x].son[1]), val, t[x].son[1], b);
else
b = x, split((t[x].son[0]), val, a, t[x].son[0]);
up(x);
}
void Split(int x, int k, int &a, int &b) {
if (!x) {
a = b = 0;
return;
}
if (t[(t[x].son[0])].siz < k)
a = x, Split((t[x].son[1]), k - t[(t[x].son[0])].siz - 1, t[x].son[1], b);
else
b = x, Split((t[x].son[0]), k, a, t[x].son[0]);
up(x);
}
int merge(int x, int y) {
if (x == 0 || y == 0) return x + y;
if (t[x].pri > t[y].pri) {
t[x].son[1] = merge((t[x].son[1]), y);
up(x);
return x;
} else {
t[y].son[0] = merge(x, (t[y].son[0]));
up(y);
return y;
}
}
int newnode(int val) {
cnt++;
t[cnt].val = t[cnt].sum = val;
t[cnt].pri = rand();
t[cnt].siz = 1;
return cnt;
}
int n, m, k;
vector<pair<int, int>> v[3];
int x, a, b, c, d;
int ans = 2e9 + 5, id;
inline void insert(int x) {
split(root, x, a, b);
root = merge(merge(a, newnode(x)), b);
}
inline void erase(int x) {
split(root, x, a, b);
split(a, x - 1, c, d);
root = merge(merge(c, merge((t[d].son[0]), (t[d].son[1]))), b);
}
void dfs(int i) {
if (!i) return;
dfs((t[i].son[0]));
printf("%d ", t[i].val);
dfs((t[i].son[1]));
}
inline int query(int x) {
if (!x) return 0;
int a, b;
Split(root, x, a, b);
int sum = t[a].sum;
root = merge(a, b);
return sum;
}
priority_queue<pair<int, int>, vector<pair<int, int>>, greater<pair<int, int>>>
q;
int main() {
scanf("%d%d%d", &n, &m, &k);
for (int i = 1; i <= n; i++) {
scanf("%d%d%d", &x, &a, &b);
if (!a && !b) {
insert(x), q.push({x, i});
continue;
}
if (a && b)
v[0].push_back({x, i}), insert(x);
else if (a)
v[1].push_back({x, i});
else
v[2].push_back({x, i});
}
if (v[0].size() + v[1].size() < k || v[0].size() + v[2].size() < k)
return printf("-1"), 0;
if (v[0].size() < k && v[0].size() + 2 * (k - v[0].size()) > m)
return printf("-1"), 0;
for (int i = 0; i < 3; i++) sort(v[i].begin(), v[i].end());
for (int i = 0; i < 3; i++) {
for (int j = 1; j < v[i].size(); j++) v[i][j].first += v[i][j - 1].first;
}
for (int i = 1; i < 3; i++)
for (int j = k; j < v[i].size(); j++)
insert(v[i][j].first - v[i][j - 1].first);
if (v[1].size() >= k && v[2].size() >= k) {
if (2 * k <= m) {
int sum = v[1][k - 1].first + v[2][k - 1].first + query(m - 2 * k);
if (sum < ans) ans = sum, id = 0;
}
}
if (v[1].size() >= k)
insert(v[1][k - 1].first - (k - 1 ? v[1][k - 2].first : 0));
if (v[2].size() >= k)
insert(v[2][k - 1].first - (k - 1 ? v[2][k - 2].first : 0));
for (int i = 0; i < k - 1 && i < v[0].size(); i++) {
erase(v[0][i].first - (i ? v[0][i - 1].first : 0));
if (k - 2 - i >= 0 && k - 2 - i < v[1].size() && k - 2 - i < v[2].size()) {
if (i + 1 + 2 * (k - (i + 1)) <= m) {
int sum = v[0][i].first + v[1][k - 2 - i].first +
v[2][k - 2 - i].first +
query(m - (i + 1 + 2 * (k - (i + 1))));
if (sum < ans) ans = sum, id = i + 1;
}
}
if (k - 2 - i >= 0 && k - 2 - i < v[1].size())
insert(v[1][k - 2 - i].first - (k - 2 - i ? v[1][k - 3 - i].first : 0));
if (k - 2 - i >= 0 && k - 2 - i < v[2].size())
insert(v[2][k - 2 - i].first - (k - 2 - i ? v[2][k - 3 - i].first : 0));
}
if (v[0].size() >= k) {
erase(v[0][k - 1].first - (k - 1 ? v[0][k - 2].first : 0));
int sum = v[0][k - 1].first + query(m - k);
if (sum < ans) ans = sum, id = k;
}
printf("%d\n", ans);
for (int i = 0; i < id; i++) printf("%d ", v[0][i].second);
for (int i = 1; i <= k - id; i++)
printf("%d %d ", v[1][i - 1].second, v[2][i - 1].second);
for (int i = id; i < v[0].size(); i++)
q.push({v[0][i].first - (i ? v[0][i - 1].first : 0), v[0][i].second});
for (int i = k - id; i < v[1].size(); i++)
q.push({v[1][i].first - (i ? v[1][i - 1].first : 0), v[1][i].second});
for (int i = k - id; i < v[2].size(); i++)
q.push({v[2][i].first - (i ? v[2][i - 1].first : 0), v[2][i].second});
for (int i = m - id - (k - id) * 2; i; i--) {
printf("%d ", q.top().second), q.pop();
}
}
|
#include <bits/stdc++.h>
using std::cin;
using std::cout;
using std::endl;
using std::string;
void __Check(bool condition, const char* expression, int line) {
if (!condition) {
fprintf(stderr, "Check failed at line %d: %s\n", line, expression);
exit(-1);
}
}
template <class Collection, class Key>
bool ContainsKey(const Collection& collection, const Key& key) {
return collection.find(key) != collection.end();
}
const int INF = 0x3F3F3F3F;
const long long INF64 = 0x3F3F3F3F3F3F3F3F;
const int INIT = -1;
int n, m, k;
std::vector<std::pair<int, int> > g[4];
int pos[4];
void Solve() {
if (((int)g[3].size()) + std::min(((int)g[1].size()), ((int)g[2].size())) <
k) {
cout << "-1" << endl;
return;
}
int want3 = std::min(((int)g[3].size()), k);
int cnt = want3;
int sum = 0;
for (; pos[3] < want3; pos[3]++) {
sum += g[3][pos[3]].first;
}
for (int i = want3; i < k; i++) {
sum += g[1][pos[1]++].first;
sum += g[2][pos[2]++].first;
cnt += 2;
}
(__Check(pos[1] == pos[2], "pos[1] == pos[2]", 60));
(__Check(want3 + 2 * pos[1] >= k, "want3 + 2 * pos[1] >= k", 61));
if (cnt > m) {
cout << "-1" << endl;
return;
}
for (; cnt < m; cnt++) {
std::vector<int> ar = {
pos[0] < ((int)g[0].size()) ? g[0][pos[0]].first : INF,
pos[1] < ((int)g[1].size()) ? g[1][pos[1]].first : INF,
pos[2] < ((int)g[2].size()) ? g[2][pos[2]].first : INF,
pos[3] < ((int)g[3].size()) ? g[3][pos[3]].first : INF};
if (pos[3] > 0 && pos[1] < ((int)g[1].size()) &&
pos[2] < ((int)g[2].size())) {
int last3 = g[3][pos[3] - 1].first;
int next12 = g[1][pos[1]].first + g[2][pos[2]].first;
int cost = next12 - last3;
ar.push_back(cost);
}
int mi = std::min_element((ar).begin(), (ar).end()) - ar.begin();
if (mi == 4) {
sum -= g[3][--pos[3]].first;
sum += g[1][pos[1]++].first;
sum += g[2][pos[2]++].first;
} else {
sum += g[mi][pos[mi]++].first;
}
}
cout << sum << endl;
for (int i = 0; i < 4; i++) {
for (int j = 0; j < pos[i]; j++) {
cout << g[i][j].second + 1 << " ";
}
}
cout << endl;
}
int main() {
cin >> n >> m >> k;
for (int i = 0; i < n; i++) {
int t, x, y;
cin >> t >> x >> y;
int idx = (x << 1) | y;
g[idx].push_back({t, i});
}
for (int i = 0; i < 4; i++) {
std::sort((g[i]).begin(), (g[i]).end());
}
Solve();
}
|
#include <bits/stdc++.h>
using namespace std;
const int md = 1000000007;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int tt{}, T{};
tt = 1;
while (tt--) {
long long n{}, m{}, k{}, a{}, b{}, c{}, f{}, p = -1, sum = 0;
long long ans{};
cin >> n >> k;
std::vector<long long> alice, bob, both;
for (long long i = 0; i < n; ++i) {
cin >> a >> b >> c;
if (b * c) {
both.push_back(a);
f += a;
} else if (b) {
alice.push_back(a);
} else if (c) {
bob.push_back(a);
} else {
p = max(a, p);
}
sum += a;
}
sort(both.begin(), both.end());
sort(alice.begin(), alice.end());
sort(bob.begin(), bob.end());
a = alice.size();
b = bob.size();
c = both.size();
if (k > c + min(a, b)) {
cout << "-1\n";
return 0;
}
for (int i = 0; i < min(a, b); ++i) {
both.push_back(alice[i] + bob[i]);
}
sort(both.begin(), both.end());
cout << accumulate(both.begin(), both.begin() + k, 0LL) << "\n";
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int i, n, k, alike, blike, t, total = 0;
cin >> n >> k;
vector<int> a, b, coll;
for (i = 0; i < n; i++) {
cin >> t >> alike >> blike;
if (alike) {
if (blike)
coll.push_back(t);
else
a.push_back(t);
} else if (blike)
b.push_back(t);
}
sort(a.begin(), a.end());
sort(b.begin(), b.end());
for (i = 0; i < min(a.size(), b.size()); i++) coll.push_back(a[i] + b[i]);
if (k > coll.size())
cout << -1;
else {
sort(coll.begin(), coll.end());
for (i = 0; i < k; i++) total += coll[i];
cout << total;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
struct BookInfo {
int t;
int a;
int b;
int i;
};
struct CombinedBook {
int t;
BookInfo b1;
BookInfo b2;
bool isCombined;
};
int main() {
ios_base::sync_with_stdio(0);
cout << fixed << setprecision(10);
cerr << fixed << setprecision(10);
cin.tie(0);
int n, k;
cin >> n >> k;
vector<BookInfo> allBooks;
int aliceLikes = 0;
int bobLikes = 0;
for (int i = 0; i < n; i++) {
BookInfo info;
cin >> info.t >> info.a >> info.b;
info.i = i + 1;
if (info.a) {
aliceLikes++;
}
if (info.b) {
bobLikes++;
}
allBooks.push_back(info);
}
if (aliceLikes < k || bobLikes < k) {
cout << -1 << endl;
return 0;
}
sort(allBooks.begin(), allBooks.end(),
[](const BookInfo &a, const BookInfo &b) -> bool { return a.t < b.t; });
vector<BookInfo> aliceBooks;
vector<BookInfo> bobBooks;
vector<CombinedBook> combined;
vector<BookInfo> other;
for (BookInfo &book : allBooks) {
if (book.a && book.b) {
CombinedBook item;
item.t = book.t;
item.b1 = book;
item.b2 = book;
item.isCombined = false;
combined.push_back(item);
} else if (!book.a && !book.b) {
other.push_back(book);
} else if (book.a) {
aliceBooks.push_back(book);
} else if (book.b) {
bobBooks.push_back(book);
}
}
for (int i = 0; i < n; i++) {
if (i < aliceBooks.size() && i < bobBooks.size()) {
CombinedBook item;
item.isCombined = true;
item.b1 = aliceBooks[i];
item.b2 = bobBooks[i];
item.t = item.b1.t + item.b2.t;
combined.push_back(item);
} else if (i < aliceBooks.size()) {
other.push_back(aliceBooks[i]);
} else if (i < bobBooks.size()) {
other.push_back(bobBooks[i]);
}
}
if (combined.size() < k) {
cout << -1 << endl;
return 0;
}
sort(combined.begin(), combined.end(),
[](const CombinedBook &a, const CombinedBook &b) -> bool {
return a.t < b.t;
});
vector<int> result;
int sum = 0;
int leftLikes = k;
for (int i = 0; i < k; i++) {
sum += combined[i].t;
}
cout << sum << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long MOD = 1000000007;
const long long PI = 3.14159265358979;
const long long INF = 1000000000000000000;
bool sortbysec(pair<long long, long long> a, pair<long long, long long> b) {
return (a.second < b.second);
}
long long powerMod(long long a, long long b, long long M) {
long long res = 1;
a = a % M;
while (b) {
if (b % 2) res = (res * a) % M;
b /= 2;
a = (a * a) % M;
}
return res;
}
long long power(long long a, long long b) {
long long res = 1;
while (b) {
if (b % 2) res = (res * a);
b /= 2;
a = (a * a);
}
return res;
}
long long modInverse(long long n, long long M) { return powerMod(n, M - 2, M); }
long long nCrModPFermat(long long n, long long r, long long M) {
if (!r) return 1;
long long fac[n + 1];
fac[0] = 1;
for (long long i = 1; i < n + 1; i++) {
fac[i] = fac[i - 1] * i % M;
}
return (fac[n] * modInverse(fac[r], M) % M * modInverse(fac[n - r], M) % M) %
M;
}
long double logABaseB(long long a, long long b) {
return (long double)((long double)log(a) / (long double)log(b));
}
struct bookDet {
long long t, a, b;
};
bool comp(bookDet b1, bookDet b2) { return b1.t < b2.t; }
int32_t main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
cout << fixed;
cout.precision(15);
long long t = 1;
while (t--) {
long long n, k;
cin >> n >> k;
vector<bookDet> books;
for (long long i = 0; i < n; i++) {
books.emplace_back(bookDet());
cin >> books[i].t >> books[i].a >> books[i].b;
}
vector<bookDet> both, ali, bob, none;
for (long long i = 0; i < n; i++) {
if (books[i].a == 1 && books[i].b == 1) {
both.emplace_back(books[i]);
} else if (books[i].a == 1 && books[i].b == 0) {
ali.emplace_back(books[i]);
}
if (books[i].a == 0 && books[i].b == 1) {
bob.emplace_back(books[i]);
}
if (books[i].a == 0 && books[i].b == 0) {
none.emplace_back(books[i]);
}
}
sort(both.begin(), both.end(), comp);
sort(none.begin(), none.end(), comp);
sort(ali.begin(), ali.end(), comp);
sort(bob.begin(), bob.end(), comp);
long long ans = 0;
auto bothP = both.begin(), aliP = ali.begin(), bobP = bob.begin();
while (k && aliP != ali.end() && bobP != bob.end() && bothP != both.end()) {
if ((*aliP).t + (*bobP).t < (*bothP).t) {
ans += ((*aliP).t + (*bobP).t);
aliP++;
bobP++;
k--;
} else {
ans += (*bothP).t;
bothP++;
k--;
}
}
if (!k) {
cout << ans << endl;
} else {
if (aliP != ali.end() && bobP != bob.end()) {
while (k && aliP != ali.end() && bobP != bob.end()) {
ans += (*aliP).t;
ans += (*bobP).t;
aliP++;
bobP++;
k--;
}
if (k) {
cout << -1 << endl;
}
} else {
if (bothP == both.end() || both.end() - bothP < k) {
cout << -1 << endl;
} else {
while (k) {
ans += (*bothP).t;
bothP++;
k--;
}
}
}
if (!k) cout << ans << endl;
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int32_t main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
;
long long n, k;
cin >> n >> k;
vector<long long> a;
vector<long long> b;
vector<long long> same;
for (long long i = 0; i < n; i++) {
long long t, x, y;
cin >> t >> x >> y;
if (x == 1 && y == 1)
same.push_back(t);
else if (x == 1)
a.push_back(t);
else if (y == 1)
b.push_back(t);
}
sort(a.begin(), a.end());
sort(b.begin(), b.end());
sort(same.begin(), same.end());
long long a_n = (long long)a.size();
long long b_n = (long long)b.size();
long long same_n = (long long)same.size();
if ((same_n + a_n < k) || (same_n + b_n < k)) {
cout << -1 << endl;
} else {
long long cnt = 0, ans = 0, i = 0, j = 0;
while (cnt < k) {
if (i < same_n && j < a_n && j < b_n && same[i] < (a[j] + b[j])) {
cnt++;
ans += same[i];
i++;
} else if (j < a_n && j < b_n) {
cnt++;
ans += (a[j] + b[j]);
j++;
} else
break;
}
if (cnt < k) {
if (i < same_n) {
while (i < same_n && cnt < k) {
cnt++;
ans += same[i];
i++;
}
} else {
while (j < a_n && j < b_n && cnt < k) {
cnt++;
ans += (a[j] + b[j]);
j++;
}
}
}
cout << ans << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <class T>
void Output(const T& v, bool print_new_line = true) {
bool first = true;
for (auto element : v) {
if (!first)
cout << " ";
else
first = false;
cout << element;
}
if (print_new_line) cout << endl;
}
template <class T>
void Input(vector<T>& v, int n) {
v.resize(n);
for (int i = 0; i < n; ++i) {
cin >> v[i];
}
}
template <class T>
vector<int> Query(const T& c, int answer_counts) {
cout << "? " << c.size();
for (auto it = c.begin(); it != c.end(); ++it) {
cout << " " << (*it);
}
cout << endl;
cout.flush();
vector<int> s(answer_counts);
for (int i = 0; i < answer_counts; ++i) {
cin >> s[i];
}
return s;
}
inline int get(int k, const vector<int>& v) {
if (k <= 0) return 0;
return v[k - 1];
}
struct Book {
int t, a, b, id;
};
struct compare {
bool operator()(const Book& a, const Book& b) {
return a.t < b.t || (a.t == b.t && a.id < b.id);
}
};
int init(int k, int m, int both, vector<vector<list<Book>>> bs,
set<Book, compare>& a, set<Book, compare>& b,
set<Book, compare>& rest) {
a.clear();
b.clear();
rest.clear();
int total = 0;
while ((int)a.size() < k - both && !bs[1][0].empty()) {
total += bs[1][0].front().t;
a.insert(bs[1][0].front());
bs[1][0].pop_front();
}
while ((int)b.size() < k - both && !bs[0][1].empty()) {
total += bs[0][1].front().t;
b.insert(bs[0][1].front());
bs[0][1].pop_front();
}
std::copy(bs[1][0].begin(), bs[1][0].end(), inserter(rest, rest.begin()));
std::copy(bs[0][1].begin(), bs[0][1].end(), inserter(rest, rest.begin()));
std::copy(bs[0][0].begin(), bs[0][0].end(), inserter(rest, rest.begin()));
while (rest.size() > 0 &&
(int)(rest.size() + a.size() + b.size()) > m - both) {
auto it = rest.end();
--it;
rest.erase(it);
}
return total + std::accumulate(rest.begin(), rest.end(), 0,
[](int v, const Book& b) { return v + b.t; });
}
int main() {
int n, m, k;
cin >> n >> m >> k;
vector<Book> books(n);
for (int i = 0; i < n; ++i) {
cin >> books[i].t >> books[i].a >> books[i].b;
books[i].id = i + 1;
}
sort(books.begin(), books.end(),
[](const Book& a, const Book& b) { return a.t < b.t; });
vector<vector<list<Book>>> bs(2);
bs[0].resize(2);
bs[1].resize(2);
for (int i = 0; i < n; ++i) {
bs[books[i].a][books[i].b].push_back(books[i]);
}
int best = 0x7FFFFFFF;
int best_i = -1;
bool inited = false;
int idx[2][2] = {0};
set<Book, compare> both, a, b, rest;
int total = 0;
auto iter = bs[1][1].begin();
set<Book, compare> rest_no;
for (int i = 0; i <= bs[1][1].size() && i <= m; ++i) {
if (!inited) {
total = init(k, m, i, bs, a, b, rest);
for (auto book : bs[0][0]) {
if (rest.find(book) == rest.end()) {
rest_no.insert(book);
}
}
inited = true;
}
while ((int)a.size() > k - i && !a.empty()) {
auto it = a.end();
--it;
rest.insert(*it);
a.erase(it);
}
while ((int)b.size() > k - i && !b.empty()) {
auto it = b.end();
--it;
rest.insert(*it);
b.erase(it);
}
while ((int)(rest.size() + a.size() + b.size()) > m - i && !rest.empty()) {
auto it = rest.end();
--it;
total -= it->t;
rest_no.insert(*it);
rest.erase(it);
}
while (!rest_no.empty() && !rest.empty() &&
rest.rbegin()->t > rest_no.begin()->t) {
auto it = rest.end();
--it;
total -= it->t;
rest.erase(it);
rest.insert(*rest_no.begin());
total += rest_no.begin()->t;
rest_no.erase(rest_no.begin());
}
if ((int)a.size() >= k - i && (int)b.size() >= k - i &&
(int)(a.size() + b.size() + rest.size()) == m - i) {
if (total < best) {
best = total;
best_i = i;
}
}
if (iter != bs[1][1].end()) {
total += iter->t;
++iter;
}
}
if (best_i == -1) {
cout << -1 << endl;
return 0;
}
cout << best << endl;
init(k, m, best_i, bs, a, b, rest);
iter = bs[1][1].begin();
while (best_i-- > 0) {
cout << iter->id << " ";
++iter;
}
std::for_each(a.begin(), a.end(), [](const Book& v) { cout << v.id << " "; });
std::for_each(b.begin(), b.end(), [](const Book& v) { cout << v.id << " "; });
std::for_each(rest.begin(), rest.end(),
[](const Book& v) { cout << v.id << " "; });
cout << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
deque<long long> v11, v10, v01;
signed main() {
ios::sync_with_stdio(0);
cin.tie(0);
long long n, k;
cin >> n >> k;
for (long long i = 0; i < n; i++) {
long long a, b, c;
cin >> a >> b >> c;
if (b == 1 && c == 1)
v11.emplace_back(a);
else if (b == 1 && c == 0)
v10.emplace_back(a);
else if (b == 0 && c == 1)
v01.emplace_back(a);
}
sort(v11.begin(), v11.end());
sort(v10.begin(), v10.end());
sort(v01.begin(), v01.end());
priority_queue<long long> pq;
long long ans = 0;
long long nk = k;
for (long long i = 0; i < min(k, (long long)min(v10.size(), v01.size()));
i++) {
pq.emplace(v10[i] + v01[i]);
ans += v10[i] + v01[i];
nk--;
}
while (v11.size() && nk) {
nk--;
ans += v11[0];
v11.pop_front();
}
if (nk) {
cout << -1 << endl;
return 0;
}
while (pq.size() && v11.size()) {
if (v11[0] < pq.top()) {
ans -= pq.top();
ans += v11[0];
v11.pop_front();
pq.pop();
} else
break;
}
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 2e5 + 5;
int stack_A[MAXN];
int stack_B[MAXN];
int stack_AB[MAXN];
int main() {
ios ::sync_with_stdio(false);
cin.tie(0);
int n, k;
cin >> n >> k;
int a_cnt = 0;
int b_cnt = 0;
int ab_cnt = 0;
int x, y, z;
for (int i = 0; i < n; ++i) {
cin >> x >> y >> z;
if (y & z) {
stack_AB[ab_cnt] = x;
ab_cnt += 1;
} else if (y) {
stack_A[a_cnt] = x;
a_cnt += 1;
} else if (z) {
stack_B[b_cnt] = x;
b_cnt += 1;
}
}
if (a_cnt + ab_cnt < k || b_cnt + ab_cnt < k) {
cout << -1 << endl;
return 0;
}
sort(stack_A, stack_A + a_cnt);
sort(stack_B, stack_B + b_cnt);
sort(stack_AB, stack_AB + ab_cnt);
int a = 0;
int b = 0;
int ab = 0;
int a_k = 0;
int b_k = 0;
int ans = 0;
while (!(a_k >= k && b_k >= k)) {
if (a < a_cnt && b < b_cnt && ab < ab_cnt) {
if (a_k < k && b_k < k) {
if (stack_AB[ab] <= stack_A[a] + stack_B[b]) {
ans += stack_AB[ab];
ab += 1;
} else {
ans += stack_A[a] + stack_B[b];
a += 1;
b += 1;
}
a_k += 1;
b_k += 1;
} else if (a_k < k) {
if (stack_A[a] <= stack_AB[ab]) {
ans += stack_A[a];
a += 1;
a_k += 1;
} else {
ans += stack_AB[ab];
ab += 1;
a_k += 1;
b_k += 1;
}
} else if (b_k < k) {
if (stack_B[b] <= stack_AB[ab]) {
ans += stack_B[b];
b += 1;
b_k += 1;
} else {
ans += stack_AB[ab];
ab += 1;
a_k += 1;
b_k += 1;
}
}
} else if (a < a_cnt && b < b_cnt) {
if (a_k < k && b_k < k) {
ans += stack_A[a] + stack_B[b];
a += 1;
b += 1;
a_k += 1;
b_k += 1;
} else if (a_k < k) {
ans += stack_A[a];
a += 1;
a_k += 1;
} else if (b_k < k) {
ans += stack_B[b];
b += 1;
b_k += 1;
}
} else if (a < a_cnt && ab < ab_cnt) {
if (a_k < k && b_k >= k && stack_A[a] <= stack_AB[ab]) {
ans += stack_A[a];
a += 1;
a_k += 1;
} else {
ans += stack_AB[ab];
ab += 1;
a_k += 1;
b_k += 1;
}
} else if (b < b_cnt && ab < ab_cnt) {
if (b_k < k && a_k >= k && stack_B[b] <= stack_AB[ab]) {
ans += stack_B[b];
b += 1;
b_k += 1;
} else {
ans += stack_AB[ab];
ab += 1;
a_k += 1;
b_k += 1;
}
} else if (ab < ab_cnt) {
ans += stack_AB[ab];
ab += 1;
a_k += 1;
b_k += 1;
} else if (a < a_cnt) {
ans += stack_A[a];
a += 1;
a_k += 1;
} else if (b < b_cnt) {
ans += stack_B[b];
b += 1;
b_k += 1;
}
}
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long mod = 998244353;
const int maxn = 1e6 + 10;
const double eps = 1e-9;
const long long inf = 1e18;
int T;
int n, m, k;
vector<long long> vec[5];
long long a, b, t;
int main() {
scanf("%d%d", &n, &k);
for (int i = 1; i <= n; i++) {
scanf("%lld%lld%lld", &t, &a, &b);
if (a && b)
vec[1].push_back(t);
else if (a && !b)
vec[2].push_back(t);
else if (!a && b)
vec[3].push_back(t);
else
vec[4].push_back(t);
}
for (int i = 1; i <= 4; i++) sort(vec[i].begin(), vec[i].end());
int flag = 1;
a = b = 0;
int l1 = vec[1].size(), l2 = min(vec[2].size(), vec[3].size());
long long ans = 0;
for (int i = 1; i <= k; i++) {
if (l1 == a && l2 == b) {
flag = 0;
break;
}
if (l1 == a || (l2 != b && vec[1][a] >= vec[2][b] + vec[3][b])) {
ans += vec[2][b] + vec[3][b];
b++;
} else {
ans += vec[1][a];
a++;
}
}
if (flag)
printf("%lld\n", ans);
else
printf("-1\n");
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;
}
while (cc) {
bool ok = 0;
lint t1 = INT_MAX;
if (abra.size()) {
t1 = abra.top();
ok = 1;
}
lint t2 = INT_MAX;
if (cadabra.size()) {
t2 = cadabra.top();
ok = 1;
}
assert(ok == true);
if (t1 <= t2) {
ret += t1;
abra.pop();
} else {
ret += t2;
cadabra.pop();
}
cc -= 1;
}
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;
int main() {
int n, k, t, a, b;
long long ans = 0;
priority_queue<int, vector<int>, greater<int>> book[3];
scanf("%d%d", &n, &k);
while (n--) {
scanf("%d%d%d", &t, &a, &b);
if (a && b)
book[0].push(t);
else if (a)
book[1].push(t);
else if (b)
book[2].push(t);
}
if (book[0].size() + book[1].size() < k ||
book[0].size() + book[2].size() < k)
printf("-1\n");
else {
while (!book[0].empty() && k--)
if (book[1].empty() || book[2].empty() ||
book[0].top() <= book[1].top() + book[2].top()) {
ans += book[0].top();
book[0].pop();
} else {
ans += book[1].top() + book[2].top();
book[1].pop();
book[2].pop();
}
while ((k--) > 0) {
ans += book[1].top() + book[2].top();
book[1].pop();
book[2].pop();
}
printf("%lld\n", ans);
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int kMaxN = 200001;
struct E {
int i, t;
bool operator<(const E &e) const { return t < e.t; }
bool operator>(const E &e) const { return t > e.t; }
} e[4][kMaxN];
bool s[kMaxN];
int c[4];
int n, m, k, x, a, b, ans, sum, tot, p;
priority_queue<E> bh;
priority_queue<E, vector<E>, greater<E> > sh;
void Make(int st) {
fill_n(s, n + 1, 0);
bh = priority_queue<E>();
sh = priority_queue<E, vector<E>, greater<E> >();
sum = 0, tot = 0;
for (int i = 1; i <= st; i++, tot++) {
sum += e[3][i].t;
s[e[3][i].i] = 1;
}
for (int i = 1; i <= k - st; i++, tot += 2) {
sum += e[1][i].t + e[2][i].t;
s[e[1][i].i] = s[e[2][i].i] = 1;
}
for (int i = 1; i <= c[0]; i++) {
sh.push(e[0][i]);
}
for (int j = 1; j <= 2; j++) {
for (int i = max(1, k - st + 1); i <= c[j]; i++) {
sh.push(e[j][i]);
}
}
for (; tot < m; tot++) {
sum += sh.top().t;
s[sh.top().i] = 1;
bh.push(sh.top());
sh.pop();
}
ans = sum;
p = st;
}
bool Find() {
int st = max(k - min(c[1], c[2]), 0);
st = max(st, m - c[0] - c[1] - c[2]);
st = max(st, 2 * k - m);
if (st > c[3] || st > m) {
return 0;
}
Make(st);
for (int i = st; i < min(c[3], m); i++) {
sum += e[3][i + 1].t;
s[e[3][i + 1].i] = 1;
tot++;
for (int j = 1; j <= 2; j++) {
if (i < k) {
sum -= e[j][k - i].t;
s[e[j][k - i].i] = 0;
sh.push(e[j][k - i]);
tot--;
}
}
while (!bh.empty() && !sh.empty() && bh.top() > sh.top()) {
sum += sh.top().t - bh.top().t;
s[sh.top().i] = 1;
s[bh.top().i] = 0;
sh.push(bh.top());
bh.push(sh.top());
sh.pop();
bh.pop();
}
for (; tot < m; tot++) {
sum += sh.top().t;
s[sh.top().i] = 1;
bh.push(sh.top());
sh.pop();
}
for (; tot > m; tot--) {
sum -= bh.top().t;
s[bh.top().i] = 0;
sh.push(bh.top());
bh.pop();
}
if (sum < ans) {
ans = sum;
p = i + 1;
}
}
return 1;
}
int main() {
cin >> n >> m >> k;
for (int i = 1; i <= n; i++) {
cin >> x >> a >> b;
a |= b * 2;
e[a][++c[a]] = {i, x};
}
for (int i = 0; i <= 3; i++) {
sort(e[i] + 1, e[i] + 1 + c[i]);
}
if (Find()) {
cout << ans << endl;
Make(p);
for (int i = 1; i <= n; i++) {
if (s[i]) {
cout << i << " ";
}
}
} else {
cout << -1;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
long long int n, k, t, a, b;
cin >> n >> k;
vector<long long int> time, alice, bob, both;
for (long long 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);
}
}
if (alice.size() + both.size() < k || bob.size() + both.size() < k) {
cout << "-1\n";
return 0;
}
sort(alice.begin(), alice.end());
sort(bob.begin(), bob.end());
sort(both.begin(), both.end());
long long int i_a = 0, i_b = 0, idx = 0, cost = 0;
while (true) {
if (i_a < alice.size() && i_b < bob.size()) {
if (idx < both.size()) {
if (alice[i_a] + bob[i_b] <= both[idx]) {
cost += (alice[i_a] + bob[i_b]);
i_a++;
i_b++;
} else {
cost += both[idx];
idx++;
}
} else {
cost += (alice[i_a] + bob[i_b]);
i_a++;
i_b++;
}
} else {
cost += both[idx];
idx++;
}
if ((i_a == k - idx) && (i_b == k - idx)) {
break;
}
}
cout << cost;
}
|
#include <bits/stdc++.h>
using namespace std;
long long n, k;
int main() {
scanf("%lld%lld", &n, &k);
vector<long long> v, ali, bob;
for (int i = 0; i < n; i++) {
long long t, x, y;
scanf("%lld%lld%lld", &t, &x, &y);
if (x == 1 && y == 1)
v.push_back(t);
else if (x == 1 && y == 0)
ali.push_back(t);
else if (x == 0 && y == 1)
bob.push_back(t);
}
sort(ali.begin(), ali.end());
sort(bob.begin(), bob.end());
long long mn = min(ali.size(), bob.size());
for (int i = 0; i < mn; i++) v.push_back(ali[i] + bob[i]);
sort(v.begin(), v.end());
if (v.size() < k)
printf("-1\n");
else {
long long ans = 0;
for (int i = 0; i < k; i++) ans += v[i];
printf("%lld", ans);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int n, k;
cin >> n >> k;
vector<long long> a, b, ab;
int count_a = 0, count_b = 0;
for (int i = 0; i < n; i++) {
int t;
bool b1, b2;
cin >> t >> b1 >> b2;
if (b1 && b2) {
ab.push_back(t);
count_a++;
count_b++;
} else if (b1) {
a.push_back(t);
count_a++;
} else if (b2) {
b.push_back(t);
count_b++;
}
}
if (count_a < k || count_b < k) {
cout << -1 << endl;
} else {
sort(a.begin(), a.end());
sort(b.begin(), b.end());
sort(ab.begin(), ab.end());
int na = a.size(), nb = b.size(), nab = ab.size();
for (int i = 1; i < na; i++) {
a[i] += a[i - 1];
}
for (int i = 1; i < nb; i++) {
b[i] += b[i - 1];
}
for (int i = 1; i < nab; i++) {
ab[i] += ab[i - 1];
}
int x = min(k, nab);
long long min_time = LONG_LONG_MAX;
for (int i = 0; i <= x; i++) {
if (k - i <= min(na, nb)) {
if (i > 0 && i < k) {
min_time = min(min_time, ab[i - 1] + a[k - i - 1] + b[k - i - 1]);
} else if (i == 0) {
min_time = min(min_time, a[k - 1] + b[k - 1]);
} else {
min_time = min(min_time, ab[k - 1]);
}
}
}
cout << min_time << endl;
}
}
|
#include <bits/stdc++.h>
using namespace std;
int32_t main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
long long n, k;
cin >> n >> k;
long long t[n], a[n], b[n];
vector<long long> ali, bob, both;
for (long long i = 0; i < n; i++) {
cin >> t[i] >> a[i] >> b[i];
if (a[i] == 1 && b[i] == 1) both.push_back(t[i]);
if (a[i] == 1 && b[i] == 0) ali.push_back(t[i]);
if (a[i] == 0 && b[i] == 1) bob.push_back(t[i]);
}
sort(ali.begin(), ali.end());
sort(bob.begin(), bob.end());
sort(both.begin(), both.end());
long long mini = 1000000000000;
long long x = both.size();
long long y = ali.size();
long long z = bob.size();
long long m = max(k - z, k - y);
if (x + y < k || x + z < k)
cout << "-1\n";
else {
for (long long i = max(m, 0ll); i <= min(x, k); i++) {
long long sum = 0;
for (long long j = 0; j < i; j++) {
sum += both[j];
}
for (long long j = 0; j < k - i; j++) {
sum += ali[j];
sum += bob[j];
}
mini = min(mini, sum);
}
cout << mini << "\n";
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 200100;
int n, m, k, sa, sb, ans = 2e9 + 10000, calc, x, ty, sz1, res[N], tim;
struct item {
int t, a, b;
} a[N];
vector<pair<int, int> > b[4];
priority_queue<pair<int, int> > s, t;
bool cmp(pair<int, int> a, pair<int, int> b) { return a.first < b.first; }
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> n >> m >> k;
a[0].t = 0;
for (int i = 1; i <= n; i++) {
cin >> a[i].t >> a[i].a >> a[i].b;
sa += a[i].a;
sb += a[i].b;
if (a[i].a + a[i].b == 2)
b[2].push_back({a[i].t, i});
else if (a[i].a == 1)
b[0].push_back({a[i].t, i});
else if (a[i].b == 1)
b[1].push_back({a[i].t, i});
else
b[3].push_back({a[i].t, i});
}
if (min(sa, sb) < k) {
cout << -1;
return 0;
}
sort(b[0].begin(), b[0].end(), &cmp);
sort(b[1].begin(), b[1].end(), &cmp);
sort(b[2].begin(), b[2].end(), &cmp);
sort(b[3].begin(), b[3].end(), &cmp);
sa = sb = 0;
sz1 = 0;
for (int i = 0; i < b[0].size(); i++)
if (i < k)
sa += b[0][i].first, sz1++;
else
sb += b[0][i].first, s.push({b[0][i].first, i});
for (int i = 0; i < b[1].size(); i++)
if (i < k)
sa += b[1][i].first, sz1++;
else
sb += b[1][i].first, s.push({b[1][i].first, i + n});
for (int i = 0; i < b[3].size(); i++)
sb += b[3][i].first, s.push({b[3][i].first, i + 3 * n});
while (!s.empty() && s.size() + sz1 > m) {
x = s.top().second;
s.pop();
ty = x / n;
x %= n;
sb -= b[ty][x].first;
t.push({-b[ty][x].first, x + ty * n});
}
for (int i = 0; i <= b[2].size(); i++) {
if (i + min(b[0].size(), b[1].size()) >= k && max(i, 2 * k - i) <= m &&
s.size() + sz1 == m && ans > sa + sb)
ans = sa + sb, tim = i;
if (!t.empty()) {
x = t.top().second;
t.pop();
ty = x / n;
x %= n;
sb += b[ty][x].first;
s.push({b[ty][x].first, x + ty * n});
}
if (k - i > 0 && k - i <= b[0].size())
sz1--, sa -= b[0][k - i - 1].first, sb += b[0][k - i - 1].first,
s.push({b[0][k - i - 1].first, k - i - 1});
if (k - i > 0 && k - i <= b[1].size())
sz1--, sa -= b[1][k - i - 1].first, sb += b[1][k - i - 1].first,
s.push({b[1][k - i - 1].first, k - i - 1 + n});
if (i < b[2].size()) sz1++, sa += b[2][i].first;
while (!s.empty() && s.size() + sz1 > m) {
x = s.top().second;
s.pop();
ty = x / n;
x %= n;
sb -= b[ty][x].first;
t.push({-b[ty][x].first, x + ty * n});
}
}
while (!s.empty()) s.pop();
while (!t.empty()) t.pop();
sa = sb = 0;
sz1 = 0;
for (int i = 0; i < b[0].size(); i++)
if (i < k)
sa += b[0][i].first, sz1++;
else
sb += b[0][i].first, s.push({b[0][i].first, i});
for (int i = 0; i < b[1].size(); i++)
if (i < k)
sa += b[1][i].first, sz1++;
else
sb += b[1][i].first, s.push({b[1][i].first, i + n});
for (int i = 0; i < b[3].size(); i++)
sb += b[3][i].first, s.push({b[3][i].first, i + 3 * n});
while (!s.empty() && s.size() + sz1 > m) {
x = s.top().second;
s.pop();
ty = x / n;
x %= n;
sb -= b[ty][x].first;
t.push({-b[ty][x].first, x + ty * n});
}
for (int i = 0; i <= b[2].size(); i++) {
if (i == tim) {
for (int j = 1; j <= i; j++) res[b[2][j - 1].second] = 1;
for (int j = 1; j <= min(k - i, int(b[0].size())); j++)
res[b[0][j - 1].second] = 1;
for (int j = 1; j <= min(k - i, int(b[1].size())); j++)
res[b[1][j - 1].second] = 1;
while (!s.empty()) {
x = s.top().second;
s.pop();
ty = x / n;
x %= n;
res[b[ty][x].second] = 1;
}
break;
}
if (!t.empty()) {
x = t.top().second;
t.pop();
ty = x / n;
x %= n;
sb += b[ty][x].first;
s.push({b[ty][x].first, x + ty * n});
}
if (k - i > 0 && k - i <= b[0].size())
sz1--, sa -= b[0][k - i - 1].first, sb += b[0][k - i - 1].first,
s.push({b[0][k - i - 1].first, k - i - 1});
if (k - i > 0 && k - i <= b[1].size())
sz1--, sa -= b[1][k - i - 1].first, sb += b[1][k - i - 1].first,
s.push({b[1][k - i - 1].first, k - i - 1 + n});
if (i < b[2].size()) sz1++, sa += b[2][i].first;
while (!s.empty() && s.size() + sz1 > m) {
x = s.top().second;
s.pop();
ty = x / n;
x %= n;
sb -= b[ty][x].first;
t.push({-b[ty][x].first, x + ty * n});
}
}
if (ans > 2e9) {
cout << -1;
return 0;
}
cout << ans << endl;
for (int i = 1; i <= n; i++)
if (res[i]) cout << i << " ";
}
|
#include <bits/stdc++.h>
using namespace std;
int gcd(int a, int b) {
if (b == 0) return a;
return gcd(b, a % b);
}
int isPrime(int n) {
if (n < 2) return 0;
if (n < 4) return 1;
if (n % 2 == 0 or n % 3 == 0) return 0;
for (int i = 5; i * i <= n; i += 6)
if (n % i == 0 or n % (i + 2) == 0) return 0;
return 1;
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
;
int64_t n, i, k;
int64_t ans = 0;
cin >> n >> k;
vector<int64_t> a, b, c;
for (i = 0; i < n; i++) {
int64_t t1, t2, t3;
cin >> t1 >> t2 >> t3;
if (t3 and t2) {
c.push_back(t1);
} else if (t2) {
a.push_back(t1);
} else if (t3) {
b.push_back(t1);
}
}
sort(a.begin(), a.end());
sort(b.begin(), b.end());
sort(c.begin(), c.end());
if ((a.size() + c.size()) < k or (b.size() + c.size()) < k) {
cout << -1 << "\n";
return 0;
}
if (a.size() >= k and b.size() >= k) {
int64_t ind = 0, j = 0;
for (i = 0; i < k; i++) {
ans = ans + a[i] + b[i];
}
int64_t temp = ans;
for (i = 0; i < min(k, (int64_t)c.size()); i++) {
temp = temp - a[k - i - 1] - b[k - i - 1];
temp = temp + c[i];
ans = min(ans, temp);
}
cout << ans << "\n";
} else {
int64_t ind = min(a.size(), b.size());
for (i = 0; i < ind; i++) {
ans = ans + a[i] + b[i];
}
for (i = 0; i < k - ind; i++) {
ans += c[i];
}
int64_t temp = ans;
for (i = k - ind; i < min(k, (int64_t)c.size()); i++) {
temp = temp - a[ind - (i - k + ind) - 1] - b[ind - (i - k + ind) - 1];
temp = temp + c[i];
ans = min(ans, temp);
}
cout << ans << "\n";
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long INF = 1e9;
const long long INFF = 1e18;
const long long MAXN = 510;
const long long MOD = 1e9 + 7;
const double PI = acos(-1.0);
const double INFD = 1E9;
const double EPS = 1e-9;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
long long n, k;
cin >> n >> k;
deque<long long> onlyA, onlyB, both;
for (long long i = 1; i <= n; i++) {
long long val, a, b;
cin >> val >> a >> b;
if (a && b)
both.push_back(val);
else if (a)
onlyA.push_back(val);
else if (b)
onlyB.push_back(val);
}
sort(onlyA.begin(), onlyA.end());
sort(onlyB.begin(), onlyB.end());
sort(both.begin(), both.end());
long long takeA = onlyA.size();
long long takeB = onlyB.size();
long long harus = 0;
long long ans = 0;
while (takeA < k && !both.empty()) {
long long cur = both.front();
both.pop_front();
++takeA;
++takeB;
++harus;
ans += cur;
}
while (takeB < k && !both.empty()) {
long long cur = both.front();
both.pop_front();
++takeA;
++takeB;
++harus;
ans += cur;
}
if (takeA < k || takeB < k)
cout << -1 << endl;
else {
while (onlyA.size() > max(0ll, k - harus)) onlyA.pop_back();
while (onlyB.size() > max(0ll, k - harus)) onlyB.pop_back();
for (auto it : onlyA) {
ans += it;
}
for (auto it : onlyB) {
ans += it;
}
for (auto it : both) {
if (onlyA.empty() || onlyB.empty()) break;
if (onlyA.back() + onlyB.back() > it) {
ans += it - (onlyA.back() + onlyB.back());
onlyA.pop_back();
onlyB.pop_back();
}
}
cout << ans << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
bool isrange(int second, int first, int n, int m) {
if (0 <= second && second < n && 0 <= first && first < m) return true;
return false;
}
int dy[4] = {1, 0, -1, 0}, dx[4] = {0, 1, 0, -1},
ddy[8] = {1, 0, -1, 0, 1, 1, -1, -1}, ddx[8] = {0, 1, 0, -1, 1, -1, 1, -1};
priority_queue<int> q[3];
int main(void) {
int n, k;
scanf("%d%d", &n, &k);
for (int e = 1; e <= n; e++) {
int t, a, b;
scanf("%d%d%d", &t, &a, &b);
if (a == 1 && b == 1)
q[2].push(-t);
else if (a == 1)
q[0].push(-t);
else if (b == 1)
q[1].push(-t);
}
long long int ans = 0;
for (int e = 0; e < k; e++) {
if ((int)q[0].size() == 0 || (int)q[1].size() == 0) {
if ((int)q[2].size() == 0) {
printf("-1");
return 0;
}
long long int tt = -q[2].top();
ans += tt;
q[2].pop();
} else {
long long int t1 = -q[0].top() - q[1].top();
if ((int)q[2].size() == 0) {
ans += t1;
q[0].pop();
q[1].pop();
} else {
long long int t2 = -q[2].top();
if (t1 > t2) {
ans += t2;
q[2].pop();
} else {
ans += t1;
q[0].pop();
q[1].pop();
}
}
}
}
printf("%lld", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <class T>
int size(const T& x) {
return x.size();
}
using namespace std;
void solve(int test_case) {
int n, k;
cin >> n >> k;
vector<int> tBoth, tAlice, tBob;
for (int i = 0; i < n; i++) {
int t, a, b;
cin >> t >> a >> b;
if (a == 1 && b == 1) tBoth.push_back(t);
if (a == 1 && b == 0) tAlice.push_back(t);
if (a == 0 && b == 1) tBob.push_back(t);
}
if (k > (tBoth.size() + tAlice.size()) ||
(k > (tBoth.size() + tBob.size()))) {
cout << -1 << endl;
return;
}
sort(begin(tBoth), end(tBoth));
sort(begin(tAlice), end(tAlice));
sort(begin(tBob), end(tBob));
int iboth = 0, isep = 0;
long long ret = 0, read = 0;
while (read < k) {
long long tbothcand = -1;
if (iboth < tBoth.size()) {
tbothcand = tBoth[iboth];
}
long long tsepcand = -1;
if (isep < min(tAlice.size(), tBob.size())) {
tsepcand = tAlice[isep] + tBob[isep];
}
if (tsepcand == -1 || (tbothcand != -1 && tbothcand < tsepcand)) {
ret += tbothcand;
iboth++;
read++;
} else {
ret += tsepcand;
isep++;
read++;
}
}
cout << ret << endl;
}
int main() {
int T = 1;
for (int test_case = 1; test_case <= T; test_case++) {
solve(test_case);
}
return 0;
}
|
#include <bits/stdc++.h>
#pragma GCC optimize("O3")
#pragma comment(linker, "/stack:200000000")
#pragma GCC optimize("unroll-loops")
using namespace std;
int main() {
ios::sync_with_stdio(0);
cin.tie(NULL);
cout.tie(NULL);
int n, k;
cin >> n >> k;
long long ans = 0;
int i, j, cnta = 0, cntb = 0, time = 0;
vector<int> veca, vecb, vec;
for (i = 0; i < n; i++) {
int t1, a1, b1;
cin >> t1 >> a1 >> b1;
cnta += a1;
cntb += b1;
time += t1;
if (a1 == 1 && b1 == 0) {
veca.push_back(t1);
} else if (a1 == 0 && b1 == 1) {
vecb.push_back(t1);
} else if (a1 == 1 && b1 == 1) {
vec.push_back(t1);
}
}
if (cnta < k || cntb < k) {
cout << -1 << "\n";
} else {
sort(veca.begin(), veca.end());
sort(vecb.begin(), vecb.end());
sort(vec.begin(), vec.end());
if (veca.size() == 0 && vecb.size() == 0) {
for (i = 0; i < vec.size(); i++) {
ans += vec[i];
if ((i + 1) == k) {
break;
}
}
} else if (vec.size() == 0) {
i = 0;
j = 0;
for (i = 0; i < veca.size(); i++) {
ans += veca[i];
if ((i + 1) == k) {
break;
}
}
for (i = 0; i < vecb.size(); i++) {
ans += vecb[i];
if (i + 1 == k) {
break;
}
}
} else if (veca.size() == 0 || vecb.size() == 0) {
for (i = 0; i < vec.size(); i++) {
ans += vec[i];
if ((i + 1) == k) {
break;
}
}
} else {
i = 0;
j = 0;
int r = 0, flag = 0;
while (i < veca.size() || j < vecb.size() || r < vec.size()) {
if (i < veca.size() && j < vecb.size() && r < vec.size()) {
if ((veca[i] + vecb[j]) < vec[r]) {
ans += (veca[i] + vecb[j]);
i++;
j++;
k--;
if (k == 0) {
flag = 1;
break;
}
} else {
ans += (vec[r]);
r++;
k--;
if (k == 0) {
flag = 1;
break;
}
}
} else if (i >= veca.size() || j >= vecb.size()) {
ans += vec[r];
r++;
k--;
if (k == 0) {
flag = 1;
break;
}
} else if (r >= vec.size()) {
ans += (veca[i] + vecb[j]);
k--;
i++;
j++;
if (k == 0) {
flag = 1;
break;
}
}
if (flag) {
break;
}
}
}
cout << ans << "\n";
}
return 0;
}
|
#include <bits/stdc++.h>
const long long INF = LLONG_MAX / 2;
const long long N = 2e5 + 1;
using namespace std;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
;
long long t;
t = 1;
while (t--) {
long long n, k;
std::cin >> n >> k;
long long sum = 0, pp = 0, i, ta[n], a[n], b[n], a1[n], j = 0, m = 0, l = 0,
b1[n], ab[n], ak = k, bk = k, j1 = 0, m1 = 0, l1 = 0;
for (long long i = 0; i < n; i++) {
std::cin >> ta[i] >> a[i] >> b[i];
if (a[i] == 1 && b[i] == 1)
ab[j++] = ta[i];
else if (a[i] == 1)
a1[m++] = ta[i];
else if (b[i] == 1)
b1[l++] = ta[i];
else
pp++;
}
if (l + j < k || m + j < k) {
cout << "-1\n";
continue;
}
if (j > 1) sort(ab, ab + j);
if (m > 1) sort(a1, a1 + m);
if (l > 1) sort(b1, b1 + l);
for (;;) {
if (ak == 0 || bk == 0) break;
if ((j1 >= j) || (m1 < m && l1 < l && a1[m1] + b1[l1] < ab[j1])) {
sum += a1[m1] + b1[l1];
ak--, bk--;
m1++, l1++;
} else {
sum += ab[j1];
ak--, bk--;
j1++;
}
if (ak == 0 || bk == 0) break;
}
cout << sum << "\n";
}
}
|
#include <bits/stdc++.h>
using namespace std;
signed main() {
ios::sync_with_stdio(0);
cin.tie(0);
long long n, k;
cin >> n >> k;
vector<long long> arr1, arr2, arr3;
for (long long i = 0; i < n; i++) {
long long t, a, b;
cin >> t >> a >> b;
if (a == 1 && b == 1) arr1.push_back(t);
if (a == 1 && b == 0) arr2.push_back(t);
if (a == 0 && b == 1) arr3.push_back(t);
}
sort(arr2.begin(), arr2.end());
sort(arr3.begin(), arr3.end());
for (long long i = 0; i < min(arr2.size(), arr3.size()); i++) {
arr1.push_back(arr2[i] + arr3[i]);
}
sort(arr1.begin(), arr1.end());
if (k > arr1.size())
cout << -1 << '\n';
else {
long long res = 0;
for (long long i = 0; i < k; i++) {
res += arr1[i];
}
cout << res << '\n';
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int NR = 4e5 + 10;
void Min(int& x, int y) { x = min(x, y); }
void Max(int& x, int y) { x = max(x, y); }
int read() {
int 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;
}
int n, m, k, mx;
struct PPP {
int x, id;
bool operator<(const PPP& A) const { return x < A.x; }
} xx[4][NR];
int a[4][NR], tt[4];
int id[4][NR];
int sum[4][NR];
bool Flag;
struct Segment {
int tr[NR], sz[NR];
void clear() {
memset(tr, 0, sizeof(tr));
memset(sz, 0, sizeof(sz));
}
void update(int rt) {
tr[rt] = tr[(rt << 1)] + tr[(rt << 1 | 1)],
sz[rt] = sz[(rt << 1)] + sz[(rt << 1 | 1)];
}
void change(int rt, int l, int r, int pos, int val) {
if (l == r) {
sz[rt] += val;
tr[rt] += val * pos;
return;
}
int mid = (l + r >> 1);
if (pos <= mid)
change((rt << 1), l, mid, pos, val);
else
change((rt << 1 | 1), mid + 1, r, pos, val);
update(rt);
}
int query(int rt, int l, int r, int x) {
if (sz[rt] < x) return -1;
if (l == r) return (sz[rt]) ? tr[rt] / sz[rt] * x : 0;
int mid = (l + r >> 1);
if (sz[(rt << 1)] > x)
return query((rt << 1), l, mid, x);
else
return query((rt << 1 | 1), mid + 1, r, x - sz[(rt << 1)]) +
tr[(rt << 1)];
}
} T;
int ans = 0x3f3f3f3f * 2, ansid;
int Ans[NR << 2], all;
struct Nd {
int x, d;
bool operator<(const Nd& A) const { return d < A.d; }
} b[NR << 2];
int tot;
Nd md(int x, int d) {
Nd tmp;
tmp.x = x, tmp.d = d;
return tmp;
}
int main() {
n = read(), m = read(), k = read();
for (int i = 1; i <= n; i++) {
int x = read(), p = read(), q = read();
xx[p * 2 + q][++tt[p * 2 + q]].x = x;
xx[p * 2 + q][tt[p * 2 + q]].id = i;
Max(mx, x);
}
for (int i = 0; i < 4; i++) sort(xx[i] + 1, xx[i] + tt[i] + 1);
for (int i = 0; i < 4; i++)
for (int j = 1; j <= tt[i]; j++) {
id[i][j] = xx[i][j].id;
a[i][j] = xx[i][j].x;
}
for (int t = 0; t < 4; t++)
for (int i = 1; i <= tt[t]; i++) T.change(1, 1, mx, a[t][i], 1);
for (int t = 0; t < 4; t++)
for (int i = 1; i <= tt[t]; i++) sum[t][i] = sum[t][i - 1] + a[t][i];
int num = min(tt[1], tt[2]);
if (num + tt[3] < k || tt[1] + tt[2] + tt[0] + tt[3] < m ||
min(k, tt[3]) + min(num, k - tt[3]) * 2 > m) {
puts("-1");
return 0;
}
num = k - min(k, tt[3]);
for (int i = 1; i <= num; i++)
for (int j = 1; j <= 2; j++) T.change(1, 1, mx, a[j][i], -1);
for (int i = 1; i <= min(k, tt[3]); i++) T.change(1, 1, mx, a[3][i], -1);
for (int i = min(k, tt[3]); i >= 0; i--) {
int sy = T.query(1, 1, mx, m - i - num * 2);
if (m < i + num * 2 || sy == -1) {
num++;
if (num > min(tt[1], tt[2])) break;
T.change(1, 1, mx, a[3][i], 1);
T.change(1, 1, mx, a[1][num], -1);
T.change(1, 1, mx, a[2][num], -1);
continue;
}
if (ans > sy + sum[3][i] + sum[1][num] + sum[2][num])
ans = sy + sum[3][i] + sum[1][num] + sum[2][num], ansid = i;
num++;
if (num > min(tt[1], tt[2])) break;
T.change(1, 1, mx, a[3][i], 1);
T.change(1, 1, mx, a[1][num], -1);
T.change(1, 1, mx, a[2][num], -1);
}
num = k - ansid;
for (int i = 1; i <= num; i++) Ans[++all] = id[1][i], Ans[++all] = id[2][i];
for (int i = 1; i <= ansid; i++) Ans[++all] = id[3][i];
for (int i = ansid + 1; i <= tt[3]; i++) b[++tot] = md(id[3][i], a[3][i]);
for (int i = num + 1; i <= tt[1]; i++) b[++tot] = md(id[1][i], a[1][i]);
for (int i = num + 1; i <= tt[2]; i++) b[++tot] = md(id[2][i], a[2][i]);
for (int i = 1; i <= tt[0]; i++) b[++tot] = md(id[0][i], a[0][i]);
sort(b + 1, b + tot + 1);
for (int i = 1; i <= m - ansid - num * 2; i++) Ans[++all] = b[i].x;
if (ans == 0x3f3f3f3f * 2) {
puts("-1");
return 0;
}
printf("%d\n", ans);
for (int i = 1; i <= all; i++) printf("%d ", Ans[i]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
void Ios() {
ios::sync_with_stdio(false);
cin.tie(0);
return;
}
constexpr int kN = int(2E5 + 10), kInf = int(2E9 + 10);
mt19937_64 rng;
struct Treap {
struct Node {
Node *l, *r;
int val, sz, sum;
long long int wei;
Node() {}
Node(int x) {
l = r = nullptr;
sz = 1;
val = sum = x;
wei = rng();
}
void pull() {
sz = 1;
sum = val;
if (l) {
sz += l->sz;
sum += l->sum;
}
if (r) {
sz += r->sz;
sum += r->sum;
}
return;
}
};
static int size(Node* u) { return u ? u->sz : 0; }
static int sum(Node* u) { return u ? u->sum : 0; }
static Node* Merge(Node* a, Node* b) {
if (!a) return b;
if (!b) return a;
if (a->wei > b->wei) {
a->r = Merge(a->r, b);
a->pull();
return a;
} else {
b->l = Merge(a, b->l);
b->pull();
return b;
}
}
static void Split_by_size(Node* s, int x, Node*& a, Node*& b) {
if (!s)
a = b = nullptr;
else if (size(s->l) + 1 <= x) {
a = s;
Split_by_size(s->r, x - (size(s->l) + 1), a->r, b);
a->pull();
} else {
b = s;
Split_by_size(s->l, x, a, b->l);
b->pull();
}
}
static void Split_by_val(Node* s, int x, Node*& a, Node*& b) {
if (!s)
a = b = nullptr;
else if (s->val <= x) {
a = s;
Split_by_val(s->r, x, a->r, b);
a->pull();
} else {
b = s;
Split_by_val(s->l, x, a, b->l);
b->pull();
}
}
Node* rt;
Treap() { rt = nullptr; }
void add(int x) {
Node *A, *B;
Split_by_val(rt, x, A, B);
rt = Merge(Merge(A, new Node(x)), B);
return;
}
int size() { return size(rt); }
int ask(int x) {
int ans;
Node *A, *B;
Split_by_size(rt, x, A, B);
ans = sum(A);
rt = Merge(A, B);
return ans;
}
};
Treap treap;
int t[kN], a[kN], b[kN];
int main() {
int n, m, k, ans = kInf, idab = -1;
vector<pair<int, int>> A, B, AB, O, V;
vector<int> the_set;
scanf("%d%d%d", &n, &m, &k);
for (int i = 1; i <= n; i++) scanf("%d%d%d", &t[i], &a[i], &b[i]);
for (int i = 1; i <= n; i++) {
if (a[i] && b[i])
AB.push_back(make_pair(t[i], i));
else if (a[i])
A.push_back(make_pair(t[i], i));
else if (b[i])
B.push_back(make_pair(t[i], i));
else
O.push_back(make_pair(t[i], i));
}
int asz = int(A.size()), bsz = int(B.size()), absz = int(AB.size()),
osz = int(O.size());
AB.push_back(make_pair(0, 0)), A.push_back(make_pair(0, 0)),
B.push_back(make_pair(0, 0)), O.push_back(make_pair(0, 0));
sort(AB.begin(), AB.end());
sort(A.begin(), A.end());
sort(B.begin(), B.end());
sort(O.begin(), O.end());
for (int i = 1; i <= asz; i++) A[i].first += A[i - 1].first;
for (int i = 1; i <= bsz; i++) B[i].first += B[i - 1].first;
for (int i = 1; i <= absz; i++) AB[i].first += AB[i - 1].first;
for (int i = 1; i <= osz; i++) O[i].first += O[i - 1].first;
for (int i = 1; i <= osz; i++) treap.add(O[i].first - O[i - 1].first);
for (int i = k + 1; i <= asz; i++) treap.add(A[i].first - A[i - 1].first);
for (int i = k + 1; i <= bsz; i++) treap.add(B[i].first - B[i - 1].first);
for (int ab = 0; ab <= absz; ab++) {
if (asz + ab >= k && bsz + ab >= k &&
ab + (max(k - ab, 0)) + (max(k - ab, 0)) <= m && n - (absz - ab) >= m) {
int tmp = AB[ab].first + A[max(k - ab, 0)].first +
B[max(k - ab, 0)].first +
treap.ask(m - (ab + (max(k - ab, 0)) + (max(k - ab, 0))));
if (tmp < ans) ans = tmp, idab = ab;
}
if (k - ab <= asz && k - ab >= 1)
treap.add(A[k - ab].first - A[k - ab - 1].first);
if (k - ab <= bsz && k - ab >= 1)
treap.add(B[k - ab].first - B[k - ab - 1].first);
}
if (idab < 0) goto No;
for (int i = 1; i <= osz; i++)
V.push_back(make_pair(O[i].first - O[i - 1].first, O[i].second));
for (int i = max(k - idab + 1, 1); i <= asz; i++)
V.push_back(make_pair(A[i].first - A[i - 1].first, A[i].second));
for (int i = max(k - idab + 1, 1); i <= bsz; i++)
V.push_back(make_pair(B[i].first - B[i - 1].first, B[i].second));
for (int i = 1; i <= idab; i++) the_set.push_back(AB[i].second);
for (int i = 1; i <= k - idab; i++) the_set.push_back(A[i].second);
for (int i = 1; i <= k - idab; i++) the_set.push_back(B[i].second);
sort(V.begin(), V.end());
for (int i = 0; i < m - idab - (max(0, k - idab)) - (max(0, k - idab)); i++)
the_set.push_back(V[i].second);
printf("%d\n%d", ans, the_set[0]);
for (int i = 1; i < m; i++) printf(" %d", the_set[i]);
printf("\n");
return 0;
No:
printf("-1\n");
}
|
#include <bits/stdc++.h>
using namespace std;
long long dp[2000005];
long long a[2000005];
int main() {
long long q;
q = 1;
for (int r = 0; r < q; r++) {
long long n, k;
cin >> n >> k;
vector<int> ans;
vector<int> a;
vector<int> b;
long long x, y, z;
for (int i = 0; i < n; i++) {
cin >> x >> y >> z;
if (y == 1 && z == 1)
ans.push_back(x);
else if (y == 1)
a.push_back(x);
else if (z == 1)
b.push_back(x);
}
if (a.size() != 0 && b.size() != 0) {
sort(a.begin(), a.end());
sort(b.begin(), b.end());
}
long long s = min(a.size(), b.size());
for (int i = 0; i < s; i++) {
ans.push_back(a[i] + b[i]);
}
if (ans.size() < k) {
cout << "-1";
return 0;
}
sort(ans.begin(), ans.end());
long long sum = 0;
for (int i = 0; i < k; i++) {
sum += ans[i];
}
cout << sum;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long MOD = 1e9 + 7;
const long long MOD2 = 998244353;
const float pi = 3.141592653;
long long power(long long a, long long b) {
if (b == 0) return 1;
long long p = power(a, b / 2);
if (b & 1)
return p * p * a;
else
return p * p;
}
void solve() {
long long n, k;
cin >> n >> k;
vector<long long> a, b, c;
for (long long i = 0; i < n; i++) {
long long o, t, f;
cin >> o >> t >> f;
if (t == 1 && f == 1)
c.push_back(o);
else if (t == 1)
a.push_back(o);
else if (f == 1)
b.push_back(o);
}
if (a.size() + c.size() < k || b.size() + c.size() < k) {
cout << -1;
return;
}
sort(a.begin(), a.end());
sort(b.begin(), b.end());
sort(c.begin(), c.end());
long long ans = 0, count = 0, index1 = 0, index2 = 0;
while (1) {
if (index2 == min(a.size(), b.size()) || index1 == c.size()) break;
if (a[index2] + b[index2] <= c[index1]) {
ans += a[index2] + b[index2];
index2++;
} else {
ans += c[index1];
index1++;
}
count++;
if (count == k) break;
}
if (index1 < c.size()) {
while (count < k) {
ans += c[index1];
index1++;
count++;
}
}
if (index2 < min(a.size(), b.size())) {
while (count < k) {
count++;
ans += (a[index2] + b[index2]);
index2++;
}
}
cout << ans;
}
int32_t main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
long long t = 1;
while (t--) {
solve();
cout << "\n";
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
priority_queue<int, vector<int>, greater<int>> ab;
priority_queue<int, vector<int>, greater<int>> av;
priority_queue<int, vector<int>, greater<int>> bv;
int n, k;
cin >> n >> k;
int cntA, cntB;
cntA = cntB = 0;
for (int i = 0; i < n; i++) {
int t, a, b;
cin >> t >> a >> b;
if (a == 1 && b == 1) {
cntA++;
cntB++;
ab.push(t);
} else if (a == 1) {
cntA++;
av.push(t);
} else if (b == 1) {
cntB++;
bv.push(t);
}
}
if (cntA < k || cntB < k) {
cout << "-1" << endl;
return 0;
}
int time = 0;
while (k > 0) {
if (!ab.empty() && !av.empty() && !bv.empty()) {
if (ab.top() > av.top() + bv.top()) {
time += av.top() + bv.top();
av.pop();
bv.pop();
k--;
} else {
time += ab.top();
ab.pop();
k--;
}
} else {
if (av.empty() || bv.empty()) {
time += ab.top();
ab.pop();
k--;
} else {
time += av.top() + bv.top();
av.pop();
bv.pop();
k--;
}
}
}
cout << time << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int reading_books(int n, int k, vector<int>& t, vector<int>& a,
vector<int>& b) {
int cnt_a, cnt_b, total;
vector<int> av, bv, cv;
total = 0;
cnt_a = cnt_b = k;
auto choose_alice = [&]() {
total += av.back();
cnt_a = max(0, cnt_a - 1);
av.pop_back();
};
auto choose_bob = [&]() {
total += bv.back();
cnt_b = max(0, cnt_b - 1);
bv.pop_back();
};
auto choose_common = [&]() {
total += cv.back();
cnt_a = max(0, cnt_a - 1);
cnt_b = max(0, cnt_b - 1);
cv.pop_back();
};
for (int i = 0; i < n; i++) {
if (a[i] && b[i])
cv.push_back(t[i]);
else if (a[i])
av.push_back(t[i]);
else if (b[i])
bv.push_back(t[i]);
}
if (av.size() + cv.size() < k || bv.size() + cv.size() < k) return -1;
sort(av.rbegin(), av.rend());
sort(bv.rbegin(), bv.rend());
sort(cv.rbegin(), cv.rend());
while (cnt_a || cnt_b) {
if (cnt_a && cnt_b) {
if (av.empty() || bv.empty() ||
(!cv.empty() && av.back() + bv.back() >= cv.back()))
choose_common();
else {
choose_alice();
choose_bob();
}
} else if (cnt_a) {
if (av.empty() || (!cv.empty() && av.back() >= cv.back()))
choose_common();
else
choose_alice();
} else {
if (bv.empty() || (!cv.empty() && bv.back() >= cv.back()))
choose_common();
else
choose_bob();
}
}
return total;
}
int main() {
int n, k;
cin >> n >> k;
vector<int> t(n), a(n), b(n);
for (int i = 0; i < n; i++) cin >> t[i] >> a[i] >> b[i];
cout << reading_books(n, k, t, a, b);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
vector<int> a, b, c, tmp;
int main() {
ios::sync_with_stdio(false);
long long n, k;
cin >> n >> k;
for (long long i = 1; i <= n; i++) {
long long a1, b1, t;
cin >> t >> a1 >> b1;
if (a1 == 1 && b1 == 1) {
c.push_back(t);
} else {
if (a1) {
a.push_back(t);
}
if (b1) {
b.push_back(t);
}
}
}
sort(b.begin(), b.end());
sort(a.begin(), a.end());
for (long long i = 0; i < a.size() && i < b.size(); i++) {
c.push_back(a[i] + b[i]);
}
if (c.size() < k)
cout << -1 << "\n";
else {
sort(c.begin(), c.end());
long long sum = 0;
for (long long i = 0; i < k; i++) {
sum += c[i];
}
cout << sum << "\n";
}
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
long long int n, count;
cin >> n >> count;
vector<long long int> both, alice, bob;
long long int time, b, c;
for (int i = 0; i < n; i++) {
cin >> time >> b >> c;
if (b == 1 && c == 1)
both.push_back(time);
else if (b == 1 || c == 1) {
if (b == 1)
alice.push_back(time);
else
bob.push_back(time);
}
}
long long int minsize = both.size() + 0LL + min(alice.size(), bob.size());
if (minsize < count) {
cout << -1;
return 0;
}
minsize -= both.size();
if (both.size() > 0) sort(both.begin(), both.end());
if (alice.size() > 0) sort(alice.begin(), alice.end());
if (bob.size() > 0) sort(bob.begin(), bob.end());
long long int total = count;
vector<long long int> both_sum(both.size() + 1, 0),
alice_sum(alice.size() + 1, 0), bob_sum(bob.size() + 1, 0);
both_sum[0] = 0;
alice_sum[0] = 0;
bob_sum[0] = 0;
for (long long int i = 0; i < both.size(); i++)
both_sum[i + 1] = both[i] + both_sum[i];
for (long long int i = 0; i < alice.size(); i++)
alice_sum[i + 1] = alice[i] + alice_sum[i];
for (long long int i = 0; i < bob.size(); i++)
bob_sum[i + 1] = bob[i] + bob_sum[i];
long long int ans = LLONG_MAX;
minsize = min(minsize, count);
for (long long int i = minsize; i >= 0; i--) {
long long int right = total - i;
if (right >= both_sum.size()) break;
long long int rightval = both_sum[right] + alice_sum[i] + bob_sum[i];
ans = min(ans, rightval);
}
if (ans == LLONG_MAX)
cout << -1;
else
cout << ans;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int INF = 2e9 + 1;
int main() {
int n, k;
cin >> n >> k;
vector<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);
}
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);
}
}
int ans = INF;
for (int cnt = 0; cnt < min(k + 1, int(sums[3].size())); ++cnt) {
if (k - cnt < int(sums[1].size()) && k - cnt < int(sums[2].size())) {
ans = min(ans, sums[3][cnt] + sums[1][k - cnt] + sums[2][k - cnt]);
}
}
if (ans == INF) ans = -1;
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
mt19937 rng(98);
struct node {
int x, y, c;
long long s;
node *l, *r;
node(int x) : x(x), y(rng()), l(nullptr), r(nullptr) {
c = 1;
s = x;
}
void recalc();
};
int cnt(node *n) { return n ? n->c : 0; }
long long sum(node *n) { return n ? n->s : 0; }
void node::recalc() {
c = cnt(l) + cnt(r) + 1;
s = sum(l) + sum(r) + x;
}
pair<node *, node *> split(node *t, int x) {
if (!t) return {nullptr, nullptr};
if (t->x > x) {
auto p = split(t->l, x);
t->l = p.second;
t->recalc();
return {p.first, t};
}
auto p = split(t->r, x);
t->r = p.first;
t->recalc();
return {t, p.second};
}
node *insert(node *t, node *n) {
if (!t) return n;
if (n->y >= t->y) {
if (n->x <= t->x) {
t->l = insert(t->l, n);
t->recalc();
} else {
t->r = insert(t->r, n);
t->recalc();
}
return t;
}
auto p = split(t, n->x);
n->l = p.first;
n->r = p.second;
n->recalc();
return n;
}
long long prf(node *t, int p) {
if (!t) return 0;
if (cnt(t) < p) return -1;
if (p <= cnt(t->l)) return prf(t->l, p);
return sum(t->l) + t->x + prf(t->r, p - cnt(t->l) - 1);
}
const int MAXN = 2e5 + 10;
int val[MAXN], msk[MAXN], n, m, k;
vector<int> byt[4];
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cin >> n >> m >> k;
for (int i = 1; i <= n; i++) {
cin >> val[i];
int x;
cin >> x;
msk[i] += x;
cin >> x;
msk[i] += 2 * x;
}
for (int i = 1; i <= n; i++) byt[msk[i]].push_back(val[i]);
for (int i = 0; i < 4; i++) sort(byt[i].begin(), byt[i].end());
node *t = nullptr;
for (auto x : byt[0]) t = insert(t, new node(x));
long long curs = 0, ans = -1, s1 = 0, s2 = 0;
for (int i = 0; i < min(k + 1, (int)byt[1].size()); i++) s1 += byt[1][i];
for (int i = 0; i < min(k + 1, (int)byt[2].size()); i++) s2 += byt[2][i];
for (int i = k + 1; i < byt[1].size(); i++)
t = insert(t, new node(byt[1][i]));
for (int i = k + 1; i < byt[2].size(); i++)
t = insert(t, new node(byt[2][i]));
int bst = -1;
for (int both = 0; both <= byt[3].size(); both++) {
int oth = max(k - both, -1);
if (both) curs += byt[3][both - 1];
if (oth >= 0 && oth < byt[1].size()) {
s1 -= byt[1][oth];
t = insert(t, new node(byt[1][oth]));
}
if (oth >= 0 && oth < byt[2].size()) {
s2 -= byt[2][oth];
t = insert(t, new node(byt[2][oth]));
}
oth = max(oth, 0);
if (oth > byt[1].size() || oth > byt[2].size() || both + 2 * oth > m ||
m - both - 2 * oth > cnt(t))
continue;
int rem = m - both - 2 * oth;
long long x = curs + s1 + s2 + prf(t, rem);
if (ans == -1) {
ans = x;
bst = both;
} else {
if (x < ans) {
ans = x;
bst = both;
}
}
}
cout << ans << '\n';
if (ans > -1) {
vector<pair<int, int> > fy[4];
for (int i = 1; i <= n; i++) fy[msk[i]].push_back({val[i], i});
for (int i = 0; i < 4; i++) sort(fy[i].rbegin(), fy[i].rend());
for (int i = 0; i < bst; i++) {
cout << fy[3].back().second << " ";
fy[3].pop_back();
}
int rem = max(k - bst, 0);
for (int i = 0; i < rem; i++) {
cout << fy[2].back().second << " ";
fy[2].pop_back();
cout << fy[1].back().second << " ";
fy[1].pop_back();
}
int reallyrem = m - bst - 2 * rem;
for (int i = 0; i < reallyrem; i++) {
int mn = INT_MAX;
for (int j = 0; j < 3; j++) {
if (fy[j].size()) mn = min(mn, fy[j].back().first);
}
for (int j = 0; j < 3; j++) {
if (fy[j].size() && fy[j].back().first == mn) {
cout << fy[j].back().second << " ";
fy[j].pop_back();
break;
}
}
}
cout << '\n';
}
}
|
#include <bits/stdc++.h>
using namespace std;
long long int a, b, c, d, e, f = 5 * 1e9, m11[200000], m01[200000], m10[200000],
k, k1, k2;
int main() {
cin >> a >> b;
for (int i = 0; i < a; i++) {
cin >> c >> d >> e;
if (e == 1 && d == 1) m11[k] = c, k++;
if (d == 1 && e == 0) m10[k1] = c, k1++;
if (d == 0 && e == 1) m01[k2] = c, k2++;
}
sort(m11, m11 + k);
sort(m10, m10 + k1);
sort(m01, m01 + k2);
if (k + min(k1, k2) < b) {
cout << -1;
return 0;
}
for (int i = 1; i < max(max(k, k1), k2); i++) {
m11[i] += m11[i - 1];
m01[i] += m01[i - 1];
m10[i] += m10[i - 1];
}
for (int i = 0; i < min(b, k); i++) {
if (b - 2 - i < min(k1, k2))
f = min(m11[i] + m01[b - 2 - i] + m10[b - 2 - i], f);
}
if (k >= b) f = min(f, m11[b - 1]);
if (min(k1, k2) >= b) f = min(m01[b - 1] + m10[b - 1], f);
cout << f;
}
|
#include <bits/stdc++.h>
using namespace std;
const int inf = 1 << 30;
const double pi = acos(-1);
const double eps = 1e-9;
const int mod = 1e9 + 7;
const int mf[] = {0, 0, 1, -1}, mc[] = {1, -1, 0, 0};
const int N = 1005;
mt19937 rng(
(unsigned int)chrono::steady_clock::now().time_since_epoch().count());
template <typename T>
static T randint(T lo, T hi) {
return uniform_int_distribution<T>(lo, hi)(rng);
}
template <typename T>
static T randreal(T lo, T hi) {
return uniform_real_distribution<T>(lo, hi)(rng);
}
void nop() {
cout << -1 << '\n';
exit(0);
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
rng.seed(time(0));
int n, m, k;
cin >> n >> m >> k;
vector<pair<int, int>> a(1, {0, 0}), b(1, {0, 0}), c(1, {0, 0}), d(1, {0, 0});
for (int i = 1; i <= n; i++) {
int ti, ai, bi;
cin >> ti >> ai >> bi;
if (ai == 1 && bi == 0) a.push_back({ti, i});
if (ai == 0 && bi == 1) b.push_back({ti, i});
if (ai == 1 && bi == 1) c.push_back({ti, i});
if (ai == 0 && bi == 0) d.push_back({ti, i});
}
sort(a.begin(), a.end());
sort(b.begin(), b.end());
sort(c.begin(), c.end());
sort(d.begin(), d.end());
vector<int> ta(a.size()), tb(b.size()), tc(c.size()), td(d.size());
int sa = a.size() - 1, sb = b.size() - 1, sc = c.size() - 1,
sd = d.size() - 1;
for (int i = 1; i <= sa; i++) ta[i] = ta[i - 1] + a[i].first;
for (int i = 1; i <= sb; i++) tb[i] = tb[i - 1] + b[i].first;
for (int i = 1; i <= sc; i++) tc[i] = tc[i - 1] + c[i].first;
for (int i = 1; i <= sd; i++) td[i] = td[i - 1] + d[i].first;
int ans = -1, ita, itb, itc, itd;
for (int fix = 0; fix <= sc && fix <= m; fix++) {
if (sa < k - fix || sb < k - fix) continue;
int s = tc[fix] + (((k - fix) >= 0) ? ta[k - fix] + tb[k - fix] : 0);
int t = fix + max(0, (k - fix) * 2);
if (t > m) continue;
if (t == m) {
if (ans == -1 || ans > s) {
ans = s;
ita = max(0, k - fix);
itb = max(0, k - fix);
itc = fix;
itd = 0;
}
continue;
}
int ra = ((k - fix) >= 0) ? k - fix : 0;
int rb = ((k - fix) >= 0) ? k - fix : 0;
if (sa - ra + sb - rb + sd < m - t) continue;
int lo = min({a[ra].first, b[ra].first}), hi = 10000;
if (sd > 0) lo = min(lo, d[1].first);
while (lo < hi) {
int mid = (lo + hi) >> 1;
int upa =
upper_bound(a.begin(), a.end(), make_pair(mid, inf)) - a.begin() - 1;
int upb =
upper_bound(b.begin(), b.end(), make_pair(mid, inf)) - b.begin() - 1;
int upd =
upper_bound(d.begin(), d.end(), make_pair(mid, inf)) - d.begin() - 1;
if (max(0, upa - ra) + max(0, upb - rb) + upd >= m - t)
hi = mid;
else
lo = mid + 1;
}
int upa =
upper_bound(a.begin(), a.end(), make_pair(lo - 1, inf)) - a.begin() - 1;
int upb =
upper_bound(b.begin(), b.end(), make_pair(lo - 1, inf)) - b.begin() - 1;
int upd =
upper_bound(d.begin(), d.end(), make_pair(lo - 1, inf)) - d.begin() - 1;
s += max(0, ta[upa] - ta[ra]) + max(0, tb[upb] - tb[rb]) + td[upd];
t += max(0, upa - ra) + max(0, upb - rb) + upd;
s += max(0, (m - t) * lo);
if (ans == -1 || ans > s) {
ans = s;
ita = max(ra, upa);
itb = max(rb, upb);
itc = fix;
itd = upd;
}
}
cout << ans << '\n';
if (ans != -1) {
vector<int> g;
multiset<pair<int, int>> ms;
for (int i = 1; i <= sa; i++)
if (i <= ita)
g.push_back(a[i].second);
else
ms.insert(a[i]);
for (int i = 1; i <= sb; i++)
if (i <= itb)
g.push_back(b[i].second);
else
ms.insert(b[i]);
for (int i = 1; i <= sc; i++)
if (i <= itc)
g.push_back(c[i].second);
else
ms.insert(c[i]);
for (int i = 1; i <= sd; i++)
if (i <= itd)
g.push_back(d[i].second);
else
ms.insert(d[i]);
while ((int)g.size() < m) {
g.push_back(ms.begin()->second);
ms.erase(ms.begin());
}
for (int i = 0; i < m; i++) cout << g[i] << " \n"[i == m - 1];
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int inf = 1e9;
struct indices {
int i11, i10, i01, i00;
};
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
int n, m, k;
cin >> n >> m >> k;
vector<pair<long long int, int> > v11, v10, v01, v00;
for (int i = 0; i < n; i++) {
int t, a, b;
cin >> t >> a >> b;
if (a && b)
v11.push_back(pair<long long int, int>(t, i + 1));
else if (a)
v10.push_back(pair<long long int, int>(t, i + 1));
else if (b)
v01.push_back(pair<long long int, int>(t, i + 1));
else
v00.push_back(pair<long long int, int>(t, i + 1));
}
sort(v11.begin(), v11.end());
sort(v10.begin(), v10.end());
sort(v01.begin(), v01.end());
sort(v00.begin(), v00.end());
if ((int)v11.size() + min((int)v10.size(), (int)v01.size()) < k) {
cout << -1 << '\n';
return 0;
}
indices res;
res.i11 = res.i10 = res.i01 = res.i00 = -1;
long long int ans = 1e15;
int b = 0, c = 0, d = 0;
long long int acum = 0ll;
for (auto e : v11) {
acum += e.first;
}
long long int sum = acum;
for (int a = (int)v11.size(); a >= 0; a--) {
while (a + b < k && b < (int)v10.size()) {
sum += v10[b].first;
b++;
}
while (a + c < k && c < (int)v01.size()) {
sum += v01[c].first;
c++;
}
if (a + b + c + d > m) {
if (d) {
sum -= v00[d - 1].first;
d--;
}
}
int faltan = m - (a + b + c + d);
bool can = true;
for (int i = 0; i < faltan; i++) {
int costb = inf, costc = inf, costd = inf;
if (b < (int)v10.size()) {
costb = v10[b].first;
}
if (c < (int)v01.size()) {
costc = v01[c].first;
}
if (d < (int)v00.size()) {
costd = v00[d].first;
}
if (min({costb, costc, costd}) == inf) {
can = false;
break;
}
if (costb <= costc && costb <= costd && costb != inf) {
sum += costb;
b++;
} else if (costc <= costb && costc <= costd && costc != inf) {
sum += costc;
c++;
} else {
sum += costd;
d++;
}
}
if (can) {
if (a + b >= k && a + c >= k && (a + b + c + d) == m && sum < ans) {
ans = sum;
res.i11 = a;
res.i10 = b;
res.i01 = c;
res.i00 = d;
}
}
if (a) sum -= v11[a - 1].first;
}
if (res.i11 < 0) {
cout << -1 << '\n';
return 0;
}
cout << ans << '\n';
for (int i = 0; i < res.i11; i++) cout << v11[i].second << " ";
for (int i = 0; i < res.i10; i++) cout << v10[i].second << " ";
for (int i = 0; i < res.i01; i++) cout << v01[i].second << " ";
for (int i = 0; i < res.i00; i++) cout << v00[i].second << " ";
cout << '\n';
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
void adskiy_razgon() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
}
const int day[12] = {31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31};
const int dx[4] = {1, 0, -1, 0}, dy[4] = {0, 1, 0, -1};
const int dxo[8] = {-1, -1, -1, 0, 1, 1, 1, 0},
dyo[8] = {-1, 0, 1, 1, 1, 0, -1, -1};
long long nod(long long a, long long b) {
if (b > a) swap(a, b);
while (b > 0) {
a %= b;
swap(a, b);
}
return a;
}
long long nok(long long a, long long b) { return a * b / nod(a, b); }
void sp(long long a, double b) { cout << fixed << setprecision(a) << b; }
template <class A>
void read(vector<A>& v);
template <class A, size_t S>
void read(array<A, S>& a);
template <class T>
void read(T& x) {
cin >> x;
}
void read(double& d) {
string t;
read(t);
d = stod(t);
}
void read(long double& d) {
string t;
read(t);
d = stold(t);
}
template <class H, class... T>
void read(H& h, T&... t) {
read(h);
read(t...);
}
template <class A>
void read(vector<A>& x) {
for (auto& a : x) read(a);
}
template <class A, size_t S>
void read(array<A, S>& x) {
for (auto& a : x) read(a);
}
string to_string(char c) { return string(1, c); }
string to_string(const char* s) { return string(s); }
string to_string(string s) { return s; }
string to_string(vector<bool> v) {
string res;
for (int i = (0); (1) > 0 ? i < ((int)(v).size()) : i > ((int)(v).size());
i += (1))
res += char('0' + v[i]);
return res;
}
template <size_t S>
string to_string(bitset<S> b) {
string res;
for (int i = (0); (1) > 0 ? i < (S) : i > (S); i += (1))
res += char('0' + b[i]);
return res;
}
template <class T>
string to_string(T v) {
bool f = 1;
string res;
for (auto& x : v) {
if (!f) res += ' ';
f = 0;
res += to_string(x);
}
return res;
}
template <class A>
void write(A x) {
cout << to_string(x);
}
template <class H, class... T>
void write(const H& h, const T&... t) {
write(h);
write(t...);
}
void print() { write("\n"); }
template <class H, class... T>
void print(const H& h, const T&... t) {
write(h);
if (sizeof...(t)) write(' ');
print(t...);
}
void yes(bool ok) { print((ok ? "YES" : "Yes")); }
void no(bool ok) { print((ok ? "NO" : "No")); }
const int MOD = 1e9 + 7;
const int N = 2e5 + 5;
const long long INF = 1e21;
const long double PI = acos((long double)-1);
const int M = 1005;
long long binpow(long long a, long long n) {
if (n == 0) return 1;
if (n % 2 == 1)
return ((binpow(a, n - 1)) * a);
else {
long long b = (binpow(a, n / 2));
return (b * b);
}
}
vector<int> eq;
vector<int> al, bob;
void solve() {
int n, m;
read(n, m);
for (int i = 1; i <= n; ++i) {
int num;
bool Alice, Bob;
read(num, Alice, Bob);
if (Alice && Bob)
eq.push_back(num);
else {
if (Alice)
al.push_back(num);
else if (Bob)
bob.push_back(num);
}
}
sort(al.begin(), al.end());
sort(bob.begin(), bob.end());
for (int i = 0; i < min((int)(al).size(), (int)(bob).size()); ++i)
eq.push_back(al[i] + bob[i]);
sort(eq.begin(), eq.end());
if ((int)(eq).size() < m) {
print(-1);
return;
}
int ans = 0;
for (int i = 0; i < m; ++i) ans += eq[i];
print(ans);
}
int main() {
adskiy_razgon();
long long t = 1;
for (int i = (0); (1) > 0 ? i < (t) : i > (t); i += (1)) {
solve();
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long mod = 1e9 + 7;
long long dx[] = {-1, 0, 1, 0};
long long dy[] = {0, -1, 0, 1};
vector<pair<long long, long long> > v[4];
long long n, m, k;
vector<long long> uttar;
bool check = false;
long long call(long long x) {
check = false;
if (x > m) {
check = true;
return INT_MAX;
}
long long res = 0;
uttar.clear();
for (long long i = 0; i < x; i++) {
res += v[3][i].first;
uttar.push_back(v[3][i].second);
}
long long rem = m - x;
vector<pair<long long, long long> > baki;
if (x < k) {
long long bacha = k - x;
if (v[1].size() < bacha || v[2].size() < bacha || rem < bacha * 2) {
check = true;
return INT_MAX - x;
}
rem -= bacha * 2;
for (long long i = 0; i < bacha; i++) {
uttar.push_back(v[1][i].second);
uttar.push_back(v[2][i].second);
res += v[1][i].first;
res += v[2][i].first;
}
for (long long i = 1; i <= 2; i++)
for (long long j = bacha; j < v[i].size(); j++) {
baki.push_back(v[i][j]);
}
for (auto i : v[0]) baki.push_back(i);
} else {
for (long long i = 1; i <= 2; i++)
for (auto j : v[i]) {
baki.push_back(j);
}
for (auto j : v[0]) baki.push_back(j);
}
sort(baki.begin(), baki.end());
if (baki.size() < rem) {
check = true;
return INT_MAX - x;
}
for (long long i = 0; i < rem; i++) {
uttar.push_back(baki[i].second);
res += baki[i].first;
}
return res;
}
int32_t main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cin >> n >> m >> k;
for (long long i = 0; i < n; i++) {
long long t, x, y;
cin >> t >> x >> y;
if (x && y)
v[3].push_back({t, i});
else if (x) {
v[2].push_back({t, i});
} else if (y)
v[1].push_back({t, i});
else
v[0].push_back({t, i});
}
for (long long i = 0; i < 4; i++) {
sort(v[i].begin(), v[i].end());
}
long long s = -1, e = min(m, (long long)v[3].size());
while (e - s > 1) {
long long mid1 = (s + e) >> 1;
long long mid2 = mid1 + 1;
if (call(mid1) > call(mid2))
s = mid1;
else
e = mid1;
}
long long ans = call(e);
if (check) {
cout << "-1"
<< "\n";
return 0;
}
cout << ans << "\n";
for (auto i : uttar) cout << i + 1 << " ";
cout << "\n";
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
long long n, k;
cin >> n >> k;
vector<long long> ones, twos, threes;
for (long long i = 0; i < n; i++) {
long long t, a, b;
cin >> t >> a >> b;
if (a == 1 && b == 1) {
threes.push_back(t);
} else {
if (a == 1) ones.push_back(t);
if (b == 1) twos.push_back(t);
}
}
long long ans = -1;
sort((ones).begin(), (ones).end());
sort((twos).begin(), (twos).end());
sort((threes).begin(), (threes).end());
vector<long long> on(ones.size() + 1, 0);
vector<long long> dos(twos.size() + 1, 0);
vector<long long> tres(threes.size() + 1, 0);
for (long long i = 0; i < ones.size(); i++) {
on[i + 1] = on[i] + ones[i];
}
for (long long i = 0; i < twos.size(); i++) {
dos[i + 1] = dos[i] + twos[i];
}
for (long long i = 0; i < threes.size(); i++) {
tres[i + 1] = tres[i] + threes[i];
}
for (long long i = 0; i < tres.size(); i++) {
long long k2 = i;
long long k1 = k - i;
if (k1 >= 0 && k1 < min(on.size(), dos.size())) {
if (ans == -1) ans = tres[i] + on[k1] + dos[k1];
ans = min(ans, tres[i] + on[k1] + dos[k1]);
}
}
cout << ans << "\n";
}
|
#include <bits/stdc++.h>
using namespace std;
const long long int MOD = 998244353;
const long double PI = 3.14159265359;
const long long int INF = 1e9;
char salpha[26] = {'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i',
'j', 'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r',
's', 't', 'u', 'v', 'w', 'x', 'y', 'z'};
char calpha[26] = {'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I',
'J', 'K', 'L', 'M', 'N', 'O', 'P', 'Q', 'R',
'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z'};
long long int gcd(long long int a, long long int b) {
if (a == 0) {
return b;
}
return gcd(b % a, a);
}
long long int exp(long long int b, long long int p) {
if (p == 0) {
return 1;
} else if (p % 2 == 0) {
return exp(b * b, p / 2);
} else {
return b * exp(b * b, (p - 1) / 2);
}
}
long long int mexp(long long int b, long long int p) {
if (p == 0) {
return 1;
} else if (p % 2 == 0) {
return mexp((b * b) % MOD, p / 2) % MOD;
} else {
return (b * mexp((b * b) % MOD, (p - 1) / 2)) % MOD;
}
}
long long int minv(long long int a) { return mexp(a, MOD - 2); }
int isprime(long long int n) {
for (long long int i = 2; i * i <= n; i++) {
if (n % i == 0) {
return 0;
}
}
return 1;
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int n, k;
cin >> n >> k;
vector<int> a, b, c;
for (int i = 0; i < n; i++) {
int t, ap, bp;
cin >> t >> ap >> bp;
if (ap == 1 && bp == 1)
c.push_back(t);
else if (ap == 1)
a.push_back(t);
else if (bp == 1)
b.push_back(t);
}
sort(a.begin(), a.end());
sort(b.begin(), b.end());
sort(c.begin(), c.end());
if (a.size() + c.size() < k || b.size() + c.size() < k)
cout << "-1"
<< "\n";
else {
int ai = 0, bi = 0, ci = 0;
long long int ans = 0;
for (int i = 0; i < k; i++) {
long long int flag1 = -1, flag2 = -1;
long long int opt1, opt2;
if (ai != a.size() && bi != b.size()) {
flag1 = 1;
opt1 = a[ai] + b[bi];
ai++;
bi++;
}
if (ci != c.size()) {
flag2 = 1;
opt2 = c[ci];
ci++;
}
if (flag1 == -1) {
ans += opt2;
} else if (flag2 == -1) {
ans += opt1;
} else if (flag1 == 1 && flag2 == 1) {
if (opt1 < opt2) {
ans += opt1;
ci--;
} else {
ans += opt2;
ai--;
bi--;
}
}
}
cout << ans << "\n";
}
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int k, n;
cin >> n >> k;
int aa[n], ba[n], ra[n];
int r = 0, a = 0, b = 0;
for (int i = 0, v, m, u; i < n; ++i) {
cin >> v >> m >> u;
if (m && u)
ra[r++] = v;
else if (u)
ba[b++] = v;
else if (m)
aa[a++] = v;
}
sort(ba, ba + b);
sort(aa, aa + a);
for (int i = 0, s = min(a, b); i < s; ++i) ra[r++] = (aa[i] + ba[i]);
if (r < k) {
cout << "-1\n";
return 0;
}
sort(ra, ra + r);
long long an = 0;
for (int i = 0; i < k; ++i) an += ra[i];
cout << an << '\n';
}
|
#include <bits/stdc++.h>
using std::max;
using std::min;
const int N = 2e5 + 5, INF = 0x7fffffff;
struct book {
int id, val, a, b;
book() {}
book(int val, int a, int b) : val(val), a(a), b(b) {}
bool operator<(const book &rhs) const { return val < rhs.val; }
bool operator>(const book &rhs) const { return val > rhs.val; }
};
template <typename T, typename comp>
struct Heap {
T hp[N];
comp cm;
int cnt;
Heap() { cnt = 0; }
void push(T x) {
hp[cnt++] = x;
int p = cnt;
while (((p) >> 1) && cm(hp[p - 1], hp[((p) >> 1) - 1]))
std::swap(hp[((p) >> 1) - 1], hp[p - 1]), p = ((p) >> 1);
}
T pop() {
T res = hp[0], nr = hp[cnt - 1];
cnt--;
hp[0] = nr;
int p = 1;
while (((p) << 1) <= cnt) {
T mns = hp[((p) << 1) - 1];
int np = ((p) << 1);
if (((p) << 1 | 1) <= cnt && cm(hp[((p) << 1 | 1) - 1], mns))
mns = hp[(np = ((p) << 1 | 1)) - 1];
if (cm(mns, hp[p - 1]))
std::swap(hp[p - 1], hp[np - 1]), p = np;
else
break;
}
return res;
}
const T top() { return hp[0]; }
const int size() { return cnt; }
};
bool cmp(const book &x, const book &y) {
if (x.a != y.a) return x.a < y.a;
if (x.b != y.b) return x.b < y.b;
return x.val < y.val;
}
struct H {
Heap<book, std::greater<book> > tp;
Heap<book, std::less<book> > bt;
int tps, bts;
H() { tps = bts = 0; }
void push(book x) {
if (bt.size() && x > bt.top())
bt.push(x), bts += x.val;
else
tp.push(x), tps += x.val;
}
int ksum(int k) {
while (tp.size() < k)
tps += bt.top().val, bts -= bt.top().val, tp.push(bt.top()), bt.pop();
while (tp.size() > k)
bts += tp.top().val, tps -= tp.top().val, bt.push(tp.top()), tp.pop();
return tps;
}
const int size() { return tp.size() + bt.size(); }
};
int main() {
static book bk[N];
static H heap;
int n, m, k;
scanf("%d%d%d", &n, &m, &k);
for (int i = 1; i <= n; i++)
scanf("%d%d%d", &bk[i].val, &bk[i].a, &bk[i].b), bk[i].id = i;
std::sort(bk + 1, bk + 1 + n, cmp);
book *b0 = NULL, *b1 = NULL, *b2 = NULL, *b3 = NULL;
int n0 = 0, n1 = 0, n2 = 0, n3 = 0;
for (int i = 1; i <= n; i++) {
if (bk[i].a == 0 && bk[i].b == 0) n0++;
if (bk[i].a == 0 && bk[i].b == 1) n1++;
if (bk[i].a == 1 && bk[i].b == 0) n2++;
if (bk[i].a == 1 && bk[i].b == 1) n3++;
}
b0 = bk;
b1 = b0 + n0;
b2 = b1 + n1;
b3 = b2 + n2;
int n12 = min(n1, n2);
int sa = k, sb = 0;
bool flg = false;
for (int i = 1; i <= n3; i++) {
if (0 <= sa && sa <= n12 && 0 <= sb && sb <= n3 && sa * 2 + sb <= m &&
sa * 2 + sb <= n) {
flg = true;
break;
}
sa--;
sb++;
}
if (0 <= sa && sa <= n12 && 0 <= sb && sb <= n3 && sa * 2 + sb <= m &&
sa * 2 + sb <= n)
flg = true;
if (!flg) return printf("-1\n"), 0;
int vans = 0;
for (int i = 1; i <= sa; i++) vans += b1[i].val + b2[i].val;
for (int i = 1; i <= sb; i++) vans += b3[i].val;
for (int i = 1; i <= n0; i++) heap.push(b0[i]);
for (int i = sa + 1; i <= n1; i++) heap.push(b1[i]);
for (int i = sa + 1; i <= n2; i++) heap.push(b2[i]);
int ans = INF, ansi = 0;
if (heap.size() + sa * 2 + sb >= m)
ans = vans + heap.ksum(m - sa * 2 - sb), ansi = sb;
int sbb = sb;
for (int i = sb + 1, j = sa; i <= n3 && j >= 1; i++, j--) {
vans += b3[i].val - b1[j].val - b2[j].val;
heap.push(b1[j]);
heap.push(b2[j]);
if (heap.size() + (j - 1) * 2 + i >= m) {
int na = vans + heap.ksum(m - (j - 1) * 2 - i);
if (na < ans) ans = na, ansi = i;
}
sbb = i;
}
for (int i = sbb + 1; i <= n3; i++) {
vans += b3[i].val;
if (m >= i && heap.size() + i >= m) {
int na = vans + heap.ksum(m - i);
if (na < ans) ans = na, ansi = i;
}
}
printf("%d\n", ans);
int vv = 0;
for (int i = 1; i <= ansi; i++) printf("%d ", b3[i].id), vv++;
for (int i = 1; i <= max(0, k - ansi); i++)
printf("%d %d ", b1[i].id, b2[i].id), vv += 2;
static book tmp[N];
int pp = 0;
for (int i = 1; i <= n0; i++) tmp[++pp] = b0[i];
for (int i = max(0, k - ansi) + 1; i <= n1; i++) tmp[++pp] = b1[i];
for (int i = max(0, k - ansi) + 1; i <= n2; i++) tmp[++pp] = b2[i];
std::sort(tmp + 1, tmp + 1 + pp);
for (int i = 1; i <= m - vv; i++) printf("%d ", tmp[i].id);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 4e5 + 10, mod = 1e9 + 7;
int bitc[N], bit[N];
int n;
void add(int i, int va) {
for (; i < N; i += (i & -i)) {
bit[i] += va;
bitc[i] += (va < 0 ? -1 : 1);
}
}
long long getprefones(int va) {
int i = 0;
int cur = 0;
long long ret = 0;
for (int j = 20; j >= 0; j--) {
if (i + (1 << j) < N && bitc[i + (1 << j)] + cur <= va) {
cur += bitc[i + (1 << j)];
ret += bit[i + (1 << j)];
i += (1 << j);
}
}
if (cur < va) ret = 2e9 + 5;
return ret;
}
int main() {
int tc = 1;
for (int cn = 1; cn <= tc; cn++) {
int m, k;
scanf("%d%d%d", &n, &m, &k);
vector<vector<pair<int, int>>> v(4);
vector<vector<int>> pref(4);
vector<pair<int, int>> vec;
for (int i = 1; i <= n; i++) {
int t, a, b;
scanf("%d%d%d", &t, &a, &b);
int m = (a * 2) + b;
v[m].push_back({t, i});
vec.push_back({t, i});
}
sort(vec.begin(), vec.end());
vector<int> id(n + 1);
for (int i = 0; i < n; i++)
add(i + 1, vec[i].first), id[vec[i].second] = i + 1;
for (int i = 0; i < 4; i++) {
sort(v[i].begin(), v[i].end());
if (v[i].size()) pref[i].push_back(v[i][0].first);
for (int j = 1; j < v[i].size(); j++)
pref[i].push_back(pref[i][j - 1] + v[i][j].first);
}
for (auto x : v[3]) add(id[x.second], -x.first);
long long ans = 2e9 + 10;
int b = -1;
for (int i = 0; i < k && i < v[1].size(); i++)
add(id[v[1][i].second], -v[1][i].first);
for (int i = 0; i < k && i < v[2].size(); i++)
add(id[v[2][i].second], -v[2][i].first);
int l = min(k, (int)v[1].size()) - 1;
int r = min(k, (int)v[2].size()) - 1;
if (2 * k <= m && l == k - 1 && r == k - 1) {
ans = min(ans, pref[1][k - 1] + pref[2][k - 1] + getprefones(m - 2 * k));
}
for (int i = 0; i < v[3].size(); i++) {
long long cur = pref[3][i];
int need = k - i - 1;
int h = i + 1 + 2 * max(0, need);
if (h > m) continue;
while (l >= need && l >= 0) {
add(id[v[1][l].second], v[1][l].first);
l--;
}
while (r >= need && r >= 0) {
add(id[v[2][r].second], v[2][r].first);
r--;
}
if ((int)v[1].size() < need || (int)v[2].size() < need) continue;
if (l >= 0) cur += pref[1][l] + pref[2][r];
cur += getprefones(m - h);
if (cur < ans) {
ans = cur;
b = i;
}
}
if (ans > 2e9)
puts("-1");
else {
printf("%lld\n", ans);
int need = k - b - 1;
vector<bool> vis(n + 1, 0);
for (int i = 0; i <= b; i++)
printf("%d ", v[3][i].second), vis[v[3][i].second] = 1;
for (int i = 0; i < v[3].size(); i++) vis[v[3][i].second] = 1;
for (int i = 0; i < need; i++)
printf("%d ", v[2][i].second), vis[v[2][i].second] = 1;
for (int i = 0; i < need; i++)
printf("%d ", v[1][i].second), vis[v[1][i].second] = 1;
int h = b + 1;
if (need > 0) h += 2 * need;
for (int i = 0; i < n && h < m; i++) {
if (vis[vec[i].second]) continue;
printf("%d ", vec[i].second);
h++;
}
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
bool rev(long long x, long long y) { return x > y; }
void input_arr(long long a[], long long n) {
for (long long i = 0; i < n; i += 1) cin >> a[i];
}
bool sortbysec(const pair<long long, long long> &a,
const pair<long long, long long> &b) {
return a.second < b.second;
}
bool sortinrev(const pair<long long, long long> &a,
const pair<long long, long long> &b) {
return (a.first > b.first);
}
void print_vec(vector<long long> &v) {
for (auto i : v) cout << i << " ";
cout << '\n';
}
bool sortinrevbysec(const pair<long long, long long> &a,
const pair<long long, long long> &b) {
return (a.second > b.second);
}
void print_arr(long long a[], long long n) {
for (long long i = 0; i < n; i += 1) cout << a[i] << " ";
cout << '\n';
}
template <typename... T>
void input(T &...args) {
((cin >> args), ...);
}
template <typename... T>
void print(T &&...args) {
((cout << args << '\n'), ...);
}
template <typename... T>
void deb(T &&...args) {
cout << "~~ ";
((cout << args << " "), ...);
cout << '\n';
}
void stand8th() {
long long n, k;
input(n, k);
long long t, a, b;
vector<long long> al, bo, bt;
long long no = 0;
for (long long i = 0; i < n; i += 1) {
input(t, a, b);
if (a == 1 && b == 1) {
bt.push_back(t);
} else if (a == 1) {
al.push_back(t);
} else if (b == 1) {
bo.push_back(t);
} else {
no++;
}
}
if ((long long)(al.size()) + (long long)(bo.size()) +
2 * (long long)(bt.size()) <
2 * k) {
print(-1);
return;
}
sort((al).begin(), (al).end());
sort((bo).begin(), (bo).end());
sort((bt).begin(), (bt).end());
for (long long i = 1; i < (long long)(al.size()); i += 1) al[i] += al[i - 1];
for (long long i = 1; i < (long long)(bo.size()); i += 1) bo[i] += bo[i - 1];
for (long long i = 1; i < (long long)(bt.size()); i += 1) bt[i] += bt[i - 1];
long long ans = INT64_MAX;
for (long long i = 0; i < min((long long)(bt.size()), k); i += 1) {
long long x = k - i - 1;
if (x != 0 && (long long)(al.size()) >= x && (long long)(bo.size()) >= x) {
ans = min(ans, bt[i] + al[x - 1] + bo[x - 1]);
} else {
if (x == 0) {
ans = min(ans, bt[i]);
}
}
}
if ((long long)(al.size()) >= k && (long long)(bo.size()) >= k) {
ans = min(ans, al[k - 1] + bo[k - 1]);
}
if (ans == INT64_MAX) {
ans = -1;
}
print(ans);
}
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
long long tin = 1;
while (tin--) {
stand8th();
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int N = INT_MAX;
long long INF1 = 1e9 + 5;
long long INF2 = 1e18L + 5;
map<long long, long long> my;
int h[10005];
int main() {
int n, k;
cin >> n >> k;
int chk1 = 0, chk2 = 0;
int a, b, c;
vector<int> v1, v2, v3;
for (int i = 0; i < n; i++) {
cin >> a >> b >> c;
if (b == 1 && c == 1) {
v1.push_back(a);
} else if (b == 1 && c == 0) {
v2.push_back(a);
} else if (b == 0 && c == 1) {
v3.push_back(a);
}
chk1 += b;
chk2 += c;
}
if (chk1 < k || chk2 < k) {
cout << -1;
return 0;
}
int n1 = v1.size(), n2 = v2.size(), n3 = v3.size();
int x = min(n2, n3);
sort(v2.begin(), v2.end());
sort(v3.begin(), v3.end());
for (int i = 0; i < x; i++) {
v1.push_back(v2[i] + v3[i]);
}
sort(v1.begin(), v1.end());
long long ans = 0;
for (int i = 0; i < k; i++) {
ans += v1[i];
}
cout << ans;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
void solve() {
int n, k;
cin >> n >> k;
vector<int> a, b, c;
for (int i = 0; i < n; i++) {
int x, y, z;
cin >> x >> y >> z;
if (y == 0 && z == 0)
continue;
else if (y == 1 && z == 0)
a.push_back(x);
else if (y == 0 && z == 1)
b.push_back(x);
else
c.push_back(x);
}
sort(a.begin(), a.end());
sort(b.begin(), b.end());
sort(c.begin(), c.end());
int n1 = a.size();
int n2 = b.size();
int n3 = c.size();
for (int i = 1; i < n1; i++) {
a[i] += a[i - 1];
}
for (int i = 1; i < n2; i++) {
b[i] += b[i - 1];
}
for (int i = 1; i < n3; i++) {
c[i] += c[i - 1];
}
int ans = INT_MAX;
int r = k;
if (r <= n1 && r <= n2) {
ans = min(ans, (r - 1 >= 0 ? a[r - 1] : 0) + (r - 1 >= 0 ? b[r - 1] : 0));
}
int s = 0;
for (int i = 0; i < k && i < n3; i++) {
int r = k - i - 1;
s = c[i];
if (r <= n1 && r <= n2) {
ans = min(ans,
s + (r - 1 >= 0 ? a[r - 1] : 0) + (r - 1 >= 0 ? b[r - 1] : 0));
}
}
if (n3 >= k) ans = min(ans, c[k - 1]);
if (ans == INT_MAX)
cout << "-1\n";
else
cout << ans << '\n';
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
int tt;
tt = 1;
while (tt--) solve();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long INF = 1e16;
class segTree {
public:
vector<long long> t;
int n;
segTree(int n) {
t.resize(n * 2 + 5, 0);
this->n = n;
}
void build() {
for (int i = n - 1; i > 0; --i) t[i] = t[i << 1] + t[i << 1 | 1];
}
void update(int p, long long value) {
for (t[p += n] += value; p > 1; p >>= 1) t[p >> 1] = t[p] + t[p ^ 1];
}
long long query(int l, int r) {
long long ret = 0;
r++;
for (l += n, r += n; l < r; l >>= 1, r >>= 1) {
if (l & 1) ret += t[l++];
if (r & 1) ret += t[--r];
}
return ret;
}
};
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
long long n, m, k;
cin >> n >> m >> k;
vector<pair<long long, long long>> a, b, c, d;
for (long long i = 0; i < n; i++) {
long long x, y, z;
cin >> x >> y >> z;
if (y == 0 && z == 0) {
d.push_back({x, i});
continue;
}
if (y && z)
a.push_back({x, i});
else if (y && !z)
b.push_back({x, i});
else
c.push_back({x, i});
}
sort(a.begin(), a.end());
sort(b.begin(), b.end());
sort(c.begin(), c.end());
sort(d.begin(), d.end());
vector<long long> sumA(a.size() + 1, 0), sumB(b.size() + 1, 0),
sumC(c.size() + 1, 0), sumD(d.size() + 1, 0);
for (long long i = 0; i < a.size(); i++) {
sumA[i + 1] = sumA[i] + a[i].first;
}
for (long long i = 0; i < b.size(); i++) {
sumB[i + 1] = sumB[i] + b[i].first;
}
for (long long i = 0; i < c.size(); i++) {
sumC[i + 1] = sumC[i] + c[i].first;
}
for (long long i = 0; i < d.size(); i++) {
sumD[i + 1] = sumD[i] + d[i].first;
}
vector<unordered_set<long long>> curr(1e4 + 5);
segTree *T1 = new segTree(1e4 + 5), *T2 = new segTree(1e4 + 5);
for (long long i = 0; i < d.size(); i++) {
T1->update(d[i].first, 1);
T2->update(d[i].first, d[i].first);
curr[d[i].first].insert(d[i].second);
}
for (long long i = 0; i < b.size(); i++) {
T1->update(b[i].first, 1);
T2->update(b[i].first, b[i].first);
curr[b[i].first].insert(b[i].second);
}
for (long long i = 0; i < c.size(); i++) {
T1->update(c[i].first, 1);
T2->update(c[i].first, c[i].first);
curr[c[i].first].insert(c[i].second);
}
long long ret = INF, pos = -1, pos2 = -1, pos3 = -1;
long long posA = a.size(), posB = 0, posC = 0;
for (long long i = k; i >= 0; i--) {
if (i > a.size()) continue;
if ((k - i) > min(b.size(), c.size())) continue;
if (i + 2 * (k - i) > m) continue;
for (long long j = i; j < posA; j++) {
T1->update(a[j].first, 1);
T2->update(a[j].first, a[j].first);
curr[a[j].first].insert(a[j].second);
}
posA = i;
long long need = m - i - 2 * (k - i);
for (long long j = posB; j < k - i; j++) {
T1->update(b[j].first, -1);
T2->update(b[j].first, -b[j].first);
curr[b[j].first].erase(b[j].second);
}
for (long long j = posB; j < k - i; j++) {
T1->update(c[j].first, -1);
T2->update(c[j].first, -c[j].first);
curr[c[j].first].erase(c[j].second);
}
posB = k - i, posC = k - i;
if (T1->query(0, 1e4) < need) continue;
long long l = 1, r = 1e4;
long long minn = 1e4;
while (l <= r) {
long long mid = (l + r) / 2;
if (T1->query(0, mid) >= need) {
minn = min(minn, mid);
r = mid - 1;
} else
l = mid + 1;
}
long long tot = sumA[i] + sumB[k - i] + sumC[k - i];
long long have = T1->query(0, minn);
tot += T2->query(0, minn) - (have - need) * minn;
if (tot < ret) {
ret = tot;
pos = i;
}
}
if (pos == -1) cout << -1 << "\n", exit(0);
cout << ret << "\n";
for (long long i = 0; i < pos; i++) cout << a[i].second + 1 << " ";
for (long long i = 0; i < k - pos; i++)
cout << b[i].second + 1 << " " << c[i].second + 1 << " ";
T1 = new segTree(1e4 + 5), T2 = new segTree(1e4 + 5);
curr.assign(1e4 + 5, {});
for (long long i = 0; i < d.size(); i++) {
T1->update(d[i].first, 1);
T2->update(d[i].first, d[i].first);
curr[d[i].first].insert(d[i].second);
}
for (long long i = 0; i < b.size(); i++) {
T1->update(b[i].first, 1);
T2->update(b[i].first, b[i].first);
curr[b[i].first].insert(b[i].second);
}
for (long long i = 0; i < c.size(); i++) {
T1->update(c[i].first, 1);
T2->update(c[i].first, c[i].first);
curr[c[i].first].insert(c[i].second);
}
posA = a.size(), posB = 0, posC = 0;
for (long long i = k; i >= 0; i--) {
if (i > a.size()) continue;
if ((k - i) > min(b.size(), c.size())) continue;
if (i + 2 * (k - i) > m) continue;
for (long long j = i; j < posA; j++) {
T1->update(a[j].first, 1);
T2->update(a[j].first, a[j].first);
curr[a[j].first].insert(a[j].second);
}
posA = i;
long long need = m - i - 2 * (k - i);
for (long long j = posB; j < k - i; j++) {
T1->update(b[j].first, -1);
T2->update(b[j].first, -b[j].first);
curr[b[j].first].erase(b[j].second);
}
for (long long j = posB; j < k - i; j++) {
T1->update(c[j].first, -1);
T2->update(c[j].first, -c[j].first);
curr[c[j].first].erase(c[j].second);
}
posB = k - i, posC = k - i;
if (T1->query(0, 1e4) < need) continue;
long long l = 1, r = 1e4;
long long minn = 1e4;
while (l <= r) {
long long mid = (l + r) / 2;
if (T1->query(0, mid) >= need) {
minn = min(minn, mid);
r = mid - 1;
} else
l = mid + 1;
}
if (i == pos) {
for (long long j = 1; j < minn; j++) {
for (auto it : curr[j]) cout << it + 1 << " ", need--;
}
long long ct = 0;
for (auto it : curr[minn]) {
if (ct == need) break;
cout << it + 1 << " ";
ct++;
}
cout << "\n";
exit(0);
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int M = 998244353;
vector<int> both, al, bob;
int k;
int good(int cnt, int mi, int ma) {
if (cnt > mi && (both[cnt - 1] > al[k - cnt] + bob[k - cnt])) return -1;
if (cnt < ma && (both[cnt] < al[k - cnt - 1] + bob[k - cnt - 1])) return 1;
return 0;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
;
int n;
cin >> n >> k;
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)
al.push_back(t);
else if (b)
bob.push_back(t);
}
sort(both.begin(), both.end());
sort(al.begin(), al.end());
sort(bob.begin(), bob.end());
if ((int)min(al.size(), bob.size()) + both.size() < k)
cout << -1 << "\n";
else {
int mi = max(0, k - (int)min(al.size(), bob.size())),
ma = min(k, (int)both.size());
int i = mi, j = ma;
int res = -1;
while (j - i > 1) {
int mid = (i + j) >> 1;
int g = good(mid, mi, ma);
if (g < 0) j = mid;
if (g > 0) i = mid;
if (g == 0) {
res = mid;
break;
}
}
if (res < 0) {
if (good(j, mi, ma) == 0)
res = j;
else
res = i;
}
long long sol = 0;
for (i = 0; i < res; i++) sol += both[i];
for (i = 0; i < k - res; i++) sol += al[i] + bob[i];
cout << sol << "\n";
}
}
|
#include <bits/stdc++.h>
using namespace std;
const long long Mod = 1e5 + 7;
const int N = 2e6 + 5;
int arr[N];
int idx[4] = {0, 0, 0, 0};
vector<int> vec[4];
int take(int x) {
if (vec[x].size() <= idx[x]) return Mod;
return vec[x][idx[x]++];
}
int get(int x) {
if (vec[x].size() <= idx[x]) return Mod;
return arr[vec[x][idx[x]]];
}
bool comp(int x, int y) { return arr[x] < arr[y]; }
int main() {
ios::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
int numCases = 1;
for (int caseNo = 1; caseNo <= numCases; caseNo++) {
int n, k, m, sum_a = 0, sum_b = 0, sum = 0;
cin >> n >> m >> k;
set<int> ans;
for (int i = 0; i < n; i++) {
cin >> arr[i];
bool f, s;
cin >> f >> s;
if (f && s)
vec[0].push_back(i);
else if (f)
vec[1].push_back(i);
else if (s)
vec[2].push_back(i);
else
vec[3].push_back(i);
}
sort(vec[0].begin(), vec[0].end(), comp);
sort(vec[1].begin(), vec[1].end(), comp);
sort(vec[2].begin(), vec[2].end(), comp);
sort(vec[3].begin(), vec[3].end(), comp);
while (idx[0] < min({(int)vec[0].size(), m, k})) ans.insert(take(0));
sum_a = sum_b = idx[0];
while (sum_a < k) {
if (get(1) == Mod) break;
ans.insert(take(1));
sum_a++;
}
while (sum_b < k) {
if (get(2) == Mod) break;
ans.insert(take(2));
sum_b++;
}
while (ans.size() < m) {
int mn = 0;
for (int i = 1; i < 4; i++)
if (get(i) < get(mn)) mn = i;
if (idx[0] && get(1) + get(2) < arr[vec[0][idx[0] - 1]] + get(mn)) {
ans.erase(vec[0][--idx[0]]);
ans.insert(take(1));
ans.insert(take(2));
continue;
}
ans.insert(take(mn));
}
if (sum_a < k || sum_b < k || ans.size() > m) {
cout << -1 << endl;
continue;
}
for (auto u : ans) sum += arr[u];
cout << sum << '\n';
for (auto u : ans) cout << u + 1 << " ";
}
}
|
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using ull = unsigned long long;
using ld = long double;
template <typename T1, typename T2>
inline void chkmin(T1 &x, const T2 &y) {
if (x > y) x = y;
}
template <typename T1, typename T2>
inline void chkmax(T1 &x, const T2 &y) {
if (x < y) x = y;
}
int n, m, k;
vector<pair<int, int>> a[4];
void read() {
cin >> n >> m >> k;
for (int i = 0; i < n; i++) {
int t, f1, f2;
cin >> t >> f1 >> f2;
a[f1 * 2 + f2].push_back({t, i});
}
for (int i = 0; i <= 3; i++) sort(a[i].begin(), a[i].end());
}
set<pair<int, int>> L, R;
int sumSet;
void relax(int sz) {
sz = max(sz, 0);
while (L.size() > sz) {
auto x = *(--L.end());
L.erase(--L.end());
sumSet -= x.first;
R.insert(x);
}
while (L.size() < sz) {
if (R.empty()) break;
auto x = *(R.begin());
R.erase(R.begin());
L.insert(x);
sumSet += x.first;
}
}
void add(pair<int, int> a) {
if (R.empty()) {
L.insert(a);
sumSet += a.first;
} else if (L.empty()) {
R.insert(a);
} else if (*(R.begin()) < a) {
R.insert(a);
} else {
L.insert(a);
sumSet += a.first;
}
}
int ans;
vector<int> fans;
void getAns() {
ans = 2e9 + 228 + 1337;
for (int it = 0; it < 2; it++) {
L.clear();
R.clear();
sumSet = 0;
int sum = 0;
for (auto i : a[0]) add(i);
int top1 = a[1].size() - 1;
int top2 = a[2].size() - 1;
for (auto i : a[1]) sum += i.first;
for (auto i : a[2]) sum += i.first;
for (int i = 0; i <= min(m, (int)a[3].size()); i++) {
while (top1 >= 0 && top1 + 1 + i > k) {
sum -= a[1][top1].first;
add(a[1][top1]);
top1--;
}
while (top2 >= 0 && top2 + 1 + i > k) {
sum -= a[2][top2].first;
add(a[2][top2]);
top2--;
}
if (min(top1, top2) + 1 + i >= k) {
int sz = m - i - (top1 + 1) - (top2 + 1);
if (L.size() + R.size() >= sz) {
relax(sz);
if ((top1 + 1) + (top2 + 1) + i + (int)L.size() == m) {
ans = min(ans, sum + sumSet);
if (it == 1 && sum + sumSet == ans) {
for (auto j : L) {
fans.push_back(j.second);
}
for (int j = 0; j <= top1; j++) {
fans.push_back(a[1][j].second);
}
for (int j = 0; j <= top2; j++) {
fans.push_back(a[2][j].second);
}
for (int j = 0; j < i; j++) {
fans.push_back(a[3][j].second);
}
return;
}
}
}
}
if (i == a[3].size()) break;
sum += a[3][i].first;
}
}
cout << -1 << endl;
exit(0);
}
void run() { getAns(); }
void write() {
cout << ans << endl;
sort(fans.begin(), fans.end());
for (auto i : fans) {
cout << i + 1 << " ";
}
cout << endl;
}
signed main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
read();
run();
write();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
inline int read() {
int x = 0;
char ch;
while (!isdigit(ch = getchar()))
;
x = ch - 48;
while (isdigit(ch = getchar())) x = x * 10 + ch - 48;
return x;
}
const int MAXN = 2e5 + 5;
int n, m, k;
vector<pair<int, int> > t[4], tmp;
vector<int> ans;
inline int calc(int x) {
int ned = max(0, k - x), tot = 0;
if (ned > min(t[1].size(), t[2].size())) return 1e9;
for (int i = 0; i < x; i++) tot += t[3][i].first;
for (int i = 0; i < ned; i++) tot += t[1][i].first + t[2][i].first;
tmp.clear();
for (auto p : t[0]) tmp.push_back(p);
for (int i = x; i < t[3].size(); i++) tmp.push_back(t[3][i]);
for (int i = ned; i < t[2].size(); i++) tmp.push_back(t[2][i]);
for (int i = ned; i < t[1].size(); i++) tmp.push_back(t[1][i]);
sort(tmp.begin(), tmp.end());
for (int i = 0; i < m - x - 2 * ned; i++) tot += tmp[i].first;
return tot;
}
int main() {
n = read(), m = read(), k = read();
int tp1 = 0, tp2 = 0, tp3 = 0;
for (int i = 1, x, a, b; i <= n; i++)
x = read(), a = read(), b = read(), t[2 * a + b].push_back(make_pair(x, i)),
tp1 += a, tp2 += b, tp3 += a & b;
if (tp1 < k || tp2 < k || 2 * k - tp3 > m) {
puts("-1");
return 0;
}
for (int i = 0; i <= 3; i++) sort(t[i].begin(), t[i].end());
int l = max(0, 2 * k - m), r = t[3].size();
while (l < r) {
int mid1 = (2 * l + r) / 3, mid2 = (2 * r + l + 2) / 3;
if (calc(mid1) < calc(mid2))
r = mid2 - 1;
else
l = mid1 + 1;
}
int ned = max(0, k - l), tot = 0;
for (int i = 0; i < l; i++)
tot += t[3][i].first, ans.push_back(t[3][i].second);
for (int i = 0; i < ned; i++)
tot += t[1][i].first + t[2][i].first, ans.push_back(t[1][i].second),
ans.push_back(t[2][i].second);
tmp.clear();
for (auto p : t[0]) tmp.push_back(p);
for (int i = l; i < t[3].size(); i++) tmp.push_back(t[3][i]);
for (int i = ned; i < t[2].size(); i++) tmp.push_back(t[2][i]);
for (int i = ned; i < t[1].size(); i++) tmp.push_back(t[1][i]);
sort(tmp.begin(), tmp.end());
for (int i = 0; i < m - l - 2 * ned; i++)
tot += tmp[i].first, ans.push_back(tmp[i].second);
printf("%d\n", tot);
for (int x : ans) printf("%d ", x);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, k;
cin >> n >> k;
multiset<int> v, v0, v1;
for (int i = 0; i < n; i++) {
int t, a, b;
cin >> t >> a >> b;
if (a == 0 && b == 0) continue;
if (a == 0 && b == 1) {
v1.insert(t);
}
if (a == 1 && b == 0) v0.insert(t);
if (a == 1 && b == 1) v.insert(t);
}
int c = 0;
int ans = 0;
while (c < k) {
if (v0.size() == 0 && v.size() == 0) {
cout << "-1";
return 0;
}
if (v1.size() == 0 && v.size() == 0) {
cout << "-1";
return 0;
}
if (v1.size() == 0) {
ans += *(v.begin());
v.erase(v.begin());
c++;
continue;
}
if (v0.size() == 0) {
ans += *(v.begin());
v.erase(v.begin());
c++;
continue;
}
if (v.size() == 0) {
ans += *(v1.begin()) + *(v0.begin());
v1.erase(v1.begin());
v0.erase(v0.begin());
c++;
continue;
}
if (*(v.begin()) < *(v1.begin()) + *(v0.begin())) {
ans += *(v.begin());
v.erase(v.begin());
c++;
} else {
ans += *(v1.begin()) + *(v0.begin());
v1.erase(v1.begin());
v0.erase(v0.begin());
c++;
}
}
cout << ans << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
const double eps = 1e-8;
long long ii = 1;
void solve() {
long long n;
long long kk;
cin >> n >> kk;
vector<long long> alice;
vector<long long> bob;
vector<long long> all;
long long al = 0;
long long bo = 0;
for (long long i = 0; i < n; i++) {
long long t;
long long a;
long long b;
cin >> t >> a >> b;
if (a == 1 && b == 1) {
all.push_back(t);
al++;
bo++;
} else if (a == 1) {
al++;
alice.push_back(t);
} else if (b == 1) {
bo++;
bob.push_back(t);
}
}
if (al >= kk && bo >= kk) {
sort(all.begin(), all.end());
sort(alice.begin(), alice.end());
sort(bob.begin(), bob.end());
long long j = 0;
long long k = 0;
long long l = 0;
long long cn = 0;
long long ans = 0;
while (1) {
if (cn == kk) break;
if (j < all.size() && k < alice.size() && l < bob.size()) {
if (all[j] <= alice[k] + bob[l])
ans += all[j++];
else
ans += alice[k++] + bob[l++];
} else if (j < all.size())
ans += all[j++];
else
ans += alice[k++] + bob[l++];
cn++;
}
cout << ans << '\n';
} else
cout << "-1" << '\n';
}
int32_t main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
long long TestCase;
TestCase = 1;
while (TestCase--) solve();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n, k;
cin >> n >> k;
vector<long long> a;
vector<long long> b;
vector<long long> m;
for (long long i = 0; i < n; i = i + 1) {
long long t, aa, bb;
cin >> t >> aa >> bb;
if (aa == 1 && bb == 0) {
a.push_back(t);
}
if (aa == 0 && bb == 1) {
b.push_back(t);
}
if (aa == 1 && bb == 1) {
m.push_back(t);
}
}
sort(a.begin(), a.end());
sort(b.begin(), b.end());
sort(m.begin(), m.end());
long long na = a.size();
long long nb = b.size();
long long nm = m.size();
for (long long i = 1; i < na; i = i + 1) a[i] += a[i - 1];
for (long long i = 1; i < nb; i = i + 1) b[i] += b[i - 1];
for (long long i = 1; i < nm; i = i + 1) m[i] += m[i - 1];
long long ans = 1e18;
if (na >= k && nb >= k) ans = a[k - 1] + b[k - 1];
long long mi = min(nm, k);
for (long long i = 0; i < mi; i = i + 1) {
if (k - i - 2 >= 0 && k - i - 2 < na && k - i - 2 < nb)
ans = min(ans, m[i] + a[k - i - 2] + b[k - i - 2]);
}
if (nm >= k) ans = min(ans, m[k - 1]);
if (ans == 1e18)
cout << -1 << endl;
else
cout << ans << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n, k;
cin >> n >> k;
vector<tuple<long long, long long, long long>> v;
long long x = 0, y = 0, z = 0;
for (long long i = 0; i < n; i++) {
long long a, b, c;
cin >> a >> b >> c;
v.push_back(make_tuple(a, b, c));
if (b == 1 && c == 1) {
x++;
}
if (b == 1 && c == 0) {
y++;
}
if (b == 0 && c == 1) {
z++;
}
}
sort(v.begin(), v.end());
long long sum = 0;
long long sum1 = 0;
long long sum2 = 0;
long long j = 0, w = 0, q = 0;
long long a[x], b[y], c[z];
for (long long i = 0; i < v.size(); i++) {
if (get<1>(v[i]) == get<2>(v[i]) && get<2>(v[i]) == 1) {
sum += get<0>(v[i]);
a[j] = sum;
j++;
}
if (get<1>(v[i]) == 1 && get<2>(v[i]) == 0) {
sum1 += get<0>(v[i]);
b[w] = sum1;
w++;
}
if (get<1>(v[i]) == 0 && get<2>(v[i]) == 1) {
sum2 += get<0>(v[i]);
c[q] = sum2;
q++;
}
}
if ((w + j) < k || (j + q) < k) {
cout << -1 << "\n";
} else {
long long ans = 10000000000;
if ((q) >= k && (w) >= k) {
ans = b[k - 1] + c[k - 1];
}
for (long long i = 0; i < j; i++) {
if ((k - i - 2) >= 0 && (k - i - 2) < w && (k - i - 2) < q) {
if ((ans) > (a[i] + b[k - i - 2] + c[k - i - 2])) {
ans = a[i] + b[k - i - 2] + c[k - i - 2];
}
}
if ((k - i - 2) < 0) {
if (j >= k) {
if ((ans) > a[k - 1]) {
ans = a[k - 1];
}
}
}
}
cout << ans << "\n";
}
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
int tt;
cin >> tt;
while (tt--) {
int n;
cin >> n;
vector<int> a(n);
for (int i = 0; i < n; ++i) {
cin >> a[i];
}
if (a[0] + a[1] <= a.back()) {
cout << "1 2 " << n << '\n';
goto nx;
}
cout << "-1\n";
nx:;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
long long t, n;
long long arr[1000000];
cin >> t;
for (int a = 1; a <= t; a++) {
cin >> n;
for (int i = 0; i < n; i++) {
cin >> arr[i];
}
if (arr[0] + arr[1] <= arr[n - 1]) {
cout << 1 << " " << 2 << " " << n << "\n";
} else
cout << -1 << "\n";
}
}
|
#include <bits/stdc++.h>
using namespace std;
using ull = unsigned long long;
using ll = long long int;
ll binpow(ll a, ll b) {
ll res = 1;
while (b > 0) {
if (b & 1) {
res = res * a;
}
a = a * a;
b >>= 1;
}
return res;
}
void solve() {
ll n;
cin >> n;
ll ar[n + 1];
for (ll i = 0; i < n; i++) {
cin >> ar[i];
}
ll mn[n + 1];
ll mx[n + 1];
mn[0] = 0;
for (ll i = 1; i < n; i++) {
if (ar[i] < ar[mn[i - 1]]) {
mn[i] = i;
} else {
mn[i] = mn[i - 1];
}
}
mx[n - 1] = n - 1;
for (ll i = (n - 2); i >= 0; i--) {
if (ar[i] > ar[mx[i + 1]]) {
mx[i] = i;
} else {
mx[i] = mx[i + 1];
}
}
for (ll i = 0; i < n; i++) {
if ((ar[i] + ar[mn[i]] <= ar[mx[i]]) && (i != mn[i]) && (i != mx[i])) {
cout << mn[i] + 1 << " " << i + 1 << " " << mx[i] + 1 << "\n";
return;
}
}
cout << -1 << "\n";
return;
}
int main() {
ios_base::sync_with_stdio(false), cin.tie(NULL), cout.tie(NULL);
ll t = 1;
cin >> t;
while (t--) {
solve();
}
}
|
#include <bits/stdc++.h>
using namespace std;
bool cmp(int a, int b) { return a > b; }
int main() {
int t, n, a, b, c, d;
cin >> t;
while (t--) {
cin >> n;
for (int i = 0; i < n; i++) {
if (i == 0)
scanf("%d", &a);
else if (i == 1) {
scanf("%d", &b);
} else if (i == (n - 1)) {
scanf("%d", &d);
} else {
scanf("%d", &c);
}
}
if (a + b <= d)
printf("1 2 %d\n", n);
else
printf("-1\n");
}
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int t;
cin >> t;
while (t--) {
int n;
cin >> n;
vector<int> vc(n);
for (int i = 0; i < n; i++) {
cin >> vc[i];
}
int i;
int count = 0;
for (i = 0; i < n - 2; i++) {
if (vc[i] + vc[i + 1] <= vc[n - 1]) {
cout << i + 1 << " " << i + 2 << " " << n << endl;
count++;
break;
}
}
if (count == 0) cout << -1 << endl;
}
}
|
#include <bits/stdc++.h>
using namespace std;
void IO() {}
int ar[50005];
char ch[50005];
int m, n, k, ii;
void solve() {
scanf("%d", &n);
vector<pair<int, int>> v;
for (int i = 1; i <= n; i++) {
scanf("%d", &ar[i]);
v.push_back({ar[i], i});
}
sort(v.begin(), v.end());
if (v[0].first + v[1].first <= v[n - 1].first) {
printf("%d %d %d\n", v[0].second, v[1].second, v[n - 1].second);
} else
printf("-1\n");
}
int main() {
IO();
int t = 1;
scanf("%d", &t);
while (t--) {
solve();
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
int t;
cin >> t;
while (t--) {
int n;
cin >> n;
vector<int> v(n);
for (auto &i : v) cin >> i;
if (v[0] + v[1] > v[n - 1])
cout << "-1\n";
else
cout << 1 << " " << 2 << " " << n << '\n';
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
inline int Int() {
int x;
cin >> x;
return x;
}
inline long long Long() {
long long x;
cin >> x;
return x;
}
inline float Float() {
float x;
cin >> x;
return x;
}
inline double Double() {
double x;
cin >> x;
return x;
}
inline void Yes() { cout << "Yes" << endl; }
inline void No() { cout << "No" << endl; }
inline void YES() { cout << "YES" << endl; }
inline void NO() { cout << "NO" << endl; }
const int N = (int)2e5 + 5;
const int maxN = (int)1e6 + 6;
const long long Mod = (long long)1e9 + 7;
const int inf = (int)2e9;
const long long Inf = (long long)1e18;
int main() {
ios_base::sync_with_stdio(false), cin.tie(NULL);
int t, q;
cin >> t;
for (q = 1; q <= t; q++) {
long long n, i, x, c = 0, c1 = 1, c2 = 1, c3 = 1;
cin >> n;
long long a[n], b[n];
for (int i = 0; i < n; i++) {
cin >> a[i];
b[i] = a[i];
}
sort(b, b + n);
for (i = n - 1; i >= 2; i--) {
if (b[0] + b[1] <= b[i]) {
x = b[i];
c = 1;
break;
}
}
if (c) {
vector<long long> v;
for (i = 0; i < n; i++) {
if (v.size() == 3) break;
if (b[0] == a[i] and c1) {
v.push_back(i + 1);
c1 = 0;
} else if (b[1] == a[i] and c2) {
v.push_back(i + 1);
c2 = 0;
} else if (x == a[i] and c3) {
v.push_back(i + 1);
c3 = 0;
}
}
sort(v.begin(), v.end());
for (i = 0; i < 3; i++) cout << v[i] << " ";
cout << endl;
} else
cout << -1 << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
void solve() {
long long n, i;
cin >> n;
vector<long long> v(n);
for (i = 0; i < n; i++) cin >> v[i];
if (v[0] + v[1] <= v[n - 1])
cout << '1' << " " << '2' << " " << n << "\n";
else
cout << "-1"
<< "\n";
return;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
long long t = 1;
cin >> t;
while (t--) solve();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long GCD(long long x, long long y) {
if (y == 0) return x;
return GCD(y, x % y);
}
long long LCM(long long x, long long y) { return (x * y) / (GCD(x, y)); }
long long LOGK(long long x, long long k) {
if (x >= k) return 1 + LOGK(x / k, k);
return 0;
}
long long MPOW(long long a, long long b, long long m) {
if (b == 0) return 1;
long long x = MPOW(a, b / 2, m);
x = (x * x) % m;
if (b % 2 == 1) x = (x * a) % m;
return x;
}
long long MINV(long long a, long long m) { return MPOW(a, m - 2, m); }
class pnc {
long long FACT_MAX, MODU;
vector<long long> fact;
public:
pnc(long long n, long long m) {
FACT_MAX = n;
fact.resize(FACT_MAX);
MODU = m;
MFACT_INIT(MODU);
}
void MFACT_INIT(long long m) {
fact[0] = 1;
for (long long i = 1; i < FACT_MAX; ++i) fact[i] = (i * fact[i - 1]) % MODU;
}
long long MFACT(long long n) { return fact[n]; }
long long PERM(long long n, long long r) {
return (fact[n] * ::MINV(fact[n - r], MODU)) % MODU;
}
long long COMB(long long n, long long r) {
return (PERM(n, r) * ::MINV(fact[r], MODU)) % MODU;
}
};
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
long long test = 1;
cin >> test;
while (test--) {
long long n;
cin >> n;
long long ar[n];
for (long long i = 0; i < n; i++) cin >> ar[i];
if (ar[0] + ar[1] <= ar[n - 1]) {
cout << 1 << ' ' << 2 << ' ' << n;
cout << "\n";
continue;
}
if (ar[n - 1] - ar[n - 2] >= ar[0]) {
cout << 1 << ' ' << n - 1 << ' ' << n;
cout << "\n";
continue;
}
cout << -1 << "\n";
}
}
|
#include <bits/stdc++.h>
int main() {
int t;
scanf("%d", &t);
while (t--) {
int n;
scanf("%d", &n);
int a[50005];
for (int x = 0; x < n; x++) {
scanf("%d", &a[x]);
}
if (a[0] + a[1] > a[n - 1]) {
printf("-1\n");
} else {
printf("1 2 %d\n", n);
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n;
const int N = 5e4 + 10;
int a[N];
void solve() {
cin >> n;
for (int i = 0; i < n; ++i) cin >> a[i];
cout << (a[0] + a[1] > a[n - 1] ? "-1" : "1 2 " + to_string(n)) << "\n";
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int t = 1;
cin >> t;
while (t--) solve();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int t;
cin >> t;
while (t--) {
int size;
cin >> size;
std::vector<int> v(size);
for (auto& x : v) cin >> x;
if (v[0] + v[1] > v[size - 1])
cout << -1 << endl;
else
cout << 1 << " " << 2 << " " << size << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int INF = 1e9 + 7;
const int N = 1e5 + 5;
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
;
int t;
cin >> t;
while (t--) {
int n;
cin >> n;
vector<long long int> a(n);
for (int i = 0; i < n; ++i) {
cin >> a[i];
}
int i = a[0];
int k = a[n - 1];
for (int j = 1; j < n - 1; ++j) {
if (i + a[j] <= k) {
cout << 1 << " " << j + 1 << " " << n;
break;
} else if (i + a[j] > k) {
cout << -1;
break;
}
}
cout << endl;
}
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int t;
scanf("%d", &t);
while (t--) {
int n;
scanf("%d", &n);
int a[n + 1];
for (int i = 0; i < n; i++) {
scanf("%d", &a[i]);
}
if (a[0] + a[1] > a[n - 1]) {
printf("-1\n");
continue;
} else {
printf("%d %d %d\n", 1, 2, n);
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long max_n = 1000000000;
int main() {
long long t;
cin >> t;
while (t--) {
int n;
cin >> n;
int arr[n];
for (int i = 0; i < n; i++) {
cin >> arr[i];
}
sort(arr, arr + n);
int a = arr[0];
int b = arr[1];
int c = arr[n - 1];
if (arr[0] + arr[1] <= arr[n - 1]) {
cout << 1 << " " << 2 << " " << n << endl;
} else {
cout << -1 << endl;
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int t;
cin >> t;
while (t--) {
int n;
cin >> n;
int v[n];
for (int i = 0; i < n; i++) {
cin >> v[i];
}
if (v[0] + v[1] <= v[n - 1])
cout << 1 << " " << 2 << " " << n << endl;
else
cout << -1 << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 501011;
int a[MAXN];
int main() {
int T;
scanf("%d", &T);
while (T--) {
int n;
scanf("%d", &n);
for (int i = 1; i <= n; ++i) scanf("%d", &a[i]);
if (a[1] + a[2] > a[n])
printf("-1\n");
else
printf("1 2 %d\n", n);
}
return 0;
}
|
#include <bits/stdc++.h>
int main() {
int t;
scanf("%d", &t);
while (t--) {
long long int n, i, j, k, f = 0;
scanf("%lld", &n);
long long int a[n];
for (i = 0; i < n; i++) scanf("%lld", &a[i]);
if (a[0] + a[1] <= a[n - 1])
printf("1 2 %lld\n", n);
else
printf("-1\n");
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
const long long maxn = 3e6;
const long long mod = 1e9 + 7;
const long double PI = acos((long double)-1);
long long pw(long long a, long long b, long long md = mod) {
long long res = 1;
while (b) {
if (b & 1) {
res = (a * res) % md;
}
a = (a * a) % md;
b >>= 1;
}
return (res);
}
int n, q;
int a[maxn];
int srt[maxn];
bool comp(int i, int j) { return (a[i] < a[j]); }
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cin >> q;
while (q--) {
cin >> n;
for (int i = 1; i <= n; i++) {
cin >> a[i];
srt[i] = i;
}
sort(srt + 1, srt + 1 + n, comp);
int x = a[srt[1]], y = a[srt[2]], z = a[srt[n]];
if (z < x + y) {
cout << -1 << '\n';
continue;
} else {
int b[] = {srt[1], srt[2], srt[n]};
sort(b, b + 3);
cout << b[0] << ' ' << b[1] << ' ' << b[2] << '\n';
}
}
return (0);
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
long long int t, i, j, a, n;
cin >> t;
while (t--) {
cin >> n;
long long int a[n + 5], f = 0;
for (i = 0; i < n; i++) cin >> a[i];
for (i = 0; i < n - 2; i++) {
if (a[i] + a[i + 1] <= a[n - 1]) {
cout << i + 1 << " " << i + 2 << " " << n << '\n';
f = 1;
break;
}
}
if (f == 0) cout << -1 << '\n';
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main(void) {
int n;
cin >> n;
while (n--) {
int t;
cin >> t;
map<int, int> mp;
int a[t], b[3];
for (int i = 0; i < t; i++) {
cin >> a[i];
mp[a[i]] = i + 1;
}
sort(b, b + 3);
if (a[0] + a[1] > a[t - 1]) {
cout << -1;
} else {
cout << 1 << " " << 2 << " " << t;
}
cout << endl;
}
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int t;
cin >> t;
while (t--) {
int n, flag1 = 0, flag2 = 0;
cin >> n;
long long a[n];
for (int i = 0; i < n; i++) cin >> a[i];
if ((a[0] + a[1]) <= a[n - 1]) {
cout << "1 "
<< "2 " << n << endl;
} else {
cout << "-1" << endl;
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
struct HASH {
static uint64_t splitmix64(uint64_t x) {
x += 0x9e3779b97f4a7c15;
x = (x ^ (x >> 30)) * 0xbf58476d1ce4e5b9;
x = (x ^ (x >> 27)) * 0x94d049bb133111eb;
return x ^ (x >> 31);
}
size_t operator()(uint64_t x) const {
static const uint64_t FIXED_RANDOM =
chrono::steady_clock::now().time_since_epoch().count();
return splitmix64(x + FIXED_RANDOM);
}
static uint64_t splitmix64(const pair<long long, long long>& p) {
static const uint64_t FIXED_RANDOM =
chrono::steady_clock::now().time_since_epoch().count();
long long x = p.first + FIXED_RANDOM, y = p.second + FIXED_RANDOM;
x += 0x9e3779b97f4a7c15;
x = (x ^ (x >> 30)) * 0xbf58476d1ce4e5b9;
x = (x ^ (x >> 27)) * 0x94d049bb133111eb;
y += 0x9e3779b97f4a7c15;
y = (y ^ (y >> 30)) * 0xbf58476d1ce4e5b9;
y = (y ^ (y >> 27)) * 0x94d049bb133111eb;
return x ^ (x >> 31) ^ y ^ (y >> 31);
}
size_t operator()(const pair<long long, long long>& p) const {
static const uint64_t FIXED_RANDOM =
chrono::steady_clock::now().time_since_epoch().count();
return splitmix64(p);
}
};
const int dx4[4] = {-1, 0, 1, 0}, dy4[4] = {0, 1, 0, -1};
const int dx8[8] = {-1, -1, 0, 1, 1, 1, 0, -1},
dy8[8] = {0, 1, 1, 1, 0, -1, -1, -1};
int n;
string str;
void solve() {
int m, a, b, c;
cin >> n;
int arr[n];
for (int i = 0; i < (int)n; i++) cin >> arr[i];
sort(arr, arr + n);
if (arr[0] + arr[1] <= arr[n - 1]) {
cout << "1 2 " << n << endl;
return;
}
cout << "-1\n";
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
;
int tc = 1;
cin >> tc;
while (tc--) {
solve();
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int t;
cin >> t;
while (t--) {
int n;
cin >> n;
int a[50001];
for (int i = 0; i < n; i++) cin >> a[i];
if (a[0] + a[1] > a[n - 1]) {
cout << -1 << endl;
} else {
cout << 1 << " " << 2 << " " << n << endl;
}
}
return 0;
}
|
#include <bits/stdc++.h>
#pragma GCC optimizer("O3")
#pragma GCC target("sse4")
using namespace std;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int t;
cin >> t;
while (t--) {
long long int n;
cin >> n;
vector<long long int> a(n);
for (long long int i = 0; i < n; i++) cin >> a[i];
if ((a[0] + a[1]) <= a[n - 1]) {
cout << 1 << " " << 2 << " " << n << endl;
} else
cout << "-1\n";
}
}
|
#include <bits/stdc++.h>
using namespace std;
int32_t main() {
long long t;
cin >> t;
while (t--) {
long long n;
cin >> n;
long long arr[n];
for (long long i = 0; i < n; i++) {
cin >> arr[i];
}
vector<long long> ans;
long long temp = arr[n - 1] - arr[0];
long long i = 0;
for (i = 1; i < n; i++) {
if (arr[i] <= temp) {
cout << "1 " << i + 1 << " " << n << "\n";
break;
}
}
if (i == n) {
cout << "-1\n";
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int t, n, val;
vector<int> v;
cin >> t;
for (int i = 0; i < t; i++) {
cin >> n;
for (int j = 0; j < n; j++) {
cin >> val;
v.push_back(val);
}
if (v[0] + v[1] > v[n - 1]) {
cout << -1 << endl;
} else {
cout << "1 "
<< "2 " << n << endl;
}
v.clear();
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int t;
cin >> t;
vector<vector<int>> v(t);
int n;
int temp;
for (int i = 0; i < t; i++) {
cin >> n;
v[i].reserve(n);
for (int j = 0; j < n; j++) {
cin >> temp;
v[i].push_back(temp);
}
}
for (int i = 0; i < t; i++) {
if (v[i][v[i].size() - 1] >= v[i][0] + v[i][1])
cout << 1 << " " << 2 << " " << v[i].size() << endl;
else
cout << -1 << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int t;
cin >> t;
while (t--) {
long long int n;
cin >> n;
long long int a[n];
for (int i = 0; i < n; i++) cin >> a[i];
if (a[0] + a[1] > a[n - 1])
cout << -1 << endl;
else
cout << 1 << " " << 2 << " " << n << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
void solve(bool& flag) {
int n;
cin >> n;
vector<int> a(n);
for (int i = 0; i < n; i++) {
cin >> a[i];
}
if (n < 3) {
return;
} else {
if (a[0] + a[1] <= a[n - 1]) {
cout << 1 << " " << 2 << " " << n << endl;
flag = true;
}
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
int test;
cin >> test;
while (test--) {
bool flag = false;
solve(flag);
if (not flag) {
cout << -1 << endl;
}
}
}
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.