solution
stringlengths 11
983k
| difficulty
int64 0
21
| language
stringclasses 2
values |
|---|---|---|
n,k=list(map(int,input().split()))
x=[]
y=[]
z=[]
for i in range(n):
t,a,b=list(map(int,input().split()))
if a==1 and b==1:
z.append(t)
elif a==0 and b==1:
y.append(t)
elif a==1 and b==0:
x.append(t)
x1=len(x)
y1=len(y)
z1=len(z)
if min(x1,y1)+z1<k:
print(-1)
else:
x.sort()
y.sort()
s=min(x1,y1)
i=0
while i<s:
z.append(x[i]+y[i])
i+=1
z.sort()
print(sum(z[:k]))
| 11 | PYTHON3 |
# SortedList copied from: https://github.com/grantjenks/python-sortedcontainers/blob/master/sortedcontainers/sortedlist.py
# Minified with pyminifier to fit codeforce char limit
from __future__ import print_function
import sys
import traceback
from bisect import bisect_left, bisect_right, insort
from itertools import chain, repeat, starmap
from math import log
from operator import add, eq, ne, gt, ge, lt, le, iadd
from textwrap import dedent
try:
from collections.abc import Sequence, MutableSequence
except ImportError:
from collections import Sequence, MutableSequence
from functools import wraps
from sys import hexversion
if hexversion < 0x03000000:
from itertools import imap as map
from itertools import izip as zip
try:
from thread import get_ident
except ImportError:
from dummy_thread import get_ident
else:
from functools import reduce
try:
from _thread import get_ident
except ImportError:
from _dummy_thread import get_ident
def recursive_repr(fillvalue="..."):
def decorating_function(user_function):
repr_running = set()
@wraps(user_function)
def wrapper(self):
key = id(self), get_ident()
if key in repr_running:
return fillvalue
repr_running.add(key)
try:
result = user_function(self)
finally:
repr_running.discard(key)
return result
return wrapper
return decorating_function
class SortedList(MutableSequence):
DEFAULT_LOAD_FACTOR = 1000
def __init__(self, iterable=None, key=None):
assert key is None
self._len = 0
self._load = self.DEFAULT_LOAD_FACTOR
self._lists = []
self._maxes = []
self._index = []
self._offset = 0
if iterable is not None:
self._update(iterable)
def __new__(cls, iterable=None, key=None):
if key is None:
return object.__new__(cls)
else:
if cls is SortedList:
return object.__new__(SortedKeyList)
else:
raise TypeError("inherit SortedKeyList for key argument")
@property
def key(self):
return None
def _reset(self, load):
values = reduce(iadd, self._lists, [])
self._clear()
self._load = load
self._update(values)
def clear(self):
self._len = 0
del self._lists[:]
del self._maxes[:]
del self._index[:]
self._offset = 0
_clear = clear
def add(self, value):
_lists = self._lists
_maxes = self._maxes
if _maxes:
pos = bisect_right(_maxes, value)
if pos == len(_maxes):
pos -= 1
_lists[pos].append(value)
_maxes[pos] = value
else:
insort(_lists[pos], value)
self._expand(pos)
else:
_lists.append([value])
_maxes.append(value)
self._len += 1
def _expand(self, pos):
_load = self._load
_lists = self._lists
_index = self._index
if len(_lists[pos]) > (_load << 1):
_maxes = self._maxes
_lists_pos = _lists[pos]
half = _lists_pos[_load:]
del _lists_pos[_load:]
_maxes[pos] = _lists_pos[-1]
_lists.insert(pos + 1, half)
_maxes.insert(pos + 1, half[-1])
del _index[:]
else:
if _index:
child = self._offset + pos
while child:
_index[child] += 1
child = (child - 1) >> 1
_index[0] += 1
def update(self, iterable):
_lists = self._lists
_maxes = self._maxes
values = sorted(iterable)
if _maxes:
if len(values) * 4 >= self._len:
values.extend(chain.from_iterable(_lists))
values.sort()
self._clear()
else:
_add = self.add
for val in values:
_add(val)
return
_load = self._load
_lists.extend(
values[pos : (pos + _load)] for pos in range(0, len(values), _load)
)
_maxes.extend(sublist[-1] for sublist in _lists)
self._len = len(values)
del self._index[:]
_update = update
def __contains__(self, value):
_maxes = self._maxes
if not _maxes:
return False
pos = bisect_left(_maxes, value)
if pos == len(_maxes):
return False
_lists = self._lists
idx = bisect_left(_lists[pos], value)
return _lists[pos][idx] == value
def discard(self, value):
_maxes = self._maxes
if not _maxes:
return
pos = bisect_left(_maxes, value)
if pos == len(_maxes):
return
_lists = self._lists
idx = bisect_left(_lists[pos], value)
if _lists[pos][idx] == value:
self._delete(pos, idx)
def remove(self, value):
_maxes = self._maxes
if not _maxes:
raise ValueError("{0!r} not in list".format(value))
pos = bisect_left(_maxes, value)
if pos == len(_maxes):
raise ValueError("{0!r} not in list".format(value))
_lists = self._lists
idx = bisect_left(_lists[pos], value)
if _lists[pos][idx] == value:
self._delete(pos, idx)
else:
raise ValueError("{0!r} not in list".format(value))
def _delete(self, pos, idx):
_lists = self._lists
_maxes = self._maxes
_index = self._index
_lists_pos = _lists[pos]
del _lists_pos[idx]
self._len -= 1
len_lists_pos = len(_lists_pos)
if len_lists_pos > (self._load >> 1):
_maxes[pos] = _lists_pos[-1]
if _index:
child = self._offset + pos
while child > 0:
_index[child] -= 1
child = (child - 1) >> 1
_index[0] -= 1
elif len(_lists) > 1:
if not pos:
pos += 1
prev = pos - 1
_lists[prev].extend(_lists[pos])
_maxes[prev] = _lists[prev][-1]
del _lists[pos]
del _maxes[pos]
del _index[:]
self._expand(prev)
elif len_lists_pos:
_maxes[pos] = _lists_pos[-1]
else:
del _lists[pos]
del _maxes[pos]
del _index[:]
def _loc(self, pos, idx):
if not pos:
return idx
_index = self._index
if not _index:
self._build_index()
total = 0
pos += self._offset
while pos:
if not pos & 1:
total += _index[pos - 1]
pos = (pos - 1) >> 1
return total + idx
def _pos(self, idx):
if idx < 0:
last_len = len(self._lists[-1])
if (-idx) <= last_len:
return len(self._lists) - 1, last_len + idx
idx += self._len
if idx < 0:
raise IndexError("list index out of range")
elif idx >= self._len:
raise IndexError("list index out of range")
if idx < len(self._lists[0]):
return 0, idx
_index = self._index
if not _index:
self._build_index()
pos = 0
child = 1
len_index = len(_index)
while child < len_index:
index_child = _index[child]
if idx < index_child:
pos = child
else:
idx -= index_child
pos = child + 1
child = (pos << 1) + 1
return (pos - self._offset, idx)
def _build_index(self):
row0 = list(map(len, self._lists))
if len(row0) == 1:
self._index[:] = row0
self._offset = 0
return
head = iter(row0)
tail = iter(head)
row1 = list(starmap(add, zip(head, tail)))
if len(row0) & 1:
row1.append(row0[-1])
if len(row1) == 1:
self._index[:] = row1 + row0
self._offset = 1
return
size = 2 ** (int(log(len(row1) - 1, 2)) + 1)
row1.extend(repeat(0, size - len(row1)))
tree = [row0, row1]
while len(tree[-1]) > 1:
head = iter(tree[-1])
tail = iter(head)
row = list(starmap(add, zip(head, tail)))
tree.append(row)
reduce(iadd, reversed(tree), self._index)
self._offset = size * 2 - 1
def __delitem__(self, index):
if isinstance(index, slice):
start, stop, step = index.indices(self._len)
if step == 1 and start < stop:
if start == 0 and stop == self._len:
return self._clear()
elif self._len <= 8 * (stop - start):
values = self._getitem(slice(None, start))
if stop < self._len:
values += self._getitem(slice(stop, None))
self._clear()
return self._update(values)
indices = range(start, stop, step)
if step > 0:
indices = reversed(indices)
_pos, _delete = self._pos, self._delete
for index in indices:
pos, idx = _pos(index)
_delete(pos, idx)
else:
pos, idx = self._pos(index)
self._delete(pos, idx)
def __getitem__(self, index):
_lists = self._lists
if isinstance(index, slice):
start, stop, step = index.indices(self._len)
if step == 1 and start < stop:
if start == 0 and stop == self._len:
return reduce(iadd, self._lists, [])
start_pos, start_idx = self._pos(start)
start_list = _lists[start_pos]
stop_idx = start_idx + stop - start
if len(start_list) >= stop_idx:
return start_list[start_idx:stop_idx]
if stop == self._len:
stop_pos = len(_lists) - 1
stop_idx = len(_lists[stop_pos])
else:
stop_pos, stop_idx = self._pos(stop)
prefix = _lists[start_pos][start_idx:]
middle = _lists[(start_pos + 1) : stop_pos]
result = reduce(iadd, middle, prefix)
result += _lists[stop_pos][:stop_idx]
return result
if step == -1 and start > stop:
result = self._getitem(slice(stop + 1, start + 1))
result.reverse()
return result
indices = range(start, stop, step)
return list(self._getitem(index) for index in indices)
else:
if self._len:
if index == 0:
return _lists[0][0]
elif index == -1:
return _lists[-1][-1]
else:
raise IndexError("list index out of range")
if 0 <= index < len(_lists[0]):
return _lists[0][index]
len_last = len(_lists[-1])
if -len_last < index < 0:
return _lists[-1][len_last + index]
pos, idx = self._pos(index)
return _lists[pos][idx]
_getitem = __getitem__
def __setitem__(self, index, value):
message = "use ``del sl[index]`` and ``sl.add(value)`` instead"
raise NotImplementedError(message)
def __iter__(self):
return chain.from_iterable(self._lists)
def __reversed__(self):
return chain.from_iterable(map(reversed, reversed(self._lists)))
def reverse(self):
raise NotImplementedError("use ``reversed(sl)`` instead")
def islice(self, start=None, stop=None, reverse=False):
_len = self._len
if not _len:
return iter(())
start, stop, _ = slice(start, stop).indices(self._len)
if start >= stop:
return iter(())
_pos = self._pos
min_pos, min_idx = _pos(start)
if stop == _len:
max_pos = len(self._lists) - 1
max_idx = len(self._lists[-1])
else:
max_pos, max_idx = _pos(stop)
return self._islice(min_pos, min_idx, max_pos, max_idx, reverse)
def _islice(self, min_pos, min_idx, max_pos, max_idx, reverse):
_lists = self._lists
if min_pos > max_pos:
return iter(())
if min_pos == max_pos:
if reverse:
indices = reversed(range(min_idx, max_idx))
return map(_lists[min_pos].__getitem__, indices)
indices = range(min_idx, max_idx)
return map(_lists[min_pos].__getitem__, indices)
next_pos = min_pos + 1
if next_pos == max_pos:
if reverse:
min_indices = range(min_idx, len(_lists[min_pos]))
max_indices = range(max_idx)
return chain(
map(_lists[max_pos].__getitem__, reversed(max_indices)),
map(_lists[min_pos].__getitem__, reversed(min_indices)),
)
min_indices = range(min_idx, len(_lists[min_pos]))
max_indices = range(max_idx)
return chain(
map(_lists[min_pos].__getitem__, min_indices),
map(_lists[max_pos].__getitem__, max_indices),
)
if reverse:
min_indices = range(min_idx, len(_lists[min_pos]))
sublist_indices = range(next_pos, max_pos)
sublists = map(_lists.__getitem__, reversed(sublist_indices))
max_indices = range(max_idx)
return chain(
map(_lists[max_pos].__getitem__, reversed(max_indices)),
chain.from_iterable(map(reversed, sublists)),
map(_lists[min_pos].__getitem__, reversed(min_indices)),
)
min_indices = range(min_idx, len(_lists[min_pos]))
sublist_indices = range(next_pos, max_pos)
sublists = map(_lists.__getitem__, sublist_indices)
max_indices = range(max_idx)
return chain(
map(_lists[min_pos].__getitem__, min_indices),
chain.from_iterable(sublists),
map(_lists[max_pos].__getitem__, max_indices),
)
def irange(self, minimum=None, maximum=None, inclusive=(True, True), reverse=False):
_maxes = self._maxes
if not _maxes:
return iter(())
_lists = self._lists
if minimum is None:
min_pos = 0
min_idx = 0
else:
if inclusive[0]:
min_pos = bisect_left(_maxes, minimum)
if min_pos == len(_maxes):
return iter(())
min_idx = bisect_left(_lists[min_pos], minimum)
else:
min_pos = bisect_right(_maxes, minimum)
if min_pos == len(_maxes):
return iter(())
min_idx = bisect_right(_lists[min_pos], minimum)
if maximum is None:
max_pos = len(_maxes) - 1
max_idx = len(_lists[max_pos])
else:
if inclusive[1]:
max_pos = bisect_right(_maxes, maximum)
if max_pos == len(_maxes):
max_pos -= 1
max_idx = len(_lists[max_pos])
else:
max_idx = bisect_right(_lists[max_pos], maximum)
else:
max_pos = bisect_left(_maxes, maximum)
if max_pos == len(_maxes):
max_pos -= 1
max_idx = len(_lists[max_pos])
else:
max_idx = bisect_left(_lists[max_pos], maximum)
return self._islice(min_pos, min_idx, max_pos, max_idx, reverse)
def __len__(self):
return self._len
def bisect_left(self, value):
_maxes = self._maxes
if not _maxes:
return 0
pos = bisect_left(_maxes, value)
if pos == len(_maxes):
return self._len
idx = bisect_left(self._lists[pos], value)
return self._loc(pos, idx)
def bisect_right(self, value):
_maxes = self._maxes
if not _maxes:
return 0
pos = bisect_right(_maxes, value)
if pos == len(_maxes):
return self._len
idx = bisect_right(self._lists[pos], value)
return self._loc(pos, idx)
bisect = bisect_right
_bisect_right = bisect_right
def count(self, value):
_maxes = self._maxes
if not _maxes:
return 0
pos_left = bisect_left(_maxes, value)
if pos_left == len(_maxes):
return 0
_lists = self._lists
idx_left = bisect_left(_lists[pos_left], value)
pos_right = bisect_right(_maxes, value)
if pos_right == len(_maxes):
return self._len - self._loc(pos_left, idx_left)
idx_right = bisect_right(_lists[pos_right], value)
if pos_left == pos_right:
return idx_right - idx_left
right = self._loc(pos_right, idx_right)
left = self._loc(pos_left, idx_left)
return right - left
def copy(self):
return self.__class__(self)
__copy__ = copy
def append(self, value):
raise NotImplementedError("use ``sl.add(value)`` instead")
def extend(self, values):
raise NotImplementedError("use ``sl.update(values)`` instead")
def insert(self, index, value):
raise NotImplementedError("use ``sl.add(value)`` instead")
def pop(self, index=-1):
if not self._len:
raise IndexError("pop index out of range")
_lists = self._lists
if index == 0:
val = _lists[0][0]
self._delete(0, 0)
return val
if index == -1:
pos = len(_lists) - 1
loc = len(_lists[pos]) - 1
val = _lists[pos][loc]
self._delete(pos, loc)
return val
if 0 <= index < len(_lists[0]):
val = _lists[0][index]
self._delete(0, index)
return val
len_last = len(_lists[-1])
if -len_last < index < 0:
pos = len(_lists) - 1
loc = len_last + index
val = _lists[pos][loc]
self._delete(pos, loc)
return val
pos, idx = self._pos(index)
val = _lists[pos][idx]
self._delete(pos, idx)
return val
def index(self, value, start=None, stop=None):
_len = self._len
if not _len:
raise ValueError("{0!r} is not in list".format(value))
if start is None:
start = 0
if start < 0:
start += _len
if start < 0:
start = 0
if stop is None:
stop = _len
if stop < 0:
stop += _len
if stop > _len:
stop = _len
if stop <= start:
raise ValueError("{0!r} is not in list".format(value))
_maxes = self._maxes
pos_left = bisect_left(_maxes, value)
if pos_left == len(_maxes):
raise ValueError("{0!r} is not in list".format(value))
_lists = self._lists
idx_left = bisect_left(_lists[pos_left], value)
if _lists[pos_left][idx_left] != value:
raise ValueError("{0!r} is not in list".format(value))
stop -= 1
left = self._loc(pos_left, idx_left)
if start <= left:
if left <= stop:
return left
else:
right = self._bisect_right(value) - 1
if start <= right:
return start
raise ValueError("{0!r} is not in list".format(value))
def __add__(self, other):
values = reduce(iadd, self._lists, [])
values.extend(other)
return self.__class__(values)
__radd__ = __add__
def __iadd__(self, other):
self._update(other)
return self
def __mul__(self, num):
values = reduce(iadd, self._lists, []) * num
return self.__class__(values)
__rmul__ = __mul__
def __imul__(self, num):
values = reduce(iadd, self._lists, []) * num
self._clear()
self._update(values)
return self
def __make_cmp(seq_op, symbol, doc):
def comparer(self, other):
if not isinstance(other, Sequence):
return NotImplemented
self_len = self._len
len_other = len(other)
if self_len != len_other:
if seq_op is eq:
return False
if seq_op is ne:
return True
for alpha, beta in zip(self, other):
if alpha != beta:
return seq_op(alpha, beta)
return seq_op(self_len, len_other)
seq_op_name = seq_op.__name__
comparer.__name__ = "__{0}__".format(seq_op_name)
doc_str = """Return true if and only if sorted list is {0} `other`.
``sl.__{1}__(other)`` <==> ``sl {2} other``
Comparisons use lexicographical order as with sequences.
Runtime complexity: `O(n)`
:param other: `other` sequence
:return: true if sorted list is {0} `other`
"""
comparer.__doc__ = dedent(doc_str.format(doc, seq_op_name, symbol))
return comparer
__eq__ = __make_cmp(eq, "==", "equal to")
__ne__ = __make_cmp(ne, "!=", "not equal to")
__lt__ = __make_cmp(lt, "<", "less than")
__gt__ = __make_cmp(gt, ">", "greater than")
__le__ = __make_cmp(le, "<=", "less than or equal to")
__ge__ = __make_cmp(ge, ">=", "greater than or equal to")
__make_cmp = staticmethod(__make_cmp)
def __reduce__(self):
values = reduce(iadd, self._lists, [])
return (type(self), (values,))
@recursive_repr()
def __repr__(self):
return "{0}({1!r})".format(type(self).__name__, list(self))
def _check(self):
try:
assert self._load >= 4
assert len(self._maxes) == len(self._lists)
assert self._len == sum(len(sublist) for sublist in self._lists)
for sublist in self._lists:
for pos in range(1, len(sublist)):
assert sublist[pos - 1] <= sublist[pos]
for pos in range(1, len(self._lists)):
assert self._lists[pos - 1][-1] <= self._lists[pos][0]
for pos in range(len(self._maxes)):
assert self._maxes[pos] == self._lists[pos][-1]
double = self._load << 1
assert all(len(sublist) <= double for sublist in self._lists)
half = self._load >> 1
for pos in range(0, len(self._lists) - 1):
assert len(self._lists[pos]) >= half
if self._index:
assert self._len == self._index[0]
assert len(self._index) == self._offset + len(self._lists)
for pos in range(len(self._lists)):
leaf = self._index[self._offset + pos]
assert leaf == len(self._lists[pos])
for pos in range(self._offset):
child = (pos << 1) + 1
if child >= len(self._index):
assert self._index[pos] == 0
elif child + 1 == len(self._index):
assert self._index[pos] == self._index[child]
else:
child_sum = self._index[child] + self._index[child + 1]
assert child_sum == self._index[pos]
except:
traceback.print_exc(file=sys.stdout)
print("len", self._len)
print("load", self._load)
print("offset", self._offset)
print("len_index", len(self._index))
print("index", self._index)
print("len_maxes", len(self._maxes))
print("maxes", self._maxes)
print("len_lists", len(self._lists))
print("lists", self._lists)
raise
def identity(value):
return value
class SortedKeyList(SortedList):
def __init__(self, iterable=None, key=identity):
self._key = key
self._len = 0
self._load = self.DEFAULT_LOAD_FACTOR
self._lists = []
self._keys = []
self._maxes = []
self._index = []
self._offset = 0
if iterable is not None:
self._update(iterable)
def __new__(cls, iterable=None, key=identity):
return object.__new__(cls)
@property
def key(self):
return self._key
def clear(self):
self._len = 0
del self._lists[:]
del self._keys[:]
del self._maxes[:]
del self._index[:]
_clear = clear
def add(self, value):
_lists = self._lists
_keys = self._keys
_maxes = self._maxes
key = self._key(value)
if _maxes:
pos = bisect_right(_maxes, key)
if pos == len(_maxes):
pos -= 1
_lists[pos].append(value)
_keys[pos].append(key)
_maxes[pos] = key
else:
idx = bisect_right(_keys[pos], key)
_lists[pos].insert(idx, value)
_keys[pos].insert(idx, key)
self._expand(pos)
else:
_lists.append([value])
_keys.append([key])
_maxes.append(key)
self._len += 1
def _expand(self, pos):
_lists = self._lists
_keys = self._keys
_index = self._index
if len(_keys[pos]) > (self._load << 1):
_maxes = self._maxes
_load = self._load
_lists_pos = _lists[pos]
_keys_pos = _keys[pos]
half = _lists_pos[_load:]
half_keys = _keys_pos[_load:]
del _lists_pos[_load:]
del _keys_pos[_load:]
_maxes[pos] = _keys_pos[-1]
_lists.insert(pos + 1, half)
_keys.insert(pos + 1, half_keys)
_maxes.insert(pos + 1, half_keys[-1])
del _index[:]
else:
if _index:
child = self._offset + pos
while child:
_index[child] += 1
child = (child - 1) >> 1
_index[0] += 1
def update(self, iterable):
_lists = self._lists
_keys = self._keys
_maxes = self._maxes
values = sorted(iterable, key=self._key)
if _maxes:
if len(values) * 4 >= self._len:
values.extend(chain.from_iterable(_lists))
values.sort(key=self._key)
self._clear()
else:
_add = self.add
for val in values:
_add(val)
return
_load = self._load
_lists.extend(
values[pos : (pos + _load)] for pos in range(0, len(values), _load)
)
_keys.extend(list(map(self._key, _list)) for _list in _lists)
_maxes.extend(sublist[-1] for sublist in _keys)
self._len = len(values)
del self._index[:]
_update = update
def __contains__(self, value):
_maxes = self._maxes
if not _maxes:
return False
key = self._key(value)
pos = bisect_left(_maxes, key)
if pos == len(_maxes):
return False
_lists = self._lists
_keys = self._keys
idx = bisect_left(_keys[pos], key)
len_keys = len(_keys)
len_sublist = len(_keys[pos])
while True:
if _keys[pos][idx] != key:
return False
if _lists[pos][idx] == value:
return True
idx += 1
if idx == len_sublist:
pos += 1
if pos == len_keys:
return False
len_sublist = len(_keys[pos])
idx = 0
def discard(self, value):
_maxes = self._maxes
if not _maxes:
return
key = self._key(value)
pos = bisect_left(_maxes, key)
if pos == len(_maxes):
return
_lists = self._lists
_keys = self._keys
idx = bisect_left(_keys[pos], key)
len_keys = len(_keys)
len_sublist = len(_keys[pos])
while True:
if _keys[pos][idx] != key:
return
if _lists[pos][idx] == value:
self._delete(pos, idx)
return
idx += 1
if idx == len_sublist:
pos += 1
if pos == len_keys:
return
len_sublist = len(_keys[pos])
idx = 0
def remove(self, value):
_maxes = self._maxes
if not _maxes:
raise ValueError("{0!r} not in list".format(value))
key = self._key(value)
pos = bisect_left(_maxes, key)
if pos == len(_maxes):
raise ValueError("{0!r} not in list".format(value))
_lists = self._lists
_keys = self._keys
idx = bisect_left(_keys[pos], key)
len_keys = len(_keys)
len_sublist = len(_keys[pos])
while True:
if _keys[pos][idx] != key:
raise ValueError("{0!r} not in list".format(value))
if _lists[pos][idx] == value:
self._delete(pos, idx)
return
idx += 1
if idx == len_sublist:
pos += 1
if pos == len_keys:
raise ValueError("{0!r} not in list".format(value))
len_sublist = len(_keys[pos])
idx = 0
def _delete(self, pos, idx):
_lists = self._lists
_keys = self._keys
_maxes = self._maxes
_index = self._index
keys_pos = _keys[pos]
lists_pos = _lists[pos]
del keys_pos[idx]
del lists_pos[idx]
self._len -= 1
len_keys_pos = len(keys_pos)
if len_keys_pos > (self._load >> 1):
_maxes[pos] = keys_pos[-1]
if _index:
child = self._offset + pos
while child > 0:
_index[child] -= 1
child = (child - 1) >> 1
_index[0] -= 1
elif len(_keys) > 1:
if not pos:
pos += 1
prev = pos - 1
_keys[prev].extend(_keys[pos])
_lists[prev].extend(_lists[pos])
_maxes[prev] = _keys[prev][-1]
del _lists[pos]
del _keys[pos]
del _maxes[pos]
del _index[:]
self._expand(prev)
elif len_keys_pos:
_maxes[pos] = keys_pos[-1]
else:
del _lists[pos]
del _keys[pos]
del _maxes[pos]
del _index[:]
def irange(self, minimum=None, maximum=None, inclusive=(True, True), reverse=False):
min_key = self._key(minimum) if minimum is not None else None
max_key = self._key(maximum) if maximum is not None else None
return self._irange_key(
min_key=min_key, max_key=max_key, inclusive=inclusive, reverse=reverse,
)
def irange_key(
self, min_key=None, max_key=None, inclusive=(True, True), reverse=False
):
_maxes = self._maxes
if not _maxes:
return iter(())
_keys = self._keys
if min_key is None:
min_pos = 0
min_idx = 0
else:
if inclusive[0]:
min_pos = bisect_left(_maxes, min_key)
if min_pos == len(_maxes):
return iter(())
min_idx = bisect_left(_keys[min_pos], min_key)
else:
min_pos = bisect_right(_maxes, min_key)
if min_pos == len(_maxes):
return iter(())
min_idx = bisect_right(_keys[min_pos], min_key)
if max_key is None:
max_pos = len(_maxes) - 1
max_idx = len(_keys[max_pos])
else:
if inclusive[1]:
max_pos = bisect_right(_maxes, max_key)
if max_pos == len(_maxes):
max_pos -= 1
max_idx = len(_keys[max_pos])
else:
max_idx = bisect_right(_keys[max_pos], max_key)
else:
max_pos = bisect_left(_maxes, max_key)
if max_pos == len(_maxes):
max_pos -= 1
max_idx = len(_keys[max_pos])
else:
max_idx = bisect_left(_keys[max_pos], max_key)
return self._islice(min_pos, min_idx, max_pos, max_idx, reverse)
_irange_key = irange_key
def bisect_left(self, value):
return self._bisect_key_left(self._key(value))
def bisect_right(self, value):
return self._bisect_key_right(self._key(value))
bisect = bisect_right
def bisect_key_left(self, key):
_maxes = self._maxes
if not _maxes:
return 0
pos = bisect_left(_maxes, key)
if pos == len(_maxes):
return self._len
idx = bisect_left(self._keys[pos], key)
return self._loc(pos, idx)
_bisect_key_left = bisect_key_left
def bisect_key_right(self, key):
_maxes = self._maxes
if not _maxes:
return 0
pos = bisect_right(_maxes, key)
if pos == len(_maxes):
return self._len
idx = bisect_right(self._keys[pos], key)
return self._loc(pos, idx)
bisect_key = bisect_key_right
_bisect_key_right = bisect_key_right
def count(self, value):
_maxes = self._maxes
if not _maxes:
return 0
key = self._key(value)
pos = bisect_left(_maxes, key)
if pos == len(_maxes):
return 0
_lists = self._lists
_keys = self._keys
idx = bisect_left(_keys[pos], key)
total = 0
len_keys = len(_keys)
len_sublist = len(_keys[pos])
while True:
if _keys[pos][idx] != key:
return total
if _lists[pos][idx] == value:
total += 1
idx += 1
if idx == len_sublist:
pos += 1
if pos == len_keys:
return total
len_sublist = len(_keys[pos])
idx = 0
def copy(self):
return self.__class__(self, key=self._key)
__copy__ = copy
def index(self, value, start=None, stop=None):
_len = self._len
if not _len:
raise ValueError("{0!r} is not in list".format(value))
if start is None:
start = 0
if start < 0:
start += _len
if start < 0:
start = 0
if stop is None:
stop = _len
if stop < 0:
stop += _len
if stop > _len:
stop = _len
if stop <= start:
raise ValueError("{0!r} is not in list".format(value))
_maxes = self._maxes
key = self._key(value)
pos = bisect_left(_maxes, key)
if pos == len(_maxes):
raise ValueError("{0!r} is not in list".format(value))
stop -= 1
_lists = self._lists
_keys = self._keys
idx = bisect_left(_keys[pos], key)
len_keys = len(_keys)
len_sublist = len(_keys[pos])
while True:
if _keys[pos][idx] != key:
raise ValueError("{0!r} is not in list".format(value))
if _lists[pos][idx] == value:
loc = self._loc(pos, idx)
if start <= loc <= stop:
return loc
elif loc > stop:
break
idx += 1
if idx == len_sublist:
pos += 1
if pos == len_keys:
raise ValueError("{0!r} is not in list".format(value))
len_sublist = len(_keys[pos])
idx = 0
raise ValueError("{0!r} is not in list".format(value))
def __add__(self, other):
values = reduce(iadd, self._lists, [])
values.extend(other)
return self.__class__(values, key=self._key)
__radd__ = __add__
def __mul__(self, num):
values = reduce(iadd, self._lists, []) * num
return self.__class__(values, key=self._key)
def __reduce__(self):
values = reduce(iadd, self._lists, [])
return (type(self), (values, self.key))
@recursive_repr()
def __repr__(self):
type_name = type(self).__name__
return "{0}({1!r}, key={2!r})".format(type_name, list(self), self._key)
def _check(self):
try:
assert self._load >= 4
assert len(self._maxes) == len(self._lists) == len(self._keys)
assert self._len == sum(len(sublist) for sublist in self._lists)
for sublist in self._keys:
for pos in range(1, len(sublist)):
assert sublist[pos - 1] <= sublist[pos]
for pos in range(1, len(self._keys)):
assert self._keys[pos - 1][-1] <= self._keys[pos][0]
for val_sublist, key_sublist in zip(self._lists, self._keys):
assert len(val_sublist) == len(key_sublist)
for val, key in zip(val_sublist, key_sublist):
assert self._key(val) == key
for pos in range(len(self._maxes)):
assert self._maxes[pos] == self._keys[pos][-1]
double = self._load << 1
assert all(len(sublist) <= double for sublist in self._lists)
half = self._load >> 1
for pos in range(0, len(self._lists) - 1):
assert len(self._lists[pos]) >= half
if self._index:
assert self._len == self._index[0]
assert len(self._index) == self._offset + len(self._lists)
for pos in range(len(self._lists)):
leaf = self._index[self._offset + pos]
assert leaf == len(self._lists[pos])
for pos in range(self._offset):
child = (pos << 1) + 1
if child >= len(self._index):
assert self._index[pos] == 0
elif child + 1 == len(self._index):
assert self._index[pos] == self._index[child]
else:
child_sum = self._index[child] + self._index[child + 1]
assert child_sum == self._index[pos]
except:
traceback.print_exc(file=sys.stdout)
print("len", self._len)
print("load", self._load)
print("offset", self._offset)
print("len_index", len(self._index))
print("index", self._index)
print("len_maxes", len(self._maxes))
print("maxes", self._maxes)
print("len_keys", len(self._keys))
print("keys", self._keys)
print("len_lists", len(self._lists))
print("lists", self._lists)
raise
SortedListWithKey = SortedKeyList
################################ End copy and paste
import io
import os
def solve(N, M, K, books):
A = []
B = []
common = []
padding = SortedList()
paddingSum = 0
extras = SortedList()
for i, (t, a, b) in enumerate(books):
if a and b:
common.append(t)
elif a:
A.append(t)
elif b:
B.append(t)
else:
extras.add(t)
A.sort()
B.sort()
common.sort()
prefA = [0]
for t in A:
prefA.append(prefA[-1] + t)
prefB = [0]
for t in B:
prefB.append(prefB[-1] + t)
prefC = [0]
for t in common:
prefC.append(prefC[-1] + t)
# Check allowable number of common books
cMin = max(0, K - len(A), K - len(B), 2 * K - M)
cMax = min(K, len(common))
if cMin > cMax:
return -1
# Want to contain every book in: common[:c], B[: K - c], A[: K - c], padding, extras
# Starting with c = cMin
for i in range(cMin, len(common)):
extras.add(common[i])
for i in range(K - cMin, len(A)):
extras.add(A[i])
for i in range(K - cMin, len(B)):
extras.add(B[i])
best = (float("inf"),)
for c in range(cMin, cMax + 1):
# Take c common books to satisfy both
# Need K - c more from A and B each
assert 0 <= c <= len(common)
assert 0 <= K - c <= len(A)
assert 0 <= K - c <= len(B)
# Pad this up to make M books exactly
pad = M - c - (K - c) * 2
assert pad >= 0
# Fill padding from extras
while len(padding) < pad and extras:
x = extras[0]
extras.remove(x)
padding.add(x)
paddingSum += x
# Overflow padding to extras
while len(padding) > pad:
x = padding[-1]
padding.remove(x)
paddingSum -= x
extras.add(x)
if len(padding) == pad:
cost = prefC[c] + prefB[K - c] + prefA[K - c] + paddingSum
best = min(best, (cost, c))
# print(cost, common[:c], B[: K - c], A[: K - c], padding, extras)
assert c + (K - c) + (K - c) + len(padding) + len(extras) == N
if padding and extras:
assert padding[-1] <= extras[0]
# assert sum(padding) == paddingSum
if 0 <= K - c - 1 < len(A):
x = A[K - c - 1]
if padding and x <= padding[-1]:
padding.add(x)
paddingSum += x
else:
extras.add(x)
if 0 <= K - c - 1 < len(B):
x = B[K - c - 1]
if padding and x <= padding[-1]:
padding.add(x)
paddingSum += x
else:
extras.add(x)
if c < len(common):
x = common[c]
if x in extras:
extras.remove(x)
elif x in padding:
padding.remove(x)
paddingSum -= x
if best[0] == float("inf"):
return -1
needC = best[1]
needA = K - needC
needB = K - needC
needPad = M - needC - needB - needA
check = 0
ans = []
for i, (t, a, b) in sorted(enumerate(books), key=lambda ix: ix[1][0]):
if a and b:
if needC:
needC -= 1
ans.append(str(i + 1))
check += t
continue
if a:
if needA:
needA -= 1
ans.append(str(i + 1))
check += t
continue
if b:
if needB:
needB -= 1
ans.append(str(i + 1))
check += t
continue
if needPad:
needPad -= 1
ans.append(str(i + 1))
check += t
assert len(ans) == M
assert check == best[0]
return str(best[0]) + "\n" + " ".join(x for x in ans)
if False:
import random
random.seed(0)
N = 2 * 10**5
for i in range(1):
books = [
[random.randint(1, 20), random.randint(0, 1), random.randint(0, 1)]
for i in range(N)
]
solve(len(books), random.randint(1, 100), random.randint(1, 100), books)
if __name__ == "__main__":
input = io.BytesIO(os.read(0, os.fstat(0).st_size)).readline
N, M, K = [int(x) for x in input().split()]
books = [[int(x) for x in input().split()] for i in range(N)]
ans = solve(N, M, K, books)
print(ans)
| 11 | PYTHON3 |
n, k = list(map(int, input().split()))
both, ab, ba = [0], [0], [0]
for i in range(n):
t, a, b = list(map(int, input().split()))
if a == 1 and b == 1:
both.append(t)
elif a == 1:
ab.append(t)
elif b == 1:
ba.append(t)
both, ab, ba = sorted(both), sorted(ab), sorted(ba)
for i in range(1, len(both)):
both[i] = both[i] + both[i-1]
for i in range(1, len(ab)):
ab[i] = ab[i] + ab[i-1]
for i in range(1, len(ba)):
ba[i] = ba[i] + ba[i-1]
mini = None
for i in range(min(k+1, len(both))):
rest = k - i
if len(ab)-1 < rest or len(ba)-1 < rest:
pass
else:
cur = both[i] + ab[rest] + ba[rest]
mini = min(mini, cur) if mini is not None else cur
if mini is None:
print("-1")
else:
print(mini) | 11 | PYTHON3 |
# e_part_2_att_1.py
#attempted after contest
import sys
def input():
return sys.stdin.readline().rstrip()
def input_split():
return [int(i) for i in input().split()]
def add_book():
global freqs, cf, cp
# cost_change = 0
while(True):
if cf < freqs[cp]:
cf += 1
return cp
else:
cp += 1
cf = 0
def remove_book():
global freqs, cf, cp
# cost_change = 0
while(True):
if cf > 0:
cf -= 1
return (-cp)
else:
cp -= 1
cf = freqs[cp]
def make_available(b_time):
global freqs, cf, cp
freqs[b_time] += 1
if b_time < cp: #had a bug here
return b_time + remove_book()
else:
return 0
def make_unavailable(b_time):
global freqs, cf, cp
if b_time < cp: #had a bug here
freqs[b_time] -= 1
# a book was made unavailable that was being used
return (-b_time + add_book())
elif (b_time == cp and cf == freqs[cp]):
freqs[b_time] -= 1
cf -= 1
return (-b_time + add_book())
else:
freqs[b_time] -= 1
return 0 #no change
n,m, k = input_split()
times = []
alice_likes = []
bob_likes = []
for _ in range(n):
t, a, b = input_split()
times.append(t)
alice_likes.append(a)
bob_likes.append(b)
# if (sum(alice_likes) < k or sum(bob_likes)< k):
# ans = -1
# else:
#worst case choose all, but possible
times_both = []
times_alice = []
times_bob = []
times_none = []
# books_alice = []
for book in range(n):
if alice_likes[book] == 1 and bob_likes[book] == 1:
times_both.append((times[book], book))
elif alice_likes[book] == 1:
times_alice.append((times[book], book))
elif bob_likes[book] == 1:
times_bob.append((times[book], book))
else:
times_none.append((times[book], book))
# pass
times_both.sort()
times_alice.sort()
times_bob.sort()
# def split_list(lis):
# return ([a for (a,b) in lis],[b for (a,b) in lis])
# books_alice = [j for (i,j) in times_alice]
# times_alice =
started = False
possibilities = []
for i in range(k+1):
# print('i is {}'.format(i))
both = i
indi = (k - i) #decreases by 1 in each iter, frees up two books
extra = m - (both + 2*indi)
# print('both {}, indi {}, extra {}, nu m_both')
if both > len(times_both) or indi > min(len(times_alice), len(times_bob)) or extra < 0:
continue
if not started:
# print('Enter')
started = True #when i comment this it works on test 10, so mere else vale mei hi problem hai
#initialise
ans = sum([i for (i,j) in times_both[:both]])
ans += sum( [i for (i,j) in times_alice[:indi]])
ans += sum([ i for (i,j) in times_bob[:indi]])
freqs = [0 for i in range(10001)]
pending = (times_both[both:] + times_bob[indi:] + times_alice[indi:] + times_none)
for tim, _ in pending:
freqs[tim] += 1
cp = 0 #current pointer
cf = 0 #current fill
extra_cost = 0
count = 0
for _ in range(extra):
extra_cost += add_book()
ans += extra_cost
possibilities.append((ans,both))
else:
# print('shouldnt enter here')
# ans = 0
#manipulate state
last_ans = possibilities[-1][0]
ans = last_ans
new_book1_time = times_alice[indi][0]
new_book2_time = times_bob[indi][0]
old_book_time = times_both[both-1][0]
ans += old_book_time
ans -= new_book1_time
ans -= new_book2_time
ans += make_available(new_book1_time)
ans += make_available(new_book2_time)
ans += make_unavailable(old_book_time)
ans += add_book()
possibilities.append((ans,both))
# times_both = times_both + [100000]*(n- len(times_both))
# times_alice = times_alice + [100000]*(n- len(times_alice))
# times_bob = times_bob + [100000]*(n- len(times_bob))
# ans = 0
# p1, p2, p3 = 0, 0, 0
# for i in range(k):
# if (times_both[p1] <= times_alice[p2] + times_bob[p3]):
# ans += times_both[p1]
# p1 += 1
# else:
# ans += times_alice[p2] + times_bob[p3]
# p2 += 1
# p3 += 1
# times_bob
if len(possibilities) == 0:
print(-1)
else:
ans , both = min(possibilities)
# picked = [False for i in range(n)]
# for b in range(n):
indi = k - both
extra = m - (indi*2 + both)
books = []
books += [j for (i,j) in times_both[:both]]
books += [j for (i,j) in times_alice[:indi]]
books += [j for (i,j) in times_bob[:indi]]
pending = (times_both[both:] + times_bob[indi:] + times_alice[indi:] + times_none)
pending.sort()
books += [j for (i,j) in pending[:extra]]
books = [b+1 for b in books]
print(ans)
print(*books, sep = ' ')
#find the configuration and redo the stupid calculation
#do 4 passes over all books and get the ans
| 11 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
const int N = 4e5 + 10, mod = 1e9 + 7;
int bitc[N], bit[N];
int n;
void add(int i, int va) {
for (; i < N; i += (i & -i)) {
bit[i] += va;
bitc[i] += (va < 0 ? -1 : 1);
}
}
long long getprefones(int va) {
int i = 0;
int cur = 0;
long long ret = 0;
for (int j = 20; j >= 0; j--) {
if (i + (1 << j) < N && bitc[i + (1 << j)] + cur <= va) {
cur += bitc[i + (1 << j)];
ret += bit[i + (1 << j)];
i += (1 << j);
}
}
if (cur < va) ret = 2e9 + 5;
return ret;
}
int main() {
int tc = 1;
for (int cn = 1; cn <= tc; cn++) {
int m, k;
scanf("%d%d%d", &n, &m, &k);
vector<vector<pair<int, int>>> v(4);
vector<vector<int>> pref(4);
vector<pair<int, int>> vec;
for (int i = 1; i <= n; i++) {
int t, a, b;
scanf("%d%d%d", &t, &a, &b);
int m = (a * 2) + b;
v[m].push_back({t, i});
vec.push_back({t, i});
}
sort(vec.begin(), vec.end());
vector<int> id(n + 1);
for (int i = 0; i < n; i++)
add(i + 1, vec[i].first), id[vec[i].second] = i + 1;
for (int i = 0; i < 4; i++) {
sort(v[i].begin(), v[i].end());
if (v[i].size()) pref[i].push_back(v[i][0].first);
for (int j = 1; j < v[i].size(); j++)
pref[i].push_back(pref[i][j - 1] + v[i][j].first);
}
for (auto x : v[3]) add(id[x.second], -x.first);
long long ans = 2e9 + 10;
int b = -1;
for (int i = 0; i < k && i < v[1].size(); i++)
add(id[v[1][i].second], -v[1][i].first);
for (int i = 0; i < k && i < v[2].size(); i++)
add(id[v[2][i].second], -v[2][i].first);
int l = min(k, (int)v[1].size()) - 1;
int r = min(k, (int)v[2].size()) - 1;
if (2 * k <= m && l == k - 1 && r == k - 1) {
ans = min(ans, pref[1][k - 1] + pref[2][k - 1] + getprefones(m - 2 * k));
}
for (int i = 0; i < v[3].size(); i++) {
long long cur = pref[3][i];
int need = k - i - 1;
int h = i + 1 + 2 * max(0, need);
if (h > m) continue;
while (l >= need && l >= 0) {
add(id[v[1][l].second], v[1][l].first);
l--;
}
while (r >= need && r >= 0) {
add(id[v[2][r].second], v[2][r].first);
r--;
}
if ((int)v[1].size() < need || (int)v[2].size() < need) continue;
if (l >= 0) cur += pref[1][l] + pref[2][r];
cur += getprefones(m - h);
if (cur < ans) {
ans = cur;
b = i;
}
}
if (ans > 2e9)
puts("-1");
else {
printf("%lld\n", ans);
int need = k - b - 1;
vector<bool> vis(n + 1, 0);
for (int i = 0; i <= b; i++)
printf("%d ", v[3][i].second), vis[v[3][i].second] = 1;
for (int i = 0; i < v[3].size(); i++) vis[v[3][i].second] = 1;
for (int i = 0; i < need; i++)
printf("%d ", v[2][i].second), vis[v[2][i].second] = 1;
for (int i = 0; i < need; i++)
printf("%d ", v[1][i].second), vis[v[1][i].second] = 1;
int h = b + 1;
if (need > 0) h += 2 * need;
for (int i = 0; i < n && h < m; i++) {
if (vis[vec[i].second]) continue;
printf("%d ", vec[i].second);
h++;
}
}
}
return 0;
}
| 11 | CPP |
# for _ in range(int(input())):
# n,x = map(int,input().split())
# arr = list(map(int,input().split()))
# # b = []
# # for i in range(n):
# # t = []
# # for j in range(n):
# # t.append(arr[i]+arr[j])
# # b.append(t)
# f = 0
# k = n
# while k>=1:
# # print(k)
# i = 0
# while i<k:
# # print(i)
# j = i
# print(k,i,j)
# print(arr[i:i+k+1], arr[j:j+k+1])
# s = k*(sum(arr[i:i+k+1]) + sum(arr[j:j+k+1]))
# # print(s)
# if s==x:
# f+=1
# k-=1
# print(f)
# print(1000000000//499999993 , 1000000000%499999993)
# print(999999995//499999993 , 999999995%499999993)
# import math
# for _ in range(int(input())):
n,k1 = map(int,input().split())
c = []
a = []
b = []
for i in range(n):
x,y,z = map(int,input().split())
if y==z==1:
c.append(x)
elif y==1 and z==0:
a.append(x)
elif y==0 and z==1:
b.append(x)
a.sort()
b.sort()
c.sort()
# print(a,b,c)
ka = k1
kb = k1
i,j,k = 0,0,0
ans = 0
while ka>0 and kb>0 and i<len(a) and j<len(b) and k<len(c):
if a[i]+b[j]<=c[k]:
ans += a[i]+b[j]
ka-=1
kb-=1
i+=1
j+=1
else:
ans += c[k]
ka-=1
kb-=1
k+=1
if i>=len(a) and ka>0:
while k<len(c) and ka>0:
ans+=c[k]
k+=1
ka-=1
kb = max(0,kb-1)
elif j>=len(b) and kb>0:
while k<len(c) and kb>0:
ans+=c[k]
k+=1
ka = max(0,ka-1)
kb-=1
while i<len(a) and ka>0:
ans += a[i]
ka-=1
i+=1
while j<len(b) and kb>0:
ans+=b[j]
kb-=1
j+=1
if ka==kb==0:
print(ans)
else:
print(-1)
| 11 | PYTHON3 |
n, k = list(map(int, input().split()))
ar1 = []
ar2 = []
ar3 = []
for i in range(n):
ar = list(map(int, input().split()))
if ar[1] == 1 and ar[2] == 0:
ar1.append(ar)
elif ar[1] == 0 and ar[2] == 1:
ar2.append(ar)
elif ar[1] == ar[2] == 1:
ar3.append(ar)
ar1.sort()
ar2.sort()
ar3.sort()
i, j, h = 0, 0, 0
num1, num2 = k, k
ans = 0
while ((i < len(ar1) and j < len(ar2)) or h < len(ar3)) and num1 > 0 and num2 > 0:
if h >= len(ar3):
ans += ar1[i][0] + ar2[j][0]
i += 1
j += 1
elif i >= len(ar1) or j >= len(ar2):
ans += ar3[h][0]
h += 1
elif ar1[i][0] + ar2[j][0] > ar3[h][0]:
ans += ar3[h][0]
h += 1
else:
ans += ar1[i][0] + ar2[j][0]
i += 1
j += 1
num1 -= 1
num2 -= 1
if num1 > 0 or num2 > 0:
print(-1)
else:
print(ans)
| 11 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
bool rev(long long x, long long y) { return x > y; }
void input_arr(long long a[], long long n) {
for (long long i = 0; i < n; i += 1) cin >> a[i];
}
bool sortbysec(const pair<long long, long long> &a,
const pair<long long, long long> &b) {
return a.second < b.second;
}
bool sortinrev(const pair<long long, long long> &a,
const pair<long long, long long> &b) {
return (a.first > b.first);
}
void print_vec(vector<long long> &v) {
for (auto i : v) cout << i << " ";
cout << '\n';
}
bool sortinrevbysec(const pair<long long, long long> &a,
const pair<long long, long long> &b) {
return (a.second > b.second);
}
void print_arr(long long a[], long long n) {
for (long long i = 0; i < n; i += 1) cout << a[i] << " ";
cout << '\n';
}
template <typename... T>
void input(T &...args) {
((cin >> args), ...);
}
template <typename... T>
void print(T &&...args) {
((cout << args << '\n'), ...);
}
template <typename... T>
void deb(T &&...args) {
cout << "~~ ";
((cout << args << " "), ...);
cout << '\n';
}
void stand8th() {
long long n, k;
input(n, k);
long long t, a, b;
vector<long long> al, bo, bt;
long long no = 0;
for (long long i = 0; i < n; i += 1) {
input(t, a, b);
if (a == 1 && b == 1) {
bt.push_back(t);
} else if (a == 1) {
al.push_back(t);
} else if (b == 1) {
bo.push_back(t);
} else {
no++;
}
}
if ((long long)(al.size()) + (long long)(bo.size()) +
2 * (long long)(bt.size()) <
2 * k) {
print(-1);
return;
}
sort((al).begin(), (al).end());
sort((bo).begin(), (bo).end());
sort((bt).begin(), (bt).end());
for (long long i = 1; i < (long long)(al.size()); i += 1) al[i] += al[i - 1];
for (long long i = 1; i < (long long)(bo.size()); i += 1) bo[i] += bo[i - 1];
for (long long i = 1; i < (long long)(bt.size()); i += 1) bt[i] += bt[i - 1];
long long ans = INT64_MAX;
for (long long i = 0; i < min((long long)(bt.size()), k); i += 1) {
long long x = k - i - 1;
if (x != 0 && (long long)(al.size()) >= x && (long long)(bo.size()) >= x) {
ans = min(ans, bt[i] + al[x - 1] + bo[x - 1]);
} else {
if (x == 0) {
ans = min(ans, bt[i]);
}
}
}
if ((long long)(al.size()) >= k && (long long)(bo.size()) >= k) {
ans = min(ans, al[k - 1] + bo[k - 1]);
}
if (ans == INT64_MAX) {
ans = -1;
}
print(ans);
}
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
long long tin = 1;
while (tin--) {
stand8th();
}
return 0;
}
| 11 | CPP |
n,k=map(int,input().split())
a=0
b=0
alike=[]
blike=[]
bothlike=[]
for _ in range(n):
t,aa,bb=map(int,input().split())
if aa==1:
a+=1
if bb==1:
b+=1
if aa==1 and bb==0:
alike.append(t)
elif aa==0 and bb==1:
blike.append(t)
elif aa==1 and bb==1:
bothlike.append(t)
if a<k or b<k:
print(-1)
else:
alike.sort()
blike.sort()
la=len(alike)
lb=len(blike)
ans=0
if la<k and lb>=k:
for i in range(la):
bothlike.append(alike[i]+blike[i])
bothlike.sort()
ans=sum(bothlike[:k])
elif lb<k and la>=k:
for i in range(lb):
bothlike.append(alike[i]+blike[i])
bothlike.sort()
ans=sum(bothlike[:k])
elif la>=k and lb>=k:
for i in range(k):
bothlike.append(alike[i]+blike[i])
bothlike.sort()
ans=sum(bothlike[:k])
else:
for i in range(min(la,lb)):
bothlike.append(alike[i]+blike[i])
bothlike.sort()
ans=sum(bothlike[:k])
print(ans)
| 11 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
int N = INT_MAX;
long long INF1 = 1e9 + 5;
long long INF2 = 1e18L + 5;
map<long long, long long> my;
int h[10005];
int main() {
int n, k;
cin >> n >> k;
int chk1 = 0, chk2 = 0;
int a, b, c;
vector<int> v1, v2, v3;
for (int i = 0; i < n; i++) {
cin >> a >> b >> c;
if (b == 1 && c == 1) {
v1.push_back(a);
} else if (b == 1 && c == 0) {
v2.push_back(a);
} else if (b == 0 && c == 1) {
v3.push_back(a);
}
chk1 += b;
chk2 += c;
}
if (chk1 < k || chk2 < k) {
cout << -1;
return 0;
}
int n1 = v1.size(), n2 = v2.size(), n3 = v3.size();
int x = min(n2, n3);
sort(v2.begin(), v2.end());
sort(v3.begin(), v3.end());
for (int i = 0; i < x; i++) {
v1.push_back(v2[i] + v3[i]);
}
sort(v1.begin(), v1.end());
long long ans = 0;
for (int i = 0; i < k; i++) {
ans += v1[i];
}
cout << ans;
return 0;
}
| 11 | CPP |
import heapq
n, k = map(int, input().rstrip().split())
inn = []
inb = []
inc = []
for i in range(n):
a,b,c = map(int, input().rstrip().split())
if(b==0 and c==0):
continue
elif(b==1 and c==0):
inb.append(a)
elif(b==0 and c==1):
inc.append(a)
else:
inn.append(a)
heapq.heapify(inb)
heapq.heapify(inc)
heapq.heapify(inn)
ans = 0
while(k>0):
if(len(inb) and len(inc) and len(inn)):
if(inb[0]+inc[0]<inn[0]):
k1 = heapq.heappop(inb)
k2 = heapq.heappop(inc)
k-=1
ans += (k1+k2)
else:
k1 = heapq.heappop(inn)
ans += k1
k-=1
elif(len(inb) and len(inc)):
k1 = heapq.heappop(inb)
k2 = heapq.heappop(inc)
k-=1
ans += (k1+k2)
elif(len(inn)):
k1 = heapq.heappop(inn)
ans += k1
k-=1
else:
bool=False
break
if(bool==True or k==0):
print(ans)
else:
print(-1) | 11 | PYTHON3 |
from collections import defaultdict
n,k=map(int,input().split())
d=defaultdict(lambda: [0,0])
la=[]
lb=[]
lboth=[]
ca,cb,cboth=0,0,0
for x in range(n):
t,a,b=map(int,input().split())
if a==1 and b==1:
lboth.append(t)
cboth+=1
elif a==1:
la.append(t)
ca+=1
d[t][0]+=1
elif b==1:
lb.append(t)
d[t][1]+=1
cb+=1
if ca+cboth<k or cb+cboth<k:
print(-1)
else:
la.sort()
lb.sort()
lboth.sort()
coa,cob=0,0
ans=0
a,b,c=0,0,0
while((coa<k or cob<k)==True):
if c<cboth:
if a<ca and b<cb:
if lboth[c]<=(la[a]+lb[b]):
coa+=1
cob+=1
ans+=lboth[c]
c+=1
else:
coa+=1
cob+=1
ans+=la[a]+lb[b]
a+=1
b+=1
else:
coa+=1
cob+=1
ans+=lboth[c]
c+=1
else:
break
while(coa<k):
coa+=1
ans+=la[a]
a+=1
while(cob<k):
cob+=1
ans+=lb[b]
b+=1
print(ans)
| 11 | PYTHON3 |
n, k = map(int, input().split())
both, f, s = [], [], []
for i in range(n):
t, x, y = map(int, input().split())
if x == 1 and y == 1:
both.append(t)
elif x == 1:
f.append(t)
elif y == 1:
s.append(t)
if min(len(f),len(s)) + len(both) < k:
print(-1)
else:
both = sorted(both)
f = sorted(f)
s = sorted(s)
g = [both, f, s]
for l in g:
for j, v in enumerate(l):
if j > 0:
l[j] = l[j-1] + l[j]
#print(both, f, s)
#swap f and s
if len(f) > len(s):
b = f
f = s
s = b
mn = 5*(10**9)
if len(f) == 0:
mn = both[k-1]
for i in range(len(f)+1):
if i > k:
break
elif i > 0:
if i == k:
mn = min(f[i-1] + s[i-1], mn)
elif len(both) >= k - i:
mn = min(f[i-1] + s[i-1] + both[k-i-1], mn)
elif i == 0:
if len(both) >= k:
mn = both[k-1]
print(mn)
| 11 | PYTHON3 |
n, k = map(int, input().split())
both, alice, bob = [], [], []
for _ 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)
both.sort(reverse=True)
alice.sort(reverse=True)
bob.sort(reverse=True)
cnt = time = 0
while cnt < k and both and alice and bob:
if both[-1] <= alice[-1] + bob[-1]:
time += both.pop()
else:
time += alice.pop() + bob.pop()
cnt += 1
while cnt < k and both:
time += both.pop()
cnt += 1
while cnt < k and alice and bob:
time += alice.pop() + bob.pop()
cnt += 1
if cnt >= k:
print(time)
else:
print(-1) | 11 | PYTHON3 |
n,k = map(int,input().split())
d = []
l = []
a = []
b = []
for _ in range(n):
p,q,r = map(int,input().split())
if q == r :
if q == 0:
d.append(p)
else:
l.append(p)
else:
if q == 0 and r == 1:
b.append(p)
else:
a.append(p)
#print(a,b,l,d)
m = min(len(a),len(b))
if m + len(l) < k:
print(-1)
else:
# ans is there
a.sort()
b.sort()
s = [0]*m
for i in range(m):
s[i] = a[i]+b[i]
#print(s)
r = s+l
#print(r)
r.sort()
#print(r)
#print(r[:k])
print(sum(r[:k]))
| 11 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
void solve() {
int n, k;
cin >> n >> k;
vector<int> a, b, c;
for (int i = 0; i < n; i++) {
int x, y, z;
cin >> x >> y >> z;
if (y == 0 && z == 0)
continue;
else if (y == 1 && z == 0)
a.push_back(x);
else if (y == 0 && z == 1)
b.push_back(x);
else
c.push_back(x);
}
sort(a.begin(), a.end());
sort(b.begin(), b.end());
sort(c.begin(), c.end());
int n1 = a.size();
int n2 = b.size();
int n3 = c.size();
for (int i = 1; i < n1; i++) {
a[i] += a[i - 1];
}
for (int i = 1; i < n2; i++) {
b[i] += b[i - 1];
}
for (int i = 1; i < n3; i++) {
c[i] += c[i - 1];
}
int ans = INT_MAX;
int r = k;
if (r <= n1 && r <= n2) {
ans = min(ans, (r - 1 >= 0 ? a[r - 1] : 0) + (r - 1 >= 0 ? b[r - 1] : 0));
}
int s = 0;
for (int i = 0; i < k && i < n3; i++) {
int r = k - i - 1;
s = c[i];
if (r <= n1 && r <= n2) {
ans = min(ans,
s + (r - 1 >= 0 ? a[r - 1] : 0) + (r - 1 >= 0 ? b[r - 1] : 0));
}
}
if (n3 >= k) ans = min(ans, c[k - 1]);
if (ans == INT_MAX)
cout << "-1\n";
else
cout << ans << '\n';
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
int tt;
tt = 1;
while (tt--) solve();
return 0;
}
| 11 | CPP |
from sys import *
from math import *
n,k= map(int, stdin.readline().split())
x,y,z=[],[],[]
for i in range(n):
t,a,b= map(int, stdin.readline().split())
if a and b :
z.append(t)
elif a:
x.append(t)
elif b:
y.append(t)
x.sort()
y.sort()
for i in range(min(len(x),len(y))):
z.append(x[i]+y[i])
z.sort()
if len(z)<k:
print(-1)
else:
ans=0
for i in range(k):
ans+=z[i]
print(ans) | 11 | PYTHON3 |
def answer(n,k,l):
l.sort(key=lambda x:x[0])
a=[]
b=[]
ab=[]
for i in range(n):
if l[i][1]==1 and l[i][2]==1:
ab.append(l[i][0])
elif l[i][1]==1:
a.append(l[i][0])
elif l[i][2]==1:
b.append(l[i][0])
mini=min(len(a),len(b))
if mini+len(ab)<k:
return -1
t=0
ai=0
bi=0
abi=0
for i in range(k):
if ai<len(a) and bi<len(b) and abi<len(ab):
if a[ai]+b[bi]<=ab[abi]:
t+=a[ai]+b[bi]
ai+=1
bi+=1
else:
t+=ab[abi]
abi+=1
elif (ai>=len(a) or bi>=len(b)):
t+=ab[abi]
abi+=1
elif abi>=len(ab):
t+=a[ai]+b[bi]
ai+=1
bi+=1
return t
n,k=map(int,input().split())
l=[]
for i in range(n):
t=list(map(int,input().split()))
l.append(t)
print(answer(n,k,l)) | 11 | PYTHON3 |
import sys, os
from io import BytesIO, IOBase
from math import floor, gcd, fabs, factorial, fmod, sqrt, inf, log
from collections import defaultdict as dd, deque
from heapq import merge, heapify, heappop, heappush, nsmallest
from bisect import bisect_left as bl, bisect_right as br, bisect
# region fastio
BUFSIZE = 8192
class FastIO(IOBase):
newlines = 0
def __init__(self, file):
self._fd = file.fileno()
self.buffer = BytesIO()
self.writable = "x" in file.mode or "r" not in file.mode
self.write = self.buffer.write if self.writable else None
def read(self):
while True:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
if not b:
break
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines = 0
return self.buffer.read()
def readline(self):
while self.newlines == 0:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
self.newlines = b.count(b"\n") + (not b)
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines -= 1
return self.buffer.readline()
def flush(self):
if self.writable:
os.write(self._fd, self.buffer.getvalue())
self.buffer.truncate(0), self.buffer.seek(0)
class IOWrapper(IOBase):
def __init__(self, file):
self.buffer = FastIO(file)
self.flush = self.buffer.flush
self.writable = self.buffer.writable
self.write = lambda s: self.buffer.write(s.encode("ascii"))
self.read = lambda: self.buffer.read().decode("ascii")
self.readline = lambda: self.buffer.readline().decode("ascii")
stdin, stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)
mod = pow(10, 9) + 7
mod2 = 998244353
def inp(): return stdin.readline().strip()
def iinp(): return int(inp())
def out(var, end="\n"): stdout.write(str(var)+"\n")
def outa(*var, end="\n"): stdout.write(' '.join(map(str, var)) + end)
def lmp(): return list(mp())
def mp(): return map(int, inp().split())
def l1d(n, val=0): return [val for i in range(n)]
def l2d(n, m, val=0): return [l1d(m, val) for j in range(n)]
def ceil(a, b): return (a+b-1)//b
S1 = 'abcdefghijklmnopqrstuvwxyz'
S2 = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'
def isprime(x):
if x<=1: return False
if x in (2, 3): return True
if x%2 == 0: return False
for i in range(3, int(sqrt(x))+1, 2):
if x%i == 0: return False
return True
n, k = mp()
a, b, ab = l2d(3, 0)
for i in range(n):
x, y, z = mp()
if y==z==1:
ab.append(x)
elif y==1:
a.append(x)
elif z==1:
b.append(x)
if min(len(b), len(a))+len(ab)<k:
print(-1)
exit()
a.sort(reverse=True)
b.sort(reverse=True)
ab.sort(reverse=True)
ans = 0
i = 0
while i < k:
if len(a)==0 or len(b)==0:
ans += ab.pop()
elif len(ab)==0:
ans += a.pop() + b.pop()
else:
x, y, z = a[-1], b[-1], ab[-1]
if x+y < z:
ans += a.pop()+b.pop()
else:
ans += ab.pop()
i+=1
print(ans)
| 11 | PYTHON3 |
def next():
return [int(x) for x in input().split()]
class book:
def __init__(self, t, a, b):
self.t = t
self.a = a
self.b = b
if __name__ == '__main__':
n, k = next()
books = []
for _ in range(n):
t, a, b = next()
books.append(book(t, a, b))
oo = list(map(lambda x: x.t, filter(lambda x: x.a == 1 and x.b == 1, books)))
zo = list(sorted(map(lambda x: x.t, filter(lambda x: x.a == 0 and x.b == 1, books))))
oz = list(sorted(map(lambda x: x.t, filter(lambda x: x.a == 1 and x.b == 0, books))))
mi = min(len(zo), len(oz))
for i in range(mi):
oo.append(zo[i] + oz[i])
if len(oo) < k:
print(-1)
else:
print(sum(sorted(oo)[:k]))
| 11 | PYTHON3 |
from sys import stdout
from collections import defaultdict
import math
'''t=int(input())
for _ in range(t):
#n=int(input())
n,k=map(int,input().split())
l=list(map(int,input().split()))
l.sort(reverse=True)'''
n,k=map(int,input().split())
l=list()
d=defaultdict(list)
for i in range(n):
a,b,c=map(int,input().split())
s=str(b)+str(c)
d[s].append(a)
l1=sorted(d['11'])
l2=sorted(d['10'])
l3=sorted(d['01'])
ans=0
l4=list()
m=min(len(l2),len(l3))
for i in range(m):
l4.append(l2[i]+l3[i])
l=sorted(l1+l4)
if len(l)<k:
stdout.write(str(-1)+'\n')
else:
print(sum(l[:k]))
| 11 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
const long long INF = 1e16;
class segTree {
public:
vector<long long> t;
int n;
segTree(int n) {
t.resize(n * 2 + 5, 0);
this->n = n;
}
void build() {
for (int i = n - 1; i > 0; --i) t[i] = t[i << 1] + t[i << 1 | 1];
}
void update(int p, long long value) {
for (t[p += n] += value; p > 1; p >>= 1) t[p >> 1] = t[p] + t[p ^ 1];
}
long long query(int l, int r) {
long long ret = 0;
r++;
for (l += n, r += n; l < r; l >>= 1, r >>= 1) {
if (l & 1) ret += t[l++];
if (r & 1) ret += t[--r];
}
return ret;
}
};
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
long long n, m, k;
cin >> n >> m >> k;
vector<pair<long long, long long>> a, b, c, d;
for (long long i = 0; i < n; i++) {
long long x, y, z;
cin >> x >> y >> z;
if (y == 0 && z == 0) {
d.push_back({x, i});
continue;
}
if (y && z)
a.push_back({x, i});
else if (y && !z)
b.push_back({x, i});
else
c.push_back({x, i});
}
sort(a.begin(), a.end());
sort(b.begin(), b.end());
sort(c.begin(), c.end());
sort(d.begin(), d.end());
vector<long long> sumA(a.size() + 1, 0), sumB(b.size() + 1, 0),
sumC(c.size() + 1, 0), sumD(d.size() + 1, 0);
for (long long i = 0; i < a.size(); i++) {
sumA[i + 1] = sumA[i] + a[i].first;
}
for (long long i = 0; i < b.size(); i++) {
sumB[i + 1] = sumB[i] + b[i].first;
}
for (long long i = 0; i < c.size(); i++) {
sumC[i + 1] = sumC[i] + c[i].first;
}
for (long long i = 0; i < d.size(); i++) {
sumD[i + 1] = sumD[i] + d[i].first;
}
vector<unordered_set<long long>> curr(1e4 + 5);
segTree *T1 = new segTree(1e4 + 5), *T2 = new segTree(1e4 + 5);
for (long long i = 0; i < d.size(); i++) {
T1->update(d[i].first, 1);
T2->update(d[i].first, d[i].first);
curr[d[i].first].insert(d[i].second);
}
for (long long i = 0; i < b.size(); i++) {
T1->update(b[i].first, 1);
T2->update(b[i].first, b[i].first);
curr[b[i].first].insert(b[i].second);
}
for (long long i = 0; i < c.size(); i++) {
T1->update(c[i].first, 1);
T2->update(c[i].first, c[i].first);
curr[c[i].first].insert(c[i].second);
}
long long ret = INF, pos = -1, pos2 = -1, pos3 = -1;
long long posA = a.size(), posB = 0, posC = 0;
for (long long i = k; i >= 0; i--) {
if (i > a.size()) continue;
if ((k - i) > min(b.size(), c.size())) continue;
if (i + 2 * (k - i) > m) continue;
for (long long j = i; j < posA; j++) {
T1->update(a[j].first, 1);
T2->update(a[j].first, a[j].first);
curr[a[j].first].insert(a[j].second);
}
posA = i;
long long need = m - i - 2 * (k - i);
for (long long j = posB; j < k - i; j++) {
T1->update(b[j].first, -1);
T2->update(b[j].first, -b[j].first);
curr[b[j].first].erase(b[j].second);
}
for (long long j = posB; j < k - i; j++) {
T1->update(c[j].first, -1);
T2->update(c[j].first, -c[j].first);
curr[c[j].first].erase(c[j].second);
}
posB = k - i, posC = k - i;
if (T1->query(0, 1e4) < need) continue;
long long l = 1, r = 1e4;
long long minn = 1e4;
while (l <= r) {
long long mid = (l + r) / 2;
if (T1->query(0, mid) >= need) {
minn = min(minn, mid);
r = mid - 1;
} else
l = mid + 1;
}
long long tot = sumA[i] + sumB[k - i] + sumC[k - i];
long long have = T1->query(0, minn);
tot += T2->query(0, minn) - (have - need) * minn;
if (tot < ret) {
ret = tot;
pos = i;
}
}
if (pos == -1) cout << -1 << "\n", exit(0);
cout << ret << "\n";
for (long long i = 0; i < pos; i++) cout << a[i].second + 1 << " ";
for (long long i = 0; i < k - pos; i++)
cout << b[i].second + 1 << " " << c[i].second + 1 << " ";
T1 = new segTree(1e4 + 5), T2 = new segTree(1e4 + 5);
curr.assign(1e4 + 5, {});
for (long long i = 0; i < d.size(); i++) {
T1->update(d[i].first, 1);
T2->update(d[i].first, d[i].first);
curr[d[i].first].insert(d[i].second);
}
for (long long i = 0; i < b.size(); i++) {
T1->update(b[i].first, 1);
T2->update(b[i].first, b[i].first);
curr[b[i].first].insert(b[i].second);
}
for (long long i = 0; i < c.size(); i++) {
T1->update(c[i].first, 1);
T2->update(c[i].first, c[i].first);
curr[c[i].first].insert(c[i].second);
}
posA = a.size(), posB = 0, posC = 0;
for (long long i = k; i >= 0; i--) {
if (i > a.size()) continue;
if ((k - i) > min(b.size(), c.size())) continue;
if (i + 2 * (k - i) > m) continue;
for (long long j = i; j < posA; j++) {
T1->update(a[j].first, 1);
T2->update(a[j].first, a[j].first);
curr[a[j].first].insert(a[j].second);
}
posA = i;
long long need = m - i - 2 * (k - i);
for (long long j = posB; j < k - i; j++) {
T1->update(b[j].first, -1);
T2->update(b[j].first, -b[j].first);
curr[b[j].first].erase(b[j].second);
}
for (long long j = posB; j < k - i; j++) {
T1->update(c[j].first, -1);
T2->update(c[j].first, -c[j].first);
curr[c[j].first].erase(c[j].second);
}
posB = k - i, posC = k - i;
if (T1->query(0, 1e4) < need) continue;
long long l = 1, r = 1e4;
long long minn = 1e4;
while (l <= r) {
long long mid = (l + r) / 2;
if (T1->query(0, mid) >= need) {
minn = min(minn, mid);
r = mid - 1;
} else
l = mid + 1;
}
if (i == pos) {
for (long long j = 1; j < minn; j++) {
for (auto it : curr[j]) cout << it + 1 << " ", need--;
}
long long ct = 0;
for (auto it : curr[minn]) {
if (ct == need) break;
cout << it + 1 << " ";
ct++;
}
cout << "\n";
exit(0);
}
}
return 0;
}
| 11 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int M = 998244353;
vector<int> both, al, bob;
int k;
int good(int cnt, int mi, int ma) {
if (cnt > mi && (both[cnt - 1] > al[k - cnt] + bob[k - cnt])) return -1;
if (cnt < ma && (both[cnt] < al[k - cnt - 1] + bob[k - cnt - 1])) return 1;
return 0;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
;
int n;
cin >> n >> k;
for (int i = 0; i < n; i++) {
int t, a, b;
cin >> t >> a >> b;
if (a && b)
both.push_back(t);
else if (a)
al.push_back(t);
else if (b)
bob.push_back(t);
}
sort(both.begin(), both.end());
sort(al.begin(), al.end());
sort(bob.begin(), bob.end());
if ((int)min(al.size(), bob.size()) + both.size() < k)
cout << -1 << "\n";
else {
int mi = max(0, k - (int)min(al.size(), bob.size())),
ma = min(k, (int)both.size());
int i = mi, j = ma;
int res = -1;
while (j - i > 1) {
int mid = (i + j) >> 1;
int g = good(mid, mi, ma);
if (g < 0) j = mid;
if (g > 0) i = mid;
if (g == 0) {
res = mid;
break;
}
}
if (res < 0) {
if (good(j, mi, ma) == 0)
res = j;
else
res = i;
}
long long sol = 0;
for (i = 0; i < res; i++) sol += both[i];
for (i = 0; i < k - res; i++) sol += al[i] + bob[i];
cout << sol << "\n";
}
}
| 11 | CPP |
n,k=map(int,input().split())
l,l1,l2=[],[],[]
for i in range(n):
a,b,c=map(int,input().split())
if b==1 and c==1:
l.append(a)
elif b==1 and c==0:
l1.append(a)
elif b==0 and c==1:
l2.append(a)
l1.sort()
l2.sort()
for j in range(min(len(l1),len(l2))):
l.append(l1[j]+l2[j])
l.sort()
if len(l)<k:
print(-1)
else:
print(sum(l[:k])) | 11 | PYTHON3 |
from sys import stdin
inp = lambda : stdin.readline().strip()
n, k = [int(x) for x in inp().split()]
b = []
for _ in range(n):
b.append([int(x) for x in inp().split()])
both = []
alice = []
bob = []
for i in b:
if i[1] == 1 and i[2] == 1:
both.append(i[0])
elif i[1] == 1:
alice.append(i[0])
elif i[2] == 1:
bob.append(i[0])
if len(alice)+len(both) < k or len(bob) + len(both) <k:
print(-1)
exit()
both.sort()
alice.sort()
bob.sort()
b = 0
ind = 0
cost = 0
liked = 0
minimum = min(len(alice),len(bob))
x = max(k-minimum,0)
for i in range(x):
if liked == k:
print(cost)
exit()
cost += both[i]
b += 1
liked += 1
while True:
if liked == k:
print(cost)
break
if b < len(both) and ind<len(alice) and ind<len(bob) and both[b] <= alice[ind] + bob[ind]:
cost += both[b]
b += 1
else:
cost += alice[ind] + bob[ind]
ind += 1
liked += 1 | 11 | PYTHON3 |
book, k = map(int, input().split())
both, bob, alice = dict(), dict(), dict()
for i in range(book):
time, x, y = map(int, input().split())
if x == 1 and y == 0:
alice[i] = time
elif x == 0 and y == 1:
bob[i] = time
elif x == 1 and y == 1:
both[i] = time
if len(both) + len(alice) < k or len(both) + len(bob) < k:
print(-1)
exit()
else:
alice = sorted(alice.items(), key = lambda x : x[1])
bob = sorted(bob.items(), key = lambda x : x[1])
both = sorted(both.items(), key = lambda x : x[1])
count, x, y, z, time = 0, 0, 0, 0, 0
while count < k:
if x < len(alice) and y < len(bob) and z < len(both):
if alice[x][1] + bob[y][1] < both[z][1]:
time += alice[x][1] + bob[y][1]
x += 1
y += 1
count += 1
else:
time += both[z][1]
count += 1
z += 1
elif z >= len(both):
time += alice[x][1] + bob[y][1]
x += 1
y += 1
count += 1
else:
time += both[z][1]
count += 1
z += 1
print(time)
| 11 | PYTHON3 |
import sys
import functools
[n,k]=[int(i) for i in sys.stdin.readline().split()]
arr=[]
for x in range(n):
[t,a,b]=[int(j) for j in sys.stdin.readline().split()]
arr.append([t,a,b])
alice=0
bob=0
for g in range(n):
if(arr[g][1]==1):
alice+=1
if(arr[g][2]==1):
bob+=1
if(alice<k or bob<k):
print(-1)
else:
comb_arr=[]
f_arr=[]
s_arr=[]
for p in range(n):
if(arr[p][1]==1 and arr[p][2]==1):
comb_arr.append(arr[p][0])
elif(arr[p][1]==1):
f_arr.append(arr[p][0])
elif(arr[p][2]==1):
s_arr.append(arr[p][0])
f_arr.sort()
s_arr.sort()
for c in range(min(len(f_arr),len(s_arr))):
comb_arr.append(f_arr[c]+s_arr[c])
comb_arr.sort()
ans=sum(comb_arr[:k])
print(ans)
# a_arr=[]
# b_arr=[]
# for a in range(n):
# if(arr[a][1]==1):
# a_arr.append([arr[a][0],arr[a][1],arr[a][2],a])
# if(arr[a][2]==1):
# b_arr.append([arr[a][0],arr[a][1],arr[a][2],a])
# a_arr.sort()
# b_arr.sort()
# # alice first
# ax=0
# ans1=0
# d1={}
# for g in range(k):
# if(a_arr[g][2]==1):
# ax+=1
# d1[a_arr[g][3]]=1
# ans1+=a_arr[g][0]
# c1=0
# i1=0
# while(c1<k-ax):
# if(b_arr[i1][3] not in d1):
# ans1+=b_arr[i1][0]
# c1+=1
# i1+=1
# # bob first
# bx=0
# ans2=0
# d2={}
# for h in range(k):
# if(b_arr[h][1]==1):
# bx+=1
# d2[b_arr[h][3]]=1
# ans2+=b_arr[h][0]
# c2=0
# i2=0
# while(c2<k-bx):
# if(a_arr[i2][3] not in d2):
# ans2+=a_arr[i2][0]
# c2+=1
# i2+=1
# ans=min(ans1,ans2)
# print(ans)
| 11 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
const long long Mod = 1e5 + 7;
const int N = 2e6 + 5;
int arr[N];
int idx[4] = {0, 0, 0, 0};
vector<int> vec[4];
int take(int x) {
if (vec[x].size() <= idx[x]) return Mod;
return vec[x][idx[x]++];
}
int get(int x) {
if (vec[x].size() <= idx[x]) return Mod;
return arr[vec[x][idx[x]]];
}
bool comp(int x, int y) { return arr[x] < arr[y]; }
int main() {
ios::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
int numCases = 1;
for (int caseNo = 1; caseNo <= numCases; caseNo++) {
int n, k, m, sum_a = 0, sum_b = 0, sum = 0;
cin >> n >> m >> k;
set<int> ans;
for (int i = 0; i < n; i++) {
cin >> arr[i];
bool f, s;
cin >> f >> s;
if (f && s)
vec[0].push_back(i);
else if (f)
vec[1].push_back(i);
else if (s)
vec[2].push_back(i);
else
vec[3].push_back(i);
}
sort(vec[0].begin(), vec[0].end(), comp);
sort(vec[1].begin(), vec[1].end(), comp);
sort(vec[2].begin(), vec[2].end(), comp);
sort(vec[3].begin(), vec[3].end(), comp);
while (idx[0] < min({(int)vec[0].size(), m, k})) ans.insert(take(0));
sum_a = sum_b = idx[0];
while (sum_a < k) {
if (get(1) == Mod) break;
ans.insert(take(1));
sum_a++;
}
while (sum_b < k) {
if (get(2) == Mod) break;
ans.insert(take(2));
sum_b++;
}
while (ans.size() < m) {
int mn = 0;
for (int i = 1; i < 4; i++)
if (get(i) < get(mn)) mn = i;
if (idx[0] && get(1) + get(2) < arr[vec[0][idx[0] - 1]] + get(mn)) {
ans.erase(vec[0][--idx[0]]);
ans.insert(take(1));
ans.insert(take(2));
continue;
}
ans.insert(take(mn));
}
if (sum_a < k || sum_b < k || ans.size() > m) {
cout << -1 << endl;
continue;
}
for (auto u : ans) sum += arr[u];
cout << sum << '\n';
for (auto u : ans) cout << u + 1 << " ";
}
}
| 11 | CPP |
n, k = map(int,input().split())
ar11 = []
ar10 = []
ar01 = []
for i in range(n):
t,a,b = map(int, input().split())
if(a==1 and b==1):
ar11.append(t)
elif(a==1 and b==0):
ar10.append(t)
elif(a==0 and b==1):
ar01.append(t)
# print(ar11, ar10, ar01)
if(len(ar11) + min(len(ar10), len(ar01)) >= k):
ar10.sort()
ar01.sort()
for i in range(min(len(ar10), len(ar01))):
ar11.append(ar10[i] + ar01[i])
# print(ar11)
ar11.sort()
print(sum(ar11[:k]))
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];
void read() {
cin >> n >> m >> k;
for (int i = 0; i < n; i++) {
int t, f1, f2;
cin >> t >> f1 >> f2;
a[f1 * 2 + f2].push_back({t, i});
}
for (int i = 0; i <= 3; i++) sort(a[i].begin(), a[i].end());
}
set<pair<int, int>> L, R;
int sumSet;
void relax(int sz) {
sz = max(sz, 0);
while (L.size() > sz) {
auto x = *(--L.end());
L.erase(--L.end());
sumSet -= x.first;
R.insert(x);
}
while (L.size() < sz) {
if (R.empty()) break;
auto x = *(R.begin());
R.erase(R.begin());
L.insert(x);
sumSet += x.first;
}
}
void add(pair<int, int> a) {
if (R.empty()) {
L.insert(a);
sumSet += a.first;
} else if (L.empty()) {
R.insert(a);
} else if (*(R.begin()) < a) {
R.insert(a);
} else {
L.insert(a);
sumSet += a.first;
}
}
int ans;
vector<int> fans;
void getAns() {
ans = 2e9 + 228 + 1337;
for (int it = 0; it < 2; it++) {
L.clear();
R.clear();
sumSet = 0;
int sum = 0;
for (auto i : a[0]) add(i);
int top1 = a[1].size() - 1;
int top2 = a[2].size() - 1;
for (auto i : a[1]) sum += i.first;
for (auto i : a[2]) sum += i.first;
for (int i = 0; i <= min(m, (int)a[3].size()); i++) {
while (top1 >= 0 && top1 + 1 + i > k) {
sum -= a[1][top1].first;
add(a[1][top1]);
top1--;
}
while (top2 >= 0 && top2 + 1 + i > k) {
sum -= a[2][top2].first;
add(a[2][top2]);
top2--;
}
if (min(top1, top2) + 1 + i >= k) {
int sz = m - i - (top1 + 1) - (top2 + 1);
if (L.size() + R.size() >= sz) {
relax(sz);
if ((top1 + 1) + (top2 + 1) + i + (int)L.size() == m) {
ans = min(ans, sum + sumSet);
if (it == 1 && sum + sumSet == ans) {
for (auto j : L) {
fans.push_back(j.second);
}
for (int j = 0; j <= top1; j++) {
fans.push_back(a[1][j].second);
}
for (int j = 0; j <= top2; j++) {
fans.push_back(a[2][j].second);
}
for (int j = 0; j < i; j++) {
fans.push_back(a[3][j].second);
}
return;
}
}
}
}
if (i == a[3].size()) break;
sum += a[3][i].first;
}
}
cout << -1 << endl;
exit(0);
}
void run() { getAns(); }
void write() {
cout << ans << endl;
sort(fans.begin(), fans.end());
for (auto i : fans) {
cout << i + 1 << " ";
}
cout << endl;
}
signed main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
read();
run();
write();
return 0;
}
| 11 | CPP |
from sys import stdin
from collections import defaultdict as dd
from collections import deque as dq
import itertools as it
from math import sqrt, log, log2
from fractions import Fraction
n, k = map(int, input().split())
alike, blike = 0, 0
zero_one, one_zero, one_one, zero_zero = [], [], [], []
for i in range(n):
t, a, b = map(int, input().split())
alike += a
blike += b
if a == 0 and b == 1:
zero_one.append((t, i))
elif a == 1 and b == 0:
one_zero.append((t, i))
elif a== 1 and b== 1:
one_one.append((t, i))
else:
zero_zero.append((t, i))
if alike < k or blike < k:
print(-1)
exit()
zero_one.sort(key = lambda x: x[0])
one_one.sort(key = lambda x: x[0])
one_zero.sort(key = lambda x: x[0])
zero_zero.sort(key = lambda x: x[0])
alike, blike = 0, 0
zo, oo, oz, zz = 0, 0, 0, 0
lzo, loo, loz, lzz = len(zero_one), len(one_one), len(one_zero), len(zero_zero)
tottime = 0
books = []
while alike<k or blike<k:
# if oo >= loo and zo >= lzo and oz>=loz:
# break
# lbo = len(books)
# if lbo == m:
if alike <k and blike <k:
if oo>= loo and zo>=lzo and oz>=loz:
print(-1)
exit()
elif zo >= lzo or oz >= loz:
tottime += one_one[oo][0]
books.append(one_one[oo][1])
oo += 1
elif oo >= loo:
tottime += zero_one[zo][0] + one_zero[oz][0]
books.append(zero_one[zo][1])
books.append(zero_one[oz][1])
zo += 1
oz += 1
elif zero_one[zo][0] + one_zero[oz][0] < one_one[oo][0]:
tottime += zero_one[zo][0] + one_zero[oz][0]
books.append(zero_one[zo][1])
books.append(zero_one[oz][1])
zo += 1
oz += 1
else:
tottime += one_one[oo][0]
books.append(one_one[oo][1])
oo += 1
alike += 1
blike += 1
elif alike == k and blike < k:
if oo>=loo and zo>=lzo:
print(-1)
exit()
elif oo >= loo:
tottime += zero_one[zo][0]
books.append(zero_one[zo][1])
zo += 1
elif zo >= lzo:
tottime += one_one[oo][0]
books.append(one_one[oo][1])
oo += 1
elif zero_one[zo][0] < one_one[oo][0]:
tottime += zero_one[zo][0]
books.append(zero_one[zo][1])
zo += 1
else:
tottime += one_one[oo][0]
books.append(one_one[oo][1])
oo += 1
blike += 1
elif alike <k and blike == k:
if oo>=loo and oz>=loz:
print(-1)
exit()
elif oo>=loo:
tottime += one_zero[oz][0]
books.append(one_zero[oz][1])
oz += 1
elif oz>= loz:
tottime += one_one[oo][0]
books.append(one_one[oo][1])
oo += 1
elif one_zero[oz][0] < one_one[oo][0]:
tottime += one_zero[oz][0]
books.append(one_zero[oz][1])
oz += 1
else:
tottime += one_one[oo][0]
books.append(one_one[oo][1])
oo += 1
print(tottime)
# print(*books)
| 11 | PYTHON3 |
n,k=map(int,input().split())
share=[]
alice=[]
bob=[]
for i in range(n):
t,a,b=map(int,input().split())
if a and b:
share.append(t)
elif a:
alice.append(t)
elif b:
bob.append(t)
share.sort()
cs=[0]
for i in share:cs.append(cs[-1]+i)
alice.sort()
ca=[0]
for i in alice:ca.append(ca[-1]+i)
bob.sort()
cb=[0]
for i in bob:cb.append(cb[-1]+i)
an=float("INF")
for i in range(min(len(share),k)+1):
if len(alice)>=k-i and len(bob)>=k-i:
an=min(an,cs[i]+ca[k-i]+cb[k-i])
if an==float("INF"):print(-1)
else:print(an) | 11 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
inline int read() {
int x = 0;
char ch;
while (!isdigit(ch = getchar()))
;
x = ch - 48;
while (isdigit(ch = getchar())) x = x * 10 + ch - 48;
return x;
}
const int MAXN = 2e5 + 5;
int n, m, k;
vector<pair<int, int> > t[4], tmp;
vector<int> ans;
inline int calc(int x) {
int ned = max(0, k - x), tot = 0;
if (ned > min(t[1].size(), t[2].size())) return 1e9;
for (int i = 0; i < x; i++) tot += t[3][i].first;
for (int i = 0; i < ned; i++) tot += t[1][i].first + t[2][i].first;
tmp.clear();
for (auto p : t[0]) tmp.push_back(p);
for (int i = x; i < t[3].size(); i++) tmp.push_back(t[3][i]);
for (int i = ned; i < t[2].size(); i++) tmp.push_back(t[2][i]);
for (int i = ned; i < t[1].size(); i++) tmp.push_back(t[1][i]);
sort(tmp.begin(), tmp.end());
for (int i = 0; i < m - x - 2 * ned; i++) tot += tmp[i].first;
return tot;
}
int main() {
n = read(), m = read(), k = read();
int tp1 = 0, tp2 = 0, tp3 = 0;
for (int i = 1, x, a, b; i <= n; i++)
x = read(), a = read(), b = read(), t[2 * a + b].push_back(make_pair(x, i)),
tp1 += a, tp2 += b, tp3 += a & b;
if (tp1 < k || tp2 < k || 2 * k - tp3 > m) {
puts("-1");
return 0;
}
for (int i = 0; i <= 3; i++) sort(t[i].begin(), t[i].end());
int l = max(0, 2 * k - m), r = t[3].size();
while (l < r) {
int mid1 = (2 * l + r) / 3, mid2 = (2 * r + l + 2) / 3;
if (calc(mid1) < calc(mid2))
r = mid2 - 1;
else
l = mid1 + 1;
}
int ned = max(0, k - l), tot = 0;
for (int i = 0; i < l; i++)
tot += t[3][i].first, ans.push_back(t[3][i].second);
for (int i = 0; i < ned; i++)
tot += t[1][i].first + t[2][i].first, ans.push_back(t[1][i].second),
ans.push_back(t[2][i].second);
tmp.clear();
for (auto p : t[0]) tmp.push_back(p);
for (int i = l; i < t[3].size(); i++) tmp.push_back(t[3][i]);
for (int i = ned; i < t[2].size(); i++) tmp.push_back(t[2][i]);
for (int i = ned; i < t[1].size(); i++) tmp.push_back(t[1][i]);
sort(tmp.begin(), tmp.end());
for (int i = 0; i < m - l - 2 * ned; i++)
tot += tmp[i].first, ans.push_back(tmp[i].second);
printf("%d\n", tot);
for (int x : ans) printf("%d ", x);
return 0;
}
| 11 | CPP |
n, k = map(int, input().split())
a = []
b = []
both = []
for _ in range(n):
x, y, z = map(int, input().split())
if y == 1 and z == 1:
both.append(x)
elif y == 1:
a.append(x)
elif z == 1:
b.append(x)
a.sort()
b.sort()
for i in range(min(len(a), len(b))):
both.append(a[i]+b[i])
both.sort()
if len(both) < k:
print(-1)
else:
print(sum(both[:k]))
| 11 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, k;
cin >> n >> k;
multiset<int> v, v0, v1;
for (int i = 0; i < n; i++) {
int t, a, b;
cin >> t >> a >> b;
if (a == 0 && b == 0) continue;
if (a == 0 && b == 1) {
v1.insert(t);
}
if (a == 1 && b == 0) v0.insert(t);
if (a == 1 && b == 1) v.insert(t);
}
int c = 0;
int ans = 0;
while (c < k) {
if (v0.size() == 0 && v.size() == 0) {
cout << "-1";
return 0;
}
if (v1.size() == 0 && v.size() == 0) {
cout << "-1";
return 0;
}
if (v1.size() == 0) {
ans += *(v.begin());
v.erase(v.begin());
c++;
continue;
}
if (v0.size() == 0) {
ans += *(v.begin());
v.erase(v.begin());
c++;
continue;
}
if (v.size() == 0) {
ans += *(v1.begin()) + *(v0.begin());
v1.erase(v1.begin());
v0.erase(v0.begin());
c++;
continue;
}
if (*(v.begin()) < *(v1.begin()) + *(v0.begin())) {
ans += *(v.begin());
v.erase(v.begin());
c++;
} else {
ans += *(v1.begin()) + *(v0.begin());
v1.erase(v1.begin());
v0.erase(v0.begin());
c++;
}
}
cout << ans << endl;
}
| 11 | CPP |
#include <bits/stdc++.h>
using namespace std;
const double eps = 1e-8;
long long ii = 1;
void solve() {
long long n;
long long kk;
cin >> n >> kk;
vector<long long> alice;
vector<long long> bob;
vector<long long> all;
long long al = 0;
long long bo = 0;
for (long long i = 0; i < n; i++) {
long long t;
long long a;
long long b;
cin >> t >> a >> b;
if (a == 1 && b == 1) {
all.push_back(t);
al++;
bo++;
} else if (a == 1) {
al++;
alice.push_back(t);
} else if (b == 1) {
bo++;
bob.push_back(t);
}
}
if (al >= kk && bo >= kk) {
sort(all.begin(), all.end());
sort(alice.begin(), alice.end());
sort(bob.begin(), bob.end());
long long j = 0;
long long k = 0;
long long l = 0;
long long cn = 0;
long long ans = 0;
while (1) {
if (cn == kk) break;
if (j < all.size() && k < alice.size() && l < bob.size()) {
if (all[j] <= alice[k] + bob[l])
ans += all[j++];
else
ans += alice[k++] + bob[l++];
} else if (j < all.size())
ans += all[j++];
else
ans += alice[k++] + bob[l++];
cn++;
}
cout << ans << '\n';
} else
cout << "-1" << '\n';
}
int32_t main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
long long TestCase;
TestCase = 1;
while (TestCase--) solve();
return 0;
}
| 11 | CPP |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n, k;
cin >> n >> k;
vector<long long> a;
vector<long long> b;
vector<long long> m;
for (long long i = 0; i < n; i = i + 1) {
long long t, aa, bb;
cin >> t >> aa >> bb;
if (aa == 1 && bb == 0) {
a.push_back(t);
}
if (aa == 0 && bb == 1) {
b.push_back(t);
}
if (aa == 1 && bb == 1) {
m.push_back(t);
}
}
sort(a.begin(), a.end());
sort(b.begin(), b.end());
sort(m.begin(), m.end());
long long na = a.size();
long long nb = b.size();
long long nm = m.size();
for (long long i = 1; i < na; i = i + 1) a[i] += a[i - 1];
for (long long i = 1; i < nb; i = i + 1) b[i] += b[i - 1];
for (long long i = 1; i < nm; i = i + 1) m[i] += m[i - 1];
long long ans = 1e18;
if (na >= k && nb >= k) ans = a[k - 1] + b[k - 1];
long long mi = min(nm, k);
for (long long i = 0; i < mi; i = i + 1) {
if (k - i - 2 >= 0 && k - i - 2 < na && k - i - 2 < nb)
ans = min(ans, m[i] + a[k - i - 2] + b[k - i - 2]);
}
if (nm >= k) ans = min(ans, m[k - 1]);
if (ans == 1e18)
cout << -1 << endl;
else
cout << ans << endl;
}
| 11 | CPP |
# stdin = open("testdata.txt")
# def input():
# return stdin.readline().strip()
def addition(lst,k):
lst_alice = []
lst_bob = []
lst_both = []
addition_lst = []
lst.sort()
for i in range(len(lst)):
if lst[i][1] == 1 and lst[i][2] == 0:
lst_alice.append(lst[i])
elif lst[i][1] == 0 and lst[i][2] == 1:
lst_bob.append(lst[i])
elif lst[i][1] == 1 and lst[i][2] == 1:
lst_both.append(lst[i])
n = min(len(lst_alice),len(lst_bob))
addition_lst = [ [lst_alice[i][j]+lst_bob[i][j] for j in range(3)] for i in range(n)]
lst_both.extend(addition_lst)
lst_both.sort()
if len(lst_both) < k:
return -1
ret = 0
for i in range(k):
ret += lst_both[i][0]
return ret
n ,k = map(int,input().split())
lst = []
for _ in range(n):
lst.append(list(map(int,input().split())))
print(addition(lst, 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==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)+min(len(a),len(b))<k: print(-1)
else:
cost, ind, tog = 0,0,0
a.sort()
b.sort()
ab.sort()
for i in range(k):
if tog==len(ab):
cost += sum(a[ind:ind+(k-i)]) + sum(b[ind:ind+(k-i)])
break
elif ind==min(len(a),len(b)):
cost += sum(ab[tog:tog+(k-i)])
break
else:
if a[ind]+b[ind]<ab[tog]:
cost += a[ind]+b[ind]
ind+=1
else:
cost += ab[tog]
tog+=1
print(cost)
| 11 | PYTHON3 |
from collections import deque
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,input().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 |
import sys
input=sys.stdin.readline
n,k=list(map(int,input().split()))
c=[]
d=[]
e=[]
for i in range(n):
t,a,b=list(map(int,input().split()))
if a==1 and b==1:
c.append(t)
if a==0 and b==1:
d.append(t)
if a==1 and b==0:
e.append(t)
d.sort()
e.sort()
x=min(len(d),len(e))
for i in range(x):
c.append(d[i]+e[i])
c.sort()
if len(c)<k:
print(-1)
else:
print(sum(c[:k])) | 11 | PYTHON3 |
from collections import deque
n,k=map(int,input().split())
s,s1,s2=deque(),deque(),deque()
while(n):
t,a,b=map(int,input().split())
if(a==1 and b==1):
s.append(t)
if(a==1 and b==0):
s1.append(t)
if(a==0 and b==1):
s2.append(t)
n-=1
s=deque(sorted(s))
s1=deque(sorted(s1))
s2=deque(sorted(s2))
x,y,t=0,0,0
while(len(s) and len(s1) and len(s2)):
if(x==k or y==k):
break
if(s[0]<s1[0]+s2[0]):
x+=1
y+=1
t+=s[0]
s.popleft()
else:
t+=s1[0]+s2[0]
x+=1
y+=1
s1.popleft()
s2.popleft()
if(x!=k and y!=k and len(s1)==0):
while (x!=k and y!=k and len(s)!=0):
x+=1
y+=1
t+=s[0]
s.popleft()
if(x!=k and y!=k and len(s2)==0):
while (x!=k and y!=k and len(s)!=0):
x+=1
y+=1
t+=s[0]
s.popleft()
if(x!=k):
while(len(s1) and x!=k):
t+=s1[0]
s1.popleft()
x+=1
if(y!=k):
while (len(s2) and y!=k):
t+=s2[0]
s2.popleft()
y+=1
if(x==k and y==k):
print(t)
else:
print("-1") | 11 | PYTHON3 |
ve1 = []
ve2 = []
ve3 = []
s = input()
n, k = map(int,s.split(' '))
num1 = 0
num2 = 0
for i in range(0,n):
s = input()
t, a, b = map(int, s.split(' '))
if(a & b):
ve3.append(t)
num1 = num1 + 1
num2 = num2 + 1
elif(a == 0 and b == 1):
ve2.append(t)
num2 = num2 + 1
elif(a == 1 and b == 0):
ve1.append(t)
num1 = num1 + 1
ve1.sort()
ve2.sort()
ve3.sort()
if(num1 < k or num2 < k):
print(-1)
exit()
num = 0
num1 = 0
num2 = 0
Sum = 0
while(num < k):
if(num1 < len(ve1) and num1 < len(ve2) and num2 < len(ve3)):
if(ve1[num1] + ve2[num1] <= ve3[num2]):
Sum = Sum + ve1[num1] + ve2[num1]
num1 = num1 + 1
else:
Sum = Sum + ve3[num2]
num2 = num2 + 1
num = num + 1
else:
break
if(num == k):
print(Sum)
exit()
if(num2 < len(ve3)):
while(num < k):
Sum = Sum + ve3[num2]
num2 = num2 + 1
num = num + 1
else:
while(num < k):
Sum = Sum + ve1[num1] + ve2[num1]
num1 = num1 + 1
num = num + 1
print(Sum) | 11 | PYTHON3 |
n,k=map(int,input().split())
at=[]
bt=[]
both=[]
f=0
for x in range(n):
t,a,b=map(int,input().split())
if a==1 and b==1:
both.append(t)
elif a==1:
at.append(t)
elif b==1:
bt.append(t)
at.sort()
bt.sort()
both.sort()
i=0
j=0
if len(at)+len(both)<k or len(bt)+len(both)<k:
f=-1
else:
for x in range(k):
if i>=len(at) or i>=len(bt):
i=-1
if j>=len(both):
j=-1
if i==-1:
f+=both[j]
j+=1
elif j==-1:
f+=at[i]+bt[i]
i+=1
else:
if at[i]+bt[i]<both[j]:
f+=at[i]+bt[i]
i+=1
else:
f+=both[j]
j+=1
print(f)
| 11 | PYTHON3 |
from sys import stdin, stdout
input = stdin.readline
print = stdout.write
n, k = map(int, input().split())
alice, bob, together = [], [], []
for _ in range(n):
t, a, b = map(int, input().split())
if a and b:
together += t,
elif a:
alice += t,
elif b:
bob += t,
sa, sb, st = len(alice), len(bob), len(together)
if sa + st < k or sb + st < k:
print('-1')
exit()
alice.sort(reverse=True)
bob.sort(reverse=True)
together.sort(reverse=True)
time = 0
for i in range(k):
if sa == 0 or sb == 0:
time += together[-1]
together.pop()
st -= 1
elif st == 0:
time += alice[-1] + bob[-1]
alice.pop()
bob.pop()
sa -= 1
sb -= 1
else:
if together[-1] <= alice[-1] + bob[-1]:
time += together[-1]
together.pop()
st -= 1
else:
time += alice[-1] + bob[-1]
alice.pop()
bob.pop()
sa -= 1
sb -= 1
print(str(time)) | 11 | PYTHON3 |
n, k = map(int, input().split())
combine = []
alice = []
bob = []
ha = 0
haa = 0
for i in range(n):
a = list(map(int, input().strip().split()))
if (a[1] == 1 and a[2] == 0):
alice.append(a[0])
ha += 1
elif (a[1] == 0 and a[2] == 1):
bob.append(a[0])
haa += 1
elif (a[1] == 1 and a[2] == 1):
combine.append(a[0])
ha += 1
haa += 1
if ha < k or haa < k:
print(-1)
else:
bob.sort()
alice.sort()
combine.sort()
sum = []
ans = 0
mini = min(len(alice), len(bob))
for i in range(mini):
sum.append(bob[i]+alice[i])
for i in combine:
sum.append(i)
sum.sort()
for i in range(k):
ans += sum[i]
print(ans)
| 11 | PYTHON3 |
#include <CodeforcesSolutions.h>
#include <ONLINE_JUDGE <solution.cf(contestID = "1373",problemID = "B",method = "GET")>.h>
"""
Author : thekushalghosh
Team : CodeDiggers
I prefer Python language over the C++ language :p :D
Visit my website : thekushalghosh.github.io
"""
import sys,math,cmath,time
start_time = time.time()
##########################################################################
################# ---- THE ACTUAL CODE STARTS BELOW ---- #################
def solve():
n,k = invr()
q = []
w = []
qw = []
for i in range(n):
t,a,b = invr()
if a & b > 0:
qw.append(t)
elif a > 0:
q.append(t)
elif b > 0:
w.append(t)
q.sort()
w.sort()
for i in range(min(len(q),len(w))):
qw.append((q[i] + w[i]))
if len(qw) < k:
print(-1)
else:
print(sum(sorted(qw)[:k]))
################## ---- THE ACTUAL CODE ENDS ABOVE ---- ##################
##########################################################################
def main():
global tt
if not ONLINE_JUDGE:
sys.stdin = open("input.txt","r")
sys.stdout = open("output.txt","w")
t = 1
for tt in range(t):
solve()
if not ONLINE_JUDGE:
print("Time Elapsed :",time.time() - start_time,"seconds")
sys.stdout.close()
#---------------------- USER DEFINED INPUT FUNCTIONS ----------------------#
def inp():
return(int(input()))
def inlt():
return(list(map(int,input().split())))
def insr():
return(input().strip())
def invr():
return(map(int,input().split()))
#------------------ USER DEFINED PROGRAMMING FUNCTIONS ------------------#
def counter(a):
q = dict()
for i in range(len(a)):
if a[i] not in q:
q[a[i]] = 0
q[a[i]] = q[a[i]] + 1
return(q)
def string_counter(a):
q = [0] * 26
for i in range(len(a)):
q[ord(a[i]) - 97] = q[ord(a[i]) - 97],1
return(q)
def factors(n):
q = []
for i in range(1,int(n ** 0.5) + 1):
if n % i == 0: q.append(i); q.append(n // i)
return(list(sorted(list(set(q)))))
def prime_factors(n):
q = []
while n % 2 == 0: q.append(2); n = n // 2
for i in range(3,int(n ** 0.5) + 1,2):
while n % i == 0: q.append(i); n = n // i
if n > 2: q.append(n)
return(list(sorted(q)))
#-----------------------------------------------------------------------#
ONLINE_JUDGE = __debug__
if ONLINE_JUDGE:
input = sys.stdin.readline
main() | 11 | PYTHON3 |
# reading_books.py
from collections import defaultdict
n,k = map(int,input().split())
my_dick = {}
my_dick = defaultdict(lambda:list(),my_dick)
for i in range(n):
a,b,c = map(int,input().split())
if b+c==2:
my_dick[b+c].append(a)
elif b==0 and c == 1:
my_dick[b+3].append(a)
elif c==0 and b == 1:
my_dick[c+4].append(a)
# if len(my_dick[2])>=k:
my_dick[2] = sorted(my_dick[2])
my_dick[3].sort()
my_dick[4].sort()
i = 0
while len(my_dick[3])>0 and len(my_dick[4])>0:
my_dick[2].append(my_dick[3][i]+my_dick[4][i])
my_dick[3].remove(my_dick[3][i])
my_dick[4].remove(my_dick[4][i])
my_dick[2].sort()
if len(my_dick[2])>=k:
print(sum(my_dick[2][:k]))
else:
print("-1") | 11 | PYTHON3 |
import sys
input = sys.stdin.readline
n,minn = map(int,input().split())
a = []
ca, cb = 0, 0
for i in range(n):
t,x,y = map(int,input().split())
if x==1:
ca += 1
if y==1:
cb += 1
a.append((t,x,y))
if ca<minn or cb<minn:
print (-1)
exit()
ca,cb = 0,0
alice = []
bob = []
both = []
for i in range(n):
if a[i][1]==a[i][2]==1:
both.append(a[i][0])
elif a[i][1]!=a[i][2]:
if a[i][1]==1:
alice.append(a[i][0])
else:
bob.append(a[i][0])
alice.sort()
bob.sort()
both.sort()
# print (alice)
# print (bob)
# print (both)
i,j,k = 0,0,0
ans = 0
while ca<minn or cb<minn:
if (i<len(alice) and j<len(bob) and k<len(both)) and alice[i]+bob[j]<=both[k]:
ans += alice[i]+bob[j]
ca += 1
cb += 1
i += 1
j += 1
elif (i<len(alice) and j<len(bob) and k<len(both)) and alice[i]+bob[j]>=both[k]:
ans += both[k]
ca += 1
cb += 1
k += 1
else:
break
if i==len(alice):
while ca<minn:
ans += both[k]
k += 1
ca += 1
cb += 1
if j==len(bob):
while cb<minn:
ans += both[k]
k += 1
ca += 1
cb += 1
if k==len(both):
while ca<minn:
ans += alice[i]
i += 1
ca += 1
while cb<minn:
ans += bob[j]
j += 1
cb += 1
print (ans) | 11 | PYTHON3 |
n,k=map(int,input().split())
a,b,c=[],[],[]
for i in range(n):
t,x,y=map(int,input().split())
if x==y==1:c.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))):
c.append(a[i]+b[i])
c.sort()
if len(c)<k:print(-1)
else:print(sum(c[:k])) | 11 | PYTHON3 |
a,k = map(int,input().split())
l1=[]
l2=[]
l3=[]
for i in range(a):
b,c,d = map(int,input().split())
if(c==1 and d==1):
l3.append(b)
elif(c==1):
l1.append(b)
elif(d==1):
l2.append(b)
l1 = sorted(l1)
l2 = sorted(l2)
l3 = sorted(l3)
if((len(l1)+len(l3))<k or (len(l2)+len(l3))<k):
print(-1)
else:
d=0
k1=0
k2=0
k3=0
for i in range(k):
if(len(l3)>k3 and (len(l1)>k1 and len(l2)>k2)):
if(l3[k3]<(l1[k1]+l2[k2])):
d+=l3[k3]
k3+=1
else:
d+=l1[k1]+l2[k2]
k1+=1
k2+=1
else:
if(k3<len(l3)):
d+=l3[k3]
k3+=1
else:
d+=l1[k1]+l2[k2]
k1+=1
k2+=1
print(d)
| 11 | PYTHON3 |
n, k = map(int, input().split())
lForE = []
lForA = []
lForB = []
cnt = 0
forE = 0
forP = 0
ans = 0
for i in range(n):
temp = list(map(int, input().split()))
if temp[1] and temp[2]:
lForE.append(temp[0])
elif temp[1] and not temp[2]:
lForA.append(temp[0])
elif not temp[1] and temp[2]:
lForB.append(temp[0])
lForE.sort()
lForA.sort()
lForB.sort()
while cnt < k and ((forP < len(lForB) and forP < len(lForA)) or forE < len(lForE)):
cnt += 1
if forP < len(lForB) and forP < len(lForA) and forE < len(lForE):
if lForA[forP] + lForB[forP] < lForE[forE]:
ans += lForA[forP] + lForB[forP]
forP += 1
else:
ans += lForE[forE]
forE += 1
elif forE < len(lForE):
ans += lForE[forE]
forE += 1
elif forP < len(lForB) and forP < len(lForA):
ans += lForA[forP] + lForB[forP]
forP += 1
if cnt < k:
print(-1)
else:
print(ans)
| 11 | PYTHON3 |
"""
// Author : snape_here - Susanta Mukherjee
"""
from __future__ import division, print_function
import os,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
def ii(): return int(input())
def fi(): return float(input())
def si(): return input()
def msi(): return map(str,input().split())
def mi(): return map(int,input().split())
def li(): return list(mi())
def read():
sys.stdin = open('input.txt', 'r')
sys.stdout = open('output.txt', 'w')
def gcd(x, y):
while y:
x, y = y, x % y
return x
mod=1000000007
from math import log,log2,sqrt,factorial,cos,tan,sin,radians,ceil,floor
import bisect
from decimal import *
abc="abcdefghijklmnopqrstuvwxyz"
pi=3.141592653589793238
def main():
n,k=mi()
l=[]
l1=[]
l2=[]
for i in range(n):
x,y,z=mi()
if y and z:
l.append(x)
elif y:
l1.append(x)
elif z:
l2.append(x)
l1.sort()
l2.sort()
for i in range(min(len(l1),len(l2))):
l.append(l1[i]+l2[i])
l.sort()
if len(l)<k:
print(-1)
else:
ans=sum(l[0:k])
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")
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)
input = lambda: sys.stdin.readline().rstrip("\r\n")
# endregion
if __name__ == "__main__":
#read()
main() | 11 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n, k;
cin >> n >> k;
vector<tuple<long long, long long, long long>> v;
long long x = 0, y = 0, z = 0;
for (long long i = 0; i < n; i++) {
long long a, b, c;
cin >> a >> b >> c;
v.push_back(make_tuple(a, b, c));
if (b == 1 && c == 1) {
x++;
}
if (b == 1 && c == 0) {
y++;
}
if (b == 0 && c == 1) {
z++;
}
}
sort(v.begin(), v.end());
long long sum = 0;
long long sum1 = 0;
long long sum2 = 0;
long long j = 0, w = 0, q = 0;
long long a[x], b[y], c[z];
for (long long i = 0; i < v.size(); i++) {
if (get<1>(v[i]) == get<2>(v[i]) && get<2>(v[i]) == 1) {
sum += get<0>(v[i]);
a[j] = sum;
j++;
}
if (get<1>(v[i]) == 1 && get<2>(v[i]) == 0) {
sum1 += get<0>(v[i]);
b[w] = sum1;
w++;
}
if (get<1>(v[i]) == 0 && get<2>(v[i]) == 1) {
sum2 += get<0>(v[i]);
c[q] = sum2;
q++;
}
}
if ((w + j) < k || (j + q) < k) {
cout << -1 << "\n";
} else {
long long ans = 10000000000;
if ((q) >= k && (w) >= k) {
ans = b[k - 1] + c[k - 1];
}
for (long long i = 0; i < j; i++) {
if ((k - i - 2) >= 0 && (k - i - 2) < w && (k - i - 2) < q) {
if ((ans) > (a[i] + b[k - i - 2] + c[k - i - 2])) {
ans = a[i] + b[k - i - 2] + c[k - i - 2];
}
}
if ((k - i - 2) < 0) {
if (j >= k) {
if ((ans) > a[k - 1]) {
ans = a[k - 1];
}
}
}
}
cout << ans << "\n";
}
}
| 11 | CPP |
z=input
mod = 10**9 + 7
from collections import *
from queue import *
from sys import *
from collections import *
from math import *
from heapq import *
from itertools import *
from bisect import *
from collections import Counter as cc
from math import factorial as f
def lcd(xnum1,xnum2):
return (xnum1*xnum2//gcd(xnum1,xnum2))
################################################################################
"""
n=int(z())
for _ in range(int(z())):
x=int(z())
l=list(map(int,z().split()))
n=int(z())
l=sorted(list(map(int,z().split())))[::-1]
a,b=map(int,z().split())
l=set(map(int,z().split()))
led=(6,2,5,5,4,5,6,3,7,6)
vowel={'a':0,'e':0,'i':0,'o':0,'u':0}
color-4=["G", "GB", "YGB", "YGBI", "OYGBI" ,"OYGBIV",'ROYGBIV' ]
"""
###########################---START-CODING---###############################################
for _ in range(1):
n,k=map(int,z().split())
a=[]
b=[]
them=[]
ta,tb,th=0,0,0
for _ in range(n):
c,d,e=map(int,z().split())
if d==1 and e==1:
them.append(c)
th+=1
continue
if d==1:
a.append(c)
ta+=1
continue
if e==1:
b.append(c)
tb+=1
a=sorted(a)
b=sorted(b)
for i in range(min(ta,tb)):
them.append(a[i]+b[i])
if len(them)<k:
print(-1)
else:
print(sum(sorted(them)[:k]))
| 11 | PYTHON3 |
t=int(input())
for z in range(t):
n=int(input())
arr=list(map(int,input().split()))
min= arr[0] + arr[1]
pos=True
for i in range(2,n):
if(arr[i]>=min):
pos=False
posf=i
break
if(pos):
print("-1")
else:
print("1 2", posf+1)
| 7 | PYTHON3 |
t=int(input())
for _ in range(t):
n=int(input())
a=list(map(int,input().split()))
f=0
for i in range(2,len(a)):
if a[0]+a[1]<=a[i]:
f=1
print("1 2",i+1)
break
if f==0:
print(-1)
| 7 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
int tt;
cin >> tt;
while (tt--) {
int n;
cin >> n;
vector<int> a(n);
for (int i = 0; i < n; ++i) {
cin >> a[i];
}
if (a[0] + a[1] <= a.back()) {
cout << "1 2 " << n << '\n';
goto nx;
}
cout << "-1\n";
nx:;
}
return 0;
}
| 7 | CPP |
for t in range(int(input())):
n=int(input())
a=list(map(int,input().split()))
c=0
for i in range(2,n):
l = i
r =n-1
if a[0]+a[1]<=a[l]:
c+=1
print(1,2,i+1)
break
if c==0:
print(-1)
| 7 | PYTHON3 |
# Pratyaydeep
import sys
inp=sys.stdin.buffer.read().split(b"\n");_ii=-1
_DEBUG=0
def debug(*args):
if _DEBUG:
import inspect
frame = inspect.currentframe()
frame = inspect.getouterframes(frame)[1]
string = inspect.getframeinfo(frame[0]).code_context[0].strip()
arns = string[string.find('(') + 1:-1].split(',')
print(' #debug:',end=' ')
for i,j in zip(arns,args): print(i,' = ',j,end=', ')
print()
def rdln():
global _ii
_ii+=1
return inp[_ii]
inin=lambda: int(rdln())
inar=lambda: [int(x) for x in rdln().split()]
inst=lambda: rdln().strip().decode()
_T_=inin()
for _t_ in range(_T_):
n=inin()
a=inar()
debug(n,a)
if a[0]+a[1]>a[n-1]:
print(-1)
else:
print(1,2,n) | 7 | PYTHON3 |
import sys
input = sys.stdin.buffer.readline
t = int(input())
for _ in range(t):
res = 0
n = int(input())
A = list(map(int, input().split()))
flag = 0
a,b,c=A[0],A[1],A[-1]
if c>=a+b:
print(1,2,n)
flag=1
if not flag:
a,b,c=A[0],A[-2],A[-1]
if c-b>=a:
print(1,n-2,n-1)
flag=1
if not flag:
print(-1)
| 7 | PYTHON3 |
t = int(input())
while t > 0:
n = int(input())
# s = input()
# n, m = map(int, input().split())
a = list(map(int, input().split()))
# b = list(map(int, input().split()))
i = 0
k = n-1
j = -1
for it in range(1,n-1):
if a[i]+a[it]<=a[k]:
j = it
break
if j == -1:
print(-1)
else:
print(i+1,j+1,k+1)
t -= 1 | 7 | PYTHON3 |
t = int(input())
for _ in range(t):
n = int(input())
array = list(map(int, input().split()))
if array[0] + array[1] <= array[-1]:
print(1, 2, len(array))
else:
print(-1) | 7 | PYTHON3 |
# A. Bad Triangle
for _ in range(int(input())):
input()
a=list(map(int,input().split()))
if a[0]+a[1]<=a[-1]:
print(1,2,len(a))
else:
print(-1) | 7 | PYTHON3 |
t = int(input())
for _ in range(t):
n = int(input())
a = list(map(int, input().split()))
if a[0] + a[1] > a[-1]:
print(-1)
else:
print(1, 2, len(a)) | 7 | PYTHON3 |
t=int(input())
for i in range(t):
n=int(input())
x=[int(x) for x in input().split()]
if x[0]+x[1]<=x[n-1]:
print(1, 2, n)
else:
print(-1) | 7 | PYTHON3 |
t = int(input())
n = []
sides = []
for _ in range(t):
n.append(int(input()))
sides.append(list(map(int, input().split())))
for te in range(t):
found = 0
if sides[te][0] + sides[te][1] <= sides[te][n[te]-1]:
print(1, 2, n[te])
found = 1
if not found:
print(-1)
| 7 | PYTHON3 |
#code
import bisect
for _ in range(int(input())):
n=int(input())
a=[int(s) for s in input().split()]
i=0
j=0
f=0
while(i<n-1):
s=a[i]+a[i+1]
j=bisect.bisect_left(a,s)
if j<n:
f=1
break
i+=1
if f:
print(i+1,i+2,j+1)
else:
print(-1) | 7 | PYTHON3 |
z,zz=input,lambda:list(map(int,z().split()));
szz,dgraphs,mod=lambda:sorted(zz()),{},10**9+7
from string import *
from collections import *
from queue import *
from sys import *
from collections import *
from math import *
from heapq import *
from itertools import *
from bisect import *
from collections import Counter as cc
from math import factorial as f
from bisect import bisect as bs
from itertools import accumulate as ac
def lcd(xnum1,xnum2):return (xnum1*xnum2//gcd(xnum1,xnum2))
def prime(x):
p=ceil(x**.5)+1
for i in range(2,p):
if x%i==0 and x!=2:return 0
return 1
def dfs(u,visit,graph):
visit[u]=True
for i in graph[u]:
if not visit[i]:
dfs(i,visit,graph)
###########################---Test-Case---#################################
"""
"""
###########################---START-CODING---##############################
num=int(z())
for _ in range(num):
n=int(z())
l=zz()
a=l[0]
b=l[1]
c=l[-1]
if a+b>c and b+c>a and a+c>b:
print(-1)
else:
print(1,2,n)
| 7 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long t, n;
long long arr[1000000];
cin >> t;
for (int a = 1; a <= t; a++) {
cin >> n;
for (int i = 0; i < n; i++) {
cin >> arr[i];
}
if (arr[0] + arr[1] <= arr[n - 1]) {
cout << 1 << " " << 2 << " " << n << "\n";
} else
cout << -1 << "\n";
}
}
| 7 | CPP |
t = int(input())
for i in range(t):
n = int(input())
a = list(map(int, input().split()))
if a[0] + a[1] > a[n-1]:
print(-1)
else:
print(1,2, n) | 7 | PYTHON3 |
#input template
from sys import stdin, stdout
from collections import Counter, OrderedDict
import math
cin = stdin.readline
cout = stdout.write
mp = lambda: list(map(int, cin().split()))
def chars(): #function for taking string input as character array since string in python is immutable
s = cin()
return(list(s[:len(s) - 1]))
#print list
def pl(a):
for val in a:
cout(str(val) + ' ')
cout('\n')
#main
t, = mp()
for _ in range(t):
n, = mp()
a = mp()
if a[0] + a[1] > a[-1]:
cout('-1\n')
else:
pl([1, 2, n]) | 7 | PYTHON3 |
from functools import reduce
import os
import sys
from math import *
from collections import *
from fractions import *
from bisect import *
from heapq import*
from io import BytesIO, IOBase
input = lambda: sys.stdin.readline().rstrip("\r\n")
def value():return tuple(map(int,input().split()))
def arr():return [int(i) for i in input().split()]
def sarr():return [int(i) for i in input()]
def inn():return int(input())
mo=1000000007
#----------------------------CODE------------------------------#
for _ in range(int(input())):
n=inn()
a=arr()
if(a[0]+a[1]<=a[-1]):
print(1,2,n)
else:
print(-1) | 7 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
using ull = unsigned long long;
using ll = long long int;
ll binpow(ll a, ll b) {
ll res = 1;
while (b > 0) {
if (b & 1) {
res = res * a;
}
a = a * a;
b >>= 1;
}
return res;
}
void solve() {
ll n;
cin >> n;
ll ar[n + 1];
for (ll i = 0; i < n; i++) {
cin >> ar[i];
}
ll mn[n + 1];
ll mx[n + 1];
mn[0] = 0;
for (ll i = 1; i < n; i++) {
if (ar[i] < ar[mn[i - 1]]) {
mn[i] = i;
} else {
mn[i] = mn[i - 1];
}
}
mx[n - 1] = n - 1;
for (ll i = (n - 2); i >= 0; i--) {
if (ar[i] > ar[mx[i + 1]]) {
mx[i] = i;
} else {
mx[i] = mx[i + 1];
}
}
for (ll i = 0; i < n; i++) {
if ((ar[i] + ar[mn[i]] <= ar[mx[i]]) && (i != mn[i]) && (i != mx[i])) {
cout << mn[i] + 1 << " " << i + 1 << " " << mx[i] + 1 << "\n";
return;
}
}
cout << -1 << "\n";
return;
}
int main() {
ios_base::sync_with_stdio(false), cin.tie(NULL), cout.tie(NULL);
ll t = 1;
cin >> t;
while (t--) {
solve();
}
}
| 7 | CPP |
def main():
t = int(input())
for i in range(t):
n = int(input())
a = [int(x) for x in input().split()]
if a[0] + a[1] <= a[-1]:
print(1, 2, n)
else:
print(-1)
if __name__ == "__main__":
main() | 7 | PYTHON3 |
import copy
import math
r = int(input())
for l in range(r):
n = int(input())
arr = [int(d) for d in input().split()]
if arr[0] + arr[1] <= arr[n-1]:
print(1, 2, n)
else:
print(-1)
| 7 | PYTHON3 |
def badtri(arr):
last=arr[-1]
for i in range(len(arr)-2):
diff=last-arr[i]
if arr[i+1]<=diff:
return (i+1,i+2,len(arr))
return (-1,)
t=int(input())
for i in range(t):
n=int(input())
arr=[int(k) for k in input().split()]
print(*badtri(arr)) | 7 | PYTHON3 |
#!/usr/local/bin/python3
t = int(input())
for _ in range(t):
n = int(input())
arr = list(map(int,input().split()))
a,b,c=arr[0],arr[1],arr[-1]
if a+b>c:
print(-1)
else:
print(1,2,n) | 7 | PYTHON3 |
def solve():
nb = int(input())
l = list(map(int, input().split()))
c = True
imi1, mi1 = l.index(min(l))+1, min(l)
l.remove(min(l))
imi2, mi2 = l.index(min(l))+2, min(l)
l.remove(min(l))
if max(l) >= mi1 + mi2:
res = [imi1, imi2, l.index(max(l))+3]
res.sort()
print(res[0], res[1], res[2])
c = False
if c:
print(-1)
n = int(input())
for _ in range(n):
solve() | 7 | PYTHON3 |
import sys
inp=sys.stdin.buffer.read().split(b"\n");_ii=-1
def debug(*args):
import inspect
frame = inspect.currentframe()
frame = inspect.getouterframes(frame)[1]
string = inspect.getframeinfo(frame[0]).code_context[0].strip()
arns = string[string.find('(') + 1:-1].split(',')
print(' #debug:',end=' ')
for i,j in zip(arns,args): print(i,' = ',j,end=', ')
print()
def rdln():
global _ii
_ii+=1
return inp[_ii]
inin=lambda: int(rdln())
inar=lambda: [int(x) for x in rdln().split()]
inst=lambda: rdln().strip().decode()
_T_=inin()
for _t_ in range(_T_):
n=inin()
a=inar()
if a[0]+a[1]>a[n-1]:
print(-1)
else:
print(1,2,n) | 7 | PYTHON3 |
# @author
import sys
class ABadTriangle:
def solve(self, tc=0):
for _ in range(int(input())):
n = int(input())
a = [int(_) for _ in input().split()]
u, v, w = a[0], a[1], a[-1]
if u + v <= w:
print(1, 2, n)
else:
print(-1)
solver = ABadTriangle()
input = sys.stdin.readline
solver.solve()
| 7 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
bool cmp(int a, int b) { return a > b; }
int main() {
int t, n, a, b, c, d;
cin >> t;
while (t--) {
cin >> n;
for (int i = 0; i < n; i++) {
if (i == 0)
scanf("%d", &a);
else if (i == 1) {
scanf("%d", &b);
} else if (i == (n - 1)) {
scanf("%d", &d);
} else {
scanf("%d", &c);
}
}
if (a + b <= d)
printf("1 2 %d\n", n);
else
printf("-1\n");
}
}
| 7 | CPP |
for t in range(int(input())):
n=int(input())
a=list(map(int,input().split()))
c=0
d=0
for i in range(2,n):
if(a[0]+a[1]<=a[i]):
c=1
d=i
break
if(c==1):
print(1,2,d+1)
else:
print(-1) | 7 | PYTHON3 |
for _ in range(int(input())):
N = int(input())
A = list(map(int, input().split()))
if A[0] + A[1] <= A[N-1]:
print(1, 2, N)
else:
print(-1) | 7 | PYTHON3 |
# Bad Triangle
t = int(input())
for i in range(0,t):
n = int(input()); a = [ ]*n
a = [int(x) for x in input().split()]
if a[0]+a[1] <= a[len(a)-1]:
print(f"1 2 {len(a)}")
else:
print("-1") | 7 | PYTHON3 |
cases = int(input())
for x in range(cases):
input()
l = input().split(' ')
if len(l) >= 3 and int(l[0]) + int(l[1]) <= int(l[-1]):
print('1 2',len(l))
else:
print(-1) | 7 | PYTHON3 |
def main():
for _ in range(int(input())):
n=int(input())
a=list(map(int,input().split()))
if(a[-1]>=a[0]+a[1]):
print(1,2,n)
else:
print(-1)
main() | 7 | PYTHON3 |
for t in range(int(input())):
n=int(input())
l=list(map(int,input().split()))
if(l[0]+l[1]<=l[-1]):
print(1,2,n)
else:
print(-1) | 7 | PYTHON3 |
for _ in range(int(input())):
n=int(input())
a=list(map(int,input().split()))
if a[0]+a[1]<=a[n-1] or a[0]+a[n-1]<=a[1] or a[1]+a[n-1]<=a[0]:
print(1,2,n)
else:
print("-1") | 7 | PYTHON3 |
a = int(input())
i = 0
while i < a :
b = int(input())
c = input().split(" ")
d = []
s = 0
while s < b :
d.append(int(c[s]))
s = s + 1
s = 0
k = d
k.sort()
o = 0
l = 0
r = 0
while s < b :
if d[s] == k[0] :
s = s + 1
o = s
break
s = s + 1
s = 1
while s < b :
if d[s] == k[1] :
s = s + 1
l = s
break
s = s + 1
s = 0
while s < b :
if d[s] == k[-1] :
s = s + 1
r = s
break
s = s + 1
if k[0] + k[1] <= k[-1] :
print(o,l,r)
else:
print(-1)
i = i + 1
| 7 | PYTHON3 |
import sys
T = int(sys.stdin.readline())
for _ in range(T):
N = int(sys.stdin.readline())
list_num = list(map(int, sys.stdin.readline().split()))
if list_num[-1] >= list_num[0] + list_num[1]:
print(1, 2, N)
else:
print(-1) | 7 | PYTHON3 |
for i in range(int(input())):
largo = int(input())
lista = [int(j) for j in input().split()]
solved = 0
minimo = lista[0]
maximo = lista[largo - 1]
for x in range(1, largo - 1):
if lista[x] + minimo <= maximo:
print(1, x + 1, largo)
solved = 1
break
if solved == 0:
print(-1) | 7 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int t;
cin >> t;
while (t--) {
int n;
cin >> n;
vector<int> vc(n);
for (int i = 0; i < n; i++) {
cin >> vc[i];
}
int i;
int count = 0;
for (i = 0; i < n - 2; i++) {
if (vc[i] + vc[i + 1] <= vc[n - 1]) {
cout << i + 1 << " " << i + 2 << " " << n << endl;
count++;
break;
}
}
if (count == 0) cout << -1 << endl;
}
}
| 7 | CPP |
def A():
n = int(input())
arr = list(map(int, input().split()))
x = arr[0] + arr[1]
ans = []
if arr[-1] >= x:
ans.append(1)
ans.append(2)
ans.append(n)
return ans
return ans
if __name__ == '__main__':
t = int(input())
for i in range(t):
ans = A()
if not ans:
print("-1")
else:
for i in range(3):
print(ans[i], end = " ")
print("") | 7 | PYTHON3 |
import sys
input = sys.stdin.readline
t=int(input())
for tests in range(t):
n=int(input())
A=list(map(int,input().split()))
if A[0]+A[1]<=A[n-1]:
print(1,2,n)
else:
print(-1)
| 7 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
void IO() {}
int ar[50005];
char ch[50005];
int m, n, k, ii;
void solve() {
scanf("%d", &n);
vector<pair<int, int>> v;
for (int i = 1; i <= n; i++) {
scanf("%d", &ar[i]);
v.push_back({ar[i], i});
}
sort(v.begin(), v.end());
if (v[0].first + v[1].first <= v[n - 1].first) {
printf("%d %d %d\n", v[0].second, v[1].second, v[n - 1].second);
} else
printf("-1\n");
}
int main() {
IO();
int t = 1;
scanf("%d", &t);
while (t--) {
solve();
}
return 0;
}
| 7 | CPP |
##########################################################
from collections import Counter
# c=sorted((i,int(val))for i,val in enumerate(input().split()))
import heapq
# c=sorted((i,int(val))for i,val in enumerate(input().split()))
# n = int(input())
# ls = list(map(int, input().split()))
# n, k = map(int, input().split())
# n =int(input())
# e=list(map(int, input().split()))
from collections import Counter
#print("\n".join(ls))
#print(os.path.commonprefix(ls[0:2]))
#for _ in range(int(input())):
for _ in range(int(input())):
n=int(input())
arr = list(map(int, input().split()))
if arr[0]+arr[1]<=arr[-1]:
print(1, 2, n)
else:
print(-1)
| 7 | PYTHON3 |
for _ in range(int(input())):
n=int(input())
a =list(map(int,input().split()))
x,y,z=a[0],a[1],a[n-1]
if(x+y >z):
print(-1)
else:
print(1,2,n) | 7 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
int t;
cin >> t;
while (t--) {
int n;
cin >> n;
vector<int> v(n);
for (auto &i : v) cin >> i;
if (v[0] + v[1] > v[n - 1])
cout << "-1\n";
else
cout << 1 << " " << 2 << " " << n << '\n';
}
return 0;
}
| 7 | CPP |
t = int(input())
for _ in range(t):
n = int(input())
l = [int(x) for x in input().split()]
a =l[0]
b = l[1]
c = l[-1]
if a+b > c:
print(-1)
else:
print(1, 2, n) | 7 | PYTHON3 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.