[LeetCode] Maximum Product Subarray的4种解法

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.

这题和之前的一题Maximum Subarray非常类似，一个是求最大和，而这个是求最大乘积。可以用大致类似的思路解，但是求乘积比求和要复杂些，多了不少corner case。不过这题出得还算仁慈，因为这题其实有两个地方简化了：

1）注意这里的数组是整型的，如果含有浮点数，就有可能出现0-1之间类似0.25这样的小数，所以即使是全都是正数，也可以越乘越小。如果数组里的数字全为正数还好说，因为可以用求对数的方式把求乘积转化为求和，从而转换为之前的Maximum Subarray。但是因为这题有负数和0的存在，所以求对数的方法行不通。

2）这题的测试用例里数组元素的绝对值都非常的小，而实际中如果真的连乘起来，最后数值越界很容易发生的。如果考虑这一点，要么估计得用类似Java里BigInteger类这样的东西去避免越界。

这题我一共尝试了4种解法。

解法1——基于数学分析的解法

类似Maximum Subarray的解题思路，在遍历过程中，不断更新以当前元素为终点的subarray的乘积极大值（下面简称极大值）和最大值。本质上无非就是要做出一个二选一：要么继续把当前遍历的元素算上，扩展当前的subarray，要么就重新开始一个subarray。此外，如何更新最大值？由于有整数，负数和0的存在，需要分为三种情况，并且还需要维护一个极小值。为了方便连乘操作，这里规定维护的最大乘积必须大于等于1，即不能等于0。另外需要注意，在没有遍历到负数之前，极小值这里其实和极大值是一样大的（不考虑为0的情况），也可以是正数。

综合考虑如下：

1）如果当前元素为正数，那么极大值只可能扩大，所以应该继续扩展当前subarray：

此种情况简单，极大值应该更新为原极大值乘以当前元素，极小值更新为原极小值乘以当前元素。全局最大值跟极大值比较。

2）如果当前元素为负数，那么极大值可能会变小，所以不清楚应该继续扩展当前subarray还是新起一个subarray：

对于极大值的更新：如果扩展当前subarray，极大值为原极小值乘以当前元素；如果另外新起一个subarray，由于当前元素为负数，所以直接舍弃，根据规定，设为初始值1。由于这里原极小值不一定为负数，所以前者和后者之间比较没有绝对的谁大。

对于极小值的更新：如果扩展当前subarray，极小值为原极大值乘以当前元素；如果另外新起一个subarray，极小值为当前元素。不过由于之前极大值肯定大于1，所以前者肯定比后者大，所以极小值更新为原极大值乘以当前元素。

最应该小心的地方是更新全局最大值：这里的全局最大值不能和极大值比较，而应该和极小值乘以当前元素值比较，即扩展当前subarray的选择比较。因为如果极大值此时为1，则并不是靠实实在在存在的，以当前元素结尾的subarray获得，而是靠舍弃当前元素，寄希望于之后“可能”出现的新subarray。举个例子，如果数组为{-2}，或者{-1, 0, -2}，那么无论如何是不会出现最大值为1这种情况的，因为负数的后面没有出现过正数。

3）如果当前元素为0，那么包括一个0会使得极大值成为0，而按照操作规定，这里的极大值应该大于等于1，所以应该舍弃当前元素，新起一个subarray。

对于极大值和极小值，由于新起一个subarray，全部还原为1。

对于全局最大值的更新，这里和2）类似。由于极大值的获取是寄希望于之后“可能”出现的新subarray，所以更新全局最大值的时候不能和此时的极大值1进行比较，而应该和实实在在的0比较。

以下代码，loc_min和loc_max表示极小值和极大值，glb_max为所求。

public int maxProduct(int[] A) {
    int loc_min = 1, loc_max = 1;   // Make sure thoese local min/max values are greater than or equal to 1 all the time.
    int glb_max = A[0];
       for (int i : A) {
           if (i > 0) {
               glb_max = Math.max(glb_max, loc_max * i);
               loc_max *= i;
               loc_min *= i;
           } else if (i < 0) {
               glb_max = Math.max(glb_max, loc_min * i);
               int temp = loc_max;
               loc_max = Math.max(loc_min * i, 1);
               loc_min = temp * i;
           } else {    // i == 0.
               glb_max = Math.max(glb_max, 0);
               loc_max = 1;
               loc_min = 1;
           }
       }

       return glb_max;
}

解法2——朴素的DP解法

其实以上的解法本质上是一种DP的解法，不过以上解法太过于注重细节上的分析，所以代码看起来比较繁琐。由于负数的存在，需要同时保存当前最大值和当前最小值，所以需要维护两个DP表，可以分别表示为dp_min和dp_max。所以即为dp_max里的最大值。

有时候做题目应该有一种大局观，从细节中解脱出来。这点类似于做物理题时，不一定非要用动力学原理弄清整个过程和每个细节，有时候用简单的从功和能的角度，只关注最终状态也可以顺利解题。这题里需要维护的当前最大值和当前最小值，都是在dp_min[i-1] * A[i]，dp_max[i] * A[i]，和A[i]这三者里面取一即可。有了这个只关乎最终状态，不关乎过程细节的结论，解题过程可以大大简化。

public int maxProduct_naiveDP(int[] A) {
    int max = A[0];
    int length = A.length;
    int[] dp_min = new int[length];
    int[] dp_max = new int[length];
    dp_min[0] = dp_max[0] = A[0];
    for (int i = 1; i < length; ++i) {
        dp_min[i] = Math.min(
                Math.min(dp_max[i - 1] * A[i], dp_min[i - 1] * A[i]), A[i]);
        dp_max[i] = Math.max(
                Math.max(dp_max[i - 1] * A[i], dp_min[i - 1] * A[i]), A[i]);
        max = Math.max(dp_max[i], max);
    }
    return max;
}

这里用了O(N)空间，所以内存开销比第一种解法大。

解法3——优化的DP解法

思考以上DP解法的空间开销过大的原因，是因为保存了整个DP表。其实整个过程中，获得dp[i]的值只需要dp[i-1]的值，所以是不需要保存整个DP表的。

这样一来，DP可以用滚动数组进行优化。简单的写法其实就是设一对prevMin/prevMax表示上一个值，以及还有一对curMin/curMax表示当前值。

public int maxProduct(int[] A) {
    int max = A[0];
    int prevMin = A[0], prevMax = A[0];
    int curMin, curMax;
    for (int i = 1; i < A.length; ++i) {
        curMin = Math.min(Math.min(prevMax * A[i], prevMin * A[i]), A[i]);
        curMax = Math.max(Math.max(prevMax * A[i], prevMin * A[i]), A[i]);
        prevMin = curMin;
        prevMax = curMax;
        max = Math.max(curMax, max);
    }
    return max;
}

解法4——分治法

如果数组里面没有0，这题可以得到大大简化，所以我们可以先考虑如何处理一个不含0的数组。如此一来，不管怎么乘，绝对值都会增长，所以最重要的就是要保证最后的乘积为正数。因此，可以分为两种情况讨论：

1）如果数组内负数的个数为偶数，直接包括整个数组即可，最大乘积就是整个数组元素的乘积。

2）如果数组内负数的个数为奇数，则应该丢弃一个含有一个奇数的部分。为了使得所剩的数组最大限度的连续，无非就是两种情况：

2.1) 丢弃掉数组里出现的第一个负数和在它之前的元素。例如{1, 2, -3, 4, -5, 6, 7}，由于第一个负数为-3，丢弃最开始的1,2和-3。

2.2) 丢弃掉数组里出现的最后一个负数和在它之后的元素。用上个例子，由于最后一个负数为-5，丢弃最后的-5,6和7。

现在有了对这个题目简化版的解法，如果扩展到这题的解法呢？很简单，首先扫一遍数组，以0为边界，将整个数组分为若干个不含0的subarray，对于每个subarray逐一求解，并求得它们的最大值。另外，由于每个subarray的最大值可能都是负数，所以一旦有0出现，还应该和0比较。代码如下，start表示subarray的起始下标，为-1的时候表示正在寻找下一个subarray。

public int maxProduct(int[] A) {
    int start = -1;
    int max = Integer.MIN_VALUE;
    for (int i = 0; i < A.length; ++i) {
        if (start == -1) {
            if (A[i] != 0) {
                start = i;
            }

            if (i == A.length - 1) {
                max = Math.max(max, A[i]);
            }
        } else {
            if (A[i] == 0) {
                max = Math.max(max, maxProductNonZero(A, start, i - 1));
                max = Math.max(max, 0);
                start = -1;
            } else if (i == A.length - 1) {
                max = Math.max(max, maxProductNonZero(A, start, i));
                start = -1;
            }
        }
    }

    return max;
}

private int maxProductNonZero(int[] A, int start, int end) {
    if (start == end)
        return A[start];

    int count_negs = 0;
    int product = 1;
    for (int i = start; i <= end; ++i) {
        if (A[i] < 0) {
            count_negs++;
        }

        product *= A[i];
    }

    if (count_negs % 2 == 0) {
        return product;
    } else {
        int productBeforeFirstNeg = 1;
        for (int i = start; i <= end; ++i) {
            productBeforeFirstNeg *= A[i];
            if (A[i] < 0) {
                break;
            }
        }

        int productAfterLastNeg = 1;
        for (int i = end; i >= start; --i) {
            productAfterLastNeg *= A[i];
            if (A[i] < 0) {
                break;
            }
        }

        product = Math.max(product / productBeforeFirstNeg, product
                / productAfterLastNeg);
    }

    return Math.max(product, 0);
}

这种解法比较繁琐，而且由于为了思路清晰，这里我对数组进行了多次扫描，其实可以将循环合并。不过无所谓了，O(n)的时间复杂度不会因为多扫了一两遍而变化。

不过这种代码量大的解法不推荐。相比较之下，前几种适用性更广，对浮点数也同样适用，而这种解法则不能允许有0-1之间的小数。