Please, try EDU on Codeforces! New educational section with videos, subtitles, texts, and problems. ×

### Geothermal's blog

By Geothermal, history, 6 weeks ago, , Hi all!

I'm here to share my solutions to today's Div. 3 round, since I managed to finish the round relatively quickly and thought that my approaches might be of some use to others. Feel free to leave questions in the comments!

# A — Minimal Square

Without loss of generality, let's say $A \leq B$, that is, $B$ is the larger side-length. We claim that the minimum side length is $\max(2A, B)$, hence, the answer is $\max(2A, B)^2$. This is relatively easy to observe just by looking at the sample cases and trying different configurations, but I'll prove this claim below in case you're curious.

To prove this, we first show that $\min(2A, B)$ is a valid side-length. To achieve this, just stack the two rectangles on top of each other, with the two short sides stacking vertically and the long sides overlapping. (This looks much like the solution given in the problem statement for the second test case.) The vertical side-length of the block formed will be $2A$, and the horizontal side-length of the block formed will be $B$. Thus, as long as we can fit a block with dimensions $2A$ by $B$ in the square, we can fit in the two rectangles; this is clearly doable when the side-length of the square is $\min(2A, B)$.

Now, we prove that no lower side-length is achievable. First, suppose the side-length is less than $B$. Then, there is no way to fit either of the rectangles in the square because the sides of length $B$ won't fit. Thus, the side-length must be at least $B$. Then, we can show that the side-length must also be greater than $2A$ through messy casework, so the side-length must be at least $\max(2A, B)$.

Since a side-length of $\max(2A, B)$ is both attainable and optimal, our answer is $\max(2A, B)^2$. We can print this value directly, after swapping $A$ and $B$ if necessary to ensure that $B$ is larger.

Time Complexity: $O(1)$ per test case. Click here for my solution.

# B — Honest Coach

We claim that the answer is the minimum difference between any two athletes' strengths. Obviously, since the answer must be a difference between two strengths, it is impossible to do any better. Then, to show that this is attainable, consider the two athletes $X$ and $Y$ who form this minimal difference, letting $X$ be at least as strong as $Y$. Place $X$ and all athletes weaker than $X$ except for $Y$ on the first team, and $Y$ and all athletes at least as strong as $X$ on the second team. It is easy to see that each team will have at least one athlete and that each athlete will be on a team. Moreover, $X$ is the strongest athlete on the first team and $Y$ is the weakest athlete on the second team, so $|max(A) - min(B)|$ is equal to the difference in their strengths, as desired.

Thus, we can simply sort the input, compare every two consecutive values, and print the minimum difference. Alternatively, since the bound on $n$ is fairly low, we can just brute-force all pairs of athletes and compare their strengths to give the answer.

Time Complexity: $O(N \log N)$ per test case. $O(N^2)$ is also possible and acceptable. Click here for my solution.

# C — Similar Pairs

Suppose that there is an even number of even numbers in the input (and thus, there is also an even number of odd numbers in the input). Then, the answer is always yes--we can just pair up the even numbers with each other and pair up the odd numbers similarly.

Now, suppose that there is an odd number of even numbers (and thus, an odd number of odd numbers). Then, if there are no numbers with difference $1$ in the input, the answer is no, because in this case we cannot pair odd numbers with even numbers, and it is impossible to pair all the numbers with other numbers of their same parity. However, if there does exist a pair of numbers with difference $1$, the answer is yes: pair these two numbers up, and then there will be even numbers of odd and even numbers in the input; we have already shown that we can pair up these remaining numbers.

Thus, the answer is yes if there is a pair of numbers with difference $1$ or there is an even number of even numbers in the input. We can check these conditions in $O(N \log N)$ by sorting the input and checking consecutive numbers to see if they have difference $1$ or in $O(N^2)$ by brute-forcing all possible pairs; either will be accepted. (Obviously, we can count even numbers in $O(N)$.)

Time Complexity: $O(N \log N)$ per test case. $O(N^2)$ is also possible and acceptable. Click here for my submission.

Clearly, the type of packages must be a factor of $N$, since to get exactly $N$ shovels from buying a certain number of packages, the number of shovels per package must be a factor of $N$. We can thus compute all factors of $N$ in $O(\sqrt(N))$, then, any factors less than $K$ could be the type of package we want to use. The last observation is that we want to buy the largest type of package possible to minimize the number of packages we have to buy. Thus, the type of package we want is the largest factor of $N$ that is less than or equal to $K$, and our answer is then $N$ divided by this package size.

Time Complexity: $O(\sqrt{N})$. Click here for my submission.

# E — Polygon

We claim that the answer is YES if and only if every $1$ has another $1$ or the border in either the cell to the right or the cell below it. We prove that this criterion is correct.

First, suppose that this is the case. Then, the desired grid is achievable; we will prove it by giving a construction. We build the grid such that the lowest $1$'s are added first; if several $1$'s appear on the same level, then we add the rightmost $1$'s first. This order ensures that whenever it comes time to add a $1$ to the grid, all $1$'s in the rectangle below and to the right of the $1$ we intend to add are already in the grid, while no $1$'s directly above or to the left of this $1$ have been added yet. Then, if there is a $1$ or the grid border below the $1$ we intend to add, we can fire the $1$ vertically and it will land in its intended position, while if there is a $1$ or the grid border to the right of the $1$ we intend to add, we can fire the $1$ horizontally and it will land where we want it. Thus, we can use this process to add $1$'s to the grid until all $1$'s have been added, showing that this grid is achievable.

Now, suppose this is not the case. Then, there exists a $1$ with $0$'s below it and to its right. It is then clearly impossible to fire a $1$ into this position because if it is fired horizontally, it will pass through to the $0$ position on its right, and if it is fired vertically, it will pass through to the $0$ position below it. Thus, in these cases, the grid is not achievable, showing that our criterion is exactly right.

Then, we can check this criterion for each $1$ in our grid; it is fairly easy to directly confirm whether it is satisfied.

Time Complexity: $O(N^2)$ per test case. Click here for my submission.

# F — Spy-string

This problem falls to a brute-force approach. Clearly, the solution must differ from the first string in the input in at most one position, thus, there are less than $26M$ possible input strings. We can simply check all of them to see if they satisfy the condition: for each string, iterate over all input strings and count the differences between the input string and our potential solution; if we find a string that has at most $1$ difference, then we can report it as our answer.

Time Complexity: $O(26NM^2)$ per test case. Click here for my submission.

# G — A/B Matrix

First, note that the matrix must have exactly $NA$ ones, since it has $N$ rows and $A$ ones per row. Likewise, it must have exactly $MB$ ones, since it has $M$ columns and $B$ ones per column. Thus, we must have $NA = MB$, so if $NA \neq MB$, the answer is NO.

If $NA = MB$, then we claim the answer is YES. Initially, let the matrix contain only zeros. Then, iterate over all rows in the matrix. For each row, $A$ times, let $X$ be the number of ones we've added so far, then, place a $1$ in the corresponding row and in column $X \mod M$. (We can maintain $X$ throughout this process so we don't need to recompute it every time.)

This clearly gives us $A$ ones per row, so we have a total of $NA$ rows. Moreover, it is fairly easy to see that this process distributes ones evenly across all the columns, so each column gets $\frac{NA}{M}$ ones. Then, since $NA = MB$, we have $B = \frac{NA}{M}$, so each column gets $B$ ones, as desired.

Runtime: $O(NM)$ per test case. Click here for my submission.

# H — Binary Median

First, note that the resulting set contains $2^M - N$ strings. Thus, our median will be larger than exactly $X = \lfloor \frac{2^M - N - 1}{2} \rfloor$ strings in our set.

Then, we build the string bit by bit, starting from the most significant bit. Suppose we add a $1$ to the end of the string. Then, if the answer string is now lexicographically greater than at most $X$ strings (not counting strings that are equivalent to our answer up until the point where the answer ends), we know that we must append a $1$, because if we do not, then our string cannot be greater than $X$ strings because it will be smaller than a string greater than at most $X$ strings. Meanwhile, if our answer string becomes lexicographically greater than more than $X$ strings, we must append a $0$ instead, because if we append a $1$, then no matter what, our string will be greater than more than $X$ strings and thus cannot be our median.

We can compute the number of lexicographically smaller strings than our current answer by computing our answer string's binary representation and subtracting the number of smaller strings we've removed from the set.

We need to complete this building process $O(M)$ times. Each time, we must evaluate whether each of the input strings is lexicographically smaller; this can be done in $O(NM)$ time. By reusing data between iterations, we can also count smaller input strings in $O(N)$ time, but this makes the code slightly more complex. As is, we have an $O(NM^2)$ solution; since the sum of all $NM$ is bounded at $10^5$, the sum of all $NM^2$ is at most $6 \cdot 10^6$, so we can expect this algorithm to pass easily.

Time Complexity: $O(NM^2)$ per test case. Click here for my submission. Comments (16)
 »
 » 6 weeks ago, # | ← Rev. 3 →   There's a potentially simpler (in my opinion) solution to H: The initial median is $2^{m-1}-1$, then each time we delete a string $a_i$, we simply determine if that number is less than or greater than our current median and adjust the median accordingly.Complexity: $O(NM + N^2 log(N))$EDIT: Editorial just came out with exact same solution right after I wrote this ._.
•  » » Yep, that's a nice solution--I ended up not implementing that one basically because I thought dealing with the parity casework, as well as the case when we delete the current median, might be a little annoying. Some people might find that way easier, though; it probably depends on personal preference.
 » Thank you so much:) This time C was really hard.
 » Geothermal thank you so much for such a fast editorial. It is very well explained too. Do post more such editorials for the upcoming contests if you find time.
 » can anyone tell what is wrong with filling b X a matrix with 1's in n X m matrix diagonally in question G https://codeforces.com/contest/1360/submission/81302323
•  » » Try cases 3 3 2 2 or 4 4 3 3It gives incorrect answer.
 » This kind of detailed analysis really helps a lot.
 » how did you guys approach, your thought process to find out how to arrange all the one's
•  » » I think the key observation is that all rows, or all columns are interchangeable, the order does not matter. So we need to distribute the 1s only somehow evenly.
•  » » » 6 weeks ago, # ^ | ← Rev. 3 →   upd- i get it finally thanx you always help me with my stupid question thank you so much
 » My approach for H:Our length after removal of n elements is ((2^m)-n)Median for the length will be the element at position (length-1)/2Let currentmedian=(length-1)/2.Then for every removed element(sorted in ascending order), I check if that removed element is less than or equal to our currentmedian. If yes, I increment currentmedian by 1.My python solutionhttps://codeforces.com/contest/1360/submission/81296011
 » 6 weeks ago, # | ← Rev. 4 →   In H, I used Binary Search on Median. If the number of elements less than Mid (After removing given numbers) is less than $\frac{K}{2}$, then we need to go right, else left. If it is equal, then we have our candidate. We just need to check if it is removed or not, if it is, just find the next non-removed number. That will be the answer.As far as I think, the TC is $O(NM+Nlog(K)) = O(NM)$If you'd like: MyCode
 » Nice Explanation Thanks!!
 » Thanks for the editorial!! Can you please tell how to approach F if the constraints were tight? I was curious about it. Thanks.
 » Your explanation for H was very useful and the best one I could find! I didn't think of finding the lower bound and then iterate above until the number of elements under the median is as expected. Thank you :))