Unfortunately no.

The first division will be easier because of this extra half of hour. And yes, all three rounds will be rated.

Mate, what do you want to say exactly? If you want to ask whether your comment is first verified by admins and then uploaded then it is not the case. If that would have been the case then some people wouldn't shit here anything they want.

Good question!

We are using the onsite round.

Because they're all there in person

It's an on-site round. Under the supervision of course.

I don't think the countdown is affected by daylight savings.

I guess YerzhanU and ikatanic are no longer eligible since Lyft acquired our startup last week: https://techcrunch.com/2018/10/23/lyft-is-buying-london-ar-startup-blue-vision-labs-to-fuel-its-autonomous-car-efforts/

Damn.

:(

I think it is something like that:

3 10
2 
4 
6
2 2 1
1 1 3
2 2 5
1 2 6
1 2 7
3 4 2
3 4 4
5 6 1
5 6 3
5 6 5

Ans: 1

Same here. I fixed a bug in my solution about 30 seconds before the end, but didn't get time to submit.

Realise that you only need horizontal lines with that starts from 1. Sort horizontal lines and vertical lines, and then iterate trough verticals, and figure out if you don't use first i verticals, what is the answer. Output is minimal answer from all.

If you delete first A vertical lines (A+1'th is not deleted) then you have to delete horizontal lines too but only those such that x1=1 and x2>=x value of A+1'th vertical line

I tried using 2 segment tree but didn't manage to get AC , but i think it can be solved using segment tree .

Yes, though not necessarily. Prefix sum is enough.

That one is somewhat easier, because there you can also do some sort of binary search. Div1D forces you to write an "augmented DSU". Though they are clearly similar.

This is exactly the same question as in the IIT Kgp regionals for 2017/18. That was for a tree but the solution is exactly the same.

So how did you solve it?

As an observation, there will always be k extreme points in a convex polygon (k ≤ 4), so every f(x) with x ≥ k will return the maximum answer.

The solution for f(3) and convex polygon with 4 extreme points can be brute-forced. Simply traverse through all points, and with each point, match it with 2 out of 4 extreme points of the polygon.

Total complexity is O(6 * n), can be reduced to O(n) by further geometrical observations.

If a horizontal wall doesn't start at 0, we can always go around it, so discard those. Also, y-coordinate of horizontal walls doesn't matter.

Sort horizontal walls by their right end's x-coordinate, and vertical walls by their x-coordinate. Loop over how many horizontal walls we discard. Obviously the optimal ones to discard are always the one with maximal x-coordinate. Then, binary search how many vertical intervals we have to remove, so that we can reach the top row, when we have removed the given amount of horizontal intervals.

When you know that xor on segment [l, r) is equal to x, you add edge between vertex l and r with cost x. Now to answer query [l, r) you need to find xor on the path between l and r (xor on costs of the edges). This can be done similar to LCA.

Consider the prefix xor-sum array p₀, p₁, ..., p_n. Now the problem is basically giving you equations and asking for . Consider a graph on n + 1 nodes where u and v are connected by an edge of cost w iff . Then query is xor-sum of path from u to v. You can handle these with DSU (recompute distance from root for smaller tree when merging two trees).

What are the corner cases ? My approach is same. But got WA on test 6.

That was my solution and it passed pretests.

Yes that is correct.

When you're trying to submit this for more than an hour but you get 13 WAs instead of an AC :(

What if multiple closest nodes to p?

Just find the immediate left and immediate right driver for each rider. You can do this by first scanning the array from left to right to find the immediate left driver for each rider. Then scan the array from right to left to find the immediate right driver for each rider. While doing so, maintain the distance as well as the position of the driver. Now for each rider, compare the left and the right distance, whichever is shorter, increase the count for that driver's position.

I think this is correct solution http://codeforces.net/blog/entry/62929?#comment-469374

It can be done in at most two queries:

We are given at least one node X that is in Li's subtree (with his labeling). We ask B X. If the given label is one of our chosen vertexes, great. Otherwise, we are given node Z (in our labeling).

We find the closest node to Z that is in our chosen subtree. Let's call it Y. Now suppose there is a node X in the intersection of the two subtrees. Since node Y is on the path between X and Z, then it must be in Li's subtree aswell, so Y must be a common vertex if an intersection exists. So we just ask A Y: if the given label is one of

then Y is in the intersection. Otherwise output -1

Look at this : http://codeforces.net/blog/entry/62929?#comment-469369

Exactly...!! Lol..

What would be your ideal problem set then?

The way I see it, to solve any nontrivial problem you need to make several observations. What is the alternative? Implement well-known but difficult algorithms? Because in my opinion the former is vastly superior to the latter.

Because of the onsite round, the system testing will be in an hour after the round.

It's already over anyway.

Guess who =)

Final Standings

There are written "wrong answer", answer should be 17444, yours is differ

What was the thing that you were missing? I have same approch and getting WA on test case 17.

The judge responded with -1 and you didnt terminate your program so you got any verdict.

Possibly your BFS loops infinitely, you don't really check whether you're not visiting your parent again.

No, this is not valid.

According to the problem statement "The peculiarity of these spells is that it is impossible for a certain pair of such spells to have a common point". In that testcase, there is one common point (2, 2). Therefore, it is not valid.