Clearly this contests was too hard and I am sorry about that. Nevertheless, I will show you in this editorial that actually these problems are not so very hard and are closely related to some problems already here.
Problem A: Ad-hoc, Lists
The reverse operation cannot be implemented by literally reversing the list as this costs \(O(n)\) per rotate operation thus leading to a \(O(n^2)\) algorithm.
Instead just keep the list elements in an array with. We keep a pointer for the leftmost element and another for the rightmost one. Also, keep a boolean flag saying whether the list is rotated. Whenever we delete an element if the list it not rotated we increase the leftmost pointer. Otherwise we decrease the rightmost one.
The rotation operation simply consists in flipping the flag in \(O(1)\).
Make sure to test your code in corner cases like an empty input list and a list with a single element. Also, make sure to print it in the right order in the end depending on the flag.
You need to be careful with the output. It is quite large avoid:
- Building it as a string with
- Making a lot of
Instead use a
StringBuilder to build it and a single call to
Problem B: Classic DP
This is a classic dynamic programming problem. Just sort the people by increasing income and compute the longest decreasing subsequence with respect to the happiness. Don't forget to ensure that when you compute your sequence you only consider elements with strictly lower income and strictly higher happiness.
After sorting the DP recurrence is the following:
Problem C: Brute-force on solution structure + BFS
If you think about the solution, it will be a path from the outside to some node \(v\) (which can be either a cell of the outside node) and then one path from each prisoner to \(v\). For a given \(v\) is it easy to compute the cost of that solution. It is simply
Thus we can just perform a BFS from P1, P2 and outside and compute the best \(v\).
Problem D: Geometry
With this type of problem it is always easier to normalize the input. We can do that in the same way you solved (or should have solved) Align Polygon.
In this case we normalize so that the first edge is the segment between \((0, 0)\) and \((x, 0)\) for some \(x\) and the camera is at \(C = (x / 2, 0)\).
Then we simply compute the lines \(l_1 = line(C, C + (1, 1))\) and \(l_2 = line(C, C + (-1, 1))\). We intersect these lines with the edges of the polygon and compute the area of the polygon with vertices
where \(v_1, \ldots, v_k\) are the vertices of the original polygon between \(inter_1\) and \(inter_2\).
Problem E: Binary search on the answer
So imagine that the problem is instead: given a time \(t\), can they move apart in time t? If you think about it you will see that it is easy to solve when \(t\) is given.
Hint: The leftmost food truck will walk left \(t\) units in the optimal solution.
Use the slack !