Алгоритмы на графах

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

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

Беси планирует бесконечное путешествие в стране с \(N\) (\(1\leq N \leq 10^5\)) городами. В каждом городе есть портал и время зацикливания \(T_i\). Все \(T_i\). являются степенями двойки и \(T_1 + \cdots + T_N \leq 10^5\). Если Вы войдёте в портал города \(i\) в день \(t\), Вы немедленно выйдете из портала в городе \(c_{i, t\bmod{T_i}}\).

У Беси есть \(Q\) (\(1\leq Q \leq 5\cdot 10^4\)) планов её путешествия, каждый из которых есть тройка чисел \((v, t, \Delta)\). В каждом плане она начинает в городе \(v\) в день \(t\). Затем она делает следующее \(\Delta\) раз. Она входит в портал текущего города, затем ждёт один день. Для каждого из её планов она хочет узнать, в каком городе она закончит путешествие.

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

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

Вторая строка содержит \(N\) разделённых одиночными пробелами целых чисел: \(T_1, T_2, \ldots, T_N\) (\(1\leq T_i\), \(T_i\) степень \(2\), и \(T_1 + \cdots + T_N \leq 10^5\)).

Для \(i = 1, 2, \ldots, N\), строка \(i+2\) содержит \(T_i\) разделённых одиночными пробелами положительных целых чисел, а именно \(c_{i, 0}, \ldots, c_{i, T_i-1}\) (\(1\leq c_{i, t} \leq N\)).

Для \(j = 1, 2, \ldots, Q\), строка \(j+N+2\) содержит три разделённых одиночными пробелами положительных целых числа, \(v_j, t_j, \Delta_j\) (\(1\leq v_j \leq N\), \(1\leq t_j \leq 10^{18}\), \(1\leq \Delta_j \leq 10^{18}\)) представляющих \(j\)-ый запрос.

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

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

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

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

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

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

Каждый вход состоит из \(T\) (\(1\le T\le 100\)) независимых подтестов. Гарантируется, что сумма \(N\) по всем тестам не превышает \(1000\).

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

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

Первая строка каждого подтеста содержит количество узлов \(N\). (\(2 \leq N \leq 1000\)) в исходном дереве Бесси, которые имеют значения \(1\dots N\).

Каждая из следующих \(N-1\) строк содержит два значения узла \(v_i\), разделенных пробелом, и \(p_i\) (\(1 \leq v_i, p_i \leq N\)), указывающий, что узел со значением \(v_i\) является дочерним узла со значением \(p_i\) в исходном дереве Бесси.

Следующая строка содержит количество узлов \(M\) (\(2 \leq M \leq N\)) в таблице Бесси. в финальном дереве.

Каждая из следующих \(M-1\) строк содержит два значения узла \(v_i\), разделенных пробелом, и \(p_i\) (\(1 \leq v_i, p_i \leq N\)), указывающий, что узел со значением \(v_i\) является дочерний узел узла со значением \(p_i\) в конечном дереве Бесси.

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

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

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

Если решений несколько, выведите любое.

Имеется \(N\) пастбищ (\(2 \le N \le 2\cdot 10^5\)), соединённых \(N-1\) дорогой, так что ои образуют дерево. Перемещение по каждой дороге занимает одну секунду. В начале на каждом пастбище 0 травы, трава на \(i\)-ом пастбище растёт со скоростью \(a_i\) (\(1\le a_i\le 10^8\)) единиц в секунду. Фермер Джон вначале находится в пастбище 1 и должен удобрить траву на каждом пастбище. Если он посещает пастбище, в котором \(x\) единиц травы, он должен потратить \(x\) единиц удобрений. Удобрять требуется только при первом посещении пастбища и удобрение пастбища занимает 0 единиц времени.

Ввод содержит дополнительный параметр \(T\in \{0,1\}\).

  • Если \(T=0\), ФД должен завершить путь в пастбище 1.
  • Если \(T=1\), ФД может завершить путь в любом пастбище.

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

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

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

Затем для каждого \(i\) от \(2\) до \(N\), имеется строка содержащая \(p_i\) и \(a_i\), означающая что есть дорога соединяющая пастбища \(p_i\) и \(i\). Гарантируется, что \(1\le p_i<i\).

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

Минимальное количество времени и минимальное количество удобрений, разделённые одиночным пробелом.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Telephone#90133
\(N\) коров Фермера Джона, последовательно пронумерованные, \(1 \ldots N\) выстроены в ряд (\(1\le N\le 5\cdot 10^4\)). \(i\)-ая корова имеет идентификатор породы \(b_i\) в интервале \(1 \ldots K\), with \(1\le K\le 50\). Коровы нуждаются в Вашей помощи чтобы узнать, как быстрее передать сообщение от коровы \(1\) корове \(N\).

\(|i-j|\) минут требуется, чтобы передать сообщение от коровы \(i\) к корове \(j\). Однако не все породы готовы взаимодействовать друг с другом, что описано в матрице \(S\) размером \(K \times K\), где \(S_{ij} = 1\) если корова породы \(i\) готова передать сообщение корове породы \(j\) и 0 в противном случае. Необязательно истина то, что \(S_{ij}=S_{ji}\), и даже может быть случай, когда \(S_{ii} = 0\), то есть корова породы \(i\) не будет передавать сообщение корове своей породы.

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

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

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

Следующая строка содержит \(N\) разделённых пробелом целых чисел \(b_1,b_2,\ldots,b_N\).

Следующие \(K\) строк описывают матрицу \(S\). Каждая строка состоит из строки из K бит. \(S_{ij}\) \(j\)-ый бит \(i\)-ой строки сверху.

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

Выведите одно целое число - минимальное количество требуемого времени. Если невозможно передать сообщение от коровы \(1\) к корове \(N\), выведите \(-1\).

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

На этой ферме имеется два амбара - один в поле \(1\), другой в поле \(N\). ФД хочет быть уверен, что имеется путь между двумя амбарами последовательностью дорожек. Оно готов построить до двух новых дорожек, чтобы добиться своей цели. Стоимость построения дорожки между полями \(i\) и \(j\) есть \((i-j)^2\).

Помогите ФД определить минимальную стоимость сделать так, чтобы амбары \(1\) и \(N\) стали достижимы друг для друга.

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

Каждый входной тест содержит \(T\) под тестов (\(1\le T\le 20\)), все из которых должны быть решены правильно, чтобы пройти этот тест.

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

Каждый подтест начинается с двух целых чисел \(N\) и \(M\). Каждая из последующих \(M\) строк содержит два целых числа \(i\) и \(j\), означающих путь между двумя различными полями \(i\) и \(j\). Гарантируется, что имеется не более одного пути между любыми двумя полями. и что сумма \(N+M\) для всех подтестов не более \(5 \cdot 10^5\).

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

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

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

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

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

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

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

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

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

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

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

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

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

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

 

ОЦЕНИВАНИЕ:

 

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

 

 

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

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

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

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

 

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

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

 

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

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

Помогите ФД определить максимальное положительное целое \(K\) такое, что дороги могут быть разделены на пути длины не менее \(K\).

ОЦЕНИВАНИЕ:

  • В тестах 2-4 дерево формирует звезду; не более чем одна вершина имеет степень больше чем 2.
  • В тестах 5-8 \(N\le 10^3\).
  • В тестах 9-15 нет дополнительных ограничений.

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

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

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

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

Выведите \(K\).

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

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

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

ОЦЕНИВАНИЕ:

  • В тестах 2-4 дерево образовывает звезду; не более одной вершины имеет степень более двух.
  • В тестах 5-8 \(N\le 10^3\).
  • В тестах 9-15 нет дополнительных ограничений.

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

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

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

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

Выведите битовую строку длины \(N-1.\) Для каждого \(1\le K\le N-1,\) \(K\)-ый бит строки слева равный 1 означает, что возможно разбиение ребер на пути длины ровно \(K\) и равный \(0\) в противном случае.

У Фермера Джона \(N\) коров, последовательно пронумерованных d \(1 \ldots N\) (\(2 \leq N \leq 10^5\)). Они организованы в сложную социальную структуру "moo networks" - маленькие группы коров взаимодействуют внутри группы, но не с другими группами.

Каждая корова расположена в точке \((x,y)\) на двумерной карте фермы. И нам известны \(M\) (\((1 \leq M < 10^5)\)) пар коров, принадлежащих к одной и той же группе.

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

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

Первая строка ввода содержит \(N\) и \(M\). Каждая из следующих \(N\) строк содержит \(x\) и \(y\) - координаты коров (неотрицательные целые числа не более \(10^8\)). Каждая из следующих \(M\) строк содержит два целых числа \(a\) и \(b\), описывающих принадлежность коров с номерами \(a\) и \(b\) к одной группе. Каждая корова присутствует как минимум в одной из таких пар. Никакие пары во вводе не повторяются.

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

Выведите минимальный периметр, удовлетворяющий ограничениям ФД.

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

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

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

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

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

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

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

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

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

#include "grader.h"

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Автор: Spencer Compton

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

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

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

Поскольку это число может быть очень большим, выводите его остаток по модулю \(10^9 + 7\).

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

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

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

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

Все стоимости от \(1\) до \(10^9\) включительно.

В 20% тестов гарантируется, что \(N \leq 500\) и все веса от \(1\) до \(5\) включительно.

В других 20% тестов гарантируется \(N \leq 5000\).

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

Одно целое число - количество планов минимальной стоимости по модулю \(10^{9} + 7\).

На ферме пожар и коровы должны спасаться.

Ферма описывается решёткой \(10 \times 10\) символов:

..........
..........
..........
..B.......
..........
.....R....
..........
..........
.....L....
..........

Символ 'B' представляет амбар, который горит. Символ 'L' представляет озеро, символ 'R' представляет огромную скалу.

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

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

Корова не может находится в квадрате, содержащем скалу, амбар или озеро. Гарантируется, что они не будут соседними друг другу.

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

Входной файл содержит 10 строк, каждая по 10 символов, описывающих план фермы.

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

Выведите одно целое число - минимальное количество коров, требуемых для того, чтобы сформировать "ведерную бригаду".

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

Конфигурация мороженого, которое производится машиной, может быть описано решёткой \(N \times N\) grid (\(1 \leq N \leq 1000\)):

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

Каждый символ '.' представляет пустое место, а каждый символ '#' представляет \(1 \times 1\) квадратную ячейку мороженого.

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

ФД хочет найти площадь и периметр сгустка, который имеет наибольшую площадь. Площадь сгустка равна количеству символов '#' в его картинке. Если несколько сгустков имеют одинаковую площадь, он хочет знать минимальный периметр из них. На рисунке выше, маленький сгусток имеет площадь 2 и периметр 6, а больший сгусток имеет площадь 13 и периметр 22.

Заметим, что сгусток может иметь "дыру" внутри (пустое пространство, окружённое мороженым). В таком случае граница "дыры" также учитывается в периметре сгустка. Сгусток может находиться внутри другого сгустка, в этом случае они рассматриваются как независимые сгустки. Например, ниже представлен сгусток площади 1 внутри сгустка площади 16:

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

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

Первая строка ввода содержит \(N\), а следующие \(N\) строк описывают вывод машины. Присутствует, как минимум, один символ '#'.

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

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

Ферма состоит из \(N\) полей (\(1 \leq N \leq 2 \cdot 10^5\)), последовательно пронумерованных \(1 \ldots N\), и удобно соединённых множеством из \(M\) двунаправленных тропинок (\(1 \leq M \leq 2 \cdot 10^5\)). Будучи "существами привычки" коровы используют одно множество из \(N-1\) тропинок для всех своих ежедневных перемещений между полями. Они называют эти тропинки "стандартными" тропинками. Возможно добраться от любого поля до любого другого поля, используя только стандартные тропинки.

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

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

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

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

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

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

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

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

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

ОЦЕНИВАНИЕ:

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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