You will become newbie.

As a not tester, I gave you contribution

Negative contribution given boy....

Good luck!

try flareon color

Yeah it's blue!often happens..

You will become newbie.

Delta will -500.

all the best!!!

OMG Blue Round

Hope not by negative delta.

I relate!

I can relate too

Really thats so true. But because of that university exam my mind was already exhausted and messed up in such easy problems :(

HOW CAN WE KEEP PHOTOS IN COMMENTS?

Div 3 is the best opportunity to reach expert

You will become newbie.

Good luck!

Best wishes

really be an expert.thank you all.

Every time you submit a wrong submission 10 minutes of penalty gets added to you after getting accepted on that problem.

the penalty is calculated as the time spent on all the problems you solved (for ex. if you solved A in 8 minutes and B in 35 minutes your penalty is 8 + 35).

the penalty is used to rank the contest's participants, if two participants have solved the same number of problems the one with smaller penalty ranks higher.

True. They always have interesting problems.

Go to the contest section Codeforces page. Find round 834 and register before the contest

nice performance

Congratulations!

I used a greedy idea:

However, I haven't proved this idea in the contest, so I'm not sure about the systests. If someone else who have proved it can mention it here, then it would be helpful.

I used a Maximum Segment Tree.

• Initialize int[] answer of length n which will store our final permutation. On every odd position(0 based indexing) fill the elements of int[] b. Because we want minimum number to be in front position, so it makes sense to keep the maximum element on the second position.
• Now we have filled half of answer array. Now we iterate integers from n to 1 and check if its not present in answer, find the right_most element in answers array which is less than this current number. So we can safely place this number on left hand side of the found number. Now delete this number. This type of operations can be done by segment trees.

My solution is not clean as wrote in hurry in contest and its a newbie's code. My AC 181520850

If you are a braindead grey (like me) and never thought to solve the problem backward, you can also binary search on a lazy add/min segtree.

https://codeforces.com/contest/1759/submission/181510473

Solution for G:

From $$$i=n/2 \space to \space1$$$,for each $$$b[i]$$$,find $$$max(x)(x<b[i],x≠b[j])$$$ .

Proof:

Note $$$X=max(x)(x<b[i],x≠b[j])$$$.

Consider $$$"... Y\space b[j] ... X\space b[i] ..."$$$ and $$$"... X \space b[j] ... Y\space b[i] ..."$$$.Because $$$X$$$ is the largest number less than $$$b[i]$$$,we get $$$X>Y$$$,the former has a smaller lexicographical order.

You can consider cases like: a == b then answer is 0 distance between a and b is >= x then answer is 1 distance between a and l or a and r is more then x and then distance from that end is more then x ( to the b ) then the answer is 2 and the last case is to make the deistance to one of the endpoints equal to at least x, and this just adds 1 to the previous case, so the answer is 3 in the last case, if you can't do that than the answer is -1

Check if ans==0

If possible use 1 step, else

if possible go to left or right end, then to b, else

if possible go to left end then right end, or to right end then left end, then to b.

else not possible.

you only have limited startegies: go left boundry then right boundry thn target go left then target go right then target go right then left then target just check if you can do the transition in these cases and print the minmum number of steps you can do to reach target (b) using one of the above stretegies or print -1 if all of the above stregies are invalid ps : ofcourse if a == b you don't need to do anything so the answer is 0 so the answer will be 0, 1, 2, 3 or -1

The important thing to realize is that the answer is between $$$-1$$$ and $$$3$$$.

Me the same. I wasted too much time in D and then found out E was much easier to figure out. But it was too late... :(

I am not sure what is your code doing. But i found a test case:

1
513943340 921893439

Brute Force Output: 
256971670000000000

Obtained Output: 
462549006000000000

My estimation would be $$$1300$$$.

The answer of problem C lies Between 0 to 3.. Otherwise -1. Try to figure out how this logic is true!!

My solution for D:

k zeros at the end of a number means that this number can be represented as 10^k*a, where a is some number. 10 = 2 * 5, therefore, in the answer we need to maximize the number of pairs {2, 5}

1) Decompose n into prime factors and count the number of 2 (let it be q2) and 5 (let it be q5). If q5 > q2, then we need to add q5 - q2 twos in the price increase coefficient. If q2 > q5, then q2 — q5 fives. If q2 == q5, it means that we cannot "collect" tens from two numbers and add a zero to the end of the answer.

2) After that, I started picking up a number from [1; m]. We need as many 10 as possible in the answer multipliers, so I multiply the number (2 or 5) that I lacked to create pairs with multipliers of the number n, abs(q5 - q2) times by itself. tmp = (q5 > q2 ? 2 : 5)^abs(q5 - q2)

3) Then, I need to maximize the quantity of 10 at answer and, if there is solutions with the same number of zeros, need to get maximum. So we can increase tmp variable. To increase the number of tens, you need a number that can be represented as 10^k * a. This is easy to do if you take a digit of the highest digit and add to it (the length of the number - 1) zeros. For example, when m = 21345, you need to take 20000. So we have to do something like this:

r = m // tmp
t = int(str(r)[0] + (len(str(r)) - 1) * '0')
tmp *= t

4) When working with the tmp variable, it is necessary not to forget that it cannot be more than m, so it is necessary to set conditions that tmp <= m everywhere you are increasing tmp.

The answer is n * tmp or n * m if there isn't solutions with zeros at the end.

Take a look at Ticket 16433 from CF Stress for a counter example.

When you are multiplying it's crossing the limit for integers. Try with long integers

What you are facing is integer overflow, try using 64-bit integers.

That is something you will often have to care about.

Observation 1. The maximum answer is $$$p-1$$$, One case where this happens is where the number is a single digit.

Observation 2. A full carry across one or several digits happens only once at most.

Now think of it like this. How many steps do we need when our number is 0? That's $$$p-1$$$. Now, how many steps do we need when we have a few more digits existing in the number, smaller than the last digit? Might be smaller than that, but we may still have to run a full cycle. For this reason, we manage two variables, $$$\mathbf{pp}$$$ and $$$\mathbf{pk}$$$. $$$\mathbf{pp}$$$ is the smallest number connected as a continuous group with $$$p$$$, $$$\mathbf{pk}$$$ is the same but it is for the last digit. These two variables serve as boundaries. To be precise, $$$\mathbf{pp}$$$ serves as the boundary before the carry, $$$\mathbf{pk}$$$ serves as a boundary after the carry. So, you should be very well able to case-work with $$$\mathbf{pk}$$$ on whether we need a carry or not. Now the rest is just implementing the carry, and fiddling with these two variables (and the last digit).

Solution for F:

Note $$$k=a[n]$$$,consider $$$k->k+1->...$$$

Case1:

$$$k->k+1->...->p-t$$$

In this case, there is no carry bit.$$$0,1,..,k-1$$$ must appear in $$$a[]$$$.

$$$p-t$$$ is the largest number that does not appear in $$$a[]$$$.

Case2:

$$$k->k+1->...->p-1->0->...->k-t$$$

In this case, you should recalculate $$$a[]$$$(consider carry bit),note it as $$$b[]$$$.

$$$k-t$$$ is the largest number that does not appear in $$$a[]$$$ and $$$b[]$$$.

coooooool!

jiangly's algorithm: the greatest element of an array is always the last element.

Just find out how many 2 and 5 you get from m and (1<=x<=n) if(x==1) answer will be m*n; otherwise m*x;

Take a look at Ticket 16430 from CF Stress for a counter example.

wait the sum of the elements he found + the sum of the lost elements must be equal to some n where n = n(n+1)/2 this should do right ?

As the humanoid can gain more health as it consumes an astronaut, you should iterate until you cannot consume an astronaut anymore instead of binary search the position at the beginning. After that you will drink a potion then try again that strategy. There are 3 ways to drink potion (2,2,3), (3,2,2) and (2,3,2) so just try all of them.

your intuition ?

I figured it out, I thought the original permutation's size can't be over 50, but the problem statement never actually said that, only the found elements can't be more than 50

Agree 100%, nitin sir orz

Use blue first.

Sir, what about Sneh_Patel_0701 he has cheated in previous rounds too. But didn't get caught. Now he is going to become expert. Is there any punishment for them?