628. Maximum Product of Three Numbers

题目描述：

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:
The length of the given array will be in range [3,104] and all elements are in the range [-1000, 1000].
Multiplication of any three numbers in the input won’t exceed the range of 32-bit signed integer.

解题思路

1. 一开始的想法是数组长度过大，不好直接排序，否则很容易运行超时。但是必须要得到最大的几个数，因此决定遍历整个数组，得到分别最大的几个正数和负数。

2. 后面发现如果全是负数的话那么这时候需要最小的三个负数，因此遍历时也将最小的负数存储。

3. 遍历完成后，则要进行比较，得到此时最大值的返回形式。详见代码。

代码如下：

class Solution {
public:
    int maximumProduct(vector<int>& nums) {
        vector<int> pos, negbig, negsmall;
        for (int i = 0; i < nums.size(); ++i) {
            if (nums[i] >= 0) {
                sortVector(pos, nums[i], 1);
            }
            else {
                sortVector(negbig, -nums[i], 1);
                sortVector(negsmall, -nums[i], 0);
            }
        }
        if (pos.size() >= 3 && negbig.size() >= 2) {
            return (pos[0] * pos[1] * pos[2] > pos[0] * negbig[0] * negbig[1]) ? pos[0] * pos[1] * pos[2]: pos[0] * negbig[0] * negbig[1];
        }
        else if (pos.size() >= 3 && negbig.size() <= 1) {
            return pos[0] * pos[1] * pos[2];
        }
        else if (pos.size() <= 2 && negbig.size() == 1) {
            return pos[0] * pos[1] * (-negbig[0]);
        }
        else if (pos.size() == 0){
            return -negsmall[0] * -negsmall[1] * -negsmall[2];
        }
        else {
            return pos[0] * negbig[0] * negbig[1];
        }
    }
    void sortVector(vector<int> & temp, int num, int flag) {
        temp.push_back(num);
        if (flag == 1)
            sort(temp.begin(), temp.end(), cmp);
        else
            sort(temp.begin(), temp.end());
        if (temp.size() > 3) {
            vector<int> temp2;
            temp2.push_back(temp[0]);
            temp2.push_back(temp[1]);
            temp2.push_back(temp[2]);
            temp = temp2;
        }
    }
    static int cmp(int a, int b) {
        return a>b;
    }
};

更好的做法

leetcode上的做法如下：

int maximumProduct(vector<int>& nums) {
    sort(nums.begin(), nums.end());
    int n = nums.size();
    int temp1 = nums[n-1]*nums[n-2]*nums[n-3];
    int temp2 = nums[0]*nums[1]*nums[n-1];
    return temp1>temp2?temp1:temp2;
}

看了一下，大吃一惊，对数组全部排序竟然不会运行超时。后面仔细一想，时间复杂度是nlogn,那么10的4次方其实也就是4n，而我的方法对每个元素加入后进行排序使用的次数不仅仅4次，所以复杂度更高了。真的是，白费精力了。