Спасибо за участие в раунде! Мы надеемся, что вам понравились задачи. Нам очень жаль, что с условием в задаче B возникли проблемы.
На раунд было предложено суммарно 30 задач
E задумывалась как C, а C — как B
2189A - Таблица, а в ней числа
Идея: Fakewave
Заметим, что максимизация суммы чисел в таблице равносильна максимизации количества пар чисел, которые образуют клетку таблицы.
Не ограничивая общности, будем считать, что $$$h \leq l$$$. Для любой клетки таблицы $$$(x, y)$$$ выполнено: $$$1 \leq x \leq h$$$, $$$1 \leq y \leq l$$$. Пусть $$$cnt_h$$$ — количество чисел массива, не превосходящих $$$h$$$, а $$$cnt_l$$$ — количество чисел массива, не превосходящих $$$l$$$. Тогда, во первых, ответ не превосходит $$$cnt_h$$$, ведь в каждой паре должно быть число, не превосходящее $$$h$$$. С другой стороны, ответ не превосходит $$$\displaystyle \Big\lfloor \frac{cnt_l}{2} \Big\rfloor$$$, ведь в каждой паре оба числа должны не превосходить $$$l$$$. Остается понять, что $$$\displaystyle min(cnt_h, \Big\lfloor \frac{cnt_l}{2} \Big\rfloor)$$$ пар можно получить. Для этого разберём два случая.
если $$$\displaystyle cnt_h \leq \Big\lfloor \frac{cnt_l}{2} \Big\rfloor$$$, то достаточно в пару каждому числу $$$x \leq h$$$ дать в пару своё число $$$h \lt y \leq l$$$, и будет $$$cnt_h$$$ пар. Это получится сделать, так как подходящих чисел $$$y$$$ не меньше, чем подходящих $$$x$$$.
если $$$\displaystyle cnt_h \gt \Big\lfloor \frac{cnt_l}{2} \Big\rfloor$$$, то нужно в пару каждому числу $$$h \lt y \leq l$$$ дать в пару своё число $$$x \leq h$$$. После этого разбить оставшиеся числа $$$x \leq h$$$ на пары (возможно, останется одно лишнее число). Получится как раз $$$\displaystyle \Big\lfloor \frac{cnt_l}{2} \Big\rfloor$$$ пар.
Заметим, что задача равносильна минимизации откатов для достижения точки с числом $$$\geq x$$$. (Рассмотрим момент, когда лягушка впервые оказалась в точке $$$\geq x$$$. Тогда вместо полного прыжка лягушка могла прыгнуть не на полную длину, а ровно в точку $$$x$$$). Тогда будем считать, что лягушка всегда прыгает на $$$a_i$$$ делений вперед $$$i$$$-м видом прыжка.
Во первых, лягушка может использовать прыжок $$$i$$$-го вида $$$b_i-1$$$ раз, не испытав откат. Пусть $$$r$$$ это количество делений, которое осталось до числа $$$x$$$ после этих прыжков (если $$$r \leq 0$$$, то нужно $$$0$$$ откатов).
Теперь у нас любой прыжок будет создавать откат. Однако заметим, что после одного прыжка с откатом, использовав $$$i$$$-й вид прыжка, мы можем использовать этот же прыжок еще $$$b_i-1$$$ раз, не испытав откат. После этого мы окажемся в той же ситуации (любой прыжок создает откат), однако мы переместимся на $$$a_ib_i-c_i$$$ делений. Таким образом, стоит использовать прыжок с максимальным значением $$$a_ib_i-c_i$$$.
Пусть $$$m = \max(a_ib_i-c_i)$$$ по всем $$$i$$$ от $$$1$$$ до $$$n$$$. Тогда если $$$m \leq 0$$$, то мы не сможем переместиться вперед (т.к. мы сначала испытываем откат на $$$c_i$$$, а затем движемся вперёд на $$$a_ib_i$$$), и ответ $$$-1$$$. Иначе потребуется $$$\displaystyle \Big\lceil \frac{r}{m} \Big\rceil$$$ откатов.
2189C1 - XOR-удобство (простая версия)
Идея: Fakewave
Во первых, заметим, что $$$p_i = p_j \oplus i$$$ равносильно $$$p_i \oplus i = p_j$$$. Для $$$i = n-1$$$ в качестве $$$j$$$ может выступать только $$$j = n$$$. Давайте попробуем сделать такую перестановку, что для всех $$$i$$$ в качестве $$$j$$$ будет выступать $$$j = n$$$. То есть хотим сделать так, чтобы для всех $$$i \geq 2$$$ было выполнено $$$p_i \oplus i = p_n$$$. Возьмем $$$p_n = 1$$$. Тогда замечаем, что на позиции $$$2k$$$ должно стоять $$$2k \oplus 1= 2k+1$$$, а на позиции $$$2k+1$$$ должно стоять $$$(2k+1) \oplus 1 = 2k$$$. То есть числа разбиваются на пары $$$2k$$$ и $$$2k+1$$$.
Разберем $$$2$$$ варианта:
$$$n$$$ четное, тогда возьмем $$$p_1 = n$$$, $$$p_{2k} = 2k+1$$$, $$$p_{2k+1} = 2k$$$ ($$$1 \leq k \leq \frac{n}{2} - 1$$$);
$$$n$$$ нечетное, тогда возьмем $$$p_1 = n-1$$$, $$$p_{2k} = 2k+1$$$ ($$$1 \leq k \leq \frac{n-1}{2}$$$) , $$$p_{2k+1} = 2k$$$ ($$$1 \leq k \leq \frac{n-3}{2}$$$).
Случаи различаются тем, что на $$$p_1$$$ останутся разные числа.
Например, при $$$n = 9$$$: $$$[8, 3, 2, 5, 4, 7, 6, 9, 1]$$$, при $$$n = 10$$$: $$$[10, 3, 2, 5, 4, 7, 6, 9, 8, 1]$$$.
2189C2 - XOR-удобство (сложная версия)
Во первых, докажем, что при $$$n = 2^x$$$ ($$$x$$$ — целое) не существует примера.
Пусть $$$n$$$ стоит на позиции $$$i$$$. Предположим, что $$$i \lt n$$$. Тогда $$$p_i \oplus i= p_j $$$, для некоторого $$$j$$$. Но $$$p_i \oplus i \geq n$$$, ведь $$$p_i = n = 2^x$$$, а $$$p_j \lt n$$$ — противоречие. Значит $$$i = n$$$. Но тогда $$$p_{n-1} = p_n \oplus (n-1)$$$. Но $$$p_n \oplus (n-1)$$$ больше $$$n$$$, а $$$p_{n-1}$$$ меньше — противоречие.
Для $$$n \neq 2^x$$$ покажем, что пример существует.
Рассмотрим примеры, взятые в C1. Заметим, что при нечетном $$$n$$$ пример подходит, ведь $$$p_1 = n-1$$$, а где то после стоит число $$$n$$$ и $$$n \oplus 1 = (n-1)$$$. Теперь рассмотрим пример для четного $$$n$$$.
$$$n = 2^x+r$$$, где $$$r \lt 2^x$$$ (иными словами, $$$x$$$ — старший бит $$$n$$$). Тогда давайте поменяем местами $$$p_1$$$ и $$$p_r$$$. Давайте посмотрим, что изменилось. Так как для всех $$$i \geq 2$$$ до этого в качестве $$$j$$$ выступало только $$$n$$$, то сломаться могло только число, стоящее на позиции $$$r$$$. Но теперь $$$p_r = n$$$. Заметим, что $$$2^x \oplus r = n$$$ и при этом число $$$2^x$$$ стоит на позиции $$$2^x+1$$$. Таким образом, для $$$i = r$$$ теперь подходит $$$j = 2^x+1 \gt r$$$.
Остается проверить, что $$$i = 1$$$ имеет подходящее $$$j$$$. Возьмем $$$j = r + 1$$$. $$$n$$$ — четное, а значит $$$r$$$ — четное. Тогда $$$p_j = r$$$ и $$$p_1 = r+1$$$. Действительно: $$$r+1 = r\oplus 1$$$.
2189D1 - Маленькая строчка (простая версия)
Рассмотрим, какие перестановки $$$p$$$ удовлетворяют условию строки $$$w$$$. Очевидно, что если $$$w_1 = \texttt{0}$$$ или $$$w_n = \texttt{0}$$$, подходящих $$$p$$$ нет (в любой перестановке есть подотрезок только с числом $$$0$$$ и подотрезок со всеми числами), поэтому дальше считаем, что $$$w_1 = w_n = \texttt{1}$$$. Давайте конструировать $$$p$$$, начиная с $$$p = [0]$$$ и вставляя по очереди числа $$$1, 2, \ldots, n - 1$$$ в какие-то позиции.
Пусть мы расставили числа $$$0, 1, \ldots, k - 1$$$ и теперь собираемся вставить число k относительно них. У нас есть $$$k + 1$$$ вариантов, куда его вставить.
Если мы вставим $$$k$$$ перед всеми числами, либо после всех чисел, то мы можем всегда выбрать все оставшиеся числа в качестве отрезка и получить на них $$$\operatorname{mex} = k$$$ (заметим, что вставка последующих чисел не повлияет на $$$\operatorname{mex}$$$ этого отрезка, поскольку все последующие значения $$$ \gt k$$$).
Если же мы вставим $$$k$$$ между какими-то значениями, то мы получим ситуацию, что у нас и слева, и справа от $$$k$$$ есть значение, которое $$$ \lt k$$$. Тогда, чтобы получить $$$\operatorname{mex} = k$$$, нам надо набрать все числа $$$ \lt k$$$, но поскольку они есть и слева, и справа, мы включим $$$k$$$, и получим $$$\operatorname{mex} \gt k$$$.
Итого, у нас есть $$$2$$$ варианта, как обеспечить $$$w_k=1$$$, и $$$k-1$$$ вариант для $$$w_k=0$$$. Мы получили, что
В этой версии задачи $$$w = s$$$, а значит нужно лишь проверить, делится ли $$$f(w)$$$ на $$$c$$$. Для этого пройдемся по всем $$$i$$$ и будем сокращать $$$c$$$ на наибольший общий делитель очередного множителя и числа $$$c$$$. Если в итоге получилось $$$c = 1$$$, то ответ $$$-1$$$. Иначе ответ $$$f(w)$$$.
2189D2 - Маленькая строчка (сложная версия)
Из D1 имеем:
Посчитаем произведение членов-множителей для всех символов $$$s$$$, которые даны (\texttt{0} или \texttt{1}), назовём это число $$$b$$$; произведение остальных членов назовём $$$x$$$. Остальные символы мы можем выбирать, то есть нам нужно найти наименьшее значение
не делящееся на $$$c$$$. От $$$b$$$ можно избавиться — $$$x$$$ не должен делиться на $$$c' = \frac{c}{\gcd(b, c)}$$$. (В реализации для получения $$$c'$$$ мы делим $$$c$$$ на $$$\gcd$$$ с каждым членом произведения $$$b$$$ во избежание переполнения.) Если мы можем выбирать $$$s_2$$$, то выберем $$$s_2 = \texttt{1}$$$, что сделает один из членов произведения равным $$$1$$$ — это не вызовет делимость и не увеличит число. В итоге, мы должны выбрать для нескольких $$$j \ge 2$$$ (для $$$j = i - 1$$$, где $$$s_i = \texttt{?}$$$) умножить $$$x$$$ либо на $$$2$$$, либо на $$$j$$$, чтобы произведение было минимально и не делилось на $$$c'$$$, и ответом будет $$$bx$$$.
Рассмотрим два случая.
- $$$c'$$$ — степень $$$2$$$. Для всех чётных $$$j$$$ выберем умножать на $$$2$$$, т.к. умножение на $$$2$$$ вместо положительного чётного числа не вызовет делимость и не увеличит произведение. Остаётся жадно выбирать умножение на $$$2$$$ для наибольших из оставшихся $$$j$$$, пока это возможно ($$$c'$$$ всё ещё не делит $$$x$$$), чтобы минимизировать $$$x$$$.
- $$$c'$$$ — не степень $$$2$$$. Тогда выбирая каждый раз умножение на $$$2$$$, $$$x$$$ не поделится на $$$c'$$$, а произведение будет минимальным, т.к. каждый раз мы выбирали меньший из возможных множителей ($$$2 \le j$$$).
Итоговая асимптотика: $$$\mathcal{O}(n \log n)$$$.
2189E - Большинство побеждает?
Сразу скажем, что ответ $$$-1$$$, если строка состоит из $$$0$$$.
Пусть мы сделали $$$k$$$ операций, $$$i$$$-я из которых стоила $$$a_i$$$. Тогда $$$(a_1-1)+(a_2-1)+\cdots+(a_k-1) = n-1$$$ (количество символов, которые надо удалить), откуда $$$cost = a_1+a_2+\cdots+a_k=n-1+k$$$. То есть задача переходит в найти наименьшее число операций $$$k$$$, для достижения цели. Ответ будет $$$n-1+k$$$.
Покажем, что $$$k \leq 4$$$. Пусть $$$s_i = 1$$$. Заменим подстроки $$$[1, i-1]$$$ и $$$[i+1, n]$$$ на какие-нибудь символы. Теперь у нас строка $$$x1y$$$. Заменим подстроку $$$[1, 2]$$$ на $$$1$$$, получится строка $$$1y$$$. Остается заменить её на строку $$$1$$$.
Теперь разберемся, когда минимальное число операций это $$$k = 0, 1, 2, 3$$$ (иначе $$$k = 4$$$).
Под \textbf{разностью} строки будем подразумевать разность между количеством единиц и нулей.
Утверждается, что за $$$k$$$ операций можно сделать, если:
$$$k = 0$$$ Когда $$$s = 1$$$.
$$$k = 1$$$ Разность строки неотрицательная.
$$$k = 2$$$ В строке есть префикс/суффикс с положительной разницей (тогда оставшуюся часть можно заменить на любой символ и после этого перевести всю строку в $$$1$$$) или разность строки равна $$$-1$$$ (тогда если первое условие не выполнено, то можно сделать операцию замены подстроки $$$[1, n-1]$$$ на $$$1$$$ (ведь её разность $$$0$$$, т.к. $$$s_n = 0$$$), получится строка $$$10$$$, которую можно перевести в $$$1$$$ одним действием).
$$$k = 3$$$ В строке есть префикс/суффикс с неотрицательной разницей (тогда оставшуюся часть можно заменить на $$$0$$$, эту часть на $$$1$$$ и получится строка $$$10$$$ или $$$01$$$, дальше достаточно одной операции) или есть $$$2$$$ единицы подряд (тогда заменим префикс и суффикс до них на что-то, получится строка с разницей $$$\geq 0$$$, которую можно перевести в $$$1$$$).
- $$$k = 4$$$ Иначе. Перейдем к доказательствам для $$$k \geq 2$$$.
$$$k = 2$$$
Предположим, что нельзя за $$$k \lt 2$$$ операции и можно за $$$k = 2$$$, при условии что разница не $$$-1$$$ и нет префикса/суффикса с положительной разницей. Если первая операция — префикс или суффикс, то в этой подстроке разница $$$\geq 0$$$. Чтобы после этого можно было победить за $$$1$$$ операцию, в оставшейся части должна быть разница $$$-1$$$ (т.к. если разница $$$\geq 0$$$, то разница всей изначальной строки неотрицательная, а если $$$ \lt -1$$$, то суммарная разница после $$$1$$$ операции $$$ \lt 0$$$). Тогда разница всей строки тоже $$$-1$$$. Если же первая операция какая-то другая, то после операции разница $$$\leq -1 + 1 + -1 = -1$$$ (префикс + подстрока + суффикс). То есть победить не получится.
$$$k = 3$$$
Предположим, что нельзя за $$$k \lt 3$$$ операции и можно за $$$k = 3$$$, при условии что нет префикса/суффикса с неотрицательной разницей и нет двух единиц подряд.
Пусть изначально разность равна $$$z$$$. Пусть мы делаем операцию с подстрокой $$$l$$$, $$$r$$$. Тогда пусть в подстроке $$$1$$$, $$$l-1$$$ разность равна $$$a \lt 0$$$, в подстроке $$$l$$$, $$$r$$$ равна $$$b$$$, а в подстроке $$$r+1$$$, $$$n$$$ равна $$$c \lt 0$$$.
Если $$$b = 0$$$, то теперь разность становится $$$a+1+c$$$.
Пусть $$$a+c+1 = -1$$$. Тогда так как $$$a + c = -2$$$ и $$$a,c \leq -1$$$, то $$$a = -1$$$ и $$$c = -1$$$. Но тогда если подстрока $$$l$$$, $$$r$$$ начинается с $$$0$$$ и заканчивается $$$0$$$ (иначе префикс $$$1\ldots l$$$ или суффикс $$$r\ldots n$$$ имеет разность $$$\geq 0$$$). Но тогда подстрока $$$l+1$$$, $$$r-1$$$ имеет разность $$$2$$$. Тогда размер этой подстроки четный (ведь если нулей $$$x$$$, то единиц $$$2+x$$$, а значит всего символов $$$2+2x$$$). Поделим символы на пары соседних $$$(l+1, l+2; \dots; r-2, r-1)$$$. В каждой из них разность $$$\leq 0$$$ (т.к. не $$$2$$$ единицы), а значит разность этой подстроки не равна $$$2$$$. Значит, такое невозможно.
Другой случай: появится положительный префикс/суффикс (не ограничивая общности, префикс). ($$$l$$$, $$$r$$$ — не префикс и не суффикс, т.к. $$$b = 0$$$).
Заметим, что получившийся положительный префикс $$$T$$$. Понятно, что $$$T$$$ будет содержать $$$1$$$ (которую получили из $$$b$$$) и ещё что-то из суффикса $$$r+1 \ldots n$$$ (обозначим его за $$$M$$$), причём это что-то имеет разность $$$ \gt 0$$$. Тогда если эта разность $$$d$$$, то у $$$T$$$ разность $$$a+1+d \geq 1$$$. Тогда $$$a+d \leq 0$$$. Ранее мы показали, что $$$d \leq 1$$$ (иначе есть $$$2$$$ единицы подряд). Тогда $$$a \geq -1$$$. Значит, $$$a = -1$$$. Тогда $$$M$$$ начинается с $$$0$$$ (иначе $$$a+b+1 = 0$$$ и мы имеем префикс $$$\geq 0$$$). Тогда оставшийся используемый префикс $$$M$$$ имеет разность $$$2$$$, а значит содержит $$$2$$$ подряд идущие единицы — противоречие.
$$$b \lt 0$$$.
Если разность становится $$$-1$$$, то тогда теперь разность равна $$$a-1+c$$$. $$$a-1+c = -1 \implies a+c = 0$$$, что невозможно.
Другой случай: появится положительный префикс/суффикс (не ограничивая общности, префикс).
Пусть $$$l = 1$$$. Тогда после этого суффикс $$$r+1, \ldots, n$$$. Теперь получается $$$0$$$ + префикс из $$$M$$$. Но тогда этот префикс должен иметь разность $$$\geq 2 \implies$$$ есть $$$2$$$ единицы — противоречие.
Иначе мы содержим префикс $$$1 \ldots (l-1)$$$ + $$$0$$$ (полученный из $$$b$$$) + префикс $$$(r+1 \ldots n)$$$ (обозначим его за $$$M$$$). Тогда этот префикс должен иметь разность $$$\geq 3$$$ (т.к. у $$$1 \ldots (l-1)$$$ разность $$$\leq -1$$$, а ещё и $$$0$$$ появляется). Тогда есть $$$2$$$ единицы подряд — противоречие.
Идея: yanb0
Будем называть вершину мёртвой, если в ней $$$0$$$ гаек, и при подвешивании за неё среди поддеревьев её детей не больше одного поддерева с положительной суммой количеств гаек.
Будем записывать операцию перемещения для вершины $$$v$$$ как $$$\operatorname{c}(v)$$$.
Пусть $$$A$$$ — лес, состоящий из всех живых вершин. Докажем, что $$$A$$$ всегда связный, т.е. является деревом. Если для противоречия $$$A$$$ состоит хотя бы из двух компонент связности, на пути между ними должна найтись мёртвая вершина $$$v$$$, но с другой стороны $$$v$$$ живая, т.к. обе компоненты связности находятся в разных поддеревьях детей $$$v$$$ при подвешивании за $$$v$$$, противоречие, ч.т.д.
Пусть $$$\deg(v)$$$ — степень вершины $$$v$$$ в $$$A$$$. Несложно заметить, что при применении $$$\operatorname{c}(v)$$$, $$$a_v := a_v + \deg(v)$$$, а для всех остальных вершин $$$u \in A$$$, $$$a_u := a_u + \deg(u) - 2$$$. Если $$$v \not \in A$$$, то $$$a_v := a_v + 1$$$, $$$a_u := a_u + \deg(u) - 2$$$, $$$a_p := a_p + \deg(p) - 1$$$, где $$$p$$$ — ближайшая к $$$v$$$ вершина из $$$A$$$. $$$[*]$$$
Для последовательности действий определим дерево $$$L$$$ как $$$A$$$ в момент после всех операций $$$\operatorname{c}(v)$$$ и до съедения гаек.
Пусть у нас есть последовательность операций (включая съедение), приводящая к тому, что гаек не останется. Докажем, что последнюю из операций $$$\operatorname{c}(v)$$$, где $$$v \not \in L$$$, можно заменить на операцию $$$\operatorname{c}(u)$$$, где $$$u \in L$$$, при этом $$$A$$$ станет своим нестрогим подмножеством, и гаек опять же не останется. Рассмотрим момент перед применением $$$\operatorname{c}(v)$$$. Есть два варианта:
$$$v$$$ жива. Тогда при замене $$$\operatorname{c}(v)$$$ на $$$\operatorname{c}(u)$$$, $$$a_v$$$ уменьшится на $$$2$$$, а $$$a_u$$$ увеличится на $$$2$$$ по $$$[*]$$$.
$$$v$$$ мертва. Пусть $$$p$$$ — ближайшая к $$$v$$$ вершина из $$$A$$$. Тогда при замене $$$\operatorname{c}(v)$$$ на $$$\operatorname{c}(u)$$$, $$$a_v$$$ и $$$a_u$$$ уменьшатся на $$$1$$$ (станут равными $$$0$$$), а $$$a_p$$$ увеличится на $$$1$$$ по $$$[*]$$$.
В обоих случаях, все $$$a_x$$$ для $$$x \not \in L$$$ уменьшатся, и несложно видеть, что последовательность операций после $$$\operatorname{c}(v)$$$ также приведёт все гайки в $$$L$$$, после чего те же самые операции съедения уберут все гайки, ч.т.д. Таким образом, все операции типа $$$\operatorname{c}(v)$$$, где $$$v \not \in L$$$, можно (последовательно с конца) заменить на $$$\operatorname{c}(u)$$$ для некоторых $$$u \in L$$$.
Теперь остаётся решить следующую задачу:
Нужно выбрать поддерево $$$L$$$ изначального дерева, потом несколько раз применить $$$\operatorname{c}(u)$$$, $$$u \in L$$$, чтобы сделать все вершины не из $$$L$$$ мёртвыми, а затем применить операцию съедения для всех $$$v \in L$$$. Заметим, что по $$$[*]$$$ все вершины не из $$$L$$$ станут мёртвыми вне зависимости от того, какие вершины $$$L$$$ мы выбираем, иными словами, можно применять все $$$\operatorname{c}(v)$$$ только к одной вершине $$$v$$$.
Представим динамику по ориентированным рёбрам $$$xy$$$, $$$dp[x][y]$$$: наименьшее количество операций $$$\operatorname{c}(v)$$$, где $$$v$$$ со стороны $$$x$$$ от $$$xy$$$, нужное, чтобы сделать все вершины со стороны $$$y$$$ (включая $$$y$$$) от $$$xy$$$ мёртвыми. Значение $$$a_y$$$ может уменьшаться только когда $$$\deg(y) = 1$$$, поэтому $$$dp[x][y] = \sum_{i=0}^{k}\Bigl(dp[y][ch[i]]\Bigr)$$$, то есть $$$dp[x][y]$$$ равно сумме $$$a_v$$$ по всем $$$v$$$ в поддереве $$$y$$$, если подвесить всё дерево за $$$x$$$.
Для всех вершин $$$v \not \in L$$$ в какой-то момент и всегда после него $$$a_v = 0$$$, а ещё возможно, что $$$a_v = 0$$$ перед всеми операциями, больше никогда $$$a_v$$$ не равно $$$0$$$.
Определим $$$zero[y]$$$ как наименьшее количество операций $$$\operatorname{c}(v)$$$, нужное, чтобы $$$a_y = 0$$$ после любого количества операций $$$\operatorname{c}(v)$$$, не меньшем $$$zero[y]$$$. $$$zero[y] = \min_x({dp[x][y]})$$$ для всех $$$x$$$, смежных с $$$y$$$, и $$$zero[y] = 0$$$, если изначально $$$a_y = 0$$$ и $$$\deg(y) = 2$$$. Это так, потому что если $$$a_y \ne 0$$$ или $$$\deg(y) \ne 2$$$, $$$y$$$ окончательно "обнулится", только когда станет мёртвой. $$$\min_x({dp[x][v]})$$$ больше $$$dp[v][u]$$$ для всех, возможно, кроме одной, вершин $$$u$$$, смежных с $$$v$$$, а значит, больше $$$\min_t({dp[t][u]})$$$ для $$$t$$$, смежных с $$$u$$$, смежных с $$$v$$$. Значит, применяя $$$\operatorname{c}(v)$$$ к $$$v$$$ с наибольшим $$$zero[v]$$$, каждое $$$a_u$$$ станет равным $$$0$$$ после $$$zero[u]$$$ операций.
Таким образом, либо операций $$$\operatorname{c}(x)$$$ нет, и операцию съедения нужно применить ко всем $$$y$$$ с начальным $$$a_y = 0$$$, либо операций $$$\operatorname{c}(x)$$$ $$$k$$$, и операцию съедения нужно применить ко всем вершинам $$$y$$$ с $$$zero[y] \ge k$$$. Для первого случая просто посчитаем стоимость этой последовательности операций, а для второго случая за $$$O(n \log n)$$$ отсортируем $$$zero$$$, после чего переберём количество "обнулённых" вершин, пробегаясь по $$$zero$$$, будем считать ответ как $$$(n - i) \cdot q + zero[i - 1] \cdot p$$$. Ответом на задачу будет минимальный из полученных.
Суммарная асимптотика: $$$O(n \log n)$$$.









Автокомментарий: текст был обновлен пользователем Fakewave (предыдущая версия, новая версия, сравнить).
thanks for the fast editorial
First
Автокомментарий: текст был обновлен пользователем yanb0 (предыдущая версия, новая версия, сравнить).
Great contest C2 and A made me cry
C1, C2 good problems.. B was so greedy... I think A is better than B A was interesting
D1 was easy Should try more.
if (s[i] is 1) ans *= 2; else ans *= i — 1;
B statement was too rubbish !!!
This change later --> bith , 2*bith ,..
that made things actually clear
Was B easier than A?
nah
clearly no
No
nuh uh. tho A seemed interesting
they kinda felt similar in difficulty
no
nah, i'd win
goated niche reference, gonna make sukuna suffer a like div 2 D.
Nice problems, english could be better. Would be better if it was 2.5 hrs.
Great contest! Explanation given in questions could have been better.
Thanks for the contest. It was hard, i was stuck on A for two hours, felt like i should be able to solve at least A. I mean its supposed to be the easiest. After reading the fun fact, it made me think juts how much I need to practice more.
Ps: Someone plz confirm if this contest was really authored by high school students, i mean damn!
same here bro I couldn't even solve A during contest but somehow I managed to solve B 30 min before contest end. Happy to know many people felt the same. Now I am more pumped to practice more.
I consider A is not so hard.I made it in 30 minutes and got ac for the first submission.But i was stuck in B and C for 1 hour.I saw the Tutorial after the contest and now i think B is easy indeed,but i was so stupid.
Yep B was easy but difficult to understand I suppose. Although I couldn't spend time on C1 bcz my morale just broke in start as I couldn't solve A and was finding B to be difficult to understand.And yes A is ezy now as I read its tutorial but I never got the intuition for it during contest.
tbh, when i saw the editorial it still didn't made full sense, but the logic they used was just amazing, i mean its something simple, and a logical but it just didn't hit me at that time. i was handling the complexity of how to count numbers less than h and l without duplicates and so.
yeah i mean the sheer demotivation of not solving A was too much for me, I never used so much brain on A, though it feels good to know i have to work on.
it make sense that this contest was made by high school student.I know a student who learnt c plus plus in middle school.
This is some text.
The rest of the text. I don't know why I can pass just by swapping the first and last numbers in the output.
My first contest, unable to solve C2. Hope I can get better next time.
Maybe D1 is not so complex?
Maybe you can compute answer modulo c and check if it is 0 like this?
Sorry for my bad english :(
I used a two pointer approach to solve A https://mirror.codeforces.com/contest/2189/submission/359430375 ~~~~~ #include <bits/stdc++.h> using namespace std;
int main() { cin.tie(0)->sync_with_stdio(0); //clock_t tStart = clock(); int T; cin>>T; while(T-- > 0) { int n, l, h; cin>>n>>h>>l; vector<int> v(n); for(auto &num : v) cin>>num; sort(v.begin(), v.end()); int mx = max(l, h); int mn = min(l, h); int left = 0, right = n-1; int res = 0; while(left < right) { if(v[left] > mn) break; if(v[right] > mx) { right--; continue; } res++; left++; right--; } cout<<res<<'\n'; } //printf("Time taken: %.2fs\n", (double)(clock() - tStart)/CLOCKS_PER_SEC); return 0; }~~~~~
Yes, I also used two pointers for problem A : 359421026
// i think this is an easier approach ~~~~~~~~~~~~~~~~~ void solve(){
ll n, h, l; cin >> n >> h >> l; ll x = min(h,l), y = max(h,l); ll a[n], small=0, big =0; for(ll i=0; i<n; i++){ cin >> a[i]; if(a[i]<=x )small++; else if(a[i]<=y)big++; } if(small >= big){cout << (small+big)/2 << endl;} else{cout << small << endl;}} ~~~~~~~~~~~
i see you are first counting the smaller elements in the array, and if they are not small, you check if they are bigger or not, so you have count of all elements smaller than h, and all elements smaller than l excluding elements from h count, so wouldn't the straightforward way will be min(small,big), because i am not getting the logic in this line if(small >= big){cout << (small+big)/2 << endl;}.
Yeah, same two pointers -
B>C I did the question C by observing a pattern for the even and the odd numbers though i did C after the contest ,But B was a nightmare for me in the contest i couldn't even understood it for the first 30 minutes and eventually leaved it as it is.
Can Anybody Explain the last part of my code, initial part i have written in the observation part but after that i am little bit confused in the ceil of (x-pos) part, I will be grateful for your help.
My Submission
If you need to travel 4 units of distance and your best operation is (2,2,1) then you will travel 3 units per cycle , so to cover 4 units you will require 2 cycles , one with 3 units and the other with 1 unit to reach the target.
I've done a unbelievable weird job during this round
solved 6 but ranked 850+
because of 10+ penalties
I suspect I'm not a human being
Can someone explain c2 ? printing -1 approach is cleared, just explain how to generate all numbers.
An intuitive way to approach problem C2 after C1 is to observe n = odd works as it is, n = power of 2 will lead to generating values greater than n, hence not possible. For n even, keeping the C1's solution intact and just swapping the first value with another will work, maintain a set for the same.
I could be the only person to solve A with two pointers ~~~~~ 359372727 ~~~~~
how will we solve the A question if it said, any cell can be chosen maximum one time? can anybody help me with the solution pls
you can use a number to form a pair only once my solution which I commented uses two pointers for solution we can start making pairs with maximum values that are strictly lower than bigger h l value and pair them with smaller values as possible
Oh you use python but main Idea I used was like that I hope it helped
thats also what i did xd
Problem A was easy but problem B was way more tough or the language of the question was not clear , i don't know
Totally a pretty tough contest
Problem E, I came up with the conclusion for the case where the number of operations ≤ 4, but how can one come up with the necessary and sufficient conditions for k = 2 and k = 3?
You can look at cases which operations could have been applied and come up with sufficient and necessary conditions for those cases.
If $$$k = 2$$$, then some operation $$$[l, r]$$$ was applied after which the operation was applied on the whole string. Suppose that the majority value in $$$[l, r]$$$ was 1. Then we can show that we could have finished in one operation. Therefore the majority value in $$$[l, r]$$$ must have been 0. Let $$$z$$$ / $$$o$$$ be the number of zeroes / ones outside $$$[l, r]$$$, respectively. Then $$$z + 1 \leq o$$$ or in other words $$$z \lt o$$$, since we finished in one operation after applying $$$[l, r]$$$. From here you can show that either prefix before $$$l$$$ or suffix after $$$r$$$ has strictly more ones than zeroes. Similarly, with this condition on prefix/suffix you can show that you can finish in 2 operations. Hence, these are sufficient and necessary.
If $$$k = 3$$$, two operations $$$[l_1, r_1]$$$ and $$$[l_2, r_2]$$$ applied before finishing with operation on the whole string. Let $$$[l_2, r_2]$$$ represent the range applied in the second operation corresponding to the range from the initial string. We can consider two cases here:
If $$$[l_1, r_1]$$$ and $$$[l_2, r_2]$$$ intersect, then we could have taken the union of the ranges instead as one operation and finished in 2 operations instead. We can show this by considering the cases of majority values in these ranges.
If $$$r_1 \lt l_2$$$ (i.e. ranges do not intersect), then with the similar argument as above, if at least one of the operations had 1 as majority, we could have finished in 2 operations. Hence, 0 was the majority value in $$$[l_1, r_1]$$$ and $$$[l_2, r_2]$$$. Let $$$z_l$$$, $$$z_m$$$, $$$z_r$$$ denote the number of zeroes in ranges $$$[1, l_1 - 1]$$$, $$$[r_1 + 1, l_2 - 1]$$$ and $$$[r_2 + 1, n]$$$ respectively. Similarly, let $$$o_l$$$, $$$o_m$$$, and $$$o_r$$$ denote number of ones in the same ranges. Then $$$z_l + z_m + z_r + 2 \leq o_l + o_m + o_r$$$. Which means that either $$$o_m \geq z_m + 2$$$ or $$$o_l \geq z_l$$$ or $$$o_r \geq z_r$$$. Since we can show that if these conditions hold we can finish in 3 operations, just by removing one of the operations from case with 4 operations, we have showed that these are necessary and sufficient conditions.
Hope it helped. Feel free to ask any questions if some parts are unclear.
In the case of $$$[l_1, r_1]$$$ and $$$[l_2, r_2]$$$ intersecting for the case $$$k = 3$$$, the idea that we could have finished in 2 operations by taking the union is not correct. Thanks to xyzt8988998 for reaching out with the mistake. The right claim is:
Claim: If the ranges intersect then there is either a prefix or a suffix that has as many 1 as 0.
First of all, since after applying $$$[l_1, r_2]$$$ the range is compressed into one element, if $$$[l_1, r_1]$$$ and $$$[l_2, r_2]$$$ intersect, then $$$l_2 \leq l_1$$$ and $$$r_1 \leq r_2$$$.
B: ceil == wa case 9 No ceil == acepted
The problem statement is almost bullshit
I understood the problem B during contest in just one read through and still couldnt solve it lol Im wondering what the rating of problem B will be
Hey everyone!
I’ve prepared detailed articles for Problem A and Problem B, explained in both English and Hinglish to make them super easy to follow.
What makes these articles useful?
Simple, beginner friendly language
Starts with understanding the problem clearly
Builds intuition step by step
Derives the formula logically
Provides a code template so you can try coding on your own
Ends with the complete solution for verification
The goal is not just to solve the problem, but to learn how to think and approach similar problems in the future.
Check them out here:
Problem A: - https://www.xorthax.com/codeforces-articles/round-1075-div-2-problem-a
Problem B: - https://www.xorthax.com/codeforces-articles/round-1075-div-2-problem-b
I genuinely hope you find these helpful. Do give them a read and let me know your feedback!
If you want more articles like this, do comment below.
I finally understood. How to do A..
A was easy, solved it pretty fast. However, it took me quite a lot of time to think about B. Therefore, I have no time left to think about C, and I'm kinda sleepy too cuz it's late at night in my country. Anyways, I did improve, cuz in the past I only solved A.
About D1, you can reconcile the idea and the code like this: the real constraint isn’t simply “you can’t insert in the middle,” but that any insertion must not break an already satisfied prefix w condition (mex = k). The loop from i = 0 to n − 2 is effectively counting how many insertion positions are safe before the first position where inserting would destroy the existing prefix property. When m = 1, a full segment with mex = k must remain intact, so only the two ends work; when m = 0, as long as the prefix hasn’t reached mex = k yet, inserting won’t affect it, giving i valid positions. From this perspective, the code is implicitly checking the previous w-state rather than explicitly reasoning about “middle vs ends,” so the implementation and the intended logic do line up—just from different angles.
I have a boring solution in F:https://mirror.codeforces.com/contest/2189/submission/360273407
The editorial for problem F seems too overwhelming. Is this normal, or is there something wrong with me? Also, is there any easier approach?
can anyone tell me how someone can get an intuition on C1?
great contest and editorial
D1: Need some help with the intuition for the solution
I understand these conditions and got them myself: • If s[i] = 1, then the value i must be placed entirely to the left or entirely to the right of all values 0..i−1. • If s[i] = 0, then the value i must be placed strictly between the values 0..i−1
I’m confused about the leap from these conditions to the construction. In particular, I don’t understand why constructing the permutation from 0 upward works, nor how one is supposed to come up with this idea during the contest. "Let's construct p, starting with p=[0] and sequentially inserting the numbers 1,2,…,n−1 into some positions." <- how do you get to this idea when solving yourself.
I think I have a simpler solution for F, correct me if it's the same as in the editorial. However I don't have a proof for it, though there is some intuition.
I have two claims. First — we need to do operations in at most one vertex. Maybe it's provable from the facts in the editorial, but idk. Before the second claim we need to understand some properties. Suppose the tree is rooted at the vertex $$$r$$$ and we look at the subtree of vertex $$$v \neq r$$$. Let $$$s_v$$$ be the sum of all $$$a_u$$$ in the subtree. Then after applying the operation the number of nuts in the subtree is $$$\max(s_v - 1, 0)$$$. From this fact it can be shown, that if we apply at least one operation, then we need to do at least $$$s_v$$$ to get rid of the nuts in vertex $$$v$$$ in 2 cases:
$$$a_v \ge 0$$$ and there is at least one non-negative $$$a_u$$$ in the subtree.
$$$a_v = 0$$$ and there is at least two non-negative $$$a_u$$$ in the subtree.
So there are $$$O(n)$$$ "events" which change the number of distinct vertices after operations among all roots (it's basically all possible values of $$$s_v$$$).
Let's find all these events. Now the plan is to bruteforce every possible root and find the optimal answer for each one. To bruteforce roots we'll do rerooting and to find the minimum among $$$O(n)$$$ values fast we'll use segment tree. Let $$$c_i$$$ be the i-th unique value in the sorted array of events. Initially the answer for $$$c_i$$$ operations is $$$c_i \cdot p$$$ plus the number of vertices with nuts. Vertex $$$v \neq root$$$ contributes $$$q$$$ to every $$$c_i \lt s_v$$$, so we add $$$q$$$ on a prefix.
Then if we reroot from $$$v$$$ to its child $$$u$$$, only their $$$s$$$ and number of non-empty children subtrees change, so we can update this information and do certain additions (and subtractions) in the segment tree. This part is technical so instead of writing in detail I'll just give my submission 362825458.
Time complexity $$$O(n \log n)$$$ memory $$$O(n)$$$.
A made think a lot. Not expected this easy solution
Can someone explain why for B, you would commit to one jump type immediately? It seems to me you could travel t = sum(a_i(b_i — 1) for all i) at the beginning. Essentially you travel as much distance as possible using each jump type before incurring a penalty (rollback). Only after do you commit to one jump type, this doesn't seem disallowed to me by the problem statement. I have a submitted solution using this solution which passed all testcases. This appears to give strictly more distance than committing to one type from the beginning.Is there a constraint or reasoning I’m missing that makes combining moves like this suboptimal or invalid?