Question

You are given a list of distances between various points on a single line.

For example:

• 100 between a and b
• 20 between c and b
• 90 between c and d
• 170 between a and d

Return the sorted sequence of points as they appear on the line with distances between them:

For example the above input yields:
a<—-80—–> c <—-20——> b <—-70—–> d or the reverse sequence(doesn’t matter)

What is this problem called? I would like to research it.

If anybody knows, also, what are some of the possible asymptotic runtimes achieved for this?

Answer 1

not sure it has a name; more formally stated, it would be:

|a-b| = 100
|c-b| = 20
|c-d| = 90
|a-d| = 170

where |x| stands for the absolute value of x

As far as the generalized system goes, if you have N equations of this type with k unknowns, you have N choices of sign. Without loss of generality (because any solution yields a second solution with reversed ordering) you can choose a sign for the first equation, and a particular value for one of the unknowns (since the whole thing can slide left and right in position). Then you have 2^N-1 possibilities for the remaining equations, and all you have to do is go through them to see which ones, if any, have solutions. Because the coefficients are all +/- 1 and each equation has 2 unknowns, you just go through them one by one:

Step 1: Without loss of generality, 
  choose a sign for one equation
  and pick a value for one unknown:
a-b = 100, a = 0

Step 2: Choose signs for the remaining absolute values.
a = 0
a-b = 100
c-b = 20
c-d = 90
a-d = 170

Step 3: go through them one by one to solve / verify there aren't conflicts 
(time = N steps).
0-b = 100  =>  b = -100
c-b = 20   =>  c = -80
c-d = 90   =>  d = -170
a-d = 170  =>  OK        => (0,-100,-80,-170) is a solution

Step 4: if this doesn't work, go back through the possible choices of sign 
and try again, starting at step 2.

Full set of solutions is (0,-100,-80,-170) 
and its negation (0,100,80,170) and any number x<sub>0</sub> added to all terms.

So an upper bound for the runtime is O(N * 2^N-1) ≡ O(N * 2^N).

I suppose there could be a shortcut but no obvious one comes to mind.