【LeetCode】Maximum Product Subarray 求连续子数组使其乘积最大

Add Date 2014-09-23

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.

简单来说就是在一个 int 数组中找一段连续的子数组，使其乘积最大，数组中包含正数、负数和0。不考虑乘积太大超出范围。

解法一：

动态规划的方法，今天在微信“待字闺中”中看到的，借来分享。遍历一遍，优于解法二，复杂度O(n).

int max2(int a, int b) {
    if(a > b) return a;
    return b;
}

int max3(int a, int b, int c) {
    return max2(max2(a, b), c);
}

int min2(int a, int b) {
    if(a > b) return b;
    return a;
}

int min3(int a, int b, int c) {
    return min2(min2(a, b), c);
}

int maxProduct(int A[], int n) {
    int max = A[0];
    int min = A[0];
    int a = max;
    for(int i = 1; i < n; ++i) {
        int tmpMax = max * A[i];
        int tmpMin = min * A[i];
        max = max3(tmpMax, tmpMin, A[i]);
        min = min3(tmpMax, tmpMin, A[i]);
        a = max2(max, a);
    }
    return a;
}

 

解法二：

之前做过找连续子数组使其加和最大，比较简单，见《剑指offer》Q31。

刚开始也试图从那道题中找思路，发现不太科学…后来自己摸索出一个思路，分享一下。

首先，任何一个数字和0相乘得到的都是0；另外，不考虑0的情况下，因为数字都是整数，所以乘积的绝对值是不会变小的；再次，负负得正。

基于这三点考虑，首先基于递归的思想用0分段，也就是说，把数组 A 拆分为 [一段不包含0的数组]、[0]、[剩下的数组]，并设 rel1 为不包含0的子数组得到的最大乘积，rel2 为剩下的数组得到的最大乘积，那么，数组 A 的最大乘积就是 max{rel1,0，rel2}。rel2递归的用这个思路得到。

然后，就是求一个不包含0的数组的最大乘积。由于负负得正，可以想到，如果负数的个数为偶数，那么所有的数字相乘就是那个最大乘积；如果负数的个数为奇数，那么一定是某一个负数的左边所有数字乘积或者右边所有数字乘积为最大，所以就可以从前向后遍历数组，并把所有元素相乘，用 numAll1 记录这个乘积，同时每次更新 num1 为从前到后相乘过程中最大的乘积；然后再从后向前遍历数组，用 numAll2 记录乘积，num2 记录最大值，这样整个数组的最大乘积就是 max{num1，num2}。

如果你觉得不理解为什么最大乘积的子数组一定是从第一个数字连续的一个子数组，或者是从最后一个数字连续的子数组，可以这样想：

如果这个乘积最大的子数组是中间的某一段，当然排除掉只有一个元素且为负数的情况，那么这个乘积一定是正数（这个还不懂的话自己想一下吧，简单的），如果

1.这段子数组左边（右边）是全正的，那么和左边（右边）所有的数相乘的结果一定不会比当前的结果小，所以可以从左边（右边）连续；所以这段子数组左边和右边一定都有负数！

2.这段子数组左边（右边）有偶数个负数，同1是不可能的；而且如果有多个负数，一定可以有偶数个可以包含在中间这段子数组中使乘积更大；所以一定左边和右边各有一个负数！

3.如果左边和右边各有一个负数，那么就有两个负数，这样的话把整个数组相乘的结果一定不小于中间这段子数组。

这个算法中遍历整个数组三次，复杂度为O(n).

终于把逻辑说完了，个人觉得很啰嗦，只是想说明白点，不知道大家有没明白，下面附 code，欢迎其它思路。

class Solution {
public:
    int maxProductNo0(int A[], int n) {                 //没有0的数组求最大乘积
        int num1 = A[0];
        int numAll1 = A[0];
        for(int i = 1; i < n; ++i) {
            numAll1 *= A[i];
            num1 = numAll1 > num1 ? numAll1 : num1;
        }
        
        int num2 = A[n-1];
        int numAll2 = A[n-1];
        for(int i = n-2; i >= 0; --i) {
            numAll2 *= A[i];
            num2 = numAll2 > num2 ? numAll2 : num2;
        }
        return num1 > num2 ? num1 : num2;
    }
    
    int maxProduct(int A[], int n) {                    //求数组最大乘积
        if(A == NULL || n < 1)
            return 0;
        int index0 = 0;
        int rel1 = A[0];
        int rel2 = A[0];
        bool have0 = false;
        for(; index0 < n; ++index0) {
            if(A[index0] == 0) {
                have0 = true;
                break;
            }
        }
        if(index0 > 0)
            rel1 = maxProductNo0(A, index0);            //没有0的数组的最大乘积
        if(n-index0-1 > 0)
            rel2 = maxProduct(A+index0+1, n-index0-1);  //剩下的数组的最大乘积
        rel1 = rel1 > rel2 ? rel1 : rel2;
        if(have0)
            rel1 = rel1 > 0 ? rel1 : 0;
        return rel1;
    }
};