Информатика

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

Фермер Джон отправил Беси на марафон.
Дистанция включает N (3 <= N <= 100,000) контрольных пунктов,
которые нужно посетить поочерёдно, от 1 до N.
Ленивая Беси решила пропустить один контрольный пункт
(не 1 и не N разумеется).

Помогите Беси найти минимальное расстояние, которое ей придётся
пробежать, если она пропустит один контрольный пункт.

Замечание: расстояние между двумя точками (x1,y1) и (x2,y2)
надо рассматривать и вычислять как манхэттенское
|x1-x2| + |y1-y2|,
поскольку во время этого марафона двигаться можно только
параллельно осям координат.

Формат входных данных

Первая строка даёт значение N.

Каждая из последующих N строк содержит два разделённых
пробелом целых числа X и Y (-1000 <= x <= 1000, -1000 <= y <= 1000),
представляющих контрольный пункт.

Контрольные пункты задаются в том порядке, в котором их
необходимо посещать.

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

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

Формат выходных данных

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

В приведенном примере, пропустив точку(8,3) получим
минимальное расстояние 14.

Пример вывода

14

Nap Sort#90264

Беси сортирует массив целых чисел собственным алгоритмом. У неё есть куча из \(N\) \((1 \leq N \leq 2\cdot 10^5)\) целых чисел \(a_1,a_2,\dots,a_N\) \((1 \leq a_i \leq 10^{11})\), которые она хочет перенести в другой массив в отсортированном порядке. Она постоянно ищет минимальный элемент в куче, удаляет его и добавляет в конец массива. Беси требуется \(p\) секунд, чтобы найти минимальный элемент в куче из \(p\) целых чисел.

ФД выделил Беси в помощь неограниченное количество коров. Беси использует их следующим образом. Она разделила все свои целые числа на две кучи: куча Беси и куча Помощниц. Для каждого числа в своей куче она выполняет алгоритм как обычно. Для каждого целого числа в куче Помощниц Беси назначает его отдельной корове. И предлагает ей поступать так. Когда корова помощница получает число \(a_i\), она должна подождать \(a_i\) секунд и затем добавить это число в конец массива. Если Беси и корова-помощница добавляют число в одно и то же время, то сначала добавляется число Беси. Если нескольким коровам-помощницам было дано одно и то же число, они добавляют копии этого числа в одно и то же время.

Помогите Беси поделить её числа так, чтобы финальный массив был отсортирован, а время сортировки было минимально.

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

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

Каждый подтест имеет такую структуру:

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

Следующая строка содержит \(a_1, a_2, \dots, a_N\), - целые числа, которые сортирует Беси. Некоторые целые числа могут появится множество раз.

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

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

Для каждого подтеста выведите в отдельной строке минимальное время сортировки массива, если Беси поделит числа оптимально.

У Фермера Джона важная задача - решить какой тип сена купить для своих коров.

У Фермера Джона есть \(N\) коров (\(2 \le N \le 10^5\)) пронумерованных от \(1\) до \(N\). Каждая корова любит ровно один тип сена \(h_i\) (\(1 \le h_i \le N\)). ФД хочет, чтобы все его коровы любили один тип сена.

Чтобы это случилось, ФД может сформировать фокус-группы. Фокус-группа состоит из всех коров в непрерывном интервале от \(i\) до \(j\), включительно. Если в фокус-группе более половины коров любит один и тот же некоторый тип сена, то все коровы начинают любить этот тип сена, иначе ни у одной коровы не изменяется любимый тип сена. Например, если фокус группа состоит из 16 коров, 9 или более из которых любят один и тот же тип сена, то и остальные 7 коров теперь будут любить этот же тип сена.

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

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

Сначала идёт одно целое число \(T\), которое обозначает количество независимых тестов \((1 \leq T \leq 10)\).

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

Вторая строка каждого теста состоит из \(N\) целых чисел, любимых типов сена \(h_i\), в порядке номеров коров.

Гарантируется, что сумма \(N\) во всех тестах не превысит \(2\cdot 10^5\).

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

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

Если возможно сделать, чтобы все коровы полюбили один и тот же тип сена, выведите все такие возможные типы сена в порядке возрастания. Иначе, выведите \(-1\). Когда выводите список чисел, выводите соседние числа через один пробел, и в конце этой строки не должно быть пробелов.

Moorbles#90257

Беси и Эльза играют с шариками так: Беси и Эльза начинают игру с некоторым количеством шариков. Беси берёт \(A\) шариков из своих, а Эльза должна угадать является ли число \(A\) чётным или нечётным. Если Эльза угадает, она забирает эти \(A\) шариков, если нет - она отдаёт \(A\) своих шариков Беси. Если у Эльзы нет \(A\) шариков - она проиграла. Игрок проиграл, если остался без шариков.

После нескольких этапов игры, у Эльзы осталось \(N\) \((1 \leq N \leq 10^9)\) шариков. Она думает, что ей тяжело выиграть, она играет, чтобы не проиграть. Она хорошо изучила привычки Беси и заметила, что на \(i\)-ом ходу есть только \(K\) \((1 \leq K \leq 4)\) различных количеств шариков, которые может предложить Беси. Проходит всего только \(M\) \((1 \leq M \leq 3 \cdot 10^5)\) ходов прежде, чем Беси надоест, и она перестанет играть. Можете ли Вы определить лексикографически минимальную последовательность ходов такую, чтобы Эльза не проиграла вне зависимости от ходов Беси.

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

Первая строка содержит целое число \(T\) (\(1 \leq T \leq 10\)) представляющее количество подтестов. Каждый подтест описывается следующим образом:
  • Сначала идёт строка, содержащая три целых числа \(N\), \(M\), \(K\), представляющая количество шариков у Эльзы, количество ходов, и количество потенциальных ходов, которые может сделать Беси, соответственно.
  • Затем идут \(M\) строк, где строка \(i\) содержит \(K\) различных разделённых одиночными пробелами целых чисел \(a_{i,1} \; a_{i,2} \ldots a_{i,K}\) (\(1 \leq a_{i, j} \leq 10^3\)) представляющих возможные количества шариков, которые Беси может выложить на \(i\)-ом ходу.
Гарантируется. что сумма \(M\) по всем подтестам не более \(3 \cdot 10^5\).

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

Для каждого подтеста выведите лексикографически минимальную последовательность ходов Эльзы, которая гарантирует, что Эльза не проиграет или \(-1\), если Эльза проиграет. Последовательность ходов должна быть на одной строке и состоять из разделённых одиночными пробелами токенов, каждый из которых равен либо "Even" либо "Odd".

Замечание: "Even" лексикографически меньше чем "Odd".

Milk Sum#90233

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

\(N\) коров фермера Джона (\(1\le N\le 1,5\cdot 10^5\)) имеют целую продуктивность \(a_1,\dots,a_N\). То есть \(i\)я корова производит \(a_i\) единиц молока за минуту ( \(0 \leq a_i \leq 10^8\)).

Каждое утро фермер Джон начинает с того, что все \(N\) коров подключены к его дойке. От него требуется отцеплять их по одной, отправляя прочь для их ежедневных упражнений. Первая корова, которую он отправляет, снимается с крючка после всего 1 минуты дойки, вторая корова, которую он отправляет, отцепляется после двух минут дойки и так далее. Поскольку первая корова (скажем, корова \(x\)) тратит только одну минуту на доильном аппарате она вносит только \(a_x\) единиц общего количества молока. Вторая корова (скажем, корова \(y\)) тратит на доение всего две минуты и, таким образом, дает \(2a_y\) единиц общего количества молока. Третья корова (скажем, корова \(z\)) приносит всего \(3a_z\) единиц и так далее. Пусть \(T\) представляет собой максимально возможное количество молока, которое может собрать фермер Джон, если он отцепляет своих коров в оптимальном порядке.

Фермеру Джону интересно, как повлияет на \(T\), если часть производительностей молока в его стаде были другими. Для каждого из запросов \(Q\) (\(1\le Q\le 1.5\cdot 10^5\)) каждое из которых задано двумя целыми числами \(i\) и \(j\), пожалуйста, рассчитайте, какой будет новое значение \(T\), если \(a_i\) было установлено в \(j\) (\(0 \leq j \leq 10^8\)). Обратите внимание, что каждый запрос рассматривает временное потенциальное изменение независимо от всех других запросов; то есть \(a_i\) возвращается к исходному значению перед следующим запросом.

ФОРМАТ ВВОДА (ввод поступает с терминала/стандартного ввода):

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

Вторая строка содержит \(a_1\dots a_N\).

Третья строка содержит \(Q\).

Следующие \(Q\) строк содержат по два целых числа \(i\) и \(j\), разделенных пробелом.

ФОРМАТ ВЫВОДА (вывод на терминал / стандартный вывод):

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

Фермер Джон выстроил в ряд свои \(N\) коров (\(1 \leq N \leq 3\cdot 10^5\)). К несчастью, стала распространяться болезнь.

Изначально некоторые коровы инфицированы. Каждую ночь инфицированная корова распространяет болезнь на коров соседних слева и справа, если они есть. Однажды инфицированная корова остаётся инфицированной.

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

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

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

Следующая строка содержит \(N\)-символьную битовую строку из цифр \(1\) и \(0\) где \(1\) представляет инфицированную корову, а \(0\) представляет неинфицированную корову после некоторого количества ночей.

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

Выведите одно целое число: минимальное количество коров, с которых могла стартовать болезнь.

Коровы Фермера Джона любят конфетные трости. У ФД \(N\) коров с определённой начальной высотой. Он хочет скормить им \(M\) конфетных тростей, различной высоты (\(1\le N,M\le 2\cdot 10^5\)).

ФД планирует кормить коров конфетными тростями одну за одной в порядке, в котором они заданы на вводе. Чтобы кормить коров ФД вывешивает конфетные трости так, чтобы изначально они касались земли. Коровы выстраиваются одна за одной в порядке, как они заданы на входе. Каждая ест до своей высоты (потому что выше не достаёт). Трость остаётся на месте где она изначально была подвешена и не опускается к земле, даже после того как её нижняя часть съедена. Возможно, что когда подойдёт очередь некоторой коровы она ничего не сможет съест, если нижняя часть трости уже выше высоты этой коровы. После того как пройдёт очередь всех коров, они подрастают на высоту равную количеству единиц трости, которую съела корова, а ФД вывешивает новую конфетную трость и коровы повторяют процесс опять (корова 1 всегда начинает есть первой).

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

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

Следующая строка содержит начальные высоты \(N\) коров, каждая в интервале \([1,10^9]\).

Следующая строка содержит высоты \(M\) конфетных тростей, каждая в интервале \([1,10^9]\).

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

Финальные высоты каждой из \(N\) коров на отдельной строке.

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

Фермер Джон изучает эволюцию пород коров. Результат - корневое дерево с \(N\) (\(2\le N\le 10^5\)) вершинами, помеченными \(1\ldots N\), каждая вершина соответствует одной породе коров. Для каждого \(i\in [2,N]\), родитель вершины \(i\) есть вершина \(p_i\) (\(1\le p_i<i\)), это означает, что порода \(i\) эволюционировала из породы \(p_i\). Вершина \(j\) называется предком вершины \(i\), если \(j=p_i\) или \(j\) предок вершины \(p_i\).

Каждая вершина \(i\) в этом дереве ассоциируется с породой, имеющей целое число пятен \(s_i\). Дисбалансом такого дерева называется максимум \(|s_i-s_j|\) по всем парам \((i,j)\) таким, что \(j\) есть предок \(i\).

Фермер Джон не знает точное значение \(s_i\) для каждой породы, но он знает нижнюю и верхнюю границу этих величин. Ваша задача - назначить значения \(s_i \in [l_i,r_i]\) (\(0\le l_i\le r_i\le 10^9\)) каждой вершине так, чтобы минимизировать дисбаланс этого дерева.

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

Первая строка содержит \(T\) (\(1\le T\le 10\)), количество независимых подтестов в тесте. и целое число \(B\in \{0,1\}\).

Каждый подтест начинается со строки, содержащей \(N\), за которым следуют \(N-1\) целых чисел \(p_2,p_3,\ldots,p_N\).

Каждая из последующих \(N\) строк содержит целые числа \(l_i\) и \(r_i\).

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

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

Для каждого подтеста выведите одну или две строки в зависимости от значения \(B\).

Первая строка должна содержать минимальный дисбаланс.

Если \(B=1,\) выведите дополнительную строку с разделёнными одиночными пробелами целыми числами \(s_1,s_2,\ldots, s_N\) содержащими назначения количеств пятен для достижения вышеуказанного дисбаланса. Любое правильное назначение будет принято.

Circus#90117
\(N\) коров из цирка Фермера Джона (\(1 \leq N \leq 10^5\)) готовят своё представление. Оно будет происходить на дереве с вершинами помеченными \(1\ldots N\). "Стартовое состояние" представления определяется числом \(1 \leq K \leq N\) и назначением коров \(1\dots K\) вершинам на дереве так, что никакие две коровы не размещаются в одной и той же вершине.

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

Для каждого \(1 \leq K \leq N\), помогите коровам определить количество классов эквивалентности стартовых состояний: то есть максимальное количество стартовых состояний, которое они могут выбрать, так что никакие два из них не будут эквивалентными. Поскольку эти числа могут быть очень большими, выведите их остатки по модулю \(10^9 + 7\).

ФОРМАТ ВВОДА (файл circus.in):

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

каждая из строк \(2\le i\le N\) содержит да целых числа \(a_i\) и \(b_i\) обозначающих ребро в дереве между вершинами \(a_i\) и \(b_i\).

ФОРМАТ ВЫВОДА (файл circus.out):

Для кажого \(1\le i\le N,\) \(i\)-ая строка вывода должна содержать ответ для \(K=i\) по модулю \(10^9+7\).

Коровы Фермера Джона устали от ежедневных сортировок перед выходом из амбара. Они получили Ph.D по квантовой физике и готовы ускорить этот процесс.

Этим утром, как обычно \(N\) коров (\(1 \leq N \leq 10^5\)), последовательно пронумерованных \(1 \dots N\), находятся в амбаре на различных позициях, также пронумерованных \(1 \dots N\), так что корова \(i\) находится в позиции \(p_i\). Однако этим утром имеется \(M\) туннелей (\(1 \leq M \leq 10^5\)), которые пронумерованы \(1 \dots M\), при этом туннель \(i\) двунаправленно связывает позиции \(a_i\) и \(b_i\) и имеет ширину \(w_i\)\(1\le a_i,b_i\le N, a_i\neq bi, 1\le w_i\le 10^9\) ).

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

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

 

ОЦЕНИВАНИЕ:

 

  • Тесты 3-5 удовлетворяют ограничениям \(N,M\le 1000.\)
  • Тесты 6-10 не имеют дополнительных ограничений.

 

 

ФОРМАТ ВВОДА:

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

Вторая строка содержит \(N\) целых чисел \(p_1, p_2, \dots, p_N\). Гарантируется, что \(p\) есть перестановка чисел \(1\ldots N.\)

Для каждого \(i\) между \(1\) и \(M\), строка \(i+2\) содержит целые числа \(a_i\), \(b_i\), и \(w_i\).

 

ФОРМАТ ВЫВОДА:

Одно целое число: наибольшая минимальная ширина туннеля, в которую поместится коров во время процесса сортировки. Если коровы не используют туннели во время сортировки выведите \(-1\).

 

Фермер Джон должен Беси \(N\) галлонов молока (\(1\le N\le 10^{12}\)). Он должен вернуть ей молоко в течение \(K\) дней. Однако он не хочет отдавать молоко слишком быстро. С другой стороны, он должен показывать прогресс в возвращении долга. Поэтому он должен возвращать Беси не менее \(M\) галлонов молока (\(1\le M\le 10^{12}\)) каждый день.

ФД собирается делать так. Он выбирает положительное целое число \(X\). А затем повторяет следующую процедуру каждый день:

  1. Предположим, что ФД уже отдал Беси \(G\) галлонов молока, он вычисляет \(\frac{N-G}{X}\) с округлением вверх. Назовём это число \(Y\).
  2. Если \(Y\) меньше чем \(M\), то устанавливает \(Y\) равным \(M\).
  3. Даёт Беси \(Y\) галлонов молока.

Определите максимальное \(X\) такое, что если ФД будет следовать этой процедуре, то ФД отдаст Беси не менее \(N\) галлонов молока после \(K\) дней (\(1\le K\le 10^{12}\)).

ОЦЕНИВАНИЕ:

  • Тесты 2-4 удовлетворяют ограничению \(K\le 10^5.\)
  • Тесты 5-11 не имеют дополнительных ограничений.

ФОРМАТ ВВОДА (файл loan.in):

Единственная строка ввода содержит три разделённых пробелом целых положительных числа \(N\), \(K\), \(M\) удовлетворяющих \(K\cdot M<N\).

ФОРМАТ ВЫВОДА (файл loan.out):

Выведите наибольшее положительное целое число \(X\) такое, что ФД отдаст Беси не менее \(N\) галлонов молока используя описанную выше процедуру.

Фермер Джон планирует построить \(N\) (\(1 \leq N \leq 10^5\)) ферм, которые будут соединены \(N-1\) дорожками, образовывая дерево. Обычно когда на одной из ферм возникает проблема, он получает информацию в виде " имеется проблема на одной из ферм на пути от фермы \(A\) к ферме \(B\).

ФД рассматривает ферму как точку на 2-мерной плоскости. Он хотел бы получать информацию о проблемах на одной из ферм в прямоугольных координатах. А именно он хочет получать информацию в виде не более двух прямоугольников, параллельных осям координат, чьё пересечение пустое, а объединение содержит все фермы на пути от \(A\) к \(B\). Вы должны помочь ФД определить, как расположить его фермы так, чтобы условие выполнялось.

Это интерактивная задача. Вы не должны использовать ввод-вывод. Решения, использующие ввод-вывод будут дисквалифицированы. Но Вам разрешено использовать глобальные и статические переменные. Вы должны разработать следующие функции:

  • void addRoad(int A, int B): обрабатывает дорогу между фермами \(A\) и \(B\) (\(0 \le A, B \le N - 1\)).
  • void buildFarms(): Определяет, где ФД должен построить все свои фермы.
  • void notifyFJ(int A, int B): сообщает ФД один или два прямоугольника, которые удовлетворяют вышеописанным условиям

Ваша реализация указанных выше функций должна вызывать следующие функции, перечисленные ниже. Вы можете полагать, что \(\texttt{notifyFJ}\) будет вызвана \(Q\) раз.

  • int getN(): получить значение \(N\).
  • int getQ(): получить значение \(Q\).
  • void setFarmLocation(int ID, int X, int Y): определяет, что ФД должен построить ферму с номером \(ID\) (\(0 \le ID \le N-1\)) в позиции \((X,Y)\), где \((1 \le X, Y \le 10^5 )\). Она будет вызвана из \(\texttt{buildFarms}\).
  • void addBox(int X1, int Y1, int X2, int Y2): добавляет прямоугольник для сообщения ФД, \((1 \le X1 \le X2 \le 10^5 )\) и \((1 \le Y1 \le Y2 \le 10^5 )\). Вызывается только из \(\texttt{notifyFJ}\).

Интерактивный протокол работает следующим образом: Сначала \(\texttt{addRoad}\) вызывается \(N-1\) раз, чтобы информировать Вашу программу о системе дорог. Затем, будет вызвана \(\texttt{buildFarms}\) и Вы должны будете определить, где ФД должен построить каждую свою ферму соотвественно. А потом будут \(Q\) вызовов \(\texttt{notifyFJ}\) где Вы должны будете сделать один или два вызова \(\texttt{addBox}\) для нотификации ФД.

Гарантируется, что всегда существует корректный способ нотифицировать ФД одним или двумя прямоугольниками. Ограничение по памяти для данной задачи 512 Мбт (в отличие от обычных 256).

Для C++ решений, используйте такой template:

#include "grader.h"

void addRoad(int a, int b){
	// Fill in code here
}

void buildFarms(){
	// Fill in code here
}

void notifyFJ(int a, int b){
	// Fill in code here
}

Для Java решений, исполозуйте такой template:

import java.io.IOException;
// If you find it necessary, you may import other standard libraries here.
public class boxes extends Grader {

  	// Copy this exactly:
        
Override
  	public static void main(String args[]) throws IOException { new boxes().run(); }

        
Override
  	public void addRoad(int a, int b) {
      // Fill in code here
  	}
        
Override
  	public void buildFarms(){
      // Fill in code here
	  }
  	
Override
  	public void notifyFJ(int a, int b){
      // Fill in code here
  	}
}
}

Пример взаимодействия

Grader calls \(\texttt{addRoad(0,1)}\)

Grader calls \(\texttt{addRoad(1,2)}\)

Grader calls \(\texttt{buildFarms()}\)

Solution calls \(\texttt{setFarmLocation(0,1,1)}\)

Solution calls \(\texttt{setFarmLocation(1,1,2)}\)

Solution calls \(\texttt{setFarmLocation(2,2,2)}\)

Solution ends \(\texttt{buildFarms()}\)

Grader calls \(\texttt{notifyFJ(0,0)}\)

Solution calls \(\texttt{addBox(1,1,1,1)}\)

Solution ends \(\texttt{notifyFJ(0,0)}\)

Grader calls \(\texttt{notifyFJ(0,2)}\)

Solution calls \(\texttt{addBox(1,1,1,2)}\)

Solution calls \(\texttt{addBox(2,2,2,2)}\)

Solution ends \(\texttt{notifyFJ(0,2)}\)

Грайдер завершает свою работу, решение прошло тест.

Автор: Spencer Compton

Snakes#90077

У Беси есть сеть ловить змеек, распределённых в \(N\) групп на линии \((1 \leq N \leq 400)\). Беси должна поймать каждую змейку в каждой группе. Каждый раз, когда Беси ловит группу она может переложить змеек в клетку и начать пустой сеткой ловить следующую группу.

Сеть размером \(s\) означает, что Беси может поймать любую группу, которая содержит \(g\) змеек, где \(g \leq s\). Однако каждый раз, когда Беси ловит группу змеек размером \(g\) сетью размером \(s\), она тратит впустую \(s - g\) пространства. Беси может начинать с сети любого размера и Беси может изменять размер своей сети \(K\) раз \((1 \leq K < N)\).

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

ФОРМАТ ВВОДА (файл snakes.in):

Первая строка содержит \(N\) и \(K\). Вторая строка содержит \(N\) целых чисел \(a_1,\dots,a_N\), где \(a_i\) (\(0 \leq a_i \leq 10^6\)) количество змеек в \(i\)-ой группе.

ФОРМАТ ВЫВОДА (файл snakes.out):

Выведите одно целое число - минимальное количество потерянного пространства после того как Беси выловит всех змеек.

Беси и Эльза играют на битовом массиве \(A\) длиной \(2N\) (\(1 \leq N \leq 10^5\)). Счёт Беси - это количество инверсий в первой половине массива \(A\), а счёт Эльзы - количество инверсий во второй половине массива \(A\). Инверсия - это такая пара \(A[i]=1\) и \(A[j]=0\), что \(i<j\). Например, если массив состоит из блока 0, за которым следует блок 1, то инверсий нет. А массив в котором за блоком из \(X\) единиц следует блок из \(Y\) нулей, то имеется \(XY\) инверсий.

Фермер Джон остановился около игры и хочет узнать минимальное количество обменов между соседними элементами, которые нужно совершить, чтобы игра получила ничейный счёт. ФОРМАТ ВВОДА (файл balance.in): Первая строка ввода содержит \(N\), следующая строка содержит \(2N\) целых чисел каждое из которых равно 0 или 1. ФОРМАТ ВЫВОДА (файл balance.out): Выведите количество соседних обменов, которые нужно сделать, чтобы игра получила ничейный счёт.

Фермер Джон пытается отсортировать свои \(N\) коров (\(1 \leq N \leq 100\)), последовательно пронумерованных \(1 \dots N\).

В настоящий момент коровы выстроились в линию в порядке \(p_1, p_2, p_3, \dots, p_N\), и ФД стоит перед коровой \(p_1\). Он хочет переупорядочить коров так, чтобы они стали в порядке \(1, 2, 3, \dots, N\), с коровой \(1\) перед ФД.

Фермера Джона слышит только корова, которая стоит перед ним. В этот момент ФД может сказать ей перейти на \(k\) позиций назад (\(k\) в интервале \(1 \ldots N-1\).). \(k\) коров, которых она проходит, двигаются вперёд, освобождая место для неё, в которое она и становится.

Например, пусть \(N=4\) и коровы стоят в таком порядке

 ФД: 4, 3, 2, 1 

Единственная корова, которая слышит ФД, это корова \(4\). Если он скажет ей сдвинуться на 2 позиции, порядок станет таким:

 ФД: 3, 2, 4, 1 

Теперь ФД слышит только корова \(3\). Теперь ей можно давать инструкцию и т.д.

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

ФОРМАТ ВВОДА (файл sleepy.in):

Первая строка содержит \(N\). Вторая строка содержит \(N\) целых чисел, разделённых одиночными пробелами : \(p_1, p_2, p_3, \dots, p_N\), указывающих стартовый порядок коров.

ФОРМАТ ВЫВОДА (файл sleepy.out):

Первая строка должна содержать одно целое число \(K\), задающее минимальное количество инструкций, которое требуется, чтобы отсортировать всех коров.

Вторая строка должна содержать \(K\) разделённых одиночными пробелами целых чисел \(c_1, c_2, \dots, c_K\), каждое в интервале \(1 \ldots N-1\), задающих последовательность инструкций, которая отсортирует исходную последовательность коров.

Если имеется несколько оптимальных последовательностей инструкций, выведите любую.

Фермер Джон построил \(N\) (\(1 \leq N \leq 10^5\)) ферм, соединённых \(N-1\) дорогами, формируя дерево (то есть, каждая ферма достижима от любой другой, и отсутствуют циклы). Каждая ферма содержит коров, чья марка Guernsey или Holstein.

\(M\) друзей ФД (\(1 \leq M \leq 10^5\)) часто посещают его фермы. Во время визита друга \(i\), ФД идёт с эти другом по уникальному маршруту от фермы \(A_i\) до фермы \(B_i\) (возможен случай, когда \(A_i = B_i\)). Дополнительно они могут попробовать некоторое количество молока вдоль пути, по которому они идут. Поскольку большинство друзей ФД сами фермеры, у них есть сильные предпочтения по молоку. Некоторые из его друзей пьют молоко только коров Guernsey, а оставшиеся пьют только молоко Holstein. Любой из друзей ФД будет счастлив только если он сможет попить предпочитаемое молоко во время визита.

Определите, каждый ли друг останется счастлив после визита.

ОЦЕНИВАНИЕ:

  • Тесты 2-5 удовлетворяют \(N\le 10^3, M\le 2\cdot 10^3.\)

ФОРМАТ ВВОДА (файл milkvisits.in):

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

Вторая строка содержит строку длину длины \(N\). \(i\)-ый символ строки есть 'G' если корова на \(i\)-ой ферме Guernsey, или 'H', если корова на \(i\)-ой ферме Holstein.

Каждая их следующих \(N-1\) строк содержит два целых числа \(X\) и \(Y\) (\(1 \leq X, Y \leq N\)), указывающих, что существует дорога между фермами \(X\) и \(Y\).

Последующие \(M\) строк содержат целые числа \(A_i\), \(B_i\) и символ \(C_i\). \(A_i\) и \(B_i\) представляют конечные точки пути \(i\)'-го друга, а \(C_i\) либо G либо H - тип молока, предпочитаемый \(i\)-ым другом.

ФОРМАТ ВЫВОДА (файл milkvisits.out):

Выведите двоичную строку длины \(M\). \(i\)-ый символ строки должен быть '1' если \(i\)-ый друг будет счастлив, или '0' в противном случае.

Фермер Джон планирует построить \(N\) (\(1 \leq N \leq 10^5\)) ферм, которые будут соединены \(N-1\) дорогой, формируя дерево (то есть каждая ферма достижима от каждой, и нет циклов). Каждая ферма содержит корову целого типа \(T_i\) между \(1\) и \(N\) включительно.

\(M\) друзей ФД (\(1 \leq M \leq 10^5\)) часто его посещают. Во время визита друга \(i\), ФД вместе с ним путешествует по уникальному пути от фермы \(A_i\) до фермы \(B_i\) (возможно \(A_i = B_i\)). Дополнительно, они пробуют молоко каждой коровы на своём пути. Поскольку друзья ФД также фермеры, они имеют сильное предпочтение по молоку. Каждый из них пьёт молоко только определённого типа коров. Любой из друзей ФД будет счастливым, только если сможет попить свой предпочитаемый тип молока во время пути.

Определите для каждого друга, будет ли он счастливым.

ОЦЕНИВАНИЕ:

  • Тест 2 второй пример, приведенный ниже.
  • Тест 3 удовлетворяет \(N\le 10^3, M\le 2\cdot 10^3\).
  • Тесты 4-7 удовлетворяют \(C_i\le 10\) (\(C_i\) определено ниже).

ФОРМАТ ВВОДА (файл milkvisits.in):

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

Вторая строка ввода содержит \(N\) разделённых целых чисел \(T_1,T_2,\ldots, T_N\). Тип коровы на \(i\)-ой ферме обозначен \(T_i\).

Каждая из последующих \(N-1\) строк содержит два различных целых числа \(X\) и \(Y\) (\(1 \leq X, Y \leq N\)), указывающих, что имеется дорожка между фермами \(X\) и \(Y\).

Последующие \(M\) строк содержат целые числа \(A_i\), \(B_i\), \(C_i\). \(A_i\) и \(B_i\) представляют конечные точки пути во время визита \(i\)-ого друга, \(C_i\) (\(1\le C_i\le N\)) указывает тип молока, предпочитаемый этим другом.

ФОРМАТ ВЫВОДА (файл milkvisits.out):

Выведите двоичную строку длины \(M\). \(i\)-ый символ этой строки должен быть '1', если \(i\)-ый друг будет счастлив, иначе - '0'.

Ферма Джона состоит из \(N\) пастбищ (\(2 \leq N \leq 50,000\)), попарно соединённых \(N-1\) двунаправленными дорожками единичной длины. Известно также, что имеется путь из любого пастбища к любому.

Однако если одну из дорожек заблокировать, то ферма разделится на две части, внутри каждой из которых связность сохранится, а между ними - нет. Поэтому ФД строит \(M\) дополнительных дорожек (\(1 \leq M \leq 50,000\)), каждая из которых имеет положительную целую длину не более \(10^9\). Коровы пользуются исходными дорожками, пока это возможно.

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

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

ФОРМАТ ВВОДА (файл disrupt.in):

Первая строка ввода содержит \(N\) и \(M\). Каждая из последующих \(N-1\) строк описывает оригинальную дорожку целыми числами \(p\) \(q\), где \(p\) \neq q$ - пастбища, соединённые этой дорожкой (в интервале \(1 \ldots N\)). Каждая из оставшихся \(M\) строк описывает дополнительную дорожку тремя целыми числами \(p\), \(q\), \(r\), где \(r\) длина этой дорожки. Не более одной дорожки пролегает между любыми двумя пастбищами.

ФОРМАТ ВЫВОДА (файл disrupt.out):

Для каждой из \(N-1\) оригинальных дорожек, в порядке как они появились на вводе, выведите длину кратчайшей "замещающей" дорожки, которая восстановит связность фермы в результате блокировки оригинальной дорожки. Если такой дорожки не существует, выведите -1.

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

ФД сделал \(M\) наблюдений об этой структуре (\(1 \leq M \leq 50,000\)). Каждое наблюдение - упорядоченный список некоторых из его коров, указывающий что их нужно доить именно в таком порядке. Например список 2 5 1 означает, он должен подоить корову 2, некоторое время спустя - корову 5 и некоторое время после - корову 1.

Наблюдения ФД приоритезированы, поэтому его цель - максимизировать значение \(X\) так, чтобы выполнились условия первых \(X\) наблюдений. Если несколько порядков дойки могут удовлетворять \(X\) наблюдениям, он выбирает тот, в котором корова с меньшим номером доится раньше. Иными словами, если несколько порядков дойки удовлетворяют этим условиям, ФД выбирает лексикографически наименьший. Порядок \(x\) является лексикографически меньшим, чем порядок \(y\), если для некоторого \(j\), , \(x_i = y_i\) для всех \(i < j\) и \(x_j < y_j\) (другими словами два порядка идентичны до некоторой точки, в которой \(x\) меньше чем \(y\)).

Помогите ФД определить наилучший порядок дойки его коров.

ФОРМАТ ВВОДА (файл milkorder.in):

Первая строка содержит числа \(N\) и \(M\). Каждая из следующих \(M\) строк описывает одно наблюдение. Строка \(i+1\) описывает наблюдение \(i\) и начинается с количества коров \(m_i\) в этом наблюдении, за которым следует список из \(m_i\) целых чисел, определяющих порядок коров в этом наблюдении. Сумма \(m_i\) не превышает \(200,000\).

ФОРМАТ ВЫВОДА (файл milkorder.out):

Выведите \(N\) разделённых пробелом целых чисел дающих перестановку чисел of \(1 \ldots N\), содержащую порядок в котором ФД должен доить своих коров.

Беси попала на дальнюю ферму. Эта ферма состоит из \(N\) амбаров (\(2 \leq N \leq 7 \cdot 10^4\)) и \(N-1\) двунаправленных туннелей между амбарами, так что между любыми двумя амбарами имеется путь, и он единственный. Каждый амбар, который имеет только один туннель, является выходом. Когда придёт утро, Беси приземлится на некоторый амбар и попытается достичь выхода.

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

Беси не уверена в своих шансах на успех, которые зависят от количества фермеров, которые будут за ней охотиться. Для каждого из \(N\) амбаров, в которых может приземлиться Беси, определите минимальное количество фермеров, которое необходимо, чтобы поймать Беси, в предположении, что фермеры распределяться оптимально среди выходных амбаров.

ФОРМАТ ВЫВОДА (файл atlarge.in):

Первая строка ввода содержит \(N\). Каждая из последующих \(N-1\) строк содержит два целых числа в интервале \(1 \ldots N\), описывающих туннель между двумя амбарами.

Заметим время на тест в этой задаче больше чем по умолчанию: 4 секунды для C/C++/Pascal, и 8 секунд для Java/Python.

ФОРМАТ ВЫВОДА (файл atlarge.out):

Выведите \(N\) строк, где \(i\)-ая строка содержит минимальное количество фермеров, необходимых, чтобы поймать Беси, если она приземлится в амбаре \(i\).

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