Don't judge 300iq by its color.

300iq is not blue pal

Yes, he was the worst coordinator I've ever met in preparing CF round.

It's because of magic , in fact he is legendary grandmaster , but he have changed his colour . exactly like you , a green grandmaster :)

Such shame that you don't who he is.he got rank 2 in IOI 2018

Hi "user ainta", hope u and cafe mountain get the 1st place this year ^_^

Hi ko_osaga

Yes

Then who will get the last places?

But you are already a legendary grandmaster :-)

For your information, ISO 8601 defined decade like this.

3.1.2.22

decade

time scale unit (3.1.1.7) of 10 calendar years (3.1.2.21), beginning with a year whose year number is divisible without remainder by ten

more likely pretest passed >= system test passed

And getting downvotes :P

Like goodbye 2019.

Yeah, man.

There weren't subtasks in the last contest.

A B C graph problems is kinda boring or well known .. if not contest would be unbalanced

Yes, it seems to be the contest with the most registration in the history.

Now it has come to that.

But if there is less query problem, the server would rather less suffer.

There will be a lot like you to reduce the load of server so that other can participate safely.

Seriously why this tough !! :(

Mostly, it will fail if you use atan2.

How can It be solved using segment tree?

Use prefix sums instead of segment tree.

If a subsequence already has an ascent, add n. If not, add (# of subsequences that have an ascent) and all subsequences that have a max value greater than this subsequence's min value (and do not have an ascent). To do this query fast, I used a suffix array from 1 to 1e6 for suffix[i] = number of sequences with max_value >= i that do not have an ascent.

Binary search?

binary search works

with binary search

First, count the sequences already with an ascent (let there be asc of them) and discard them. Then interpret all remaining sequences as line segments (from their min value to their max value), create 2 events (start and end) for every one, and sort them. Use that to count how many segments start after the current segment ends for every segment and sum these numbers, i.e. find the number of non-overlapping segments, and use that to find the number of overlapping segments (m*m - non_overlapping_count where m is the number of remaining segments). The answer is m*m-non_overlapping_count + 2*n*asc - asc*asc (add pairs of sequences where at least one already has an ascent, and subtract those where both do).

So, there can be two types of valid concat. One is ascents exists in either the s_x or in s_y, second is smaller element exists in s_x and greater element exist in s_y.

So if we find an array where we got a ascent, we can pair it with all arrays. Now, we will count how many subarrays of type two exist. for each array which doesn't contain any ascent, you can pair this with such type of array where the maximum element is greater than the minimum element of the current array.

• Find min, max of each sequence — store that (no need to store the entire list)
• Store how many numbers are greater than and less than each min/max in an array (doesn't need segment tree)
• If a sequence is already sorted, maintain a count of that and don't count its min/max. This is because this sequence concatenation will always result in a desired sequence
• For each sequence, check how many min's its max is greater than. Add that to total.
• Note that a sequence can be concatenated with itself (so make sure that's not double counted)

68188241

Why so many downvotes? My solution is accepted using segment tree, but I'm sure it should be not the intended solution. That's why I'm asking here

Instead of checking subets, check only pairs.

My idea was the following.

Suppose you have a graph for each venue. Vertices are the intervals, we connect them only if they don’t intersect. The problem asks if those two graphs are equal.

The size of each graph is quadratic, so you can’t just create them and compare. My idea was to make the hash of each graph and compare them. For each vertex you can get the sum of its neighbors indices multiplied by some power of 2s .You can check out the hashing method in more details in my solution.

Did anyone else solve the same way with hashing?

In D, I figured out one observation, say intervals at the same indices at venue A and venue B must have the same number of overlapping intervals. This is a necessary condition and we can also easily prove by induction that it is sufficient condition as well.

Now the task is to calculate the number of overlapping intervals for each index which can be easily calculated using sorting.

Let K be the sum of the points lying inside each triangle. The answer is: K * (N-4) / 2;

How to solve C? TIA

What was nice about it? :)

Yes. Try to find constructive proof not using Hall.

My solution (pending systests) doesn't use a LCT (or something similar). My solution was to find an edge $$$(u, v)$$$ in $$$T_2$$$ such that $$$u$$$ is a leaf. Let $$$w$$$ be the first neighbour of $$$u$$$ in $$$T_1$$$ on the path from $$$u$$$ to $$$v$$$ (in $$$T_1$$$). Then we print $$$(u, w)\in T_1$$$ and $$$(u, v)\in T_2$$$, remove $$$(u, v)$$$ from $$$T_2$$$ and contract the edge $$$(u, w)$$$ in $$$T_1$$$. One can prove the resulting graphs are trees on $$$n-1$$$ vertices, correctness follows inductively. The contraction operation requires some careful bookkeeping with vectors/sets, but ultimately doesn't require anything fancy.

The main idea is check venue-sensitive set with size 2

For each lecture, check if the list of lectures that intersect with it in venue $$$a$$$ is the same as the list of lectures that intersect with it in venue $$$b$$$

Instead of comparing each element in two list, we'll check does any element that appear in this list but doesn't appear in the other list

for length k permutations, the sum is (n-k+1) * (n-k+1) * k! * (n-k)!

eg n=4,k=2

we have 12 23 34 (4-2+1 kinds)

and for 12, it has 2! permutations

the numbers left are 34, has (4-2)! permutations

we want to put 12 into ()3()4() , which have (4-2+1 blanks)

It is almost always not the right idea to start with the harder problems.

Here is the explanation: It is more probable that you will get the easier problem quickly and harder problem will take more time. Submitting earlier ensures that you don't accumulate the penalty for the easier problems. Even in a simple scenario where you solve A in 3 minutes and E in 30 minutes, your penalty is 3 + 33 = 36 minutes. If you solve A later, you penalty for A is 33 minutes and so the total penalty is 63 minutes. I don't exactly know about how scoring works, but at least in the time penalty approach you can see how worse it can be to not solve an easier problem.

Your input format is a bit messed up — You cannot attend 1 and 3 at A (1-5/3-6) nor can you attend 1 and 3 at B (2-9/7-11)