Question

I encountered the problem in a programming interview and have no idea about it by now.

A list whose length is n, the elements in it are all positive integers without order.
To find out all possible triples (a, b, c), that a < b < c, and a appears before b and b before c in the list.

And analyse the time complexity of your algorithm.

Answer 1

If it is known that there are only a small set of triples (say k), then you may prefer to find all the triples by storing pointers to the previous smallest element.

ALGORITHM

Prepare an empty data structure (possible choices described later).

Prepare an empty array B of length n.

Then for each element c in the list:

1. Store the index (in the array B) of the most recent element in the list that is smaller than c (if it exists) using the data structure.
2. Store c (and its index in the original list) in the data structure
3. Then use array B to find all elements b smaller than c, and then again to find all elements a smaller than b, and emit all these combinations as output triples.

DATA STRUCTURE

The data structure needs to be able to store value,position pairs to make it easy to find the largest position (i.e. most recent) over all elements with value less than c.

One easy way to do this if the range of allowed values is fairly small is to use a series of arrays where A[k][x] stores the maximum position for all elements in the range [x*2^k,(x+1)*2^k).

If the values have up to M bits (i.e. the values are in the range 0 to 2^M-1) then updating or accessing this data structure are both O(M) operations.

COMPLEXITY

The given method is O(nM+k).

If the values have a larger range, then you could use a form of binary search tree instead of the series of arrays, or instead sort the values and replace the values with their ordinal value. This would then have complexity O(nlogn+k).

COUNTING TRIPLES

If you just wish to know the total number of triples of this form then you can do this in O(n).

The idea is similar to before:

1. Find the most recent smaller element for each index, and the count of smaller elements for each index
2. Find the next greater element for each index, and the count of greater elements
3. Compute the sum of the product of the count of smaller elements and the count of larger elements for each index.

To make this O(n) we need to be able to find the next greater element in O(n). This can be done by:

1. Push the current index i to the stack
2. while A[top(stack)] < A[i+1], pop an index x off the stack and store NGE[x]=i+1
3. increment i and return to step 1

We also need to be able to find the count of greater elements in O(n). Once the NGE array has been prepared, we can find the counts by iterating backwards over the array and computing

count_greater_elements[i] = count_greater_elements[ NGE[i] ] + 1 if NGE[i] is defined
                          = 0 otherwise

The most recent smaller elements and counts can be computed in an analogous way.