乘积最大子数组

152 乘积最大子数组

来源 LeetCode ：乘积最大子数组

非动态规划

一开始我并没有用DP
而是分情况讨论的，即通过0将数据分为几段，因为含有0的必定会使结果为0
然后就是考虑负数
在所分的每段里计算乘积，如果负数个数为奇数，将最后出现的那段除掉，然后输出最大值再比较
代码非常长
但是可以跑过
长的我自己都不想看，没脸看，看不明白啊，娘的

class Solution {
public:
    int maxProduct(vector<int>& nums) {
        int len = nums.size();
        int rst = 0;
        if(len == 0)
            rst = 0;
        else if(len == 1)
            rst = nums[0];
        else
        {
            int tag = true;
            int i = 0;int j = 0;
            for(; j<len; ++j) //依据0将元素分为几段
            {
                if(nums[j] == 0)
                {
                    rst = i==j ? rst : max(rst, paraProduct(nums, i, j)); // [i,j) i == j 的目的是为了解决长度为0的情况
                    i = j;
                    ++i;
                }             
            }
            rst = i == j ? rst : max(rst, paraProduct(nums, i, j)); // 长度为0无需
        }
        return rst;
    }
    int paraProduct(vector<int>& nums, int low, int high)
    {
        if(low == high-1){return nums[low];} 
        else
        {
        	int neg_head = 1; //第一次为负的结点值
        	int neg_tail = 1; // 最后一次为负的结点值
            int count = 0; // 第几次负结点
            int mulp = 1;
            int head_mulp = nums[low];
            int tail_mulp = nums[high-1];
            for(int i=low; i<high; ++i)
            {
                if(nums[i]<0)
                {
                    tail_mulp = mulp;
                    if(count < 1)
                    {
                    	neg_head = nums[i];
                        ++count;
                        head_mulp = mulp;
                    }
                    neg_tail = nums[i];
                }
                mulp *= nums[i];
            }
            return max(mulp, max(max(head_mulp, mulp/(neg_head*head_mulp)),max(tail_mulp, mulp/(tail_mulp*neg_tail))));
           
        }  
    }
};
```
## DP