Давайте считать, что $$$l_1$$$, $$$l_2$$$ и $$$l_3$$$ — это посортированные рабочие отрезки. Можем ли мы явно сказать что-то об одном из них?
$$$l_1$$$ должен равняться $$$1$$$.
Давайте считать, что $$$l_1$$$, $$$l_2$$$ и $$$l_3$$$ — это посортированные рабочие отрезки.
Если $$$l_1$$$ не равняется $$$1$$$, тогда мы можем уменьшить $$$l_1$$$ на $$$1$$$ и увеличить $$$l_3$$$ на $$$1$$$. Таким образом мы увеличим ответ.
Мы получили, что $$$l_1 = 1$$$, и нам осталось работать с $$$l_2$$$ и $$$l_3$$$.
Теперь задачу можно переписать как: $$$l_2 + l_3 = n - 4$$$, максимизируйте $$$min(l_2 - 1, l_3 - l_2)$$$.
И поскольку мы знаем, что $$$l_3 = n - 4 - l_2$$$, то даже:
максимизируйте $$$min(l_2 - 1, n - 4 - 2 \cdot l_2)$$$.
Если мы увеличим оба значение внутри минимума на один, то решения не изменятся, то есть можем решать:
максимизируйте $$$min(l_2, (n - 3) - 2 \cdot l_2)$$$.
Если мы выберем $$$l_2 = \left\lfloor\frac{n-3}{3}\right\rfloor$$$, тогда $$$min(l_2, (n - 3) - 2 \cdot l_2) = \left\lfloor\frac{n-3}{3}\right\rfloor$$$.
Если ответ больше, тогда $$$l_2 > \frac{n - 3}{3}$$$ and $$$(n - 3) - 2 \cdot l_2 > \frac{n - 3}{3}$$$, и это означает, что $$$2 \cdot (l_2) + ((n - 3) - 2 \cdot l_2) > n - 3$$$, но $$$2 \cdot (l_2) + ((n - 3) - 2 \cdot l_2) = n - 3$$$.
Единственное, что осталось сделать, это вычислить финальный ответ. И это $$$\left\lfloor\frac{n-3}{3}\right\rfloor - 1$$$. Или просто $$$\left\lfloor\frac{n}{3}\right\rfloor - 2$$$.
Выше был математический подход к решению.
Поскольку весьма очевидно, что $$$l_2$$$ — это примерно $$$\frac{n}{3}$$$, то вы могли проверить $$$l_2 = \frac{n}{3} \pm 5$$$ и выбрать лучший ответ.
Есть ли способ нарезать кусочки так, чтобы сохранить минимальный кусочек и удовлетворить потребности задачи?
Какое минимальное количество действий надо совершить для этого?
Есть ли решение лучше?
Начнем с простого решения.
Просто выберем минимальное значение из $$$a$$$ и предположим, что оно останется минимумом до конца. Поскольку массив посортирован, обозначим этот кусок как $$$a_1$$$.
То есть в конце все кусочки должны быть меньше либо равны $$$2 \cdot a_1 - 1$$$.
Мы можем ограничить снизу такое решение как $$$\displaystyle{\sum\limits_{i=1}^{n}\left\lceil\frac{a_i}{2 \cdot a_1 - 1}\right\rceil}$$$.
Покажем, как достичь такой оценки. Для каждого кусочка, пока его размер строго больше чем $$$2 \cdot a_1 - 1$$$, давайте отрывать от него кусок размера $$$2 \cdot a_1 - 1$$$.
Единственная проблема в том, что мы можем получить кусок меньше чем $$$a_1$$$ в конце.
Но это означает, что перед последним отрыванием кусок имел размер в отрезке $$$[2 \cdot a_1, 3 \cdot a_1 - 2]$$$. Все размеры кусочков из этого отрезка могут быть легко разорваны на два кусочка правильных размеров одним действием.
Теперь остается вопрос: почему минимальным куском в конце мы хотим оставить именно кусок размера $$$a_1$$$.
На самом деле, могут быть и другие решения, но это решение дает лучший ответ в любом случае.
Как было описано выше, нижняя граница решения, где минимальный кусок имеет размер $$$x$$$ в конце — это $$$\displaystyle{\sum\limits_{i=1}^{n}\left\lceil\frac{a_i}{2 \cdot x - 1}\right\rceil}$$$.
То есть, имея минимальный кусок меньшего размера, мы не можем получить результата лучше, потому что ограничение снизу на ответ будет таким же или большим для всех $$$x < a_1$$$.
Какой будет первая буква в ответе?
$$$a$$$, если $$$t$$$ не начинается с $$$a$$$, и $$$b$$$ иначе.
Задайтесь тем же вопросом как в Hint1 для каждой позиции.
Когда мы не можем просто взять минимальную неиспользованную букву?
Только если мы формируем цикл размера меньше чем $$$26$$$, создавая новый переход из одной буквы в другую.
Поддерживайте любую структуру, которая может это проверять.
Во-первых, процесс шифрования обратим. Если мы получили $$$t$$$ из $$$s$$$, используя $$$c$$$, то мы можем получить $$$s$$$ из $$$t$$$, используя тот же цикл $$$c$$$, но в обратном порядке. Таким образом, мы можем просто пытаться зашифровать $$$t$$$.
Лексикографическая минимальность сама по себе является жадной штукой. Поэтому мы можем сделать жадный алгоритм.
Давайте идти слева направо и генерировать результат буква за буквой. Мы можем выбирать лучший вариант на каждом шаге. Давайте опишем, какие варианты у нас есть
- Если буква на этом шагу уже встречалась раньше, то мы уже знаем, на что ее надо заменить.
- Иначе, мы бы хотели выбрать как можно меньшую букву. Но нам нужна какая-то структура, чтобы понимать, какие варианты приемлемы.
Давайте поддерживать круг, который уже сгенерирован(это некий граф). Для каждой буквы у нас будет одно входящее и одно выходящее ребро в конце. Давайте поддерживать их для каждой буквы: массивы $$$in[26]$$$, $$$out[26]$$$.
Когда мы хотим сгенерировать исходящее ребро на некотором шаге(определим буквы на этом шаге как $$$x$$$), мы должны выбрать минимальную букву, у которой еще нет входящего ребра. С одним исключением: если создание ребра создаст нам круг размера меньше $$$26$$$. Это бы означало, что мы не сможем получить полный круг в конце. Можно увидеть, что у нас есть не более одной такой буквы, поскольку такой буквой будет та, в которую мы упремся, стартуя по ребрам из $$$x$$$.
Чтобы проверить, что таковой маленький цикл не был сгенерирован, мы можем пройти по исходящему ребру $$$26$$$ раз, стартуя в $$$x$$$. Если мы закончим в $$$x$$$, или в какой-то момент у нас не было исходящего ребра, то добавленное ребро нам подходит.
Сложность $$$\mathcal{O}(26 \cdot 26 + n)$$$, то есть, $$$\mathcal{O}(n)$$$.
Как много сетов может быть среди $$$5$$$ карт?
Не более двух. Если есть два сета среди $$$5$$$ карт, то там будет "центральная" карта.
Переберите центральную карту.
Для любых двух карт всегда есть ровно одна карта, дополняющая их до сета.
[1] Это значит, что два любых сета пересекаются не более чем по одной карте.
Давайте покажем, что есть не более чем два сета в мета-сете. Обозначим $$$5$$$ карт как $$$c_1, c_2, c_3, c_4, c_5$$$. Предположим, что $$$(c_1, c_2, c_3)$$$ — это сет.
Все другие сеты содержат не более одной карты среди $$$(c_1, c_2, c_3)$$$ (потому что [1]), поэтому они обязаны включать $$$c_4$$$ и $$$c_5$$$. Получается, у нас есть не более одного другого сета, иначе бы они уже имели две одинаковые карты, что запрещено по [1].
Получается, каждый мета-сет выглядит как $$$2$$$ сета, пересекающиеся по одной карте. Давайте назовем ее центральной картой.
Теперь осталась простая комбинаторика. Для каждой карты мы хотим знать количество сетов, которые ее содержат. Если это количество $$$s$$$, то мы должны добавить $$$\frac{s(s-1)}{2}$$$ к ответу — это количество мета-сетов, где эта карта является центральной.
Чтобы получить количество сетов с каждой картой, проитерируемся по всем парам карт $$$(i, j)$$$, сгенерируем дополнение до сета, и добавим $$$1$$$ к этой карте в map/hashmap.
Сложность $$$\mathcal{O}(kn^2\log(n))$$$ или $$$\mathcal{O}(kn^2)$$$.
Как много возможных вариантов расстояния между $$$p_1$$$ и $$$p_2$$$.
Мы можем ограничить это значение $$$2 \cdot n$$$ вариантами.
Рассмотрим варианты $$$d_1[1] + d_2[i]$$$, $$$|d_1[1] - d_2[i]|$$$. Решите для каждого из них за линейное(почти) время.
Рассмотрим наибольшую дистанцию среди $$$d_1$$$ и $$$d_2$$$.
Можем ли мы ее сопоставить чему-то?
Можем явно.
Будем убирать такие, пока они превышают расстояние между $$$p_1$$$ и $$$p_2$$$.
Дальше задача очевидна.
Предположим, что рассматриваемые точка $$$p_1$$$ была левее чем рассматриваемая точка $$$p_2$$$.
Предположим, что мы знаем расстояние $$$l$$$ между рассматриваемыми точкам $$$p_1$$$ и $$$p_2$$$. Давайте покажем, как решить такую задачу за линейное время(почти линейное).
Пока у нас есть значение больше $$$l$$$, давайте будем брать наибольшее среди них(назовем его $$$x$$$). Предположим, что это значение из $$$d_1$$$.
Не трудно заметить, что дом с таким расстоянием должен быть правее рассматриваемой точки $$$p_2$$$ (потому что максимальное расстояние до точки $$$p_1$$$). Это означает, что мы можем сопоставить расстояние $$$x$$$ из $$$d_1$$$ расстоянию $$$x - l$$$ из $$$d_2$$$.
Когда не осталось значений больше $$$l$$$, все другие дома располагаются между рассматриваемыми точками. Мы можем сопоставить их просто сортировкой.
Это было решение за $$$\mathcal{O}(n log(n))$$$.
Давайте ограничим количество возможных расстояний $$$l$$$ — $$$\mathcal{O}(n)$$$ вариантами.
Если мы знаем, что какой-то дом имеет расстояния $$$x$$$ и $$$y$$$ до рассматриваемых точек, тогда у нас есть $$$2$$$ варианта для $$$l$$$: $$$x + y$$$ и $$$|x - y|$$$.
Давайте рассмотрим $$$2 \cdot n$$$ вариантов: $$$d_1[1] + d_2[i]$$$, $$$|d_1[1] - d_2[i]|$$$.
Сложность $$$\mathcal{O}(n^2 log(n))$$$.
Изобразите валюты на 2D плоскости.
Предположите, что вы можете выбросить любое количество денег в любой момент.
Как будет выглядеть область возможных точек?
Она будет выглядеть как выпуклый многоугольник в верхней правой четверти.
Поддерживайте его ребра.
Как меняется структура, когда приходит новый день?
Добавляется новый отрезок. Префикс старых отрезков сдвигается на вектор, а оставшийся суффикс на противоположный вектор.
Давайте изображать валюты на 2D плоскости. Если у нас есть $$$x$$$ камушков и $$$y$$$ бусинок, то изобразим это точкой $$$(x, y)$$$.
Предположим, что мы можем выбросить любое количество денег в любой момент. В таком случае, область возможных точек может быть описана выпуклым многоугольником в верхней правой четверти.
Изначально это прямоугольник $$$[(0, 0), (0, b), (a, b), (a, 0)]$$$.
В любой момент многоугольник может быть описан списком отрезков, начинающихся с точки $$$(0, y_0)$$$ и заканчивающихся в $$$(x_k, 0)$$$. В прямоугольнике, описанном выше, есть $$$2$$$ таких отрезка.
Давайте хранить эти отрезки посортированными по углу.
Когда приходит новый день, каждая точка может быть сдвинута на вектор $$$c\cdot(p_i, -q_i)\ \forall c \in [-1, 1]$$$, если у новой точки неотрицательные координаты.
Если мы забудем о том, что новые точки должны быть неотрицательными, как будут выглядеть новые сегменты?
Нам нужно лишь добавить отрезок $$$(2 \cdot p_i, -2 \cdot q_i)$$$, после чего сдвинуть префикс старых отрезков на $$$(-p_i, q_i)$$$ и оставшийся суффикс на $$$(p_i, -q_i)$$$.
Тогда единственное, что осталось сделать — это обрезать отрезки, чтобы поддерживать наш многоугольник неотрицательным.
Звучит классно, но звучит как $$$\mathcal{O}(n^2)$$$.
Надо ли нам поддерживать отрезки явно?
Нет!
Давайте просто поддерживать сет их длин и углов. Знания крайних точек $$$(0, y_0)$$$ и $$$(x_k, 0)$$$ достаточно.
Получается, нам надо:
- Вставить новый отрезок в сет. (Вам нужны только длины и углы).
- Сдвинуть крайние точки $$$(0, y_0)$$$ и $$$(x_k, 0)$$$ на $$$(-p_i, q_i)$$$ и $$$(p_i, -q_i)$$$ соответственно.
- Удалять и обрезать первые и последние отрезки, пока они все не уберутся в неотрицательной области.
Сложность $$$\mathcal{O}(nlog(n))$$$.
Есть другое простой подход за $$$\mathcal{O}(n^2log(n))$$$:
Поддерживаем область как многоугольник. На каждом шаге создадим две его копии, сдвинутые на соответствующие вектора. Построим выпуклую оболочку по ним. Обрежем выпуклую оболочку, чтобы она помещалась в неотрицательной области.
Это не зайдет. Упомянуто забавы ради.
lol I hopcroft-karp'ed the E
Upd: mine got tle lol. guess it's not my lucky day
YES! I had same solution but i had no time to implement it. Sad :(
I tried and got WA :( dunno how I messed it up.
lmao same, i did dinics. Only took 187 ms too, good flow templates r just too fast.
Could you describe your flows approach?
WLOG, $$$p_1=0$$$ (u can shift at the end to make all the vals in $$$[0, 2e9]$$$). Each element for $$$d_2$$$ that you can match $$$d_1[0]$$$ to gives u two options for $$$p_2$$$, so we want to test a $$$p_1, p_2$$$ pair relatively fast.
Each $$$d_2$$$ val has two possibilities for a distance from $$$p_1$$$. If we frequency bucket the $$$d_2$$$ and $$$d_1$$$ values, we can setup a flow network which is like bipartite matching except that the edges from S / to T have capacity of the frequency of that element.
Each flow run has $$$2n=O(n)$$$ edges and $$$O(n)$$$ nodes, so (by a little handwaving that this is basically bipartite matching) it takes $$$O(m*\sqrt{n}) = O(n^{1.5})$$$. We do this flow $$$O(n)$$$ times, so overall $$$O(n^{2.5})$$$.
This comment got me curious. Does Dinic outperform Hopcroft-Karp?
Bro, if u know what is Dinic and Hopcroft-Karp, but u are specialist, u are doing something wrong
Can you explain what you mean?
BTW Idk either of those two terms
well I am specialist and I know that dinic and hopcroft-karp are both algorithms for the network flow problems. and also that dinic is usually fast but the optimal algorithm always depends on the problem in question.
smart boy
So because I am a specialist I shouldn't be learning more about algorithms. I'm sorry but what you are saying is just absurd.
studying more complex algorithms, while not fully working out the easy ones, is not a very good practice
I know flows and graph matchings from reading a book about algorithms, I didn't study them that much. I asked the question because I know that Hopcroft-Karp should be faster than Dinic in unweighted bipartite matchings but it seems that HK got TLE and Dinic passed here. Anyway, thank you for the advice and have a nice day.
As a tester, who solved it using the same technique. I can prove that Dinic is asimptotically correct here. There are $$$m = O(n^2)$$$ edges in total and $$$n$$$ vertices for bipartite matching. Dinic for bipartite matching works in $$$O(m\sqrt{n})$$$ which in this case gives us a solution in $$$O(n^{2.5})$$$ which is fast enough.
Don't u need to run the flow 2n times (for each possibility for p2 given by matching the first d1 to a d2)?
The trick I did was to deduplicate so $$$m$$$ is bounded by $$$O(n)$$$ cuz each d2 guy only has 2 options in d1. This isn't bipartite matching network anymore (non unit capacities from/to S/T) so the bound doesn't hold.
I suspect this is asymptotically still $$$O(n^{1.5})$$$ or something close per flow run, but I have no way to show that.
It's important, that there are a total of $$$m$$$ edges, so for each case it will work in $$$O(cntedges_i\sqrt{n})$$$, which in total is $$$O(\sum cntedges_i\sqrt{n}) = O(m\sqrt{n})$$$
I did exactly this but I got TLE on test 48. I learned flows quite literally yesterday so I'm not sure if it's something I'm doing wrong or if my template is just inefficient, could you please take a look once?
My submission
I used max bipartite matching from CP4 ch4 and passed :)
well-balanced contest. thank you so much. hated it
logic in A was quite good!
well tbh it was just maths. let's define $$$k$$$ as $$$\lfloor \frac{n-3}{3} \rfloor$$$ and assume $$$n$$$ is a multiple of 3 then probably the 3 segments are $$$[1,k,2k-1]$$$ and the difference is $$$\lfloor \frac{n-3}{3} \rfloor - 1$$$. Didn't prove more (the minimum wouldn't be getting bigger anyways), and got AC.
idk, i just div it for 3 and minus 2
I didn't even understand A... Just needed to find some $$$x$$$ from $$$0$$$ to $$$7$$$ such that $$$\lfloor \frac{1033-x}{3} \rfloor=342$$$
In editorial of D, what is a "central card"?
It's the card that is shared by both sets in a metaset.
It's a card that appears in two different sets within a meta-set.
Two different sets can have at most one overlapping card (two overlaps would imply that the third must be the same as well, but then they're no longer different sets), so a meta-set (which has only five cards) can only fit in two sets if they have exactly one overlapping card. This card is considered as the central card of the meta-set.
(I actually mentally used the term "central card" as well when thinking about this problem during the contest, even though the statement never suggested such a term; I guess the visual explanation kinda screams "central card")
Thanks. I get it now. 2 sets means 2x3 = 6 cards, but we are only considering 5 cards. So 1 card is shared, or in other words, central.
Balanced Difficulties, great Problems, fast Editorial, all in one contest. Rated it as the best contest I have ever participated.
0≤hi,p1,p2≤2⋅109 for what?(((
I agree that it could be better to set $$$-2\cdot10^9 \leq h_i, p_1, p_2 \leq 2\cdot10^9$$$, but I don't find it a big challenge. You just need to shift all the values by an easy found constant in the end.
Yes, it is easy. But at last minute of contest I submitted my solution and got wa5 so now I have negative delta instead of top 40 div2. Unlucky...
My approach to D involved the key observation that three cards form a set if and only if the sum of values for each feature is 0 mod 3 (i.e., either i + i + i or 0 + 1 + 2). We can find the sum of every possible pair of cards, and count them in a structure (like a map). Then we iterate through each card in our input (to consider it as a potential central card) and subtract this card's value from 0 modulo 3 to get the required pair sum it can form a set with. We can then add sC2 as described in the editorial, where $$$s$$$ is the number of times this pair sum appears.
If we form a circle of size less then 26. Maintain any structure to check it.
Is there anyone who thinks he has implemented a very nice structure to check whether there is a cycle of small length or not?
well we already have the DSU???????
Writing DSU takes too much time i didn't had pre written code for it.
And copy pasting code from online sites is not my style.
Oh come on, I took less than two minutes typing it. You didn't even have to apply two compressions here, one compression (path compression is what I used) was more than enough.
having some snippets is really useful. It makes your life easy a lot of times.
I used a dsu, but it isn't necessary. You can store for each letter the previous and the next. When you make 25 connections in this structure you have a unique set and can connect the ends
edit: no w8 that's not right. You still have to assign some number to the whole structure each time so you can understand if you aren't connecting a loop too soon. But you can do it the stupid way assigning an id to each member of the sequence you change each time. It's like O(n+alphabet²) complexity if i'm not wrong
You don't need a number for the whole structure; just storing the previous and next is enough, due to the nature of this problem. When we want to consider whether we can assign $$$c_2$$$ to be after $$$c_1$$$, this requires that $$$c_1$$$ doesn't already have a next character assigned, and $$$c_2$$$ doesn't already have a previous character assigned. So you can simply check the previous character from $$$c_1$$$, and then the previous character of that, and so on, counting how many steps this takes. If we took 25 steps, then the chain has all 26 letters, and we only need to complete the cycle. Otherwise, we can only link $$$c_1$$$ to $$$c_2$$$ if $$$c_2$$$ isn't at the end of this predecessor chain from $$$c_1$$$.
A simple while loop will work. 174406487
I used DSU, which is probably overkill when the size is max 26.
It should suffice to simply store which character precedes another in our circular wheel, using a simple array, e.g., pred[0] = 3 means D precedes A. To check if it's okay to set $$$c_1$$$ as the predecessor of $$$c_2$$$, we can check the predecessor of $$$c_1$$$ and then its predecessor, and then its predecessor, and so on. If we find $$$c_2$$$ at some point, then it forms a cycle, which is only okay if we saw all 26 letters in this chain. You could, of course, store successors instead of predecessors with similar logic.
In E distance arrays can be sorted just once and then each candidate (distance between $$$p1$$$ and $$$p2$$$) can be checked in $$$\mathcal{O}(n)$$$ with two pointers resulting in $$$\mathcal{O}(n^2)$$$ complexity
I think Problem A was very confusing.
Some experience and you will solve it very fast
Can someone tell me what's wrong is my approach for A or I read it incorrect? For a 0 based indexing,
I marked index 1 as Off Day, so I have index n-1,1 as Off days and now I need to find one more index which is Off such that my answer is maximum. I did that by finding such possible index b/w 1 and n-1. I can't take index 2 and index n-2 as Off days as they are adjacent to index 1 and index n-1. So I have (n-2-2)-1 possible indexes for the 3rd Off day. I choose this position by finding the middle of middle of that subarray. So the 3rd Off Day should be res/4 + 3 by my logic where res = (n-2-2)-1.
I think you're making it complicated by thinking on indexes. If you think about the way the intervals become it should get more clear. You have this setup: |w-ww...ww-| with a gap of length 1 and a gap of length n-3. Now if the answer is x the ranges are 1, x+1 and 2x+1 long (add the remainder to the last). The ranges x+1 and 2x+1 are in the part that's long n-3, so you can find x by the simple equation n-3 = 3x+2 + 1(this 1 is the day off) => (n-6)/3 = x
got FST on pE, at first glance I think it is because dinic but turn out to be map<int, vector<pair<int, int>> being tooooooooo slow :/
fix the latex typo in B solution it looks like:
[2 \cdot a_1, 3 \cdot a_1 — 2]
Fixed, thanks!
damn these aholes destroy the fun** https://www.youtube.com/watch?v=IZSyj2pTe_I T_T
yes
In problem D if it is allowed that 2 cards have the same feature set then problem becomes really hard I guess. If anybody has any solution ideas to this
did anybody else find B confusing ?
I found the problem itself easy, but I think the wording of the problem could have been a bit better (the twice part)... Also, one thing in B that threw me off the hook a bit was the test case given where the minimum element changed, but later I just assumed that min will remain same and coded accordingly as it didnt affect anything.
Me
SORRY to Bother u by mentioning :"" Akulyat... But i think some links in problems' codes are swapped.
BTW.. A,B,C Problems are great ^_^
Thanks! Fixed
And don't worry about mentioning, it helps others get the correct information faster.
I assume it was unintended, but a lot of $$$O(K N^3)$$$ solutions passed under the time limit in D.
$$$\mathcal{O}(kn^2log(n))$$$ with vectors was intended to pass freely. Also $$$\mathcal{O}(kn^2log(n) + n^3)$$$ with a low constant is ok.
Could you share some links to solutions with $$$\mathcal{O}(kn^3)$$$?
From the last page of submissions, sorted by execution time: 174409139,174420917,174438219,174428203,174409139.
174402025 too, but the amount of pragmas in his template deserves a special mention :D
UPD: I managed to hack one submission, probably because they didn't even have break statements anywhere. The rest of them pass in >3000ms. Perhaps a TL of 2 seconds would have been better!
In B why would you not just half the values at each step rather than removing 2 × a1 — 1 at each step?
Surely if you repeatedly half the value it will get smaller soon which means less number of steps.
Halving each time is not correct. For example, take 2550 -> (halving) -> 2 pieces of size 1275 for those 2 pieces, we again need to use 1-1 operations to make all pieces less than 1200 (600*2), so in total, we used 3 operations while we only need to use two operations if use operations like this 2550 -> 1199 and 1351, 1351 -> 1199 and 152
You are right, but how did you come up with the idea that halving might not be optimal.
Edit it was in the sample test case. I missed it.
The link to the code for C problem , directs to the solution code for D problem. An update would be appreciated :)
FIX
You accidentally put the link of D submission in the Code section for problem C.
The solutions are not at the correct question number.
Provided solution for problem D looks wrong: https://codeforces.me/contest/1735/submission/174443540
Sample testcase: 3 3 0 0 0 0 0 0 0 0 0
Actual answer should be 0. But it gives 9. This is happening because it doesn't take into account that central card should not be part of calculated set of pairs from which meta-set is created.
Akulyat: can you please look into this?
It is given that all the n cards are distinct in the input so the test case is not valid.
I see. This further simplifies the problem btw. Thanks for resolving my confusion!!
could someone explain editorial of A problem ... I am fine till "If we increase both values under the minimum scope by one, solutions don't change: maximize min(l2,(n−3)−2⋅l2)" but after that things are above my mind .
has someone solved problem A with binary search ?
Yes. Submission
I just couldnt form any mathematical formulation, and finally binary search was only thing I knew will work for sure.
can u please explain your approach ?
Submission I figured that L1=1, that means that there are n-4 days to distribute between L2 and L3. So i am searching for L2=mid and L3=n-4-mid, I am looking to maximize L2-L1 while still keeping (L3-L1 bigger than L2-L1) and (L3-L2 bigger than L2-L1).
can anyone explain ques C. Its difficult for me to understand whats written in editorial.
I got wa on pretest 14 in problem F during the competition, but when I replaced double with long double I got accepted... My error was about 10-5...
Yeah it's a little unfair for languages that don't have 80-bit floating point (and those who may avoid
long double
out of principle due to architecture specificity). I basically had to hand-roll fixed-point arithmetic just to get it to pass in Rust: 174869219Interestingly it is important in this implementation that the multiply be performed before division, otherwise it loses enough precision to fail.
UPD: I found a way to get 64-bit floats to pass: 174932779, compare with failing submission 174826031. Basically, truncating the convex hull from the "pebbles" axis first apparently gives more accurate results, since that's the result you have to output.
It may also be more optimal for accuracy if, when interpolating, you reuse the slope values from the input, rather than recalculating the slope from the rounded-off endpoints.
I don't know why but I felt A to be bit harder than usual.
Does anyone have ideas on how to solve D if the cards are NOT distinct?
There is two option :
1-ABCDE = combine ABC and CDE and ignore clones of them. Use clones just for how many different A can come etc.
2-AAA??, AAAA??, AAAAA = iterate A over all different cards and let $$$x$$$ be frequency of a card increase ans by $$$C(x,3)*C(n-x,2)+C(x,4)*C(n-x,1)+C(x,5)$$$.
There's an intersection AAABC and you can calculate it with iteration over suitable ABC's (iterate A and B, find C at $$$O(log(n))$$$) and some combinations using A, B and C's frequencies.
But this solution can require so much casework.
(Sorry if this solution is wrong or has missing part, and for my poor English.)
Deleted
https://codeforces.me/contest/1735/submission/174486190
can anybody tell why my solution from problem D gives me wrong answer ?. I am taking ith card as central card and finding no of sets formed with ith card as central card.
Consider this case:
It is the same as the first example, only that the card "0 0 0 0" is now the last card. Your code returns 0, but the correct answer is 1.
This round is so great that I cannot understand the meaning of the problem D.
Can someone explain the flows solution to E?
I get the general idea, there are $$$O(n)$$$ possible values for the distance between $$$p_1$$$ and $$$p_2$$$ and you run a max flow for each of these options, what I don't quite understand is how, for some house $$$h_i$$$ and some candidate distance $$$d$$$, it could be that $$$|p_1 - h_i| + |p_2 - h_i| = d$$$, or $$$||p_1 - h_i| - |p_2 - h_i|| = d$$$, how do I formulate this into a max flow / max bipartite matching problem?
Actually $$$|p - h_i|$$$ is just the distance between point $$$p$$$ and the house, so the above equation can be rephrased as $$$d_{1, j} + d_{2, k} = d$$$ or $$$|d_{1, j} - d_{2, k}| = d$$$ for some index $$$j, k$$$.
So just let $$$d_{1, 1...n}$$$ be the vertices of left part($$$L_{1...n}$$$) and $$$d_{2, 1...n}$$$ be the vertices of right part($$$R_{1...n}$$$), and for every pair of $$$(j, k)$$$ satisfy $$$d_{1, j} + d_{2, k} = d$$$ or $$$|d_{1, j} - d_{2, k}| = d$$$ connect $$$L_j$$$ and $$$R_k$$$.
Ahh, so you don't need to distinguish between the plus and minus parts. Thank you I'll try that
can anybody tell why my solution (https://codeforces.me/contest/1735/submission/174557086) from problem E has tle, but https://codeforces.me/contest/1735/submission/174558165 — normal what is the difference?
a harder version of D with k<=100 or with more than 3 values for a characteristic would be great imo
I really liked problem d
174937931 I understood the editorial of C but I am unable to find whats wrong in my solution. I am getting WA in test case 3. If possible can someone tell me the test case where my solution is wrong.
Thank you in advance.
Take a look at Ticket 16251 from CF Stress for a counter example.
Thank you very much Made some changes and now solution is accepted.
C and D are really good problems, I especially love how D balances implementation and thinking so well.
My E was TLE on #45.
Anyone can tell me why it got TLE?
Submission: 175739035
[deleted]
[deleted]
how can we check the cycle in problem c ?
without using dsu
Why does set or map of string takes far more time than set or map of vector doing same operations . See my submissions there is a reasonable time reduction . Submission — https://codeforces.me/contest/1735/submission/266351992 (890ms) https://codeforces.me/contest/1735/submission/266349652 (3889ms)
Akulyat In problem 1735B, let assume the following input:
Here the max size of a peel could be 3
(2 * 2 - 1)
, if we break 10 into smaller parts then it would be something like this, 3, 3, 3, 1. So the total units will now become 2, 3, 3, 3, 1. As per the above solution this is correct. But my point is that there exists 1 and 2 in the answer and 2 >= 2 * 1.Wouldn't it be incorrect?
Any explanations are welcome.