Enough with that already. Instead of being sarcastic, why not prepare a round yourself? :)

Please read upstairs first

Rip. My problem D in ECR 73 got hacked only because I didn't use fast printer. Sad the test cases didn't catch that.

But this is suitable for Chinese people XDDDD

You can hack others after the contest and it lasts 12 hours

Basically when you switch from unofficial to official standings, in addition to removing non-div3 participants, it will remove all non-trusted participants. However non-trusted participants will still be used for rating calculations. So to simply answer your question — Yes, it will be rated for them but they will only be visible under unofficial standings

Another Candidate master , making an alt account , waiting for people to reply "Wow you did it" after the contest.

round is rated right?

USA all nighter gang

https://math.stackexchange.com/questions/188812/n-th-digit-in-the-sequence-of-natural-numbers

you will also need to subtract area of the intersection of the intersections as that will be counted twice.

I did the same. But remember to filter out the '0' values while finding the gcd.

I got the same firstly.

Expecting test smth like:

4

1 1 5 9

try it.

using x, y, z — notations from D;

x = max element of the array;

z = gcd(z, x — a[i]), i = 1..n;

y += (x — a[i]) / z, i = 1..n;

This is not true number of swords is right in your case bt the number if people is sum of the difference of each element with maximum divided by the number of sword

Totally agree, I skipped C without thinking once I saw these rectangles in the problem and start solving (D) xD

Hacking phase will start soon, you have to wait till it's over.

You can try to solve 1177B - Digits Sequence (Hard Edition), as they are quite similar.

Hint: Try to calculate number of digits for 123456789101112.... by breaking them down into 1-9,10-99,100-999,1000-9999,...

For E1.
k is small. We can process the number of digits of i as d[i], and process the perfix sum of d[i] as sum[i]. Then for each k, we can use binary search to find i which contains k-th digits.

For E2.
Link my solution, another comment, here.

Hope it can help you.

It can be done using RMQ and dp

I solved it with DP + binary search (Just a lower bound).

Read the blog update please

Yes, this is more logical. I didn't knew when the elimination stage starts and ends and thought that all is ok.

So lucky that it passed.

I also got WA on test 11 for my first submissions. For me it was because I had calculated the area of overlap between the two black papers, but didn't check that this overlap was within the white paper.

Deleted

You need to find areas of intersections. Between first and second, first and third, and between all of them. Then if S(1, 2)+S(1, 3)-S(1, 2, 3) < S(1) -> Yes, else -> No

You can find area of intersections using intersections of projections. Notice that rectangles intersect when both x, y projections intersect.

Here is my submission 61021591

vovuh

I did it using binary search. for each i we are writing numbers from 1 to i. So first I did a binary search on i such that when I write from 1 to i+1, the number of digits exceed k. Now we have to find the number j between 1 and i+1 such that writing till jth number makes the number of digits greater than k. again binary search on this. Once we get j we can easily get our answer. you can refer to my code here

Write down each block in a column and consider all the blocks that the last number has the same number of digits as the Big-block.

// Big-block 1
1
12
...
123456789           // the longest block in Big-block 1

// Big-block 2
1...910
...
1...910...99        // the longest block in Big-block 2

// ...              // ...

The number of Big-blocks is about 9, so we can find k in which Big-block easily.

Then the right block can be found by using binary search. I preprocessed the longest length of block in each Big-block and the sum of digits of all Big-blocks.

Now this problem 1216E2 - Numerical Sequence (hard version) was translated to 1177B - Digits Sequence (Hard Edition).

Here is my solution 61007196 and wish it can help you more.

Dunno why you ask. White rectangle is almost inside first black rectangle except a little part near point (0;0) and the 2nd rectangle covers this part.

Possibly you should notice that it's 999999 that is not 99999

Think of the problem like this — there are $$$n$$$ offers for intervals $$$[l_i, r_i]$$$ and the $$$i$$$-th offer has cost $$$c_i$$$ (this problem is only a special case). We want to cover all indices $$$1$$$ to $$$n$$$ and choose the cheapest such set of intervals.

Now here's the dp state: let $$$dp[i]$$$ denote the minimum cost to cover indices $$$1$$$ to $$$i$$$ with intervals that have their right point $$$\le i$$$. The answer is $$$dp[n]$$$. The base is $$$dp[0] = 0$$$. How do you transition?

To find $$$dp[i]$$$, you must cover indices $$$1, \cdots, i - 1, i$$$. Since in $$$dp[i]$$$ we're looking only at intervals that end $$$\le i$$$, obviously, we must choose at least one interval that ends at index $$$i$$$ to cover it. Also, we choose exactly one such interval, because if we chose more than one, we can pick the longest and that won't affect the answer. Which interval should we choose? Let's iterate on all possible choices for that — let's pick an interval that ends at $$$i$$$ (call it $$$[l, i]$$$) and say it has cost $$$c$$$. Once we have picked this interval, we just have to ensure that indices $$$1, \cdots, l - 1$$$ are covered because this interval covers the indices after $$$l - 1$$$. What is the minimum cost of this subproblem? It's not $$$dp[l - 1]$$$, because there could be a cheaper configuration with intervals that end after $$$l - 1$$$ but before $$$i$$$. To cover those possibilities, we take the minimum of $$$dp[l - 1], dp[l], \cdots, dp[i - 1]$$$ (call it $$$m$$$). So the optimal cost of doing this is $$$m + c$$$. And $$$dp[i]$$$ is the minimum of this expression over all intervals that end at $$$i$$$.

We can store at each index a list of intervals that end at that index, and to support finding $$$m$$$ quickly, we can maintain a segment tree that stores $$$dp$$$ values of each index and allows us to find minimum in a range of indices.

your answer is 2 3 1 , but it's wrong , the correct answers are 1 3 2 or 3 1 2 .

Did you get not "Do you get"

Process the number of digits of i and get the prefix sum, then use a binary search to find i which takes up the k-th posithon. Finaly the answer is the k-sum[i-1]-th digit of i.

Here is the commit which is my solution for E2. If you are interested in E2, Link it.

I solved it with binary search and some mathematical calculations.

If you are interested in my solution, hope the commit-544591 can bring you some of the inspiration

one of them =)) 0 0 3 3 5 5 6 6 0 0 4 4

your solution is WA with follow case 2 6 8 8 1 2 3 3 1 3 10 10 sorry, I will hack your solution :(

you can solved it with complexity n*logn time

Try to avoid using += with strings in Python, when you add chars multiple times. There are some optimizations thrown in here and there, but it sometimes happens that this method's performance degrades to $$$O(n^2)$$$, since each time you append a couple of chars this way, a brand new copy of the whole string may be created.

Instead, you can put all strings into an array, and then write something like s = ''.join(a), which is definitely faster.

Update: now your code passes in 140 ms — 61033581

The same idea causes similar solutions but not exactly the same code with only the changes in indentation and variable names. Don't you think your solutions are somehow too similar?

Sorry if I'm wrong.