solution
stringlengths 11
983k
| difficulty
int64 0
21
| language
stringclasses 2
values |
|---|---|---|
n,k=map(int,input().split())
t=[]
a=[]
b=[]
an=k
bn=k
for i in range(n):
t1,a1,b1=map(int,input().split())
t.append(t1)
a.append(a1)
b.append(b1)
both_like=[]
a_like=[]
b_like=[]
for i in range(n):
if(a[i]==1 and b[i]==1):
both_like.append(t[i])
elif(a[i]==1 and b[i]==0):
a_like.append(t[i])
elif(a[i]==0 and b[i]==1):
b_like.append(t[i])
both_like.sort()
a_like.sort()
b_like.sort()
ans=0
i=0
j=0
k=0
while(i<len(both_like) and an>0 and bn>0):
if(j<len(a_like) and k<len(b_like) and both_like[i]>=a_like[j]+b_like[k]):
ans+=a_like[j]+b_like[k]
j+=1
k+=1
an-=1
bn-=1
else:
ans+=both_like[i]
i+=1
an-=1
bn-=1
while(an>0 and j<len(a_like)):
ans+=a_like[j]
j+=1
an-=1
while(bn>0 and k<len(b_like)):
ans+=b_like[k]
k+=1
bn-=1
if(an==0 and bn==0):
print(ans)
else:
print(-1)
| 11 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
template <typename T = int>
struct Fenwick {
int n;
vector<T> v;
Fenwick(int size = 100005) : n(size), v(n + 1, 0) {}
inline void add(int p, T val) {
for (; p <= n; p += (p & -p)) {
v[p] += val;
}
}
inline T query(int p) {
T tmp = 0;
for (; p > 0; p -= (p & -p)) {
tmp += v[p];
}
return tmp;
}
inline T query(int l, int r) { return query(r) - query(l - 1); }
};
template <typename T>
T bs_first(T l, T r, function<bool(T)> f) {
assert(l < r);
T mid;
while (l != r) {
mid = l + (r - l) / 2;
if (f(mid)) {
r = mid;
} else {
l = mid + 1;
}
}
return r;
}
void solve() {
int n, m, k;
cin >> n >> m >> k;
vector<int> a(n);
vector<int> g[2][2];
for (int i = 0; i < n; i++) {
cin >> a[i];
int x, y;
cin >> x >> y;
g[x][y].push_back(i);
}
int lb, ub;
{
int c = min(g[0][1].size(), g[1][0].size());
lb = max({0, k - c, 2 * k - m});
ub = min(k, (int)g[1][1].size());
}
if (lb > ub) {
cout << -1;
return;
}
auto comp = [&](int u, int v) { return a[u] < a[v]; };
vector<int> id(n);
iota(id.begin(), id.end(), 0);
sort(id.begin(), id.end(), comp);
for (int x = 0; x < 2; x++) {
for (int y = 0; y < 2; y++) {
sort(g[x][y].begin(), g[x][y].end(), comp);
}
}
vector<int> pos(n);
Fenwick<int> sum(n), sz(n);
for (int i = 0; i < n; i++) {
sz.add(i + 1, 1);
sum.add(i + 1, a[id[i]]);
pos[id[i]] = i;
}
int must = 0;
auto add = [&](int i) {
sz.add(pos[i] + 1, 1);
sum.add(pos[i] + 1, a[i]);
must -= a[i];
};
auto del = [&](int i) {
sz.add(pos[i] + 1, -1);
sum.add(pos[i] + 1, -a[i]);
must += a[i];
};
for (int x = 0; x < lb; x++) {
int i = g[1][1][x];
del(i);
}
for (int y = 0; y < k - lb; y++) {
int i = g[0][1][y];
del(i);
i = g[1][0][y];
del(i);
}
int mi = 2e9 + 10, z = -1;
for (int x = lb; x <= ub; x++) {
int need = m - x - 2 * (k - x);
int p = bs_first<int>(0, n + 1, [&](int p) { return sz.query(p) >= need; });
int tmp = must + sum.query(p);
if (tmp < mi) {
mi = tmp;
z = x;
}
if (x == ub) break;
int i = g[1][1][x];
del(i);
i = g[0][1][k - x - 1];
add(i);
i = g[1][0][k - x - 1];
add(i);
}
assert(z != -1);
vector<bool> trk(n);
vector<int> res;
for (int x = 0; x < z; x++) {
int i = g[1][1][x];
res.push_back(i);
trk[i] = true;
}
for (int y = 0; y < k - z; y++) {
int i = g[0][1][y];
res.push_back(i);
trk[i] = true;
i = g[1][0][y];
res.push_back(i);
trk[i] = true;
}
for (int i : id)
if (!trk[i] && (int)res.size() < m) {
res.push_back(i);
trk[i] = true;
}
int ans = 0;
for (int i : res) ans += a[i];
assert(ans == mi);
cout << ans << "\n";
for (int i : res) cout << i + 1 << ' ';
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
solve();
return 0;
}
| 11 | CPP |
#include <bits/stdc++.h>
using namespace std;
const long long mxn = 100010;
void solve(long long tc) {
long long n, k, x, y, z;
cin >> n >> k;
deque<long long> d00, d01, d10, d11;
for (long long i = 0; i < n; i++) {
cin >> x >> y >> z;
if (y == 0 && z == 0)
d00.push_back(x);
else if (y == 0 && z == 1)
d01.push_back(x);
else if (y == 1 && z == 0)
d10.push_back(x);
else
d11.push_back(x);
}
sort(d00.begin(), d00.end());
sort(d01.begin(), d01.end());
sort(d10.begin(), d10.end());
sort(d11.begin(), d11.end());
long long ans = 0;
while (k--) {
if (!d01.empty() && !d10.empty()) {
if (!d11.empty()) {
if (d01.front() + d10.front() <= d11.front()) {
ans += d01.front() + d10.front();
d01.pop_front();
d10.pop_front();
} else {
ans += d11.front();
d11.pop_front();
}
} else {
ans += d01.front() + d10.front();
d01.pop_front();
d10.pop_front();
}
} else if (!d11.empty()) {
ans += d11.front();
d11.pop_front();
} else {
cout << -1 << '\n';
return;
}
}
cout << ans << '\n';
}
int32_t main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
solve(1);
return 0;
}
| 11 | CPP |
#include <bits/stdc++.h>
const long long INF = 1000000000000000001;
using namespace std;
mt19937 random1(179);
struct Node {
Node* l;
Node* r;
long long x, y, sum1, num, len;
Node(long long x1)
: x(x1), y(random1()), l(nullptr), r(nullptr), sum1(x1), num(1), len(1) {}
};
void update(Node* tree) {
if (tree == nullptr) {
return;
}
tree->sum1 = tree->x * tree->num, tree->len = tree->num;
if (tree->l != nullptr) {
tree->sum1 += tree->l->sum1, tree->len += tree->l->len;
}
if (tree->r != nullptr) {
tree->sum1 += tree->r->sum1, tree->len += tree->r->len;
}
}
Node* merge(Node* tree1, Node* tree2) {
if (tree1 == nullptr) {
return tree2;
}
if (tree2 == nullptr) {
return tree1;
}
if (tree1->y < tree2->y) {
tree1->r = merge(tree1->r, tree2);
update(tree1);
return tree1;
} else {
tree2->l = merge(tree1, tree2->l);
update(tree2);
return tree2;
}
}
pair<Node*, Node*> split(Node* tree, long long x) {
if (tree == nullptr) {
return {nullptr, nullptr};
}
if (x == tree->x) {
Node* right = tree->r;
tree->r = nullptr;
update(tree);
return {tree, right};
} else if (x < tree->x) {
pair<Node*, Node*> tree1 = split(tree->l, x);
tree->l = nullptr;
update(tree);
return {tree1.first, merge(tree1.second, tree)};
} else {
pair<Node*, Node*> tree1 = split(tree->r, x);
tree->r = nullptr;
update(tree);
return {merge(tree, tree1.first), tree1.second};
}
}
long long sum_k(Node* tree, long long k) {
if (tree == nullptr) {
return 0;
}
long long now = (tree->l == nullptr ? 0 : tree->l->len),
sum1 = (tree->l == nullptr ? 0 : tree->l->sum1);
if (now <= k && now + tree->num >= k) {
return sum1 + tree->x * (k - now);
} else if (now < k) {
return sum_k(tree->r, k - now - tree->num) + sum1 + tree->x * tree->num;
} else {
return sum_k(tree->l, k);
}
}
Node* add(Node* tree, long long x) {
pair<Node*, Node*> tree1 = split(tree, x);
pair<Node*, Node*> tree2 = split(tree1.first, x - 1);
if (tree2.second == nullptr) {
Node* root = new Node(x);
return merge(merge(tree2.first, root), tree1.second);
} else {
tree2.second->num++;
update(tree2.second);
return merge(merge(tree2.first, tree2.second), tree1.second);
}
}
Node* del(Node* tree, long long x) {
pair<Node*, Node*> tree1 = split(tree, x);
pair<Node*, Node*> tree2 = split(tree1.first, x - 1);
if (tree2.second == nullptr || tree2.second->num == 1) {
return merge(tree2.first, tree1.second);
} else {
tree2.second->num--;
update(tree2.second);
return merge(merge(tree2.first, tree2.second), tree1.second);
}
}
signed main() {
ios::sync_with_stdio(false);
cin.tie(nullptr);
cout.tie(nullptr);
long long n, m, k;
cin >> n >> m >> k;
vector<pair<long long, long long> > s00, s01, s10, s11;
vector<long long> pref01 = {0}, pref10 = {0}, pref11 = {0};
for (long long q = 0; q < n; q++) {
long long t, x, y;
cin >> t >> x >> y;
if (x == 0 && y == 0) {
s00.push_back({t, q});
} else if (x == 0) {
s01.push_back({t, q});
} else if (y == 0) {
s10.push_back({t, q});
} else {
s11.push_back({t, q});
}
}
sort(s00.begin(), s00.end());
sort(s01.begin(), s01.end());
sort(s10.begin(), s10.end());
sort(s11.begin(), s11.end());
Node* DD = nullptr;
for (pair<long long, long long> q : s00) {
DD = add(DD, q.first);
}
for (pair<long long, long long> q : s01) {
pref01.push_back(pref01.back() + q.first);
DD = add(DD, q.first);
}
for (pair<long long, long long> q : s10) {
pref10.push_back(pref10.back() + q.first);
DD = add(DD, q.first);
}
for (pair<long long, long long> q : s11) {
pref11.push_back(pref11.back() + q.first);
}
long long ans = INF, ind = -1;
for (long long q1 = m; q1 > -1; q1--) {
if (q1 <= s11.size() &&
((DD != nullptr && DD->len >= m - q1 - 2 * max(0LL, k - q1)) ||
m == q1 + 2 * max(0LL, k - q1)) &&
m >= q1 + 2 * max(0LL, k - q1)) {
long long w = pref11[q1] + pref01[max(0LL, k - q1)] +
pref10[max(0LL, k - q1)] +
sum_k(DD, m - q1 - 2 * max(0LL, k - q1));
if (w < ans) {
ans = w, ind = q1;
}
}
if (k - q1 + 1 > min(s01.size(), s10.size())) {
break;
}
if (q1 <= k) {
DD = del(DD, s01[k - q1].first);
DD = del(DD, s10[k - q1].first);
}
}
if (ans == INF) {
cout << -1 << '\n';
} else {
cout << ans << '\n';
for (long long q = 0; q < ind; q++) {
cout << s11[q].second + 1 << ' ';
}
for (long long q = 0; q < max(0LL, k - ind); q++) {
cout << s01[q].second + 1 << ' ' << s10[q].second + 1 << ' ';
}
long long q00 = 0, q01 = max(0LL, k - ind), q10 = max(0LL, k - ind);
for (long long q = 0; q < m - ind - 2 * max(0LL, k - ind); q++) {
if (q00 != s00.size() &&
(q01 == s01.size() || s01[q01].first >= s00[q00].first) &&
(q10 == s10.size() || s10[q10].first >= s00[q00].first)) {
cout << s00[q00++].second + 1 << ' ';
} else if (q01 != s01.size() &&
(q00 == s00.size() || s00[q00].first >= s01[q01].first) &&
(q10 == s10.size() || s10[q10].first >= s01[q01].first)) {
cout << s01[q01++].second + 1 << ' ';
} else {
cout << s10[q10++].second + 1 << ' ';
}
}
cout << '\n';
}
return 0;
}
| 11 | CPP |
#from bisect import bisect_left as bl #c++ lowerbound bl(array,element)
#from bisect import bisect_right as br #c++ upperbound br(array,element)
#from __future__ import print_function, division #while using python2
def modinv(n,p):
return pow(n,p-2,p)
def main():
#sys.stdin = open('input.txt', 'r')
#sys.stdout = open('output.txt', 'w')
n, k = [int(x) for x in input().split()]
alice = []
bob = []
both = []
for i in range(n):
t, a, b = [int(x) for x in input().split()]
if a == 1 and b == 1:
both.append(t/2)
elif a == 1:
alice.append(t)
elif b == 1:
bob.append(t)
else:
pass
alice.sort()
bob.sort()
both.sort()
k_alice = k
k_bob = k
final_t = 0
i = 0
j = 0
k = 0
p = len(alice)
q = len(bob)
r = len(both)
for i in range(k + 1):
alice.append(99999)
bob.append(99999)
both.append(99999)
t = 0
break_flag = False
# print(alice)
# print(bob)
# print(both)
t = 0
impossible = False
while k_alice > 0 and k_bob > 0:
if 2 * both[k] <= alice[i] + bob[j]:
inc = int(2 * both[k])
if inc >= 99999:
impossible = True
print(-1)
return
t += inc
k += 1
else:
inc = 0
inc += alice[i]
inc += bob[j]
if inc >= 99999:
impossible = True
print(-1)
return
t += inc
i += 1
j += 1
k_bob -= 1
k_alice -= 1
while k_alice > 0:
if alice[i] <= int(2*both[j]):
inc = alice[i]
if inc >= 99999:
impossible = True
print(-1)
return
t += inc
i += 1
else:
inc = int(both[k] * 2)
if inc >= 99999:
impossible = True
print(-1)
return
t += inc
k += 1
k_alice -= 1
while k_bob > 0:
if bob[j] <= int(2*both[k]):
inc = bob[j]
if inc >= 99999:
impossible = True
print(-1)
return
t += inc
j += 1
else:
inc = int(both[k] * 2)
if inc >= 99999:
impossible = True
print(-1)
return
t += inc
k += 1
k_bob -= 1
if impossible:
print(-1)
else:
print(t)
#------------------ Python 2 and 3 footer by Pajenegod and c1729-----------------------------------------
py2 = round(0.5)
if py2:
from future_builtins import ascii, filter, hex, map, oct, zip
range = xrange
import os, sys
from io import IOBase, BytesIO
BUFSIZE = 8192
class FastIO(BytesIO):
newlines = 0
def __init__(self, file):
self._file = file
self._fd = file.fileno()
self.writable = "x" in file.mode or "w" in file.mode
self.write = super(FastIO, self).write if self.writable else None
def _fill(self):
s = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
self.seek((self.tell(), self.seek(0,2), super(FastIO, self).write(s))[0])
return s
def read(self):
while self._fill(): pass
return super(FastIO,self).read()
def readline(self):
while self.newlines == 0:
s = self._fill(); self.newlines = s.count(b"\n") + (not s)
self.newlines -= 1
return super(FastIO, self).readline()
def flush(self):
if self.writable:
os.write(self._fd, self.getvalue())
self.truncate(0), self.seek(0)
class IOWrapper(IOBase):
def __init__(self, file):
self.buffer = FastIO(file)
self.flush = self.buffer.flush
self.writable = self.buffer.writable
if py2:
self.write = self.buffer.write
self.read = self.buffer.read
self.readline = self.buffer.readline
else:
self.write = lambda s:self.buffer.write(s.encode('ascii'))
self.read = lambda:self.buffer.read().decode('ascii')
self.readline = lambda:self.buffer.readline().decode('ascii')
sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)
input = lambda: sys.stdin.readline().rstrip('\r\n')
if __name__ == '__main__':
main()
| 11 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
#pragma GCC optimize("O3")
const long long MOD = 1e9 + 7;
long long n_bits(long long n) {
long long x = __builtin_popcount(n);
return x;
}
int pow(int a, int b, int m) {
int ans = 1;
while (b) {
if (b & 1) ans = (ans * a) % m;
b /= 2;
a = (a * a) % m;
}
return ans;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
long long t = 1;
while (t--) {
int n, k, x, y, z;
cin >> n >> k;
vector<int> A;
vector<int> B;
vector<int> C;
for (long long i = 0; i < (n); ++i) {
cin >> x >> y >> z;
if (y == z && y == 1) {
C.push_back(x);
} else if (y == 1 && z == 0) {
A.push_back(x);
} else if (z == 1 && y == 0) {
B.push_back(x);
}
}
if (A.size() + C.size() < k || B.size() + C.size() < k) {
cout << -1;
return 0;
}
vector<int> t1;
sort(A.begin(), A.end());
sort(B.begin(), B.end());
int mini = min(A.size(), B.size());
int j = 0, ans = 0, total = 0;
for (int i = 0; i < mini; i++) {
t1.push_back(A[i] + B[i]);
}
sort(C.begin(), C.end());
for (int i = 0; i < C.size(); i++) {
t1.push_back(C[i]);
}
total = 0;
sort(t1.begin(), t1.end());
for (int i = 0; i < k; i++) {
total += t1[i];
}
cout << total;
}
return 0;
}
| 11 | CPP |
#include <bits/stdc++.h>
using namespace std;
double const EPS = 1e-8, PI = acos(-1);
const int N = 2e5 + 9, M = 30 + 7, OO = (int)1e6 + 1, MAXN = 4 * N;
const long long MOD = 1e9 + 7, INF = 1e18 + 9;
void INPUT() {}
bool cmp(pair<int, pair<bool, bool>> a, pair<int, pair<bool, bool>> b) {
if (a.first == b.first) {
return (b.second.first && b.second.second);
}
return a.first < b.first;
}
int main() {
ios::sync_with_stdio(false), cin.tie(nullptr), cout.tie(nullptr);
cout << fixed << setprecision(0);
INPUT();
int n, k;
cin >> n >> k;
vector<pair<int, pair<bool, bool>>> v(n), fir, sec, bot;
for (int i = 0; i < n; i++) {
cin >> v[i].first >> v[i].second.first >> v[i].second.second;
if (v[i].second.first && v[i].second.second)
bot.push_back(v[i]);
else if (v[i].second.first)
fir.push_back(v[i]);
else if (v[i].second.second)
sec.push_back(v[i]);
}
sort(bot.begin(), bot.end());
sort(fir.begin(), fir.end());
sort(sec.begin(), sec.end());
vector<long long> botCum(((int)((bot).size())) + 1, 0),
firCum(((int)((fir).size())) + 1, 0),
secCum(((int)((sec).size())) + 1, 0);
for (int i = 1; i <= ((int)((bot).size())); i++) {
botCum[i] = bot[i - 1].first + botCum[i - 1];
}
for (int i = 1; i <= ((int)((fir).size())); i++) {
firCum[i] = fir[i - 1].first + firCum[i - 1];
}
for (int i = 1; i <= ((int)((sec).size())); i++) {
secCum[i] = sec[i - 1].first + secCum[i - 1];
}
long long ans = INF;
for (int i = 0; i <= k; i++) {
int need = k - i;
if (((int)((bot).size())) < i || ((int)((fir).size())) < need ||
((int)((sec).size())) < need)
continue;
ans = min(ans, botCum[i] + firCum[need] + secCum[need]);
}
cout << (ans == INF ? -1 : ans);
return 0;
}
| 11 | CPP |
n,k=map(int,input().split())
a=[] # 1 1
b=[] #0 1
c=[] # 1 0
for i in range(n):
t,x,y=map(int,input().split())
if x:
if y:
a.append(t)
else:
c.append(t)
else:
if y:b.append(t)
if len(a)+len(b) <k or len(a)+len(c)<k:print(-1)
else:
mn=10**10
a=sorted(a)
b=sorted(b)
c=sorted(c)
apre=[0]
cpre=[0]
bpre=[0]
#print(len(a),len(b),len(c))
for num in a:
apre.append(apre[-1]+num)
for num in b:
bpre.append(bpre[-1]+num)
for num in c:
cpre.append(cpre[-1]+num)
for tk in range(min(k+1,len(a)+1)):
chane=k-tk
#print(chane)
if chane<=len(b) and chane<=len(c):
sm=apre[tk]+bpre[chane]+cpre[chane]
mn=min(sm,mn)
print(mn)
| 11 | PYTHON3 |
import sys, os
from io import BytesIO, IOBase
from math import floor, gcd, fabs, factorial, fmod, sqrt, inf, log
from collections import defaultdict as dd, deque
from heapq import merge, heapify, heappop, heappush, nsmallest
from bisect import bisect_left as bl, bisect_right as br, bisect
# region fastio
BUFSIZE = 8192
class FastIO(IOBase):
newlines = 0
def __init__(self, file):
self._fd = file.fileno()
self.buffer = BytesIO()
self.writable = "x" in file.mode or "r" not in file.mode
self.write = self.buffer.write if self.writable else None
def read(self):
while True:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
if not b:
break
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines = 0
return self.buffer.read()
def readline(self):
while self.newlines == 0:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
self.newlines = b.count(b"\n") + (not b)
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines -= 1
return self.buffer.readline()
def flush(self):
if self.writable:
os.write(self._fd, self.buffer.getvalue())
self.buffer.truncate(0), self.buffer.seek(0)
class IOWrapper(IOBase):
def __init__(self, file):
self.buffer = FastIO(file)
self.flush = self.buffer.flush
self.writable = self.buffer.writable
self.write = lambda s: self.buffer.write(s.encode("ascii"))
self.read = lambda: self.buffer.read().decode("ascii")
self.readline = lambda: self.buffer.readline().decode("ascii")
stdin, stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)
mod = pow(10, 9) + 7
mod2 = 998244353
def inp(): return stdin.readline().strip()
def iinp(): return int(inp())
def out(var, end="\n"): stdout.write(str(var)+"\n")
def outa(*var, end="\n"): stdout.write(' '.join(map(str, var)) + end)
def lmp(): return list(mp())
def mp(): return map(int, inp().split())
def l1d(n, val=0): return [val for i in range(n)]
def l2d(n, m, val=0): return [l1d(m, val) for j in range(n)]
def ceil(a, b): return (a+b-1)//b
S1 = 'abcdefghijklmnopqrstuvwxyz'
S2 = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'
def isprime(x):
if x<=1: return False
if x in (2, 3): return True
if x%2 == 0: return False
for i in range(3, int(sqrt(x))+1, 2):
if x%i == 0: return False
return True
n, k = mp()
a, b, ab = l2d(3, 1, inf)
for i in range(n):
x, y, z = mp()
if y==z==1:
ab.append(x)
elif y==1:
a.append(x)
elif z==1:
b.append(x)
if min(len(b), len(a))+len(ab)-2<k:
print(-1)
exit()
a.sort(reverse=True)
b.sort(reverse=True)
ab.sort(reverse=True)
ans = 0
i = 0
while i < k:
x, y, z = a[-1], b[-1], ab[-1]
if x+y < z:
ans += a.pop()+b.pop()
else:
ans += ab.pop()
i+=1
print(ans) | 11 | PYTHON3 |
n,m,k = map(int,input().split())
ab = []
a = []
b = []
other = []
l = [list(map(int,input().split())) for i in range(n)]
for i in range(n):
t,c,d = l[i]
if c and d == 0:
a.append([t,i+1])
elif d and c == 0:
b.append([t,i+1])
elif c*d:
ab.append([t,i+1])
else:
other.append([t,i+1])
a.sort()
b.sort()
ab.sort()
other.sort()
la = len(a)
lb = len(b)
lab = len(ab)
lo = len(other)
a.append([float("INF"),-1])
b.append([float("INF"),-1])
ab.append([float("INF"),-1])
other.append([float("INF"),-1])
if la<lb:
la,lb = lb,la
a,b = b,a
ans = float("INF")
count = 0
ia = 0
ib = 0
iab = 0
io = 0
ana = 0
anb = 0
anab = 0
ano = 0
for i in range(lab+1):
if k-i > lb:
continue
if 2*k-i > m:
continue
if i + la + lb + lo < m:
continue
if ia > 0:
ia -= 1
count -= a[ia][0]
if ib > 0:
ib -= 1
count -= b[ib][0]
if io > 0:
io -= 1
count -= other[io][0]
while ia < la and ia < k-i:
count += a[ia][0]
ia += 1
while ib < lb and ib < k-i:
count += b[ib][0]
ib += 1
while iab < lab and iab < i:
count += ab[iab][0]
iab += 1
while ia+ib+iab+io < m:
na = a[ia][0]
nb = b[ib][0]
no = other[io][0]
mi = min(na,nb,no)
if mi == na:
count += na
ia += 1
elif mi == nb:
count += nb
ib += 1
else:
count += no
io += 1
if count < ans:
ans = count
ana = ia
anb = ib
anab = iab
ano = io
if ans == float("INF"):
print(-1)
else:
print(ans)
l = []
for i in range(ana):
l.append(a[i][1])
for i in range(anb):
l.append(b[i][1])
for i in range(anab):
l.append(ab[i][1])
for i in range(ano):
l.append(other[i][1])
print(*l) | 11 | PYTHON3 |
from sys import stdin
n,k = map(int,stdin.readline().split())
ba,bb,bc = [],[],[]
for _ in range(n):
t,a,b = map(int, stdin.readline().split())
if a and b:
bc.append(t)
elif a:
ba.append(t)
elif b:
bb.append(t)
ba.sort()
bb.sort()
bc.sort()
a,b,c = 0,0,0
T = 0
while k:
if c<len(bc) and a<len(ba) and b<len(bb):
if bc[c] < ba[a]+bb[b]:
T += bc[c]
c += 1
k -= 1
else:
T += ba[a] + bb[b]
a += 1
b += 1
k -= 1
elif c<len(bc):
T += bc[c]
c += 1
k -= 1
elif a<len(ba) and b<len(bb):
T += ba[a] + bb[b]
a += 1
b += 1
k -= 1
else:
T = -1
break
print(T)
| 11 | PYTHON3 |
import sys, math,os
from io import BytesIO, IOBase
#data = BytesIO(os.read(0,os.fstat(0).st_size)).readline
# from bisect import bisect_left as bl, bisect_right as br, insort
# from heapq import heapify, heappush, heappop
from collections import defaultdict as dd, deque, Counter
# from itertools import permutations,combinations
# from decimal import Decimal
def data(): return sys.stdin.readline().strip()
def mdata(): return list(map(int, data().split()))
def outl(var): sys.stdout.write(' '.join(map(str, var)) + '\n')
def out(var): sys.stdout.write(str(var) + '\n')
#sys.setrecursionlimit(100000 + 1)
INF = 10**9
mod = 998244353
n,k=mdata()
a,b,c,d=[],[],[],[]
for i in range(n):
t1,a1,b1=mdata()
if a1==1 and b1==1:
c.append(t1)
elif a1==1:
a.append(t1)
elif b1==1:
b.append(t1)
else:
d.append(t1)
a.sort(reverse=True)
b.sort(reverse=True)
c.sort(reverse=True)
d.sort(reverse=True)
ans=0
while k:
if len(a)!=0 and len(b)!=0:
if len(c)!=0:
if c[-1]<a[-1]+b[-1]:
ans+=c.pop()
else:
ans+=a.pop()+b.pop()
else:
ans += a.pop() + b.pop()
elif len(c)!=0:
ans += c.pop()
else:
break
k-=1
if k!=0:
out(-1)
else:
out(ans)
| 11 | PYTHON3 |
n, k = map(int, input().split())
ab, a, b = [], [], []
for _ in range(n):
t, aa, bb = map(int, input().split())
if aa and bb:ab.append(t)
elif aa:a.append(t)
elif bb:b.append(t)
a.sort()
b.sort()
zz = min(len(a), len(b))
for i in range(zz):ab.append(a[i]+b[i])
print(-1 if len(ab)<k else sum(sorted(ab)[:k])) | 11 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
template <typename Arg1>
void __f(const char* name, Arg1&& arg1) {
cout << name << " : " << arg1 << "\n";
}
template <typename Arg1, typename... Args>
void __f(const char* names, Arg1&& arg1, Args&&... args) {
const char* comma = strchr(names + 1, ',');
cout.write(names, comma - names) << " : " << arg1 << " | ";
__f(comma + 1, args...);
}
inline long long sbt(long long x) { return __builtin_popcountll(x); }
inline long long iceil(long double a) { return (long long)(ceil(a)); }
inline long long abceil(long long a, long long b) { return (a + b - 1) / b; }
inline long long mul(long long a, long long b,
long long m = (long long)(1e9 + 7)) {
return ((a % m) * (b % m)) % m;
}
inline long long add(long long a, long long b,
long long m = (long long)(1e9 + 7)) {
return (a + b) % m;
}
inline long long sub(long long a, long long b,
long long m = (long long)(1e9 + 7)) {
return (a - b + m) % m;
}
long long fastpow(long long a, long long b,
long long m = (long long)(1e9 + 7)) {
long long res = 1;
while (b > 0) {
if (b & 1) res = mul(res, a, m);
a = mul(a, a, m);
b >>= 1;
}
return res;
}
long long modinv(long long a, long long m = (long long)(1e9 + 7)) {
return fastpow(a, m - 2, m);
}
void get_ac() {
long long a, b, c, n, m, k;
cin >> n >> m >> k;
vector<pair<long long, long long> > alice, bob, both, none;
for (auto i = 1; i <= n; i++) {
cin >> a >> b >> c;
if (b & c)
both.push_back({a, i});
else if (b)
alice.push_back({a, i});
else if (c)
bob.push_back({a, i});
else
none.push_back({a, i});
}
long long ans = 0;
set<long long> indices;
sort(bob.begin(), bob.end());
sort(alice.begin(), alice.end());
sort(both.begin(), both.end());
sort(none.begin(), none.end());
for (long i = 0; i < min(k, (long long)(both.size())); i++) {
ans += both[i].first;
indices.insert(both[i].second);
}
for (long i = 0; i < min({(long long)(alice.size()), (long long)(bob.size()),
max(k - (long long)(both.size()), 0LL)});
i++) {
ans += alice[i].first + bob[i].first;
indices.insert(alice[i].second);
indices.insert(bob[i].second);
}
long long inone = 0,
ibob = min({(long long)(alice.size()), (long long)(bob.size()),
max(k - (long long)(both.size()), 0LL)}),
ialice = min({(long long)(alice.size()), (long long)(bob.size()),
max(k - (long long)(both.size()), 0LL)}),
iboth = min(k, (long long)(both.size()));
long long nboth = (long long)(both.size()),
nalice = (long long)(alice.size()), nbob = (long long)(bob.size()),
nnone = (long long)(none.size());
if ((iboth + ialice) < k || (long long)(indices.size()) > m) {
cout << -1;
return;
}
while ((long long)(indices.size()) < m) {
vector<pair<long long, long long> > candidate;
if (inone < nnone) candidate.push_back({none[inone].first, 0});
if (ialice < nalice) candidate.push_back({alice[ialice].first, 2});
if (ibob < nbob) candidate.push_back({bob[ibob].first, 1});
if (iboth < nboth) candidate.push_back({both[iboth].first, 3});
if (iboth > 0 && ialice < nalice && ibob < nbob)
candidate.push_back(
{alice[ialice].first + bob[ibob].first - both[iboth - 1].first, 4});
sort(candidate.begin(), candidate.end());
if ((long long)(candidate.size()) == 0) break;
long long f = candidate[0].second;
if (f == 0) {
ans += none[inone].first;
indices.insert(none[inone].second);
inone++;
} else if (f == 1) {
ans += bob[ibob].first;
indices.insert(bob[ibob].second);
ibob++;
} else if (f == 2) {
ans += alice[ialice].first;
indices.insert(alice[ialice].second);
ialice++;
} else if (f == 3) {
ans += both[iboth].first;
indices.insert(both[iboth].second);
iboth++;
} else {
ans += alice[ialice].first + bob[ibob].first - both[iboth - 1].first;
indices.erase(both[iboth - 1].second);
indices.insert(alice[ialice].second);
indices.insert(bob[ibob].second);
ialice++;
ibob++;
iboth--;
}
}
if ((long long)(indices.size()) < m) {
cout << -1;
return;
}
cout << ans;
cout << "\n";
for (auto i : indices) {
cout << i << " ";
}
}
int main() {
cin.sync_with_stdio(false);
cout.sync_with_stdio(false);
cin.tie(NULL);
{
get_ac();
cout << "\n";
}
return 0;
}
| 11 | CPP |
n, k = map(int, input().split())
a = []
b = []
ab = []
for i in range(n):
t, a1, b1 = map(int, input().split())
if a1 == 1 and b1 == 1:
ab.append(t)
elif a1 == 1 and b1 == 0:
a.append(t)
elif a1 == 0 and b1 == 1:
b.append(t)
a.sort()
a_i = 0
b.sort()
ab.sort()
ab_i = 0
sum_t = 0
count = 0
while count < k:
if (a_i == len(a) or a_i == len(b)) and ab_i < len(ab):
sum_t += ab[ab_i]
ab_i += 1
elif ab_i == len(ab) and a_i < len(a) and a_i < len(b):
sum_t += a[a_i] + b[a_i]
a_i += 1
elif ab_i < len(ab) and a_i < len(a) and a_i < len(b):
if a[a_i] + b[a_i] < ab[ab_i]:
sum_t += a[a_i] + b[a_i]
a_i += 1
else:
sum_t += ab[ab_i]
ab_i += 1
else:
sum_t = -1
break
count += 1
print(sum_t) | 11 | PYTHON3 |
def p(x):
return x[0]
n, k = map(int, input().split())
a = []
for i in range(n):
a.append(list(map(int, input().split())))
a.sort(key=p)
# print()
# print()
# for i in a:
# print(i)
alice, bob, common = [], [], []
al, bo = 0, 0
flag = 1
for i in a:
if(i[1] and not i[2] and flag and al < k):
alice.append(i[0])
al += 1
if(i[2] and (not i[1]) and flag and bo < k):
bob.append(i[0])
bo += 1
if(i[1] and i[2]):
if(flag):
common.append(i[0])
al += 1
bo += 1
if(al > k and alice):
alice.pop()
al -= 1
if(bo > k and bob):
bob.pop()
bo -= 1
else:
if(alice and bob):
if(alice[-1]+bob[-1] > i[0]):
alice.pop()
bob.pop()
common.append(i[0])
else:
break
if(al >= k and bo >= k):
flag = 0
# print(alice, bob, common, al, bo)
if(al >= k and bo >= k):
print(sum(alice)+sum(bob)+sum(common))
else:
print(-1)
| 11 | PYTHON3 |
lis = input().split()
n,k = int(lis[0]),int(lis[1])
like1 = []
like2 = []
likeall = []
for i in range(n):
lis = input().split()
tval,l1,l2 = int(lis[0]),int(lis[1]),int(lis[2])
if(l1==1 and l2==1):
likeall.append(tval)
elif(l1==1):
like1.append(tval)
elif(l2==1):
like2.append(tval)
like1.sort()
like2.sort()
likeall.sort()
if(len(like1)<len(like2)):
mm = len(like1)
like2 = like2[:len(like1)]
elif(len(like1)>len(like2)):
mm = len(like2)
like1 = like1[:len(like2)]
else:
mm = len(like1)
if(mm+len(likeall)<k):
print(-1)
else:
likedouble = [0]*mm
for i in range(mm):
likedouble[i] = like1[i]+like2[i]
merged = [0]*(mm+len(likeall))
ind,ind1,ind2=0,0,0
while(ind<k and ind1<mm and ind2<len(likeall)):
if(likedouble[ind1]<likeall[ind2]):
merged[ind] = likedouble[ind1]
ind+=1
ind1+=1
else:
merged[ind] = likeall[ind2]
ind+=1
ind2+=1
while(ind<k and ind1<mm):
merged[ind] = likedouble[ind1]
ind+=1
ind1+=1
while(ind<k and ind2<len(likeall)):
merged[ind] = likeall[ind2]
ind+=1
ind2+=1
sum=0
for i in range(k):
sum+=merged[i]
print(sum) | 11 | PYTHON3 |
l=list(map(int,input().split()))
n,y=l[0],l[1]
fir=[]
sec=[]
bot=[]
for _ in range(n):
k=list(map(int,input().split()))
if(k[1]==1 and k[2]==1):
bot.append(k[0])
elif(k[1]==1 and k[2]==0):
fir.append(k[0])
elif(k[1]==0 and k[2]==1):
sec.append(k[0])
f=len(fir)
s=len(sec)
b=len(bot)
if(f+b<y or s+b<y):
print(-1)
else:
fir.sort()
sec.sort()
bot.sort()
if(f<y):
fir+=((y-f)*[10001])
else:
fir=fir[0:y]
if(s<y):
sec+=((y-s)*[10001])
else:
sec=sec[0:y]
val=sum(fir)+sum(sec)
fir.reverse()
sec.reverse()
for i in range(y):
try:
if(fir[i]+sec[i]>bot[i]):
val=val-fir[i]-sec[i]+bot[i]
except:
break
print(val) | 11 | PYTHON3 |
from sys import stdin, stdout
import math,sys
from itertools import permutations, combinations
from collections import defaultdict,deque,OrderedDict
from os import path
import bisect as bi
import heapq
def yes():print('YES')
def no():print('NO')
if (path.exists('input.txt')):
#------------------Sublime--------------------------------------#
sys.stdin=open('input.txt','r');sys.stdout=open('output.txt','w');
def I():return (int(input()))
def In():return(map(int,input().split()))
else:
#------------------PYPY FAst I/o--------------------------------#
def I():return (int(stdin.readline()))
def In():return(map(int,stdin.readline().split()))
def main():
try:
n,k=In()
l1,l2,l3=[],[],[]
for x in range(n):
t,a,b=In()
if a==1 and b==1:
l1.append(t)
elif a==0 and b==1:
l3.append(t)
elif a==1 and b==0:
l2.append(t)
else:
continue
#l1.sort()
l2.sort()
l3.sort()
l4=[]
#print(l2)
if len(l2)<len(l3):
for x in range(len(l2)):
l4.append(l2[x]+l3[x])
elif len(l2)>=len(l3) and len(l2)!=0:
for x in range(len(l3)):
l4.append(l2[x]+l3[x])
l1+=l4
if k>len(l1):
print(-1)
else:
ans=0
l1.sort()
for x in range(k):
ans+=l1[x]
print(ans)
except:
pass
M = 998244353
P = 1000000007
if __name__ == '__main__':
#for _ in range(I()):main()
for _ in range(1):main() | 11 | PYTHON3 |
import sys
input = sys.stdin.readline
INF = 10 ** 18
n, m, k = map(int, input().split())
B = [tuple(map(int, input().split())) for _ in range(n)]
GB = []
AB = []
BB = []
RB = []
for i, (t, a, b) in enumerate(B):
if a and b:
GB.append((t, i))
elif a:
AB.append((t, i))
elif b:
BB.append((t, i))
else:
RB.append((t, i))
GB.sort(key=lambda v: v[0])
AB.sort(key=lambda v: v[0])
BB.sort(key=lambda v: v[0])
N = 1
while N <= 10 ** 4: N *= 2
T = [(0, 0)] * (2 * N)
def comb(a, b):
return (a[0] + b[0], a[1] + b[1])
def add_book(t, inc=1):
i = t + N
T[i] = comb(T[i], (t*inc, inc))
while i > 1:
i //= 2
T[i] = comb(T[i*2], T[i*2+1])
def query(x):
assert x >= 0
s = 0
i = 1
while x:
ts, tc = T[i]
if tc < x: return INF
elif tc == x:
s += ts
break
if i >= N:
s += ts // tc * x
break
i *= 2
if T[i][1] < x:
s += T[i][0]
x -= T[i][1]
i += 1
return s
gb_i = 0
gb_t = 0
while gb_i < min(len(GB), m):
gb_t += GB[gb_i][0]
gb_i += 1
cb_i = 0
cb_t = 0
while gb_i + cb_i < k and gb_i + 2 * (cb_i + 1) <= m and cb_i < min(len(AB), len(BB)):
cb_t += AB[cb_i][0] + BB[cb_i][0]
cb_i += 1
for t, _ in GB[gb_i:]: add_book(t)
for t, _ in AB[cb_i:]: add_book(t)
for t, _ in BB[cb_i:]: add_book(t)
for t, _ in RB: add_book(t)
if gb_i + cb_i < k:
print(-1)
sys.exit()
best = (INF, -1, -1)
while True:
best = min(best, (gb_t + cb_t + query(m - 2 * cb_i - gb_i), gb_i, cb_i))
if not gb_i: break
gb_i -= 1
gb_t -= GB[gb_i][0]
add_book(GB[gb_i][0])
if gb_i + cb_i < k:
if cb_i == min(len(AB), len(BB)): break
cb_t += AB[cb_i][0] + BB[cb_i][0]
add_book(AB[cb_i][0], -1)
add_book(BB[cb_i][0], -1)
cb_i += 1
if gb_i + 2 * cb_i > m: break
bs, bi, bj = best
assert bs != INF
ans = []
comps = 0
for t, i in GB[:bi]:
ans.append(i+1)
comps += t
for t, i in AB[:bj]:
ans.append(i+1)
comps += t
for t, i in BB[:bj]:
ans.append(i+1)
comps += t
if bi + 2 * bj < m:
rem = GB[bi:] + AB[bj:] + BB[bj:] + RB
rem.sort()
for t, i in rem[:m - bi - 2 * bj]:
ans.append(i+1)
comps += t
assert comps == bs
print(bs)
print(*ans)
| 11 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
const long long mod = 998244353;
const int N = 1e5 + 5e4 + 2;
const int inf = 2e9;
const long long linf = 4e18;
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cerr.tie(0);
int n, k;
cin >> n >> k;
vector<int> alice, bob, common;
for (int i = 0; i < n; i++) {
int t, a, b;
cin >> t >> a >> b;
if (a && b)
common.push_back(t);
else if (a)
alice.push_back(t);
else if (b)
bob.push_back(t);
}
sort(alice.begin(), alice.end());
sort(bob.begin(), bob.end());
priority_queue<int, vector<int>, greater<int>> q;
for (int i = 0; i < common.size(); i++) q.push(common[i]);
for (int i = 0; i < min(alice.size(), bob.size()); i++)
q.push(alice[i] + bob[i]);
if (q.size() < k) {
cout << -1;
return 0;
}
int ans = 0;
while (k--) {
ans += q.top();
q.pop();
}
cout << ans;
return 0;
}
| 11 | CPP |
#include <bits/stdc++.h>
using namespace std;
void solve() {
long long int n, k;
cin >> n >> k;
vector<long long int> a, b, c, d;
a.emplace_back(0), b.emplace_back(0), c.emplace_back(0);
for (int i = 0; i < n; i++) {
int x, y, z;
cin >> x >> y >> z;
if (y + z == 2) {
a.emplace_back(x);
} else if (y == 1) {
b.emplace_back(x);
} else if (z == 1) {
c.emplace_back(x);
}
}
sort(a.begin(), a.end());
sort(b.begin(), b.end());
sort(c.begin(), c.end());
for (int i = 1; i < ((long long)a.size()); i++) {
a[i] = a[i] + a[i - 1];
}
for (int i = 1; i < ((long long)b.size()); i++) b[i] = b[i] + b[i - 1];
for (int i = 1; i < ((long long)c.size()); i++) c[i] = c[i] + c[i - 1];
long long int ans = (long long int)1e18 + 7;
for (int i = 0; i < min(k + 1, ((long long)a.size())); i++) {
if (k - i < ((long long)b.size()) && k - i < ((long long)c.size())) {
ans = min(ans, a[i] + b[k - i] + c[k - i]);
}
}
if (ans == (long long int)1e18 + 7)
cout << -1 << "\n";
else
cout << ans << "\n";
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
int t = 1;
while (t--) {
solve();
}
return 0;
}
| 11 | CPP |
#include <bits/stdc++.h>
using namespace std;
const long long INF = 1e18;
void solve() {}
int32_t main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
long long n, k;
cin >> n >> k;
vector<long long> times[4];
vector<long long> sums[4];
for (long long i = 0; i < n; ++i) {
long long t, a, b;
cin >> t >> a >> b;
times[a * 2 + b].push_back(t);
}
for (long long 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);
}
}
long long ans = INF;
for (long long cnt = 0; cnt < min(k + 1, (long long)(sums[3].size()));
++cnt) {
if (k - cnt < (long long)(sums[1].size()) &&
k - cnt < (long long)(sums[2].size())) {
ans = min(ans, sums[3][cnt] + sums[1][k - cnt] + sums[2][k - cnt]);
}
}
if (ans == INF) ans = -1;
cout << ans << "\n";
return 0;
}
| 11 | CPP |
#include <bits/stdc++.h>
using namespace std;
void fast() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
}
int main() {
long long int n, i, j, w, x, y, k, cv1 = 0, cv2 = 0, cv3 = 0, c = 0, ans = 0;
cin >> n >> k;
vector<long long int> v2, v1, v3;
for (i = 0; i < n; i++) {
cin >> w >> x >> y;
if (x == 1 && y == 1) {
cv3++;
v3.push_back(w);
} else if (x == 0 && y == 1) {
v2.push_back(w);
cv2++;
} else if (x == 1 && y == 0) {
v1.push_back(w);
cv1++;
}
}
sort(v1.begin(), v1.end());
sort(v2.begin(), v2.end());
sort(v3.begin(), v3.end());
long long int i1 = 0, i3 = 0;
while (c < k && (min(cv1, cv2) > 0 || cv3 > 0)) {
if (min(cv1, cv2) == 0 && cv3 > 0) {
ans += v3[i3];
i3++;
cv3--;
c++;
} else if (min(cv1, cv2) > 0 && cv3 == 0) {
ans += v1[i1] + v2[i1];
cv1--;
cv2--;
c++;
i1++;
} else if (min(cv1, cv2) == 0 && cv3 == 0) {
break;
} else if (v1[i1] + v2[i1] >= v3[i3]) {
ans += v3[i3];
i3++;
c++;
cv3--;
} else {
ans += v1[i1] + v2[i1];
cv1--;
cv2--;
c++;
i1++;
}
}
if (c == k)
cout << ans << endl;
else
cout << "-1" << endl;
return 0;
}
| 11 | CPP |
n,k = [int(i) for i in input().split()]
a=[]
b=[]
t=[]
for i in range (n):
ti,ai,bi=[int(i) for i in input().split()]
t.append([ti,i])
a.append(ai)
b.append(bi)
temp = 0
if a.count(1)<k or b.count(1)<k:
temp = 1
print(-1)
if temp == 0:
alice=[]
bob=[]
both = []
for i in range (n):
if a[i]==1 and b[i]==0:
alice.append(t[i][0])
if b[i]==1 and a[i]==0:
bob.append(t[i][0])
if a[i]==1 and b[i]==1:
both.append(t[i][0])
alice.sort()
bob.sort()
both.sort()
alice.reverse()
bob.reverse()
both.reverse()
aa,bb=k,k
ans = 0
while(aa and bb):
if len(both)>0 :
if len(alice)>0 and len(bob)>0:
if both[-1]<=alice[-1]+bob[-1]:
aa-=1
bb-=1
ans+=both[-1]
both.pop()
else:
aa-=1
bb-=1
ans+=alice[-1]+bob[-1]
alice.pop()
bob.pop()
else:
aa-=1
bb-=1
ans+=both[-1]
both.pop()
else:
aa-=1
bb-=1
ans+=alice[-1]+bob[-1]
alice.pop()
bob.pop()
if aa>0:
for i in range (aa):
ans+=alice[len(alice)-1-i]
if bb>0:
for i in range (bb):
ans+=bob[len(bob)-1-i]
print(ans) | 11 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
using vl = vector<long long>;
using vs = vector<string>;
using vvl = vector<vector<long long>>;
const long long INF = 1LL << 60;
template <class T>
bool chmax(T &a, const T &b) {
if (a < b) {
a = b;
return 1;
}
return 0;
}
template <class T>
bool chmin(T &a, const T &b) {
if (b < a) {
a = b;
return 1;
}
return 0;
}
long long gcd(long long a, long long b) { return b ? gcd(b, a % b) : a; }
long long lcm(long long a, long long b) { return a / gcd(a, b) * b; }
bool compare(pair<long long, long long> a, pair<long long, long long> b) {
if (a.first != b.first) {
return a.first < b.first;
} else {
return a.second < b.second;
}
}
bool In_map(long long y, long long x, long long h, long long w) {
if (y < 0 || x < 0 || y >= h || x >= w) {
return 0;
} else {
return 1;
}
}
void print(vector<long long> a) {
for (int i = 0; i < (a.size()); i++) {
if (i == a.size() - 1) {
cout << a[i] << endl;
} else {
cout << a[i] << " ";
}
}
}
const vector<long long> dx{1, 0, -1, 0};
const vector<long long> dy{0, 1, 0, -1};
void Main() {
long long n, k;
cin >> n >> k;
vl a, b, ab;
for (int i = 0; i < (n); i++) {
long long t, A, B;
cin >> t >> A >> B;
if (A == 1 && B == 1) {
ab.push_back(t);
} else if (A == 1) {
a.push_back(t);
} else if (B == 1) {
b.push_back(t);
}
}
sort(ab.begin(), ab.end());
sort(a.begin(), a.end());
sort(b.begin(), b.end());
if (ab.size() + a.size() < k || ab.size() + b.size() < k) {
cout << -1 << endl;
return;
}
long long ans = INF;
vl suma(a.size() + 1), sumb(b.size() + 1), sumab(ab.size() + 1);
for (int i = 0; i < (a.size()); i++) {
suma[i + 1] = suma[i] + a[i];
}
for (int i = 0; i < (b.size()); i++) {
sumb[i + 1] = sumb[i] + b[i];
}
for (int i = 0; i < (ab.size()); i++) {
sumab[i + 1] = sumab[i] + ab[i];
}
long long idx1 = min(k, (long long)ab.size());
long long idx2 = k - idx1;
while (1) {
if (idx1 < 0 || idx2 > min(a.size(), b.size())) {
break;
}
chmin(ans, sumab[idx1] + suma[idx2] + sumb[idx2]);
idx1--;
idx2++;
}
cout << ans << endl;
return;
}
int main() {
ios::sync_with_stdio(false);
cin.tie(nullptr);
int t = 1;
while (t--) {
Main();
}
return 0;
}
| 11 | CPP |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
int n, k;
cin >> n >> k;
vector<int> a, b, ab;
for (int i = 1; i <= n; ++i) {
int x, l, r;
cin >> x >> l >> r;
if (l == 1 and r == 0) {
a.push_back(x);
} else if (l == 0 and r == 1) {
b.push_back(x);
} else if (l == 1 and r == 1) {
ab.push_back(x);
}
}
sort(a.begin(), a.end());
sort(b.begin(), b.end());
sort(ab.begin(), ab.end());
for (int i = 1; i < a.size(); ++i) {
a[i] += a[i - 1];
}
for (int i = 1; i < b.size(); ++i) {
b[i] += b[i - 1];
}
for (int i = 1; i < ab.size(); ++i) {
ab[i] += ab[i - 1];
}
int answer = 2e9 + 10;
for (int i = 0; i <= k; ++i) {
int x = k - i, t = 2e9 + 10;
if (i == 0) {
if (x <= ab.size()) {
t = ab[x - 1];
}
} else if (i == k) {
if (i <= a.size() and i <= b.size()) {
t = a[i - 1] + b[i - 1];
}
} else {
if (x <= ab.size() and i <= a.size() and i <= b.size()) {
t = ab[x - 1] + a[i - 1] + b[i - 1];
}
}
answer = min(answer, t);
}
if (answer == 2e9 + 10) {
answer = -1;
}
cout << answer;
}
| 11 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e5 + 10;
inline int read() {
int x = 0, f = 1;
char ch = getchar();
while (!isdigit(ch)) {
if (ch == '-') f = -1;
ch = getchar();
}
while (isdigit(ch)) {
x = x * 10 + ch - 48;
ch = getchar();
}
return x * f;
}
priority_queue<int, vector<int>, greater<int>> v, v1, v2;
int main() {
int n = read(), k = read();
for (int i = 0; i < n; i++) {
int t = read(), a = read(), b = read();
if (a && b) {
v.push(t);
} else if (a) {
v1.push(t);
} else if (b) {
v2.push(t);
}
}
long long sum = 0;
if (v.size() + min(v1.size(), v2.size()) >= k) {
for (int i = 0; i < k; i++) {
if (v.size() && v1.size() && v2.size()) {
if (v.top() < v1.top() + v2.top()) {
sum += v.top();
v.pop();
} else {
sum += v1.top() + v2.top();
v1.pop();
v2.pop();
}
} else if (v.size()) {
sum += v.top();
v.pop();
} else if (v1.size() && v2.size()) {
sum += v1.top() + v2.top();
v1.pop();
v2.pop();
}
}
printf("%lld\n", sum);
} else {
printf("-1\n");
}
return 0;
}
| 11 | CPP |
n ,k = map(int, input().split(" "))
arr_both = []
arr_alice = []
arr_bob = []
for i in range(n):
t1 ,t2, t3 = map(int, input().split(" "))
if(t2==0 and t3==0):
continue
elif(t2==1 and t3==1):
arr_both.append(t1)
elif(t2==1):
arr_alice.append(t1)
else:
arr_bob.append(t1)
i = 0
j = 0
arr_alice.sort()
arr_bob.sort()
while(i<len(arr_alice) and j<len(arr_bob)):
arr_both.append(arr_alice[i] + arr_bob[j])
i += 1
j += 1
arr_both.sort()
if(len(arr_both)<k):
print(-1)
else:
print(sum(arr_both[0:k]))
| 11 | PYTHON3 |
from sys import stdin,stdout,setrecursionlimit
# n = int(stdin.readline())
n,k = map(int,stdin.readline().split())
a = []
b = []
ab = []
for _ in range(n):
x,y,z = map(int,stdin.readline().split())
if y == 1 and z == 1:
ab.append(x)
if y == 1 and z == 0:
a.append(x)
if y == 0 and z == 1:
b.append(x)
a.sort()
b.sort()
ab.sort()
if len(ab) + min(len(a), len(b)) < k:
print(-1)
else:
p = 0
e = 0
ans = 0
for i in range(k):
if p == min(len(a), len(b)):
for j in range(k-i):
ans += ab[e]
e+=1
break
elif e == len(ab):
for r in range(k-i):
ans += (a[p]+b[p])
p+=1
break
ans += min(a[p]+b[p], ab[e])
if a[p]+b[p] < ab[e]:
p += 1
else:
e += 1
print(ans)
| 11 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 7;
int n, k;
vector<int64_t> a;
vector<int64_t> b;
vector<int64_t> c;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cin >> n >> k;
for (int i = 1; i <= n; i++) {
int64_t _t;
bool _a, _b;
cin >> _t >> _a >> _b;
if (_a && _b) {
c.push_back(_t);
} else {
if (_a)
a.push_back(_t);
else if (_b)
b.push_back(_t);
}
}
a.push_back(0);
b.push_back(0);
c.push_back(0);
sort(a.begin(), a.end());
sort(b.begin(), b.end());
sort(c.begin(), c.end());
for (int i = 1; i < int(a.size()); i++) a[i] += a[i - 1];
for (int i = 1; i < int(b.size()); i++) b[i] += b[i - 1];
for (int i = 1; i < int(c.size()); i++) c[i] += c[i - 1];
bool done = false;
int64_t ans = 0;
for (int i = 0; i <= k; i++) {
if ((c.size() > i) && (min(a.size(), b.size()) > (k - i))) {
if (!done)
ans = c[i] + a[k - i] + b[k - i];
else
ans = min(ans, c[i] + a[k - i] + b[k - i]);
done = true;
}
}
if (!done)
cout << -1 << '\n';
else
cout << ans << '\n';
return 0;
}
| 11 | CPP |
import sys
from collections import Counter as CO
input=sys.stdin.readline
from collections import defaultdict as dd
n,k=map(int,input().split())
arr=[]
brr=[]
both=[]
for _ in range(n):
t,a,b=map(int,input().split())
if(a==1 and b==1):
both+=[t]
elif(a==1):
arr+=[t]
elif(b==1):
brr+=[t]
ans=[]
both.sort(reverse=True)
arr.sort(reverse=True)
brr.sort(reverse=True)
for i in range(k):
if(len(both)>0 and min(len(arr),len(brr))>0):
if(both[-1]<arr[-1]+brr[-1]):
ans+=[both.pop()]
else:
ans+=[arr.pop()+brr.pop()]
elif(len(both)==0 and min(len(arr),len(brr))>0):
ans+=[arr.pop()+brr.pop()]
elif(len(both)>0 and min(len(arr),len(brr))==0):
ans+=[both.pop()]
else:
break
if(len(ans)<k):
print(-1)
else:
print(sum(ans))
| 11 | PYTHON3 |
#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();
}
| 11 | CPP |
n,k=[int(j) for j in input().split()]
al=bo=0
both=[]
sial=[]
sibob=[]
for i in range(n):
tim,alice,bob=[int(j) for j in input().split()]
if(alice==1 and bob==1):
both.append(tim);
al+=1
bo+=1
elif(alice ==1):
sial.append(tim)
al+=1
elif(bob == 1):
sibob.append(tim)
bo+=1
if(al<k or bo<k):
print(-1)
else:
both.sort()
sial.sort()
sibob.sort()
bsize=bosize=alsize=count=ans=cntboth=cntsial=cntsibob=0
bsize = len(both)
alsize=len(sial)
bosize = len(sibob)
while(count != k):
if(cntboth<bsize and cntsial<alsize and cntboth<bosize):
if(both[cntboth] <= (sial[cntsial]+sibob[cntsibob]) ):
ans += both[cntboth]
cntboth+=1
else:
ans += (sial[cntsial]+sibob[cntsibob])
cntsial+=1
cntsibob+=1
elif(cntboth>=bsize and cntsial<alsize and cntsibob<bosize):
ans += (sial[cntsial]+sibob[cntsibob])
cntsial+=1
cntsibob+=1
elif( cntboth<bsize and (cntsial>=alsize or cntboth>=bosize) ):
ans += both[cntboth]
cntboth+=1
count+=1
print(ans) | 11 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
const int inf = 1 << 30;
const long long mod = 1e9 + 7;
const long long linf = 1LL << 62;
const double EPS = 1e-7;
template <class T>
void chmin(T& x, T y) {
if (x > y) x = y;
}
template <class T>
void chmax(T& x, T y) {
if (x < y) x = y;
}
int n, m, k;
vector<pair<long long, long long> > g[4];
int solve(int mode, int pos) {
if (pos == -1) {
cout << -1 << endl;
return 0;
}
int mx = min((int)g[0].size(), m);
int ones = max(k - mx, 0);
if (ones > min(g[1].size(), g[2].size()) || mx + ones * 2 > m) {
return -1;
}
long long sum = 0;
for (int i = 0; i < mx; i++) sum += g[0][i].first;
set<pair<int, int> > fr, mn;
for (int i = 0; i < ones; i++) sum += g[1][i].first + g[2][i].first;
for (int i = ones; i < g[1].size(); i++) fr.insert(g[1][i]);
for (int i = ones; i < g[2].size(); i++) fr.insert(g[2][i]);
for (auto u : g[3]) fr.insert(u);
for (int i = 0; i < m - (ones * 2 + mx); i++) {
sum += fr.begin()->first;
mn.insert(*fr.begin());
fr.erase(fr.begin());
}
long long res = mx, val = sum;
for (int sz11 = mx - 1; sz11 >= 0; sz11--) {
if (mode == 1 && pos > sz11) break;
if (fr.empty()) break;
sum -= g[0][sz11].first;
sum += fr.begin()->first;
mn.insert(*fr.begin());
fr.erase(fr.begin());
if (sz11 < k) {
if (ones < g[1].size() && ones < g[2].size()) {
if (mn.size() < 2) break;
auto f = [&](int num) {
if (mn.find(g[num][ones]) != mn.end()) {
mn.erase(g[num][ones]);
} else {
sum += g[num][ones].first;
auto it = mn.end();
it--;
sum -= it->first;
mn.erase(it);
}
};
f(1), f(2);
ones++;
} else {
break;
}
}
if (val > sum) {
res = sz11;
val = sum;
}
}
if (mode == 1) {
cout << val << endl;
for (int i = 0; i < pos; i++) cout << g[0][i].second << " ";
for (int i = 0; i < ones; i++) cout << g[1][i].second << " ";
for (int i = 0; i < ones; i++) cout << g[2][i].second << " ";
for (auto u : mn) cout << u.second << " ";
cout << endl;
}
return res;
}
int main() {
cin >> n >> m >> k;
for (int i = 1; i <= n; i++) {
int t, a, b;
cin >> t >> a >> b;
if (a == 1 && b == 1)
g[0].push_back({t, i});
else if (a == 1)
g[1].push_back({t, i});
else if (b == 1)
g[2].push_back({t, i});
else
g[3].push_back({t, i});
}
for (int i = 0; i < 4; i++) sort(g[i].begin(), g[i].end());
solve(1, solve(0, 0));
}
| 11 | CPP |
t=1
while t>0 :
n,k=map(int,input().split())
a=[]
b=[]
c=[]
ans=0
for i in range(n) :
ti,al,bo=map(int,input().split())
if al==1 and bo==1 :
c.append(ti)
elif al==1 :
a.append(ti)
elif bo==1 :
b.append(ti)
a.sort()
b.sort()
for i in range(min(len(a),len(b))) :
c.append(a[i]+b[i])
c.sort()
if len(c)<k :
print(-1)
else :
print(sum(c[:k]))
# print(a,b,c)
# if len(c)+min(len(a),len(b))<k :
# print(-1)
# else :
# for i in range(k) :
# if len(a)>0 and len(b)>0 :
# if len(c)>0 :
# if a[0]+b[0]>c[0] :
# ans +=c[0]
# del c[0]
# else :
# ans+=a[0]+b[0]
# del a[0]
# del b[0]
# else :
# ans+=sum(a[:k-i])+sum(b[:k-i])
# break
# else :
# ans+=sum(c[:k-i])
# break
# #print(a,b,c,ans)
# print(ans)
t-=1 | 11 | PYTHON3 |
import sys
input=sys.stdin.readline
from collections import defaultdict
n,k=map(int,input().split())
c1,c2=k,k
both,al,bob=[],[],[]
co1,co2=0,0
for i in range(n):
t,a,b=map(int,input().split())
if a==1 and b==1:
both.append(t)
co1+=1
co2+=1
elif a==1:
al.append(t)
co1+=1
elif b==1:
bob.append(t)
co2+=2
if co1<k or co2<k:
print(-1)
exit()
maxa=max(len(both),len(al),len(bob))
for i in range(len(both),3*k):
both.append(1000000000000)
for i in range(len(al),3*k):
al.append(1000000000000)
for i in range(len(bob),3*k):
bob.append(1000000000000)
both.sort()
al.sort()
bob.sort()
#print(both,al,bob)
ans=0
i,j,k=0,0,0
while c1>0 and c2>0:
if both[i]<=al[j]+bob[k]:
ans+=both[i]
c1-=1
c2-=1
i+=1
else:
ans+=al[j]
ans+=bob[k]
j+=1
k+=1
c1-=1
c2-=1
if ans>=1000000000000:
print(-1)
else:
print(ans)
| 11 | PYTHON3 |
import sys
from collections import defaultdict as dd
from collections import deque
from fractions import Fraction as f
from copy import *
from bisect import *
from heapq import *
from math import *
from itertools import permutations
def eprint(*args):
print(*args, file=sys.stderr)
zz=1
#sys.setrecursionlimit(10**6)
if zz:
input=sys.stdin.readline
else:
sys.stdin=open('input.txt', 'r')
sys.stdout=open('all.txt','w')
def li():
return [int(x) for x in input().split()]
def fi():
return int(input())
def si():
return list(input().rstrip())
def mi():
return map(int,input().split())
def gh():
sys.stdout.flush()
def graph(n,m):
for i in range(m):
x,y=mi()
a[x].append(y)
a[y].append(x)
def bo(i):
return ord(i)-ord('a')
n,k=mi()
a=[]
for i in range(n):
p=li()
a.append(p)
a.sort()
c=d=ans=0
c1=[]
d1=[]
r=0
#print(a)
for i in range(n):
if a[i][1:]==[0,1]:
if d+r>=k:
continue
ans+=a[i][0]
d1.append(a[i][0])
d+=1
elif a[i][1:]==[1,0]:
if c+r>=k:
continue
ans+=a[i][0]
c1.append(a[i][0])
c+=1
elif a[i][1:]==[1,1]:
#ans+=a[i][0]
if c+r>=k and d+r>=k and len(c1)+len(d1)>1:
#print("lol")
if c1[-1]+d1[-1]>a[i][0]:
#print("LOL",ans)
r+=1
c-=1
d-=1
ans-=(c1[-1]+d1[-1])
ans+=a[i][0]
c1.pop()
d1.pop()
continue
if c+r<k or d+r<k:
r+=1
ans+=a[i][0]
if c+r>k:
ans-=c1[-1]
c-=1
c1.pop()
#ans+=a[i][0]
if d+r>k:
ans-=d1[-1]
d-=1
d1.pop()
#ans+=a[i][0]
if r>=k:
break
#print(c+r,d+r,r,ans,c1,d1)
print(ans if c+r>=k and d+r>=k else -1)
| 11 | PYTHON3 |
#include <bits/stdc++.h>
#pragma GCC target("avx")
#pragma GCC optimize("O3")
#pragma GCC optimize("unroll-loops")
#pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,tune=native")
using std::cin;
using std::cout;
using std::lower_bound;
using std::string;
using std::upper_bound;
using std::vector;
using vi = vector<long long>;
using vii = vector<vi>;
using pii = std::pair<long long, long long>;
constexpr long long MOD = 1e9 + 7;
constexpr long long MAX = 1e7;
constexpr long long INF = (1ll << 60);
template <class T>
class prique : public std::priority_queue<T, std::vector<T>, std::greater<T>> {
};
template <typename T>
struct Segment_tree {
long long N;
T mem;
vector<T> node;
Segment_tree(vector<T> &X, T m) : mem(m) {
long long sz = X.size();
N = 1;
while (N < sz) N *= 2;
node.resize(2 * N - 1, mem);
for (long long i = (long long)(0); i < (long long)(sz); i++)
node[N - 1 + i] = X[i];
for (long long i = (long long)(N - 2); (long long)(0) <= i; i--) {
node[i] = Compare(node[i * 2 + 1], node[i * 2 + 2]);
}
}
T Compare(T &A, T &B) { return std::min(A, B); }
void update(long long X, T val) {
X += N - 1;
node[X] = val;
while (X > 0) {
X = (X - 1) / 2;
node[X] = Compare(node[X * 2 + 1], node[X * 2 + 2]);
}
}
T Query(long long a, long long b, long long now, long long l, long long r) {
if (r < 0) r = N;
if (r <= a || b <= l) return mem;
if (a <= l && r <= b) return node[now];
auto vl = Query(a, b, now * 2 + 1, l, (l + r) / 2),
vr = Query(a, b, now * 2 + 2, (l + r) / 2, r);
return Compare(vl, vr);
}
};
struct Binary_indexed_tree {
int N;
vi bit;
Binary_indexed_tree(int n) : N(n) { bit.resize(N + 1, 0); }
void add(int x, int a) {
for (x; x <= N; x += (x & -x)) bit[x] += a;
}
long long sum(int x) {
long long ret = 0;
for (x; x > 0; x -= (x & -x)) ret += bit[x];
return ret;
}
long long lower_bound(long long X) {
if (sum(N) < X) return -1;
long long ret = 0, memo = 1, sum = 0;
while (memo * 2 <= N) memo *= 2;
while (memo > 0) {
if (memo + ret <= N && sum + bit[memo + ret] < X) {
sum += bit[memo + ret];
ret += memo;
}
memo /= 2;
}
return ret + 1;
}
};
struct Union_Find {
long long N;
vi par;
vi siz;
Union_Find(int n) : N(n) {
par.resize(N);
siz.resize(N, 1);
for (long long i = (long long)(0); i < (long long)(N); i++) par[i] = i;
}
long long root(long long X) {
if (par[X] == X) return X;
return par[X] = root(par[X]);
}
bool same(long long X, long long Y) { return root(X) == root(Y); }
void unite(long long X, long long Y) {
X = root(X);
Y = root(Y);
if (X == Y) return;
par[X] = Y;
siz[Y] += siz[X];
siz[X] = 0;
}
long long size(long long X) { return siz[root(X)]; }
};
long long modpow(long long a, long long n, long long mod) {
long long res = 1;
while (n > 0) {
if (n & 1) res = res * a % mod;
a = a * a % mod;
n >>= 1;
}
return res;
}
vi fac, finv, inv;
void COMinit() {
fac.resize(MAX);
finv.resize(MAX);
inv.resize(MAX);
fac[0] = fac[1] = 1;
finv[0] = finv[1] = 1;
inv[1] = 1;
for (int i = 2; i < MAX; i++) {
fac[i] = fac[i - 1] * i % MOD;
inv[i] = MOD - inv[MOD % i] * (MOD / i) % MOD;
finv[i] = finv[i - 1] * inv[i] % MOD;
}
}
long long COM(long long n, long long r) {
if (n < r || n < 0 || r < 0) return 0;
return fac[n] * finv[r] % MOD * finv[n - r] % MOD;
}
long long modinv(long long a, long long m) {
long long b = m, u = 1, v = 0;
while (b) {
long long t = a / b;
a -= t * b;
std::swap(a, b);
u -= t * v;
std::swap(u, v);
}
u %= m;
if (u < 0) u += m;
return u;
}
int main() {
std::ios::sync_with_stdio(false);
std::cin.tie(nullptr);
long long N, K, M;
cin >> N >> M >> K;
vii memo(4);
vector<std::set<pii>> p(4);
for (long long i = (long long)(0); i < (long long)(N); i++) {
long long T, A, B;
cin >> T >> A >> B;
long long sum = 0;
if (A) sum += 1;
if (B) sum += 2;
memo[sum].emplace_back(T);
p[sum].insert(std::make_pair(T, i));
}
for (long long i = (long long)(0); i < (long long)(4); i++)
sort((memo[i]).begin(), (memo[i]).end());
std::tuple<long long, long long, long long, long long> ans =
std::make_tuple(INF, INF, INF, INF);
vii sum(4, vi(1));
for (long long i = (long long)(0); i < (long long)(4); i++) {
for (long long j = (long long)(0); j < (long long)(memo[i].size()); j++)
sum[i].emplace_back(sum[i][j] + memo[i][j]);
}
for (long long i = (long long)(0); i <= (long long)(memo[3].size()); i++) {
if (K < i) break;
vi max(4);
if (K - i > (long long)memo[1].size() || K - i > (long long)memo[2].size())
continue;
max[3] = i;
max[2] = max[1] = K - i;
if (max[1] + max[2] + max[3] > M) continue;
long long left = 0, right = INF;
while (left + 1 < right) {
long long mid = (left + right) / 2;
long long cnt = 0;
for (long long j = (long long)(0); j < (long long)(4); j++) {
cnt += std::max(
(long long)distance(memo[j].begin(),
upper_bound((memo[j]).begin(), (memo[j]).end(),
(long long)(mid))),
max[j]);
}
if (cnt >= M)
right = mid;
else
left = mid;
}
long long Sum = 0, cnt = 0;
for (long long j = (long long)(0); j < (long long)(4); j++) {
long long X = std::max(
(long long)distance(memo[j].begin(),
upper_bound((memo[j]).begin(), (memo[j]).end(),
(long long)(right))),
max[j]);
cnt += X;
Sum += sum[j][X];
}
Sum -= right * (cnt - M);
ans = std::min(ans, std::make_tuple(Sum, i, right, cnt - M));
}
long long Ans, X, Y, differ;
std::tie(Ans, X, Y, differ) = ans;
if (Ans == INF) {
cout << -1 << "\n";
return 0;
}
cout << Ans << "\n";
vi max(4);
max[3] = X;
max[2] = max[1] = K - X;
std::set<long long> ind;
for (long long i = (long long)(0); i < (long long)(4); i++) {
long long Z = std::max(
max[i],
(long long)distance(
memo[i].begin(),
upper_bound((memo[i]).begin(), (memo[i]).end(), (long long)(Y))));
auto it = p[i].begin();
for (long long j = (long long)(0); j < (long long)(Z); j++) {
ind.insert((*it).second);
it++;
}
}
while (differ > 0) {
for (long long i = (long long)(0); i < (long long)(4); i++) {
long long Z = std::max(
max[i],
(long long)distance(
memo[i].begin(),
upper_bound((memo[i]).begin(), (memo[i]).end(), (long long)(Y))));
auto it = p[i].begin();
for (long long j = (long long)(0); j < (long long)(Z); j++) {
if (j >= max[i] && (*it).first == Y) {
differ--;
ind.erase((*it).second);
if (differ == 0) goto XYZ;
}
it++;
}
}
XYZ:;
}
for (auto p : ind) cout << p + 1 << " ";
cout << "\n";
}
| 11 | CPP |
import sys
tokens = input().split()
n, nb_required = int(tokens[0]), int(tokens[1])
both_liked = []
alice_liked = []
bob_liked = []
for i in range(n):
tokens = input().split()
t, a, b = int(tokens[0]), int(tokens[1]), int(tokens[2])
if a == 1 and b == 1:
both_liked.append(t)
elif a == 1:
alice_liked.append(t)
elif b == 1:
bob_liked.append(t)
both_liked.sort()
alice_liked.sort()
bob_liked.sort()
i = 0
j = 0
k = 0
total = 0
while nb_required > 0:
if k < len(both_liked):
if i == len(alice_liked) or j == len(bob_liked) or both_liked[k] <= alice_liked[i] + bob_liked[j]:
nb_required -= 1
total += both_liked[k]
k += 1
continue
if i == len(alice_liked) or j == len(bob_liked):
print(-1)
sys.exit(0)
nb_required -= 1
total += alice_liked[i] + bob_liked[j]
i += 1
j += 1
print(total)
| 11 | PYTHON3 |
#!/usr/bin/pypy3
n, k = map(int, input().split())
x, y, z = [], [], []
for _ in range(n):
t, a, b = map(int, input().split())
if a & b:
z.append(t)
elif a:
x.append(t)
elif b:
y.append(t)
x.sort()
y.sort()
for i in range(min(len(x), len(y))):
z.append(x[i] + y[i])
z.sort()
if len(z) >= k:
print(sum(z[:k]))
else:
print(-1)
| 11 | PYTHON3 |
n, k = map(int, input().split())
aa = []
bb = []
oo = []
for i in range(n):
t, a, b = map(int, input().split())
if (a==1):
if (b==1):
oo.append(t)
else:
aa.append(t)
else:
if (b==1):
bb.append(t)
if (len(aa) + len(oo) < k) or (len(oo) + len(bb) < k):
print(-1)
else:
aa.sort(reverse = True)
bb.sort(reverse = True)
oo.sort(reverse= True)
ans = 0
for i in range(k):
if len(oo)==0:
ans += aa.pop()
ans += bb.pop()
elif len(aa)==0 or len(bb)==0:
ans += oo.pop()
else:
if (oo[-1] < aa[-1]+bb[-1]):
ans += oo.pop()
else:
ans += aa.pop()
ans += bb.pop()
print(ans) | 11 | PYTHON3 |
import os
import sys
from io import BytesIO, IOBase
BUFSIZE = 8192
class FastIO(IOBase):
newlines = 0
def __init__(self, file):
self._fd = file.fileno()
self.buffer = BytesIO()
self.writable = "x" in file.mode or "r" not in file.mode
self.write = self.buffer.write if self.writable else None
def read(self):
while True:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
if not b:
break
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines = 0
return self.buffer.read()
def readline(self):
while self.newlines == 0:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
self.newlines = b.count(b"\n") + (not b)
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines -= 1
return self.buffer.readline()
def flush(self):
if self.writable:
os.write(self._fd, self.buffer.getvalue())
self.buffer.truncate(0), self.buffer.seek(0)
class IOWrapper(IOBase):
def __init__(self, file):
self.buffer = FastIO(file)
self.flush = self.buffer.flush
self.writable = self.buffer.writable
self.write = lambda s: self.buffer.write(s.encode("ascii"))
self.read = lambda: self.buffer.read().decode("ascii")
self.readline = lambda: self.buffer.readline().decode("ascii")
sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)
input = lambda: sys.stdin.readline().rstrip("\r\n")
def list2d(a, b, c): return [[c] * b for i in range(a)]
def list3d(a, b, c, d): return [[[d] * c for j in range(b)] for i in range(a)]
def list4d(a, b, c, d, e): return [[[[e] * d for j in range(c)] for j in range(b)] for i in range(a)]
def ceil(x, y=1): return int(-(-x // y))
def Yes(): print('Yes')
def No(): print('No')
def YES(): print('YES')
def NO(): print('NO')
INF = 10 ** 18
MOD = 10**9+7
Ri = lambda : [int(x) for x in sys.stdin.readline().split()]
ri = lambda : sys.stdin.readline().strip()
# for _ in range(int(ri())):
n,k =Ri()
lis = []
a = []
b = []
ab = []
for i in range(n):
temp = Ri()
if temp[1] != 0 or temp[2] != 0:
if temp[1] !=0 and temp[2] != 0:
ab.append(temp[0])
elif temp[1] != 0:
a.append(temp[0])
else:
b.append(temp[0])
ab.sort()
a.sort()
b.sort()
if len(ab) + len(a) < k or len(ab) + len(b) < k:
print(-1)
else:
ans = 0
totans = 0
curab,cura,curb = 0,0,0
while ans < k:
if len(a) == cura or len(b) == curb:
ans+=1
totans+=ab[curab]
curab+=1
else:
if len(ab) == curab:
ans+=1
totans+=a[cura]+b[curb]
cura+=1
curb+=1
# ans+=1
else:
if ab[curab] > a[cura]+b[curb]:
ans+=1
totans+=a[cura]+b[curb]
cura+=1
curb+=1
# ans+=1
else:
ans+=1
totans+=ab[curab]
curab+=1
print(totans)
| 11 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
const long long N = 2e5 + 10;
const long long inf = 1e9;
struct node {
long long num, tim;
} A[N], B[N], C[N], D[N];
bool cmp(node l1, node l2) { return l1.tim < l2.tim; }
signed main() {
ios::sync_with_stdio(false);
cin.tie(0);
long long n, m, k, x, y, z, a = 0, b = 0, c = 0, d = 0;
cin >> n >> m >> k;
for (long long i = 1; i <= n; ++i) {
cin >> x >> y >> z;
if (y && z) {
C[c].num = i;
C[c++].tim = x;
} else if (y) {
A[a].num = i;
A[a++].tim = x;
} else if (z) {
B[b].num = i;
B[b++].tim = x;
} else {
D[d].num = i;
D[d++].tim = x;
}
}
if (a + c < k || b + c < k) {
cout << -1 << endl;
return 0;
}
if (c < k && (k - c) * 2 + c > m) {
cout << -1 << endl;
return 0;
}
sort(A, A + a, cmp);
sort(B, B + b, cmp);
sort(C, C + c, cmp);
sort(D, D + d, cmp);
long long ai = 0, bi = 0, ci = 0, di = 0, sum = 0;
for (; ci < c; ++ci) {
if (ci == k) break;
sum += C[ci].tim;
}
while (ai + ci < k) {
sum += A[ai].tim + B[bi].tim;
ai++, bi++;
}
while (ai + bi + ci + di < m) {
long long pro1, pro2, pro3, pro4, pro5;
if (ai < a && bi < b && ci)
pro1 = A[ai].tim + B[bi].tim - C[ci - 1].tim;
else
pro1 = inf;
if (ai < a)
pro2 = A[ai].tim;
else
pro2 = inf;
if (bi < b)
pro3 = B[bi].tim;
else
pro3 = inf;
if (ci < c)
pro4 = C[ci].tim;
else
pro4 = inf;
if (di < d)
pro5 = D[di].tim;
else
pro5 = inf;
long long mini = min(pro1, min(pro2, min(pro3, min(pro4, pro5))));
if (mini == inf) {
cout << -1 << endl;
return 0;
}
sum += mini;
if (mini == pro1 && pro1 < inf)
ai++, bi++, ci--;
else if (mini == pro2 && pro2 < inf)
ai++;
else if (mini == pro3 && pro3 < inf)
bi++;
else if (mini == pro4 && pro4 < inf)
ci++;
else if (mini == pro5 && pro5 < inf)
di++;
}
cout << sum << endl;
for (long long i = 0; i < ai; ++i) cout << A[i].num << " ";
for (long long i = 0; i < bi; ++i) cout << B[i].num << " ";
for (long long i = 0; i < ci; ++i) cout << C[i].num << " ";
for (long long i = 0; i < di; ++i) cout << D[i].num << " ";
return 0;
}
| 11 | CPP |
from heapq import *
l=[]
n,k=map(int,input().split());
a,b,c=[],[],[]
for i in range(n):
l.append(list(map(int,input().split())))
l.sort()
for i in range(n):
la,lb=len(a)+len(c),len(b)+len(c)
if((l[i][1]==1 or l[i][2]==1) and (la<k or lb<k)):
if(l[i][1]==1 and l[i][2]==0 and la<k):
heappush(a,-l[i][0])
elif(l[i][1]==0 and l[i][2]==1 and lb<k):
heappush(b,-l[i][0])
elif((l[i][1]==1 and l[i][2]==1)):
heappush(c,-l[i][0])
elif((l[i][1]==1 and l[i][2]==1) and (la==k and lb==k)):
ra,rb=0,0
if(len(a)>0):
ra=-a[0]
if(len(b)>0):
rb=-b[0]
if((ra+rb)>l[i][0]):
heappush(c,-l[i][0])
if(len(a)+len(c)>k):
heappop(a)
if(len(b)+len(c)>k):
heappop(b)
if(len(a)+len(c)<k or len(b)+len(c)<k):
print(-1)
else:
print(-(sum(a)+sum(b)+sum(c)))
| 11 | PYTHON3 |
import os
import sys
from io import BytesIO, IOBase
# region fastio
BUFSIZE = 8192
class FastIO(IOBase):
newlines = 0
def __init__(self, file):
self._fd = file.fileno()
self.buffer = BytesIO()
self.writable = "x" in file.mode or "r" not in file.mode
self.write = self.buffer.write if self.writable else None
def read(self):
while True:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
if not b:
break
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines = 0
return self.buffer.read()
def readline(self):
while self.newlines == 0:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
self.newlines = b.count(b"\n") + (not b)
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines -= 1
return self.buffer.readline()
def flush(self):
if self.writable:
os.write(self._fd, self.buffer.getvalue())
self.buffer.truncate(0), self.buffer.seek(0)
class IOWrapper(IOBase):
def __init__(self, file):
self.buffer = FastIO(file)
self.flush = self.buffer.flush
self.writable = self.buffer.writable
self.write = lambda s: self.buffer.write(s.encode("ascii"))
self.read = lambda: self.buffer.read().decode("ascii")
self.readline = lambda: self.buffer.readline().decode("ascii")
sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)
input = lambda: sys.stdin.readline().rstrip("\r\n")
# ------------------------------
def RL(): return map(int, sys.stdin.readline().rstrip().split())
def RLL(): return list(map(int, sys.stdin.readline().rstrip().split()))
def N(): return int(input())
def comb(n, m): return factorial(n) / (factorial(m) * factorial(n - m)) if n >= m else 0
def perm(n, m): return factorial(n) // (factorial(n - m)) if n >= m else 0
def mdis(x1, y1, x2, y2): return abs(x1 - x2) + abs(y1 - y2)
mod = 998244353
INF = float('inf')
from math import factorial
from collections import Counter, defaultdict, deque
from heapq import heapify, heappop, heappush
# ------------------------------
# f = open('../input.txt')
# sys.stdin = f
def main():
n, k = RL()
na = 0
nb = 0
ab = 0
ar, br, abr = [], [], []
for _ in range(n):
t, a, b = RL()
if a and not b:
na+=1
ar.append(t)
if b and not a:
nb+=1
br.append(t)
if a==1 and b==1:
ab+=1
abr.append(t)
if na+ab<k or nb+ab<k:
print(-1)
else:
ar.sort()
br.sort()
for a, b in zip(ar, br):
abr.append(a+b)
abr.sort()
print(sum(abr[:k]))
if __name__ == "__main__":
main()
| 11 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, k, x, xa, xb, aa = 0, bb = 0, cc;
vector<int> a, b, c;
cin >> n >> k;
for (int i = 0; i < n; i++) {
cin >> x >> xa >> xb;
aa += xa;
bb += xb;
if (xa & xb)
c.push_back(x);
else if (xa)
a.push_back(x);
else if (xb)
b.push_back(x);
}
if (aa < k || bb < k) {
cout << -1;
return 0;
}
aa = 0;
bb = 0;
cc = 0;
int ka = a.size(), kb = b.size(), kc = c.size();
x = 0;
sort(a.begin(), a.end());
sort(b.begin(), b.end());
sort(c.begin(), c.end());
for (int i = 0; i < k; i++) {
if (cc >= kc)
x += a[aa++] + b[bb++];
else if (aa < ka && bb < kb) {
if (a[aa] + b[bb] < c[cc])
x += a[aa++] + b[bb++];
else
x += c[cc++];
} else {
x += c[cc++];
}
}
cout << x;
return 0;
}
| 11 | CPP |
#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);
}
| 11 | CPP |
n,k=map(int,input().split())
a,b,tog=[],[],[]
for i in range(n):
t,x,y=map(int,input().split())
if x==1 and y==1:
tog.append(t)
elif x==1 and y==0:
a.append(t)
elif x==0 and y==1:
b.append(t)
ltog=len(tog)
la=len(a)
lb=len(b)
if ltog+la<k or ltog+lb<k:
print(-1)
else:
a.sort(reverse=True)
b.sort(reverse=True)
tog.sort(reverse=True)
ca,cb=0,0
res=0
while ca<k or cb<k:
if tog:
ptog=tog[-1]
else:
ptog=0
if a:
pa=a[-1]
else:
pa=0
if b:
pb=b[-1]
else:
pb=0
if ca<k and cb<k:
if pa and pb and ptog:
if pa+pb<ptog:
res+=pa+pb
a.pop()
b.pop()
else:
res+=ptog
tog.pop()
ca+=1
cb+=1
elif ptog:
res+=ptog
tog.pop()
ca+=1
cb+=1
elif pa and pb:
res+=pa+pb
a.pop()
b.pop()
ca+=1
cb+=1
else:
res=-1
break
else:
if ca<k:
if pa and ptog:
if pa<ptog:
res+=pa
a.pop()
ca+=1
else:
res+=ptog
tog.pop()
ca+=1
cb+=1
elif ptog:
res+=ptog
tog.pop()
ca+=1
cb+=1
elif pa:
res+=pa
a.pop()
ca+=1
else:
res=-1
break
elif cb<k:
if pb and ptog:
if pb<ptog:
res+=pb
b.pop()
cb+=1
else:
res+=ptog
tog.pop()
ca+=1
cb+=1
elif ptog:
res+=ptog
tog.pop()
ca+=1
cb+=1
elif pb:
res+=pb
b.pop()
cb+=1
else:
res=-1
break
print(res)
| 11 | PYTHON3 |
N, K = [int(i) for i in input().split()]
T, A, B = [], [], []
Tall = []
Talice = []
Tbob = []
for i in range(N):
t, a, b = [int(j) for j in input().split()]
T.append(t)
A.append(a)
B.append(b)
if a and b:
Tall.append(t)
elif a:
Talice.append(t)
elif b:
Tbob.append(t)
Tall = sorted(Tall)
Talice = sorted(Talice)
Tbob = sorted(Tbob)
iall = 0
isep = 0
ans = 0
ml = min(len(Talice), len(Tbob))
for i in range(K):
if iall >= len(Tall) and isep >= ml:
ans = -1
break
if iall < len(Tall) and (isep >= ml or (Tall[iall] <= Talice[isep] + Tbob[isep])):
ans += Tall[iall]
iall += 1
else:
ans += Talice[isep] + Tbob[isep]
isep += 1
print(ans)
| 11 | PYTHON3 |
n, k = map(int, input().split())
a = []
b = []
ab = []
for i in range(n):
x, y, z = map(int, input().split())
if y == 1 and z == 1:
ab.append(x)
elif y == 1:
a.append(x)
elif z == 1:
b.append(x)
a = sorted(a)
b = sorted(b)
#ab = sorted(ab)
for i in range(min(len(a), len(b))):
ab.append(a[i] + b[i])
ab = sorted(ab)
ans = 0
if len(ab) >= k:
for i in range(k):
ans += ab[i]
else:
print(-1)
exit()
print(ans)
| 11 | PYTHON3 |
#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");
}
}
}
| 11 | CPP |
#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 << " ";
}
| 11 | CPP |
# -*- coding: utf-8 -*-
"""
Created on Thu Jul 9 09:18:37 2020
@author: Harshal
"""
n,k=map(int,input().split());
z=[]
x=[]
y=[]
for _ in range(n):
t,a,b=map(int,input().split())
if a&b:
z.append(t)
elif a:
x.append(t)
elif b:
y.append(t)
x.sort()
y.sort()
for i in range(min(len(x),len(y))):
z.append(x[i]+y[i])
z.sort()
print( -1 if len(z)<k else sum(z[:k])) | 11 | PYTHON3 |
#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;
}
| 11 | CPP |
temparr = input()
temparr = temparr.split()
n = int(temparr[0])
minimum = int(temparr[1])
common = []
alice = []
bob = []
for i in range(n):
temparr = input()
temparr = temparr.split()
t = int(temparr[0])
a = int(temparr[1])
b = int(temparr[2])
if a == 1 and b == 1:
common.append(t)
continue
if a == 1 :
alice.append(t)
if b == 1 :
bob.append(t)
common = sorted(common)
alice = sorted(alice)
bob = sorted(bob)
counta = 0
countb = 0
commonlen = len(common)
alicelen = len(alice)
boblen = len(bob)
i = 0
j = 0
k = 0
flag = 0
ans = 0
# print(alice)
# print(bob)
# print(common)
if commonlen + alicelen < minimum or commonlen + boblen < minimum:
print(-1)
else:
while True:
if counta >= minimum and countb >= minimum:
print(ans)
break
if i == commonlen and j == alicelen and k == boblen:
flag = 1
break
if j == alicelen or k == boblen:
ans += common[i]
countb += 1
counta += 1
i += 1
elif i == commonlen:
counta += 1
countb += 1
ans += alice[j]
ans += bob[k]
j += 1
k += 1
elif common[i] <= alice[j] + bob[k]:
ans += common[i]
i += 1
counta += 1
countb += 1
else:
counta += 1
countb += 1
ans += alice[j]
ans += bob[k]
j += 1
k += 1
if flag == 1:
print(-1)
| 11 | PYTHON3 |
n, k = map(int, input().split())
group = [[], [], [], []]
for i in range(n):
t, a, b = map(int, input().split())
group[a * 2 + b].append(t)
pref_sum = [[0], [0], [0], [0]]
for g, ps in zip(group, pref_sum):
g.sort()
for i in g:
ps.append(ps[-1] + i)
# print(group)
# print(pref_sum)
ans = 10**18
for i in range(min(k, len(group[3])) + 1):
rest = k - i
if rest > len(group[2]) or rest > len(group[1]):
continue
ans = min(ans, pref_sum[3][i] + pref_sum[1][rest] + pref_sum[2][rest])
if ans < 10**18:
print(ans)
else:
print(-1)
| 11 | PYTHON3 |
n, k = map(int, input().split())
cnta = []
cntb = []
cntab = []
for i in range(n):
t, a, b = map(int, input().split())
if a:
if b:
cntab.append(t)
else:
cnta.append(t)
elif b:
cntb.append(t)
T = 0
cnta = sorted(cnta)
cntb = sorted(cntb)
cntab = sorted(cntab)
l, m = 0, 0
r = min(len(cnta), len(cntb))
it = 0
while (l < r) and (it < k):
if (m >= len(cntab)) or (cnta[l] + cntb[l] < cntab[m]):
T += cnta[l] + cntb[l]
l += 1
else:
T += cntab[m]
m += 1
it += 1
if (it + len(cntab) - m < k):
print(-1)
else:
print(T + sum(cntab[m:m + k - it]))
| 11 | PYTHON3 |
a,b = map(int,input().split())
m,n,o,ans=[],[],[],0
for _ in range(a):
q,w,e= map(int,input().split())
if w==e==1:m.append(q)
elif w!=e:
if e==0:n.append(q)
else:o.append(q)
m.sort();n.sort();o.sort()
v,t,u=[],min(len(n),len(o)),len(m)
for i in range(t):
v.append(n[i]+o[i])
if b>u+t:
print(-1)
else:
i,j=0,0
while b>0:
if i<u and j<t:
if m[i]<=v[j]:
ans+=m[i]
i+=1
else:
ans+=v[j]
j+=1
else:
if i<=(u-1):
ans+=m[i]
i+=1
elif j<=(t-1):
ans+=v[j]
j+=1
b-=1
print(ans) | 11 | PYTHON3 |
import math
from collections import Counter,deque
L=lambda:list(map(int,input().split()))
M=lambda:map(int,input().split())
I=lambda:int(input())
IN=lambda:input()
mod=10**9+7
def s(a):
print(" ".join(list(map(str,a))))
#______________________-------------------------------_____________________#
def solve():
n,k=M()
a=[];b=[]
d=[]
for i in range(n):
t,x,y=M()
if x+y==2:
d.append(t)
elif x==1:
a.append(t)
elif y==1:
b.append(t)
a.sort()
b.sort()
for i in range(min(len(a),len(b))):
d.append((a[i]+b[i]))
if len(d)<k:
print(-1)
else:
d.sort()
print(sum(d[:k]))
for i in range(1):
solve()
| 11 | PYTHON3 |
#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();
}
| 11 | CPP |
#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();
}
| 11 | CPP |
n, k = tuple(map(int, input().split()))
alice = []
bob = []
both = []
for _ in range(n):
t, a, b = tuple(map(int, input().split()))
if a == 1 and b == 1:
both.append(t)
elif a == 1:
alice.append(t)
elif b == 1:
bob.append(t)
both.sort()
alice.sort()
bob.sort()
remain = 0
if k <= len(both):
result = sum(both[:k])
else:
remain = k - len(both)
if remain > len(bob) or remain > len(alice):
result = -1
else:
result = sum(both)
result += sum(alice[:remain]) + sum(bob[:remain])
index = max(0, k - len(both))
lenbob = len(bob)
lenalice = len(alice)
if result != -1:
for i in range(min(k, len(both)) - 1, -1, -1):
if index > lenbob - 1 or index > lenalice - 1:
break
newresult = result - both[i] + alice[index] + bob[index]
index += 1
if newresult < result:
result = newresult
else:
break
print(result)
| 11 | PYTHON3 |
#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;
}
| 11 | CPP |
n,k = map(int,input().split())
a = []
b =[]
c = []
c1 = []
for i in range(n):
q,w,e = map(int,input().split())
if w== 1 and e == 1:
c.append(q)
if w == 1 and e == 0:
a.append(q)
if w == 0 and e == 1:
b.append(q)
a = sorted(a)
b = sorted(b)
for i in range(min(len(a),len(b))):
c.append(a[i]+b[i])
c = sorted(c)
if len(c)<k:
print(-1)
exit(0)
s = 0
for i in range(k):
s+=c[i]
print(s) | 11 | PYTHON3 |
n,k=map(int,input().split())
ans=[]
c1=0
c2=0
for i in range(n):
z=list(map(int,input().split()))
if(z[1]==1):
c1+=1
if(z[2]==1):
c2+=1
ans.append(z)
if(min(c1,c2)<k):
print(-1)
else:
a0=[]
a1=[]
a2=[]
for i in range(len(ans)):
if(ans[i][1]==1 and ans[i][2]==1):
a0.append(ans[i])
elif(ans[i][1]==1 and ans[i][2]==0):
a1.append(ans[i])
elif(ans[i][1]==0 and ans[i][2]==1):
a2.append(ans[i])
p0=0
p1=0
p2=0
c1=0
c2=0
a0.sort()
a1.sort()
a2.sort()
total=0
while(c1<k and c2<k):
if(p0<len(a0) and p1<len(a1) and p2<len(a2) and a0[p0][0]<=a1[p1][0]+a2[p2][0]):
total+=a0[p0][0]
c1+=1
c2+=1
p0+=1
else:
if(p1<len(a1) and p2<len(a2)):
total+=a1[p1][0]+a2[p2][0]
c1+=1
c2+=1
p1+=1
p2+=1
continue;
if(p1==len(a1) or p2==len(a2)):
total+=a0[p0][0]
c1+=1
c2+=1
p0+=1
print(total)
| 11 | PYTHON3 |
# input = raw_input
# range = xrange
import sys
inp = [int(x) for x in sys.stdin.read().split()]; ii = 0
seg = [0]*200000
def offset(x):
return x + 100000
def encode(x, y):
return x*200002 + y
def decode(x):
return x//200002, x%200002
def upd(node, L, R, pos, val):
while L < R:
seg[node] += val
seg[offset(node)] += val*pos
if L+1 == R:
break
M = (L+R)//2
node <<= 1
if pos < M:
R = M
else:
L = M
node += 1
def query(node, L, R, k):
ret = 0
while L < R:
if k == 0:
return ret
if seg[node] == k:
return ret + seg[offset(node)]
if L+1 == R:
return ret + k*L
M = (L+R)//2
node <<= 1
if seg[node] >= k:
R = M
else:
ret += seg[offset(node)]
k -= seg[node]
L = M
node += 1
return ret
n, m, k = inp[ii:ii+3]; ii += 3
A, B, both, neither = [], [], [], []
for i in range(n):
t, a, b = inp[ii:ii+3]; ii += 3
if a == 0 and b == 0:
neither.append(encode(t, i+1))
if a == 1 and b == 0:
A.append(encode(t, i+1))
if a == 0 and b == 1:
B.append(encode(t, i+1))
if a == 1 and b == 1:
both.append(encode(t, i+1))
upd(1, 0, 10001, t, 1)
A.sort(); B.sort(); both.sort()
p1 = min(k, len(both))
p2 = k - p1
if 2*k - p1 > m or p2 > min(len(A), len(B)):
print(-1)
exit(0)
sum, ans, ch = 0, 2**31, p1
for i in range(p1):
sum += both[i]//200002
upd(1, 0, 10001, both[i]//200002, -1)
for i in range(p2):
sum += A[i]//200002 + B[i]//200002
upd(1, 0, 10001, A[i]//200002, -1)
upd(1, 0, 10001, B[i]//200002, -1)
ans = query(1, 0, 10001, m-2*k+p1) + sum
while p1 > 0:
if p2 == min(len(A), len(B)):
break
upd(1, 0, 10001, A[p2]//200002, -1); sum += A[p2]//200002
upd(1, 0, 10001, B[p2]//200002, -1); sum += B[p2]//200002
upd(1, 0, 10001, both[p1-1]//200002, 1); sum -= both[p1-1]//200002
p2 += 1
p1 -= 1
if m - 2*k + p1 < 0:
break
Q = query(1, 0, 10001, m-2*k+p1)
if ans > sum + Q:
ans = sum + Q
ch = p1
print(ans)
ind = [both[i]%200002 for i in range(ch)] + [A[i]%200002 for i in range(k-ch)] + [B[i]%200002 for i in range(k-ch)]
st = neither + [both[i] for i in range(ch, len(both))] + [A[i] for i in range(k-ch, len(A))] + [B[i] for i in range(k-ch, len(B))]
st.sort()
ind += [st[i]%200002 for i in range(m-2*k+ch)]
print (' '.join(str(x) for x in ind)) | 11 | PYTHON3 |
#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();
}
}
| 11 | CPP |
#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';
}
| 11 | CPP |
n,k=map(int,input().split())
p1=[]
a1=[]
b1=[]
c1=0
c2=0
for _ in range(n):
p,a,b=map(int,input().split())
if(a==1 and b==1):
p1.append(p)
c1+=1
c2+=1
elif(a==1):
a1.append(p)
c1+=1
elif( b==1):
b1.append(p)
c2+=1
if(c1<k or c2<k):
print(-1)
else:
a1.sort()
b1.sort()
i=0
while(i<len(a1) and i<len(b1)):
p1.append(a1[i]+b1[i])
i+=1
p1.sort()
ans=0
for i in range(k):
ans+=p1[i]
print(ans)
| 11 | PYTHON3 |
####################################################
import os
import sys
from io import BytesIO, IOBase
BUFSIZE = 8192
class FastIO(IOBase):
newlines = 0
def __init__(self, file):
self._fd = file.fileno()
self.buffer = BytesIO()
self.writable = "x" in file.mode or "r" not in file.mode
self.write = self.buffer.write if self.writable else None
def read(self):
while True:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
if not b:
break
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines = 0
return self.buffer.read()
def readline(self):
while self.newlines == 0:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
self.newlines = b.count(b"\n") + (not b)
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines -= 1
return self.buffer.readline()
def flush(self):
if self.writable:
os.write(self._fd, self.buffer.getvalue())
self.buffer.truncate(0), self.buffer.seek(0)
class IOWrapper(IOBase):
def __init__(self, file):
self.buffer = FastIO(file)
self.flush = self.buffer.flush
self.writable = self.buffer.writable
self.write = lambda s: self.buffer.write(s.encode("ascii"))
self.read = lambda: self.buffer.read().decode("ascii")
self.readline = lambda: self.buffer.readline().decode("ascii")
sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)
input = lambda: sys.stdin.readline().rstrip("\r\n")
#######################################
n,k=map(int,input().split())
l1=[]
l2=[]
l3=[]
l4=[]
for i in range(n):
t,a,b=map(int,input().split())
if a==1 and b==1:
l3.append(t)
elif a==1 and b==0:
l1.append(t)
elif a==0 and b==1:
l2.append(t)
else:
l4.append(t)
l1.sort(reverse=True)
l2.sort(reverse=True)
l3.sort()
l4.sort()
ans=0
t=True
if len(l1)+len(l3)<k or len(l2) +len(l3)<k:
print(-1)
else:
if k>=len(l3):
if len(l3):
ans=sum(l3)
else:
ans=0
t=False
ln=len(l3)
else:
ans=sum(l3[:k])
l3=l3[:k]
ln=k
if t==True:
if min(len(l2),len(l1))>0:
while l1[-1]+l2[-1]<=l3[-1]:
ans-=l3[-1]
ans+=l1[-1]+l2[-1]
l1.pop()
l2.pop()
l3.pop()
if len(l3)==0 or len(l1)==0 or len(l2)==0:
break
print(ans)
else:
for j in range(k-ln):
ans+=l1[-1]+l2[-1]
l1.pop()
l2.pop()
if min(len(l2),len(l1),len(l3))>0:
while l1[-1]+l2[-1]<=l3[-1]:
ans-=l3[-1]
ans+=l1[-1]+l2[-1]
l1.pop()
l2.pop()
l3.pop()
if len(l3)==0 or len(l1)==0 or len(l2)==0:
break
print(ans)
| 11 | PYTHON3 |
l1 = input().split(' ')
n = int(l1[0])
k = int(l1[1])
alike = 0
blike = 0
total = 0
tboth = []
ta = []
tb = []
for i in range(n):
b = input().split(' ')
time = int(b[0])
alice = int(b[1])
bob = int(b[2])
if alice:
alike += 1
if bob:
blike += 1
if alice and bob:
tboth.append(time)
if alice and not bob:
ta.append(time)
if not alice and bob:
tb.append(time)
if alike<k or blike<k:
print (-1)
else:
import heapq
heapq.heapify(tboth)
heapq.heapify(ta)
heapq.heapify(tb)
alike = blike = k
while alike > 0 or blike > 0:
a = b = o = False
if tboth:
mo = heapq.heappop(tboth)
o = True
if ta:
ma = heapq.heappop(ta)
a = True
if tb:
mb = heapq.heappop(tb)
b = True
if a and b and o:
mi = min(ma+mb,mo)
total += mi
if mi == mo:
heapq.heappush(ta,ma)
heapq.heappush(tb,mb)
else:
heapq.heappush(tboth,mo)
alike -=1
blike -=1
elif a and b:
total += (ma+mb)
alike -=1
blike -=1
elif o:
total += mo
alike -=1
blike -=1
elif a:
total += ma
alike -= 1
elif b:
total += mb
blike -= 1
print (total)
| 11 | PYTHON3 |
n,k = map(int,input().split())
x= []
y= []
z = []
for _ in range(n):
t,a,b = map(int,input().split())
if a==1 and b==1:
x.append(t)
elif a==1 and b==0:
y.append(t)
elif a==0 and b==1:
z.append(t)
if len(x)>=k or (k - len(x)<=len(y) and k - len(x)<= len(z)):
x.sort()
y.sort()
z.sort()
i = 0
j = 0
ans = 0
while i +j<k:
if i<len(x) and j<len(y) and j<len(z):
if x[i]<y[j]+z[j]:
ans = ans+x[i]
i =i+1
else:
ans = ans+y[j]+z[j]
j=j+1
elif i<len(x):
ans = ans+x[i]
i = i+1
elif j<len(y) and j<len(z):
ans = ans+y[j]+z[j]
j = j+1
print(ans)
else:
print('-1')
| 11 | PYTHON3 |
def solve():
n, k = map(int,input().split())
a1 = []
b1 = []
ab1 = []
for i in range(n):
t,a,b = map(int,input().split())
if a == 1 and b == 1:
ab1.append(t)
elif a == 1:
a1.append(t)
elif b == 1:
b1.append(t)
a1.sort()
b1.sort()
for i in range(min(len(a1),len(b1))):
ab1.append(a1[i]+b1[i])
ab1.sort()
p = 0
qq = len(ab1)
if qq < k:
print(-1)
else:
ans = 0
for i in range(k): ans += ab1[i]
print(ans)
for i in range(1):
solve() | 11 | PYTHON3 |
#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 << " ";
}
}
| 11 | CPP |
#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;
}
| 11 | CPP |
import sys
from collections import defaultdict
input = lambda:sys.stdin.readline().strip()
n,k = map(int,input().split())
a = []
b = []
c = []
for i in range(n):
ti,ai,bi = map(int,input().split())
if ai==0 and bi==1:
a.append(ti)
elif ai==1 and bi==0:
b.append(ti)
elif ai==1 and bi==1:
c.append(ti)
a.sort()
b.sort()
c.sort()
for i in range(1,len(a)):
a[i]+=a[i-1]
for i in range(1,len(b)):
b[i]+=b[i-1]
for i in range(1,len(c)):
c[i]+=c[i-1]
c = [0]+c
# print(a,b,c)
ans = float('inf')
for i in range(len(c)):
rem = k-i
if i==k:
ans = min(ans,c[i])
if rem-1>=0 and rem<=min(len(a),len(b)):
ans = min(ans,c[i]+a[rem-1]+b[rem-1])
if ans==float('inf'):
print(-1)
else:
print(ans)
| 11 | PYTHON3 |
#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();
}
}
| 11 | CPP |
n,k=map(int,input().split())
alice=[]
bob=[]
both =[]
for i in range(n):
t,a,b = map(int,input().split())
if (a==1 and b==1):
both.append(t)
elif (a==1):
alice.append(t)
elif (b==1):
bob.append(t)
alice.sort()
bob.sort()
l = min(len(alice),len(bob))
for i in range(l):
both.append(alice[i]+bob[i])
if (len(both)< k):
print(-1)
else:
both.sort()
sumi=0
for i in range(k):
sumi=sumi+both[i]
print(sumi)
| 11 | PYTHON3 |
import sys
import random
from math import *
def input():
return sys.stdin.readline().strip()
def iinput():
return int(input())
def finput():
return float(input())
def tinput():
return input().split()
def linput():
return list(input())
def rinput():
return map(int, tinput())
def fiinput():
return map(float, tinput())
def rlinput():
return list(map(int, input().split()))
def trinput():
return tuple(rinput())
def srlinput():
return sorted(list(map(int, input().split())))
def NOYES(fl):
if fl:
print("NO")
else:
print("YES")
def YESNO(fl):
if fl:
print("YES")
else:
print("NO")
def main():
#n = iinput()
#k = iinput()
#m = iinput()
#n = int(sys.stdin.readline().strip())
n, k = rinput()
#n, m = rinput()
#m, k = rinput()
#n, k, m = rinput()
#n, m, k = rinput()
#k, n, m = rinput()
#k, m, n = rinput()
#m, k, n = rinput()
#m, n, k = rinput()
#q = srlinput()
#q = linput()
q = []
for i in range(n):
q.append(rlinput())
q.sort()
w,e,r, fak,pr,pe,pw = [], [], [], [], [0],[0],[0]
res1, res2 = 0, 0
for i in range(n):
res1, res2 = res1 + q[i][1], res2 + q[i][2]
if q[i][1] and q[i][2]:
w.append(q[i][0])
pw.append(w[-1] + pw[-1])
elif q[i][1]:
e.append(q[i][0])
pe.append(e[-1] + pe[-1])
elif q[i][2]:
r.append(q[i][0])
pr.append(r[-1] + pr[-1])
else:
fak.append(q[i])
if min(res1, res2) < k:
print(-1)
else:
res = 5e9
for i in range(1 + min(k, len(w))):
if k - i <= min(len(r), len(e)):
res = min(res, pw[i] + pr[k - i] + pe[k - i])
print(res)
for inytd in range(1):
main() | 11 | PYTHON3 |
n, k = [int(i) for i in input().split()]
a1 = []
a2 = []
a3 = []
A1 = False
A2 = False
A3 = False
amount = 0
summ = 0
for i in range(n):
t, a, b = [int(z) for z in input().split()]
if a == 1 and b == 1:
a1.append(t)
A1 = True
elif a == 1:
a2.append(t)
A2 = True
elif b == 1:
a3.append(t)
A3 = True
a1 = sorted(a1)
a2 = sorted(a2)
a3 = sorted(a3)
if len(a1) + min(len(a2), len(a3)) < k:
print(-1)
else:
x, y = 0, 0
len1 = len(a1)
len2 = len(a2)
len3 = len(a3)
while amount < k:
if x == len2 or x == len3:
summ += sum(a1[y:y+k-amount])
break
if y == len1:
summ += sum(a2[x:x+k-amount] + a3[x:x+k-amount])
break
if a3[x] + a2[x] < a1[y]:
summ += a3[x] + a2[x]
x += 1
amount += 1
else:
summ += a1[y]
y += 1
amount += 1
print(summ) | 11 | PYTHON3 |
#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();
}
| 11 | CPP |
#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;
}
| 11 | CPP |
line = input()
n, m, k = [int(i) for i in line.split(' ')]
books, allL, aliceL, bobL, other =list(range(1, n + 1)), [], [], [], []
ts = [[] for _ in range(n + 1)]
for i in range(n):
line = input()
t, a, b = [int(j) for j in line.split(' ')]
ts[i + 1] = [t, a, b]
if a == 1 and b == 1:
allL.append(i + 1)
elif a == 1:
aliceL.append(i + 1)
elif b == 1:
bobL.append(i + 1)
else:
other.append(i + 1)
if len(allL) + min(len(aliceL), len(bobL)) < k or (len(allL) < k and 2 * (k - len(allL)) > m - len(allL)) :
print(-1)
exit()
books.sort(key=lambda x: (ts[x][0], -ts[x][2]*ts[x][1]))
allL.sort(key=lambda x: (ts[x][0], -ts[x][2]*ts[x][1]))
aliceL.sort(key=lambda x: (ts[x][0], -ts[x][2]*ts[x][1]))
bobL.sort(key=lambda x: (ts[x][0], -ts[x][2]*ts[x][1]))
other.sort(key=lambda x: (ts[x][0], -ts[x][2]*ts[x][1]))
x = max(2 * k - m, 0, k - min(len(aliceL), len(bobL)), m - len(aliceL) - len(bobL) - len(other))
cura, curb, curo, cur = max(0, k - x), max(0, k - x), 0, sum(ts[i][0] for i in allL[:x])
cur += sum(ts[i][0] for i in aliceL[:cura]) + sum(ts[i][0] for i in bobL[:curb])
while cura + x + curb + curo < m:
an = ts[aliceL[cura]][0] if cura < len(aliceL) else 9999999999
bn = ts[bobL[curb]][0] if curb < len(bobL) else 9999999999
on = ts[other[curo]][0] if curo < len(other) else 9999999999
cur += min(an, bn, on)
if an <= bn and an <= on:
cura += 1
elif bn <= an and bn <= on:
curb += 1
else:
curo += 1
res, a, b, o = cur, cura, curb, curo
for i in range(x + 1, len(allL) + 1): #都喜欢的长度
cur += ts[allL[i - 1]][0]
if cura > 0:
cura -= 1
cur -= ts[aliceL[cura]][0]
if curb > 0:
curb -= 1
cur -= ts[bobL[curb]][0]
if curo > 0:
curo -= 1
cur -= ts[other[curo]][0]
while cura + i + curb + curo < m:
an = ts[aliceL[cura]][0] if cura < len(aliceL) else 9999999999
bn = ts[bobL[curb]][0] if curb < len(bobL) else 9999999999
on = ts[other[curo]][0] if curo < len(other) else 9999999999
cur += min(an, bn, on)
if an <= bn and an <= on:
cura += 1
elif bn <= an and bn <= on:
curb += 1
else:
curo += 1
if res > cur:
res,x, a, b, o = cur,i, cura, curb, curo
else:
break
print(res)
for i in range(x):
print(allL[i], end=' ')
for i in range(a):
print(aliceL[i], end = ' ')
for i in range(b):
print(bobL[i], end = ' ')
for i in range(o):
print(other[i], end = ' ')
| 11 | PYTHON3 |
## *********************************************
## * *
## * | | \ / |- |\ --- |\ | *
## * | | \ / | \ | | | | | \ | *
## * |--| \ / | | |/ | | | \ | *
## * | | / | / | \ | | | \ | *
## * | | / |- | \ --- | \| *
## * *
## *********************************************
n, k = map(int, input().split())
t=list()
a=list()
b=list()
alice=list()
bob=list()
both=list()
for i in range(0, n):
x, y, z = map(int, input().split())
if y and z:
both.append(x)
else:
if y:
alice.append(x)
else:
if z:
bob.append(x)
alice.sort()
bob.sort()
both.sort()
INF = 200000000000
res = INF
if len(alice) > 1:
for i in range(1, len(alice)):
alice[i] += alice[i-1]
if len(bob) > 1:
for i in range(1, len(bob)):
bob[i] += bob[i-1]
if len(both) > 1:
for i in range(1, min(k, len(both))):
both[i] += both[i-1]
if not((len(alice)) * (len(bob))):
if len(both) < k:
res = -1
else:
res = both[k-1]
else:
if not(len(both)):
if len(bob) >= k and len(alice) >= k:
res = bob[k-1] + alice[k-1]
else:
res = -1
else:
for cnt in range(1, len(both)+1):
if cnt > k:
break
i = k - cnt - 1
if i == -1:
res = min(res, both[cnt-1])
break
if i < len(alice) and i < len(bob):
res = min(res, both[cnt-1] + alice[i] + bob[i])
if k <= len(alice) and k <= len(bob):
res = min(res, alice[k-1] + bob[k-1])
if res == INF:
print(-1)
else:
print(int(res))
## 1
## *
## ***
## *****
## \ **000** /
## \ ***0|0*** /
## ****000****
## *************
## ***************
## *****************
## .| |.
| 11 | PYTHON3 |
#!/usr/bin/env pypy3
from sys import stdin, stdout
import heapq
def input():
return stdin.readline().strip()
def ans(both, alice_only, bob_only, neither, M, K):
both_fc = [b[0] for b in both]
neither_fc = [b[0] for b in neither]
alice_only_fc = [a[0] for a in alice_only]
bob_only_fc = [b[0] for b in bob_only]
both_prefix = [0]
for b in both_fc:
both_prefix += [both_prefix[-1] + b]
alice_only_prefix = [0]
for b in alice_only_fc:
alice_only_prefix += [alice_only_prefix[-1] + b]
bob_only_prefix = [0]
for b in bob_only_fc:
bob_only_prefix += [bob_only_prefix[-1] + b]
neither_prefix = [0]
for b in neither_fc:
neither_prefix += [neither_prefix[-1] + b]
p = min(len(both), M)
q = 0
r = 0
s = 0
# maintain K condition
while p + q < K:
if q == len(alice_only): break
q += 1
if p + q < K: return None
while p + r < K:
if r == len(bob_only): break
r += 1
if p + r < K: return None
# maintain M condition
while p+q+r+s < M:
# greedily increment q,r,s
g = dict()
if q < len(alice_only):
g["q"] = alice_only_fc[q]
if r < len(bob_only):
g["r"] = bob_only_fc[r]
if s < len(neither):
g["s"] = neither_fc[s]
if len(g.keys()) == 0: return None
to_increment = min(g, key=g.get)
if to_increment == "q": q += 1
if to_increment == "r": r += 1
if to_increment == "s": s += 1
while p+q+r+s > M:
# greedily decrement q,r,s
g = dict()
if 0 < q and p + q > K:
g["q"] = alice_only_fc[q-1]
if 0 < r and p + r > K:
g["r"] = bob_only_fc[r-1]
if 0 < s:
g["s"] = neither_fc[s-1]
if len(g.keys()) == 0: break
to_decrement = max(g, key=g.get)
if to_decrement == "q": q -= 1
if to_decrement == "r": r -= 1
if to_decrement == "s": s -= 1
if p+q+r+s > M: return None
best_score = both_prefix[p] + alice_only_prefix[q] + bob_only_prefix[r] + neither_prefix[s]
best_pqrs = (p,q,r,s)
# print("starting candidate", best_score, best_pqrs)
while p > 0:
p -= 1
# maintain K condition
while p + q < K:
if q == len(alice_only): break
q += 1
if p + q < K: break
while p + r < K:
if r == len(bob_only): break
r += 1
if p + r < K: break
# maintain M condition
while p+q+r+s < M:
# greedily increment q,r,s
g = dict()
if q < len(alice_only):
g["q"] = alice_only_fc[q]
if r < len(bob_only):
g["r"] = bob_only_fc[r]
if s < len(neither):
g["s"] = neither_fc[s]
if len(g.keys()) == 0: break
to_increment = min(g, key=g.get)
if to_increment == "q": q += 1
if to_increment == "r": r += 1
if to_increment == "s": s += 1
if p+q+r+s < M: break
while p+q+r+s > M:
# greedily decrement q,r,s
g = dict()
if 0 < q and p + q > K:
g["q"] = alice_only_fc[q-1]
if 0 < r and p + r > K:
g["r"] = bob_only_fc[r-1]
if 0 < s:
g["s"] = neither_fc[s-1]
if len(g.keys()) == 0: break
to_decrement = max(g, key=g.get)
if to_decrement == "q": q -= 1
if to_decrement == "r": r -= 1
if to_decrement == "s": s -= 1
if p+q+r+s > M: break
score = both_prefix[p] + alice_only_prefix[q] + bob_only_prefix[r] + neither_prefix[s]
if score < best_score:
best_score = score
best_pqrs = (p,q,r,s)
p,q,r,s = best_pqrs
ret_array = []
for i in range(p): ret_array += [both[i][1]]
for i in range(q): ret_array += [alice_only[i][1]]
for i in range(r): ret_array += [bob_only[i][1]]
for i in range(s): ret_array += [neither[i][1]]
return best_score, ret_array
N, M, K = input().split(' ')
N = int(N)
K = int(K)
M = int(M)
alice_only = []
bob_only = []
both = []
neither = []
inorder = []
for i in range(1,N+1):
t, a, b = input().split(' ')
t = int(t)
a = int(a)
b = int(b)
if a == 0 and b == 0: neither += [(t, i)]
if a == 1 and b == 1: both += [(t, i)]
if a == 1 and b == 0: alice_only += [(t, i)]
if a == 0 and b == 1: bob_only += [(t, i)]
inorder += [t]
alice_only = sorted(alice_only)
bob_only = sorted(bob_only)
both = sorted(both)
neither = sorted(neither)
ret = ans(both, alice_only, bob_only, neither, M, K)
if ret is None:
print(-1)
else:
a, b = ret
print(a)
print(' '.join(map(str, b)))
check = 0
for idx in b:
check += inorder[idx-1]
assert(a == check) | 11 | PYTHON3 |
from copy import copy, deepcopy
def read_int():
return int(input())
def read_arr():
return [int(x) for x in input().split(' ')]
def read_mx(n):
return [[int(num) for num in input().split(' ')] for _ in range(0, n)]
def work(p_case):
n, k = read_arr()
mx = read_mx(n)
# split
b_only = []
a_only = []
both = []
for row in mx:
cost = row[0]
if row[1] and not row[2]:
b_only.append(cost)
elif row[2] and not row[1]:
a_only.append(cost)
elif row[1] and row[2]:
both.append(cost)
b_only.sort()
a_only.sort()
# merge
ia, ib = 0, 0
while ia < len(a_only) and ib < len(b_only):
both.append(a_only[ia]+b_only[ib])
ia += 1
ib += 1
both.sort()
# print(both)
sm, cnt = 0, 0
while cnt < k and cnt < len(both):
sm += both[cnt]
cnt += 1
if cnt == k:
print(sm)
else:
print(-1)
if __name__ == "__main__":
work(0)
# t = read_int() # cases
# for case in range(0, t):
# work(case+1)
| 11 | PYTHON3 |
import sys
input = sys.stdin.readline
INF = 10 ** 18
n, m, k = map(int, input().split())
B = [tuple(map(int, input().split())) for _ in range(n)]
GB = []
AB = []
BB = []
RB = []
for i, (t, a, b) in enumerate(B):
if a and b:
GB.append((t, i))
elif a:
AB.append((t, i))
elif b:
BB.append((t, i))
else:
RB.append((t, i))
GB.sort()
AB.sort()
BB.sort()
# TODO: already sorted
CB = sorted((t1+t2, i1, i2) for (t1, i1), (t2, i2) in zip(AB, BB))
N = 1
while N <= 10 ** 4: N *= 2
T = [(0, 0)] * (2 * N)
def comb(a, b):
return (a[0] + b[0], a[1] + b[1])
def add_book(t, inc=1):
i = t + N
T[i] = comb(T[i], (t*inc, inc))
while i > 1:
i //= 2
T[i] = comb(T[i*2], T[i*2+1])
def query(x):
assert x >= 0
s = 0
i = 1
while x:
ts, tc = T[i]
if tc < x: return INF
elif tc == x:
s += ts
break
if i >= N:
s += ts // tc * x
break
i *= 2
if T[i][1] < x:
s += T[i][0]
x -= T[i][1]
i += 1
return s
for t, _ in RB: add_book(t)
for t, _ in AB: add_book(t)
for t, _ in BB: add_book(t)
gb_i = 0
gb_t = 0
while gb_i < min(len(GB), m):
gb_t += GB[gb_i][0]
gb_i += 1
for t, _ in GB[gb_i:]: add_book(t)
cb_i = 0
cb_t = 0
while gb_i + cb_i < k and gb_i + 2 * (cb_i + 1) <= m and cb_i < len(CB):
cb_t += CB[cb_i][0]
add_book(AB[cb_i][0], -1)
add_book(BB[cb_i][0], -1)
cb_i += 1
if gb_i + cb_i < k:
print(-1)
sys.exit()
best = (INF, -1, -1)
while True:
best = min(best, (gb_t + cb_t + query(m - 2 * cb_i - gb_i), gb_i, cb_i))
if not gb_i: break
gb_i -= 1
gb_t -= GB[gb_i][0]
add_book(GB[gb_i][0])
if gb_i + cb_i < k:
if cb_i == len(CB): break
cb_t += CB[cb_i][0]
add_book(AB[cb_i][0], -1)
add_book(BB[cb_i][0], -1)
cb_i += 1
if gb_i + 2 * cb_i > m: break
"""
if not gb_i: break
gb_i -= 1
gb_t -= GB[gb_i][0]
add_book(GB[gb_i][0])
"""
bs, bi, bj = best
assert bs != INF
ans = []
comps = 0
for t, i in GB[:bi]:
ans.append(i+1)
comps += t
for t, i1, i2 in CB[:bj]:
ans.append(i1+1)
ans.append(i2+1)
comps += t
if bi + 2 * bj < m:
rem = GB[bi:] + AB[bj:] + BB[bj:] + RB
rem.sort()
for t, i in rem[:m - bi - 2 * bj]:
ans.append(i+1)
comps += t
assert comps == bs
print(bs)
print(*ans)
| 11 | PYTHON3 |
#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;
}
| 11 | CPP |
def main():
n, k = map(int, input().split())
alice_counter = k
bob_counter = k
total_time = 0
both = []
alice = []
bob = []
for _ in range(n):
t, a, b = map(int, input().split())
if a and b:
both.append(t)
elif a:
alice.append(t)
elif b:
bob.append(t)
both = sorted(both)
alice = sorted(alice)
bob = sorted(bob)
pointer = [0] * 3
while True:
if bob_counter == 0 and alice_counter == 0:
return total_time
if pointer[1] >= len(alice) or pointer[2] >= len(bob):
while bob_counter > 0 or alice_counter > 0:
if pointer[0] >= len(both):
return -1
total_time += both[pointer[0]]
pointer[0] += 1
bob_counter -= 1
alice_counter -= 1
return total_time
elif pointer[0] >= len(both):
while bob_counter > 0 or alice_counter > 0:
if pointer[1] >= len(alice) or pointer[2] >= len(bob):
return -1
total_time += alice[pointer[1]] + bob[pointer[2]]
pointer[1] += 1
pointer[2] += 1
bob_counter -= 1
alice_counter -= 1
return total_time
else:
if both[pointer[0]] > alice[pointer[1]] + bob[pointer[2]]:
total_time += alice[pointer[1]] + bob[pointer[2]]
pointer[1] += 1
pointer[2] += 1
else:
total_time += both[pointer[0]]
pointer[0] += 1
bob_counter -= 1
alice_counter -= 1
print(main())
| 11 | PYTHON3 |
import sys
input = lambda :sys.stdin.readline().rstrip()
from heapq import heapify,heappop,heappush
n,k = map(int,input().split())
a,b,c=[],[],[]
for _ in range(n):
t,e,d=map(int,input().split())
if e and d:
a.append(t)
elif e:
b.append(t)
elif d:
c.append(t)
fl=False
if len(b)+len(a)>=k and len(c)+len(a)>=k:
fl=True
if not fl:
print(-1)
sys.exit(0)
heapify(a)
b.sort()
c.sort()
ans=0
for i in range(min(len(b),len(c))):
heappush(a,b[i]+c[i])
while k:
ans+=heappop(a)
k-=1
print(ans) | 11 | PYTHON3 |
#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;
}
| 11 | CPP |
#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;
}
| 11 | CPP |
#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;
}
| 11 | CPP |
l=input().split()
n=int(l[0])
k=int(l[1])
l=[]
arrboth=[]
arralice=[]
arrbob=[]
for i in range(n):
lo=input().split()
x=int(lo[0])
u=int(lo[1])
v=int(lo[2])
if(u==1 and v==1):
arrboth.append(x)
elif(u==1):
arralice.append(x)
elif(v==1):
arrbob.append(x)
arrbob.sort()
arralice.sort()
arrboth.sort()
pref1=[0 for i in range(len(arrboth)+1)]
pref2=[0 for i in range(len(arralice)+1)]
pref3=[0 for i in range(len(arrbob)+1)]
sumi=0
for i in range(1,len(arrboth)+1):
sumi+=arrboth[i-1]
pref1[i]=sumi
sumi=0
for i in range(1,len(arrbob)+1):
sumi+=arrbob[i-1]
pref3[i]=sumi
sumi=0
for i in range(1,len(arralice)+1):
sumi+=arralice[i-1]
pref2[i]=sumi
z=[]
for i in range(min(len(arrboth),k)+1):
if(k-i>len(arrbob) or k-i>len(arralice)):
continue
z.append(pref1[i]+pref2[k-i]+pref3[k-i])
if(z==[]):
print(-1)
else:
print(min(z))
| 11 | PYTHON3 |
#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;
}
| 11 | CPP |
#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;
}
| 11 | CPP |
import sys
import math
import heapq
import collections
from collections import OrderedDict
def inputnum():
return(int(input()))
def inputnums():
return(map(int,input().split()))
def inputlist():
return(list(map(int,input().split())))
def inputstring():
return([x for x in input()])
def inputmatrixchar(rows):
arr2d = [[j for j in input().strip()] for i in range(rows)]
return arr2d
def inputmatrixint(rows):
arr2d = []
for _ in range(rows):
arr2d.append([int(i) for i in input().split()])
return arr2d
n, k = inputnums()
mins = [ [ [] for i in range(2) ] for j in range(2) ]
for i in range(n):
t, a, b = inputnums()
mins[a][b].append(t)
mins[1][0].sort()
mins[0][1].sort()
x = len(mins[1][0])
y = len(mins[0][1])
for i in range(min(x, y)):
mins[1][1].append(mins[1][0][i] + mins[0][1][i])
mins[1][1].sort()
ans = 0
if len(mins[1][1]) < k:
ans = -1
if ans != -1:
for i in range(k):
ans += mins[1][1][i]
print (ans) | 11 | PYTHON3 |
from collections import defaultdict
n,k=list(map(int,input().split()))
d=defaultdict(list)
for i in range(n):
t,a,b=list(map(int,input().split()))
x=int(str(a)+str(b),2)
d[x].append(t)
if len(d[2])+len(d[3])<k or len(d[1])+len(d[3])<k:
print(-1)
else:
d[1].sort()
d[2].sort()
d[3].sort()
i,j,l=0,0,0
c=0
s=0
while c<k:
if l<len(d[3]):
if i<len(d[1]):
if(j<len(d[2])):
if d[1][i]+d[2][j]<d[3][l]:
s+=d[1][i]+d[2][j]
i+=1
j+=1
else:
s+=d[3][l]
l+=1
else:
s+=d[3][l]
l+=1
else:
s+=d[3][l]
l+=1
else:
s+=d[1][i]+d[2][j]
i+=1
j+=1
c+=1
print(s)
| 11 | PYTHON3 |
n,k=map(int,input().split())
v1,v2,v12=[],[],[]
for _ in range(n):
t,l1,l2=map(int,input().split())
if l1==1 and l2==1:
v12.append(t)
elif l1==1:
v1.append(t)
elif l2==1:
v2.append(t)
v1.sort()
v2.sort()
v12.sort()
x,y,z=0,0,0
ans=0
sb=k-min(len(v1),len(v2))
sb = sb if sb>0 else 0
k-=sb
if sb>len(v12):
print(-1)
else:
for z in range(sb):
ans+=v12[z]
z=sb
while(k>0 and z< len(v12)):
if v12[z]<= v1[x]+v2[y]:
ans+=v12[z]
z+=1
else:
ans+=v1[x]+v2[y]
x+=1
y+=1
k-=1
if k<=(len(v1)-x) and k<= (len(v2)-y):
while k>0:
ans+=v1[x]+v2[y]
x+=1
y+=1
k-=1
print(ans)
else:
print(-1)
| 11 | PYTHON3 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.