Информатика

16 015 задачвместе с подтемами
Число у задачи — рейтинг сложности, слово рядом — насколько она трудна по сравнению с другими задачами такого же типа. Шкалы задач с ответом и задач с кодом между собой не сравниваются. Рядом — счётчики попыток: ✓ успешные, ✗ неуспешные.
Cow Jog#90329

N (1 <= N <= 100,000) коров фермера Джона бегут по бесконечной
трассе. Все коровы начинают в различных позициях и некоторые
коровы бегут с различной скоростью.

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

Фермер Джон хочет, чтобы никакая корова не меняла свою дорожку
или изменяла свою скорость. И он интересуется, сколько дорожек
ему нужно, если коровы будут бежать T минут (1 <= T <= 1,000,000,000).

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

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

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

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

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

К несчастью, ФД не ученье удачно собрал данные о своих коровах
Для каждой из его N(1 <= N <= 50,000) коров, всё что он знает, это
вес коровы и имеет или нет она пятна. Все его коровы имеют
различный вес. По этим данным он построил то, что он назвал,
"классификатор ближайшего соседа". Чтобы угадать, есть у новой
коровы C пятно или нет, он сначала находит в своём стаде корову С'
такую, что её вес ближайший к C'. Если корова C' имеет пятна,
то ФД предполагает, что корова C имеет пятна, если корова C'
не имеет пятен, то ФД предполагает, что и корова C не имеет пятен.
Если же уникального ближайшего соседа нет, а есть две коровы
на одинаковом минимальном расстоянии от C', тогда ФД предполагает,
что корова C имеет пятна, если одна из двух ближайших коров
также имеется пятна.

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

Пожалуйста, определите, сколько из этих коров будут классифицированы
как имеющие пятна. Заметим, что классификатор делает предсказание,
основываясь на данных об N существующих коровах.
Также заметим, что A и B могут быть достаточно большими числами,
так что просто проверка всех чисел по одному от A до B не пройдёт
по времени.

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

Первая строка ввода содержит три целых числа N,A,B
(1 <= A <= B <= 1,000,000,000).

Каждая из следующих N строк описывают одну корову. Каждая строка
содержит либо S W, означающее, что корова с весом W имеет пятна
или NS W, означающее, что корова с весом W не имеет пятен.
Все веса - целые числа в интервале 1 ... 1 000 000 000.

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

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

В приведенном примере новые коровы с весами
1, 2, 7, 8, 9, 10
будут классифицированы как пятнистые.

Беси любит разгадывать кроссворды.
Однако её сестра Эльза пролила молоко на кроссворд,
и теперь Вам предстоит его восстановление (номеров
загаданных слов).

Вам даётся кроссворд, как решётка N*M (3 <= N <=
50, 3 <= M <= 50). Некоторые из клеток пусты (обычно они
белые), а некоторые заблокированы (обычно они чёрные).

Теперь процесс присвоения номеров загаданным словам -
это простой процесс из двух логических шагов:

Шаг 1: Для каждой ячейки мы определяем, начинает ли она
горизонтальное загаданное слово, или вертикальное
загаданное слово. Чтобы ячейка начинала горизонтальное
загаданное слово, нужно, чтобы её левая соседка была
заблокированной ячейкой или лежала вне кроссворда и две
клетки вправо от неё должны быть пустыми. (То есть
горизонтальное загаданное слово всегда содержит 3 или более
символов). Правила для ячейки, начинающей вертикальное
загаданное слово аналогичны: ячейка сверху должна быть
заблокирована или вне кроссворда и две клетки вниз
должны быть пустыми.

Шаг 2: Мы назначаем номер каждой ячейке, которая начинает
слово, последовательно от 1 в том же порядке, в котором
мы читаем книгу.
В первой строке назначаем числа слева направо, затем во
второй строке назначаем числа слева направо и т.д.
Числа назначаются только ячейкам, начинающим слова.

Например, рассмотрим кроссворд, где пустые ячейки отмечены
символами '.'. а блокированные ячейки отмечены символами '#'.

...
#..
...
..#
.##

Ячейки, которым могут быт присвоены номера
горизонтальных или вертикальных загаданных слов
помечены символами !.

!!!
#..
!..
..#
.##

Номера должны быть таковы:

123
#..
4..
..#
.##

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

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

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

Последующие N строк ввода описывают строки
решётки. Каждая состоит из M символов, каждый из которых
либо '.' (пустая ячейка) либо '#' (блокированная ячейка).

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

На первой строке выведите количество загаданных слов.
На каждой из оставшихся строк выведите строку и колонку
дающую позицию одного слова (в порядке, описанном выше).
Верхняя левая ячейка имеет позицию (1,1). Нижняя правая
ячейка имеет позицию (N,M).

Cow Jog#90325

Имеется N коров, бегающих вдоль бесконечно-длинной прямой
трассы. (1 <= N <= 100,000). Каждая корова начинает
с уникальной позиции и некоторые коровы бегут с различной скоростью.
Трасса имеет только одну дорожку и корова не может
перепрыгнуть другую. Поэтому, когда более быстрая корова
настигает более медленную, она замедляет свою скорость
и становится частью некоторой бегущей группы коров.

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

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

Первая строк ввода содержит целое число N.
Каждая из последующих строк содержит начальную позицию
и скорость одной коровы. Позиция - это неотрицательное
целое число, а скорость - положительное целое число,
оба числа не более 1,000,000,000.
Все коровы начинают в различных позициях, которые
задаются в порядке возрастания на вводе.

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

Одно целое число, указывающее, сколько групп останется.

Фермер Джон заметил, что имеется \(N\) (\(1\le N\le 2\cdot 10^5\)) уникальных ID-номеров и для каждого уникального ID \(d_i\) (\(0\le d_i\le 10^9\)), имеется \(n_i\) (\(1\le n_i\le 10^9\)) коров с таким ID.

Эти коровы могут коммуницировать в парах, их секретный метод шифрования имеет одно строгое правило: две коровы могут обмениваться информацией если это не одна и та же корова и сумма их ID-номеров равна или \(A\) или \(B\) (\(0\le A\le B\le 2\cdot 10^9\)). В один момент времени, корова может быть вовлечена только в одну беседу (то есть никакая корова не может быть частью более чем одной пары)

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

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

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

Каждая из последующих \(N\) строк содержит \(n_i\) и \(d_i\). Никакие два \(d_i\) не совпадают.

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

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

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

Lazy Sort#90320

У Фермера Джона есть \(N\) коров (\(2 \leq N \leq 5\cdot 10^6\)) и пытается заставить их отсортировать неотрицательный целочисленный массив \(A\) длины \(N\), полагаясь на их лень. У него много тяжелых коробок, поэтому он выстраивает коров одну за другой, где корова \(i+1\) находится за коровой \(i\), и дает \(a_i\) коробок корове \(i\) (\(0\le a_i\)).

Коровы по своей природе ленивы, поэтому они всегда ищут способ передать свою работу кому-то другому. От коровы \(1\) до \(N-1\) по порядку каждая корова смотрит на корову позади себя. Если у коровы \(i\) строго больше коробок, чем у коровы \(i+1\), корова \(i\) считает, что это «несправедливо» и отдает одну из своих коробок корове \(i+1\). Этот процесс повторяется, пока каждая корова не будет удовлетворена.

Фермер Джон пометил количество ящиков \(b_i\), которое каждая корова \(i\) держит и создал массив \(B\) из этих величин. Если \(B = sorted(A)\) тогда ФД счастлив. К несчастью. ФД забыл все кроме \(Q\) величин массива \(A\). (\(2 \leq Q \leq \min(N, 100)\)). К счастью, эти величины включают количество ящиков, которое он собирается дать первой и последней корове. Каждое число, которое помнит ФД задано в виде \(c_i \; v_i\), представляющее, что \(a_{c_i}=v_i\). (\(1 \leq c_i \leq N\), \(1\le v_i\le 10^9\)). Определите количество различных способов, которыми могут быть заполнены пропущенные величины так чтобы ФД был счастливым. ответ выводите по модулю \(10^9+7\).

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

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

Следующие \(Q\) строк содержат два разделённых пробелом целых числа \(c_i \; v_i\) представляющих что корова \(c_i\) изначально держит \(v_i\) ящиков. Гарантируется, что \(c_1 = 1\), \(c_Q = N\), и \(c_i < c_{i+1}\) (порядок коров строго возрастающий).

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

Выведите количество способов по модулю \(10^9+7\), которыми могут быть назначены значения \(a_i\), так, что ФД будет счастлив после того, как коровы выполнят ленивую сортировку. Гарантируется существование как минимум одного такого назначения.

У Фермера Джона есть \(N\) \((1 \leq N \leq 10^5)\) бутылок, которые он хочет наполнить молоком. Каждая бутылка изначально содержит некоторое количество молока \(m_i\) \((0 \leq m_i \leq 10^9)\). Каждый день он берёт \(A\) \((1 \le A \le N)\) бутылок и наполняет одной единицей молока.

К несчастью, Фермер Нхой, соперник ФД по бизнесу, знает об этом процессе ФД и намерен навредить. Каждый день после того, как ФД заполнит свои \(A\) бутылок, ФН незаметно крадёт одну единицу молока из \(B\) \((0 \le B < A)\) различных непустых бутылок. Чтобы оставаться незамеченным, ФН выбирает \(B\) так, чтобы оно было строго меньше чем \(A\).

После \(D\) (\(1 \leq D \leq 10^9\)) дней ФД продаёт своё молоко. Если в бутылке \(M\) единиц молока, он продаёт эту бутылку за \(M^2\) денежных единиц.

Пусть \(P\) - уникальная прибыль, такая, что FJ может гарантировать, что он получит не менее \(P\) прибыли независимо от того, как ведет себя FN, а FN может гарантировать, что FJ получит не более \(P\) прибыли независимо от того, как ведет себя FJ. Выведите значение \(P\) по модулю \(10^9+7\).

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

Первая строка содержит \(N\) и \(D\), где \(N\) это количество бутылок, а \(D\) - количество дней.

Вторая строка содержит \(A\) и \(B\) количество единиц молока, которое ФД добавляет, а ФН вычитает соответственно.

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

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

Выведите значение \(P\) по модулю \(10^9+7\).

Вам дана длинная строка \(S\) из символов M и O и целое число \(K \geq 1\). Посчитайте количество способов разбить \(S\) на подпоследовательности так, что каждая подпоследовательность MOOOO....O с ровно \(K\) O, по модулю \(10^9+7\).

Поскольку строка очень длинная, Вам она не дана точно. Вместо этого Вам дано целое число \(L\) (\(1 \leq L \leq 10^{18}\)), и строка \(T\) длины \(N\) (\(1 \leq N \leq 10^6\)). Строка \(S\) есть конкатенация \(L\) копий строки \(T\).

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

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

Вторая строка содержит строку \(T\) длины \(N\). Каждый символ или M или O.

Гарантируется, что количество декомпозиций \(S\) не равно 0.

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

Выведите количество разбиений строки \(S\), по модулю modulo \(10^9+7\).

Фермер Джон выстроил коров в ряд и хочет их сфотографировать.

Каждая из \(N\) коров \((1 \le N \le 10^5)\) имеет целую высоту от \(1\) до \(N\). ФД хочет сфотографировать их в определённом порядке. Если коровы с высотами \(h_1, \dots, h_K\) стоят в ряд слева направо, он хочет, чтобы для их высот выполнялись следующие три свойства:

  • Чтобы высоты коров сначала возрастали, а потом убывали. Формально, должно существовать такое целое число \(i\), что \(h_1 \le \dots \le h_i \ge \dots \ge h_K\).
  • Чтобы рядом стояли коровы с одинаковой высотой. Формально, \(h_i \neq h_{i+1}\) для \(1 \le i < K\).
  • Чтобы фотография была симметричной. Формально, если \(i + j = K+1\), then \(h_i = h_j\).

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

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

Имеется множество подтестов.

Первая строка ввода содержит одно целое число \(T\) (\(1 \leq T \leq 10^5\)), обозначающее количество подтестов. Далее следуют \(T\) подтестов.

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

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

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

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

Беси анализирует строку из \(N\) (\(3 \leq N \leq 10^5\)) маленьких латинских букв \(s_1s_2 \ldots s_N\). Эльза рассматривает строку \(t\), содержащую три символа как MOO если \(t_2 = t_3\) и \(t_2 \neq t_1\).

Триплет \((i, j, k)\) валидный, если \(i < j < k\) и строка \(s_i s_j s_k\) формирует MOO. Для этого триплета ФД выполняет следующее, чтобы вычислить его величину

  • ФД сгибает строку \(s\) на 90-градусов в индексе \(j\)
  • Величина триплета - удвоенная площадь \(\Delta ijk\).

Другими словами, величина триплета есть \((j-i)(k-j)\).

Беси задаёт Вам \(Q\) (\(1 \leq Q \leq 3 \cdot 10^4\)) вопросов. В каждом вопросе она даёт Вам два целых числа \(l\) и \(r\) (\(1 \leq l \leq r \leq N\), \(r-l+1 \ge 3\)) и просит Вас определить максимальную величину среди всех валидных триплетов \((i, j, k)\) таких, что \(l \leq i\) и \(k \leq r\). Если валидных триплетов нет, выведите \(-1\).

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

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

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

Следующая строка содержит символы \(s_1 s_2, \ldots s_N\).

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

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

Выведите ответ на каждый вопрос в отдельной строке.

У Фермера Джона есть массив \(a\) из \(N\) (\(1 \leq N \leq 2 \cdot 10^5\)) неотрицательных целых чисел и целое число \(M\) (\(1 \leq M \leq 10^9\)). Затем ФД спрашивает у Беси число \(x\). За одну операцию ФД может выбрать индекс \(i\) и вычесть или прибавить \(1\) к \(a_i\). ФД называет число скучным - если оно равно минимальному количеству операций, которые он должен выполнить, чтобы \(a_i-x\) стало делится на \(M\) для всех \(1 \leq i \leq N\).

Среди всех возможных \(x\) выберите минимально возможное скучное число.

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

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

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

Вторая строка каждого подтеста содержит \(a_1, a_2, ..., a_N\) (\(0 \leq a_i \leq 10^9\)).

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

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

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

Сад Беси имеет \(N\) растений, помеченных от \(1\) до \(N\) (\(2\leq N\leq 5\cdot 10^5\)) слева направо. Беси знает, что растение \(i\) требует не менее \(w_i\) (\(0\leq w_i \leq 10^6\)) единиц воды.

У Беси своеобразная ирригационная система с \(N-1\) каналами, пронумерованными от \(1\) до \(N-1\). Каждый канал \(i\) имеет ассоциированную с ним стоимость \(c_i\) (\(1\le c_i\le 10^6\)), такую что Беси может заплатить \(c_i*k\) чтобы обеспечить растение \(i\) и \(i+1\) каждое \(k\) единицами воды где \(k\) неотрицательное целое число.

Беси сильно занята и может не иметь времени использовать все каналы. Для каждого \(2\leq i \leq N\) вычислите минимальную стоимость требуемую, чтобы доставить воду растениям от \(1\) до \(i\) используя только первые \(i-1\) каналов.

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

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

Вторая строка содержит \(N\) разделённых одиночными пробелами целых чисел \(w_1, \ldots, w_N\).

Тртья строка содержит \(N-1\) разделённых одиночными пробелами целых чисел \(c_1, \ldots, c_{N-1}\).

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

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

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

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

Ночью происходит что-то странное со звёздами на небе. Каждая звезда или исчезает или перемещается на \(A\) пикселов вправо и на \(B\) пикселов вниз (\(0 \leq A,B \leq N\)). Если звезда исчезает или перемещается за границу фото, она больше не появляется на втором фото.

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

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

Первая строка ввода содержит \(T\), далее следуют \(T\) подтестов.

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

Далее следуют \(N\) строк, каждая из которых представляет одну строку наложенных фотографий. \(i\)-ая строка представлена строкой \(c_{i,1}c_{i,2}\dots c_{i,N}\), где каждый \(c_{i,j} \in \{W,G,B\}\), представляющих белый, серый и чёрный цвет соответственно.

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

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

Для каждого подтеста выведите минимальное количество звёзд, которые существовали до сдвига или \(-1\) если это невозможно определить.

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

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

Ночью происходит что-то странное со звёздами на небе. Каждая звезда или исчезает или перемещается на \(A\) пикселов вправо и на \(B\) пикселов вниз (\(0 \leq A,B \leq N\)). Если звезда исчезает или перемещается за границу фото, она больше не появляется на втором фото.

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

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

Первая строка ввода содержит \(T\), далее следуют \(T\) подтестов.

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

Далее следуют \(N\) строк, каждая из которых представляет одну строку наложенных фотографий. \(i\)-ая строка представлена строкой \(c_{i,1}c_{i,2}\dots c_{i,N}\), где каждый \(c_{i,j} \in \{W,G,B\}\), представляющих белый, серый и чёрный цвет соответственно.

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

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

Для каждого подтеста выведите минимальное количество звёзд, которые существовали до сдвига или \(-1\) если это невозможно определить.

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

Пока банк не пустой, Беси выбирает слово из банка, удаляет его из банка, читает его Эльзе по одному символу за раз слева направо. Задача Эльзы сказать Беси, как только она уникально определит слово, после чего Беси прекращает чтение.

Беси уже решила читать слова из словаря в порядке \(w_1,w_2,\dots,w_M\). Если Эльза ответит так быстро, как это возможно, сколько символов из каждого слова прочитает Беси?

Слова заданы в сжатом формате. Сначала мы определяем \(N+1\) (\(1\le N\le 10^6\)) различных слов и затем банк слов состоит из всех этих слов, ни одно из которых не является префиксом другого. Слова определяются следующим образом:

  • Изначально, 0-ое слово - пустая строка.
  • Затем для каждого each \(1\le i\le N\), \(i\)-ое слово будет равно \(p_i\)-ому слову плюс дополнительный символ в конце (\(0\le p_i<i\)). Символы выбираются так, что все \(N+1\) слов различны.

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

Первая строка содержит \(N\), где \(N+1\) количество слов, представленных в сжатом формате.

Следующая строка содержит числа \(p_1,p_2,\dots,p_N\) где \(p_i\) представляет, что \(i\)-ое слово формируется взятием \(p_i\)-го слова и добавлением одного символа в конец.

\(M\) - количество слов, которые не являются префиксом некоторого другого слова. Следующие \(M\) строк содержат \(w_1,w_2,\dots,w_M\), означающие что \(w_i\)-ое слово будет \(i\)-ым прочитанным. Гарантируется, что слова к чтению формируют перестановку слов из банка.

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

Выведите \(M\) строк, где \(i\)-ая строка содержит количество символов \(i\)-го слова, которое прочиает Беси.

п»ї

Беси стоит пере двумя стогами сена. Первый содержит \(a\) снопов, второй - \(b\) снопов \(1\le a,b\le 10^{18}\)).

Она должна превратить их в стоги с \(c\) и \(d\) снопами - ни больше, ни меньше.

Беси может выполнять только такие два заклинания:

  • Увеличить размер первого стога РЅР° количество СЃРЅРѕРїРѕРІ РІРѕ втором стоге.
  • Увеличить размер второго стога РЅР° количество СЃРЅРѕРїРѕРІ РІ первом стоге.
Она должна выполнять операции последовательно, но она может выполнять их любое количество раз и в любом порядке. Она должна получить ровно \(c\) снопов в первом стоге и \(d\) во втором (\(1\le c,d\le 10^{18}\)).

Для каждого из \(T\) (\(1\le T\le 10^4\)) независимых подтестов, выведите минимальное количество операций, чтобы добиться нужного результата, или если это невозможно, выведите -1.

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

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

Каждая из следующих \(T\) строк содержит четыре целых числа \(a,b,c,d\).

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

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

ПР�МЕР ВВОДА:

4
5 3 5 2
5 3 8 19
5 3 19 8
5 3 5 3

ПР�МЕР ВЫВОДА:

-1
3
-1
0

В первом подтесте невозможно, посокльку изначально \(b>d\), разрешённые операции могут только увеличивать \(b\).

Во втором подтесте изначально стоги имеют \((5, 3)\) снопов. Беси может увеличить первый стог на количество снопов во втором получит \((8, 3)\). Затем увеличит количество второй стог на новое количество снопов в первом, получит \((8, 11)\) Затем сделает эту операцию ещё раз и получит \((8, 19)\) � это минимальное количество операций, чтобы получить данный результат.

Заметим, что в третьем подтесте ответ не такой как во втором, потому, что \(c\) и \(d\) поменяны местами (порядок куч имеет значение).

В четвертом подтесте не требуется выполнять операции.

ПР�МЕР ВВОДА:

1
1 1 1 1000000000000000000

ПР�МЕР ВЫВОДА:

999999999999999999

ОЦЕН�ВАН�Е:

  • Тесты 3-4: \(\max(c, d) \le 20 \cdot\min(a, b)\)
  • Тесты 5-7: \(T \le 10\) and \(a,b,c,d\le 10^6\)
  • Тесты 8-12: Нет дополнительных ограничений

Автор: Benjamin Qi

Фермер Джон выстроил \(N\) \((1 \leq N \leq 2 \cdot 10^5)\) своих коров в ряд \(a\). \(i\)'-ая корова от начала ряда \(a\) помечена целым числом \(a_i\) (\(1 \leq a_i \leq N\)). Несколько коров могут быть помечены одним и тем же числом.

ФД конструирует ряд \(b\) следующим образом:

  • Изначально массив \(b\) пустой.
  • Пока массив \(a\) не пустой, удалить первый элемент ряда \(a\) и добавить или не добавить этот элемент в конец массива \(b\).

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

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

  • Выбрать корову в ряду \(a\) и переместить её в любую позицию, кроме текущей.

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

Каждый тест состоит из \(T\) (\(1 \leq T \leq 100\)) независимых подтестов.

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

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

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

Вторая строка каждого подтеста содержит \(N\) разделённых одиночными пробелами целых чисел \(a_1, a_2, \ldots, a_N\).

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

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

Для каждого подтеста выведите лексикографически наибольший \(b\).

**Замечание: Время на тест для этой задачи 3сек, в 1.5 большее чем по умолчанию. Память на тест для этой задачи 512MB, в два раза больше чем по умолчанию.**

Беси проходит тест вида да/нет из \(N\) вопросов (\(1\le N\le 2\cdot 10^5\)). За \(i\)-ый вопрос она может добавить \(a_i\) баллов если ответит правильно, и отнять \(b_i\) баллов, если ответит неправильно или не изменить сумму, если не ответит вообще на вопрос (\(0<a_i,b_i\le 10^9\)).

Беси знает ответы на все вопросы, но боится, что администратор теста Эльза подменит до \(k\) вопросов так, чтоб получилось, что Беси ответила неправильно.

Заданы \(Q\) (\(1\le Q\le N+1\)) кандидатов величин \(k\) (\(0\le k\le N\)), определите количество баллов, которые Беси гарантированы для каждого \(k\), зная, что она должна ответить не менее чем на \(k\) вопросов.

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

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

Каждая из следующих \(N\) строк содержит \(a_i\) и \(b_i\).

Каждая из следующих \(Q\) строк содержит значение \(k\). Ни одно из значений \(k\) не появится более одного раза.

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

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

Ответьте на \(Q\) (\(1\le Q\le 10^5\)) независимых запроса следующего вида:

Вам даны четыре целых числа \(a,b,c,d\) (\(-10^{18}\le a,b,c,d\le 10^{18}\)). За одну операцию Вы можете сделать либо \(a\mathrel{+}=b\), или \(b\mathrel{+}=a\) Определите минимальное количество операций чтобы трансформировать \((a,b)\) в \((c,d)\), если это невозможно сделать, выведите \(-1\).

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

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

Каждая из следующих \(Q\) строк содержит четыре целых числа \(a,b,c,d\).

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

Ответ для каждого запроса на отдельной строке

п»ї

У Фермера Джона есть двоичная строка длиной \(N\) \((1 \leq N \leq 10^9)\), изначально из одних нулей.

Сначала он выполнит \(M\) (\(1 \leq M \leq 2 \cdot 10^5\)) изменений строки по порядку. Каждое изменение переворачивает каждый символ от \(l\) до \(r\). То есть \(0\) изменяется на \(1\) и наоборот.

Затем он задаёт Вам \(Q\) (\(1 \leq Q \leq 2 \cdot 10^5\)) вопросов. Для каждого вопроса Вы должны ввести лексикографически наибольшую подпоследовательность длины \(k\) состоящую из символов подстроки от \(l\) до \(r\). Если Ваш ответ - двоичная строка \(s_1s_2 \dots s_k\), выведите \(\sum_{i=0}^{k-1} 2^i \cdot s_{k-i}\) (то есть строка интерпретируется как двоичное число) по модулю \(10^9+7\).

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

Напомним, что строка \(A\) лексикографически больше чем строка \(B\) такой же длины если и только если в первой позиции \(i\), если она существует, \(A_i \neq B_i\), выполняется \(A_i > B_i\).

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

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

Следующие \(M\) строк содержат по два целых числа \(l\) и \(r\) (\(1 \leq l \leq r \leq N\)) конечные точки обновления.

Следующие \(Q\) строк содержат по три целых числа, \(l\), \(r\), \(k\) (\(1 \leq l \leq r \leq N, 1 \leq k \leq r - l + 1\)) —

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

Выведите \(Q\) строк. \(i\)-ая строка должна содержать ответ на \(i\)-ый запрос.

ПР�МЕР ВВОДА:

5 3 9
1 5
2 4
3 3
1 5 5
1 5 4
1 5 3
1 5 2
1 5 1
2 5 4
2 5 3
2 5 2
2 5 1

ПР�МЕР ВЫВОДА:

21
13
7
3
1
5
5
3
1

После выполнения \(M\) операций, строка такова: \(10101\).

Для первого запроса - длины \(5\) ответ вся строка \(10101\), которая интерпретируется как \(1 \cdot 2^4 + 0 \cdot 2^3 + 1 \cdot 2^2 + 0 \cdot 2^1 + 1 \cdot 2^0 = 21\).

Для второго запроса, существует \(5\) уникальных подпоследовательностей длины \(4\): \(0101\), \(1101\), \(1001\), \(1011\), \(1010\). Лексикографически наибольшая из них \(1101\), которая интерпретируется как \(1 \cdot 2^3 + 1 \cdot 2^2 + 0 \cdot 2^1 + 1\cdot 2^0 = 13\).

Для третьей строки лексикографически наибольшая последовательность \(111\), которая интерпретируется как \(7\).

ПР�МЕР ВВОДА:

9 1 1
7 9
1 8 8

ПР�МЕР ВЫВОДА:

3

ПР�МЕР ВВОДА:

30 1 1
1 30
1 30 30

ПР�МЕР ВЫВОДА:

73741816

Не забудьте выводить ответ по модулю \(10^9+7\).

ОЦЕН�ВАН�Е:

  • Тест 4: \(N \leq 10, Q \leq 1000\)
  • Тест 5: \(M \leq 10\)
  • Тесты 6-7: \(N, Q \leq 1000\)
  • Тесты 8-12: \(N \leq 2 \cdot 10^5\)
  • Тесты 13-20: Нет дополнительных ограничений.

Автор: Chongtian Ma

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