三重态的最大值和最小值

Question

I have a Java computational problem in which I am given an array of integers:

For example:

3 -2 -10 0 1

and I am supposed to compute what is the minimal integer and maximum triplet that can be formed from these integers. (In this case, min=-30,max=60)

I initially thought that the maximum would always be positive and minimum would always be negative.

Hence,

My initial algorithm was:

1. Scan the array and take out the 3 largest elements inside, store into an array.
2. At the same time, take out the 3 smallest elements inside, store into another array.

By inequalities, we can deduce the following:

+ve = (-)(-)(+) or (+)(+)(+)

-ve = (+)(+)(-) or (-)(-)(-)

Hence, I used the elements from the two arrays that I computed to try to obtain the maximal and minimal triplet. (ie In order to obtain the maximal triplet, I compared the triplet formed by the largest 3 with the triplet formed by the smallest 2 and the largest integer)

However, I realized that if all the given integers were negative, my algorithm would be defeated because of the fact that the maximal would be negative. (Vice-versa for minimal)

I know that I can simply add more checks to solve this problem or simply just use the brute force O(N^3) solution. But there must be a better way to solve this problem.

This problem must be solved by recursion and only in O(N) time.

I am in a fix. Could someone please guide me?

Thanks.

Answer 1

There is a O(n) solution if you find the 3 maximum and 2 minimum values in linear times.

But you can also use nlog(n) sorting (ie quick sort) to do that job easily.

Then here the solution to find the maximum product triplet in C with explanations in comments -

int cmpfunc (const void * a, const void * b)
{
   return ( *(int*)a - *(int*)b );
}

int solution(int A[], int N) {

long product = A[0] * A[1] * A[2];
if (N == 3) {
    return product;
}

// Nlog(N)
qsort(A, N, sizeof(int), cmpfunc);

if (A[N - 3] >= 0) {
    // if there is at least 3 non-negative value
    // then take three maximum values
    product = A[N - 1] * A[N - 2] * A[N - 3];

    if (A[1] < 0) {
        // if there is at least 2 negative value
        if (product < A[N - 1] * A[0] * A[1]) {
            // then take maximum positive and two minimum negative, if that is more than 3 positive values
            product = A[N - 1] * A[0] * A[1];
        }
    }

} else if (A[N - 1] >= 0) { 
    // else if there is least 1 non-negative value
    // then take maximum positive and two minimum negative
    product = A[N - 1] * A[0] * A[1];

} else {
    // otherwise, take 3 maximum negative values
    product = A[N - 1] * A[N - 2] * A[N - 3];
}

return product;
}

Answer 2

First, you only have to solve one of the two problems, say find the biggest triple product. With this you can find the least by negating all the input values, finding the biggest triple product, and negating to find the answer.

So let's focus on finding the biggest. You have it pretty well worked out. Take the maximum positive number first (if there is one). Then pick either the pair of the two biggest remaining positive numbers or the two biggest (in magnitude) negative numbers, whichever pair has the largest product.

If there are no positive numbers at all, then pick the three smallest negative numbers.

Certainly this can all be done in O(n) time, but this is not an algorithm where recursion has a natural place. You'd have to use trivial tail recursion to substitute for loops.