leetcode——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.

方法一：

假设数组中没有0，将所有的元素相乘，如果结果是正数，那么最大积就是它；如果结果是负数，那么我们可以通过删除数组中仅有一个负数的前缀或者后缀，剩下部分相乘就是最大乘积。比如 [2, 3, -2, 4] 的所有元素的乘积是-48小于0，那么删除后缀[-2, 4]后元素的积为6，这就是最大积（我们总是删除仅包含一个负数的前缀或者后缀中积较大的部分，这里前缀的积为2*3*(-2)=-12 < 后缀积-8，所以删除后缀更优）。

这种方法一定要确保数组中没有0，因此，代码先把0作为分隔符，将数组nums分成一个个不包含0元素的子数组，在通过上面的方法求取最大积，返回这些最大积的最大值即可。当然，如果求出的最大积小于0，那么判断nums中有没有0，如果有0，那么返回0；如果没有0，没办法，最大积就是负数。

class Solution {
private:
    //对于没有0的数组，将所有的元素相乘，如果积大于0，那么返回这个最大积；如果积小于0，那么需要去掉最边上的一个负数
    int maxProduct(vector<int>& nums, int start, int end)
    {
        if (end - start == 1)
        {
            //只包含一个元素，返回之
            return nums[start];
        }
        //从前往后找到连续正数的积(product1)；
        //从后往前找到连续正数的积(product2).
        //所有数的积是product
        int product1 = 1, product2 = 1;
        int product = 1;
        int i = start, j = end - 1;
        for (i = start; i < end; ++i)
        {
            product1 *= nums[i];
            if (nums[i] < 0)
            {
                break;
            }
        }
        product *= product1;

        for (j = end - 1; j >= i; --j)
        {
            product2 *= nums[j];
            if (nums[j] < 0)
            {
                break;
            }
        }
        product *= product2;
        if (j == i && i < end) product /= nums[i];//重复乘了一次nums[i]

        for (int k = i + 1; k < j; ++k)
        {
            product *= nums[k];
        }
        if (product > 0)
        {
            return product;
        }
        else
        {
            if (product1 > product2)
            {
                return product / product1;
            }
            else
            {
                return product / product2;
            }
        }
    }
public:
    int maxProduct(vector<int>& nums) {
        if (nums.empty())
        {
            return 0;
        }
        //遍历，处理被0分割出来的子数组
        nums.push_back(0);//最后加一个0，为了end
        int start = 0;
        bool hasZero = false;
        int res = INT_MIN;
        for (int end = start; end < nums.size(); ++end)
        {
            if (nums[end] == 0)
            {
                if (end != nums.size() - 1) hasZero = true;
                if (end > start) //防止出现连续的0
                {
                    int product = maxProduct(nums, start, end);
                    res = max(product, res);
                }
                start = end + 1;
            }
        }
        if (res < 0 && hasZero)
        {
            return 0;
        }
        return res;
    }
};

方法二：

还记得传说中的最大连续子数组的和问题么？本题可以采用类似的方法解决——动态规划。

（1）介绍一下最大连续子数组的和问题的解法吧，维护两个变量，当前最大和与全局最大和。考虑一个新元素，如果当前和小于0，那么加入新元素后必然更小，此时应当用新元素代替当前和（新元素作为子数组的起始）；如果当前和大于0，那么加上新元素更新当前和。最后每次判断并更新全局最大和即可。如果此刻写出转移方程式如下：
local[i + 1] = Max(local[i] + A[i], A[i]);
global[i + 1] = Max(local[i + 1], global[i]);

（2）回归本题，亦需要维护当前乘积和全局最大乘积，由于新元素可正可负，所以要想得到并更新当前最大乘积，必须维护当前最大乘积（针对新元素大于0）和当前最小乘积（针对新元素小于0）。写出转移方程式如下：

max_copy[i] = max_local[i]
max_local[i + 1] = Max(Max(max_local[i] * A[i], A[i]),  min_local * A[i])

min_local[i + 1] = Min(Min(max_copy[i] * A[i], A[i]),  min_local * A[i])

class Solution {
public:
    int maxProduct1(vector<int>& nums) {
        if (nums.empty())
        {
            return 0;
        }
        int global = nums[0], local_max = nums[0], local_min = nums[0];
        for (int i = 1; i < nums.size(); ++i)
        {
            int temp = local_max;
            local_max = max(nums[i], max(local_max * nums[i], local_min * nums[i]));
            local_min = min(nums[i], min(temp * nums[i], local_min * nums[i]));
            global = max(global, local_max);
        }
        return global;
    }
};