Thanks everybody for participating. Tasks follow in the order of the original contest (the mirror order is given in the brackets).

The editorial is being translated right now.

## 562A - Logistical Questions

(in mirror: 566C - Logistical Questions)

Let's think about formal statement of the problem. We are given a tricky definition of a distance on the tre: ρ(*a*, *b*) = *dist*(*a*, *b*)^{1.5}. Each vertex has its weight *w*_{i}. We need to choose a place *x* for a competition such that the sum of distances from all vertices of the tree with their weights is minimum possible: *f*(*x*) = *w*_{1}ρ(1, *x*) + *w*_{2}ρ(*x*, 2) + ... + *w*_{n}ρ(*x*, *n*).

Let's understand how function *f*(*x*) works. Allow yourself to put point *x* not only in vertices of the tree, but also in any point inside each edge by naturally expanding the distance definition (for example, the middle of the edge of length 4 km is located 2 km from both ends of this edge).

**Fact 1**. For any path in the tree the function ρ(*i*, *x*) is convex. Actually, the function *dist*(*i*, *x*) plot on each path [*a*, *b*] looks like the plot of a function *abs*(*x*): it first decreases linearly to the minimum: the closes to *i* point on a segment [*a*, *b*], and then increases linearly. Taking a composition with a convex increasing function *t*^{1.5}, as we can see, we get the convex function on any path in the tree. Here by function on the path we understand usual function of a real variable *x* that is identified with its location on path *x*: *dist*(*a*, *x*). So, each of the summands in the definition of *f*(*x*) is convex on any path in the tree, so *f*(*x*) is also convex on any path in the tree.

Let's call convex functions on any path in the tree *convex on tree*. Let's formulate few facts about convex functions on trees.

**Fact 2**. A convex function on tree can't have two different local minimums. Indeed, otherwise the path between those minimums contradicts the property of being convex on any path in the tree.

So, any convex function *f*(*x*) on the tree has the only local minimum that coincides with its global minimum.

**Fact 3**. From each vertex *v* there exists no more than one edge in which direction the function *f* decreases. Indeed, otherwise the path connecting two edges of function decrease would contradict the definition of a convex function in a point *v*.

Let's call such edge that function decreases along this edge to be a *gradient* of function *f* in point *x*. By using facts 2 and 3 we see that in each vertex there is either a uniquely defined gradient or the vertex is a global minimum.

Suppose we are able to efficiently find a gradient direction by using some algorithm for a given vertex *v*. If our tree was a bamboo then the task would be a usual convex function minimization that is efficiently solved by a binary search, i. e. dichotomy. We need some equivalent of a dichotomy for a tree. What is it?

Let's use **centroid decmoposition**! Indeed, let's take a tree center (i. e. such vertex that sizes of all its subtrees are no larger than *n* / 2). By using fact 3 we may consider the gradient of *f* in the center of the tree. First of all, there may be no gradient in this point meaning that we already found an optimum. Otherwise we know that global minimum is located in a subtree in direction of gradient, so all remaining subtrees and the center can be excluded from our consideration. So, by running one gradient calculation we reduced the number of vertices in a considered part of a tree twice.

So, in runs of gradient calculation we almost solved the problem. Let's understand where exactly the answer is located. Note that the global optimum will most probably be located inside some edge. It is easy to see that the optimum vertex will be one of the vertices incident to that edge, or more specifically, one of the last two considered vertices by our algorithms. Which exactly can be determined by calculating the exact answer for them and choosing the most optimal among them.

Now let's calculate the gradient direction in a vertex *v*. Fix a subtree *u*_{i} of a vertex *v*. Consider a derivative of all summands from that subtree when we move into that subtree. Denote this derivative as *der*_{i}. Then, as we can see, the derivative of *f*(*x*) while moving from *x* = *v* in direction of subtree *u*_{i} is - *der*_{1} - *der*_{2} - ... - *der*_{i - 1} + *der*_{i} - *der*_{i + 1} - ... - *der*_{k} where *k* is a degree of vertex *v*. So, by running one DFS from vertex *v* we may calculate all values *der*_{i}, and so we may find a gradient direction by applying the formula above and considering a direction with negative derivative.

Finally, we got a solution in .

## 562B - Clique in the Divisibility Graph

(in mirror: 566F - Clique in the Divisibility Graph)

Order numbers in the sought clique in ascending order. Note that set *X* = {*x*_{1}, ..., *x*_{k}} is a clique iff for (1 ≤ *i* ≤ *k* - 1). So, it's easy to formulate a dynamic programming problem: *D*[*x*] is equal to the length of a longest suitable increasing subsequence ending in a number *x*. The calculation formula: for all *x* in set *A*.

If DP is written in "forward" direction then it's easy to estimate the complexity of a solution. In the worst case we'll process transitions.

## 562C - Restoring Map

(in mirror: 566E - Restoring Map)

Let's call a *neighborhood* of a vertex — the set consisting of it and all vertices *near* to it. So, we know the set of all neighborhoods of all vertices in some arbitrary order, and also each neighborhood is shuffled in an arbitrary order.

Let's call the tree vertex to be *internal* if it is not a tree leaf. Similarly, let's call a tree edge to be *internal* if it connects two internal vertices. An nice observation is that if two neighborhoods intersect exactly by two elements *a* and *b* then *a* and *b* have to be connected with an edge, in particular the edge (*a*, *b*) is internal. Conversely, any internal edge (*a*, *b*) may be represented as an intersection of some two neighborhoods *С* and *D* of some two vertices *c* and *d* such that there is a path *c* – *a* – *b* – *d* in the tree. In such manner we may find all internal edges by considering pairwise intersections of all neighborhoods. This can be done in about *n*^{3} / 2 operations naively, or in 32 times faster, by using bitsets technique.

Note that knowing all internal edges we may determine all internal vertices except the only case of a star graph (i. e. the graph consisting of a vertex with several other vertices attached to it). The case of a star should be considered separately.

Now we know the set of all leaves, all internal vertices and a tree structure on all internal vertices. The only thing that remained is to determine for each leaf, to what internal vertex is should be attached. This can be done in following manner. Consider a leaf *l*. Consider all neighborhoods containing it. Consider a minimal neighborhood among them; it can be shown that it is exactly the neighborhood *L* corresponding to a leaf *l* itself. Consider all internal vertices in *L*. There can be no less than two of them.

If there are three of them or more then we can uniquely determine to which of them *l* should be attached — it should be such vertex from them that has a degree inside *L* larger than 1. If there are exactly two internal vertices in *L* (let's say, *a* and *b*), then determining the attach point for *l* is a bit harder.

Statement: *l* should be attached to that vertex among *a*, *b*, that has an internal degree exactly 1. Indeed, if *l* was attached to a vertex with internal degree larger than 1, we would have considered this case before.

If both of vertices *a* and *b* have internal degree — 1 then our graph looks like a dumbbell (an edge (*a*, *b*) and all remaining vertices attached either to *a* or to *b*). Such case should also be considered separately.

The solution for two special cases remains for a reader as an easy exercise.

## 562D - Restructuring Company

(in mirror: 566D - Restructuring Company)

This problem allows a lot of solution with different time asymptotic. Let's describe a solution in .

Let's first consider a problem with only a queries of second and third type. It can be solved in a following manner. Consider a line consisting of all employees from 1 to *n*. An observation: any department looks like a contiguous segment of workers. Let's keep those segments in any logarithmic data structure like a balanced binary search tree (std::set or TreeSet). When merging departments from *x* to *y*, just extract all segments that are in the range [*x*, *y*] and merge them. For answering a query of the third type just check if employees *x* and *y* belong to the same segment. In such manner we get a solution of an easier problem in per query.

When adding the queries of a first type we in fact allow some segments to correspond to the same department. Let's add a DSU for handling equivalence classes of segments. Now the query of the first type is just using merge inside DSU for departments which *x* and *y* belong to. Also for queries of the second type it's important not to forget to call merge from all extracted segments.

So we get a solution in time.

## 562E - Max and Min

(in mirror: 566G - Max and Min)

Consider a following geometrical interpretation. Both Max and Min have a set of vectors from the first plane quadrant and a point (*x*, *y*). During his turn Max may add any of his vectors to a point (*x*, *y*), and Min — may subtract any of his vectors. Min wants point (*x*, *y*) to be strictly in the third quadrant, Max tries to prevent his from doing it. Denote Max vectors as *Mx*_{i} and Min vectors as *Mn*_{j}.

Consider a following obvious sufficient condition for Max to win. Consider some non-negative direction in a plane, i. e. such vector (*a*, *b*) that *a*, *b* ≥ 0 and at least one of numbers *a*, *b* is not a zero. Then if among Max vectors there is such vector *Mx*_{i}, that it's not shorter than any of Min vectors *Mn*_{j} along the direction (*a*, *b*) then Max can surely win. Here by the length of vector *v* along a direction (*a*, *b*) we mean a scalar product of vector *v* and vector (*a*, *b*).

Indeed, let Max always use that vector *Mx*_{i}. Then during the turns of Max and Min point (*x*, *y*) is shifted by a vector *Mx*_{i} - *Mn*_{j} for some *j*, so its overall shift along the vector (*a*, *b*) is equal to ((*Mx*_{i} - *Mn*_{j}), (*a*, *b*)) = (*Mx*_{i}, (*a*, *b*)) - (*Mn*_{j}, (*a*, *b*)) ≥ 0. By observing that initially the scalar produt ((*x*, *y*), (*a*, *b*)) = *ax* + *by* > 0 we see that at any moment *ax* + *by* will be strictly positive. This means that Min won't be able at any moment to make *x* and *y* both be negative (since it would mean that *ax* + *by* < 0).

Now let's formulate some kind of converse statement. Suppose Max vector *Mx*_{i} lies strictly inside the triangle formed by Min vectors *Mn*_{j} and *Mn*_{k}. In particular, vector *Mx*_{i} endpoint can't lie on a segment [*Mn*_{j}, *Mn*_{k}], but it may be collinear one of vectors *Mn*_{j} and *Mn*_{k}.

Note that since *Mx*_{i} lies strictly inside the triangle formed by vectors *Mn*_{j} and *Mn*_{k} it can be extended to a vector *Mx*'_{i}, whose endpoint lies on a segment [*Mn*_{j}, *Mn*_{k}]. By using linear dependence of *Mx*'_{i} and *Mn*_{j}, *Mn*_{k} we have that *Mx*'_{i} = (*p* / *r*)*Mn*_{j} + (*q* / *r*)*Mn*_{k}, where *p* + *q* = *r* and *p*, *q*, *r* — integer non-negative numbers. This is equivalent to a formula *rMx*'_{i} = *pMn*_{j} + *qMn*_{k}. This means that if per each *r* turns of Max in *Mx*_{i} we will respond with *p* turns of Min in *Mn*_{j} and *q* turns of Min in *Mn*_{k}, then the total shift will be equal to - *pMn*_{j} - *qMn*_{k} + *rMx*_{i} = - *rMx*'_{i} + *rMx*_{i} = - *r*(*Mx*'_{i} - *Mx*_{i}), that is the vector with strictly negative components. So, we are able to block that Max turn, i. e. it does not give any advantage to Max.

The natural wish is to create a convex hull of all Min turns and to consider all Max turns in respect to it. If Max turn lies inside the convex hull of Min turns, then by using the previous fact this turn is meaningless to Max. Otherwise, there are two possibilities.

First, this turn may intersect the hull but go out of it somewhere; in this case this Max turn is no shorter than all Min turns in some non-negative direction (more specifically, in its own direction), so Max wins.

On the other hand, Max vector lies to aside from the Min turns convex hull. Let's suppose the vector *Mx*_{i} lies to the left of the Min turns. This case requires a special analysis. Consider the topmost of the Min vectors *Mn*_{j}. If *Mx*_{i} is no lower than *Mx*_{j}, then by using the first fact Max is able to win by using only this vector. Otherwise the difference *Mn*_{i} - *Mx*_{j} is a vector with strictly negative components, by using which we are able to block that Max vector.

So, the full version of a criteria for Min being a winner looks like the following. Consider a convex hull of Min turns and expand it to the left of the topmost point and to the bottom of the rightmost point. If all Max turns lie strictly inside the formed figure then Min wins, otherwise Max wins.

## 562F - Matching Names

==== **UNTRANSLATED SECTION, PLEASE WAIT A FEW MINUTES...** ====

Kitten to take your attention :)

Сформиурем бор из всех имён и псевдонимов. Отметим красным все вершины, соответствующие именам, и синим все вершины, соответствующие всем псевдонимам (одна вершина может быть отмечена несколько раз, в том числе разными цветами). Заметим, что если мы сопоставили имя *a* и псевдоним *b*, то качество такого сопоставления может быть выражено как *lcp*(*a*, *b*) = 1 / 2(2 * *lcp*(*a*, *b*)) = 1 / 2(|*a*| + |*b*| - (|*a*| - *lcp*(*a*, *b*)) - (|*b*| - *lcp*(*a*, *b*))), что представляет собой константу 1 / 2(|*a*| + |*b*|), из которой вычитается половина длины пути между *a* и *b* по бору. Таким образом, мы должны соединить все красные вершины с синими, минимизировав суммарную длину путей.

Нетрудно видеть, что такая задача решается жадным образом следующей рекурсивной процедурой: если у нас есть вершина *v*, в поддереве которой *x* красных вершин и *y* синих вершин, то мы должны сопоставить *min*(*x*, *y*) красных вершин этого поддерева синим вершинам, а оставшиеся *max*(*x*, *y*) - *min*(*x*, *y*) красных или синих вершин "отдать" на уровень выше. Корректность данного алгоритма легко объясняется следующим соображением. Ориентируем ребро каждого пути по направлению от красной вершины к синей. Если ребро получает две разных ориентации, то два пути, на которых оно лежит, легко "развести", уменьшив их суммарную длину.

Таким образом, получается несложное решение за *O*(*sumlen*), где *sumlen* — суммарная длина всех имён и псевдонимов.

(в трансляции: 566A - Matching Names)

## 562G - Replicating Processes

(в трансляции: 566B - Replicating Processes)

Эту задачу можно решить симулируя процесс реплицирования. Будем к каждому шагу поддерживать список всех репликаций, которые в текущий момент можно применить. Применяем любую репликацию, после чего обновляем список, добавляя/удаляя все подходящие или переставшие быть подходящими репликации со всех затронутых на данном шаге серверов. Список репликаций можно поддерживать в структуре данных "двусвязный список", которая позволяет за *O*(1) добавлять и удалять элемент в/из множества и вынимаь произвольный элемент множества.

Доказательство корректности этого алгоритма несложно и оставляется как упражнение (впрочем, если будет большое количество желающих, оно появится здесь позднее).

Получается решение за *O*(*n*) операций (впрочем, константа, скрытая за *O*-нотацией весьма немаленькая — один только ввод составляет 12*n* чисел, да и само решение оперирует по меньшей мере константой 36).