Извините за не очень хорошие примеры и поздний разбор. Это был наш первый раунд, поэтому он был очень напряженным для нас, но мы надеемся, что вам понравились задачи, несмотря на это!
Попробуйте посмотреть на четность $$$n, m$$$.
Игрок, который победит не зависит от стратегии.
Единственное, от чего зависит победивший игрок это четность $$$n, m$$$.
Заметим, что игра закончится только тогда, когда фишка находится в правом верхнем углу (иначе можно сдвинуть её на $$$1$$$ клетку вправо или вверх). За все ходы фишка сдвинется на $$$n - 1$$$ вправо и на $$$m - 1$$$ вверх, значит, суммарная длина всех ходов равна $$$n + m - 2$$$ (длина хода — на сколько сдвинулась фишка за ход). Так как длина любого хода нечётна, то после любого хода Бурёнки сумма длин будет нечётна, а после любого хода Тони чётна. Значит, мы можем узнать, кто сделал последний ход в игре, посмотрев на $$$(n + m - 2) \operatorname{mod} 2 = (n + m) \operatorname{mod} 2$$$. При $$$(n + m) \operatorname{mod} 2 = 0$$$ побеждает Тоня, иначе — Бурёнка.
Сложность решения — $$$O(1)$$$.
Вместо $$$k$$$ можно рассматривать остаток от деления $$$k$$$ на 4.
Для остатка 0 ответа нет.
Для всех остальных остатков ответ есть.
Заметим, что от числа $$$k$$$ нам нужен только остаток по модулю $$$4$$$, поэтому возьмём $$$k$$$ по модулю и будем считать, что $$$0 \leq k \leq 3$$$.
Если $$$k = 0$$$, то ответа нет, так как тогда произведение чисел в каждой паре должно делиться на $$$4 = 2^2$$$, то есть произведение всех чисел от $$$1$$$ до $$$n$$$ должно делиться на $$$2^{\frac{n}{2} \cdot 2} = 2^n$$$, но степень вхождения $$$2$$$ в эту сумму равно $$$\lfloor\frac{n}{2}\rfloor + \lfloor\frac{n}{4}\rfloor$$$, что меньше $$$n$$$.
Если $$$k = 1$$$ или $$$k = 3$$$, то сделаем все пары вида $$$(i, i + 1)$$$, где $$$i$$$ — нечётное. Тогда $$$a + k$$$ будет чётным в каждой паре, так как $$$a$$$ и $$$k$$$ нечётные, а так как $$$b$$$ тоже чётное, то произведение будет делится на $$$4$$$.
Если $$$k = 2$$$, то сделаем то же разбиение на пары, но во всех парах, где $$$i + 1$$$ не делится на $$$4$$$, поменяем числа местами (то есть сделаем $$$a = i + 1$$$ и $$$b = i$$$). Тогда в парах, где $$$i + 1 \operatorname{mod} 4 = 0$$$, $$$b$$$ делится на $$$4$$$ (значит, и произведение тоже), а в остальных $$$a + k$$$ делится на $$$4$$$ (так как $$$a$$$ и $$$k$$$ имеют остаток $$$2$$$ по модулю $$$4$$$).
Сложность решения — $$$O(n)$$$.
Кто бы побеждал в поединках, если бы самый сильный спортсмен был бы первым в очереди?
После какого числа раундов самый сильный спортсмен гарантированно окажется в начале очереди?
Промоделируйте первые $$$n$$$ раундов и запишите их победителей так, чтобы для каждого человека можно было быстро узнавать число побед в раундах с номерами не больше заданного числа.
Заметим, что после того, как самый сильный спортсмен окажется в начале очереди, выигрывать будет только он. Самый сильный спортсмен окажется в начале очереди не более, чем после $$$n$$$-го раунда. Промоделируем первые $$$n$$$ раундов, если в $$$i$$$-м раунде победил $$$j$$$-й спортсмен, то запишем для него номер $$$i$$$. Теперь для ответа на запрос $$$(i, k)$$$ достаточно бинпоиском найти число побед $$$i$$$-го спортсмена в раундах с номерами $$$j \leq k$$$, а если $$$k > n$$$, и сила $$$i$$$-го спортсмена равна $$$n$$$, то к ответу нужно прибавить ещё $$$k - n$$$.
Сложность решения — $$$O(n + q log n)$$$.
1718A2 - Бурёнка и традиции (сложная версия)
Можно использовать только отрезки длины $$$2$$$ и $$$1$$$.
Существует ответ, в котором отрезки длины $$$2$$$ не пересекаются с отрезками длины $$$1$$$.
Если для $$$l, r$$$ выполнено $$$a_l \oplus a_{l + 1} \oplus \ldots \oplus a_{r} = 0$$$, то мы можем заполнить нулями этот подотрезок за $$$r-l$$$ секунд используя только отрезки длины 2.
Существует ответ, где потраченное время минимально и длины всех взятых отрезков 1 и 2. Ведь, отрезок длины $$$l, r, x$$$ можно представить как $$$\lceil \frac{r-l+1}{2} \rceil$$$ отрезков длины 2 и 1, а точнее $$$[l, l + 1, x], [l + 2, l + 3, x], \ldots, [r, r, x]$$$(или $$$[r-1, r, x]$$$ если $$$(l - r + 1)$$$ четное).
Заметим, что если для $$$l, r$$$ выполнено $$$a_l \oplus a_{l + 1} \oplus \ldots \oplus a_{r} = 0$$$, то мы можем заполнить нулями подотрезок $$$l, r$$$ за $$$r-l$$$ секунд запросами $$$[l, l+1, a_l], [l+1, l+2, a_l \oplus a_{l+1}], ... [r-1, r, a_l \oplus a_{l+1} \oplus \ldots \oplus a_r]$$$.
Заметим, что если отрезок длины 2 пересекается с отрезком длины 1, их можно менять на 2 отрезка длины 1.
Из этого всего следует, что ответ представляет из себя отрезки длины 1 и куски покрытые отрезками длины 2. Тогда легко видеть, что ответ представляет из себя $$$n - $$$ (максимальное количество непересекающихся подотрезков с ксором 0). это количество можно посчитать динамическим программированием или жадно.
Попробуйте представить $$$n$$$ как $$$F_1 + F_2 + \ldots + F_m= n$$$.
Пусть, $$$n = F_1 + F_2 + \ldots + F_m$$$, тогда попробуйте найти минимальное $$$x$$$, начиная с которого если существует $$$c_i=x$$$ ответа нет.
$$$x$$$ это (максимальная сумма чисел фибоначчи, среди которчых нет соседних) + 1.
$$$x$$$ это $$$F_1 + F_3 + F_5 + \ldots + F_{m} + 1$$$ для нечетного $$$k$$$ и $$$F_2 + F_4 + F_6 + \ldots + F_{m} + 1$$$ для четного.
$$$x$$$ это $$$F_{m+1} + 1$$$ для нечетного $$$k$$$ и $$$F_{m+1}$$$ для четного.
Попробуйте понять, может ли получиться так, что существует два различных ответа в которых отличается буква образующая блок длины $$$F_{m}$$$.
Правильный ответ: может если есть $$$c_i = F_m$$$ и $$$c_j = F_m$$$ и это единственный возможный вариант.
Теперь используя всё, что вы поняли напишите жадник.
Попробуйте написать жадник.
А программисту вторая подсказка не нужна, он после первой жадник написал.
В начале проверим, что число $$$n$$$ (сумма всех $$$c_i$$$) представимо в виде суммы какого-то префикса чисел Фибоначчи, в противном случае выведем ответ NO.
Давайте попробуем набирать ответ жадно, идя от больших чисел Фибоначчи к меньшим. Для очередного числа Фибоначчи возьмём букву с наибольшим числом вхождений в строку из числа тех, которые не равны предыдущей взятой букве (для избежания появления двух соседних блоков из одной и той же буквы, чего быть не может). Если вхождений этой буквы меньше, чем это число, то ответ NO. Иначе поставим букву на это число Фибоначчи и вычтем его из числа вхождений этой буквы.Если мы смогли набрать все числа Фибоначчи, то ответ YES.
Почему же жадное решение работает? Пусть на данном шаге нужно взять $$$F_i$$$ (я буду говорить взять число из $$$c_t$$$ это будет значить взять $$$F_i$$$ букв вида $$$t$$$) , посмотрим на максимальное $$$c_x$$$ сейчас, если его нельзя представить как сумму несоседних чисел Фибоначчи до $$$F_i$$$, то ответ нет. Можно доказать, что если $$$c_x > F_{i+1}$$$, то представить $$$c_x$$$ невозможно.
Если на шаге ровно одно число больше или равно $$$F_i$$$, тогда вариант взять нужное число всего один, поэтому жадное решение работает.
Если существует два таких числа и они равны, то вариант взять нужное число ровно один с точностью до перестановки букв. Жадник опять работает.
Если же есть $$$c_j \geq F_i, c_x \geq F_i, j \ne x$$$, то заметим, что большее из чисел $$$c_j, c_x$$$ будет больше $$$F_i$$$, если мы не возьмем его, то на следующем шаге это число будет больше $$$F_{i+1}$$$($$$i$$$ станет на 1 меньше), по доказанному выше ответа не будет, значит, брать большее из чисел всегда оптимально.
Ответ для $$$k=x$$$ и $$$k=\gcd(x, n)$$$ одинаков.
В этой задаче полезно общее утверждение: для любого массива $$$c$$$ длины $$$k$$$ верно $$$k \cdot \operatorname{max}(c_1, c_2, \ldots, c_k) \geq c_1 + c_2 + \ldots + c_n$$$.
Попробуйте применить вторую подсказку для $$$k_1=p$$$ и $$$k_2$$$ делящимся на $$$k_1$$$, где $$$k_1, k_2$$$ делители $$$n$$$/ разных $$$s$$$.
Можно рассматривать только $$$k$$$ вида $$$\frac{n}{p}$$$, где $$$p$$$ простой делитель $$$n$$$.
Давайте заметим, что ответ для $$$k=x$$$ и $$$k=\gcd(x, n)$$$ одинаков.
Действительно, для числа $$$k$$$ мы посетим числа c индексами $$$s + ik \mod n$$$ для $$$i$$$ от $$$0$$$ до $$$n-1$$$ включительно, из этого можно видеть, что индекс $$$i$$$-го числа совпадает с индексом $$$i + \frac{n}{\gcd(k, n)}$$$, причем если смотреть на два индекса, разница между которыми равна $$$l$$$ и $$$l < \frac{n}{\gcd(k, n)}$$$, то они различны, так как $$$k \cdot l \mod n \neq 0$$$, следовательно, ответ представляет из себя (сумму чисел с индексами $$$s + ik \mod n$$$ для $$$i$$$ от $$$0$$$ до $$$\frac{n}{\gcd(k, n)}-1$$$) $$$\cdot \gcd(k, n)$$$.
Теперь давайте докажем, что первые $$$\gcd(k, n)$$$ чисел одинаковы для $$$(s, x)$$$ и $$$(s, \gcd(x, n))$$$, заметим, что подходят только те индексы, которые имеют такой же остаток при делении на $$$\gcd(x, n)$$$ как и $$$s$$$, но таких индексов только $$$\frac{n}{\gcd(k, n)}$$$, а мы доказали, что у нас должно встречаться $$$\frac{n}{\gcd(k, n)}$$$ различных индексов, значит все они представлены по разу, следовательно ответ для $$$k=x$$$ и $$$k=\gcd(x, n)$$$ одинаков, ведь сумма состоит из одинаковых чисел. Ч.Т.Д.
Значит, нам нужно рассматривать только $$$k$$$ являющиеся делителями $$$n$$$, это уже заходит, если написать, например, дерево отрезков, но мы не хотим писать дерево отрезков, поэтому идем дальше, докажем, что для $$$k_1 = x$$$, ответ меньше или равен, чем для $$$k_2 = x \cdot y$$$ если $$$k_1$$$ и $$$k_2$$$ делители $$$n$$$, почему это так?
Заметим, что для числа $$$k$$$ ответ бьется на $$$\gcd(k, n)$$$ групп чисел, так что в каждой группе ровно $$$\frac{n}{\gcd(k, n)}$$$ и каждое число входит ровно в одну группу, причем для разных $$$s$$$ ответ будет выглядеть как (сумма в группе которой принадлежит $$$s$$$) $$$\cdot \gcd(k, n)$$$.
Посмотрим, на ответ для оптимального $$$s$$$ для $$$k_1$$$ назовем множество при котором он достигается $$$t$$$, заметим, что в $$$k_2$$$ для разных $$$s$$$ есть $$$m$$$ независимых множеств, которые являются подмножествами $$$t$$$. Пусть $$$m_i$$$ сумма в $$$i$$$-м множестве. Теперь заметим, что нам нужно доказать $$$max(m_1, m_2, \ldots, m_y) * y \geq m_1 + m_2 + \ldots m_y$$$ это верно для любых $$$m_i$$$, легко видеть. Ч.Т.Д.
Значит нужно перебирать делители вида $$$\frac{n}{p}$$$ где $$$p$$$ простое, теперь это можно сдать с сетом. ура!
Для делителя $$$d$$$ предлагается хранить ответы для всех пар $$$(s, d)$$$, где $$$s \le \frac{n}{d}$$$ и максимум среди них, их можно посчитать изначально за $$$O(n log n)$$$ для одного $$$d$$$, каждый запрос это изменение одного из значений, это можно сделать за $$$O(log n)$$$.
Сложность авторского решения $$$O(6 \cdot n \operatorname{log}(n))$$$, где 6 это максимальное количество различных простых делителей числа $$$n$$$.
1718D - Перестановка для Бурёнки
Попробуйте свести задачу к одному массиву и дереву.
Попробуйте свести дерево к паросочетанию.
Первая доля:для каждого $$$a_i=0$$$ отрезок подходящих значений.
Вторая доля: множество $$$S$$$ и число $$$d$$$.
Существуют $$$L$$$ и $$$R$$$ такие, что ответ на запрос <> тогда и только тогда, когда $$$L \le d \le R$$$.
Давайте построим дерево рекурсивно начав с отрезка $$$[1, n]$$$, на каждом шаге будем выбирать корнем поддерева $$$v = \operatorname{argmax}([p_l, p_{l+1} \ldots, p_r]) + l - 1$$$, затем рекурсивно построим деревья для подотрезков $$$[1, v-1], [v+1, n]$$$ если они не пустые, затем создадим ребра из корня в корни этих поддеревьев. То что мы получили называется декартовым деревом по массиву. Дальше в разборе будет упоминаться именно это дерево.
Легко видеть, что декартовы деревья по массивам совпадают тогда и только тогда, когда эти массивы похожи. Тогда необходимое и достаточное условие для того, чтобы массив $$$a$$$ был похож на $$$p$$$ это то, что для любой пары $$$u, v$$$ такой, что $$$u$$$ находится в поддереве $$$v$$$, выполнено $$$a_v > a_u$$$, другими словами $$$a_v$$$ максимум среди чисел в поддереве вершины $$$v$$$.
Назовем позицию $$$i$$$ изначально пустой, если изначально $$$a_i = 0$$$
Назовем массив $$$a$$$ почти похожим на $$$p$$$ если для любой пары $$$u, v$$$ такой, что $$$u$$$ находится в поддереве $$$v$$$, выполнено $$$a_v > a_u$$$ или обе позиции $$$u$$$, $$$v$$$ изначально пустые.
Докажем, что если существует способ заполнить пропуски в $$$a$$$, чтобы получить почти похожий на $$$p$$$ массив, то существует и способ заполнить пропуски, чтобы получить похожий.
Действительно, давайте посмотрим на почти похожий на $$$p$$$ массив $$$a$$$. пройдемся по дереву рекурсивно начиная с корня. На шаге с вершиной $$$v$$$ сначала запустимся рекурсивно от всех детей $$$v$$$, теперь для них верно, что максимумы их поддеревьев в них, посмотрим на максимального ребенка $$$v$$$, пусть это $$$u$$$, тогда если $$$a_v > a_u$$$, то всё хорошо, иначе $$$a_v < a_u$$$ заметим, что $$$v$$$ является изначально пустой позицией, ведь для всех изначально не пустых позиций верно, что они являются максимумами в своих поддеревьях (это легко видеть подставив в определение), a $$$v$$$ не является. Заметим, что $$$u$$$ является изначально пустой позицией. ведь иначе, мы ни разу не изменили $$$a_v$$$ и $$$a_u$$$, следовательно в изначальном почти похожем на $$$p$$$ массиве $$$a$$$ выполнялось $$$a_v > a_u$$$ противоречие. значит $$$v, u$$$ изначально пустые, мы можем выполнить $$$swap(a_v, a_u)$$$ и всё будет выполняться.
После выполнения этого алгоритма мы изменили только изначально пустые элементы и получили $$$a$$$ похожую на $$$p$$$. ЧТД
Как проверить существование почти похожего на $$$p$$$ массива? Назовем числом $$$r_i$$$ минимум среди всех чисел $$$a_v$$$ таких, что $$$i$$$ находится в поддереве $$$v$$$. Назовем числом $$$l_i$$$ максимум среди всех чисел $$$a_v$$$ таких, что $$$v$$$ находится в поддереве $$$i$$$. легко видеть, что $$$a$$$ является почти похожим на $$$p$$$ если для всех $$$i$$$ выполняется, $$$l_i < a_i < r_i$$$.
Это звучит невероятно хорошо. Значит, всё что нам нужно это найти паросочетание множества $$$S_d$$$ и отрезков вида $$$[l_i, r_i]$$$ для $$$i$$$ являющихся изначально пустыми. Теперь легко доказать (пусть для $$$d_1$$$ ответ да, ответ для $$$d_2$$$ мы не знаем, попробуйте посмотреть на чередующийся путь из $$$d_1$$$ в $$$d_2$$$ в парососчетании, легко видеть, что если такой путь есть, то для $$$d_2$$$ ответ да, иначе, нет. Если посмотреть на структуру паросочетания точек с отрезками, можно увидеть, что чередующийся путь существует для непрерывного отрезка значений $$$d_2$$$), что подходящие $$$d$$$ являются непрерывным отрезком. границы можно найти бинарным поиском или два раза набирав жадно.
Асимптотика решения $$$O(n \operatorname{log} n)$$$ или $$$O(n \operatorname{log}^2 n)$$$
можно заметить, что пара действий $$$1 \, i \, j$$$, $$$2 \, k \, t$$$ и $$$2 \, k \, t$$$, $$$1 \, i \, j$$$ приводят к одинаковому результату, что это значит?
Это значит, что операции можно представить как две перестановки, описывающие то, какие обмены произойдут со строками и то, какие обмены произойдут со столбцами.
Попробуйте свести эту задачу к задаче о изоморфности графов.
Заведем две перестановки $$$p$$$ длины $$$n$$$ и $$$q$$$ длины $$$m$$$. Изначально обе перестановки тождественны. Для операции $$$1\, i \, j$$$, будем выполнять $$$\operatorname{swap}(p_i, p_j)$$$, для операции $$$2\, i\, j$$$ будем выполнять $$$\operatorname{swap}(q_i, q_j)$$$. Легко видеть, что после выполнения всех операций в позиции $$$i, j$$$ будет стоять $$$a_{p_i,q_j}$$$.
Теперь нужно найти подходящие перестановки $$$p, q$$$, чтобы $$$a_{p_i,q_j} = b_{i, j}$$$.
Давайте посмотрим на двудольный граф, где первая доля это строки, а вторая это столбцы. Пусть если $$$a_{i, j} \ne 0$$$, то из $$$i$$$ есть неориентированное ребро в $$$j$$$ цвета $$$a_{i, j}$$$. если построить такой же граф для $$$b$$$, то нам нужно проверить на изоморфность два двудольных графа каждое ребро которых имеет цвет, причем как мы помним по условию вершине не могут быть инцедентны 2 ребра одного цвета. Назовем их графом $$$a$$$ и графом $$$b$$$.
Эта задача во многом на реализацию, поэтому начиная с этого момента описываются действия, которые вы можете наблюдать в авторском решении 168728958.
Пусть $$$n < m$$$ иначе давайте поменяем $$$n$$$ и $$$m$$$ местами. Давайте попробуем сопоставить элементы массива $$$a$$$ элементам массива $$$b$$$. Давайте пройдемся по индексам от $$$1$$$ до $$$n$$$. Пусть сейчас мы выбираем, какую пару из $$$b$$$ выбрать для $$$i$$$-ой вершины первой доли графа $$$a$$$. Если мы уже нашли пару раньше, пропустим шаг, иначе давайте переберем подходящий вариант для пары среди всех еще не имеющих пары вершин первой компоненты $$$b$$$, таких не больше $$$n$$$, после сапостовления вершин, рёбра тоже сопоставляются однозначно(ведь не существует 2 ребер разных цветов), давайте, тогда запустим подставление рекурсивно для ребер(если мы сопоставили вершину $$$v$$$ вершине $$$u$$$ и из $$$v$$$ есть ребро цвета $$$x$$$ в $$$i$$$, а из $$$u$$$ есть ребро $$$x$$$ в $$$j$$$, то легко доказать, что в ответе $$$i$$$ будет сопоставлено с $$$j$$$), а значит мы восстановим всю компоненту. Пусть сумма числа вершин и числа ребер в компоненте это $$$k$$$, тогда мы выполним не больше, чем $$$n \cdot k$$$ действий для восстановления компоненты.
по перестановкам получить последовательность обменов это дело техники, его я объяснять не буду, но это отдельная функция в авторском решении вы разберетесь.
суммарно наше решение работает за $$$O(n(n \cdot m + n + m))$$$ изи за $$$O(min(n, m)(n \cdot m + n + m))$$$, где $$$n \cdot m + n + m$$$ суммарное число вершин и ребер во всех компонентах.
если вы чего-то не поняли, задавайте вопросы!
1718F - Бурёнка, массив и запросы
Единственная подсказка по этой задаче — вам не надо пытаться ее решить, оно того не стоит.
Для того, чтобы найти количество чисел от $$$1$$$ до $$$C$$$, взаимнопростых с $$$x$$$ выпишем его простые делители (различные). Пусть это простые числа $$$a_{1}, a_{2}, \ldots, a_{k}$$$. Тогда можно найти ответ за $$$2^{k}$$$ при помощи формулы включений-исключений.
Так как, $$$\left\lfloor\frac{a}{b\cdot c}\right\rfloor = \left\lfloor\frac{\left\lfloor\frac{a}{b}\right\rfloor}{c}\right\rfloor$$$, аналогичное утверждение выполнено и для $$$k$$$ чисел (можно делить нацело в любом порядке).
Разобьем простые числа до $$$2\times 10^4$$$ на 2 класса — мальнькие ($$$\leq 42$$$) и большие (остальные). Маленьких чисел 13, а больших 2249. Отдельно запишем пары больших чисел, которые в произведении дают число не превосходящее $$$10^5$$$. Таких пар будет 4904.
Сопоставим каждому набору маленьких простых чисел какую-то маску. Напишем $$$dp[mask]$$$ — знакопеременная сумма по подмаскам $$$mask$$$ чисел $$$\left\lfloor\frac{C}{a_{1} \cdot a_{2} \cdot \ldots \cdot a_{k}} \right\rfloor$$$, где $$$a_{1}, \ldots, a_{k}$$$ — простые из подмаски. Аналогично определим $$$dp[mask][big]$$$ (кроме маски есть большое простое $$$big$$$) и $$$dp[mask][case]$$$ (кроме маски есть пара простых из пары больших простых $$$case$$$). Каждое $$$dp$$$ можно насчитать за $$$states \times bits$$$, где $$$states$$$ — количество состояний в $$$dp$$$, а $$$bits$$$ — размер маски (количество битов).
Если выписать все большие простые на отрезке, для которого $$$mask$$$ — маска маленьких простых, ответом для этого отрезка будет сумма $$$dp[mask] + \sum dp[mask][big_{i}] + \sum dp[mask][case_{i}]$$$ (для $$$big$$$ и $$$case$$$, лежащих на отрезке). Таким образом, на запрос можно ответить за 7000 обращений к $$$dp$$$.
Для того, чтобы найти множетсво простых на отрезке, можно воспользоваться алгоритмом МО.
Итоговая асимптотика $$$O(n\sqrt{n} + q\times(\pi(m)+casesCount(C)))$$$
Стоит отметить, что (при очень сильном желании) можно дополнительно оптимизировать решение с помощью avx-инструций, а именно в 16 раз ускорить подсчет суммы по подмаскам в динамике, в 8 раз ускорить подсчет суммы $$$dp[mask][big]$$$, что позволит ответить на запрос за ~5000 (вместо 7000) обращений к $$$dp$$$, а предподсчет за $$$4\cdot 10^7$$$ вместо $$$7\cdot 10^8$$$ (на самом деле предподсчет работает намного быстрее за счет оптимизаций компилятора).
Пожалуйста, оцените задачи, это поможет нам сделать задачи лучше в следующий раз!
Вы можете выбрать одну лучшую задачу, или не выбирать, если считаете, что такой нет.
In Div1D, how it is easy to see that suitable d will form a contiguous segment. Can somebody please elaborate?
I think it's by far the hardest part of the entire problem, so the editorial's claim that it's easy is quite baffling.
But here's how someone explained it to me: by Hall's theorem, for there to be a matching between $$$x$$$ and intervals, you want for all sets of intervals $$$I$$$, the number of elements of $$$S$$$ inside these intervals must be greater than the number of intervals (let's say $$$x(I) \ge N(I)$$$). In other words, your added value $$$d$$$ is valid if and only if it is inside the union of intervals for every set $$$I$$$ such that $$$x(I) < N(I)$$$.
Now the trick is to realize that sets of intervals whose union is not a contiguous segment don't matter -- if a set whose union is two or more disjoint parts has $$$x(I) < N(I)$$$, then definitely one of the parts violates the condition as well, and that part alone would be a more restrictive condition on the added value $$$d$$$. Therefore the valid values of $$$d$$$ are in the intersection of some contiguous segments, which is a contiguous segment.
Wow!! Really nice proof. My approach didn't utilize this observation, it might be interesting to you.
Approach: The problem is same that we have $$$k$$$ intervals and $$$k-1$$$ points, one query point and we have to check whether we can perfectly match them or not.
The idea is to find those intervals, removing which we can perfectly match the given $$$k-1$$$ points and remaining $$$k-1$$$ intervals.
Let's match the intervals greedily:
Sort the intervals according to left endpoints
Sort the points in increasing order
Move from left to right and for the current point say $$$x$$$ insert all right endpoint values in a set whose left endpoint $$$\le x$$$(can be done using a pointer).
Match the point with the segment having the smallest $$$r$$$ value.
Also for each point, we can calculate what it will be matched to if the segment in the previous step was removed (-1 for those points that don't have such an option).
In the end, the set should have exactly one spare segment.
Let $$$seg_i$$$ be the segment alloted to $$$i^{th}$$$ $$$(1 \le i \le k - 1)$$$ interval and $$$seg_k$$$ be the only spare segment.
We can be sure that we can match $$$seg_k$$$ to $$$d$$$ ensuring that the remaining segments still have a perfect match.
Let's make a DP where $$$dp_i$$$ denotes whether we can remove $$$seg_i$$$ such that the remaining segments perfectly match with given $$$k-1$$$ points. Initially, $$$seg_k = true$$$.
Finally, we have all the segments in which $$$d$$$ can lie. Assuming segments do not always form a contiguous section, we can answer queries offline (using sweepline) or online (using segment tree).
Code
"Transposed" version of your solution can be used to prove that "suitable $$$d$$$ will form a contiguous segment" as well (and as a bonus, with a few standard tricks it can be implemented in $$$O(n \alpha(n))$$$, faster not only in theory but in practice).
Can we also just go in order of decreasing right endpoint and match every segment to its rightmost available value? I feel like this strategy works and is simpler.
Neat! Eventually it needs to be looked at in a way similar to this because we still need a way to construct the interval of valid $$$d$$$, even if we know it's an interval.
And it's easy to show it's an interval from your solution: $$$dp_i = dp_{nxt_i}$$$, and obviously $$$i$$$ and $$$nxt_i$$$ have at least one common point by the definition of $$$nxt_i$$$.
1718A2, I think the observations (segments of length 1 and 2) are pretty simple and obvious. The more interesting part is how to implement a solution from that. I worked like an hour on it and even did not solve A1.
The editorial answers this with "this amount can be calculated by dynamic programming or greedily." Thanks a lot!
Yeah, the editorial should definitely elaborate on that. And some of these observations aren't even needed for D1.
My DP approach: the optimal solution for an array of $$$n$$$ elements can be constructed by taking the optimal solution for the first $$$k$$$ elements (for some $$$k < n$$$) and then applying the XOR chain (overlapping segments of size 2) on the rest of the elements. We need to try each value of $$$k$$$, however, which leads to an $$$O(n^2)$$$ solution, maintaining both an array of optimal time as well as an array of accumulating XOR chain results for each possible starting index. This doesn't work in D1.
Greedy approach: maintain a running XOR while also storing each intermediate result in a set. If a result appears twice, i.e., $$$r \oplus a_i \oplus \oplus a_{i + 1} \oplus \cdots \oplus a_{i + k} = r$$$, then the subarray $$$a_i, \ldots, a_{i + k}]$$$ has a XOR sum of 0. We don't need to know where the subarray starts ($$$i$$$), but we just need to detect when it ends (when the running XOR is not a new value), so we can update the saving counter and reset the running XOR chain. You can check out just how simple it is over here: https://mirror.codeforces.com/contest/1719/submission/168640804
That being said, the observation that a running XOR will encounter an old element if a subarray has a XOR sum of 0 should definitely be included in the editorial, in my opinion, since that's essential to the greedy approach (unless the authors had a different greedy approach in mind).
Hi, I found a nice dp solution for div1 A1 :- https://mirror.codeforces.com/contest/1718/submission/168713136
Can you please help me to understand the transitions in following solution
It's literally according to the editorial.
How do you decide N=8191 ? It won't work with any other value.
It is just the maximum xor between 2 numbers between 1 and 5000
why we dont need to know where the subarray starts??
Say I have XOR equal to 0 for a subarray from index 4....20 and inside that we have a subarray from index 9....16 which have its XOR = 0 as well Then shouldn't not considering where the subarray would start be wrong in this case as I would have 2 saves in this case while if I clear the set when reaching index 16 then how would I know about the save for 4....20 ??
Just curious about this and couldn't actually understand how this works.
Any help would be really appreciated :)
We only want to count the number of non-overlapping subarrays with XOR of 0. If a 0-XOR subarray is inside a larger 0-XOR subarray, we will not benefit from exploiting the larger subarray, since we don't want to waste time in revisiting the smaller subarray.
For your example, if we find that 9-16 has a XOR of 0, then we can save 1 second from the 9-16 subarray. The "saving" means that we can perform the operation on [9, 10], [10, 11], [11, 12], [13, 14], [14, 15], and [15, 16]. We always choose $$$x$$$ as the current value of the first index we pick (so the first index turns into 0). Since indices 9-16 have a XOR value of 0, the latest operation of [15, 16] will also turn index 16 to 0, allowing us to make the 9-16 subarray (7 elements) into all 0s in 6 seconds.
The fact that the subarray from 4-20 also has a XOR of 0 is not something we can exploit anymore. It's true that, if we then perform the operation on pairs like [4, 5], [5, 6], ..., [18, 19], and [19, 20], then we will get them all to 0, but this requires revisiting indices 9 to 16, which are already 0! The operations from [8, 9] to [16, 17] take 8 seconds to perform, when it would have been much faster to just apply the operation on [8] alone, and then move on to [17, 18] and so on.
So it makes no sense to try to take advantage of BOTH the 9-16 subarray and the 4-20 subarray, because the moment you decide to exploit the 9-16 subarray, you turn this range into 0 (saving 1 second) and you don't want to touch this 9-16 subarray ever again. Now, it's possible that we could instead decide to exploit the 4-20 subarray directly without exploiting the 9-16 array; however, it's always better to exploit the subarray that ends the earliest first, since then you have more indices available for future exploits (e.g., if there is a subarray from say, 18-25 that has a XOR of 0, then we can save 1 second from 9-16 and another 1 second from 18-25; whereas if we instead decided to save 1 second from 4-20, then we are no longer able to save another second through 18-25 since 18-20 have been zero'd out).
Let me know if you're still confused about anything here.
I am quite the opposite of this, I couldn't do anything during the contest to both of the versions, and only when I was told the hint of segments of length 1 and 2, I solved the hard version instantly
Well, the above code is fairly simple, but actually I still do not really understand why this works.
What is the key idea we can see here instantly?
The Key Idea is to notice that the extra XOR that comes to a[i] before turning a[i] to zero with one operation can be represented as the xor subarray ending at index i-1 (can be empty) (where this subarray represents consecutive subarray of size 2 before going to index i), so to make a[i] already 0 before reaching it, we have to find a subarray ending at index i with xor sum equal to 0 (i.e find maximum j such that pref[i]^pref[j] = 0)
As far as I understood:
You can always use n steps to turn all elements to zero by just taking all indexes consecutively. And you want to improve this result. How you can do it?
You notice that there's no sense to use range of size greater than 2 since the given formula of seconds calculation. What can you do with this?
If you take two numbers a[i] and a[i+1] and apply xor with a[i] to them you can get two results:
1) [0,0] it means a[i]==a[i+1] => you saved 1 second here!
2) [0,X] now you can apply xor with X to next pair [X,a[i+2]] and so on. you can apply it until you get [0,0] pair or get to end of array and turn last element to zero with xor with range of 1. However you saved 1 second!
So what do these both situations have in common? xor of all elements in covered ranges equal to 0.
so now you can convert problem into finding count of subarrays with xor=0 (every subarray is a saved 1 second) and the answer will be n-(count of such subarrays)
"Unable to parse markup [type=CF_MATHJAX]" in problem D.
Can anyone share their div 1c solution using segment tree which passes for all factors of $$$n$$$ as claimed in the editorial? I used segment tree but got TLE.
Here is mine: 168744644.
I believe it is $$$O(n\sqrt{n} + q\sqrt{n}\log{n})$$$ or something like that.
Another approach for Div2 C, based on Editorial one.
Let's calculate next greater element and previous greater element. Then, for each $$$a_i$$$, we can calculate how many rounds athlete will win for infinite $$$k$$$. If previous greater element exist, he won't win a single round. Otherwise, the answer equals to distance between athlete and its next greater element.
When we answering queries, one should notice that an athlete start to fight after $$$i-1$$$ rounds — this is the time he should wait to get into second index and start fighting.
Time complexity: $$$O({n})$$$
https://mirror.codeforces.com/contest/1719/submission/168605787
Or we could do my weird solution:
submission: 168590217
instead of the previous greater element max of segment[0, i] should also work, right?
Yes, it's the same
I thoght quite similarly, and wrote this code:here. Can anyone detect the error here?
I did exactly what you said, i feel it's more intuitive.
Oh, wow, am I the only one who actually started filling up Sprague-Grundy values for Div2A (Chip Game) to realize and prove that they form a binary chessboard? I felt that this was more straightforward (albeit requiring knowledge on the Sprague-Grundy Theorem) than the number-theoretic observations.
Is it planned for solutions to be posted later? I'm curious to see whether the authors' solution for Div2E/Div1B actually passes some of the really nasty but valid input test cases.
I solve problem C (div2) in $$$O(n)$$$ time complexity:
submission : 168668282
me too my submission 168676244
There are $$$2$$$ conditions in this problem.
I use $$$tmp$$$ to mark the number of the steps to make the biggest value to the front of the array.
And array $$$cnt_i$$$ is used to count the number of the victories of the i_th player.
If $$$k \lt tmp$$$
There are two subtask in this conditions:
$$$val_{id}$$$ is the biggest number ($$$val_id == n$$$) then the answer should be
cnt[id] + k - tmp
, because this player will win after round $$$k - tmp - 1$$$Otherwise : the answer is $$$cnt_i$$$.
Otherwise
There are also two conditions:
I use array $$$r$$$ to mark the first element which is on its right and has a bigger value than it ( you can use a stack to get array $$$r$$$ in $$$O(n)$$$ in the begining.
The answer of this condition is
(id != 1) + min(r[id] - id - 1, k - id + 1)
In this way, I can get each answer in $$$O(1)$$$ and use $$$O(n)$$$ time to get $$$tmp$$$ and array $$$cnt$$$ and $$$r$$$.
Is there an English editorial for this contest?
Edit: The issue has been fixed. Thanks.
sorry, I accidentally removed it, but now it is returned
Any proof for Div 1B/2E why greedily choosing the letter with maximum frequency as the current last block will work?
You could maybe search more on Zeckendorf Representation, that's a formal name for the fibonacci-sum representation of a positive integer.
assume the answer is YES, with n+1 blocks total, then we can prove that the number of letters with third highest frequency cant be greater than F_n. If the last block used the letter with second highest frequency, then we can prove that ( because F_n = F_(n-1) + F_(n-2) ) the next two segments has to BOTH be from the letter from maximum frequency, that leads to a contradiction. Therefore the last block has to come from the letter of max frequency.
the parts I didn't prove can be done by messy but routine bounding
I'm sorry but i really do not understand the editorial of Div2D. Especially the "n − (the maximum number of disjoint sub-segments with a xor of 0) " part.
tried to make it clearer
Thank you. Got it!!
Another way to understand the solution to div1B is the Zeckendorf Theorem, which states that each positive integer can be uniquely represented by the sum of a set of unique fibonacci numbers where no two are adjacent.
We can apply this representation directly to the frequency of each letter and solve the problem.
And due to this uniqueness of the representation, the greedy solution will also always work.
DIV2 (ABCDEF)video Editorial for Chinese :
Bilibili
Сделал разбор на русском и получил ноль русских комментариев(
Держи русский комментарий.
Ещё один русский комментарий. Спасибо за русский разбор, очень удобно)))
Мне кажется можно в разборе d2/div2 сказать, как решить d1 и в чём отличие от d2
Я думаю, что подсказок для д1 хватает
по техническим причинам их нет в русской версии)
I remember now that there was a problem similar to Div2. D on USACO, except that it had to count the number of subsegments whose sum is divisible by some integer $$$k$$$ if I remember correctly. Similar observations to that problem but not quite the same.
Does anyone have the DP approach to Div2 D1? Also, is there a mistake in the Hint for A1 2? Is it a_i = v?
Hello there! A question to the authors of the round. I see that there are a lot of problems about Buryatia in this round. Is one of you from it, or is it just a meme? Thanks.
During contest my solution of problem B was accepted, but after thr contest it is showing that my time limit was exceeded at test case 5.Was that a bug?
Nope, not a bug. Looks like you failed system tests.
So, to put it short, the test cases that are run on your code during the contest are called pretests. These are normally not too big but are certainly meant to be strong. after the round is over, there will be system tests, which are basically extra cases added on to the pretests to make sure that your solution is indeed efficient/correct
My comment will be published soon
I have a solution with bitset in $$$O(\frac{nC\log n}{p(k)}+\frac{nC\log n}{w}+\frac{qC}{w}+\frac{2^kC}{w})$$$.
We just calculate the bitset of every subset of the first $$$k$$$ primes. For larger primes, we can use the trick called "猫树分治"(i don't know how to translate it into English, maybe it's called "cat tree divide and conquer").
Since std::bitset have an extremely small constant, we can solve this problem by this weird method.
Edit:
$$$p(k)$$$ is the $$$k$$$-th prime, i can't prove its exact bound, but it has a small constant.
Edit2:
I think $$$k=14$$$ or $$$k=15$$$ would be the fastest one, but it takes too much memory. It runs 1668 ms with $$$k=13$$$.
Hello SomethingNew, please can you explain , in problem 1718A2(hard version): What does disjoint sub-segments with XOR 0 actually mean ??
I know it is a very noob question and you can say that you have googled it and I have searched it and kind of understood that also. But in this problem , when using my that limited knowledge I kind of failed on working my own test cases/examples of this problem.
For example incase you want to know: the array I am confused on :
Not clearly able to find out "distinct subs-segments with XOR 0" .
if prefix_xor[i] = prefix_xor[j] then a[i+1] ^ a[i + 2] ^ ... ^ a[j] = 0, disjoint sub-segments means disjoint subarrays.
Если вдруг хочется, 1718F - Бурёнка, массив и запросы можно решать за $$$O(n \cdot q)$$$ — 169446727 и это работает достаточно быстро, чтобы получать АС на текущих тестах.
Идея в том, чтобы сделать сканлайн по левой границе запроса, и для каждого $$$x$$$ поддерживать минимальную позицию $$$first[x]$$$ такую, что $$$gcd(x, a[first[x]]) \ne 1$$$. Тогда для ответа на запрос $$$r$$$ нужно посчитать количество элементов в $$$first$$$, которые не больше $$$r$$$.
Вот тут можно почитать про решение детальнее.
Div.1 A~D solutions for Chinese readers. https://www.cnblogs.com/jklover/p/16595927.html
A2. Burenka and Traditions (hard version) https://mirror.codeforces.com/contest/1718/submission/169707649 I just can't understand Why Is This Giving TLE ??? Although its O(N)
https://mirror.codeforces.com/blog/entry/62393
read this
Thanks a lot, bro. That really was quite helpful.
I don't think the editorial of 1E is understandable, but my poor English doesn't allow me to write a whole editorial.
But I can give a proof for the time complexity. Consider divide the connected components of the two graphs into groups, such that each component in a group has the same number of left vertices. Then we can consider only matchings between vertices that their connected components are in the same group.
Now we only consider components in the $$$i$$$-th group. Let the $$$x_i$$$ be the number of left vertices in each component, $$$y_i$$$ be the number of components in the graph $$$a$$$, $$$z_i$$$ be the number of edges in the graph $$$b$$$. If $$$x_i=0$$$, each of the components is made up of only a right vertices. It's easy to deal with this situation.
Otherwise $$$x_i\ne0$$$. Consider a component in $$$a$$$ and a vertex $$$u$$$ in it, we are looking for a vertex to match with $$$u$$$. For an edge in $$$b$$$, suppose the edge belongs to the component $$$S$$$, then the edge will contribute to the time only when we try to match $$$u$$$ with some left vertex in $$$S$$$. So the time complexity of dealing with this group is $$$O(x_iy_iz_i)$$$, and the total time is $$$\sum x_iy_iz_i\le(\sum x_iy_i)(\sum z_i)=O(n^2m)$$$. Now we can solve the whole problem in $$$O(nm\sqrt{nm})$$$ time.
coincidentally, i notice div2C this time is so similar with 569 div2C. XD
Stuck in Fibonacci Strings : 1718B (link: https://mirror.codeforces.com/problemset/problem/1718/B) since the past few days, cant think why it is going wrong, any help would be really nice.
Subsmission: https://mirror.codeforces.com/problemset/submission/1718/170409697 Test 9: WA in test 136 — found YES instead of NO.
Take a look at Ticket 16135 from CF Stress for a counter example.
Thanks a lot!
Can anyone find out my error in this code? It WA on test 2.560 :(
1718A1 — Burenka and Traditions (easy version)
"Note that if a segment of length 2 intersects with a segment of length 1, they can be changed to 2 segments of length 1."
Can someone help me understand this. If a segment of length 1 intersects a segment of length 2, it lies completely inside it, right? I do not understand the purpose of this statement. I know that I'm missing something very silly.
I just did the basic 2-length segment thing, which fails 183824117. I cannot find a case where it fails though. Please if somebody could help me out. Thanks!
Also if possible, it will be very helpful if the problem setters could create small test cases ( preferably corner cases ) which can fit the status screen, for say first five test cases. It will help a lot while upsolving/practising. I know WA is a mistake from our part, but doing this will help us a lot. Thanks!
Take a look at Ticket 16540 from CF Stress for a counter example.
Thanks! I handled this case but I still don't understand the editorial :(
Funny, but there is bruteforce soultion of problem Div1/B: 184648373
Fibonacci Strings : 1718B submission: https://mirror.codeforces.com/contest/1718/submission/194429652
Why am i getting TLE??
got it, solution was int to long long int!!
it's been a while but for problem C we can use monotonic stack good luck everyone !!!
Another stupid solution to div1F:
First, do divide and conquer on the queries to remap them to "answer this query given the set of these prime numbers in my range" (storing them in a bitset of O(primes under M) size)
Then, sort the queries in bitset lexicographical order (where primes[0] = 2, primes[1] = 3, etc.). Process them left to right, and process adjacent differences in bitsets; whenever we add/remove a bit, naively do O(C / prime[i]) work on all of the multiples of the number to maintain how many times that multiple is hit. We want to maintain how many indices are non-zero.
To really squeeze and cache optimize this, make everything chars since max # distinct prime factors under 2e4 = 6.
you can show that the sum of O(C / prime[i]) ops takes ~2e4 * MAXC operations in the worst case [sum of 2 *(1/2) + 4 * (1/3) + 8 * (1/5)... until we exhaust (max # distinct prime factors) * N terms] * 2 * MAXC, but I guess 2e9 simple operations are fast enough.