That's the score, not the problem rating.

I was also surprised but it appears to be more common than I thought: three of the last 10 div2 rounds had a problem valued at 3500 points, including Codeforces Round 949 (Div. 2) and Codeforces Round 940 (Div. 2) and CodeCraft-23. Additionally, I'd say that a good 1+2 needs at least 3 problems of this level (judging by Codeforces Round 942 (Div. 2) and Codeforces Round 942 (Div. 1)), so it's not as easy to extend as it may appear.

This is the first time I've seen a grandmaster's comment receive so many downvotes. People generally tend to upvote whatever a grandmaster says.

I think you are right.Maybe it is hard to add more problem.Or it will have too many div1 and div1+2 if every div.2 like this add more problem to div1+2.

"> ...

I, Tester

as a contestant

us

B=C

B+C=D

A+B+C=E

A+B+D=F

A+C+D=F

etc.....

if you want 1750 rate then solve 2000 problems

are you asking for downvotes?

Same

problem statements are the main reason as we read a big story and makers make more confusing some good coders ignores the stories and go read testcases. some problem have confusing story and does not have testcase exxplained. took more time! good wishes ;)

Every round should be unique so it's fine to have bit different score distribution

you were literally correct lol

I am good at math. (•-•)

He's from China :(

I knew it. why some codeforces rounds are so maths heavy

How did it go?

There is a Div. 2 round scheduled for this Saturday :)

this time your goal is realistic :)

2 accounts are forbidden, so you will be banned.

number of people who cheat are insane now. When ABC is hard cheaters will have the advantage because honest people wont be able to solve it but they can copy paste it from somewhere doesnt matter what the difficulty is.

smurf account detected.

++

Less than past contests, maybe cheaters needed some rest

A is easy, am I missing something?

Personally, I didn't come up with a formula for problem A. I just used multiset to simulate without thinking too much, with an extra optimization which is to not insert all the 1's inside the set again

(My first solution got TLE because I underestimated the problem and didn't add the optimization lol)

I wasn't able to solve A. I wasted too much time on it and because of that low rating in B and C.

lol

At first it looks like the most innocent-looking bipartite graph problem lol

haha

This problem from 2015 Facebook Hacker Cup is also similar: https://www.facebook.com/codingcompetitions/hacker-cup/2015/round-1/problems/D

bro please clean your nose you are cooking wrong

I solved B & C but failed in A :<

I think it requires O(logn) rounds to kill all monsters?

me too

I was thinking of using segment tree and binary searching through the upto which range our ai is the current minimum. Is this approach correct. In theory this will work in O(N log^2N). What do you think

In what sense bro, i couldn't come up with any idea how to approach C :(

Both the observation and implementation of A are simpler than C

for the first time i couldn't solve A, but i was able to solve B and C.

Did A in 9 mins, but was not able to do C even after throwing my whole mind at it for 1.5 hours.

also here's my approach for D

observation 1: you only need to delete at most 3 times

first deletion will split everything into trees of depth 0 or 1 (if it's depth 2 then the non-leaf can be deleted in the first move and it's guranteed to be better)

2nd and 3rd deletion just "cleans" the trees of depth 0,1 i let dp[a][i] = min price to delete subtree i WHILE deleting node i at t = a

then for all child v1,v2,...,vk of dp[1][i] = val[i] + min(dp[2][v1], dp[3][v1]) + min(dp[2][v2], dp3[v2]) + ... + min(dp[2][vk], dp[3][vk])

dp[2][i] = 2*val[i] + min(dp[1][v1], dp[3][v1]) + ... (you get the idea)

then the final result would be min(dp[1][0], dp[2][0], dp[3][0])

however this gets wrong answer on pretest 2 (either it's wrong or it's my implementation that's wrong)

$$$k$$$ needs to be atleast $$$2$$$

The minimum value of K has to be 2

Think of a case like this one:

1

4

100 5 5 100

1 2

2 3

3 4

it fails this test case

1

4

1000 1 1 1000

1 2 2 3 3 4

i think its because lets say u have 4 straight connecting nodes and u can imagine like an array and counter test case will be something like 100000 1 1 10000 since best option is picking 1 and 4 instead of 1 and 3 or 2 and 4

if the tree is 10 — 1 — 1 — 9 the answer is not 31, but 24. the optimal in this case is with 3 turns instead of 2 (I'm also thinking about the logic, but this was my counterexample of the dfs idea)

this shouldn't work, counter scenario: think of an array where you need to maximize the total value you pick without picking adjacent elements! this can be solved by a simple dp; and so this each path in this tree can act as an individual array if you think

Can you explain your logic in brief Please ?

You can take a look at my solution here. You basically iterate over the bits from highest to lowest significance, and if the bit is on, you turn it off and print the rest of the bits as they were. Also don't print zeros and that's it.

You can look at my solution if it is of any help

take n in binary for example 23 is 10111

the answer will look like :

(the number of ones + 1)

00111 10011 10101 10110 10111

look at my submission

true, It feels like I am too dumb for not solving A in 5 minutes.

let me help you bro

think of this test case 00000011100000000

here in this test case in first move you will combine all prefix 0 with 1 in the second move combine all suffix 0 and in the third move apply operation on the remaining array so answer will be 1

the corrrect approach is to combine all consecutive 0 into one '0' so that no one gets into waste and then checking is count of 1 is greater than 0 or not

Just replace all consecutive zeros with a single single zero(make a new string) and then count c0 and c1 and apply the conditions given in the question.

For each number, just unset one set bit starting from msb to lsb

My solution : keep searching the bit which is 1 from the smallest bit. When it is 1 , replace it with 0 and make the bits after it to be valid for A | B = N (So we can keep finding smaller number)

(Sorry, My English is bad, I am not native speaker.)

Example:
- 14 = 1110
- =>   1100
- =>   10?? (only 1010 is valid for A | B = N)
- =>   0??? (since 1010 | 0??? should = 1110 , 0??? can be 0110 or 0100
and no more answer smaller.)