Алгоритмы

918 задачвместе с подтемами
Число у задачи — рейтинг сложности, слово рядом — насколько она трудна по сравнению с другими задачами такого же типа. Шкалы задач с ответом и задач с кодом между собой не сравниваются. Рядом — счётчики попыток: успешные, неуспешные.

Беси любит смотреть шоу на сервисе Mooloo. Поскольку Беси очень занятая корова, она создаёт план на следующие \(N\) (\(1 \leq N \leq 10^5\)) дней в течение которых будет смотреть шоу. Mooloo - платный сервис и она хочет минимизировать оплату.

У Mooloo интересная система подписки: она стоит \(d + K\) денег (\(1\le K\le 10^9\)), чтобы подписаться на \(d\) последовательных дней. Вы можете начать подписку в любой день. И Вы можете начать новую подписку, если текущая подписка истекла. Определите минимальное количество денег, чтобы заплатить за просмотр шоу.

ФОРМАТ ВВОДА (с клавитауры / stdin):

Первая строка содержит целые числа \(N\) и \(K\).

Вторая строка содержит \(N\) целых чисел описывающих дни, в которые Беси планирует смотреть шоу: \(1\le d_1<d_2<\dots<d_N\le 10^{14}\).

ФОРМАТ ВЫВОДА (на экран / stdout):

Рекомендуется использовать 64-битный целый тип для ответа (например "long long" в C/C++).

Беси - голодная корова. Каждый день на обед если есть пакеты сена в амбаре, она съедает ровно один пакет. Чтобы Беси не голодала, Фермер Джон присылает в некоторые дни некоторое количество пакетов с сеном, которые прибывают утром (до обеда). В частности в день \(d_i\), ФД присылает \(b_i\) пакетов сена (\(1\leq d_i \leq 10^{14}\), \(1 \leq b_i \leq 10^9\)).

Вычислите общее количество пакетов сена, которые съест Беси в течение \(T\) дней.

ФОРМАТ ВВОДА (с клавиатуры / stdin):

Первая строка содержит \(N\) и \(T\) (\(1 \le N \le 10^5\), \(1 \le T \le 10^{14}\)).

Каждая из последующих \(N\) строк содержит \(d_i\) и \(b_i\). Гарантируется, что \(1\le d_1<d_2<\dots < d_N\le T\).

ФОРМАТ ВЫВОДА (на экран / stdout):

Выведите количество пакетов сена, которые съест Беси за первые \(T\) дней.

Для вывода ответа требуется использовать 64-битные целые (например "long long" in C/C++).

Фермер Джон решил потренировать своих коров в акробатике. Сначала он взвесил своих коров и определил, что они имеют \(N\) (\(1\le N\le 2\cdot 10^5\)) различных весов. В частности, для каждой \(i\in [1,N]\), \(a_i\) из его коров имеют вес \(w_i\) (\(1\le a_i\le 10^9, 1\le w_i\le 10^9\)).

Его наиболее популярный трюк включает коров, формирующих сбалансированную башню. Башня это последовательность коров, стоящих одна на другой. Башня называется сбалансированной, если каждая корова с коровой над ней имеет вес не менее чем на (\(1\le K\le 10^9\)) больший, чем вес коровы непосредственно над ней. Каждая корова может быть частью не более чем одной сбалансированной башни.

Если ФД хочет создать не более \(M\) (\(1 \le M \le 10^9\)) сбалансированных башен из своих коров, какое наибольшее количество коров может быть частью некоторой башни?

ФОРМАТ ВВОДА (с клавиатуры):

Первая строка содержит три разделённых пробелом целых числа \(N\), \(M\), \(K\).

Следующие \(N\) строк содержат два разделённых пробелом целых числа \(w_{i}\) и \(a_i\). Гарантируется, что все \(w_i\) различны.

ФОРМАТ ВЫВОД (на экран):

Выведите максимальное количество коров в сбалансированных башнях, если ФД поможет сформировать эти башни оптимально.

Падают яблоки! В определённые моменты времени некоторое количество яблок падает в некоторые точки числовой прямой. В определённый момент времени некоторые коровы появляются на числовой прямой и НАЧИНАЮТ ловить яблоки.

Если яблоко падает на числовую прямую и корова его не поймала, оно исчезает бесследно. Если корова и яблоко прибыли в одно и то же время, корова ловит яблоко. Каждая корова может перемещаться на одну единицу за секунду. Если корова поймала яблоко, она покидает числовую прямую.

Сколько максимально яблок смогут поймать коровы, если будут действовать сообща оптимально?

ФОРМАТ ВВОДА (с клавиатуры / stdin):

Первая строка содержит \(N\) (\(1\le N\le 2\cdot 10^5\)), количество раз когда яблоки падали на числовую прямую или там появлялись коровы.

Каждая из последующих \(N\) строк содержит четыре целых числа \(q_i\), \(t_i\), \(x_i\), \(n_i\) (\(q_i\in \{1,2\}, 0\le t_i\le 10^9, 0\le x_i\le 10^9, 1\le n_i\le 10^3\)).

  • Если \(q_i=1\), это значит, что \(n_i\) коров прибыли на числовую прямую в момент времени \(t_i\) в позицию \(x_i\).
  • Если \(q_i=2\), это значит, что \(n_i\) яблок упали на числовую прямую в момент времени \(t_i\) в позицию \(x_i\).

Гарантируется, что все упорядоченные пары \((t_i,x_i)\) различны.

ФОРМАТ ВЫВОДА (на экран / stdout):

Максимальное количество яблок, которое коровы могут поймать сообща.

Фермер Джон пытается сделать совершенную фотографию своих \(N\) коров (\(2 \leq N \leq 2\cdot 10^5\), \(N\) четное).

У ФД есть коровы двух пород Guernseys и Holsteins. Чтобы сделать свою фотографию как можно более эстетичной, он хочет выстроить своих коров так, чтобы как можно больше коров породы Guernseys находились на позициях с чётными номерами (первая позиция в ряду - нечётная, следующая чётная и т.д.). Для перестройки порядка коров он может только попросить "префикс" своих коров четной длины сделать реверс. "Префикс" состоит из диапазона коров от первой коровы до \(j\)-ой коровы для некоторой позиции \(j\).

Вычислите минимальное количество реверсов, которое потребуется ФД для достижения своей цели.

ФОРМАТ ВВОДА (с клавиатуры / stdin):

Первая строка ввода содержит величину \(N\).

Вторая строка ввода содержит набор символов длины \(N\), указывающих начальный порядок коров слева направо. Символ 'H' представляет породу Holstein, а символ 'G' представляет породу Guernsey.

ФОРМАТ ВЫВОДА (на экран / stdout):

Выведите минимальное количество реверсов.

У Фермера Джона есть \(N\) (\(1\leq N \leq 10^5\)) стогов из тюков сена. Для каждого \(i\in [1,N]\), \(i\)-ый стог имеет \(h_i\) (\(1\le h_i\le 10^9\)) тюков. Бесси может выполнять следующие операции:

  • Если высоты двух соседних стогов сена различаются не более чем на \(K\) (\(1\le K\le 10^9\)), она может поменять местами два стога

Какую лексикографически минимальную последовательность высот Беси может получить после некоторой последовательности таких операций?

**Примечание: ограничения на время и память для этой задачи 4сек и 512 Мбт, что в 2 раза больше значений по умолчанию.**

ФОРМАТ ВВОДА (с клавиатуры / stdin):

Первая строка ввода содержит \(N\) и \(K\). \(i+1\)-ая строка содержит высоту \(i\)-того стога.

ФОРМАТ ВЫВОДА (на экран / stdout):

Выведите \(N\) строк, \(i\)-ая строка содержит высоту \(i\)-го стога в решении.

Коровы Фермера Джона решили предложить соревнование по программированию коровам фермера Нхоя. Для того, чтобы сделать задачи получше, они потратили значительное количество на подготовку тестов. В частности, для одной из задач им потребовалась Ваша помощь.

Имеется массив отсортированных чисел \(x_1 \leq x_2 \leq \dotsb \leq x_N\) (\(1 \leq N \leq 10^5\)), и целое число \(K\). Вы не знаете массив или \(K\) но Вы знаете для каждого индекса \(i\), наибольший индекс \(j_i\) такой, что \(x_{j_i} \leq x_i + K\). Гарантируется, что \(i\le j_i\) и \(j_1\le j_2\le \cdots \le j_N\le N\).

По заданной информации коровы ФД должны сконструировать любой массив, который соответствует данной информации для некоторого целого \(K\). Конструкция должна удовлетворять условию \(0 \leq x_i \leq 10^{18}\) для всех \(i\) и \(1 \leq K \leq 10^{18}\).

Можно доказать, что это всегда возможно. Помогите коровам ФД решить эту задачу.

ФОРМАТ ВВОДА (с клавиатуры / stdin):

Первая строка ввода содержит \(N\). Следующая строка содержит \(j_1,j_2,\ldots,j_N\).

ФОРМАТ ВЫВОДА (на экран / stdout):

Выведите \(K\), затем \(x_1,\ldots,x_N\) на отдельных строках. Любой корректный вывод будет принят.

SCORING:

  • Для 50% всех тестов, \(N\le 5000\)
  • Для оставшихся тестов нет дополнительных ограничений.

Автор: Danny Mittal

Drought#90165

\(N\) (\(1 \leq N \leq 100\)) коров Фермера Джона выстроены в ряд так, что \(i\)-ая корова имеет уровень голода \(h_i\) (целое неотрицательное число). Коровы хотят есть вместе, и единственный способ уменьшить уровень голода его коров - выбрать соседнюю пару коров \(i\) и \(i+1\) и дать каждой из них мешок кукурузы, тем самым уменьшить на 1 уровень голода каждой из них.

ФД хочет кормить своих коров пока у всех у них не станет один и тот же уровень голода - целый, неотрицательный. Хотя он не знает точно уровень голода каждой из своих коров, он знает верхнюю границу уровня голода каждой коровы, то есть уровень голода \(i\)-ой cow \(h_i\) не более \(H_i\) (\(0\le H_i\le 1000\)).

Ваша задача - посчитать по модулю \(10^9+7\) количество комбинаций из \(N\) уровней голода \([h_1,h_2,\ldots,h_N]\) таких, что ФД сможет достичь своей цели.

ФОРМАТ ВВОДА (с клавиатуры / stdin):

Первая строка содержит число \(N\).

Вторая строка содержит \(H_1,H_2,\ldots,H_N\).

ФОРМАТ ВЫВОДА (на экран / stdout):

Количество комбинаций из \(N\) чисел уровней голода по модулю \(10^9+7\).

Коровы играют с двумя игральными костями X и Y. Побеждает та кость, на которой больше очков. Если выпало одинаковое число, кости бросаются повторно, пока не выпадут разные числа. Мы говорим, что кость X бьёт кость Y, если более вероятно, что кость X выиграет у Y.

Рассмотрим 4-гранные кости

Кость A имеет числа 4, 5, 6, 7 на своих гранях.

Кость B имеет числа 2, 4, 5, 10 на своих гранях.

Кость C имеет числа 1, 4, 8, 9 на своих гранях.

Эти кости удовлетворяют довольно интересному свойству: A бьёт B, B бьёт C, C бьёт A. В частности, ни одна из этих костей не является "наилучшей", бьющёй две других. В этом случае, когда ни одна из трёх костей не является "наилучшей" и нет двух костей с олинаковой вероятностью победить, мы называем множество из таких трёх костей "не-транзитивным".

Вам дали числа на гранях двух 4-гранных костей A и B. Помогите коровам определить, есть ли способ назначить числа на гранях третьей кости С так, чтобы множество стало "не-транзитивным". Числа на всех гранях всех костей - целые в интервале от 1 до 10 включительно.

ФОРМАТ ВВОДА (с клавиатуры / stdin):

Каждый ввод состоит из нескольких независимых тестов, каждый из которых нужно решить правильно, чтобы пройти весь тест. Первая строка ввода содержит \(T\) (\(1\le T\le 10\)) - количество тестов.

Каждая из следующих \(T\) строк описывает один тест 8 числами: 4 числа на гранях кости A и 4 числа на гранях кости B. Все числа от 1 до 10, не обязательно в отсортированном порядке. Одно и тоже число может появиться несколько раз, даже на одной кости.

ФОРМАТ ВВОДА (на экран / stdout):

Выведите \(T\) строк. \(k\)-ая строка должна быть 'yes' если возможно спроектировать C, чтобы сделать множество "не-транзитивным", иначе вывести 'no'.

Drought#90162

\(N\) (\(1 \leq N \leq 10^5\)) коров Фермера Джона выстроены в ряд так, что \(i\)-ая корова в этому ряду имеет уровень голода \(h_i\) (\(0 \leq h_i \leq 10^9\)). Поскольку коровы - социальные животные и хотят есть вместе, единственный способ уменьшить уровень голода его коров - выбрать двух соседних коров с номерами \(i\) и \(i+1\) и скормить каждой из них по мешку кукурузы, чтобы уменьшить уровень голода каждой из них на один.

ФД хочет накормить своих коров так, чтобы все имели один и тот же некоторый не отрицательный уровень голода. Помогите ФД определить минимальное количество мешков кукурузы, которое ему потребуется, или -1, если это сделать невозможно.

ФОРМАТ ВВОДА (с клавиатуры / stdin):

Каждый ввод состоит из нескольких независимых тестов, каждый из которых нужно решить правильно, чтобы решить полностью входной тест. Первая строка содержит \(T\) (\(1\le T\le 100\)) - количество тестов на вводе. Каждый тест описывается парой строк. Первая строка в паре содержит \(N\), а вторая - \(h_1,h_2,\ldots,h_N\). Гарантируется, что сумма всех \(N\) в тесте не превысит \(10^5\). Значения \(N\) могут различаться внутри ввода.

ФОРМАТ ВЫВОДА (на экран / stdout):

Выведите \(T\) строк, по одной для каждого теста на вводе.

Заметим что требуется использовать 64-битное целое для ответа (например "long long" в C/C++)

Фермер Джон реорганизует свою электронную почту. Его экран выглядит как вертикальный список папок с левой стороны экрана и и вертикальный список писем с право стороны экрана. Имеется \(M\) папок, пронумерованных \(1 \ldots M\) (\(1 \le M \le 10^4)\). Его почта сейчас содержит \(N\) писем, пронумерованных \(1\ldots N\) (\(1 \le N \le 10^5\)); \(i\)-ое письмо необходимо переместить в папку \(f_i\) (\(1\le f_i\le M\)).

Экран ФД небольшой, поэтому он может видеть одновременно \(K\) (\(1\le K\le \min(N,M)\)) папок и \(K\) писем одновременно. Изначально, его экран показывает папки \(1 \ldots K\) слева и письма \(1 \ldots K\) справа. Для того чтобы увидеть другие папки и письма, он должен скроллить соответствующие списки. Например, если он проскроллит вниз на одну позицию в списке папок, он увидит папки \(2 \ldots K+1\), а если проскроллит ещё на одну позицию вниз, он увидит папки \(3 \ldots K+2\). Когда ФД переносит письмо в папку, оно исчезает из списка писем, и все нижние письма поднимаются на одну позицию вверх. Например, пусть на экране отображены письма \(1, 2, 3, 4, 5\) и ФД переносит письмо 3 в соответствующую папку, тогда видимая часть списка писем станет такой: \(1, 2, 4, 5, 6\). ФД может переносить письма только в назначенные им папки.

К несчастью, колесо скроллинга на мышке ФД сломалось, и он может скроллить только вниз и не может скроллить вверх. Единственное подобие скроллинга вверх если он видит последние \(K\) писем из своего списка и переносит в папку одно из них. В этом случае после переноса список опять покажет последние \(K\) ещё не разнесенных писем, что соответствует скроллингу вверх на одно письмо. Если осталось менее \(K\) писем, они отображаются все.

Помогите ФД определить, может ли он разнести по папкам все свои письма.

ФОРМАТ ВВОДА (с клавиатуры / stdin):

Первая строка ввода содержит \(T\) (\(1 \le T \le 10\)), количество подслучаев в тесте, каждый из которых должен решаться независимо. Далее идут \(T\) подслучаев. Для каждого подслучая первая строка содержит \(M\), \(N\), \(K\). Вторая строка содержит \(f_1 \ldots f_N\).

Гарантируется, что сумма \(M\) по всем подслучаям не превысит \(10^4\), а сумма \(N\) по всем подслучаям не превысит \(10^5\).

ФОРМАТ ВЫВОДА (на экран / stdout):

Выведите \(T\) строк, каждая содержит YES или NO, указывая может ли ФД разнести письма для каждого из \(T\) подслучаев.

\(N\) коров (\(1 \leq N \leq 10^5\)) Фермера Джона разместились на его ферме и хотят построить коммуникационную сеть для обмена электронными текстовыми сообщениями.

\(i\)-ая корова размещена в точке \((x_i,y_i)\), где \(0 \leq x_i \leq 10^6\) \(0 \leq y_i \leq 10\). Стоимость построения коммуникационной линии между коровами \(i\) и \(j\) есть квадрат расстояния между ними: \((x_i-x_j)^2 + (y_i-y_j)^2\).

Вычислите минимальную стоимость построения коммуникационной сети, так чтобы каждая корова могла разговаривать с любой другой непосредственно или через последовательность линий связи.

**Замечание : Лимитна время на тест = 4s, в дфа раза больше обычного..**

Формат ввода (с клавиатуры / stdin):

Первая строка ввода содержит \(N\), каждая из последующих \(N\) строк описывает \(x\) и \(y\) - координаты коровы, все числа - целые.

ФОРМАТ ВЫВОДА (на экран / stdout):

Выведите минимальную стоимость сети, которая позволит коммуницировать всем коровам. Заметим, что стоимость может быть очень большой, и может потребовать 64-битную целую типа "long long" в C++.

Беси радовалась введению индивидуального обучения. К несчастью, её тьютор Фермер Джон, очень скучный лектор, и поэтому она часто засыпала на занятиях.

ФД это заметил и попросил Эльзу вести учёт засыпаний Беси. Всего имеется \(N\) (\(1\le N\le 10^5\)) периодов, когда проходили занятия. И Эльза записала, что Беси засыпала \(a_i\) (\(0\le a_i\le 10^6\)) раз во время \(i\)-го периода. Общее количество засыпаний Беси не превышает \(10^6\).

Эльза хочет показать ФД, что Беси всегда засыпала одинаковое количество раз. Но единственный способ, которым она это может сделать - объединить два соседних периода проведения занятий. Например, если \(a=[1,2,3,4,5],\) то Эльза может объединить второй и третий периоды и лог станет таким \([1,5,4,5]\).

Помогите Эльзе вычислить минимальное количество модификаций лога, которые она должна сделать, чтобы сделать все числа лога равными.

ФОРМАТ ВВОДА (с клавиатуры / stdin):

Каждый ввод содержит \(T\) (\(1\le T\le 10\)) тестов, которые нужно решать независимо.

Первая строка содержит \(T\) - количество тестов. Затем следуют \(T\) тестов, каждый описывается парой строк. Первая строка пары содержит \(N\), а вторая содержит \(a_1,a_2,\ldots,a_N\).

Гарантируется, что внутри каждого теста сумма всех \(a_i\) не превышает \(10^6\). Также гарантируется, что сумма всех \(N\) в этих тестах не превысит \(10^5\).

ФОРМАТ ВЫВОДА (на экран / stdout):

Выведите \(T\), содержащих минимальное число модификаций, которое может выполнить Эльза, чтобы уравнять все числа в логах для каждого теста.

Фермер Джон выстроил в ряд своих \(N\) коров для фотографии.

Изначально коровы выстроились в порядке \(a_1,a_2,\ldots,a_N\) слева направо. Цель ФД выстроить их в порядке \(b_1,\ldots,b_N\) слева направо. Чтобы достичь своей цели, ФД может выполнить несколько модификаций порядка. Каждая модификация состоит в том, чтобы выбрать корову и переместить её влево на некоторое количество позиций.

Вычислите минимальное количество модификаций, которое потребуется ФД, чтобы выстроить коров в желаемом порядке.

ФОРМАТ ВВОДА (с клавиатуры / stdin):

Первая строка ввода содержит \(N\). Вторая строка содержит \(a_1,a_2,\ldots,a_N\). Третья строка содержит \(b_1,b_2,\ldots,b_N\).

ФОРМАТ ВЫВОДА (на экран / stdout):

Выведите минимальное количество модификаций, требуемое ФД для получения желаемого порядка.

Blocks#90150
У Беси есть 4 деревянных кубика. На каждой из 6 сторон каждого кубика написана одна буква.

По заданным буквам на каждом из 4 кубиков и списку слов, которые Беси хочет составлять из этих кубиков, определите слова из списка, которые она сможет составить, используя эти кубики.

ФОРМАТ ВВОДА (с клавиатуры / stdin):

Первая строка ввода содержит \(N\) (\(1\le N\le 10\)), количество слов, которые Беси хочет составить. Каждая из следующих 4 строк содержат строку из 6 символов - больших английских букв, представляющих буквы на сторонах кубика. Следующий \(N\) строк содержат \(N\) слов, которые Беси хочет составлять. Каждое слово имеет длину от 1 до 4 букв (больших английских).

ФОРМАТ ВЫВОДА (на экран / stdout):

Для каждого слова из списка Беси выведите YES, если она может составить это слово из своих кубиков и NO в противном случае.

Mountains#90142
**Обратите внимание: время на тест для этой задачи 5s, в 2.5 раза больше, чем обычно. Предельный размер памяти также увеличен в два раза по сравнению с умолчанием.

Имеется \(N\) (\(1 \leq N \leq 2000\)) гор в ряд на ферме Джона Это может быть выражено как массив высот \(h_1,h_2,\dots,h_N\). Для горы \(i\), Вы можете увидеть другую гору \(j\) если нет гор строго выше чем линия взгляда, соединяющая горы \(j\) и \(i\). Формально, для двух гор \(i < j\), они могут видеть друг друга, если не существует такого \(k\) \(i < k < j\) и \((k, h_k)\) выше чем отрезок, соединяющий \((i, h_i)\) и \((j, h_j)\). Имеется \(Q\) (\(1 \leq Q \leq 2000\)) изменений высот, когда высота одной горы возрастает. Определите общее количество неупорядоченных пар гор, которые могут видеть друг друга после каждого изменения.

ФОРМАТ ВВОДА (с клавиатуры / stdin):

Строка \(1\) содержит \(N\).

Строка \(2\) содержит \(N\) высот \(h_1,h_2,\dots,h_N\) (для каждого \(i\), \(0 \leq h_i \leq 10^9\)).

Строка \(3\) содержит \(Q\).

Строки \(4\) - \(3+Q\) содержат \(x\), \(y\) (\(1 \leq x \leq N\), \(1 \leq y\)) где \(x\) индекс горы, \(y\) - величина на которую эта гора возрастает. Гарантируется, что новая высота горы не превысит \(10^9\).

ФОРМАТ ВЫВОДА (на экран / stdout):

\(Q\) строк, на каждой общее количество неупорядоченных пар гор, которые могут видеть друг друга после каждого обновления.

ПРМЕР ВВОДА:

5
2 4 3 1 5
3
4 3
1 3
3 2
Беси хочет посмотреть Bovine Genomics: The Documentary, но она не хочет идти одна. К сожалению, её друзья не очень хотят идти с ней. Ей нужно чем то их привлечь. У неё есть два инструмента : mooney и мороженое.

У Беси \(N\) (\(1 \le N \le 2000\)) друзей. Однако они разные! Друг \(i\) имеет счёт популярности \(P_i\) (\(1 \le P_i \le 2000\)), и Беси хочет максимизировать сумму популярности друзей, которые пойдут с ней. Друг \(i\) пойдёт с ней только если она даст ему \(C_i\) (\(1 \le C_i \le 2000\)) "moonies". Друг \(i\) также может сделать скидку в \(1\) "mooney", если она даст ему \(X_i\) (\(1 \le X_i \le 2000\)) мороженых. Беси может получить сколько угодно скидок.

У Беси есть \(A\) moonies и \(B\) мороженых (\(0 \le A, B \le 2000\)). Помогите ей определить максимальную сумму популярностей, которую она может добиться, если потратит mooney и мороженое оптмально.

ФОРМАТ ВВОДА (с клавиатуры / stdin):

Строка \(1\) содержит три числа \(N\), \(A\), \(B\), представляющих количества друзей, mooney и мороженых, которые есть у Беси соответственно.

Каждая из последующих \(N\) строк содержит три числа \(P_i\), \(C_i\), \(X_i\), представляющих популярность (\(P_i\)), mooney, за которые он согласится пойти, количество мороженых для скидки в \(1\) mooney для друга \(i\) (\(X_i\)).

ФОРМАТ ВЫВОДА (на экран / stdout):

Выведите максимальную сумму популярностей друзей Беси, в предположении что она оптимально потратит moonie и мороженые.

У Фермера Джона имеется \(N\) (\(1 \le {N} \le {10^5}\)) коров, каждая из которых имеет породу или Guernsey(G) или Holstein(H). Они выстроились в ряд заняв позиции \(1\dots N\).

Поскольку все коровы голодные, ФД решил выложить пакты с травой в некоторых позициях \(1\dots N\). Коровы разных пород едят разные типы травы. Каждый пакет травы должен содержать траву только одного типа (для G или для H). Он не может разместить пакеты с разной травой в одной и той же позиции. Каждый пакет травы может накормить неограниченное количество коров соответствующего типа.

Каждая корова готова пройти не более \(K\) (\(0 \le {K} \le N-1\)) позиций чтобы добраться до пакета с травой. Определите минимальное количество пакетов с травой, необходимое чтобы накормить всех коров. Любая конфигурация, удовлетворяющая указанным выше ограничениям, будет рассматриваться как корректная.

ФОРМАТ ВВОДА (с клавитатуры / stdin):

Каждый тест состоит из \(T\) подтестов, описывающих расположение коров. Первая строка сдержит \(T\) (\(1 \le T \le 10\)). Далее следует \(T\) подтестов.

Каждый подтест начинается со строки содержащей \(N\) и \(K\). Следующая строка содержит строку длины \(N\), в которой каждый символ обозначает породу коровы на позиции \(i\) (G или H).

ФОРМАТ ВЫВОДА (на экран / stdout):

Для каждого из \(T\) подтестов выведите две строки. В первой строке выведите минимальное количество пакетов с травой, которые требуются. Во второй строке нужно вывести строку из \(N\) символов, которая описывает Ваше решение. \(i\)-ый символ этой строки указывает что нужно разместить в позиции \(i\): '.' - ничего 'G' - пакет с травой типа G 'H' - пакет с травой типа H Любая корректная конфигурация будет принята.

Фермер Джон планирует открыть новый университет для коров!

Имеется \(N\) (\(1 \le N \le 10^5\)) коров, которые потенциально могут посещать университет. Каждая корова готова платить за обучение максимум \(c_i\) (\(1 \le c_i \le 10^6\)). Фермер Джон может установить плату за обучение, которую все коровы должны оплатить. Если эта плата больше, чем корова готова платить, она не платит и не учится в университете. Фермер Джон хочет установить такую оплату, чтобы получить максимальную сумм оплат. Определите эту максимальную сумму и установленную плату за обучение.

ФОРМАТ ВВОДА (с клавиатуры / stdin):

Первая строка содержит \(N\). Вторая строка содержит \(N\) целых чисел \(c_1, c_2, \dots, c_N\), где \(c_i\) - это максимальная плата, которую готова платить корова \(i\).

ФОРМАТ ВЫВОДА (на экран / stdout):

Выведите максимальное количество денег, которое может получить ФД и оптимальную оплату за обучение, которую он должен установить. Если имеется несколько вариантов, выберите тот в котором минимальная оплата за обучение.

Заметим, что надо использовать 64-битный целый тип, например "long" в Java, или "long long" в C/C++).

У Беси есть коллекция связных неориентированных графов \(G_1,G_2,\ldots,G_K\) (\(2\le K\le 5\cdot 10^4\)). Для каждого i (\(1\le i\le K\)), \(G_i\) имеет ровно \(N_i\) (\(N_i\ge 2\)) вершин, помеченных \(1\ldots N_i\) и \(M_i\) (\(M_i\ge N_i-1\)) ребер. Каждый \(G_i\) может содержать циклы, но нет двух и более ребер между парой вершин.

Сейчас Эльза создаёт новый неориентированный граф \(G\) с \(N_1\cdot N_2\cdots N_K\) вершинами, каждая из которых помечена \(K\)-плетом \((j_1,j_2,\ldots,j_K)\), где \(1\le j_i\le N_i\). В \(G\) две вершины \((j_1,j_2,\ldots,j_K)\) и \((k_1,k_2,\ldots,k_K)\) соединены ребром, если для всех i \(1\le i\le K\), \(j_i\) и \(k_i\) соединены ребром в \(G_i\).

Определим расстояние между двумя вершинами в \(G\) которые лежат в одной и той же связной компоненте как минимальное количество ребер на пути из одной вершины в другую. Вычислите сумму расстояний между вершиной \((1,1,\ldots,1)\) и каждой вершиной в этой же компоненте в \(G\) по модулю \(10^9+7\).

ФОРМАТ ВВОДА (с клавиатуры / stdin):

Первая строка содердит \(K\), количество графов.

Описание каждого графа начинается с \(N_i\) и \(M_i\) в одной строке, за которой следуют \(M_i\) ребер.

Последовательные графы разделены пустыми строками для читабельности. Гарантируется, что \(\sum N_i\le 10^5\) и \(\sum M_i\le 2\cdot 10^5\).

ФОРМАТ ВЫВОДА (на экран / stdout):

Сумма расстояний от вершины \((1,1,\ldots,1)\) и каждой вершины достижимой от неё по модулю \(10^9+7\).

Поделиться
Класснуть