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.

分析思路:

一开始看这题目的样子以为要用动态规划，但是完全不好写动态规划的方程。其实，题目中的输入可以这么来看，

如果输入数组中一个0都没有，那么就把所有的输入全部相乘得到一个结果，如果这个结果为>0，必然是largest product,如果结果<0，那么就从输入数组的左边开始向右扫描，直到找到第1个负数为主，那么此时去掉左边的subarray(从输入数组的第1个开始，到第1个负数为止的子数组。例如，[-2, 2, 3, -3]的左subarray为[-2], [2, -2, 3, -3]的左subarray为[2, -2])后，去掉左边的subarray后剩下数的乘积必然为正数。同样的过程按照从右到左的顺序对右边的数组走一遍，得到去掉右边subarray后剩下数的乘积，也必然为正数。比较两个正数，较大者为所求。把上面的过程放入辅助函数subsetMax中。

如果输入数组中有0，就把0作为分界线，得出一些子数组，对每个子数组做上面的事情。在每个子数组得到的最大乘积中选择最大的。

比较特殊的情况是 当输入数组为[-1],此时需要在subsetMax中特殊处理一下。

这道题目也是个非常具有面试题目感觉的题目，没有任何算法纯代码，但是代码很有区分度。
代码如下：

class Solution {    private:    int subsetMax(int sub[], int n) {        if (n == 1) return sub[0];        int subsetProduct = 1;        int posStart = -1;        int posEnd = -1;        for (int i = 0; i < n ; ++i)            subsetProduct *= sub[i];        if (subsetProduct > 0) return subsetProduct;        int leftSubsetProduct = 1;        int rightSubsetProduct = 1;        for (posStart = 0; posStart < n ; ++posStart)            if (sub[posStart] < 0) break;        for (int i = posStart + 1; i < n; ++i)            leftSubsetProduct *= sub[i];        for (posEnd= n-1; posEnd >= 0 ; --posEnd)            if (sub[posEnd] < 0) break;        for (int i = posEnd - 1; i >= 0; --i)            rightSubsetProduct *= sub[i];        return leftSubsetProduct > rightSubsetProduct ? leftSubsetProduct:rightSubsetProduct;    }    public:        int maxProduct(int A[], int n) {        int arrayMax = INT_MIN;        int subStart = 0;        int subEnd = 0;        int curMax = INT_MIN;        bool hasZero = false;        while (subStart < n) { // 简化了while (subStart < n && subEnd < n) 因为while{}内部的最后一步是subStart = subEnd + 1;            while (subStart < n && A[subStart]==0) {                hasZero = true;                subStart++;            }            subEnd = subStart;            while (subEnd < n && A[subEnd]!=0)                subEnd++;            if (subEnd < n)                hasZero = true;            if (subStart < subEnd) {                curMax = subsetMax(A + subStart, subEnd - subStart);                if (curMax > arrayMax) arrayMax = curMax;            }            subStart = subEnd + 1;        }        if (hasZero && arrayMax < 0) return 0;        else return arrayMax;    }};

update 2014-11-23

更简洁的思路是动态规划。解答思路来自官网的答案解析。

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] )

There we have a dynamic programming formula. Using two arrays of size n, we could deduce the final answer as f(n-1).

class Solution {public:    int maxProduct(int A[], int n) {        if (n == 0) return 0;        if (n == 1) return A[0];        int result = A[0]; //NOTE: 不能初始化为resutl = INT_MIN,因为已经用了A[0]作为基准了。        int min_product = A[0];        int max_product = A[0];        for (int i = 1; i < n; ++i) {            int org_min = min_product; //NOTE: data dependency: 原始的min max值需要保留下来。            int org_max = max_product; //NOTE: data dependency: 原始的min max值需要保留下来。            max_product = ((org_max * A[i]) > (org_min * A[i]))?(org_max * A[i]):(org_min * A[i]);            max_product = (max_product > A[i]) ? max_product:A[i];            min_product = ((org_max * A[i]) < (org_min * A[i]))?(org_max * A[i]):(org_min * A[i]);            min_product = (min_product < A[i]) ? min_product:A[i];            if (max_product > result)                result = max_product;            //std::cout<<"i = "<<i<<", max="<<max_product<<", min="<< min_product<<" ,res="<<result<<std::endl;        }        return result;    }};