Maximum Product Subarray

Catelogue: array+动态规划

Question：

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.

First try

class Solution {
public:
    int maxProduct(int A[], int n) {
        int ret = INT_MIN;
        int currMax;
        for(int i = 0; i < n; i++)
        {
            currMax= A[i];
            for(int j = i+1; j < n; j++)
            {
                currMax *= A[j];
                if(currMax > ret) ret = currMax;
            }
        }
        return ret;
    }
};

Result：Time Limit Exceeded

Second try:

先确定负数的位置，乘积的大小与第一个与最后一个负数的位置有关

class Solution {
public:
    int maxProduct(int A[], int n) {
        int product = INT_MIN;
        int maxProduct = INT_MIN;
        int firstNegPos = -1;
        int lastNegPos = -1;
        int startPos = 0;
        bool negFlag = false;
        for(int i = 0; i < n; i++)
        {
            if(A[i] == 0) //计算0之前的最大积
            {
                if(!negFlag)
                {
                    product = A[startPos];
                    for(int j = startPos+1; j < i; j++)
                    {
                        product *= A[j];
                    }
                    if(product > maxProduct)
                    {
                        maxProduct = max(0,product); //考虑product中只有一个负数的情况
                    }
                }
                else
                {
                    product = A[startPos];
                    for(int j = startPos+1; j < lastNegPos; j++)
                    {
                        product *= A[j];
                    }
                    if(product > maxProduct)
                    {
                        maxProduct = max(0,product);
                    }
                    if(firstNegPos+1<i)
                    {
                        product = A[firstNegPos+1];
                        for(int j = firstNegPos+2; j < i; j++)
                        {
                            product *= A[j];
                        }
                        if(product > maxProduct)
                        {
                            maxProduct = max(0,product);
                        }
                    }
                }
                firstNegPos = -1;
                lastNegPos = -1;
                startPos = i+1;
                negFlag = false;
            }
            else if(A[i] < 0)
            {
                negFlag = !negFlag;
                if(firstNegPos < 0)
                {
                    firstNegPos = i;
                    lastNegPos = firstNegPos;
                }
                else
                {
                    lastNegPos = i;
                }
            }
        }
        
        /*负数位置遍历完毕，且最后一位不是0（是0的话在之前已经处理过了）*/
        if(A[n-1]==0) return maxProduct;
        if(!negFlag)
        {
            product= A[startPos];
            for(int j = startPos+1; j < n; j++)
            {
                product *= A[j];
            }
            if(product > maxProduct)
            {
                maxProduct = product;
            }
        }
        else
        {
            product= A[startPos];
            for(int j = startPos+1; j < lastNegPos; j++)
            {
                product *= A[j];
            }
            if(product > maxProduct)
            {
                maxProduct = product;
            }
            if(firstNegPos+1<n)
            {
                product = A[firstNegPos+1];
                for(int j = firstNegPos+2; j < n; j++)
                {
                    product *= A[j];
                }
                if(product > maxProduct)
                {
                    maxProduct = product;
                }
            }
        }
        return maxProduct;
    }
};

Result：Accepted