## Saturday, June 28, 2014

### ICPC Problem J: Skiing

I'll start by mentioning that there is also some analysis discussion on the Topcoder forums, which includes alternative solutions that in some cases I think are much nicer than mine.

So, on to problem J - which no team solved, and only one team attempted. I'm a little surprised by this, since it's the sort of problem where one can do most of the work on paper while someone else is using the machine. A possible reason is that it's difficult to determine the runtime: I just coded it up and hoped for the best.

It is a slightly annoying problem for a few reasons. Firstly, there are a few special cases, because $$v_y$$ or $$a$$ can be zero. We also have to find the lexicographically smallest answer.

Let's deal with those special cases first. If $$v_y = 0$$ then we can only reach targets with $$y = 0$$. If $$a \not= 0$$ then we can reach all of them in any order, otherwise we can only reach those with $$x = 0$$. To get the lexicographically smallest answer, just go through them in order and print out those that are reachable. I actually dealt with the $$v_y \not= 0$$, $$a = 0$$ case as part of my general solution, but is also easy enough to deal with. We can only reach targets with $$x = 0$$, and we can only reach them in increasing order of y. One catch is that targets are not guaranteed to have distinct coordinates, so if two targets have the same coordinates we must be careful to visit them in lexicographical order. I handled this just by using a stable sort.

So, onwards to the general case. Before we can start doing any high-level optimisation, we need to start by answering this question: if we are at position P with X velocity $$v$$ and want to pass through position Q, what possible velocities can we arrive with? I won't prove it formally, but it's not hard to believe that to arrive with the smallest velocity, you should start by accelerating (at the maximum acceleration) for some time, then decelerate for the rest of the time. Let's say that the total time between P and Q is $$T$$, the X separation is $$x$$, the initial acceleration time is $$T - t$$ and the final deceleration time is $$t$$. Some basic integration then gives
$x = v(T-t)+\tfrac{1}{2}a(T-t)^2 + (v+a(T-t))t - \tfrac{1}{2}at^2.$
This gives a quadratic in $$t$$ where the linear terms conveniently cancel, leaving
$t = \sqrt{\frac{vT+\tfrac{1}{2}aT^2-x}{a}}$
The final velocity is just $$v+aT-2at$$. We can also find the largest possible arrival velocity simply by replacing $$a$$ with $$-a$$. Let's call these min and max velocity functions $$V_l(v, T, x)$$ and $$V_h(v, T, x)$$.

More generally, if we can leave P with a given range of velocities $$[v_0, v_1]$$, with what velocities can we arrive at Q? We first need to clamp the start range to the range from which we can actually reach Q i.e., that satisfy $$|vT - x| \le \frac{1}{2}aT^2$$. A bit of calculus shows that $$V_l$$ and $$V_h$$ are decreasing functions of $$v$$, so the arrival range will be $$[V_l(v_1), V_h(v_0)]$$.

Finally, we are ready to tackle the problem as a whole, with multiple targets. We will use dynamic programming to answer this question, starting from the last target (highest Y): if I start at target i and want to hit a total of j targets, what are the valid X velocities at i? The answer will in general be a set of intervals. We will make a pseudo-target at (0, 0), and the answer will then be the largest j for which 0.0 is a valid velocity at this target.

Computing the DP is generally straightforward, except that the low-level queries we need are the reverse of those we discussed above i.e. knowing the arrival velocities we need to compute departure velocities. No problem, this sort of physics is time-reversible, so we just need to be careful about which signs get flipped. For each (i, j) we consider all options for the next target, back-propagate the set of intervals from that next target, and merge them into the answer for (i, j). Of course, for $$j = 1$$ we use the interval $$(-\infty, \infty)$$.

The final inconvenience is that we must produce a lexicographical minimum output. Now we will see the advantage of doing the DP in the direction we chose. We build a sequence forwards, keeping track of the velocity interval for our current position. Initially the position will be (0, 0) and the velocity interval will be [0.0, 0.0]. To test whether a next position is valid, we forward-propagate the velocity interval to this next position, and check whether it has non-empty intersection with the set of velocities that would allow us to hit the required number of remaining targets. We then just take the next valid position with the lowest ID.

What is the complexity? It could in theory be exponential, because every path through the targets could induce a separate interval in the interval set. However, in reality the intervals merge a lot, and I wouldn't be surprised if there is some way to prove that there can only be a polynomial number of intervals to consider. My solution still ran pretty close to the time limit, though.