技術標籤：# 陣列、連結串列與模擬演算法leetcode資料結構

題目地址：

https://www.lintcode.com/problem/maximum-product/description

給定一個長 n n n的陣列 A A A，找出其中三個數使得它們的乘積最大，返回這個乘積。題目保證 n ≥ 3 n\ge 3 n≥3。

如果數組裡含大於等於 3 3 3個正數，那麼答案或者是最大的正數乘以最小的兩個負數，或者是最大的正數乘以接下來最大的兩個正數；如果數組裡恰好含兩個正數，那麼最大值或者是最大正數乘以最小的兩個負數，或者是那兩個正數乘以最大的負數（此時意味著負數個數小於 2 2 2）；如果數組裡恰好含一個正數，那答案是這個正數乘以最小的兩個負數；如果數組裡沒有正數，則答案是最大的三個負數相乘。無論怎樣，答案一定是出在最大的三個數和最小的兩個數之組合。可以用quick select求出最大的三個數和最小的兩個數，然後暴力列舉所有情況。程式碼如下：

import java.util.ArrayList;
import java.util.List;

public class Solution {
    /**
     * @param nums: Unordered array
     * @return: return the largest product
     */
    public long MaximumProduct(int[] nums) {
        // write your code here
        int l = 0, r = nums.length - 1, pos = 0;
        while
 
 ((pos = partition(nums, l, r)) != nums.length - 3) {
            if (pos < nums.length - 3) {
                l = pos + 1;
            } else {
                r = pos - 1;
            }
        }
        l = 0;
        r = nums.length - 1;
        while ((pos = partition(nums, l, r)) != 1) {
            if
 
 (pos < 1) {
                l = pos + 1;
            } else {
                r = pos - 1;
            }
        }
        
        List<Long> list = new ArrayList<>();
        int i = 0;
        for (i = nums.length - 1; i >= nums.length - 3; i--) {
            list.add((long) nums[i]);
        }
        
        for (int j = 0; j <= Math.min(1, i); j++) {
            list.add((long) nums[j]);
        }
        
        long res = Long.MIN_VALUE;
        for (int j = 0; j < list.size() - 2; j++) {
            for (int k = j + 1; k < list.size() - 1; k++) {
                for (int m = k + 1; m < list.size(); m++) {
                    res = Math.max(res, list.get(j) * list.get(k) * list.get(m));
                }
            }
        }
        
        return res;
    }
    
    private int partition(int[] nums, int l, int r) {
        if (l >= r) {
            return l;
        }
        
        int pivot = nums[l];
        while (l < r) {
            while (l < r && pivot <= nums[r]) {
                r--;
            }
            nums[l] = nums[r];
            while (l < r && nums[l] <= pivot) {
                l++;
            }
            nums[r] = nums[l];
        }
        
        nums[l] = pivot;
        return l;
    }
}

時間複雜度 O ( n ) O(n) O(n)，空間 O ( 1 ) O(1) O(1)。