It is unknown now but we hope so =)

Last 4 rounds are so, so maybe!

From now "Educational Rounds" will be rated for Div.2

But maybe some rounds will be unrated for Div.2

Me contribution is well er. u not know da wae.

I don`t wish ratings like my contribution :-) Good luck and peace!

Timelimit for all questions is very tight!

Polygon

polygon

How did you solve C?

Consider the input 543 433. (If you mean the task C. I imagine a correct solution uses backtracking)

For C? Try this : 201 200

Implicit segment tree can do work. But I couldn't find my bug.

my seg tree O(Q * log2(N)) solution got TLE, time limit is very tight

I did segtree with coordinate compressing, got TL16

I solved it using just a set (of segments), each time, I erase the segments which are totally inside the new one and cut the ones that intersect and are not totally inside (at most two).

Is mine correct, please someone check:

Find any cycle. For each edges in this cycle, delete it and check is condition is true or not.

(I didn't write it during contest so I'm not sure it works or not)

I think we'd have to find the strongly connected components and check if there is more than 1 component with >1 vertices in it.

For each cycle that you find, increase the number of cycles for each edge in it. Chech if there are any cycles and if yes, check if there is one edge which exists in every cycle.

Edit: As it was already mentioned — each cycle has maximum n edges, so the complexity should be something like O(nm).

I passed the pretests by checking for every edge if the graph without this edge has a cycle. O(nm). Edit: I'm wrong

I run a dfs on the graph. If there are <= 1 back edges, the answer is yes.

Otherwise, I try erasing each tree edge. Is this correct? XD obviously I cannot remove all the cycles by removing a back edge if there are more than one back edge... But cross and forward edges shouldn't matter, right?

I think yes. My solution is O(nm) too.

Maybe something like that : 123456 165422

Excepted answer : 165342

a = 22221

b = 22220

ans = 22212

i think maybe something like this

2495

4951

Same here :) Is there any faster way than lazy propagation?

Yes they do the final systests contains all the hacks

It is Educational Round so they should allow hacks.

If he did that there will be no hacks at all.

The main reason why we have small testsets is to speed up testing. The queue on the first rated ER was really awful, so we had to do something about it.

Maybe a better solution would be adding multitests to each problem. Perhaps we should give it a try when preparing next round.

It is disappointing that in E dynamic segment tree get's tle. I wanted to implement this structure and thought that this task might be perfect for it...

xuanquang1999 if you are creating new nodes in heap try to create it in stack instead

Node d[15000000]; int curr; // ID of last node I created
if (root->left  == NULL) ++curr, root->left  = d+curr;
if (root->right == NULL) ++curr, root->right = d+curr;

my first solution I created new nodes in heap and got TLE in test 18, and then after some optimization got MLE in test 32 :D now after creating new nodes in stack instead it finally gives AC.

Build the answer from the first to last digit by trying each digit from 9 to 0. Checking if a digit work can be done by trying to put all the unused digit to the right of the answer (from smallest to largest) and check whether the number you get does not exceed b.

1. Look at the leading digit of b. Call it N. If a has N, then try to form a number from a that starts with N and is less than b without it's leading digit. (you can use recursion) 1a. If you can't form a valid number (formed number>b), continue to next step.
2. If a does not have N, find the largest digit of a less than N (call it M). Place that digit next, and after that, place the digits of a, sorted, as it will always be less than b.
3. If M does not exist (which isn't possible at start but if you do it recursively it will be possible), then return some value indicating this route is impossible.

It is O(N*logN) because there is a max of 1 recursive call per call, and by using binarySearch you can find the elements of a in logN time.

Edit: On second thought, I think this version is harder to implement than most, so you may want to try using someone else's.

Hello, soohotiam

Please check your private messages.

Nope

9221211

Something like that: 34143849

simple (dp + bitmask)

Let's say L=3 R=7 and POS=10.

You can't move to L=3 in 1 move because max(POS-1,L) = POS-1

No.

As stated, In the aforementioned expressions a and b denote the minimum and maximum index of an unclosed tab, respectively.

Therefore, if you move left right on the 1st step, you will still stand at tab 1, since a = 1 (as tab 1 is the unclosed tab with minimum index). As a result, your next delete command will only delete that tab.

Not in Educational Rounds!

Take a look at the accepted submissions and you'll find there exists O(nlogn) solution using inclusive-exclusive theorem for Problem G.

The same problem with google chrome, no problem with firefox though :\

Happens to me in chrome, but is fixed everytime if I do ctrl+F5 in that page. I don't know if that works for everyone

Not sure.. But it's still unchanged!

Now it's normal :) I_am_Heisenberg

See this test case:

6 1 4 5

Your answer is 9 but it should be 6

Idk but sorting+Union-find also gets the job done.

Here, check my solution:http://mirror.codeforces.com/contest/915/submission/34157745

Solution with centroid decomposition is too slow.

My TLE code: http://mirror.codeforces.com/contest/915/submission/34159437

Actually when I read the problem first thought came to my mind was Centroid Decomposition, but on reading constraints 10⁶ and not 10⁵ , it can be really risky, I thought more, and decided to go for DSU + Sorting solution, faster non-asymptotically.

As I'm thinking, we will only need 2 actions: delete the tabs to the left, then delete the tabs to the right. We're at tab 3 already, so we don't need to make any movements.