【LeetCode】152. Maximum Product Subarray

题目：　　

Find the contiguous subarray within an array (containing at least one number) which has the largest product.

For example, given the array [2,3,-2,4],
the contiguous subarray [2,3] has the largest product = 6.

题解：

　　先暴力解，遍历所有组合，更新最大值。很显然得超时。

Solution 1 (TLE)

class Solution {
public:
    int maxProduct(vector<int>& nums) {
        int n = nums.size(), mproduct = nums[0];
        for (int i = 0; i < n; ++i) {
            int tmp = nums[i];
            mproduct = max(mproduct, tmp);
            for (int j = i + 1; j < n; ++j) {
                tmp = tmp * nums[j];
                mproduct = max(mproduct, tmp);
            }
        }
        return mproduct;
    }
};

　　Besides keeping track of the largest product, we also need to keep track of the smallest product. Why? The smallest product, which is the largest in the negative sense could become the maximum when being multiplied by a negative number. (from here)

　　Let us denote that:

f(k) = Largest product subarray, from index 0 up to k.

 　　Similarly,

g(k) = Smallest product subarray, from index 0 up to k.

 　　Then,

f(k) = max( f(k-1) * A[k], A[k], g(k-1) * A[k] )
g(k) = min( g(k-1) * A[k], A[k], f(k-1) * A[k] )

Solution 2 ()

class Solution {
public:
    int maxProduct(vector<int>& nums) {
        int maxPro = nums[0], minPro = nums[0], result = nums[0], n = nums.size();
        for (int i=1; i<n; i++) {
            int mx = maxPro, mn = minPro;
            maxPro = max(max(nums[i], mx * nums[i]), mn * nums[i]);
            minPro = min(min(nums[i], mx * nums[i]), mn * nums[i]);
            result = max(maxPro, result);
        }
        return result;
    }
};

1. Fist we assume there is no zero in the A[]. The answer must be A[0] A[1] .... A[i] OR A[j] *A[j+1] A[n - 1]. (Try to prove yourself)

2. Then when we have zero in the A[] (assum A[k] == 0). We could see A[0],A[1]...A[k - 1 ] As An Array and A[k + 1] A[k + 2]...A[n-1] is another.(from here)

　　The key point of this problem is: there are only two patterns:
One is "aBcD", and the other is "aBcDe", where I use lowercase to denote a negative number, and use upper case to denote a positive number.
For the first pattern, the maximum product would be "aBcD"; and for the second pattern, the maximum product would be "max (aBcD, BcDe)". So above solution code is very elegant and efficient. 

Solution 3 ()

class Solution {
 // author : s2003zy
 // weibo : http://weibo.com/574433433
 // blog : http://s2003zy.com
 // Time : O(n)
 // Space : O(1)
 public:
    int maxProduct(vector<int>& nums) {
        int ans = INT_MIN, frontProduct = 1, backProduct = 1;
        int n = nums.size();
        for(int i = 0; i < n; ++i) {
           frontProduct *= nums[i];
           backProduct *= nums[n - i - 1];
           ans = max(ans,max(frontProduct,backProduct));
           frontProduct = frontProduct == 0 ? 1 : frontProduct;
           backProduct = backProduct == 0 ? 1 : backProduct;
        }
        return ans;
    }
};