Leetcode - Maximum Product Subarray

Paste_Image.png

My code:

public class Solution {
    public int maxProduct(int[] nums) {
        if (nums == null || nums.length == 0)
            return 0;
        else if (nums.length == 1)
            return nums[0];
        
        int max = nums[0];
        int currMax = nums[0];
        int currMin = nums[0];
        for (int i = 1; i < nums.length; i++) {
            int temp = currMax;
            currMax = Math.max(Math.max(currMax * nums[i], currMin * nums[i]), nums[i]);
            currMin = Math.min(Math.min(temp * nums[i], currMin * nums[i]), nums[i]);
            max = Math.max(max, currMax);
        }
        return max;
    }
}

My test result:

这道题目还是没能自己想出来，看了提示。
http://bangbingsyb.blogspot.com/2014/11/leetcode-maximum-product-subarray.html

来仔细分析下。
这道题目和前面一题求和，有什么区别。
求和的话，当你出现了和为负数的情况后，这个情况就结束了。就可以重新开始开头遍历了。
比如， -5, 2,1,1,1,1
当遍历到，-5, 2时，和为-3 < 0, 那么后面的和一定是 >= 该和，只要后面存在正数。
于是，这段值，就不需要再考虑了。直接可以从下一个正数开始考虑了。
但是乘积不同。
-5, 2, 3, -4
遍历到 -5, 2时，此时是负数，但不代表这段值就没用了。如果后面还存在一个负数，那么，这一段，积就是最大的，所以不能简单地舍弃。
于是我就在想，怎么保存这些一开始是负数最后却可能变成最大正数的情况。
解决不了，于是看了提示。
设置两个变量， currMax, currMin
主要在于这个currMin, 可以用来保存负数，然后下次这个负数乘以负数，说不定就成了 currMax. 然后可以保存住这些情况。
所以可以这么理解。这段array，一定存在一个最大的正数，以及一个绝对值最大的负数。
然后一个一定是整段array的乘积。还有一个一定是，在出现了一个负数之后的那段array的乘积。
这两个乘积一定一个是最大正数，一个是绝对值最大的负数。

然后刚刚我试了下，发现还有一种干扰情况。 0
如果出现0.是需要把之前的割舍掉的。然后从新的头开始。
具体就不考虑了。

**
总结： Array, DP
**

My code:

public class Solution {
    public int maxProduct(int[] nums) {
        if (nums == null || nums.length == 0)
            return 0;
        
        int ret = nums[0];
        int prevMin = nums[0];
        int prevMax = nums[0];
        for (int i = 1; i < nums.length; i++) {
            int currMax = Math.max(prevMax * nums[i], Math.max(prevMin * nums[i], nums[i]));
            int currMin = Math.min(prevMax * nums[i], Math.min(prevMin * nums[i], nums[i]));
            ret = Math.max(ret, currMax);
            prevMax = currMax;
            prevMin = currMin;
        }
        
        return ret;
    }
} 

这道题目第二遍还是不会。。。
DP真的是软肋。想不清楚，不知道怎么做。
想这个，仔细想来，就是许多连续的正数被许多负数分割开。然后我们要找出最大值。不仅仅要考虑之前整段的积，还要考虑部分的积。
所以，每次找currMax and currMin 时，都是考虑三个值，
prevMax * nums[i]
prevMin * nums[i]
nums[i]
所以，积是要和之前的连接在一起的。然后找最大值就是找这些散落部分的最大的一个。
下面是我参考的链接：
https://www.quora.com/How-do-I-solve-maximum-product-subarray-problems

感觉下次做这道题目还是做不出来。。
其实这道题，和 maximum subarray, 都有一个共同点，需要两种类型的变量。

1. 一个变量用来记录以前的结果， past
2. 一个变量用来记录最大值， max
   max = Math.max(max, past + nums[i]);
   或者，在乘积中，就是，past与当前值的乘积，然后再取最大值给max，差不多。

Anyway, Good luck, Richardo!

My code:

public class Solution {
    public int maxProduct(int[] nums) {
        if (nums == null || nums.length == 0) {
            return 0;
        }
        int min = nums[0];
        int max = nums[0];
        int ret = nums[0];
        
        for (int i = 1; i < nums.length; i++) {
            int temp_max = Math.max(nums[i], Math.max(max * nums[i], min * nums[i]));
            int temp_min = Math.min(nums[i], Math.min(max * nums[i], min * nums[i]));
            ret = Math.max(ret, temp_max);
            max = temp_max;
            min = temp_min;
        }
        
        return ret;
    }
}

这次做是做出来了，但是代码很丑。改了之后才成这样。

Anyway, Good luck, Richardo!