I'll try to check all peoples, who will hack their own submissions, manually and check if in their code will appear parts like if (n == 1234) return 1; and similar.

Why did you change your profile picture?

Is it communist?

yeah didn't even felt the joke.

Too real

Welcome to future,your rank in 504 will be 2942.

Same here

gl hf

standartno

So that no of registrations crosses 9k mark...

For few seconds, the website crashed as well. Maybe the delay was to fix the issue

To solve A: 1. Wait for 15 minutes. -_- 2. Open contest page. 3. See question A. 4. Solve.

http://lmgtfy.com/?q=codeforces+how+to+solve+problem+A+in+contest, Here you go.

Unratedforces

dragonforces

Wrongproblemorderforces

I didn't actually give it a go, but I believe you should calculate ((V[i] * 10 ^ j) % K) for every i and j and then, for each j, build a frequency array / map of these such values. After that, it's easy to see that for every V[i] the amount of elements you can pair it up with is freq[j][K — (v[i] % K)].

i hate vovuh

You miss read the statement.

I solved it with sliding window

At least one color must form a rectangle i.e if you remove red, blue must form a rectangle or if you remove blue, red must form a rectangle

I also was not able to understand the problem statement because of this. According to Firastic, the intended meaning is quite different to what they wrote.

A pretest of this type: your solution should be based on the statement and not the samples.

try this input:

6 2

ababab

output should be: abababab

Your approach seems not to be on the correct path. You may want to think it differently.

My guess is that it is something like this:

300000
1 100000000
2 100000001
3 100000002
...
300000 100299999

Same here, I putted the code and clicked submit and there was almost 10 seconds, but it wasn't submitted :(.

Then that hard deadline should have a hard deadline. xD

Try this input:

2 1000000000 1000000000 1000000000

only the top 2 numbers matter.

    sort(l , l+n);
    sort(r, r+n);
    reverse(l, l+n);
    int ans = r[0] - l[0];
    if(!notin(l[0], r[0])){
        ans = max(ans, r[1] - l[0]);
        ans = max(ans, r[0] - l[1]);
    }
    else
        ans = max(ans, r[1] - l[1]);
    cout << max(0,ans)  << endl;

Easy O(n log n) with multiset 42096347

Yes, it will. Mine did.

DP d(i, j): i represent the index of the nodes, j represent the depth of node i; http://codeforces.net/contest/1029/submission/42054107

The complexity is O(n)

Root the tree at 1. Sort the nodes by their depth in descending order (so we start with leaves). Make an array to store if we can reach a node in <= 2 steps. Loop through the nodes by depth and if not marked create a connection to the parent of that node and mark all the neighbors of the parent in the array.

I was trying it with dp, though couldn't complete the code within contest. My idea was to consider states if there is an edge from 1 to v or not. if there is an edge from 1 to v, then there can be edge from 1 to childrens of v or not. if there is no edge from 1 to v, then there must be an edge from 1 to atleast one of child of v

during the contest I coded it in 8 minutes but I got WA37 did you get the problem in this test?

The intersection length of n segments is min R - max L (invalid if it's negative), so just ignore each segment and evaluate length, i used multiset to insert/remove in O(log n). I'm doing this for n segments, so the total complexity is O(n log n).

Code: 42096347

Small infinity(got wa on 37 too).

2 large prime numbers, so only rectangle with side 2 will pass

the area (a + b) can only be divided by 2, some people have the answer 6179835302 because they devide it by 64728, but we can't color the rectangle like this because " all tiles of at least one color would also form a rectangle ". The solution is check that are there any divisor of a (or b) (called i) that i <= (divisor of S (called div)) and a/i <= (S / div) so we can have a rectangle with size div * (S / div).
my code : https://ideone.com/3bFclD

vovuh, MikeMirzayanov.

Why his submissions are not showing after testing?

I can't comprehend how do you even hack. There are too many solutions and most of them are fully correct.

Can somebody explain, please?

It seems he is the one brought done the submissions of D for ~640 to ~150

lol，halyavin is really good at hacking，I have been hacked by him for many times. But I maintain it also help me develop my skills，because the probability I will be hacked decreased more now at least.

Can I have the original picture plz?

I guess that this solution would be the best if the sequence was not in increasing order.

You can try to prove it during the contest. Just imagine you have already some subset, with the last element at index i (the array is sorted, and all of the elements with indexes > i are bigger). Now you want to try to add another element to this subset, suppose you added element j (j > i+1). Now you can see, that if element a_[j] <= a_[i]*2, the same applies to other elements in an interval [i+1, j-1] and it's always worth it to take smaller element. But why? Consider x as the smallest integer in the subset we consider at the moment. It's easy to see we want to minimize the largest integer in our subset (lets name it y), so 2*x >= y. This strategy applies to every element we consider in our subset — concluding — our subset will always be contiguous (if the array is sorted). Please correct me if I made some logical mistakes.

I had the very same issue as you so I thought of helping. TLE will go if you use unordered_map. Link to your submitted solution.

I think the issue is not in usage of map instead of unordered_map, but it is in that you used the operator [] when you wanted to add values to the result.

Instead, you should check if a key you want to add its value was already existed in the map by the member function count(), and if yes, then add the value of that key to the result.

Because when you use [], if the key in [] is not existed yet, this operator will create it, so the size of the map will increase by one, and so on. So, the time needed to access the map will also increase with the increasing of its size, thus you will get TLE.

Check my submission for more details.

use unordered_map

http://codeforces.net/blog/entry/61399?#comment-453807 . Hopefully this comment of mine helps you to get an AC by using map only.

You can traverse greedily in O(n): find the longest increasing subset that the criterion a_ij + 1 ≤ a_ij * 2 holds true.

So, of course, if the array isn't sorted yet, we can just sort it beforehand — nothing special.

Excluding the last element (i.e., the biggest), you can just calculate the length of the largest interval I = [L,R) such that I[R-1] <= 2 * I[R-2] holds.

So L starts at 0, R at L+1, keep increasing R until the property I[R] <= 2 * I[R-1] is false. Then reset L = R, and repeat the process until R >= N. After doing that, the answer is the max R-L difference you've found in this process. There is one corner case: N = 1.