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


Олимпиадный тренинг

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

C. Игра с перестановкой

дп игры Перебор *1600

После долгого дня Алиса и Боб решили сыграть в игру. Игровая доска состоит из \(n\) ячеек на прямой, пронумерованных от \(1\) до \(n\), где каждая ячейка содержит число \(a_i\) в диапазоне от \(1\) до \(n\). Кроме того, никакие две ячейки не содержат одинаковые числа.

Игровая фигурка находится на одной ячейке. Они ходят по очереди, двигая фигурку. Алиса ходит первая. Игрок, который ходит, может передвинуть фигурку с ячейки \(i\) на ячейку \(j\), только если выполняются условия:

  • число в новой ячейке \(j\) строго больше, чем в старой ячейке \(i\) (то есть \(a_j > a_i\)), и
  • расстояние, на которое передвигается фигурка в этом ходу, должно делиться на число, расположенное в старой ячейке (то есть \(|i-j|\bmod a_i = 0\)).

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

Входные данные

Первая строка содержит одно целое число \(n\) (\(1 \le n \le 10^5\)) — количество чисел.

Вторая строка содержит \(n\) целых чисел \(a_1, a_2, \ldots, a_n\) (\(1 \le a_i \le n\)). Гарантируется, что нет таких чисел \(i \neq j\), что \(a_i = a_j\).

Выходные данные

Выведите \(s\) — строку из \(n\) символов, где \(i\)-й символ представляет результат игры, которая начинается в ячейке \(i\). Если победит Алиса, то \(s_i\) должен быть равен «A»; в другом случае, \(s_i\) должен быть равен «B».

Примечание

В первом примере, если Боб поместит игровую фигурку на число (не на позицию):

  • \(1\): Алиса может переместиться на любую ячейку. Она может выбрать число \(7\), из которого у Боба нет выхода.
  • \(2\): Алиса может переместиться на числа \(3\) и \(5\). При переходе в \(5\), Боб может выиграть, если переместится в \(8\). Если она выберет \(3\), то она победит, так как Боб сможет переместиться только в \(4\), из которого Алиса сможет переместиться в \(8\).
  • \(3\): Алиса может переместиться только в \(4\), после чего Боб побеждает, перемещаясь в \(8\).
  • \(4\), \(5\) или \(6\): Алиса побеждает, перемещаясь в \(8\).
  • \(7\), \(8\): Алиса не может никуда переместиться, поэтому проигрывает.

G. Игра с фишками

игры *3500

Алиса и Боб решили сыграть в одну игру. У них есть \(n\) кучек, \(i\)-я кучка изначально содержит \(v_i\) фишек. Алиса изначально выбирает положительное целое число \(a\) из интервала \([1, m]\), а Боб выбирает число \(b\) таким же образом.

Затем начинается игра. В свою очередь, Алиса может выбрать любую кучку, содержащую как минимум \(a\) фишек, и удалить из нее ровно \(a\) фишек. Точно так же, в свою очередь, Боб может выбрать любую кучку с не менее \(b\) фишками и удалить из нее ровно \(b\) фишек. Если игрок не может сделать ход, он или она проигрывает.

Если оба игрока играют оптимально, результат в конечном счете зависит от выбора \(a\) и \(b\), а также от того, кто начинает. Рассмотрим пару \((a,b)\). Всего есть четыре вида игр:

  • Алиса побеждает вне зависимости от того, кто начинает.
  • Боб побеждает вне зависимости от того, кто начинает.
  • Если Алиса начинает, она побеждает. Если Боб начинает, он побеждает. То есть первый игрок побеждает.
  • Если Алиса начинает, Боб побеждает. Если Боб начинает, Алиса побеждает. То есть второй игрок побеждает.

Для всех возможных \(a\) и \(b\) (то есть для каждой пары \((a, b)\), такой что (\(1\leq a, b\leq m\))) нужно определить, сколько игр будут выиграны Алисой (вне зависимости от того, кто начинает), сколько Бобом (вне зависимости от того, кто начинает), сколько игроком, который начинает игру, и сколько вторым игроком.

Входные данные

Первая строка содержит два целых числа \(n\) и \(m\) (\(1 \leq n \leq 100, 1 \leq m \leq 10^5\)) — количество кучек и верхняя граница на количество фишек, которые могут забирать игроки за раз.

Вторая строка содержит \(n\) целых чисел \(v_1, v_2, \dots, v_n\) (\(1 \leq v_i \leq 10^{18}\)) — начальное количество фишек в каждой кучке.

Выходные данные

В первой строке выведите четыре числа \(w_a\), \(w_b\), \(w_f\), \(w_s\) — количество игр, выигранных Алисой, Бобом, первым игроком и вторым игроком соответственно.

Примечание

В первом примере есть всего четыре способа выбрать пару \((a,b)\).

  • \(a = b = 1\): Не имеет значения с каких кучек забираются фишки — можно сделать всего \(9\) ходов. Первый игрок победит, так как он сделает последний ход.
  • \(a = b = 2\): Второй игрок может выиграть, если всегда будет выбирать ту же кучку, которую первый игрок выбирает, до того момента, когда будет \(0\) и \(1\) фишек в кучках. Так как невозможно выбрать кучку из \(2\) фишками, то первый игрок проигрывает.
  • \(a = 1\) и \(b = 2\):
    • Пусть начинает Алиса. Она может выиграть, забирая одну фишку с кучки с \(5\) фишками, а потом, копируя действия Боба. После следующих четырех ходов игра закончится, так как будет по \(1\) фишке в каждой кучке, и Боб не сможет сделать ход.
    • Пусть начинает Боб. Если он заберет две фишки из второй кучки, то Алиса сможет забрать одну фишку из первой кучки. А потом она всегда может копировать действия Боба. Если же Боб заберет две фишки из первой кучки в свой первый ход, то Алиса может тоже забрать одну от туда. Так как в первой кучке осталась только одна фишка, то Боб вынужден забрать две фишки из второй кучки, оставляя \(3\). Вне зависимости от того, что делает Алиса, она победит.
    Значит, Алиса победит вне зависимости от того, кто начинает.
  • \(a = 2\) и \(b = 1\): Симметрично до предыдущего пункта — поэтому победит Боб.

Во втором примере очень много игр, например при \(a = 7\) и \(b = 6\) игра сразу же закончится, так как никто не может сделать ход — значит, что победил второй игрок. Игры, который закончатся победой для первого игрока: \((1, 1)\), \((1, 4)\), \((2, 3)\), \((3, 2)\), \((4, 1)\) и \((5, 5)\).

G. Игра над строками

игры *3200

Алиса и Боб играют в игру со строками.

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

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

Алиса и Боб привыкли играть со строкой \(s\), но недавно им стало это надоедать. Теперь перед каждой игрой они выбирают два целых числа \(l\) и \(r\) такие, что \(1 \le l \le r \le |s|\) и играют вместо этого на строке \(s_{l} s_{l+1} s_{l+2} \ldots s_{r}\).

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

Входные данные

Первая строка содержит строку \(s\) (\(1 \le |s| \le 10^5\)), состоящую из строчных латинских букв. Это строка, с которой Алиса и Боб привыкли играть.

Вторая строка содержит одно целое число \(m\) (\(1 \le m \le 10^5\)) — количество игр.

Каждая из следующих \(m\) строк содержит два целых числа \(l\) и \(r\) (\(1 \le l \le r \le |s|\)) — границы стартовой строки в строке \(s\).

Выходные данные

Для каждой игры выведите имя игрока, который её выигрывает — «Alice» или «Bob» соответственно.

Примечание

В первом примере:

  1. В первой игре для игры выбрана строка «aa». Алиса удаляет символ «a», после этого Боб не может сделать ход.
  2. Во второй игре для игры выбрана строка «aaab». Какой бы символ не удалила Алиса, Боб удалит оставшийся и Алиса не сможет сделать ход.

Во втором примере Алиса выигрывает и игру со строками «bdb» и «aaccbdb».

Чтобы выиграть в «bdb», Алиса может удалить символ «d», тогда игра продолжится независимо на строках «b» и «b». Боб удаляет одну из этих строк, Алиса удаляет оставшуюся и Боб не может сделать ход.

Чтобы выиграть игру «aaccbdb», Алиса может удалить символ «d», после чего игра будет идти независимо на «aaccb» и «b». Можно показать, что вне зависимости от ходов игроков, эта игра может закончится только за ровно \(4\) хода, а значит, после этого Боб не сможет сделать ход.

G. Игра на массиве

игры Структуры данных *3000

Рассмотрим следующую игру для двух игроков:

Дан массив \(b_1\), \(b_2\), ..., \(b_k\), состоящий из положительных целых чисел. В начале в первую ячейку массива помещается фишка, и \(b_1\) уменьшается на \(1\). Игроки по очереди делают ходы. В каждый ход текущий игрок делает следующее: если номер ячейки с фишкой равен \(x\), то он или она выбирает некоторую позицию \(y \in [x, min(k, x + m)]\) такую, что \(b_y > 0\), двигает фишку в \(y\) и уменьшает \(b_y\) на \(1\). Если невозможно сделать корректный ход, то текущий игрок проигрывает.

Ваша задача в следующем: дан массив \(a\), состоящий из \(n\) положительных целых чисел, и \(q\) запросов к нему. Существуют два типа запросов:

  • \(1\) \(l\) \(r\) \(d\) — для каждого \(i \in [l, r]\) увеличить \(a_i\) на \(d\);
  • \(2\) \(l\) \(r\) — сказать, кто победит в игре на подмассиве \(a\) с позиции \(l\) до позиции \(r\) включительно. Считается, что оба игрока играют оптимально.
Входные данные

В первой строке записаны три целых числа \(n\), \(m\) and \(q\) (\(1 \le n, q \le 2 \cdot 10^5\), \(1 \le m \le 5\)) — количество элементов в \(a\), параметр, описанный в игре, и количество запросов, соответственно.

Во второй строке записаны \(n\) целых чисел \(a_1\), \(a_2\), ..., \(a_n\) (\(1 \le a_i \le 10^{12}\)) — элементы массива \(a\).

Затем следуют \(q\) строк, в каждой содержится один запрос. Есть два типа запросов. Запрос первого типа описывается строкой \(1\) \(l\) \(r\) \(d\) (\(1 \le l \le r \le n\), \(1 \le d \le 10^{12}\)) и обозначает, что для каждого \(i \in [l, r]\) необходимо увеличить \(a_i\) на \(d\). Запрос второго типа описывается строкой \(2\) \(l\) \(r\) (\(1 \le l \le r \le n\)) и обозначает, что требуется определить, кто выиграет в игре, если она будет сыграна на подмассиве \(a\) с позиции \(l\) до позиции \(r\) (включительно).

Гарантируется, что существует хотя бы один запрос типа \(2\).

Выходные данные

Для каждого запроса типа \(2\) выведите \(1\), если первый игрок выигрывает в соответствующей игре, или \(2\), если выигрывает второй игрок.

H. Новый год и триколор

игры *3200

Алиса и Боб играют в игру на поле с \(n\) строками и бесконечным количеством столбцов. В каждой строке есть три фишки: синяя, белая и красная. Перед началом игры и после каждого хода должны выполнятся следующие два условия:

  • Любые две фишки находятся в разных ячейках.
  • В каждой строке синяя фишка находится слева от белой, а красная фишка справа от белой.

Сначала Алиса и Боб выбирают целое положительное число \(f\), значение которого не меняется на протяжении игры. Потом начинающий игрок делает его/её первый ход, после которого игроки ходят по очереди. Игрок, который не может сделать ход, проигрывает.

Когда игрок делает ход, он выбирает целое число \(k\), которое либо простое число, либо произведение двух (не обязательно различных) простых чисел. Наименьшие возможные значения \(k\): \(2, 3, 4, 5, 6, 7, 9, 10, 11, 13, 14, 15, 17, 19, \dots\). Более того, \(k\) не должно быть равно тому \(f\), которое было выбрано в начале игры. Каждый ход происходит только в одной строке.

Если это ход Алисы, то она выбирает синюю фишку и передвигает её на \(k\) ячеек вправо. Или же она может передвинуть и синюю, и белую фишки в одной и той же строке на \(k\) ячеек вправо.

Боб, в свою очередь, выбирает красную фишку и передвигает её на \(k\) ячеек влево. Альтернативно, он может передвинуть и белую, и красную фишки в одной и той же строке на \(k\) ячеек влево.

Обратите внимание, что Алиса никогда не передвигает красную фишку, а Боб синюю. Помните, что после каждого хода те два условия должны выполняться.

Оба игрока играют оптимально. Учитывая начальное состояние игрового поля, определите, кто победит в двух играх: если Алиса начинает игру, и если начинает Боб.

Входные данные

Первая строка содержит два целых числа \(n\) и \(f\) (\(1 \leq n \leq 10^5\), \(2 \leq f \leq 2 \cdot 10^5\)) — количество строк и на сколько ячеек нельзя передвигать фишки соответственно.

Каждая из следующих \(n\) строк содержит три целых числа \(b_i\), \(w_i\), \(r_i\) (\(-10^5 \leq b_i < w_i < r_i \leq 10^5\)) — номера столбцов в \(i\)-й строке, в которых находятся синяя, белая и красная фишки соответственно.

Выходные данные

Выведите две строки.

Первая строка должна содержать имя победителя игры, которую Алиса начинает, а вторая строка — имя победителя игры, которую начинает Боб.

Если побеждает Алиса, то нужно вывести «Alice», а если Боб, то «Bob».

Примечание

Первый пример:

Когда Алиса начинает, она может выиграть, передвигая синюю и белую фишки вправо на \(2\) ячейки, заняв позиции \(2~5~9\). Вне зависимо от того, что сделает Боб, у Алисы будет еще один ход, и тогда она сможет выиграть. Например, он может переместить как красную, так и белую фишки на \(2\) ячейки влево, получив позиции \(2~3~7\). Затем Алиса может переместить синюю и белую фишки на \(2\) вправо, чтобы получить \(4~5~7\), тогда Боб не сможет больше сделать ход.

Если Боб начинает, он получает достаточно преимуществ, чтобы выиграть. Например, он может переместить красную фишку на \(3\) влево, перейдя в положение \(0~3~6\). Алиса может, например, переместить синюю фишку на \(2\), после чего Боб передвигает красную фишку на \(2\). Игра заканчивается на позициях \(2~3~4\).

Во втором примере запрещено двигать фишки на \(2\) ячейки, но это не останавливает Алису, чтобы победить! Она может передвинуть синюю и белую фишки на \(4\), получая позиции \(4~7~9\). Теперь у Боба нет ходов, так как ход на \(2\) ячейки запрещен.

F. Печеньки

Бинарный поиск Деревья дп игры поиск в глубину и подобное Структуры данных *2400

Митя и Вася играют в интересную игру. У них есть подвешенное дерево из \(n\) вершин, пронумерованных числами от \(1\) до \(n\). В этом дереве вершина \(1\) является корнем, а родителем вершины \(i \ge 2\) является вершина \(p_i\) (при этом будем говорить, что вершина \(i\) — ребенок вершины \(p_i\)).

В каждой вершине дерева находятся печеньки, в вершине \(i\) находится \(x_i\) печенек. Чтобы съесть одну печеньку в вершине \(i\), нужно потратить \(t_i\) единиц времени. Также в игре есть одна фишка. Изначально она находится в корне дерева. Чтобы переместить фишку по ребру, соединяющему вершину \(i\) с ее родителем, нужно потратить \(l_i\) единиц времени.

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

На любом своем ходу Митя может закончить игру. После этого он двигает фишку вверх до корня, по пути съедая какие-то печеньки. Митя может потратить суммарно на спуск, подъем и поедание печенек не более \(T\) единиц времени. Обратите внимание, что в конце игры фишка всегда оказывается в корне: Митя не может оставить фишку ни в какой промежуточной вершине, даже если требуемое число печенек уже было съедено — он обязан переместить фишку в корень (и на каждое перемещение фишки по ребру из вершины \(v\) в ее предка он тратит \(l_v\) единиц времени).

Какое максимальное количество печенек Митя может съесть, независимо от действий Васи?

Входные данные

В первой строке находятся два числа \(n\), \(T\) — количество вершин в дереве и время, которое у него есть на это (\(2\le n \le 10^5\); \(1\le T\le10^{18}\)).

Во второй строке находятся \(n\) чисел \(x_1\), \(x_2\), ..., \(x_n\) — число печенек в каждой вершине (\(1\le x_i\le10^6\)). В третьей строке находятся \(n\) чисел \(t_1\), \(t_2\), ..., \(t_n\) — время, которое требуется, чтобы съесть одну печеньку в \(i\)-й вершине (\(1\le t_i\le10^6\)).

Далее следует \(n - 1\) строка, которые описывают дерево. Для каждого \(i\) от \(2\) до \(n\) в отдельной строке записаны два числа \(p_i\) и \(l_i\), где \(p_i\) — родитель вершины \(i\), а \(l_i\) — время, которое требуется Мите для перемещения фишки вдоль ребра из вершины \(i\) в ее родителя (\(1\le p_i < i\), \(0\le l_i \le 10^9\)).

Выходные данные

Выведите одно целое число — максимальное число печенек, которое может съесть Митя.

Примечание

В первом примере Митя может первым ходом переместить фишку в вершину \(2\). В этом случае, как бы после этого не играл Вася, Митя сможет съесть не менее \(11\) печенек. Ниже приведен пример того, как могла происходить игра:

  1. Митя перемещает фишку в вершину \(2\).
  2. Вася отрезает ребро, ведущее в вершину \(4\).
  3. Митя перемещает фишку в вершину \(5\).
  4. Так как у вершины \(5\) нет детей, Вася не отрезает ничего.
  5. Митя заканчивает игру и поднимается наверх, по пути собирая печеньки (\(7\) в вершине \(5\), \(3\) в вершине \(2\), \(1\) в вершине \(1\)).

Митя тратит \(1+0\) времени на движение вниз, \(0+1\) на движение вверх, \(7\cdot 2\) чтобы съесть \(7\) печенек в вершине 5, \(3\cdot 3\) чтобы съесть \(3\) печеньки в вершине 2, \(1\cdot 1\) чтобы съесть \(1\) печеньку в вершине 1. Суммарное время равно \(1+0+0+1+7\cdot 2+3\cdot 3+1\cdot 1=26\).

D. Даша и шахматы

игры интерактив Конструктив *2500

Это интерактивная задача.

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

На шахматной доске размером \(999 \times 999\) расположено \(666\) чёрных ладей и \(1\) белый король. Задача белого короля — попасть под шах ладьи, т. е. встать на такое поле, что на одной горизонтали или вертикали с ним будет находиться чёрная ладья.

Ходы совершаются по очереди, начинают белые. NN играет за белого короля, на каждом ходу он перемещает короля в одну из соседних по стороне или диагонали клеток, т. е. если король стоит на поле \((x, y)\), то он может переместиться на поле \((nx, ny)\) такое, что \(\max (|nx - x|, |ny - y|) = 1\) , \(1 \leq nx, ny \leq 999\). При этом NN не имеет права брать фигуры Даши, т. е. перемещаться на поле, на котором в данный момент находится чёрная ладья. Однако он может вставать на одну горизонталь или вертикаль с черными ладьями.

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

Каждый игрок делает \(2000\) ходов, если за это время белый король не попадет под шах ладьи, то победителем объявляются чёрные.

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

Входные данные

В начале работы на вход вашей программе подаётся \(667\) строк. В каждой строке находятся пара целых чисел \(x\) и \(y\) (\(1 \leq x, y \leq 999\)) — координаты фигур. В первой строке подаются координаты короля, в следующих \(666\) строках находятся координаты ладей. Первая координата обозначает номер строки на доске, вторая — номер столбца, в которых находится фигура. Гарантируется, что изначально король не находится под ударом ладьи. Кроме того, все фигуры стоят на различных клетках.

Выходные данные

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

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

Чтобы сделать ход королем, выведите два целых числа \(x\) и \(y\) (\(1 \leq x, y \leq 999\)) — поле, на которое будет перемещен король. Король не имеет права вставать на поле, на котором в данный момент находится черная ладья (т. е. король не может брать ладьи). Гарантируется, что у короля в каждый момент будет возможность совершить корректный ход.

После каждого вашего хода считайте ход ладьи в следующем формате: в одной строке находятся три целых числа \(k\), \(x\) и \(y\) (\(1 \leq k \leq 666\), \(1 \leq x_i, y_i \leq 999\)) — номер ладьи, совершающей ход и поле, на которое ладья перемещается. Гарантируется, что ладья не будет перемещаться на поле, в котором в данный момент стоит другая ладья или король, но при этом ладья может совершить ход на поле, в котором она находилась до хода (т. е. остаться на том же поле). Гарантируется, что после хода ладьи король не будет под шахом. В случае, если ваш король попал под шах ладьи, все три числа будут равны \(-1\), после чего ваша программа должна немедленно завершиться.

После вывода хода не забудьте вывести перевод строки и сбросить буфер вывода. В противном случае вы получите вердикт Решение «зависло». Для сброса буфера используйте:

  • fflush(stdout) или cout.flush() в C++;
  • System.out.flush() в Java;
  • flush(output) в Pascal;
  • stdout.flush() в Python;
  • смотрите документацию для других языков.

Ответ «0 0 0» вместо корректного ответа означает, что ваша программа сделала некорректный ход или превысила число ходов. Ваша программа должна немедленно завершиться после прочтения ответа «0 0 0», вы получите вердикт Неправильный ответ. В противном случае вы можете получить любой вердикт, так как программа продолжит чтение из закрытого потока.

Взломы в этой задаче запрещены.

Примечание

Пример сокращен. Полное начальное положение ладей в первом тесте можно найти по ссылке https://pastebin.com/qQCTXgKP. Не гарантируются, что они будут передвигаться так, как показано в примере.

C. Выпиливание и запиливание дверей

игры *1200

Вы — милиционер и играете в игру со Славиком. Игра является пошаговой, а каждый шаг состоит из двух фаз. Во время первой фазы вы делаете ход, а во время второй фазы Славик делает ход.

Есть \(n\) дверей, прочность \(i\)-й двери изначально равна \(a_i\).

Во время вашего хода вы можете попробовать выпилить одну из дверей. Если вы выбираете дверь \(i\) и ее текущая прочность равна \(b_i\), то ее прочность становится \(max(0, b_i - x)\) (значение \(x\) задано).

Во время хода Славика он пробует запилить одну из дверей. Если он выбирает дверь \(i\) и ее текущая прочность равна \(b_i\), то ее прочность становится \(b_i + y\) (значение \(y\) задано). Славик не может запиливать двери с текущей прочностью \(0\).

Игра длится \(10^{100}\) шагов. Если какой-то игрок не может сделать свой ход, то он его пропускает.

Ваша задача — максимизировать количество дверей с прочностью \(0\) в конце игры. Можете считать, что Славик хочет минимизировать количество таких дверей. Чему равно это количество, если вы оба играете оптимально?

Входные данные

Первая строка входных данных содержит три целых числа \(n\), \(x\) и \(y\) (\(1 \le n \le 100\), \(1 \le x, y \le 10^5\)) — количество дверей, значение \(x\) и значение \(y\) соответственно.

Вторая строка входных данных содержит \(n\) целых чисел \(a_1, a_2, \dots, a_n\) (\(1 \le a_i \le 10^5\)), где \(a_i\) равно изначальной прочности \(i\)-й двери.

Выходные данные

Выведите одно целое число — количество дверей с прочностью \(0\) в конце игры, если и вы, и Славик играете оптимально.

Примечание

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

G. Крестики-нолики на дереве

Деревья игры Конструктив *3100

Игра в крестики-нолики начинается на дереве из \(n\) вершин. Некоторые вершины уже окрашены в белый цвет, а остальные пока бесцветны.

Есть два игрока — белый и чёрный. Игроки ходят по очереди, белый игрок начинает игру. В свой ход игрок выбирает ещё не покрашенную вершину и красит её в свой цвет.

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

Не могли бы вы выяснить, кто выиграет эту игру или закончится ли она в ничью, если оба игрока играют оптимально?

Входные данные

Первая строка содержит одно целое число \(T\) (\(1 \le T \le 50\,000\)) — количество тестовых случаев. Далее следуют описания \(T\) тестовых случаев.

Первая строка каждого тестового случая содержит одно целое число \(n\) (\(1 \le n \le 5 \cdot 10^5\)) — количество вершин в дереве.

Каждая из следующих \(n - 1\) строк содержит целые числа \(v\) и \(u\) (\(1 \le v, u \le n\)), означающие, что вершины \(u\) и \(v\) соединены очередным ребром.

Последняя строка теста содержит строку длины \(n\), состоящую из букв «W» и «N». Покрашенные в белый цвет вершины отмечены как «W».

Гарантируется, что заданные рёбра образуют дерево, что есть хотя бы одна неокрашенная вершина и что пути, состоящего из трёх белых вершин, нет.

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

Выходные данные

Для каждого тестового случая выведите «White», «Draw» или «Black» в зависимости от того, кто выиграет (соответственно белый, ничья или черный).

Примечание

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

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

C. Ним Таноса

игры *2000

Алиса и Боб играют в игру с \(n\) кучками камней. Гарантируется, что \(n\) — четное. В \(i\)-й кучке \(a_i\) камней.

Алиса и Боб ходят по очереди, Алиса ходит первой.

На каждом ходу игрок должен выбрать ровно \(\frac{n}{2}\) непустых куч и независимо удалить положительное количество камней из каждой из выбранных куч. Игрок может удалить разное количество камней из каждой из них за один ход. Первый игрок, который не может сделать ход, проигрывает (когда меньше, чем \(\frac{n}{2}\) непустых куч).

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

Входные данные

Первая строка содержит одно целое число \(n\) (\(2 \leq n \leq 50\)) — количество кучек. Гарантируется, что \(n\) — четное.

Вторая строка содержит \(n\) целых чисел \(a_1, a_2, \ldots, a_n\) (\(1 \leq a_i \leq 50\)) — количество камней в каждой кучке.

Выходные данные

Выведите «Alice», если победит Алиса, если же победит Боб, то выведите «Bob» (без кавычек).

Примечание

В первом примере каждый игрок может удалить камни только из одной кучи (\(\frac{2}{2}=1\)). Алиса проигрывает, так как Боб может копировать действия Алисы, поэтому у Алисы первой закончатся ходы.

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

F. Зигзагообразная игра

игры интерактив *3500

Вам дан полный двудольный граф с \(2n\) вершинами, с \(n\) вершинами в каждой доле. Вершины от \(1\) до \(n\) находятся в одной доле, а вершины от \(n+1\) до \(2n\) — в другой. Вам также дается \(n \times n\) матрица \(a\), описывающая веса ребер. \(a_{ij}\) обозначает вес ребра между вершинами \(i\) и \(j+n\). Каждое ребро имеет определенный вес.

Алиса и Боб играют в игру на этом графе. Сначала Алиса выбирает для себя способ игры либо «увеличение», либо «уменьшение», а Боб получает то, что не выбрала Алиса. Затем она помещает фишку в любую вершину графа. После чего Боб перемещает фишку по любому ребру, которое выходит из этой вершины. Теперь они по очереди играют в следующую игру, в которой Алиса ходит первой.

Текущий игрок должен переместить фишку из текущей вершины в некоторую соседнюю не посещенную вершину. Пусть \(w\) будет вес последнего пройденного ребра. Вес следующего ребра должен быть строго больше, чем \(w\), если игрок играет за «увеличение», в противном случае он должен быть строго меньше. Первый игрок, который не может сделать ход, проигрывает.

Вам даны \(n\) и веса ребер графа. Вы можете играть за Алису или Боба, и вы будете играть против тестирующей программы. Вы должны выиграть все игры.

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

Во входных данных находятся несколько (не меньше одного) тестовых случаев. В первой строке находится одно целое число \(t\) (\(1 \le t \le 50\)) — количество тестовых случаев. Далее следуют описания тестовых случаев.

Первая строка описания тестового случая содержит одно целое число \(n\) (\(1 \leq n \leq 50\)) — количество вершин в каждой доле.

Каждая из следующих \(n\) строк содержит \(n\) целых чисел \(a_{ij}\) (\(1 \leq a_{ij} \leq n^2\)). \(a_{ij}\) обозначает вес ребра между вершиной \(i\) и вершиной \(j+n\). Гарантируется, что все \(a_{ij}\) различны.

Сначала выведите «A» или «B», этот символ обозначает за какого игрока вы хотите играть («A» за Алису и «B» за Боба).

Если вы играете за Алису, выведите либо «I», либо «D» (обозначает способ игры «увеличение» («I») или «уменьшение» («D»). После этого выведите вершину, в которой вы хотите начать игру.

Если вы играете за Боба, считайте символ «I» или «D» (обозначает способ игры, который выбрала тестирующая программа), после этого считайте вершину, которую тестирующая программа выбрала для начала.

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

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

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

Если вы не можете походить или сдались, выведите \(-1\) и немедленно прекратите вашу программу. В таком случае вы получите вердикт Неправильный ответ.

После вывода запроса не забудьте вывести перевод строки и сбросить буфер вывода. В противном случае вы получите вердикт Решение «зависло». Для сброса буфера используйте:

  • fflush(stdout) или cout.flush() в C++;
  • System.out.flush() в Java;
  • flush(output) в Pascal;
  • stdout.flush() в Python;
  • смотрите документацию для других языков.

Формат для взломов

Чтобы взламывать, используйте следующий формат. Обратите внимание, что вы можете взламывать только одним тестом.

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

Вторая строка должна содержать одно целое число \(n\) (\(1 \leq n \leq 50\)).

Каждая из следующих \(n\) строк должна содержать \(n\) целых чисел \(a_{ij}\) (\(1 \leq a_{ij} \leq n^2\)). \(a_{ij}\) обозначает вес ребра между вершиной \(i\) и вершиной \(j+n\). Все \(a_{ij}\) должны быть различны.

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

Примечание

Первый пример содержит два случая. В первом случае граф выглядит следующим образом.

В примере игрок решает играть за Алису и выбирает «уменьшение» и начинает с вершины \(3\). Проверяющая система отвечает, двигаясь к вершине \(6\). После этого игрок перемещается в вершину \(2\). В этот момент у проверяющей программы больше нет ходов (поскольку вес должен «увеличиться»), поэтому она сдается и выводит \(-1\).

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

E. Предвыборные обещания

графы игры *3200

В Байтландии, две политические партии борются за места в парламенте на предстоящих выборах: Партия Wrong Answer и Партия Time Limit Exceeded. Поскольку они хотят убедить как можно больше граждан отдать за них свои голоса, они продолжают обещать все более низкие налоги.

В байтландии есть \(n\) городов, соединенных \(m\) односторонними дорогами.

Также интересно, что дорожная сеть не имеет циклов — невозможно начать в каком-то городе, пройти по нескольким дорогам и вернуться в этот город.

В прошлом году, жители \(i\)-го города должны были платить \(h_i\) бурлей налога.

Теперь партии будут поочередно проводить избирательные съезды в разных городах.

Если партия проводит съезд в городе \(v\), она должна уменьшить налог в этом городе до любого неотрицательного целого числа бурлей. Однако, в то же время она может произвольно изменить налоги в каждом из городов, которые могут быть достижимы из \(v\), пройдя по одной дороге.

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

Первая партия, которое проводит съезд это Партия Wrong Answer. Ходят легенды, что партия, которая проведет последний съезд, победит на выборах.

Может ли Партия Wrong Answer победить, независимо от ходов Партии Time Limit Exceeded?

Входные данные

В первой строке записано два целых числа \(n\), \(m\) (\(1 \leq n \leq 200\,000\), \(0 \leq m \leq 200\,000\)) — количество городов и дорог в Байтландии.

В следующей строке записано \(n\) целых чисел, разделенных пробелами \(h_1, h_2, \dots, h_n\) (\(0 \leq h_i \leq 10^9\)); \(h_i\) обозначает налог, который требуется платить в \(i\)-м городе.

В каждой из следующих \(m\) строк записано по два целых числа (\(1 \leq u, v \leq n\), \(u \neq v\)), описывающих дорогу, ведущую из города \(u\) в город \(v\). Гарантируется, что в сети дорог нет циклов. Никакие две дороги не соединяют одну и ту же пару городов.

Можно показать, что съезды не могут продолжаться бесконечно для любого корректного теста.

Выходные данные

Если Партия Wrong Answer может выиграть выборы, выведите WIN на первой строке вашего вывода. В этом случае, мы вас дополнительно просим вывести \(n\) неотрицательных целых чисел \(h'_1, h'_2, \dots, h'_n\) (\(0 \leq h'_i \leq 2 \cdot 10^{18}\)), описывающих налоги в каждом городе после первого съезда, которые позволят выиграть. Если существует несколько возможных ответов, вы можете вывести любой. Гарантируется, что если у партии есть выигрышный ход, то существует и выигрышный ход, в котором в каждом городе налог не превосходит \(2 \cdot 10^{18}\) бурлей.

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

Примечание

В первом примере, Партия Wrong Answer должна провести съезд в городе \(1\). Партия уменьшит налоги в этом городе до \(1\) бурля. Так как город \(2\) напрямую соединен с городом \(1\), мы можем как угодно поменять налоги в этом городе. Партия должна поменять налог на \(5\) бурлей. Можно просто доказать, что Time Limit Exceeded не может выиграть выборы после такого действия если Партия Wrong Answer будет играть оптимально.

Во втором примере теста представлена ситуация, которую мы создали после одного хода в предыдущем тесте; Так как сейчас это ход партии Wrong Answer, партия не может выиграть.

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

B. Игра с телефонным номером

жадные алгоритмы игры реализация *1200

Телефонный номер — это последовательность из ровно \(11\) цифр, в которой первая цифра это 8.

Вася и Петя играют в игру. Изначально у них есть строка \(s\) длины \(n\) (\(n\) нечетно), состоящая из десятичных цифр. Игроки ходят по очереди, первым ходит Вася. Во время своего хода игрок должен удалить символ из строки по своему выбору. Например, строка 1121 после хода игрока может превратиться в строки 112, 111 или 121. Игра заканчивается, когда длина строки \(s\) становится равной 11. Если получившаяся строка является телефонным номером, то выиграл Вася, иначе — Петя.

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

Входные данные

Первая строка содержит число \(n\) (\(13 \le n < 10^5\), \(n\) нечетно) — длина строки \(s\).

Вторая строка содержит саму строку \(s\) (\(|s| = n\)), состоящую только из десятичных цифр.

Выходные данные

Если у Васи есть стратегия, гарантирующая ему победу, выведите YES.

Иначе выведите NO.

Примечание

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

Во втором примере после хода Васи Пете нужно удалить единственную цифру 8. Таким образом, результирующая строка не сможет стать телефонным номером, поскольку в ней вообще нет цифры 8.

B. Tokitsukaze, CSL и игра с камнями

игры *1800

Tokitsukaze и CSL играют в небольшую игру с камнями.

В начале игры есть \(n\) кучек камней, \(i\)-я из которых содержит \(a_i\) камней. Игроки делают ходы, выбирая непустую кучку и убирая ровно один камень из этой кучки, при этом Tokitsukaze ходит первым. Кучка не может быть выбрана любым игроком, если в ней не осталось камней. Игрок проиграет, если не останется кучек, которые можно выбрать, или если после его хода две кучки (возможно, пустые) имеют одинаковое число камней.

Рассмотрим пример: \(n=3\) и размеры кучек равны \(a_1=2\), \(a_2=3\), \(a_3=0\). Невозможно выбрать пустую кучку, поэтому Tokitsukaze имеет два возможных варианта хода: первая и вторая кучка. Если она выбирает первую кучку, состояние кучек будет \([1, 3, 0]\) и это хороший ход. Но если она выберет вторую кучку, состояние будет \([2, 2, 0]\), и она проиграет, потому что первые две кучки имеют одинаковое число камней. Значит, единственный хороший ход для нее в этой ситуации — выбрать первую кучку.

Если считать, что игроки действуют оптимально, кто из них выиграет в этой игре?

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

Входные данные

В первой строке записано одно число \(n\) (\(1 \le n \le 10^5\)) — количество кучек.

Во второй строке записаны \(n\) целых чисел \(a_1, a_2, \ldots, a_n\) (\(0 \le a_1, a_2, \ldots, a_n \le 10^9\)), которые означают, что \(i\)-я кучка содержит \(a_i\) камней.

Выходные данные

Выведите "sjfnb" (без кавычек), если Tokitsukaze выиграет, или "cslnb" (без кавычек), если CSL выиграет. Заметьте, что выводить нужно буквы нижнего регистра.

Примечание

В первом примере Tokitsukaze не может взять ни один камень, поэтому CSL выиграет.

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

В третьем примере Tokitsukaze выиграет. Вот один из возможных способов:

  • Сначала Tokitsukaze может выбрать первую кучку и взять из нее камень.
  • После этого CSL может выбрать только первую кучку.
  • В итоге Tokitsukaze может выбрать вторую кучку, после чего CSL не может сходить и не проиграть.

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

C. Tokitsukaze и дуэль

жадные алгоритмы игры Перебор *2300

"Duel!"

Только что началась дуэль между Tokitsukaze и Quality за прекрасную принцессу Claris.

Есть \(n\) карт, расположенных в ряд. Каждая карта имеет две стороны, одна из которых покрашена в некоторый цвет. В начале дуэли некоторые из карт лежат одной цветной стороной вверх, а некоторые — цветной стороной вниз. Игроки ходят, переворачивая карты, при этом Tokitsukaze ходит первым. Каждый ход игрок выбирает ровно \(k\) последовательных карт и переворачивает их так, чтобы или все они лежали цветной стороной вниз, или все они лежали цветной стороной вверх. Если все цветные стороны этих \(n\) карт смотрят в одном направлении после хода игрока, он выигрывает.

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

Входные данные

В первой строке записаны два целых числа \(n\) и \(k\) (\(1 \le k \le n \le 10^5\)).

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

Выходные данные

Выведите "once again" (без кавычек), если общее число ходов может превысить \(10^9\), что считается ничьей.

В другом случае, выведите "tokitsukaze" (без кавычек), если Tokitsukaze выиграет, или "quailty" (без кавычек) если Quailty выиграет.

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

Примечание

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

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

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

Ответ на четвертый пример может быть получен аналогично со вторым примером.

D. 1-2-K игра

игры математика *1700

Алиса и Боб играют в игру. У них есть полоска, разлинованная на n + 1 клетку; клетки пронумерованы слева направо начиная с 0. Первоначально, в n-й клетке (в самой последней) расположена фишка.

Игроки ходят по очереди, первой начинает Алиса. Каждый игрок на своем ходу должен сдвинуть фишку на 1, 2 или k клеток влево (то есть, если фишка стоит в позиции i, игрок может переместить ее в клетку i - 1, i - 2 либо i - k). Фишка не может выходить за границы полоски: например, невозможно сдвинуть ее на k клеток левее, если текущая клетка i < k. Игрок, который не может сделать ход, проигрывает игру.

Кто выиграет, если оба участника играют оптимально?

Алиса и Боб хотят сыграть несколько игр — помогите им определить победителя в каждой игре.

Входные данные

В первой строке задано одно число T (1 ≤ T ≤ 100) — количество игр. Следующие T строк содержат описание игр — по одному в строке. Все игры независимы.

Каждая из следующих T строк содержит по два целых числа n и k (0 ≤ n ≤ 109, 3 ≤ k ≤ 109) — длина полоски и число, описывающее третий ход, соответственно.

Выходные данные

Для каждой игры выведите Alice, если Алиса выиграет в данной игре, или Bob, если выиграет Боб.

F. Игра с раскрашиванием

дп игры матрицы *2700

Алиса и Боб собираются сыграть в игру. У них есть \(n\) раскрашенных полосок бумаги; \(i\)-я полоска поделена на \(a_i\) клеток, пронумерованных от \(1\) до \(a_i\). Каждая клетка может быть раскрашена в один из \(3\) цветов.

В самом начале игры Алиса и Боб ставят на полоски \(n\) фишек, \(i\)-я фишка ставится в клетку \(a_i\) полоски \(i\). Затем игроки совершают ходы по очереди, Алиса ходит первой. В процессе хода игрок должен выбрать ровно одну фишку и подвинуть ее на \(1\), \(2\) или \(3\) клетки к началу полоски (если текущая клетка имеет номер \(x\), то можно подвинуть фишку в клетку \(x - 1\), \(x - 2\) или \(x - 3\)). Есть два ограничения: фишка не может покидать пределы полоски (например, если фишка находится в ячейке \(3\), нельзя подвинуть ее на \(3\) ячейки); и некоторые ходы могут быть недоступны из-за цвета текущей клетки (эти запреты обозначаются матрицей \(f\) размера \(3 \times 3\), где \(f_{i, j} = 1\), если можно подвинуть фишку на \(j\) клеток к началу полоски из клетки с цветом \(i\), или \(f_{i, j} = 0\), если этот ход недоступен). Игрок, который не может сделать ход, проигрывает.

Изначально некоторые клетки могут быть бесцветными. Боб может покрасить все бесцветные клетки так, как он хочет (но нельзя оставлять бесцветную клетку бесцветной). Назовем раскраску хорошей, если Боб может выиграть игру при любых действиях Алисы, если клетки окрашены в соответствии с этой раскраской. Две раскраски считаются различными, если существует хотя бы одна клетка, которая в этих раскрасках имеет разные цвета.

Боб хочет посчитать количество хороших раскрасок. Можете ли вы сделать это для него?

Так как ответ может быть очень большим, выведите его по модулю \(998244353\).

Входные данные

В первой строке задано одно целое число \(n\) — количество полосок (\(1 \le n \le 1000\)).

Во второй строке заданы \(n\) целых чисел \(a_1\), \(a_2\), ..., \(a_n\) (\(1 \le a_i \le 10^9\)), где \(a_i\) — количество клеток в \(i\)-й полоске.

В третьей строке задано одно целое число \(m\) (\(1 \le m \le 1000\)) — количество изначально окрашенных клеток.

Затем следуют \(m\) строк, каждая из которых обозначает окрашенную клетку. \(i\)-я строка содержит три целых числа \(x_i\), \(y_i\) и \(c_i\) (\(1 \le x_i \le n\), \(1 \le y_i \le a_{x_i}\), \(1 \le c_i \le 3\)), обозначающие, что клетка \(y_i\) в полоске \(x_i\) окрашена в цвет \(c_i\). Гарантируется, что если \(i \ne j\), то \(x_i \ne x_j\), или \(y_i \ne y_j\) (или и то, и другое сразу).

Затем следуют \(3\) строки, \(i\)-я строка содержит \(3\) целых числа \(f_{i, 1}\), \(f_{i, 2}\), \(f_{i, 3}\) (\(0 \le f_{i, j} \le 1\)). Если \(f_{i, j} = 1\), то можно переместить фишку на \(j\) клеток к началу полоски из клетки с цветом \(i\); если же \(f_{i, j} = 0\), то такой ход невозможен.

Выходные данные

Выведите количество хороших раскрасок по модулю \(998244353\).

E. Поставь Коня!

игры математика *1400

Петя и Гена играют в очень занимательную игру «Поставь Коня!» на шахматной доске размером n × n. В этой игре ребята по очереди ставят на доску шахматных коней так, чтобы никакие два коня не находились под ударом друг друга. Под ударом шахматного коня, находящегося в клетке (r, c), находятся клетки (r - 1, c + 2), (r - 1, c - 2), (r + 1, c + 2), (r + 1, c - 2), (r - 2, c + 1), (r - 2, c - 1), (r + 2, c + 1) и (r + 2, c - 1) (некоторые из них могут находиться вне доски). Проигрывает тот, кто не может сделать ход. Определите, кто выиграет при оптимальной игре обоих, если первым ходит Петя.

Входные данные

В первой строке задано целое число T (1 ≤ T ≤ 100) — количество досок, для которых вам надо определить исход игры. В следующих T строках заданы T целых чисел ni (1 ≤ ni ≤ 10000) — размеры шахматных досок.

Выходные данные

Для каждой доски ni × ni выведите в отдельной строке «0», если при оптимальной игре выигрывает Петя, иначе выведите «1».

D. Игра с билетом

жадные алгоритмы игры математика *1700

Монокарп и Бикарп живут в Берляндии, где все автобусные билеты состоят из \(n\) цифр, при этом \(n\) — четное число. Гуляя вечером, они нашли билет, некоторые цифры на котором были стерты. Количество позиций, в которых цифры стерты, четно.

Монокарп и Бикарп решили сыграть в игру, используя найденный билет. Монокарп очень не любит счастливые билеты, в то время как Бикарп коллекционирует счастливые билеты. Билет считается счастливым, если сумма первых \(\frac{n}{2}\) цифр билета равна сумме последних \(\frac{n}{2}\) цифр билета.

Монокарп и Бикарп будут ходить по очереди, первый ход сделает Монокарп. На каждом своем ходу игроки будут записывать на место какой-то стертой цифры произвольную цифру от \(0\) до \(9\). Игра заканчивается, когда в билете не останется позиций со стертыми цифрами.

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

Входные данные

В первой строке следует целое четное число \(n\) \((2 \le n \le 2 \cdot 10^{5})\) — количество цифр в билете.

Во второй строке следует строка, состоящая из \(n\) цифр и знаков «?» — билет, найденный Монокарпом и Бикарпом. Если в позиции \(i\) стоит знак «?», то цифра, стоящая в позиции \(i\) в билете, была стерта. Обратите внимание, что номер билета может содержать лидирующие нули. Количество символов «?» четно.

Выходные данные

Если в игре победит Монокарп, выведите «Monocarp» (без кавычек). В противном случае, выведите «Bicarp» (без кавычек).

Примечание

В первом примере нет ни одной стертой цифры в билете, поэтому игроки не смогут сделать ни одного хода. Так как билет счастливый, то выиграет Бикарп.

Во втором примере выиграет Бикарп, для этого ему нужно поставить на место стертой цифры ту же цифру, которую поставит Монокарп на своем ходу.

C. Игра в подстроки на уроке

жадные алгоритмы игры Строки *1300

Миша и Аня сидят на скучном уроке. Чтобы хоть как-то скрасить ожидание перемены, они придумали интересную игру. Для игры необходима лишь строка \(s\) и число \(k\) (\(0 \le k < |s|\)).

Игра начинается с того, что на строке \(s\) отмечается подстрока длины 1, ее левая граница \(l\) и правая граница \(r\) равны \(k\) (то есть вначале игры \(l=r=k\)). Далее игроки ходят по очереди, расширяя подстроку по следующим правилам:

  • Игрок выбирает индексы \(l^{\prime}\) и \(r^{\prime}\) такие, что \(l^{\prime} \le l\), \(r^{\prime} \ge r\) и \(s[l^{\prime}, r^{\prime}]\) лексикографически меньше \(s[l, r]\). После этого изменяет значения \(l\) и \(r\) следующим образом: \(l := l^{\prime}\), \(r := r^{\prime}\).
  • Аня ходит первой.
  • Проигрывает тот, кто не может сделать ход.

Напомним, что подстрокой \(s[l, r]\) (\(l \le r\)) строки \(s\) будем называть непрерывную подпоследовательность символов начинающуюся в позиции \(l\) и заканчивающуюся в позиции \(r\). Например «ehn» — подстрока (\(s[3, 5]\)) строки «aaaehnsvz», а «ahz» — нет.

Миша и Аня играли в игру так увлеченно, что не заметили как к ним подошел учитель. К большому удивлению обоих, он не стал их отчитывать, а сказал, что может определить победителя до начала игры, зная лишь \(s\) и \(k\)!

К сожалению, Миша и Аня не разбираются в теории игр, поэтому попросили Вас написать программу, которая по заданной \(s\) определяет победителя для всех возможных \(k\).

Входные данные

Входные данные состоят из единственной строки \(s\) (\(1 \leq |s| \leq 5 \cdot 10^5\)), которая содержит исключительно строчные английские буквы.

Выходные данные

Выходные данные должны содержать \(|s|\) строк.

В строке номер \(i\) выведите имя победителя игры (выведите Ann или Mike) со строкой \(s\), для \(k = i\), при условии, что Аня и Миша играют оптимально.

E. Игра со строкой

игры *2500

Алиса и Боб играют в игру. Изначально у них есть строка \(s_1, s_2, \dots, s_n\), состоящая только из символов . и X. Игроки ходят по очереди, и Алиса ходит первой. В течении хода игрок должен выбрать непрерывную подстроку, состоящую только из символов ., и заменить каждый символ в ней на X. Алиса выбирает подстроки длины ровно \(a\), а Боб выбирает подстроки длины ровно \(b\). Гарантируется, что \(a > b\).

Например, если \(s =\) ...X.. и \(a = 3\), \(b = 2\), то после хода Алисы строка может превратиться только в XXXX... Если \(s =\) ...X.., и сейчас ход Боба, то после него строка может превратиться в XX.X.., .XXX.. или ...XXX.

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

Вам нужно ответить на \(q\) независимых запросов.

Входные данные

Первая строка содержит число \(q\) (\(1 \le q \le 3 \cdot 10^5\)) — количество запросов.

Первая строка каждого запроса содержит два числа \(a\) и \(b\) (\(1 \le b < a \le 3 \cdot 10^5\)).

Вторая строка каждого запроса содержит строку \(s\) (\(1 \le |s| \le 3 \cdot 10^5\)), состоящую только из символов . и X.

Гарантируется, что сумма \(|s|\) по всем запросам не превосходит \(3 \cdot 10^5\).

Выходные данные

На каждый запрос выведите YES, если Алиса может выиграть, и NO в обратном случае.

Вы можете выводить ответ в любом регистре (например, строки yEs, yes, Yes и YES будут распознаны как положительный ответ).

Примечание

В первом запросе Алиса может выбрать подстроку \(s_3 \dots s_5\). После этого \(s\) превратится в XXXXX...XX...X. Теперь, независимо от хода Боба, у Алисы будет возможность сделать второй ход, а вот Боб второй ход сделать не сможет.

Во втором запросе Алиса не может выиграть, так как не может сделать даже первый ход.

В третьем запросе Алиса может выбрать подстроку \(s_2 \dots s_6\). После этого \(s\) превратится в .XXXXX.X..X, и Боб не сможет сделать ход.

A. Игра с картами

жадные алгоритмы игры математика *800

Два игрока решили сыграть в интересную карточную игру.

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

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

К примеру, пусть \(n = 5\), у первого игрока есть карты со стоимостями \(2\) и \(3\), а у второго есть карты со стоимостями \(1\), \(4\), \(5\). Ниже продемонстрирован возможный ход игры:

  • Первый игрок выбирает карту \(3\), второй игрок выбирает карту \(1\). Так как \(3>1\), первый игрок получает обе карты. Теперь у первого игрока есть карты \(1\), \(2\), \(3\), у второго игрока есть карты \(4\), \(5\).

  • Первый игрок выбирает карту \(3\), второй игрок выбирает карту \(4\). Так как \(3<4\), второй игрок получает обе карты. Теперь у первого игрока есть карты \(1\), \(2\), у второго игрока есть карты \(3\), \(4\), \(5\)

  • Первый игрок выбирает карту \(1\), второй игрок выбирает карту \(3\). Так как \(1<3\), второй игрок получает обе карты. Теперь у первого игрока есть только карта \(2\), у второго игрока есть карты \(1\), \(3\), \(4\), \(5\)

  • Первый игрок выбирает карту \(2\), второй игрок выбирает карту \(4\). Так как \(2<4\), второй игрок получает обе карты. Теперь у первого игрока не осталось карт, и он проигрывает. Как следствие, второй игрок побеждает.

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

Входные данные

Во входных данных находятся несколько (не меньше одного) тестовых случаев. В первой строке находится одно целое число \(t\) (\(1 \le t \le 100\)) — количество тестовых случаев. Далее следуют описания тестовых случаев.

Первая строка описания тестового случая содержит три целых числа \(n\), \(k_1\), \(k_2\) (\(2 \le n \le 100, 1 \le k_1 \le n - 1, 1 \le k_2 \le n - 1, k_1 + k_2 = n\)) — количество карт, количество карт у первого игрока и второго игрока соответственно.

Вторая строка описания тестового случая содержит \(k_1\) целых чисел \(a_1, \dots, a_{k_1}\) (\(1 \le a_i \le n\)) — стоимости карт первого игрока.

Третья строка описания тестового случая содержит \(k_2\) целых чисел \(b_1, \dots, b_{k_2}\) (\(1 \le b_i \le n\)) — стоимости карт второго игрока.

Гарантируется, что все стоимости карт различны.

Выходные данные

Для каждого тестового случая, выведите «YES» с новой строки, если первый игрок победит. Иначе, выведите «NO» с новой строки. Вы можете выводить каждую букву в любом регистре (строчную или заглавную).

Примечание

В первом тестовом случае примера, у каждого игрока есть только один возможный ход: первый игрок положит \(2\), второй игрок положит \(1\). \(2>1\), поэтому первый игрок заберет обе карточки и победит.

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

F. Атака на Красное Королевство

игры *2500

Красное Королевство атаковано войсками Белого Короля и Черного Короля!

Королевство охраняют \(n\) замков, \(i\)-й из которых защищают \(a_i\) солдат. Чтобы захватить Королевство, необходимо уничтожить всех солдат, защищающих замки.

Каждый день Белый Король атакует один из замков. Затем ночью войска Черного Короля атакуют один из замков (возможно, тот же самый). После этого снова следует атака Белого Короля, потом атака Черного Короля, и так далее. Первую атаку проводит Белый Король.

Целью каждой атаки должен быть замок с хотя бы одним живым защитником. Существует три типа атак:

  • смешанная атака уменьшает количество защитников замка на \(x\) (или до \(0\), если их было меньше \(x\));
  • атака пехоты уменьшает количество защитников замка на \(y\) (или до \(0\), если их было меньше \(y\));
  • атака конницы уменьшает количество защитников замка на \(z\) (или до \(0\), если их было меньше \(z\)).

Смешанная атака может быть проведена по любой цели (по любому замку, в котором жив хотя бы один защитник). Однако атака пехоты не может быть проведена по замку, если предыдущая атака на этот замок была того же самого типа, вне зависимости от того, кто и когда провел эту атаку. То же самое относится к атаке конницы. Еще не атакованный замок доступен как цель для атаки любого типа.

Король, который проведет последнюю атаку, будет прославлен как завоеватель Красного Королевства, поэтому оба Короля хотят провести последнюю атаку (и они достаточно мудры, чтобы составить план действий, который позволит им это сделать вне зависимости от действий оппонента, если это возможно). Войска Белого Короля готовятся к первой атаке, а вам поручено ее распланировать. Сможете ли вы посчитать количество возможных вариантов первой атаки, при которых у Белого Короля есть стратегия, позволяющая ему провести последнюю атаку вне зависимости от действий Черного Короля? Каждый вариант первой атаки — это тип атаки и номер атакуемого замка, и два варианта различны, если хоть что-то из этого отличается в этих вариантах.

Входные данные

В первой строке задано одно целое число \(t\) (\(1 \le t \le 1000\)) — количество наборов входных данных.

Затем следуют сами входные данные. Каждый набор входных данных состоит из двух строк.

В первой строке заданы четыре целых числа \(n\), \(x\), \(y\) и \(z\) (\(1 \le n \le 3 \cdot 10^5\), \(1 \le x, y, z \le 5\)).

Во второй строке заданы \(n\) целых чисел \(a_1\), \(a_2\), ..., \(a_n\) (\(1 \le a_i \le 10^{18}\)).

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

Выходные данные

Для каждого набора тестовых данных выведите ответ на него — одно целое число, равное количеству возможных вариантов для первой атаки (или \(0\), если у Черного Короля всегда будет возможность провести последнюю атаку, вне зависимости от действий Белого Короля).

D. Досуг в школе №41

графы жадные алгоритмы игры Конструктив Перебор реализация сортировки *2100

В средней школе №41 учатся \(n\) детей. Всем известно, что они хорошие математики. Однажды на перемене ребята решили провести исследование. Они выстроились в один ряд и повернули головы налево или направо.

Дети проделывали следующую операцию: каждую секунду несколько пар соседних в ряду детей, смотрящих друг на друга, могли одновременно развернуться в противоположную сторону. Таким образом, ребенок, смотрящий на правого соседа, повернется налево, и наоборот для второго ребенка. Более того, каждую секунду хотя бы одна пара соседних детей проделывала подобную операцию. Процесс заканчивается, когда нет пары соседних детей смотрящих друг на друга.

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

Для примера, дети могут действовать с конфигурацией приведенной ниже и \(k = 2\) следующим образом:

На первом ходу развернутся две пары: \((1, 2)\) и \((3, 4)\). После этого получается такая конфигурация:
На втором ходу развернется только пара \((2, 3)\). В итоговой конфигурации никакая пара детей не смотрит друг на друга. Хорошая работа.

Если решение существует, то гарантируется что дети совершат не более чем \(n^2\) разворотов.

Входные данные

Первая строка входных данных содержит два целых числа \(n\), \(k\) (\(2 \le n \le 3000\), \(1 \le k \le 3000000\))  — количество детей и количество ходов через которые нужно закончить.

Вторая строка входных данных содержит строку длины \(n\), которая состоит только из символов L и R. L значит, что ребенок смотрит налево, а R  — направо.

Выходные данные

Если решения не существует, выведите \(-1\).

Иначе, вывод должен состоять из \(k\) строк. Каждая строка должна начинаться с положительного целого числа \(n_i\) (\(1\le n_i \le \frac{n}{2}\))  — количества пар детей, которые развернутся на этом ходу. Далее в этой же строке должно следовать \(n_i\) попарно различных чисел  — номера детей, которые повернут голову налево во время этого хода.

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

Если существует более одного решения, выведите любое из них.

Примечание

Первый тест описывает пару детей смотрящих друг на друга. За один ход они развернутся.

Во втором тесте дети не могут сделать ни одного хода. В итоге они не смогут закончить за \(k>0\) ходов.

Третий тест описан в условии.

H. Игра с отрезками

*особая задача игры Структуры данных *2700

Алиса и Боб играют в игру (да, опять).

У них есть две последовательности отрезков на числовой прямой: последовательность из \(n\) начальных отрезков: \([l_1, r_1]\), \([l_2, r_2]\), ..., \([l_n, r_n]\), и последовательность из \(m\) конечных отрезков: \([L_1, R_1]\), \([L_2, R_2]\), ..., \([L_m, R_m]\). В начале игры они выбирают один из начальных отрезков в качестве текущего отрезка.

Алиса и Боб ходят по очереди: Алиса делает первый ход, затем ходит Боб, после него Алиса и т. д. Во время своего хода игрок обязан уменьшить текущий отрезок либо увеличением его левой границы на \(1\), либо уменьшением его правой границы на \(1\). Таким образом, если текущий отрезок \([c_l, c_r]\), то он превратится либо в \([c_l + 1, c_r]\), либо в \([c_l, c_r - 1]\).

Если в начале игры либо после хода Боба текущий отрезок совпадает с одним из конечных отрезков — то Боб выигрывает. Если текущий отрезок стал вырожденным (\(c_l = c_r\)), и Боб еще не выиграл — то выигрывает Алиса. Если текущий отрезок совпадает с одним из конечных отрезков после хода Алисы — игра продолжается.

Оба игрока играют оптимально — если игрок может выиграть, то он выберет стратегию, которая позволит ему сделать это за минимальное количество ходов. Если же игрок не может выиграть, то он выберет стратегию, которая продлит игру как можно дольше.

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

Входные данные

Первая строка содержит два числа \(n\) и \(m\) (\(1 \le n, m \le 2 \cdot 10^5\)) — количество начальных отрезков и конченых отрезков, соответственно.

Затем следуют \(n\) строк, \(i\)-я содержит два числа \(l_i\) и \(r_i\) (\(1 \le l_i < r_i \le 10^6\)) — концы \(i\)-го начального отрезка.

Затем следуют \(m\) строк, \(i\)-я содержит два числа \(L_i\) и \(R_i\) (\(1 \le L_i < R_i \le 10^6\)) — концы \(i\)-го конечного отрезка.

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

Выходные данные

Выведите \(n\) чисел, \(i\)-е соответствует результату игры, в которой начали игру с \(i\)-го начального отрезка:

  • если выигрывает Алиса — выведите \(-1\);
  • если выигрывает Боб — выведите, сколько ходов успеет сделать Алиса.

C. Ноль-один

жадные алгоритмы игры Конструктив *1900

Маленький Петя очень любит играть с маленькой Машей. Недавно мама подарила ему игру под названием «Ноль-один». Петя сразу же предложил Маше сыграть в эту игру.

Перед игрой на столе выкладывается несколько карточек в один ряд, слева направо. На каждой карточке написано число: 0 либо 1. Игроки ходят по очереди, первой ходит Маша. На каждом ходу игроку требуется взять одну карточку со стола, а все остальные карточки сдвинуть так, чтобы закрыть пустоту на месте вытянутой карточки. Например, если перед чьим-то ходом на столе карточки образовывали последовательность 01010101, то после вытягивания четвертой по счету карточки (нумерация с единицы), последовательность станет такой: 0100101.

Игра заканчивается, когда на столе остается ровно две карточки. Цифры на этих карточках задают число в двоичной системе счисления: старший бит находится слева. Цель Маши — минимизировать это число, а цель Пети — максимизировать его.

Перед самым началом игры случилась неприятность. Дети пролили сок на некоторые карточки и цифры на них расплылись. На каждой из испорченных карточек могло быть написано как число 0, так и число 1. Рассмотрим все возможные начальные расклады (до проливания сока). Для каждого из этих раскладов найдем, какие 2 карточки останутся на столе после игры, при условии, что и Петя, и Маша играют оптимально. Упорядоченная пара цифр, написанных на этих двух карточках, называется исходом игры. Ваша задача — найти множество исходов для всех возможных начальных раскладов.

Входные данные

Первая строка содержит последовательность символов, каждый из которых может быть либо «0», либо «1», либо «?». Эта последовательность задает начальный расклад карточек на столе слева направо. Символы «?» означают, что соответствующая карточка перед началом игры была испорчена. Длина последовательности лежит в диапазоне от 2 до 105, включительно.

Выходные данные

Выведите множество исходов для всех начальных раскладов игры. Каждый исход выводите в отдельной строке. Каждый исход представляет собой два символа — цифры, написанные на карточках, оставшихся после конца игры. Исходы должны быть отсортированы лексикографически (см. первый пример).

Примечание

В первом примере возможны 16 вариантов начального расклада карточек. Для варианта 0000 исходом будет 00. Для варианта 1111 исходом будет 11. Для варианта 0011 исходом будет 01. Для варианта 1100 исходом будет 10. Вне зависимости от исходов для всех остальных раскладов, искомое множество содержит все 4 возможных исхода.

В третьем примере возможны всего 2 варианта начального расклада: 111 и 101. Для варианта 111 исходом будет 11. Для варианта 101 исходом будет 01, поскольку Маша на первом ходу может забрать первую слева карточку, после чего игра закончится.

C. Игра на листьях

Деревья игры *1600

Ayush и Ashish играют в игру на некорневом дереве, состоящем из \(n\) вершин, пронумерованных от \(1\) до \(n\). Игроки делают следующий ход по очереди:

       
  • Выберите любой лист в дереве и удалите его вместе со всеми ребрами, для которых этот лист является одним из концов. Лист  — это вершина со степенью, не превосходящей \(1\).

Дерево  — это связный неориентированный граф без циклов.

Дана специальная вершина с номером \(x\). Игрок, который удаляет эту вершину, выигрывает игру.

Ayush ходит первым. Определите победителя игры, если каждый игрок играет оптимально.

Входные данные

В первой строке входных данных содержится одно целое число \(t\) \((1 \leq t \leq 10)\) — количество наборов входных данных. Далее следуют описания наборов входных данных.

Первая строка каждого набора входных данных содержит два целых числа \(n\) и \(x\) \((1\leq n \leq 1000, 1 \leq x \leq n)\) — количество вершин в дереве и специальную вершину, соответственно.

Каждая из следующих \(n-1\) строк содержит два целых числа \(u\), \(v\) \((1 \leq u, v \leq n, \text{ } u \ne v)\), что означает, что между вершинами \(u\) и \(v\) есть ребро.

Выходные данные

Для каждого набора входных данных, если побеждает Ayush, выведите "Ayush", иначе выведите "Ashish" (без кавычек).

Примечание

В первом наборе входных данных Ayush может удалить только вершину \(2\) или \(3\), после чего вершина \(1\) становится листом, и Ashish может удалить ее в свою очередь.

Во втором наборе входных данных Ayush может удалить вершину \(2\) на самом первом шаге.

A. Игра с таблицей

жадные алгоритмы игры реализация *1100

Ashish и Vivek играют в игру на таблице с \(n\) строками и \(m\) столбцами, захватывая клетки. Незахваченные клетки обозначены \(0\), а захваченные клетки обозначены \(1\). Вам дано исходное состояние таблицы.

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

Если Ashish и Vivek ходят по очереди и Ashish ходит первым, найдите победителя игры если они оба играют оптимально.

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

Входные данные

В первой строке записано одно целое число \(t\) \((1 \le t \le 50)\) — количество наборов входных данных. Далее следуют описания наборов входных данных.

В первой строке каждого набора входных данных записаны два целых числа \(n\), \(m\) \((1 \le n, m \le 50)\) — количество строк и столбцов в таблице.

В каждой из следующих \(n\) строк записаны \(m\) целых чисел, \(j\)-е число на \(i\)-й строке описывает \(a_{i,j}\) \((a_{i,j} \in \{0, 1\})\).

Выходные данные

Для каждого набора входных данных, если Ashish выиграет при правильной игре, выведите «Ashish», иначе выведите «Vivek» (без кавычек).

Примечание

В первом наборе входных данных: Один из возможных исходов игры следующий: Ashish захватывает клетку \((1, 1)\), затем Vivek захватывает клетку \((2, 2)\). Ashish не может захватить ни клетку \((1, 2)\), ни клетку \((2, 1)\), так как клетки \((1, 1)\) и \((2, 2)\) уже захвачены. Таким образом, Ashish проигрывает. Можно показать, что вне зависимости от ходов Ashish, Vivek выиграет. Во втором наборе входных данных: Ashish захватывает клетку \((1, 1)\), единственная клетка, которую можно захватить. После этого у Vivek не будет возможных ходов.

В третьем наборе входных данных: Ashish не может сделать ход, поэтому Vivek выиграет.

В четвертом наборе входных данных: Ashish захватывает клетку \((2, 3)\), у Vivek не останется возможных ходов.

F. Лампочки по кругу

игры интерактив математика реализация *2600

Это интерактивная задача.

Джон и его воображаемый друг играют в игру. По кругу расположено \(n\) лампочек. Лампочки пронумерованы от \(1\) до \(n\) по часовой стрелке, то есть, лампочки \(i\) и \(i + 1\) являются соседними для любого \(i = 1, \ldots, n - 1\), а также соседними являются лампочки \(n\) и \(1\). Исходно все лампочки выключены.

Джон и его друг ходят по очереди, начиная с Джона. Джон в качестве своего действия может завершить игру либо сделать ход. Чтобы сделать ход, Джон выбирает положительное число \(k\) и может включить любые \(k\) лампочек на свой выбор. Его друг в ответ может выбрать любые \(k\) подряд идущих лампочек и выключить их (выбранные лампочки, которые уже были выключены, остаются выключенными), где \(k\) равно числу, которое выбрал Джон на последнем ходу. Например, если \(n = 5\) и Джон только что включил три лампочки, то его друг может выключить лампочки \(1, 2, 3\), или \(2, 3, 4\), или \(3, 4, 5\), или \(4, 5, 1\), или \(5, 1, 2\).

После этого Джон снова может завершить игру или сходить, и так далее. Однако, Джон не может сделать более \(10^4\) ходов.

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

Пусть в игре \(n\) лампочек. Обозначим \(R(n)\) количество включенных лампочек в конце игры, если оба игрока действуют оптимально. Ваша программа должна сделать не более \(10^4\) ходов и завершить игру не менее чем с \(R(n)\) включенными лампочками. Детали реализации приведены в секции «Протокол взаимодействия».

По техническим причинам взломы по этой задаче невозможны.

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

Исходно ваша программа получит на вход одно целое число \(n\) (\(1 \leq n \leq 1000\)) — количество лампочек в игре. После этого программа жюри будет ожидать ваших действий.

Чтобы сделать ход, выведите в одной строке целое число \(k\) (\(1 \leq k \leq n\)), а зачем \(k\) различных целых чисед \(l_1, \ldots, l_k\) (\(1 \leq l_i \leq n\)) — номера лампочек, которые вы хотите включить. Индексы можно выводить в любом порядке. Можно пытаться включать лампочки, которые уже включены (в таком случае их состояние не изменится).

Если ваш ход по какой-либо причине некорректен, или вы совершили более \(10^4\) ходов, программа жюри выведет одно число \(-1\). В противном случае, программа жюри выведет одно целое число \(x\) (\(1 \leq x \leq n)\). Это означает, что в ответ были выключены \(k\) лампочек, начиная с лампочки номер \(x\) в порядке по часовой стрелке.

Чтобы вместо следующего хода завершить игру, выведите в отдельной строке одно число \(0\). Тест будет пройден, если в этот момент включено не менее \(R(n)\) лампочек (значение \(R(n)\) и полученный вердикт не будут сообщены вашей программе). Это действие не включается в количество сделанных ходов (то есть, разрешается завершить игру после ровно \(10^4\) ходов).

Чтобы получить правильный вердикт, ваша программа должна завершиться сразу, как только выведет \(0\) либо получит ответ \(-1\).

Не забудьте сбросить буфер вывода после каждого действия.

Примечание

Если \(n = 3\), любой ход Джона может быть отменен обратно, поэтому \(R(3) = 0\) и завершить игру сразу является верной стратегией.

\(R(4) = 1\), и одна из стратегий, которая достигает этого результата, приведена во втором примере.

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

F. ПобедитеЛи

дп игры поиск в глубину и подобное *2700

Ли предпочитает завершать свои истории стильно, но не в этот раз. Благо, Белый Медведь успел придти к нему на помощь. В благодарность, Ли решил показать Белому его новую игру под названием «Critic»...

Данная игра — один на один. Она состоит из \(t\) раундов, каждый раунд определяется двумя целыми числами \(s_i\) и \(e_i\) (которые определены заранее и известны перед началом игры, \(s_i\) и \(e_i\) могут отличаться от раунда к раунду). В начале соответствующего раунда число \(s_i\) написано на доске.

Игроки ходят по очереди. Каждый игрок стирает число на доске (назовем его \(a\)) и выбирает, что написать: \(2 \cdot a\) или \(a + 1\). Тот, кто напишет на доске число строго больше чем \(e_i\), проигрывает.

Сейчас Ли хочет сыграть в «Critic» против Белого, и для каждого раунда он уже выбрал соответствующие \(s_i\) и \(e_i\). Ли начинает первый раунд, и проигравший текущего раунда будет начинать в следующем раунде.

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

Определите, может ли Ли победить независимо от действий Белого. Также, определите, может ли он проиграть независимо от действий Белого.

Входные данные

В первой строке задано единственное целое число \(t\) (\(1 \le t \le 10^5\)) — количество раундов в игре.

В следующих \(t\) строках заданы по два целых числа \(s_i\) и \(e_i\) (\(1 \le s_i \le e_i \le 10^{18}\)) — информация про \(i\)-й раунд.

Раунды играются в том порядке, как они заданы во входных данных, \(s_i\) и \(e_i\) для всех раундов известны всем до начала игры.

Выходные данные

Выведите два числа.

Первым числом выведите 1, если Ли может победить независимо от действий Белого, иначе выведите 0.

Вторым числом выведите 1, если Ли может проиграть независимо от действий Белого, иначе выведите 0.

Примечание

Напоминаем, проигрывает тот, кто напишет число строго больше чем \(e_i\).

C. Игра с числом

игры математика теория чисел *1400

Ashishgup и FastestFinger играют в игру.

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

  • Разделить \(n\) на один из его нечетных делителей, который больше чем \(1\).
  • Вычесть \(1\) из \(n\), если \(n\) больше чем \(1\).

Обратите внимание, что множество делителей числа включает само число.

Если игрок не может сделать ход он проигрывает игру.

Ashishgup ходит первым. Определите победителя игры, если оба игрока играют оптимально.

Входные данные

В первой строке находится единственное целое число \(t\) (\(1 \leq t \leq 100\))  — количество наборов входных данных. Описание наборов входных данных следует.

В единственной строке описания каждого набора входных данных находится единственное целое число \(n\) (\(1 \leq n \leq 10^9\)).

Выходные данные

Для каждого набора входных данных, выведите «Ashishgup», если он побеждает в игре и «FastestFinger» иначе (без кавычек).

Примечание

В первом наборе входных данных \(n = 1\) и Ashishgup не может сделать ход. Он проигрывает.

Во втором наборе входных данных \(n = 2\) и Ashishgup вычитает \(1\) на первом ходу. Теперь \(n = 1\) и FastestFinger не может сделать ход, поэтому он проигрывает.

В третьем наборе входных данных \(n = 3\) и Ashishgup делит на \(3\) на первом ходу. Теперь \(n = 1\) и FastestFinger не может сделать ход, поэтому он проигрывает.

В последнем наборе входных данных \(n = 12\) и Ashishgup делит на \(3\) на первом ходу. Теперь \(n = 4\), FastestFinger может только вычесть \(1\) и Ashishgup получает число \(3\). Наконец, он побеждает после деления этого числа на \(3\).

D. Омкар и круг

дп жадные алгоритмы игры Перебор *2100

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

Вам даны \(n\) неотрицательных целых чисел \(a_1, a_2, \dots, a_n\), расположенных по кругу, где \(n\) гарантированно будет нечетным (т.е. \(n-1\) делится на \(2\)). Формально для всех \(i\) таких, что \(2 \leq i \leq n\), элементы \(a_{i - 1}\) и \(a_i\) считаются соседними, а \(a_n\) и \(a_1\) также рассматриваются как соседние. За одну операцию вы выбираете число в круге, заменяете его суммой двух соседних элементов, а затем удаляете два соседних элемента из круга. Это повторяется до тех пор, пока в круге не останется только одно число, которое мы называем круговым значением.

Помогите Дэнни найти максимально возможное круговое значение после некоторой последовательности операций.

Входные данные

Первая строка содержит одно нечетное целое число \(n\) (\(1 \leq n < 2 \cdot 10^5\), \(n\) нечетно)  — начальный размер круга.

Вторая строка содержит \(n\) целых чисел \(a_{1},a_{2},\dots,a_{n}\) (\(0 \leq a_{i} \leq 10^9\))  — начальные числа в круге.

Выходные данные

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

Примечание

Для первого примера круговое значение \(17\) получается так:

Выберите число с индексом \(3\). Сумма соседних элементов равна \(17\). Удалите \(7\) и \(10\) из круга и замените \(2\) на \(17\).

Обратите внимание, что ответ может выйти за пределы \(32\)-разрядного целого числа.

B. 01-игра

игры *900

Алиса и Боб играют в игру.

Изначально у них есть строка \(s\), состоящая только из символов 0 и 1.

Алиса и Боб ходят по очереди: Алиса делает первый ход, второй делает Боб, третий ход делает Алиса, и так далее. Во время своего хода игрок должен выбрать два соседних различных символа строки \(s\) и удалить их. Например, если \(s = 1011001\), тогда возможны следующие ходы:

  1. удалить \(s_1\) и \(s_2\): \(\textbf{10}11001 \rightarrow 11001\);
  2. удалить \(s_2\) и \(s_3\): \(1\textbf{01}1001 \rightarrow 11001\);
  3. удалить \(s_4\) и \(s_5\): \(101\textbf{10}01 \rightarrow 10101\);
  4. удалить \(s_6\) и \(s_7\): \(10110\textbf{01} \rightarrow 10110\).

Если игрок не может сделать ход — он проигрывает. Оба игрока играют оптимально. Вам нужно определить, сможет ли Алиса выиграть.

Входные данные

Первая строка содержит число \(t\) (\(1 \le t \le 1000\)) — количество наборов входных данных.

Единственная строка каждого набора входных данных содержит строку \(s\) (\(1 \le |s| \le 100\)), состоящую только из символов 0 и 1.

Выходные данные

На каждый набор входных данных выведите ответ в отдельной строке.

Если Алиса может выиграть, выведите DA в любом регистре. Иначе выведите NET в любом регистре.

Примечание

В первом наборе входных данных после хода Алисы строка \(s\) станет пустой и Боб не сможет сделать ход.

Во втором наборе входных данных Алиса не может сделать ход изначально.

В третьем наборе входных данных после хода Алисы строка \(s\) превратится в \(01\). А после хода Боба строка \(s\) станет пустой и Алиса не сможет сделать ход.

F. Игра с числами

игры интерактив Конструктив математика *2600

Это интерактивная задача.

Антон и Харрис играют в игру, чтобы решить, кто из них является королем проблемсеттинга.

Есть три кучи камней, изначально содержащих \(a\), \(b\), \(c\) камней соответственно, где \(a\), \(b\) и \(c\) являются попарно различными целыми положительными числами. На каждом ходу игры происходит следующая последовательность событий:

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

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

Чувствуя себя уверенно в своем мастерстве, Антон решил позволить Харрису выбрать, хочет он ходить первым или вторым. Помогите Харрису победить Антона и стать королем проблемсеттинга!

Входные данные

Первая строка содержит три различных положительных целых числа \(a\), \(b\), and \(c\) (\(1 \le a, b, c \le 10^9\))  — начальные количества камней в кучах \(1\), \(2\) и \(3\) соответственно.

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

Взаимодействие начинается с чтения целых чисел \(a\), \(b\) и \(c\).

После прочтения выведите одну строку, содержащую "First" или "Second", обозначающую, кем вы хотите играть (за первого или за второго, соответственно).

На каждом ходу первый игрок (вы или интерактор) должен вывести положительное целое число \(y\) (\(1 \le y \le 10^{12}\)).

Затем второй игрок должен вывести \(1\), \(2\) или \(3\), указав, к какой куче должны быть добавлены \(y\) камней. Начиная со второго хода, куча, которую выбирает второй игрок, должна отличаться от кучи, выбранной на предыдущем ходу.

Если вы играете за Second и продержались \(1000\) ходов без проигрыша, или если вы играете за First, и интерактор определил, что он не может сделать ход без проигрыша, интерактор выведет \(0\) и закончит взаимодействие. Это означает, что ваша программа прошла данный тест, и вы должны немедленно завершить программу.

Если вы играете как First и не побеждаете за \(1000\) ходов, или если вы играете как Second и выводите ход, в котором два кучи имеют одинаковое количество камней, или вы выводите невозможный ход как любой из игроков, интерактор выведет \(-1\) и завершит взаимодействие. Вы получите вердикт Wrong Answer. Завершите программу немедленно, чтобы избежать других вердиктов.

После вывода запроса не забудьте вывести перевод строки, и сбросить буфер вывода. В противном случае вы получите вердикт Решение «зависло». Для сброса буфера используйте:

  • fflush(stdout) или cout.flush() в C++;
  • System.out.flush() в Java;
  • flush(output) в Pascal;
  • stdout.flush() в Python;
  • смотрите документацию для других языков.

В этой задачи взломы отключены.

Примечание

В примере в кучах изначально \(5\), \(2\) и \(6\) камней соответственно. Харрис решает пойти первым и предоставляет Антону число \(2\). Антон добавляет \(2\) камня в третью кучу, что дает \(5\), \(2\) и \(8\).

На следующем ходу Харрис выбирает число \(3\). Обратите внимание, что Антон не может добавить камни в третью кучу, так как он выбрал третью кучу в предыдущем ходу. Антон понимает, что у него не осталось действительных ходов, и неохотно признает Харриса королем.

D. World of Darkraft

дп игры *2500

Недавно Рома стал счастливым обладателем новой игры World of Darkraft. Эта игра сочетает элементы практически всех известных жанров, и на одном из поздних этапов игры Рома столкнулся с трудностями игры-головоломки.

В этой части Рома сражается с хитрым вражеским магом. Сражение происходит на прямоугольном клетчатом поле n × m. В каждой клетке находится один из магических символов: L, R или X. Изначально все клетки поля «активны».

Игроки, Рома и вражеский маг, ходят по очереди. Рома делает первый ход. На очередном ходу игрок выбирает одну из активных клеток, и после этого в зависимости от изображенного в ней символа происходит одно из следующих действий:

  • L — из клетки влево вниз и вправо вверх по диагоналям исходят магические волны. Все клетки, оказавшиеся на пути волн (в том числе и сама выбранная клетка), становятся неактивными. Волны продолжаются до ближайшей неактивной клетки либо до границы поля, если неактивных клеток на пути нет.
  • R — магические волны исходят влево вверх и вправо вниз.
  • X — магические волны исходят во всех четырех диагональных направлениях.

Если очередной игрок не может сделать ход (то есть все клетки неактивны), он проигрывает.

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

Входные данные

В первой строке находятся два целых числа, разделенных пробелом — n и m (1 ≤ n, m ≤ 20).

В следующих n строках по m символов находится описание игрового поля: j-ый символ i-ой строки равен магическому символу соответствующей клетки поля.

Выходные данные

В первой строке выведите «WIN», если Рома может победить, или «LOSE», если при оптимальной игре соперника победа невозможна.

Примечание

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

Во втором тесте есть три варианта хода: «закрыть» главную диагональ либо одну из оставшихся клеток. Значит, после трех ходов игра закончится, и Рома выиграет.

B. Последовательный ним

дп игры *1100

Есть \(n\) кучек камней, \(i\)-я из них содержит \(a_i\) камней. Два игрока играют в игру, поочередно забирая камни из кучек.

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

Входные данные

В первой строке находится единственное целое число \(t\) (\(1\le t\le 1000\))  — количество наборов входных данных. Следующие \(2t\) строк содержат описания наборов входных данных.

В первой строке каждого набора входных данных содержится единственное целое число \(n\) (\(1\le n\le 10^5\))  — количество кучек.

Во второй строке каждого набора входных данных содержится \(n\) целых чисел \(a_1,\ldots,a_n\) (\(1\le a_i\le 10^9\))  — \(a_i\) равно количеству камней в \(i\)-й кучке.

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

Выходные данные

Для каждого набора входных данных, если игрок, делающий первый ход победит, выведите «First». Иначе выведите «Second».

Примечание

В первом наборе входных данных первый игрок выиграет игру. Его выигрышная стратегия:

  1. Первый игрок должен забирать камни из первой кучки. Он возьмет \(1\) камень. Количества камней в кучках будут \([1, 5, 4]\).
  2. Второй игрок должен забирать камни из первой кучки. Он возьмет \(1\) камень, потому что он не может взять никакое другое количество камней. Количества камней в кучках будут \([0, 5, 4]\).
  3. Первый игрок должен забирать камни из второй кучки, потому что первая кучка пустая. Он возьмет \(4\) камня. Количества камней в кучках будут \([0, 1, 4]\).
  4. Второй игрок должен забирать камни из второй кучки, потому что первая кучка пустая. Он возьмет \(1\) камень, потому что он не может взять никакое другое количество камней. Количества камней в кучках будут \([0, 0, 4]\).
  5. Первый игрок должен забирать камни из третьей кучки, потому что первая и вторая кучка пустые. Он возьмет \(4\) камня. Количества камней в кучках будут \([0, 0, 0]\).
  6. Второй игрок проигрывает игру, потому что все кучки пустые.

B. GameGame

битмаски дп жадные алгоритмы игры Конструктив математика *1900

Коала Коа и ее лучшая подруга хотят поиграть в игру.

Игра начинается с массива \(a\) длины \(n\), состоящего из неотрицательных целых чисел. Коа и ее лучшая подруга ходят по очереди, и у каждой из них есть счет, изначально равный \(0\). Коа начинает.

Ход в игре происходит следующим образом:

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

    Более формально: если текущий счет игрока равен \(x\), а выбранный элемент равен \(y\), его новый счет будет равен \(x \oplus y\). Здесь \(\oplus\) обозначает операцию побитового исключающего ИЛИ..

    Обратите внимание, что после хода элемент \(y\) удаляется из \(a\).

  • Игра заканчивается, когда массив пуст.

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

Если оба игрока играют оптимально, выясните, выиграет ли Коа, проиграет или сыграет вничью.

Входные данные

Каждый тест содержит несколько наборов входных данных. Первая строка содержит \(t\) (\(1 \le t \le 10^4\)) — количество наборов входных данных. Описание наборов входных данных приведено ниже.

Первая строка каждого набора входных данных содержит целое число \(n\) (\(1 \le n \le 10^5\)) — длину массива \(a\).

Вторая строка каждого набора входных данных содержит \(n\) целых чисел \(a_1, a_2, \ldots, a_n\) (\(0 \le a_i \le 10^9\)) — элементы \(a\).

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

Выходные данные

Для каждого набора входных данных выведите:

  • WIN, если Коа выиграет.
  • LOSE, если Коа проиграет.
  • DRAW, если игра закончится вничью.
Примечание

В \(1\)-м наборе входных данных первого примера:

\(a = [1, 2, 2]\). Здесь Коа выбирает \(1\), другой игрок должен выбрать \(2\), Коа выбирает оставшуюся \(2\). Счет для Коа составляет \(1 \oplus 2 = 3\), а для другого игрока  — \(2\), поэтому Коа выигрывает.

B. Каменная игра

жадные алгоритмы игры Конструктив Перебор *1800

T играет в игру со своим другом HL.

Есть \(n\) кучек с камнями, в \(i\)-й из них исходно содержится \(a_i\) камней.

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

Считая, что оба игрока играют оптимально, для заданных стартовых конфигураций \(t\) игр, определите победителя.

Входные данные

В первой строке записано одно целое число \(t\) \((1 \le t \le 100)\) — количество игр. Далее следуют описания игр, описание каждой игры состоит из двух строк:

В первой строке записано одно целое число \(n\) \((1 \le n \le 100)\) — количество куч.

Во второй строке записаны \(n\) целых чисел \(a_1, a_2, \dots, a_n\) \((1 \le a_i \le 100)\).

Выходные данные

Для каждой игры, выведите в отдельной строке имя победителя, «T» или «HL» (без кавычек).

Примечание

В первой игре, T убирает один камень из единственной кучи. После этого, несмотря на то, что в куче еще остался \(1\) камень, HL не можем сходить, из-за того что T использовал эту кучу на прошлом ходу. Таким образом, T побеждает.

B. Игра с удалением подстрок

жадные алгоритмы игры сортировки *800

Алиса и Боб играют в игру. У них есть бинарная строка \(s\) (каждый символ бинарной строки — либо \(0\), либо \(1\)). Алиса ходит первой, потом Боб, потом снова Алиса, и так далее.

В свой ход игрок должен выбрать несколько (не менее одного) последовательных одинаковых символов в \(s\) и удалить их.

Например, если текущая строка — \(10110\), существует \(6\) возможных ходов (удаляемые символы выделены жирным):

  1. \(\textbf{1}0110 \to 0110\);
  2. \(1\textbf{0}110 \to 1110\);
  3. \(10\textbf{1}10 \to 1010\);
  4. \(101\textbf{1}0 \to 1010\);
  5. \(10\textbf{11}0 \to 100\);
  6. \(1011\textbf{0} \to 1011\).

После удаления символов те символы, которые стояли слева и справа от удаленного блока, становятся последовательными. Т. е. следующая последовательность операций возможна: \(10\textbf{11}0 \to 1\textbf{00} \to 1\).

Игра заканчивается, когда строка становится пустой. Счет каждого игрока равен кол-ву символов \(1\), которые он удалил.

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

Входные данные

В первой строке задано одно целое число \(T\) (\(1 \le T \le 500\)) — количество наборов входных данных.

Каждый набор входных данных содержит одну бинарную строку \(s\) (\(1 \le |s| \le 100\)).

Выходные данные

Для каждого набора входных данных выведите ответ на него — счет Алисы в конце игры (количество символов \(1\), которые она удалит).

Примечание

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

C. Star Trek

*особая задача графы Деревья дп игры Комбинаторика матрицы поиск в глубину и подобное *2600

The United Federation of Planets is an alliance of \(N\) planets, they are indexed from \(1\) to \(N\). Some planets are connected by space tunnels. In a space tunnel, a starship can fly both ways really fast. There are exactly \(N-1\) space tunnels, and we can travel from any planet to any other planet in the Federation using these tunnels.

It's well known that there are \(D\) additional parallel universes. These are exact copies of our universe, they have the same planets and space tunnels. They are indexed from \(1\) to \(D\) (our universe has index \(0\)). We denote the planet \(x\) in universe \(i\) by \(P_x^i\). We can travel from one universe to another using dimension portals. For every \(i\) (\(0\leq i \leq D-1\)), we will place exactly one portal that allows us to fly from \(P_{A_i}^i\) to \(P_{B_i}^{i+1}\), for some planet indices \(A_i\) and \(B_i\) (i.e. \(1 \leq A_i, B_i \leq N\)).

Once all the portals are placed, Starship Batthyány will embark on its maiden voyage. It is currently orbiting around \(P_1^0\). Captain Ágnes and Lieutenant Gábor have decided to play the following game: they choose alternately a destination (a planet) to fly to. This planet can be in the same universe, if a space tunnel goes there, or it can be in another universe, if a portal goes there. Their aim is to visit places where no one has gone before. That's why, once they have visited a planet \(P_x^i\), they never go back there (but they can visit the planet \(x\) in another universe). Captain Ágnes chooses the first destination (then Gábor, then Ágnes etc.). If somebody can't choose a planet where they have not been before in his/her turn, he/she loses.

Captain Ágnes and Lieutenant Gábor are both very clever: they know the locations of all tunnels and portals, and they both play optimally. For how many different placements of portals does Captain Ágnes win the game? Two placements are different if there is an index \(i\) (\(0\leq i \leq D-1\)), where the \(i\)th portal connects different pairs of planets in the two placements (i.e \(A_i\) or \(B_i\) differs).

This number can be very big, so we are interested in it modulo \(10^9+7\).

Input

The first line contains two space-separated integers, \(N\) (\(1\leq N \leq 10^{5}\)) – the number of planets and \(D\) (\(1 \leq D \leq 10^{18}\)) – the number of additional parallel universes. Each of the next \(N-1\) lines contains two space-separated integers \(u\) and \(v\) (\(1 \leq u, v \leq N\)), denoting that \(P_u^i\) and \(P_v^i\) are connected by a space tunnel for all \(i\) (\(0 \leq i \leq D\)).

Output

You should print a single integer, the number of possible placements of portals where Captain Ágnes wins modulo \(10^9+7\).

Scoring
\( \begin{array}{|c|c|c|} \hline \text{Subtask} & \text{Points} & \text{Constraints} \\ \hline 1 & 0 & \text{samples}\\ \hline 2 & 7 & N=2 \\ \hline 3 & 8 & N \leq 100 \: \text{and} \: D = 1 \\ \hline 4 & 15 & N \leq 1000 \: \text{and} \: D = 1\\ \hline 5 & 15 & D=1 \\ \hline 6 & 20 & N \leq 1000 \: \text{and} \: D \leq 10^5\\ \hline 7 & 20 & D \leq 10^5\\ \hline 8 & 15 & \text{no additional constraints}\\ \hline \end{array} \)
Note

There is only 1 portal and \(3 \cdot 3 = 9\) different placements. The following 4 placements are when the Captain wins.

B. Догонялки на дереве

Деревья дп игры поиск в глубину и подобное *1900

Алиса и Боб играют в забавную игру — догонялки на дереве.

В эту игру играют на дереве из \(n\) вершин, пронумерованных от \(1\) до \(n\). Напомним, что дерево на \(n\) вершинах — это неориентированный, связный граф с \(n-1\) ребрами.

Изначально Алиса располагается в вершине \(a\), а Боб — в вершине \(b\). Они ходят по очереди, и Алиса делает первый ход. За свой ход Алиса может перепрыгнуть в вершину с расстоянием не более \(da\) от текущей вершины. Боб же за свой ход может перепрыгнуть в вершину с расстоянием не более \(db\) от текущей вершины. Расстояние между двумя вершинами определяется как количество рёбер на уникальном простом пути между ними. В частности, любому из игроков разрешается остаться на одной и той же вершине в свой ход. Заметим, что при выполнении хода игрок занимает только начальную и конечную вершины своего хода, а не вершины между ними.

Если после не более чем \(10^{100}\) ходов Алиса и Боб занимают одну и ту же вершину, то победителем объявляется Алиса. В противном случае побеждает Боб.

Определите победителя, если оба игрока играют оптимально.

Входные данные

Каждый тест содержит несколько наборов входных данных. В первой строке указано количество наборов входных данных \(t\) (\(1 \le t \le 10^4\)). Описание наборов входных данных приведено ниже.

Первая строка каждого набора входных данных содержит пять целых чисел \(n,a,b,da,db\) (\(2\le n\le 10^5\), \(1\le a,b\le n\), \(a\ne b\), \(1\le da,db\le n-1\)) — количество вершин, вершину Алисы, вершину Боба, максимальное расстояние прыжка Алисы и максимальное расстояние прыжка Боба, соответственно.

Следующие \(n-1\) строк описывают ребра дерева. \(i\)-я из этих строк содержит два целых числа \(u\), \(v\) (\(1\le u, v\le n, u\ne v\)), обозначающие ребро между вершинами \(u\) и \(v\). Гарантируется, что данный граф является деревом.

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

Выходные данные

Для каждого набора входных данных выведите одну строку, содержащую победителя игры: «Alice» или «Bob».

Примечание

В первом наборе входных данных Алиса может выиграть, перейдя к вершине \(1\). Тогда куда бы Боб не двигался дальше, Алиса сможет перейти к той же самой вершине на следующем шаге.

Во втором наборе входных данных у Боба есть следующая победная стратегия. Куда бы Алиса ни двигалась, Боб всегда будет двигаться к той из вершин \(1\) или \(6\), которая более удалена от Алисы.

G. Нет игры - нет жизни

битмаски игры математика матрицы *2700

Рассмотрим следующую игру Алисы и Боба на ориентированном ациклическом графе. Каждая вершина может содержать произвольное количество фишек. Алиса и Боб совершают ходы по очереди. Первой ходит Алиса. Ход состоит в том, чтобы передвинуть ровно одну фишку по какому-то ребру, исходящему из вершины, в которой сейчас лежит фишка, в конец этого ребра. Проигрывает тот, кто не может сделать ход. Оба играют оптимально.

Рассмотрим следующий процесс, происходящий каждую секунду на данном графе с \(n\) вершинами:

  1. Целое число \(v\) выбирается случайно и равновероятно из \([1, n + 1]\).
  2. Если \(v \leq n\), в \(v\)-ю вершину графа добавляется фишка, а процесс переходит к шагу 1.
  3. Если \(v = n + 1\), Алиса и Боб играют в описанную выше игру на данном графе с текущим расположением фишек, определяется победитель этой игры. После чего, процесс завершается.

Найдите вероятность победы Алисы. Можно показать, что ответ можно представить в виде \(\frac{P}{Q}\), где \(P\) и \(Q\) — взаимно простые целые числа, \(Q \not\equiv 0 \pmod{998\,244\,353}\). Выведите значение \(P \cdot Q^{-1} \bmod 998\,244\,353\).

Входные данные

В первой строке даны два целых числа \(n\) и \(m\) — количество вершин и ребер в графе (\(1 \leq n \leq 10^5\), \(0 \leq m \leq 10^5\)).

Затем следует \(m\) строк, в \(i\)-й из которых содержатся два целых числа \(u_i\) и \(v_i\) — начало и конец \(i\)-го ребра (\(1 \leq u_i, v_i \leq n\)). Гарантируется, что граф является ациклическим.

Выходные данные

В единственной строке выведите вероятность победы Алисы по модулю \(998\,244\,353\).

A. Цифробой

жадные алгоритмы игры реализация *900

Ни для кого не секрет, что в Валоранте агенты разыгрывают стороны до начала матча, и делают это именно Рейз и Брич, которые решили, что для этого надо сыграть \(t\) партий следующей игры...

В каждой из \(t\) партий игры сначала генерируется какое-то положительное целое число, состоящее из \(n\) цифр. Цифры этого числа пронумерованы целыми числами от \(1\) до \(n\) от старшего разряда к младшему. После того, как число становится известно, начинается партия.

Агенты ходят по очереди, Рейз начинает первой. За один ход агент выбирает любую незакрашенную цифру и закрашивает её. Рейз может выбирать цифры на нечётных позициях, но не может на чётных, а Брич может выбирать цифры на чётных позициях, но не может на нечётных. Партия заканчивается тогда, когда остаётся одна незакрашенная цифра. Если единственная оставшаяся цифра нечётная, то выигрывает Рейз, иначе выигрывает Брич.

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

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

Входные данные

В первой строке входных данных находится единственное целое число \(t\) \((1 \le t \le 100)\)  — количество партий.

В первой строке описания каждой партии находится единственное целое число \(n\) \((1 \le n \le 10^3)\)  — количество цифр в числе, с которым будет проведена партия.

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

Выходные данные

Для каждой партии выведите \(1\), если выиграет Рейз, и \(2\), если выиграет Брич.

Примечание

В первой партии никто не может сделать ход, единственная оставшаяся цифра  — это \(2\), она четная, поэтому выигрывает Брич.

Во второй партии единственная оставшаяся цифра  — это \(3\), она нечётная, поэтому выигрывает Рейз.

В третьей партии Рейз может закрасить последнюю цифру, после чего Брич может закрасить только \(0\). Останется только цифра \(1\), и она нечётная, поэтому выигрывает Рейз.

В четвертой партии вне зависимости от игры Рейз, Брич может закрасить \(9\), и в конце игры останется \(0\)  — чётная цифра, поэтому выигрывает Брич.

D. Помогите Крокодилу Гене 2

игры *2600

Научившись (не без помощи участников Codeforces) оптимально играть в карточную игру из предыдущего раунда, Гена и Чебурашка (как Вы, возможно, помните — тоже обитатели Тридевятого царства) решили бросить скучные карточные игры и поиграть в солдатиков.

Правила игры следующие: есть боевая площадка n × m клеток, на некоторых клетках которой стоят игрушечные солдатики (зеленые принадлежат Крокодилу Гены, а красные — Чебурашке), причем на каждой из n линий площадки стоит не более двух солдатиков. Своим ходом игрок должен выбрать не менее 1 и не более k солдатиков, принадлежащих ему, и совершить ими либо наступление, либо отступление.

Наступление — это перемещение всех выбранных солдатиков вдоль линий, на которых они стоят, по направлению к вражескому солдатику, если он в этой линии есть. Если на данной линии нет вражеского солдатика — солдатик на данной линии во время хода может перемещаться в любом направлении. Каждый выбранный солдатик должен переместиться хотя бы на одну клетку, при этом разные солдатики могут переместиться на разное количество клеток. В процессе наступления солдатикам не разрешено пересекать клетки, в которых стоят (или стояли непосредственно перед наступлением) другие солдатики, выходить за пределы боевой площадки, а также по окончании наступления стоять в клетках, на которых стоят (или стояли непосредственно перед наступлением) другие солдатики.

Отступление — это перемещение всех выбранных солдатиков вдоль линий, на которых они стоят, по направлению от вражеского солдатика, если он в этой линии есть. Остальные правила отступления полностью повторяют наступление.

Например, пусть первоначально боевая площадка имела вид (здесь символами «G» обозначены солдатики Крокодила Гены, а символами «R» — солдатики Чебурашки):

-G-R-
-R-G-

Пусть k = 2 и ходит Крокодил Гена. Если он решит совершить наступление, то после него боевая площадка может принять вид:

--GR-     --GR-     -G-R-
-RG-- -R-G- -RG--

Если в предыдущем примере Крокодил Гена решит совершить отступление, то после него боевая площадка может принять вид:

G--R-     G--R-     -G-R-
-R--G -R-G- -R--G

С другой стороны, следующие площадки не могут быть получены в результате корректного хода Крокодила Гены:

G--R-     ---RG     --GR-
-RG-- -R-G- GR---

Начинает игру Крокодил Гена. Ход состоит в проведении наступления или отступления согласно правилам. Игрок, который не может сделать ход, проигрывает, а его соперник считается победителем. Определите победителя заданной партии в «Солдатиков», если Крокодил Гена и Чебурашка продолжают находиться под воздействием желтых таблеточек из задачи прошлого тура и всегда играют оптимально (то есть стараются выиграть, если это возможно, либо свести игру в ничью, сделав так, чтобы она продолжалась бесконечно, при невозможности выиграть).

Входные данные

В первой строке записаны через пробел целые числа n, m и k (1 ≤ n, m, k ≤ 100). Далее в n строках записано по m символов из множества {«-», «G», «R»}, обозначающих, соответственно, свободную клетку боевой площадки, клетку, занятую солдатиком Крокодила Гены и клетку, занятую солдатиком Чебурашки.

Гарантируется, что в каждой строке находится не более двух солдат.

Выходные данные

Выведите «First» (без кавычек), если в заданной партии в «Солдатиков» победит Крокодил Гена, «Second» (без кавычек), если победит Чебурашка, либо «Draw» (также без кавычек) в случае, если игра будет продолжаться бесконечно.

A. Arena of Greed

жадные алгоритмы игры *1400

Lately, Mr. Chanek frequently plays the game Arena of Greed. As the name implies, the game's goal is to find the greediest of them all, who will then be crowned king of Compfestnesia.

The game is played by two people taking turns, where Mr. Chanek takes the first turn. Initially, there is a treasure chest containing \(N\) gold coins. The game ends if there are no more gold coins in the chest. In each turn, the players can make one of the following moves:

  • Take one gold coin from the chest.
  • Take half of the gold coins on the chest. This move is only available if the number of coins in the chest is even.

Both players will try to maximize the number of coins they have. Mr. Chanek asks your help to find the maximum number of coins he can get at the end of the game if both he and the opponent plays optimally.

Input

The first line contains a single integer \(T\) \((1 \le T \le 10^5)\) denotes the number of test cases.

The next \(T\) lines each contain a single integer \(N\) \((1 \le N \le 10^{18})\).

Output

\(T\) lines, each line is the answer requested by Mr. Chanek.

Note

For the first case, the game is as follows:

  1. Mr. Chanek takes one coin.
  2. The opponent takes two coins.
  3. Mr. Chanek takes one coin.
  4. The opponent takes one coin.

For the second case, the game is as follows:

  1. Mr. Chanek takes three coins.
  2. The opponent takes one coin.
  3. Mr. Chanek takes one coin.
  4. The opponent takes one coin.

H. Побег из тюрьмы

Бинарный поиск геометрия игры Тернарный поиск *3500

Заключенный хочет сбежать из тюрьмы. Тюрьма является внутренней частью выпуклого многоугольника с вершинами \(P_1, P_2, P_3, \ldots, P_{n+1}, P_{n+2}, P_{n+3}\). Известно, что \(P_1=(0,0)\), \(P_{n+1}=(0, h)\), \(P_{n+2}=(-10^{18}, h)\) и \(P_{n+3}=(-10^{18}, 0)\).

Стены тюрьмы \(P_{n+1}P_{n+2}\), \(P_{n+2}P_{n+3}\) и \(P_{n+3}P_1\) очень высокие, и заключенный не может на них взобраться. Следовательно, его единственный шанс  — это достичь точки на одной из стен \(P_1P_2, P_2P_3,\dots, P_{n}P_{n+1}\) и сбежать оттуда. По периметру тюрьмы находятся два охранника. Заключенный движется со скоростью \(1\), в то время как охранники движутся, всегда оставаясь на периметре тюрьмы, со скоростью \(v\).

Если заключенный достигает точки на периметре, где есть охранник, охранник убивает заключенного. Если заключенный достигает точки, на которую он может взобраться, и там нет охранника, то он сразу же убегает. Изначально заключенный находится в точке \((-10^{17}, h/2)\), а охранники  — в точке \(P_1\).

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

Замечания:

  • В любой момент охрана и заключенный могут видеть друг друга.
  • Залезание на стену не занимает времени.
  • Вы можете считать, что и заключенный, и охранники могут изменить направление и скорость мгновенно и что они оба имеют идеальные рефлексы (так что они могут мгновенно реагировать на то, что делает другой).
  • Оба охранника могут заранее спланировать, как реагировать на передвижения заключенного.
Входные данные

Первая строка ввода содержит \(n\) (\(1 \le n \le 50\)).

Следующие \(n+1\) строк описывают точки \(P_1, P_2,\dots, P_{n+1}\). В \(i\)-й из этих строк находятся два целых числа \(x_i\), \(y_i\) (\(0\le x_i, y_i\le 1,000\))  — координаты \(P_i=(x_i, y_i)\).

Гарантируется, что \(P_1=(0,0)\) и \(x_{n+1}=0\). Гарантируется, что многоульник с вершинами \(P_1,P_2,\dots, P_{n+1}, P_{n+2}, P_{n+3}\) (где \(P_{n+2}, P_{n+3}\) построены так, как в условии) является выпуклым, и что никакие 3 его вершины не лежат на одной прямой.

Выходные данные

Выведите одно действительное число  — минимальную скорость \(v\), которая позволяет охранникам гарантировать, что заключенный не сбежит. Ваш ответ будет считаться правильным, если его относительная или абсолютная погрешность не превысит \(10^{-6}\).

G. Игра с удалением чисел

*особая задача дп жадные алгоритмы игры *2100

Алиса и Боб играют в игру. У них есть множество, который изначально состоит из \(n\) целых чисел. Игра длится \(k\) ходов. Во время каждого хода происходит следующее:

  1. сначала Алиса выбирает целое число из множества. Она может выбрать любое целое число кроме максимального. Пусть целое число, выбранное Алисой, равно \(a\);
  2. затем Боб выбирает целое число из множества. Он может выбрать любое целое число которое больше \(a\). Пусть целое число, выбранное Бобом, равно \(b\);
  3. наконец, и \(a\), и \(b\) удаляются из множества, а значение \(b - a\) добавляется к счету игры.

Изначально счет игры равен \(0\). Алиса хочет максимизировать итоговый счет, а Боб хочет минимизировать его. Предположив, что и Алиса, и Боб играют оптимально, вычислите итоговый счет игры.

Входные данные

Первая строка содержит два целых числа \(n\) и \(k\) (\(2 \le n \le 400\), \(1 \le k \le \lfloor\frac{n}{2}\rfloor\)) — начальный размер множества и количество ходов в игре.

Вторая строка содержит \(n\) целых чисел \(a_1, a_2, \dots, a_n\) (\(1 \le a_i \le 10^6\)) — стартовое содержимое множества. Это попарно различные целые числа.

Выходные данные

Выведите одно целое число — итоговый счет игры (при условии, что и Алиса, и Боб играют оптимально).

E. Выпуклая игра

игры снм *3500

Шикамару и Асума любят играть в различные игры, и очень часто они играют в следующую игру. У них есть список возрастающих чисел, и они по очереди делают ходы. Каждый ход — это выбор числа из списка. Пусть в процессе игры последовательно были выбраны числа \(v_{i_1}\), \(v_{i_2}\), \(\ldots\), \(v_{i_k}\). Числа должны удовлетворять следующим правилам:

  • \(i_{j} < i_{j+1}\), если \(1 \leq j \leq k-1\);
  • \(v_{i_{j+1}} - v_{i_j} < v_{i_{j+2}} - v_{i_{j+1}}\), если \(1 \leq j \leq k-2\).

Но поскольку играть в одну игру просто, то сегодня Шикамару и Асума решили сыграть в \(n\) игр одновременно. Они договорились, что ходить они также будут по очереди, причем начинает Шикамару. Делать ход разрешается в любой из игр, где это еще возможно. Проигрывает тот, кто не может сделать ход ни в одной из игр. Необходимо определить, кто выиграет при оптимальной игре обоих игроков.

Входные данные

В первой строке дано число \(n\) (\(1 \leq n \leq 1000\)) — количество игр. В следующих строках содержатся описания игр.

В первой строке описания каждой игры содержится число \(m\) (\(m\geq 1\)) — количество чисел в игре.

В следующей строке содержится последовательность целых чисел \(v_1\), \(v_2\), ..., \(v_m\) через пробел (\(1 \leq v_{1} < v_{2} < ... < v_{m} \leq 10^{5}\)).

Сумма длин последовательностей во всех играх не превосходит \(10^5\).

Выходные данные

Необходимо вывести «YES», если Шикамару может выиграть при оптимальной игре, и «NO» иначе.

Примечание

В первом примере Шикамару может сделать ход в последнее число. Тогда Асума не сможет сделать ход из-за первого условия и проиграет.

Во втором примере куда бы ни делал ход Шикамару, Асума всегда может сделать такой же ход в другой игре, поэтому Асума выиграет.

E. Поступи нечестно и выиграй

битмаски Деревья игры Структуры данных *3500

Рассмотрим таблицу \((10^9+1) \times (10^9+1)\). Строки пронумерованы целыми числами от \(0\) до \(10^9\), и столбцы пронумерованы целыми числами от \(0\) до \(10^9\). Обозначим за \((x, y)\) клетку, расположенную в строке \(x\) в столбце \(y\).

Давайте назовем клетку \((x, y)\) хорошей, если \(x \& y = 0\), где \(\&\) — это операция побитового И.

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

Два игрока играют в игру. Изначально некоторые хорошие клетки черные, а остальные белые. Каждый игрок на своем ходе выбирает черную хорошую клетку и подмножество ее предков (возможно пустое) и инвертирует их цвета (с белого на черный и наоборот). Игрок, который не может сделать ход (потому что все хорошие клетки белые), проигрывает. Можно доказать, что эта игра конечна.

Изначально все клетки белые. Вам дано \(m\) пар клеток. Для каждой пары клеток все клетки на простом пути между клетками в паре красятся в черный цвет. Обратите внимание, что эти цвета не инвертируются, а мы красим клетки в черный цвет.

Sohrab и Mashtali собираются сыграть в эту игру. Sohrab будет первым игроком, а Mashtali вторым.

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

Mammad, который наблюдает за ними, задался вопросом: «какое минимальное количество операций должен сделать Mashtali, чтобы иметь выигрышную стратегию?».

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

Входные данные

В первой строке находится единственное целое число \(m\) (\(1 \leq m \leq 10^5\)).

Каждая из следующих \(m\) строк содержит четыре целых числа \(x_{1}\), \(y_{1}\), \(x_{2}\), \(y_{2}\) (\(0 \leq x_i, y_i \leq 10^9\), \(x_i \& y_i = 0\)). Вы должны покрасить все вершины на пути между \((x_1, y_1)\) и \((x_2, y_2)\) в черный цвет.

Выходные данные

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

Примечание

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

Во втором тесте вы можете сделать нечестные операции в клетками \((0, 2), (0, 0), (3, 4)\).

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

D. Игра в круге

геометрия игры математика *1700

Utkarsh снова заставили играть в игры Ashish. Игроки ходят по очереди, Ashish ходит первым.

Рассмотрим плоскость. На нем стоит фишка, исходно в точке \((0,0)\). За один ход игрок может увеличить либо \(x\) координату, либо \(y\) координату фишки ровно на \(k\). Делая эти операции, игрок должен убедиться, что фишка остается в пределах (Евклидового) расстояния \(d\) от \((0,0)\).

Иначе говоря, если после хода координаты фишки \((p,q)\), должно быть выполнено \(p^2 + q^2 \leq d^2\).

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

Входные данные

В первой строке записано одно целое число \(t\) (\(1 \leq t \leq 100\)) — количество наборов входных данных.

Первая строка каждого набора входных данных содержит два целых числа \(d\) (\(1 \leq d \leq 10^5\)) и \(k\) (\(1 \leq k \leq d\)).

Выходные данные

Для каждого набора входных данных, если выигрывает первый игрок, выведите «Ashish». Иначе выведите «Utkarsh» (без кавычек).

Примечание

Возможная последовательность действий для первого набора входных данных:

\((0, 0) \xrightarrow{\text{Ashish }} (0, 1) \xrightarrow{\text{Utkarsh }} (0, 2)\).

Ashish не может сделать ход, так что Utkarsh выигрывает.

F. Обнулить матрицу

игры Конструктив *2700

Jeel и Ashish играют в игру на матрице \(n \times m\). Строки пронумерованы от \(1\) до \(n\) сверху вниз, а столбцы пронумерованы от \(1\) до \(m\) слева направо. Они ходят по очереди. Ashish ходит первым.

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

  • Выбрать стартовую клетку \((r_1, c_1)\) с ненулевым значением.
  • Выбрать финишную клетку \((r_2, c_2)\) так, что \(r_1 \leq r_2\) и \(c_1 \leq c_2\).
  • Уменьшить значение в стартовой клетке на положительное целое число.
  • Выбрать любой кратчайший путь между двумя клетками и уменьшить/увеличить/не изменить все клетки на этом пути. Обратите внимание, что:
    • кратчайший путь это путь, который проходит по наименьшему числу клеток;
    • все клетки на этом пути не включают стартовую клетку, но финишная клетка может быть изменена;
    • итоговое значение каждой клетки должно быть неотрицательным целым числом;
    • клетки изменяются независимо, не обязательно на одно и то же число.

Если стартовая и финишная клетки совпадают, то, следуя правилам, значение этой клетки уменьшается. Никаких других операций не выполняется.

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

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

Входные данные

В первой строке записано одно целое число \(t\) (\(1 \leq t \leq 10\)) — количество наборов входных данных. Далее следуют описания наборов входных данных.

В первой строке каждого набора входных данных записаны два целых числа \(n\) и \(m\) (\(1 \leq n, m \leq 100\)) — размерности матрицы.

В каждой из следующих \(n\) строк записаны \(m\) разделенных пробелами целых чисел \(a_{i,j}\) (\(0 \leq a_{i,j} \leq 10^6\)) — значения клеток матрицы.

Выходные данные

Для каждого набора входных данных, если первый игрок выиграет, выведите «Ashish». Иначе выведите «Jeel» (без кавычек).

Примечание

В первом наборе входных данных единственная клетка матрицы это 0, первый игрок не может сделать хода. Jeel побеждает.

Во втором наборе входных данных Ashish может выбрать \((r_1, c_1) = (r_2, c_2) = (1,3)\) и уменьшить значение клетки до \(0\), оставляя \([0, 0, 0]\). Jeel не может сделать хода. Ashish побеждает.

C. Пинг-понг

игры Конструктив математика *1100

Алиса и Боб играют в пинг-понг по упрощенным правилам.

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

Тот, кто не отбивает удар, проигрывает этот раунд. Победитель раунда начинает следующий раунд. Алиса начинает первый раунд.

У Алисы \(x\) выносливости, а у Боба \(y\). Чтобы ударить по мячу (при подаче или отбивании), каждый игрок тратит \(1\) выносливости, поэтому, если у него нулевая выносливость, он не может отбить мяч (и проигрывает раунд) или не может подать мяч (в этом случае подача мяча переходит к другому игроку). Если у обоих игроков закончилась выносливость, игра окончена.

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

И Алиса, и Боб играют оптимально и хотят, во-первых, максимизировать свое количество побед а, во-вторых, минимизировать количество побед своего противника.

Подсчитайте итоговое число побед Алисы и Боба.

Входные данные

Первая строка содержит одно целое число \(t\) (\(1 \le t \le 10^4\)) — количество наборов входных данных.

Первая и единственная строка каждого набора содержит два целых числа \(x\) и \(y\) (\(1 \le x, y \le 10^6\)) — выносливость Алисы и Боба.

Выходные данные

Для каждого набора входных данных выведите два целых числа — итоговое число побед Алисы и Боба, если они оба играют оптимально.

Примечание

В первом примере Алиса подает мяч и тратит \(1\) выносливости. Затем Боб отбивает мяч и также тратит \(1\) выносливости. Алиса не может отбить мяч, так как у нее не осталось выносливости, и она проигрывает раунд. У них обоих закончилась выносливость, так что игра закончилась с \(0\) побед у Алисы и \(1\) победой Боба.

Во втором примере Алиса подает мяч и тратит \(1\) выносливости. Боб решает не отбивать мяч — он проигрывает раунд, но сохраняет выносливость. Алиса, как победитель последнего раунда, подает мяч в следующем и тратит еще \(1\) выносливости. На этот раз Боб отбивает мяч и тратит \(1\) выносливости. У Алисы не осталось сил, поэтому она не может отбить мяч и проигрывает раунд. У них обоих закончилась выносливость, так что игра закончилась с \(1\) победой у Алисы и \(1\) победой у Боба.

В третьем примере Алиса подает мяч и тратит \(1\) выносливости. Боб отбивает мяч и тратит \(1\) выносливости. У Алисы кончилась выносливость, поэтому она не может отбить мяч и проигрывает раунд. Боб, как победитель, подает мяч в следующих \(6\) раундах. Каждый раз Алиса не может отбить мяч и проигрывает каждую раунд. Игра заканчивается с \(0\) побед у Алисы и \(7\) победами у Боба.

E. Ним с секретами

игры Структуры данных *3100

После успеха вашей первой мобильной игры «Ним» вы решили выпустить сиквел под названием «Ним 2». Новая игра будет развивать успех проверенной формулы Нима, и добавит столь ожидаемую пользователями вторую кучку!

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

Чтобы упростить тестирование игры, вы добавили секреты, известные только разработчику. Есть \(n\) секретных позиций \((x_1, y_1), \ldots, (x_n, y_n)\), которые влияют на игру следующим образом. Пусть перед ходом одного из игроков первая и вторая кучка содержат \(x\) и \(y\) камней соответственно. Если пара чисел \((x, y)\) совпадает с одной из пар \((x_i, y_i)\), то игрок, который должен ходить следующим, немедленно проигрывает, в противном случае этот игрок ходит как обычно. Обратите внимание, что в описании выше кучки и все пары упорядочены, то есть, \(x\) обязательно означают размер первой кучки, а \(y\) обязательно означают размер второй кучки.

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

Входные данные

В первой строке записано два целых числа \(n\) и \(m\) (\(1 \leq n, m \leq 10^5\)) — количество секретных позиций и количество исходных позиций для оценки соответственно.

Следующие \(n\) строк описывают секретные позиции. В \(i\)-й из этих строк записано два целых числа \(x_i, y_i\) (\(0 \leq x_i, y_i \leq 10^9\)). Гарантируется, что все секретные позиции различны.

Следующие \(m\) строк описывают исходные позиции. В \(i\)-й из этих строк записано два целых числа \(a_i, b_i\) (\(0 \leq a_i, b_i \leq 10^9\)) — количество камней в первой и второй кучке соответственно. Гарантируется, что все исходные позиции различны. Однако, некоторые исходные позиции могут совпадать с секретными позициями.

Выходные данные

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

D. Четно-нечётная игра

дп жадные алгоритмы игры сортировки *1200

Во время своих новогодних каникул Алиса и Боб играют в следующую игру, используя массив \(a\) из \(n\) целых чисел:

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

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

Например, если \(n = 4\) и \(a = [5, 2, 7, 3]\), то игра могла пройти следующим образом (существуют и другие варианты):

  • Первым ходом Алиса выбрала число \(2\) и получила два очка. Ее результат теперь равен \(2\). Массив \(a\) становится равным \([5, 7, 3]\).
  • Вторым ходом Боб выбрал число \(5\) и получил пять очков. Его результат теперь равен \(5\). Массив \(a\) становится равным \([7, 3]\).
  • Третьим ходом Алиса выбрала число \(7\) и не получила очков. Ее результат теперь равен \(2\). Массив \(a\) становится равным \([3]\).
  • Последним ходом Боб выбрал число \(3\) и получил три очка. Его результат теперь равен \(8\). Массив \(a\) становится пустым.
  • Так как у Боба на конец игры больше очков, он объявлется победителем.

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

Входные данные

В первой строке находится целое число \(t\) (\(1 \le t \le 10^4\)) — количество наборов входных данных. Далее следуют \(t\) наборов входных данных.

В первой строке каждого набора содержится целое число \(n\) (\(1 \le n \le 2 \cdot 10^5\)) — количество элементов в массиве \(a\).

В следующей строке находится \(n\) целых чисел \(a_1, a_2, \ldots, a_n\) (\(1 \le a_i \le 10^9\)) — массив \(a\), с помощью которого проводится игра.

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

Выходные данные

Для каждого набора входных данных в отдельной строке выведите:

  • «Alice», если при оптимальной игре выиграет Алиса;
  • «Bob», если при оптимальной игре выиграет Боб;
  • «Tie», если при оптимальной игре будет объявлена ничья.

D. Мешок мышек

дп игры математика Теория вероятностей *1800

Дракон и принцесса решают, что делать в новогоднюю ночь: дракон предлагает лететь в горы любоваться танцами фей под луной, а принцесса — лечь спать пораньше. Договориться полюбовно они отчаялись и решили отдаться на волю случая.

Они по очереди тянут мышек из мешка, в котором изначально w белых и b черных мышек, и выигрывает тот, кто первым достает белую мышь. После каждой вытянутой драконом мыши оставшиеся впадают в панику, и одна из них выпрыгивает из мешка сама (принцесса вытаскивает мышей из мешка аккуратно и не пугает их). Принцесса тянет первой. Какова вероятность ее победы?

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

Входные данные

В единственной строке входных данных записано два целых числа w и b (0 ≤ w, b ≤ 1000).

Выходные данные

Выведите вероятность победы принцессы. Ответ считается правильным, если абсолютная или относительная погрешность не превосходит 10 - 9.

Примечание

Рассмотрим подробнее первый тест. С вероятностью 1/4 принцесса вытащит белую мышь сразу же и выиграет. С вероятностью 3/4 * 2/3 = 1/2 после этого дракон вытащит черную мышь и не выиграет; затем в мешке останется одна белая и одна черная мышь, одна из которых выпрыгнет, а вторая достанется принцессе в ее второй ход. Если оставшаяся мышь белая, выигрывает принцесса (вероятность 1/2 * 1/2 = 1/4), иначе мыши заканчиваются, и по правилам выигрывает дракон.

A. Еще одна игра со строкой

жадные алгоритмы игры Строки *800

У Гомера есть два друга — Алиса и Боб. Оба они фанаты строк.

Однажды Алиса и Боб решили сыграть в игру на строке \(s = s_1 s_2 \dots s_n\) длиной \(n\), состоящей из строчных английских букв. Они ходят по очереди, Алиса начинает.

В свой ход игрок должен выбрать индекс \(i\) (\(1 \leq i \leq n\)), который не был выбран ранее, и поменять \(s_i\) на любую другую строчную английскую букву \(c\), удовлетворяющую \(c \neq s_i\).

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

Цель Алисы — сделать финальную строку лексикографически как можно меньше, в то время как цель Боба — сделать финальную строку лексикографически как можно больше. Оба они являются профессиональными игроками, поэтому всегда играют оптимально. Гомер не является профессиональным игроком, поэтому ему интересно, какой будет финальная строка.

Строка \(a\) лексикографически меньше строки \(b\), если и только если выполняется один из следующих пунктов:

  • \(a\)  — префикс \(b\), но \(a \ne b\);
  • в первой позиции, где \(a\) и \(b\) различны, в строке \(a\) находится буква, которая встречается в алфавите раньше, чем соответствующая буква в \(b\).
Входные данные

Каждый тест содержит несколько наборов входных данных. Первая строка содержит \(t\) (\(1 \le t \le 1000\))  — количество наборов входных данных. Описание наборов входных данных приведено ниже.

Единственная строка каждого набора входных данных содержит одну строку \(s\) (\(1 \leq |s| \leq 50\)), состоящую из строчных английских букв.

Выходные данные

Для каждого набора входных данных выведите финальную строку в отдельной строке.

Примечание

В первом наборе входных данных: Алиса делает первый ход и должна поменять единственную букву на другую, поэтому она меняет ее на «b».

Во втором наборе входных данных: Алиса меняет первую букву на «a», затем Боб меняет вторую букву на «z», Алиса меняет третью букву на «a», а затем Боб меняет четвертую букву на «z».

В третьем наборе входных данных: Алиса меняет первую букву на «b», а затем Боб меняет вторую букву на «y».

B. Идем в поход!

жадные алгоритмы игры *1900

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

На листочке записана перестановка \(p\). Сначала Циншань выбирает индекс \(x\) (\(1\le x\le n\)) и сообщает его Даниэлю. После этого Даниэль выбирает другой индекс \(y\) (\(1\le y\le n\), \(y \ne x\)).

Далее начинается игра, в которой они ходят по-очереди, Циншань ходит первой. Правила следующие:

  • В свой ход Циншань должна изменить значение \(x\) на \(x'\) так, что одновременно выполняются условия \(1\le x'\le n\), \(|x'-x|=1\), \(x'\ne y\) и \(p_{x'}<p_x\).
  • В свой ход Даниэль должен изменить значение \(y\) на \(y'\) так, что одновременно выполняются условия \(1\le y'\le n\), \(|y'-y|=1\), \(y'\ne x\) и \(p_{y'}>p_y\).

Игрок, который не может сделать ход, проигрывает, а другой игрок выигрывает. Вы болеете за Циншань и должны определить, сколько существует различных способов выбрать в начале \(x\) так, чтобы Циншань выигрывала при условии, что оба игрока играют оптимально.

Входные данные

Первая строка содержит единственное целое число \(n\) (\(2\le n\le 10^5\)) — длину перестановки.

Вторая строка содержит \(n\) различных целых чисел \(p_1,p_2,\dots,p_n\) (\(1\le p_i\le n\)) — числа перестановки.

Выходные данные

Выведите количество способов выбрать \(x\) в начале игры так, чтобы выигрывала Циншань.

Примечание

В первом тесте Циншань для выигрыша обязана выбрать \(x=3\), поэтому ответ равен \(1\).

Во втором тесте если Циншань выберет \(x=4\), Даниэль может выбрать \(y=1\). На первом ходу (ходит Циншань) Циншань выберет \(x'=3\) и поменяет \(x\) на \(3\). На втором ходу (ходит Даниэль) Даниэль выберет \(y'=2\) и поменяет \(y\) на \(2\). Далее Циншань не сможет выбрать \(x'=2\), потому что \(y=2\) в текущий момент. Поэтому Циншань проиграет.

F. Рождественская игра

битмаски Деревья дп игры математика поиск в глубину и подобное Структуры данных *2500

Алиса и Боб собираются отмечать Рождество, играя в игру с деревом подарков. Дерево состоит из \(n\) вершин (пронумерованных от \(1\) до \(n\), вершина \(r\) является корнем). На \(i\)-й вершине висят \(a_i\) подарков.

Перед началом игры выбирается некоторое целое число \(k\). Затем игра проходит следующим образом:

  • Алиса начинает игру, затем ходы совершаются обоими игроками по очереди;
  • на каждом ходу текущий игрок выбирает некоторую вершину (например, \(i\)), которая находится на глубине хотя бы \(k\). Затем игрок снимает некоторое положительное целое число подарков, которые висят на этой вершине, — назовем его \(m\) \((1 \le m \le a_i)\);
  • затем игрок вешает эти \(m\) подарков на \(k\)-го предка (назовем его \(j\)) \(i\)-й вершины (\(k\)-м предком вершины \(i\) назовем такую вершину \(j\), что \(i\) — потомок \(j\), а глубина \(j\) ровно на \(k\) меньше глубины \(i\)). Теперь количество подарков на \(i\)-й вершине \((a_i)\) уменьшилось на \(m\), а \(a_j\), соответственно, увеличилось на \(m\);
  • Алиса и Боб играют оптимально. Тот, кто не может совершить ход, проигрывает.

Для каждого возможного корня дерева сообщите, кто выиграет игру — Алиса или Боб.

Глубина вершины \(i\) в дереве с корнем \(r\) определяется, как количество ребер на простом пути из вершины \(r\) до вершины \(i\). Глубина корня \(r\) равна нулю.

Входные данные

В первой строке записаны два целых числа \(n\) и \(k\) \((3 \le n \le 10^5, 1 \le k \le 20)\).

В каждой из следующих \(n-1\) строк записаны два целых числа \(x\) и \(y\) \((1 \le x, y \le n, x \neq y)\), описывающие неориентированное ребро между двумя вершинами \(x\) и \(y\). Эти ребра образуют дерево из \(n\) вершин.

В следующей строке записаны \(n\) целых чисел, задающих массив \(a\) \((0 \le a_i \le 10^9)\).

Выходные данные

Выведите \(n\) целых чисел, где \(i\)-е число равно \(1\), если Алиса выиграет игру, если дерево подвешено за вершину \(i\), и \(0\) в противном случае.

Примечание

Посчитаем ответ для примера с корнем в 1 и в 2.

Корень 1

Алиса всегда выигрывает в данном случае. Возможная игра между Алисой и Бобом выглядит так:

  • Алиса перемещает один подарок из вершины 4 в вершину 3.
  • Боб перемещает четыре подарка из вершины 5 в вершину 2.
  • Алиса перемещает четыре подарка из вершины 2 в вершину 1.
  • Боб перемещает три подарка из вершины 2 в вершину 1.
  • Алиса перемещает три подарка из вершины 3 в вершину 1.
  • Боб перемещает три подарка из вершины 4 в вершину 3.
  • Алиса перемещает три подарка из вершины 3 в вершину 1.

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

Корень 2

Боб всегда выигрывает в данном случае. Пример игры:

  • Алиса перемещает четыре подарка из вершины 4 в вершину 3.
  • Боб перемещает четыре подарка из вершины 5 в вершину 2.
  • Алиса перемещает шесть подарков из вершины 3 в вершину 1.
  • Боб перемещает шесть подарков из вершины 1 в вершину 2.

Алиса не может сделать ход, а потому проигрывает.

C. Промышленный Ним

игры *2000

В городе Петрограде есть n камнедобывающих предприятий.

В каждом из них стоит в ряд mi самосвалов (1 ≤ i ≤ n). Известно, что в первом самосвале i-го предприятия лежит xi камней. Во втором самосвале xi + 1 камень, в третьем xi + 2, в mi-ом (последнем для i-го предприятия) xi + mi - 1 камней.

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

Олигархи пожелали остаться неизвестными, но так как вам придется предугадывать, кто из них станет победителем при правильной игре, то если выиграет олигарх, который ходит первым, выведите «tolik», иначе «bolik».

Входные данные

В первой строке входных данных находится число n (1 ≤ n ≤ 105) — количество предприятий. Далее перечислено n строк, в которых записано по два числа — количество камней xi (1 ≤ xi ≤ 1016) в первом самосвале i-го предприятия и количество самосвалов i-го предприятия mi (1 ≤ mi ≤ 1016).

Выходные данные

Выведите «tolik», если выиграл первый олигарх, иначе — «bolik».

A. Победи или замерзни

игры математика теория чисел *1400

Вы даже не представляете себе, как же холодно нашим друзьям этой зимой в городе XXXводске! Чтобы согреться, двое из них играют в следующую игру. Изначально на бумажке написано одно целое число q. Своим ходом игрок должен написать любое число, являющееся нетривиальным делителем последнего из написанных чисел, после чего он должен столько раз пробежать вокруг гостиницы. Напоминаем, что делитель числа называется нетривиальным, если он отличен от единицы и от самого делимого числа.

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

Входные данные

В первой строке записано единственное целое число q (1 ≤ q ≤ 1013).

Пожалуйста, не используйте спецификатор %lld для чтения или записи 64-х битовых чисел на С++. Рекомендуется использовать потоки cin, cout или спецификатор %I64d.

Выходные данные

В первой строке выведите номер игрока-победителя (1 или 2). Если побеждает первый игрок, то во второй строке должно находиться еще одно целое число — его первый ход (если первый игрок не может сделать даже первый ход, выведите 0). Если решений несколько, выведите любое.

Примечание

Число 6 имеет только два нетривиальных делителя: 2 и 3. Из чисел 2 и 3 ходов сделать уже нельзя, поэтому они оба являются выигрышными, а значит число 6 проигрышное. Из числа 30 можно сделать ход в число 6, которое, как мы уже знаем, проигрышное, значит этот ход принесет нам победу.

B. 3-раскраска

игры интерактив Конструктив *1700

Это интерактивная задача.

Алиса и Боб играют в игру. Есть доска \(n\times n\), изначально пустая. Мы будем обозначать ячейку в строке \(i\) и столбце \(j\) как \((i, j)\) для \(1\le i, j\le n\). Также, есть бесконечный запас фишек \(3\) цветов, обозначенных \(1\), \(2\) и \(3\).

Алиса и Боб ходят по очереди по следующим правилам: каждый ход начинается с того, что Алиса называет один из трех цветов, назовем его \(a\). Затем Боб выбирает цвет \(b\ne a\), выбирает пустую ячейку и помещает на нее фишку цвета \(b\).

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

Если в какой-то момент возникает конфликт, Алиса побеждает. В противном случае, если было совершено \(n^2\) ходов (так что доска полностью заполнилась) без конфликтов, побеждает Боб.

У нас есть доказательство того, что у Боба есть выигрышная стратегия. Сыграйте в игру за Боба и выиграйте.

Интерактор адаптивен. Таким образом, выбор цвета Алисой может зависеть от предыдущих ходов Боба.

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

Взаимодействие начинается с чтения единственного целого числа \(n\) (\(2\le n\le 100\)) — размера доски.

Дальше начинаются ходы. Каждый ход следует начинать с чтения целого \(a\) (\(1\le a\le 3\)) — выбранного цвета Алисы.

Затем необходимо вывести три целых числа \(b,i,j\) (\(1\le b\le 3,b\ne a, 1\le i,j\le n\)) —, что означает, что Боб кладет в ячейку \((i, j)\) фишку цвета \(b\). Ячейка \((i, j)\) не должна содержать фишки из предыдущих ходов. Если ваш ход недействителен или проигрывает партию, взаимодействие прекратится и вы получите вердикт Неправильный ответ.

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

После вывода запроса не забудьте вывести перевод строки и сбросить буфер вывода. В противном случае вы получите вердикт Решение «зависло». Для сброса буфера используйте:

  • fflush(stdout) или cout.flush() в C++;
  • System.out.flush() в Java;
  • flush(output) в Pascal;
  • stdout.flush() в Python;
  • смотрите документацию для других языков.

Формат взломов

Для взлома используйте следующий формат.

Первая строка содержит одно целое число \(n\) (\(2\le n\le 100\)).

Вторая строка содержит \(n^2\) целых чисел \(a_1,\ldots,a_{n^2}\) (\(1\le a_i\le 3\)), где \(a_i\) обозначает цвет Алисы на \(i\)-м ходу игры.

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

Примечание

Конечное состояние доски из примера изображено ниже. Боб выигрывает, потому что нет двух соседних ячеек с фишками одного и того же цвета. \(\)\begin{matrix}2&3\\3&1\end{matrix}\(\)

Пример приведен только для демонстрации входного и выходного формата. Не гарантируется, что он будет представлять оптимальную стратегию для Боба или реальное поведение интерактора.

G. Фишки на доске

битмаски дп игры Перебор Структуры данных *2700

У Алисы и Боба есть доска из \(n\) строк и \(m\) столбцов. В каждой строке есть ровно одна фишка.

Алиса и Боб играют в следующую игру. Они выбирают два целых числа \(l\) и \(r\), такие, что \(1 \le l \le r \le m\), и разрезают доску таким образом, что только столбцы с \(l\) по \(r\) (включительно) принадлежат доски. То есть все столбцы левее столбца \(l\) и все столбцы правее столбца \(r\) больше не являются частью доски.

После разрезания доски они начинают свою игру на оставшейся части доски (от столбца \(l\) до столбца \(r\)). Они ходят по очереди, и первый игрок, который не может сделать ход, проигрывает. Первый ход делает Алиса, второй — Боб, третий — снова Алиса, и так далее. Во время своего хода игрок должен выбрать одну из фишек и сдвинуть ее на любое количество столбцов влево (то есть, если фишка была в столбце \(i\), ее можно переместить в любой столбец \(j < i\), а фишки в самом левом столбце двигать нельзя). Фишки не должны покидать выбранную часть доски.

У Алисы и Боба есть \(q\) пар чисел \(L_i\) и \(R_i\). Для каждой такой пары они хотят определить, кто выиграет, если \(l = L_i\) и \(r = R_i\). Обратите внимание, что эти игры рассматриваются независимо (они не влияют на положение на доске в последующих играх), и оба игрока играют оптимально.

Входные данные

В первой строке заданы два целых числа \(n\) и \(m\) (\(1 \le n, m \le 2 \cdot 10^5\)) — количество строк и столбцов, соответственно.

Во второй строке заданы \(n\) целых чисел \(c_1, c_2, \dots, c_n\) (\(1 \le c_i \le m\)), где \(c_i\) — номер столбца, в котором расположена фишка в \(i\)-м ряду (то есть, такое число обозначает фишку в клетке на пересечении \(i\)-й строки и \(c_i\)-го столбца).

В третьей строке задано одно целое число \(q\) (\(1 \le q \le 2 \cdot 10^5\)).

Затем следуют \(q\) строк, в \(i\)-й строке заданы два целых числа \(L_i\) и \(R_i\) (\(1 \le L_i \le R_i \le m\)).

Выходные данные

Выведите строку из \(q\) символов. \(i\)-й символ должен быть A, если Алиса выигрывает при \(l = L_i\) и \(r = R_i\), или B, если выигрывает Боб.

B1. Игра на палиндроме (простая версия)

игры Конструктив *1200

Единственное отличие между простой и сложной версией заключается в том, что \(s\) в простой версии изначально является палиндромом, что не всегда верно в сложной версии.

Палиндромом называется строка, читающаяся одинаково слева направо и справа налево. Например, «101101» — палиндром, а «0101» — нет.

Алиса и Боб играют в игру со строкой \(s\) (которая изначально является палиндромом в простой версии) длины \(n\), состоящей из символов '0' и '1'. Оба игрока ходят по очереди, и Алиса делает первый ход.

За один ход игрок может сделать одну из следующих операций:

  1. Выбрать любое \(i\) (\(1 \le i \le n\)) такое, что \(s[i] =\) '0', заменить \(s[i]\) на '1' и заплатить 1 доллар, или
  2. Развернуть всю строку, заплатив 0 долларов. Эта операция доступна только в том случае, если сейчас строка не палиндром, и последняя операция была не разворотом. Это значит, что если Алиса развернула строку, то Боб не может развернуть ее следующим ходом, и наоборот.

Под разворотом строки подразумевается переупорядочивание символов от последнего к первому. Например, «01001» после разворота становится «10010».

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

Входные данные

Первая строка содержит целое число \(t\) (\(1 \le t \le 10^3\)). Далее следуют \(t\) наборов входных данных.

Первая строка каждого набора входных данных содержит целое число \(n\) (\(1 \le n \le 10^3\)).

Вторая строка набора содержит строку \(s\) длины \(n\), состоящую только из '0' и '1'. Гарантируется, что строка \(s\) палиндром и содержит минимум один '0'.

Обратите внимание, что ограничения на сумму \(n\) по всем наборам входных данных нет.

Выходные данные

Для каждого набора входных данных выведите ответ:

  • «ALICE», если Алиса побеждает,
  • «BOB», если Боб побеждает,
  • «DRAW», если игра закончится ничьей.
Примечание

В первом примере:

  • на \(1\)-м ходу Алиса обязана использовать \(1\)-ю операцию, так как строка — палиндром.
  • на \(2\)-м ходу Боб разворачивает строку.
  • на \(3\)-м ходу Алиса опять обязана использовать \(1\)-ю операцию. Теперь все символы '1', игра окончена.
Алиса тратит \(2\) доллара, а Боб \(0\). Таким образом, Боб побеждает.

B2. Игра на палиндроме (сложная версия)

игры Конструктив *1900

Единственное отличие между простой и сложной версией заключается в том, что \(s\) в простой версии изначально палиндром, что не всегда верно в сложной версии.

Палиндромом называется строка, читающаяся одинаково слева направо и справа налево. Например, «101101» — палиндром, а «0101» — нет.

Алиса и Боб играют в игру со строкой \(s\) длины \(n\) состоящей из символов '0' и '1'. Оба игрока ходят по очереди, и Алиса делает первый ход.

Каждый ход игрок может сделать одну из следующих операций:

  1. Выбрать любое \(i\) (\(1 \le i \le n\)) такое, что\(s[i] =\) '0' и заменить \(s[i]\) на '1'. Цена такого ходя 1 доллар.
  2. Развернуть всю строку, заплатив 0 долларов. Эта операция доступна только в том случае, если сейчас строка НЕ палиндром, и последняя операция была не разворотом. Это значит, что если Алиса развернула строк, тогда Боб не может развернуть ее следующим ходом, и наоборот.

Под разворотом строки подразумевается переупорядочивание символов от последнего к первому. Например, «01001» после разворота становится «10010».

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

Входные данные

Первая строка содержит целое число \(t\) (\(1 \le t \le 10^3\)). Далее следуют \(t\) наборов входных данных.

Первая строка каждого набора входных данных содержит целое число \(n\) (\(1 \le n \le 10^3\)).

Вторая строка набора содержит строку \(s\) длины \(n\), состоящую только из '0' и '1'. Гарантируется, что строка \(s\) содержит минимум один '0'.

Обратите внимание, что ограничения на сумму \(n\) по всем наборам входных данных нет.

Выходные данные

Для каждого набора входных данных выведите ответ:

  • «ALICE», если Алиса побеждает,
  • «BOB», если Боб побеждает,
  • «DRAW», если игра закончится ничьей.
Примечание

В первом примере,

  • на \(1\)-м ходу, Алиса использует \(2\)-ю операцию, чтобы развернуть строку, так как если она сделает \(1\)-ю операцию, то обязательно проиграет. Это заставляет Боба использовать \(1\)-ю операцию.
  • на \(2\)-м ходу Боб использует \(1\)-ю операцию, так как \(2\)-я не может быть использована два раза подряд. Все символы строки '1', игра окончена.
Алиса потратила \(0\) долларов, а Боб \(1\). Таким образом, Алиса победила.

Во втором примере,

  • на \(1\)-м ходу Алиса использует \(1\)-ю операцию, так как строка — палиндром.
  • на \(2\)-м ходу Боб разворачивает строку.
  • на \(3\)-м ходу Алиса должна использовать \(1\)-ю операцию. Все символы строки '1', игра окончена.
Алиса потратила \(2\) доллара, а Боб \(0\). Таким образом, Боб победил.

F. Омкар и Акмар

meet-in-the-middle бпф геометрия игры китайская теорема об остатках Комбинаторика Конструктив математика строковые суфф. структуры *2600

Омкар и Акмар играют в игру на круговой доске с \(n\) (\(2 \leq n \leq 10^6\)) клетками. Клетки пронумерованы от \(1\) до \(n\), для каждой \(i\) (\(1 \leq i \leq n-1\)) клетка \(i\) соседствует с клеткой \(i+1\), а клетка \(1\) соседствует с клеткой \(n\). Изначально каждая клетка пуста.

Омкар и Акмар по очереди выкладывают на доску букву A или B, причем Акмар ходит первым. Буква должна быть помещена на пустую клетку. Кроме того, буква не может быть помещена в такую клетку, что соседняя клетка содержит ту же букву.

Игрок проигрывает, когда наступает его очередь и больше нет допустимых ходов.

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

Две игры считаются разными, если количества ходов в них отличаются, или на каком-то ходу буква или номер клетки, на которую ставится буква, были разными.

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

Входные данные

Первая строка будет содержать целое число \(n\) (\(2 \leq n \leq 10^6\)) — количество клеток на доске.

Выходные данные

Выведите одно целое число, — количество возможных различных игр, в которых оба игрока играют оптимально по модулю \(10^9+7\).

Примечание

В первом примере первый игрок имеет \(4\) возможных хода. Независимо от того, как ходит первый игрок, у второго игрока есть ровно \(1\) возможный ход, поэтому существует \(4\) возможных игры.

D. Удаляя делители

игры математика теория чисел *1700

Алиса и Боб играют в игру.

Они начинают с целого положительного числа \(n\) и поочередно выполняют над ним операции. В свой игрок может вычесть из \(n\) один из его делителей, который не равен \(1\) или \(n\). Игрок, который не может сделать ход в свой ход, проигрывает. Алиса всегда ходит первой.

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

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

Входные данные

Первая строка содержит одно целое число \(t\) (\(1 \leq t \leq 10^4\)) — количество наборов входных данных. Затем следуют \(t\) наборов входных данных.

Каждый набор входных данных содержит одно целое число \(n\) (\(1 \leq n \leq 10^9\)) — начальное число.

Выходные данные

Для каждого набора входных данных выведите «Alice», если Алиса выиграет игру, или «Bob», если выиграет Боб, если оба игрока играют оптимально.

Примечание

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

Во втором наборе входных данных Алиса может вычесть \(2\), получив \(n = 2\), тогда Боб не сможет сделать ход, и Алиса выиграет.

В третьем наборе входных данных Алиса может вычесть \(3\), получив \(n = 9\). Единственный ход Боба — вычесть \(3\) и сделать \(n = 6\). Теперь Алиса может снова вычесть \(3\) и получить \(n = 3\). После этого Боб не может сделать ход, и Алиса выигрывает.

D. Флатландское фехтование

игры математика *2400

Король Флатландии проводит рыцарский турнир! Победителю достанется полцарства и расположение принцессы, о красоте и мудрости которой ходят легенды. Последней проверкой смелости и силы претендентов будет турнир по фехтованию. Турнир проходит по следующим правилам: участники сражаются один на один, победитель (а точнее, выживший) выходит в следующий круг соревнований.

Перед битвой оба участника становятся в указанные им точки оси Ox с целыми координатами. Затем они совершают ходы по очереди. Первым, естественно, ходит первый участник. На своем ходу первый участник из точки x может переместиться в любую целочисленную точку из отрезка [x + a; x + b], а второй — в любую целочисленную точку из отрезка [x - b; x - a], то есть варианты ходов для игроков симметричны (обратите внимание, что числа a и b не обязаны быть положительными; также, если a ≤ 0 ≤ b, то остаться на месте — корректный ход.) В любой момент участники могут располагаться произвольным образом друг относительно друга, то есть «перепрыгивать» через противника в любую сторону позволяется. Побеждает тот участник, который на своем ходу переместится в точку, где находится его противник.

Разумеется, принцесса уже выбрала себе жениха, и теперь она хочет сделать так, чтобы её избранник выиграл турнир. Он уже вышел в финал турнира, и ему осталась последняя битва. Принцесса просит управляющего турнира расположить участников финала так, чтобы при оптимальных действиях обоих участников выиграл тот, который интересен принцессе. Однако начальное расположение участников уже оглашено, и можно повлиять лишь на то, кто из соперников будет первым участником, а кто — вторым. Но как понять, какой из участников может обеспечить себе победу, ведь принцесса не сильна в военных делах... Поэтому она просит Вас определить, как закончится битва при оптимальных действиях обоих соперников, а также, в случае, если первый участник выигрывает, выигрышный ход для него.

Входные данные

В первой и единственной строке входных данных записано четыре целых числа, разделенных пробелами — x1, x2, a и b (x1 ≠ x2, a ≤ b,  - 109 ≤ x1, x2, a, b ≤ 109) — координаты точек, в которых начинают первый и второй участник, а также два числа, определяющие ходы игроков, соответственно.

Выходные данные

В первой строке выведите результат битвы в виде: «FIRST» (без кавычек), если при оптимальных действиях обоих игроков выигрывает первый участник, «SECOND» (без кавычек), если выигрывает второй участник, или «DRAW» (без кавычек), если никто не может обеспечить себе победу.

В случае, если выигрывает первый участник, в следующей строке выведите одно целое число x — координату точки, в которую должен пойти первый игрок, чтобы выиграть. Указанный ход должен быть корректным, то есть должно выполняться условие x1 + a ≤ x ≤ x1 + b. Если выигрышных ходов несколько, выведите любой. Если первый участник не может обеспечить себе победу, ничего дополнительно выводить не нужно.

Примечание

В первом примере первый участник может выиграть в один ход.

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

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

E. Игра с камнями

Бинарный поиск жадные алгоритмы игры Структуры данных *2300

Боб решил отдохнуть от домашних заданий по матанализу и придумал для себя игру.

Игра происходит на последовательности куч камней, которая может быть представлена как массив \(s_1, \ldots, s_k\), где \(s_i\) — количество камней в \(i\)-й куче. За один ход Боб выбирает две соседние непустые кучи \(i\) и \(i+1\) и убирает по одному камню из каждой. Если куча стала пустой, то её соседи не становятся соседними. Игра заканчивается, когда у Боба нет доступных ходов. Боб считает, что он выиграл, если в конце игры все кучи стали пустыми.

Мы считаем последовательность куч выигрышной, если Боб может начать с неё и выиграть после некоторой последовательности ходов.

Вам дана последовательность \(a_1, \ldots, a_n\), посчитайте количество выигрышных подотрезков \(a\). Другими словами, найдите количество отрезков \([l, r]\) (\(1 \leq l \leq r \leq n\)) таких, что \(a_l, a_{l+1}, \ldots, a_r\) является выигрышной последовательностью куч.

Входные данные

Каждый тест состоит из нескольких наборов входных данных. В первой строке находится единственное целое число \(t\) (\(1 \leq t \leq 3 \cdot 10^5\)) — количество наборов входных данных. Далее следуют описания наборов входных данных.

Первая строка описания каждого набора входных данных содержит единственное целое число \(n\) (\(1 \leq n \leq 3 \cdot 10^5\)).

Вторая строка описания каждого набора входных данных содержит \(n\) целых чисел \(a_1, a_2, \ldots, a_n\) (\(0 \leq a_i \leq 10^9\)).

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

Выходные данные

Для каждого набора входных данных выведите единственное целое число — ответ на задачу.

Примечание

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

Во втором наборе входных данных каждый подотрезок не является выигрышным.

В четвертом наборе входных данных подотрезок \([1, 4]\) выигрышный, потому что Боб может сделать ходы со следующими парами соседних кучек: \((2, 3)\), \((1, 2)\), \((3, 4)\). Другой выигрышный подотрезок это \([2, 3]\).

G. Браконьеры

графы Деревья дп игры *2500

Алиса и Боб — два браконьера, которые рубят лес.

Лес это набор (возможно пустой) деревьев. Дерево — это связный граф без циклов. Подвешенное дерево имеет специальную вершину — корень. Родителем вершины \(v\) называется следующая вершина на кратчайшем пути от \(v\) до корня. Детьми вершины \(v\) называются вершины, для которых \(v\) является родителем. Вершина называется листом, если у неё нет детей.

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

Изначально дан непустой лес подвешенных деревьев. Алиса и Боб играют в игру на этом лесе. Они ходят по очереди, Алиса ходит первой. В начале каждого хода игрок выбирает дерево из леса. Далее игрок выбирает положительное целое число — глубину разреза, которая не превосходит ранга выбранного дерева. Затем игрок удаляет из дерева все вершины, чьи глубины меньше либо равны глубине разреза. Все остальные вершины разбиваются на набор подвешенных деревьев, корнем каждого становится вершина, имевшая наименьшую глубину в дереве до разреза. Все эти деревья добавляются в лес и игра продолжается.

Игрок проигрывает, если на момент начала его хода лес пуст.

Определите, может ли Алиса победить, если оба игрока играют оптимально.

Входные данные

Во входных данных находятся несколько наборов входных данных. В первой строке находится одно целое число \(t\) (\(1 \leq t \leq 5 \cdot 10^5\)) — количество наборов входных данных. Далее следуют наборы входных данных.

Первая строка набора входных данных содержит одно целое число \(n\) (\(1 \leq n \leq 5 \cdot 10^5\)) — суммарное количество вершин в деревьях изначального леса.

Вторая строка содержит \(n\) целых чисел \(p_1, p_2, \ldots, p_n\) (\(0 \leq p_i \leq n\)) — описание леса. Если \(p_i = 0\), то \(i\)-я вершина дерева является корнем, иначе \(p_i\) является родителем вершины \(i\). Гарантируется, что \(p\) задает корректный лес подвешенных деревьев.

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

Выходные данные

Для каждого набора входных данных выведите «YES» (без кавычек), если Алиса может победить, иначе выведите «NO» (без кавычек). Вы можете выводить каждую букву в любом регистре.

Примечание

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

Во втором наборе Алиса может выбрать второе дерево и глубину разреза \(1\), чтобы получить лес, где уже у нее есть симметричная стратегия.

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

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

E. Array Game

жадные алгоритмы игры *1900

Alice and Bob are playing a game. They are given an array \(A\) of length \(N\). The array consists of integers. They are building a sequence together. In the beginning, the sequence is empty. In one turn a player can remove a number from the left or right side of the array and append it to the sequence. The rule is that the sequence they are building must be strictly increasing. The winner is the player that makes the last move. Alice is playing first. Given the starting array, under the assumption that they both play optimally, who wins the game?

Input

The first line contains one integer \(N\) (\(1 \leq N \leq 2*10^5\)) - the length of the array \(A\).

The second line contains \(N\) integers \(A_1\), \(A_2\),...,\(A_N\) (\(0 \leq A_i \leq 10^9\))

Output

The first and only line of output consists of one string, the name of the winner. If Alice won, print "Alice", otherwise, print "Bob".

D. Деревонумерация

битмаски Деревья жадные алгоритмы игры Конструктив поиск в глубину и подобное реализация *2100

Eikooc и Sushi играют в игру.

Игра проводится на дереве из \(n\) вершин, пронумерованных от \(1\) до \(n\). Напомним, что дерево с \(n\) вершинами это неориентированный связный граф с \(n-1\) ребрами.

Игроки поочередно перемещают фишку по дереву. Eikooc делает первый ход, помещая фишку на любую вершину по своему выбору. Sushi делает следующий ход, затем Eikooc, затем Sushi, и так далее. В каждый ход после первого, игрок должен переместить фишку в какую-то вершину \(u\) такую, что:

  • Между вершинами \(u\) и \(v\) (на которой фишка находится данный момент), есть ребро
  • \(u\) не была посещена ранее
  • \(u \oplus v \leq min(u, v)\)

Здесь \(x \oplus y\) обозначает операцию побитового исключающего ИЛИ чисел \(x\) и \(y\).

Оба игрока играют оптимально. Игрок, который не может сделать ход, проигрывает.

Ниже приведены примеры, демонстрирующие правила игры.

Предположим, Eikooc начинает игру, помещая фишку в вершину \(4\). Затем Sushi перемещает фишку в вершину \(6\), которая не была посещена и является соседней к \(4\). Также \(6 \oplus 4 = 2 \leq min(6, 4)\). На следующем ходу Eikooc перемещает фишку в вершину \(5\), которая не была посещена и является соседней к \(6\). Также, \(5 \oplus 6 = 3 \leq min(5, 6)\). У Sushi больше нет ходов для игры, поэтому она проигрывает.
Предположим, Eikooc начинает игру, помещая фишку в вершинул \(3\). Sushi перемещает фишку в вершину \(2\), которая не была посещена и является соседней к \(3\). Также \(3 \oplus 2 = 1 \leq min(3, 2)\). Eikooc не может переместить фишку в вершину \(6\), так как \(6 \oplus 2 = 4 \nleq min(6, 2)\). Поскольку у Eikooc нет ходов для игры, она проигрывает.

Перед началом игры Eikooc решает тайком перенумеровать вершины дерева в свою пользу. Формально, перенумерация — это перестановка \(p\) длины \(n\) (последовательность из \(n\) целых чисел, где каждое целое число от \(1\) до \(n\) встречается ровно один раз), где \(p_i\) обозначает новый номер вершины \(i\).

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

Входные данные

Первая строка содержит одно целое число \(t~(1 \le t \le 10^5)\)  — количество наборов входных данных. Описание каждого набора входных данных выглядит следующим образом.

Первая строка каждого набора входных данных содержит целое число \(n~(1 \le n \le 2 \cdot 10^5)\)  — количество вершин в дереве.

Следующие \(n-1\) строки содержат по два целых числа \(u\) и \(v\) \((1 \le u, v \le n; u \neq v)\)  — обозначающие ребро между вершинами \(u\) и \(v\).

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

Выходные данные

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

Примечание

В первом наборе входных данных у Eikooc есть только одна вершина. У Sushi не будет ходов после того, как Eikooc выберет эту вершину, и Eikooc выиграет.

Во втором наборе входных данных \(1 \oplus 2 = 3 \nleq min(1, 2)\). Следовательно, после того, как Eikooc выберет любую из вершин, у Sushi не останется ходов, и Eikooc выиграет. И \(\{1, 2\}\), и \(\{2, 1\}\) являются допустимыми перенумерациями.

I. Маштали против AtCoder

Деревья игры *3100

После многих неудачных попыток, Маштали решил скопировать модифицировать задачу с AtCoder. Итак, вот его скопированная новая задача:

Дано дерево на \(n\) вершинах, и некоторое непустое множество вершин прибито к земле.

Два игрока играют друг против друга на дереве. Они поочередно выполняют следующее действие:

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

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

Вам дано дерево, но не дано множество прибитых вершин. Ваша задача — определить для каждого \(k\) победителя игры, если прибиты только вершины \(1, 2, 3, \ldots, k\), и оба игрока играют оптимально.

Входные данные

Первая строка ввода содержит целое число \(n\) — количество вершин (\(1 \le n \le 3 \cdot 10^5\)).

В \(i\)-й из следующих \(n-1\) строк содержится два целых числа \(u_i, v_i\) (\(1 \le u_i, v_i \le n\), \(u_i \ne v_i\)) — вершины \(i\)-го ребра. Гарантируется, что эти ребра образуют дерево.

Выходные данные

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

Примечание

Ниже вы можете увидеть дерево с первого примера:

Если \(k = 1\), то первый игрок может разрезать ребро \((1, 2)\).

Если \(k = 2\) или \(k = 3\), то первый игрок может перерезать ребро \((2, 4)\), после чего останутся только ребра \((1, 2)\) и \((2, 3)\). После хода второго игрока у первого игрока останется только одно ребро для разрезания. Поэтому первый игрок выигрывает.

E. Фиолетовый мелок

графы Деревья жадные алгоритмы игры математика поиск в глубину и подобное сортировки Структуры данных *2400

Два игрока, Красный и Синий, снова в деле, и этот раз они играют с цветными мелками! Сегодня озорной паре под руку попалось корневое дерево, с которым они играют в свою любимую игру, раскрашивая вершины этого дерева.

Игра выглядит следующим образом: есть дерево из \(n\) вершин с корнем в вершине \(1\), и каждая вершина первоначально белого цвета. У Красного и Синего есть ровно по одному ходу. Первым ходит Красный.

В свой ход, Красный может выполнить следующее действие произвольное количество раз:

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

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

  • Он выбирает любое поддерево корневого дерева и красит каждую вершину поддерева в синий. Однако, ему нельзя выбирать поддеревья, в которых содержатся вершины, уже покрашенные в красный. Ведь в таком случае вершина получится фиолетового цвета, а никто не любит фиолетовый мелок* (англ. purple crayon).
Заметим, что нет ограничения на то, сколько вершин покрасит Синий, главное, что он не красит уже покрашенные Красным вершины.

После того как каждый сделает свой ход, счет игры определяется следующим образом: пусть \(w\) — количество оставшихся белых вершин, \(r\) — количество красных вершин, а \(b\) — количество синих вершин. Счет игры будет равен \(w \cdot (r - b)\).

Красный хочет максимизировать счет, а Синий — минимизировать. Чему будет равен счет игры, если оба игрока действуют оптимально?

Входные данные

В первой строке заданы два целых числа \(n\) и \(k\) (\(2 \le n \le 2 \cdot 10^5\); \(1 \le k \le n\)) — количество вершин в дереве и максимальное количество красных вершин.

В следующих \(n - 1\) строках заданы описания ребер дерева. В \(i\)-й строке заданы два целых числа \(u_i\) и \(v_i\) через пробел (\(1 \le u_i, v_i \le n\); \(u_i \neq v_i\)) — \(i\)-е ребро дерева.

Гарантируется, что заданные ребра образуют дерево.

Выходные данные

Выведите одно число — итоговый счет игры, если и Красный и Синий действуют оптимально.

Примечание

В первом наборе входных данных, одна из оптимальных стратегий следующая:

  • Красный выбирает для покраски поддеревья вершин \(2\) и \(3\).
  • Синий выбирает для покраски поддерево вершины \(4\).
В результате вершины \(2\) и \(3\) покрашены в красный, \(4\) — в синий, а вершина \(1\) — в белый. Счет игры равен \(1 \cdot (2 - 1) = 1\).

Во втором наборе, оптимальная стратегия следующая:

  • Красный выбирает для покраски поддерево вершины \(4\). Тем самым красит вершины \(4\) и \(5\).
  • Синий не может ничего выбрать, а потому ничего не красит.
В результате вершины \(4\) и \(5\) покрашены в красный, а вершины \(1\), \(2\) и \(3\) — белые. Счет игры равен \(3 \cdot (2 - 0) = 6\).

В третьем наборе:

Счет игры равен \(4 \cdot (2 - 1) = 4\).

E. Новогодние конфеты

графы Деревья дп игры кратчайшие пути математика поиск в глубину и подобное реализация теория чисел *2700

Лунный Новый год приближается, и Льдинка только что получила коробку конфет от бабушки с дедушкой! Коробка содержит \(n\) конфет. \(i\)-я конфета имеет вкус \(a_i\).

Льдинка верит, что хорошие вещи случаются парами. К сожалению, вкусы всех конфет попарно различны (все \(a_i\) различны). Льдинка хочет сделать равные вкусы хотя бы у одной пары конфет.

Поэтому она попросила бабушку с дедушкой выполнить несколько замен. Перед выполнением замен Льдинка выбирает две конфеты с номерами \(x\) и \(y\) (\(1 \le x, y \le n\), \(x \ne y\)).

За одну замену дедушка и бабушка Льдинки выбирают неотрицательное целое число \(k\) такое, что \(2^k \ge a_x\), и заменяют вкус \(x\)-й конфеты с \(a_x\) на \(2^k - a_x\) (то есть, присваивают \(a_x := 2^k - a_x\)).

Замены прекратятся только при условии, что \(a_x = a_y\). Заметьте, что другие пары равных по вкусу конфет не остановят процесс.

У Льдинки умные бабушка и дедушка, поэтому они выберут такую последовательность замен, которая минимизирует количество требуемых замен. Поскольку Льдинка любит доставлять неприятности, она хочет максимизировать минимальное требуемое количество замен, выбрав соответствующие \(x\) и \(y\). Она задаётся вопросом, как выбрать такую пару \((x, y)\), что минимальное требуемое количество замен максимально среди всех возможных пар \((x, y)\).

Так как у Льдинки не очень хорошо с математикой, она надеется, что вы поможете ей решить эту задачу.

Входные данные

Первая строка ввода содержит единственное целое число \(n\) (\(2 \le n \le 2 \cdot 10^5\)) — количество конфет.

Вторая строка ввода содержит \(n\) целых чисел \(a_1, a_2, \dots, a_n\) (\(0 \le a_i \le 10^9\)).

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

Выходные данные

Выведите три целых числа \(x\), \(y\) и \(m\).

\(x\) и \(y\) являются номерами оптимальных конфет для применения замен. Ваш ответ должен удовлетворять \(1 \le x, y \le n\), \(x \ne y\).

\(m\) является минимальным количеством замен, чтобы сделать \(a_x = a_y\). Можно показать, что \(m \le 10^9\) для любой пары конфет.

Примечание

В первом тесте минимальное количество замен, требуемое, чтобы заменить конфету со вкусом \(6\) на конфету со вкусом \(9\), является \(5\). Последовательность замен следующая: \(6 \rightarrow 2 \rightarrow 0 \rightarrow 1 \rightarrow 7 \rightarrow 9\).

Во втором тесте минимальное количество замен, требуемое, чтобы заменить конфету со вкусом \(4\) на конфету со вкусом \(8\), является \(2\). Последовательность замен следующая: \(4 \rightarrow 0 \rightarrow 8\).

B. Не садиться

жадные алгоритмы игры сортировки *1300

Рахул и Тина с нетерпением ждут начала нового учебного года в колледже. Вот они заходят в учебный класс и видят, что места для студентов расположены в виде прямоугольника \(n \times m\). Место, соответствующее клетке в строке \(r\) столбце \(c\) этого прямоугольника, обозначается как \((r, c)\). Расстояние между двумя местами \((a,b)\) и \((c,d)\) вычисляется по формуле \(|a-c| + |b-d|\).

Как президент класса, Тина имеет доступ к ровно \(k\) ведрам розовой краски. Далее происходит следующий процесс.

  • Сначала Тина выбирает ровно \(k\) мест в классе, чтобы покрасить их розовой краской. Одним ведром краски можно покрасить ровно одно место.
  • После того как Тина покрасит \(k\) мест в розовый цвет, Рахул выбирает, где ему сесть. Он не выберет место, покрашенное в розовый цвет, так как он очень не любит розовый.
  • После того, как Рахул выберет свое место, Тина выбирает место для себя. Она может выбрать любое место, покрашенное или нет, за исключением того места, которое выбрал Рахул.

Рахул хочет выбрать место так, чтобы он сидел как можно ближе к Тине. Однако Тина хочет сидеть как можно дальше от Рахула из-за сложной истории отношений, которую мы решили не добавлять в условие задачи.

Теперь Рахул задается вопросом: для \(k = 0, 1, \dots, n \cdot m - 1\), если у Тины есть \(k\) ведер с краской, насколько близко Рахул может сидеть к Тине, если и Рахул, и Тина знают о намерениях друг друга и оба действуют оптимально? Пожалуйста, помогите удовлетворить любопытство Рахула!

Входные данные

Входные данные состоят из одного или нескольких наборов входных данных. Первая строка содержит целое число \(t\) (\(1 \leq t \leq 5 \cdot 10^4\)) — количество наборов входных данных в тесте. Далее заданы описания наборов входных данных.

Единственная строка каждого набора входных данных содержит два целых числа \(n\), \(m\) (\(2 \leq n \cdot m \leq 10^5\)) — количество строк и столбцов в прямоугольнике, который описывает места студентов в классе.

Сумма значений \(n \cdot m\) по всем наборам входных данных не превосходит \(10^5\).

Выходные данные

Для каждого набора входных данных выведите \(n \cdot m\) целых чисел — расстояние между Рахулом и Тиной, если они оба действуют оптимально для каждого \(k \in [0, n \cdot m - 1]\).

Примечание

Одна из возможных последовательностей выбора для первого набора входных данных, где у Тины есть \(k=3\) ведра с красками, выглядит следующим образом.

Тина красит места в позициях \((1, 2)\), \((2, 2)\), \((3, 2)\) розовой краской. Рахул выбирает место \((3, 1)\), после чего Тина выбирает место \((1, 3)\).

Следовательно, расстояние между Тиной и Рахулом равно \(|3-1| + |1-3| = 4\). Мы можем доказать, что это действительно минимально возможное расстояние при заданных ограничениях. Могут быть и другие варианты мест, которые также приводят к тому же ответу.

При \(k=0\) в первом наборе входных данных Рахул может решить сесть на \((2, 2)\), а Тина может сесть на \((4, 3)\), так что расстояние между ними будет \(|2 - 4| + |2 - 3| = 3\).

Ниже приведены изображения случаев \(k=3\) и \(k=0\) для первого набора входных данных.

Возможная рассадка при \(k=3\). Возможная рассадка при \(k=0\).

D1. Игра на сумму (Легкая версия)

дп игры Комбинаторика математика *2100

Это легкая версия задачи. Разница заключается в ограничениях на \(n\), \(m\) и \(t\). Делать взломы можно только в том случае, если решены обе задачи.

Алисе и Бобу даются числа \(n\), \(m\) и \(k\), и они играют в следующую игру:

В игре есть счет, который Алиса пытается максимизировать, а Боб старается минимизировать. Первоначально счет равен \(0\). Игра состоит из \(n\) ходов. Каждый ход Алиса выбирает число от \(0\) до \(k\) (необязательно целое), которое Боб либо прибавляет, либо вычитает из счета игры. Но на протяжении всей игры Боб должен прибавить не менее \(m\) из \(n\) ходов.

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

Если Алиса и Боб будут играть оптимально, каков будет окончательный счет игры?

Входные данные

Первая строка входных данных содержит единственное целое число \(t\) (\(1 \le t \le 1000\)) — количество тестов. Описание тестовых примеров следует ниже.

Каждый тестовый пример состоит из одной строки, содержащей три целых числа: \(n\), \(m\) и \(k\) (\(1 \le m \le n \le 2000, 0 \le k < 10^9 + 7\)) — количество ходов, сколько из этих ходов Боб должен прибавить, и наибольшее число, которое Алиса может выбрать соответственно.

Гарантируется, что сумма \(n\) по всем тестам не превышает \(2000\).

Выходные данные

Для каждого тестового примера выведите одно число — результат оптимальной игры по модулю \(10^9 + 7\).

Формально пусть \(M = 10^9 + 7\). Можно показать, что ответ может быть выражен в виде неприводимой дроби \(\frac{p}{q}\), где \(p\) и \(q\) — целые числа, \(q \not \equiv 0 \pmod{M}\). Выведите целое число, равное \(p \cdot q^{-1} \bmod M\). Другими словами, выведите такое целое число \(x\), что \(0 \le x < M\) и \(x \cdot q \equiv p \pmod{M}\).

Примечание

В первом тестовом примере вся игра имеет \(3\) хода, и, поскольку \(m = 3\), Боб должен добавить в каждый из них. Следовательно, Алиса должна каждый ход выбирать самое большое число, которое она может, а именно \(k = 2\).

В третьем тестовом примере у Алисы есть стратегия, гарантирующая оценку \(\frac{75}{8} \equiv 375000012 \pmod{10^9 + 7}\).

В четвертом тестовом примере у Алисы есть стратегия, гарантирующая оценку \(\frac{45}{2} \equiv 500000026 \pmod{10^9 + 7}\).

D2. Игра на сумму (Сложная версия)

дп игры Комбинаторика математика *2400

Это сложная версия задачи. Разница заключается в ограничениях на \(n\), \(m\) и \(t\). Делать взломы можно только в том случае, если решены обе задачи.

Алисе и Бобу даются числа \(n\), \(m\) и \(k\), и они играют в следующую игру:

В игре есть счет, который Алиса пытается максимизировать, а Боб старается минимизировать. Первоначально счет равен \(0\). Игра состоит из \(n\) ходов. Каждый ход Алиса выбирает число от \(0\) до \(k\) (необязательно целое), которое Боб либо прибавляет, либо вычитает из счета игры. Но на протяжении всей игры Боб должен прибавить не менее \(m\) из \(n\) ходов.

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

Если Алиса и Боб будут играть оптимально, каков будет окончательный счет игры?

Входные данные

Первая строка входных данных содержит единственное целое число \(t\) (\(1 \le t \le 10^5\)) — количество тестов. Описание тестовых примеров следует ниже.

Каждый тестовый пример состоит из одной строки, содержащей три целых числа: \(n\), \(m\) и \(k\) (\(1 \le m \le n \le 10^6, 0 \le k < 10^9 + 7\)) — количество ходов, сколько из этих ходов Боб должен прибавить, и наибольшее число, которое Алиса может выбрать соответственно.

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

Выходные данные

Для каждого тестового примера выведите одно число — результат оптимальной игры по модулю \(10^9 + 7\).

Формально пусть \(M = 10^9 + 7\). Можно показать, что ответ может быть выражен в виде неприводимой дроби \(\frac{p}{q}\), где \(p\) и \(q\) — целые числа, \(q \not \equiv 0 \pmod{M}\). Выведите целое число, равное \(p \cdot q^{-1} \bmod M\). Другими словами, выведите такое целое число \(x\), что \(0 \le x < M\) и \(x \cdot q \equiv p \pmod{M}\).

Примечание

В первом тестовом примере вся игра имеет \(3\) хода, и, поскольку \(m = 3\), Боб должен добавить в каждый из них. Следовательно, Алиса должна каждый ход выбирать самое большое число, которое она может, а именно \(k = 2\).

В третьем тестовом примере у Алисы есть стратегия, гарантирующая оценку \(\frac{75}{8} \equiv 375000012 \pmod{10^9 + 7}\).

В четвертом тестовом примере у Алисы есть стратегия, гарантирующая оценку \(\frac{45}{2} \equiv 500000026 \pmod{10^9 + 7}\).

E. Годзё и игра на матрице

дп игры математика реализация сортировки Структуры данных теория чисел хэши *2500

Марин измоталась после долгого дня косплея, поэтому Годзё приглашает ее сыграть в игру!

Марин и Годзё по очереди кладут одну из своих фишек на таблицу размером \(n \times n\), при этом Марин ходит первой. Существуют некоторые ограничения на размещение фишек:

  • За исключением первого хода фишка, размещенная игроком, должна находиться на манхэттенском расстоянии более чем \(k\) от последней размещенной фишки. Другими словами, если игрок кладет фишку в \((x_1, y_1)\), то фишка, помещенная на следующем ходу, должна находиться в ячейке \((x_2, y_2)\), удовлетворяющей \(|x_2 - x_1| + |y_2 - y_1| > k\).
  • Помимо предыдущего ограничения, фишка может быть размещена в любом месте матрицы, включая ячейки, где уже были размещены фишки любого игрока.

Каждый раз, когда какой-либо игрок кладет фишку в ячейку \((x, y)\), этот игрок получает \(v_{x,\ y}\) очков. Все значения \(v\) в таблице различны. Очки за ячейку даются даже в случае, если какие-то фишки уже находятся в этой ячейке. Игра заканчивается, когда каждый игрок сделает \(10^{100}\) ходов.

Марин и Годзё сыграют \(n^2\) партий. Для каждой ячейки таблицы будет ровно одна партия, в которой первым ходом Марин размещает фишку в этой ячейке. Для каждой такой партии определите, у кого в итоге будет больше очков при оптимальной игре Марин и Годзё (после первого хода Марин)? Или партия закончится вничью?

Входные данные

Первая строка содержит два целых числа \(n\), \(k\) (\(3 \le n \le 2000\), \(1 \leq k \leq n - 2\)). Заметьте, что при таких ограничениях всегда возможно сделать ход.

Следующие \(n\) строк содержат по \(n\) целых чисел. \(j\)-м числом в \(i\)-й строке является \(v_{i,j}\) (\(1 \le v_{i,j} \le n^2\)). Все значения в \(v\) различны.

Выходные данные

Выведите \(n\) строк. \(i\)-я строка должна содержать \(n\) символов, где \(j\)-й символ является результатом партии, в которой Марин начинает с ячейки \((i, j)\). Выведите 'M' в случае победы Марин, 'G' — в случае победы Годзё и 'D' — в случае равного количества очков. Не выводите пробелы между символами в одной строке.

F. Игра с деревом и перестановкой

графы Деревья игры поиск в глубину и подобное *3000

Есть дерево из \(n\) вершин и перестановка \(p\) из \(n\) чисел. В вершине \(x\) дерева находится фишка.

Алиса и Боб играют в игру. Алиса управляет перестановкой \(p\), а Bob управляет фишкой на дереве. В свой ход Алиса обязана выбрать два различных числа \(u\) и \(v\) (не индексы; \(u \neq v\)) такие, что фишка не находится ни в вершине \(u\), ни в вершине \(v\) дерева, и поменять их местами в перестановке \(p\). В свой ход Боб обязан передвинуть фишку в соседнюю с текущей вершину.

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

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

Входные данные

Первая строка содержит одно целое число \(t\) (\(1 \le t \le 1000\)) — количество наборов входных данных. Далее следуют описания наборов входных данных.

Первая строка содержит два целых числа \(n\) и \(x\) (\(3 \leq n \leq 2 \cdot 10^5\); \(1 \leq x \leq n\)).

Каждая из следующих \(n-1\) строк содержит два целых числа \(a\) и \(b\) (\(1 \le a, b \le n\), \(a \neq b\)), обозначающих неориентированное ребро между вершинами \(a\) и \(b\). Гарантируется, что данные ребра образуют дерево.

Следующая строка содержит \(n\) целых чисел \(p_1, p_2, \ldots, p_n\) (\(1 \le p_i \le n\)) — перестановка \(p\).

Сумма значений \(n\) по всем наборам входных данных не превосходит \(2 \cdot 10^5\).

Выходные данные

Для каждого набора входных данных выведите одну строку, содержащую слово Alice или Bob — победителя игры. В ответе важен регистр букв.

Примечание

Ниже находится объяснение первого примера.

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

  1. Алиса меняет местами \(5\) и \(6\), получается \([2,1,3,5,4,6]\).
  2. Боб передвигает фишку в вершину \(5\).
  3. Алиса меняет местами \(1\) и \(2\), получается \([1,2,3,5,4,6]\).
  4. Боб передвигает фишку в вершину \(3\).
  5. Алиса меняет местами \(4\) и \(5\), получается \([1,2,3,4,5,6]\) и выигрывает.

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

  1. Алиса меняет местами \(1\) и \(3\), получается \([3,1,2]\).
  2. Боб передвигает фишку в вершину \(1\).
  3. Алиса меняет местами \(2\) и \(3\), получается \([2,1,3]\).
  4. Боб передвигает фишку в вершину \(2\).
  5. Алиса меняет местами \(1\) и \(3\), получается \([2,3,1]\).
  6. Боб передвигает фишку в вершину \(3\).
  7. Алиса меняет местами \(1\) и \(2\), получается \([1,3,2]\).
  8. Боб передвигает фишку в вершину \(2\).
И далее последовательность бесконечно повторяется.

В третьем наборе Алиса выигрывает сразу, так перестановка уже отсортирована.

D. НОД-угадайка

битмаски игры интерактив китайская теорема об остатках Конструктив математика теория чисел *2000

Это интерактивная задача.

Загадано некоторое положительное целое число \(1 \le x \le 10^9\).

За один запрос вы можете выбрать два положительных целых числа \(a \neq b\). В качестве ответа на этот запрос вы получите \(\gcd(x + a, x + b)\), где \(\gcd(n, m)\) обозначает наибольший общий делитель чисел \(n\) и \(m\).

Чтобы угадать одно загаданное число \(x\), вы можете совершить не более \(30\) запросов.

Входные данные

Первая строка содержит одно целое число \(t\) (\(1 \le t \le 1000\)) — количество наборов входных данных.

Загаданное число \(x\) удовлетворяет следующим ограничениям: (\(1 \le x \le 10^9\)).

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

Загаданное число \(x\) зафиксировано до начала взаимодействия и не зависит от ваших запросов.

Для угадывания каждого \(x\) вы можете сделать не более \(30\) запросов следующего вида:

  • «? a b» (\(1 \le a, b \le 2 \cdot 10^9\), \(a \neq b\)).

В ответ на этот запрос вы получите \(\gcd(x + a, x + b)\).

Когда вы узнаете число \(x\), выведите одну строку следующего формата:

  • «! x» (\(1 \le x \le 10^9\)).

После этого переходите к решению следующего набора входных данных.

Если вы сделаете более \(30\) запросов для одного \(x\), или запросы будут некорректными, взаимодействие будет немедленно прекращено, а ваша программа получит вердикт Неправильный ответ.

После вывода запросов не забудьте выводить символ перевода строки и сбрасывать буфер вывода. В противном случае вы получите вердикт Решение «зависло». Для сброса буфера используйте:

  • fflush(stdout) или cout.flush() в C++;
  • System.out.flush() в Java;
  • flush(output) в Pascal;
  • stdout.flush() в Python;
  • смотрите документацию для других языков.

Взломы

Для взломов используйте следующий формат:

Первая строка должна содержать одно целое число \(t\) (\(1 \le t \le 1000\)) — количество наборов входных данных.

Первая и единственная строка каждого набора входных данных должна содержать единственное целое число \(x\) (\(1 \le x \le 10^9\)) — число \(x\), которое нужно угадать.

Примечание

Первое загаданное число равно \(4\), поэтому ответы на запрос следующие:

«? 1 2» — \(\gcd(4 + 1, 4 + 2) = \gcd(5, 6) = 1\).

«? 12 4» — \(\gcd(4 + 12, 4 + 4) = \gcd(16, 8) = 8\).

Второе загаданное число равно \(10^9\), поэтому ответ на запрос следующий:

«? 2000000000 1999999999» — \(\gcd(3 \cdot 10^9, 3 \cdot 10^9 - 1) = 1\).

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

C. Волшебники и числа

игры математика *2300

В некоторой стране живут волшебники. Они любят играть с числами.

На доске записано два числа — a и b. Порядок чисел не важен. Пусть для определенности a ≤ b. Игроки по очереди могут колдовать одно из двух заклинаний.

  • Заменить b на b - ak. Число k может выбрать игрок, с ограничениями, что k > 0 и b - ak ≥ 0. Число k выбирается независимо при каждом использовании заклинания игроком, делающим ход.
  • Заменить b на b mod a.

В случае, когда a > b возможны аналогичные ходы.

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

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

Входные данные

В первой строке дано одно целое число t — количество наборов входных данных (1 ≤ t ≤ 104). Далее в t строках даны по два целых числа a, b (0 ≤ a, b ≤ 1018). Числа записаны через пробел.

Пожалуйста, не используйте спецификатор %lld для чтения или записи 64-х битовых чисел на С++. Рекомендуется использовать потоки cin, cout или спецификатор %I64d.

Выходные данные

Для каждого из t наборов входных данных выведите «First» (без кавычек), если, при оптимальной игре, выиграет игрок, который ходит первым, и «Second» (без кавычек), если выиграет игрок, который ходит вторым. Ответы на разные наборы данных выводите в разных строках в том порядке, в котором они записаны во входных данных.

Примечание

В первом примере первому игроку следует пойти в (11,10). Тогда, после единственного хода второго игрока в (1,10), он возьмет 10 по модулю 1 и выиграет.

Во втором примере у первого игрока есть два хода в (1,10) и в (21,10). После обоих ходов второй может выиграть.

В третьем примере у первого игрока нет хода.

В четвертом примере первый игрок выигрывает за один ход, взяв 30 по модулю 10.

A. Рубка бревен

игры математика реализация *800

Есть \(n\) бревен, длина \(i\)-го бревна составляет \(a_i\) метров. Поскольку рубить бревна  — утомительная работа, errorgorn и maomao90 решили сыграть в игру.

errorgorn и maomao90 будут по очереди рубить бревна, причем errorgorn рубит первым. В свой ход игрок выбирает бревно и рубит его на \(2\) части. Если длина выбранного бревна \(x\), а длины получившихся кусков \(y\) и \(z\), то должно выполняться условие \(x=y+z\), а \(y\) и \(z\) должны быть целыми положительными числами. Например, бревно длиной \(3\) можно разрубить на бревна с длинами \(2\) и \(1\), но не на бревна с длинами \(3\) и \(0\), \(2\) и \(2\), или \(1.5\) и \(1.5\).

Игрок, который не сможет выбрать бревно и разрубить его, проиграет. Кто победит, если и errorgorn, и maomao90 играют оптимально?

Входные данные

Каждый тест содержит несколько наборов входных данных. Первая строка содержит одно целое число \(t\) (\(1 \leq t \leq 100\))  — количество наборов входных данных. Далее следует описание наборов входных данных.

Первая строка каждого набора входных данных содержит одно целое число \(n\) (\(1 \leq n \leq 50\))  — количество бревен.

Вторая строка каждого набора входных данных содержит \(n\) целых чисел \(a_1,a_2, \ldots, a_n\) (\(1 \leq a_i \leq 50\))  — длины бревен.

Обратите внимание, что ограничения на сумму \(n\) по всем наборам входных данных нет.

Выходные данные

Для каждого набора входных данных выведите «errorgorn», если победил errorgorn, или «maomao90», если победил maomao90. (Выводите без кавычек).

Примечание

В первом наборе входных данных победителем будет errorgorn. Оптимальным ходом будет разрезать бревно длиной \(4\) на \(2\) бревна длиной \(2\). После этого останется только \(4\) бревен длины \(2\) и \(1\) бревен длины \(1\).

После этого единственный ход, который может сделать любой игрок, это разрубить любое бревно длиной \(2\) на \(2\) бревна длиной \(1\). После \(4\) ходов наступит очередь maomao90, и он не сможет сделать ход. Поэтому победителем будет errorgorn.

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

A. Хитрое удаление подстроки

жадные алгоритмы игры Строки *800

Алиса и Боб играют в игру со строками. Всего в игре будет \(t\) раундов. В каждом раунде будет строка \(s\), состоящая из строчных латинских букв.

Оба игрока делают ходы по очереди, Алиса ходит первой. Алиса может удалить любую подстроку чётной длины (возможно пустую) и Боб может удалить любую подстроку нечётной длины из \(s\).

Более формально, если была строка \(s = s_1s_2 \ldots s_k\) игрок может выбрать подстроку \(s_ls_{l+1} \ldots s_{r-1}s_r\) длины соответствующей чётности и удалить её. После этого строка станет \(s = s_1 \ldots s_{l-1}s_{r+1} \ldots s_k\).

Когда строка становится пустой, раунд заканчиваются и каждый игрок считает его/её очки за этот раунд. Количество очков игрока равно сумме стоимостей символов, удалённых им/ей. Стоимость \(\texttt{a}\) равна \(1\), стоимость \(\texttt{b}\) равна \(2\), стоимость \(\texttt{c}\) равна \(3\), \(\ldots\), и стоимость \(\texttt{z}\) равна \(26\). Игрок с большим количеством очков побеждает в раунде. Для каждого раунда определите победителя и разницу очков победителя и проигравшего. Считайте, что оба игрока играют оптимально с целью максимизировать свои очки. Можно доказать, что ничья невозможна.

Входные данные

В первой строке входных данных содержится единственное число \(t\) (\(1\leq t\leq 5\cdot 10^4\)) — количество раундов.

Каждая из следующих \(t\) строк содержит единственную строку \(s\) (\(1\leq |s|\leq 2\cdot 10^5\)), состоящую из строчных латинских букв — строку, используемую в раунде. Здесь \(|s|\) обозначает длину строки \(s\).

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

Выходные данные

Для каждого раунда выведите единственную строку, содержащую строку и число. Если Алиса выиграет в раунде, строка должна быть «Alice». Если Боб выигрывает в раунде, строка должна быть «Bob». Число должно быть равно разности очков, если оба игрока играют оптимально.

Примечание

В первом раунде \(\texttt{"aba"}\xrightarrow{\texttt{Alice}}\texttt{"}{\color{red}{\texttt{ab}}}\texttt{a"}\xrightarrow{} \texttt{"a"}\xrightarrow{\texttt{Bob}}\texttt{"}{\color{red}{\texttt{a}}}\texttt{"}\xrightarrow{}\texttt{""}\). Общее количество очков Алисы равно \(1+2=3\). Общее количество очков Боба равно \(1\).

Во втором раунде \(\texttt{"abc"}\xrightarrow{\texttt{Alice}}\texttt{"a}{\color{red}{\texttt{bc}}}\texttt{"}\xrightarrow{} \texttt{"a"}\xrightarrow{\texttt{Bob}}\texttt{"}{\color{red}{\texttt{a}}}\texttt{"}\xrightarrow{}\texttt{""}\). Общее количество очков Алисы равно \(2+3=5\). Общее количество очков Боба равно \(1\).

В третьем раунде \(\texttt{"cba"}\xrightarrow{\texttt{Alice}}\texttt{"}{\color{red}{\texttt{cb}}}\texttt{a"}\xrightarrow{} \texttt{"a"}\xrightarrow{\texttt{Bob}}\texttt{"}{\color{red}{\texttt{a}}}\texttt{"}\xrightarrow{}\texttt{""}\). Общее количество очков Алисы равно \(3+2=5\). Общее количество очков Боба равно \(1\).

В четвёртом раунде \(\texttt{"n"}\xrightarrow{\texttt{Alice}}\texttt{"n"}\xrightarrow{} \texttt{"n"}\xrightarrow{\texttt{Bob}}\texttt{"}{\color{red}{\texttt{n}}}\texttt{"}\xrightarrow{}\texttt{""}\). Общее количество очков Алисы равно \(0\). Общее количество очков Боба равно \(14\).

В пятом раунде \(\texttt{"codeforces"}\xrightarrow{\texttt{Alice}}\texttt{"}{\color{red}{\texttt{codeforces}}}\texttt{"}\xrightarrow{} \texttt{""}\). Общее количество очков Алисы равно \(3+15+4+5+6+15+18+3+5+19=93\). Общее количество очков Боба равно \(0\).

A. Игра с карточками

жадные алгоритмы игры *800

Алиса и Боб играют в игру. У Алисы есть \(n\) карточек с числами, на \(i\)-й из них написано число \(a_i\). У Боба есть \(m\) карточек с числами, на \(j\)-й из них написано число \(b_j\).

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

Если какой-то игрок не может сделать ход, то он проигрывает.

Например, пусть у Алисы \(4\) карточки, числа на них равны \([10, 5, 3, 8]\). У Боба \(3\) карточки, числа на них равны \([6, 11, 6]\). Игра может идти следующим образом:

  • Алиса может выбрать любую карточку. Она выбирает карточку с числом \(5\) и кладет ее на стол.
  • Боб может выбрать любую карточку с числом больше \(5\). Он выбирает карточку с числом \(6\) и кладет ее на стол.
  • Алиса может выбрать любую карточку с числом больше \(6\). Она выбирает карточку с числом \(10\) и кладет ее на стол.
  • Боб может выбрать любую карточку с числом больше \(10\). Он выбирает карточку с числом \(11\) и кладет ее на стол.
  • Алиса может выбрать любую карточку с числом больше \(11\), но у нее нет таких карточек, поэтому она проигрывает.

Алиса и Боб играют в игру оптимально (то есть если кто-то из них может победить независимо от того, как будет играть противник, то этот игрок обязательно выигрывает).

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

  • кто победит, если первый ход делает Алиса?
  • кто победит, если первый ход делает Боб?
Входные данные

В первой строке задано одно целое число \(t\) (\(1 \le t \le 1000\)) — количество наборов входных данных. Каждый набор входных данных состоит из четырех строк.

В первой строке набора входных данных задано одно целое число \(n\) (\(1 \le n \le 50\)) — количество карточек у Алисы.

Во второй строке набора входных данных заданы \(n\) целых чисел \(a_1, a_2, \dots, a_n\) (\(1 \le a_i \le 50\)) — числа, записанные на карточках Алисы.

В третьей строке набора входных данных задано одно целое число \(m\) (\(1 \le m \le 50\)) — количество карточек у Боба.

В четвертой строке набора входных данных заданы \(m\) целых чисел \(b_1, b_2, \dots, b_m\) (\(1 \le b_i \le 50\)) — числа, записанные на карточках Боба.

Выходные данные

Для каждого набора входных данных выведите две строки. В первой строке выведите Alice, если в случае, когда Алиса делает первый ход, она выигрывает; в противном случае выведите Bob. Во второй строке в аналогичном формате выведите, кто выигрывает, если первый ход делает Боб.

Примечание

Разберем первый набор входных данных в примере из условия.

У Алисы одна карточка с числом \(6\), у Боба есть две карточки с числами \([6, 8]\).

Если Алиса делает первый ход, то она должна выложить на стол карточку \(6\). Боб должен в ответ выложить на стол карточку с числом \(8\). У Алисы нет карточек, которые она может выложить на стол, поэтому она проигрывает.

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

A. Много цифр

игры Конструктив математика Строки *800

У самых истоков CrowdForces, ещё совсем давно, стояла именно Тётя Люсине. За это время она заработала много денег, даже забыла все цифры и теперь просто платит. Но совершенно неожиданно ей на ревью попалась задача как раз на цифры! Тётя Люсине не может решить даже on-ramp задачу. Помогите ей, ведь судьба вашего аккаунта в её руках!

Дано целое число \(n\) без нулей в десятичной записи. Алиса и Боб играют в игру с этим числом. Алиса начинает первой. Они делают ходы по очереди.

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

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

Входные данные

В первой строке входных данных находится единственное целое число \(t\) (\(1 \le t \le 10^4\)) — количество наборов входных данных.

В единственной строке описания каждого набора входных данных находится одно целое число \(n\) (\(10 \le n \le 10^9\)) — число, с которым ведётся игра. \(n\) не содержит нулей в десятичной записи.

Выходные данные

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

Примечание

В первом наборе входных данных Алиса должна поменять местами \(1\) и \(2\). После этого Боб удаляет последнюю цифру, т. е. \(1\), поэтому ответ \(2\).

Во втором наборе входных данных Алиса может поменять местами \(3\) и \(1\): \(312\). После этого Боб удаляет последнюю цифру: \(31\). Потом Алиса меняет местами \(3\) и \(1\): \(13\) и Боб удаляет \(3\), поэтому ответ \(1\).

A. Угадывание подпрямоугольника

игры *800

Майкл и Джо играют в игру. Игра ведется в табличке с \(n\) строками и \(m\) столбцами, заполненной попарно различными целыми числами. Обозначим ячейку в \(i\)-й (\(1\le i\le n\)) строке и \(j\)-м (\(1\le j\le m\)) столбце через \((i, j)\), а число в ней через \(a_{ij}\).

Майкл начинает с того, что называет два числа \(h\) (\(1\le h \le n\)) и \(w\) (\(1\le w \le m\)). Затем Джо выбирает любой подпрямоугольник доски размером \(h\times w\) (так, чтобы Майкл не видел).

Формально, подпрямоугольник \(h\times w\) начинается с некоторой ячейки \((a,b)\), где \(1 \le a \le n-h+1\) и \(1 \le b \le m-w+1\). Он содержит все ячейки \((i,j)\) с \(a \le i \le a+h-1\) и \(b \le j \le b+w-1\).

Возможный ход Джо, если Майкл скажет \(3\times 2\) (с максимумом в \(15\)).

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

Так как Майкл не любит большие числа, он хочет, чтобы площадь выбранного подпрямоугольника (то есть \(h \cdot w\)) была как можно меньше, но чтобы при этом он мог выиграть, независимо от выбора Джо. Помогите Майклу найти эту минимально возможную площадь.

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

Входные данные

Каждый тест содержит несколько наборов входных данных. Первая строка содержит количество наборов входных данных \(t\) (\(1 \le t \le 20\)). Далее следует описание наборов входных данных.

Первая строка каждого набора входных данных содержит два целых числа \(n\) и \(m\) (\(1 \le n, m \le 40\))  — размер таблицы.

Каждая из следующих \(n\) строк содержит \(m\) целых чисел. \(j\)-е целое число в \(i\)-й строке это \(a_{ij}\) (\(-10^9 \le a_{ij} \le 10^9\))  — элемент в ячейке \((i, j)\).

Гарантируется, что все числа попарно различны (то есть, если \(a_{i_1j_1} = a_{i_2j_2}\), то \(i_1 = i_2, j_1 = j_2\)).

Выходные данные

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

Примечание

В первом примере таблица имеет размер \(1\times 1\), поэтому единственным возможным выбором для \(h, w\) является \(h = 1, w = 1\), что дает площадь \(h\cdot w = 1\).

Таблица из второго набора входных данных нарисована в условии. Можно показать, что при \(h = 3, w = 3\) Майкл может гарантировать победу и что любой выбор с \(h\cdot w \le 8\) победы не гарантирует.

B. Игра по кругу

жадные алгоритмы игры *1000

Майк и Джо играют в игру с камнями. У них есть \(n\) кучек камней размерами \(a_1, a_2, \ldots, a_n\). Эти кучки расположены по кругу.

Игра проходит следующим образом. Игроки по очереди удаляют некоторое положительное число камней из кучек по часовой стрелке, начиная с кучки \(1\). Формально, если игрок в свой ход убрал камни из кучки \(i\), то другой игрок в следующий ход убирает камни из кучки \(((i\bmod n) + 1)\).

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

Если Майк и Джо играют оптимально, кто выиграет?

Входные данные

Каждый тест содержит несколько наборов входных данных. Первая строка содержит количество наборов входных данных \(t\) (\(1 \le t \le 1000\)). Далее следует описание наборов входных данных.

Первая строка каждого набора входных данных содержит одно целое число \(n\) (\(1 \le n \le 50\))  — количество кучек.

Вторая строка содержит \(n\) целых чисел \(a_1, a_2, \ldots, a_n\) (\(1 \le a_i \le 10^9\))  — размеры кучек.

Выходные данные

Для каждого набора входных данных выведите победителя игры, либо «Mike», либо «Joe», в отдельной строке (без кавычек).

Примечание

В первом наборе входных данных Майк просто берет все \(37\) камней на своем первом ходу.

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

F. Игра-раскраска

дп игры Конструктив *2600

Алиса и Боб играют в игру. В строке \(n\) ячеек. Изначально каждая ячейка либо красная, либо синяя. Алиса ходит первой.

На каждом ходу Алиса выбирает две соседние клетки, в которых есть хотя бы одна красная клетка, и окрашивает эти две клетки в белый цвет. Затем Боб выбирает две соседние клетки, содержащие хотя бы одну синюю клетку, и окрашивает эти две клетки в белый цвет. Игрок, который не может сделать ход, проигрывает.

Определите победителя, если и Алиса, и Боб играют оптимально.

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

Входные данные

Первая строка содержит единственное целое число \(t\) (\(1 \leq t \leq 10^4\)) — количество наборов входных данных. Далее следует их описание.

Для каждого набора входных данных первая строка содержит целое число \(n\) (\(2 \leq n \leq 5 \cdot 10^5\)) — количество ячеек.

Вторая строка содержит строку \(s\) длины \(n\) — начальное состояние ячеек. \(i\)-я ячейка красная, если \(s_i = \)R, и синяя, если \(s_i = \)B.

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

Выходные данные

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

Примечание

В первом наборе входных данных у Алисы есть два варианта: закрасить первую и вторую клетки или закрасить вторую и третью клетки. Какой бы выбор ни сделала Алиса, после хода Алисы останется ровно одна синяя клетка. Бобу нужно просто закрасить синюю клетку и ее соседнюю, тогда каждая клетка будет белой и Алиса не сможет сделать ход. Итак, Боб — победитель.

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

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

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

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

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

E. Два массива

Бинарный поиск игры Паросочетания *2400

Вам даны два массива целых чисел \(a_1,a_2,\dots,a_n\) и \(b_1,b_2,\dots,b_m\).

Алиса и Боб играют в игру. Алиса ходит первой, а затем они ходят по очереди.

Они играют на доске \(n \times m\) (\(n\) строк и \(m\) столбцов). Изначально в клетке в первой строке и первом столбце стоит ладья.

В свой ход игрок может сделать одну из следующих двух операций:

  1. Переместить ладью в другую клетку в том же ряду или в том же столбце с текущей клеткой. Игрок не может переместить ладью в клетку, которая уже была посещена \(1000\) раз до этого (т. е. ладья может находиться на одной клетке не более \(1000\) раз за всю игру). Обратите внимание, что стартовая клетка считается уже посещенной один раз в начале игры.
  2. Немедленно закончить игру со счетом \(a_r+b_c\), где \((r, c)\) — координаты текущей клетки (т. е. ладья находится в \(r\)-й строку \(c\)-м столбце).

Боб хочет максимизировать счет игры, а Алиса хочет минимизировать его. Если они оба играют оптимально, каким будет итоговый счет?

Входные данные

Первая строка содержит два целых числа \(n\) и \(m\) (\(1 \leq n,m \leq 2 \cdot 10^5\)) — длины массивов \(a\) и \(b\) (которые совпадают с размерами доски).

Вторая строка содержит \(n\) целых чисел \(a_1, a_2, \dots, a_n\) (\(1 \leq a_i \leq 5 \cdot 10^8\)).

Третья строка содержит \(m\) целых чисел \(b_1, b_2,\dots, b_n\) (\(1 \leq b_i \leq 5 \cdot 10^8\)).

Выходные данные

Выведите одну строку — итоговый счет игры.

Примечание

В первом примере Алиса передвинет ладью на клетку \((2, 1)\), а Боб передвинет ладью обратно на клетку \((1, 1)\). Этот процесс повторится \(999\) раз, а затем, после хода Алисы, Боб не сможет передвинуть ладью обратно на клетку \((1, 1)\), так как она уже была посещена \(1000\) раз. Поэтому счет игры будет равен \(a_2+b_1=4\).

Во втором примере счет игры равен \(a_3+b_5\).

A. Игра с фишкой

игры математика *800

Бурёнка и Тоня играют в старинную бурятскую игру с фишкой на поле \(n \times m\) клеток.

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

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

Стартовая клетка фишки имеет зелёный цвет, единственная клетка, из которой нельзя сделать ход — красный. Если фишка находится в жёлтой клетке, то голубые клетки — это все варианты того, куда её можно сдвинуть за один ход.
Входные данные

Первая строка содержит одно целое число \(t\) (\(1 \leq t \leq 10^4\)) — количество наборов входных данных. Далее следует описание наборов входных данных.

Единственная строка каждого набора входных данных содержит два целых числа \(n\) и \(m\) (\(1 \leq n, m \leq 10^9\)) — размеры игровой доски.

Выходные данные

Для каждого набора входных данных выведите единственную строку — имя победителя игры («Burenka» или «Tonya»).

Примечание

В первом наборе входных данных у Бурёнки нет хода, поэтому выигрывает Тоня.

Во втором наборе входных данных Бурёнка может сходить на \(3\) клетки вправо, после этого у Тони не будет возможности сделать ход, значит, выигрывает Бурёнка.

В третьем наборе входных данных Бурёнка может сходить на \(5\) клеток вправо. Тогда можно считать, что игра происходит на поле \(1 \times 5\), а первый ход делает Тоня. В игре на таком поле побеждает второй игрок, поэтому в исходной игре победит Бурёнка.

D. Выбор букв

дп игры Конструктив *1800

Алиса и Боб играют в игру. Изначально им дана непустая строка \(s\), состоящая из строчных латинских букв. Длина строки четная. У каждого игрока также есть своя строка, изначально пустая.

Алиса начинает, затем они ходят по очереди. За один ход игрок берет либо первую, либо последнюю букву из строки \(s\), удаляет ее из \(s\) и приписывает ее в начало своей строки.

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

Строка \(a\) лексикографически меньше строки \(b\), если существует такая позиция \(i\), что \(a_j = b_j\) для всех \(j < i\) и \(a_i < b_i\).

С каким результатом закончится игра, если оба игрока играют оптимально (т. е. оба игрока стараются выиграть; если они не могут, то стараются сыграть вничью)?

Входные данные

В первой строке записано одно целое число \(t\) (\(1 \le t \le 1000\)) — количество наборов входных данных.

Каждый набор входных данных состоит из одной строки — непустой строки \(s\), состоящей из строчных латинских букв. Длина строки \(s\) четная.

Суммарная длина строк по всем наборам входных данных не превосходит \(2000\).

Выходные данные

На каждый набор входных данных выведите результат игры, если оба игрока играют оптимально. Если Алиса выиграет, то выведите «Alice». Если Боб выиграет, то выведите «Bob». Если игра закончится вничью, то выведите «Draw».

Примечание

Одна из возможных игр, которую могут сыграть Алиса и Боб в первом наборе входных данных:

  1. Алиса выбирает первую букву в \(s\): \(s=\)«orces», \(a=\)«f», \(b=\)«»;
  2. Боб выбирает последнюю букву в \(s\): \(s=\)«orce», \(a=\)«f», \(b=\)«s»;
  3. Алиса выбирает последнюю букву в \(s\): \(s=\)«orc», \(a=\)«ef», \(b=\)«s»;
  4. Боб выбирает первую букву в \(s\): \(s=\)«rc», \(a=\)«ef», \(b=\)«os»;
  5. Алиса выбирает последнюю букву в \(s\): \(s=\)«r», \(a=\)«cef», \(b=\)«os»;
  6. Боб выбирает оставшуюся букву в \(s\): \(s=\)«», \(a=\)«cef», \(b=\)«ros».

Алиса выигрывает, потому что «cef» < «ros». Ни один из игроков не следует никакой стратегии в конкретно этой игре, поэтому она не показывает, что Алиса выигрывает, если игроки играют оптимально.

C. Эла и сверчки

игры Конструктив математика реализация *1500

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

Задача, которая включает в себя нестандартный тип шахматных фигур, описанный ниже, гласит: даны \(3\) белых сверчка на доске \(n \cdot n\), расположенных в форме буквы «L» рядом друг с другом. Других фигур на доске нет. Эла хочет знать, может ли она за конечное количество ходов поставить какого-либо белого сверчка на клетку на горизонтали \(x\) и на вертикали \(y\)?

Расположение фигур в форме буквы «L» может быть только одним из следующих:

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

Для лучшего понимания, смотрите примеры ходов сверчка в описании к примеру.

Входные данные

Во входных данных находятся несколько наборов входных данных. В первой строке находится одно целое число \(t\) (\(1 \le t \le 10^4\)) — количество наборов входных данных. Далее следуют наборы входных данных.

Первая строка каждого набора входных данных содержит одно целое число \(n\) (\(4 \le n \le 10^5\)) — размер шахматной доски.

Вторая строка каждого набора входных данных содержит шесть чисел: \(r_1\), \(c_1\), \(r_2\), \(c_2\), \(r_3\), \(c_3\) (\(1 \le r_1, c_1, r_2, c_2, r_3, c_3 \le n\)) — координаты сверчков. Ввод гарантирует, что три сверчка расположены в форме буквы «L», одним из способов, которые показаны в условии.

Третья строка каждого набора входных данных содержит 2 числа: \(x\), \(y\) (\(1 \le x, y \le n\)) — координаты клетки, куда надо поставить сверчка.

Выходные данные

Для каждого набора входных данных выведите «YES», если Эла может поставить сверчка на требуемую клетку, и «NO» иначе

Примечание

Решение для первого примера. Сверчка нужно поставить в красную клетку. Обратите внимание, что в шахматах горизонтали нумеруются снизу вверх, как и на этой картинке.

C. Упоротые четные числа

дп жадные алгоритмы игры математика *1500

Алиса и Боб играют в игру на последовательности \(a_1, a_2, \dots, a_n\) длины \(n\). Их ходы чередуются, и Алиса ходит первой.

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

Алиса выигрывает, если сумма убранных ей чисел четная; в противном случае выигрывает Боб.

Ваша задача определить кто победит, если оба игрока играют оптимально.

Входные данные

Первая строка содержит целое число \(t\) (\(1 \leq t \leq 100\)) — Количество наборов входных данных. Затем следуют описания наборов входных данных.

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

Во второй строке набора входных данных содержится \(n\) целых чисел \(a_1, a_2, \dots, a_n\) (\(-10^9 \leq a_i \leq 10^9\)), сама последовательность.

Выходные данные

Для каждого набор входных данных выведите «Alice» (без кавычек) если Алиса побеждает, и «Bob» (без кавычек) в противном случае.

Примечание

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

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

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

C. Карточная игра

дп игры Комбинаторика Конструктив *1500

Рассмотрим игру с \(n\) картами (\(n\) четное). На каждой карте написано число от \(1\) до \(n\). Числа на всех картах различны. Скажем, что карта с числом \(x\) сильнее карты с числом \(y\), если \(x > y\).

Два игрока, Алексей и Борис играют в эту игру. В начале каждый из них получает ровно по \(\frac{n}{2}\) карт, так что каждая карта находится ровно у одного игрока. Затем они ходят по очереди. Сначала ходит Алексей, затем Борис, затем снова Алексей и так далее.

На своем ходу игрок должен сыграть ровно одну из своих карт. Затем, если у соперника нет карт сильнее сыгранной карты, то соперник проигрывает, и игра заканчивается. Иначе соперник должен сыграть карту сильнее сыгранной (тоже ровно одну). Эти две карты удаляются из игры, и ход заканчивается. Если карт больше нет, то игра заканчивается вничью; иначе ход переходит к сопернику.

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

  • количество способов раздать карты так, чтобы выиграл Алексей;
  • количество способов раздать карты так, чтобы выиграл Борис;
  • количество способов раздать карты так, чтобы игра закончилась вничью.

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

Например, пусть \(n = 4\), Алексей получает карты \([2, 3]\), а Борис получает карты \([1, 4]\). Игра может пойти следующим образом:

  • если Алексей играет карту \(2\), Борис должен ответить картой \(4\). Ход Алексея заканчивается, и начинается ход Бориса. У Бориса осталась только карта \(1\); он играет ее, и Алексей отвечает картой \(3\). Игра заканчивается ничьей;
  • если Алексей играет карту \(3\), Борис должен ответить картой \(4\). Ход Алексея заканчивается, и начинается ход Бориса. У Бориса осталась только карта \(1\); он играет ее, и Алексей отвечает картой \(2\). Игра заканчивается ничьей.

Таким образом, в этом случае игра заканчивается вничью.

Входные данные

В первой строке записано одно целое число \(t\) (\(1 \le t \le 30\)) — количество наборов входных данных.

Затем следуют \(t\) строк. В \(i\)-й строке записано одно четное число \(n\) (\(2 \le n \le 60\)).

Выходные данные

На каждый набор входных данных выведите три числа:

  • количество способов раздать карты так, чтобы выиграл Алексей;
  • количество способов раздать карты так, чтобы выиграл Борис;
  • количество способов раздать карты так, чтобы игра закончилась вничью.

Так как ответ может быть достаточно большим, выведите его по модулю \(998244353\).

Примечание

В первом наборе входных данных Алексей выигрывает, если он получает карту \(2\) (он ее играет, а Борис не может ответить). Если Алексей получает карту \(1\), то игра заканчивается вничью.

Во втором наборе входных данных:

  • Алексей выигрывает, если он получает карты \([3, 4]\), \([2, 4]\) или \([1, 4]\);
  • Борис выигрывает, если Алексей получает карты \([1, 2]\) или \([1, 3]\);
  • игра заканчивается вничью, если Алексей получает карты \([2, 3]\).

C. Кубики и мешки

жадные алгоритмы игры Конструктив сортировки *1400

Есть \(n\) кубиков, пронумерованных от \(1\) до \(n\). Кубик \(i\) имеет вес \(a_i\).

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

После того, как Пак Чанек разложит кубики, Бу Денгклек возьмет ровно по одному кубику из каждого мешка. Пусть \(w_j\) — вес кубика, который Бу Денгклек берет из мешка \(j\). Результатом всех действий назовем число \(|w_1 - w_2| + |w_2 - w_3|\), где \(|x|\) — модуль числа \(x\).

Известно, что Денгклек будет брать кубики таким образом, чтобы минимизировать результат. Чему равен максимально возможный результат, если Пак Чанек раскладывает кубики оптимально?

Входные данные

Каждый тест содержит несколько наборов входных данных. Первая строка содержит целое число \(t\) (\(1 \leq t \leq 2 \cdot 10^4\)) — количество наборов. Следующие строки содержат описание каждого набора.

Первая строка каждого набора входных данных содержит целое число \(n\) (\(3 \leq n \leq 2 \cdot 10^5\)) — количество кубиков.

Вторая строка каждого набора содержит \(n\) целых чисел \(a_1, a_2, \ldots, a_n\) (\(1 \leq a_i \leq 10^9\)) — веса кубиков.

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

Выходные данные

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

Примечание

В первом наборе входных данные, один из вариантов получить итоговый результат, равный \(6\), выглядит следующим образом:

  • Положить кубики \(1\), \(4\), и \(5\) в мешок \(1\).
  • Положить кубик \(3\) в мешок \(2\).
  • Положить кубик \(2\) в мешок \(3\).

Если Пак Чанек разложит кубики таким образом, то Денгклек может взять кубики следующим образом:

  • Взять кубик \(5\) из мешка \(1\).
  • Взять кубик \(3\) из мешка \(2\).
  • Взять кубик \(2\) из мешка \(3\).

Результат равен \(|a_5 - a_3| + |a_3 - a_2| = |3 - 5| + |5 - 1| = 6\). Можно показать, что Бу Денгклек не может получить меньший результат при таком распределении кубиков.

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

C. Игра обменов

игры *1200

Алиса и Боб играют в игру c массивом \(a\) из \(n\) целых положительных чисел. Алиса и Боб делают ходы по очереди, причем Алиса ходит первой.

В свой ход игрок делает следующий ход:

  • Если \(a_1 = 0\), игрок проигрывает игру, иначе:
  • Игрок выбирает некоторое число \(i\) с \(2\le i \le n\). Затем он уменьшает значение \(a_1\) на \(1\) и меняет местами \(a_1\) и \(a_i\).

Определите победителя игры, если оба игрока играют оптимально.

Входные данные

Входные данные состоят из нескольких наборов входных данных. Первая строка содержит одно целое число \(t\) \((1 \leq t \leq 2 \cdot 10^4)\)  — количество наборов входных данных. Далее следует описание наборов входных данных.

Первая строка каждого набора входных данных содержит одно целое число \(n\) \((2 \leq n \leq 10^5)\)  — длину массива \(a\).

Вторая строка каждого набора входных данных содержит \(n\) целых чисел \(a_1,a_2 \ldots a_n\) \((1 \leq a_i \leq 10^9)\)  — элементы массива \(a\).

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

Выходные данные

Для каждого набора входных данных, если Алиса выиграет игру, выведите «Alice». В противном случае выведите «Bob».

Вы можете выводить каждую букву в любом регистре. Например, «alIcE», «Alice», «alice» будут считаться одинаковыми.

Примечание

В первом наборе входных данных, в свой ход Алиса может выбрать только \(i = 2\), сделав массив равным \([1, 0]\). Тогда Боб, в свою очередь, также выберет \(i = 2\) и сделает массив равным \([0, 0]\). Поскольку \(a_1 = 0\), Алиса проигрывает.

Во втором наборе входных данных, опять же, игроки могут выбирать только \(i = 2\). Тогда массив будет изменяться следующим образом: \([2, 1] \to [1, 1] \to [1, 0] \to [0, 0]\), и Боб проигрывает.

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

C. Игра с числами

Бинарный поиск жадные алгоритмы игры реализация Структуры данных *1400

Алиса и Боб играют в игру. У них есть массив положительных целых чисел \(a\) размера \(n\).

Перед началом игры Алиса выбирает целое число \(k \ge 0\). Игра длится \(k\) ходов, номера ходов нумеруются от \(1\) до \(k\). На \(i\)-м ходу Алиса должна удалить из массива элемент, который меньше либо равен \(k - i + 1\). После этого, если массив не пустой, Боб должен прибавить к некоторому элементу массива \(k - i + 1\). Обратите внимание, что и действие Алисы, и следующее за ним действие Боба — это две части одного и того же хода. Если Алиса не может удалить элемент на каком-то ходу — она проигрывает. Если \(k\)-й ход закончился, а Алиса еще не проиграла, то она выигрывает.

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

Входные данные

Первая строка содержит одно целое число \(t\) (\(1 \le t \le 100\)) — количество наборов входных данных.

Первая строка каждого набора содержит одно целое число \(n\) (\(1 \le n \le 100\)) — размер массива \(a\).

Вторая строка содержит \(n\) целых чисел \(a_1, a_2, \dots, a_n\) (\(1 \le a_i \le n\)).

Выходные данные

Для каждого набора входных данных выведите одно целое число — максимальное значение \(k\), при котором Алиса может выиграть при оптимальной игре обоих игроков.

D. Косия и игра

графы игры Конструктив Паросочетания поиск в глубину и подобное Потоки реализация снм Структуры данных *2000

Косия и Махиру играют в игру с тремя массивами \(a\), \(b\) и \(c\) длины \(n\). Каждый элемент \(a\), \(b\) и \(c\) — целое число от \(1\) до \(n\) включительно.

Игра состоит из \(n\) раундов. В \(i\)-м раунде они делают следующие ходы:

  • Пусть \(S\) — мультимножество \(\{a_i, b_i, c_i\}\).
  • Косия удаляет один из элементов \(S\) по своему выбору.
  • Затем Махиру выбирает одно из двух оставшихся в \(S\) чисел.

Пусть \(d_i\) — число, выбранное Махиру в \(i\)-м раунде. Если \(d\) является перестановкой\(^\dagger\), Косия выигрывает. Иначе выигрывает Махиру.

Сейчас выбраны только массивы \(a\) и \(b\). Являясь ярым поклонником Косии, вы хотите выбрать массив \(c\) так, чтобы Косия выиграла. Вычислите количество таких \(c\) по модулю \(998\,244\,353\).

Обратите внимание, что Косия и Махиру играют оптимально.

\(^\dagger\) Перестановкой длины \(n\) является массив, состоящий из \(n\) различных целых чисел от \(1\) до \(n\) в произвольном порядке. Например, \([2,3,1,5,4]\) — перестановка, но \([1,2,2]\) не перестановка (\(2\) встречается в массиве дважды) и \([1,3,4]\) тоже не перестановка (\(n=3\), но в массиве встречается \(4\)).

Входные данные

Каждый тест состоит из нескольких наборов входных данных. В первой строке находится одно целое число \(t\) (\(1 \leq t \leq 2 \cdot 10^4\)) — количество наборов входных данных. Далее следует описание наборов входных данных.

Первая строка каждого набора входных данных содержит одно целое число \(n\) (\(1 \leq n \leq {10}^5\)) — размеры массивов.

Вторая строка содержит \(n\) целых чисел \(a_1, a_2, \dots, a_n\) (\(1 \leq a_i \leq n\)).

Третья строка содержит \(n\) целых чисел \(b_1, b_2, \dots, b_n\) (\(1 \leq b_i \leq n\)).

Гарантируется, что сумма значений \(n\) по всем наборам входных данных не превосходит \({10}^5\).

Выходные данные

Выведите одно целое число — количество массивов \(c\), при которых выигрывает Косия, по модулю \(998\,244\,353\).

Примечание

В первом примере есть \(6\) массивов \(c\), при которых выигрывает Косия: \([1, 2, 3]\), \([1, 3, 2]\), \([2, 2, 3]\), \([2, 3, 2]\), \([3, 2, 3]\), \([3, 3, 2]\).

Во втором примере можно показать, что нет массивов \(c\), при которых выигрывает Косия.

E. Игра с перестановкой

игры *1700

Два игрока играют в игру. У них есть перестановка чисел \(1\), \(2\), ..., \(n\) (перестановка — это массив, в котором каждый элемент от \(1\) до \(n\) встречается ровно один раз). Перестановка не отсортирована ни в прямом, ни в обратном порядке (т.е. перестановка не имеет вид \([1, 2, \dots, n]\) или \([n, n-1, \dots, 1]\)).

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

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

Первый игрок выигрывает, если перестановка окажется отсортирована в порядке возрастания (т.е. станет равна \([1, 2, \dots, n]\)). Второй — если перестановка окажется отсортирована в порядке убывания (т.е. станет равна \([n, n-1, \dots, 1]\)). Если игра длится \(100^{500}\) ходов и никто не выигрывает, она заканчивается вничью.

Ваша задача — определить результат игры при оптимальной игре обоих игроков.

Входные данные

Первая строка содержит одно целое чисел \(t\) (\(1 \le t \le 10^5\)) — количество наборов входных данных.

Первая строка каждого набора входных данных содержит одно целое число \(n\) (\(3 \le n \le 5 \cdot 10^5\)) — размер перестановки.

Вторая строка содержит \(n\) целых чисел \(p_1, p_2, \dots, p_n\) — сама перестановка. Перестановка \(p\) не отсортирована ни в прямом, ни в обратном порядке.

Сумма \(n\) по всем наборам входных данных не превосходит \(5 \cdot 10^5\).

Выходные данные

Для каждого набора входных данных выведите First, если победу одержит первый игрок, Second, если победу одержит второй игрок, и Tie, если результатом будет ничья.

Примечание

Давайте покажем, как первый игрок выигрывает в первом примере.

Он должен покрасить элементы \(3\) и \(4\) в синий цвет в течение первых двух ходов, а затем он может изменить порядок синих элементов таким образом, чтобы перестановка стала равна \([1, 2, 3, 4]\). Второй игрок не может ни вмешаться в эту стратегию, ни выиграть быстрее.

C. Library game

жадные алгоритмы игры интерактив сортировки *2500

Alessia and Bernardo are discovering the world of competitive programming through the books of their university library.

The library consists of \(m\) sections numbered from \(1\) to \(m\). Each section contains only books dedicated to a particular subject and different sections correspond to different subjects. In order to prevent the students from wandering in the library, the university has established a system of passes. Each pass has a length \(y\) associated to it and allows access to an interval of \(y\) consecutive sections in the library. During a visit, the student must choose exactly one book from one of these sections and leave the library. Each pass can be used only once.

At the moment Alessia and Bernardo have \(n\) passes of lengths \(x_1, \, x_2, \, \dots, \, x_n\). They have different opinions on the best way to improve: Alessia thinks that it is important to study many different topics, while Bernardo believes that it is important to study deeply at least one topic. So, Alessia wants to use the \(n\) passes to get \(n\) books on distinct topics, while Bernardo would like to get at least two books on the same topic.

They have reached the following agreement: for each of the following \(n\) days, Alessia will choose a pass of length \(y\) among those which are still available and an interval of \(y\) sections in the library, and Bernardo will go into the library and will take exactly one book from one of those sections.

Can Bernardo manage to get at least two books on the same subject, or will Alessia be able to avoid it?

You should decide whether you want to be Alessia or Bernardo, and you have to fulfill the goal of your chosen character. The judge will impersonate the other character. Note that, even if at some moment Bernardo has already taken two books on the same subject, the interaction should go on until the end of the \(n\) days.

Input

The first line contains two integers \(n\) and \(m\) (\(1 \le n \le 100\), \(n \le m \le 5000\)) — the number of passes and the number of sections.

The second line contains \(n\) integers \(x_1, \, x_2, \, \dots, \, x_n\) (\(1 \le x_i \le m\)) — the lengths of the passes available.

Interaction

First, you should print a line containing either the string \(\texttt{Alessia}\) or the string \(\texttt{Bernardo}\) — the character that you want to impersonate.

Then, for each of the \(n\) turns:

  • If you are taking the role of Alessia, print a single line consisting of two integers \(y\) and \(a\) (\(1 \le a \le m - y + 1\)) — you are choosing a pass of length \(y\) and the interval of sections \([a, a + y - 1]\). Note that at least one pass of length \(y\) must still be available. After this, read a single integer \(b\) (\(a \le b \le a + y - 1\)) — the subject of the book selected by Bernardo.
  • If you are taking the role of Bernardo, read two integers \(y\) and \(a\) (\(1 \le a \le m - y + 1\)) — the length of the pass chosen by Alessia and the index of the first section of the interval. It is guaranteed that there is at least one pass of length \(y\) available. Then, print a line consisting of a single integer \(b\) (\(a \le b \le a + y - 1\)) — the subject from which you choose to take a book.

If one of your interactions is malformed, the interactor terminates immediately and your program receives the verdict \(\texttt{WRONG-ANSWER}\). Otherwise, you will receive the verdict according to the game's criteria described above.

After printing a line do not forget to end the line and flush the output. Otherwise, you will get the verdict \(\texttt{TIMELIMIT}\). To flush the output, use:

  • \(\texttt{fflush(stdout)}\) in C;
  • \(\texttt{fflush(stdout)}\), \(\texttt{cout <}\texttt{< flush}\) or \(\texttt{cout.flush()}\) in C++;
  • \(\texttt{System.out.flush()}\) in Java and Kotlin;
  • \(\texttt{sys.stdout.flush()}\) in Python.
Note

In the first sample, it can be shown that Alessia can accomplish her goal. An example of interaction (after reading the input) follows:

\(\) \begin{array}{|c|c|c|} \hline \textbf{Contestant} & \textbf{Judge} & \textbf{Explanation} \\ \hline \texttt{Alessia} & & \text{The program will act as Alessia} \\ \hline 3 \quad 11 & & \text{Choose $y = 3$ and $a = 11$} \\ \hline & 13 & \text{Judge selects $b = 13$} \\ \hline 10 \quad 2 & & \text{Choose $y = 10$ and $a = 2$} \\ \hline & 9 & \text{Judge selects $b = 9$} \\ \hline 7 \quad 1 & & \text{Choose $y = 7$ and $a = 1$} \\ \hline & 4 & \text{Judge selects $b = 4$} \\ \hline 2 \quad 10 & & \text{Choose $y = 2$ and $a = 10$} \\ \hline & 10 & \text{Judge selects $b = 10$} \\ \hline 3 \quad 6 & & \text{Choose $y = 3$ and $a = 6$} \\ \hline & 7 & \text{Judge selects $b = 7$} \\ \hline \end{array} \(\)

The program of the contestant wins because all the books chosen by Bernardo pertain to different topics. The actions performed by the contestant and the judge in this example of interaction may be non-optimal.

In the second sample, it can be shown that Bernardo can manage to fulfil his goal. An example of interaction (after reading the input) follows:

\(\) \begin{array}{|c|c|c|} \hline \textbf{Contestant} & \textbf{Judge} & \textbf{Explanation} \\ \hline \texttt{Bernardo} & & \text{The program will act as Bernardo} \\ \hline & 4 \quad 1 & \text{Judge chooses $y = 4$ and $a = 1$} \\ \hline 4 & & \text{Select $b = 4$} \\ \hline & 1 \quad 10 & \text{Judge chooses $y = 1$ and $a = 10$} \\ \hline 10 & & \text{Select $b = 10$} \\ \hline & 6 \quad 3 & \text{Judge chooses $y = 6$ and $a = 3$} \\ \hline 4 & & \text{Select $b = 4$} \\ \hline & 4 \quad 5 & \text{Judge chooses $y = 4$ and $a = 5$} \\ \hline 8 & & \text{Select $b = 8$} \\ \hline \end{array} \(\)

The program of the contestant wins because Bernardo has selected two books on topic number \(4\). The actions performed by the contestant and the judge in this example of interaction may be non-optimal.

I. Spinach Pizza

геометрия жадные алгоритмы игры интерактив *2500

The two siblings Alberto and Beatrice have to eat a spinach pizza together. However, none of them likes spinach, so they both want to eat as little as possible.

The pizza has the shape of a strictly convex polygon with \(n\) vertices located at integer coordinates \((x_1, y_1), \, (x_2, y_2), \, \dots, \, (x_n, y_n)\) of the plane.

The siblings have decided to eat the pizza in the following way: taking turns, starting with Alberto, each sibling chooses a vertex of the remaining part of the pizza and eats out the triangle determined by its two neighboring edges. In this way, after each of the first \(n - 3\) turns the pizza will have one less vertex. The game ends after the \((n - 2)\)-th turn, when all the pizza has been eaten.

Assuming that Alberto and Beatrice choose the slices to eat optimally, which of the siblings manages to eat at most half of the pizza? You should identify a sibling that has a strategy to do so and help them choose the slices appropriately. Note that it is possible that both Alberto and Beatrice end up eating exactly half of the area if they choose their slices optimally.

Input

The first line contains a single integer \(n\) (\(4 \le n \le 100\)) — the number of vertices.

The next \(n\) lines contain two integers \(x_i\) and \(y_i\) each (\(-10^6 \le x_i, y_i \le 10^6\)) — the coordinates of the \(i\)-th vertex of the polygon representing the initial shape of the pizza.

It is guaranteed that the polygon is strictly convex and that its vertices are given in counterclockwise order.

Interaction

First, you should print a line containing either the string \(\texttt{Alberto}\) or the string \(\texttt{Beatrice}\) — the sibling that you will help to win.

Then, for the next \(n - 2\) turns, you will alternate with the judge in choosing a slice of the pizza and removing it, starting with you if you chose to help Alberto, or starting with the judge if you chose to help Beatrice.

  • When it is your turn, print a single line containing an integer \(p\) (\(1 \leq p \leq n\)) that has not been chosen before, indicating that you want to eat the slice determined by the vertex located at \((x_p, y_p)\).
  • When it is the judge's turn, read an integer \(q\) (\(1 \leq q \leq n\)), indicating that the other player eats the slice determined by the vertex located at \((x_q, y_q)\). It is guaranteed that \(q\) has not been chosen before.

If one of your interactions is malformed, the interactor terminates immediately and your program receives the verdict \(\texttt{WRONG-ANSWER}\). Otherwise, you will receive \(\texttt{CORRECT}\) if at the end your player has eaten at most half of the pizza, and \(\texttt{WRONG-ANSWER}\) otherwise.

After printing a line do not forget to end the line and flush the output. Otherwise, you will get the verdict \(\texttt{TIMELIMIT}\). To flush the output, use:

  • \(\texttt{fflush(stdout)}\) in C;
  • \(\texttt{fflush(stdout)}\), \(\texttt{cout <}\texttt{< flush}\) or \(\texttt{cout.flush()}\) in C++;
  • \(\texttt{System.out.flush()}\) in Java and Kotlin;
  • \(\texttt{sys.stdout.flush()}\) in Python.
Note

In the first sample, the pizza has area \(15\). Alberto can eat less than half of the pizza by eating the slice around vertex \(2\) (which has area \(6.5\)) or around vertex \(3\) (which has area \(3.5\)).

In the second sample, it can be proved that both players will eat exactly half of the pizza if they eat optimally. Therefore it is possible to choose to help either Alberto or Beatrice.

In the third sample, it is possible to show that only Beatrice has a strategy to eat at most half of the pizza. The following is an example of a valid interaction (after reading the input):

\(\) \begin{array}{|c|c|c|} \hline \textbf{Contestant} & \textbf{Judge} & \textbf{Explanation} \\ \hline \texttt{Beatrice} & & \text{The contestant will help Beatrice} \\ \hline & \texttt{7} & \text{Alberto eats the triangle with vertices $6$, $7$, $1$ and area $1$} \\ \hline \texttt{2} & & \text{Beatrice eats the triangle with vertices $1$, $2$, $3$ and area $2$} \\ \hline & \texttt{5} & \text{Alberto eats the triangle with vertices $4$, $5$, $6$ and area $1.5$} \\ \hline \texttt{4} & & \text{Beatrice eats the triangle with vertices $3$, $4$, $6$ and area $8$} \\ \hline & \texttt{6} & \text{Alberto eats the triangle with vertices $3$, $6$, $1$ and area $11$} \\ \hline \end{array} \(\) The total area eaten by Alberto is \(13.5\) and the total area eaten by Beatrice is \(10\), which is less than half the area of the whole pizza. The actions performed by the contestant and the judge in this example of interaction may be non-optimal. The process is illustrated below:

E. Бесконечная игра

дп игры Комбинаторика Перебор Теория вероятностей *3100

Алиса и Боб играют в бесконечную игру, состоящую из сетов. Каждый сет состоит из раундов. В каждом раунде выигрывает один из игроков. В сете выигрывает тот, кто первым выиграет два раунда. Соответственно, сет всегда заканчивается со счётом \(2:0\) или \(2:1\) по раундам в пользу одного из игроков.

Сценарием игры назовём конечную строку \(s\) из символов «a» и «b». Рассмотрим бесконечную строку, образованную повторениями строки \(s\): \(sss \ldots\) Пусть игроки играют раунды в соответствии с этой бесконечной строкой по порядку. Если очередной символ строки \(sss \ldots\) равен «a», то в текущем раунде выигрывает Алиса, если «b» — выигрывает Боб. Как только один из игроков выигрывает два раунда, сет завершается в его пользу, и со следующего раунда начинается новый сет.

Пусть \(a_i\) равно числу выигранных Алисой сетов среди первых \(i\) сетов при игре по данному сценарию. Обозначим через \(r\) предел отношения \(\frac{a_i}{i}\) при \(i \rightarrow \infty\). Если \(r > \frac{1}{2}\), то строку \(s\) назовём выигрышным для Алисы сценарием. Если \(r = \frac{1}{2}\), то строку \(s\) назовём ничейным сценарием. Если \(r < \frac{1}{2}\), то строку \(s\) назовём выигрышным для Боба сценарием.

Вам дана строка \(s\), состоящая из символов «a», «b» и «?». Рассмотрим все способы заменить каждый символ «?» на «a» или «b», чтобы получить строку, состоящую только из символов «a» и «b». Посчитайте, в скольких случаях получится выигрышный для Алисы сценарий, в скольких — ничейный, а в скольких — выигрышный для Боба, и выведите эти три числа по модулю \(998\,244\,353\).

Входные данные

Единственная строка ввода содержит строку \(s\) (\(1 \le |s| \le 200\)), состоящую из символов «a», «b» и «?».

Выходные данные

Выведите три числа: сколько способов замены приведут к выигрышному для Алисы сценарию, сколько — к ничейному, а сколько — к выигрышному для Боба. Все числа нужно вывести по модулю \(998\,244\,353\).

Примечание

В первом примере есть четыре варианта замены:

  • \(s = \mathtt{aa}\): Алиса выигрывает все сеты со счётом \(2:0\) — сценарий выигрышный для Алисы;
  • \(s = \mathtt{ab}\): поочерёдно сначала Алиса, а потом Боб выигрывает сет со счётом \(2:1\) — сценарий ничейный;
  • \(s = \mathtt{ba}\): поочерёдно сначала Боб, а потом Алиса выигрывает сет со счётом \(2:1\) — сценарий ничейный;
  • \(s = \mathtt{bb}\): Боб выигрывает все сеты со счётом \(2:0\) — сценарий выигрышный для Боба.

E. Красивые подграфы

Деревья дп жадные алгоритмы игры поиск в глубину и подобное *2500

У Монокарпа есть дерево, состоящее из \(n\) вершин.

Он планирует выбрать некоторую вершину \(r\) и проделать следующие операции над каждой вершиной \(v\) от \(1\) до \(n\):

  • присвоить \(d_v\) равным расстоянию от \(v\) до \(r\) (количество ребер на кратчайшем пути);
  • раскрасить \(v\) в какой-нибудь цвет.

Раскраска называется красивой, если она удовлетворяет двум условиям:

  • для каждой пары вершин одного цвета \((v, u)\) существует путь из \(v\) в \(u\), который посещает только вершины того же цвета;
  • для каждой пары вершины одного цвета \((v, u)\), \(d_v \neq d_u\).

Обратите внимание, что Монокарп может выбирать любое количество различных цветов, которые он хочет использовать.

Для каждого использованного цвета он затем считает количество вершин этого цвета. Стоимость дерева — это минимум из этих значений.

Какая может быть наибольшая стоимость дерева?

Входные данные

В первой строке записано одно целое число \(t\) (\(1 \le t \le 10^4\)) — количество наборов входных данных.

В первой строке записано одно целое число \(n\) (\(3 \le n \le 2 \cdot 10^5\)) — количество вершин в дереве.

В каждой из следующих \(n-1\) строк записаны два целых числа \(v\) и \(u\) (\(1 \le v, u \le n\)) — описание ребра.

Заданные ребра образуют дерево. Сумма \(n\) по всем наборам входных данных не превосходит \(2 \cdot 10^5\).

Выходные данные

На каждый набор входных данных выведите одно целое число — наибольшая возможная стоимость дерева.

D. Автомат с игрушками

игры Конструктив реализация *2700

Рассмотрим автомат с игрушками, в котором игрушки расположены в два ряда по \(n\) ячеек каждый (\(n\) — нечетное).

Начальное состояние для \(n=9\).

Изначально в верхнем ряду в неугловых ячейках размещены \(n-2\) игрушки. Нижний ряд изначально пуст, и его левая, правая и центральная ячейки заблокированы. Есть \(4\) кнопки для управления автоматом: влево, вправо, вверх и вниз, обозначенные буквами L, R, U и D соответственно.

При нажатии на L, R, U или D все игрушки будут одновременно двигаться в соответствующем направлении и остановятся, только если они столкнутся с другой игрушкой, стеной или заблокированной ячейкой. Ваша цель — переместить \(k\)-ю игрушку в крайнюю левую ячейку верхнего ряда. Игрушки пронумерованы с \(1\) по \(n-2\) слева направо. Вам даны \(n\) и \(k\), найдите решение, которое использует не более \(1\,000\,000\) нажатий кнопок.

Чтобы опробовать автомат, вы можете воспользоваться веб-страницей, позволяющей вам играть в описанную игру в режиме реального времени.

Входные данные

Первая и единственная строка содержит два целых числа \(n\) и \(k\) (\(5 \le n \le 100\,000\), \(n\) — нечетное, \(1 \le k \le n-2\)) — количество ячеек в ряду и номер игрушки, которую нужно переместить в крайнюю левую ячейку верхнего ряда.

Выходные данные

Выведите описание нажатий кнопок в виде строки из не более чем \(1\,000\,000\) символов. Строка должна содержать только символы L, R, U и D. \(i\)-й символ в строке соответствует \(i\)-й нажатой кнопке. После нажатия всех кнопок в указанной последовательности \(k\)-я игрушка должна быть в крайней левой ячейке верхнего ряда.

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

Примечание

В первом примере будет \(5-2 = 3\) игрушки. Первая игрушка должна оказаться в крайней левой ячейке верхнего ряда. Ходы RDL позволят достичь этого, см. картинку для лучшего понимания. Другим возможным решением было бы выполнить одно нажатие кнопки L.

Визуализация ходов для первого примера.

E. Удалить граф

графы дп игры математика Перебор *2500

Алиса и Боб играют с графом. У них есть неориентированный граф без петель и кратных ребер. Все вершины графа имеют степень равную \(2\). Граф может содержать несколько компонент связности. Обратите внимание, что если такой граф имеет \(n\) вершин, он будет иметь ровно \(n\) ребер.

Алиса и Боб ходят по очереди. Алиса ходит первой. За один ход игрок может выбрать \(k\) (\(l \le k \le r\); \(l < r\)) вершин, которые образуют связный подграф, и удалить эти вершины из графа, включая все инцидентные ребра.

Игрок, который не может сделать ход, проигрывает.

Предположим, для примера, что они играют на заданном графе с заданными \(l = 2\) и \(r = 3\):

Следующие множества вершин допустимы для первого хода Алисы:

  • \(\{1, 2\}\)
  • \(\{1, 3\}\)
  • \(\{2, 3\}\)
  • \(\{4, 5\}\)
  • \(\{4, 6\}\)
  • \(\{5, 6\}\)
  • \(\{1, 2, 3\}\)
  • \(\{4, 5, 6\}\)
Пусть Алиса выбрала подграф \(\{4, 6\}\).

Тогда следующие множества вершин допустимы для первого хода Боба:

  • \(\{1, 2\}\)
  • \(\{1, 3\}\)
  • \(\{2, 3\}\)
  • \(\{1, 2, 3\}\)
Пусть Боб выбрал подграф \(\{1, 2, 3\}\).

Алиса не может сделать ход, поэтому она проигрывает.

Вам дан граф размера \(n\) и целые числа \(l\) и \(r\). Кто победит, если Алиса и Боб играют оптимально.

Входные данные

Первая строка содержит три целых числа \(n\), \(l\) и \(r\) (\(3 \le n \le 2 \cdot 10^5\); \(1 \le l < r \le n\)) — количество вершин в графе и ограничения на количество вершин, которые Алиса или Боб могут выбрать одним ходом.

Следующие \(n\) строк содержат ребра графа: по одному в строке. \(i\)-я строка содержит два целых числа \(u_i\) и \(v_i\) (\(1 \le u_i, v_i \le n\); \(u_i \neq v_i\)) — описание \(i\)-го ребра.

Гарантируется, что степени всех вершин данного графа равны \(2\).

Выходные данные

Выведите Alice (регистро-независимо), если Алиса победит, или Bob в противном случае.

Примечание

В первом тесте даны те же входные данные, что и в условии.

Во втором тесте дан тот же граф, что и в условии, но \(l = 1\) и \(r = 2\)

C. Игра с переворотом

жадные алгоритмы игры математика Строки *1200

Алиса и Боб играют в игру. У них есть две строки \(S\) и \(T\) одинаковой длины \(n\), состоящие из строчных латинских букв. Игроки ходят по очереди, первой ходит Алиса.

В свой ход Алиса выбирает число \(i\) от \(1\) до \(n\), одну из строк \(S\) или \(T\), а также любую строчную латинскую букву \(c\), и заменяет \(i\)-й символ в выбранной строке на символ \(c\).

Боб же в свой ход выбирает одну из строк \(S\) или \(T\), и переворачивает её. Более формально, Боб делает замену \(S := \operatorname{rev}(S)\) или \(T := \operatorname{rev}(T)\), где \(\operatorname{rev}(P) = P_n P_{n-1} \ldots P_1\).

Игра длится до тех пор, пока строки \(S\) и \(T\) не равны. Как только строки становятся равны, игра моментально заканчивается.

Определим длительность игры как суммарное количество ходов, сделанных обоими игроками в процессе игры. Например, если всего Алиса сделала \(2\) хода, а Боб — \(1\) ход, то длительность такой игры равна \(3\).

Цель Алисы — минимизировать длительность игры, а цель Боба — максимизировать длительность игры.

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

Входные данные

Каждый тест состоит из нескольких наборов входных данных. В первой строке находится одно целое число \(t\) (\(1 \le t \le 10^4\)) — количество наборов входных данных. Далее следует описание наборов входных данных.

Первая строка каждого набора входных данных содержит единственное целое число \(n\) (\(1 \le n \le 10^5\)) — длина строк \(S\) и \(T\).

Вторая строка каждого набора входных данных содержит строку \(S\) длины \(n\), состоящую из строчных латинских букв.

Третья строка каждого набора входных данных содержит строку \(T\) длины \(n\), состоящую из строчных латинских букв.

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

Выходные данные

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

Примечание

В первом наборе входных данных Алиса в свой ход может заменить третий символ строки \(S\) на x. После чего обе строки станут равны «abxde» и игра завершится после одного хода. Так как цель Алисы закончить игру за минимальное число ходов, этот ход будет одним из оптимальных первых ходов для неё, и итоговый ответ равен \(1\).

Во втором наборе входных данных Алиса в свой ход может заменить пятый символ строки \(T\) на h. После этого хода \(S =\) «hello», \(T =\) «olleh». Далее ходит Боб. В свой ход он обязан перевернуть одну из строк. Если Боб выберет строку \(S\), то после его хода обе строки будут равны «olleh», а если он выберет строку \(T\), то после его хода обе строки будут равны «hello». Таким образом, после представленного первого хода Алисы игра гарантированно завершится через \(2\) хода. Несложно показать, что стратегии, гарантирующей завершение игры менее чем за \(2\) хода, у Алисы не существует. Итоговый ответ равен \(2\).

В третьем наборе входных данных Алиса в свой первый ход может заменить второй символ строки \(S\) на c. После этого хода \(S =\) «ac», \(T =\) «cd». Далее ходит Боб. Если Боб перевернёт строку \(S\), то после его хода \(S =\) «ca», \(T =\) «cd». Тогда несложно видеть, что в этом случае Алиса может гарантированно закончить игру на \(3\)-м ходу, заменив второй символ строки \(T\) на a, после чего обе строки станут равны «ca». Если же Боб перевернёт строку \(T\), то после его хода \(S =\) «ac», \(T =\) «dc». В этом случае Алиса также может гарантированно закончить игру на \(3\)-м ходу, заменив первый символ строки \(S\) на d, после чего обе строки станут равны «dc». Таким образом Алиса может гарантированно закончить игру за \(3\) хода вне зависимости от ходов Боба. Можно показать, что меньше чем за \(3\) хода, при оптимальной игре Боба, игра завершиться не может.

В пятом наборе входных данных строки \(S\) и \(T\) равны, а значит игра завершится, не начавшись, за \(0\) ходов.

A. Игра на доске

игры Конструктив *800

Алиса и Боб играют в игру. У них есть доска; изначально на ней написано \(n\) целых чисел, каждое из которых равно \(1\).

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

Например, если на доске сейчас написаны числа \(\{1, 1, 2, 2, 2, 3\}\), то возможны следующие ходы:

  • выбрать два числа, равных \(1\), стереть их и написать число \(2\), тогда доска станет \(\{2, 2, 2, 2, 3\}\);
  • выбрать два числа, равных \(2\), стереть их и написать число \(4\), тогда доска станет \(\{1, 1, 2, 3, 4\}\);
  • выбрать три числа, равных \(2\), стереть их и написать число \(6\), тогда доска станет \(\{1, 1, 3, 6\}\).

Если игрок не может сделать ход (все числа на доске различны), то этот игрок выигрывает в игре.

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

Входные данные

Первая строка содержит одно целое число \(t\) (\(1 \le t \le 99\)) — количество тестов.

Каждый тест состоит из одной строки, содержащей одно целое число \(n\) (\(2 \le n \le 100\)) — количество чисел, равных \(1\), на доске.

Выходные данные

Для каждого теста выведите Alice, если Алиса выиграет (с учетом того, что оба игрока будут играть оптимально). Иначе выведите Bob.

Примечание

В первом наборе входных данных \(n = 3\), поэтому на доске изначально написаны числа \(\{1, 1, 1\}\). Мы можем показать, что Боб всегда может выиграть. У Алисы есть два возможных первых хода:

  • если Алиса выбирает два числа, равных \(1\), стирает их и пишет \(2\), то доска становится \(\{1, 2\}\). Боб не может сделать ход, поэтому он выигрывает;
  • если Алиса выбирает три числа, равных \(1\), стирает их и пишет \(3\), то доска становится \(\{3\}\). Боб не может сделать ход, поэтому он выигрывает.

Во втором наборе входных данных \(n = 6\), поэтому на доске изначально написаны числа \(\{1, 1, 1, 1, 1, 1\}\). Алиса может выиграть, например, выбрав на первом ходу два числа, равных \(1\), стерев их и написав \(2\). Тогда доска станет \(\{1, 1, 1, 1, 2\}\), и у Боба будет три возможных ответных хода:

  • если Боб выберет четыре числа, равных \(1\), сотрет их и напишет \(4\), то доска станет \(\{2,4\}\). Алиса не может сделать ход, поэтому она выигрывает;
  • если Боб выберет три числа, равных \(1\), сотрет их и напишет \(3\), то доска станет \(\{1,2,3\}\). Алиса не может сделать ход, поэтому она выигрывает;
  • если Боб выберет два числа, равных \(1\), сотрет их и напишет \(2\), то доска станет \(\{1, 1, 2, 2\}\). Алиса может продолжить, например, выбрав два числа, равных \(2\), стерев их и написав \(4\). Тогда доска станет \(\{1,1,4\}\). Единственный возможный ответ для Боба — выбрать два числа, равных \(1\), и написать вместо них \(2\); тогда доска станет \(\{2,4\}\), Алиса не может сделать ход, поэтому она выигрывает.

A. Тенцинг и Цонду

игры математика *800

Цонду всегда бежит первым! ! !

Цонду и Тенцинг играют в карточную игру. У Цонду есть \(n\) монстров со способностями \(a_1, a_2, \ldots, a_n\), а у Тенцинга — \(m\) монстров со способностями \(b_1, b_2, \ldots, b_m\).

Цонду и Тенцинг по очереди делают ходы, причем Цонду ходит первым. Каждый ход делающий ход игрок выбирает двух монстров: одного со своей стороны и одного со стороны соперника. Эти монстры устроят бой между собой. Предположим, что значения способностей выбранных монстров равны \(x\) и \(y\) соответственно, тогда значения способностей монстров станут \(x-y\) и \(y-x\) соответственно. Если значение способности любого монстра станет меньше или равно \(0\), то монстр умирает.

Игра заканчивается, когда хотя бы у одного игрока не останется в живых ни одного монстра. Победителем считается игрок, у которого монстры остались в живых. Если у обоих игроков не осталось в живых ни одного монстра, игра заканчивается вничью.

Найдите результат игры, когда оба игрока играют оптимально.

Входные данные

Каждый тест содержит несколько наборов входных данных. Первая строка ввода содержит одно целое число \(t\) (\(1 \le t \le 2 \cdot 10^3\)) — количество наборов входных данных. Далее следует описание наборов.

Первая строка каждого набора входных данных содержит два целых числа \(n\) и \(m\) (\(1 \leq n,m \leq 50\)) — количество монстров у Цонду и Тенцинга соответственно.

Вторая строка каждого набора содержит \(n\) целых чисел \(a_1,a_2,\ldots,a_n\) \((1 \leq a_i \leq 10^9\)) — значения способностей монстров Цонду.

Третья строка каждого набора содержит \(m\) целых чисел \(b_1,b_2,\ldots,b_m\) \((1 \leq b_i \leq 10^9\)) — значения способностей монстров Тенцинга.

Выходные данные

Для каждого набора входных данных выведите «Tsondu» (без кавычек), если победил Цонду, «Tenzing», если победил Тенцинг, и «Draw», если игра закончилась вничью.

Обратите внимание, что вывод чувствителен к регистру букв. Например, если ответ равен «Tsondu», но вы вывели «tsondu», «TSONDU» или «tSonDu», то это всё неправильные ответы.

Примечание

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

  • В первый ход Цонду выбирает монстра со способностью \(9\) на своей стороне для борьбы с монстром со способностью \(1\) на стороне Тенцинга, стоимость способностей обоих монстров становится \(8\) и \(-8\) соответственно. Монстр со способностью \(-8\) на стороне Тенцинга погибает.
  • Во второй ход Тенцинг выбирает монстра со способностью \(2\) на своей стороне, чтобы сразиться с монстром со способностью стоимостью \(8\) на стороне Цонду, стоимость способностей обоих монстров становится \(-6\) и \(6\) соответственно. Монстр со способностью \(-6\) на стороне Тенцинга погибает.
  • На третьем ходу Цонду выбирает монстра со способностью \(6\) на своей стороне, чтобы сразиться с монстром со способностью \(3\) на стороне Тенцинга, стоимость способностей обоих монстров становится \(3\) и \(-3\) соответственно. Монстр со способностью \(-3\) на стороне Тенцинга погибает.
  • Теперь у Тенцинга не осталось живых монстров. Поскольку у Тсонду еще остались монстры в живых, Тсонду побеждает.

A. Игра в вычитание

игры Конструктив *800

Вам даны два положительных целых числа \(a\) и \(b\) (\(a < b\)).

Два игрока играют в игру с кучей из \(n\) камней для некоторого положительного целого \(n\). Они ходят по очереди, на каждом ходу убирая из кучи ровно \(a\) или ровно \(b\) камней. Проигрывает тот, кто не может сделать ход.

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

Входные данные

Каждый тест состоит из нескольких наборов входных данных. В первой строке находится одно целое число \(t\) (\(1 \le t \le 100\)) — количество наборов входных данных. Далее следует описание наборов входных данных.

Единственная строка каждого набора входных данных содержит два целых числа \(a\) и \(b\) (\(1 \le a < b \le 100\)).

Выходные данные

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

Можно доказать, что \(n\), удовлетворяющее всем ограничениям задачи, всегда существует.

Примечание

В первом наборе входных данных при \(n = 2\) первый игрок своим первым ходом обязан удалить \(a = 1\) камень. Второй игрок может ответить удалением \(a = 1\) камня. Теперь первый игрок не может сделать ход, значит, второй выигрывает.

Во втором наборе входных данных при \(n = 6\) у первого игрока есть два варианта действий:

  • Если он удаляет из кучи \(b = 5\) камней, то второй игрок может в ответ удалить \(a = 1\) камень. Теперь первый игрок не может сделать ход, значит, второй выигрывает.
  • Если он удаляет \(a = 1\) камень, то второй вновь может в ответ удалить \(a = 1\) камень. Затем игроки могут лишь по очереди удалять по \(a = 1\) камню из кучи. Второй игрок удалит последний камень, а потому победит.

Поскольку второй игрок имеет выигрышную стратегию вне зависимости от действий первого, это корректный ответ.

В третьем наборе входных данных при \(n = 3\) первый игрок не может сделать ни одного хода, значит, второй сразу же побеждает.

A. Вика и подружки

игры математика *900

Вика с подружками пришла на шоппинг в торговый центр, который может быть представлен в виде клетчатого прямоугольника из залов со сторонами длины \(n\) и \(m\). Каждый зал имеет координаты \((a, b)\), где \(1 \le a \le n, 1 \le b \le m\). При этом мы называем зал с координатами \((c, d)\) соседним для него, если \(|a - c| + |b - d| = 1\).

Устав от пустых разговоров о моде, Вика решила незаметно сбежать. Но так как она ещё не успела заглянуть в один из магазинчиков, покидать территорию торгового центра девушка не хочет. Спустя некоторое время подружки заметили исчезновение Вики и начали её искать.

Сейчас девушка находится в зале с координатами \((x, y)\), а \(k\) её подруг в залах с координатами \((x_1, y_1)\), \((x_2, y_2)\), ... \(, (x_k, y_k)\) соответственно. Координаты могут совпадать.

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

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

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

Входные данные

Каждый тест состоит из нескольких наборов входных данных. В первой строке входных содержится одно целое число \(t\) (\(1 \le t \le 100\)) — количество наборов входных данных. Далее следует описание наборов входных данных.

В первой строке каждого набора входных данных содержатся три целых числа \(n\), \(m\), \(k\) (\(1 \le n, m, k \le 100\)) — размеры торгового центра и количество подруг Вики.

Во второй строке каждого набора входных данных содержатся два целых числа \(x\) и \(y\) (\(1 \le x \le n\), \(1 \le y \le m\)) — координаты зала, в котором находится Вика.

В каждой из следующих \(k\) строк каждого набора входных данных содержатся два целых числа \(x_i\) и \(y_i\) (\(1 \le x_i \le n\), \(1 \le y_i \le m\)) — координаты зала, в котором находится \(i\)-я подруга.

Выходные данные

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

Вы можете выводить каждую букву в любом регистре (строчную или заглавную). Например, строки «yEs», «yes», «Yes» и «YES» будут приняты как положительный ответ.

Примечание

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

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

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

A. Кнопки

жадные алгоритмы игры математика *800

Аня и Катя попали в секретную лабораторию.

В секретной лаборатории есть \(a+b+c\) кнопок. Оказалось, что на \(a\) кнопок может нажать только Аня, на \(b\) кнопок может нажать только Катя, а на \(c\) кнопок могут нажать обе девочки. Аня и Катя решили сыграть в игру, нажимая по очереди на эти кнопки. Первой нажимает на кнопку Аня. Каждую кнопку можно нажать не более одного раза, поэтому в какой-то момент одна из девочек не сможет нажать на кнопку.

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

Входные данные

В первой строке записано одно целое число \(t\) (\(1 \le t \le 10^4\)) — количество наборов входных данных.

Каждый набор входных данных состоит из трех целых чисел \(a\), \(b\) и \(c\) (\(1 \le a, b, c \le 10^9\)) — количества кнопок, на которые может нажать только Аня, количества кнопок, на которые может нажать только Катя и количества кнопок, на которые могут нажать обе девочки, соответственно.

Выходные данные

Для каждого набора входных данных выведите «First», если выиграет Аня, или «Second», если выиграет Катя.

Примечание

Для удобства объяснения будем считать, что кнопки пронумерованы целыми числами от \(1\) до \(a+b+c\): на первые \(a\) кнопок может нажать только Аня, на следующие \(b\) кнопок может нажать только Катя, а на последние \(c\) кнопок могут нажать обе девочки.

В первом наборе входных данных Аня может первым ходом нажать на \(3\)-ю кнопку. Тогда Катя сможет нажать только на \(2\)-ю кнопку на своём ходе, а Аня потом нажмёт на \(1\)-ю кнопку. У Кати не будет возможного хода, поэтому Аня победит.

Во втором наборе входных данных Аня может нажимать на одну из первых девяти кнопок на своём ходе (не нажимая на одну кнопку более одного раза). Тогда вне зависимости от действий Кати, после первых \(12\) ходов все кнопки с \(10\)-й по \(15\)-ю будут нажаты. На \(13\)-м ходе Аня сможет нажать на одну из первых девяти кнопок, после чего Катя не сможет сделать ход, поэтому победит Аня.

В третьем наборе входных данных один из возможных вариантов развития игры приведён ниже:

  • На \(1\)-м ходе Аня нажмёт на \(5\)-ю кнопку.
  • На \(2\)-м ходе Катя нажмёт на \(4\)-ю кнопку.
  • На \(3\)-м ходе Аня нажмёт на \(6\)-ю кнопку.
  • На \(4\)-м ходе Катя нажмёт на \(3\)-ю кнопку.
  • На \(5\)-м ходе Аня нажмёт на \(1\)-ю кнопку.
  • На \(6\)-м ходе Катя нажмёт на \(2\)-ю кнопку.
  • Аня не сможет сделать ход, поэтому выиграет Катя.

Можно показать, что Катя может выиграть вне зависимости от действий Ани.

C. Игра с перестановкой

дп жадные алгоритмы игры Структуры данных *1400

Алиса и Боб играют в игру. У них есть перестановка \(p\) размера \(n\) (перестановка размера \(n\)  — это массив размера \(n\), где каждый элемент от \(1\) до \(n\) встречается ровно один раз). Также у них есть фишка, которую можно разместить на любом элементе перестановки.

Алиса и Боб делают ходы поочередно: Алиса делает первый ход, затем Боб делает второй ход, затем Алиса делает третий ход и так далее. Во время первого хода Алиса выбирает любой элемент перестановки и ставит фишку на этот элемент. Во время каждого из следующих ходов текущий игрок должен переместить фишку на элемент, который одновременно находится слева и строго меньше текущего элемента (т.е. если фишка находится на \(i\)-м элементе, она может быть перемещена на \(j\)-й элемент, если \(j < i\) и \(p_j < p_i\)). Если игрок не может сделать ход (переместить фишку в соответствии с правилами игры невозможно), этот игрок выигрывает в игре.

Скажем, что \(i\)-й элемент перестановки счастливый, если выполняется следующее условие:

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

Ваша задача — посчитайте количество счастливых элементов в перестановке.

Входные данные

Первая строка содержит одно целое число \(t\) (\(1 \le t \le 10^4\)) — количество наборов входных данных.

Первая строка каждого набора содержит одно целое число \(n\) (\(1 \le n \le 3 \cdot 10^5\)) — количество элементов в перестановке.

Вторая строка содержит \(n\) целых чисел \(p_1, p_2, \dots, p_n\) (\(1 \le p_i \le n\)). Все \(p_i\) различны.

Сумма \(n\) по всем наборам входных данных не превышает \(3 \cdot 10^5\).

Выходные данные

Для каждого набора входных данных выведите одно целое число — количество счастливых элементов в перестановке.

Примечание

В первом наборе входных данных из примера \(3\)-й элемент — счастливый.

Во втором наборе входных данных из примера нет счастливых элементов.

В третьем наборе входных данных из примера \(2\)-й элемент — счастливый.

В четвертом наборе входных данных из примера \(3\)-й и \(4\)-й элемент — счастливые.

E. Угадайка

битмаски Деревья игры математика сортировки Строки Структуры данных Теория вероятностей *2100

У Кэрол есть последовательность \(s\) из \(n\) неотрицательных целых чисел. Она хочет сыграть с Алисой и Бобом в «Угадайку».

Игра устроена следующим образом. Сначала Кэрол случайно выберет два целых индекса \(i_a\) и \(i_b\) из диапазона \([1, n]\) и обозначит \(a=s_{i_a}\), \(b=s_{i_b}\). Обратите внимание: \(i_a\) и \(i_b\) могут совпасть.

Затем Кэрол сообщит:

  • значение \(a\) — Алисе;
  • значение \(b\) — Бобу;
  • значение \(a \mid b\) и Алису и Бобу, где \(|\) обозначает операцию побитового ИЛИ.

Обратите внимание: Кэрол не сообщит никакой информации об \(s\) ни Алисе, ни Бобу.

Затем начинается процесс угадывания. Алиса и Боб ходят по очереди, причём первой ходит Алиса. Цель обоих игроков — выяснить, какое из утверждений верно: \(a < b\), \(a > b\), или \(a = b\).

На своём ходу игрок может сделать одно из двух:

  • сказать «Я не знаю» и передать ход другому игроку;
  • сказать «Я знаю», а затем сообщить ответ: «\(a<b\)», «\(a>b\)», или же «\(a=b\)»; после этого игра заканчивается.

Алиса и Боб слышат фразы друг друга и могут использовать их в своих рассуждениях. Оба игрока достаточно умны. Сказать «Я знаю» они могут только в том случае, если точно уверены в ответе.

Найдите математическое ожидание числа шагов в такой игре. Выведите ответ по модулю \(998\,244\,353\).

Формально, пусть \(M = 998\,244\,353\). Можно показать, что ответ может быть представлен в виде несократимой дроби \(\frac{p}{q}\), где \(p\) и \(q\) — целые числа, и \(q \not \equiv 0 \pmod{M}\). Выведите целое число, равное \(p \cdot q^{-1} \bmod M\). Другими словами, выведите такое целое число \(x\), что \(0 \le x < M\) и \(x \cdot q \equiv p \pmod{M}\).

Входные данные

Каждый тест состоит из нескольких наборов входных данных. В первой строке находится одно целое число \(t\) (\(1 \le t \le 10^5\)) — количество наборов входных данных. Далее следует описание наборов входных данных.

Первая строка каждого набора входных данных содержит одно целое число \(n\) (\(1 \le n \le 2\cdot 10^5\)).

Вторая строка каждого набора входных данных содержит \(n\) целых чисел \(s_1,s_2,\ldots, s_n\) (\(0 \le s_i < 2^{30}\)).

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

Выходные данные

Для каждого набора входных данных выведите одно число — ответ на задачу по модулю \(998\,244\,353\).

Примечание

В первом наборе входных данных есть всего \(4\) возможные ситуации:

  1. \(i_a=1\), \(i_b=1\), \(a=2\), \(b=2\), число шагов равно \(2\);
  2. \(i_a=1\), \(i_b=2\), \(a=2\), \(b=3\), число шагов равно \(3\);
  3. \(i_a=2\), \(i_b=1\), \(a=3\), \(b=2\), число шагов равно \(2\);
  4. \(i_a=2\), \(i_b=2\), \(a=3\), \(b=3\), число шагов равно \(3\).

Математическое ожидание числа шагов равно \(\frac{2+3+2+3}{4}=\frac{5}{2}=499122179\pmod{998244353}\).

Рассмотрим первый случай, когда \(a=2\), \(b=2\). Процесс угадывания происходит следующим образом.

На первом ходу Алиса думает так: «Я знаю, что \(a=2, a\mid b=2\). Можно сделать вывод, что \(b=0\) или \(b=2\), но какой из этих двух случаев имеет место — пока неясно». Поэтому она говорит: «Я не знаю».

На втором ходу Боб думает так: «Я знаю, что \(b=2, a\mid b=2\). Можно сделать вывод, что \(a=0\) или \(a=2\). Однако если \(a=0\), то Алиса на своём ходу уже бы сказала, что \(a<b\). Но она этого не сказала. Значит, \(a=2\)». Поэтому он говорит: «Я знаю, \(a=b\)». Игра завершается.

Во втором наборе входных данных, при \(a=0\), \(b=0\), Алиса сразу заключает, что \(a=b\). Ожидаемое число ходов равно \(1\).

I. Imagination Castle

дп игры *2300

Given a chessboard of size \(N \times M\) (\(N\) rows and \(M\) columns). Each row is numbered from \(1\) to \(N\) from top to bottom and each column is numbered from \(1\) to \(M\) from left to right. The tile in row \(r\) and column \(c\) is denoted as \((r,c)\). There exists \(K\) distinct special tiles on the chessboard with the \(i\)-th special tile being tile \((X_i,Y_i)\). It is guaranteed that tile \((1,1)\) is not a special tile.

A new chess piece has been invented, which is the castle. The castle moves similarly to a rook in regular chess, but slightly differently. In one move, a castle that is on some tile can only move to another tile in the same row or in the same column, but only in the right direction or the down direction. Formally, in one move, the castle on tile \((r,c)\) can only move to tile \((r',c')\) if and only if one of the following two conditions is satisfied:

  • \(r'=r\) and \(c'>c\).
  • \(c'=c\) and \(r'>r\).

Chaneka and Bhinneka will play a game. In the beginning of the game, there is a castle in tile \((1,1)\). The two players will play alternatingly with Chaneka going first. In one turn, the player on that turn must move the castle following the movement rules of the castle.

If a player moves the castle to a special tile on her turn, then that player wins the game and the game ends. If on a turn, the castle cannot be moved, the player on that turn loses and the game ends.

Given the size of the board and the locations of each special tile. Determine the winner of this game if Chaneka and Bhinneka plays optimally.

Input

The first line contains three integers \(N\), \(M\), and \(K\) (\(1 \leq N,M \leq 2 \cdot 10^5\); \(0 \leq K \leq \min(N \times M - 1, 2\cdot10^5)\)) — the size of the chessboard and the number of special tiles.

The \(i\)-th of the next \(K\) lines contains two integers \(X_i\) and \(Y_i\) (\(1\leq X_i\leq N\); \(1\leq Y_i\leq M\); \((X_i, Y_i) \neq (1,1)\)) — the location of each special tile. The special tiles are pairwise distinct.

Output

Output Chaneka if Chaneka is the winner, output Bhinneka if Bhinneka is the winner.

Note

In the first example, the following is an illustration of the chessboard in the beginning of the game.

Chaneka can move the castle to special tile \((1,3)\) or \((1,5)\) directly on her first turn. Therefore, Chaneka is the winner.

In the second example, the following is an illustration of the chessboard in the beginning of the game.

Chaneka can only move the castle to tile \((1, 2)\) or \((2, 1)\) on her first turn. Whatever Chaneka does, Bhinneka will be able to directly move the castle to tile \((2, 2)\). After that, on Chaneka's turn, she cannot move the castle, so Chaneka loses. Therefore, Bhinneka is the winner.

C. salyg1n и игра с MEX

жадные алгоритмы игры интерактив Конструктив Структуры данных *1300

Это интерактивная задача!

salyg1n подарил Алисе множество \(S\) из \(n\) различных целых чисел \(s_1, s_2, \ldots, s_n\) (\(0 \leq s_i \leq 10^9\)). Алиса решила сыграть против Боба в игру с этим множеством. Правила игры таковы:

  • Игроки ходят по очереди, первой ходит Алиса.

  • Алиса за один ход добавляет в множество \(S\) одно число \(x\) (\(0 \leq x \leq 10^9\)). Множество \(S\) не должно содержать число \(x\) на момент хода.
  • Боб за один ход удаляет из множества \(S\) одно число \(y\). Множество \(S\) должно содержать число \(y\) на момент хода. Также число \(y\) должно быть строго меньше последнего добавленного Алисой числа.
  • Игра заканчивается, когда Боб не может сделать ход или спустя \(2 \cdot n + 1\) ходов (в таком случае последним ходом будет ход Алисы).
  • Результатом игры назовем \(\operatorname{MEX}\dagger(S)\) (\(S\) на момент конца игры).
  • Алиса стремится максимизировать результат, а Боб минимизировать.

Пусть \(R\) — результат при оптимальной игре обоих игроков. В этой задаче вы играете за Алису против программы жюри, играющей за Боба. Ваша задача — реализовать стратегию Алисы, при которой результат игры всегда будет не меньше \(R\).

\(\dagger\) \(\operatorname{MEX}\) набора чисел \(c_1, c_2, \ldots, c_k\) определяется как наименьшее неотрицательное целое число \(x\), которое не встречается в наборе чисел \(c\). Например, \(\operatorname{MEX}(\{0, 1, 2, 4\})\) \(=\) \(3\).

Входные данные

В первой задано одно целое число \(t\) (\(1 \leq t \leq 10^5\)) — количество тестовых случаев.

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

Взаимодействие Вашей программы с программой жюри в каждом тестовом случае начинается со считывания целого числа \(n\) (\(1 \leq n \leq 10^5\)) — размера множества \(S\) до начала игры.

Затем считайте одну строку — \(n\) различных целых чисел \(s_i\) \((0 \leq s_1 < s_2 < \ldots < s_n \leq 10^9)\) — множество \(S\) подаренное Алисе.

Чтобы сделать ход выведите целое число \(x\) (\(0 \leq x \leq 10^9\)) — число которое вы хотите добавить в множество \(S\). \(S\) не должно содержать \(x\) на момент хода. Затем считайте одно целое число \(y\) \((-2 \leq y \leq 10^9)\).

  • Если \(0 \leq y \leq 10^9\) — Боб удаляет число \(y\) из множества \(S\). Ваш ход!
  • Если \(y\) \(=\) \(-1\) — игра закончена. После этого следует приступать к обработке следующего тестового случая или завершить программу, если это был последний тестовый случай.
  • Иначе \(y\) \(=\) \(-2\). Это значит, что вы сделали некорректный запрос. Ваша программа должна немедленно завершится, чтобы получить вердикт Неправильный ответ. Иначе она может получить любой другой вердикт.

После вывода запроса не забудьте вывести перевод строки и сбросить буфер вывода. В противном случае вы получите вердикт Решение «зависло». Для сброса буфера используйте:

  • fflush(stdout) или cout.flush() в C++;
  • System.out.flush() в Java;
  • flush(output) в Pascal;
  • stdout.flush() в Python;
  • смотрите документацию для других языков.
Гарантируется, что сумма \(n\) по всем тестовым случаям не превосходит \(10^5\).

По этой задаче нельзя делать взломы.

Примечание

В первом наборе входных данных множество \(S\) менялось так:

{\(1, 2, 3, 5, 7\)} \(\to\) {\(1, 2, 3, 5, 7, 8\)} \(\to\) {\(1, 2, 3, 5, 8\)} \(\to\) {\(1, 2, 3, 5, 8, 57\)} \(\to\) {\(1, 2, 3, 8, 57\)} \(\to\) {\(0, 1, 2, 3, 8, 57\)}. В конце игры, \(\operatorname{MEX}(S) = 4\), \(R = 4\).

Во втором наборе входных данных множество \(S\) менялось так:

{\(0, 1, 2\)} \(\to\) {\(0, 1, 2, 3\)} \(\to\) {\(1, 2, 3\)} \(\to\) {\(0, 1, 2, 3\)}. В конце игры, \(\operatorname{MEX}(S) = 4\), \(R = 4\).

В третьем наборе входных данных множество \(S\) менялось так:

{\(5, 7, 57\)} \(\to\) {\(0, 5, 7, 57\)}. В конце игры, \(\operatorname{MEX}(S) = 1\), \(R = 1\).

H. Безумный город

графы Деревья игры кратчайшие пути поиск в глубину и подобное снм *1700

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

Марсель и Валериу начинают в зданиях \(a\) и \(b\) соответственно. Марсель хочет поймать Валериу, то есть оказаться в том же здании, что и он, или встретиться на одной дороге.

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

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

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

Входные данные

Первая строка содержит одно целое число \(t\) (\(1 \leq t \leq 1000\)) — количество наборов входных данных.

Первая строка каждого набора содержит три целых числа, разделенных пробелом: \(n\), \(a\), \(b\) (\(3 \leq n \leq 2 \cdot 10^5\); \(1 \leq a, b \leq n\)) — количество зданий (которое равно количеству дорог) и начальные здания Марселя и Валериу.

Следующие \(n\) строк содержат по два целых числа \(u_i\), \(v_i\) (\(1 \le u_i, v_i \le n\), \(u_i \neq v_i\)) — между зданиями \(u_i\) и \(v_i\) есть дорога. Между любой неупорядоченной парой зданий может быть не более одной дороги.

Сумма \(n\) по всем наборам входных данных не превышает \(2 \cdot 10^5\).

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

Выходные данные

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

Вы можете выводить ответ в любом регистре (например, строки «yEs», «yes», «Yes» и «YES» будут распознаны как положительный ответ).

Примечание

В первом примере граф выглядит следующим образом:

Марсель начинает в здании \(2\), а Валериу начинает в здании \(1\). Валериу знает, каким путем Марсель будет двигаться вокруг треугольника, и он может просто всегда двигаться так же, чтобы всегда избегать Марселя.

Во втором примере граф выглядит следующим образом:

Марсель начинает в здании \(1\), а Валериу начинает в здании \(4\). Марсель может пойти в здание \(4\) на своем первом ходу и победить, так как Валериу должен либо пойти в здание \(1\) (тогда они встретятся на дороге от \(1\) до \(4\)), либо остаться в здании \(4\) (тогда они встретятся в здании \(4\)). Таким образом, у Валериу нет стратегии для победы.

A. Медуза и игра

жадные алгоритмы игры Перебор реализация *1200

У Медузы есть \(n\) зеленых яблок со значениями \(a_1, a_2, \dots, a_n\), а у Гедузы есть \(m\) зеленых яблок со значениями \(b_1,b_2,\ldots,b_m\).

Они будут играть в игру, состоящую из \(k\) раундов. Для \(i=1,2,\ldots,k\) в этом порядке они будут выполнять следующие действия:

  • Если \(i\) нечетное, то Медуза может поменять одно свое яблоко на одно яблоко Гедузы или ничего не делать.
  • Если \(i\) четное, то Гедуза может поменять одно из своих яблок на одно из яблок Медузы или ничего не делать.

Оба игрока хотят максимизировать сумму стоимостей своих яблок.

Поскольку вы — один из самых умных людей в мире, Медуза хочет, чтобы вы сообщили ей окончательную сумму стоимости ее яблок после всех \(k\) раундов игры. Предположим, что и Медуза, и Гедуза играют оптимально, стремясь максимизировать сумму стоимостей своих яблок.

Входные данные

Каждый тест содержит несколько наборов входных данных. В первой строке указывается количество наборов входных данных \(t\) (\(1 \leq t \leq 2000\)). Далее следует описание наборов входных данных.

Первая строка каждого набора входных данных содержит три целых числа, \(n\), \(m\) и \(k\) (\(1 \leq n, m \leq 50\), \(1 \leq k \leq 10^9\)) — количество зеленых яблок у Медузы, количество зеленых яблок у Гедузы и количество раундов игры соответственно.

Вторая строка каждого набора входных данных содержит \(n\) целых чисел \(a_1, a_2, \dots, a_n\) (\(1 \leq a_i \leq 10^9\)) — значения зеленых яблок Медузы.

Третья строка каждого набора входных данных содержит \(m\) целых чисел \(b_1, b_2, \dots, b_m\) (\(1 \leq b_i \leq 10^9\)) — значения зеленых яблок Гедузы.

Заметим, что суммы \(n\) и \(m\) по всем наборам входных данных не ограничены.

Выходные данные

Для каждого набора входных данных выведите одно целое число — конечную сумму значений яблок Медузы.

Примечание

В первом наборе входных данных Медуза поменяет местами яблоки стоимостью \(1\) и \(4\).

Во втором наборе входных данных оба игрока поменяют местами два яблока \(10,000\) раз.

В четвертом наборе входных данных Медуза ничего не будет делать.

E. Бесконечная карточная игра

Бинарный поиск графы дп жадные алгоритмы игры Перебор поиск в глубину и подобное снм сортировки Структуры данных *2300

Монокарп и Бикарп играют в карточную игру. Каждая карта имеет два параметра: значение атаки и значение защиты. Карта \(s\) бьет карту \(t\), если значение атаки карты \(s\) строго больше значения защиты карты \(t\).

У Монокарпа есть \(n\) карт, \(i\)-я из которых имеет значение атаки \(\mathit{ax}_i\) и значение защиты \(\mathit{ay}_i\). У Бикарпа есть \(m\) карт, \(j\)-я из которых имеет значение атаки \(\mathit{bx}_j\) и значение защиты \(\mathit{by}_j\).

На первом ходе Монокарп выбирает одну из своих карт и кладет ее на стол. Бикарп должен побить эту карту своей картой. Затем Монокарп должен побить карту Бикарпа. Затем ход переходит к Бикарпу, и так далее.

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

Если игра длится \(100^{500}\) ходов, объявляется ничья.

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

Вам нужно вычислить три значения:

  • количество начальных ходов Монокарпа, которые приводят к победе Монокарпа;
  • количество начальных ходов Монокарпа, которые приводят к ничьей;
  • количество начальных ходов Монокарпа, которые приводят к победе Бикарпа.
Входные данные

Первая строка содержит одно целое число \(t\) (\(1 \le t \le 10^4\)) — количество наборов входных данных.

Первая строка каждого набора содержит целое число \(n\) (\(1 \le n \le 3 \cdot 10^5\)) — количество карт у Монокарпа.

Вторая строка содержит \(n\) целых чисел \(\mathit{ax}_1, \mathit{ax}_2, \dots, \mathit{ax}_n\) (\(1 \le \mathit{ax}_i \le 10^6\)) — значения атаки карт Монокарпа.

Третья строка содержит \(n\) целых чисел \(\mathit{ay}_1, \mathit{ay}_2, \dots, \mathit{ay}_n\) (\(1 \le \mathit{ay}_i \le 10^6\)) — значения защиты карт Монокарпа.

Четвертая строка содержит одно целое число \(m\) (\(1 \le m \le 3 \cdot 10^5\)) — количество карт у Бикарпа.

Пятая строка содержит \(m\) целых чисел \(\mathit{bx}_1, \mathit{bx}_2, \dots, \mathit{bx}_m\) (\(1 \le \mathit{bx}_j \le 10^6\)) — значения атаки карт Бикарпа.

Шестая строка содержит \(m\) целых чисел \(\mathit{by}_1, \mathit{by}_2, \dots, \mathit{by}_m\) (\(1 \le \mathit{by}_j \le 10^6\)) — значения защиты карт Бикарпа.

Дополнительные ограничения на входные данные: сумма \(n\) по всем наборам входных данных не превосходит \(3 \cdot 10^5\), сумма \(m\) по всем наборам входных данных не превосходит \(3 \cdot 10^5\).

Выходные данные

Для каждого набора входных данных выведите три целых числа:

  • количество начальных ходов Монокарпа, которые приводят к победе Монокарпа;
  • количество начальных ходов Монокарпа, которые приводят к ничьей;
  • количество начальных ходов Монокарпа, которые приводят к победе Бикарпа.

A. Игра с числами

игры математика теория чисел *800

Ваня и Вова играют в игру. Игрокам дано целое число \(n\). На своём ходу игрок может либо прибавить к текущему числу \(1\), либо вычесть \(1\). Игроки ходят по очереди, начинает Ваня. Если после хода Вани число стало делиться нацело на \(3\), то он побеждает. Если после \(10\) ходов Ваня не выиграл, то побеждает Вова.

Напишите программу, которая по целому числу \(n\) определяет, кто победит, если оба игрока играют оптимально.

Входные данные

В первой строке дано целое число \(t\) (\(1 \leq t \leq 100\)) — количество наборов входных данных.

В единственной строке каждого набора входных данных дано целое число \(n\) (\(1 \leq n \leq 1000\)).

Выходные данные

Для каждого набора входных данных выведите «First» без кавычек, если выиграет Ваня, и «Second» без кавычек иначе.

G. Grid Game 2

игры теория чисел *2900

You are playing "Grid Game 2" with your friend. There is a grid with \(10^9\) rows (numbered from \(1\) to \(10^9\)) and \(10^9\) columns (numbered from \(1\) to \(10^9\)). The cell at row \(r\) and column \(c\) is denoted as \((r, c)\).

Each cell can have a colour of either black or white. Initially, there are exactly \(N\) black cells (numbered from \(1\) to \(N\)). Black cell \(i\) is located at \((R_i, C_i)\). The rest of the cells are white.

You and your friend will alternately take turn playing on this grid, and you are playing in the first turn. In one turn, a player will choose a black cell \((r, c)\), then toggle cells \((r - x, c - y)\) for all \(0 \leq x, y < \min(r, c)\). If a cell is toggled, then the cell becomes black if it was a white cell, and the cell becomes white if it was a black cell.

For example, the following illustration shows how the grid changes after a player chooses a black cell \((5, 4)\) in their turn.

A player who is unable to play on their turn, i.e. no remaining black cells, loses the game, and the opposing player wins the game. If you and your friend are playing optimally, determine who will win the game.

Input

The first line consists of an integer \(N\) (\(1 \le N \le 200\,000\)).

Each of the next \(N\) lines consists of two integers \(R_i\) \(C_i\) (\(1 \leq R_i, C_i \leq 10^9)\). For \(1 \leq i < j \leq N\), \((R_i, C_i) \neq (R_j, C_j)\).

Output

Output FIRST if you will win the game, or SECOND otherwise.

Note

Explanation for the sample input/output #1

You can start your move by choosing \((2, 4)\), whose effect was demonstrated in the following illustration.

The remaining black cells are \((1, 3)\) and \((1, 4)\), each of which will only toggle itself when chosen. Whichever your friend chooses on the next move, the you can choose the remaining black cell.

Explanation for the sample input/output #2

You have only one cell to choose, and will toggle cells \((1, 1)\), \((1, 2)\), \((2, 1)\), and \((2, 2)\). Your friend and you will alternately choose the remaining black cells with your friend choosing the last black cell.

E1. Игра с шариками (простая версия)

жадные алгоритмы игры Перебор сортировки *1400

Простая и сложная версии этой задачи отличаются друг от друга только ограничениями на количество наборов входных данных и \(n\). В простой версии количество наборов входных данных не превосходит \(10^3\), а \(n\) не превосходит \(6\).

Недавно Алисе и Бобу родители подарили шарики \(n\) различных цветов: получилось, что у Алисы \(a_1\) шариков цвета \(1\), \(a_2\) шариков цвета \(2\),..., \(a_n\) шариков цвета \(n\). У Боба: \(b_1\) шариков цвета \(1\), \(b_2\) шариков цвета \(2\), ..., \(b_n\) шариков цвета \(n\). Все \(a_i\) и \(b_i\) от \(1\) до \(10^9\).

Посовещавшись, Алиса и Боб придумали следующую игру: игроки ходят по очереди, начиная с Алисы. На своём ходу игрок выбирает такой цвет \(i\), что у обоих игроков есть хотя бы по одному шарику этого цвета. Он выбрасывает один шарик цвета \(i\), а его противник — все шарики цвета \(i\). Игра заканчивается, когда не существует такого цвета \(i\), что у обоих игроков есть хотя бы по одному шарику этого цвета.

Счёт в игре — это количество оставшихся шариков у Алисы минус количество оставшихся шариков у Боба по окончании игры. То есть счёт равен \((A-B)\), где \(A\) — количество шариков у Алисы, а \(B\) — количество шариков у Боба в конце игры. Алиса хочет максимизировать счёт, а Боб — минимизировать.

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

Входные данные

В первой строке задано одно целое число \(t\) (\(1 \le t \le 10^3\)) — количество наборов входных данных.

Каждый набор входных данных состоит из трех строк:

  • в первой строке задано одно целое число \(n\) (\(2 \le n \le 6\)) — количество цветов шариков;
  • во второй строке заданы \(n\) целых чисел \(a_1, a_2, \dots, a_n\) (\(1 \le a_i \le 10^9\)), где \(a_i\) — количество шариков \(i\)-го цвета у Алисы;
  • в третьей строке заданы \(n\) целых чисел \(b_1, b_2, \dots, b_n\) (\(1 \le b_i \le 10^9\)), где \(b_i\) — количество шариков \(i\)-го цвета у Боба.
Выходные данные

Для каждого набора входных данных выведите одно целое число — счёт в конце игры, если и Алиса и Боб будут действовать оптимально.

Примечание

В первом примере один из способов получить счёт \(1\) — следующий:

  1. Алиса выбирает цвет \(1\), выбрасывает \(1\) шарик. Боб также выбрасывает \(1\) шарик;
  2. Боб выбирает цвет \(3\), выбрасывает \(1\) шарик. Алиса также выбрасывает \(1\) шарик;
  3. Алиса выбирает цвет \(2\), выбрасывает \(1\) шарик, а Боб — \(2\) шарика.

В результате у Алисы остается \(a = [3, 1, 0]\), а у Боба — \(b = [0, 0, 3]\). Счёт равен \(3 + 1 - 3 = 1\).

Можно показать, что ни Алиса ни Боб не могут получить лучший счёт, если оба играют оптимально.

Во втором примере Алиса может сначала выбрать цвет \(1\), далее Боб выберет цвет \(4\), после этого Алиса выберет цвет \(2\), и Боб — цвет \(3\). Можно показать, что это оптимальная игра.

E2. Игра с шариками (сложная версия)

жадные алгоритмы игры сортировки *1400

Простая и сложная версии этой задачи отличаются друг от друга только ограничениями на количество наборов входных данных и \(n\). В сложной версии количество наборов входных данных не превосходит \(10^4\), а сумма значений \(n\) по всем наборам входных данных не превосходит \(2 \cdot 10^5\). Кроме того, никаких дополнительных ограничений на значение \(n\) в одиночном наборе входных данных нет.

Недавно Алисе и Бобу родители подарили шарики \(n\) различных цветов: получилось, что у Алисы \(a_1\) шариков цвета \(1\), \(a_2\) шариков цвета \(2\),..., \(a_n\) шариков цвета \(n\). У Боба: \(b_1\) шариков цвета \(1\), \(b_2\) шариков цвета \(2\), ..., \(b_n\) шариков цвета \(n\). Все \(a_i\) и \(b_i\) от \(1\) до \(10^9\).

Посовещавшись, Алиса и Боб придумали следующую игру: игроки ходят по очереди, начиная с Алисы. На своём ходу игрок выбирает такой цвет \(i\), что у обоих игроков есть хотя бы по одному шарику этого цвета. Он выбрасывает один шарик цвета \(i\), а его противник — все шарики цвета \(i\). Игра заканчивается, когда не существует такого цвета \(i\), что у обоих игроков есть хотя бы по одному шарику этого цвета.

Счёт в игре — это количество оставшихся шариков у Алисы минус количество оставшихся шариков у Боба по окончании игры. То есть счёт равен \((A-B)\), где \(A\) — количество шариков у Алисы, а \(B\) — количество шариков у Боба в конце игры. Алиса хочет максимизировать счёт, а Боб — минимизировать.

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

Входные данные

В первой строке задано одно целое число \(t\) (\(1 \le t \le 10^4\)) — количество наборов входных данных.

Каждый набор входных данных состоит из трех строк:

  • в первой строке задано одно целое число \(n\) (\(2 \le n \le 2 \cdot 10^5\)) — количество цветов шариков;
  • во второй строке заданы \(n\) целых чисел \(a_1, a_2, \dots, a_n\) (\(1 \le a_i \le 10^9\)), где \(a_i\) — количество шариков \(i\)-го цвета у Алисы;
  • в третьей строке заданы \(n\) целых чисел \(b_1, b_2, \dots, b_n\) (\(1 \le b_i \le 10^9\)), где \(b_i\) — количество шариков \(i\)-го цвета у Боба.

Дополнительное ограничение на входные данные: сумма \(n\) по всем наборам входных данных не превосходит \(2 \cdot 10^5\).

Выходные данные

Для каждого набора входных данных выведите одно целое число — счёт в конце игры, если и Алиса и Боб будут действовать оптимально.

Примечание

В первом примере один из способов получить счёт \(1\) — следующий:

  1. Алиса выбирает цвет \(1\), выбрасывает \(1\) шарик. Боб также выбрасывает \(1\) шарик;
  2. Боб выбирает цвет \(3\), выбрасывает \(1\) шарик. Алиса также выбрасывает \(1\) шарик;
  3. Алиса выбирает цвет \(2\), выбрасывает \(1\) шарик, а Боб — \(2\) шарика.

В результате у Алисы остается \(a = [3, 1, 0]\), а у Боба — \(b = [0, 0, 3]\). Счёт равен \(3 + 1 - 3 = 1\).

Можно показать, что ни Алиса ни Боб не могут получить лучший счёт, если оба играют оптимально.

Во втором примере Алиса может сначала выбрать цвет \(1\), далее Боб выберет цвет \(4\), после этого Алиса выберет цвет \(2\), и Боб — цвет \(3\). Можно показать, что это оптимальная игра.

C. Тренировка перед олимпиадой

жадные алгоритмы игры Конструктив математика реализация *1200

У Маши и Оли скоро важная командная олимпиада. В честь этого Маша, для разминки, предложила сыграть Оле в следующую игру:

Есть массив \(a\) размера \(n\). Первой ходит Маша, игроки ходят по-очереди. Каждый ход описывается следующей последовательностью действий:

\(\bullet\) Если размер массива равен \(1\) — игра завершается.

\(\bullet\) Игрок, который сейчас ходит, выбирает два различных индекса \(i\), \(j\) (\(1 \le i, j \le |a|\)), и проделывает следующую операцию — удаляет \(a_i\) и \(a_j\) из массива и добавляет в массив число равное \(\lfloor \frac{a_i + a_j}{2} \rfloor \cdot 2\). Иными словами, сначала делит сумму чисел \(a_i\), \(a_j\) на \(2\) с округлением вниз, после чего результат умножает на \(2\).

Маша стремится максимизировать итоговое число, Оля же — минимизировать.

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

Для каждого \(k = 1, 2, \ldots, n\) ответьте на следующий вопрос. Пусть в игре присутствуют только первые \(k\) элементов массива \(a\), соответственно с индексами \(1, 2, \ldots, k\). Какое число тогда останется при оптимальной игре обоих игроков?

Входные данные

Первая строка содержит целое число \(t\) (\(1 \leq t \leq 10^4\)) — количество наборов входных данных.

Первая строка каждого набора входных данных содержит единственное целое число \(n\) (\(1 \le n \le 10^5\)) — размер массива.

Во второй строке содержится \(n\) целых чисел \(a_1,a_2, \ldots,a_n\) (\(1 \leq a_i \leq 10^9\)) — массив, на котором играют Маша и Оля.

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

Выходные данные

Для каждого набора входных данных выведите \(n\) целых чисел. \(k\)-е из этих чисел должно быть равно числу, которое останется в конце при оптимальной игре обоих, на массиве, состоящем из первых \(k\) элементов массива \(a\).

Примечание

В третьем наборе входных данных для префикса длины \(1\) ответ \(3\). Для префикса длины \(2\) у Маши есть один вариант для хода, поэтому ответ \(12\). Для префикса длины \(3\) у Маши есть три возможных хода: она выбирает \(3\) и \(10\), тогда число в конце \(22\), \(3\) и \(11\), тогда число в конце \(24\), \(10\) и \(11\), тогда число в конце \(22\), значит Маша выберет \(3\) и \(11\) и получит \(24\).

A. Обмен кошельками

игры математика *800

Алисе и Бобу стало скучно, и они решили поиграть в игру со своими кошельками. У Алисы в кошельке есть \(a\) монет, а у Боба — \(b\) монет.

Игроки ходят по очереди, причем первый ход делает Алиса. Каждый ход текущий игрок выполняет следующие действия по очереди:

  1. Решить, обменяться кошельками с соперником или же оставить свой текущий кошелек.
  2. Вынуть \(1\) монету из своего текущего кошелька. Перед выполнением этого шага в кошельке не может быть \(0\) монет.

Игрок, который не может сделать корректный ход, проигрывает. Определите, кто победит в игре, если и Алиса, и Боб играют оптимально.

Входные данные

Каждый тест состоит из нескольких наборов входных данных. В первой строке находится одно целое число \(t\) (\(1 \leq t \leq 1000\)) — количество наборов входных данных. Далее следует описание наборов входных данных.

Первая и единственная строка каждого набора входных данных содержит два целых числа \(a\) и \(b\) (\(1 \le a, b \le 10^9\)) — количество монет в кошельках Алисы и Боба соответственно.

Выходные данные

Для каждого набора входных данных выведите «Alice», если в игре победит Алиса, и «Bob», если в игре победит Боб.

Примечание

Пример игры для первого набора входных данных:

  • Алиса решает не обмениваться кошельками с Бобом на 1 шаге своего хода. Теперь \(a=0\) и \(b=1\).
  • Поскольку кошелёк Алисы пуст, Боб должен решить не обмениваться кошельками на 1 шаге своего хода. Теперь \(a=0\) и \(b=0\).
  • Поскольку кошельки Алисы и Боба пусты, Алиса не может сделать ход. Следовательно, Боб выигрывает.

Пример игры для второго набора входных данных:

  • Алиса решает поменяться кошельками с Бобом на 1 шаге своего хода. Теперь \(a=3\) и \(b=1\).
  • Боб решает поменяться кошельками с Алисой на 1 шаге своего хода. Теперь \(a=1\) и \(b=2\).
  • Алиса решает не обмениваться кошельками с Бобом на 1 шаге своего хода. Теперь \(a=0\) и \(b=2\).
  • Поскольку кошелёк Алисы пуст, Боб может выбрать только не обмениваться кошельками с Алисой на 1 шаге своего хода. Теперь \(a=0\) и \(b=1\).
  • Поскольку кошелёк Алисы пуст, Алиса может выбрать только обмен кошельками с Бобом на 1 шаге своего хода. Теперь \(a=0\) и \(b=0\).
  • Поскольку и кошелёк Алисы, и кошелёк Боба пусты, Боб не может сделать ход. Следовательно, Алиса выигрывает.

G. Легендарный древесный гроссмейстер

Деревья игры Конструктив разделяй и властвуй *3500

В мире деревьев есть популярная игра для двух игроков, которая проводится на дереве с \(n\) вершинами, пронумерованными от \(1\) до \(n\). В этой игре ведущие турнира сначала выбирают вершину, которая будет корнем дерева, и выбирают другую вершину (возможно, ту же самую, что и корень), на которую кладут монету. Затем каждый игрок по очереди перемещает монету в любую дочернюю\(^\dagger\) вершину вершины, на которой в данный момент находится монета. Первый игрок, который не может сделать ход, проигрывает.

Алиса хочет стать легендарным древесным гроссмейстером, поэтому она тратит много времени на изучение игры. Она записала матрицу \(s\) размером \(n\) на \(n\), где \(s_{i,j} = \mathtt{1}\), если первый игрок может выиграть, если корнем дерева выбрана вершина \(i\), а монета изначально была помещена на вершину \(j\). В противном случае \(s_{i, j} = \mathtt{0}\). Алиса — перфекционистка, поэтому она предполагает, что оба игрока играют идеально.

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

\(^\dagger\) Вершина \(c\) является дочерней по отношению к вершине \(u\), если между \(c\) и \(u\) есть ребро, и \(c\) не лежит на единственном простом пути из корня в вершину \(u\).

Входные данные

Первая строка содержит одно целое число \(n\) (\(1 \le n \le 5000\))  — количество вершин в дереве.

Каждая из следующих \(n\) строк содержит строку из \(n\) символов, где \(j\)-й символ \(i\)-й строки равняется \(s_{i, j}\) (\(s_{i, j} \in \{\mathtt{0}, \mathtt{1}\}\)) — выигрышные и проигрышные состояния дерева.

Выходные данные

Если не существует дерева, удовлетворяющего выигрышным и проигрышным состояниям, представленным матрицей \(s\), выведите единственную строку, содержащую «NO».

В противном случае, если существует дерево, удовлетворяющее матрице \(s\), выведите «YES» в первой строке, а затем \(n - 1\) строку, каждая из которых содержит два целых числа \(u\) и \(v\) (\(1 \le u, v \le n\)), означающих, что дерево имеет ребро между вершинами \(u\) и \(v\).

Вы можете выводить каждую букву в любом регистре (строчную или заглавную). Например, строки «yEs», «yes», «Yes» и «YES» будут приняты как положительный ответ.

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

Примечание

В первом наборе входных данных граф \(1\!-\!4\!-\!2\!-\!3\) удовлетворяет выигрышным и проигрышным состояниям, представленным матрицей \(s\). Например, \(s_{3,3} = 1\), так как первый игрок может переместить монету из \(3\rightarrow 2\), затем второй игрок перемещает монету из \(2\rightarrow 4\), и, наконец, первый игрок перемещает монету из \(4\rightarrow 1\). В этот момент у вершины \(1\) нет детей, поэтому второй игрок не может сделать ход и проигрывает. С другой стороны, \(s_{1,3} = 0\), так как если \(1\) является корнем, то у \(3\) нет детей, поэтому первый игрок не может сделать первый ход и проигрывает.

Во втором наборе входных данных можно показать, что ни одно дерево не удовлетворяет матрице \(s\).

B. Игра в суммирование

жадные алгоритмы игры математика сортировки *1100

Алиса и Боб играют в игру. У них есть массив \(a_1, a_2,\ldots,a_n\). Игра состоит из двух шагов:

  • Сначала Алиса удаляет не более \(k\) элементов из массива.
  • Затем Боб умножает не более \(x\) элементов массива на \(-1\).

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

Входные данные

Каждый тест состоит из нескольких наборов входных данных. Первая строка содержит одно целое число \(t\) (\(1 \leq t \leq 10^4\)) — количество наборов входных данных. Далее следует описание наборов входных данных.

Первая строка каждого набора входных данных содержит три целых числа \(n\), \(k\) и \(x\) (\(1 \leq n \leq 2 \cdot 10^5\), \(1 \leq x,k \leq n\)) — количество элементов в массиве, ограничение на количество элементов массива, которые может удалить Алиса, и ограничение на количество элементов массива, которые Боб может умножить на \(-1\).

Вторая строка каждого набора входных данных содержит \(n\) целых чисел \(a_1, a_2,\ldots, a_n\) (\(1 \leq a_i \leq 1000\)) — элементы массива.

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

Выходные данные

Для каждого набора входных данных выведите одно целое число — сумму элементов массива после игры, если оба игрока играют оптимально.

Примечание

В первом наборе входных данных для Алисы оптимально удалить единственный элемент массива. Тогда сумма элементов массива будет равна \(0\) после окончания игры.

Во втором наборе входных данных для Алисы оптимально не удалять никакие элементы. Тогда Боб умножит \(4\) на \(-1\). Таким образом, итоговая сумма элементов массива будет равна \(3+1+2-4=2\).

В пятом наборе входных данных для Алисы оптимально удалить \(9, 9\). Затем Боб умножит \(5, 5, 3\) на \(-1\). Таким образом, итоговая сумма элементов массива будет равна \(-5-5-3+3+3+2=-5\).

E. Съесть фишку

жадные алгоритмы игры математика Перебор *1600

Алиса и Боб играют в игру на клетчатой доске. Доска имеет \(h\) строк, пронумерованных сверху вниз, и \(w\) столбцов, пронумерованных слева направо. Оба игрока имеют по фишке. Изначально фишка Алисы стоит в клетке с координатами \((x_a, y_a)\) (строка \(x_a\), столбец \(y_a\)), а фишка Боба — в \((x_b, y_b)\). Гарантируется, что начальные позиции фишек не совпадают. Игроки делают ходы по очереди, начинает Алиса.

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

Более формально, если в начале хода Алиса стоит в клетке с координатами \((x_a, y_a)\), то она может переместить свою фишку в одну из клеток \((x_a + 1, y_a)\), \((x_a + 1, y_a - 1)\) или \((x_a + 1, y_a + 1)\). Боб же, в свою очередь, из клетки \((x_b, y_b)\) может переместиться в \((x_b - 1, y_b)\), \((x_b - 1, y_b - 1)\) или \((x_b - 1, y_b + 1)\). При этом новые координаты фишки \((x', y')\) должны удовлетворять условиям \(1 \le x' \le h\) и \(1 \le y' \le w\).

Пример состояния игры. Алиса играет белой фишкой, Боб — черной. Стрелками обозначены возможные ходы.

Игрок немедленно побеждает, если ставит свою фишку в клетку, занятую фишкой другого игрока. Если какой-либо из игроков не может сделать ход (Алиса — если находится в последней строке, т. е. \(x_a = h\), Боб — если в первой, т. е. \(x_b = 1\)), игра сразу же завершается ничьей.

Каким будет исход игры при оптимальной игре обоих противников?

Входные данные

Каждый тест состоит из нескольких наборов входных данных. В первой строке находится одно целое число \(t\) (\(1 \le t \le 10^4\)) — количество наборов входных данных. Далее следует описание наборов входных данных.

Каждый набор входных данных состоит из одной строки, содержащей шесть целых чисел \(h\), \(w\), \(x_a\), \(y_a\), \(x_b\), \(y_b\) (\(1 \le x_a, x_b \le h \le 10^6\), \(1 \le y_a, y_b \le w \le 10^9\)) — размеры доски и координаты начальных позиций фишек Алисы и Боба. Гарантируется, что: либо \(x_a \ne x_b\), либо \(y_a \ne y_b\).

Сумма \(h\) по всем наборам входных данных не превышает \(10^6\).

Выходные данные

Для каждого набора входных данных выведите «Alice», если побеждает Алиса, «Bob», если побеждает Боб, и «Draw», если никто из игроков не может обеспечить себе победу. Вы можете выводить каждую букву в любом регистре (строчную или заглавную). Например, строки «bOb», «bob», «Bob» и «BOB» будут приняты как победа Боба.

C. Саша и казино

Бинарный поиск жадные алгоритмы игры Конструктив математика Перебор *1400

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

Саша знает, что казино работает по следующим правилам. Если Саша сделает ставку в \(y\) монет (где \(y\) — положительное целое число), то в случае победы он получит \(y \cdot k\) монет (то есть количество его монет увеличится на \(y \cdot (k - 1)\)). А в случае поражения он потеряет всю сумму ставки (то есть количество его монет уменьшится на \(y\)).

Обратите внимание, что сумма ставки всегда должна быть положительным (\(> 0\)) целым числом и не может превышать текущее количество монет у Саши.

Также Саше известно, что в казино действует акция: он не может проиграть более \(x\) раз подряд.

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

Входные данные

Каждый тест состоит из нескольких наборов входных данных. Первая строка содержит одно целое число \(t\) (\(1 \le t \le 1000\)) — количество наборов входных данных. Далее следует описание наборов входных данных.

Единственная строка каждого набора входных данных содержит три целых числа \(k, x\) и \(a\) (\(2 \leq k \leq 30\), \(1 \leq x \leq 100\), \(1 \leq a \leq 10^9\)) — количество раз, в которое увеличивается ставка при выигрыше, максимальное количество проигрышей подряд и изначальное количество монет у Саши.

Выходные данные

Для каждого набора входных данных выведите «YES» (без кавычек), если Саша сможет получить сколь угодно много монет и «NO» (без кавычек) в противном случае.

Вы можете выводить «YES» и «NO» в любом регистре (например, строки «yEs», «yes» и «Yes» будут распознаны как положительный ответ).

Примечание

В первом наборе входных данных Саша может действовать следующим образом:

  • Если Саша делает ставку в первый раз или в предыдущий раз он выиграл, то он ставит \(1\) монету.
  • Если в предыдущий раз Саша проиграл, то он ставит \(2\) монеты.

Обратите внимание, что Саша не может проиграть более одного раза подряд.

Можно доказать, что при такой стратегии Саша может получить сколько угодно много монет.

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

E. Аня и подарок на День святого Валентина

жадные алгоритмы игры математика сортировки *1400

Саша подарил Ане на День святого Валентина массив \(a\) из \(n\) целых чисел. Ане не нужен этот массив, поэтому она предлагает его уничтожить, сыграв в игру.

Игроки ходят по очереди. Саша джентльмен, поэтому уступает право первого хода Ане.

  • Аня в свой ход должна выбрать элемент \(a_i\) из массива и развернуть последовательность цифр его значения. Например, если Аня выбрала элемент со значением \(42\), он превратится в \(24\); если Аня выбрала элемент со значением \(1580\), он превратится в \(851\). Обратите внимание, что ведущие нули удаляются. После этого хода количество элементов в массиве не изменится.
  • Саша в свой ход должен извлечь два элемента \(a_i\) и \(a_j\) (\(i \ne j\)) из массива, склеить их в любом порядке и вставить результат в массив. Например, если Саша выбрал элементы равные \(2007\) и \(19\), то он удалит эти два элемента из массива и добавит значение \(200719\) или \(192007\). После этого хода количество элементов в массиве уменьшится на \(1\).

Пропускать ходы игроки не могут. Игра заканчивается, когда Саша не может сделать ход, то есть после хода Ани осталось ровно одно число. Если это число не меньше \(10^m\) (т.е., \(\ge 10^m\)), побеждает Саша. В противном случае побеждает Аня.

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

Входные данные

В первой строке дано целое число \(t\) (\(1 \le t \le 10^4\)) — количество наборов входных данных.

Далее следуют описание наборов.

В первой строке каждого набора даны целые числа \(n\), \(m\) (\(1 \le n \le 2 \cdot 10^5\), \(0 \le m \le 2 \cdot 10^6\)) — количество чисел в массиве и параметр, определяющий, когда побеждает Саша.

Во второй строке каждого набора даны \(n\) целых чисел \(a_1, a_2, \ldots, a_n\) (\(1 \le a_i \le 10^9\)) — массив, который Саша подарил Ане.

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

Выходные данные

Для каждого набора входных данных выведите:

  • «Sasha», если при оптимальной игре побеждает Саша;
  • «Anna», если при оптимальной игре побеждает Аня.
Примечание

Рассмотрим первый набор входных данных.

Аня может развернуть число \(2\), тогда Саша склеит числа \(2\) и \(14\), получив число \(214\), что больше \(10^2 = 100\). Если бы Аня развернула число \(14\), Саша бы склеил числа \(41\) и \(2\), получив число \(412\), что больше \(10^2 = 100\). Других возможных ходов у Ани нет, поэтому она проигрывает.

D2. Разбиение XOR — игровая версия

битмаски жадные алгоритмы игры интерактив *2400

Это интерактивная задача.

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

Алиса и Боб играют в игру. Игра начинается с целого числа \(n\). Игроки совершают ходы по очереди. На каждом ходу игры происходит следующая последовательность событий:

  • Игрок, имеющий целое число \(p\), разбивает его на два целых числа \(p_{1}\) и \(p_{2}\), где \(0 \lt p_{1} \lt p\), \(0 \lt p_{2} \lt p\) и \(p_{1} \oplus p_{2} = p\).
  • Если такие \(p_{1}\), \(p_{2}\) не существуют, то игрок проигрывает.
  • Иначе, оппонент выбирает либо \(p_{1}\), либо \(p_{2}\).
  • Игра продолжается с выбранным числом. Оппонент будет пытаться разбить его.

Ваша задача помочь Алисе выиграть. Вы можете выполнить не более \(63\) операций разбиения. Вы можете выбрать будет Алиса ходить первой или второй. Система будет играть за Боба.

Здесь \(\oplus\) обозначает операцию побитового исключающего ИЛИ.

Входные данные

Каждый тест состоит из нескольких наборов входных данных. В первой строке находится одно целое число \(t\) (\(1 \leq t \leq 1000\)) — количество наборов входных данных.

Единственная строка каждого набора входных данных содержит целое число \(n\) (\(1 \leq n \leq 10^{18}\)) — число, с которого начинается игра.

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

Для каждого тестового случая, взаимодействие начинается с чтения целого числа \(n\).

После чтения \(n\), выведите отдельную строку, содержащую либо «first», либо «second», обозначив, каким вы хотите начать игру(первым или вторым соответственно).

Во время хода Алисы вы должны вывести два положительных целых числа \(p_{1}\) и \(p_{2}\), такие что \(0 \lt p_{1} \lt p\), \(0 \lt p_{2} \lt p\) и \(p_{1} \oplus p_{2} = p\). Здесь \(p\) должно равняться одному из двух чисел выведенных Бобом на предыдущем ходу. Если до этого не было ходов, то \(p\) равняется \(n\). Если Алиса не может произвести операцию разбиения, выведите «0 0», после чего вы получите вердикт Неправильный ответ.

Во время хода Боба, вы должны прочитать два положительных целых числа \(p_{1}\) и \(p_{2}\), такие что \(0 \lt p_{1} \lt p\), \(0 \lt p_{2} \lt p\) и \(p_{1} \oplus p_{2} = p\). Здесь \(p\) должно равняться одному из двух чисел выведенных Алисой на предыдущем ходу. Если до этого не было ходов, то \(p\) равняется \(n\). Если Боб не может произвести операцию разбиения, \(p_{1} = 0\) and \(p_2 = 0\), в случае чего вы должны перейти к решению следующего тестового случая.

Если операция, совершенная Алисой, некорректна, интерактор выведет «-1 -1» и ваша программа должна завершиться незамедлительно, чтобы получить вердикт Неправильный ответ.

Если Алиса совершает \(63\) хода и Боб все еще может совершить операцию разбиения с текущими числами, интерактор выведете «-1 -1», и ваша программа должна завершиться незамедлительно, чтобы получить вердикт Неправильный ответ.

После вывода запроса не забудьте вывести перевод строки и сбросить буфер вывода. В противном случае вы получите вердикт Решение «зависло». Для сброса буфера используйте:

  • fflush(stdout) или cout.flush() в C++;
  • System.out.flush() в Java;
  • flush(output) в Pascal;
  • stdout.flush() в Python;
  • смотрите документацию для других языков.

Вы не можете делать взломы в этой задаче.

Примечание

Пояснения по взаимодействию.

Интерактор / БобАлисаПояснение
4\(t\)
1\(n\) для первого тестового случая
secondАлиса выбирает начать второй
0 0Боб говорит, что не может разбить \(p = 1\)
3\(n\) для второго тестового случая
firstАлиса выбирает начать первой
1 2Алиса ломает \(p = 3\) на \(p_1 = 1\) и \(p_2 = 2\)
0 0Боб говорит, что не может разбить ни \(p = 1\), ни \(p = 2\)
13\(n\) для третьего тестового случая
firstАлиса выбирает начать первой
10 7Алиса ломает \(p = 13\) на \(p_1 = 10\) и \(p_2 = 7\)
3 4Боб ломает \(p = 7\) на \(p_1 = 3\) и \(p_2 = 4\)
1 2Алиса ломает \(p = 3\) на \(p_1 = 1\) и \(p_2 = 2\)
0 0Боб говорит, что не может разбить ни \(p = 1\), ни \(p = 2\)
777777770001\(n\) для четвертого тестового случая
firstАлиса выбирает начать первой
777777770000 1Алиса ломает \(p = 777\,777\,770\,001\) на \(p_1 = 777\,777\,770\,000\) и \(p_2 = 1\)
0 0Боб говорит, что не может совершить операцию разбиения

Таблица лишь для пояснения формата взаимодействия и не отражает настоящего поведения интерактора.

Обратите внимание, что в последнем тестовом случае Боб мог выбрать \(p_1\) и совершить операцию разбиения, но он сдался.

E. Фермерская игра

игры Комбинаторика *2300

Фермер Нхой привел своих коров на ферму Фермера Джона, чтобы поиграть в игру! Ферма Фермера Джона может быть представлена в виде числовой прямой со стенами в точках \(0\) и \(l + 1\). На ферме есть \(2n\) коров, причем \(n\) коров принадлежат Фермеру Джону, а остальные \(n\) — Фермеру Нхою. Они размещают своих коров в различных точках так, чтобы никакие две коровы одного фермера не были соседними. Две коровы являются соседними, если между ними нет других коров.

Формально, если \(a_1, a_2, \ldots, a_n\) представляют позиции коров фермера Джона, а \(b_1, b_2, \ldots, b_n\) представляют позиции коров фермера Нхоя, то \(0 < a_1 < b_1 < a_2 < b_2 < \ldots < a_n < b_n < l + 1\), или \(0 < b_1 < a_1 < b_2 < a_2 < \ldots < b_n < a_n < l + 1\).

За один ход фермер выбирает число \(k\) \((1 \leq k \leq n)\) и направление (влево или вправо). Затем этот фермер выбирает \(k\) своих коров и перемещает их на одну позицию в выбранном направлении. Фермер не может переместить ни одну из своих коров на стены или на корову другого фермера. Если фермер не может переместить ни одной коровы, то он проигрывает. Фермер Джон начинает игру и делает первый ход.

Учитывая \(l\) и \(n\), найдите количество возможных конфигураций игры, при которых Фермер Джон выиграет, если оба фермера играют оптимально. В случае, если при оптимальной игре она продолжается бесконечно долго, считается, что никто из фермеров не выигрывает. Конфигурация отличается от другой, если существует такое \(i\), что \(a_i\) или \(b_i\) отличаются. Выведите ответ по модулю \(998\,244\,353\).

Входные данные

Каждый тест состоит из нескольких наборов входных данных. В первой строке находится одно целое число \(t\) (\(1 \leq t \leq 10^4\)) — количество наборов входных данных. Далее следует описание наборов входных данных.

Каждый набор входных данных содержит два целых числа \(l\) и \(n\) (\(2 \leq l \leq 10^6, 1 \leq n \leq \lfloor \frac{l}{2} \rfloor\)) — длина числовой прямой и количество коров, которое поставит каждый фермер.

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

Выходные данные

Для каждого набора входных данных выведите целое число: количество конфигураций игры, в которых Фермер Джон выигрывает, если оба фермера играют оптимально, по модулю \(998\,244\,353\).

Примечание

Пусть J обозначает корову Фермера Джона, N обозначает корову Фермера Нхоя, а _ обозначает пустое место.

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

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

A. MEX игра - 1

жадные алгоритмы игры *1300

Алиса и Боб играют в очередную игру на массиве \(a\) длины \(n\). Алиса начинает с пустого массива \(c\). Оба игрока ходят по очереди, причем Алиса начинает первой.

В свой ход Алиса выбирает один элемент из \(a\), добавляет его в \(c\), а затем удаляет из \(a\).

В свой ход Боб выбирает один элемент из \(a\), а затем удаляет его из \(a\).

Игра заканчивается, когда массив \(a\) становится пустым. Счет игры определяется как MEX\(^\dagger\) элементов \(c\). Алиса хочет максимизировать счет игры, а Боб — минимизировать его. Найдите итоговый счет игры, если оба игрока играют оптимально.

\(^\dagger\) \(\operatorname{MEX}\) (minimum excludant) массива целых чисел определяется как наименьшее целое неотрицательное число, которое не встречается в массиве. Например:

  • MEX массива \([2,2,1]\) равен \(0\), потому что \(0\) не принадлежит массиву.
  • MEX массива \([3,1,0,1]\) равен \(2\), потому что \(0\) и \(1\) принадлежат массиву, а \(2\) — нет.
  • MEX массива \([0,3,1,2]\) равен \(4\), потому что \(0\), \(1\), \(2\) и \(3\) принадлежат массиву, а \(4\) — нет.
Входные данные

Каждый тест состоит из нескольких наборов входных данных. В первой строке находится одно целое число \(t\) (\(1 \leq t \leq 2 \cdot 10^4\)) — количество наборов входных данных. Далее следует описание наборов входных данных.

В первой строке каждого набора входных данных находится одно целое число \(n\) (\(1 \le n \le 2 \cdot 10^5\)).

Вторая строка каждого набора входных данных содержит \(n\) целых чисел \(a_1, a_2, \ldots, a_n\) (\(0 \le a_i < n\)).

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

Выходные данные

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

Примечание

В первом наборе входных данных возможная игра со счетом \(2\) выглядит следующим образом:

  1. Алиса выбирает элемент \(1\). После этого хода \(a=[0,0,1]\) и \(c=[1]\).
  2. Боб выбирает элемент \(0\). После этого хода \(a=[0,1]\) и \(c=[1]\).
  3. Алиса выбирает элемент \(0\). После этого хода \(a=[1]\) и \(c=[1,0]\).
  4. Боб выбирает элемент \(1\). После этого хода \(a=[\,]\) и \(c=[1,0]\).

В конце массив \(c=[1,0]\), и его MEX равен \(2\). Обратите внимание, что это пример игры и не обязательно представляет собой оптимальную стратегию для обоих игроков.

H. Щелчок Таноса

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

Имеется массив \(a\) длины \(2^k\), который изначально является перестановкой значений от \(1\) до \(2^k\) для некоторого целого положительного числа \(k\). Алиса и Боб играют в следующую игру на массиве \(a\). Сначала Алисе и Бобу даётся значение \(t\) между \(1\) и \(k\). Затем, ровно \(t\) ходов происходит следующее:

  • Алиса либо ничего не делает, либо выбирает два различных элемента массива \(a\) и меняет их местами.
  • Боб выбирает либо левую половину, либо правую половину массива \(a\), и стирает её.

Счет игры определяется как максимальное значение в \(a\) после всех \(t\) ходов. Алиса хочет максимизировать этот счет, а Боб — минимизировать.

Вам нужно вывести \(k\) чисел: счет игры, если и Алиса, и Боб играют оптимально, для всех \(t\) от \(1\) до \(k\).

Входные данные

Каждый тест состоит из нескольких наборов входных данных. Первая строка содержит целое число \(t\) (\(1 \le t \le 10^4\)) — количество наборов входных данных. Далее следует описание наборов входных данных.

Первая строка каждого набора входных данных содержит целое число \(k\) (\(1 \le k \le 20\)) — параметр длины массива \(a\).

Вторая строка каждого набора входных данных содержит \(2^k\) целых чисел \(a_1, a_2, \ldots, a_{2^k}\) (\(1 \le a_i \le 2^k\), \(a_i\) попарно различны) — заданный массив \(a\).

Гарантируется, что сумма \(2^k\) по всем наборам входных данных не превосходит \(2^{20}\).

Выходные данные

Для каждого набора входных данных выведите \(k\) чисел, где \(i\)-е число — это счет игры, если Алиса и Боб играют оптимально, а игра длится \(t = i\) ходов.

Примечание

В третьем наборе входных данных, для \(t = 2\), игра могла бы проходить следующим образом:

  • Изначально, \(a = [5, 1, 6, 4, 7, 2, 8, 3]\).
  • Алиса меняет местами \(a_6\) и \(a_8\), \(a\) становится \([5, 1, 6, 4, 7, 3, 8, 2]\).
  • Боб стирает правую половину массива, \(a\) становится \([5, 1, 6, 4]\).
  • Алиса ничего не делает, \(a\) остается \([5, 1, 6, 4]\).
  • Боб стирает правую половину массива, \(a\) становится \([5, 1]\).
  • Игра заканчивается со счётом \(5\).

E. Линейное сканирование

*особая задача игры Комбинаторика математика

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

Первая строка содержит одно целое число \(n\) (\(1 \leq n \leq 10^5\)) — длина массива \(a\).

Вторая строка содержит \(n\) целых чисел \(a_1, a_2, \ldots, a_n\) (\(0 \leq a_i \leq 2\)) — массив \(a\).

Выходные данные

Выведите одно целое число — количество решений по модулю \(20240401\).

Примечание

В первом примере массив выглядит следующим образом:

\( \color{blue}{1} \)\( \color{blue}{1} \)\( \color{darkgreen}{2} \)\( \color{blue}{1} \)\( \color{blue}{1} \)\( \color{darkgreen}{2} \)\( \color{gray}{0} \)

Очевидно, что ответ здесь равен \(1 \pmod{20240401}\).

Во втором примере массив выглядит следующим образом:

\( \color{blue}{1} \)\( \color{blue}{1} \)\( \color{darkgreen}{2} \)\( \color{blue}{1} \)\( \color{blue}{1} \)\( \color{blue}{1} \)\( \color{gray}{0} \)

Я не знаю, почему ответ здесь равен \(2 \pmod{20240401}\), мне пришлось догадаться.

В третьем примере массив выглядит следующим образом:

\( \color{gray}{0} \)\( \color{blue}{1} \)\( \color{darkgreen}{2} \)\( \color{blue}{1} \)\( \color{blue}{1} \)\( \color{blue}{1} \)\( \color{gray}{0} \)

Если ответ здесь не равен \(0 \pmod{20240401}\), я буквально взорвусь.

F. Нечестная игра

дп жадные алгоритмы игры математика расписания *1800

Алиса и Боб собрались вечером, чтобы поиграть в увлекательную игру на последовательности из \(n\) натуральных чисел, не превосходящих \(4\). Правила игры слишком сложны для их описания, поэтому просто опишем критерий победы — Алиса побеждает, если исключающее ИЛИ всех чисел последовательности отлично от нуля, в противном случае же побеждает Боб.

Ребята позвали Еву, чтобы она выступала в качестве судьи. Изначально Алиса и Боб играют с \(n\) числами. После одной игры Ева удаляет одно из чисел из последовательности, затем Алиса и Боб играют с \(n-1\) числами, Ева снова удаляет одно из чисел, после чего Алиса и Боб играют с \(n - 2\) числами. Так продолжается до тех пор, пока последовательность чисел не пуста.

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

Входные данные

В первой строке задано целое число \(t\) (\(1 \le t \le 10^4\)) — количество наборов входных данных.

Первая и единственная строка каждого набора содержит четыре целых числа \(p_i\) (\(0 \le p_i \le 200\)) — количество единиц, двоек, троек и четвёрок в последовательности в начале игры.

Выходные данные

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

Примечание

В первом примере Боб выигрывает, когда Ева ещё не убрала ни одного числа.

Во втором примере Боб выигрывает, если Ева уберёт одну единицу и одну тройку.

A. Игра Нины

Бинарный поиск жадные алгоритмы игры Перебор Структуры данных *800

Нина придумала новую игру, основанную на возрастающей последовательности целых чисел \(a_1, a_2, \ldots, a_k\).

В этой игре, изначально \(n\) игроков встают в ряд. В каждом раунде происходит следующее:

  • Нина находит \(a_1\)-го, \(a_2\)-го, \(\ldots\), \(a_k\)-го игроков в ряду. Они покидают игру одновременно. Если игру должен покинуть \(i\)-й игрок в ряду, но в ряду меньше \(i\) игроков, этот игрок пропускается.

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

Например, рассмотрим игру с \(a=[3, 5]\) и \(n=5\) игроками. Пусть игроков зовут игрок A, игрок B, \(\ldots\), игрок E в том порядке, в котором они выстроились изначально. Тогда,

  • Перед первым раундом, порядок игроков в ряду ABCDE. Нина находит \(3\)-го и \(5\)-го игроков в ряду. Это игроки C и E. Они покидают игру в первом раунде.
  • Теперь порядок игроков ABD. Нина находит \(3\)-го и \(5\)-го игроков в ряду. \(3\)-й игрок это игрок D и в ряду нет \(5\)-го игрока. Поэтому только игрок D покидает игру во втором раунде.
  • В третьем раунде никто не покидает игру, поэтому после этого раунда игра заканчивается.
  • Игроки A и B объявляются победителями.

Нина пока не решила, сколько игроков будут принимать участие в игре. Она даст вам \(q\) целых чисел \(n_1, n_2, \ldots, n_q\), а вы должны ответить на следующий вопрос для всех \(1 \le i \le q\) независимо:

  • Сколько игроков будут объявлены победителями, если изначально в игре будут принимать участие \(n_i\) игроков?
Входные данные

В первой строке дано одно целое число \(t\) (\(1 \le t \le 250\)) — количество наборов входных данных.

В первой строке даны два целых числа \(k\) и \(q\) (\(1 \le k, q \le 100\)) — длина последовательности \(a\) и количество значений \(n_i\), для которых вы должны решить задачу.

Во второй строке даны \(k\) целых чисел \(a_1,a_2,\ldots,a_k\) (\(1\leq a_1<a_2<\ldots<a_k\leq 100\)) — последовательность \(a\).

В третьей строке даны \(q\) целых чисел \(n_1,n_2,\ldots,n_q\) (\(1\leq n_i \leq 100\)).

Выходные данные

Для каждого набора входных данных выведите \(q\) целых чисел: \(i\)-е (\(1\le i \le q\)) из них должно быть равно количеству игроков, которые будут объявлены победителями, если изначально в игре будет принимать участие \(n_i\) игроков.

Примечание

Первый набор входных данных разобран в условии.

Во втором наборе входных данных при \(n=1\), единственный игрок остаётся в игре после первого раунда. После этого, игра заканчивается и он объявляется победителем.

B. Нина и карточная игра

жадные алгоритмы игры *800

Вы и Нина играете в карточную игру. Для игры используется колода из \(2n\) карт. На каждой карте написано целое число от \(1\) до \(n\), и каждое из чисел от \(1\) до \(n\) встречается ровно на \(2\) картах. Кроме того, есть стол, на который размещаются карты во время игры (в начале игры стол пустой).

В начале игры эти \(2n\) карты распределяются между вами и Ниной так, что каждый игрок получает по \(n\) карт.

После этого вы и Нина поочередно делаете суммарно \(2n\) ходов, т. е. каждый делает по \(n\) ходов, начиная с вас. На каждом ходу:

  • Игрок, чей сейчас ход, выбирает одну из карт в своей руке. Пусть \(x\) — число на выбранной карте.
  • Игрок, чей сейчас ход, получает \(1\) очко, если на столе уже есть карта с числом \(x\) (в противном случае он не получает очков). Затем он кладет выбранную карту с числом \(x\) на стол.

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

Нина очень умная, поэтому она всегда выбирает карты оптимальным образом, чтобы максимизировать свой счет в конце игры (после \(2n\) раундов). Если у нее есть несколько оптимальных ходов, она выбирает ход, который минимизирует ваш счет в конце игры.

Более формально, Нина всегда делает ходы оптимальным образом, чтобы в первую очередь максимизировать свой счет в конце игры и во вторую очередь минимизировать ваш счет в конце игры.

Пусть в начале игры числа на ваших картах — \(a_1, a_2, \ldots, a_n\). Какое максимальное количество очков вы можете получить, делая свои ходы оптимальным образом?

Входные данные

В первой строке дано одно целое число \(t\) (\(1 \le t \le 10^4\)) — количество наборов входных данных.

В первой строке дано одно целое число \(n\) (\(1 \le n \le 2 \cdot 10^5\)) — количество карт, которые вы и Нина получаете в начале игры.

Во второй строке даны \(n\) целых чисел \(a_1, a_2, \ldots, a_n\) (\(1 \le a_i \le n\)) — числа на картах в вашей руке. Гарантируется, что каждое целое число от \(1\) до \(n\) встречается в последовательности \(a_1, a_2, \ldots, a_n\) не более \(2\) раз.

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

Выходные данные

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

Примечание

В первом наборе входных данных на ваших картах написаны числа \(1\), \(1\), \(2\) и \(3\). На картах Нины написаны числа \(2\), \(3\), \(4\) и \(4\). Возможный ход игры:

  1. Вы выбираете одну из карт с числом \(1\) и кладете ее на стол.
  2. Нина выбирает одну из карт с числом \(4\) и кладет ее на стол.
  3. Вы выбираете карту с числом \(1\), получаете \(1\) очко и кладете выбранную карту на стол.
  4. Нина выбирает карту с числом \(4\), получает \(1\) очко и кладет выбранную карту на стол.
  5. Вы выбираете карту с числом \(2\) и кладете ее на стол.
  6. Нина выбирает карту с числом \(2\), получает \(1\) очко и кладет выбранную карту на стол.
  7. Вы выбираете карту с числом \(3\) и кладете ее на стол.
  8. Нина выбирает карту с числом \(3\), получает \(1\) очко и кладет выбранную карту на стол.

В конце игры вы набрали \(1\) очко, а Нина \(3\). Можно показать, что вы не можете набрать больше \(1\) очка, если Нина играет оптимальным образом, поэтому ответ \(1\).

Во втором тестовом случае, если оба игрока играют оптимальным образом, вы набираете \(2\) очка, а Нина — \(6\) очков.

A. Всё о Ниме

жадные алгоритмы игры математика сортировки *1400

Алиса и Боб играют в игру с \(n\) кучками из камней. На каждом ходу игрок выбирает положительное целое число \(k\), которое не превышает размера самой маленькой непустой кучки, и удаляет \(k\) камней из каждой непустой кучки одновременно. Первый игрок, который не может сделать ход (потому что все кучки пусты), проигрывает.

Учитывая, что Алиса ходит первой, кто выиграет игру, если оба игрока играют оптимально?

Входные данные

Первая строка ввода содержит одно целое число \(t\) (\(1 \le t \le 10^4\)) — количество тестов. Далее следует описание самих тестов.

Первая строка каждого теста содержит одно целое число \(n\) (\(1 \le n \le 2\cdot 10^5\)) — количество кучек в игре.

Следующая строка каждого теста содержит \(n\) целых чисел \(a_1, a_2, \ldots a_n\) (\(1 \le a_i \le 10^9\)), где \(a_i\) — начальное количество камней в \(i\)-й кучке.

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

Выходные данные

Для каждого теста выведите одну строку с именем победителя, предполагая, что оба игрока играют оптимально. Если выигрывает Алиса, выведите «Alice», в противном случае выведите «Bob» (без кавычек).

Примечание

В первом тесте Алиса может победить, выбрав \(k=3\) на своем первом ходу, что сразу опустошит все кучки.

Во втором тесте Алисе придется выбрать \(k=1\) на своем первом ходу, так как есть кучка размера \(1\), поэтому Боб может победить на следующем ходу, выбрав \(k=6\).

E. Связанные кубики

игры Конструктив *3100

На позициях от \((1, 1, 1)\) до \((n, m, 1)\) находится \(n \cdot m\) единичных кубиков. Каждый из этих кубиков имеет один из \(k\) цветов. Вы хотите добавить дополнительные кубики в любых целочисленных координатах так, чтобы подмножество кубиков каждого цвета было связано, где два кубика считаются связанными, если они имеют общую грань.

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

Существующие кубики в настоящее время находятся в углу комнаты. Есть бесцветные кубики, полностью заполняющие плоскости \(x = 0\), \(y = 0\) и \(z = 0\), что мешает вам размещать дополнительные кубики там или в отрицательных координатах.

Найдите решение, которое использует не более \(4 \cdot 10^5\) дополнительных кубиков (не включая кубики, которые в настоящее время присутствуют), или определите, что решения нет. Можно показать, что при заданных ограничениях, если есть решение, то оно использует не более \(4 \cdot 10^5\) дополнительных кубиков.

Входные данные

Первая строка ввода содержит три целых числа \(n\), \(m\) и \(k\) (\(2 \le n, m, k \le 50\)) — количество строк и столбцов кубиков, и количество цветов, соответственно.

\(i\)-я из следующих \(n\) строк содержит \(m\) целых чисел. \(j\)-е из них — \(a_{ij}\) (\(1 \le a_{ij} \le k\)) — цвет кубика в позиции \((i, j, 1)\). Для каждого цвета от \(1\) до \(k\) гарантируется, что во входных данных есть как минимум один кубик этого цвета.

Выходные данные

Если решения нет, выведите одно целое число \(-1\).

В противном случае, первая строка вывода должна содержать одно целое число \(p\) (\(0 \le p \le 4 \cdot 10^5\)) — количество дополнительных кубиков, которые вы добавите.

Следующие \(p\) строк должны содержать четыре целых числа \(x\), \(y\), \(z\) и \(c\) (\(1 \le x, y, z \le 10^6\), \(1 \le c \le k\)) — указывая, что вы добавляете кубик цвета \(c\) в позицию \((x, y, z)\).

Ни у каких двух кубиков в выводе не должны быть одинаковые координаты, и ни один кубик в выводе не должен иметь одинаковые координаты с любым кубиком во входных данных.

Если есть несколько решений, выведите любое.

Примечание

Изображение в условии соответствует первому примеру, с \(\text{красным} = 1\), \(\text{синим} = 2\), \(\text{зеленым} = 3\).

A. Обмен картами

жадные алгоритмы игры Конструктив *800

У вас есть \(n\) карт, на каждой карте написано число, а также фиксированное целое число \(k\). Вы можете выполнять следующую операцию любое количество раз:

  • Выберите любые \(k\) карт, на которых написано одно и то же число.
  • Обменяйте эти карты на \(k-1\) карт, каждая из которых может иметь любое число, которое вы выберете (включая число, написанное на меняемых вами картах).

Вот одна из возможных последовательностей операций для первого примера, в котором \(k=3\):

Какое минимальное количество карт у вас может остаться в конце этого процесса?

Входные данные

Первая строка ввода содержит одно целое число \(t\) (\(1 \le t \le 500\)) — количество тестов. Затем следует описание тестов.

Первая строка каждого теста содержит два целых числа \(n\) и \(k\) (\(1 \le n \le 100\), \(2 \le k \le 100\)) — количество карт у вас и количество карт, которые вы обмениваете во время каждой операции, соответственно.

Следующая строка каждого теста содержит \(n\) целых чисел \(c_1, c_2, \ldots c_n\) (\(1 \le c_i \le 100\)) — числа, написанные на ваших картах.

Выходные данные

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

Примечание

Первый пример соответствует изображению выше. Последовательность операций, отображенная там, является оптимальной, поэтому ответ равен \(2\).

Во втором примере операции выполнить нельзя, поэтому ответ равен \(1\).

В четвертом примере вы можете многократно выбирать \(4\) карты с номером \(1\) и заменять их на \(3\) карты с номером \(1\), пока не останется \(3\) карты.

D. Игра в перестановке

графы жадные алгоритмы игры математика Перебор поиск в глубину и подобное *1300

Бодя и Саша нашли перестановку \(p_1,\dots,p_n\) и массив \(a_1,\dots,a_n\). Они решили сыграть в известную игру в перестановке.

Перестановкой длины \(n\) является массив, состоящий из \(n\) различных целых чисел от \(1\) до \(n\) в произвольном порядке. Например, \([2,3,1,5,4]\) — перестановка, но \([1,2,2]\) не перестановка (\(2\) встречается в массиве дважды) и \([1,3,4]\) тоже не перестановка (\(n=3\), но в массиве встречается \(4\)).

Каждый из них выбрал стартовую позицию в перестановке.

Игра длится \(k\) ходов. Игроки делают ходы одновременно. На каждом ходу с каждым игроком происходит две вещи:

  • Если текущая позиция игрока \(x\), его счет увеличивается на \(a_x\).
  • Затем игрок либо остается на своей текущей позиции \(x\), либо перемещается с \(x\) на \(p_x\).
Победителем игры становится игрок с более высоким счетом после ровно \(k\) ходов.

Зная стартовую позицию Боди \(P_B\) и стартовую позицию Саши \(P_S\), определите, кто выигрывает в игре, если оба игрока пытаются победить.

Входные данные

Первая строка содержит одно целое число \(t\) (\(1\le t\le 10^4\)) — количество наборов входных данных.

Первая строка каждого набора содержит целые числа \(n\), \(k\), \(P_B\), \(P_S\) (\(1\le P_B,P_S\le n\le 2\cdot 10^5\), \(1\le k\le 10^9\)) — длина перестановки, продолжительность игры, стартовые позиции соответственно.

Следующая строка содержит \(n\) целых чисел \(p_1,\dots,p_n\) (\(1 \le p_i \le n\)) — элементы перестановки \(p\).

Следующая строка содержит \(n\) целых чисел \(a_1,\dots,a_n\) (\(1\le a_i\le 10^9\)) — элементы массива \(a\).

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

Выходные данные

Для каждого набора входных данных выведите:

  • «Bodya», если Бодя выигрывает игру.
  • «Sasha», если Саша выигрывает игру.
  • «Draw», если у игроков одинаковый счет.
Примечание

Ниже вы можете найти объяснение для первого набора входных данных, где игра состоит из \(k=2\) ходов.

ХодПозиция БодиОчки БодиХод БодиПозиция СашиОчки СашиХод Саши
первый\(3\)\(0 + a_3 = 0 + 5 = 5\)остаётся в текущей позиции\(2\)\(0 + a_2 = 0 + 2 = 2\)переходит в \(p_2=1\)
второй\(3\)\(5 + a_3 = 5 + 5 = 10\)остаётся в текущей позиции\(1\)\(2 + a_1 = 2 + 7 = 9\)остаётся в текущей позиции
конечный результат\(3\)\(10\)\(1\)\(9\)

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

A. Игра с тарелками

игры Конструктив математика *1600

Имеются прямоугольный стол длиной a и шириной b и бесконечное число тарелок радиуса r. Два игрока играют в следующую игру: они по очереди ставят тарелки на стол так, чтобы тарелки не накладывались друг на друга (однако они могут касаться), и чтобы любая точка любой тарелки находилась в пределах стола. В процессе игры уже поставленные тарелки нельзя двигать. Проигрывает тот, кто не может сделать очередной ход. Определите, какой из игроков (тот, который ходит первым или тот, который ходит вторым) победит, если оба будут играть оптимально.

Входные данные

В единственной строке находятся три целых числа a, b, r (1 ≤ a, b, r ≤ 100), записанные через пробел, — размеры стола и радиус тарелок соответственно.

Выходные данные

Если победит игрок, который ходит первым, выведите «First» (без кавычек). Иначе выведите «Second» (без кавычек).

Примечание

В первом примере на столе есть место только для одной тарелки. Первый игрок поставит тарелку на стол, а второй этого сделать не сможет и проиграет.

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

C1. Game on Tree (Easy)

игры *1400

This is the easy version of the problem. The difference in this version is that \(t=1\) and we work on an array-like tree.

Ron and Hermione are playing a game on a tree of \(n\) nodes that are initially inactive. This tree is special because it has exactly two leaves. It can thus be seen as an array. The game consists of \(t\) rounds, each of which starts with a stone on exactly one node, which is considered as activated. A move consists of picking an inactive neighbor of the node with a stone on it and moving the stone there (thus activating this neighbor). Ron makes the first move, after which he alternates with Hermione until no valid move is available. The player that cannot make a move loses the round. If both players play optimally, who wins each round of this game?

Note that all the rounds are played with the same tree; only the starting node changes. Moreover, after each round, all active nodes are considered inactive again.

Input

The first line contains integers \(n\) (\(2 \leq n \leq 2\times 10^5\)), \(t\) (\(t=1\)), the number of nodes in the tree and the number of rounds, respectively.

The next \(n-1\) lines contain two integers \(1 \leq u, v \leq n\) each, corresponding to an edge of the tree. It is guaranteed that the tree has exactly two leaves.

The next line contains \(t\) integers \(1 \leq u_1 , \dots, u_t \leq n\), corresponding to the node where the stone is initially put.

Output

The output consists of \(t=1\) line which is either "Ron" or "Hermione".

C2. Game on Tree (Medium)

Деревья дп игры поиск в глубину и подобное *1700

This is the medium version of the problem. The difference in this version is that \(t=1\) and we work on trees.

Ron and Hermione are playing a game on a tree of \(n\) nodes that are initially inactive. The game consists of \(t\) rounds, each of which starts with a stone on exactly one node, which is considered as activated. A move consists of picking an inactive neighbor of the node with a stone on it and moving the stone there (thus activating this neighbor). Ron makes the first move, after which he alternates with Hermione until no valid move is available. The player that cannot make a move loses the round. If both players play optimally, who wins each round of this game?

Note that all the rounds are played with the same tree; only the starting node changes. Moreover, after each round, all active nodes are considered inactive again.

Input

The first line contains integers \(n\) (\(2 \leq n \leq 2\times 10^5\)), \(t\) (\(t=1\)), the number of nodes in the tree and the number of rounds, respectively.

The next \(n-1\) lines contain two integers \(1 \leq u, v \leq n\) each, corresponding to an edge of the tree.

The next line contains \(t\) integers \(1 \leq u_1 , \dots, u_t \leq n\), corresponding to the node where the stone is initially put.

Output

The output consists of \(t=1\) line which is either "Ron" or "Hermione".

C3. Game on Tree (Hard)

Деревья дп игры поиск в глубину и подобное *1900

This is the hard version of the problem. The only difference in this version is the constraint on \(t\).

Ron and Hermione are playing a game on a tree of \(n\) nodes that are initially inactive. The game consists of \(t\) rounds, each of which starts with a stone on exactly one node, which is considered as activated. A move consists of picking an inactive neighbor of the node with a stone on it and moving the stone there (thus activating this neighbor). Ron makes the first move, after which he alternates with Hermione until no valid move is available. The player that cannot make a move loses the round. If both players play optimally, who wins each round of this game?

Note that all the rounds are played with the same tree; only the starting node changes. Moreover, after each round, all active nodes are considered inactive again.

Input

The first line contains integers \(n\) (\(2 \leq n \leq 2\times 10^5\)), \(t\) (\(1 \leq t \leq n\)), the number of nodes in the tree and the number of rounds, respectively.

The next \(n-1\) lines contain two integers \(1 \leq u, v \leq n\) each, corresponding to an edge of the tree.

The next line contains \(t\) integers \(1 \leq u_1 , \dots , u_t \leq n\), corresponding to the node where the stone is initially put.

Output

The output consists of \(t\) lines, each line being either "Ron" or "Hermione".

B. Игры с монетками

игры *900

На столе лежат \(n\) монет, образующих круг, и каждая монета лежит либо лицевой стороной вверх, либо лицевой стороной вниз. Алиса и Боб играют в игру, где они ходят по очереди, причем Алиса ходит первой.

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

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

Входные данные

Каждый тест состоит из нескольких наборов входных данных. Первая строка содержит одно целое число \(t\) (\(1\le t\le 100\)) — количество наборов входных данных. Далее следует описание наборов входных данных.

Первая строка каждого набора входных данных содержит одно положительное целое число \(n\) (\(1 \leq n \leq 100\)), обозначающее количество монет.

Во второй строке каждого набора входных данных содержится строка \(s\) длины \(n\), состоящая из символов «U» и «D», обозначающие, что монета лежит лицевой стороной вверх или лицевой стороной вниз, соответственно.

Выходные данные

Для каждого набора входных данных выведите «YES», если Алиса выиграет игру, и «NO» в противном случае.

Вы можете выводить каждую букву в любом регистре (строчную или заглавную). Например, строки «yEs», «yes», «Yes» и «YES» будут приняты как положительный ответ.

Примечание

В первом наборе входных данных игра может выглядеть следующим образом:

  • Алиса выбирает первую монету и \(s\) становится «DDUU».
  • Боб выбирает последнюю монету и \(s\) становится «UDD».
  • Алиса выбирает первую монету и \(s\) становится «UU».
  • Боб выбирает первую монету и \(s\) становится «U».
  • Алиса выбирает единственную монету и \(s\) становится пустой.
  • Боб теперь не может выбрать ни одной монеты и проигрывает.

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

D. Мир мой

дп игры *1800

Алиса и Боб играют в игру. Изначально есть \(n\) тортов, у \(i\)-го из них вкусность равна \(a_i\).

Алиса и Боб по очереди их едят, первой начинает Алиса:

  • В свой ход Алиса выбирает и ест любой из оставшихся тортов, вкусность которого строго выше максимальной вкусности любого из съеденных ею до этого тортов. Обратите внимание, что в первый ход Алиса может съесть любой торт.
  • В свой ход Боб выбирает любой из оставшихся тортов и ест его.

Игра заканчивается, когда текущий игрок не может съесть подходящий торт. Пусть \(x\) это число тортов, съеденных Алисой. Тогда Алиса хочет максимизировать \(x\), в то время как Боб хочет минимизировать \(x\).

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

Входные данные

Каждый тест состоит из нескольких наборов входных данных. В первой строке находится одно целое число \(t\) (\(1 \le t \le 500\)) — количество наборов входных данных. Далее следует описание наборов входных данных.

Первая строка каждого набора входных данных содержит одно целое число \(n\) (\(1 \le n \le 5000\)) — количество тортов.

Вторая строка каждого набора входных данных содержит \(n\) целых чисел \(a_1, a_2, \ldots, a_n\) (\(1 \le a_i \le n\)) — значения вкусностей тортов.

Гарантируется, что сумма \(n\) по всем наборам входных данных не превышает \(5000\).

Выходные данные

Для каждого набора входных данных выведите одно целое число — количество тортов, съеденных Алисой, если оба игрока будут играть оптимально.

Примечание

В первом наборе входных данных одна возможная последовательность ходов — следующая:

  1. Алиса съедает торт со вкусностью \(1\). Остались торты со вкусностями \([4, 2, 3]\).
  2. Боб съедает торт со вкусностью \(2\). Остались торты со вкусностями \([4, 3]\).
  3. Алиса съедает торт со вкусностью \(3\). Остались торты со вкусностями \([4]\).
  4. Боб съедает торт со вкусностью \(4\). Остались торты со вкусностями \([]\).
  5. Так как больше тортов нет, игра на этом заканчивается.

Во втором наборе входных данных одна возможная последовательность ходов — следующая:

  1. Алиса съедает торт со вкусностью \(1\). Остались торты со вкусностями \([1, 1]\).
  2. Боб съедает торт со вкусностью \(1\). Остались торты со вкусностями \([1]\).
  3. Так как Алиса уже съела торт со вкусностью \(1\), она не может сделать ход, поэтому игра на этом заканчивается.

A. Байт на посылку

жадные алгоритмы игры Перебор сортировки *900

Алиса и Боб играют в игру на массиве \(a\) размера \(n\).

Они поочередно выполняют операции, начинает Алиса. Игрок, который не может выполнить операцию, проигрывает. Есть переменная \(mx\) изначально равная \(0\).

За одну операцию игрок может:

  • Выбрать индекс \(i\) (\(1 \le i \le n\)) такой, что \(a_{i} \geq mx\) и присвоить \(mx\) значение \(a_{i}\). Затем сделать \(a_{i}\) равным \(0\).

Определите, есть ли у Алисы выигрышная стратегия.

Входные данные

Первая строка содержит целое число \(t\) (\(1 \leq t \leq 10^3\)) — количество наборов входных данных.

Для каждого набора входных данных:

  • Первая строка содержит целое число \(n\) (\(2 \leq n \leq 50\)) — размер массива.
  • Вторая строка содержит \(n\) целых чисел \(a_1, a_2, \ldots, a_n\) (\(1 \leq a_i \leq n\)) — элементы массива.
Выходные данные

Для каждого набора входных данных, если у Алисы есть выигрышная стратегия, выведите «YES». В противном случае, выведите «NO».

Вы можете выводить каждую букву в любом регистре (строчную или заглавную). Например, строки «yEs», «yes», «Yes» и «YES» будут приняты как положительный ответ.

Примечание

В первом наборе входных данных Алиса может выбрать \(i=1\), поскольку \(a_1=2 \ge mx=0\).

После операции Алисы, \(a=[0,1]\) и \(mx=2\). Боб не может выполнить никакую операцию. Алиса выигрывает.

Во втором наборе входных данных у Алисы нет выигрышной стратегии.

Например, если Алиса выбирает \(i=1\), после операции Алисы: \(a=[0,1]\) и \(mx=1\). Тогда Боб может выбрать \(i=2\), так как \(a_2=1 \ge mx=1\). После операции Боба: \(a=[0,0]\) и \(mx=1\). Алиса не может выполнить никакую операцию. Боб выигрывает.

E. Игра с раскрасками

графы жадные алгоритмы игры интерактив Конструктив поиск в глубину и подобное *1900

Это интерактивная задача.

Рассмотрим связный неориентированный граф, состоящий из \(n\) вершин и \(m\) ребер. Каждая вершина может быть окрашена в один из трех цветов: \(1\), \(2\) или \(3\). Изначально все вершины не окрашены.

Алиса и Боб играют в игру, состоящую из \(n\) раундов. В каждом раунде происходит следующий двухэтапный процесс:

  1. Алиса выбирает два различных цвета.
  2. Боб выбирает непокрашенную вершину и красит ее в один из двух цветов, выбранных Алисой.

Алиса выигрывает, если существует ребро, соединяющее две вершины одного цвета. В противном случае побеждает Боб.

Вам дан граф. Ваша задача — решить, за кого из игроков вы хотите играть, и выиграть игру.

Входные данные

Каждый тест состоит из нескольких наборов входных данных. Первая строка содержит одно целое число \(t\) (\(1 \le t \le 1000\)) — количество наборов входных данных. Далее следует описание наборов входных данных.

Первая строка каждого набора входных данных содержит два целых числа \(n\), \(m\) (\(1 \le n \le 10^4\), \(n - 1 \le m \le \min(\frac{n \cdot (n - 1)}{2}, 10^4)\)) — количество вершин и количество ребер в графе соответственно.

Каждая из следующих \(m\) строк каждого набора входных данных содержит по два целых числа \(u_i\), \(v_i\) (\(1 \le u_i, v_i \le n\)) — ребра графа. Гарантируется, что граф связен, и что в нем нет петель и кратных ребер.

Гарантируется, что сумма \(n\) и сумма \(m\) по всем наборам входных данных не превосходят \(10^4\).

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

Для каждого набора входных данных необходимо вывести одну строку, содержащую либо «Alice», либо «Bob» — игрока, за которого вы хотите играть.

Затем происходит \(n\) раундов, в каждом из которых происходит данный двухэтапный процесс:

  1. Алиса (либо вы, либо собеседник) выводит два целых числа \(a\) и \(b\) (\(1 \le a, b \le 3\), \(a \neq b\)) — цвета, выбранные Алисой.
  2. Боб (либо вы, либо собеседник) выводит два целых числа \(i\) и \(c\) (\(1 \le i \le n\), \(c = a\) или \(c = b\)) — вершина и цвет, выбранные Бобом. Вершина \(i\) должна быть неокрашенной.

Если любой из ваших выводов недействителен, жюри выведет «-1» и вы получите вердикт Неправильный ответ.

В конце \(n\) раундов, если ваше решение проиграло, жюри выведет «-1» и вы получите вердикт Неправильный ответ.

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

Обратите внимание, что если вы играете за Алису, и уже есть ребро, соединяющее вершины одного цвета, интерактор не завершит игру досрочно, и будут сыграны все \(n\) раундов.

После вывода запроса не забудьте вывести перевод строки и сбросить буфер вывода. В противном случае вы получите вердикт Решение «зависло». Для сброса буфера используйте:

  • fflush(stdout) или cout.flush() в C++;
  • System.out.flush() в Java;
  • flush(output) в Pascal;
  • stdout.flush() в Python;
  • смотрите документацию для других языков.

Взломы в этой задаче отключены.

Примечание

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

В первом наборе входных данных вы решили играть за Алису.

  1. Алиса выбирает два цвета: \(3\) и \(1\). Боб выбирает вершину \(3\) и окрашивает ее в цвет \(1\).
  2. Алиса выбирает два цвета: \(1\) и \(2\). Боб выбирает вершину \(2\) и окрашивает ее в цвет \(2\).
  3. Алиса выбирает два цвета: \(2\) и \(1\). Боб выбирает вершину \(1\) и окрашивает ее в цвет \(1\).

Алиса выигрывает, потому что ребро \((3, 1)\) соединяет две вершины одного цвета.

Во втором наборе входных данных вы решили играть за Боба.

  1. Алиса выбирает два цвета: \(2\) и \(3\). Боб выбирает вершину \(1\) и окрашивает ее в цвет \(2\).
  2. Алиса выбирает два цвета: \(1\) и \(2\). Боб выбирает вершину \(2\) и окрашивает ее в цвет \(1\).
  3. Алиса выбирает два цвета: \(2\) и \(1\). Боб выбирает вершину \(4\) и окрашивает ее в цвет \(1\).
  4. Алиса выбирает два цвета: \(3\) и \(1\). Боб выбирает вершину \(3\) и окрашивает ее в цвет \(3\).

Боб выигрывает, потому что нет ребер, соединяющих вершины одного цвета.

H. Игра в простые разделения

битмаски бпф дп игры математика теория чисел *3300

Алиса и Боб играют в игру с \(n\) кучками камней, где \(i\)-я кучка содержит \(a_i\) камней. Игроки делают ходы по очереди, причем Алиса ходит первой.

На каждом ходу игрок выполняет следующие три шага:

  1. Выбирает целое число \(k\) (\(1 \leq k \leq \frac n 2\)). Обратите внимание, что значение \(k\) может быть разным для разных ходов.
  2. Удаляет \(k\) куч камней.
  3. Выбирает еще \(k\) кучек камней и разделяет каждую кучку на две кучки. Количество камней в каждой новой куче должно быть простым числом.

Игрок, который не сможет сделать ход, проигрывает.

Определите, кто выиграет, если оба игрока играют оптимально.

Входные данные

Каждый тест состоит из нескольких наборов входных данных. Первая строка содержит одно целое число \(t\) (\(1 \le t \le 10^4\)) — количество наборов входных данных. Далее следует описание наборов входных данных.

Первая строка каждого набора входных данных содержит одно целое число \(n\) (\(2 \le n \le 2 \cdot 10^5\)) — количество куч камней.

Вторая строка каждого набора входных данных содержит \(n\) целых чисел \(a_1, a_2, \ldots, a_n\) (\(1 \le a_i \le 2 \cdot 10^5\)) — количество камней в кучах.

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

Выходные данные

Для каждого набора входных данных выведите «Alice» (без кавычек), если Алиса выиграет, и «Bob» (без кавычек) в противном случае.

Вы можете выводить каждую букву в любом регистре (строчную или заглавную). Например, строки «alIcE», «Alice» и «alice» будут считаться одинаковыми.

Примечание

В первом наборе входных данных есть \(2\) кучи камней с количествами камней \(2\) и \(1\) соответственно. Поскольку ни \(1\), ни \(2\) не могут быть разделены на два простых числа, Алиса не может сделать ход, поэтому Боб выигрывает.

Во втором наборе входных данных есть \(3\) кучи камней с \(3\), \(5\) и \(7\) камнями соответственно. Алиса может выбрать \(k = 1\), удалить кучу из \(7\) камней, а затем разделить кучу из \(5\) камней на две кучи камней с простыми количествами \(2\) и \(3\). В итоге получится \(3\) кучки камней с \(3\), \(2\) и \(3\) камнями соответственно, в результате чего у Боба не остается ни одного допустимого хода, и Алиса выигрывает.

В третьем наборе входных данных есть \(4\) кучи камней с \(4\), \(6\), \(8\) и \(10\) камнями соответственно. Алиса может выбрать \(k = 2\) и удалить две кучи камней \(8\) и \(10\). Далее она делит кучу камней \(4\) на две кучи камней с простыми количествами \(2\) и \(2\), а кучу камней \(6\) — на две кучи камней \(3\) и \(3\). После этого у Боба не остается допустимых ходов, и Алиса выигрывает.

В четвертом наборе входных данных есть \(5\) куч камней, каждая из которых содержит \(8\) камней. Можно показать, что если оба игрока играют оптимально, то победит Боб.

I. Игра на сетке

жадные алгоритмы игры интерактив Конструктив Паросочетания *3500

Это интерактивная задача.

Вам дана сетка из \(n\) строк и \(m\) столбцов. Вам нужно заполнить каждую ячейку уникальным целым числом от \(1\) до \(n \cdot m\).

После заполнения сетки вы сыграете с интерактором в игру на этой сетке. Игроки по очереди выбирают из сетки ранее не выбранные ячейки, причем интерактор ходит первым.

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

Ваша цель состоит в том, чтобы сумма чисел в выбранных вами клетках была строго меньше суммы чисел в клетках, выбранных соперником.

Входные данные

Каждый тест состоит из нескольких наборов входных данных. Первая строка содержит одно целое число \(t\) (\(1 \le t \le 100\)) — количество наборов входных данных. Далее следует описание наборов входных данных.

Единственная строка каждого набора входных данных содержит два целых числа \(n\) и \(m\) (\(4 \le n, m \le 10\)) — количество строк и столбцов в сетке.

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

Сначала выведите \(n\) строк, каждая из которых содержит по \(m\) целых чисел — числа, которыми вы заполнили сетку. Каждое целое число от \(1\) до \(n \cdot m\) должно появиться ровно один раз.

Затем начинается игра. Интерактор и вы по очереди выводите координаты выбранных ячеек в течение \(n \times m\) ходов, причем интерактор начинает первым.

В свой ход каждый игрок (либо вы, либо интерактор) выводит два целых числа \(i\) и \(j\) (\(1 \le i \le n\), \(1 \le j \le m\)), означающие, что игрок выбрал клетку в \(i\)-й строке и \(j\)-м столбце. Эта клетка не должна быть выбрана в предыдущих раундах. Кроме того, если это не первый ход, клетка должна быть смежной по стороне хотя бы с одной ранее выбранной клеткой.

Если любой из ваших выводов некорректен, жюри выведет «-1», и вы получите вердикт Неправильный ответ.

После всех \(n \cdot m\) ходов, если сумма чисел в выбранных вами клетках не будет строго меньше суммы чисел в клетках, выбранных соперником, жюри выведет «-1» и вы получите вердикт Неправильный ответ.

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

После вывода не забудьте вывести перевод строки и сбросить буфер вывода. В противном случае вы получите вердикт Решение «зависло». Для сброса буфера используйте:

  • fflush(stdout) или cout.flush() в C++;
  • System.out.flush() в Java;
  • flush(output) в Pascal;
  • stdout.flush() в Python;
  • смотрите документацию для других языков.

Взломы в этой задаче отключены.

Примечание

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

Сначала мы заполнили сетку \(4 \times 4\) различными целыми числами от \(1\) до \(16\) следующим образом:

\(2\)\(3\)\(4\)\(10\)
\(12\)\(6\)\(11\)\(15\)
\(5\)\(13\)\(16\)\(8\)
\(9\)\(7\)\(1\)\(14\)

Далее началась игра.

  1. Сначала соперник выбирает клетку \((3, 4)\), в которой находится число \(8\). Во время первого раунда интерактор может выбрать любое число. Начиная со следующего раунда, каждое выбранное число должно быть смежным с любым ранее выбранным числом.
  2. Мы выбрали клетку \((2, 4)\), в которой находится число \(15\), и которая является соседней с \((3, 4)\).
  3. Интерактор выбрал клетку \((4, 4)\), в которой находится число \(14\), и которая является смежной с \((3, 4)\).
  4. Мы выбрали клетку \((4, 3)\), в которой находится число \(1\), и которая является смежной с \((4, 4)\).
  5. \(\ldots\)
  6. Это продолжается до тех пор, пока не будут выбраны все числа.

В итоге вы выбрали такие числа: \([15, 1, 16, 5, 4, 2, 11, 13]\), а соперник выбрал \([8, 14, 7, 9, 10, 3, 6, 12]\). Сумма выбранных нами чисел составляет \(67\), что меньше суммы чисел, выбранных соперником: \(69\). Таким образом, мы выиграли эту игру.

H. Fortnite

жадные алгоритмы игры интерактив Комбинаторика Конструктив математика Строки теория чисел хэши *3500

Это интерактивная задача!

Тимофей пишет соревнование, которое называется Capture the flag (или сокращённо CTF). Ему осталась одна задача, в которой нужно взломать систему безопасности. Вся система основана на полиномиальных хеш-функциях\(^{\text{∗}}\).

Тимофей может ввести в систему строку, состоящую из строчных латинских букв, и система выдаст её полиномиальный хеш. Чтобы взломать систему, Тимофею нужно узнать параметры полиномиального хеша, которые использует система (\(p\) и \(m\)).

У Тимофея осталось очень мало времени, поэтому он успеет сделать только \(3\) запроса. Помогите ему решить задачу.

\(^{\text{∗}}\) Полиномиальный хеш по основанию \(p\) и модулю \(m\) строки \(s\), состоящей из строчных латинских букв, длины \(n\) — это \((\mathrm{ord}(s_1) \cdot p ^ 0 + \mathrm{ord}(s_2) \cdot p ^ 1 + \mathrm{ord}(s_3) \cdot p ^ 2 + \ldots + \mathrm{ord}(s_n) \cdot p ^ {n - 1}) \bmod m\). Где за \(s_i\) обозначен \(i\)-й символ строки \(s\), за \(\mathrm{ord}(\mathrm{chr})\) — порядковый номер символа \(\mathrm{chr}\) в английском алфавите, а за \(x \bmod m\) остаток, который даёт \(x\) при делении на \(m\).

Входные данные

Каждый тест состоит из нескольких наборов входных данных. Первая строка содержит целое число \(t\) (\(1 \leq t \leq 10^3\)) — количество наборов входных данных.

Гарантируется, что \(p\) и \(m\), которые использует система удовлетворяют условиям: \(26 < p \leq 50\) и \(p + 1 < m \leq 2 \cdot 10^9\).

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

Чтобы сделать запрос в систему выведите ? \(s\), где \(s\) — строка, длины не более \(50\), хеш которой вы хотите узнать. В ответ на этот запрос вы получите полиномиальный хеш строки \(s\).

Чтобы вывести ответ, выведите ! \(p\) \(m\), где — \(p\) основание хеша, а \(m\) — модуль. После этого сразу же переходите к следующему набору входных данных.

Вы должны сделать не более \(3\) запросов ?, в противном случае вы получите вердикт Wrong Answer.

После вывода запроса не забудьте вывести перевод строки и сбросить буфер вывода. В противном случае вы получите вердикт Решение «зависло». Для сброса буфера используйте:

  • fflush(stdout) или cout.flush() в C++;
  • System.out.flush() в Java;
  • flush(output) в Pascal;
  • stdout.flush() в Python;
  • смотрите документацию для других языков.
Примечание

Ответом на первый запрос будет \((ord(a) \cdot 31^0 + ord(a) \cdot 31^1) \mod 59 = (1 + 1 \cdot 31) \mod 59 = 32\).

Ответом на второй запрос является \((ord(y) \cdot 31^0 + ord(b) \cdot 31^1) \mod 59 = (25 + 2 \cdot 31) \mod 59 = 28\).

B. Игра с удалением

игры Конструктив *1000

Алиса получила перестановку \(a_1, a_2, \ldots, a_n\) чисел \([1,2,\ldots,n]\), а Боб — другую перестановку \(b_1, b_2, \ldots, b_n\) чисел \([1,2,\ldots,n]\). Они собираются сыграть в игру с этими массивами.

На каждом ходу игры происходят следующие события по порядку:

  • Алиса выбирает первый или последний элемент своего массива и удаляет его из массива;
  • Боб выбирает первый или последний элемент своего массива и удаляет его из массива.

Игра продолжается в течение \(n-1\) ходов, после чего в обоих массивах останется ровно по одному элементу: \(x\) в массиве \(a\) и \(y\) в массиве \(b\).

Если \(x=y\), выигрывает Боб, в противном случае — Алиса. Найдите, кто из игроков выиграет, если оба игрока играют оптимально.

Входные данные

Каждый тест состоит из нескольких наборов входных данных. В первой строке находится одно целое число \(t\) (\(1\le t\le10^4\)) — количество наборов входных данных. Далее следует описание наборов входных данных.

В первой строке каждого набора входных данных дано целое число \(n\) (\(1\le n\le 3\cdot 10^5\)).

Следующая строка содержит \(n\) целых чисел \(a_1,a_2,\ldots,a_n\) (\(1\le a_i\le n\), все \(a_i\) различны) — перестановка Алисы.

Следующая строка содержит \(n\) целых чисел \(b_1,b_2,\ldots,b_n\) (\(1\le b_i\le n\), все \(b_i\) различны) — перестановка Боба.

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

Выходные данные

Для каждого набора входных данных выведите в единственной строке имя победителя, предполагая, что оба игрока играют оптимально. Если выигрывает Алиса, выведите \(\texttt{Alice}\); в противном случае выведите \(\texttt{Bob}\).

Примечание

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

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

B. Черепаха и Свинка играют в игру 2

жадные алгоритмы игры сортировки *800

Черепаха и Свинка играют в игру на последовательности. Им дана последовательность \(a_1, a_2, \ldots, a_n\). Черепаха ходит первой. Животные ходят по очереди(т.е. Черепаха делает первый ход, Свинка делает второй, Черепаха делает третий и т.д.).

Игра проходит следующим образом:

  • Пусть текущая длина последовательности равна \(m\). Если \(m = 1\), игра заканчивается.
  • Если игра не закончилась и ходит Черепаха, то Черепаха должна выбрать целое число \(i\) такое, что \(1 \le i \le m - 1\), сделать \(a_i\) равным \(\max(a_i, a_{i + 1})\) и удалить \(a_{i + 1}\).
  • Если игра не закончилась и ходит Свинка, то Свинка должна выбрать целое число \(i\) такое, что \(1 \le i \le m - 1\), сделать \(a_i\) равным \(\min(a_i, a_{i + 1})\) и удалить \(a_{i + 1}\).

Черепаха хочет максимизировать значение \(a_1\) в конце, в то время как Свинка хочет минимизировать значение \(a_1\) в конце. Найдите значение \(a_1\) в конце, если оба игрока играют оптимально.

Вы можете обратиться к примечаниям для дальнейшего разъяснения.

Входные данные

Каждый тест содержит несколько наборов входных данных. Первая строка содержит количество наборов входных данных \(t\) (\(1 \le t \le 10^4\)). Описание наборов следует далее.

Первая строка каждого набора содержит одно целое число \(n\) (\(2 \le n \le 10^5\)) — длина последовательности.

Вторая строка каждого набора содержит \(n\) целых чисел \(a_1, a_2, \ldots, a_n\) (\(1 \le a_i \le 10^5\)) — элементы последовательности \(a\).

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

Выходные данные

Для каждого набора выведите одно целое число — значение \(a_1\) в конце, если оба игрока играют оптимально.

Примечание

В первом наборе изначально \(a = [1, 2]\). Черепаха может выбрать только \(i = 1\). Затем она сделает \(a_1\) равным \(\max(a_1, a_2) = 2\) и удалит \(a_2\). Последовательность \(a\) становится \([2]\). Затем длина последовательности становится \(1\), и игра закончится. Значение \(a_1\) равно \(2\), поэтому вы должны вывести \(2\).

Во втором наборе один из возможных процессов игры выглядит следующим образом:

  • Изначально \(a = [1, 1, 2]\).
  • Черепаха может выбрать \(i = 2\). Затем она сделает \(a_2\) равным \(\max(a_2, a_3) = 2\) и удалит \(a_3\). Последовательность \(a\) станет \([1, 2]\).
  • Свинка может выбрать \(i = 1\). Затем она сделает \(a_1\) равным \(\min(a_1, a_2) = 1\) и удалит \(a_2\). Последовательность \(a\) станет \([1]\).
  • Длина последовательности становится \(1\), так что игра закончится. Значение \(a_1\) будет \(1\) в конце.

В четвертом наборе один из возможных процессов игры выглядит следующим образом:

  • Изначально \(a = [3, 1, 2, 2, 3]\).
  • Черепаха может выбрать \(i = 4\). Затем она сделает \(a_4\) равным \(\max(a_4, a_5) = 3\) и удалит \(a_5\). Последовательность \(a\) станет \([3, 1, 2, 3]\).
  • Свинка может выбрать \(i = 3\). Затем она сделает \(a_3\) равным \(\min(a_3, a_4) = 2\) и удалит \(a_4\). Последовательность \(a\) станет \([3, 1, 2]\).
  • Черепаха может выбрать \(i = 2\). Затем она сделает \(a_2\) равным \(\max(a_2, a_3) = 2\) и удалит \(a_3\). Последовательность \(a\) станет \([3, 2]\).
  • Свинка может выбрать \(i = 1\). Затем она сделает \(a_1\) равным \(\min(a_1, a_2) = 2\) и удалит \(a_2\). Последовательность \(a\) станет \([2]\).
  • Длина последовательности становится \(1\), так что игра закончится. Значение \(a_1\) будет \(2\) в конце.

C. Делим предметы

жадные алгоритмы игры сортировки *1100

У Алисы и Боба есть \(n\) предметов, которые они хотят разделить между собой, поэтому они решили сыграть в игру. У каждого предмета есть стоимость: \(i\)-й предмет стоит \(a_i\). Игроки ходят по очереди, начиная с Алисы.

На каждом ходу игрок выбирает один из оставшихся предметов и забирает его. Игроки ходят, пока не закончатся все предметы.

Обозначим суммарную стоимость предметов, взятых Алисой, за \(A\), а суммарную стоимость предметов Боба за \(B\). Тогда итоговый счет игры будет равен \(A - B\).

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

Однако игра состоится завтра, а потому сегодня Боб может немного изменить стоимости предметов. Он может увеличить стоимости \(a_i\) нескольких предметов (возможно, всех или ни одного) на целое значение (возможно одно и то же или на разное для каждого предмета). Однако, общее увеличение должно быть не более \(k\). В противном случае Алиса может заподозрить что-то неладное. Обратите внимание, что Боб не может уменьшать стоимости, только увеличивать.

Какого минимально возможного счета может достигнуть Боб?

Входные данные

В первой строке задано одно целое число \(t\) (\(1 \le t \le 5000\)) — количество наборов входных данных. Далее следуют сами \(t\) наборов.

В первой строке каждого набора заданы два целых числа \(n\) и \(k\) (\(2 \le n \le 2 \cdot 10^5\); \(0 \le k \le 10^9\)) — количество предметов и максимальное общее увеличение, которое может сделать Боб.

Во второй строке каждого набора заданы \(n\) целых чисел \(a_1, a_2, \dots, a_n\) (\(1 \le a_i \le 10^9\)) — первоначальные стоимости предметов.

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

Выходные данные

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

Примечание

В первом наборе Боб может увеличить \(a_1\) на \(5\), сделав стоимости равными \([6, 10]\). Завтра Алиса возьмет \(10\), а Боб возьмет \(6\). Общий счет будет равен \(10 - 6 = 4\), и это минимально возможный результат.

Во втором наборе Боб не может изменять стоимости. Таким образом, итоговый счет будет равен \((15 + 10) - 12 = 13\), поскольку Алиса возьмет \(15\), Боб возьмет \(12\), а Алиса — \(10\).

В третьем наборе Боб, например, может увеличить \(a_1\) на \(1\), \(a_2\) на \(3\) и \(a_3\) на \(2\). Общее изменение равно \(1 + 3 + 2 \le 6\), и стоимости будут равны \([4, 4, 4, 4]\). Очевидно, что счет будет равен \((4 + 4) - (4 + 4) = 0\).

В четвертом наборе Боб может увеличить \(a_1\) на \(3\), сделав стоимости равными \([9, 9]\). Счет будет равен \(9 - 9 = 0\).

E. Это не задача про ним

игры математика Перебор теория чисел *2100

Два игрока, Алиса и Боб, играют в игру. У них есть \(n\) куч камней, в \(i\)-й куче изначально \(a_i\) камней.

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

  • пусть текущее количество камней в куче равно \(x\). Нельзя забрать из кучи такое число камней \(y\), что наибольший общий делитель \(x\) и \(y\) не равен \(1\).

Тот игрок, который не может сделать ход, проигрывает. Оба игрока играют оптимально (то есть если у игрока есть стратегия, которая позволяет ему выиграть, как бы оппонент ни сопротивлялся, он выигрывает). Алиса ходит первой.

Определите, кто выиграет.

Входные данные

В первой строке задано одно целое число \(t\) (\(1 \le t \le 10^4\)) — количество наборов входных данных.

Каждый набор входных данных состоит из двух строк:

  • в первой задано одно целое число \(n\) (\(1 \le n \le 3 \cdot 10^5\));
  • во второй задано \(n\) целых чисел \(a_1, a_2, \dots, a_n\) (\(1 \le a_i \le 10^7\)).

Дополнительное ограничение на входные данные: сумма \(n\) по всем наборам входных данных не превосходит \(3 \cdot 10^5\).

Выходные данные

Для каждого набора входных данных выведите Alice, если выигрывает Алиса, или Bob, если выигрывает Боб.

E1. Игра Подугольник (простая версия)

дп жадные алгоритмы игры реализация *2100

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

Цовак и Нарек играют в игру. У них есть массив \(a\) и матрица целых чисел \(b\) с \(n\) строками и \(m\) столбцами, пронумерованных с \(1\). Ячейка в \(i\)-й строке и \(j\)-м столбце обозначается \((i, j)\).

Они ищут элементы \(a\) по очереди; первым начинает Цовак. Каждый раз игрок ищет в матрице клетку, содержащую текущий элемент \(a\) (Цовак ищет первый, Нарек — второй и т.д.). Допустим, игрок выбрал клетку \((r, c)\). Следующий игрок должен выбрать свою клетку в подматрице, начинающейся в \((r + 1, c + 1)\) и заканчивающейся в \((n, m)\) (подматрица может быть пустой, если \(r=n\) или \(c=m\)). Если игрок не может найти такую клетку (или оставшаяся подматрица пуста) или массив заканчивается (предыдущий игрок выбрал последний элемент), то он проигрывает.

Ваша задача — определить победителя, если игроки играют оптимально.

Входные данные

Каждый тест состоит из нескольких наборов входных данных. Первая строка содержит одно целое число \(t\) (\(1 \le t \le 300\)) — количество наборов входных данных. Далее следует описание наборов входных данных.

Первая строка каждого набора входных данных содержит три целых числа \(l\), \(n\) и \(m\) (\(1 \le l, n, m \le 300\)) – длина массива и размер матрицы.

Вторая строка содержит \(l\) целых чисел \(a_1, a_2, a_3, \ldots a_l\) (\(1 \le a_i \le \min(7, n \cdot m)\)) – элементы массива \(a\).

В \(i\)-й из последующих \(n\) строк содержится \(m\) целых чисел \(b_{i,1}, b_{i,2}, b_{i,3}, \ldots b_{i,m}\) (\(1 \le b_{i,j} \le \min(7, n \cdot m)\), представляющих \(i\)-ю строку матрицы.

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

Гарантируется, что сумма \(l\) по всем наборам входных данных не превосходит \(300\).

Выходные данные

Вы должны вывести \(t\) строк, \(i\)-я из которых содержит символ, представляющий ответ на \(i\)-й набор входных данных: «T», если победил Цовак, или «N», в противном случае (без кавычек).

Примечание

В первом наборе входных данных Цовак начинает с поиска \(1\). Существует только одно вхождение \(1\) в \((1,1)\), поэтому он выбирает его. Затем Нареку нужно найти \(2\) в подматрице \((2, 2)\), которая состоит только из двух последних элементов: \(5\) и \(2\). Он выбирает \(2\), и Цовак проигрывает, так как массив закончился.

Во втором наборе входных данных Цовак должен выбрать \(1\). В клетке \((n,m)\) есть \(1\), поэтому он выбирает эту клетку. Затем, поскольку подматрица \((n + 1, m + 1)\) пуста, Нарек не может найти \(2\), поэтому он проигрывает.

E2. Игра Подугольник (сложная версия)

дп жадные алгоритмы игры реализация Структуры данных *2500

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

Цовак и Нарек играют в игру. У них есть массив \(a\) и матрица целых чисел \(b\) с \(n\) строками и \(m\) столбцами, пронумерованных с \(1\). Ячейка в \(i\)-й строке и \(j\)-м столбце обозначается \((i, j)\).

Они ищут элементы \(a\) по очереди; первым начинает Цовак. Каждый раз игрок ищет в матрице клетку, содержащую текущий элемент \(a\) (Цовак ищет первый, Нарек — второй и т.д.). Допустим, игрок выбрал клетку \((r, c)\). Следующий игрок должен выбрать свою клетку в подматрице, начинающейся в \((r + 1, c + 1)\) и заканчивающейся в \((n, m)\) (подматрица может быть пустой, если \(r=n\) или \(c=m\)). Если игрок не может найти такую клетку (или оставшаяся подматрица пуста) или массив заканчивается (предыдущий игрок выбрал последний элемент), то он проигрывает.

Ваша задача — определить победителя, если игроки играют оптимально.

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

Например, в C++ достаточно использовать следующие строки в начале функции main():

int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL); cout.tie(NULL);
}
Входные данные

Каждый тест состоит из нескольких наборов входных данных. Первая строка содержит одно целое число \(t\) (\(1 \le t \le 1500\)) — количество наборов входных данных. Далее следует описание наборов входных данных.

Первая строка каждого набора входных данных содержит три целых числа \(l\), \(n\) и \(m\) (\(1 \le l, n, m \le 1500\)) – длина массива и размер матрицы.

Вторая строка содержит \(l\) целых чисел \(a_1, a_2, a_3, \ldots a_l\) (\(1 \le a_i \le n \cdot m\)) – элементы массива \(a\).

В \(i\)-й из последующих \(n\) строк содержится \(m\) целых чисел \(b_{i,1}, b_{i,2}, b_{i,3}, \ldots b_{i,m}\) (\(1 \le b_{i,j} \le n \cdot m\), представляющих \(i\)-ю строку матрицы.

Гарантируется, что сумма \(n \cdot m\) по всем наборам входных данных не превосходит \(3 \cdot 10^6\).

Гарантируется, что сумма \(l\) по всем наборам входных данных не превосходит \(1500\).

Выходные данные

Вы должны вывести \(t\) строк, \(i\)-я из которых содержит символ, представляющий ответ на \(i\)-й набор входных данных: «T», если победил Цовак, или «N», в противном случае (без кавычек).

Примечание

В первом наборе входных данных Цовак начинает с поиска \(1\). Существует только одно вхождение \(1\) в \((1,1)\), поэтому он выбирает его. Затем Нареку нужно найти \(2\) в подматрице \((2, 2)\), которая состоит только из двух последних элементов: \(6\) и \(2\). Он выбирает \(2\), и Цовак проигрывает, так как массив закончился.

Во втором наборе входных данных Цовак должен выбрать \(1\). В клетке \((n,m)\) есть \(1\), поэтому он выбирает эту клетку. Затем, поскольку подматрица \((n + 1, m + 1)\) пуста, Нарек не может найти \(2\), поэтому он проигрывает.

A. Ирис и игра на дереве

графы Деревья жадные алгоритмы игры Конструктив поиск в глубину и подобное *1700

У Ирис есть дерево, корень которого находится в вершине \(1\). Каждая вершина имеет значение \(\mathtt 0\) или \(\mathtt 1\).

Рассмотрим лист дерева (вершина \(1\) никогда не считается листом) и определим его вес. Построим строку, сформированную значениями вершин на пути от корня до этого листа. Тогда вес листа — это разность количества вхождений подстроки \(\mathtt{10}\) и количества вхождений подстроки \(\mathtt{01}\) в этой строке.

Возьмем следующее дерево в качестве примера. Зеленые вершины имеют значение \(\mathtt 1\), в то время как белые вершины имеют значение \(\mathtt 0\).

  • Посчитаем вес листа \(5\): сформированная строка равна \(\mathtt{10110}\). Количество вхождений подстроки \(\mathtt{10}\) равно \(2\), количество вхождений подстроки \(\mathtt{01}\) равно \(1\), так что разность равна \(2 - 1 = 1\).
  • Посчитаем вес листа \(6\): сформированная строка равна \(\mathtt{101}\). Количество вхождений подстроки \(\mathtt{10}\) равно \(1\), количество вхождений подстроки \(\mathtt{01}\) равно \(1\), так что разность равна \(1 - 1 = 0\).

Оценкой дерева назовём количество листьев с ненулевым весом в дереве.

Однако значения некоторых вершин ещё не определены и будут даны вам как \(\texttt{?}\). Заполнение пропусков было бы слишком скучным, поэтому Ирис собирается пригласить Дору поиграть в игру. На каждом ходу одна из девочек выбирает любую из оставшихся вершин со значением \(\texttt{?}\) и изменяет её значение на \(\mathtt{0}\) или \(\mathtt{1}\), при этом Ирис ходит первой. Игра продолжается до тех пор, пока в дереве не останется вершин со значением \(\mathtt{?}\). Ирис стремится максимизировать оценку дерева, в то время как Дора стремится минимизировать её.

Предполагая, что обе девочки играют оптимально, определите итоговую оценку дерева.

Входные данные

Каждый тест состоит из нескольких наборов входных данных. Первая строка содержит одно целое число \(t\) (\(1 \leq t \leq 5\cdot 10^4\)) — количество наборов входных данных. Далее следует описание наборов входных данных.

Первая строка каждого набора входных данных содержит одно целое число \(n\) (\(2 \leq n \leq 10^5\)) — количество вершин в дереве.

Каждая из следующих \(n - 1\) строк содержит два целых числа \(u\) и \(v\) (\(1 \leq u, v \leq n\)) — обозначающие ребро между вершинами \(u\) и \(v\).

Гарантируется, что данные рёбра образуют дерево.

Последняя строка содержит строку \(s\) длины \(n\). \(i\)-й символ строки \(s\) представляет значение вершины \(i\). Гарантируется, что \(s\) содержит только символы \(\mathtt{0}\), \(\mathtt{1}\) и \(\mathtt{?}\).

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

Выходные данные

Для каждого набора входных данных выведите одно целое число — итоговую оценку дерева.

Примечание

В первом наборе входных данных значения во всех вершинах уже определены. Существует три различных пути от корня до листа:

  • От вершины \(1\) до вершины \(2\). Сформированная строка равна \(\mathtt{01}\), так что вес листа равен \(0-1=-1\).
  • От вершины \(1\) до вершины \(3\). Сформированная строка равна \(\mathtt{00}\), так что вес листа равен \(0-0=0\).
  • От вершины \(1\) до вершины \(4\). Сформированная строка равна \(\mathtt{01}\), так что вес листа равен \(0-1=-1\).

Таким образом, есть два листа с ненулевым весом, так что оценка дерева равна \(2\).

Во втором наборе входных данных одна из последовательностей оптимальных ходов для двух игроков может быть следующей:

  • Ирис выбирает изменить значение вершины \(3\) на \(\mathtt 1\).
  • Дора выбирает изменить значение вершины \(1\) на \(\mathtt 0\).
  • Ирис выбирает изменить значение вершины \(2\) на \(\mathtt 0\).

Итоговое дерево выглядит следующим образом:

Единственный лист с ненулевым весом — это \(3\), так что оценка дерева равна \(1\). Обратите внимание, что это может быть не единственная последовательность оптимальных ходов для Ирис и Доры.

F1. Игра на дереве (простая версия)

Бинарный поиск Деревья дп жадные алгоритмы игры Перебор реализация Структуры данных *2700

Это простая версия задачи. В этой версии \(\mathbf{u = v}\). Вы можете совершать взломы только в том случае, если решены обе версии задачи.

Алиса и Боб играют в забавную игру на дереве. В эту игру играют на дереве из \(n\) вершин, пронумерованных от \(1\) до \(n\). Напомним, что дерево на \(n\) вершинах — это неориентированный связный граф с \(n - 1\) ребрами.

Алиса и Боб ходят по очереди, причём Алиса ходит первой. Каждый игрок начинает с какой-то вершины.

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

Вам даны две вершины \(u\) и \(v\). Представим простой путь из вершины \(u\) в \(v\) как массив \(p_1, p_2, p_3, \ldots, p_m\), где \(p_1 = u\), \(p_m = v\), между \(p_i\) и \(p_{i + 1}\) есть ребро для всех \(i\) (\(1 \le i < m\)).

Вы должны определить победителя игры, если Алиса начнёт в вершине \(1\), а Боб в вершине \(p_j\) для каждого \(j\) (где \(1 \le j \le m\)).

Входные данные

Каждый тест состоит из нескольких наборов входных данных. В первой строке находится одно целое число \(t\) (\(1 \le t \le 10^4\)) — количество наборов входных данных. Далее следует описание наборов входных данных.

Первая строка каждого набора входных данных содержит единственное число \(n\) (\(2 \le n \le 2 \cdot 10^5\)) — количество вершин дерева.

Каждая из следующих \(n - 1\) строк содержит два целых числа \(a\), \(b\) (\(1 \le a, b \le n\)), обозначающих неориентированное ребро между вершинами \(a\) и \(b\). Гарантируется, что данные ребра образуют дерево.

Последняя строка каждого набора входных данных содержит два целых числа \(u\) и \(v\) (\(2 \le u, v \le n\), \(\mathbf{u = v}\)).

Гарантируется, что путь между \(u\) и \(v\) не проходит через вершину \(1\).

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

Выходные данные

Для каждого набора входных данных выведите \(m\) строк.

В \(i\)-й строке выведите победителя игры, если Алиса начинает с вершины \(1\), а Боб с вершины \(p_i\), выведите «Alice» (без кавычек), если выиграет Алиса, или «Bob» (без кавычек) в противном случае.

Примечание
Дерево из первого и второго примера.

В первом наборе входных данных путь будет иметь вид (\(2,2\)). Боб начинает в вершине \(2\), Алиса в своём первом ходу не сможет никуда пойти, и она проиграет.

Во втором наборе входных данных путь будет иметь вид (\(3,3\)). Боб начинает в вершине \(3\), Алиса переместится в вершину \(2\), и у Боба не останется вершин, которые можно посетить, и он проиграет.

E1. Битовая игра (простая версия)

битмаски игры математика Перебор *2800

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

Алиса и Боб играют в знакомую игру, в которой они по очереди вынимают камни из \(n\) кучек. Изначально в \(i\)-й куче находится \(x_i\) камней, и она имеет значение \(a_i\). Игрок может забрать \(d\) камней из \(i\)-й кучи тогда и только тогда, когда выполняются оба следующих условия:

  • \(1 \le d \le a_i\), и
  • \(x \, \& \, d = d\), где \(x\) — текущее количество камней в \(i\)-й куче, а \(\&\) обозначает операцию побитового И.

Алиса ходит первой. Игрок, который не может сделать ход, проигрывает.

Вам даны значения \(a_i\) и \(x_i\) для каждой кучи. Определите, кто выиграет в данной игре, если оба игрока будут действовать оптимально.

Входные данные

Каждый тест состоит из нескольких наборов входных данных. Первая строка содержит одно целое число \(t\) (\(1 \le t \le 1000\)) — количество наборов входных данных. Далее следует описание наборов входных данных.

Первая строка каждого набора входных данных содержит одно число \(n\) (\(1 \le n \le 10^4\)) — количество кучек.

Вторая строка каждого набора входных данных содержит \(n\) целых чисел \(a_1, a_2, \ldots, a_n\) (\(1 \le a_i < 2^{30}\)).

Третья строка каждого набора входных данных содержит \(n\) целых чисел \(x_1, x_2, \ldots, x_n\) (\(1 \le x_i < 2^{30}\)).

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

Выходные данные

Для каждого набора входных данных выведите на отдельной строке имя победителя. Если победила Алиса, выведите «Alice», в противном случае выведите «Bob» (без кавычек).

Примечание

В первом наборе входных данных ни один из игроков не может взять ни одного камня из первой кучки, так как не существует значения \(d\), удовлетворяющего условиям. Из второй кучи в первый ход Алиса может вынуть от \(1\) до \(6\) камней. Независимо от того, какой ход сделает Алиса, Боб сможет вынуть остальные камни в свой ход. После хода Боба Алиса больше не может сделать ни одного хода, поэтому Боб выиграет.

Для второго набора входных данных приведём один пример того, как может проходить игра. Алиса ходит первой и решает взять камни из первой кучи. Она не может взять \(17\) камней, потому что \(17 > 10\), что противоречит первому условию. Она не может взять \(10\) камней, потому что \(25 \, \& \, 10 = 8\), что противоречит второму условию. Один из вариантов — взять \(9\) камней; теперь в куче осталось \(16\) камней. В свой ход Боб решает взять камни из второй кучи; единственный вариант — взять все \(4\). Теперь ни из одной из первых двух куч больше нельзя взять ни одного камня, поэтому Алиса должна взять несколько камней из последней кучи. Она решает взять \(12\) камней, и Боб следует за ней, забирая последние \(2\) камня из этой кучи. Поскольку теперь у Алисы не осталось разрешённых ходов, Боб выигрывает. Можно показать, что независимо от того, какой стратегии придерживается Алиса, Боб всегда сможет выиграть, если будет играть оптимально.

E. Приключения Алисы в кроличьей норе

Деревья дп жадные алгоритмы игры Комбинаторика математика поиск в глубину и подобное Теория вероятностей *2300

Алиса находится на дне кроличьей норы! Кроличья нора может быть смоделирована как дерево\(^{\text{∗}}\), у которого выход находится на вершине \(1\), а Алиса начинает с некоторой вершины \(v\). Она хочет выбраться из норы, но, к сожалению, Дама Червей приказала её казнить.

Каждую минуту подбрасывается обычная монета. Если выпадает орёл, Алиса может переместиться в любую вершину, смежную со своим текущим положением, а если решка, Дама Червей может перетащить Алису на смежную вершину по своему выбору. Если Алиса когда-либо окажется на любом из некорневых листьев\(^{\text{†}}\) дерева, Алиса проигрывает.

Предполагая, что они обе действуют оптимально, для каждой начальной вершины \(1\le v\le n\) вычислите вероятность того, что Алиса сможет убежать. Поскольку эти вероятности могут быть очень малыми, выведите их по модулю \(998\,244\,353\).

Формально, пусть \(M = 998\,244\,353\). Можно показать, что точный ответ может быть представлен в виде несократимой дроби \(\frac{p}{q}\), где \(p\) и \(q\) — целые числа, и \(q \not \equiv 0 \pmod{M}\). Выведите целое число, равное \(p \cdot q^{-1} \bmod M\). Другими словами, выведите такое целое число \(x\), что \(0 \le x < M\) и \(x \cdot q \equiv p \pmod{M}\).

\(^{\text{∗}}\)Дерево — это связный простой граф, который имеет \(n\) вершин и \(n-1\) рёбер.

\(^{\text{†}}\)Лист — это вершина, соединённая ровно с одним ребром.

Входные данные

Каждый тест состоит из нескольких наборов входных данных. В первой строке находится одно целое число \(t\) (\(1 \le t \le 10^4\)) — количество наборов входных данных. Далее следует описание наборов входных данных.

Первая строка каждого набора входных данных содержит одно целое число \(n\) (\(2\le n\le 2\cdot 10^5\)) — количество вершин в дереве.

\(i\)-я из следующих \(n - 1\) строк содержит два целых числа \(x_i\) и \(y_i\) (\(1 \le x_i, y_i \le n\) и \(x_i \neq y_i\)) — рёбра дерева. Гарантируется, что заданные ребра образуют дерево.

Сумма значений \(n\) по всем наборам входных данных не превосходит \(2\cdot 10^5\).

Выходные данные

Для каждого набора входных данных выведите \(n\) целых чисел в одной строке — вероятности того, что Алиса убежит, начиная с вершины \(1, 2, \ldots, n\). Поскольку эти вероятности могут быть очень малыми, выведите их по модулю \(998\,244\,353\).

Примечание

Для первого набора входных данных:

  1. Алиса убегает из корня (вершина \(1\)) по определению с вероятностью \(1\).
  2. Алиса немедленно проигрывает из вершин \(4\) и \(5\), так как они являются листьями.
  3. Из других двух вершин Алиса убегает с вероятностью \(\frac 12\), так как Дама перетащит её к листьям.

B. Замена

игры Конструктив Строки *1100

У вас есть бинарная строка\(^{\text{∗}}\) \(s\) длины \(n\), и Айрис дал вам другую бинарную строку \(r\) длины \(n-1\).

Айрис собирается сыграть с вами в игру. В ходе игры вы выполните \(n-1\) операций над \(s\). В \(i\)-й операции (\(1 \le i \le n-1\)):

  1. Сначала вы выбираете индекс \(k\) такой, что \(1\le k\le |s| - 1\) и \(s_{k} \neq s_{k+1}\). Если выбрать такой индекс невозможно, вы проигрываете;
  2. Затем вы заменяете \(s_ks_{k+1}\) на \(r_i\). Обратите внимание, что это уменьшает длину \(s\) на \(1\).

Если все \(n-1\) операций выполнены успешно, вы выигрываете.

Определите, возможно ли вам выиграть в этой игре.

\(^{\text{∗}}\)Бинарная строка — это строка, в которой каждый символ равен либо \(\mathtt{0}\), либо \(\mathtt{1}\).

Входные данные

Каждый тест состоит из нескольких наборов входных данных. В первой строке находится одно целое число \(t\) (\(1\le t\le 10^4\)) — количество наборов входных данных. Далее следует описание наборов входных данных.

Первая строка каждого набора входных данных содержит одно целое число \(n\) (\(2\le n\le 10^5\)) — длину \(s\).

Вторая строка каждого набора входных данных содержит бинарную строку \(s\) длины \(n\) (\(s_i=\mathtt{0}\) или \(\mathtt{1}\)).

Третья строка каждого набора входных данных содержит бинарную строку \(r\) длины \(n-1\) (\(r_i=\mathtt{0}\) или \(\mathtt{1}\)).

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

Выходные данные

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

Вы можете выводить каждую букву в любом регистре (строчную или заглавную). Например, строки «yEs», «yes», «Yes» и «YES» будут приняты как положительный ответ.

Примечание

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

Во втором наборе входных данных вы можете выбрать \(k=1\) в единственной операции, и после этого \(s\) станет равным \(\mathtt{1}\). Таким образом, вы выигрываете.

В третьем наборе входных данных вы можете выполнить следующие операции: \(\mathtt{1}\underline{\mathtt{10}}\mathtt{1}\xrightarrow{r_1=\mathtt{0}} \mathtt{1}\underline{\mathtt{01}} \xrightarrow{r_2=\mathtt{0}} \underline{\mathtt{10}} \xrightarrow{r_3=\mathtt{1}} \mathtt{1}\).

B. Минимизируйте единичность

игры Комбинаторика Конструктив математика *800

Для произвольной бинарной строки \(t\)\(^{\text{∗}}\), пусть \(f(t)\) — количество непустых подпоследовательностей\(^{\text{†}}\) \(t\), которые содержат только символы \(\mathtt{0}\), и пусть \(g(t)\) — это количество непустых подпоследовательностей \(t\), которые содержат хотя бы одну \(\mathtt{1}\).

Обратите внимание, что для \(f(t)\) и \(g(t)\) каждая подпоследовательность считается столько раз, сколько раз она встречается в \(t\). Например, \(f(\mathtt{000}) = 7, g(\mathtt{100}) = 4\).

Назовём единичностью бинарной строки \(t\) значение \(|f(t)-g(t)|\), где \(|z|\) обозначает абсолютное значение \(z\) для любого числа \(z\).

Вам дано целое положительное число \(n\). Найдите бинарную строку \(s\) длины \(n\), такую, чтобы её единичность была как можно меньше. Если строк несколько, вы можете вывести любую из них.

\(^{\text{∗}}\)Бинарная строка — это строка, состоящая только из символов \(\texttt{0}\) и \(\texttt{1}\).

\(^{\text{†}}\)Последовательность \(a\) является подпоследовательностью последовательности \(b\), если \(a\) может быть получена из \(b\) удалением нескольких (возможно, нуля или всех) элементов. Например, подпоследовательности \(\mathtt{1011101}\) — это \(\mathtt{0}\), \(\mathtt{1}\), \(\mathtt{11111}\), \(\mathtt{0111}\), но не \(\mathtt{000}\) и не \(\mathtt{11100}\).

Входные данные

Каждый тест состоит из нескольких наборов входных данных. Первая строка содержит одно целое число \(t\) (\(1 \leq t \leq 10^4\)) — количество наборов входных данных. Далее следует описание наборов входных данных.

Единственная строка каждого набора входных данных содержит целое число \(n\) (\(1 \leq n \leq 2\cdot10^5\)) — длина \(s\).

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

Выходные данные

Для каждого набора входных данных выведите \(s\) на отдельной строке. Если существует несколько ответов, выведите любой.

Примечание

В первом наборе входных данных \(f(t)=1\), потому что существует одна подпоследовательность, содержащая только \(\mathtt{0}\) (подпоследовательность \(\mathtt{0}\)), и \(g(t)=0\), потому что нет подпоследовательностей, содержащих хотя бы одну \(1\). Единичность равна \(|1-0|=1\). Строка \(\mathtt{1}\) также является корректным ответом, так как её единичность равна \(|0-1|=1\).

Во втором наборе входных данных \(f(t)=1\), потому что существует одна непустая подпоследовательность, содержащая только \(\mathtt{0}\), и \(g(t)=2\), потому что существуют две непустые подпоследовательности, содержащие хотя бы одну \(\mathtt{1}\) (\(\mathtt{01}\) и \(\mathtt{1}\)). Таким образом, единичность равна \(|1-2|=1\). Можно показать, что \(1\) — это минимально возможное значение единичности среди всех бинарных строк длины \(2\).

C. ИСТИННАЯ битва

жадные алгоритмы игры Перебор *1100

Алиса и Боб играют в игру. Имеется список из \(n\) булевых значений, каждое из которых равняется либо true, либо false, заданный в виде бинарной строки\(^{\text{∗}}\) длины \(n\) (где \(\texttt{1}\) представляет true, а \(\texttt{0}\) представляет false). Изначально между булевыми значениями нет никаких операторов.

Алиса и Боб будут поочерёдно ставить между булевыми значениями операторы and (обозначающие логическое «И») и операторы or (обозначающие логическое «ИЛИ»), причём Алиса будет ходить первой. Таким образом, игра будет состоять из \(n-1\) ходов, поскольку в списке \(n\) булевых значений. Алиса стремится к тому, чтобы итоговое значение было равно true, а Боб — к тому, чтобы оно было равно false. По данному списку булевых значений определите, выиграет ли Алиса, если оба игрока будут играть оптимально.

Чтобы вычислить итоговое значение выражения, выполняйте следующие шаги, пока выражение не будет состоять только из одного true или false:

  • Если условие содержит операторы and, выберите любой из них и замените окружающее его подвыражение его значением.
  • В противном случае условие содержит операторы or. Выберите любой из них и замените подвыражение, окружающее оператор or, его значением.
Например, выражение true or false and false имеет значение true or (false and false) \(=\) true or false \(=\) true. Можно показать, что значение любого составного выражения определено однозначно.

\(^{\text{∗}}\)Бинарная строка — это строка, состоящая только из символов \(\texttt{0}\) и \(\texttt{1}\)

Входные данные

Каждый тест состоит из нескольких наборов входных данных. Первая строка содержит одно целое число \(t\) (\(1 \leq t \leq 10^4\)) — количество наборов входных данных. Далее следует описание наборов входных данных.

Первая строка каждого набора входных данных содержит целое число \(n\) (\(2 \leq n \leq 2 \cdot 10^5\)) — длина строки.

Вторая строка содержит бинарную строку длины \(n\), состоящую из символов \(\texttt{0}\) и \(\texttt{1}\) — список булевых значений.

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

Выходные данные

Для каждого набора входных данных выведите «YES« (без кавычек), если Алиса выиграет, и «NO» (без кавычек) в противном случае.

Вы можете выводить каждую букву в любом регистре (строчную или заглавную). Например, строки «yEs», «yes», «Yes» и «YES» будут приняты как положительный ответ.

Примечание

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

Во втором наборе входных данных Алиса может поместить or между левым false и средним true. Боб может поместить and между средним true и правым false. Выражение false or true and false равняется false.

Обратите внимание, что эти примеры могут не быть оптимальными стратегиями для Алисы или Боба.

F. Арахис

дп игры Комбинаторика математика *2700

Имея волшебную бобовую палку, Джек в последнее время собирал много арахисов. В конечном итоге он получил \(n\) мешков с арахисом, удобно пронумерованных от \(1\) до \(n\) слева направо. В \(i\)-м мешке находится \(a_i\) арахисов.

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

После этого Алиса и Джек будут по очереди делать ходы, при этом Алиса ходит первой.

На каждом ходе текущий игрок будет забирать положительное количество арахисов из ровно одного мешка, который лежит в самой левой непустой коробке (т.е. самой левой коробке, содержащей хотя бы один непустой мешок). Другими словами, если мы пронумеруем коробки слева направо, то каждый игрок может забирать арахисы из мешка в \(j\)-й коробке (\(j \ge 2\)) только в том случае, если в \((j - 1)\)-й коробке не осталось арахисов. Игрок, который не может сделать допустимый ход, проигрывает.

Алиса уверена, что она выиграет, так как у нее есть преимущество в том, что она сама делит мешки на коробки. Она хочет знать, сколько существует способов разделить мешки на коробки в начале игры, чтобы она выиграла, предполагая, что оба игрока играют оптимально. Можете помочь ей с расчетами?

Поскольку результат может быть очень большим, выведите его по модулю \(998\,244\,353\).

Входные данные

Каждый тест состоит из нескольких наборов входных данных. Первая строка содержит одно целое число \(t\) (\(1 \le t \le 10^4\)) — количество наборов входных данных. Далее следует описание наборов входных данных.

Первая строка каждого набора входных данных содержит одно целое число \(n\) (\(1 \leq n \leq 10^6\)) — количество мешков.

Вторая строка каждого набора входных данных содержит \(n\) целых чисел \(a_1, a_2, \ldots, a_n\) (\(1 \leq a_i \leq 10^9\)) — количество арахисов в каждом мешке.

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

Выходные данные

Для каждого набора входных данных выведите одно целое число — количество способов для Алисы разделить мешки на коробки в начале игры, чтобы гарантировать ее победу, предполагая, что оба игрока играют оптимально, по модулю \(998\,244\,353\).

Примечание

В первом наборе входных данных единственный способ для Алисы выиграть — это разделить мешки на две коробки следующим образом: \(([1, 2], [3])\) (первая коробка содержит первые два мешка, а вторая коробка содержит третий мешок). Алиса выигрывает, забирая оба арахиса из второго мешка, оставляя Джеку \(([1], [3])\). Джек вынужден забрать единственный оставшийся арахис в первой коробке, что позволяет Алисе забрать оставшиеся в второй коробке.

Во втором наборе входных данных выигрышные разделения для Алисы — это \(([1], [2, 3, 1])\), \(([1, 2, 3, 1])\), \(([1, 2], [3], [1])\) и \(([1, 2], [3, 1])\).

В третьем наборе входных данных Алиса всегда выигрывает, независимо от того, как она разделяет мешки на коробки.

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

A. Bonus Project

жадные алгоритмы игры *1400

There is a team of \(n\) software engineers numbered from \(1\) to \(n\). Their boss promises to give them a bonus if they complete an additional project. The project requires \(k\) units of work in total. The bonus promised to the \(i\)-th engineer is \(a_i\) burles. The boss doesn't assign specific tasks to engineers; it is expected that every engineer will voluntarily complete some integer amount of work units. The bonus will be paid to the entire team only if the project is completed; in other words, if the total amount of voluntary work units on the project is greater than or equal to \(k\).

The amount of work that can be performed by each engineer is not limited. However, all engineers value their labour. The \(i\)-th engineer estimates one unit of their work as \(b_i\) burles. If the bonus is paid, the benefit \(s_i\) of the \(i\)-th engineer for completing \(c\) units of work is defined as \(s_i = a_i - c \cdot b_i\). If the bonus is not paid, the engineer will not volunteer to do any work.

Engineers work together for many years, so they know how the bonus is going to be distributed and how much their colleagues value the labour. That is, all \(a_i\) and all \(b_i\) are known to every engineer in the team.

Engineers are eager to get the bonus, so they agreed on the following process of work distribution between them:

  • the first engineer says: "I will complete \(c_1\) units of work", where \(c_1\) is a non-negative integer;
  • then, the second engineer says: "I will complete \(c_2\) units of work", where \(c_2\) is a non-negative integer;
  • ... and so on;
  • finally, the \(n\)-th engineer says: "I will complete \(c_n\) units of work", where \(c_n\) is a non-negative integer.

Every engineer voices \(c_i\) in a way to maximize their own benefit \(s_i\). If the expected benefit is going to be zero, an engineer will still agree to work to get the experience and to help their colleagues obtain the bonus. However, if the benefit is expected to be negative for some reason (an engineer needs to perform an excessive amount of work or the project is not going to be completed), that engineer will not work at all (completes zero amount of work units).

Given that every engineer acts perfectly, your task is to find out the numbers \(c_i\) voiced by every engineer.

Input

The first line contains two integers \(n\) and \(k\) (\(1 \le n \le 1000\); \(1 \le k \le 10^6\)) — the number of engineers in the company and the number of work units the project requires, respectively.

The second line contains \(n\) integers \(a_1, a_2, \dots, a_n\) (\(1 \le a_i \le 10^9\)), where \(a_i\) is the bonus which will be paid to the \(i\)-th engineer if the project is completed.

The third line contains \(n\) integers \(b_1, b_2, \dots, b_n\) (\(1 \le b_i \le 1000\)), where \(b_i\) is the work unit cost for the \(i\)-th engineer.

Output

Print \(n\) integers \(c_1, c_2, \dots, c_n\) (\(0 \le c_i \le k\)) — the amount of work completed by each engineer given that every engineer behaves optimally. Note that the answer is unique.

Note

In the first example, engineers distributed the work across them and got the bonus, even though the benefit for the third engineer is zero.

In the second example, the bonus project requires too many work units to complete, so it's more beneficial for engineers not to work at all.

A. Игра деления

игры математика *800

Дан массив целых чисел \(a_1, a_2, \ldots, a_n\) длины \(n\) и число \(k\).

Играют два игрока. Первый игрок выбирает индекс \(1 \le i \le n\). Затем второй игрок выбирает другой индекс \(1 \le j \le n, i \neq j\). Первый игрок побеждает, если \(|a_i - a_j|\) не делится на число \(k\). В противном случае побеждает второй игрок.

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

Абсолютное значение (или модуль) числа \(x\) обозначается как \(|x|\) и равно \(x\), если \(x \ge 0\), и \(-x\) в противном случае.

Входные данные

Каждый тест состоит из нескольких наборов входных данных. В первой строке находится одно целое число \(t\) (\(1 \le t \le 100\)) — количество наборов входных данных. Далее следует описание наборов входных данных.

Первая строка каждого набора входных данных содержит два целых числа \(n\) и \(k\) (\(1 \le n \le 100\); \(1 \le k \le 100\)) — длина массива и число \(k\).

Вторая строка каждого набора входных данных содержит \(n\) целых чисел \(a_1, a_2, \ldots, a_n\) (\(1 \le a_i \le 100\)) — элементы массива \(a\).

Выходные данные

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

Иначе выведите «YES» (без кавычек) и на следующей строке подходящий индекс \(1 \le i \le n\). Если есть несколько решений, выведите любое из них.

Вы можете выводить каждую букву в любом регистре (строчную или заглавную). Например, строки «yEs», «yes», «Yes» и «YES» будут приняты как положительный ответ.

Примечание

В первом наборе первый игрок может выбрать \(a_2 = 2\). Тогда:

  • Если второй игрок выберет \(a_1 = 1\), то полученная разность будет \(|2 - 1| = 1\), что не делится на \(k = 2\).
  • Если второй игрок выберет \(a_3 = 3\), то полученная разность будет \(|2 - 3| = 1\), что не делится на \(k = 2\).

Во втором наборе:

  • Если первый игрок выберет \(a_1 = 1\), то второй игрок выберет \(a_4 = 5\), и полученная разность будет \(|1 - 5| = 4\), что делится на \(k = 2\).
  • Если первый игрок выберет \(a_2 = 2\), то второй игрок выберет \(a_3 = 4\), и полученная разность будет \(|2 - 4| = 2\), что делится на \(k = 2\).
  • Если первый игрок выберет \(a_3 = 4\), то второй игрок выберет \(a_2 = 2\), и полученная разность будет \(|4 - 2| = 2\), что делится на \(k = 2\).
  • Если первый игрок выберет \(a_4 = 5\), то второй игрок выберет \(a_1 = 1\), и полученная разность будет \(|5 - 1| = 4\), что делится на \(k = 2\).
В любом случае, победит второй игрок.

B. Игра с цветными шариками

жадные алгоритмы игры *900

Алиса и Боб играют в игру. У них есть \(n\) шариков, \(i\)-й из них имеет цвет \(c_i\). Игроки ходят по очереди; сначала ходит Алиса, затем Боб, затем снова Алиса, затем опять Боб и так далее.

Во время своего хода игрок должен взять один из оставшихся шариков и убрать его из игры. Если шариков больше не осталось (все \(n\) шариков были взяты), игра заканчивается.

Очки Алисы в конце игры рассчитываются следующим образом:

  • она получает \(1\) очко за каждый цвет \(x\), для которого она взяла хотя бы один шарик этого цвета;
  • дополнительно она получает \(1\) очко за каждый цвет \(x\), для которого она взяла все шарики этого цвета (конечно, учитываются только цвета, присутствующие в игре).

Например, предположим, что есть \(5\) шариков, их цвета \([1, 3, 1, 3, 4]\), и игра проходит следующим образом: Алиса берет \(1\)-й шарик, затем Боб берет \(3\)-й шарик, затем Алиса берет \(5\)-й шарик, затем Боб берет \(2\)-й шарик, и, наконец, Алиса берет \(4\)-й шарик. Тогда Алиса получает \(4\) очка: \(3\) очка за наличие хотя бы одного шарика для цветов \(1\), \(3\) и \(4\), и \(1\) очко за наличие всех шариков цвета \(4\). Обратите внимание, что эта стратегия не обязательно является оптимальной для обоих игроков.

Алиса хочет максимизировать свои очки в конце игры. Боб хочет минимизировать их. Оба игрока играют оптимально (т. е. Алиса выбирает стратегию, которая позволяет ей получить как можно больше очков, а Боб выбирает стратегию, которая минимизирует количество очков, которые может получить Алиса).

Вычислите очки Алисы в конце игры.

Входные данные

Первая строка содержит одно целое число \(t\) (\(1 \le t \le 1000\)) — количество наборов входных данных.

Каждый набор входных данных состоит из двух строк:

  • первая строка содержит одно целое число \(n\) (\(1 \le n \le 1000\)) — количество шариков;
  • вторая строка содержит \(n\) целых чисел \(c_1, c_2, \dots, c_n\) (\(1 \le c_i \le n\)) — цвета шариков.

Дополнительное ограничение на входные данные: сумма \(n\) по всем наборам входных данных не превышает \(1000\).

Выходные данные

Для каждого набора входных данных выведите одно целое число — очки Алисы в конце игры, предполагая, что оба игрока играют оптимально.

Примечание

Во втором наборе входных данных примера цвета всех шариков различны, поэтому, независимо от того, как действуют игроки, Алиса получает \(4\) очка — у нее все шарики двух цветов и ни одного шарика третьего цвета.

В третьем наборе входных данных примера цвета всех шаров одинаковы, поэтому, независимо от того, как действуют игроки, Алиса получает \(1\) очко за то, что у нее хотя бы один (но не все) шарик цвета \(4\).

F. Ним

битмаски дп жадные алгоритмы игры Комбинаторика кратчайшие пути Перебор реализация *2700

Кратко напомним правила игры «Ним». Имеется \(n\) кучек камней, при этом в кучке \(i\) изначально лежит какое-то число камней. Два игрока по очереди выбирают непустую кучку и берут из нее произвольное положительное (строго больше \(0\)) количество камней. Проигрывает тот, кто не может сделать ход.

Дан массив \(a\), состоящий из \(n\) целых чисел. Артем и Руслан решили играть в Ним на подотрезках массива. Каждый из \(q\) раундов определяется отрезком \((l_i, r_i)\), где элементы массива \(a_{l_i}, a_{l_i+1}, \dots, a_{r_i}\) рассматриваются как размеры кучек камней.

До начала игры Руслан может удалить любое количество кучек из выбранного подотрезка. Однако хотя бы одна кучка должна остаться, поэтому в рамках одного раунда он может удалить не более \((r_i - l_i)\) кучек. Разрешается удалить \(0\) кучек. После удаления ребята играют в Ним на всех оставшихся кучках из этого отрезка.

Все раунды независимы: удаления, произведенные в одном раунде, не влияют на исходный массив или другие раунды.

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

Для каждого раунда определите:

  1. максимальное количество кучек, которые Руслан может удалить;
  2. количество способов выбрать максимальное количество кучек для удаления.

Два способа считаются различными, если существует такая позиция \(i\), что в одном из способов кучка на позиции \(i\) удаляется, а во втором — нет. Поскольку количество способов может быть большим, выведите его по модулю \(998\,244\,353\).

Если в каком-то раунде Руслан не может сделать так, чтобы Артем проиграл, выведите для этого раунда одно число -1.

Входные данные

Первая строка входных данных содержит два целых числа \(n\) и \(q\) (\(1 \le n, q \le 10^5\)) — размер массива и количество раундов.

Вторая строка входных данных содержит \(n\) целых чисел \(a_1, a_2, \dots, a_n\) (\(0 \le a_i \le 50\)) — элементы исходного массива.

Далее следуют \(q\) строк, \(i\)-я из которых содержит два целых числа \(l_i, r_i\) (\(1 \le l_i \le r_i \le n\)) — границы отрезка, на котором ребята хотят сыграть в игру в \(i\)-м раунде.

Выходные данные

Для каждого раунда:

  • если Руслан может победить, выведите два целых числа — максимальное количество кучек, которые можно удалить, и количество способов удалить максимальное количество кучек, взятое по модулю \(998\,244\,353\);
  • иначе выведите -1.

F. Grid Game 3-angle

игры математика *3000

Your friends, Anda and Kamu decide to play a game called Grid Game and ask you to become the gamemaster. As the gamemaster, you set up a triangular grid of size \(N\). The grid has \(N\) rows (numbered from \(1\) to \(N\)). Row \(r\) has \(r\) cells; the \(c\)-th cell of row \(r\) is denoted as \((r, c)\).

Before the game starts, \(M\) different cells (numbered from \(1\) to \(M\)) are chosen: at cell \((R_i, C_i)\), you add \(A_i\) stones on it. You then give Anda and Kamu an integer \(K\) and commence the game.

Anda and Kamu will take turns alternately with Anda taking the first turn. A player on their turn will do the following.

  • Choose a cell \((r, c)\) with at least one stone on it.
  • Remove at least one but at most \(K\) stones from the chosen cell.
  • For each cell \((x, y)\) such that \(r + 1 \leq x \leq \min(N, r + K)\) and \(c \leq y \leq c + x - r\), add zero or more stones but at most \(K\) stones to cell \((x, y)\).

The following illustrations show all the possible cells in which you can add stones for \(K = 3\). You choose the cell \((2, 1)\) for the left illustration and the cell \((4, 3)\) for the right illustration.

A player who is unable to complete their turn (because there are no more stones on the grid) will lose the game, and the opposing player wins. Determine who will win the game if both players play optimally.

Input

This problem is a multi-case problem. The first line consists of an integer \(T\) (\(1 \leq T \leq 100\)) that represents the number of test cases.

Each test case starts with a single line consisting of three integers \(N\) \(M\) \(K\) (\(1 \leq N \leq 10^9; 1 \leq M, K \leq 200\,000\)). Then, each of the next \(M\) lines consists of three integers \(R_i\) \(C_i\) \(A_i\) (\(1 \leq C_i \leq R_i \leq N; 1 \leq A_i \leq 10^9\)). The pairs \((R_i, C_i)\) are distinct.

The sum of \(M\) across all test cases does not exceed \(200\,000\).

Output

For each case, output a string in a single line representing the player who will win the game if both players play optimally. Output Anda if Anda, the first player, wins. Otherwise, output Kamu.

Note

Explanation for the sample input/output #1

For the first case, during the first turn, Anda will remove all the stones from cell \((1, 1)\) and then add three stones at \((2, 1)\). The only cell with stones left is now cell \((2, 1)\) with five stones, so Kamu must remove stones from that cell. No matter how many stones are removed by Kamu, Anda can remove all the remaining stones at \((2, 1)\) and win the game.

For the second case, Kamu can always mirror whatever move made by Anda until Anda can no longer complete their turn.

E. Находчивая гусеничная последовательность

графы Деревья дп жадные алгоритмы игры поиск в глубину и подобное *1900

Endless Repeating 7 Days
— r-906, Panopticon

Дано дерево, состоящее из \(n\) вершин. Гусеница обозначается парой целых чисел \((p, q)\) (\(1 \leq p, q \leq n\), \(p \neq q\)): её голова находится в вершине \(p\), её хвост находится в вершине \(q\), и она доминирует над всеми вершинами на простом пути от \(p\) до \(q\) (включая \(p\) и \(q\)). Гусеничная последовательность пары \((p, q)\) определяется как последовательность, состоящая только из вершин на простом пути, отсортированных в порядке возрастания расстояния до \(p\).

Нора и Арон по очереди двигают гусеницу, причем Нора ходит первой. Оба игрока будут использовать свою собственную оптимальную стратегию:

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

В свой ход Нора может выбрать вершину \(u\), смежную с вершиной \(p\), над которой не доминирует гусеница, и переместить все вершины в ней на одно ребро по направлению к вершине \(u\)\(^{\text{∗}}\). В свою очередь, Арон может выбрать вершину \(v\), смежную с вершиной \(q\), над которой не доминирует гусеница, и переместить все вершины в ней на одно ребро по направлению к вершине \(v\). Обратите внимание, что ходы, разрешенные двум игрокам, различны.

Если \(p\) — лист\(^{\text{†}}\), то Нора выигрывает\(^{\text{‡}}\). Если \(q\) — лист, то Арон выигрывает. Если либо изначально оба \(p\) и \(q\) являются листьями, либо после \(10^{100}\) ходов игра не закончится, результатом будет ничья.

Пожалуйста, посчитайте количество целочисленных пар \((p, q)\) с \(1 \leq p, q \leq n\) и \(p \neq q\) таких, что если изначально гусеница находится на \((p, q)\), то Арон выиграет.

\(^{\text{∗}}\)Другими словами: Пусть текущая гусеничная последовательность равна \(c_1, c_2, \ldots, c_k\). Тогда после перемещения новая гусеничная последовательность становится \(d(u, c_1), d(u, c_2), \ldots, d(u, c_k)\). Здесь \(d(x, y)\) обозначает следующую вершину на простом пути от \(y\) до \(x\).

\(^{\text{†}}\)В дереве вершина называется листом тогда и только тогда, когда её степень равна \(1\).

\(^{\text{‡}}\)Поэтому Нора всегда может выбрать вершину \(u\), если игра ещё не закончилась. То же самое относится и к Арону.

Входные данные

Каждый тест состоит из нескольких наборов входных данных. Первая строка содержит одно целое число \(t\) (\(1 \leq t \leq 2\cdot 10^4\)) — количество наборов входных данных. Далее следует описание наборов входных данных.

Первая строка каждого набора входных данных содержит одно целое число \(n\) (\(2 \leq n \leq 2\cdot 10^5\)) — количество вершин в дереве.

Каждая из следующих \(n - 1\) строк содержит по два целых числа \(u\) и \(v\) (\(1 \leq u, v \leq n\)), обозначающих ребро между вершинами \(u\) и \(v\). Гарантируется, что заданные ребра образуют дерево.

Гарантируется, что сумма значений \(n\) по всем наборам входных данных не превосходит \(4\cdot 10^5\).

Выходные данные

Для каждого набора входных данных выведите одну строку, содержащую целое число: количество целых пар \((p, q)\), для которых Арон выиграет.

Примечание

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

Во втором наборе входных данных, гусеницы, которые позволяют Арону выиграть, следующие: \((1, 3)\), \((1, 4)\), \((1, 5)\), \((2, 3)\), \((2, 4)\), \((2, 5)\). Давайте рассмотрим некоторых гусениц.

  • Для гусеницы \((1, 5)\): вершина \(p = 1\) — это не лист, но вершина \(q = 5\) — лист, так что Арон выигрывает в самом начале.
  • Для гусеницы \((2, 1)\): вершина \(p = 2\) не является листом, и \(q = 1\) не является листом. На первом ходу Нора может переместить гусеницу в направлении вершины \(5\). Следовательно, гусеница становится \((5, 2)\), а вершина \(p = 5\) — лист, так что Нора выиграет.

A. Две лягушки

жадные алгоритмы игры Конструктив математика *800

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

В ряд расположено \(n\) кувшинок, пронумерованных от \(1\) до \(n\) слева направо. Алиса и Боб — лягушки, изначально расположенные на разных кувшинках \(a\) и \(b\), соответственно. Они прыгают по очереди, начиная с Алисы.

Во время хода лягушка может перепрыгнуть либо на одну позицию влево, либо на одну позицию вправо, но только если кувшинка, на которую она прыгает, существует. Например, в первый ход Алиса может перейти либо на кувшинку \(a-1\), либо на \(a+1\), при условии, что эти кувшинки находятся в пределах допустимых значений. Важно отметить, что каждая лягушка обязана прыгнуть во время своего хода и не может остаться на той же кувшинке.

Однако существуют некоторые ограничения:

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

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

Входные данные

Каждый тест состоит из нескольких наборов входных данных. В первой строке находится одно целое число \(t\) (\(1 \le t \le 500\)) — количество наборов входных данных. Далее следует описание наборов входных данных.

Первая и единственная строка каждого набора входных данных содержит три целых числа \(n\), \(a\) и \(b\) (\(2 \leq n \leq 100\), \(1 \leq a, b \leq n\), \(a\neq b\)) — количество кувшинок и начальные позиции Алисы и Боба, соответственно.

Обратите внимание, что нет ограничения на сумму \(n\) по всем наборам входных данных.

Выходные данные

Для каждого набора входных данных выведите одну строку, содержащую либо «YES», либо «NO», обозначающую, есть ли у Алисы выигрышная стратегия.

Вы можете выводить каждую букву в любом регистре (строчную или заглавную). Например, строки «yEs», «yes», «Yes», и «YES» будут приняты как положительный ответ.

Примечание

В первом наборе входных данных у Алисы нет разрешённых ходов. Следовательно, Алиса проигрывает в первый ход.

Во втором наборе входных данных Алиса может перейти только на кувшинку \(2\). Тогда у Боба нет разрешённых ходов. Следовательно, в данном случае у Алисы есть выигрышная стратегия.

В третьем наборе входных данных Алиса может перейти только на кувшинку \(1\). Затем Боб может перейти на кувшинку \(2\). Алиса больше не в состоянии двигаться и проигрывает, отдавая победу Бобу. Можно показать, что Боб всегда может выиграть, независимо от ходов Алисы; следовательно, у Алисы нет выигрышной стратегии.

A. Две лягушки

жадные алгоритмы игры Конструктив математика *800

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

В ряд расположено \(n\) кувшинок, пронумерованных от \(1\) до \(n\) слева направо. Алиса и Боб — лягушки, изначально расположенные на разных кувшинках \(a\) и \(b\), соответственно. Они прыгают по очереди, начиная с Алисы.

Во время хода лягушка может перепрыгнуть либо на одну позицию влево, либо на одну позицию вправо, но только если кувшинка, на которую она прыгает, существует. Например, в первый ход Алиса может перейти либо на кувшинку \(a-1\), либо на \(a+1\), при условии, что эти кувшинки находятся в пределах допустимых значений. Важно отметить, что каждая лягушка обязана прыгнуть во время своего хода и не может остаться на той же кувшинке.

Однако существуют некоторые ограничения:

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

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

Входные данные

Каждый тест состоит из нескольких наборов входных данных. В первой строке находится одно целое число \(t\) (\(1 \le t \le 500\)) — количество наборов входных данных. Далее следует описание наборов входных данных.

Первая и единственная строка каждого набора входных данных содержит три целых числа \(n\), \(a\) и \(b\) (\(2 \leq n \leq 100\), \(1 \leq a, b \leq n\), \(a\neq b\)) — количество кувшинок и начальные позиции Алисы и Боба, соответственно.

Обратите внимание, что нет ограничения на сумму \(n\) по всем наборам входных данных.

Выходные данные

Для каждого набора входных данных выведите одну строку, содержащую либо «YES», либо «NO», обозначающую, есть ли у Алисы выигрышная стратегия.

Вы можете выводить каждую букву в любом регистре (строчную или заглавную). Например, строки «yEs», «yes», «Yes», и «YES» будут приняты как положительный ответ.

Примечание

В первом наборе входных данных у Алисы нет разрешённых ходов. Следовательно, Алиса проигрывает в первый ход.

Во втором наборе входных данных Алиса может перейти только на кувшинку \(2\). Тогда у Боба нет разрешённых ходов. Следовательно, в данном случае у Алисы есть выигрышная стратегия.

В третьем наборе входных данных Алиса может перейти только на кувшинку \(1\). Затем Боб может перейти на кувшинку \(2\). Алиса больше не в состоянии двигаться и проигрывает, отдавая победу Бобу. Можно показать, что Боб всегда может выиграть, независимо от ходов Алисы; следовательно, у Алисы нет выигрышной стратегии.

C. Игра математиков

жадные алгоритмы игры сортировки *900

Алиса и Боб играют в игру. На доске написано \(n\) (\(n\) четное) целых чисел \(x_1, x_2, \ldots, x_n\). Также дано целое число \(k\) и целое число score, которое изначально равно \(0\). Игра длится \(\frac{n}{2}\) ходов, в которых последовательно происходят следующие события:

  • Алиса выбирает целое число с доски и стирает его. Назовем выбранное Алисой число \(a\).
  • Боб выбирает целое число с доски и стирает его. Назовем выбранное Бобом число \(b\).
  • Если \(a+b=k\), добавляем \(1\) к score.

Алиса играет, чтобы минимизировать score, в то время как Боб играет, чтобы максимизировать score. Предполагая, что оба игрока используют оптимальные стратегии, каков будет score после окончания игры?

Входные данные

Первая строка содержит целое число \(t\) (\(1 \leq t \leq 10^4\)) — количество наборов входных данных.

Первая строка каждого набора входных данных содержит два целых числа \(n\) и \(k\) (\(2 \leq n \leq 2\cdot 10^5, 1 \leq k \leq 2\cdot n\), \(n\) четное).

Вторая строка каждого набора входных данных содержит \(n\) целых чисел \(x_1,x_2,\ldots,x_n\) (\(1 \leq x_i \leq n\)) — числа на доске.

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

Выходные данные

Для каждого набора входных данных выведите score, если оба игрока играют оптимально.

Примечание

В первом наборе входных данных один из возможных сценариев игры выглядит следующим образом:

  • Алиса выбирает \(1\), а Боб выбирает \(3\). Счет увеличивается, так как \(1+3=4\). Теперь на доске остаются два целых числа \(2\) и \(2\).
  • Алиса и Боб оба выбирают \(2\). Счет увеличивается, так как \(2+2=4\).
  • Игра заканчивается, так как на доске больше нет целых чисел.

В третьем наборе входных данных невозможно, чтобы сумма выбранных Алиской и Бобом целых чисел была равна \(1\), поэтому мы отвечаем \(0\).

Обратите внимание, что это всего лишь пример того, как может проходить игра для демонстрационных целей. Это может не быть самыми оптимальными стратегиями Алисы или Боба.

E1. Игра (простая версия)

графы Деревья жадные алгоритмы игры поиск в глубину и подобное Структуры данных *2000

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

Чирно и Дайёсей играют в игру с деревом\(^{\text{∗}}\) из \(n\) вершин, корнем которого является вершина \(1\). Значение \(i\)-й вершины равно \(w_i\). Они по очереди делают ходы; первым ходит Чирно.

На каждом ходу, предполагая, что противник выбрал \(j\) на последнем ходу, игрок может выбрать любую оставшуюся вершину \(i\), удовлетворяющую условию \(w_i>w_j\), и удалить поддерево\(^{\text{†}}\) вершины \(i\). В частности, Чирно может выбрать любую вершину и удалить её поддерево на первом ходу.

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

\(^{\text{∗}}\)Деревом называется связный граф без циклов.

\(^{\text{†}}\)Вершина \(u\) принадлежит поддереву вершины \(i\), если любой путь от \(1\) до \(u\) проходит через \(i\).

Входные данные

Первая строка ввода содержит одно целое число \(t\) (\(1 \leq t \leq 10^5\)) — количество наборов входных данных.

Первая строка каждого набора входных данных содержит одно целое число \(n\) (\(1 \le n \le 4\cdot 10^5\)) — количество вершин в дереве.

Вторая строка содержит \(n\) целых чисел \(w_1,w_2,\ldots,w_n\) (\(1 \le w_i \le n\)) — значения вершин.

Следующие \(n-1\) строк содержат ребра дерева. \(i\)-я строка содержит два целых числа \(u_i,v_i\) (\(1\le u_i,v_i \le n\), \(u_i \neq v_i\)) — ребро, соединяющее \(u_i\) и \(v_i\). Гарантируется, что заданные ребра образуют дерево.

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

Выходные данные

Для каждого набора входных данных выведите одну строку.

Если Чирно может выиграть, выведите любую вершину, которую она может выбрать на первом ходу.

В противном случае выведите «0» (без кавычек).

Примечание

В первом наборе входных данных:

  1. Если Чирно выберет \(1\) или \(3\) на первом ходу, Дайёсей не сможет сделать ход, поэтому Дайёсей выигрывает.
  2. Если Чирно выберет \(2\) или \(4\) на первом ходу, Дайёсей сможет выбрать только \(3\), но после этого Чирно не сможет сделать ход, поэтому Чирно выигрывает.

Таким образом, все возможные вершины, которые может выбрать Чирно — это \(2\) и \(4\).

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

В третьем и четвертом наборах входных данных единственной возможной вершиной, которую может выбрать Чирно на первом ходу, является \(2\).

В пятом наборе входных данных все возможные вершины, которые может выбрать Чирно на первом ходу — это \(3,4,6,7\) и \(10\).

E2. Игра (сложная версия)

графы Деревья игры поиск в глубину и подобное реализация Структуры данных *3000

Это сложная версия задачи. Отличие между версиями заключается в том, что в этой версии вам нужно найти все возможные вершины, которые может выбрать Чирно. Вы можете делать взломы только в том случае, если решили все версии этой задачи.

Чирно и Дайёсей играют в игру с деревом\(^{\text{∗}}\) из \(n\) вершин, корнем которого является вершина \(1\). Значение \(i\)-й вершины равно \(w_i\). Они по очереди делают ходы; первым ходит Чирно.

На каждом ходу, предполагая, что противник выбрал \(j\) на последнем ходу, игрок может выбрать любую оставшуюся вершину \(i\), удовлетворяющую условию \(w_i>w_j\), и удалить поддерево\(^{\text{†}}\) вершины \(i\). В частности, Чирно может выбрать любую вершину и удалить её поддерево на первом ходу.

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

\(^{\text{∗}}\)Деревом называется связный граф без циклов.

\(^{\text{†}}\)Вершина \(u\) принадлежит поддереву вершины \(i\), если любой путь от \(1\) до \(u\) проходит через \(i\).

Входные данные

Первая строка ввода содержит одно целое число \(t\) (\(1 \leq t \leq 10^5\)) — количество наборов входных данных.

Первая строка каждого набора входных данных содержит одно целое число \(n\) (\(1 \le n \le 4\cdot 10^5\)) — количество вершин в дереве.

Вторая строка содержит \(n\) целых чисел \(w_1,w_2,\ldots,w_n\) (\(1 \le w_i \le n\)) — значения вершин.

Следующие \(n-1\) строк содержат ребра дерева. \(i\)-я строка содержит два целых числа \(u_i,v_i\) (\(1\le u_i,v_i \le n\), \(u_i \neq v_i\)) — ребро, соединяющее \(u_i\) и \(v_i\). Гарантируется, что заданные ребра образуют дерево.

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

Выходные данные

Для каждого набора входных данных выведите одну строку.

Если Чирно может выиграть, выведите несколько чисел. Первое число \(k\) обозначает количество возможных вершин, которые она может выбрать на первом ходу. Следующие \(k\) чисел обозначают данные вершины в порядке возрастания.

В противном случае выведите «0» (без кавычек).

Примечание

В первом наборе входных данных:

  1. Если Чирно выберет \(1\) или \(3\) на первом ходу, Дайёсей не сможет сделать ход, поэтому Дайёсей выигрывает.
  2. Если Чирно выберет \(2\) или \(4\) на первом ходу, Дайёсей сможет выбрать только \(3\), но после этого Чирно не сможет сделать ход, поэтому Чирно выигрывает.

Таким образом, все возможные вершины, которые может выбрать Чирно — это \(2\) и \(4\).

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

В третьем и четвертом наборах входных данных единственной возможной вершиной, которую может выбрать Чирно на первом ходу, является \(2\).

В пятом наборе входных данных все возможные вершины, которые может выбрать Чирно на первом ходу — это \(3,4,6,7\) и \(10\).

E. Фурло и Рубло и Игра

игры математика реализация *2200

Фурло и Рубло играют в игру. На столе лежат n кучек монет, в кучке номер i лежит ai монет. Фурло и Рубло делают ходы по очереди, Фурло ходит первым. За один ход разрешается:

  • выбрать какую-то кучку, обозначим текущее количество монет в ней через x;
  • выбрать некоторое целое число y (0 ≤ y < xx1 / 4 ≤ y ≤ x1 / 2) и уменьшить количество монет в этой кучке до y. Другими словами после описанного хода игрока в выбранной кучке останется y монет.

Игрок, который не может сделать ход — проигрывает.

Ваша задача — узнать, кто выиграет в данной игре, если и Фурло и Рубло играют оптимально.

Входные данные

В первой строке содержится целое число n (1 ≤ n ≤ 77777) — количество кучек. В следующей строке заданы n целых чисел a1, a2, ..., an (1 ≤ ai ≤ 777777777777) — размеры кучек. Числа разделены одиночными пробелами.

Пожалуйста, не используйте спецификатор %lld для чтения или записи 64-х битовых чисел на С++. Рекомендуется использовать потоки cin, cout или спецификатор %I64d.

Выходные данные

Если при оптимальной игре обоих выиграет Фурло — выведите «Furlo», иначе выведите «Rublo». Ответы выводите без кавычек.

B. Игра в кубики

жадные алгоритмы игры реализация *1300

Петя и Вася захотели немного поиграть. Они нашли n кубиков красного цвета и m кубиков синего цвета. Игра заключается в следующем: игроки по очереди берут по одному кубику одного из двух цветов и выставляют их в ряд слева направо (всего будет выставлено n + m кубиков в ряд). Первым ходит Петя. Задача Пети — получить как можно больше пар соседних кубиков одного цвета. Задача Васи — получить как можно больше пар соседних кубиков разных цветов.

Количество очков Пети в игре — это количество пар соседних в ряду кубиков одного цвета, количество очков Васи в игре — это количество пар соседних в ряду кубиков разного цвета. От Вас требуется узнать счет в конце игры (количество очков Пети и Васи соответственно), если оба мальчика играют оптимально. «Играть оптимально» означает в первую очередь максимизировать количество своих очков, а во вторую — минимизировать количество очков соперника.

Входные данные

В единственной строке через пробел записаны два целых числа n и m (1 ≤ n, m ≤ 105) — количество красных и синих кубиков соответственно.

Выходные данные

В единственную строку через пробел выведите два числа — количество очков Пети и Васи соответственно при оптимальной игре обоих.

Примечание

В первом тестовом примере для Пети оптимально самым первым ходом выставить в ряд синий кубик. После этого хода останутся только красные кубики, поэтому на конец игры ряд кубиков (слева направо) будет иметь следующий вид: [синий, красный, красный, красный]. Значит, Петя получит 2 очка, а Вася — 1 очко.

Если бы первым ходом Петя выставил красный кубик, то, при дальнейшей оптимальной игре обоих мальчиков, Петя получил бы 1 очко, а Вася — 2 очка.

E. Дима и игра

дп игры *2600

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

Дима пишет на листке n пар целых чисел (li, ri) (1 ≤ li < ri ≤ p). Далее игроки ходят по очереди. За один ход игрок может выполнить следующее действие:

  1. выбрать номер пары i (1 ≤ i ≤ n), такой что ri - li > 2;
  2. заменить пару номер i на пару или на пару . Запись x обозначает округление к ближайшему меньшему целому числу.

Игрок, который не может сделать ход — проигрывает.

Конечно, Дима хочет, чтобы Аня, которая будет ходить первая, выиграла. Поэтому Дима должен выписать такие n пар целых чисел (li, ri) (1 ≤ li < ri ≤ p), чтобы при оптимальной игре обоих игроков выигрывал первый. Посчитайте, сколькими способами Дима может это сделать. Выведите остаток от деления ответа на число 1000000007 (109 + 7).

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

Входные данные

В первой строке даны два целых числа n, p (1 ≤ n ≤ 1000, 1 ≤ p ≤ 109). Числа разделены единичным пробелом.

Выходные данные

В единственную строку выведите остаток от деления ответа на задачу на число 1000000007 (109 + 7).

B. Девочка и игра

жадные алгоритмы игры *1300

Девочка очень любит задачи про игры. Вот одна из них.

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

  • Игроки ходят по очереди; За один ход игрок может удалить из строки s произвольную букву.
  • Если игрок перед своим ходом может перемешать буквы в строке s таким образом, чтобы получился палиндром, этот игрок побеждает. Палиндром — строка, которая одинаково читается в обоих направлениях. Например, строка «abba» — палиндром, а строка «abc» — нет.

Определите, кто из игроков победит при оптимальной игре обеих сторон — тот, кто ходит первым, или тот, кто ходит вторым.

Входные данные

Во входных данных содержится единственная строка. Единственная строка содержит строку s (1 ≤ |s| ≤  103). Строка s состоит из строчных букв латинского алфавита.

Выходные данные

В единственной строке выведите слово «First» в случае, если при оптимальной игре обоих игроков победит первый игрок. Иначе, выведите слово «Second». Слова выводите без кавычек.

C. Игра

игры реализация *2400

Два игрока играют в следующую игру. Изначально у игроков имеется нож и прямоугольный лист бумаги, разделенный сеткой на одинаковые квадратные клетки единичного размера. Участники делают ходы по очереди, проигрывает тот, кто не может сделать ход. За один ход игрок может провести ножом вдоль любого отрезка линии сетки (необязательно от края до края). Участок бумаги, по которому провели ножом хотя бы один раз, считается разрезанным. Чтобы игра не зациклилась, на ход накладывается ограничение: каждый ход должен разрезать какой-то новый участок бумаги ненулевой длины.

Очевидно, что игра завершится, когда весь лист будет разрезан на клетки 1 × 1. В процессе игры запрещается перемещать части листа. Также запрещается проводить разрезы вдоль границы. Координаты концов каждого разреза должны быть целыми числами.

Вам дан лист бумаги размером n × m, на котором уже кто-то сделал k разрезов. Ваша задача — определить, кто выиграет при оптимальной игре, если игроки начнут играть на данном листе. В случае победы первого игрока также требуется найти выигрышный первый ход.

Входные данные

В первой строке записано три целых числа n, m, k (1 ≤ n, m ≤ 109, 0 ≤ k ≤ 105) — размеры листа бумаги и количество разрезов. Далее следует k строк по четыре целых числа в каждой xbi, ybi, xei, yei (0 ≤ xbi, xei ≤ n, 0 ≤ ybi, yei ≤ m) — координаты концов существующих разрезов.

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

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

Выходные данные

Если выигрывает второй игрок, выведите «SECOND». Иначе в первой строке выведите «FIRST», а во второй строке — любой выигрышный ход первого игрока (координаты концов разреза в том же формате, что и во входных данных).

E. Красивая декомпозиция

дп жадные алгоритмы игры теория чисел *1900

Валера считает, что число красивое, если оно равно 2k или -2k для некоторого целого k (k ≥ 0). Недавно учитель математики попросил Валеру представить число n в виде суммы красивых чисел. Так как Валера очень жадный, он хочет использовать для выполнения этого задания минимально возможное количество красивых чисел.

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

Входные данные

В первой строке задана строка s (1 ≤ |s| ≤ 106), обозначающая двоичное представление числа n без лидирующих нулей (n > 0).

Выходные данные

Выведите единственное целое число — минимальное количество красивых чисел, сумма которых равна n.

Примечание

В первом примере n = 2 является красивым числом.

Во втором примере n = 7, и Валера может разложить его в сумму 23 + ( - 20).

В третьем примере n = 109 раскладывается в сумму четырех слагаемых следующим образом: 27 + ( - 24) + ( - 22) + 20.

D. Очередная игра с числами

дп игры *2100

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

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

BitLGM и BitAryo играют в очередную сумасшедшую интеллектуальную игру. У них есть последовательность неотрицательных целых чисел a1, a2, ..., an. Игроки ходят по очереди. BitLGM ходит первым. Каждый игрок на своем ходе обязан сделать одно из двух следующих действий:

  • Выбрать одно из чисел (обозначим его ai). Выбрать целое число x (1 ≤ x ≤ ai). Уменьшить число ai на x, то есть выполнить присвоение: ai = ai - x.
  • Выбрать целое число x . Уменьшить все ai на x, то есть выполнить присвоение: ai = ai - x, для всех i.

Проигрывает тот, кто не может сделать ход.

Вам задана последовательность a1, a2, ..., an. Определите, кто победит при оптимальной игре, если BitLGM и BitAryo начнут играть в описанную игру на этой последовательности.

Входные данные

В первой строке записано целое число n (1 ≤ n ≤ 3).

В следующей строке записаны n целых чисел a1, a2, ..., an (0 ≤ ai < 300).

Выходные данные

Выведите имя победителя при оптимальной игре: «BitLGM» или «BitAryo» (без кавычек).

A. Странная игра

жадные алгоритмы игры *1500

Ярослав, Андрей и Роман могут часами напролет играть в кубики. Но это игра для трех человек, поэтому, когда Роман отсутствует, Ярослав и Андрей играют в другую игру.

Роман оставляет каждому из них по слову, состоящему из n символов «0» или «1». После этого игроки начинают ходить по очереди. Ярослав ходит первым. На своем ходе игрок должен выбрать целое число от 1 до n, которое не выбиралось никем из игроков ранее, и выписать себе на листочек соответствующий символ из своей строки.

Обозначим слово, которое оставили Ярославу, как s = s1s2... s2n. Аналогично, обозначим слово, которое оставили Андрею, как t = t1t2... t2n. Тогда, если Ярослав выбрал на своем ходе число k, то он выпишет на свой листочек символ sk. Аналогично, если Андрей выбрал на своем ходе число r, то он выпишет на свой листочек символ tr.

Игра заканчивается, когда ни один из игроков не может сделать ход. После окончания игры, Ярослав составляет из символов, записанных на своем листочке, некоторое целое число (символы можно переставлять в любом порядке), тоже самое делает Андрей (полученные числа могут содержать лидирующие нули). Побеждает тот, у кого получилось большее число. Если получившиеся числа равны, то объявляется ничья.

Вам заданы две строки s и t. Определите исход игры при оптимальной игре Ярослава и Андрея.

Входные данные

В первой строке записано целое число n (1 ≤ n ≤ 106). Во второй строке записана строка s — слово Ярослава. В третьей строке записана строка t — слово Андрея.

Гарантируется, что оба слова состоят из n символов «0» и «1».

Выходные данные

Выведите «First», если при оптимальной игре побеждает Ярослав, «Second» — в случае победы Андрея и «Draw», если при оптимальной игре будет ничья. Слова выводите без кавычек.

C. Крестики-нолики

игры Перебор реализация *1800

Все, наверное, знакомы с игрой крестики-нолики. Правила в самом деле очень просты. Игроки по очереди ставят на свободные клетки поля 3 × 3 знаки (один всегда крестики, другой всегда нолики). Первый, выстроивший в ряд три своих фигур по вертикали, горизонтали или диагонали, выигрывает и игра заканчивается. Первый ход делает игрок, ставящий крестики. В том случае, если все поле заполнено, но никакие три фигуры в ряд не стоят, то объявляется ничья.

Вам задано поле 3 × 3, на котором каждая клетка свободна или занята крестиком или ноликом. Ваша задача указать игрока (first или second), ход которого ожидается или вывести один из четырех вердиктов:

  • illegal — если заданная игровая позиция не может появиться в ходе игры, т.е. является некорректной;
  • the first player won — если в заданной игровой позиции первый игрок только что победил;
  • the second player won — если в заданной игровой позиции второй игрок только что победил;
  • draw — если в заданной игровой позиции только что наступила ничья.
Входные данные

Входные данные состоят из трех строк, каждая из которых содержит по три символа: «.», «X» или «0» (точку, заглавную букву X или ноль).

Выходные данные

Выведите один из шести вердиктов: first, second, illegal, the first player won, the second player won или draw.

E. Игра со строкой

игры *2300

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

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

Пример изначальной ситуации при s = «abacaba»

Ход игрока — это последовательность действий:

  1. Игрок выбирает один из доступных листочков, на котором записана некоторая строка. Обозначим ее t. Заметим, что изначально доступен только один листочек.
  2. Игрок выбирает в строке t = t1t2... t|t| символ в позиции i (1 ≤ i ≤ |t|) такой, что для некоторого целого положительного l (0 < i - li + l ≤ |t|) выполняются равенства: ti - 1 = ti + 1, ti - 2 = ti + 2, ..., ti - l = ti + l.
  3. Игрок вырезает ячейку с выбранным символом. В результате этой операции образуется три новых листочка, причем на первом будет записана строка t1t2... ti - 1, на втором — строка, состоящая из одного символа ti, на третьем — ti + 1ti + 2... t|t|.
Пример выполнения действия (i = 4) со строкой s = «abacaba»

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

Входные данные

В первой строке записана строка s (1 ≤ |s| ≤ 5000). Гарантируется, что строка s состоит только из строчных букв латинского алфавита.

Выходные данные

Если выиграет второй игрок, то в единственной строке выведите «Second» (без кавычек). Иначе в первой строке выведите «First» (без кавычек), а во второй строке — минимально возможный выигрышный ход — целое число i (1 ≤ i ≤ |s|).

Примечание

В первом примере у первого игрока есть несколько выигрышных ходов. Но минимальный из них — это вырезать символ в позиции 2.

Во втором примере у первого игрока нет доступных ходов.

D. Игра со степенями

дп игры *2300

Вася и Петя выписали на доску все натуральные числа от 1 до n и играют в игру (n может быть достаточно велико, но Васю и Петю это не смущает).

Игроки по очереди выбирают числа, начинает Вася. Если на данном ходу было выбрано число x, то в дальнейшем в игре нельзя выбирать само число x и все его остальные натуральные степени (x2, x3, ...). К примеру, если на первом ходу выбрано число 9, то в дальнейшем числа 9 и 81 выбирать нельзя, в то время как числа 3 и 27 выбрать разрешается. Проигрывает тот, кто не может сделать ход.

Кто выигрывает при оптимальной игре обоих соперников?

Входные данные

Единственная строка входных данных содержит натуральное число n (1 ≤ n ≤ 109).

Выходные данные

Выведите имя победителя — «Vasya» или «Petya» (без кавычек).

Примечание

В первом примере Вася выберет 1 и сразу выиграет.

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

A. Алиса и Боб

игры математика теория чисел *1600

Ах, какая же скукота на летних каникулах! И вот, Алиса и Боб придумали новую игру. Правила у игры следующие: у игроков имеется множество из n различных целых чисел. Игроки ходят по очереди. Во время каждого хода либо Алиса, либо Боб (игрок, чья очередь подошла) может выбрать из множества два различных целых числа, x и y, такие, что в множестве не содержится число |x - y|. Затем игрок, который ходит, добавляет число |x - y| ко множеству (таким образом, размер множества увеличивается на один).

Если игрок не может сделать ход, то он (или она) проигрывает. Вопрос вот в чем: кто в итоге выиграет при оптимальной игре обоих игроков? Помните, что Алиса всегда ходит первой.

Входные данные

В первой строке записано целое число n (2 ≤ n ≤ 100) — исходное количество элементов в множестве. Во второй строке записано n различных целых чисел a1, a2, ..., an (1 ≤ ai ≤ 109), разделенных пробелом, — элементы множества.

Выходные данные

В единственной строке выведите имя победителя. Если победит Алиса, выведите «Alice», а если победит Боб, то «Bob» (без кавычек).

Примечание

Рассмотрим первый пример. Сперва ходит Алиса. Она может сделать только один ход: выбрать 2 и 3, а затем добавить ко множеству 1. Затем ходит Боб, допустимых ходов не остается и побеждает Алиса.

B. Игра со строками

битмаски дп игры *2400

Задана таблица T размера n × n, состоящая из строчных латинских букв. Строка s считается хорошей, если в таблице существует корректный путь, соответствующий данной строке. Другими словами, хорошими считаются все строки, которые можно получить, двигаясь из левой верхней клетки таблицы только вправо и вниз. Далее — формальное определение этого понятия:

Пронумеруем строки таблицы сверху вниз от 1 до n, колонки таблицы слева направо от 1 до n. Будем называть клеткой (r, c) — клетку таблицы T на r-той строке в c-той колонке. Данной клетке соответствует буква Tr, c.

Назовем путем длины k последовательность клеток таблицы [(r1, c1), (r2, c2), ..., (rk, ck)]. Тогда следующие пути являются корректными:

  1. Существует один корректный путь длины 1, то есть состоящий из одной клетки: [(1, 1)];
  2. Пусть [(r1, c1), ..., (rm, cm)] — корректный путь длины m, тогда пути [(r1, c1), ..., (rm, cm), (rm + 1, cm)] и [(r1, c1), ..., (rm, cm), (rm, cm + 1)] являются корректными путями длины m + 1.

Следует считать, что пути [(r1, c1), (r2, c2), ..., (rk, ck)] соответствует строка длины k: Tr1, c1 + Tr2, c2 + ... + Trk, ck.

Два игрока играют в следующую игру: изначально записана пустая строка, затем игроки по очереди приписывают в конец строки по одной букве, после каждого хода (приписывания новой буквы) полученная строка должна являться хорошей. Игра заканчивается после 2n - 1 ходов. Победитель определяется следующим образом:

  1. Если в полученной строке букв «a» строго больше, чем букв «b», то выигрывает первый игрок;
  2. Если в полученной строке букв «b» строго больше, чем букв «a», то выигрывает второй игрок;
  3. Если в полученной строке букв «a» и букв «b» одинаковое количество, то объявляется ничья.

Определите результат игры при оптимальной игре обоих игроков.

Входные данные

В первой строке содержится одно целое число n (1 ≤ n ≤ 20).

Следующие n строк содержат по n строчных латинских букв — таблицу T.

Выходные данные

В единственной строке выведите строку «FIRST», если выиграет первый игрок, «SECOND», если выиграет второй игрок и «DRAW», если игра закончится в ничью.

Примечание

Рассмотрим первый пример:

Хорошими строками являются: a, ab, ac, abd, acd.

Первый игрок в первый ход допишет к строке букву a, так как существует всего одна хорошая строка длины 1. Затем, второй игрок может приписать одну из букв b или c и тогда игра закончится соответственно со строками abd или acd. В первом случае будет ничья (в строке по одной букве a и b), во втором же случае выиграет первый игрок. Понятно, что в таком случае второму игроку выгодно выбрать букву b и получить ничью.

Рассмотрим второй пример:

Хорошие строки: x, xa, xay.

Понятно, что игра закончится со строкой xay и победит первый игрок.

D. Новая игра с шахматной фигурой

игры *2300

Петя и Вася придумывают новую игру. Для игры нужна прямоугольная доска и одна шахматная фигура. В начале игры фигура стоит в левом верхнем углу доски. Два игрока по очереди делают ходы. За ход можно передвинуть фигуру либо на 1 клетку вправо, либо на 1 клетку вниз, либо совершить прыжок на k клеток по диагонали вправо и вниз. Проигрывает тот, кто не может сделать ход.

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

Входные данные

В первой строке входного файла содержатся два целых числа t и k (1 ≤ t ≤ 20, 1 ≤ k ≤ 109). Каждая из следующих t строк содержат пару чисел n, m — размеры доски (1 ≤ n, m ≤ 109).

Выходные данные

Выведите t строк, соответствующих исходам игры на каждой из досок. Выведите «+», если в данном случае первый игрок имеет выигрышную стратегию, и «-» иначе.

C. Captains Mode

битмаски дп игры *2200

Костя — профессиональный киберспортсмен, специализирующийся на дисциплине Dota 2. Недавно компания Valve, разработчик этой игры, выпустила новый патч, перевернувший баланс игры с ног на голову. Костя, являясь капитаном команды, понимает, что наибольшая ответственность лежит на нем, поэтому он хочет прибегнуть к анализу нововведений патча с математической точки зрения, чтобы выбирать наилучших героев для своей команды в каждом матче.

В матче Dota 2 участвуют две команды, каждая из которых должна взять для себя некоторых героев, за которых впоследствии будут играть члены этой команды, причем запрещено выбирать одного и того же героя несколько раз, даже разными командами. На крупных киберспортивных турнирах, таких, в которых собирается участвовать команда Кости, матчи проходят в режиме Captains Mode. В этом режиме для выбора героев капитаны команд в определенном, заранее установленном порядке совершают одно из двух возможных действий: пик (pick) или бан (ban).

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

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

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

Входные данные

В первой строке записано единственное целое число n (2 ≤ n ≤ 100) — количество героев в Dota 2.

Во второй строке записаны n целых чисел s1, s2, ..., sn (1 ≤ si ≤ 106) — силы всех героев.

В третьей строке записано единственное целое число m (2 ≤ m ≤ min(n, 20)) — количество действий, которые должны выполнить капитаны команд.

Следующие m строк имеют вид «action team», где action — действие, которое необходимо выполнить: пик (обозначающийся символом «p») или бан (обозначающийся символом «b»), а team — номер команды, которой предстоит выполнить это действие (число 1 или 2).

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

Выходные данные

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

F. Умный мальчик

дп игры Строки *2100

Однажды Вася и Петя придумали новую игру и назвали ее «Умный мальчик». Для игры они зафиксировали некоторый набор слов — словарь. Допускается, что словарь содержит одинаковые слова.

Правила игры таковы: сначала первый игрок выбирает любую букву (слово длины 1) из любого слова из словаря и записывает ее на лист бумаги. Второй игрок приписывает к этой букве некоторую другую в начало или в конец, таким образом получая уже слово длины 2, затем опять ходит первый игрок, и он опять приписывает некоторую букву в начало или в конец, получая слово длины 3. И так далее. Но игрок не имеет права нарушать условие: новое записанное слово должно являться подстрокой некоторого слова из словаря. Проигрывает тот, кто не может увеличить текущую строку так, чтобы не нарушалось условие.

Также если после хода на бумаге записана некоторая строка s, то игрок, сделавший этот ход, получает количество очков по формуле:

где:

  • — порядковый номер символа c в латинском алфавите, пронумерованном с 1. Например, , а .
  • — количество слов из словаря, где встречается строка s как подстрока хотя бы один раз.

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

Входные данные

В первой строке входных данных записано целое число n — количество слов в зафиксированном словаре (1 ≤ n ≤ 30). Далее в n строках по одному на строке записаны слова из словаря — непустые строки, состоящие из строчных букв латинского алфавита, длиной не более 30 символов. Среди списка слов могут быть одинаковые.

Выходные данные

В первую строку выходных данных выведите строку «First» или «Second» — кто выиграет в игре. Во вторую строку выведите количество очков у первого игрока и количество очков у второго игрока после завершения игры. Числа разделите одним пробелом.

C. Лиса и игра в карты

жадные алгоритмы игры сортировки *2000

Лиса Сиель играет в карты со своим другом, лисом Джиро. На столе лежат n стопок карт и на каждой карте записано по положительному целому числу.

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

С каким счетом закончится игра при условии, что Сиель и Джиро играют оптимально?

Входные данные

В первой строке записано целое число n (1 ≤ n ≤ 100). В каждой из следующих n строк записано описание одной стопки: первым в строке идет целое число si (1 ≤ si ≤ 100); число si обозначает количество карт в i-ой стопке; затем следуют si положительных целых чисел c1, c2, ..., ck, ..., csi (1 ≤ ck ≤ 1000) — последовательность чисел на картах в текущей стопке, перечисленных сверху вниз.

Выходные данные

Выведите два целых числа: сумму карт Сиель и сумму карт Джиро, если они играют оптимально.

Примечание

В первом примере Сиель возьмет карты с числами 100 и 1, Джиро возьмет карту с числом 10.

Во втором примере Сиель возьмет карты с числами 2, 8, 6, 5, 9, а Джиро возьмет карты с числами 4, 7, 1, 3.

E. При чем тут Дирихле?

дп игры *2000

Всем вам известен принцип Дирихле, идея которого в том, что размещение по n коробкам не менее n + 1 предметов влечет существование коробки, в которой хотя бы два предмета.

Узнав об этом принципе, но не владея техникой логических рассуждений, восьмилетние Стас с Машей придумали игру. Имеется a различимых коробок и b различимых предметов, за ход можно либо добавить новую коробку, либо — новый предмет. Проигрывает в игре тот игрок, после хода которого число способов разложить по a коробкам b предметов становится не меньше некоторого заданного числа n. Все коробки и предметы считаются различными. Возможно, некоторые коробки останутся пустыми.

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

Входные данные

В единственной строке входного файла записано три целых числа a, b, n (1 ≤ a ≤ 10000, 1 ≤ b ≤ 30, 2 ≤ n ≤ 109) — начальное число коробок, предметов и число, ограничивающее количество способов, соответственно. Гарантируется, что изначальное количество способов строго меньше n.

Выходные данные

Выведите «Stas», если победит Маша. Выведите «Masha», если победит Стас. Если будет ничья, то выведите «Missing».

Примечание

Во втором примере первоначальное количество способов равно 3125.

  • Если Стас увеличит число коробок, то проиграет, так как Маша следующим ходом может еще раз увеличить число коробок. После этого любой ход Стаса приведет к поражению.
  • Если же Стас увеличит число предметов, то любой машин ход будет проигрышным.

B. Много игр

Деревья дп игры поиск в глубину и подобное реализация Строки *1900

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

Задан набор, состоящий из n непустых строк. Во время игры два игрока вместе строят слово, изначально это слово пустое. Игроки ходят по очереди. За свой ход игрок должен дописать в конец слова одну букву так, чтобы полученное слово было префиксом хотя бы одной строки из заданного набора. Проигрывает тот, кто не может сделать ход.

Андрей и Леша решили сыграть в эту игру k раз. Причем, игрок, проигравший в i-й игре, делает первый ход в (i + 1)-й игре. Ребята решили, что победителем по сумме всех игр будет считаться тот, кто победил в последней (k-й) игре. Андрей и Леша уже начали играть, а Федя в это время решил посчитать: кто будет победителем, если оба игрока будут играть оптимально. Помогите ему.

Входные данные

Первая строка содержит два целых числа, n и k (1 ≤ n ≤ 105; 1 ≤ k ≤ 109).

Каждая из n следующих строк содержит непустую строку из заданного набора. Суммарная длина всех строк из набора не превышает 105. Все строки из набора состоят только из строчных латинских букв.

Выходные данные

Если победит игрок, который ходит первым, то выведите «First», иначе выведите «Second» (кавычки выводить не нужно).

F. Простая задача о деревьях

Деревья дп жадные алгоритмы игры *3200

Pieguy и Piegirl играют в игру. У них есть корневое бинарное дерево, которое обладает следующим свойством: каждая вершина дерева либо лист, либо имеет ровно два сына. Каждый лист имеет некоторое значение, ассоциированное с ним.

Во время игры игроки по очереди делают ходы. На своем ходу игрок выбирает два листа, имеющих общего непосредственного предка, и удаляет их. При этом он ассоциирует с общим предком листов (после удаления он станет листом) какое-то одно из ассоциированных с ними значений на свой выбор. Игра заканчивается, когда в дереве остается ровно одна вершина — корень дерева.

Pieguy ходит первым и его цель — максимизировать значение, которое будет ассоциировано с корнем в конце игры. Piegirl, наоборот, хочет минимизировать это значение. Считая, что оба игрока играют оптимально, вычислите значение, которое будет ассоциировано с корнем в конце игры.

Входные данные

В первой строке записано целое число t (1 ≤ t ≤ 100) — количество тестовых данных. Далее идет описание t тестовых данных. Каждый тест начинается с пустой строки, за которой следует строка, содержащая целое число n (1 ≤ n ≤ 250) — количество вершин дерева. Затем следуют n строк, описывающих n вершин дерева. Если текущая строка описывает лист дерева, то в ней содержится одно неотрицательное целое число ai (0 ≤ ai ≤ 1000), обозначающее ассоциированное с этим листом значение. Иначе, сперва в строке записано число  - 1, а затем два целых числа l и r (0 ≤ l, r ≤ n - 1) — номер левого и правого сыновей текущей вершины. Вершины дерева пронумерованы от 0 до n - 1. Корень дерева — это вершина с номером 0.

Выходные данные

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

E. Иванушка-дурачок против Змея Горыныча

графы дп игры *2100

В тридевятом царстве, в тридесятом государстве... Итак, начнем с того момента, как Иванушка-дурачок встретил Змея Горыныча. Достал Иванушка меч-кладенец, и началась у них битва. Сначала у Змея Горыныча было h голов и t хвостов. Каждым ударом меча Иванушка может отрубить либо несколько голов (от 1 до n, но не больше, чем голов у Горыныча в данный момент), либо несколько хвостов (от 1 до m, но не больше, чем хвостов у Горыныча в данный момент). При этом (о, ужас!) у Змея Горыныча могут вырастать новые головы и хвосты. Причем количество вырастающих голов и хвостов однозначно определяется в зависимости от количества голов или хвостов, отрубленных очередным ударом. Когда суммарное количество голов и хвостов станет строго больше R, Змей Горыныч нанесет свой решающий удар и повергнет Иванушку-дурачка. Поэтому Иванушка стремится как можно быстрее отрубить все головы и хвосты Змею и победить. Возможен и третий вариант развития событий: ни один из противников не сможет одолеть другого и они будут сражаться бесконечно.

Скоро сказка сказывается, да нескоро дело делается. Ваша задача — написать программу, определяющую исход битвы. Учтите, что Иванушка-дурачок наносит удары последовательно. После каждого удара у Горыныча вырастают новые головы и хвосты в зависимости от количества отрубленных. Змей Горыныч считается побежденным, если после очередного удара он лишается всех голов и хвостов и у него не вырастает новых. Иванушка сражается оптимально (дурачкам везет!), т.е.

  • если Иванушка может победить, он побеждает за наименьшее количество ударов;
  • если победить Горыныча невозможно, но можно бесконечно долго сопротивляться ему, то Иванушка выбирает именно эту стратегию;
  • если победу в любом случае одержит Змей Горыныч, Иванушка стремится сопротивляться ему как можно дольше.
Входные данные

В первой строке содержатся три целых числа h, t и R (0 ≤ h, t, R ≤ 200, 0 < h + t ≤ R) — изначальные количества голов и хвостов у Змея Горыныча и наибольшее суммарное количество голов и хвостов, при котором Змей Горыныч еще не переходит в наступление. В следующей строке содержится целое число n (1 ≤ n ≤ 200). Следующие n строк содержат пары неотрицательных целых чисел «hi ti» — количество голов и количество хвостов соответственно, которые вырастут, если Горынычу отрубить i голов (1 ≤ i ≤ n). В следующей строке содержится целое число m (1 ≤ m ≤ 200) и затем — описание поведения Горыныча при отрубании хвостов в формате, аналогичном описанному выше. Все числа во входном файле не превосходят 200.

Выходные данные

В первой строке выведите «Ivan» (без кавычек), если победит Иванушка, или «Zmey», если победит Змей Горыныч. Во второй строке выведите единственное целое число — количество ударов, нанесенных Иванушкой. Если битва будет продолжаться бесконечно, выведите в первой строке «Draw».

D. Вася и шахматы

игры Конструктив математика *1700

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

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

Есть шахматная доска n × n. Будем обозначать клетку на пересечении r-й горизонтали и c-й вертикали как (r, c). На поле (1, 1) стоит белый ферзь, на поле (1, n) — черный ферзь. На всех других полях стоят зеленые пешки, за которых никто не играет.

Игроки ходят по очереди. Игрок, делающий ход первым, играет за белого ферзя, его оппонент — играет за чёрного ферзя.

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

Помогите Васе определить, кто побеждает при правильной стратегии на доске n × n.

Входные данные

На вход даётся единственное число n (2 ≤ n ≤ 109) — размер доски.

Выходные данные

В первой строке выведите ответ на задачу — строку «white» или строку «black», в зависимости от того, кто выиграет при правильной игре.

Если ответ — «white», то также требуется вывести два числа r и c, обозначающих клетку (r, c), в которую следует совершить первый ход первому игроку, чтобы гарантированно победить. Если таких клеток несколько, выведите клетку с минимальным r. Если и таких клеток несколько, то выведите клетку с минимальным c.

Примечание

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

Во втором тесте из условия если белый ферзь побьёт зелёную пешку, расположенную на центральной вертикали, он будет следующим ходом побит чёрным ферзём, поэтому единственный ход для белых — взять зелёную пешку, расположенную в (2, 1).

Аналогично, у чёрного ферзя нет другой возможности, кроме как взять зелёную пешку, расположенную в (2, 3), иначе, оказавшись на средней вертикали, он будет побит белым ферзём.

На следующем ходу происходит то же самое — ни у белого, ни у чёрного ферзя нет других возможностей, кроме как взять зелёные пешки, расположенные над ними. Таким образом, белый ферзь окажется на клетке (3, 1), а чёрный ферзь — на клетке (3, 3).

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

E. Шарти

игры Структуры данных *3200

Хамед и Малек провел последние 24 часа за игрой в «Шарти». Они очень устали и не могут завершить последний раунд. Поэтому они попросили Вас помочь им определить победителя этого раунда.

«Шарти» играется на доске размера n × n, клетки которой покрашены в белый и чёрный цвета. Строки доски пронумерованы сверху вниз номерами от 1 до n. Столбцы доски пронумерованы слева направо номерами от 1 до n. Клетка, расположенная на пересечении i-го ряда и j-го столбца обозначается как (i, j).

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

Вы знаете, что Хамед и Малек очень умные и они действуют оптимальным образом. Зная это и то, что Хамед ходит первым, а также имея описание исходной доски во входных данных, определите, кто из них победит.

Входные данные

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

В первой строке ввода следуют три целых числа через пробел n, m, k (1 ≤ k ≤ n ≤ 109, 1 ≤ m ≤ 5·104) — размер доски, количество прямоугольников и максимальный размер квадрата, доступного игроку во время его хода, соответственно.

В i-й из следующих m строк записано четыре целых числа через пробел ai, bi, ci, di (1 ≤ ai ≤ ci ≤ n, 1 ≤ bi ≤ di ≤ n), обозначающих, что i-й прямоугольник, описывающий исходную доску, это прямоугольник с левой верхней клеточкой в (ai, bi) и правой нижней клеточкой в (ci, di).

Выходные данные

Если выигрывает Хамед, выведите «Hamed», в противном случае выведите «Malek» (без кавычек).

D. Кубики

жадные алгоритмы игры реализация *2100

Как-то раз Вася с Петей собрали конструкцию из m кубиков, на каждом из которых написано число от 0 до m - 1 (каждое число встречалось ровно один раз). Введём систему координат так, что осью OX является земля, а ось OY направлена вверх. Каждый кубик задаётся координатами своего нижнего левого угла, при этом эти координаты целые для каждого кубика.

Конструкция получилась устойчивой. Это значит, что для любого кубика, который не стоит на земле, есть хотя бы один кубик под ним, с которым он касается по стороне или по углу. Более формально, это значит, что для кубика с координатами (x, y) либо выполняется y = 0, либо существует кубик, имеющий координаты (x - 1, y - 1), (x, y - 1) или (x + 1, y - 1).

Теперь мальчики хотят разобрать конструкцию и выложить все кубики в ряд. Очередной кубик удаляется из конструкции и кладется в ряд справа от уже положенных кубиков, при этом ребята вынимают кубики таким образом, что конструкция остаётся устойчивой. Чтобы разнообразить процесс, ребята решили поиграть в следующую игру. Ребята вынимают кубики из конструкции по очереди. Легко видеть, что после разбора конструкции цифры, написанные на кубиках, образуют число, записанное в m-ичной системе счисления (возможно, содержащее ведущий нуль). Вася хочет, чтобы полученное в результате число было наибольшим, а Петя, наоборот, старается его сделать как можно меньше. Вася ходит первым.

Ваша задача — определить, какое число получится после разбора конструкции, если ребята будут действовать оптимально. Определите остаток от деления ответа на 109 + 9.

Входные данные

В первой строке дано число m (2 ≤ m ≤ 105).

В последующих m строках даны координаты кубиков xi, yi ( - 109 ≤ xi ≤ 109, 0 ≤ yi ≤ 109) в порядке следования чисел, написанных на них. Гарантируется, что исходная конструкция устойчива.

Никакие два кубика не совпадают.

Выходные данные

В единственной строке выведите ответ на задачу.

D. Тавас в Канзасе

дп игры *2900

Тавас живет в Канзасе. Канзас состоит из n городов, пронумерованных от 1 до n, соединенных m двусторонними дорогами. Из любого города можно добраться в любой другой город по этим дорогам. Канзас не менее странный, чем Тавас, поэтому дорога может соединять город с самим собой, а также несколько дорог могут соединять одну и ту же пару городов.

Тавас изобрел игру и назвал её "Дашти". Он хочет играть в Дашти со своей девушкой Нафас.

В этой игре к каждому городу в Канзасе сопоставляется произвольное целочисленное значение. Значение i-го города устанавливается равным pi.

В процессе игры Тавас находится в городе s, а Нафас — в городе t. Они совершают ходы по очереди и Тавас ходит первым. Во время хода игрок должен выбрать неотрицательное целое число x и тогда его или её счет увеличивается на сумму значений всех городов, находящихся на расстоянии не более x до его/её города. Каждый город может быть использован только один раз, иными словами, после первого использования значение города обнуляется.

Есть дополнительное правило: игрок на каждом ходу обязан выбрать такой x, что как минимум один из городов на расстоянии x не был использован до этого. Город может исходно иметь значение ноль, такой город исходно не считается использованным, таким образом, такой город может быть использован на очередном ходу для исполнения дополнительного правила.

Игра заканчивается, когда никто не може сделать ход.

Счет игрока — это сумма баллов, заработанных им в процесса игры. Побеждает игрок с большим счетом, а если у игроков одинаковые значения счета, то объявляется ничья. Оба игрока начинают игру с нулем баллов.

Если победит Тавас, то он разобьет этим сердце своей девушки. А если победит Нафас, то Тавас заплачет. Но если у них образуется одинаковый счет, от оба игрока останутся довольны, а Тавас подарит Нафас цветы.

В конце концов, результат игры волнует Тавас и Нафас сильнее, чем их дальнейшие взаимоотношения, поэтому они будут играть оптимально. Ваша задача — сказать Тавасу, что произойдет, когда завершится игра.

Входные данные

В первой строке входа записано два целых числа n и m (2 ≤ n ≤ 2000, n - 1 ≤ m ≤ 105).

Во второй строке входа записано два целых числа s и t (1 ≤ s, t ≤ n, s ≠ t).

В следующей строке записано n целых чисел p1, p2, ..., pn, разделенных пробелами (|pi| ≤ 109).

В следующих m строках записаны дороги. В каждой строке записано три целых числа v, u, w, это означает, что есть дорога длины w между городами v и u (1 ≤ u, v ≤ n и 0 ≤ w ≤ 109). Дорога может вести из города в него же, между двумя городами может быть несколько дорог.

Выходные данные

Если победит Тавас, выведите "Break a heart". Если победит Нафас, выведите "Cry", а если никто не победит (то есть, если игра закончится ничьей), выведите "Flowers".

C. Солдат и карты

игры Перебор поиск в глубину и подобное *1400

Два скучающих солдата играют в карточную войну (эквивалент карточной игры «пьяница» в англоязычных странах). Их колода состоит ровно из n карт, пронумерованных различными числами от 1 до n. Исходно они делят между собой картны некоторым образом, возможно, не равным образом.

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

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

Входные данные

В первой строке записано единственное целое число n (2 ≤ n ≤ 10), количество карт.

Во второй строке записано целое число k1 (1 ≤ k1 ≤ n - 1), количество карт у первого солдата. Затем следует k1 целых чисел — значения карт первого солдата в порядке сверху вниз.

В третьей строке записано целое число k2 (k1 + k2 = n), количество карт у второго солдата. Затем следует k2 целых чисел — значения карт второго солдата сверху вниз.

Все значения карт различны.

Выходные данные

Если кто-то победит в этой игре, выведите 2 целых чисел, где первое число обозначает количество сражений в игре, а второе — 1 или 2, обозначающее, какой игрок победил.

Если игра не закончится, а будет продолжаться вечно, выведите  - 1.

Примечание

Первый пример:

Второй пример:

C. Игра чётности

игры *2200

В Вестеросе расположены n городов. В i-м городе живет ai человек. Дейнерис и Станнис играют в следующую игру: за один ход игрок выбирает какой-то город и сжигает его дотла. При этом все его жители, как ни печально, погибают. Ходы совершаются по очереди, начинает Станнис. Игра завершается, когда в Вестеросе останется ровно k городов.

Пророчество гласит, что если суммарное число выживших жителей будет чётным, то Дейнерис выигрывает: Станнис лишается головы, а Дейнерис всходит на Железный трон. Если же суммарное число выживших жителей будет нечётным, то всё происходит наоборот.

Лорд Петир Бейлиш хочет знать, кого из претендентов на престол стоит поддержать, а посему его интересует, кто из них обладает выигрышной стратегией. Подскажите ответ на этот вопрос лорду Бейлишу и, возможно, вы станете следующим лордом Харренхолла.

Входные данные

В первой строке записаны два целых положительных числа, разделенные пробелом, n и k (1 ≤ k ≤ n ≤ 2·105) — изначальное количество городов в Вестеросе и количество городов, при котором игра завершается.

Вторая строка содержит n разделённых пробелами целых положительных чисел ai (1 ≤ ai ≤ 106), обозначающих население каждого из городов Вестероса.

Выходные данные

Выведите строку «Daenerys» (без кавычек), если победит Дейнерис, и «Stannis» (без кавычек), если победит Станнис.

Примечание

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

Во втором примере, если Станнис сжигает город с двумя жителями, Дейнерис сжигает город с одним жителем, либо наоборот. В любом случае, последний оставшийся город будет населён двумя жителями, то есть, итоговая сумма четная, а значит, побеждает Дейнерис.

C. Кекс или смерть

игры *1900

Володя и Влад играют в игру. На доске n × m в некоторых клетках расположены кексы, всего k штук. Первым ходит Володя. На своем ходу Володя может подвинуть один из кексов в соседнюю по стороне клетку. Если перед ходом Володи какой-либо кекс находится на граничной клетке доски и кекс можно скинуть с доски, то считается, что Володя получает кекс и тем самым побеждает. Задача Влада — помешать Володе заполучить кекс. На своем ходу Влад может отметить часть границы доски длины 1 (с концами в углах клеток доски) как непроходимую. Тем самым, в этом месте Володе скинуть кекс не удастся. Ваша задача — узнать, выигрывает ли Володя при правильной игре обоих соперников.

Входные данные

В первой строке записаны три целых числа, разделенные пробелом: 1 ≤ n, m ≤ 100 — размеры доски и 0 ≤ k ≤ 100 — количество кексов. Каждая из следующих k строк описывает расположение кексов в виде двух целых чисел, разделенных пробелом: 1 ≤ x ≤ n и 1 ≤ y ≤ m — координаты кекса на доске. В одной клетке может находиться несколько кексов.

Выходные данные

Выведите единственное слово: "YES" — если Володя выигрывает, "NO" — в противном случае.

B. Простая игра

жадные алгоритмы игры Конструктив математика реализация *1300

Как-то Миша и Андрей играли в очень простую игру. Сначала каждый игрок выбирает целое число в пределах от 1 до n. Пусть Миша выбрал число m, а Андрей — число a.

Затем с помощью генератора случайных чисел выбирается случайное целое число c в пределах от 1 до n (любое целое число от 1 до n может быть выбрано с одной и той же вероятностью), после чего побеждает тот игрок, чьё число оказалось ближе к c. Ребята договорились, что в случае, когда m и a находятся на одинаковом расстоянии от c, выигрывает Миша.

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

Более формально, нужно найти такое целое число a (1 ≤ a ≤ n), чтобы вероятность того, что , была максимальна, где c — выбранное равновероятно случайное целое число от 1 до n (включительно).

Входные данные

В первой строке находятся два целых числа n и m (1 ≤ m ≤ n ≤ 109) — диапазон чисел в игре и выбранное Мишей число соответственно.

Выходные данные

Выведите одно целое число — такое значение a, чтобы вероятность победы Андрея была максимальной. Если таких значений несколько, выведите минимальное из них.

Примечание

В первом тесте: Андрей победит если c равно 2 или 3. Вероятность победы Андрея равна 2 / 3. Если Андрей выберет число a, равное 3, то вероятность победы будет 1 / 3. При a, равном 1, вероятность победы — 0.

Во втором тесте: Андрей победит если c равно 1 или 2. Вероятность победы Андрея — 1 / 2. При остальных вариантах выбора a вероятность победы меньше.

A. Воин и лучник

игры *2300

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

Вова и Лёша — большие друзья. Они часто собираются дома у Вовы и играют друг против друга в компьютерную игру The Ancient Papyri: Swordsink. Вова выбрал для сражения воина, а Лёша — лучника. Теперь они должны выбрать начальные позиции для своих персонажей и начать сражение. Воин силён в ближнем бою, поэтому Вова будет действовать так, чтобы противники находились друг к другу как можно ближе в начале боя. Лучнику же лучше держать дистанцию от противника, поэтому Лёша будет действовать так, чтобы расстояние между ним и воином в начале боя было как можно больше.

Вдоль прямой Ox отмечено n (n — четное) возможных позиций, куда каждый из игроков может поставить своего персонажа. Позиции заданы своими попарно различными координатами x1, x2, ..., xn, при этом два персонажа не могут в итоге оказаться на одной позиции.

Вова и Лёша ходят по очереди, при этом Вова ходит первым. Каждый ход состоит из того, что один из ребят запрещает использовать ровно одну из оставшихся возможных позиций. Ходы продолжаются, пока возможных позиций не останется ровно две (таким образом, суммарно они сделают n - 2 хода). После этого персонаж Вовы занимает позицию с меньшей координатой, а персонаж Лёши — с большей, и ребята начинают сражение.

Вову и Лёшу уже достаточно утомило играть в игру с выбором позиций каждый раз перед тем, как провести сражение, поэтому они попросили вас, как разработчика игры The Ancient Papyri: Swordsink, написать модуль, который автоматически определял бы расстояние, на котором воин и лучник начнут сражение, если оба друга действуют оптимально.

Входные данные

В первой строке содержится число n (2 ≤ n ≤ 200 000, n — четное) — количество изначально доступных позиций. Во второй строке содержатся n различных целых чисел x1, x2, ..., xn (0 ≤ xi ≤ 109), определяющих координаты соответствующих позиций.

Выходные данные

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

Примечание

В первом примере одно из оптимальных поведений игроков выглядит так:

  1. Вова запрещает позицию в координате 15;
  2. Леша запрещает позицию в координате 3;
  3. Вова запрещает позицию в координате 31;
  4. Леша запрещает позицию в координате 1.

После их действий останутся позиции 0 и 7, расстояние между которыми равно 7.

Во втором примере существует лишь две возможные позиции, и запрещений сделано не будет.

C. Легенды Лиги

игры математика *2200

Кевин и Ники Сан изобрели новую игру под названием «Легенды Лиги». В этой игре два игрока по очереди совершают ходы, изменяющие состояние игры. Кевин ходит первым. Изначально есть n групп коров, в i-й группе находится ai коров. Каждый ход игрок призывает силу Солнечного света и использует её, чтобы совершить одно из двух действий:

  1. Удалить одну корову из выбранной непустой группы.
  2. Взять группу коров четного размера x (x > 0) и заменить её на k групп по x коров в каждой.

Игрок, который удаляет последнюю корову, выигрывает. Для данных n, k и последовательности a1, a2, ..., an помогите Кевину и Ники определить, кто обладает выигрышной стратегией, если оба они играют оптимально.

Входные данные

Первая строка входных данных содержит два целых числа n и k (1 ≤ n ≤ 100 000, 1 ≤ k ≤ 109).

Вторая строка содержит n целых чисел a1, a2, ... an (1 ≤ ai ≤ 109), описывающих начальное состояние игры.

Выходные данные

Выведите имя игрока-победителя, то есть либо "Kevin", либо "Nicky" (без кавычек).

Примечание

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

B. Ужин с Наташей

жадные алгоритмы игры *1000

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

Город Мюнхетен состоит из n улиц и m проспектов. На пересечении любой улицы и проспекта находится один ресторан. Пронумеруем улицы целыми числами от 1 до n, а проспекты — целыми числами от 1 до m. Стоимость ужина в ресторане на пересечении i-й улицы и j-го проспекта составляет cij.

Павел и Наташа решили выбрать ресторан следующим образом. Сначала Наташа выбирает улицу, на которой хочет ужинать, затем Павел выбирает проспект. Наташа и Павел делают свой выбор оптимально: Наташа желает максимизировать стоимость ужина, а Павел — минимизировать. При выборе улицы Наташа учитывает то, что Павел хочет сэкономить. Определите стоимость ужина влюблённой пары.

Входные данные

В первой строке находится пара целых чисел n, m (1 ≤ n, m ≤ 100) — количество улиц и проспектов в Мюнхетене.

В каждой из следующих n строк находятся m целых чисел cij (1 ≤ cij ≤ 109) — стоимость ужина в ресторане на пересечении i-й улицы и j-го проспекта.

Выходные данные

Выведите целое число a — стоимость ужина Павла и Наташи.

Примечание

В первом примере, если Наташа выберет первую или третью улицу, то Павел сможет выбрать проспект со стоимостью ужина 1. Поэтому Наташа выбирает вторую улицу, а Павел любой проспект. Таким образом, стоимость ужина равна 2.

Во втором примере какую бы улицу не выбрала Наташа, Павел сможет выбрать проспект такой, что стоимость ужина будет равна 1.

E. Игра с конфетами

битмаски дп игры поиск в глубину и подобное реализация *2000

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

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

Карлсон ходит первым — ведь это он в гостях у Малыша, а не наоборот. Игроки играют оптимальным образом. Определите, кому достанется торт.

Входные данные

Входные данные содержат 5 строк, которые содержат 19 слов, состоящих из одного символа. Слово «O» означает, что в данной ячейке находится конфета, «.» — что данная ячейка пуста. Гарантируется, что в коробке имеется хотя бы одна конфета. Смотрите примеры для более точного понимания.

Выходные данные

Если торт достанется Карлсону — выведите «Karlsson» (без кавычек), иначе выведите «Lillebror» (опять же без кавычек).

R. Игра

игры математика *1200

В вузе ИТ-града существует такая легенда. Студенту, не ответившему ни на один вопрос на экзамене по теории игр, преподаватель даёт последний шанс. Студенту нужно сыграть с преподавателем в игру.

Игра происходит на квадратном клетчатом поле n × n. Изначально все клетки поля пусты. На каждом ходу игрок выбирает пустую клетку, не имеющую общих сторон с закрашенными клетками, и закрашивает её. Касание закрашенных клеток углами допускается. На следующем ходу то же самое делает второй игрок, после него первый и так далее. Тот, кому некуда сделать ход, проигрывает.

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

Входные данные

Единственная строка входных данных содержит одно целое число n (1 ≤ n ≤ 1018) — размер поля.

Выходные данные

Выведите число 1, если при оптимальной игре обоих игроков выиграет игрок, делающий первый ход, иначе число 2.

D. Точка

дп игры *1900

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

  • На клетчатой бумаге рисуется система координат. В позицию (x, y) ставится точка.
  • Ходом является перемещение точки на один из заранее выбранных векторов. Также каждый игрок может один раз за игру симметрично отобразить точку относительно прямой y = x.
  • Антон и Даша ходят по очереди. Первым ходит Антон.
  • Проигрывает тот, после чьего хода расстояние от точки до начала координат превышает d.

Помогите им определить победителя.

Входные данные

В первой строке входного файла находится 4 целых числа x, y, n, d ( - 200 ≤ x, y ≤ 200, 1 ≤ d ≤ 200, 1 ≤ n ≤ 20) — начальные координаты точки, расстояние d и количество векторов. Гарантируется, что изначально точка находится на расстоянии меньшем d от начала координат. В следующих n строках записано по 2 неотрицательных числа xi и yi (0 ≤ xi, yi ≤ 200) — координаты i-ого вектора. Гарантируется, что все векторы ненулевые и различны.

Выходные данные

Cледует вывести "Anton", если при оптимальной игре обоих игроков выигрывает Антон, и "Dasha" в противном случае.

Примечание

В первом тесте Антон ходит на вектор (1;2), и Даша проигрывает. Во втором тесте Даша своим первым ходом перемещает точку так, чтобы ее координаты стали (2;3), и Антон проигрывает, та как у него остается единственный возможный ход — отражение относительно прямой y = x, на который Даша ответит аналогичным ходом и вернет точку в позицию (2;3).

B. Человек-паук

игры математика *1100

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

В начале игры имеются k циклов, i-й из которых состоит ровно из vi вершин. Игроки ходят по очереди, Питер ходит первым. За один ход игрок должен выбрать какой-нибудь цикл, состоящий хотя бы из 2 вершин (обозначим размер выбранного цикла за x), и заменить его двумя непустыми циклами размера p и x - p для некоторого 1 ≤ p < x, выбор которого остаётся на усмотрение игрока. Игрок, который не может сделать ход, проигрывает (и расстаётся с жизнью!).

Питер хочет протестировать несколько изначальных конфигураций игры, перед тем как вступить в схватку с Доктором Октопусом. Изначально набор циклов пуст. Перед i-м тестом Питер добавляет в набор цикл, состоящий из ai вершин (обратите внимание: набор является мультимножеством, то есть может содержать несколько циклов одинакового размера). После добавления каждого цикла Питер хочет знать, кто выигрывает на текущем наборе?

Питер вообще неплохо разбирается в математике, но сейчас решил обратиться к вам за помощью.

Входные данные

В первой строке входных данных записано целое число n (1 ≤ n ≤ 100 000) — количество тестов, которые собирается провести Питер.

Во второй строке записаны n целых чисел a1, a2, ..., an (1 ≤ ai ≤ 109), i-е из которых равно количеству вершин в цикле, добавленном перед i-м тестом.

Выходные данные

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

Примечание

Рассмотрим первый пример:

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

Во втором тесте есть один цикл длины 1 и один цикл длины 2. Первый игрок делит второй цикл на два цикла длины 1, после чего второй игрок не может сделать ход и проигрывает.

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

Рассмотрим второй тестовый пример:

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

Когда появляется цикл длины 5, у первого игрока есть два варианта хода: поделить его на 1 и 4 или на 2 и 3.

  • Если поделить на циклы длины 1 и 4, то своим ходом второй игрок поделит 4 на два цикла длины 2, после чего останется два однозначно определяемых хода.
  • Если поделить на циклы длины 2 и 3, то второй игрок поделит цикл длины 3 на 2 и 1, опять оставив ситуацию когда есть два однозначных хода.

Таким образом, второй игрок может гарантировать себе победу во всех тестах второго примера.

D. Лаборатория Негодницы

игры матрицы Теория вероятностей *1900

Послушница и Негодница были соперницами сколько себя помнят. Поскольку обе они — очень интеллигентные молодые девушки, то они всегда решали свои вопросы миролюбиво и без насилия. Поскольку бог знает скольких игр друг с другом их счёт по-прежнему равен, и они уже не знаю, в какую ещё игру им сыграть. В этот раз Послушница предложила Негоднице сыграть в игру ним.

Ним, это игра для двух игроков, в начале которой имеется некоторое количество кучек с объектами. На своём ходу каждый игрок удаляет ровно из одной кучи произвольное положительное количество объектов. Проигрывает тот, кто не может сделать ход. Они договорились, что размер каждой кучки будет определяться как случайное число в диапазоне [0, x]. Каждый размер выбирается независимо из одного и того же распределения вероятностей, которое известно до начала игры.

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

Входные данные

В первой строке входных данных записаны два целых числа n (1 ≤ n ≤ 109) и x (1 ≤ x ≤ 100) — количество кучек и максимальное количество объектов в одной куче соответственно. Во второй строке записаны x + 1 вещественное число, данное не более чем с 6 знаками после запятой: P(0), P(1), ... , P(X). Здесь P(i) означает вероятность того, что в кучке будет ровно i объектов. Гарантируется, что сумма все P(i) равна 1.

Выходные данные

Выведите одно вещественное число — вероятность победы первого игрока. Ответ будет считаться правильным, если он отличается от ответа жюри не более чем на 10 - 6.

F. Семейные фотографии

жадные алгоритмы игры *2900

Хотя Алиса и Бонни — родные сёстры, отношения между ними очень напряжённые. Когда они нашли на чердаке старые семейные фотографии, они сразу принялись спорить про каждую из них, кому она должна достаться. В конце концов, они решили сыграть в игру, по очереди забирая себе по одной фотографии. Алиса ходит первой.

Фотографии лежат в n стэках. В каждом стэке содержится ровно две фотографии. На каждом ходу игрок может взять только фотографию, которая является сейчас верхней в каком-нибудь из стэков.

Каждая фотография описывается двумя целыми неотрицательными числами a и b, означающими, что обладание данной фотографией принесёт a единиц счастья Алисе и b единиц счастья Бонни. Значения a и b могут отличаться для разных фотографий.

Разрешается не брать фотографию и пропустить текущий ход. Игра заканчивается, когда заканчиваются фотографии или когда оба игрока последовательно пасуют (то есть и Алиса, и Бонни не хотят сейчас ходить).

Игроки не стараются максимизировать своё количество счастья. Вместо этого, каждая из игроков действует таким образом, чтобы максимизировать своё счастье минус счастье своей сестры. Считая, что оба игрока действуют оптимально, найдите результат игры, то есть значение x - y, где x — счастье Алисы, а y — счастье Бонни.

Входные данные

В первой строке входных данных записано целое число n (1 ≤ n ≤ 100 000) — количество стэков из двух фотографий. Далее следуют n строк, каждая из которых описывает один из стэков. Каждое описание стэка состоит из четырёх неотрицательных целых чисел a1, b1, a2 и b2, не превышающих 109. Числа a1 и b1 описывают верхнюю фотографию в стэке, а числа a2 и b2 описывают нижнюю фотографию.

Выходные данные

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

E. Веселая игра

дп игры *2200

Однажды после очередного написанного соревнования по программированию Петя и Гена решили поиграть в какую-нибудь игру. Так как большинство современных игр кажутся им достаточно скучными, они любят придумывать свои собственные. В доступности нашлись только стикеры и ручки, но это их не остановило.

Они придумали следующую игру. Изначально они расклеили n стикеров в ряд на стене и написали на каждом стикере своё число. Далее они стали совершать ходы по очереди, причём Петя ходит первым.

В течение каждого хода происходит следующее. Пусть на стене сейчас висит m ≥ 2 стикеров. Игрок, которых ходит в данный момент, выбирает целое число k от 2 до m и забирает k стикеров с левого конца ряда себе. После этого он клеит новый стикер с левого конца ряда и пишет на нём число, равное сумме всех чисел на стикерах, которые он забрал себе на этом ходу.

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

Конечно же, Петя и Гена вкладывают другой смысл в понятие «играть в игру», нежели мы привыкли себе думать. Они уже разобрались, как по значению n и числам, написанным на каждом из стикеров исходно, определить разницу между Петиными и Гениными очками, если они будут играть оптимально. Справитесь ли вы с той же самой задачей?

Входные данные

В первой строке находится целое число n (2 ≤ n ≤ 200 000) — количество стикеров, которые исходно висят на стене.

Во второй строке находится n чисел a1, a2, ..., an ( - 10 000 ≤ ai ≤ 10 000) — числа, написанные на стикерах в порядке слева направо.

Выходные данные

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

Примечание

В первом тесте из условия оптимальным ходом для Пети будет сразу взять себе все имеющиеся стикеры, в результате чего счёт Пети составит 14, а счёт Гены — 0.

Во втором тесте из условия оптимальная последовательность ходов для игроков выглядит следующим образом. На первом ходу Петя возьмёт себе первые три стикера и добавит слева от ряда стикер с числом  - 8. На втором ходу Гена возьмёт себе оставшиеся два стикера. Счёт Пети составит 1 + ( - 7) + ( - 2) =  - 8, а счёт Гены — ( - 8) + 3 =  - 5, значит разность очков Пети и Гены составит  - 3.

B. Электричка

дп жадные алгоритмы игры *1500

«Заяц» и контролер играют в следующую игру.

Электричка представляет собой n вагонов, которые нумеруются натуральными числами от 1 до n в порядке от головы до хвоста. «Заяц» и контролер изначально находятся в некоторых двух различных вагонах. Электричка каждую минуту может быть в одном из двух состояний — в движении или на остановке. Каждую минуту игроки делают ходы.

Ход контролера заключается в следующем. Контролер имеет направление движения — к голове электрички или к ее хвосту. За свой ход контролер перемещается в соседний вагон в соответствии со своим направлением движения. Если по окончании своего хода контролер заходит в 1-ый или n-ый вагон, то он меняет свое направление движения на противоположное. Другими словами — контролер циклически ходит от головы электрички до хвоста и обратно в течение всего времени игры, на каждом ходу сдвигаясь на один вагон. Заметим, что у контролера есть всегда есть ровно один допустимый ход.

Ход «зайца» зависит от того, в каком состоянии находится электричка. Если электричка движется, то «заяц» может перейти в один из соседних вагонов или же никуда не перемещаться. Если электричка на остановке, то «заяц» покидает электричку (то есть теперь не находится ни в одном из вагонов электрички) и затем, если остановка не конечная, заходит в электричку снова в любой из n вагонов (не обязательно в тот, из которого он только что вышел, и не обязательно в соседний для этого вагона). Если электричка стоит на остановке несколько минут, «заяц» покидает электричку и заходит в нее каждую минуту.

Определим очередность ходов игроков. Если в данную минуту электричка находится в движении — то сначала делает ход «заяц», а затем — контролер. Если в данную минуту электричка на остановке, то сначала «заяц» выходит из электрички, затем контролер делает ход, а затем «заяц» заходит в электричку.

Если в какой-то момент времени «заяц» и контролер оказываются в одном вагоне, то выигрывает контролер: он заставляет «зайца» выплатить штраф. Если через некоторое время «заяц» доезжает до конечной остановки — выигрывает «заяц»: своим ходом он просто выходит из электрички и более в нее не возвращается.

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

Входные данные

В первой строке находятся три целых числа n, m и k — количество вагонов в электричке, начальное положение «зайца» и контролера соответственно (2 ≤ n ≤ 50, 1 ≤ m, k ≤ n, m ≠ k).

Во второй строке задано направление движения контролера. «to head» означает, что контролер движется к голове электрички, «to tail» — что контролер движется к ее хвосту. Гарантируется, что в направлении движения контролера имеется хотя бы один вагон. Вагон 1 — это голова, вагон n — хвост.

Третья строка имеет длину от 1 до 200 и состоит из символов «0» и «1». i-ый символ содержит информацию о состоянии электрички в i-ую минуту времени. «0» означает, что в данную минуту электричка движется, «1» — что электричка в данную минуту стоит на остановке. Последний символ третьей строки всегда «1» — это конечная остановка.

Выходные данные

Если выигрывает «заяц» — выведите «Stowaway» без кавычек. Иначе выведите «Controller» опять же без кавычек, затем через пробел — номер минуты, на которой «заяц» будет пойман.

B. Польшар и Игра

Бинарный поиск жадные алгоритмы игры сортировки Строки Структуры данных *1100

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

Вам даны списки слов, известных Польшару и Врагошару. Определите, кто выиграет, если оба играют оптимально?

Входные данные

Первая строка содержит два целых числа n и m (1 ≤ n, m ≤ 103) — число слов, которые знают Польшар и Врагошар соответственно.

Затем следуют n строк, по одной в строке — слова, известные Польшару.

Затем следуют m строк, по одной в строке — слова, известные Врагошару.

Заметьте, что ни один из шаров не может знать слово больше одного раза (слова различны), но некоторые слова могут быть известны обоим игрокам.

Каждое слово непустое и состоит из не более чем 500 строчных букв латинского алфавита.

Выходные данные

В единственной строке выведите ответ: «YES», если выиграет Польшар, и «NO» иначе. Оба шара играют оптимально.

Примечание

В первом примере Польшар знает намного больше слов и выиграет без труда.

Во втором примере если Польшар скажет вначале kremowka, то Врагошар не сможет использовать это слово. Единственное, что может сделать Врагошар — сказать wiedenska. Польшар скажет wadowicka и выиграет.

E. Игра Камней

битмаски дп игры *2100

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

  • Игра начинается с n куч камней, пронумерованных от 1 до n. i-я куча содержит si камней.
  • Игроки делают ходы по очереди. Ход рассматривается, как удаление некоторого числа камней из кучи. Удаление 0 камней не считается ходом.
  • Игрок, который не может сделать ход, проигрывает.

Теперь Джон верит, что готов к бою, но Сэм так не думает. Чтобы доказать его аргумент, Сэм предлагает сыграть в модификацию игры.

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

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

Входные данные

Первая строка входных содержит единственное целое число n (1 ≤ n ≤ 106) — количество куч.

Каждая из следующих n строк содержит единственное целое число si (1 ≤ si ≤ 60) — количество камней в i-й куче.

Выходные данные

Выведите единственную строку, содержащую «YES» (без кавычек), если Джон выиграет, иначе выведите «NO» (без кавычек).

Примечание

В первом примере Сэм удаляет все камни и Джон проигрывает.

Во втором примере следующие ходы Сэма возможны:

В каждом из этих случаев Джон может сделать последний ход и выиграть:

C. Игра для бобров

дп игры теория чисел *2000

Бобры Тимур и Марсель играют в следующую игру.

Имеются n бревен, каждое длиной ровно m метров. Бобры делают ходы по очереди. За свой ход бобер выбирает одно из бревен и разгрызает его на некоторое количество (больше одной) равных частей, длина каждой из которых выражается целым числом и не меньше k метров. Каждая получившаяся часть в свою очередь тоже является бревном, которое в дальнейшем может быть разгрызено любым бобром. Проигрывает бобер, который не может сделать ход. Другой бобер, соответственно, выигрывает.

Тимур ходит первым. Игроки играют оптимально. Определите победителя.

Входные данные

В первой строке находятся три целых числа n, m, k (1 ≤ n, m, k ≤ 109).

Выходные данные

Выведите «Timur», если выигрывает Тимур или «Marsel», если выигрывает Марсель. Все нужно выводить без кавычек.

Примечание

В первом примере у бобров имеется только одно бревно, длина которого 15 метров. Тимур ходит первым. Единственный ход, который он может сделать — это разгрызть бревно на 3 части длиною 5 метров каждая. После этого ход Марселя, но он уже не может разгрызть ни одно из оставшихся бревен, так как k = 4. Поэтому победителем является Тимур.

Во втором примере у бобров имеется 4 бревна длины 9 метров. Тимур не может разгрызть ни одно из них, так чтобы оставшиеся части имели длину не меньше 5 метров, поэтому сразу проигрывает.

A. Берсерк

дп игры поиск в глубину и подобное *2000

Рик и Морти играют в свою собственную версию игры Берсерк (которая не имеет ничего общего с известной игрой Берсерк). Эта игра требует много пространства, поэтому они играют в нее на компьютере.

В этой игре есть n объектов, пронумерованных от 1 до n, расположенных в круг (по часовой стрелке). Объект номер 1 является черной дырой, а все остальные объекты являются планетами. Монстр находится на одной из планет. Рик и Морти ещё не знают на какой, только то, что он изначально не в черной дыре, но Юнити сообщит им положение монстра после начала игры. Но сейчас они хотят подготовиться к каждому возможному сценарию.

У каждого есть множество чисел, каждое из которых лежит между 1 и n - 1 (включительно). Множество Рика s1, имеющее k1 элементов, и множество Морти s2, имеющее k2 элементов. Один из них ходит первый, и игроки ходят поочередно. На каждом ходу игрок должен выбрать произвольное число x из своего множества, и монстр пойдет к x-му следующему объекту от его текущей позиции (по часовой стрелке). Если после его хода монстр попал в черную дыру, игрок выигрывает.

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

Входные данные

Первая строка входных данных содержит единственное целое число n (2 ≤ n ≤ 7000) — количество объектов в игре.

Вторая строка содержит целое число k1, за которым следует k1 различных целых чисел s1, 1, s1, 2, ..., s1, k1 — множество Рика.

Третья строка содержит целое число k2, за которым следует k2 различных целых чисел s2, 1, s2, 2, ..., s2, k2 — множество Морти.

1 ≤ ki ≤ n - 1 и 1 ≤ si, 1, si, 2, ..., si, ki ≤ n - 1 для всех 1 ≤ i ≤ 2.

Выходные данные

В первой строке выведите n - 1 слов, разделенных пробелом, где i-е слово равно «Win» (без кавычек), если в сценарии, в котором Рик начинает первым и монстр изначально на объекте номер i + 1, он выигрывает, «Lose», если он проигрывает, и «Loop», если игра никогда не закончится.

Подобным образом, во второй строке выведите n - 1 слов, разделенных пробелом, где i-е слово равно «Win» (без кавычек), если в сценарии, в котором Морти начинает первым, и монстр изначально на объекте номер i + 1, он выигрывает, «Lose», если он проигрывает, и «Loop», если игра никогда не закончится.

C. Название компании

жадные алгоритмы игры сортировки *1800

Клиент банка Олег и аналитик Игорь — хорошие друзья. Однако, иногда они спорят по мелочам. Недавно они основали новую компанию, но испытывают трудности с выбором названия для компании.

Чтобы разрешить спор, они решили сыграть в игру. Название компании будет состоять из n букв. У Олега и Игоря есть по одному набору из n букв (наборы могут содержать одну и ту же букву несколько раз, наборы могут отличаться). Изначально название компании состоит из n знаков вопроса. Олег и Игорь ходят по очереди, Олег ходит первым. На каждом ходу игрок выбирает одну букву c, имеющуюся у него в наборе, и заменяет один любой знак вопроса на эту букву c. Затем одна такая буква c исчезает из его набора. Игра оканчивается, когда все знаки вопроса заменены на какие-то буквы.

Например, предположим, у Олега есть набор букв {i, o, i}, а у Игоря есть набор букв {i, m, o}. Одна из возможных игр приведена ниже:

Изначально название компании равно ???.

Олег заменяет второй знак вопроса на «i». Название компании теперь ?i?. Набор букв Олега теперь равен {i, o}.

Игорь заменяет третий знак вопроса на «o». Название компании теперь ?io. Набор букв Игоря теперь равен {i, m}.

Наконец, Олег заменяет первый знак вопроса на «o». Название компании теперь oio. Набор букв Олега равен {i}.

В итоге название компании равно oio.

Олег хочет, чтобы название компании было лексикографически как можно меньше, а Игорь хочет, чтобы название компании было лексикографически как можно больше. Каким будет название компании, если Олег и Игорь играют оптимально?

Строка s = s1s2...sm лексикографически меньше строки t = t1t2...tm (если s ≠ t), если si < ti, где i — наименьший индекс такой, что si ≠ ti (т.е. sj = tj для всех j < i).

Входные данные

Первая строка содержит строку s длины n (1 ≤ n ≤ 3·105). Все символы строки — строчные латинские буквы. Строка описывает множество букв в наборе Олега.

Вторая строка содержит строку t длины n. Все символы строки — строчные латинские буквы. Строка описывает множество букв в наборе Игоря.

Выходные данные

Выведите строку из n строчных латинских букв — название компании при условии, что Олег и Игорь играют оптимально.

Примечание

Одна из оптимальных игр в первом примере:

  • Изначально название компании равно ???????.
  • Олег заменяет первый знак вопроса на «f». Название компании становится f??????.
  • Игорь заменяет второй знак вопроса на «z». Название компании становится fz?????.
  • Олег заменяет третий знак вопроса на «f». Название компании становится fzf????.
  • Игорь заменяет четвертый знак вопроса на «s». Название компании становится fzfs???.
  • Олег заменяет пятый знак вопроса на «i». Название компании становится fzfsi??.
  • Игорь заменяет шестой знак вопроса на «r». Название компании становится fzfsir?.
  • Олег заменяет седьмой знак вопроса на «k». Название компании становится fzfsirk.

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

E. Выбор морковки

игры математика *2800

Обычный клиент банка Олег и аналитик Игорь опять спорят. На этот раз они выбирают подарок их другу программисту ZS. После долгих раздумий они решили. что их друг очень любит морковки, поэтому они хотят выбрать лучшую морковку в качестве подарка.

В ряд расположены n морковок. Морковка на позиции i слева имеет сочность ai. Олег думает, что ZS любит сочные морковки, а Игорь считает, что он ненавидит сочные морковки. Поэтому Олег хочет максимизировать сочность морковки, которую они выберут, а Игорь хочет минимизировать сочность морковки, которою они выберут.

Чтобы не разругаться, они опять решили сыграть в игру. Олег и Игорь будут ходить по очереди, первым будет ходить Олег. На каждом ходу игрок может взять одну морковку с любого конца ряда и съесть ее. Игра закончится, как только останется одна морковка. Она и будет той морковкой, которую они дадут своему другу ZS.

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

Олегу стало интересно: для всех k таких, что 0 ≤ k ≤ n - 1, какова сочность морковки, которую они подарят ZS, если он сделает k ходов заранее, и оба игрока действуют оптимально?

Входные данные

В первой строке содержится одно целое число n (1 ≤ n ≤ 3·105) — количество морковок в ряду.

Вторая строка содержит n целых чисел a1, a2, ..., an (1 ≤ ai ≤ 109). Число ai обозначает сочность i-й морковки слева.

Выходные данные

Выведите n целых чисел x0, x1, ..., xn - 1. Число xi должно быть сочностью морковки, которые друзья подарят ZS, если k = i.

Примечание

Рассмотрим первый пример.

Если k = 0, то одна из оптимальных игр выглядит так:

  • Олег съедает морковку с сочностью 1.
  • Игорь съедает морковку с сочностью 5.
  • Олег съедает морковку с сочностью 2.
  • Остается морковка с сочностью 3.

Если k = 1, то одна из оптимальных игр выглядит так:

  • Олег съедает морковку с сочностью 1 заранее.
  • Олег съедает морковку с сочностью 2.
  • Игорь съедает морковку с сочностью 5.
  • Остается морковка с сочностью 3.

Если k = 2, то одна из оптимальных игр выглядит так:

  • Олег съедает морковку с сочностью 1 заранее.
  • Олег съедает морковку с сочностью 2 заранее.
  • Олег съедает морковку с сочностью 3.
  • Остается морковка с сочностью 5.

Если k = 3, то одна из оптимальных игр выглядит так:

  • Олег съедает морковку с сочностью 1 заранее.
  • Олег съедает морковку с сочностью 2 заранее.
  • Олег съедает морковку с сочностью 3 заранее.
  • Остается морковка с сочностью 5.

Таким образом, ответ равен 3, 3, 5, 5.

Во втором примере Олег всегда может съесть морковку с сочностью 1, так как он ходит первым. Поэтому сочность оставшейся морковки всегда равна 1000000000.

E. Сахир и дерево с яблоками

Деревья игры *2300

Сахир играет со своим лучшим другом Солиманом. Он принес дерево из n вершин, пронумерованных от 1 до n, корнем дерева является вершина 1. Вершина номер i изначально содержит ai яблок. У дерева есть особенность: длина всех путей от корня к любому из листьев имеет одну и ту же четность (т.е. все пути имеют четную длину, или все пути имеют нечетную длину).

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

На каждом ходу текущий игрок выберет одну из вершин, возьмет ненулевое количество яблок из нее и сделает одно из следующих действий:

  1. съест эти яблоки, если вершина — лист.
  2. переместит все эти яблоки в одного из сыновей выбранной вершины, если эта вершина не является листом.

Перед тем, как Солиман сделает первых ход, Сахир сделает ровно одно изменение в дереве. А именно, он выберет две различные вершины u и v и поменяет местами яблоки в вершине u и в вершине v.

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

Входные данные

Первая строка содержит одно целое число n (2 ≤ n ≤ 105) — количество вершин в дереве.

Вторая строка содержит n целых чисел a1, a2, ..., an (1 ≤ ai ≤ 107) — количество яблок в каждой из вершин дерева.

Третья строка содержит n - 1 целое число p2, p3, ..., pn (1 ≤ pi ≤ n) — родителей вершин в дереве. Вершина i имеет родителя pi (для 2 ≤ i ≤ n). Вершина 1 является корнем дерева.

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

Выходные данные

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

Примечание

В первом примере Сахир может выиграть только если он поменяет яблоки в вершине 1 с яблоками в вершине 3. В таком случае в обоих листьях будет по 2 яблока. Если Солиман сделает ход в листе, то Сахир сделает такой же ход в другом листе. Если Солиман передвинет яблоки из корня, то Сахир съест эти яблоки. Когда-нибудь у Солимана не будет хода.

Во втором примере нет такого изменения, чтобы Сахир выиграл.

Заметьте, что Сахир должен сделать изменение, даже если он выигрывает с изначальным деревом.

A. Мистер Б и скучная игра

жадные алгоритмы игры *2200

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

Свободными вечерами Мистеру Б иногда нечем заняться, потому он ищет различные игры в интернете. И вот в один день он нашел интересную игру, в которой предлагалось сыграть против инопланетян.

Все символы в данной игре — строчные буквы английского алфавита. В данной игре участвуют два игрока: Мистер Б и его соперник.

Первоначально игрокам задана строка s из a первых символов английского алфавита в алфавитном порядке (при a = 5, например, строка s выглядит следующим образом: «abcde»).

Далее каждый игрок по очереди дописывает в конец строки s по несколько букв. Первым ходом ходит Мистер Б.

Мистер Б может добавить в конец строки ровно b произвольных букв. Его противник — ровно a букв.

Мистер Б быстро догадался, что его противник — никакой не инопланетянин, а компьютер, действующий по простой программе. Компьютер на очередном своем шаге рассматривает суффикс из последних a символов строки s и для своего хода выбирает строку t длины a такую, что все символы в t попарно различны, никакой из символов строки не встречается в рассматриваемом суффиксе, и из всех возможных вариантов t — лексикографически минимальный (при a = 4 и суффиксе «bfdd» компьютер выберет строку t, равную «aceg»). Далее выбранную строку t компьютер просто добавляет в конец строки s.

Мистеру Б уже надоело играть с компьютером, а потому его заинтересовал вопрос: какое минимальное количество различных символов могло быть в строке s на отрезке с символа номер l по символ номер r, включительно. Символы строки s нумеруется слева направо, начиная с 1.

Входные данные

В первой и единственной строке задано четыре натуральных числа через пробел: a, b, l и r (1 ≤ a, b ≤ 12, 1 ≤ l ≤ r ≤ 109) — количество букв, которые добавляют каждый из игроков, и границы интересующего Мистера Б отрезка, соответственно.

Выходные данные

Выведите единственное число — минимально возможное количество различных символов в отрезке с символа номер l по символ номер r в строке s.

Примечание

В первом примере одной из оптимальных стратегий будет такая, при которой s = "abababab...", поэтому ответ равен 2.

Во втором примере может быть получена строка s = "abcdbcaefg...", нужный отрезок имеет вид "bcdbc", поэтому ответ равен 3.

В третьем примере может быть получена строка s = "abczzzacad...", нужный отрезок имеет вид "zzz", поэтому ответ равен 1.

A. Саша и палочки

игры математика *800

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

Как-то раз на очередном уроке Саше стало скучно и он решил сыграть со своей соседкой по парте, Леной, в одну игру, правила которой очень просты. Саша рисует на бумаге n палочек. После этого каждый из ребят по очереди зачёркивает k идущих подряд палочек, имея возможность сделать это как справа, так и слева. Саша, как создатель игры, всегда делает ход первым. Если перед ходом кого-то из игроков палочек на бумаге останется строго меньше, чем k, игра прекращается. Саша считает, что он победил, если он сделал строго больше ходов, чем его соседка. Саша очень не любит ждать, поэтому просит вас определить, выиграет он, или нет.

Входные данные

В первой строке входных данных через пробел записаны два целых числа n и k (1 ≤ n, k ≤ 1018, k ≤ n) — количество палочек, которые нарисовал Саша и число k — количество подряд идущих палочек, которые ребята могут зачеркивать.

Выходные данные

Если Саша выиграет, выведите «YES» (без кавычек), иначе «NO» (без кавычек).

Вы можете выводить каждую из букв в любом регистре.

Примечание

Пояснение в первому примеру: Саша вычеркивает 1 палочку, после чего палочек не остается и его соседка не может сделать ход, то есть проигрывает.

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

C. Будущий проигрыш

дп игры *2800

Алиса и Боб играют в игру со строкой символов, они ходят по очереди, первой ходит Алиса. Строка состоит из n символов, каждый из них является одним из первых k символов алфавита. На своем ходу игрок может либо произвольным образом перемешать символы в строке, либо удалить из строки ровно один символ (если в строке есть хотя бы один символ). Кроме того, результирующая строка не может совпадать ни с одной строкой, встречавщейся ранее в игре. Игрок, который не может сделать корректный ход, проигрывает.

По данным n, k, p найдите число строк длины n, состоящих из первых k символов алфавита таких, что Алиса выиграет, если и Алиса, и Боб играют оптимально. Выведите это число по простому модулю p.

Входные данные

Первая строка содержит три целых числа n, k, p (1 ≤ n ≤ 250 000, 1 ≤ k ≤ 26, 108 ≤ p ≤ 109 + 100, p простое).

Выходные данные

Выведите одно целое число — число выигрышных для Алисы строк по модулю p.

Примечание

Выигрышными для Алисы являются 14 строк. Среди них строки «bbaa» и «baaa». Алиса проиграет на строках «aaaa» или «bbbb».

B. Находка

игры математика *1100

Леха как-то нашёл массив состоящий из n целых чисел. Посмотрев на него он придумал эту задачу. Два игрока играют в игру на массиве. Игроки ходят по очереди. Первый игрок может за свой ход выбрать подотрезок ненулевой длины с нечётной суммой чисел и удалить его из массива, после этого оставшиеся части склеиваются в один массив и игра продолжается. Второй игрок может выбрать подотрезок ненулевой длины с чётной суммой и удалить его. Проигрывает тот кто не может сделать ход. Кто победит, если оба играют оптимально?

Входные данные

В первой строке входных данных содержится единственной число n (1 ≤ n ≤ 106) — длина массива.

Следующая строка содержит n целых чисел a1, a2, ..., an (0 ≤ ai ≤ 109) — найденный массив.

Выходные данные

Ответ в единственной строке. «First», если победит первый игрок, и «Second» иначе (без кавычек).

Примечание

В первом примере первый игрок сразу забирает весь массив и побеждает.

Во втором примере первый игрок изначально не может сделать ход и проигрывает.

C. Арпа и игра с Можтабой

битмаски дп игры *2200

Можтаба и Арпа играют в игру. У них есть список из n чисел.

На каждом ходу игрок может выбрать целое число pk (где p простое, а k — положительное целое) такое, что pk делит хотя бы одно число в списке. Затем для каждого числа в списке, делящегося на pk, обозначим его x, игрок удалит из списка число x и добавит в список. Игрок, который не может сделать корректного выбора числа p и k проигрывает.

Можтаба начинает, и игроки по-очереди делают ходы. Определите, кто выиграет, если оба игрока играют оптимально.

Входные данные

Первая строка содержит одно целое число n (1 ≤ n ≤ 100) — число элементов с списке.

Вторая строка содержит n целых чисел a1, a2, ..., an (1 ≤ ai ≤ 109) — элементы списка.

Выходные данные

Если выиграет Можтаба, выведите «Mojtaba», иначе выведите «Arpa» (без кавычек).

Вы можете вывести каждую из букв в любом регистре (строчную или заглавную).

Примечание

В первом примере Можтаба сразу не может сделать ход.

Во втором примере Можтаба выберет p = 17 и k = 1, и список примет вид [1, 1, 1, 1].

В третьем примере если Можтаба выберет p = 17 и k = 1, то Арпа выберет p = 17 и k = 1 и выиграет, а если Можтаба выберет p = 17 и k = 2, то Арпа выберет p = 17 и k = 1 и выиграет.

C. Правило торта

дп игры *1500

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

Они решили разделить кусочки следующим образом. Сначала они определили порядок, в котором кусочки будут распределены. У них есть специальная фишка, называемая «решающий», изначально она находится у Боба. Пока не все кусочки распределены, тот, у кого находится фишка, дает очередной кусочек пирога по своему усмотрению одному участнику дележа, а фишку — другому. Так продолжается, пока все кусочки не будут распределены.

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

Входные данные

В первой строке находится одно целое число N (1 ≤ N ≤ 50) — количество кусочков пирога.

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

Выходные данные

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

Примечание

В первом примере Боб должен взять кусок размера 141 себе и отдать фишку Алисе. Затем Алиса отдаст кусочек размера 592 Бобу, а фишку оставит себе, чтобы забрать себе кусочек размера 653.

C. Интересная игра

дп игры математика *2000

Два лучших друга Сережа и Гена играют в игру.

Изначально на столе находится одна кучка из n камней. За один ход нужно взять одну кучку и разбить ее на произвольное число кучек размерами a1 > a2 > ... > ak > 0 камней так, что a1 - a2 = a2 - a3 = ... = ak - 1 - ak = 1. Естественно, количество кучек k должно быть не меньше двух.

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

Входные данные

В единственной строке записано одно целое число n (1 ≤ n ≤ 105).

Выходные данные

Если выигрывает Сережа, выведите k — минимальное число кучек, на которое он может разбить исходную первым ходом при выигрышной стратегии.

Если выигрывает Гена, выведите «-1» (без кавычек).

B. Айсея играет с Ктолли

Бинарный поиск жадные алгоритмы игры интерактив Конструктив *2000

Это интерактивная задача. Обратитесь к секции «Протокол взаимодействия» для лучшего понимания.

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

Изначально Айсея выкладывает n листов бумаги в ряд. Они пронумерованы от 1 до n слева направо.

Во время игры будет проведено m раундов. В каждом раунде Айсея даст Ктолли целое число от 1 до c и Ктолли будет должена записать это число на одном из листов бумаги (если на этом листе уже было записано число, Ктолли сотрёт его и запишет на его месте новое).

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

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

Гарантируется, что ходы Айсея выбраны заранее и что они не зависят от ходов вашей программы.

Входные данные

В первой строке содержатся три целых числа n, m и c (, означает число , округленное вверх) — количество листов бумаги, количество раундов и максимальное число, которое Айсея может сказать Ктолли, соответственно. Остальная часть ввода описана в разделе «Протокол взаимодействия».

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

Во время каждого раунда ваша программа должна считать одно целое число pi (1 ≤ pi ≤ c), которое обозначает число, названное Айсеей.

Ваша программа должна вывести в новой строке одно целое число от 1 до n, обозначающее номер листа, на который необходимо записать число.

После вывода каждой строки не забудьте сбросить буфер вывода. Например:

  • fflush(stdout) в C/C++;
  • System.out.flush() в Java;
  • sys.stdout.flush() в Python;
  • flush(output) в Pascal;
  • Обратитесь к документации для других языков программирования.

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

Примечание

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

Затем Айсея называет число 2 и Ктолли записывает его на лист с номером 1. После этого Айсея называет число 1 и записывает на лист с номером 2. Наконец, Айсея называет число 3, после чего Ктолли заменяет число 1 на число 3 на листе с номером 2 и выигрывает, так как на каждом листе записано какое-то число и они упорядочены по неубыванию слева направо.

Обратите внимание, что Ваша программа должна немедленно завершиться после победы Чтолли и не должна читать числа из входного потока для последующих раундов. В противном случае вердикт программы не определён. В частности, учитывайте этот факт при взломах чужих решений. В тестовом примере Ктолли выиграла после раунда 3, поэтому требуется, чтобы Ваша программа не считывала число для раунда 4.

Формат ввода для взломов:

  • В первой строке записаны 3 целых числа n, m и c;
  • В последующих m строках записаны целые числа от 1 до c, обозначающие число, произнесённое Ктолли во время каждого раунда.

B. Конан и Агаса играют в карточную игру

жадные алгоритмы игры реализация *1200

Эдогава Конан устал разбираться со своими делами и пригласил своего друга, профессора Агасу, в гости. Они решили сыграть в карточную игру. У Конана есть n карт, на i-й из которых записано число ai.

Игроки ходят по очереди, первым ходит Конан. На каждом ходу игрок выбирает карту и выбрасывает её. Кроме того, он выбрасывает все карты, на которых число меньше, чем на выбранной. Формально, если игрок выбирает карту с номером i, он выбрасывает эту карту, а также все карты с номерами j для всех j таких, что aj < ai.

Игрок проигрывает, если он не может сделать ход, то есть если не осталось карт. Определите победителя, если игроки играют оптимально.

Входные данные

В первой строке задано целое число n (1 ≤ n ≤ 105) — количество карт Конана.

Во второй строке содержатся n целых чисел a1, a2, ..., an (1 ≤ ai ≤ 105), где ai обозначает число, записанное на карте с номером i.

Выходные данные

Если победит Конан, выведите "Conan" (без кавычек), иначе выведите "Agasa" (без кавычек).

Примечание

В первом тестовом примере Конан может выбрать карту с числом 7 и тем самым выкинуть все карты. После этого Агаса проиграет.

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

H. Деревянная игра Эмбера и Шторма

Деревья дп игры Комбинаторика *3400

Эмбер и Шторм играют в игру. Вначале, Эмбер выбирает помеченное дерево T на n вершинах, такое что степень каждой вершины не превосходит d. Затем Шторм выбирает две различные вершины u и v в этом дереве и выписывает номера вершин на пути из u в v как последовательность a1, a2... ak. Наконец Эмбер выбирает произвольный индекс i (1 ≤ i < k) и выполняет одну из следующих операций ровно один раз:

  • перевернуть подотрезок [i + 1, k] и прибавить ai ко всем числам на нём. После этого последовательность приобретает вид a1, ... ai, ak + ai, ak - 1 + ai, ... ai + 1 + ai
  • Заменить все числа на подотрезке [i + 1, k] на противоположные и прибавить ai к ним. После этого последователньость приобретает вид a1, ... ai,  - ai + 1 + ai,  - ai + 2 + ai, ... - ak + ai

Эмбер выигрывает, если после произведённой операции массив монотонно возрастает или убывает, иначе выигрывает Шторм.

Игра может быть представлена набором (T, u, v, i, op), где op — это «перевернуть» или «выполнить отрицаение» в зависимости от действия, которое Эмбер выполнил на последнем шаге. Найдите количество наборов, которые могут образоваться в результате оптимальной игры Эмбера и Шторма. Если они играют оптимально и у игрока есть несколько ходов, которые гарантируют победу, игрок может воспользоваться любым из них. Также если у игрока нет ни одного хода, гарантирующего победу, он может воспользоваться любым ходом.

Выведите ответ по модулю m.

Входные данные

В первой строке задано три целых числа n, d и m (2 ≤ n ≤ 200, 1 ≤ d < n, 1 ≤ m ≤ 2·109).

Выходные данные

Выведите единственное число — количество возможных наборов по модулю m.

Примечание

В первом тестовом примере существует только одно возможное дерево. Можно выбрать два пути: из 1 в 2 и из 2 в 1. Для обоих путей i может быть равно только 1, а op может принимать оба возможных значения. Поэтому ответ равен 4.

Во втором тестовом примере подходящих деревьев нет.

В третьем тестовом примере есть три возможных дерева.

B. Безумная Макс

графы дп игры поиск в глубину и подобное *1700

Как мы все знаем, Макс лучше всех играет в компьютерные игры. Ее друзья настолько ей завидуют, что придумали игру в реальном мире, чтобы показать, что она не во всех играх лучшая. Игра проходит на ориентированном ациклическом графе с n вершинами и m ребрами. На каждом ребре написан символ — строчная латинская буква.

Играют Макс и Лукас. Первой ходит Макс, потом ходит Лукас, затем снова Макс и так далее. У каждого игрока есть камешек, изначально расположенный в некоторой вершине. Каждый игрок в свой ход должен передвинуть свой камешек вдоль одного ребра (игрок может передвинуть камешек из вершины v в вершину u, если есть ребро из вершины v в u). Если игрок передвигает камешек из вершины v в вершину u, то «символом» этого раунда называется символ, написанный на ребре из v в u. Есть одно дополнительное правило: ASCII код символа раунда i должен быть не меньше, чем ASCII код символа раунда i - 1 (для i > 1). Раунды нумеруются для всех игроков вместе, иными словами, Макс ходит в нечетных раундах, в Лукас — в четных. Игрок, который не может сделать ход, проигрывает. Камешки могут находиться в одной вершине в одно и то же время.

Поскольку игра занимает некоторое время, а Лукас и Макс должны найти Дарта, у них нет времени для игр. Они спрашивают у вас, кто выиграет, если оба будут играть оптимально?

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

Входные данные

Первая строка содержит два целых числа n и m (2 ≤ n ≤ 100, ).

Следующие m строк содержат ребра. Каждая строка содержит два целых числа v, u и строчную латинскую букву c (1 ≤ v, u ≤ n, v ≠ u), которые означают, что есть ребро из вершины v в u, и на нем написана буква c. Между каждой парой вершин есть не более одного ребра. Гарантируется, что в графе нет циклов.

Выходные данные

Выведите n строк, в каждой по n символов. j-й символ в i-й строке должен быть «A», если Макс побеждает в игре, где ее камешек изначально в вершине i, а камешек Лукаса — в вершине j, и «B» иначе.

Примечание

Граф из первого примера показан на рисунке ниже:

Граф из второго примера показан на рисунке ниже:

F. Игра с числами

графы игры кратчайшие пути *2600

Представим, что Алиса играет в карточную игру со своим другом Бобом. У каждого из них есть ровно \(8\) карт, и на каждой карте есть целое число от \(0\) до \(4\). На каждом ходу Алиса или Боб по очереди выбирают две карты, по одной у каждого, пусть это будут карты \(a\) и \(b\), где \(a\) — число на карте игрока, совершающего ход, а \(b\) — число на карте соперника. Необходимо, чтобы \(a \cdot b \ne 0\). Затем игрок вычислает \(c = (a + b) \bmod 5\) и заменяет число \(a\) на \(c\). Игрок, который первым получит \(0\) на всех своих \(8\) картах, побеждает.

Теперь Алиса хочет узнать, кто выигрывает при каких начальных условиях. Она даст вам числа на ее картах, числа на картах Боба, и кто будет ходить первым. Ваша задача — узнать, кто выигрывает, если оба играют оптимально.

Входные данные

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

Далее описываются эти \(T\) ситуаций. Для каждой ситуации:

  • Первая строка содержит неотрицательное число \(f\) (\(0 \leq f \leq 1\)), где \(f = 0\) означает, что Алиса ходит первой, а \(f = 1\) означает, что первым ходит Боб.
  • Вторая строка содержит \(8\) неотрицательных целых чисел \(a_1, a_2, \ldots, a_8\) (\(0 \leq a_i \leq 4\)), описывающих карты Алисы.
  • Третья строка содержит \(8\) неотрицательных целых чисел \(b_1, b_2, \ldots, b_8\) (\(0 \leq b_i \leq 4\)), описывающих карты Боба.

Гарантируется, что, если \(f=0\), то \(\sum_{i=1}^{8}a_i \ne 0\). Если \(f=1\), то \(\sum_{i=1}^{8}b_i \ne 0\).

Выходные данные

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

  • «Alice» (без кавычек), если выигрывает Алиса.
  • «Bob» (без кавычек), если выигрывает Боб.
  • «Deal» (без кавычек), если никто не сможет выиграть.
Примечание

В первой ситуации у Алисы на всех картах нули \(0\). Она мгновенно выигрывает.

Во второй ситуации Боб выбирает числа \(4\) и \(1\). Так как \((4 + 1) \bmod 5 = 0\), Боб выигрывает после этого хода.

В третьей ситуации, Алиса выбирает числа \(1\) и \(4\). Она выигрывает после этого хода.

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

D. Игра с фишками

игры реализация Структуры данных *2500

Рассмотрим следующую игру для двух игроков. Есть одна белая фишка и ненулевое количество черных фишек. Каждая фишка расположена на координатной плоскости в точке с целыми координатами x и y.

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

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

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

Входные данные

Первая строка содержит одно целое число n (1 ≤ n ≤ 105) — количество черных фишек.

В (i + 1)-й строке находятся два целых числа xi, yi ( - 105 ≤ xi, yi,  ≤ 105) — координаты точки, в которой стоит i-я черная фишка изначально.

Гарантируется, что все начальные позиции черных фишек различны.

Выходные данные

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

Примечание

В первом и втором тесте черными кругами обозначены положения черных фишек, белыми кругами — возможные положения белых фишек, при которых выигрывают черные.

Первый тест:

Второй тест:

В третьем тесте белые фишки должны располагаться во внутреннем квадрате 2 × 2, чтобы выиграли черные.

A. Совместимая пара

игры Перебор *1400

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

У Маленького Томми есть n фонарей, а у Большого Банбана — m фонарей. Фонари Томми имеют яркости a1, a2, ..., an, а фонари Банбана — b1, b2, ..., bm, соответственно.

Томми хочет спрятать один из фонарей, а затем Банбан выберет один из не спрятанных фонарей Томми, и один свой фонарь. Яркость пары фонарей будет равна произведению яркости двух выбранных фонарей.

Томми хочет, чтобы это произведение было как можно меньше, а Банбан хочет, чтобы произведение было как можно больше.

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

Входные данные

Первая строка содержит два целых числа n и m (2 ≤ n, m ≤ 50).

Вторая строка содержит n целых чисел a1, a2, ..., an.

Третья строка содержит m целых чисел b1, b2, ..., bm.

Все числа находятся в пределах от  - 109 до 109.

Выходные данные

Выведите одно число — яркость итоговой пары.

Примечание

В первом примере Томми спрячет фонарь с яркостью 20, а Банбан выберет фонарь Томми с яркостью 18, и свой фонарь с яркостью 14.

Во втором примере Томми спрячет фонарь с яркостью 3, а Банбан выберет фонарь с яркостью 2 от Томми, и свой фонарь с яркостью 1.

D. Сонная игра

графы игры поиск в глубину и подобное *2100

Петя и Вася договорились сыграть в свою любимую игру. Игра проходит по следующим правилам. У игроков есть ориентированный граф с n вершинами и m рёбрами, в одной из вершин которого стоит фишка. Изначально она находится в вершине s. Игроки по очереди перемещают фишку, за каждый ход передвигая её вдоль ребра графа. Первым ходит Петя. Игрок, который не может совершить ход, проигрывает. Если игра продолжается 106 ходов, объявляется ничья.

В ночь перед игрой Васе нужно было выполнить большую лабораторную работу по предмету «Орфография и части речи», поэтому, как только началась игра, он уснул. Петя решил воспользоваться ситуацией и делать ходы как за себя, так и за Васю.

Помогите Пете понять, может ли он выиграть, или хотя бы сыграть вничью.

Входные данные

В первой строке входных данных содержатся два целых числа n и m — число вершин и число рёбер в графе соответственно (2 ≤ n ≤ 105, 0 ≤ m ≤ 2·105).

В следующих n строках содержится информация о рёбрах графа. В i-й строке (1 ≤ i ≤ n) записано целое неотрицательное число ci — количество вершин, в которые есть рёбра из вершины i, а затем ci различных целых чисел ai, j — номера этих вершин (1 ≤ ai, j ≤ n, ai, j ≠ i).

Гарантируется, что сумма всех ci равна m.

В следующей строке содержится номер вершины s — изначальной позиции фишки (1 ≤ s ≤ n).

Выходные данные

Если Петя может выиграть, в первой строке выведите «Win». В следующей строке выведите числа v1, v2, ..., vk (1 ≤ k ≤ 106) — последовательность вершин, которые должен посетить Петя для победы. Вершина v1 должна совпадать с s. Для i = 1... k - 1 в графе должно быть ребро из вершины vi в вершину vi + 1. Последовательность должна быть такова, что из вершины vk нет хода, и при такой игре проигрывает именно Вася, а не Петя.

Если Петя не может выиграть, но может сыграть вничью, в единственной строке выведите «Draw». Иначе выведите «Lose».

Примечание

В первом примере игра происходит на следующем графе:

Изначально фишка находится в вершине 1. Первым ходом Петя передвигает фишку в вершину 2, затем он ходит за Васю в вершину 4. После чего опять за себя в вершину 5. Теперь ход Васи, но ему некуда ходить, поэтому Петя выиграл.

Во втором примере игра происходит на следующем графе:

Изначально фишка находится в вершине 2. Петя может сходить только в вершину 1. После этого он вынужден сходить за Васю в вершину 3. Теперь ход Пети, но ему некуда ходить, поэтому Петя проиграл.

В третьем примере игра происходит на следующем графе:

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

A. Махмуд, Эхаб и игра в четное-нечетное

игры математика *800

Махмуд и Эхаб играют в игру, которую они называют игрой в четное-нечетное. Эхаб выбирает его любимое положительное целое число n, после чего они ходят по очереди. Первый ход делает Махмуд. Каждый игрок в свой ход должен уменьшить n на целое число a, выбранное этим игроком, такое, что:

  • 1 ≤ a ≤ n.
  • Если ходит Махмуд, a должно быть чётным, а если ходит Эхаб, a должно быть нечётным.

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

Входные данные

В единственной строке находится целое число n (1 ≤ n ≤ 109) — число, выбранное Эхабом в начале игры.

Выходные данные

Выведите «Mahmoud» (без кавычек), если победит Махмуд и «Ehab» (без кавычек) в противном случае.

Примечание

В первом примере Махмуд изначально не может выбрать ни одного целого числа a, поскольку нету положительных целых чётных чисел, меньше или равных 1, поэтому победит Эхаб.

Во втором примере, Махмуд обязан выбрать a = 2 и вычесть его из n. Теперь ход Эхаба и n = 0. Не существует положительных целых нечётных чисел, меньших или равных 0, поэтому Махмуд победит.

E. Помогите Крокодилу Гене

дп игры математика Теория вероятностей *2700

Крокодил Гена и Чебурашка (как вы, наверное, догадались, тоже обитатели Тридевятого царства, Тридесятого государства) решили сыграть в карточную игру под названием ЕОИгра. Правила очень просты: изначально у Крокодила Гены в руках m карт, у Чебурашки — n карт (игроки не видят карты друг друга), и еще одна карта лежит на столе рубашкой вверх, так что оба игрока тоже не видят ее. Таким образом, всего в начале игры m + n + 1 карта, и игроки знают состав колоды и свои карты (но не знают, какая карта лежит на столе, а какие –– в руках у другого игрока). Игроки ходят по очереди, начинает Крокодил Гена. Своим ходом игрок может:

  • Попытаться угадать карту, которая лежит на столе. В случае если он угадывает — игра заканчивается, и он считается победителем. Если он не угадывает — игра также заканчивается, но победителем считается его соперник.
  • Назвать любую карту из колоды. В случае если у соперника есть такая карта — он обязан показать ее и вывести из игры. Если же у него нет такой карты — он сообщает об этом.
Недавно Чебурашка стал принимать какие-то желтые таблеточки, и постоянно выигрывать у Крокодила Гены. Теперь Крокодил Гена хочет определить свои шансы на победу в случае, если и он тоже начнет принимать эти таблеточки.

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

Входные данные

В первой строке через пробел записаны целые числа m и n (0 ≤ m, n ≤ 1000).

Выходные данные

Выведите через пробел вероятности победы Крокодила Гены и Чебурашки соответственно, с абсолютной погрешностью не более 10 - 9.

C. Постеризация

жадные алгоритмы игры *1700

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

Этот алгоритм будет тестироваться на массиве целых чисел, в котором \(i\)-е число обозначает цвет \(i\)-го пикселя в изображении. Изображение чёрно-белое, поэтому цвет каждого пикселя будет целым числом между 0 и 255 (включительно).

Для реализации алгоритма фильтра студенты должны разделить чёрно-белую гамму [0, 255] на группы последовательных цветов и выбрать в каждой группе один ключевой цвет. Для сохранения деталей изображения размер каждой группы не может быть больше \(k\) и каждый цвет должен принадлежать ровно одной группе. После этого студенты должны заменить цвет каждого пикселя в массиве на ключевой цвет группы, в которую он входит.

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

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

Входные данные

В первой строке ввода содержится два целых числа \(n\) и \(k\) (\(1 \leq n \leq 10^5\), \(1 \leq k \leq 256\)) — число пикселей в изображении и максимальный размер группы цветов соответственно.

Вторая строка содержит \(n\) целых чисел \(p_1, p_2, \dots, p_n\) (\(0 \leq p_i \leq 255\)), где \(p_i\) — цвет \(i\)-го пикселя.

Выходные данные

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

Примечание

Один из возможных методов выбора групп и ключевых цветов для первого примера таков:

Цвет \(2\) принадлежит группе \([0,2]\) с ключевым цветом \(0\).

Цвет \(14\) принадлежит группе \([12,14]\) с ключевым цветом \(12\).

Цвета \(3\) и \(4\) принадлежат группе \([3, 5]\) с ключевым цветом \(3\).

Остальные группы не повлияют на результат, поэтому они не выписаны.

Разбираем задачу про MEX

жадные алгоритмы игры

Palindrome Game

игры

Беси и Эльза играют в игру с кучей камней. Изначально в ней \(S\) камней (\(1\le S<10^{10^5}\)). Коровы делают ходы по очереди, Беси начинает. В свой ход корова должна убрать из кучи \(x\) камней, где \(x\) - любое положительное целое число, которое является палиндромом. Если ход коровы, а куча пуста, эта корова проиграла.

Определение: Положительное целое число является палиндромом, если оно читается одинаково от начала к концу и от конца к началу, например 1, 121, 9009. Лидирующие нули нельзя опускать. Поэтому 990 не палиндром.

Всего имеется \(T\) (\(1\le T\le 10\)) независимых подтестов в каждом тесте. Для каждого подтеста выведите имя коровы, которая победит, если обе играют оптимально.

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

Первая строка содержит \(T\), количество подтестов. Следующие \(T\) строк описывают подтесты, по одной строке на каждый подтест.

Каждый подтест содержит одно целое число \(S\).

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

Для каждого подтеста на отдельной строке выведите B, если выиграет Беси, E - Эльза - при оптимальной игре обоих игроков.

Cake Game

игры

Беси и Эльза нашли ряд из \(N\) пирожных \((2 \leq N \leq 5\cdot 10^5, N \text{ четное})\), с размерами \(a_1,a_2,\dots,a_N\) в таком порядке (\(1\le a_i\le 10^9\)).

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

  1. Беси выбирает два соседних пирожных и ставит одно из них на другое, создавая новое пирожное, размером равным сумме размеров этих пирожных.
  2. Эльза выбирает либо самое левое пирожное, либо самое правое пирожное и кладёт себе в тайник.

Когда остаётся только одно пирожное Беси съедает его, а Эльза съедает все пирожные из своего тайника. Если обе коровы играют оптимально, и Беси начинает первой, сколько пирожных съест каждая корова?

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

Каждый ввод состоит \(T\) (\(1\le T\le 10\)) независимых подтестов. Гарантируется, что сумма всех \(N\) на вводе не превысит \(10^6\).

Каждый подтест сформатирован следующим образом. Первая строка содержит \(N\). Следующая строка содержит \(N\) разделённых одиночными пробелами целых чисел \(a_1,a_2,\ldots,a_N\).

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

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

Circular Barn

игры

Фермеры Джон и Нхой играют в игру в круглом амбаре. В этом амбаре имеется \(N\) (\(1 \leq N \leq 10^5\)) комнат, \(i\)-ая комната изначально содержит \(a_i\) коров (\(1 \leq a_i \leq 5\cdot 10^6\)). Игра такова:

    Оба фермера всегда находятся в одной и той же комнате. После входа в комнату каждый фермер делает ровно один ход. ФД ходит первым. Об фермера изначально входят в комнату \(1\).
  • Если в комнате 0 коров, то фермер проиграл, иначе фермер выбирает целое число \(P\), где \(P\) должно быть или \(1\), или простое число, не более чем количество коров в амбаре и удаляет \(P\) коров из текущей комнаты.
  • После того, как оба фермера сделали ход, оба фермера переходят в следующую комнату по кругу. То есть, если фермеры находятся в комнате \(i\), они перемещаются в комнату \(i+1\), а из комнаты \(N\) они перемещаются в комнату \(1\).

Определите фермера, который выиграет в этой игре, если оба играют оптимально.

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

Ввод содержит \(T\) подтестов. Первая строка содержит \(T\) (\(1 \leq T \leq 1000\)). Далее следуют \(T\) подтестов.

каждый подтест начинается со строки, содержащей \(N\), за которой следует строка, содержащая числа \(a_1,\dots,a_N\).

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

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

Для каждого подтеста выведите кто выиграет игру то есть "Farmer John" или "Farmer Nhoj."

Игра с прямоугольником

игры Простые игры

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

Загрузить библиотеку для тестирования

Рассмотрим игру для двух игроков. Игрокам дан прямоугольник размером x × y (где x и y — положительные целые числа). Игроки ходят по очереди. Ход состоит в разделении прямоугольника на два прямоугольника одним горизонтальным или вертикальным разрезом. Полученные прямоугольники должны иметь положительные целочисленные размеры.


                  Возможные разрезы прямоугольника размером 4 × 3.

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

Ваша задача — написать программу, которая бы играла в игру с прямоугольниками и выигрывала. Для того чтобы играть, программа должна использовать специальную библиотеку. В библиотеке есть функции dimension_x() и dimension_y(), возвращающие размеры прямоугольника. Начальные размеры прямоугольника — целые числа от 1 до 100 000 000. Как минимум один из размеров больше 1. К тому же, в 50% тестов размеры прямоугольника не будут превышать 25.

В библиотеке есть также процедура cut(dir, position), которая должна вызываться вашей программой, чтобы сделать ход. Параметры dir и position описывают направление и позицию разреза соответственно. Параметр dir может принимать одно из двух значений: vertical и horizontal. Если dir = vertical, то проводится вертикальный разрез, а параметр position указывает x - координату разреза, как показано на рисунке выше. При этом вы должны гарантировать выполнение неравенства 1 ≤ position  ≤ dimension_x()− 1. Если dir = horizontal, то проводится горизонтальный разрез, а параметр position указывает y ? координату разреза. При этом, вы должны гарантировать выполнение неравенства 1 ≤ position  ≤ dimension_y()− 1.

После запуска вашей программы она будет играть за одного из игроков. Ваша программа ходит первой, она должна разрезать исходный прямоугольник. Когда ваша программа вызывает процедуру cut, ваш ход записывается и управление передается программе соперника. После хода соперника управление возвращается вашей программе. Значения, которые возвращаются функциями dimension_x() и dimension_y(), будут отражать результат вашего хода и хода соперника. Как только ваша программа выигрывает, проигрывает или делает неправильный ход, ее исполнение будет прервано. Прерывание вашей программы — это автоматический процесс, так что ваша программа должна продолжать делать столько ходов, сколько возможно до автоматического прерывания ее исполнения. Вы можете предполагать, что для предложенных входных данных всегда существует выигрышная стратегия для вашей программы.

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

Экспериментирование

Для того, чтобы дать вам возможность поэкспериментировать с библиотекой, в ваше распоряжение предоставлены примеры библиотек: их исходные тексты находятся в файлах preclib.pas, creclib.c и creclib.h . Эти библиотеки вы можете взять по адресу: http :// contest / . Они реализуют очень простую стратегию. Когда вы запустите вашу программу, она будет играть против этих простых соперников. Вы можете изменять их, чтобы протестировать вашу программу с лучшими соперниками. Следует учесть, что во время тестирования после окончания тура, ваша программа будет играть против другого соперника.

При посылке вашей программы на проверку с использованием интерфейса TEST , она будет откомпилирована с немодифицированной библиотекой соперника. При этом посылаемый вами входной файл будет передан как стандартный ввод вашей программе. Входной файл должен состоять из двух строк, каждая из которых должна содержать по одному целому числу. Первая строка должна содержать исходную ширину, вторая — исходную высоту прямоугольника. Эти размеры будут прочитаны библиотекой, предложенной в качестве примера.

Если вы модифицируете часть implementation библиотеки preclib.pas, пожалуйста, перекомпилируйте её, используя команду ppc386 -O2 preclib.pas. Эта команда создаст файлы preclib.o и preclib.ppu. Эти файлы необходимы для компиляции вашей программы и должны быть в помещены в каталог, где находится ваша программа. Пожалуйста, не модифицируйте часть interface библиотеки preclib.pas.

Если вы модифицируете библиотеку creclib.c, пожалуйста, не забудьте поместить ее вместе с creclib.h в каталог, где находится ваша программа, — они необходимы для компиляции. Пожалуйста, не модифицируйте файл creclib.h.

В ваше распоряжение также предоставляются две простые программы, которые иллюстрируют использование библиотек crec.c и prec.pas. Пожалуйста, помните, что эти программы не являются правильными решениями. Вы можете откомпилировать их, используя такие команды:

gcc -O2 -static crec.c creclib.c -lm
g++ -O2 -static crec.c creclib.c -lm
ppc386 -O2 -XS prec.pas

Библиотеки

В ваше распоряжение предоставлены библиотеки, которые обеспечивают следующую функциональность:

Библиотека для FreePascal (preclib.ppu, preclib.o)
type direction = (vertical, horizontal);
function dimension_x(): longint;
function dimension_y(): longint;
procedure cut(dir: direction; position: longint);

 
Включите следующий оператор в ваш исходный файл rec.pas:
uses preclib;
Чтобы откомпилировать вашу программу, скопируйте файлы preclib.o и reclib.ppu в каталог, где находится ваш исходный файл, и выполните следующую команду:
ppc386 -O2 -XS rec.pas
Файл prec.pas является примером использования библиотеки preclib.

Библиотека для GNU C/C++ (creclib.h, creclib.c)

typedef enum __direction {vertical, horizontal} direction;
int dimension_x();
int dimension_y();
void cut(direction dir, int position);



Включите следующий оператор в ваш исходный файл (rec.c или rec.cpp):
#include ”creclib.h”
Чтобы откомпилировать вашу программу, скопируйте файлы creclib.c и creclib.h в каталог, где находится ваш исходный файл, и выполните следующую команду:
gcc -O2 -static rec.c creclib.c –lm
или:
g++ -O2 -static rec.cpp creclib.c –lm
Файл crec.c является примером использования библиотеки в C.
Пример взаимодействия

Ниже приведен пример взаимодействия вашей программы с библиотекой. Он показывает, как может проходить игра. Игра начинается с прямоугольника размером 4 × 3. Существует выигрышная стратегия для этого случая.
 

Ваша программа вызывает

Что происходит

dimension_x()

возвращает 4

dimension_y()

возвращает 3

cut(vertical, 1)

ваш разрез записывается, и прямоугольник размером 3 × 3 передается вашему сопернику, который разрезает его и получается прямоугольник размером 3 × 2; после этого управление передается вашей программе

dimension_x()

возвращает 3

dimension_y()

возвращает 2

cut(horizontal, 1)

ваш разрез записывается, и прямоугольник размером 3 × 1 передается вашему сопернику, который разрезает его и получается прямоугольник размером 2 × 1; после этого управление передается вашей программе

dimension_x()

возвращает 2

dimension_y()

возвращает 1

cut(vertical, 1)

в результате вашего разреза получается прямоугольник размером 1 × 1, так что вы выиграли; после этого работа вашей программы автоматически прекращается.

Монетки

игры дп Простые игры

Два участника олимпиады играют в следующую игру. Участники по очереди бросают монетки (одну или больше) в хитрый ящик. Если в ящике находится в точности X1, или X2, ..., или Xn монеток, то они, кроме одной, отдаются участнику, сделавшему последний ход. Оставшаяся монетка "исчезает" из игры. Игра заканчивается, если у одного из участников игры не осталось монеток. При этом монетки из ящика (все до одной) отдаются другому участнику(он является победителем игры). Определить наибольшее количество монеток, которое может выиграть первый участник при наилучшей игре второго. Если первый участник не может выиграть, то результатом является число 0.

Входные данные
В первой строке входного файла два числа 0 < S,T <= 50 (число монеток у первого и второго игроков). Во второй строке N (0 <= N <= 50) - число хитрых состояний ящика. В третьей строке целые числа X1, X2,..., Xn, 0 < X1 <= X2 <= ... <= Xn <= 100.

Выходные данные
Вывести число монеток у первого участника или 0.

Тестовая сцена

игры

{ "X":110, "Z":110, "Step":10, "PlayerPoint": {"pointX" : -10, "pointZ" : -10, "angle" : 90}, "WallPoints": [ { "pointX" : 15, "pointZ" : -10, "angle" : 90}, { "pointX" : 15, "pointZ" : 0, "angle" : 90}, { "pointX" : 15, "pointZ" : 10, "angle" : 90}, { "pointX" : 15, "pointZ" : 20, "angle" : 90}, { "pointX" : 15, "pointZ" : 30, "angle" : 90}, { "pointX" : -20, "pointZ" : 35, "angle" : 0}, { "pointX" : -10, "pointZ" : 35, "angle" : 0}, { "pointX" : 0, "pointZ" : 35, "angle" : 0}, { "pointX" : 10, "pointZ" : 35, "angle" : 0} ], "HolePoints": [ { "pointX" : -20, "pointZ" : -30, "angle" : 0}, { "pointX" : -30, "pointZ" : -30, "angle" : 0}, { "pointX" : -40, "pointZ" : -30, "angle" : 0}, { "pointX" : -40, "pointZ" : -40, "angle" : 0}, ], "PrizePoints": [ { "pointX" : -30, "pointZ" : -40, "angle" : 0}, { "pointX" : 30, "pointZ" : 30, "angle" : 0} ] }

Игра для Пети и Вани

игры НОД и алгоритм Евклида Вывод формулы

Некоторые уроки в школе для Вани и Пети  очень скучны. На этих уроках Петя и Ваня придумали игру. Сначала мальчики записывают на листке два различных натуральных числа a и b .
Ход игры заключается в следующем: среди записанных чисел выбирают p и q такие, что модуля их разности \(| p - q |\) еще нет на листке, и дописывают его.
Проигрывает тот, кто не может сделать ход.
Определите, кто из ребят окажется победителем при правильной игре обоих. Ваня вежливый мальчик, поэтому всегда ходит вторым.

Входные данные: В первой и единственной строке записано два различных натуральных числа 1 <= <= 10^9 , разделенные пробелом - два исходных числа на листке.

Выходные данные: Выведите имя победителя в этой игре (Petya или Vanya)

Примечание: В первом примере Петя первым ходом допишет на листок число |6−2| = 4 . Больше ходов нет, поэтому выигрывает Петя. Во втором примере первым ходом на листок будет дописано число |4−1| = 3 . Затем Ваня может записать |3−1| = 2 , тогда у Пети ходов не останется. Побеждает Ваня.

Примеры
Входные данные Выходные данные
1 6 2 Petya
2 4 1 Vanya