He is white...

Well, in last two rounds I had really bad luck and missed too many easy key ideas because of my brain (idk what's wrong with it) and because I didn't participate in any contests after NEERC at all. So I forget how to solve problems fast

Actually, because of precedence of operators, it is: (given 6) | (7 problems) = 69. So today we will have 69.

to tag a user: press "user" in the right of spacebar at the top of a message

if(m==69) return 0;

You can construct the solution for x from solution of (x-4)

Base cases: n = 0 => ans = 0, n = 1 => ans = 1, n = 2 => ans = 1, n = 3 => ans = 0

Suppose you have numbers x, x + 1, x + 2 and x + 3. Then you can take x and x + 3 to the first set, x + 1 and x + 2 to the second set and the difference between their sums will be 0. So you can take n modulo 4 and just solve it manually.

The summation from 1 to n is n*(n+1)/2, let it be S, if S is even we can straight away divide the array into two subsets such that, the sum for both the subsets are equal, thus giving a minimum of 0, in the case of S being odd, since the division will not happen equally, the difference between the sum of two partitions will be at least 1, since the difference will be caused by any two numbers which are consecutive in nature.

You could try this test case: 1 1 2 2

After some precalculations, one can do bitmask DP to find the maximum answer

My recurrence relation was DP[mask][first line][last line]

Haha, I actually think difficulties worked out surprisingly well. When I solved C (it was B at the time), I said Vovuh it's really hard for B (and for C, tbh). He told me the less complicated solution, but still. After that E was added and I felt it was even easier than C. And it turned out, Vovuh was about right about all the difficulties (considering B had hard to understand statement).

After some precalculations, one can do bitmask DP to find the maximum answer 48133701

My recurrence relation was DP[mask][first line][last line]

it is because your code make more changes than the minimum.see my code

Compiler optimizations

So his solution has a loop of size 2 × 10⁹ which the compiler optimizes for him. And he overflows 32-bit integer which does not matter since we're only interested in the last bit.

i am agree with you for problem b.but others are not really hard.

If you hack someone's solution, you (may) climb 1 place. Your ranking will increase(or decrease, in case you get hacked).

Penalty is meant to separate contestants with the same amount of problems solved.

Oops, doesnt seem right 265918 :think:

this would give an advantage to python coders, because coding in python may take less time than coding the same solution in c++ because of built in functions, simplifications, etc;

Those time limits are incredibly difficult to get right — HackerRank has many problems where writing a suboptimal solution in a slower language actually nets you more points, which is pretty counter-intuitive. This system, while harsh to slower languages, minimizes the work testers / setters have to do and has fewer slow solutions unexpectedly pass.

In "Baekjoon Online Judge", Korea's biggest online judge, we can submit in about 40 (Not quite sure the exact number. Different compiler version counted.) different languages and they all get different time and memory bonuses. For example, if C++ solution has TL x second and ML y MB, all python solutions will judged with TL (3x+2) second and ML (2y+32) MB. Kotlin Native solution will be judged with same TL with C++ and (y+16) MB ML.

This is great for python coders and most of JAVA coders. However, this had also made countless problems too. There are a lot of problems which something like in C++ you'll get TL with naive solution but with python you can actually fit the naive solution.

To solve this problem, community members make harder datas or even "temporarily change the TL/ML bonus only for that question". This actually happens a lot. Then the system rejudges every single solution submitted for that problem — which is possible because it is online judge, not a competitive programming platform, and There are only 1/4 problems there.

Baekjoon Online Judge holds Competitive Programming contests like codeforces gym, and to avoid these problems some setters just ignore the BOJ basic policy and make sure that the contest will ignore TL/ML bonuses (and it is allowed for setter to do so).

I believe it is not only extremely difficult in terms of resources, it may have some unintended results which in Codeforces it will be harder to fix.

Maybe I am missing smth obvious, but can you explain me why you don't one-- here:

for (int i = 0; i < n && zero < k; i++) {
    if (chars[i] == '1') {
        chars[i] = '0';
        zero++;
    }
}

It looks like you are using one after this loop, and therefore it should have a correct value.

Second for loop "i" is reaching the number 5001 and checking if (hash[i] > k), while the maximum index of that array is 5000 as you defined it. the index is out of bound , so it is calculating the wrong number and flagging it. it works on some compilers and on others it doesn't. fixing this should let you pass the first test.

From line 16 to 27: you are traversing the variable i from 0 to 5001, which caused a certain undefined behavior / memory violation since element hash[5001] didn't exist.

It's undefined behaviour, happens on your second for when you access hash[5001]

https://codeforces.net/contest/1102/submission/48130657

You cannot simply divide the answer by 2 in the last line, since such division might not work.

For example: if the true answer before dividing is 998244354, if you divide its modulo, your output will be 0 instead of expected 499122177.

To do this, you'll need to multiply your answer by modular inverse of 2 by modulo 998244353. Remember to take the remainder of the product again (since obviously there is a high chance that it might exceed 998244353).

DP+Bitmasking. DP states are mask,last row,starting row.Here mask represents which rows are selected and cannot be selected again.Starting row represents the first row and last row represents the row of previous position.

Basically we count the 0's 1's and 2's.

they should all equal X = (the string length) / 3;

if not then we swap these depending on the best lexicographical outcome.

• if the 0's are more than X then we need to swap some 0's to 1's or 2's, and the best way for lexicographical order is to swap the last 0's from the string because the 0's on the left assure a smaller lexicographical string, if we are missing both 1's and 2's we swap the 1's first because the 1's also assure lower value, after that we swap to 2's , else we just swap the number that is lower than X.

• if the 1's are more than X then we swap the first 1's with 0's -**IF (0's are missing)** — and then swap the last 1's with 2's — IF (2's are missing).

• if the 2's are ore than X then we swap the first 2's with 0's — IF (0's are missing) - and then NEXT first 2's with 1's — IF (1's are missing) .

I'm too lazy for write the proof, my solution use a greedy approach, i put the numbers in order (0, 1, 2) of course if is necessary to put them (cnt(#i) < n/3), and can be generalized for k digits instead of three. 48136350

B has a simple solution, I(and probably the problemsetters too) don't get why people tend to overcomplicate things for problems like A and B which can be solved with naive solutions most of the times.

For example, even though I obviously know how to solve B in O(n log n), it wasn't needed in this case, and O(5000^2) works fine enough and it's simple to write.

Also, in the end, no matter how strong the initial tests are, they are still pretests so fails can come at any problem

Oh yes, I made weak tests in purpose! Of course! OMG... How this thought comes into your head?

You just said B was easy to understand?

It's only the problem of weak testcases, not incorrect problem statement. Thus, it's your fault that your solution got hacked or failed system test. Practice more, and try to map out every possible case within your mind.

Line 61 in b.at(j)

I guess that's a null-character, and the checker probably ignored it or considered it as a whitespace.

I think we have

I think, it would be a great idea if blue/purple/orange/red guys that solved all problems during the contest will write editorials. I mean, for div3 and div2 contests, there are a lot of people who could do that. For div3, even I can write an acceptable editorial.

It's also hard for vovuh to write every editorial, it's really exhausting. Moreover, writing editorials will increase your contribution (if someone is interested in it).

https://codeforces.net/contest/1102/submission/48132783 I put first k colours to the first k numbers. Then I start iterating over remaining elements and create variable cur initialised with 1 and check if 1 hasnt been used for the same number before by using hash. If it isnt simply put cur in the answer for that element. Else increase cur.If cur>=k at any time answer as false.

You just need to understand what each of those data structures do. unordered_map implememts a hash table and, as such, it takes contsant time per operation on average BUT linear time in the worst-case.

Cleverly designed anti-hash tests can be conceived to force the worst-case scenario (and this is very likely to happen with 12-hour open hacking). There are some tricks you can do to get around that though (you can find countless threads about this on codeforces).

map on the other hand implements a BST and, as such, will run in logarithmic time in both average and worst case scenarios.

Maybe it'll get away with hashhack.48279914

Remember that only the trusted participants of the third division will be included in the official standings table.

Take a look at the link to see the criteria for "trusted participants". There might be users, which are still eligible to have this contest as rated, but do not fulfill the "trusted participants" criteria.

Thanks AkiLotus for your response. I'm quoting the important part collected from that link if anyone's interested to know as well.

" Accounts that materially participated in less than 2 rating rounds (materially means solved at least one problem there) before the start of the Div. 3 rounds, and those who have ever gained 1900 or more rating units will not get into the official standings and will be assigned to separate rooms. However, this does not mean that there is no rating recalculation for them. Thus, the rating will be updated for all users whose rating is strictly less than 1600 at the time of the start of a round."

You are using an unordered map. Either change it to a map or randomize the key(example by taking xor with a random number generated using high resolution clock) in unordered map to avoid anti hash tests.

See the comment above for more information : https://codeforces.net/blog/entry/64379?#comment-483358

This blog explains it very well — https://codeforces.net/blog/entry/62393