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.

public class Solution {
    public int maxProduct(int[] A) {
        int localmin = A[0];
        int localmax = A[0];
        int globle = A[0];
        //localmin[i] = MIN{A[i],localmin[i-1]*A[i]}
        //localmax[i] = MAX{A[i],localmin[i-1]*A[i],localmax[i-1]*A[i]}
        //globle = MAX{globle,localmax}
        for(int i = 1 ; i < A.length; i ++){
            int tmp1 = localmin;
            int tmp2 = localmax;
            localmin = Math.min(A[i],Math.min(tmp1*A[i],tmp2*A[i])) ;
            localmax = Math.max(A[i],Math.max(tmp2*A[i],tmp1*A[i]));
            globle = Math.max(localmax,globle);
        }
        return globle;
    }
}

利用动态规划法，有如求最长子序列和的问题，但是这个问题的考虑要再加上一点--局部最小值，由于负负得正的问题，所有整个过程维护两个变量局部最小值和局部最大值。

动态规划题最核心的步骤就是要写出其状态转移方程，但是如何写出正确的方程式，不断的实践并总结才能达到。

自己对于动态规划算法理解的不够深刻，从来都没有掌握到动态规划的精髓！！！

Runtime: 416 ms

第二种方法

这题如果没有负数和0，答案就很简单了，所有数的乘积。有负数和0就要复杂一些。

1. 先考虑只有正数和负数而没有 0 的情况：

   • 负数是偶数个。答案也很简单，所有数的乘积。
   • 负数是奇数个。那就要枚举这个负数位置，将序列分成两部分，取乘积大的那部分。

2. 然后再考虑数据中有 0 的情况，这时我们可以将整个序列以 0 进行分割成多个子序列，每个子序列的处理和情况 1 一样。

public class Solution {
    public int maxProduct(int[] A) {
        int ans = A[0], start = 0, end = 0, i = 0, hasZero = 0;
      while(i < A.length) {
        while(i < A.length && A[i] == 0) {
          i++;
          hasZero = 1; // 标记数据中有 0
        }
        start = i;
        while(i < A.length && A[i] != 0) {
          i++;
        }
        end = i - 1;
        if(end >= start) {
          // 以 0 分割成多个子串
          int tmp = noZero(A, start, end);
          if(tmp > ans) {
            ans = tmp;
          }
        }
      }
      if(hasZero > 0 && ans < 0) {
        ans = 0;
      }
      return ans;
    }
    //如果一个序列中没有0的话,那么从负数开始分割为left和right，
    public int noZero(int A[],int start,int end){
        if(start == end){//只有一个元素
            return A[start];
        }
        int negative = 0; //记录负数的个数
        int left=1,right=1; 
        int res=1;
        for(int i = start ; i <= end ; i++){
            if(A[i] < 0){
                negative ++;
            }
            right *= A[i];
        }
        if(negative % 2 == 0){//偶数个负数
            return right;
        }else{                //奇数个负数
            res = right;
            for(int i = start ; i <= end; i ++){
                left *= A[i];
                right = right / A[i];
                res = Math.max(Math.max(left,right),res);
            }
        }
        return res;
    }
}

Runtime:  380 ms

开始分析时，自己也注意到0的分割问题，结果想的情况（比如，一个序列没有0怎么处理，以0开头怎么处理，以0结尾怎么处理）越多脑子很混乱，怎么也理不清头绪，不知道怎么记录0的位置，以及怎么来计算两个0之间的乘积。现在learned了（http://orzorz.me/learn/lesson.htm?courseId=4&lessonId=20）。