Bro why aren't the ratings yet updated?

When will the Codeforces rating update?

They have a lot of experience

They must have unlimited problem generator AI...

All the best vro

hope to change my color to green

The penalty for each incorrect submission until the submission with a full solution is 10 minutes.

Maybe read the blog?

Share and subscribe.

why?

because you didn't solve it?

Carp is a large fish that lives in lakes and rivers

The name Polycarp (which is a usual Russian name, though an uncommon one) was very commonly used in contests made by authors from Saratov State University, namely MikeMirzayanov and his students. The name Monocarp (which is NOT a usual Russian name) was originally used as a one-time joke for one of the ICPC qualification stages in our region (as a reference to Polycarp), but later on, we chose to make Monocarp the main character of most our problems.

I used to read it as PolyCRAP and MonoCRAP

Also I found B to be easier than A

Just try E

I wasn't able to find them either

[0], [0, 1], [1], [0, 2], [0, 1, 2], [0, 1, 3], [0, 1, 2, 3]

0 1 01 02 012 0123 013

Same Doubt

0

0, 1

0, 1, 2

0, 1, 2, 3

0, 1, 3

0, 2

1

Wasn't it stated in problem description that here you can take any sequence? edit: nvm

1) [0]

2) [0,1]

3) [0,1,2]

4) [0,1,2,3]

5) [0,1,3]

6) [0,2]

7) [1]

Let's solve it by inclusion exclusion principle, let's denote $$$f(x)$$$ as the number of permutations with at least $$$x$$$ edges such that $$$c_{child} = c_{parent} + 1$$$. The answer to the problem is $$$f(0) - f(1) + f(2) - f(3) + f(4)$$$... up to n.

To compute $$$f(x)$$$ for some fixed $$$x$$$, $$$x$$$ nodes should have exactly one child with their value minus one (it is impossible to have more than one since it is a permutation).

Let $$$g(x)$$$ will be the number of ways to select $$$x$$$ edges such that there are no two edges with the same parent node, this can be reduced to a knapsack problem, with the degrees as items, all $$$g(x)$$$ can be solved in $$$O(n\log^2{n})$$$ with divide and conquer and fft since the sum of all items is up to n.

Finally, $$$f(x) = g(x) \cdot (n-x)!$$$ since $$$x$$$ numbers are equal to the number of their parents minus one, so there are $$$(n-x)!$$$ possible permutations.

x mod y always gives values between [0,y-1] if we choose y as smallest element of the array then it is obvious that our requirements are met (given in the question)

take the smallest number as y in all pairs. since x % y < y it satisfies the conditions

Just take y as smallest element in array so that remainder is [0 , y-1] which doesnt exists in the array

I have failed on this one:

4
0 2 2 0

same here

Figured out E 3 mins after contest :/

It was very easy to lose yourself into the implementation details of A and this is why I also felt like A was (much) harder than B.

I found C easier than B , and i think my solution to B is terrible, because i used brute force and depended on the case (f[1]!=0) 137676564

Bro C was just binary search. It was easier than most Cs we see in div2. I was surprised at how direct it was actually

My recursive binary search solution passed (https://codeforces.me/contest/1613/submission/137671370).

The issue is that you added an extra min operation to your recursive function which caused it to keep around a lot of unnecessary info on the stack- your solution passes if you just remove the min

https://codeforces.me/contest/1613/submission/137709365

Yes.

The rating takes a bit of time to be updated, partly becasue of the hacking phase. If you want an idea of your future rating, you can check cf predictor

Edit : As beginners, since I am one too, I believe we shouldn't focus too much on ratings. Just start solving problems, enjoy and check where we land in a couple month =D

Use dynamic programming. You can get that there are only some types in mex correct sequence. First of all, Thre are a sequence which starts with 0 and looks like 0 0 0 .. 0 1 1 1 .. 1 2 2 .. 2 ...(from 3 to n-1) n n .. n n n. In this case, you can expand this sequence with adding n, n+1, or n+2. Also, there is another type of sequence. which also starts with 0 and like 0 0 0 .... (from 1 to n-1) ... n n n ... n+2 n n+2 n+2 n n n (don't have to alternative, just after all, you should add either n or n+2) In this case, you can exapnd this sequence with adding n or n+2 Finally, you can think about this kind of sequence: which is composed with only 1, like 1 1 1... 1. count first two kinds of sequences with dynamic programming with dp[i][j]=number of sequence which ends with i and type is j(either first or second) and count last one with just counting the number of 1. number of last kind of sequence is 2^cnt-1

maybe you should use this: min((i+1<n?a[i+1] — a[i]:(int)2e18-a[i]),mid)

a[i+1]-a[i]?

Also (int)1e18 will overflow. Use long long.

why??

everyone knows that endl is slower than "\n"

You learnt something new! What I would do after something like this, is try to find out why this happens. I would recommend you to do the same ;)

That particular test case you are flushing the console 10^6 times hence TLE

Link to my comment above

you use a and b as length, but then when you compare them, if you have a = b, you print equality, although this is equality of lengths, not numbers

Your AC code scared me

At the cost of increasing your endurance to solve hard problems

You are a beast for coming up with a solution, no matter the cost! Congratz!

GAWD LEVEL

Wow I wish i could have endurance like you during contest :).

In check function value will get overflow when n = 100

v.pb(1e12);

Here,because h can up to 1e18..that's why you are getting wrong answer

v.pb(1e12) and h = 1e18 => ans maybe > 1e12

"wrong answer 1st numbers differ — expected: '433940482775969078', found: '1'"

Add 1e18 to your array instead of 1e12.

as well as these two submissions 137693885 137674037

Indeed it has

eg. if I run this code

double x = 0.1;

cout << (x * 3 == 0.3) << endl;

result is 0 (false) for me

you can't compare numbers after mod operation, order is lost.
(7 mod 5) > (10 mod 5), but 7 < 10

Binary search on answer.

Div1 participants also appear in the standings table

Edit: For thorough explanation: See my video explanation

long long int is USUALLY (it depends on the compiler) coded on 64bit which means it's in a range -9e18 +9e18. To get the real limits, you should read <limits.h>.

Anyway, in A, the exponent can be up to 10^6 so you will get numbers up to 1e1000006 which will overflow by a LOOOOOOOT,

h can be up to 10^18. Numbers above 2^53 cannot all be represented exactly by floats, so you lose precision.

[deleted]

Maybe it is "hacked", not "heacked".