No wonder you love it because I'm about to get -1000 delta on it...

im a newbie, could u plz help me getting z best benefit of this "codeforces" , i am really confused with it ..

i have some questions i just need u to awenser it for me :) 1- where and how to find problems to solve Gradually? 2- when i will be ready to enroll one of these contests that is published on here? 3- how much time should i spend here a day? thanks in advance :)

orz

If you hasn't tested, said that it's good, but in fact it will be bad, I'll find you.

Same here

Maybe in the next div1 contest

Well it's not possible today.. Two more contests needed

That's not possible cuz he will get at max +70 as rating increase is very slow at that level

He is in a position where if he didn't get the first position among RED coder's he will get mines(-)...

no

fifty-fifty

Why do you need it? I almost immediately understood, that the solution is written on the screen.

Note that $$$33\cdot10^n$$$ is divisible by $$$66$$$.

I dont think we need the divisibility properties of 11. We can only use 3 and 6 as digits, and the number is to be divisible by 66, so the number must end with 66.

Then you need to add 33 * pow(10, x) always, and you cannot have 9 as a digit in the resultant number. So, by logic we have answer ->

for n >= 4: concat(333333....(n — 2)times, 66) when n is even and concat(33333...(n — 4)times, 6366) when n is odd.

Then you can handle cases for n < 4.

Neither did I. Fun part: If you divided the solutions in the tests by 11 you'd get something very interesting.

when I looked on "n = 500", I started observing the testcases on the screen and I got it it only about 3s.

Sample just gives the answer. You can also just dp with the remainder, no need of any math.

u must be using mod somewhere where u shouldn't be using it

Nah, I can assure you it is not that easy. Most probably, your algorithm doesn't even work on case #2 in the sample. Just check it.

Can you verify if this approach is ok I maintain a 2 stacks one with the value and one with the potential

the value is essentially the number that remains after we remove all the 2 from it if the last number is greater the the value of the stack we maintain we remove that and add it's potential to the potential of the current number ,and subtract (last_elem-1) * (2^its_potential) to the ans and at the end we add curr_elem * (2^curr_potentail) to the ans and stack

cache the 2 ^ power into and array

I spent 1 hour + on this still wa on tc 2

Me too

I used monotonic decreasing Stack, which stores Odd values and powers Of 2.

You can refer to my submission. I have tried using as much as verbose variable names. In case you still have doubts, you can ask me.

https://codeforces.net/contest/2035/submission/288353463

That is what CF is supposed to be, yes.

Use sqrt-decomposition. You can refer to 1954E - Chain Reaction

you dont "find" the local minimum, you bruteforce!

let A be a chain of k operation 1s and 1 operation 2 (in that order)

optimal answer would be A repeated some amount of times -> op1 some amt (must be <= k) -> op2 some amt

brute force through number of A repeats -> sqrt(z/k)

if k is small (k <= 1e4) -> number of op1s is bruteforceable -> sqrt(z/k)*k = sqrt(zk) but k <= 1e4 so at worst it's 1e6 per case

if k is large then the number of op2s so that number of op1s is >1e4 is also small (i wasnt able to exactly calculate the amt but it should run fast enough)

Check my 288346163. I used ternary-300 optimization to pass it. I will write a blog about it soon.

find patterns in sample testcases

if odd then obviously the max you can get is just n, and if not odd, then you can set all bits that are present in the permutation, by doing the same thing as with n-1, but just adding result^(n-1) at the en

+1

I thought there must be some proof and did not see the standings assuming it was hard, i fcdkup :)

To be fair, C really just boils down to solving for $$$2 \cdot \lfloor \frac{n}{2} \rfloor$$$ so idk if it is fair to call it casework.

Try to get $$$2^{k}-1$$$ for even numbers.

How to solve D?

For large enough ($$$\geq 8$$$ works) even $$$n$$$, you can just end the permutation with $$${1, 3, maxpow-2, maxpow-1, n}$$$, where $$$maxpow$$$ is the greatest power of $$$2$$$ that's $$$\leq n$$$, which ends up with having all bits that are set in at least one number $$$\leq n$$$ on, so the answer is $$$2*maxpow-1$$$. A greater answer is clearly impossible. And for large enough odd $$$n$$$ ($$$\geq 8$$$ still works), you may note that the result is bounded by the last element of the permutation, and therefore by $$$n$$$. And the result $$$n$$$ is achievable by putting $$$n$$$ at the end of the optimal permutation for $$$n-1$$$. Cases where $$$n<8$$$ can be hardcoded.

You've to wait until system testing ends.

Contest ended $$$20$$$ minutes ago. The editorial isn't usually published that early. I'm sure it will eventually appear.

minimize something => binary search

Because they are global rounds :)

Even my C $$$maybe$$$ hackable.. for even $$$N$$$.

I agree wholeheartedly with $$$[l, h]$$$ being painful.

next time u will get ... fosho ! just don't give up.

Same mentioned here.

Me who submitted it 15 times: I first ran into a wrong idea that a single ternary search would work. It turned out that it doesn't work because it can have multiple local minimums. It was too late for me to carefully think of a right approach, so instead I could only try to add some extra ranges to search and hope that they are enough. None of them could pass pretests.

Nevermind, overlooked something in the question.

Interestingly enough the answer for lower $$$n$$$ is just the identity permutation. I still decided to remove it so people didn't get confused by edge cases.

In my correct submission, I apply it while calculating answer for each index but I store numbers num = x * 2^y as (x, y) , where x is an odd number (Edit: clearly here x and y will always lie in int range as per constraints in the problem). And while comparing I use log2 of the num which is log2(x) + y, which gives correct comparison.

Numbers quite large. So, instead of doing the multiplication, you just need to store the oddNumber, and powerOfTwo everytime you process the value. This will help in managing integer overflows ( although, in python u won't get any ).