I don't know why people giving me down vote! I just expressed my feelings! I really shocked about people's attitude. But I have done well today that is my satisfaction.

Good luck

my chance for expert !

my chance to lose expert

My chance for pupil!

Hoping I get my blue back in this contest

I hope I become an expert after this :)

Don't go :(

However, I come back now... (Eason_AC is my another account)
That means I can enjoy the CF rounds again guys :)

And you're not Errichto

There is no score in Educational Codeforces Round

What? So early in India? In China usually in January or February...
Anyway, you'd better take a good rest as the end semester exam is more important than a CF round :)

pikMike loves Math problems, so who knows!!!

same i have opportunity for 1000 points

i hope that :D

Congrats ub33 :p

nvm

meow

CONGRATULATIONS !!!!!!

C's statement is definitely hard to understand at first, need to google "ping-pong" after reading the statement

ObservationForces

I think C easier then A. Because during contest I solved A help with pretests but C was really apparent but for understand what it says on C i need to read multiple times maybe this becomes C harder than A.

So it's a good reason to start solving C firstly the next time. I think cfpredictor is a suitable work for you :)

After you draw the steps (don't come back initially) you will realize that you can come back by not making some pth move in front, but by just making it backwards. suppose you are at point y such that y>x, you need to check if there exists some p, such that (p+1) = (y-x). this accounts for not making the pth move in front, i dont have proof, but since p can take all natural numbers, it's always possible.
and yeas if(y-x)=1 then add one.

Ans is always (x-1,y), since the 2nd player wants to maximize he always gets y points by loosing the first x-1 games and now player 1 has only 1 stamina and uses it to serve and player 2 reflects it to get his first point and wins the rest y-1 points after that.

C easier than A. Seriously?

lower end question may be interesting so try them !!!

Exactly. A,B,C were more about observation than implementation! -_-

The problem wasn't even interesting. Just trying to come up with possible ways of playing and hoping one of them is optimal.

Today's A,B,C were more like Atcoder's ABC contest A,B,C

Yes, C was very ambiguous for me

I won't say C was bad even though i was not able to solve it during contest . I didn't expected that observation will be so simple and was always thinking in complicated way .

It was observation that you calculate $$$s = 1+2+3\, ...\, + k\ge n$$$. Now see that if $$$s = n+1$$$ then answer is $$$k+1$$$, otherwise it is $$$k$$$.

This is because if you overstep by some amount $$$o > 1$$$ and also we have $$$o < k$$$ so we can do the $$$-1$$$ step on $$$(o-1)^{th}$$$ move and $$$+j$$$ step on other $$$j^{th}$$$ moves and so effectively we have reduced the sum to $$$n$$$, so answer is $$$k$$$.

But if $$$o$$$ is $$$1$$$ then you must step back on $$$(k+1)^{th}$$$ move, so giving total $$$k+1$$$.

A should be a better example.

greedy

I used a greedy approach: First check whether the original array is already sorted or not. If it is sorted, print 0. Otherwise traverse the original array. Swap the value at current index with 'x' if it's greater than x and increment your answer by 1. At every step of the traversal check whether the Array has become sorted or not. The low constraints allows this. If it has become sorted print your answer. At the end of the traversal if the array is not sorted print -1.

It was a greedy solution. I solved it this way:

• Notice that $$$x$$$ is monotonically strictly increasing.
• If at any point, for any $$$i$$$ starting from $$$1$$$ to $$$n$$$, $$$a_{i \dots n}$$$ is sorted, break out.
• If for any $$$i$$$, $$$a_i > x$$$, do the operation. As an operation can only lower down the value of an element, so it is optimal to lower down the values when possible starting from the left.
• Finally, at the end check if $$$a$$$ is sorted, if it is, then print the moves you took, else print $$$-1$$$.

Update: Cleaner and faster code.

C++ Code: 100058194

Time Complexity: $$$O(n)$$$
Auxiliary Space: $$$O(1)$$$

Ikr. i don't see why it was a D. Q.Q

Hey, I iterated on the input array and every time check whether input array is equal to sorted input array if that's the case print answer and return else if the current element is greater than X then swap it. Here is the implementation of the same.

Find the cnt where cnt*(cnt+1)/2 is just greater than x Then find by how much it is greater than x,let it be y=(cnt*(cnt+1)/2)-x; Now just we have to remove the step y which can be done without any extra step. if y>1 so ans = cnt and if y==1 ans=cnt+1

Let's say x=7.So cnt=4; And the guy moved 1+2+3+4 steps. Then his final position is at step 10; y=(1+2+3+4)-7=3 Only if he could move 3 steps behind then the problem will be sorted. So we just need to remove the step size 3. So lets do Step 1: +1 position =1 Step 2: -1 position =0 Step 3: +3 position =3 step 4: +4 position =7

So we get the minimum number of steps as cnt=4

For B, let's use only +i as long as sum < X.

+1  +2  +3  +4  ...  + K  =  S  (>=X)

If we switch a "+i" to "-1", then S updates to S-i-1
That is great, because for i = 1, 2, 3.. it is -2, -3, -4 ... -K on S with no more jumps (result = K), and we could reach any S, S-2, S-3, ... except S-1, in which case we need an additional "-1" jump (result = K + 1).

1 + -1 + 3 + 4 + 5

1 -1 3 4 5

Find the cnt where cnt*(cnt+1)/2 is just greater than x Then find by how much it is greater than x,let it be y=(cnt*(cnt+1)/2)-x; Now just we have to remove the step y which can be done without any extra step. if y>1 so ans = cnt and if y==1 ans=cnt+1

Let's say x=7.So cnt=4; And the guy moved 1+2+3+4 steps. Then his final position is at step 10; y=(1+2+3+4)-7=3 Only if he could move 3 steps behind then the problem will be sorted. So we just need to remove the step size 3. So lets do Step 1: +1 position =1 Step 2: -1 position =0 Step 3: +3 position =3 step 4: +4 position =7

So we get the minimum number of steps as cnt=4