В спортивном соревновании приняло участие $$$N$$$ команд. Результат каждого участника каждой команды оценивается в некоторую сумму призовых денег. Однако по правилам соревнования команде выдаётся только один приз. В качестве суммы приза команды организаторы хотели выбрать медиану призовых денег её участников, но призовой бюджет уже зафиксирован. Жюри хочет избежать обвинений в предвзятости, поэтому было решено распределить призы так, чтобы сумма абсолютных разностей по всем участникам между заработанными и полученными деньгами была минимальной.
Распределите призы между командами.
В первой строке задано $$$1\le N \le 1000$$$ — число команд. В следующих $$$N$$$ строках записаны команды. Первое число в строке $$$1\le M_i \le 100$$$ — размер команды. Оставшиеся $$$M_i$$$ целых чисел $$$0 \le D_{ij} \le 10^6$$$ — призовые деньги заработанные участниками команды. В последней строке записано единственное целое число $$$1\le T \le 10^9$$$ — размер призового фонда.
Выведите в одной строке $$$N$$$ целых чисел $$$0 \le T_i \le 10^9$$$ — призы полученные командами. Весь призовой бюджет должен быть полностью израсходован, то есть $$$\sum_{i=1}^{N}T_i = T$$$. Также должна быть минимизирована величина $$$\sum_{i=1}^{N}\sum_{j=1}^{M_i}|D_{ij} - T_i|$$$. Если есть несколько оптимальных распределений призов, выведите любое из них.
2 3 5 4 1 3 1 2 3 6
4 2
2 2 1 1 2 1 1 4
3 1
2 1 0 2 0 1 3
2 1
4 1 1 1 1 1 1 1 1 1
0 0 0 1
В первом тесте организаторы могут выдать каждой команде её медиану. В остальных тестах им приходится изменять выдаваемые призы.
Лето уже в самом разгаре — а это значит, что нас всех ждут и дождливые, и жаркие дни. В дождь людям нужны зонты и дождевики, и производителям этих товаров крайне важно отслеживать рост интереса к ним. С другой стороны, производителям прохладительных напитков важны жаркие дни, когда на продвижение можно потратить бóльшие бюджеты.
Итак, владельцам рекламных объявлений определённых тематик требуется возможность управлять настройками показов в зависимости от погоды. В этой задаче вам потребуется реализовать простейшую версию этой функциональности — таргетинг на температуру в определённые диапазоны дней.
В вашем распоряжении есть исторические данные о температуре, а также прогноз на ближайшее будущее. А именно:
Кроме того, есть данные о настройках показа $$$B$$$ рекламных объявлений. Каждому из них соответствуют четыре числа $$$t_{min}$$$, $$$t_{max}$$$, $$$d_{min}$$$, $$$d_{max}$$$, означающие, что объявление можно показывать только в том случае, если за период от дня $$$d_{min}$$$ до дня $$$d_{max}$$$ включительно температура принимала или примет значение от $$$t_{min}$$$ до $$$t_{max}$$$ включительно. При этом гарантируется, что $$$d_{min} \le 0 \le d_{max}$$$, то есть диапазон дней должен включать сегодняшний.
Обратите внимание, что температура не дискретна! Например, если вчера значение температуры было $$$-5$$$, а сегодня $$$-2$$$, то необходимо считать, что в период, включающий сегодняшний и вчерашний дни, температура принимала не только значения $$$-5$$$ и $$$-2$$$, но и $$$-4$$$ и $$$-3$$$ (и даже $$$-3{,}14$$$, но в этой задаче все входные данные целочисленны).
Для каждого рекламного объявления определите, может ли оно быть показано в текущий день с учётом настроек и известных погодных данных.
В первой строке входного файла вводится единственное целое неотрицательное число $$$N$$$ ($$$N \le 100\,000$$$).
В следующей строке вводится $$$2N+1$$$ целых чисел — значения температуры в дни $$$-N$$$, $$$-N+1$$$, ..., $$$-1$$$, $$$0$$$, $$$1$$$, ..., $$$N$$$. Значения температуры по модулю не превосходят $$$10^9$$$.
В третьей строке содержится единственное целое положительное число $$$B$$$ ($$$B \le 100\,000$$$) — количество рекламных объявлений.
Наконец, в каждой из следующих $$$B$$$ строк содержатся 4 целых числа $$$t_{min}$$$, $$$t_{max}$$$, $$$d_{min}$$$, $$$d_{max}$$$, описывающие настройки соответствующего объявления. Гарантируется, что $$$-10^9 \le t_{min} \le t_{max} \le 10^9$$$ и $$$-N \le d_{min} \le 0 \le d_{max} \le N$$$.
Для каждого из объявлений выведите в отдельной строке «yes», если оно может быть показано согласно настройкам, и «no» в противном случае.
2 2 4 5 -2 2 4 -1 -1 -1 1 0 10 -1 0 6 8 -2 2 3 3 -1 0
yes yes no no
Уже не первый год в Байтландии идёт тяжелая борьба за быструю отрисовку страниц в интернете...
Одним из шагов к победе стало нововведение Баннерной крутилки: отдавать баннеры для нескольких блоков в одном ответе, тем самым сохранив дополнительные вызовы, а с ними и время. Однако оказалось, что совсем непросто разумно разбить полученные баннеры по блокам.
Имеется $$$N$$$ баннеров, которые мы хотим разбить на $$$K$$$ блоков. В ответе есть массив $$$P$$$, где $$$P_i$$$ — прогнозируемая польза от показа $$$i$$$-го баннера, а также массив $$$L$$$, где $$$L_{j}$$$ — возможная потеря внимания пользователя на $$$j$$$-й по счёту блок.
Аналитик Виталик тестирует гипотезы, которые должны в первую очередь повысить счастье пользователя. Сейчас он прорабатывает следующую метрику: для блока вводим функцию $$$f(Block_{s}) = P_{min} \cdot len(Block_{s}) - L_{s} P_{max}$$$, где $$$P_{min}$$$ — минимальное значение $$$P$$$ среди баннеров в блоке, $$$P_{max}$$$ — максимальное, $$$len(Block_{s})$$$ — количество баннеров в блоке, $$$s$$$ — номер блока в разбиении. Значением метрики для конкретного разбиения является сумма значений $$$f$$$ для всех блоков в этом разбиении. На каждом запросе необходимо находить разбиение, которое максимизирует эту метрику.
Виталик умеет решать эту задачу, но его алгоритм оказался не очень быстрым. Вас, как эксперта, попросили помочь ему и ускорить отбор!
Первая строка входных данных содержит 2 целых числа $$$N$$$ и $$$K$$$ ($$$1 \leq N \leq 5 \cdot 10^4$$$, $$$1 \leq K \leq \min(100, N)$$$).
Вторая стока содержит $$$N$$$ целых чисел $$$1 \leq P_{i} \leq 10^6$$$; гарантируется, что $$$P_{i} \gt P_{i + 1}$$$.
Третья строка содержит $$$K$$$ целых чисел $$$0 \leq L_{i} \leq 10^6$$$.
Выведите одно целое число — значение метрики для наилучшего разбиения.
4 2 6 4 3 1 0 3
7
10 3 10 9 8 7 6 5 4 3 2 1 0 4 2
19
В первом примере возможны три разбиения:
В распределённых системах одна из наиболее важных задач — это умение переживать сбои оборудования. Классическим подходом к решению проблемы сбоев в случае хранения данных является тройная репликация, то есть хранение каждого блока данных на трёх разных хостах в кластере. В таком случае данные не потеряются при одновременном выходе из строя двух дисков. Одновременная поломка трёх дисков считается крайне маловероятным событием и на практике практически никогда не случается.
Однако, тройная репликация приводит к тому, что для хранения $$$X$$$ данных на кластере надо иметь $$$3X$$$ свободного места, что достаточно расточительно. Для экономии места и сохранения гарантий надёжности используются коды, исправляющие ошибки (а точнее, в нашем случае, коды, исправляющие потерю части данных).
Рассмотрим один из таких кодов. Представим, что наши данные состоят из числа битов, кратного 20. Для простоты будем считать, что ровно из 20 бит и научимся кодировать эти 20 бит (для большего числа бит задача решается простым повторением данного алгоритма).
Итак, представим наши 20 бит в виде матрицы $$$\{a_{i,j}\}$$$ размером 4 на 5, то есть $$$i = 1 \ldots 4, j=1 \ldots 5$$$. Мы дополним матрицу с данными двумя контрольными столбцами $$$\{a_{i,6}\}$$$ и $$$\{a_{i,7}\}$$$.
Шестой столбец будет просто представлять собой xor-сумму столбцов, то есть: $$$$$$ a_{i,6} = \bigoplus_{j=1}^{5} a_{i,j}, \quad i = 1\ldots4 $$$$$$
Седьмой столбец будет устроен более хитро. Он будет представлять собой определённые xor-суммы диагоналей. А именно, положим $$$S=\bigoplus_{k=1..4} a_{k,6-k}$$$ , тогда: $$$$$$ a_{i,7} = S \oplus \bigoplus_{k=1..4} a_{k, shift(6 + i - k)}, \quad i = 1\ldots4 $$$$$$
Здесь $$$shift$$$ обозначает функцию, которая шагом величины 5 сдвигает число в диапазон $$$1 \ldots 5$$$, (то есть $$$shift(x) \in \{1 \ldots 5\}$$$ и $$$x - shift(x)$$$ кратно 5).
Изобразим вклад элементов в контрольные суммы 7-го столбца в виде матрицы: $$$$$$ \begin{pmatrix} a_{7,1} & a_{7,2} & a_{7,3} & a_{7,4} & S \\ a_{7,2} & a_{7,3} & a_{7,4} & S & a_{7,1}\\ a_{7,3} & a_{7,4} & S & a_{7,1} & a_{7,2} \\ a_{7,4} & S & a_{7,1} & a_{7,2} & a_{7,3} \end{pmatrix} $$$$$$
После этого мы будем писать каждый столбец матрицы на отдельный хост. Утверждается, что при потере любых двух столбцов их можно восстановить из имеющихся, то есть полученный код в определённом смысле не менее надёжен, чем тройная репликация. При этом видно, что накладные расходы указанного кода составляют лишь 40%, в отличие от 200%, которые были у тройной репликации.
Заметим, что при подсчёте контрольных сумм используется только операция xor, поэтому можно в качестве $$$a_{i,j}$$$ использовать числа фиксированной битовой ширины, а не просто биты. В нашем случае мы будем кодировать 32-битные беззнаковые числа.
Опишем немного точнее, как мы будем кодировать данные. Для кодирования данные разбиваются на пять непрерывных частей одинакового размера, причём размер части должен быть кратен четырём. Каждая из частей соответствует фиксированному столбцу, при этом первые четыре числа в части относятся к первой матрице, которую мы кодируем, вторые четыре числа ко второй матрице и так далее.
Ваша задача состоит в том, чтобы написать алгоритм, который восстанавливает потерянные данные при использовании указанной схемы кодирования.
В первой строке входных данных указано число $$$n$$$ — количество кодируемых чисел в одной части и числа $$$e_1, e_2$$$, обозначающие номера потерянных частей ($$$1 \leq e_1 \lt e_2 \leq 7, i=1,2$$$). Число $$$n$$$ кратно четырём и не превосходит $$$2 \cdot 10^5$$$.
Далее в 5 строках заданы данные, отвечающие частям, которые остались в сохранности. В каждой из 5 строк записано $$$n$$$ чисел, разделенных пробелами, относящихся к очередному сохранившемуся столбцу в порядке возрастания индексов столбцов.
Например, если были потеряны 1-й и 4-й столбцы, то в пяти строках будут указаны данные, относящиеся к 2-му, 3-му, 5-му, 6-му и 7-му столбцам соответственно.
Гарантируется, что входные данные были получены алгоритмом, описанным в условии.
Выведите две строки по $$$n$$$ чисел в каждой, соответствующие потерянным данным.
4 6 7 1 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0
1 0 0 1 0 1 1 1
8 1 2 0 0 0 0 2 2 2 2 0 0 0 0 2 2 2 2 0 0 0 0 2 2 2 2 1 0 0 1 2 2 2 2 0 1 1 1 0 0 0 0
1 0 0 0 2 2 2 2 0 0 0 1 2 2 2 2
Обратите внимание, что у задачи большой вход, поэтому в случае использования языка C++ рекомендуется выключить синхронизацию С/С++ способов чтения, то есть вызвать метод std::ios::sync_with_stdio(false).
В $$$n$$$ кластерах расположены сервера, на каждом из которых установлена одна и та же операционная система. В её ядре была найдена уязвимость, поэтому сервера нужно обновить на исправленную версию ядра. В $$$i$$$-м кластере расположено $$$x_i$$$ серверов. Обновление одного сервера занимает одну единицу времени. Сервера обновляются строго последовательно, поэтому их суммарное время обновления занимает $$$x_i$$$ единиц времени. Начатый процесс обновления в одном кластере нельзя прерывать до того, как все сервера в нём будут обновлены. Также нельзя выполнять обновление в двух кластерах одновременно. В каждом кластере под обновление было выделено окно времени $$$[a_i, a_i + x_i]$$$, эти окна могут пересекаться. Необходимо выбрать кластера, в которых провести обновление, чтобы на максимальном количестве серверов была установлена новая версия ядра.
В первой строке дано число кластеров $$$n \ (1 \leq n\leq 10^5)$$$. В каждой из $$$n$$$ следующих строк дана пара чисел $$$a_i$$$ и $$$x_i$$$, разделённая пробелом $$$(1 \leq a_i, x_i \leq 10^9)$$$.
В первой строке выходного файла нужно вывести максимальное суммарное количество серверов, на которых возможно обновить ядро. Во второй строке выходного файла нужно вывести разделённые пробелом номера кластеров, в которых следует обновить ядро. Кластера нумеруются с нуля. Их номера можно вывести в произвольном порядке.
4 1 4 4 11 8 5 12 5
11 1
4 1 4 4 11 8 3 12 5
12 3 2 0
2 1 1 2 1
2 1 0
У разработчика была директория $$$A$$$, в которой размещались директории и файлы. Для каждого файла посчитана его хэш сумма. В процессе работы известно, что разработчик создавал хардлинки, удалял хардлинки, создавал и удалял директории. Более формально, изменения были одного из четырех типов:
При каждом изменении разработчик соблюдал правила:
В результате своей работы разработчик пришел к выводу, что это уже не директория $$$A$$$, а директория $$$B$$$. Тогда он решил рассмотреть все свои изменения от изначального состояния директории $$$A$$$ (далее просто "от $$$A$$$") до нынешнего состояния (далее "до $$$B$$$"). Но, к сожалению, он не смог найти историю изменений. Зато он смог найти список файлов с их хэш суммами и поддиректорий директории $$$A$$$ и список файлов с их хэш суммами и поддиректорий директории $$$B$$$.
Разработчик заметил, что пространства имен директорий в $$$A$$$ и файлов в $$$B$$$ не пересекаются, то есть нет файла в $$$B$$$ с именем, совпадающим с именем какой-либо директории в $$$A$$$. Аналогично, пространства имен файлов в $$$A$$$ и директорий в $$$B$$$ тоже не пересекаются, то есть нет файла в $$$A$$$ с именем, совпадающим с именем какой-либо директории в $$$B$$$. К тому же, если в $$$A$$$ и в $$$B$$$ есть файлы с одинаковым именем, то их хэш суммы тоже одинаковые.
Разработчик хотел бы восстановить последовательность своих изменений, соответствующих всем описанным правилам, но это невозможно, поэтому он просит Вас помочь найти произвольную минимальную последовательность.
Найдите минимальную последовательность изменений, соответствующих описанным правилам, которая преобразует директорию $$$A$$$ в директорию $$$B$$$.
В первой строке через пробел заданы 2 целых числа $$$n$$$ и $$$m$$$ ($$$0 \le n, m \le 10^4$$$) — количество файлов и директорий в $$$A$$$ и количество файлов и директорий в $$$B$$$ соответственно.
Каждая из следующих $$$n$$$ строк содержит имя директории (оканчивается на '/') или имя файла (не заканчивается на '/') в $$$A$$$. Имя состоит из букв английского алфавита, цифр, знаков '.' и '/' и не содержит двух подряд идущих знаков '/'. Если это имя файла, то следом за ним через пробел указана хэш сумма — строка, состоящая из строчных букв английского алфавита и цифр.
Каждая из следующих $$$m$$$ строк содержит имя директории (оканчивается на '/') или имя файла (не заканчивается на '/') в $$$B$$$. Имя состоит из букв английского алфавита, цифр, знаков '.' и '/' и не содержит двух подряд идущих знаков '/'. Если это имя файла, то следом за ним через пробел указана хэш сумма — строка, состоящая из строчных букв английского алфавита и цифр.
Длины имен от 2 до 256, длины хэш сумм от 1 до 256.
В первой строке выведите целое число $$$k$$$ — минимальное количество операций, за которое можно получить директорию $$$B$$$ из директории $$$A$$$. В следующих $$$k$$$ строках выведите сами операции в формате, описанном в условии.
4 3 /a/ /a/b.txt hash1 /a/d.txt hash2 /f/ /a/ /a/e/ /a/e/c.txt hash1
5 mkdir /a/e/ rmdir /f/ unlink /a/d.txt link /a/b.txt /a/e/c.txt unlink /a/b.txt
Сеть компании состоит из серверов, каждый из которых имеет уникальный целочисленный идентификатор. $$$N$$$ пар серверов соединены друг с другом. Соединённые серверы образуют кластеры: два сервера относятся к одному и тому же кластеру, если от одного из них можно добраться до другого, перемещаясь по связям.
Периодически возникает необходимость скачать определённый файл на некоторый сервер. В сети работает сервис, аналогичный торрент-трекеру, который может сообщить, на каких серверах уже имеется необходимый файл.
Проблема, однако, заключается в том, что любой сервер может скачивать файлы только с серверов в его кластере.
Составьте программу, которая будет анализировать конфигурацию сети и сообщать, из каких источников определённый сервер может скачать необходимый файл.
Первая строка содержит целое число $$$N$$$ ($$$0 \le N \le 10^6$$$) — количество связей между серверами.
Следующие $$$N$$$ строк описывают связи между серверами. Каждая из них содержит целые числа $$$A_i$$$ и $$$B_i$$$ ($$$1 \le A_i, B_i \le 10^9$$$) — идентификаторы соединённых серверов.
Следующая строка содержит целое число $$$Q$$$ ($$$1 \le Q \le 10^3$$$) — количество запросов на скачивание файлов.
Следующие $$$(2 \cdot Q)$$$ строк описывают запросы на скачивание файлов. Первая строка каждой пары содержит целые числа $$$X_i$$$ и $$$K_i$$$ ($$$1 \le X_i \le 10^9$$$, $$$1 \le K_i \le 100$$$) — соответственно идентификатор сервера, на который нужно скачать файл, и количество серверов, содержащих файл. Вторая строка каждой пары содержит $$$K_i$$$ целых чисел $$$Y_{ij}$$$ ($$$1 \le Y_{ij} \le 10^9$$$) — идентификаторы серверов, содержащих файл.
Для каждого запроса в отдельной строке выведите сначала целое число $$$R_j$$$ — количество серверов, с которых можно скачать файл. Затем выведите $$$R_j$$$ целых чисел — идентификаторы серверов, с которых можно скачать файл. Серверы следует выводить в том порядке, в котором они перечислены в описании соответствующего запроса во входных данных.
8 54578972 99368556 79699669 54578972 64508306 99368556 56554555 64508306 27101564 81480071 89445516 27101564 93762227 81480071 89808815 93762227 4 56554555 2 93762227 79699669 99368556 2 64508306 56554555 27101564 2 99368556 79699669 93762227 2 56554555 54578972
1 79699669 2 64508306 56554555 0 0
10 85619126 64616465 98159933 85619126 73978229 85619126 29978081 64616465 72404745 29978081 97698445 75243921 36815728 97698445 18360411 97698445 66445821 75243921 92142380 66445821 4 97698445 4 75243921 92142380 98159933 73978229 66445821 4 29978081 92142380 73978229 97698445 18360411 4 29978081 92142380 98159933 97698445 36815728 4 64616465 92142380 97698445 29978081
2 75243921 92142380 2 92142380 97698445 2 92142380 97698445 2 92142380 97698445
Метаданные пользователей Яндекс.Почты лежат в БД PostgreSQL и разбиты на $$$N$$$ шардов (теоретически $$$N$$$ может быть очень большим). У каждого шарда есть вес, который постоянно пересчитывается пропорционально загрузке процессора на мастере шарда. Новому пользователю при регистрации автоматически присваивается шард рандомно с учётом веса этого шарда. Нужно реализовать класс который хранит веса шардов и отвечает на следующие типы запросов:
Первая строка содержит два целых числа $$$n$$$ ($$$1 \le n \le 10^6$$$) — количество шардов (шарды нумеруются с 0); $$$q$$$ ($$$1 \le q \le 10^5$$$) — количество запросов.
Каждая из следующих $$$q$$$ строк содержит запрос. Запрос описан в одном из форматов:
Для каждого запроса формата 2 выведите номер шарда, который удовлетворяет условию, описанному выше.
1 5 + 0 2 + 0 1 + 0 3 ? 6 ? 5
0 -1
Индустриализация добралась до самых отдалённых уголков страны, и наружная реклама уже вовсю показывается в Байтландии.
Реклама на билбордах показывается по определённым правилам:
Аукцион второй цены проходит по следующей схеме:
Одной из новинок в индустрии рекламы является геотаргетинг — возможность задать окружность на карте, ограничивающую множество щитов, на которых необходимо производить рекламные показы конкретного объявления. Волевым решением Байтландия была выбрана в качестве испытательного полигона для новой функциональности. Перед аналитиком Михаилом стоит задача: определить места в городе, в которых рекламодатели готовы заплатить наибольшее количество денег. Для этого Михаил прикрепил огромный билборд на свой автомобиль и решил проехать по прямой улице из точки $$$(X_{start}, Y_{start})$$$. Автомобиль Михаила может ехать только с постоянной скоростью. В некоторые моменты времени аналитик останавливается и проверяет, какая реклама показывается на его билборде.
Помогите аналитику Михаилу определить лучшие места для расположения билбордов.
Первая строка входных данных содержит 4 целых числа $$$-10^9 \leq X_{start}, Y_{start}, dx, dy \leq 10^9$$$ — стартовую точку и вектор движения, который автомобиль проезжает за единицу времени. Гарантируется, что либо $$$dx$$$, либо $$$dy$$$ равен нулю, но при этом они не равны нулю одновременно.
Вторая строка содержит количество остановок $$$1 \leq N \leq 3\cdot 10^5$$$. Третья строка содержит $$$N$$$ возрастающих целых чисел $$$0 \leq t_i \leq 10^9$$$. Четвёртая строка содержит 2 числа: количество объявлений $$$1 \leq M \leq 10^5$$$ и минимальную ставку $$$1 \leq MinCost \leq 10^9$$$.
Далее следует $$$M$$$ окружностей, описывающих настройки соответствующих объявлений. Каждая окружность описывается 4 целыми числами: $$$-10^9 \leq X, Y \leq 10^9$$$ — центр окружности, радиус $$$1 \leq R \leq 10^9$$$ и ставка $$$1 \leq Cost \leq 10^9$$$.
Выведите $$$N$$$ чисел — стоимость победившего объявления в моменты времени $$$t_1, \ldots, t_N$$$.
0 0 0 1 10 0 1 2 3 4 5 6 7 8 9 4 50 0 2 1 100 0 4 1 200 0 6 1 300 0 7 1 250
50 50 50 100 50 200 250 250 50 50
-3 -1 3 0 3 1 3 20 3 100 6 -1 1 400 8 -1 9 300 0 -3 3 200
200 300 100
У вас есть записанный в строку невалидный json. Заранее известно что в нём был потерян один символ. Надо восстановить json до валидного добавив один символ. Об исходном JSON сообщении нам известно:
Строка c не валидным json длиной от 1 до $$$10^5$$$.
Строка с валидным json отличающаяся от входной одним добавленным символом.
{"key":"value}
{"key":"value"}
{"key""value"}
{"key":"value"}
Электронное письмо можно упрощённо представить в виде структуры
struct Message {
int userId; // id получателя
string from; // email-адрес отправителя
unsigned receiveTimestamp; // время получения
int folderId; // id папки, в которую доставлено письмо
int threadId; // id цепочки (треда), в которую группируются письма при обсуждении
};
Нужно реализовать хранилище писем, в которое можно складывать письма и у которого можно запрашивать список писем по параметрам. Параметрами для запроса являются:
Письма в выдаче должны быть сгруппированы в треды (сначала идут письма первого треда, затем второго и так далее). Таймстемпом треда считается таймстемп самого свежего письма в этом треде.
Должны выбираться только треды, принадлежащие папке $$$folderId$$$. Считается, что тред принадлежит папке $$$folderId$$$, если хотя бы одно письмо из этого треда лежит в папке $$$folderId$$$. Таким образом в выдаче писем могут присутствовать письма с $$$folderId$$$, отличающимся от переданного.
В выдачу должны попасть только треды, таймстемпы которых попадают в отрезок $$$[since, till]$$$, включительно.
Треды в выдаче должны быть отсортированы по убыванию своих таймстемпов. Для тредов с одинаковым таймстемпом сортировка идет по увеличению $$$threadId$$$. Письма внутри треда должны быть отсортированы по убыванию таймстемпа. Для писем с одинаковым таймстемпом сортировка идет по порядку сохранения в хранилище.
После всех группировок применяется правило для ограничения количества элементов в выдаче: надо выбрать $$$count$$$ первых.
На вход программе подается последовательность строк вида
n q
+ <userId> <from> <timestamp> <folderId> <threadId>
...
? <userId> <folderId> <since> <till> <count>
...
Программа должна для каждой операции $$$?$$$ выдать следующую секцию:
M
<userId> <from> <timestamp> <folderId> <threadId>
...
<userId> <from> <timestamp> <folderId> <threadId>
где $$$M$$$ - количество элементов в выдаче на запрос $$$?$$$. После строки с числом $$$M$$$ следует столько же строк, каждое обозначает письмо. Количество таких секций равняется количеству действий $$$?$$$ во входном файле.
8 1 + 0 hello0.0.0@yandex.ru 39 0 0 + 0 hello0.0.1@yandex.ru 83 0 0 + 0 hello0.1.0@yandex.ru 91 1 0 + 0 hello0.1.1@yandex.ru 0 1 0 + 1 hello1.0.0@yandex.ru 61 0 0 + 1 hello1.0.1@yandex.ru 64 0 0 + 1 hello1.1.0@yandex.ru 89 1 0 + 1 hello1.1.1@yandex.ru 45 1 0 ? 1 0 3 90 2
2 1 hello1.1.0@yandex.ru 89 1 0 1 hello1.0.1@yandex.ru 64 0 0
2 1 + 1 hello1@yandex.ru 1 1 1 + 1 hello2@yandex.ru 2 1 2 ? 1 1 0 10 1
1 1 hello2@yandex.ru 2 1 2
При решении различных задач используются классификационные алгоритмы (или классификаторы), которые относят наблюдаемый объект к определённому классу. Например, рассмотрим запросные классификаторы, которые относят запрос пользователя в поисковую систему к той или иной группе запросов: спортивные события, новости, рецепты и пр. Такие классификаторы помогают улучшить взаимодействие пользователя с сервисом.
При внедрении классификаторов смотрят на метрики и на время работы. Метрики отвечают за пользу, которую классификаторы приносят сервису, а время работы должно быть небольшим — для удобства пользователя. Опытным путём было выявлено, что для быстрого и комфортного взаимодействия с поисковой системой, одновременно может работать не более $$$M$$$ классификаторов.
Всего есть $$$K$$$ метрик, которые определены для каждого классификатора. Для набора классификаторов значение метрики определяется как максимум по ней среди классификаторов, входящих в набор. Пользой набора классификаторов считается сумма его метрик.
Вам дано $$$N$$$ классификаторов. Необходимо найти набор из $$$M$$$ классификаторов с максимальной пользой.
Первая строка содержит три целых числа $$$N$$$, $$$M$$$ и $$$K$$$ ($$$1 \leqslant N \leqslant 2000$$$, $$$1 \leqslant M \leqslant N$$$, $$$1 \leqslant K \leqslant 15$$$) — количество классификаторов, размер искомого набора и количество метрик.
Следующие $$$N$$$ строк описывают классификаторы. В $$$i$$$-й строке содержатся $$$K$$$ значений метрик $$$a_{ij}$$$ ($$$1 \leqslant a_{ij} \leqslant 10^8$$$) $$$i$$$-го классификатора.
В первой строке выведите одно число — максимальную пользу, которую можно получить для набора из $$$M$$$ классификаторов. Во второй строке выведите через пробел $$$M$$$ чисел — номера классификаторов из набора с максимальной пользой.
Если таких наборов несколько, можно вывести любой.
6 2 3 4 1 1 1 4 1 1 1 4 1 3 3 3 1 3 3 3 1
10 1 4
3 3 2 10 10 5 5 1 1
20 1 2 3