dynamic programming algorithm during an interview [closed]

Question

This question was asked to me in an interview and it embarrassingly exposed my shortcomings on dynamic programming. I will appreciate if someone can help me crack this one. Also, it would be very helpful to me (and others) if you can explain your thinking process along the way as you devise the solution as i seem to be able to understand when i see a solution which uses dynamic programming paradigm but struggle to come up with my own.

Without further ado, here is the question i was asked.

Given an integer i and set X of k points x1, x2, ... xk on real line, select i points from set X so as to minimize the sum of the distance from every point in X to a point in i using Dynamic programming.

Answer 1

With most DP problems I try and find a kind of reduce-and-conquer relation. That is, a relation whereby I can cut away from the problem size with each step (like divide and conquer, but usually doesn't divide the problem, it just removes a small part). In this problem (like many others) we can make a very simple observation: Either the first point is in the set of i points, or it isn't.

Some notation: Let's say X = {x₁, x₂, ..., x_k}, and denote the reduced set X_n = {x_n, x_n+1, ..., x_k}.

So the observation is that either x₁ is one of the i points, or it isn't. Let's call our i-set finding function MSD(i,X_k) (minimum sum of distances). We can express that cut-away observation as follows:

MSD(i,X_k) = Either MSD(i-1,X_k-1) U {x₁} or MSD(i,X_k-1)

We can formalise the "either or" part by realising a simple way of checking which of those two options it actually is: We run through the set X and calculate the sum of the distances, and check which is actually the smaller. We note at this point, that that check has a running time of ki since we will naively run through each of the k points and grab the minimum distance from points in the set of size i.

We make two simple observations regarding base cases:

MSD(i,X_i) = X_i
MSD(0,X_n) = {}

The first is that when looking for i points in a set of size i we obviously just take the whole set.
The second is that when looking for no points in a set, we return the empty set. This inductively ensures that MSD returns sets of size i (it's true for the case where i=0 and by induction is true according to our definition of MSD above).

That's it. That will find the appropriate set. Runtime complexity is upper bounded by O(ik * step) where step is our O(ik) check from above. This is because MSD will be run on parameters that range from 0-i and X₁ - X_k, which is a total of ik possible arguments.

That leaves us with a runtime of O((ik)²).

The following part is based on my understanding of the OP's question. I'm not sure if the distance of every point in X from the i-sized subset is the sum of the distances of every point from every other point in the subset, or the sum of the distances of every point in X from the subset itself.
I.e. sigma of x in X of (sum of distances of x from every point in the subset) OR sigma of x in X of (distance of x from the subset which is the minimum distance from x to any point in the subset)

I assume the latter.

We can reduce the runtime by optimising the O(ik) check from above. We notice that the elements are actually sorted (albeit in reverse order in this current notation), since when we add them on we do so always from the right hand side. Assuming they're sorted to begin with, they will be once out of the MSD routine. If they weren't sorted to begin with we can sort them, which will only cost O(klogk) anyway.

Once sorted, checking the distance of each point from a point in the set will be k * logi since for each point we do a binary search. This yields a total running time of O(ik * klogi + klogk)
= O(k² * ilogi).

Finally, we can express that as O(k³logk). Not the fastest solution, but a solution.

I'm sure there are even more optimisations, but that's my 2c.