This round was unusual: some of problems was prepared by students and employees of Saratov State U for some of past olympiads and one of problems was prepared by dalex for Codeforces regular round but was not used there.

Let's sort the array in nonincreasing order. Now the answer is some of the first flash-drives. Let's iterate over array from left to right until the moment when we will have the sum at least *m*. The number of elements we took is the answer to the problem.

Complexity: *O*(*nlogn*).

Let's denote *cnt*_{i} — the number of books of *i* th genre. The answer to problem is equals to . In first sum we are calculating the number of good pairs, while in second we are subtracting the number of bad pairs from the number of all pairs.

Complexity: *O*(*n* + *m*^{2}) or *O*(*n* + *m*).

Denote *s* — the sum of elements in array. If *s* is divisible by *n* then the balanced array consists of *n* elements . In this case the difference between maximal and minimal elements is 0. Easy to see that in any other case the answer is greater than 0. On the other hand the array consists of numbers and numbers is balanced with the difference equals to 1. Let's denote this balanced array *b*. To get array *b* let's sort array *a* in nonincreasing order and match element *a*_{i} to element *b*_{i}. Now we should increase some elements and decrease others. In one operation we can increase some element and decrease another, so the answer is .

Complexity: *O*(*nlogn*).

609D - Gadgets for dollars and pounds

If Nura can buy *k* gadgets in *x* days then she can do that in *x* + 1 days. So the function of answer is monotonic. So we can find the minimal day with binary search. Denote *lf* = 0 — the left bound of binary search and *rg* = *n* + 1 — the right one. We will maintain the invariant that in left bound we can't buy *k* gadgets and in right bound we can do that. Denote function *f*(*d*) equals to 1 if we can buy *k* gadgets in *d* days and 0 otherwise. As usual in binary search we will choose . If *f*(*d*) = 1 then we should move the right bound *rg* = *d* and the left bound *lf* = *d* in other case. If binary search found the value *lf* = *n* + 1 then the answer is - 1, otherwise the answer is *lf*. Before binary search we can create two arrays of gadgets which are selling for dollars and pounds, and sort them. Easy to see that we should buy gadgets for dollars on day *i* ≤ *d* when dollar costs as small as possible and *j* ≤ *d* when pounds costs as small as possible. Let now we want to buy *x* gadgets for dollars and *k* - *x* gadgets for pounds. Of course we will buy the least cheap of them (we already sort the arrays for that). Let's iterate over *x* from 0 to *k* and maintain the sum of gadgets for dollars *s*_{1} and the sum of gadgets for pounds *s*_{2}. For *x* = 0 we can calculate the sums in *O*(*k*). For other x's we can recalculate the sums in *O*(1) time from the sums for *x* - 1 by adding gadget for dollars and removing gadget for pounds.

Complexity: *O*(*klogn*).

609E - Minimum spanning tree for each edge

This problem was prepared by dalex.

Let's build any MST with any fast algorithm (for example with Kruskal's algorithm). For all edges in MST the answer is the weight of the MST. Let's consider any other edge (*x*, *y*). There is exactly one path between *x* and *y* in the MST. Let's remove mostly heavy edge on this path and add edge (*x*, *y*). Resulting tree is the MST contaning edge (*x*, *y*) (this can be proven by Tarjan criterion).

Let's fix some root in the MST (for example the vertex 1). To find the most heavy edge on the path from *x* to *y* we can firstly find the heaviest edge on the path from *x* to *l* = *lca*(*x*, *y*) and then on the path from *y* to *l*, where *l* is the lowest common ancestor of vertices *x* and *y*. To find *l* we can use binary lifting method. During calculation of *l* we also can maintain the weight of the heaviest edge.

Of course this problem also can be solved with difficult data structures, for example with Heavy-light decomposition method or with Linkcut trees.

Complexity: *O*(*mlogn*).

It's very strange but I can't find any articles with Tarjan criterion on English (although there are articles on Russian), so here it is:

Some spanning tree is minimal if and only if the weight of any other edge (*x*, *y*) (not from spanning tree) is not less than the weight of the heaviest edge on the path from *x* to *y* in spanning tree.

Let's maintain the set of not eaten mosquitoes (for example with *set* in C++ or with *TreeSet* in Java) and process mosquitoes in order of their landing. Also we will maintain the set of segments (*a*_{i}, *b*_{i}), where *a*_{i} is the position of the *i*-th frog and *b*_{i} = *a*_{i} + *l*_{i}, where *l*_{i} is the current length of the tongue of the *i*-th frog. Let the current mosquito landed in the position *x*. Let's choose segment (*a*_{i}, *b*_{i}) with minimal *a*_{i} such that *b*_{i} ≥ *x*. If the value *a*_{i} ≤ *x* we found the frog that will eat mosquito. Otherwise the current mosquito will not be eaten and we should add it to our set. If the *i*-th frog will eat mosquito then it's tongue length will be increased by the size of mosquito and we should update segment (*a*_{i}, *b*_{i}). After that we should choose the nearest mosquito to the right the from frog and if it's possible eat that mosquito by the *i*-th frog (this can be done with *lower_bound* in C++). Possibly we should eat several mosquitoes, so we should repeat this process several times.

Segments (*a*_{i}, *b*_{i}) we can store in segment tree by position *a*_{i} and value *b*_{i}. Now to find segment we need we can do binary search by the value of *a*_{i} and check the maximum *b*_{i} value on the prefix to be at least *x*. This will work in *O*(*nlog*^{2}*n*) time. We can improve this solution. Let's go down in segment tree in the following manner: if the maximum value *b*_{i} in the left subtree of segment tree is at least *x* then we will go to the left, otherwise we will go to the right.

Complexity: *O*((*n* + *m*)*log*(*n* + *m*)).