You swapped flag1 and flag2.

Can you explain your answer ?

this round was much tougher than previous round 1's . p1 > div2d p2 > div2e p3 > div2f or more.

I'd say today's A is Div1 B/C, and today's B is Div1 A/B.

Let $$$N$$$, $$$S$$$, $$$E$$$ and $$$W$$$ be masks representing the moves in corresponding directions.

$$$N-S = Y$$$

$$$E-W = X$$$

Lets fix number of moves K Then,

$$$N+S+E+W = 2^K-1$$$

From above equations we can solve for, $$$N+E$$$, $$$S+W$$$ and $$$N+W$$$ lets say $$$a$$$, $$$b$$$ and $$$c$$$.

Since, each bit can be present in only one of them, we get

$$$N=a$$$ & $$$c$$$

$$$E=a - N$$$

$$$W=c-N$$$

$$$S=b-W$$$

Now, we can just check if the solution is valid.

Find mininal T such that 1 + 2 + 4 + 8 + ... + T >= abs(X) + abs(Y). Now for each of {1, 2, 4, 8, ..., T} you can uniquely determine if it should be negated. Now you have a vector of <= 31 numbers. You should choose a subset with sum equal to x (other numbers will have sum y). It is done with meet in the middle.

Try to reproduce the sequence in reverse direction. On each step, check what coordinate has larger absolute value, and make a shift towards the origin along that axis.

I solved it using some visualization. I found the points reachable for every possible string for Len =1,2,3 and then it just followed a pattern. Every point reachable by Len=w will be reachable by Len= z where z > w.
And if abs(x) + abs(y) = even, then answer is impossible. After this we only need to generate the path. Here is the visualization:

Well, I ran a dfs basically for every index (1<<index) has to present in any one of the directions if at any point u find that N-S == Y && E-W == X print the answer. I got AC for test set 1 and 2 but failed for 3 bcoz of the costly time complexity :(

In C, I couldn't come up with a tc where just coming from back and maintaining sorted order from back will fail. does anyone know the testcase?

Let's name continuous sequence of cards with same rank as a group. First obvious observation: you shouldn't divide group.
Let's name group which contains all the suits as complete one. Otherwise it is incomplete.

The main idea is that if you have two incomplete groups on the top of the deck — you should place them (select as pile A) between next two cards with same ranks as cards in groups(*)(**). Otherwise, there remains only one incomplete group, which can be completed in a single operation.

(*) — Such cards will always exist because groups aren't complete. Also, it's guaranteed that this cards will be consequent because described solution will keep relative order of card ranks.
(**) — In such a way you will add one card to both groups in single operation and this is the best we can achieve with described type of operation.

I am doing the same and have the same doubt :/

[deleted] do_good_ is right

actually you are getting TLE bcoz you are taking cin >> x >> y for every test case in solve() function. just use it once. i tried it and it is giving WA for ur code.

I spend most of time with TLE due to same issue.

u need to input a and b only one time

Same solution here.

I was looking for something like this, thanks a lot!

This is a modification I did to last year runner. I think the runner changed this year, so beware not to use that code, but try to adapt that to the new runner. Probably I'll do it before Round 2 if anybody had.

Your loop contains simple instructions, and you can thank google's 10+ seconds TL policy for the rest.

The 20 seconds time limit should easily allow you to run the loop 1e9 times.

I wonder what the logic is behind your solution?

I used the same logic.

Did anyone solve it by simulation + Observation on small cases?

On the beginning I noted that $$$\lceil \frac{(s-1)r}{2} \rceil$$$ is kind of an obvious lower bound, but didnt have an idea how to construct it, so I was dubious about it being correct answer. Then I wrote simple exponential bruteforce BFS on all permutations, because I thought it would be too hard for me to guess the pattern quickly. Fortunately, solutions I got from it were very heplful and helped me notice the patterns, but even with it, I needed to consider a lot of small cases by hand to get the hang of it and answer turned out to be equal to that lower bound indeed. In total that was pretty hard problem for me, took me more than hour. I am often against writing bruteforces to notice patterns if thinking could be used instead (it is often the case that Radewoosh tells me and Marek that we are stupid because we have not written backtrack for some small cases even though the problem was so simple we managed to get its full understanding within one minute), but everything has its own balance — if problem seems hard to you to then it may be a good idea. I am sure many people solved it without help of bruteforce though, it was doable as well. Probably the best line of attack without writing bruteforce was investigating the lower bound and targeting it directly by inspecting what kind of move we need to make to not make it worse (<=> always creating two pairs of adjacent numbers that will stand next to each other in sorted sequence).

https://mirror.codeforces.com/blog/entry/76281?#comment-607467

How have you applied binary search?

In order to use binary search, you need to find a point laying inside the circle or on the border at first.