графы

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

Для того, чтобы мероприятие прошло интересно, необходимо выбрать хороших спикеров. Есть \(n\) кандидатов, \(i\)-й из которых характеризуется своей осведомленностью о проектах — целым числом \(a_i\) от \(0\) до \(2^k - 1\). При этом некоторые из кандидатов дружат между собой, а именно, есть \(m\) пар друзей \((f_i, s_i)\).

Разумеется, всем хочется, чтобы мероприятие прошло гладко, а для этого необходимо, чтобы все спикеры попарно дружили между собой. При этом, чтобы рассказы спикеров не казались однообразными, важно, чтобы количество выбранных спикеров было как можно больше. Осведомленностью группы размера \(s\), состоящей из кандидатов \(i_1, i_2, \ldots, i_s\), называется \(a_{i_1} \oplus a_{i_2} \oplus \ldots a_{i_s}\), где \(\oplus\) — операция побитового исключающего <<ИЛИ>>. Соответственно, помимо уже описанных критериев, среди всех подходящих групп кандидатов максимального размера необходимо выбрать группу спикеров с максимальной осведомленностью.

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

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

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

Первая строка каждого набора содержит три целых числа \(n\), \(m\) и \(k\) — количество кандидатов, количество пар друзей среди кандидатов и количество различных тем, которые будут обсуждаться на конференции, соответственно (\(1 \le n \le 40\); \(0 \le m \le \frac{n \cdot (n - 1)}{2}\); \(0 \le k \le 30\)).

Во второй строке каждого набора через пробел перечислены \(n\) целых чисел \(a_i\) — уровни осведомленности о проектах каждого из кандидатов (\(0 \le a_i \le 2^k - 1\)).

Далее следуют \(m\) строк, \(i\)-я из которых содержит два целых числа \(f_i\) и \(s_i\) — номера кандидатов, образующих \(i\)-ю пару друзей (\(1 \le f_i, s_i \le n\); \(f_i \neq s_i\)). Гарантируется, что все перечисленные пары друзей различны.

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

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

Замечание

В примере из условия:

1. в первом наборе входных данных выгодно выбрать спикеров под номерами \(3\) и \(4\) с осведомленностью \(a_3 \oplus a_4 = 3 \oplus 4 = 7\);

2. во втором наборе входных данных выгодно выбрать спикеров под номерами \(1\), \(3\) и \(4\) с осведомленностью \(1 \oplus 4 \oplus 8 = 14\);

3. в третьем наборе входных данных есть единственный способ выбрать четырех попарно дружащих спикеров: выбрать всех, кроме пятого.

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

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

1. Компьютер называет целое число \(k > 0\).

2. Вы ровно \(k\) раз некоторым образом выбираете одну из еще не удаленных клеток, соседних по стороне (имеющих общую сторону) с той, в которой фишка находится в текущий момент, и перемещаете фишку в эту клетку. Вы можете перемещать фишку на клетку, в которой она уже была. Если не существует еще не удаленных клеток, соседних по стороне с текущей, перемещение не производится.

3. Компьютер называет координаты \((i, j)\) произвольной еще не удаленной клетки поля, после чего она сразу же удаляется.

Если компьютер удаляет клетку, на которой находится фишка, игра заканчивается вашей победой. Ваша цель — победить как можно раньше. При этом вы не сообщаете компьютеру свои перемещения, поэтому можете играть нечестно: вместо реального перемещения фишки по полю вы можете следить за всеми возможными ее положениями. Иными словами, если в какой-то момент при удалении клетки \((i, j)\) существует последовательность перемещений фишки, при которой в данный момент фишка находится в точности в клетке \((i, j)\), вы можете сообщить компьютеру, что игра завершена, и вы победили.

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

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

Формат входных данных
В единственной строке ввода даны четыре целых числа \(n\), \(m\), \(r\) и \(c\) — размеры доски и координаты изначального расположения фишки (\(1 \le r \le n \le 1000\); \(1 \le c \le m \le 1000\)).

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

В следующих \(n \cdot m\) строках даны ходы, которые последовательно собирается сделать компьютер. Описание \(t\)-го хода задается тремя целыми числами \(k_t\), \(i_t\) и \(j_t\) — количеством перемещений фишки, которые вам понадобится совершить, и координатами клетки поля, которую после этого требуется удалить (\(1 \le k_t \le 10^9\); \(1 \le i_t \le n\); \(1 \le j_t \le m\)).

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

Формат выходных данных
Выведите одно целое число от \(1\) до \(n \cdot m\) — номер хода, после которого вы сообщите компьютеру о своей победе.

 

В первом примере можно, например, первым ходом передвинуть фишку из \((1, 1)\) в \((1, 2)\), а вторым — из \((1, 2)\) в \((2, 2)\) и затем в \((2, 1)\), тем самым поместив ее на удаляемую клетку.

IT-компания <<VK>> имеет огромную инфраструктуру проектов, и чтобы разработчики могли гармонично работать вместе и структурировать вносимые в код изменения, им необходима система контроля версий (VCS).

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

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

• <<Исток>> графа — стартовая вершина, соответствующая изначальному состоянию проекта. Это единственная вершина, в которую не входят ребра.

• Каждая вершина, кроме корня, соответствует определенному коммиту. Коммит — блок из одного или более изменений.

• Версия проекта, задаваемая вершиной — набор всех изменений на путях между стартовой вершиной и данной.

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

• Из всех веток выделяется текущая ветка — версия проекта, с которой сейчас работает пользователь. Вершину, на которую указывает текущая ветка, будем обозначать как HEAD.

Пример графа можно видеть ниже. Рядом с каждым коммитом указаны соответствующие ему изменения. Вершина номер \(8\) соответствует команде merge между ветками <<main>> и <<new_config>> (описание команд см. ниже). Набор команд, позволяющий получить приведенную структуру графа версий, приведен в первом тесте. Пошаговые иллюстрации изменения графа версий можно видеть в прикрепленном к условию архиве.

Изначально граф состоит из единственной вершины с номером \(1\), на которую указывает текущая ветка <<main>>. Требуется поддерживать следующие команды:

1. <<add <файл> <хеш изменений>>> — запомнить изменения, внесенные в данный файл. Хеш однозначно описывает набор изменений в файле. Иными словами, хеши двух независимых изменений совпадают тогда и только тогда, когда состояния файла до и после изменения одинаковы.

   Иными словами, если в пустой файл добавляется строчка <<print(something)>>, и в непустой файл добавляется та же строчка, хеши этих двух изменений будут различными.

2. <<commit>> — подвесить к HEAD новую вершину, состоящую из всех изменений (add), сделанных с момента предыдущего успешного коммита. Новой вершине присваивается первый неиспользованный натуральный номер, после чего HEAD перемещается на нее.

   Операция возможна только тогда, когда множество сделанных изменений непустое. В противном случае требуется выдать ошибку <<ERROR: no changes>>, при этом новая вершина не создается.

3. <<reset <номер>>> — переместить HEAD на вершину с данным номером.

   Гарантируется, что вершина с данным номером существует. Если присутствуют несохраненные (commit) изменения (add), операция отклоняется с ошибкой <<ERROR: uncommitted changes>>.

4. <<checkout <имя ветки>>> — поменять текущую ветку на ветку с указанным именем (и, соответственно, переместить HEAD на версию, соответствующую выбранной ветке). Если ветки с таким именем не существует, создать новую ветку с таким именем, которая будет указывать на HEAD, после чего сделать ее текущей.

   Если присутствуют несохраненные изменения, операция отклоняется с ошибкой <<ERROR: uncommitted changes>>, аналолгично операции reset.

5. <<merge <имя ветки>>> — объединить изменения в текущей ветке и в ветке с указанным именем. При этом создается новая вершина, которая подвешивается к HEAD и к вершине, соответствующей второй ветке. HEAD при этом перемещается на новую вершину, а указатель второй ветки не двигается. Гарантируется, что имя второй ветки не совпадает с текущей.

   Если есть незакоммиченные изменения, операция отклоняется с ошибкой <<ERROR: uncommitted changes>>.

   Если несохраненных изменений нет, проверяется отсутствие конфликтов при объединении. Конфликтом считается ситуация, когда в состояниях проекта, соответствующим данным веткам, с одним и тем же файлом сделаны различные изменения. Иными словами, если обозначить множество изменений определенного файла в текущей ветке как \(D_1\), а во второй — как \(D_2\), то конфликт возникает, когда оба множества \(D_1 \setminus D_2\) и \(D_2 \setminus D_1\) непустые. В таком случае операция отклоняется с ошибкой <<ERROR: conflicts detected>>.

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

   Если какое-то изменение содержится в версиях разное ненулевое количество раз (например, изменение может присутствовать дважды после merge двух веток, в которые оно входило), конфликт не возникает. Конфликт возникает только если в каждой версии есть измененение одного и того же файла, которого нет в другой версии.

   Ниже можно найти иллюстрации к успешным и конфликтным вызовам операции merge.

   

   

Вам дается последовательность команд, которые требуется обработать. Для каждой команды выведите через пробел слово <<OK>> и номер вершины, на которую указывает HEAD, если команда выполнена успешно, или же соответствующую ошибку, если команда отклонена.

Формат входных данных
В первой строке дано единственное целое число \(T\) — количество наборов входных данных, которые вам предстоит обработать (\(1 \le T \le 20\)). Далее следуют описания наборов входных данных.

Каждый набор входных данных начинается со строки, содержащей единственное целое число \(n\) — количество команд в наборе (\(0 \le n \le 400\)). В \(i\)-й из следующих \(n\) строк задается \(i\)-я команда.

Гарантируется, что имена веток состоят только из маленьких латинских букв (‘a’ – ‘z’) и нижних подчеркиваний (‘_’), а хеши изменений — уникальные шестнадцатеричные строки длины ровно \(6\) (состоят из цифр и маленьких латинских букв от ‘a’ до ‘f’). Имена файлов в команде add состоят из маленьких латинских букв, точек и слешей (‘/’).

Также гарантируется, что команде reset всегда передается существующая вершина, а команде merge — существующая ветка, не совпадающая с текущей.

Формат выходных данных
Для каждого набора входных данных в порядке их следования во вводе сначала выведите строку <<Test case <номер>>> (наборы нумеруются от \(1\) до \(T\)), а затем \(n\) результатов выполнения команд, каждый в своей строке.

Результат выполнения каждой команды должен соответствовать либо формату <<OK <HEAD>>>, либо формату <<ERROR: <сообщение об ошибке>>>.

Рассмотрим строки, состоящие из первых k букв английского алфавита. Некоторые пары букв называются коммутирующими: если они стоят рядом в строке, их разрешается поменять местами.
Даны пары коммутирующих букв и две строки равной длины s и t. Требуется выяснить, можно ли получить t из s, выполнив произвольное количество операций: поменять местами две рядом стоящие коммутирующие буквы.

Входные данные
Первая строка содержит два целых числа k и n — количество используемых букв и количество пар коммутирующих букв (2 ≤ k ≤ 10, 0 ≤ n ≤ k(k − 1)/2).
Следующие n строк содержат по две буквы, не разделенные пробелом: пары коммутирующих букв. Гарантируется, что каждая пара приведена во вводе не более одного раза.
Следующие две строки содержат строки s и t, они имеют равную длину L (1 ≤ L ≤ 100 000) и состоят из первых k букв латинского алфавита.

Выходные данные
Выведите «YES», если строку t можно получить из строки s описанными операциями.
В противном случае выведите «NO».
 

Примеры

№	Входные данные	Выходные данные
1	3 2 ab bc abbcabc abcacbb	YES
2	3 2 ab bc abbcabc aabbbcc	NO

Мальчик Коля любит графы, но не любит циклы. У Коли есть несколько ориентированных не обязательно связных
графов. Графы могут содержать параллельные ребра, но не содержат петли. К сожалению, некоторые из них могут содержать
циклы.
Коля хочет развернуть некоторые ребра в каждом графе, чтобы избавиться от циклов. Разворотом ребра будем считать
замену ребра из вершины a в вершину b на противоположное ребро, которое будет направлено из вершины b в вершину a. При
этом Коля хочет развернуть наименьшее число ребер в каждом графе, чтобы получившиеся графы не содержали циклов.
Помогите Коле узнать, какое наименьшее число ребер ему нужно развернуть в каждом графе.

Входные данные
В первой строке входных данных содержится число t - число графов (1≤t≤8).
В первой строке описания каждого графа дано два числа n и m - число вершин и число ребер соответственно
(2≤n≤10, 1≤m≤1000).
В следующих m строках содержатся пары чисел a_i, b_i - описание ребер графа (1≤ a_i, b_i ≤ n, a_i ≠ b_i).
Для удобства, описания графов разделены пустыми строками. Пустой строки после последнего графа нет.
Гарантируется, что суммарное число вершин во всех графах не превосходит 50.

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

Примеры

№	Входные данные	Выходные данные
1	4 2 2 1 2 2 1 4 2 1 4 4 3 3 3 1 2 2 3 3 1 3 5 1 2 2 3 3 1 2 3 1 3	1 0 1 1

Замечание
В первом графе нужно развернуть одно из ребер, чтобы убрать цикл. Во втором графе циклов изначально нет, так что
ничего разворачивать не надо. В третьем графе можно развернуть любое ребро, чтобы убрать цикл. В четвертом графе нужно
развернуть ребро (3,1) или ребро (1,2), чтобы новый граф не содержал циклов.

                   ЭПИЗОД X: ФИРИОН НАНОСИТ ОТВЕТНЫЙ УДАР
Берляндия наконец-то окрепла после крупного поражения в войне против Стерляндии, и император Берляндии Фирион готовит атаку на противника. 
Стерляндия представляет собой определенное количество городов, соединенных двусторонними дорогами. От любого города Стерляндии можно добраться до любого другого. Никакая дорога не соединяет город с самим собой. 
Планируется следующее:
Выбирается город, на который будет производиться атака. Город уничтожают, а дороги, исходящие из него, баррикадируются. При этом Стерляндия должна потерять свою целостность. Далее одна из образованных областей подвергается атаке. При этом эта область должна составлять не менее 1/8 и не более 1/4  от оставшейся площади страны ( площадь измеряется в количестве городов в данной области).  Если при разрушении города Стерляндия сохраняет целостность, или подходящих областей не образуется, то данный город не подходит для атаки.
Фирион хочет знать сколько городов удовлетворяют выше описанным условиям, а также номера этих городов в порядке возрастания.
Входные данные
В первой строке даны два числа: n – кол-во городов в Стерляндии ( 2 <= n <= 10^3), m – количество дорог в Стерляндии ( 1 <= m <= 10^4).
Далее идут m строк, в которых задается описание дорог, а именно: в каждой строке заданы два числа: X и Y. Это означает, что город X и город Y соединены дорогой.
Выходные данные
В первой строке выведите число s  – кол-во городов, подходящих для атаки. Во второй строке выведите s чисел  - номера таких городов в порядке возрастания.
Пример

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

1 4