Correctness proof of Algorithm - algorithm

Question

Our teacher asked us a question which goes like this.
Given a list of n distinct integers and a sequence of n boxes with preset
inequality signs inserted between them, design an algorithm that places
the numbers into the boxes to satisfy those inequalities. For example, the
numbers 2, 5, 1, and 0 can be placed in the four boxes as shown below
The from looking at the question we can say the numbers be sorted and if less than symbol appears next we have to insert the least number, if greater than symbol appears we have to insert max number and proceed as so.
How can I say this algorithm works for every case?
Traversing in
one direction i found one solution and in reverse order i found
another. What is the efficient method to find all solutions to this
problem?

Answer 1

To answer question 1, I'd say that should be done by induction over the number of distinct numbers involved.
Say n is the number of numbers.
for n = 1 there's nothing left to prove.
for n = 2, you have either a greater than or a less than operator. Since the numbers are distinct and the set of natural (or real) numbers is well ordered, your algorithm will trivially yield a solution.
n -> n+1:
case 1: the first operator is a less than sign. According to your algorithm you pick the smallest number and put it into the first box. Then you solve the problem for the last n boxes. This is possible by induction. Since the number in the first box is the smallest, it is also smaller than the number in the second box. Therefor you have a solution.
Case 2: the first operator is a greater than sign. This also works analogue to case 1.
QED
Now for the second part of the question. My thoughts came up with the algorithm described below. Happy with the fact I solved the question (of getting all solutions) in the first place, I can't guarantee that it's the fastest solution.
As already noted in a comment, if there are no operator changes, there will be only one solution. So we assume there are operator changes (but the algorithm will produce this solution too).
for all operator changes of the form >< or nil < (first operator is a <):
place the smallest element between them
now divide the remaining set of numbers into two.
if there are n numbers and there are k operators to the left of
the placed number, that will give you k over (n - 1) possibilities.
do this recursively with the two remaining parts.
If no operator changes of the form >< or nil < are left,
do the same with the mirrored operator changes <> and nil >,
but choose the highest element of the set.
If no operator changes are left, fill in the elements according to the
remaining operator in ascending or descending order.
OK, this is not program code, but I think that will be comparatively easy (the choose k out of n - 1 is the hard part). I hope my explanation of the algorithm is understandable. And beware, the number of solutions grows fast (exponentially, probably worse).

Answer 2

Answering part two of the question in part, finding one single solution:
First, the input can be sorted, which can be done in O( n log n ) time. Then, the algorithm described can be applied; the minimum and maximum element are at the beginning and the end of the list, which can be accessed in constant time. This means that, once the input is sorted, the output can be generated in O( n ) time. This yields a runtime bound of O( n log n ) in total.

Answer 3

Here's a proof that there is an assignment of numbers to boxes:
The diagram defines a partial order on the empty boxes (box A <= box B
if either A=B, or A is the left of B and there's only < between them,
or A is to the right of B and there's only > between them). It's easy
to check that <= satisfies the properties of a partial order.
Any finite partially ordered set can be totally ordered (for example
by using a topological sort).
So sort the boxes with respect to the total order, and assign numbers
based on the position in the resulting list.
This yields an answer to part (2) of your question, which is to enumerate all possible solutions. A solution is exactly a total order that's compatible with the partial order defined in the proof, and you can generate all possible total orders by choosing which minimal element you pick at each stage in the topological sort algorithm.
That is, you can generate all solutions like this:
topo_sort(boxes):
if boxes = [] then return [[]]
let result = []
for each x in minimal(boxes)
for each y in topo_sort(boxes - x)
append ([x] + y) to result
return result
minimal(boxes):
return [all x in boxes such that there's no y != x in boxes with y lesseq x]
Here "lesseq" is constructed as in the proof.
If you squint hard enough, you can see that your algorithm can also be viewed as a topological sorting algorithm, using the observation that if the next symbol is a > then the first element is maximal in the remaining list, and if the next symbol is a < then the first element is minimal in the remaining list. That observation gives you a proof that your algorithm is also correct.
Here's an inefficient Python 2.7 implementation:
def less(syms, i, j):
if i == j: return False
s = '<' if i < j else '>'
return all(c == s for c in syms[min(i,j):max(i,j)])
def order(boxes, syms):
if not boxes:
yield []
return
for x in [b for b in boxes if not any(less(syms, a, b) for a in boxes)]:
for y in order(boxes - set([x]), syms):
yield [x] + y
def solutions(syms):
for idxes in order(set(range(len(syms)+1)), syms):
yield [idxes.index(i) for i in xrange(len(syms)+1)]
print list(solutions('<><'))
Which gives as output all 5 solutions:
[[0, 2, 1, 3], [0, 3, 1, 2], [1, 2, 0, 3], [1, 3, 0, 2], [2, 3, 0, 1]]