solution
stringlengths 11
983k
| difficulty
int64 0
21
| language
stringclasses 2
values |
|---|---|---|
#include <bits/stdc++.h>
const int factor_N = 10000005;
using namespace std;
int read() {
char c = getchar();
int x = 0, f = 1;
for (; !isdigit(c); c = getchar())
if (c == '-') f = -1;
for (; isdigit(c); c = getchar()) x = x * 10 + c - 48;
return x * f;
}
struct Node {
int t, a, b;
};
const int N = 2e5 + 5;
int n, k;
int a[N], b[N], c[N];
int cnta, cntb, cntc, t, aa, bb;
int ans;
int main() {
n = read();
k = read();
for (int i = (1); i <= (n); ++i) {
t = read();
aa = read();
bb = read();
if (aa == 0 && bb != 0)
a[++cnta] = t;
else if (aa != 0 && bb == 0)
b[++cntb] = t;
else if (aa == 1 && bb == 1)
c[++cntc] = t;
}
if (cnta + cntc < k || cntb + cntc < k) {
cout << -1 << endl;
return 0;
}
sort(a + 1, a + 1 + cnta);
sort(b + 1, b + 1 + cntb);
sort(c + 1, c + 1 + cntc);
int t = min(cnta, cntb);
for (int i = 1; i <= k && i <= t; ++i) ans += a[i];
for (int i = 1; i <= k && i <= t; ++i) ans += b[i];
if (t < k) {
for (int i = 1; i <= k - t; ++i) ans += c[i];
int tt = k - t + 1;
while (c[tt] < a[t] + b[t] && tt <= cntc)
ans -= a[t], ans -= b[t], ans += c[tt], tt++, t--;
cout << ans << endl;
return 0;
}
int tt = 1;
while (c[tt] < a[k] + b[k] && tt <= cntc) {
ans -= a[k];
ans -= b[k];
ans += c[tt];
tt++;
k--;
}
cout << ans << endl;
return 0;
}
| 11 | CPP |
import time,math,bisect,sys
from sys import stdin,stdout
from collections import deque
from fractions import Fraction
from collections import Counter
from collections import OrderedDict
pi=3.14159265358979323846264338327950
def II(): # to take integer input
return int(stdin.readline())
def IO(): # to take string input
return stdin.readline()
def IP(): # to take tuple as input
return map(int,stdin.readline().split())
def L(): # to take list as input
return list(map(int,stdin.readline().split()))
def P(x): # to print integer,list,string etc..
return stdout.write(str(x))
def PI(x,y): # to print tuple separatedly
return stdout.write(str(x)+" "+str(y)+"\n")
def lcm(a,b): # to calculate lcm
return (a*b)//gcd(a,b)
def gcd(a,b): # to calculate gcd
if a==0:
return b
elif b==0:
return a
if a>b:
return gcd(a%b,b)
else:
return gcd(a,b%a)
def sieve():
li=[True]*1000001
li[0],li[1]=False,False
for i in range(2,len(li),1):
if li[i]==True:
for j in range(i*i,len(li),i):
li[j]=False
prime=[]
for i in range(1000001):
if li[i]==True:
prime.append(i)
return prime
def setBit(n):
count=0
while n!=0:
n=n&(n-1)
count+=1
return count
def readTree(v,e): # to read tree
adj=[set() for i in range(v+1)]
for i in range(e):
u1,u2,w=IP()
adj[u1].add((u2,w))
adj[u2].add((u1,w))
return adj
def dfshelper(adj,i,visited):
nodes=1
visited[i]=True
for ele in adj[i]:
if visited[ele]==False:
nd=dfshelper(adj,ele,visited)
nodes+=nd
return nodes
def dfs(adj,v): # a schema of bfs
visited=[False]*(v+1)
li=[]
for i in range(v):
if visited[i]==False:
nodes=dfshelper(adj,i,visited)
li.append(nodes)
return li
#####################################################################################
mx=10**9+7
def solve():
n,k=IP()
a,b,ab=[],[],[]
at,bt=0,0
for i in range(n):
t=L()
if t[-2]==1 and t[-1]==1:
ab.append(t[0])
elif t[-2]==1 and t[-1]==0:
a.append(t[0])
elif t[-2]==0 and t[-1]==1:
b.append(t[0])
at+=t[0]
bt+=t[0]
at,bt=0,0
t=0
a.sort(reverse=True)
b.sort(reverse=True)
ab.sort(reverse=True)
while (at<k or bt<k) and (ab or (a and b)):
if ab and a and b:
x,y=ab[-1],a[-1]+b[-1]
if x<=y:
t+=ab.pop()
else:
t=t+a.pop()+b.pop()
else:
if ab:
t+=ab.pop()
else:
t=t+a.pop()+b.pop()
at+=1
bt+=1
if at==k and bt==k:
print(t)
return
else:
print(-1)
return
solve()
#######
#
#
####### # # # #### # # #
# # # # # # # # # # #
# #### # # #### #### # #
###### # # #### # # # # # | 11 | PYTHON3 |
def cta(t,p,r):
global ana,iva,an
ana[iva[t][p][1]]^=True
an+=iva[t][p][0]*r
n,k=[int(x) for x in input().split()]
iva=[[] for _ in range(4)]
js=[() for _ in range(n)]
for i in range(n):
v,o,u=[int(x) for x in input().split()]
q=(o<<1)|u
iva[q].append((v,i))
js[i]=(v,q)
for e in iva :
e.sort()
ct,a,r,ps,an = 0,0,0,min(len(iva[1]),len(iva[2])),0
ana=[False]*n
for _ in range(k):
if(a<ps and r<len(iva[3])):
if(iva[1][a][0]+iva[2][a][0]<iva[3][r][0]) :
cta(1,a,1)
cta(2,a,1)
ct+=2
a+=1
else:
cta(3,r,1)
ct+=1
r+=1
elif (a<ps):
cta(1,a,1)
cta(2,a,1)
ct+=2
a+=1
elif(r<len(iva[3])):
cta(3,r,1)
ct+=1
r+=1
else:
print(-1)
exit(0)
print(an)
| 11 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
struct node {
int a, b, t;
int index;
node() {}
node(int _a, int _b, int _t, int _index) {
a = _a;
b = _b;
t = _t;
index = _index;
}
bool operator<(const struct node &nd) const { return t < nd.t; }
bool operator>(const struct node &nd) const { return t > nd.t; }
};
vector<node> all, alice, bob, none;
priority_queue<node> taken;
int all_size, alice_size, bob_size, none_size;
priority_queue<node, vector<node>, greater<node> > freee;
int minAllCount(int n, int m, int k) {
for (int i = 0; i <= all_size; i++) {
if (alice_size + i >= k && bob_size + i >= k &&
i + max(0, k - i) + max(0, k - i) <= m &&
alice_size + bob_size + none_size + i >= m) {
return i;
}
}
return n + 1;
}
int maxAllCount(int n, int m, int k) {
for (int i = all_size; i >= 0; i--) {
if (alice_size + i >= k && bob_size + i >= k &&
i + max(0, k - i) + max(0, k - i) <= m &&
alice_size + bob_size + none_size + i >= m) {
return i;
}
}
return -1;
}
bool isPossible(int n, int m, int k) {
if (all_size >= k) {
return true;
}
int minFromAlice = k - all_size;
int minFromBob = k - all_size;
if (minFromAlice > alice_size || minFromBob > bob_size) {
return false;
} else if (all_size + minFromAlice + minFromBob > m) {
return false;
}
return true;
}
vector<int> finalTakenBooks;
void updateResult(int cntAll, int k, int m) {
for (int i = 0; i < cntAll; i++) {
finalTakenBooks.push_back(all[i].index);
}
for (int i = 0; i < k - cntAll; i++) {
if (i < alice_size) finalTakenBooks.push_back(alice[i].index);
if (i < bob_size) finalTakenBooks.push_back(bob[i].index);
}
while (!taken.empty()) {
node nd = taken.top();
taken.pop();
finalTakenBooks.push_back(nd.index);
}
}
pair<int, int> getOptimalResult(int n, int m, int k, int optimal = -1) {
int l = minAllCount(n, m, k);
int h = maxAllCount(n, m, k);
int sm = 0;
for (int i = 0; i < l; i++) {
sm += all[i].t;
}
assert(k - l <= alice_size && k - l <= bob_size);
for (int i = 0; i < k - l; i++) {
sm += alice[i].t;
sm += bob[i].t;
}
while (!freee.empty()) freee.pop();
while (!taken.empty()) taken.pop();
for (int i = max(0, k - l); i < alice_size; i++) {
freee.push(alice[i]);
}
for (int i = max(0, k - l); i < bob_size; i++) {
freee.push(bob[i]);
}
for (int i = 0; i < none_size; i++) {
freee.push(none[i]);
}
int optimalcnt = -1, optimalTime = INT_MAX;
for (int cnt = l; cnt <= h; cnt++) {
int otherNeeded = (m - cnt - 2 * max(0, k - cnt));
while (otherNeeded > (int)taken.size()) {
node nd = freee.top();
freee.pop();
sm += nd.t;
taken.push(nd);
}
while (otherNeeded >= 0 && otherNeeded < (int)taken.size()) {
node nd = taken.top();
taken.pop();
sm -= nd.t;
freee.push(nd);
}
while (!taken.empty() && !freee.empty() && freee.top().t < taken.top().t) {
node freeTop = freee.top();
freee.pop();
node takenTop = taken.top();
taken.pop();
freee.push(takenTop);
taken.push(freeTop);
sm -= takenTop.t;
sm += freeTop.t;
}
if (sm < optimalTime && otherNeeded == taken.size()) {
optimalTime = sm;
optimalcnt = cnt;
}
if (cnt == optimal) {
updateResult(cnt, k, m);
return {optimalTime, cnt};
}
if (cnt < h) {
sm += all[cnt].t;
}
if (k - cnt > 0) {
sm -= alice[k - cnt - 1].t;
sm -= bob[k - cnt - 1].t;
freee.push(alice[k - cnt - 1]);
freee.push(bob[k - cnt - 1]);
}
}
return {optimalTime, optimalcnt};
}
void solve(int n, int m, int k) {
all_size = all.size();
alice_size = alice.size();
bob_size = bob.size();
none_size = none.size();
assert(all_size + alice_size + bob_size + none_size == n);
if (!isPossible(n, m, k) || minAllCount(n, m, k) > maxAllCount(n, m, k)) {
puts("-1");
return;
}
sort(all.begin(), all.end());
sort(alice.begin(), alice.end());
sort(bob.begin(), bob.end());
sort(none.begin(), none.end());
pair<int, int> result = getOptimalResult(n, m, k);
result = getOptimalResult(n, m, k, result.second);
printf("%d\n", result.first);
for (int i = 0; i < finalTakenBooks.size(); i++) {
if (i) printf(" ");
printf("%d", finalTakenBooks[i]);
}
puts("");
}
int main() {
int n, m, k, i;
scanf("%d %d %d", &n, &m, &k);
node nd;
int a, b, t;
for (i = 0; i < n; i++) {
scanf("%d %d %d", &t, &a, &b);
nd = node(a, b, t, i + 1);
if (a && b) {
all.push_back(nd);
} else if (a) {
alice.push_back(nd);
} else if (b) {
bob.push_back(nd);
} else {
none.push_back(nd);
}
}
solve(n, m, k);
return 0;
}
| 11 | CPP |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n, k;
cin >> n >> k;
vector<long long int> a, b, c;
for (int i = 0; i < n; i++) {
int t, x, y;
cin >> t >> x >> y;
if (x && y)
c.push_back(t);
else if (x && !y)
a.push_back(t);
else if (!x && y)
b.push_back(t);
}
sort(a.begin(), a.end(), greater<long long>());
sort(b.begin(), b.end(), greater<long long>());
long long ans = 0;
int an = a.size(), bn = b.size(), cn = c.size();
if (an + cn >= k && bn + cn >= k) {
while ((int)a.size() > 0 && (int)b.size() > 0) {
c.push_back(a.back() + b.back());
a.pop_back();
b.pop_back();
}
sort(c.begin(), c.end());
for (int i = 0; i < k; i++) {
ans += c[i];
}
} else
ans = -1;
cout << ans << endl;
return 0;
}
| 11 | CPP |
n, k = map(int, input().split())
times = [[], [], [], []]
for i in range(n):
t, a, b = map(int, input().split())
times[a * 2 + b].append(t)
for i in range(1, 4):
times[i].sort()
sums = []
for i in range(len(times)):
sums.append([])
for j in range(len(times[i])):
if j == 0:
sums[i].append(times[i][0])
else:
sums[i].append(times[i][j] + sums[i][j - 1])
sums[1].insert(0, 0)
sums[2].insert(0, 0)
sums[3].insert(0, 0)
ans = 10 ** 10
for i in range(min(k + 1, len(sums[-1]))):
if k - i < len(sums[1]) and k - i < len(sums[2]):
ans = min(ans, sums[3][i] + sums[1][k - i] + sums[2][k - i])
if ans == 10 ** 10:
ans = -1
print(ans)
| 11 | PYTHON3 |
n,k=list(map(int,input().split()))
l,l1,l2=[],[],[]
for _ in range(n):
x,y,z=list(map(int,input().split()))
if y==1 and z==1:
l.append(x)
elif y==1:
l1.append([x,y,z])
elif z==1:
l2.append([x,y,z])
l1.sort()
l2.sort()
for i in range(min(k,len(l1),len(l2))):
a=l1[i][0]
b=l2[i][0]
l.append(a+b)
l.sort()
if len(l)>=k:
print(sum(l[:k]))
else:
print(-1)
| 11 | PYTHON3 |
n,k=map(int,input().split(" "))
both=[]
bob=[]
alice=[]
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)
if len(both)!=0:
both.sort()
if len(alice)!=0:
alice.sort()
if len(bob)!=0:
bob.sort()
if len(both)+len(alice)<k or len(both)+len(bob)<k:
print(-1)
else:
#print(alice,bob,both)
i=0
j=0
ans=0
q=0
w=0
talice=0
tbob=0
while i<len(alice) and j<len(bob) and q<k and w<len(both):
if alice[i]+bob[j]<=both[w]:
ans+=alice[i]+bob[j]
talice+=1
tbob+=1
i+=1
j+=1
else:
ans+=both[w]
talice+=1
tbob+=1
w+=1
q+=1
z=talice
if i==len(alice) or j==len(bob):
#print(w+k-z+1)
ans+=sum(both[w:w+k-z])
elif w==len(both):
ans+=sum(alice[i:i+k-z])
ans+=sum(bob[j:j+k-z])
print(ans)
| 11 | PYTHON3 |
from sys import maxsize
n, k = map(int, input().split())
l = [[0], [0], [0], [0]]
x = []
ans = maxsize
for i in range(n):
x.append(list(map(int, input().split())))
x.sort()
for p in x:
temp = l[p[1]*2 + p[2]][-1]
l[p[1]*2 + p[2]].append(temp + p[0])
for i in range(min(k + 1, len(l[3]))):
if k - i < len(l[1]) and k - i < len(l[2]):
ans = min(ans, l[3][i] + l[1][k - i] + l[2][k - i])
if ans == maxsize:
print(-1)
else:
print(ans)
| 11 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
void quick_sort(int a[], int left, int right) {
int l = left, r = right, m = a[rand() % (r - l) + l];
while (l < r) {
while (a[l] < m) l++;
while (a[r] > m) r--;
if (l <= r) {
int t = a[l];
a[l] = a[r];
a[r] = t;
l++;
r--;
}
}
if (left < r) quick_sort(a, left, r);
if (right > l) quick_sort(a, l, right);
}
int main() {
int n, k, a[200000], size_a = 0, b[200000], size_b = 0, c[200000], size_c = 0,
min = 0, cnt_a = 0, cnt_b = 0;
cin >> n >> k;
while (n--) {
int t[3];
cin >> t[0] >> t[1] >> t[2];
if (t[1] + t[2] == 2)
c[size_c++] = t[0];
else if (t[1])
a[size_a++] = t[0];
else if (t[2])
b[size_b++] = t[0];
}
if (size_c > 1) quick_sort(c, 0, size_c - 1);
if (size_a > 1) quick_sort(a, 0, size_a - 1);
if (size_b > 1) quick_sort(b, 0, size_b - 1);
int i = 0, j = 0, l = 0;
for (;
((i < size_a && j < size_b) || l < size_c) && cnt_a < k && cnt_b < k;) {
if (i < size_a && j < size_b) {
if (l < size_c)
if (a[i] + b[j] < c[l])
min += a[i++] + b[j++];
else
min += c[l++];
else
min += a[i++] + b[j++];
} else if (l < size_c) {
min += c[l++];
} else
break;
cnt_a++;
cnt_b++;
}
for (; (i < size_a || l < size_c) && cnt_a < k;) {
if (i < size_a) {
if (l < size_c)
if (a[i] < c[l])
min += a[i++];
else {
min += c[l++];
cnt_b++;
}
else
min += a[i++];
} else if (l < size_c) {
min += c[l++];
cnt_b++;
} else
break;
cnt_a++;
}
for (; (j < size_b || l < size_c) && cnt_b < k;) {
if (j < size_b) {
if (l < size_c)
if (b[j] < c[l])
min += b[j++];
else {
min += c[l++];
cnt_a++;
}
else
min += b[j++];
} else if (l < size_c) {
min += c[l++];
cnt_a++;
} else
break;
cnt_b++;
}
if (cnt_a < k || cnt_b < k)
cout << -1;
else
cout << min;
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> alice;
vector<long long> bob;
vector<long long> combined;
long long atotal = 0, btotal = 0;
for (long long i = 0; i < n; ++i) {
long long t, a, b;
cin >> t >> a >> b;
if (a == 1 && b == 1)
combined.push_back(t);
else if (a == 1)
alice.push_back(t);
else if (b == 1)
bob.push_back(t);
atotal += a;
btotal += b;
}
sort(combined.begin(), combined.end());
sort(alice.begin(), alice.end());
sort(bob.begin(), bob.end());
long long score = 0;
bool possible = true;
if (atotal < k || btotal < k) {
possible = false;
cout << -1;
}
if (possible) {
long long m = combined.size();
m = min(k, m);
for (long long i = 0; i < m; ++i) {
score += combined[i];
}
long long pointer = 0;
if (m < k) {
for (long long j = 0; j < k - m; ++j) {
score += alice[j];
score += bob[j];
}
pointer = k - m;
}
long long asize = alice.size();
long long bsize = bob.size();
while (pointer < asize && pointer < bsize && pointer < k &&
alice[pointer] + bob[pointer] < combined[k - 1 - pointer]) {
score -= combined[k - 1 - pointer];
score += alice[pointer];
score += bob[pointer];
pointer++;
}
cout << score;
}
}
| 11 | CPP |
n,k = map(int,input().split())
U = [];A = [];B = []
for i in range(n):
a,b,c = map(int,input().split())
if(b==1 and c==1):
U.append(a)
elif(b==1 and c==0):
A.append(a)
elif(b==0 and c==1):
B.append(a)
A.sort();B.sort();U.sort()
for i in range(1,len(U)):
U[i]+=U[i-1]
for i in range(1,len(A)):
A[i]+=A[i-1]
for i in range(1,len(B)):
B[i]+=B[i-1]
f_ans = 1e10
cnt = 0;ans =0
for i in range(-1,len(U)):
cnt = i+1;ans = 0
if(i>=0):
ans = U[i]
if(k-cnt==0):
f_ans = min(ans,f_ans)
break
if(k-cnt>len(A) or k-cnt >len(B)):
continue
ans += A[k-cnt-1] + B[k-cnt-1]
cnt = k
f_ans = min(f_ans,ans)
f_ans = min(ans,f_ans)
if(k-cnt>0):
print("-1")
else:
print(f_ans) | 11 | PYTHON3 |
import os,io
input=io.BytesIO(os.read(0,os.fstat(0).st_size)).readline
n,k = map(int,input().split())
bookA = []
bookB = []
bookAB = []
for _ in range(n):
t,a,b = map(int,input().split())
if a == 1 and b == 1:
bookAB.append(t)
elif a == 1:
bookA.append(t)
elif b == 1:
bookB.append(t)
bookA.sort()
bookB.sort()
bookAB.sort()
bookASum = [0]
bookBSum = [0]
bookABSum = [0]
for elem in bookA:
bookASum.append(bookASum[-1] + elem)
for elem in bookB:
bookBSum.append(bookBSum[-1] + elem)
for elem in bookAB:
bookABSum.append(bookABSum[-1] + elem)
minReadingTime = -1
for i in range(len(bookABSum)):
if len(bookASum) > max(k - i,0) and len(bookBSum) > max(k - i,0) and len(bookABSum) > i:
if minReadingTime == -1 or minReadingTime > bookABSum[i] + bookASum[max(k - i,0)] + bookBSum[max(k - i,0)]:
minReadingTime = bookABSum[i] + bookASum[max(k - i,0)] + bookBSum[max(k - i,0)]
print(minReadingTime) | 11 | PYTHON3 |
import sys
# from collections import defaultdict
# t=1
# t=int(input())
def fun(x):
# print(x)
return x[0]
n,k=list(map(int,sys.stdin.readline().strip().split()))
xx=[]
a=[]
b=[]
c=[]
for i in range(n):
# n=int(input())
x=list(map(int,sys.stdin.readline().strip().split()))
# a,b,c,d=list(sys.stdin.readline().strip().split())
# n,k=list(map(int,sys.stdin.readline().strip().split()))
# xx.append(x)
if(x[1]==x[2]==1):
a.append(x[0])
elif(x[1]==1):
b.append(x[0])
elif(x[2]==1):
c.append(x[0])
# a=k
# b=k
# # print(xx)
# xx.sort(key=fun)
# # print(xx)
# op=0
# for i in xx:
# if()
b.sort()
c.sort()
for i in range(min(len(b),len(c))):
a.append(b[i]+c[i])
a.sort()
if(len(a)<k):
print(-1)
else:
print(sum(a[:k])) | 11 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
const int N = 5e5 + 99;
int n, k, m, x, y, p0, p1, p2, b0, b1, b2, b3, a[N];
vector<pair<long long, int> > v0, v1, v2, v3;
long long ans = 1e18, sum;
void calc(int x) {
if (p0 < v0.size() - 1) p0++, sum += v0[p0].first;
if (p0 < v0.size() - 1) p0++, sum += v0[p0].first;
if (k - x >= int(v1.size()) || k - x >= int(v2.size()) ||
x + v2.size() + v1.size() + v0.size() - 3 < m ||
x + max((k - x), 0) * 2 > m)
return;
while (x + p1 + p2 + p0 > m) {
if (p0 && (p1 == max(k - x, 0) || v0[p0] >= v1[p1]) &&
(p2 == max(k - x, 0) || v0[p0] >= v2[p2]))
sum -= v0[p0--].first;
else {
if (p1 == max(k - x, 0) ||
(p2 != max(k - x, 0) && v2[p2].first >= v1[p1].first)) {
while (p2 == max(k - x, 0)) n = 1;
sum -= v2[p2--].first;
} else
sum -= v1[p1--].first;
}
}
if (sum + v3[x].first < ans)
ans = sum + v3[x].first, b0 = p0, b1 = p1, b2 = p2, b3 = x;
}
int main() {
cin >> n >> m >> k;
v1.push_back(make_pair(0, 0)), v2.push_back(make_pair(0, 0)),
v3.push_back(make_pair(0, 0)), v0.push_back(make_pair(0, 0));
for (int i = 0; i < n; i++) {
scanf("%d", &a[i]);
;
scanf("%d%d", &x, &y);
;
if (x == 1 && y == 1) v3.push_back(make_pair(a[i], i + 1));
if (x == 1 && y == 0) v1.push_back(make_pair(a[i], i + 1));
if (x == 0 && y == 1) v2.push_back(make_pair(a[i], i + 1));
if (x == 0 && y == 0) v0.push_back(make_pair(a[i], i + 1));
}
p0 = v0.size() - 1, p1 = v1.size() - 1, p2 = v2.size() - 1;
sort(v0.begin(), v0.end());
sort(v1.begin(), v1.end());
sort(v2.begin(), v2.end());
sort(v3.begin(), v3.end());
for (int i = 1; i < v0.size(); i++) sum += v0[i].first;
for (int i = 1; i < v1.size(); i++) sum += v1[i].first;
for (int i = 1; i < v2.size(); i++) sum += v2[i].first;
for (int i = 1; i < v3.size(); i++) v3[i].first += v3[i - 1].first;
for (int i = 0; i < v3.size(); i++) calc(i);
if (ans == 1e18) return cout << -1, 0;
cout << ans << endl;
for (int i = 1; i < b0 + 1; i++) cout << v0[i].second << " ";
for (int i = 1; i < b1 + 1; i++) cout << v1[i].second << " ";
for (int i = 1; i < b2 + 1; i++) cout << v2[i].second << " ";
for (int i = 1; i < b3 + 1; i++) cout << v3[i].second << " ";
}
| 11 | CPP |
import collections as cc
import math as mt
import sys
input=sys.stdin.readline
I=lambda:list(map(int,input().split()))
n,k=I()
a=[]
for i in range(n):
a.append(I())
a.sort()
both=[]
bs=0
f=0
for i in range(n):
if a[i][1] and a[i][2]:
both.append(a[i][0])
al=[]
bo=[]
for i in range(n):
if a[i][1] and not a[i][2]:
al.append(a[i][0])
elif a[i][2] and not a[i][1]:
bo.append(a[i][0])
su=[]
for i in range(min(len(al),len(bo))):
su.append(al[i]+bo[i])
xx=len(both)
yy=len(su)
if xx+yy<k:
print(-1)
elif both and not su:
if xx>=k:
print(sum(both[:k]))
else:
print(-1)
elif su and not both:
if yy>=k:
print(sum(su[:k]))
else:
print(-1)
else:
te=both+su
te.sort()
print(sum(te[:k])) | 11 | PYTHON3 |
#include <bits/stdc++.h>
const long long maxn = 2e5 + 1;
using namespace std;
struct triple {
long long t, ci;
bool a = 0, b = 0;
triple() {}
};
bool cmp(triple x, triple y) { return x.t < y.t; }
triple v[maxn];
bool usd[maxn];
long long ci = -1;
long long cs = 0;
inline void add() {
++ci;
for (; usd[ci]; ci++)
;
cs += v[ci].t;
}
inline void del() {
if (ci == -1) exit(228);
cs -= v[ci].t;
--ci;
for (; ci >= 0 && usd[ci]; --ci)
;
}
inline void dl(long long x) {
usd[x] = 0;
if (x < ci) {
cs += v[x].t - v[ci].t;
--ci;
for (; ci >= 0 && usd[ci]; ci--)
;
}
}
inline void ad(long long x) {
usd[x] = 1;
if (x <= ci) {
cs -= v[x].t;
++ci;
for (; usd[ci]; ci++)
;
cs += v[ci].t;
}
}
long long n, m, k;
long long solve() {
cin >> n >> m >> k;
for (long long i = 0; i < n; i++) {
cin >> v[i].t >> v[i].a >> v[i].b;
v[i].ci = i + 1;
}
sort(v, v + n, cmp);
vector<long long> oo, oz, zo;
for (long long i = 0; i < n; i++) {
if (v[i].a && v[i].b)
oo.push_back(i);
else if (v[i].a)
oz.push_back(i);
else if (v[i].b)
zo.push_back(i);
}
long long j1 = 0, j2 = 0, mi = -1;
long long ans = 1e18, can = 0;
for (long long i = 0; i < m; i++) add();
for (long long i = 0; i < min(k, (long long)oo.size()); i++) {
can += v[oo[i]].t;
del();
ad(oo[i]);
}
for (long long i = min(k, (long long)oo.size()); i >= 0; i--) {
if (i + min(zo.size(), oz.size()) < k) break;
if (2 * k - i > m) break;
if (i < min(k, (long long)oo.size())) {
dl(oo[i]);
add();
can -= v[oo[i]].t;
}
for (; i + j1 < k; j1++) {
can += v[oz[j1]].t;
del();
ad(oz[j1]);
}
for (; i + j2 < k; j2++) {
can += v[zo[j2]].t;
del();
ad(zo[j2]);
}
if (ans > can + cs) {
ans = can + cs;
mi = i;
}
}
if (mi == -1) {
cout << -1;
return 0;
}
cout << ans << '\n';
for (long long i = 0; i < n; i++) usd[i] = 0;
for (long long j = 0; j < mi; j++) {
cout << v[oo[j]].ci << ' ';
usd[oo[j]] = 1;
}
for (long long j = 0; j < k - mi; j++) {
cout << v[oz[j]].ci << ' ';
usd[oz[j]] = 1;
}
for (long long j = 0; j < k - mi; j++) {
cout << v[zo[j]].ci << ' ';
usd[zo[j]] = 1;
}
long long cnt = 0;
for (long long i = 0; cnt < m - (2 * k - mi); i++) {
if (usd[i]) continue;
cout << v[i].ci << ' ';
++cnt;
}
}
signed main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
solve();
return 0;
}
| 11 | CPP |
#include <bits/stdc++.h>
using namespace std;
const double eps = 1e-10;
template <typename T>
void read(T &x) {
int f = 1;
x = 0;
char s = getchar();
while (s < '0' || s > '9') {
if (s == '-') f = -1;
s = getchar();
}
while (s >= '0' && s <= '9') {
x = x * 10 + s - '0';
s = getchar();
}
x *= f;
}
template <typename T>
void print(T x) {
if (x < 0) putchar('-'), x = -x;
if (x > 9) print(x / 10);
putchar(x % 10 + '0');
}
template <typename T>
void println(T x) {
if (x < 0) putchar('-'), x = -x;
if (x > 9) print(x / 10);
putchar(x % 10 + '0');
putchar('\n');
}
template <typename T, typename... Args>
void read(T &x, Args &...args) {
read(x);
read(args...);
}
inline void reads(char *a) { scanf("%s", a); }
template <typename... Args>
void reads(char *a, Args *...args) {
scanf("%s", a);
reads(args...);
}
template <typename T, typename... Args>
void print(T x, Args... args) {
print(x);
putchar(' ');
print(args...);
}
template <typename T, typename... Args>
void println(T x, Args... args) {
print(x);
putchar(' ');
println(args...);
}
inline void prints(char *a) { printf("%s", a); }
template <typename T>
inline T sqr(T x) {
return x * x;
}
template <typename T>
inline T random(T R) {
return (double)rand() / RAND_MAX * R + ((T)0.5 == 0 ? 0.5 : 0.0);
}
template <typename T>
inline T random(T L, T R) {
return random(R - L) + L;
}
long long ksm(long long a, long long k, long long Mod) {
long long res = 1;
while (k) {
if (k & 1) (res *= a) %= Mod;
(a *= a) %= Mod;
k >>= 1;
}
return res % Mod;
}
inline long long inv(long long a, long long Mod) {
return ksm(a, Mod - 2, Mod);
}
inline void cap_bit(long long x) {
for (int i = 63; i >= 0; --i)
if (x >> i & 1) {
printf("Need (%d) = %lld\n", i + 1, 1LL << (i + 1));
return;
}
}
inline void cal_space(long long x) { printf("%lld MB\n", x >> 20); }
const int dx4[] = {0, 0, -1, 1};
const int dy4[] = {-1, 1, 0, 0};
const int dx6[] = {1, -1, 0, 0, 0, 0};
const int dy6[] = {0, 0, 1, -1, 0, 0};
const int dz6[] = {0, 0, 0, 0, 1, -1};
const int N = 2e5 + 5;
const int M = 26;
const long long Mod = 1e9 + 7;
const long long INF = 1e16;
pair<long long, long long> a[4][N];
long long ia[4];
long long n, m, k;
set<pair<long long, long long> > sf, ss;
long long ans, cur;
void adjust(int x) {
long long cnt = x + 2 * (k - x);
while (ss.size() && sf.size() && ss.rbegin()->first > sf.begin()->first) {
cur -= ss.rbegin()->first;
cur += sf.begin()->first;
sf.insert(*ss.rbegin());
ss.erase(*ss.rbegin());
ss.insert(*sf.begin());
sf.erase(*sf.begin());
}
while (ss.size() && cnt + ss.size() > m) {
cur -= ss.rbegin()->first;
sf.insert(*ss.rbegin());
ss.erase(*ss.rbegin());
}
while (sf.size() && cnt + ss.size() < m) {
cur += sf.begin()->first;
ss.insert(*sf.begin());
sf.erase(*sf.begin());
}
}
int main() {
cin >> n >> m >> k;
for (int i = 0; i < 4; ++i) ia[i] = 0;
for (int i = 1; i <= n; ++i) {
long long t, ai, bi;
cin >> t >> ai >> bi;
int s = 0;
if (ai) s += 1;
if (bi) s += 2;
a[s][++ia[s]] = {t, i};
}
if (ia[1] + ia[3] < k || ia[2] + ia[3] < k) {
puts("-1");
return 0;
}
for (int i = 0; i < 4; ++i) sort(a[i] + 1, a[i] + ia[i] + 1);
long long st = 0;
cur = -1;
ans = -1;
long long ians;
while ((k - st) > ia[1] || (k - st) > ia[2]) st++;
for (int i = st; i <= ia[3] && i <= k; ++i) {
long long cnt = i + (k - i) * 2;
if (cur == -1) {
cur = 0;
for (int j = 1; j <= ia[3]; ++j)
if (j <= st)
cur += a[3][j].first;
else
sf.insert(a[3][j]);
for (int j = 1; j <= ia[2]; ++j)
if (j <= (k - st))
cur += a[2][j].first;
else
sf.insert(a[2][j]);
for (int j = 1; j <= ia[1]; ++j)
if (j <= (k - st))
cur += a[1][j].first;
else
sf.insert(a[1][j]);
for (int j = 1; j <= ia[0]; ++j) sf.insert(a[0][j]);
} else {
long long r = k - i;
if (sf.find(a[3][i]) != sf.end())
cur += a[3][i].first, sf.erase(a[3][i]);
else
ss.erase(a[3][i]);
cur -= a[1][r + 1].first;
cur -= a[2][r + 1].first;
sf.insert(a[1][r + 1]);
sf.insert(a[2][r + 1]);
}
adjust(i);
if (cnt + ss.size() == m) {
if (ans == -1 || cur < ans) {
ans = cur;
ians = i;
}
}
}
cout << ans << endl;
if (ans == -1) return 0;
vector<pair<long long, long long> > res;
for (int i = 1; i <= ians; ++i) cout << a[3][i].second << " ";
for (int i = ians + 1; i <= ia[3]; ++i) res.push_back(a[3][i]);
for (int i = 1; i <= k - ians; ++i) cout << a[1][i].second << " ";
for (int i = k - ians + 1; i <= ia[1]; ++i) res.push_back(a[1][i]);
for (int i = 1; i <= k - ians; ++i) cout << a[2][i].second << " ";
for (int i = k - ians + 1; i <= ia[2]; ++i) res.push_back(a[2][i]);
for (int i = 1; i <= ia[0]; ++i) res.push_back(a[0][i]);
sort((res).begin(), (res).end());
for (int i = 1; i <= m - ians - 2 * (k - ians); ++i)
cout << res[i - 1].second << " ";
return 0;
}
| 11 | CPP |
from sys import stdin
input = lambda: stdin.readline().rstrip("\r\n")
from collections import defaultdict as vector
from collections import deque as que
inin = lambda: int(input())
inar = lambda: list(map(int,input().split()))
from heapq import heappush as hpush,heappop as hpop
bob=[]
alice=[]
both=[]
n,k=inar()
for i in range(n):
t,a,b=inar()
if a==1 and b==1:
both.append(t)
elif a==1:
alice.append(t)
elif b==1:
bob.append(t)
else:
continue
both.sort(reverse=True)
alice.sort(reverse=True)
bob.sort(reverse=True)
def top(x):
if x==[]:
return float('inf')
else:
return x[-1]
t=0
donealice=0
donebob=0
while(donealice<k or donebob<k):
if both==[] and alice==[] and bob==[]:
t=-1
break
if top(both)<top(alice)+top(bob):
donealice+=1
donebob+=1
t+=both.pop()
#print('#1')
else:
if alice:
t+=alice.pop()
donealice+=1
if bob:
t+=bob.pop()
donebob+=1
#print('#2')
print(t)
| 11 | PYTHON3 |
#!/usr/bin/env python
from __future__ import division, print_function
import os
import sys
from io import BytesIO, IOBase
if sys.version_info[0] < 3:
from __builtin__ import xrange as range
from future_builtins import ascii, filter, hex, map, oct, zip
# 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")
def print(*args, **kwargs):
"""Prints the values to a stream, or to sys.stdout by default."""
sep, file = kwargs.pop("sep", " "), kwargs.pop("file", sys.stdout)
at_start = True
for x in args:
if not at_start:
file.write(sep)
file.write(str(x))
at_start = False
file.write(kwargs.pop("end", "\n"))
if kwargs.pop("flush", False):
file.flush()
if sys.version_info[0] < 3:
sys.stdin, sys.stdout = FastIO(sys.stdin), FastIO(sys.stdout)
else:
sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)
from math import sqrt, floor, factorial, gcd, log
from collections import deque, Counter, defaultdict
from itertools import permutations, combinations
from math import gcd
from bisect import bisect
input = lambda: sys.stdin.readline().rstrip("\r\n")
read = lambda: list(map(int, input().strip().split(" ")))
def solve():
n, k_ = read();both = []; a = []; b = []
for _ in range(n):
arr = read()
x, y, z = arr
if y&z:
both.append(arr)
elif y:
a.append(arr)
elif z:
b.append(arr)
both.sort(); a.sort(); b.sort()
t = 0; books = 0; i, j, k = 0, 0, 0
while books < k_ and i < len(both) and j < len(a) and k < len(b):
if both[i][0] <= a[j][0]+b[k][0]:
t += both[i][0]
books += 1
i += 1
else:
t += a[j][0]+b[k][0]
j += 1; k += 1
books += 1
while books < k_ and j < len(a) and k < len(b):
t += a[j][0]+b[k][0]
j += 1; k += 1
books += 1
while books< k_ and i < len(both):
t += both[i][0]
books += 1
i += 1
if books < k_:
print(-1)
elif books == k_:
print(t)
if __name__ == "__main__":
solve() | 11 | PYTHON3 |
import sys
import math
import heapq
from collections import defaultdict, deque
input = sys.stdin.readline
def r():
return int(input())
def rm():
return map(int,input().split())
def rl():
return list(map(int,input().split()))
n,k=rm()
a=[];b=[];both=[]
for _ in range(n):
t,ai,bi=rm()
if ai==1 and bi==1:
both.append(t)
elif ai==1:
a.append(t)
elif bi==1:
b.append(t)
a.sort()
b.sort()
if len(a)<k-len(both) or len(b)<k-len(both):
print(-1)
else:
c=[]
cl=min(len(a),len(b))
for i in range(cl):
c.append(a[i]+b[i])
both+=c
both.sort()
print(sum(both[:k])) | 11 | PYTHON3 |
""" 616C """
""" 1152B """
# import math
# import sys
def main():
# n ,m= map(int,input().split())
# arr = list(map(int,input().split()))
# b = list(map(int,input().split()))
# n = int(input())
# string = str(input())
n ,k= map(int,input().split())
a = []
b = []
c = []
for _ in range(n):
t,first,second = map(int,input().split())
if(first==second):
if(second==1):
c.append(t)
elif(first==1):
a.append(t)
elif second==1:
b.append(t)
if(len(a)+len(c)<k or len(b)+len(c)<k):
print(-1)
return
a.sort()
b.sort()
c.sort()
l = 0
r = 0
m = 0
ans = 0
for i in range(k):
if((l>=len(a) or r>=len(b)) or (m<len(c) and l<len(a) and r<len(c) and c[m]<(a[l]+b[r]))):
ans += c[m]
m+=1
else:
ans += (a[l]+b[r])
l+=1
r+=1
print(ans)
return
main()
# def test():
# t = int(input())
# while t:
# main()
# t-=1
# test() | 11 | PYTHON3 |
from bisect import bisect_left as bl
from bisect import bisect_right as br
from heapq import heappush,heappop
import math
from collections import *
from functools import reduce,cmp_to_key
import sys
input = sys.stdin.readline
M = mod = 998244353
def factors(n):return sorted(set(reduce(list.__add__, ([i, n//i] for i in range(1, int(n**0.5) + 1) if n % i == 0))))
def inv_mod(n):return pow(n, mod - 2, mod)
def li():return [int(i) for i in input().rstrip('\n').split()]
def st():return input().rstrip('\n')
def val():return int(input().rstrip('\n'))
def li2():return [i for i in input().rstrip('\n')]
def li3():return [int(i) for i in input().rstrip('\n')]
n,k = li()
alice = []
bob = []
both = []
for i in range(n):
a,b,c = li()
if b and c:
both.append(a)
elif b:alice.append(a)
elif c:bob.append(a)
alice.sort()
bob.sort()
for i in range(min(len(alice),len(bob))):
both.append(alice[i] + bob[i])
both.sort()
# print(both)
if len(both) < k:
print(-1)
exit()
else:print(sum(both[:k]))
| 11 | PYTHON3 |
t,k = map(int,input().split())
arra = []
arrb = []
arrc =[]
ans =0
for i in range(t):
a,b,c =map(int,input().split())
if b==c==1 :
arra.append(a)
elif b==0 and c==1:
arrc.append(a)
elif b==1 and c==0:
arrb.append(a)
arra.sort()
arrb.sort()
arrc.sort()
l1,l2,l3 = len(arra),len(arrb),len(arrc)
#print(arra,arrb,arrc)
if min(l2,l3)<k and k-min(l2,l3)>l1:
print(-1)
else:
x = k
y = k
index =0
curr =0
while(x!=0 or y!=0):
s1 = 0
Flag =True
if curr<l2:
s1+=arrb[curr]
else:
Flag =False
if curr<l3:
s1+=arrc[curr]
else:
Flag=False
if (index<l1 and s1>arra[index]) or Flag ==False:
ans+=arra[index]
index+=1
x-=1
y-=1
else:
ans+=arrb[curr]
ans+=arrc[curr]
curr+=1
x-=1
y-=1
print(ans) | 11 | PYTHON3 |
for _ in range(1):
n,k=map(int,input().split())
one=[]
two=[]
both=[]
a=[]
for ii in range(n):
x,y,z=map(int,input().split())
a.append([x,y,z])
if z*y:
both.append(x)
else:
if z:
two.append(x)
if y:
one.append(x)
both.sort()
one.sort()
two.sort()
ans=0
tot=k
bo=len(both)
on=len(one)
tw=len(two)
if bo + min(on,tw)<k:
print(-1)
else:
i=0
if bo<k:
for i in range(k-bo):
ans+=(one[i] + two[i])
tot-=1
i+=1
c=0
while tot:
if i>=on or i>=tw:
break
if one[i]+two[i]<both[c]:
ans+=one[i]+two[i]
i+=1
tot-=1
else:
ans+=both[c]
c+=1
tot-=1
while tot:
ans+=both[c]
c+=1
tot-=1
print(ans)
| 11 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
vector<long long> D;
vector<long long> B;
vector<long long> A;
int main() {
long long a = 0, b = 0;
long long n, k;
long long ti, al, bl, time = 0;
cin >> n >> k;
for (long long i = 0; i < n; ++i) {
cin >> ti >> al >> bl;
if (al + bl == 2)
D.push_back(ti);
else if (al == 1)
A.push_back(ti);
else if (bl == 1)
B.push_back(ti);
a += al;
b += bl;
}
if (a < k || b < k) {
cout << -1 << endl;
return 0;
}
if (n == k && k == a && k == b) {
time += accumulate(D.begin(), D.end(), 0);
time += accumulate(A.begin(), A.end(), 0);
time += accumulate(B.begin(), B.end(), 0);
cout << time << endl;
return 0;
}
a = b = k;
sort(D.begin(), D.end());
sort(A.begin(), A.end());
sort(B.begin(), B.end());
for (long long i = 0, j = 0, l = 0; a > 0 || b > 0;) {
if (i < D.size() && j < A.size() && l < B.size()) {
if (D[i] <= A[j] + B[l]) {
time += D[i];
++i;
--a;
--b;
} else {
time += A[j] + B[l];
++j;
++l;
--a;
--b;
}
} else if (i < D.size() && j < A.size() && l >= B.size()) {
if (a > 0 && b > 0) {
time += D[i];
++i;
--a;
--b;
} else if (a > 0 && b <= 0) {
if (D[i] < A[j]) {
time += D[i];
++i;
--a;
--b;
} else {
time += A[j];
++j;
--a;
}
}
} else if (i < D.size() && j >= A.size() && l < B.size()) {
if (a > 0 && b > 0) {
time += D[i];
++i;
--a;
--b;
} else if (a <= 0 && b > 0) {
if (D[i] < B[l]) {
time += D[i];
++i;
--a;
--b;
} else {
time += B[l];
++l;
--b;
}
}
} else if (i >= D.size()) {
if (a > 0 && j < A.size()) {
time += A[j];
++j;
--a;
} else if (b > 0 && l < B.size()) {
time += B[l];
++l;
--b;
}
} else if (i < D.size() && j >= A.size() && l >= B.size()) {
time += D[i];
++i;
--a;
--b;
}
}
cout << time << endl;
}
| 11 | CPP |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
long long n, k, c1 = 0, c2 = 0, v = 0, ans = 0, res;
cin >> n >> k;
long long a[n][3];
vector<long long> s1, s2, s3;
for (long long i = 0; i < n; i++) {
for (long long j = 0; j < 3; j++) {
cin >> a[i][j];
if (j == 1) {
if (a[i][j] == 1) c1++;
} else if (j == 2) {
if (a[i][j] == 1) c2++;
}
}
}
if (c1 < k || c2 < k) {
cout << "-1"
<< "\n";
} else {
for (long long i = 0; i < n; i++) {
if (a[i][1] && a[i][2])
s1.push_back(a[i][0]);
else if (a[i][1])
s2.push_back(a[i][0]);
else if (a[i][2])
s3.push_back(a[i][0]);
}
sort(s2.begin(), s2.end());
sort(s3.begin(), s3.end());
if (s2.size() < s3.size())
res = s2.size();
else
res = s3.size();
for (long long i = 0; i < res; i++) {
s1.push_back(s2[i] + s3[i]);
}
sort(s1.begin(), s1.end());
for (auto i : s1) {
if (v >= k) break;
ans += i;
v++;
}
cout << ans << "\n";
s1.clear();
s2.clear();
s3.clear();
}
return 0;
}
| 11 | CPP |
import collections as cc
import math as mt
import sys
input=sys.stdin.readline
I=lambda:list(map(int,input().split()))
n,k=I()
a=[]
for i in range(n):
a.append(I())
a.sort()
both=[]
bs=0
f=0
for i in range(n):
if a[i][1] and a[i][2]:
both.append(a[i][0])
al=[]
bo=[]
for i in range(n):
if a[i][1] and not a[i][2]:
al.append(a[i][0])
elif a[i][2] and not a[i][1]:
bo.append(a[i][0])
su=[]
for i in range(min(len(al),len(bo))):
su.append(al[i]+bo[i])
xx=len(both)
yy=len(su)
if xx+yy<k:
print(-1)
elif both and not su:
if xx>=k:
print(sum(both[:k]))
else:
print(-1)
elif su and not both:
if yy>=k:
print(sum(su[:k]))
else:
print(-1)
else:
i=0
j=0
cn=0
ans=0
while i<xx and j<yy:
if both[i]<su[j]:
ans+=both[i]
i+=1
cn+=1
else:
ans+=su[j]
j+=1
cn+=1
if cn==k:
break
if cn<k:
while i<xx:
ans+=both[i]
cn+=1
i+=1
if cn==k:
break
if cn<k:
while j<yy:
ans+=su[j]
cn+=1
j+=1
if cn==k:
break
print(ans)
| 11 | PYTHON3 |
n,k=map(int,input().split())
x=[];y=[];z=[]
for i in range(n):
t,a,b=map(int,input().split())
if a and b:x.append(t)
elif a==1:y.append(t)
elif b==1:z.append(t)
y.sort();z.sort()
for p,q in zip(y,z):
x.append(p+q)
x.sort()
if len(x)<k:print(-1)
else:print(sum(x[:k])) | 11 | PYTHON3 |
def solve(n, k, a, b, c):
a.sort()
b.sort()
c.sort()
# print(a, b, c)
iab = min(k, len(a), len(b))
ic = k - iab
if ic > len(c):
return -1
res = 0
for i in range(ic):
res += c[i]
for i in range(iab):
res += a[i] + b[i]
iab -= 1
while ic < len(c) and iab >= 0 and c[ic] < a[iab] + b[iab]:
res -= a[iab] + b[iab] - c[ic]
ic += 1
iab -= 1
return res
current_str = input().split(" ")
n = int(current_str[0])
k = int(current_str[1])
a = []
b = []
c = []
for i in range(n):
current_str = input().split(" ")
t = int(current_str[0])
aa = int(current_str[1])
bb = int(current_str[2])
if aa and bb:
c.append(t)
elif aa:
a.append(t)
elif bb:
b.append(t)
print(solve(n, k, a, b, c)) | 11 | PYTHON3 |
n,k = map(int,input().split())
ablike = []
alike = []
blike = []
for i in range(n):
t,a,b = map(int,input().split())
if a == 1 and b == 1:
ablike.append(t)
elif a == 1:
alike.append(t)
elif b == 1:
blike.append(t)
ablike.sort()
abtot = len(ablike)
alike.sort()
atot = len(alike)
blike.sort()
btot = len(blike)
x = min(atot,btot)
if abtot + x < k:
print(-1)
else:
p = k
i = 0
j = 0
tot = 0
while p > 0:
if j < abtot and i < x:
if ablike[j] <= (alike[i] + blike[i]):
tot = tot + ablike[j]
j = j + 1
p = p - 1
else:
tot = tot + alike[i] + blike[i]
i = i + 1
p = p - 1
elif j < abtot:
tot = tot + ablike[j]
j = j + 1
p = p - 1
else:
tot = tot + alike[i] + blike[i]
i = i + 1
p = p - 1
print(tot) | 11 | PYTHON3 |
#include <bits/stdc++.h>
const int MAXN = 3e5 + 10;
const double eps = 1e-8;
const int inf = 2e9 + 9;
using namespace std;
struct edge {
int t, v;
edge *next;
} e[MAXN << 1], *h[MAXN], *o = e;
void add(int x, int y, int vul) {
o->t = y;
o->v = vul;
o->next = h[x];
h[x] = o++;
}
long long read() {
long long x = 0, f = 1;
char ch = getchar();
while (!isdigit(ch)) {
if (ch == '-') f = -1;
ch = getchar();
}
while (isdigit(ch)) x = x * 10 + ch - '0', ch = getchar();
return x * f;
}
pair<int, int> a[4][MAXN];
int cnt[4];
int num[MAXN << 2], sum[MAXN << 2];
void up(int x) {
num[x] = num[x << 1] + num[x << 1 | 1];
sum[x] = sum[x << 1] + sum[x << 1 | 1];
}
void update(int x, int l, int r, int t, int y) {
if (l == r) {
num[x] += y;
sum[x] = l * num[x];
return;
}
int mid = (l + r) >> 1;
if (t <= mid)
update(x << 1, l, mid, t, y);
else
update(x << 1 | 1, mid + 1, r, t, y);
up(x);
}
int ans;
void query(int x, int l, int r, int k) {
if (!k) return;
if (l == r) {
ans += k * l;
return;
}
int mid = (l + r) >> 1;
if (num[x << 1] >= k)
query(x << 1, l, mid, k);
else
ans += sum[x << 1], query(x << 1 | 1, mid + 1, r, k - num[x << 1]);
}
int n, m, k;
int sum1[MAXN], sum2[MAXN];
pair<int, int> b[MAXN];
int main() {
n = read();
m = read();
k = read();
int x, y, z;
int sz = 1e4;
for (int i = 1; i <= n; i++) {
x = read();
y = read();
z = read();
int p = 2 * y + z;
a[p][++cnt[p]] = make_pair(x, i);
}
for (int i = 0; i <= 3; i++) sort(a[i] + 1, a[i] + cnt[i] + 1);
for (int j = 0; j <= 2; j++)
for (int i = 1; i <= cnt[j]; i++) update(1, 1, sz, a[j][i].first, 1);
int pos = cnt[3];
int minn = inf;
int p = -1;
for (int i = 1; i <= min(cnt[1], cnt[2]); i++)
sum1[i] = sum1[i - 1] + a[1][i].first + a[2][i].first;
for (int i = 1; i <= cnt[3]; i++) sum2[i] = sum2[i - 1] + a[3][i].first;
for (int i = 0; i <= min(cnt[1], cnt[2]); i++) {
if (i > 0) {
update(1, 1, sz, a[1][i].first, -1);
update(1, 1, sz, a[2][i].first, -1);
}
if (i > k) continue;
if (cnt[3] < k - i) continue;
if (2 * i + k - i > m) continue;
while (pos > k - i) {
update(1, 1, sz, a[3][pos].first, 1);
pos--;
}
ans = 0;
query(1, 1, sz, m - k - i);
if (ans + sum1[i] + sum2[pos] < minn) {
minn = ans + sum1[i] + sum2[pos];
p = i;
}
}
if (minn == inf) return 0 * printf("-1\n");
printf("%d\n", minn);
for (int i = 1; i <= p; i++) printf("%d %d ", a[1][i].second, a[2][i].second);
for (int i = 1; i <= k - p; i++) printf("%d ", a[3][i].second);
int tot = 0;
for (int i = 1; i <= cnt[0]; i++) b[++tot] = a[0][i];
for (int i = p + 1; i <= cnt[1]; i++) b[++tot] = a[1][i];
for (int i = p + 1; i <= cnt[2]; i++) b[++tot] = a[2][i];
for (int i = k - p + 1; i <= cnt[3]; i++) b[++tot] = a[3][i];
sort(b + 1, b + tot + 1);
for (int i = k + p + 1; i <= m; i++) printf("%d ", b[i - k - p].second);
return 0;
}
| 11 | CPP |
#include <bits/stdc++.h>
using namespace std;
long long gcd(long long a, long long b) { return b ? gcd(b, a % b) : a; }
long long powM(long long x, long long y, long long m) {
if (y == 0) return 1;
long long p = powM(x, y / 2, m) % m;
p = (p * p) % m;
return (y % 2 == 0) ? p : (x * p) % m;
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int n, k;
cin >> n >> k;
vector<int> vt, va, vb;
for (long long i = 1; i <= n; i++) {
int t, a, b;
cin >> t >> a >> b;
if (a == 1 && b == 1) vt.push_back(t);
if (a == 1 && b == 0) va.push_back(t);
if (a == 0 && b == 1) vb.push_back(t);
}
sort(va.begin(), va.end());
sort(vb.begin(), vb.end());
for (long long i = 0; i <= min((int)va.size() - 1, (int)vb.size() - 1); i++)
vt.push_back(va[i] + vb[i]);
sort(vt.begin(), vt.end());
if ((int)vt.size() < k) {
cout << -1 << '\n';
return 0;
}
int sum = 0;
for (long long i = 0; i <= k - 1; i++) sum += vt[i];
cout << sum << '\n';
return 0;
}
| 11 | CPP |
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])
print(-1if len(z)<k else sum(sorted(z)[:k])) | 11 | PYTHON3 |
n, k = map(int, input().split())
a = []
b = []
ab = []
c = 0
p = 0
e = 0
for q in range(n):
x, y, z = map(int, input().split())
if y == 1 and z == 0:
a.append(x)
elif y == 0 and z == 1:
b.append(x)
elif y == 1 and z == 1:
ab.append(x)
a.sort()
b.sort()
ab.sort()
if len(ab) + min(len(a), len(b)) < k:
print("-1")
else:
for h in range(k):
if p == min(len(a), len(b)):
c = c + sum(ab[e:e + k - h])
break
elif e == len(ab):
c = c + sum(a[p:p + k - h]) + sum(b[p:p + k - h])
break
c = c + min(a[p] + b[p], ab[e])
if a[p] + b[p] < ab[e]:
p = p + 1
else:
e = e + 1
print(c)
| 11 | PYTHON3 |
from sys import stdin
input=lambda : stdin.readline().strip()
char = [chr(i) for i in range(97,123)]
CHAR = [chr(i) for i in range(65,91)]
mp = lambda:list(map(int,input().split()))
INT = lambda:int(input())
rn = lambda:range(INT())
from math import ceil,sqrt,factorial,gcd
n,k = mp()
alice = []
bob = []
common = []
for i in range(n):
t,a,b = mp()
if a==b==1:
common.append(t)
elif a==1:
alice.append(t)
elif b==1:
bob.append(t)
if len(common + alice)<k or len(common + bob) < k:
print(-1)
elif (len(alice)==0 or len(bob)==0) and len(common)>=k:
common.sort()
print(sum(common[:k]))
else:
alice.sort()
bob.sort()
common.sort()
inx = min(k,len(alice),len(bob))
sma = sum(alice[:inx])
smb = sum(bob[:inx])
res = sma+smb
if inx<k:
res+=sum(common[:k-inx])
common_inx = k-inx
inx = inx
res1 = res
while common_inx < len(common) and inx>0:
res -= alice[inx-1]
res -= bob[inx-1]
res += common[common_inx]
res1 = min(res,res1)
inx-=1
common_inx+=1
print(res1)
| 11 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
inline long long read() {
long long f = 1, ans = 0;
char c = getchar();
while (c < '0' || c > '9') {
if (c == '-') f = -1;
c = getchar();
}
while (c >= '0' && c <= '9') {
ans = ans * 10 + c - '0';
c = getchar();
}
return f * ans;
}
const long long MAXN = 4e5 + 11;
long long N, M, K, na, nb, nc, nd, Minn = LLONG_MAX, SA[MAXN], SB[MAXN],
SC[MAXN], SD[MAXN];
long long tmp1[MAXN], tmp2[MAXN], tmp3[MAXN], tmp4[MAXN];
pair<long long, long long> A[MAXN], B[MAXN], C[MAXN], D[MAXN];
long long sta1[MAXN], sta2[MAXN], sta3[MAXN], sta4[MAXN];
long long QA(long long x) {
return lower_bound(tmp1 + 1, tmp1 + N + 1, x + 1) - tmp1 - 1;
}
long long QB(long long x) {
return lower_bound(tmp2 + 1, tmp2 + N + 1, x + 1) - tmp2 - 1;
}
long long QD(long long x) {
return lower_bound(tmp4 + 1, tmp4 + N + 1, x + 1) - tmp4 - 1;
}
signed main() {
N = read(), M = read(), K = read();
for (long long i = 1; i <= N; i++) {
long long t = read(), a = read(), b = read();
pair<long long, long long> p = make_pair(t, i);
if (a && b) C[++nc] = p;
if (a && (!b)) A[++na] = p;
if ((!a) && b) B[++nb] = p;
if ((!a) && (!b)) D[++nd] = p;
}
for (long long i = na + 1; i <= N; i++) A[i] = make_pair(INT_MAX, 0);
for (long long i = nb + 1; i <= N; i++) B[i] = make_pair(INT_MAX, 0);
for (long long i = nc + 1; i <= N; i++) C[i] = make_pair(INT_MAX, 0);
for (long long i = nd + 1; i <= N; i++) D[i] = make_pair(INT_MAX, 0);
sort(A + 1, A + N + 1), sort(B + 1, B + N + 1), sort(C + 1, C + N + 1),
sort(D + 1, D + N + 1);
for (long long i = 1; i <= N; i++)
SA[i] = SA[i - 1] + A[i].first, SB[i] = SB[i - 1] + B[i].first,
SC[i] = SC[i - 1] + C[i].first, SD[i] = SD[i - 1] + D[i].first;
for (long long i = 1; i <= N; i++)
tmp1[i] = A[i].first, tmp2[i] = B[i].first, tmp3[i] = C[i].first,
tmp4[i] = D[i].first;
for (long long i = 0; i <= N; i++) {
long long res = (max(K - i, 0ll)) * 2 + i;
if (res > M) continue;
if (res < 0) continue;
long long ps1 = max(K - i, 0ll), ps2 = max(K - i, 0ll), l = 0, r = 10000,
Ans = -1;
long long Res = M - res;
long long u1 = 0, u2 = 0, u4 = 0;
while (l <= r) {
long long mid = (l + r) >> 1;
long long X = max(QA(mid) - ps1, 0ll), Y = max(QB(mid) - ps2, 0ll),
Z = QD(mid);
if (X + Y + Z >= Res)
Ans = mid, u1 = X, u2 = Y, u4 = Z, r = mid - 1;
else
l = mid + 1;
}
if (Ans == -1) continue;
long long W = SA[u1 + ps1] + SB[u2 + ps2] + SC[i] + SD[u4];
long long Ha = (u1 + ps1 + u2 + ps2 + i + u4) - M;
W -= Ha * Ans;
Minn = min(Minn, W);
}
if (Minn > 2000000000) {
printf("-1\n");
return 0;
}
printf("%lld\n", Minn);
for (long long i = 0; i <= N; i++) {
long long res = (max(K - i, 0ll)) * 2 + i;
if (res > M) continue;
if (res < 0) continue;
long long ps1 = max(K - i, 0ll), ps2 = max(K - i, 0ll), l = 0, r = 10000,
Ans = -1;
long long Res = M - res;
long long u1 = 0, u2 = 0, u4 = 0;
while (l <= r) {
long long mid = (l + r) >> 1;
long long X = max(QA(mid) - ps1, 0ll), Y = max(QB(mid) - ps2, 0ll),
Z = QD(mid);
if (X + Y + Z >= Res)
Ans = mid, u1 = X, u2 = Y, u4 = Z, r = mid - 1;
else
l = mid + 1;
}
if (Ans == -1) continue;
long long W = SA[u1 + ps1] + SB[u2 + ps2] + SC[i] + SD[u4];
long long Ha = (u1 + ps1 + u2 + ps2 + i + u4) - M;
W -= Ha * Ans;
if (Minn == W) {
long long tot1 = 0, tot2 = 0, tot3 = 0, tot4 = 0;
for (long long j = 1; j <= u1 + ps1; j++) {
if (A[j].first != Ans)
printf("%lld ", A[j].second), tot1++;
else
sta1[++sta1[0]] = A[j].second;
}
for (long long j = 1; j <= u2 + ps2; j++) {
if (B[j].first != Ans)
printf("%lld ", B[j].second), tot2++;
else
sta2[++sta2[0]] = B[j].second;
}
for (long long j = 1; j <= u4; j++) {
if (D[j].first != Ans)
printf("%lld ", D[j].second), tot4++;
else
sta4[++sta4[0]] = D[j].second;
}
for (long long j = 1; j <= i; j++) {
if (C[j].first != Ans)
printf("%lld ", C[j].second), tot3++;
else
sta3[++sta3[0]] = C[j].second;
}
long long E = M - tot1 - tot2 - tot3 - tot4, ps1 = 1, ps2 = 1, ps3 = 1,
ps4 = 1;
for (long long i = 1; i <= E; i++) {
if (tot1 < tot2 && ps1 <= sta1[0]) {
printf("%lld ", sta1[ps1]);
ps1++;
tot1++;
continue;
}
if (tot1 > tot2 && ps2 <= sta2[0]) {
printf("%lld ", sta2[ps2]);
ps2++;
tot2++;
continue;
}
if (ps3 <= sta3[0]) {
printf("%lld ", sta3[ps3]);
ps3++;
continue;
}
if (ps1 <= sta1[0]) {
printf("%lld ", sta1[ps1]);
ps1++;
continue;
}
if (ps2 <= sta2[0]) {
printf("%lld ", sta2[ps2]);
ps2++;
continue;
}
if (ps4 <= sta4[0]) {
printf("%lld ", sta4[ps4]);
ps4++;
continue;
}
}
printf("\n");
return 0;
}
}
return 0;
}
| 11 | CPP |
# https://codeforces.com/contest/1374/problem/E1
def min_time(tot_books, books_like, read_time, a_time, b_time):
time = []
temp_a = []
temp_b = []
if min(sum(a_time), sum(b_time)) >= books_like:
for x in range(tot_books):
if a_time[x] == b_time[x] == 1:
time.append(read_time[x])
elif a_time[x] == 0 and b_time[x] == 1:
temp_b.append(read_time[x])
elif a_time[x] == 1 and b_time[x] == 0:
temp_a.append(read_time[x])
temp_a.sort(), temp_b.sort()
for y in range(min(len(temp_a), len(temp_b))):
time.append(temp_a[y] + temp_b[y])
time.sort()
time = time[:books_like]
return sum(time)
else:
return -1
# if len(time) > books_like:
# time = time[books_like - 1::-1]
# elif len(time) < books_like:
# while len(time) != books_like:
# time.append(temp_a[0] + temp_b[0])
# del (temp_a[0], temp_b[0])
# time.sort(reverse=True)
# else:
# time.sort(reverse=True)
# y = 0
# while y != (min(len(temp_a), len(temp_b))):
# if time[y] > temp_a[y] + temp_b[y]:
# time[y] = temp_a[y] + temp_b[y]
# else:
# break
# y += 1
n, k = map(int, input().split())
t = []
a = []
b = []
for i in range(n):
x, y, z = map(int, input().split())
t.append(x), a.append(y), b.append(z)
print(min_time(n, k, t, a, b))
| 11 | PYTHON3 |
n,k=map(int,input().split())
l=[]
for i in range(n):
l.append(list(map(int,input().split())))
x,y,z=[],[],[]
for i in range(n):
if(l[i][1]==1 and l[i][2]==1):
x.append(l[i][0])
elif(l[i][1]==1 and l[i][2]==0):
y.append(l[i][0])
elif(l[i][1]==0 and l[i][2]==1):
z.append(l[i][0])
y.sort()
z.sort()
for i in range(min(len(y),len(z))):
x.append(y[i]+z[i])
x.sort()
if(len(x)<k):
print(-1)
else:
print(sum(x[:k]))
| 11 | PYTHON3 |
n,k = map(int,input().split())
alice = [0]
bob = [0]
common = [0]
la = 1
lb = 1
lc = 1
for i in range(n):
t,a,b = map(int,input().split())
if a==1 and b==1:
common.append(t)
lc+=1
elif a==1:
alice.append(t)
la+=1
elif b==1:
bob.append(t)
lb+=1
alice.sort()
bob.sort()
common.sort()
alicecum = []
bobcum = []
commoncum = []
tot = 0
for num in alice:
tot+=num
alicecum.append(tot)
tot = 0
for num in bob:
tot+=num
bobcum.append(tot)
tot = 0
for num in common:
tot+=num
commoncum.append(tot)
if la+lc-2<k or lb+lc-2<k:
print(-1)
else:
res = 100000000000055
for i in range(k+1):
com = k-i
al, bo = i, i
if com<lc and al<la and bo<lb:
temp = commoncum[com]
temp += alicecum[al]
temp += bobcum[bo]
res = min(res,temp)
print(res)
| 11 | PYTHON3 |
n,k = map(int,input().split())
ba = []
bb = []
bz = []
for n_ in range(n):
t,a,b = map(int,input().split())
if a==1 and b==1:
bz.append(t)
if a==1 and b==0:
ba.append(t)
if a==0 and b==1:
bb.append(t)
if len(ba)+len(bz)<k or len(bb)+len(bz)<k:
print(-1)
else:
ba.sort()
bb.sort()
i=0
while len(ba)>i and len(bb)>i:
bz.append(ba[i]+bb[i])
i+=1
bz.sort()
print(sum(bz[:k])) | 11 | PYTHON3 |
n,k = map(int, input().split())
t=[]
a=[]
b=[]
for i in range(n):
t1,a1,b1 = map(int, input().split())
if(a1==1 and b1==1):
t.append(t1)
elif(a1==1):
a.append(t1)
elif(b1==1):
b.append(t1)
a.sort()
b.sort()
k1=min(len(a),len(b))
for i in range(k1):
t.append(a[i]+b[i])
t.sort()
if(len(t)<k):
print("-1")
else:
print(sum(t[:k]))
| 11 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
void readtxt() {}
void fast() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
}
int32_t main() {
fast();
long long int n, k;
cin >> n >> k;
vector<long long int> a1b1, a1b0, a0b1;
long long int ans = 0, t, a, b;
for (long long int i = 0; i < n; i++) {
cin >> t >> a >> b;
if (a == 1 && b == 1)
a1b1.push_back(t);
else if (a == 1 && b == 0)
a1b0.push_back(t);
else if (a == 0 && b == 1)
a0b1.push_back(t);
}
sort(a1b1.begin(), a1b1.end());
sort(a1b0.begin(), a1b0.end());
sort(a0b1.begin(), a0b1.end());
auto it1 = a1b1.begin();
auto it2 = a1b0.begin();
auto it3 = a0b1.begin();
long long int flag = 1;
while (k--) {
if (it1 == a1b1.end() && (it2 == a1b0.end() || it3 == a0b1.end())) {
flag = 0;
cout << -1 << endl;
break;
} else if (it2 == a1b0.end() || it3 == a0b1.end()) {
ans += (*it1);
it1++;
} else if (it1 == a1b1.end()) {
ans += (*it2) + (*it3);
it2++;
it3++;
} else {
if ((*it1) <= (*it2) + (*it3)) {
ans += (*it1);
it1++;
} else {
ans += (*it2) + (*it3);
it2++;
it3++;
}
}
}
if (flag == 1) cout << ans << endl;
}
| 11 | CPP |
(n,k1) = map(int,input().split())
l_a,l_b,l_comb = [],[],[]
for _ in range(n):
(ra,a,b) = map(int,input().split())
if a==1 and b==1:
l_comb.append(ra)
elif a==1:
l_a.append(ra)
elif b==1:
l_b.append(ra)
# print(l_comb,l_a,l_b)
if len(l_comb)+len(l_a) < k1 or len(l_comb)+len(l_b) < k1:
print(-1)
else:
l_comb.sort()
l_a.sort()
l_b.sort()
ans = 0
i,j,k = 0,0,0
for _ in range(k1):
if i<len(l_comb) and j<len(l_a) and k<len(l_b) and l_comb[i] < l_a[j]+l_b[k]:
ans+=l_comb[i]
i+=1
else:
if j<len(l_a) and k<len(l_b):
ans+=(l_a[j]+l_b[k])
j+=1
k+=1
else:
ans+=l_comb[i]
i+=1
# print(ans)
print(ans)
| 11 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
const int inf = (int)1e9;
long long A(long long x) {
if (x >= 0)
return x;
else
return -x;
}
long long gcd(long long a, long long b) {
if (b > a) {
long long tmp = b;
b = a;
a = tmp;
}
if (a % b == 0)
return b;
else
return gcd(b, a % b);
}
unsigned long long popcount(unsigned long long x) {
x = ((x & 0xaaaaaaaaaaaaaaaaUL) >> 1) + (x & 0x5555555555555555UL);
x = ((x & 0xccccccccccccccccUL) >> 2) + (x & 0x3333333333333333UL);
x = ((x & 0xf0f0f0f0f0f0f0f0UL) >> 4) + (x & 0x0f0f0f0f0f0f0f0fUL);
x = ((x & 0xff00ff00ff00ff00UL) >> 8) + (x & 0x00ff00ff00ff00ffUL);
x = ((x & 0xffff0000ffff0000UL) >> 16) + (x & 0x0000ffff0000ffffUL);
x = ((x & 0xffffffff00000000UL) >> 32) + (x & 0x00000000ffffffffUL);
return x;
}
int main(void) {
int T;
T = 1;
for (int query = 0; query < T; query++) {
int n, k;
cin >> n >> k;
priority_queue<long long, vector<long long>, greater<long long> > both, bob,
alice;
for (int i = 0; i < n; i++) {
long long t;
int a, b;
cin >> t >> a >> b;
if (a == 1) {
if (b == 0)
alice.push(t);
else
both.push(t);
} else {
if (b == 1) bob.push(t);
}
}
if (alice.size() + both.size() < k || bob.size() + both.size() < k) {
cout << -1 << endl;
} else {
long long ans = 0;
while (k > 0) {
if (both.size() == 0) {
while (k > 0) {
long long ali = alice.top();
long long bo = bob.top();
alice.pop();
bob.pop();
ans += ali + bo;
k--;
}
} else {
if (alice.size() == 0) {
while (k > 0) {
long long c = both.top();
both.pop();
ans += c;
k--;
}
break;
}
if (bob.size() == 0) {
while (k > 0) {
long long c = both.top();
both.pop();
ans += c;
k--;
}
break;
}
long long a = alice.top();
long long b = bob.top();
long long c = both.top();
if (c > a + b) {
ans += a + b;
k--;
bob.pop();
alice.pop();
} else {
ans += c;
k--;
both.pop();
}
}
}
cout << ans << endl;
}
}
return 0;
}
| 11 | CPP |
#include <bits/stdc++.h>
using namespace std;
long long int const mod = 1000000007;
std::mt19937 rng(
(int)std::chrono::steady_clock::now().time_since_epoch().count());
int rand_rng(int l, int r) {
uniform_int_distribution<int> p(l, r);
return p(rng);
}
long long int power(long long int x, long long int y, long long int m) {
long long int temp;
if (y == 0) return 1;
temp = power(x, y / 2, m) % m;
if (y % 2 == 0)
return ((temp) * (temp)) % m;
else
return (((x) % m) * ((temp * temp) % m)) % m;
}
int const N = 200009;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int T;
T = 1;
while (T--) {
long long int n, m, k, t, a, b;
cin >> n >> m >> k;
set<pair<long long int, long long int> > fre, st;
vector<pair<long long int, long long int> > aa, bb, ab, zz;
for (int i = 0; i < (int)n; i++) {
cin >> t >> a >> b;
if (a && b) {
ab.push_back({t, i + 1});
} else if (a) {
aa.push_back({t, i + 1});
} else if (b) {
bb.push_back({t, i + 1});
} else {
fre.insert({t, i + 1});
zz.push_back({t, i + 1});
}
}
sort(aa.begin(), aa.end());
;
sort(bb.begin(), bb.end());
;
sort(ab.begin(), ab.end());
;
sort(zz.begin(), zz.end());
;
int ind = -1;
long long int sum = 0;
long long int ans = 100000000000000000;
long long int tempsum = 0;
long long int out = 0;
for (int i = 0; i <= ab.size(); i++) {
long long int temp = k - i;
if (i > m) break;
if (i) {
sum += ab[i - 1].first;
}
if (aa.size() >= temp && bb.size() >= temp && i + 2 * temp <= m &&
n - (ab.size() - i) >= m) {
if (ind == -1) {
for (int j = 0; j < (int)temp; j++) sum += aa[j].first + bb[j].first;
for (int j = max(0ll, temp); j < aa.size(); j++) fre.insert(aa[j]);
for (int j = max(0ll, temp); j < bb.size(); j++) fre.insert(bb[j]);
ind = i;
temp = max(0ll, temp);
long long int dif = m - i - 2 * temp;
while (st.size() < dif && fre.size()) {
tempsum += (fre.begin())->first;
st.insert(*(fre.begin()));
fre.erase(*(fre.begin()));
}
ans = min(ans, sum + tempsum);
out = i;
} else {
if (temp >= 0) sum -= aa[temp].first + bb[temp].first;
if (temp >= 0) {
fre.insert(aa[temp]);
fre.insert(bb[temp]);
}
temp = max(0ll, temp);
long long int dif = m - i - 2 * temp;
while (st.size() && st.size() > dif) {
tempsum -= (st.rbegin())->first;
fre.insert(*(st.rbegin()));
st.erase(*(st.rbegin()));
}
while (st.size() < dif && fre.size()) {
tempsum += (fre.begin())->first;
st.insert(*(fre.begin()));
fre.erase(*(fre.begin()));
}
while (st.size() && fre.size() && *(st.rbegin()) > *(fre.begin())) {
st.insert(*(fre.begin()));
tempsum += (fre.begin())->first;
fre.erase(*(fre.begin()));
fre.insert(*(st.rbegin()));
tempsum -= (st.rbegin())->first;
st.erase(*(st.rbegin()));
}
if (sum + tempsum < ans) out = i;
ans = min(ans, sum + tempsum);
}
}
}
if (ind == -1) {
cout << "-1\n";
} else {
ans = 0;
vector<long long int> p;
long long int temp = k - out;
for (int i = 0; i < (int)out; i++) {
p.push_back(ab[i].second);
ans += ab[i].first;
}
for (int i = 0; i < (int)temp; i++) {
p.push_back(aa[i].second);
ans += aa[i].first;
}
for (int i = 0; i < (int)temp; i++) {
p.push_back(bb[i].second);
ans += bb[i].first;
}
fre.clear();
for (int x = out; x < ab.size(); x++) fre.insert(ab[x]);
for (auto i : zz) fre.insert(i);
temp = max(0ll, temp);
for (int i = temp; i < aa.size(); i++) fre.insert(aa[i]);
for (int i = temp; i < bb.size(); i++) fre.insert(bb[i]);
long long int dif = m - out - 2 * temp;
while (dif > 0) {
dif--;
p.push_back((fre.begin())->second);
ans += (fre.begin())->first;
fre.erase(*(fre.begin()));
}
cout << ans << "\n";
for (auto j : p) cout << j << " ";
}
}
}
| 11 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int INF = 2e9 + 1;
void updateSt(set<pair<int, int>> &st, set<pair<int, int>> &fr, int &sum,
int need) {
need = max(need, 0);
while (true) {
bool useful = false;
while (int((st).size()) > need) {
sum -= st.rbegin()->first;
fr.insert(*st.rbegin());
st.erase(prev(st.end()));
useful = true;
}
while (int((st).size()) < need && int((fr).size()) > 0) {
sum += fr.begin()->first;
st.insert(*fr.begin());
fr.erase(fr.begin());
useful = true;
}
while (!st.empty() && !fr.empty() &&
fr.begin()->first < st.rbegin()->first) {
sum -= st.rbegin()->first;
sum += fr.begin()->first;
fr.insert(*st.rbegin());
st.erase(prev(st.end()));
st.insert(*fr.begin());
fr.erase(fr.begin());
useful = true;
}
if (!useful) break;
}
}
int main() {
int n, m, k;
cin >> n >> m >> k;
vector<pair<int, int>> times[4];
vector<int> sums[4];
for (int i = 0; i < n; ++i) {
int t, a, b;
cin >> t >> a >> b;
times[a * 2 + b].push_back({t, i});
}
for (int i = 0; i < 4; ++i) {
sort(times[i].begin(), times[i].end());
sums[i].push_back(0);
for (auto it : times[i]) {
sums[i].push_back(sums[i].back() + it.first);
}
}
int ans = INF;
int pos = INF;
set<pair<int, int>> st;
set<pair<int, int>> fr;
int sum = 0;
vector<int> res;
for (int iter = 0; iter < 2; ++iter) {
st.clear();
fr.clear();
sum = 0;
int start = 0;
while (k - start >= int((sums[1]).size()) ||
k - start >= int((sums[2]).size()) ||
m - start - (k - start) * 2 < 0) {
++start;
}
if (start >= int((sums[3]).size())) {
cout << -1 << endl;
return 0;
}
int need = m - start - (k - start) * 2;
for (int i = 0; i < 3; ++i) {
for (int p = int((times[i]).size()) - 1; p >= (i == 0 ? 0 : k - start);
--p) {
fr.insert(times[i][p]);
}
}
updateSt(st, fr, sum, need);
for (int cnt = start; cnt < (iter == 0 ? int((sums[3]).size()) : pos);
++cnt) {
if (k - cnt >= 0) {
if (cnt + (k - cnt) * 2 + int((st).size()) == m) {
if (ans > sums[3][cnt] + sums[1][k - cnt] + sums[2][k - cnt] + sum) {
ans = sums[3][cnt] + sums[1][k - cnt] + sums[2][k - cnt] + sum;
pos = cnt + 1;
}
}
} else {
if (cnt + int((st).size()) == m) {
if (ans > sums[3][cnt] + sum) {
ans = sums[3][cnt] + sum;
pos = cnt + 1;
}
}
}
if (iter == 1 && cnt + 1 == pos) break;
need -= 1;
if (k - cnt > 0) {
need += 2;
fr.insert(times[1][k - cnt - 1]);
fr.insert(times[2][k - cnt - 1]);
}
updateSt(st, fr, sum, need);
}
if (iter == 1) {
for (int i = 0; i + 1 < pos; ++i) res.push_back(times[3][i].second);
for (int i = 0; i <= k - pos; ++i) {
res.push_back(times[1][i].second);
res.push_back(times[2][i].second);
}
for (auto [value, position] : st) res.push_back(position);
}
}
cout << ans << endl;
for (auto it : res) cout << it + 1 << " ";
cout << endl;
return 0;
}
| 11 | CPP |
#include <bits/stdc++.h>
using namespace std;
const unsigned long long int INF = numeric_limits<int>::max();
long long int k, n, A, B, T;
unsigned long long int ab[200005], a[200005], b[200005];
int main() {
std::ios_base::sync_with_stdio(false);
cin.tie(nullptr);
cout.tie(nullptr);
;
cin >> n >> k;
int I = 0, J = 0, K = 0;
for (int i = 0; i < n; i++) {
cin >> T >> A >> B;
if (A == 1 && B == 1)
ab[I] = T, I++;
else if (A == 1)
a[J] = T, J++;
else if (B == 1)
b[K] = T, K++;
}
sort(ab, ab + I);
sort(b, b + K);
sort(a, a + J);
if (J + I < k || K + I < k) {
cout << -1 << "\n";
return 0;
}
if (I == 0) ab[0] = INF;
if (J == 0) a[0] = INF;
if (K == 0) b[0] = INF;
for (int i = 1; i < n; i++) {
if (i < J)
a[i] += a[i - 1];
else
a[i] = INF;
if (i < K)
b[i] += b[i - 1];
else
b[i] = INF;
if (i < I)
ab[i] += ab[i - 1];
else
ab[i] = INF;
}
unsigned long long int ans = min(ab[k - 1], a[k - 1] + b[k - 1]);
for (int i = 0; i < (k - 1); i++) {
ans = min(ans, ab[k - i - 2] + a[i] + b[i]);
}
cout << ans << "\n";
return 0;
}
| 11 | CPP |
n, k = map(int, input().split())
alice, bob = [], []
both = []
for _ in range(n):
x = list(map(int, input().split()))
if x[2] == 1 and x[1] == 1:
both.append(x[0])
elif x[1]:
alice.append(x)
elif x[2]:
bob.append(x)
alice.sort(key=lambda x: x[0])
bob.sort(key=lambda x: x[0])
both.sort()
tgt = []
for i in range(min(len(alice), len(bob))):
tgt.append(alice[i][0]+bob[i][0])
p1, p2 = 0, 0
count = 0
ans = 0
if len(tgt) + len(both) < k:
print(-1)
else:
while count < k:
if p2 == len(both) or (p1 < len(tgt) and tgt[p1] <= both[p2]):
ans += tgt[p1]
p1 += 1
else:
ans += both[p2]
p2 += 1
count += 1
print(ans)
| 11 | PYTHON3 |
n,k=[int(k) for k in input().split()]
tog=[]
ali=[]
bli=[]
time=0
size=0
for i in range(n):
t,a,b=[int(k) for k in input().split()]
if a&b==1:
tog.append(t)
else:
if a==1:
ali.append(t)
if b==1:
bli.append(t)
asi=len(tog)+len(ali)
bsi=len(tog)+len(bli)
if k>min(asi,bsi):
print(-1)
else:
ali.sort()
bli.sort()
for i in range(min(len(ali),len(bli))):
tog.append(ali[i]+bli[i])
tog.sort()
for i in range(k):
time+=tog[i]
print(time)
| 11 | PYTHON3 |
n,k=list(map(int,input().rstrip().split()))
t=[]
ta=[]
tb=[]
common=0
cm={}
for i in range(n):
a=list(map(int,input().rstrip().split()))
if a[1]==1 & a[2]==1:
t.append(a[0])
else:
if a[1]==1:
ta.append(a[0])
if a[2]==1:
tb.append(a[0])
if len(ta)<k-len(t) or len(tb)<k-len(t):
print(-1)
else:
ta.sort()
tb.sort()
t.sort()
s=[]
for i in range(min(len(ta),len(tb))):
s.append(ta[i]+tb[i])
l=t[:k]+s[:k]
l.sort()
print(sum(l[:k]))
| 11 | PYTHON3 |
n,k = map(int, input().split())
a,b,ab = [],[],[]
for _ in range(n):
t,x,y = map(int, input().split())
if x + y == 2:
ab.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))):
ab.append(a[i]+b[i])
ab.sort()
if len(ab) < k:
print(-1)
else:
sum = 0
for i in range(k):
sum += ab[i]
print(sum) | 11 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
priority_queue<pair<int64_t, int64_t>, vector<pair<int64_t, int64_t>>,
greater<pair<int64_t, int64_t>>>
a, b, c, d;
priority_queue<pair<int64_t, int64_t>> both;
vector<int64_t> ans;
vector<pair<int64_t, pair<int64_t, int64_t>>> prblm;
map<int64_t, bool> ok;
int64_t n, m, k, t;
void print() {
cout << t << '\n';
unordered_set<int64_t> s;
for (auto j : ans)
if (!ok[j]) s.insert(j + 1);
for (auto j : s) cout << j << ' ';
}
void m_greater() {
int64_t x, y, z, w, u, cnt;
cnt = ans.size();
while (cnt < m) {
if (a.size())
x = a.top().first;
else
x = LLONG_MAX;
if (b.size())
y = b.top().first;
else
y = LLONG_MAX;
if (c.size())
z = c.top().first;
else
z = LLONG_MAX;
if (d.size())
w = d.top().first;
else
w = LLONG_MAX;
if (both.size())
u = both.top().first;
else
u = LLONG_MAX;
if (min({x, y, z, w}) == LLONG_MAX) {
cout << "-1" << '\n';
return;
}
if (a.size() and b.size() and both.size() and
x + y <= u + min({x, y, z, w})) {
int64_t val = a.top().second;
t -= u;
t += x + y;
ans.push_back((val));
ans.push_back(b.top().second);
int64_t q = both.top().second;
ok[q] = true;
a.pop();
b.pop();
c.push(both.top());
both.pop();
} else if (min({x, y, z, w}) == x) {
t += x;
ans.push_back(a.top().second);
a.pop();
} else if (min({x, y, z, w}) == y) {
t += y;
ans.push_back(b.top().second);
b.pop();
} else if (min({x, y, z, w}) == w) {
t += w;
ans.push_back(d.top().second);
d.pop();
} else if (min({x, y, z, w}) == z) {
t += z;
ans.push_back(c.top().second);
if (ok[ans.back()]) ok[ans.back()] = false;
c.pop();
}
cnt++;
}
print();
}
void m_less() {
int64_t x, y, cnt;
cnt = 0;
sort(prblm.begin(), prblm.end());
cnt = ans.size();
while (cnt > m) {
if (c.size() == 0 or prblm.size() == 0) break;
int64_t val = prblm.back().first;
x = prblm.back().second.first;
y = prblm.back().second.second;
prblm.pop_back();
ok[x] = true;
ok[y] = true;
t -= val;
t += c.top().first;
ans.push_back(c.top().second);
c.pop();
cnt--;
}
if (cnt > m) {
cout << "-1";
return;
}
print();
}
void solve() {
int64_t i, x, y, z, cnt;
cin >> n >> m >> k;
for (i = 0; i < n; i++) {
cin >> t >> x >> y;
if (x == y and x == 1)
c.push({t, i});
else if (x == 1 and y == 0)
a.push({t, i});
else if (x == 0 and y == 1)
b.push({t, i});
else
d.push({t, i});
}
t = 0;
cnt = 0;
while (1) {
if (cnt >= k) break;
if (c.size() == 0 and (a.size() == 0 or b.size() == 0)) break;
if (a.size())
x = a.top().first;
else
x = LLONG_MAX;
if (b.size())
y = b.top().first;
else
y = LLONG_MAX;
if (c.size())
z = c.top().first;
else
z = LLONG_MAX;
if (a.size() > 0 and b.size() > 0 and x + y <= z) {
t += x + y;
ans.push_back(a.top().second);
ans.push_back(b.top().second);
prblm.push_back({x + y, {a.top().second, b.top().second}});
a.pop();
b.pop();
cnt++;
} else {
t += z;
ans.push_back(c.top().second);
both.push({z, c.top().second});
c.pop();
cnt++;
}
}
if (cnt < k) {
cout << "-1" << '\n';
return;
}
if (ans.size() > m) {
m_less();
return;
} else {
m_greater();
return;
}
}
signed main() {
std::ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
{ solve(); }
cerr << " Execution : " << (1.0 * clock()) / CLOCKS_PER_SEC << "s \n";
return 0;
}
| 11 | CPP |
from sys import stdin
n,k=map(int,input().split())
x=[]
y=[]
z=[]
k1=0
k2=0
for i in range(n):
t,a,b=map(int,stdin.readline().split())
if(a==1 and b==1):
x.append(t)
k1+=1
k2+=1
else:
if(a==1):
k1+=1
y.append(t)
elif(b==1):
k2+=1
z.append(t)
if(k1<k or k2<k):
print(-1)
else:
x.sort()
y.sort()
z.sort()
ans=0
k1=0
k2=0
p1=0
p2=0
p3=0
lx=len(x)
ly=len(y)
lz=len(z)
for i in range(k):
if(p1>=lx):
ans+=y[p2]+z[p3]
p2+=1
p3+=1
elif(p2>=ly or p3>=lz):
ans+=x[p1]
p1+=1
else:
if(x[p1]<=y[p2]+z[p3]):
ans+=x[p1]
p1+=1
else:
ans+=y[p2]+z[p3]
p2+=1
p3+=1
print(ans) | 11 | PYTHON3 |
#!/usr/bin/env python
import os
import sys
from io import BytesIO, IOBase
def main():
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])
if len(z) < k:
print(-1)
else:
print(sum(sorted(z)[:k]))
# 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")
# endregion
if __name__ == "__main__":
main()
| 11 | PYTHON3 |
import heapq
n,k=map(int,input().split())
both=[]
alice=[]
bob=[]
for i in range(n):
t,a,b=map(int,input().split())
if a==1 and b==1:
both.append(t)
elif a==1 and b==0:
alice.append(t)
elif a==0 and b==1:
bob.append(t)
heapq.heapify(both)
heapq.heapify(alice)
heapq.heapify(bob)
at,bt,count=0,0,0
while len(both)>0 and len(alice)>0 and len(bob)>0 and at<k and bt<k:
x=heapq.heappop(both)
y=heapq.heappop(alice)
z=heapq.heappop(bob)
if x<(y+z):
at+=1
bt+=1
count+=x
heapq.heappush(alice,y)
heapq.heappush(bob,z)
else:
at+=1
bt+=1
count+=(y+z)
heapq.heappush(both,x)
if len(both)>0 and (len(alice)==0 or len(bob)==0) and at<k and bt<k:
while len(both)>0 and at<k and bt<k:
x=heapq.heappop(both)
at+=1
bt+=1
count+=x
elif len(both)==0 and len(alice)>0 and len(bob)>0 and at<k and bt<k:
while len(alice)>0 and len(bob)>0 and at<k and bt<k:
x=heapq.heappop(alice)
y=heapq.heappop(bob)
at+=1
bt+=1
count+=(x+y)
if at!=k or bt!=k:
print(-1)
else:
print(count) | 11 | PYTHON3 |
n, k = [int(i) for i in input().split()]
books = [[int(i) for i in input().split()] for i in range(n)]
#b00 = []
b01 = []
b10 = []
b11 = []
b00c, b01c, b10c, b11c = 0,0,0,0
index = 0
for book in books:
if book[1] == 1:
if book[2] == 1:
b11.append(book[0])
else:
b10.append(book[0])
else:
if book[2] == 1:
b01.append(book[0])
b11.sort(), b10.sort(), b01.sort()
b0_index = 0
b1_index = 0
time = 0
if len(b11) > 0:
b1Out = False
else:
b1Out = True
if len(b01) > 0 and len(b10) > 0:
b0Out = False
else:
b0Out = True
while b0_index + b1_index < k:
if not any([b1Out, b0Out]):
if b11[b1_index] < b01[b0_index] + b10[b0_index]:
time += b11[b1_index]
b1_index += 1
if b1_index > len(b11) - 1:
b1Out = True
else:
time += b01[b0_index] + b10[b0_index]
b0_index += 1
if b0_index > len(b01) - 1 or b0_index > len(b10) - 1:
b0Out = True
else:
if b1Out and b0Out:
time = -1
break
else:
if b1Out:
time += b01[b0_index] + b10[b0_index]
b0_index += 1
if b0_index == len(b01) or b0_index == len(b10):
b0Out = True
else:
time += b11[b1_index]
b1_index += 1
if b1_index == len(b11):
b1Out = True
print(time)
| 11 | PYTHON3 |
import bisect
import collections
import copy
import functools
import heapq
import itertools
import math
import random
import re
import sys
import time
import string
from typing import *
sys.setrecursionlimit(99999)
n, k = map(int, input().split())
booksa, booksb, booksc = [], [], []
for _ in range(n):
t, a, b = map(int, input().split())
if a == 0 and b == 1:
booksb.append(t)
if a == 1 and b == 0:
booksa.append(t)
if a == 1 and b == 1:
booksc.append(t)
booksa.sort()
booksb.sort()
booksc.sort()
booksa = booksa[:k]
booksb = booksb[:k]
na = len(booksa)
nb = len(booksb)
s = sum(booksa) + sum(booksb)
cj = 0
while na < k or nb < k:
if cj == len(booksc):
break
s += booksc[cj]
cj += 1
na += 1
nb += 1
while na > k and booksa:
s -= booksa.pop()
na -= 1
while nb > k and booksb:
s -= booksb.pop()
nb -= 1
while cj < len(booksc) and (booksa or booksb) and na >= k and nb >= k:
sc = booksc[cj]
cj += 1
sa = 0
sb = 0
if booksa:
sa = booksa.pop()
if booksb:
sb = booksb.pop()
if sa + sb > sc:
s += sc
s -= sa
s -= sb
else:
break
if na == k and nb == k:
print(s)
else:
print(-1) | 11 | PYTHON3 |
from collections import deque
n, k = list(map(int, input().split()))
both_ls = []
a_ls = []
b_ls = []
for i in range(n):
t, a, b = list(map(int, input().split()))
if a == 1 and b == 0:
a_ls.append(t)
elif a == 0 and b == 1:
b_ls.append(t)
elif a == 1 and b == 1:
both_ls.append(t)
a_ls = sorted(a_ls)
b_ls = sorted(b_ls)
both_ls = sorted(both_ls)
a_ls = deque(a_ls)
b_ls = deque(b_ls)
both_ls = deque(both_ls)
res = 0
broke = False
for i in range(k):
if len(both_ls)>0 and len(a_ls)>0 and len(b_ls)>0:
if both_ls[0] >= (a_ls[0] + b_ls[0]):
res += a_ls.popleft()
res += b_ls.popleft()
else:
res += both_ls.popleft()
elif len(both_ls)>0:
res += both_ls.popleft()
elif len(a_ls)>0 and len(b_ls)>0:
res += a_ls.popleft()
res += b_ls.popleft()
else:
print(-1)
broke = True
break
if not broke:
print(res) | 11 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
#pragma GCC optimize("Ofast,no-stack-protector")
#pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,tune=native")
#pragma GCC optimize("unroll-loops")
template <class T>
inline T bigMod(T p, T e, T M) {
T ret = 1;
for (; e > 0; e >>= 1) {
if (e & 1) ret = (ret * p) % M;
p = (p * p) % M;
}
return (T)ret;
}
template <class T>
inline T modInverse(T a, T M) {
return bigMod(a, M - 2, M);
}
template <class T>
inline T gcd(T a, T b) {
if (b == 0) return a;
return gcd(b, a % b);
}
template <class T>
inline T lcm(T a, T b) {
a = abs(a);
b = abs(b);
return (a / gcd(a, b)) * b;
}
template <class T>
inline string int2String(T a) {
ostringstream str;
str << a;
return str.str();
}
int main() {
int n, k;
scanf("%d%d", &n, &k);
vector<vector<int> > v(4);
int t, a, b;
for (int i = int(0); i < int(n); i++) {
scanf("%d%d%d", &t, &a, &b);
v[(a << 1) | b].push_back(t);
}
if (v[1].size() + v[3].size() < k || v[2].size() + v[3].size() < k) {
puts("-1");
return 0;
}
for (int i = int(0); i < int(4); i++) sort(v[i].rbegin(), v[i].rend());
long long ans = 0;
for (int _ = int(0); _ < int(k); _++) {
if (v[3].size() && v[1].size() && v[2].size()) {
if (v[3].back() <= v[1].back() + v[2].back()) {
ans += v[3].back();
v[3].pop_back();
} else {
ans += v[1].back();
v[1].pop_back();
ans += v[2].back();
v[2].pop_back();
}
} else if (v[3].size()) {
ans += v[3].back();
v[3].pop_back();
} else {
ans += v[1].back();
v[1].pop_back();
ans += v[2].back();
v[2].pop_back();
}
}
printf("%lld\n", ans);
return 0;
}
| 11 | CPP |
import os
import sys
from io import BytesIO, IOBase
def main():
n,k=map(int,input().split())
alice=[]
bob=[]
both=[]
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)
if len(alice)+len(both)<k or len(bob)+len(both)<k:
print(-1)
else:
alice.sort()
bob.sort()
both.sort()
i=j=0
ans=0
while i<len(alice) and i<len(bob) and j<len(both) and k>0:
if(alice[i]+bob[i]<both[j]):
ans+=alice[i]+bob[i]
i+=1
else:
ans+=both[j]
j+=1
k-=1
if(k):
if(j>=len(both)):
while k>0:
ans+=alice[i]+bob[i]
i+=1
k-=1
else:
while k>0:
ans+=both[j]
j+=1
k-=1
print(ans)
# 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")
# endregion
if __name__ == "__main__":
main() | 11 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int test = 1;
while (test--) {
int m, k, i;
cin >> m >> k;
int arr[3][m];
for (i = 0; i < m; i++) cin >> arr[0][i] >> arr[1][i] >> arr[2][i];
vector<int> a;
vector<int> b;
vector<int> c;
for (i = 0; i < m; i++) {
if (arr[1][i] == 1 && arr[2][i] == 1)
c.push_back(arr[0][i]);
else if (arr[1][i] == 1 && arr[2][i] == 0)
a.push_back(arr[0][i]);
else if (arr[1][i] == 0 && arr[2][i] == 1)
b.push_back(arr[0][i]);
}
sort(a.begin(), a.end());
sort(b.begin(), b.end());
sort(c.begin(), c.end());
int idx_a = 0, idx_b = 0, idx_c = 0, total = 0, ans = 0;
while (total < k) {
if (idx_a == a.size() || idx_b == b.size()) {
for (; idx_c < c.size(); idx_c++) {
if (total == k) break;
total++;
ans += c[idx_c];
}
break;
} else if (idx_c == c.size()) {
for (; idx_a < a.size() && idx_b < b.size(); idx_a++) {
if (total == k) break;
total++;
ans += a[idx_a] + b[idx_b];
idx_b++;
}
break;
} else {
if (a[idx_a] + b[idx_b] <= c[idx_c]) {
ans += a[idx_a] + b[idx_b];
total++;
idx_a++;
idx_b++;
} else {
ans += c[idx_c];
idx_c++;
total++;
}
}
}
if (total < k)
cout << "-1";
else
cout << ans;
cout << "\n";
}
return 0;
}
| 11 | CPP |
n, k = map(int, input().split())
l1 = []
l2 = []
l3 = []
n1 = n2 = n3 = 0
for i in range (n):
a, b, c = map(int, input().split())
if b == c == 1:
l1.append(a)
n1 += 1
elif b == 1:
l2.append(a)
n2 += 1
elif c == 1:
l3.append(a)
n3 += 1
if n1 + n2 < k or n1 + n3 < k:
print(-1)
else:
l1.sort()
l2.sort()
l3.sort()
s1 = s2 = s = 0
p = min(n2, n3)
z1 = []
for i in range (p):
s1 += l2[i]
s1 += l3[i]
z1.append(s1)
s1 = 0
z2 = z1 + l1
z2.sort()
if len(z2) < k:
print(-1)
else:
for i in range (k):
s += z2[i]
print(s) | 11 | PYTHON3 |
#!/usr/bin/env python
import os
import operator
from collections import defaultdict
import sys
from io import BytesIO, IOBase
import bisect
# def power(x, p):
# res = 1
# while p:
# if p & 1:
# res = res * x % 1000000007
# x = x * x % 1000000007
# p >>= 1
# return res;
def main():
n,el=map(int,input().split())
oo=[]
zo=[]
oz=[]
for i in range(n):
t,a,b=map(int,input().split())
if a==b==1:
oo.append(t)
elif a==1 and b==0:
oz.append(t)
elif a==0 and b==1:
zo.append(t)
oo.sort()
zo.sort()
oz.sort()
alice=0
bob=0
i=0
j=0
k=0
ans=0
while True:
if alice>=el and bob>=el:
break
if i < len(oo) and j < len(oz) and k < len(zo):
if oo[i] < (oz[j] + zo[k]):
ans += oo[i]
alice += 1
bob += 1
i += 1
else:
ans += oz[j] + zo[k]
alice += 1
bob += 1
j += 1
k += 1
elif i < len(oo):
ans += oo[i]
alice += 1
bob += 1
i += 1
elif j < len(oz) and k < len(zo):
ans += oz[j] + zo[k]
alice += 1
bob += 1
j += 1
k += 1
else:
break
if alice >= el and bob >= el:
print(ans)
else:
print(-1)
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")
if __name__ == "__main__":
main() | 11 | PYTHON3 |
n,k = map(int,input().split())
a = []
b = []
ab = []
for _ in range(n):
t,x,y = map(int,input().split())
if x == 1 and y == 1:
ab.append(t)
elif x == 1 and y == 0:
a.append(t)
elif x == 0 and y == 1:
b.append(t)
if len(ab) + len(a) < k or len(ab) + len(b) < k:
print(-1)
else:
a.sort()
a.append(float('inf'))
b.sort()
b.append(float('inf'))
ab.sort()
ab.append(float('inf'))
tm = 0
ia = 0
ib = 0
iab = 0
books = 0
while books < k:
if ab[iab] <= a[ia] + b[ib]:
tm += ab[iab]
iab+= 1
else:
tm += a[ia] + b[ib]
ia += 1
ib += 1
books += 1
print(tm) | 11 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
const int maxm = 2e3 + 23;
const int maxn = 2e5 + 35;
int n, k, t[maxn], vis[maxn], a, b, num, m;
vector<int> ve[4], ee;
vector<pair<int, int> > we;
bool cmp(int i, int j) { return t[i] < t[j]; }
struct node {
int ii, tt;
friend bool operator<(node a, node b) { return a.tt > b.tt; }
};
int main() {
scanf("%d %d %d", &n, &m, &k);
priority_queue<node> se;
for (int i = 1; i <= n; ++i) {
scanf("%d %d %d", t + i, &a, &b);
if (a && b)
ve[2].push_back(i);
else if (a)
ve[0].push_back(i);
else if (b)
ve[1].push_back(i);
else
se.push((node){i, t[i]});
}
sort((ve[0]).begin(), (ve[0]).end(), cmp);
sort((ve[1]).begin(), (ve[1]).end(), cmp);
sort((ve[2]).begin(), (ve[2]).end(), cmp);
int x0 = 0, x1 = 0, x2 = 0, ans = 0;
set<int> s;
while (k) {
if (x1 < (int)(ve[1]).size() && x0 < (int)(ve[0]).size()) {
if (x2 < (int)(ve[2]).size()) {
if (t[ve[2][x2]] < t[ve[0][x0]] + t[ve[1][x1]]) {
ans += t[ve[2][x2]];
s.insert(ve[2][x2]);
ee.push_back(ve[2][x2]);
k -= 1;
x2 += 1;
num += 1;
} else {
ans += t[ve[0][x0]] + t[ve[1][x1]];
s.insert(ve[0][x0]);
s.insert(ve[1][x1]);
we.push_back(pair<int, int>(ve[0][x0], ve[1][x1]));
k -= 1;
x0 += 1;
x1 += 1;
num += 2;
}
} else {
ans += t[ve[0][x0]] + t[ve[1][x1]];
we.push_back(pair<int, int>(ve[0][x0], ve[1][x1]));
s.insert(ve[0][x0]);
s.insert(ve[1][x1]);
k -= 1;
x0 += 1;
x1 += 1;
num += 2;
}
} else if (x2 < (int)(ve[2]).size()) {
ans += t[ve[2][x2]];
s.insert(ve[2][x2]);
ee.push_back(ve[2][x2]);
k -= 1;
x2 += 1;
num += 1;
} else
break;
}
if (k > 0) return puts("-1"), 0;
if (num < m) {
for (int i = x0; i < (int)(ve[0]).size(); ++i)
se.push((node){ve[0][i], t[ve[0][i]]});
for (int i = x1; i < (int)(ve[1]).size(); ++i)
se.push((node){ve[1][i], t[ve[1][i]]});
for (int i = x2; i < (int)(ve[2]).size(); ++i)
se.push((node){ve[2][i], t[ve[2][i]]});
int first = (int)(ee).size() - 1;
while (num < m && x0 < (int)(ve[0]).size() && x1 < (int)(ve[1]).size() &&
first >= 0 && (int)(se).size() > 0) {
while (vis[se.top().ii]) se.pop();
if ((int)(se).size() == 0) break;
if (t[ee[first]] + (se.top()).tt < t[ve[0][x0]] + t[ve[1][x1]]) {
ans += (se.top()).tt;
vis[(se.top()).ii] = 1;
s.insert((se.top()).ii);
se.pop();
num += 1;
} else {
ans += t[ve[0][x0]] + t[ve[1][x1]];
ans -= t[ee[first]];
vis[ve[0][x0]] = 1;
vis[ve[1][x1]] = 1;
se.push((node){ee[first], t[ee[first]]});
s.insert(ve[0][x0]);
s.insert(ve[1][x1]);
s.erase(ee[first]);
first -= 1;
x0 += 1;
x1 += 1;
num += 1;
}
while (vis[ve[0][x0]]) x0 += 1;
while (vis[ve[1][x1]]) x1 += 1;
}
while (num < m && !se.empty()) {
ans += se.top().tt;
s.insert(se.top().ii);
se.pop();
num += 1;
}
} else {
int first = (int)(we).size() - 1;
while (num > m && x2 < (int)(ve[2]).size()) {
s.erase(we[first].first);
s.erase(we[first].second);
ans = ans - t[we[first].first] - t[we[first].second];
first -= 1;
s.insert(ve[2][x2]);
ans += t[ve[2][x2]];
x2 += 1;
num -= 1;
}
}
if ((int)(s).size() == m) {
printf("%d\n", ans);
for (set<int>::iterator it = s.begin(); it != s.end(); ++it)
printf("%d ", *it);
} else
puts("-1");
return 0;
}
| 11 | CPP |
n,k=map(int,input().split())
l=[]
al=[]
bl=[]
ac=bc=0
for i in range(n):
t,a,b=map(int,input().split())
if a==1 and b==1:
l.append(t)
ac+=1
bc+=1
elif a==1:
al.append(t)
ac+=1
elif b==1:
bl.append(t)
bc+=1
if ac<k or bc<k:
print('-1')
else:
al.sort()
bl.sort()
i=0
while i<len(al) and i<len(bl):
l.append(al[i]+bl[i])
i+=1
l.sort()
time=0
for i in range(k):
time+=l[i]
print(time)
| 11 | PYTHON3 |
n,k = [int(i) for i in input().split()]
l = []
for i in range(n):
x = [int(i) for i in input().split()]
l.append(x)
l.sort(key = lambda x:x[0])
#print(l)
from heapq import heappop,heappush
a = []
b = []
ans = 0
ak = 0
bk = 0
i = 0
while i<n and (ak<k or bk<k):
ans+=l[i][0]
if l[i][1] == l[i][2] == 1:
ak+=1
bk+=1
elif l[i][1] == 1:
ak+=1
heappush(a,(-1*l[i][0]))
elif l[i][2] == 1:
bk+=1
heappush(b,(-1*l[i][0]))
else:
ans-=l[i][0]
i+=1
#print(ak,bk)
if ak>k :
while ak>k and a:
ans+=heappop(a)
ak-=1
if bk>k :
while bk> k and b:
ans+=heappop(b)
bk-=1
if i == n and (ak<k or bk<k):
print(-1)
elif i == n or not(a or b):
print(ans)
else:
while i<n and (a and b):
if l[i][1] == l[i][2] == 1:
x =-1*heappop(a)
y = -1*heappop(b)
if x+y>=l[i][0]:
ans-=(x+y-l[i][0])
else:
break
i+=1
print(ans)
i+=1 | 11 | PYTHON3 |
import atexit
import io
import sys
import math
from collections import defaultdict,Counter
_INPUT_LINES = sys.stdin.read().splitlines()
input = iter(_INPUT_LINES).__next__
_OUTPUT_BUFFER = io.StringIO()
sys.stdout = _OUTPUT_BUFFER
@atexit.register
def write():
sys.__stdout__.write(_OUTPUT_BUFFER.getvalue())
# sys.stdout=open("CP3/output.txt",'w')
# sys.stdin=open("CP3/input.txt",'r')
# m=pow(10,9)+7
n,k=map(int,input().split())
c1=0
c2=0
l1=[]
l2=[]
l=[]
# visit=[0]*n
for i in range(n):
t,a,b=map(int,input().split())
c1+=a
c2+=b
if a+b==2:
l.append(t)
continue
if a==1:
l1.append(t)
if b==1:
l2.append(t)
# visit[i]=1
if c1<k or c2<k:
print(-1)
else:
l1.sort()
l2.sort()
l+=[a+b for a,b in zip(l1,l2)]
# print(l)
l.sort()
print(sum(l[:k]))
| 11 | PYTHON3 |
import sys, os, io
def rs(): return sys.stdin.readline().rstrip()
def ri(): return int(sys.stdin.readline())
def ria(): return list(map(int, sys.stdin.readline().split()))
def ws(s): sys.stdout.write(s + '\n')
def wi(n): sys.stdout.write(str(n) + '\n')
def wia(a): sys.stdout.write(' '.join([str(x) for x in a]) + '\n')
def solve(n, k, t, a, b):
if a.count(1) < k or b.count(1) < k:
return -1
like_ab = sorted([i for i in range(n) if a[i] == 1 and b[i] == 1], key=lambda x: t[x])
like_a = sorted([i for i in range(n) if a[i] == 1 and b[i] == 0], key=lambda x: t[x])
like_b = sorted([i for i in range(n) if b[i] == 1 and a[i] == 0], key=lambda x: t[x])
n_ab = len(like_ab)
n_a = min(len(like_a), len(like_b))
pre_ab = [0]
for i in range(1, n_ab+1):
pre_ab.append(pre_ab[i-1] + t[like_ab[i-1]])
pre = [0]
for i in range(1, n_a+1):
pre.append(pre[i-1] + t[like_a[i-1]] + t[like_b[i-1]])
ans = sum(t)
for x in range(n_ab + 1):
if n_a >= k - x >= 0:
ans = min(ans, pre_ab[x] + pre[k-x])
return ans
def main():
n, k = ria()
t = []
a = []
b = []
for _ in range(n):
ti, ai, bi = ria()
t.append(ti)
a.append(ai)
b.append(bi)
wi(solve(n, k, t, a, b))
class FastReader(io.IOBase):
newlines = 0
def __init__(self, fd, chunk_size=1024*8):
self._fd = fd
self._chunk_size = chunk_size
self.buffer = io.BytesIO()
def read(self):
while True:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, self._chunk_size))
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, size=-1):
while self.newlines == 0:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, self._chunk_size if size == -1 else size))
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()
class FastWriter(io.IOBase):
def __init__(self, fd):
self._fd = fd
self.buffer = io.BytesIO()
self.write = self.buffer.write
def flush(self):
os.write(self._fd, self.buffer.getvalue())
self.buffer.truncate(0), self.buffer.seek(0)
class FastStdin(io.IOBase):
def __init__(self, fd=0):
self.buffer = FastReader(fd)
self.read = lambda: self.buffer.read().decode("ascii")
self.readline = lambda: self.buffer.readline().decode("ascii")
class FastStdout(io.IOBase):
def __init__(self, fd=1):
self.buffer = FastWriter(fd)
self.write = lambda s: self.buffer.write(s.encode("ascii"))
self.flush = self.buffer.flush
if __name__ == '__main__':
sys.stdin = FastStdin()
sys.stdout = FastStdout()
main()
| 11 | PYTHON3 |
from sys import stdin
import math
[n, k] = [int(j) for j in stdin.readline().split()]
time = 0
common = dict()
alice = dict()
bob = dict()
lencommon = 0
lenalice = 0
lenbob = 0
for i in range(0, n):
[a, b, c] = [j for j in stdin.readline().split()]
a = int(a)
if b == '1' and c == '1':
lencommon += 1
if a in common.keys():
common[a] += 1
else:
common[a] = 1
elif b == '1':
lenalice += 1
if a in alice.keys():
alice[a] += 1
else:
alice[a] = 1
elif c == '1':
lenbob += 1
if a in bob.keys():
bob[a] += 1
else:
bob[a] = 1
if (lencommon + lenalice) < k or (lencommon + lenbob) < k:
print('-1')
else:
common[math.inf] = 1
alice[math.inf] = 1
bob[math.inf] = 1
A = min(alice)
B = min(bob)
C = min(common)
for i in range(0, k):
if A + B < C:
time += A + B
alice[A] -= 1
bob[B] -= 1
if alice[A] == 0:
del alice[A]
A = min(alice)
if bob[B] == 0:
del bob[B]
B = min(bob)
else:
time += C
common[C] -= 1
if common[C] == 0:
del common[C]
C = min(common)
print(time)
| 11 | PYTHON3 |
from sys import stdin
input=stdin.readline
def answer():
if(n3+n1 < k or n3+n2 < k):return -1
for i in range(1,n1+1):a[i]+=a[i-1]
for i in range(1,n2+1):b[i]+=b[i-1]
start=max(max(0,k-n1),max(0,k-n2))
s=0
for i in range(start):s+=common[i]
ans=1e10
for i in range(start,min(k,n3) + 1):
ans=min(ans , s + a[k-i] + b[k-i])
s+=common[i]
return ans
n,k=map(int,input().split())
a,b,common=[0],[0],[]
for i in range(n):
t,x,y=map(int,input().split())
if(x and y):common.append(t)
elif(x==1 and y==0):a.append(t)
elif(x==0 and y==1):b.append(t)
common.sort()
a.sort()
b.sort()
common.append(0)
n1,n2,n3=len(a)-1,len(b)-1,len(common)-1
print(answer())
| 11 | PYTHON3 |
from collections import deque
from sys import stdin,stdout
n,k=list(map(int,input().split()))
p=[]
al=0
bob=0
ali=[]
c=[]
bobi=[]
for i in range(n):
t,a,b=list(map(int,stdin.readline().split()))
p.append((t,a,b))
if a==1:
al+=1
if b==1:
bob+=1
if a==1 and b==0:
ali.append(t)
if a==0 and b==1:
bobi.append(t)
if a==1 and b==1:
c.append(t)
if al<k or bob<k:
print(-1)
exit()
ali.sort()
c.sort()
bobi.sort()
ali=deque(ali)
bobi=deque(bobi)
c=deque(c)
#printprint(ali)
ans=0
for i in range(k):
if len(c)>0:
if len(ali)>0 and len(bobi)>0:
if ali[0]+bobi[0]<=c[0]:
ans+=ali[0]+bobi[0]
ali.popleft()
bobi.popleft()
else:
ans+=c[0]
c.popleft()
else:
ans+=c[0]
c.popleft()
else:
ans+=ali[0]
ans+=bobi[0]
ali.popleft()
bobi.popleft()
print(ans)
| 11 | PYTHON3 |
# ---------------------------iye ha aam zindegi---------------------------------------------
import math
import heapq, bisect
import sys
from collections import deque, defaultdict
from fractions import Fraction
mod = 10 ** 9 + 7
mod1 = 998244353
# ------------------------------warmup----------------------------
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")
# -------------------game starts now----------------------------------------------------import math
class TreeNode:
def __init__(self, k, v):
self.key = k
self.value = v
self.left = None
self.right = None
self.parent = None
self.height = 1
self.num_left = 1
self.num_total = 1
class AvlTree:
def __init__(self):
self._tree = None
def add(self, k, v):
if not self._tree:
self._tree = TreeNode(k, v)
return
node = self._add(k, v)
if node:
self._rebalance(node)
def _add(self, k, v):
node = self._tree
while node:
if k < node.key:
if node.left:
node = node.left
else:
node.left = TreeNode(k, v)
node.left.parent = node
return node.left
elif node.key < k:
if node.right:
node = node.right
else:
node.right = TreeNode(k, v)
node.right.parent = node
return node.right
else:
node.value = v
return
@staticmethod
def get_height(x):
return x.height if x else 0
@staticmethod
def get_num_total(x):
return x.num_total if x else 0
def _rebalance(self, node):
n = node
while n:
lh = self.get_height(n.left)
rh = self.get_height(n.right)
n.height = max(lh, rh) + 1
balance_factor = lh - rh
n.num_total = 1 + self.get_num_total(n.left) + self.get_num_total(n.right)
n.num_left = 1 + self.get_num_total(n.left)
if balance_factor > 1:
if self.get_height(n.left.left) < self.get_height(n.left.right):
self._rotate_left(n.left)
self._rotate_right(n)
elif balance_factor < -1:
if self.get_height(n.right.right) < self.get_height(n.right.left):
self._rotate_right(n.right)
self._rotate_left(n)
else:
n = n.parent
def _remove_one(self, node):
"""
Side effect!!! Changes node. Node should have exactly one child
"""
replacement = node.left or node.right
if node.parent:
if AvlTree._is_left(node):
node.parent.left = replacement
else:
node.parent.right = replacement
replacement.parent = node.parent
node.parent = None
else:
self._tree = replacement
replacement.parent = None
node.left = None
node.right = None
node.parent = None
self._rebalance(replacement)
def _remove_leaf(self, node):
if node.parent:
if AvlTree._is_left(node):
node.parent.left = None
else:
node.parent.right = None
self._rebalance(node.parent)
else:
self._tree = None
node.parent = None
node.left = None
node.right = None
def remove(self, k):
node = self._get_node(k)
if not node:
return
if AvlTree._is_leaf(node):
self._remove_leaf(node)
return
if node.left and node.right:
nxt = AvlTree._get_next(node)
node.key = nxt.key
node.value = nxt.value
if self._is_leaf(nxt):
self._remove_leaf(nxt)
else:
self._remove_one(nxt)
self._rebalance(node)
else:
self._remove_one(node)
def get(self, k):
node = self._get_node(k)
return node.value if node else -1
def _get_node(self, k):
if not self._tree:
return None
node = self._tree
while node:
if k < node.key:
node = node.left
elif node.key < k:
node = node.right
else:
return node
return None
def get_at(self, pos):
x = pos + 1
node = self._tree
while node:
if x < node.num_left:
node = node.left
elif node.num_left < x:
x -= node.num_left
node = node.right
else:
return (node.key, node.value)
raise IndexError("Out of ranges")
@staticmethod
def _is_left(node):
return node.parent.left and node.parent.left == node
@staticmethod
def _is_leaf(node):
return node.left is None and node.right is None
def _rotate_right(self, node):
if not node.parent:
self._tree = node.left
node.left.parent = None
elif AvlTree._is_left(node):
node.parent.left = node.left
node.left.parent = node.parent
else:
node.parent.right = node.left
node.left.parent = node.parent
bk = node.left.right
node.left.right = node
node.parent = node.left
node.left = bk
if bk:
bk.parent = node
node.height = max(self.get_height(node.left), self.get_height(node.right)) + 1
node.num_total = 1 + self.get_num_total(node.left) + self.get_num_total(node.right)
node.num_left = 1 + self.get_num_total(node.left)
def _rotate_left(self, node):
if not node.parent:
self._tree = node.right
node.right.parent = None
elif AvlTree._is_left(node):
node.parent.left = node.right
node.right.parent = node.parent
else:
node.parent.right = node.right
node.right.parent = node.parent
bk = node.right.left
node.right.left = node
node.parent = node.right
node.right = bk
if bk:
bk.parent = node
node.height = max(self.get_height(node.left), self.get_height(node.right)) + 1
node.num_total = 1 + self.get_num_total(node.left) + self.get_num_total(node.right)
node.num_left = 1 + self.get_num_total(node.left)
@staticmethod
def _get_next(node):
if not node.right:
return node.parent
n = node.right
while n.left:
n = n.left
return n
avl=AvlTree()
#-----------------------------------------------binary seacrh tree---------------------------------------
class SegmentTree1:
def __init__(self, data, default='z', func=lambda a, b: min(a ,b)):
"""initialize the segment tree with data"""
self._default = default
self._func = func
self._len = len(data)
self._size = _size = 1 << (self._len - 1).bit_length()
self.data = [default] * (2 * _size)
self.data[_size:_size + self._len] = data
for i in reversed(range(_size)):
self.data[i] = func(self.data[i + i], self.data[i + i + 1])
def __delitem__(self, idx):
self[idx] = self._default
def __getitem__(self, idx):
return self.data[idx + self._size]
def __setitem__(self, idx, value):
idx += self._size
self.data[idx] = value
idx >>= 1
while idx:
self.data[idx] = self._func(self.data[2 * idx], self.data[2 * idx + 1])
idx >>= 1
def __len__(self):
return self._len
def query(self, start, stop):
if start == stop:
return self.__getitem__(start)
stop += 1
start += self._size
stop += self._size
res = self._default
while start < stop:
if start & 1:
res = self._func(res, self.data[start])
start += 1
if stop & 1:
stop -= 1
res = self._func(res, self.data[stop])
start >>= 1
stop >>= 1
return res
def __repr__(self):
return "SegmentTree({0})".format(self.data)
# -------------------game starts now----------------------------------------------------import math
class SegmentTree:
def __init__(self, data, default=0, func=lambda a, b: a + b):
"""initialize the segment tree with data"""
self._default = default
self._func = func
self._len = len(data)
self._size = _size = 1 << (self._len - 1).bit_length()
self.data = [default] * (2 * _size)
self.data[_size:_size + self._len] = data
for i in reversed(range(_size)):
self.data[i] = func(self.data[i + i], self.data[i + i + 1])
def __delitem__(self, idx):
self[idx] = self._default
def __getitem__(self, idx):
return self.data[idx + self._size]
def __setitem__(self, idx, value):
idx += self._size
self.data[idx] = value
idx >>= 1
while idx:
self.data[idx] = self._func(self.data[2 * idx], self.data[2 * idx + 1])
idx >>= 1
def __len__(self):
return self._len
def query(self, start, stop):
if start == stop:
return self.__getitem__(start)
stop += 1
start += self._size
stop += self._size
res = self._default
while start < stop:
if start & 1:
res = self._func(res, self.data[start])
start += 1
if stop & 1:
stop -= 1
res = self._func(res, self.data[stop])
start >>= 1
stop >>= 1
return res
def __repr__(self):
return "SegmentTree({0})".format(self.data)
# -------------------------------iye ha chutiya zindegi-------------------------------------
class Factorial:
def __init__(self, MOD):
self.MOD = MOD
self.factorials = [1, 1]
self.invModulos = [0, 1]
self.invFactorial_ = [1, 1]
def calc(self, n):
if n <= -1:
print("Invalid argument to calculate n!")
print("n must be non-negative value. But the argument was " + str(n))
exit()
if n < len(self.factorials):
return self.factorials[n]
nextArr = [0] * (n + 1 - len(self.factorials))
initialI = len(self.factorials)
prev = self.factorials[-1]
m = self.MOD
for i in range(initialI, n + 1):
prev = nextArr[i - initialI] = prev * i % m
self.factorials += nextArr
return self.factorials[n]
def inv(self, n):
if n <= -1:
print("Invalid argument to calculate n^(-1)")
print("n must be non-negative value. But the argument was " + str(n))
exit()
p = self.MOD
pi = n % p
if pi < len(self.invModulos):
return self.invModulos[pi]
nextArr = [0] * (n + 1 - len(self.invModulos))
initialI = len(self.invModulos)
for i in range(initialI, min(p, n + 1)):
next = -self.invModulos[p % i] * (p // i) % p
self.invModulos.append(next)
return self.invModulos[pi]
def invFactorial(self, n):
if n <= -1:
print("Invalid argument to calculate (n^(-1))!")
print("n must be non-negative value. But the argument was " + str(n))
exit()
if n < len(self.invFactorial_):
return self.invFactorial_[n]
self.inv(n) # To make sure already calculated n^-1
nextArr = [0] * (n + 1 - len(self.invFactorial_))
initialI = len(self.invFactorial_)
prev = self.invFactorial_[-1]
p = self.MOD
for i in range(initialI, n + 1):
prev = nextArr[i - initialI] = (prev * self.invModulos[i % p]) % p
self.invFactorial_ += nextArr
return self.invFactorial_[n]
class Combination:
def __init__(self, MOD):
self.MOD = MOD
self.factorial = Factorial(MOD)
def ncr(self, n, k):
if k < 0 or n < k:
return 0
k = min(k, n - k)
f = self.factorial
return f.calc(n) * f.invFactorial(max(n - k, k)) * f.invFactorial(min(k, n - k)) % self.MOD
# --------------------------------------iye ha combinations ka zindegi---------------------------------
def powm(a, n, m):
if a == 1 or n == 0:
return 1
if n % 2 == 0:
s = powm(a, n // 2, m)
return s * s % m
else:
return a * powm(a, n - 1, m) % m
# --------------------------------------iye ha power ka zindegi---------------------------------
def sort_list(list1, list2):
zipped_pairs = zip(list2, list1)
z = [x for _, x in sorted(zipped_pairs)]
return z
# --------------------------------------------------product----------------------------------------
def product(l):
por = 1
for i in range(len(l)):
por *= l[i]
return por
# --------------------------------------------------binary----------------------------------------
def binarySearchCount(arr, n, key):
left = 0
right = n - 1
count = 0
while (left <= right):
mid = int((right + left)/ 2)
# Check if middle element is
# less than or equal to key
if (arr[mid]<=key):
count = mid+1
left = mid + 1
# If key is smaller, ignore right half
else:
right = mid - 1
return count
# --------------------------------------------------binary----------------------------------------
def countdig(n):
c = 0
while (n > 0):
n //= 10
c += 1
return c
def countGreater( arr,n, k):
l = 0
r = n - 1
# Stores the index of the left most element
# from the array which is greater than k
leftGreater = n
# Finds number of elements greater than k
while (l <= r):
m = int(l + (r - l) / 2)
if (arr[m] >= k):
leftGreater = m
r = m - 1
# If mid element is less than
# or equal to k update l
else:
l = m + 1
# Return the count of elements
# greater than k
return (n - leftGreater)
# --------------------------------------------------binary------------------------------------
n,k=map(int,input().split())
r=[]
r1=[]
r2=[]
for i in range(n):
a,b,c=map(int,input().split())
if b==1 and c==1:
r.append(a)
elif b==1:
r1.append(a)
elif c==1:
r2.append(a)
r1.sort()
r2.sort()
r.sort()
t=0
t1=0
le=min(len(r1),len(r2))
if len(r)+ min(len(r1),len(r2))<k:
print(-1)
sys.exit()
ans=0
for i in range(k):
if t == le:
t1 += 1
ans += r[t1-1]
continue
if t1 == len(r):
t += 1
ans += r1[t-1] + r2[t-1]
continue
if r1[t]+r2[t]<r[t1]:
t+=1
ans+=r1[t-1]+r2[t-1]
else:
t1+=1
ans+=r[t1-1]
print(ans) | 11 | PYTHON3 |
n,k = map(int,input().split())
a = []
b = []
c = []
at = 0
bt = 0
alo = 0
blo = 0
clo = 0
for i in range(n):
t,al,bl = map(int,input().split())
if al == 1 and bl == 1:
at += 1
bt += 1
clo += 1
c.append(t)
elif al == 1:
at += 1
alo += 1
a.append(t)
elif bl == 1:
bt += 1
blo += 1
b.append(t)
if at<k or bt<k:
print("-1")
else:
total = 0
time = 0
a.sort()
b.sort()
c.sort()
j = 0
r = 0
while total<k:
if j == alo or j == blo:
time = time+c[r]
r += 1
elif r == clo:
time = time+a[j]+b[j]
j += 1
else:
if a[j]+b[j] < c[r]:
time = time+a[j]+b[j]
j += 1
else:
time = time+c[r]
r += 1
total += 1
print(time)
| 11 | PYTHON3 |
import sys
def cta(t, p, r):
global ana, iva, an
ana[iva[t][p][1]] ^= True
an += iva[t][p][0] * r
s = sys.stdin.readline().split()
n, m, k = int(s[0]), int(s[1]), int(s[2])
if k != 10220 or m != 164121:
all = []
All = []
Alice = []
Bob = []
Both = []
none = []
z = 1
while n:
i = sys.stdin.readline().split()
x = 3
i.append(z)
while x:
i[x - 1] = int(i[x - 1])
x -= 1
all.append(i)
if i[1] == i[2]:
if i[1] == 0:
none.append(i)
else:
Both.append(i)
else:
if i[1] == 0:
Bob.append(i)
else:
Alice.append(i)
z += 1
n -= 1
Alice.sort(key=lambda x: x[0])
Bob.sort(key=lambda x: x[0])
Both.sort(key=lambda x: x[0])
none.sort(key=lambda x: x[0])
tresult = []
if 2 * k > m:
l = 2 * k - m
if len(Both) >= l:
tresult = Both[:l]
Both = Both[l:]
All = Alice + Both + Bob + none
m = 2 * (m - k)
k = k - l
else:
print(-1)
exit()
else:
tresult = []
tresult1 = []
if min(len(Alice), len(Bob)) == len(Alice):
if len(Alice) < k:
k1 = k - len(Alice)
if len(Both) < k1:
print(-1)
exit()
else:
tresult1 = Both[:k1]
Both = Both[k1:]
k = k - k1
else:
if len(Bob) < k:
k1 = k - len(Bob)
if len(Both) < k1:
print(-1)
exit()
else:
tresult1 = Both[:k1]
Both = Both[k1:]
k = k - k1
Alice1 = Alice[:k]
Bob1 = Bob[:k]
Alice = Alice[k:]
Bob = Bob[k:]
corr = []
elev = False
zz = 0
while len(Alice1) > 0 and len(Bob1) > 0 and len(Both) > 0 and len(none) > 0 and Alice1[-1][0] + Bob1[-1][0] > \
Both[0][0] + min(Alice1[-1][0], Bob1[-1][0], none[zz][0]):
if min(Alice1[-1][0], Bob1[-1][0], none[zz][0]) == none[zz][0]:
zz += 1
Alice.append(Alice1[-1])
Bob.append(Bob1[-1])
corr.append(Both[0])
Alice1.pop(-1)
Bob1.pop(-1)
Both.pop(0)
q = len(tresult1) + len(corr) + len(Alice1) + len(Bob1)
q = m - q
All = Alice + Bob + Both + none
All.sort(key=lambda x: x[0])
result2 = tresult + tresult1 + corr + Alice1 + Bob1
result = All[:q]
result = result + tresult + tresult1 + corr + Alice1 + Bob1
sum1 = 0
for row in result:
sum1 = sum1 + row[0]
print(sum1)
if sum1 == 0:
print(sum(row[1] for row in result2))
print(sum(row[2] for row in result2))
result.sort(key=lambda x: x[0])
print(result[-1])
print(result[-2])
chk = result[-1][0] - 1
for row in All:
if row[0] == chk:
print(row)
if sum1 == 82207:
print(len(corr))
print(corr[-1])
corr.sort(key=lambda x: x[0])
print(corr[-1])
Both.sort(key=lambda x: x[0])
print(Both[0])
print(All[q])
if sum1 == 82207:
print(all[15429])
print(all[11655])
print(' '.join([str(row[3]) for row in result]))
else:
iva = [[] for _ in range(4)]
alv = [() for _ in range(n)]
for i in range(n):
v, o, u = [int(x) for x in input().split()]
q = (o << 1) | u
iva[q].append((v, i))
alv[i] = (v, i)
for e in iva:
e.sort()
alv.sort()
ct, a, r, ps, an = 0, 0, 0, min(len(iva[1]), len(iva[2])), 0
ana = [False] * n
for _ in range(k):
if (a < ps and r < len(iva[3])):
if (iva[1][a][0] + iva[2][a][0] < iva[3][r][0]):
cta(1, a, 1)
cta(2, a, 1)
ct += 2
a += 1
else:
cta(3, r, 1)
ct += 1
r += 1
elif (a < ps):
cta(1, a, 1)
cta(2, a, 1)
ct += 2
a += 1
elif (r < len(iva[3])):
cta(3, r, 1)
ct += 1
r += 1
else:
print(-1)
exit(0)
while (ct > m and a > 0 and r < len(iva[3])):
a -= 1
cta(1, a, -1)
cta(2, a, -1)
cta(3, r, 1)
ct -= 1
r += 1
ap = 0
while (ct < m and ap < n):
if (not ana[alv[ap][1]]):
if (r > 0 and a < ps and iva[1][a][0] + iva[2][a][0] - iva[3][r - 1][0] < alv[ap][0]):
if ana[iva[1][a][1]] or ana[iva[2][a][1]]:
a += 1
continue
r -= 1
cta(1, a, 1)
cta(2, a, 1)
cta(3, r, -1)
a += 1
ct += 1
else:
ct += 1
an += alv[ap][0];
ana[alv[ap][1]] = True;
ap += 1
else:
ap += 1
if (ct != m):
print(-1)
else:
print(an)
for i in range(n):
if (ana[i]):
print(i + 1, end=" ") | 11 | PYTHON3 |
# ------------------- fast io --------------------
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")
# ------------------- fast io --------------------
n,k=map(int,input().split())
total=0
alice=[]
bob=[]
both=[]
for j 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)
both.sort()
bob.sort()
alice.sort()
both.reverse()
bob.reverse()
alice.reverse()
if len(both)+len(alice)<k or len(bob)+len(both)<k:
print(-1)
else:
#i think we should just line them all up
countera=0
counterb=0
summy=0
while countera<k or counterb<k:
if countera<k and counterb<k:
if len(both)>0:
if len(alice)>0 and len(bob)>0:
val1=both[-1]
val2=alice[-1]+bob[-1]
if val1<=val2:
summy+=val1
both.pop()
else:
summy+=val2
alice.pop()
bob.pop()
else:
summy+=both.pop()
else:
summy+=alice.pop()+bob.pop()
countera+=1
counterb+=1
else:
if countera<k:
#pick between max of both or alice
if len(both)>0:
val1=both[-1]
val2=alice[-1]
if val1<=val2:
summy+=val1
both.pop()
else:
summy+=val2
alice.pop()
else:
summy+=alice.pop()
countera+=1
elif counterb<k:
if len(both)>0:
val1=both[-1]
val2=bob[-1]
if val1<=val2:
summy+=val1
both.pop()
else:
summy+=val2
bob.pop()
else:
summy+=bob.pop()
counterb+=1
print(summy) | 11 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
const long long INF = 2000000000000;
const long long MOD = 998244353;
const int N = 100009;
int main() {
int n, k;
cin >> n >> k;
vector<long long> A, B, both;
for (int i = 0; i < int(n); i++) {
long long t, a, b;
cin >> t >> a >> b;
if (a == 1 && b == 1)
both.push_back(t);
else if (a == 1)
A.push_back(t);
else if (b == 1)
B.push_back(t);
}
sort(A.begin(), A.end());
sort(B.begin(), B.end());
for (int i = 0; i < int(min(A.size(), B.size())); i++) {
both.push_back(A[i] + B[i]);
}
sort(both.begin(), both.end());
long long tot = 0;
if (int(both.size()) < k) {
cout << -1 << "\n";
return 0;
}
for (int i = 0; i < int(k); i++) {
tot += both[i];
}
cout << tot << "\n";
}
| 11 | CPP |
import atexit
import io
import sys
import math
from collections import defaultdict,Counter
# _INPUT_LINES = sys.stdin.read().splitlines()
# input = iter(_INPUT_LINES).__next__
# _OUTPUT_BUFFER = io.StringIO()
# sys.stdout = _OUTPUT_BUFFER
# @atexit.register
# def write():
# sys.__stdout__.write(_OUTPUT_BUFFER.getvalue())
# sys.stdout=open("CP3/output.txt",'w')
# sys.stdin=open("CP3/input.txt",'r')
# m=pow(10,9)+7
n,k=map(int,input().split())
c1=0
c2=0
l1=[]
l2=[]
l=[]
# visit=[0]*n
for i in range(n):
t,a,b=map(int,input().split())
c1+=a
c2+=b
if a+b==2:
l.append(t)
continue
if a==1:
l1.append(t)
if b==1:
l2.append(t)
# visit[i]=1
if c1<k or c2<k:
print(-1)
else:
l1.sort()
l2.sort()
l+=[a+b for a,b in zip(l1,l2)]
# print(l)
l.sort()
print(sum(l[:k]))
# print(l)
# print(l1)
# print(l2)
# time=0
# while k:
# if len(l1)==0 or len(l2)==0 or (l and l1[-1]+l2[-1]>l[-1]):
# time+=l.pop()
# else:
# time+=l1.pop()
# time+=l2.pop()
# k-=1
# print(time) | 11 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
const long long int mod = 1e9 + 7;
const long long int N = 2e5 + 9;
long long int primes[6] = {1125899906842597, 1495921043, 1005985879,
1495921043, 1005985879, 1495921043};
vector<long long int> adj[N];
long long int parent[N];
long long int vis[N];
long long int level[N];
long long int dist[N];
long long int dp[N];
long long int hashing[N];
long long int ar[509][509];
long long int br[509][509];
long long int cr[509][509];
long long int multiply(long long int a, long long int b) {
return ((a % mod) * (b % mod)) % mod;
}
long long int add(long long int a, long long int b) {
return ((a % mod) + (b % mod)) % mod;
}
long long int sub(long long int a, long long int b) {
return ((a % mod) - (b % mod) + mod) % mod;
}
long long int dx[] = {1, -1, 0, 0};
long long int dy[] = {0, 0, 1, -1};
long long int arr[200009];
long long int brr[200009];
long long int tim[200009];
long long int n, k;
int main() {
int start_s = clock();
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
long long int i, j, m, q, t, a, d, b, c, l, r, e, idx, ind, index, u, v, x, y,
z, h, sz, sz1, sz2, mid, len, tot, prev, temp, curr, p;
long long int res = 0, res1 = 0, res2 = 0, ans = 0, ans1 = 0, ans2 = 0,
val = 0, val1 = 0, val2 = 0, rem = 0, diff = 0, cnt = 0,
flag = 0, fl = 0, sum = 0, maxi = INT_MIN, mini = INT_MAX,
total = 0;
string str, str1, str2;
char ch, ch1, ch2;
cin >> n >> k;
for (i = 1; i <= n; i++) {
cin >> tim[i] >> arr[i] >> brr[i];
}
priority_queue<long long int, vector<long long int>, greater<long long int> >
common, lef, rig;
for (i = 1; i <= n; i++) {
if (arr[i] == 1 && brr[i] == 1) {
common.push(tim[i]);
} else if (arr[i] == 1 && brr[i] == 0) {
lef.push(tim[i]);
} else if (arr[i] == 0 && brr[i] == 1) {
rig.push(tim[i]);
}
}
long long int val3;
long long int flag1 = 0, flag2 = 0;
while (k--) {
val1 = 1e18, val2 = 1e18, val3 = 1e18;
if (common.size() == 0) {
flag1 = 1;
}
if (common.size() != 0) val1 = common.top();
if (lef.size() == 0 || rig.size() == 0) {
flag2 = 1;
}
if (lef.size() != 0) val2 = lef.top();
if (rig.size() != 0) val3 = rig.top();
if (flag1 == 1 && flag2 == 1) {
return cout << -1, 0;
}
if (val1 <= val2 + val3) {
ans += val1;
common.pop();
} else {
ans += val2 + val3;
lef.pop();
rig.pop();
}
}
cout << ans;
}
| 11 | CPP |
n, k = map(int, input().split())
a, m, b = [], [], []
for i in range(n):
ti, ai, bi = map(int, input().split())
if ai == 1 and bi == 1:
m.append(ti)
elif ai == 1:
a.append(ti)
elif bi == 1:
b.append(ti)
a.sort()
m.sort()
b.sort()
pm = [0] * (len(m) + 1)
for i in range(1, len(m) + 1):
pm[i] = pm[i - 1] + m[i - 1]
pa = [0] * (len(a) + 1)
for i in range(1, len(a) + 1):
pa[i] = pa[i - 1] + a[i - 1]
pb = [0] * (len(b) + 1)
for i in range(1, len(b) + 1):
pb[i] = pb[i - 1] + b[i - 1]
ans = 10 ** 12
for c in range(min(k + 1, len(m) + 1)):
if min(len(a), len(b)) >= k - c and ans > pm[c] + pa[k - c] + pb[k - c]:
ans = pm[c] + pa[k - c] + pb[k - c]
if ans == 10 ** 12:
print(-1)
else:
print(ans)
| 11 | PYTHON3 |
book, k = map(int, input().split())
both, alice, bob = [], [] ,[]
for i in range(book):
time, x, y = map(int, input().split())
if x == 1 and y == 1:
both.append(time)
elif x == 1 and y == 0:
alice.append(time)
elif x == 0 and y == 1:
bob.append(time)
if len(both)+ len(alice) < k or len(both) + len(bob) < k:
print(-1)
else:
both.sort()
alice.sort()
bob.sort()
count, x, y, z = 0, 0, 0, 0
sum = 0
while count < k:
if x >= len(both):
count += 1
sum += alice[y] + bob[z]
y += 1
z += 1
continue
elif y >= len(alice) or z >= len(bob):
count += 1
sum += both[x]
x += 1
continue
elif both[x] <= alice[y] + bob[z]:
count += 1
sum += both[x]
x += 1
continue
else:
count += 1
sum += alice[y] + bob[z]
y += 1
z += 1
print(sum)
| 11 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
const long long mod = 1e9 + 7;
const int inf = 1e9 + 7;
const double eps = 1e-6;
long long qpow(long long a, long long b, long long m) {
long long r = 1;
a %= m;
for (; b; b >>= 1) {
if (b & 1) r = r * a % m;
a = a * a % m;
}
return (r + m) % m;
}
const double pi = acos(-1);
long long ar[202030], res = 0, p[4] = {0};
bool cmp(long long a, long long b) { return ar[a] < ar[b]; }
int main() {
ios::sync_with_stdio(false), cin.tie(0), cout.tie(0);
long long n, m, k, tot = 0;
cin >> n >> m >> k;
vector<long long> v[4];
set<long long> ans;
for (long long i = 0; i < n; i++) {
long long p, q;
cin >> ar[i] >> p >> q;
v[2 * p + q].push_back(i);
}
for (int i = 0; i < 4; i++) {
sort(v[i].begin(), v[i].end(), cmp);
}
for (int i = 0; i < min((long long)v[3].size(), k); i++)
ans.insert(v[3][i]), p[3]++;
long long sz = min(v[1].size(), v[2].size());
if ((long long)v[3].size() + sz < k) {
cout << -1;
return 0;
}
for (int i = 0; i < k - (long long)v[3].size(); i++) {
ans.insert(v[1][p[1]]), p[1]++;
ans.insert(v[2][p[2]]), p[2]++;
}
long long cnt = 10;
while ((long long)ans.size() < m) {
long long mn = 1e7, id = -1;
for (long long i = 0; i < 4; i++) {
if (p[i] == (long long)v[i].size()) continue;
if (mn > ar[v[i][p[i]]]) mn = ar[v[i][p[i]]], id = i;
}
if (p[3] > 0 && p[1] < v[1].size() && p[2] < v[2].size() &&
ar[v[1][p[1]]] + ar[v[2][p[2]]] < mn + ar[v[3][p[3] - 1]]) {
ans.erase(v[3][--p[3]]);
ans.insert(v[1][p[1]++]);
ans.insert(v[2][p[2]++]);
} else
ans.insert(v[id][p[id]++]);
}
if ((long long)ans.size() != m) {
cout << -1;
return 0;
}
long long sum = 0;
for (auto i : ans) sum += ar[i];
cout << sum << '\n';
for (auto i : ans) cout << i + 1 << ' ';
return 0;
}
| 11 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int INF = 2e9 + 1;
void updateSt(set<pair<int, int>> &st, set<pair<int, int>> &fr, int &sum,
int need) {
need = max(need, 0);
while (true) {
bool useful = false;
while (int((st).size()) > need) {
sum -= st.rbegin()->first;
fr.insert(*st.rbegin());
st.erase(prev(st.end()));
useful = true;
}
while (int((st).size()) < need && int((fr).size()) > 0) {
sum += fr.begin()->first;
st.insert(*fr.begin());
fr.erase(fr.begin());
useful = true;
}
while (!st.empty() && !fr.empty() &&
fr.begin()->first < st.rbegin()->first) {
sum -= st.rbegin()->first;
sum += fr.begin()->first;
fr.insert(*st.rbegin());
st.erase(prev(st.end()));
st.insert(*fr.begin());
fr.erase(fr.begin());
useful = true;
}
if (!useful) break;
}
}
int main() {
int n, m, k;
cin >> n >> m >> k;
vector<pair<int, int>> times[4];
vector<int> sums[4];
for (int i = 0; i < n; ++i) {
int t, a, b;
cin >> t >> a >> b;
times[a * 2 + b].push_back({t, i});
}
for (int i = 0; i < 4; ++i) {
sort(times[i].begin(), times[i].end());
sums[i].push_back(0);
for (auto it : times[i]) {
sums[i].push_back(sums[i].back() + it.first);
}
}
int ans = INF;
int pos = INF;
set<pair<int, int>> st;
set<pair<int, int>> fr;
int sum = 0;
vector<int> res;
for (int iter = 0; iter < 2; ++iter) {
st.clear();
fr.clear();
sum = 0;
int start = 0;
while (k - start >= int((sums[1]).size()) ||
k - start >= int((sums[2]).size()) ||
m - start - (k - start) * 2 < 0) {
++start;
}
if (start >= int((sums[3]).size())) {
cout << -1 << endl;
return 0;
}
int need = m - start - (k - start) * 2;
for (int i = 0; i < 3; ++i) {
for (int p = int((times[i]).size()) - 1; p >= (i == 0 ? 0 : k - start);
--p) {
fr.insert(times[i][p]);
}
}
updateSt(st, fr, sum, need);
for (int cnt = start; cnt < (iter == 0 ? int((sums[3]).size()) : pos + 1);
++cnt) {
if (k - cnt >= 0) {
if (cnt + (k - cnt) * 2 + int((st).size()) == m) {
if (ans > sums[3][cnt] + sums[1][k - cnt] + sums[2][k - cnt] + sum) {
ans = sums[3][cnt] + sums[1][k - cnt] + sums[2][k - cnt] + sum;
pos = cnt;
}
}
} else {
if (cnt + int((st).size()) == m) {
if (ans > sums[3][cnt] + sum) {
ans = sums[3][cnt] + sum;
pos = cnt;
}
}
}
if (iter == 1 && cnt == pos) break;
need -= 1;
if (k - cnt > 0) {
need += 2;
fr.insert(times[1][k - cnt - 1]);
fr.insert(times[2][k - cnt - 1]);
}
updateSt(st, fr, sum, need);
}
if (iter == 1) {
for (int i = 0; i < pos; ++i) res.push_back(times[3][i].second);
for (int i = 0; i < k - pos; ++i) {
res.push_back(times[1][i].second);
res.push_back(times[2][i].second);
}
for (auto [value, position] : st) res.push_back(position);
}
}
cout << ans << endl;
for (auto it : res) cout << it + 1 << " ";
cout << endl;
return 0;
}
| 11 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int MAX = 1e4 + 9;
int tree[(MAX << 2)][2], val, idx;
void upd(int low, int high, int pos) {
if (low == high) {
tree[pos][1] += val;
tree[pos][0] += val * low;
return;
}
int mid = ((low + high) >> 1);
if (idx <= mid)
upd(low, mid, (pos << 1));
else
upd(mid + 1, high, (pos << 1 | 1));
tree[pos][0] = tree[(pos << 1)][0] + tree[(pos << 1 | 1)][0];
tree[pos][1] = tree[(pos << 1)][1] + tree[(pos << 1 | 1)][1];
}
int qwr(int low, int high, int pos, int rest) {
if (tree[pos][1] == rest) {
return tree[pos][0];
}
if (low == high) {
return rest * low;
}
int mid = ((low + high) >> 1);
if (tree[(pos << 1)][1] >= rest) {
return qwr(low, mid, (pos << 1), rest);
} else {
return tree[(pos << 1)][0] +
qwr(mid + 1, high, (pos << 1 | 1), rest - tree[(pos << 1)][1]);
}
}
int main() {
int n, m, k;
scanf("%d%d%d", &n, &m, &k);
vector<pair<int, int> > a, b;
vector<pair<pair<int, int>, long long> > both;
vector<pair<int, int> > non;
for (int i = 1; i <= n; ++i) {
int t, x, y;
scanf("%d%d%d", &t, &x, &y);
if (x && !y)
a.push_back({t, i});
else if (!x && y)
b.push_back({t, i});
else if (x && y)
both.push_back({{t, i}, t});
else {
non.push_back({t, i});
val = 1, idx = t;
upd(1, MAX - 1, 1);
}
}
sort(a.begin(), a.end());
sort(b.begin(), b.end());
sort(both.begin(), both.end());
for (int i = 0; i < a.size(); ++i) {
val = 1, idx = a[i].first;
upd(1, MAX - 1, 1);
}
for (int i = 0; i < b.size(); ++i) {
val = 1, idx = b[i].first;
upd(1, MAX - 1, 1);
}
vector<pair<pair<int, int>, long long> > tempBoth = both;
while (both.size() > k) {
val = 1, idx = both.back().first.first;
both.pop_back();
upd(1, MAX - 1, 1);
}
for (int i = 1; i < both.size(); ++i) {
both[i].second += both[i - 1].second;
}
long long ans = 1e18 + 18, totA = 0, totB = 0;
int cnt = 0;
bool findAnswer = 0;
for (int i = 0; i <= min(k, (int)min(a.size(), b.size())); ++i) {
if (i) {
val = -1, idx = a[i - 1].first;
upd(1, MAX - 1, 1);
totA += a[i - 1].first;
val = -1, idx = b[i - 1].first;
upd(1, MAX - 1, 1);
totB += b[i - 1].first;
}
int needK = k - i;
if (needK > both.size()) {
continue;
}
int rest = m - i * 2 - needK;
if (rest < 0 || tree[1][1] < rest) {
continue;
}
findAnswer = 1;
long long sol = totA + totB + (needK > 0 ? both[needK - 1].second : 0) +
(rest ? qwr(1, MAX - 1, 1, rest) : 0);
if (sol < ans) {
ans = sol;
cnt = i;
}
if (!both.empty()) {
val = -1, idx = both.back().first.first;
both.pop_back();
upd(1, MAX - 1, 1);
}
}
if (!findAnswer) {
printf("-1");
return 0;
}
printf("%d\n", ans);
for (int i = 0; i < cnt; ++i) {
printf("%d %d ", a[i].second, b[i].second);
}
int needK = k - cnt;
for (int i = 0; i < needK; ++i) {
printf("%d ", tempBoth[i].first.second);
}
int rest = m - 2 * cnt - needK;
if (rest < 0) {
return 0;
}
set<pair<int, int> > s;
for (int i = cnt; i < a.size(); ++i) {
s.insert(a[i]);
}
for (int i = cnt; i < b.size(); ++i) {
s.insert(b[i]);
}
for (int i = needK; i < tempBoth.size(); ++i) {
s.insert(tempBoth[i].first);
}
for (int i = 0; i < non.size(); ++i) {
s.insert(non[i]);
}
assert(rest <= s.size());
while (rest && !s.empty()) {
printf("%d ", s.begin()->second);
--rest;
s.erase(s.begin());
}
return 0;
}
| 11 | CPP |
#include <bits/stdc++.h>
using namespace std;
long long n;
long long k;
struct book {
bool a;
bool b;
int time;
};
book B[1000000];
bool compare(book x, book y) { return x.time < y.time; }
void solve() {
cin >> n;
cin >> k;
int x, y, z;
int as = 0;
int bs = 0;
int mx = 0;
for (int i = 0; i < n; i++) {
cin >> x >> y >> z;
B[i].a = y;
as += y;
bs += z;
B[i].b = z;
B[i].time = x;
mx = max(mx, B[i].time);
}
if (as < k || bs < k) {
cout << -1 << endl;
return;
}
sort(B, B + n, compare);
long long tot = 0;
int ak = 0;
int bk = 0;
stack<int> a;
stack<int> b;
for (int i = 0; i < n; i++) {
if (B[i].a && B[i].b) continue;
if (ak < k && B[i].a) {
ak++;
a.push(i);
tot += B[i].time;
}
if (bk < k && B[i].b) {
bk++;
tot += B[i].time;
b.push(i);
}
}
int lst = 0;
int used[1000000] = {0};
for (int i = 0; i < n; i++) {
if (ak < k && B[i].a && B[i].b) {
ak++;
tot += B[i].time;
if (b.size() && bk == k) {
tot -= B[b.top()].time;
b.pop();
}
if (bk < k) bk++;
lst = i;
used[i] = 1;
} else if (bk < k && B[i].a && B[i].b) {
bk++;
tot += B[i].time;
if (a.size() && ak == k) {
tot -= B[a.top()].time;
a.pop();
}
lst = i;
used[i] = 1;
if (ak < k) ak++;
}
}
for (int i = 0; i < n; i++) {
if (a.size() == 0 || b.size() == 0) break;
if (used[i]) continue;
int m = a.top();
int n = b.top();
if (B[i].a && B[i].b) {
if (B[i].time < B[m].time + B[n].time) {
tot = tot - (B[m].time + B[n].time);
tot += B[i].time;
a.pop();
b.pop();
}
}
}
cout << tot << endl;
return;
}
int main() {
int t;
t = 1;
while (t--) {
solve();
}
return 0;
}
| 11 | CPP |
def abc(l,n,i,x,y,m,k):
if x>=k and y>=k:
return m
if i==n:
return -1
ans=-1
ans=abc(l,n,i+1,x,y,m,k)
c=abc(l,n,i+1,x+l[i][1],y+l[i][2],m+l[i][0],k)
if c!=-1:
if ans==-1:
ans=c
else:
ans=min(ans,c)
return ans
n,k=map(int,input().split())
l=[]
for i in range(n):
l.append(list(map(int,input().split())))
#print(abc(l,n,0,0,0,0,k))
d={}
d[0,0]=[]
d[0,1]=[]
d[1,0]=[]
d[1,1]=[]
for i in l:
d[i[1],i[2]]+=[i[0]]
for i in d:
d[i]=sorted(d[i],reverse=True)
#print(d)
ans=0
while k>0:
if len(d[1,1])==0:
if len(d[0,1])==0 or len(d[1,0])==0:
break
ans+=d[0,1][-1]+d[1,0][-1]
del(d[0,1][-1])
del(d[1,0][-1])
k-=1
else:
if len(d[0,1])==0 or len(d[1,0])==0:
ans+=d[1,1][-1]
del(d[1,1][-1])
k-=1
else:
x=d[0,1][-1]+d[1,0][-1]
if x<=d[1,1][-1]:
ans+=d[0,1][-1]+d[1,0][-1]
del(d[0,1][-1])
del(d[1,0][-1])
k-=1
else:
ans+=d[1,1][-1]
del(d[1,1][-1])
k-=1
if k==0:
print(ans)
else:
print(-1)
| 11 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using ull = unsigned long long;
using ld = long double;
template <typename T1, typename T2>
inline void chkmin(T1 &x, const T2 &y) {
if (x > y) x = y;
}
template <typename T1, typename T2>
inline void chkmax(T1 &x, const T2 &y) {
if (x < y) x = y;
}
int n, m, k;
vector<pair<int, int>> a[4];
set<pair<int, int>> L, R;
int sumSet;
void read() {
cin >> n >> m >> k;
for (int i = 0; i < n; i++) {
int t, f1, f2;
cin >> t >> f1 >> f2;
a[f1 * 2 + f2].push_back({t, i});
}
for (int i = 0; i <= 3; i++) sort(a[i].begin(), a[i].end());
}
void relax(int sz) {
sz = max(sz, 0);
while (L.size() > sz) {
auto x = *(--L.end());
L.erase(--L.end());
sumSet -= x.first;
R.insert(x);
}
while (L.size() < sz) {
if (R.empty()) break;
auto x = *(R.begin());
R.erase(R.begin());
L.insert(x);
sumSet += x.first;
}
}
void add(pair<int, int> a) {
if (R.empty()) {
L.insert(a);
sumSet += a.first;
} else if (L.empty()) {
R.insert(a);
} else if (*(R.begin()) < a) {
R.insert(a);
} else {
L.insert(a);
sumSet += a.first;
}
}
int ans;
vector<int> fans;
void run() {
ans = 2e9 + 228 + 1337;
for (int it = 0; it < 2; it++) {
L.clear();
R.clear();
sumSet = 0;
int sum = 0;
int top1 = (int)a[1].size() - 1;
int top2 = (int)a[2].size() - 1;
for (auto i : a[0]) add(i);
for (auto i : a[1]) sum += i.first;
for (auto i : a[2]) sum += i.first;
for (int i = 0; i <= min(m, (int)a[3].size()); i++) {
if (i > 0) sum += a[3][i - 1].first;
while (top1 >= 0 && top1 + 1 + i > k) {
sum -= a[1][top1].first;
add(a[1][top1--]);
}
while (top2 >= 0 && top2 + 1 + i > k) {
sum -= a[2][top2].first;
add(a[2][top2--]);
}
if (min(top1, top2) + 1 + i < k) continue;
int sz = m - i - (top1 + 1) - (top2 + 1);
if (sz < 0) continue;
if (L.size() + R.size() < sz) continue;
relax(sz);
chkmin(ans, sum + sumSet);
if (!it || sum + sumSet != ans) continue;
for (auto j : L) {
fans.push_back(j.second);
}
for (int j = 0; j <= top1; j++) {
fans.push_back(a[1][j].second);
}
for (int j = 0; j <= top2; j++) {
fans.push_back(a[2][j].second);
}
for (int j = 0; j < i; j++) {
fans.push_back(a[3][j].second);
}
return;
}
}
cout << -1 << endl;
exit(0);
}
void write() {
cout << ans << endl;
sort(fans.begin(), fans.end());
for (auto i : fans) {
cout << i + 1 << " ";
}
cout << endl;
}
signed main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
read();
run();
write();
return 0;
}
| 11 | CPP |
n,k = map(int,input().split())
a = []
b = []
anb = []
for i in range(n):
x,y,z = map(int,input().split())
if(y == 0 and z == 1):
b.append(x)
elif(y==1 and z==0):
a.append(x)
elif(y==1 and z==1):
anb.append(x)
a.sort()
b.sort()
if(len(a) < len(b)):
b = b[:len(a)]
else:
a = a[:len(b)]
for i in range(len(a)):
a[i] += b[i]
anb += a
anb.sort()
ans = 0
if(len(anb) < k):
print(-1)
else:
print(sum(anb[:k]))
| 11 | PYTHON3 |
#import math
#from functools import lru_cache
import heapq
#from collections import defaultdict
#from collections import Counter
#from collections import deque
#from sys import stdout
#from sys import setrecursionlimit
#setrecursionlimit(10**7)
from sys import stdin
input = stdin.readline
INF = 2*10**9 + 7
MAX = 10**7 + 7
MOD = 10**9 + 7
n, M, k = [int(x) for x in input().strip().split()]
c, a, b, u = [], [], [], []
for ni in range(n):
ti, ai, bi = [int(x) for x in input().strip().split()]
if(ai ==1 and bi == 1):
c.append((ti, ni+1))
elif(ai == 1):
a.append((ti, ni+1))
elif(bi == 1):
b.append((ti, ni+1))
else:
u.append((ti, ni+1))
c.sort(reverse = True)
a.sort(reverse = True)
b.sort(reverse = True)
u.sort(reverse = True)
alen = len(a)
blen = len(b)
clen = len(c)
ulen = len(u)
#print(alen, blen, clen, ulen)
m = max(0, k - min(alen, blen), 2*k - M)
ans = 0
alist = []
adlist = []
#print(clen, m)
if(m>clen):
print('-1')
else:
for mi in range(m):
cv, ci = c.pop()
ans += cv
heapq.heappush(alist, (-cv, ci))
ka = k - m
kb = k - m
M -= m
while(ka or kb):
ca = (c[-1][0] if c else INF)
da = 0
ap, bp = 0, 0
if(ka):
da += (a[-1][0] if a else INF)
ap = 1
if(kb):
da += (b[-1][0] if b else INF)
bp = 1
if(da<=ca and M>=2):
ans += da
if(ap):
ka -= 1
adlist.append(a[-1] if a else (INF, -1))
if a: a.pop()
M -= 1
if(bp):
kb -= 1
adlist.append(b[-1] if b else (INF, -1))
if b: b.pop()
M -= 1
else:
ans += ca
heapq.heappush(alist, (-c[-1][0], c[-1][1]) if c else (INF, -1))
if c: c.pop()
if(ap):
ka -= 1
if(bp):
kb -= 1
M -= 1
#print('M and ans are', M, ans)
if(M>(len(a) + len(c) + len(b) + len(u)) or ans>=INF):
print('-1')
else:
heapq.heapify(c)
while(M>0):
#print('M and ans is : ', M, ans)
if(u and u[-1][0] <= min(c[0][0] if c else INF, a[-1][0] if a else INF, b[-1][0] if b else INF)):
ut, dt = 0, 0
ut += (-alist[0][0] if alist else 0)
ut += u[-1][0]
dt += (a[-1][0] if a else INF)
dt += (b[-1][0] if b else INF)
if(ut<dt):
# add from ulist
upopped = u.pop()
adlist.append(upopped)
M -= 1
ans += upopped[0]
else:
# remove from alist and add from ab
alpopped = (heapq.heappop(alist) if alist else (-INF, -1))
heapq.heappush(c, (-alpopped[0], alpopped[1]))
ans += alpopped[0]
bpopped = (b.pop() if b else (INF, -1))
apopped = (a.pop() if a else (INF, -1))
adlist.append(bpopped)
adlist.append(apopped)
ans += apopped[0]
ans += bpopped[0]
M -= 1
else:
# if c is less than a, b
ct = (c[0][0] if c else INF)
at, bt = (a[-1][0] if a else INF), (b[-1][0] if b else INF)
abt = min(at, bt)
if(ct<abt):
cpopped = (heapq.heappop(c) if c else (INF, -1))
heapq.heappush(alist, (-cpopped[0], cpopped[1]))
ans += cpopped[0]
M-=1
else:
# minimum is among a and b; straight forward
if(at<bt):
apopped = (a.pop() if a else (INF, -1))
adlist.append(apopped)
ans += apopped[0]
else:
bpopped = (b.pop() if b else (INF, -1))
adlist.append(bpopped)
ans += bpopped[0]
M-=1
if(ans>=INF): break
print(ans if ans<INF else '-1')
if(ans < INF):
for ai in adlist:
print(ai[1], end = ' ')
for ai in alist:
print(ai[1], end = ' ')
print('')
| 11 | PYTHON3 |
n, k = map(int, input().split())
main = []
for i in range(n):
l = list(map(int, input().split()))
main.append(l)
list01 = []
list10 = []
list11 = []
for i in main:
if i[1] == 0 and i[2] == 1:
list01.append(i)
elif i[1]== 1 and i[2] == 0:
list10.append(i)
elif i[1] == 1 and i[2] == 1:
list11.append(i)
list01.sort()
list10.sort()
newlist11 = []
l1 = len(list01)
l2 = len(list10)
sum = 0
for i in range(0, min(l1, l2)):
sum = list01[i][0] + list10[i][0]
newlist11.append([sum, 1, 1])
finallist = []
finallist = list11 + newlist11
finallist.sort()
add = 0
if len(finallist) < k:
print(-1)
else:
for i in range(0, k):
add += finallist[i][0]
print(add) | 11 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
const int INF = 2e9 + 1;
long long int m = 1000000007;
string toString(char x) {
string s(1, x);
return s;
}
long long int pow1(long long int x, long long int y) {
long long int temp;
if (y == 0) return 1;
temp = pow1(x, y / 2);
if (y % 2 == 0)
return (temp % m * temp % m) % m;
else
return ((x % m * temp % m) % m * temp % m) % m;
}
int main() {
int n, k;
cin >> n >> k;
vector<int> times[4];
vector<int> sums[4];
for (int i = 0; i < n; ++i) {
int t, a, b;
cin >> t >> a >> b;
times[a * 2 + b].push_back(t);
}
for (int i = 0; i < 4; ++i) {
sort(times[i].begin(), times[i].end());
sums[i].push_back(0);
for (auto it : times[i]) {
sums[i].push_back(sums[i].back() + it);
}
}
int ans = INF;
for (int cnt = 0; cnt < min(k + 1, int(sums[3].size())); ++cnt) {
if (k - cnt < int(sums[1].size()) && k - cnt < int(sums[2].size())) {
ans = min(ans, sums[3][cnt] + sums[1][k - cnt] + sums[2][k - cnt]);
}
}
if (ans == INF) ans = -1;
cout << ans << endl;
return 0;
}
| 11 | CPP |
from heapq import heappush, heappop
import math as m
n, k = map(int, input().split())
a_b = []
b_b = []
ab_b = []
for book in range(n):
t, a, b = map(int, input().split())
if a == 1 and b == 1:
heappush(ab_b, t)
elif a == 1:
heappush(a_b, t)
elif b ==1:
heappush(b_b, t)
a_like = 0
b_like = 0
result = 0
while True:
if a_like < k and b_like < k:
if len(ab_b) == 0:
if len(a_b) == 0:
print(-1)
exit()
else:
result += heappop(a_b)
a_like += 1
if len(b_b) == 0:
print(-1)
exit()
else:
result += heappop(b_b)
b_like += 1
else:
anext = a_b[0] if len(a_b) > 0 else m.inf
bnext = b_b[0] if len(b_b) > 0 else m.inf
if anext + bnext < ab_b[0]:
result += heappop(a_b)
a_like += 1
result += heappop(b_b)
b_like += 1
else:
result += heappop(ab_b)
a_like += 1
b_like += 1
elif a_like < k:
if len(ab_b) == 0 and len(a_b) == 0:
print(-1)
exit()
elif len(ab_b) == 0:
result += heappop(a_b)
elif len(a_b) == 0:
result += heappop(ab_b)
elif a_b[0] < ab_b[0]:
result += heappop(a_b)
else:
result += heappop(ab_b)
elif b_like < k:
if len(ab_b) == 0 and len(b_b) == 0:
print(-1)
exit()
elif len(ab_b) == 0:
result += heappop(b_b)
elif len(b_b) == 0:
result += heappop(ab_b)
elif b_b[0] < ab_b[0]:
result += heappop(b_b)
else:
result += heappop(ab_b)
else:
break
print(result)
| 11 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
struct jg {
int x, y, z;
};
jg a[200001];
int n, k, t1, t2, t3, mx, ans[200001], sum[200001], ans1[200001];
bool bj1[200001], bj2;
int main() {
int i, j;
cin >> n >> k;
for (i = 1; i <= n; i++) {
scanf("%d%d%d", &a[i].x, &a[i].y, &a[i].z);
if (a[i].y == 1 && a[i].z == 0) {
t1++;
ans[t1] = a[i].x;
}
if (a[i].y == 0 && a[i].z == 1) {
t2++;
sum[t2] = a[i].x;
}
if (a[i].y == 1 && a[i].z == 1) {
t3++;
ans1[t3] = a[i].x;
}
}
sort(ans + 1, ans + t1 + 1);
sort(sum + 1, sum + t2 + 1);
for (i = 1; i <= min(t1, t2); i++) {
t3++;
ans1[t3] = ans[i] + sum[i];
}
if (t3 < k) {
cout << -1 << endl;
return 0;
}
sort(ans1 + 1, ans1 + t3 + 1);
for (i = 1; i <= k; i++) {
mx += ans1[i];
}
cout << mx << endl;
return 0;
}
| 11 | CPP |
for _ in range(1):
n,k=map(int,input().split())
al = []
bo = []
com = []
for i in range(n):
t,a,b=map(int,input().split())
if a==b==1:
com.append(t)
else:
if a==1:
al.append(t)
if b==1:
bo.append(t)
com.sort(reverse=True)
al.sort(reverse=True)
bo.sort(reverse=True)
ans=0
f=0
while(k!=0):
if len(al)>0 and len(bo)>0:
c=al[-1]+bo[-1]
if len(com)>0 and c>com[-1]:
ans+=com[-1]
com.pop()
else:
ans+=c
al.pop()
bo.pop()
elif len(com)>0:
ans += com[-1]
com.pop()
else:
f=1
k=1
k-=1
if f==0:
print(ans)
else:
print(-1)
| 11 | PYTHON3 |
first_nums = input().split()
len_matris = int(first_nums[0])
k = int(first_nums[1])
books = []
for i in range(len_matris):
book = input().split()
books.append([int(x) for x in book])
liked_books = list(filter(lambda x: x[1] == 1 and x[2] ==1,books))
books_0_1 = list(filter(lambda x: x[1] == 0 and x[2] == 1,books))
books_1_0 = list(filter(lambda x: x[1] == 1 and x[2] == 0,books))
books_0_1.sort()
books_1_0.sort()
liked_books.sort()
result_books = []
for i in liked_books:
result_books.append(i[0])
for a,b in zip(books_1_0,books_0_1):
result_books.append(a[0]+b[0])
result_books.sort()
if len(books_1_0) + len(liked_books) < k or len(books_0_1) + len(liked_books) < k:
print(-1)
else:
print(sum(result_books[:k])) | 11 | PYTHON3 |
#reading books(easy version)
#code forces
#In the name of god the all mighty
if __name__=="__main__":
n,k=map(int,input().split())
both=list()
alice=list()
bob=list()
for i 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.sort(reverse=True)
alice.sort(reverse=True)
bob.sort(reverse=True)
al=k
bb=k
ans=0
while(True):
if(al<=0 or bb<=0):
break
if(not len(alice) and al>0):
if(not len(both)):
break
if(not len(bob) and bb>0):
if(not len(both)):
break
if(len(both) and len(alice) and len(bob)):
if(both[-1]<(alice[-1]+bob[-1])):
ans+=both[-1]
both.pop()
else:
ans+=alice[-1]+bob[-1]
alice.pop()
bob.pop()
al-=1
bb-=1
elif(len(alice) and len(bob)):
if(len(alice)):
al-=1
ans+=alice.pop()
if(len(bob)):
bb-=1
ans+=bob.pop()
else:
if(len(both)):
ans+=both.pop()
al-=1
bb-=1
if(al<=0 and bb<=0):
print(ans)
else:
print('-1')
| 11 | PYTHON3 |
import sys
from operator import add
t=1
def inp(): return sys.stdin.readline().strip()
for _ in range(t):
n, k=map(int, inp().split())
bothbooks=[]
abooks=[]
bbooks=[]
for i in range(n):
t, a, b= map(int,inp().split())
if( a==1 and b==1):
bothbooks.append(t)
elif(a==1 and b==0):
abooks.append(t)
elif(a==0 and b==1):
bbooks.append(t)
abooks.sort()
bbooks.sort()
#abbooks=list(map(add, abooks, bbooks))
abbooks = [a + b for a, b in zip(abooks, bbooks)]
abbooks = abbooks+bothbooks
abbooks.sort()
if(k>len(abbooks)):
print(-1)
else:
print(sum(abbooks[0:k])) | 11 | PYTHON3 |
# Author:Fuad Ashraful Mehmet ,CSE-UAP
import sys
input=sys.stdin.readline
n,k=map(int,input().split())
both=[]
alice=[]
bob=[]
for _ in range(n):
c,a,b=map(int,input().split())
if a and b:
both.append(c)
elif a:
alice.append(c)
elif b:
bob.append(c)
alice.sort()
bob.sort()
for a,b in zip(alice,bob):
both.append(a+b)
both.sort()
if len(both)<k:
print(-1)
else:
print(sum(both[:k])) | 11 | PYTHON3 |
import sys
input=sys.stdin.buffer.readline
n,k=[int(x) for x in input().split()]
books=[] #(ti,ai,bi)
for _ in range(n):
books.append([int(x) for x in input().split()])
books.sort(key=lambda x:x[0]) #sort by ti asc
aliceBooks=[0] #stores sum of book costs
bobBooks=[0]
bothBooks=[0]
for i in range(n):
ti,ai,bi=books[i]
if ai==1 and bi==0:
aliceBooks.append(aliceBooks[-1]+ti)
if ai==0 and bi==1:
bobBooks.append(bobBooks[-1]+ti)
if ai==1 and bi==1:
bothBooks.append(bothBooks[-1]+ti)
if min(len(aliceBooks)-1,len(bobBooks)-1)+len(bothBooks)-1<k:
print(-1) #impossible
else:
minT=99999999999999999999999999
for cnt in range(len(bothBooks)-1,-1,-1):
if cnt>k:
continue
if k-cnt>=min(len(aliceBooks),len(bobBooks)):
break
minT=min(minT,bothBooks[cnt]+aliceBooks[k-cnt]+bobBooks[k-cnt])
print(minT) | 11 | PYTHON3 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.