Maximum Product of Three Numbers LT628

Given an integer array, find three numbers whose product is maximum and output the maximum product.

Example 1:

Input: [1,2,3]
Output: 6

 

Example 2:

Input: [1,2,3,4]
Output: 24

Note:

1. The length of the given array will be in range [3,10⁴] and all elements are in the range [-1000, 1000].
2. Multiplication of any three numbers in the input won't exceed the range of 32-bit signed integer.

 Idea 1. Bruteforce, three cases: (1)all positive max1 * max2 * max3 (2) all negative, 0 or negMax1 * negMax2 *negMax3 (3) otherwise, Math.max(max1* max2 * max3, negMin1 * negMax2*max1)

Time complexity: O(n)

Space complexity: O(1), 8 variables

class Solution {
    public int maximumProduct(int[] nums) {
        int posMax = -1;
        int posSecondMax = -1;
        int posThirdMax = -1;
        
        int negMin = 1;
        int negSecondMin = 1;
        
        int negMax = 1;
        int negSecondMax = 1;
        int negThirdMax = 1;
        
        boolean hasZero = false;
        
        for(int num: nums) {
            if(num >= 0) {
                if(num == 0) {
                    hasZero = true;
                }
                
                if(num > posMax) {
                    posThirdMax = posSecondMax;
                    posSecondMax = posMax;
                    posMax = num;
                }
                else if(num > posSecondMax) {
                    posThirdMax = posSecondMax;
                    posSecondMax = num;
                }
                else if(num > posThirdMax) {
                    posThirdMax = num;
                }
            }
            else if(num < 0) {
                
                if(negMax == 1 || num > negMax) {
                    negThirdMax = negSecondMin;
                    negSecondMax = negMax;
                    negMax = num;
                }
                else if(negSecondMax == 1 || num > negSecondMax) {
                    negThirdMax = negSecondMax;
                    negSecondMax = num;
                }
                else if(negThirdMax == 1 || num > negThirdMax) {
                    negThirdMax = num;
                }
                
                if(num < negMin) {
                    negSecondMin = negMin;
                    negMin = num;
                }
                else if(num < negSecondMin) {
                    negSecondMin = num;
                }
            }
        }
        
        if(posMax == -1) {
            if(hasZero) {
                return 0;
            }
            else {
                return negMax * negSecondMax * negThirdMax;
            }
        }
        else if(negMax == 1) {
            return posMax * posSecondMax * posThirdMax;
        }
        else {
            return Math.max(negMin * negSecondMin* posMax, posMax * posSecondMax * posThirdMax);
        }
    }
}

Idea 1.b. Instead just need 5 variables, the two smallest values(min1 and min2), and three largest (max1, max2 and max3) determins the maximum product of three numbers Math.max(max1 * max2 * max3, min1*min2*max1) 

Time complexity: O(N)

Space complexity: O(1)

class Solution {
    public int maximumProduct(int[] nums) {
        int max = Integer.MIN_VALUE;
        int secondMax = Integer.MIN_VALUE;
        int thirdMax = Integer.MIN_VALUE;
        
        int min = Integer.MAX_VALUE;
        int secondMin = Integer.MAX_VALUE;
        
        
        for(int num: nums) {
            if(num > max) {
                thirdMax = secondMax;
                secondMax = max;
                max = num;
            }
            else if(num > secondMax) {
                thirdMax = secondMax;
                secondMax = num;
            }
            else if(num > thirdMax) {
                thirdMax = num;
            }
            
            if(num < min) {
                secondMin = min;
                min = num;
            }
            else if(num < secondMin) {
                secondMin = num;
            }
        }
        
        return Math.max(max * secondMax * thirdMax, max * min * secondMin);      
    }
}

Idea 2. Sort, sort is a good start if you have no clue

Time complexity: O(NlogN)

Space complexity: O(logN) the depth of recursive call tree,  worse case O(N)

class Solution {
    public int maximumProduct(int[] nums) {
        int n = nums.length;
        Arrays.sort(nums);
        
        return Math.max(nums[n-1] * nums[n-2] * nums[n-3], nums[n-1] * nums[0] * nums[1]);      
    }
}

Idea 2.b use minHeap to get the max 3 elements, maxHeap to get the min 2 elements

Time complexity: O(NLogK), K = 3

Space complexity: O(K)

class Solution {
    public int maximumProduct(int[] nums) {
        int n = nums.length;
        PriorityQueue<Integer> minHeap = new PriorityQueue<>();
        PriorityQueue<Integer> maxHeap = new PriorityQueue<>((a, b) -> Integer.compare(b, a));
        
        for(int num: nums) {
            minHeap.add(num);
            if(minHeap.size() > 3) {
                minHeap.poll();
            }
            
            maxHeap.add(num);
            if(maxHeap.size() > 2) {
                maxHeap.poll();
            }
        }
        
        int max3 = minHeap.poll();
        int max2 = minHeap.poll();
        int max1 = minHeap.poll();
        
        int min2 = maxHeap.poll();
        int min1 = maxHeap.poll();
        
        return Math.max(max1 * max2 * max3, max1 * min1 * min2);
    }
}