LeetCode Maximum Product Subarray_DP_最大子数组

http://www.cnblogs.com/bakari/p/4007368.html

http://blog.csdn.net/worldwindjp/article/details/39826823

题目：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. 

1、这道题属于动态规划的题型，之前常见的是Maximum SubArray，现在是Product Subarray，不过思想是一致的。

用动态规划的方法，就是要找到其转移方程式，也叫动态规划的递推式，动态规划的解法无非是维护两个变量，局部最优和全局最优，我们先来看Maximum SubArray的情况，如果遇到负数，相加之后的值肯定比原值小，但可能比当前值大，也可能小，所以，对于相加的情况，只要能够处理局部最大和全局最大之间的关系即可，对此，写出转移方程式如下：
local[i + 1] = Max(local[i] + A[i], A[i]);


global[i + 1] = Max(local[i + 1], global[i]);


对应代码如下：

1 int maxSubArray(int A[], int n)
 2 {
 3     assert(n > 0);
 4     if (n <= 0)
 5         return 0;
 6     int global = A[0];
 7     int local = A[0];
 8     
 9     for(int i = 1; i != n; ++ i) {
10         local = MAX(A[i], local + A[i]);
11         global = MAX(local, global);
12     }
13     return global;
14 }

2、而对于Product Subarray，要考虑到一种特殊情况，即负数和负数相乘：如果前面得到一个较小的负数，和后面一个较大的负数相乘，得到的反而是一个较大的数，如{2，-3，-7}，所以，我们在处理乘法的时候，除了需要维护一个局部最大值，同时还要维护一个局部最小值，由此，可以写出如下的转移方程式：
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])

其实子数组乘积最大值的可能性为：累乘的最大值碰到了一个正数；或者，累乘的最小值（负数），碰到了一个负数。所以每次要保存累乘的最大（正数）和最小值（负数）。同时还有一个选择起点的逻辑，如果之前的最大和最小值同当前元素相乘之后，没有当前元素大（或小）那么当前元素就可作为新的起点。例如，前一个元素为0的情况，{1,0,9,2}，到9的时候9应该作为一个最大值，也就是新的起点，{1,0,-9,-2}也是同样道理，-9比当前最小值还小，所以更新为当前最小值。

1 #define MAX(x,y) ((x)>(y)?(x):(y))
 2 #define MIN(x,y) ((x)<(y)?(x):(y))
 3 
 4 int maxProduct1(int A[], int n)
 5 {
 6     assert(n > 0);
 7     if (n <= 0)
 8         return 0;
 9 
10     if (n == 1)
11         return A[0];
12     int max_local = A[0];
13     int min_local = A[0];
14 
15     int global = A[0];
16     for (int i = 1; i != n; ++ i) {
17         int max_copy = max_local;
18         max_local = MAX(MAX(A[i] * max_local, A[i]), A[i] * min_local);
19         min_local = MIN(MIN(A[i] * max_copy, A[i]), A[i] * min_local);
20         global = MAX(global, max_local);
21     }
22     return global;
23 }