LeetCode:152. Maximum Product Subarray

题目大意：求一个数组中最大连续子数组的乘积。

这题的第一反应是动态规划，而且经过思考之后，不可能只定义一个状态就能够解决这个问题，必须得定义两个状态（看另一题需要定义两个状态才能求解的DP问题：https://blog.csdn.net/weixin_43462819/article/details/83240210 ）

1.我的解法
我的解法是自己思考出来的，但是过程很繁琐。定义两个数组：dp1和dp2，其中：
dp1[i]:代表以数组中第i个数结尾的连续子数组的最大乘积
dp2[i]:代表以数组中第i个数结尾的连续子数组的最小乘积
具体的状态转移方程就不列出来了，非常繁琐，而且看代码而且也能看明白。
在列转移方程时，需要记住的是，对于任意的k（在范围内）,dp1[k] >= dp2[k]

代码：

class Solution {
public:
    int maxProduct(vector<int>& nums) {
        if (nums.empty())
            return 0;
        int sz = nums.size();
        vector<int> dp1(sz);
        vector<int> dp2(sz);
        dp1[0] = nums[0];
        dp2[0] = nums[0];
        for (int i = 1; i < sz; ++i) {
            if (nums[i] > 0) 
                dp1[i] = nums[i] * (dp1[i-1] < 1? dp1[i-1] : 1);
            else 
                dp1[i] = nums[i] * (dp2[i-1] < 1? 1 : dp2[i-1]);
            
            if (nums[i] > 0)
                dp2[i] = nums[i] * (dp2[i-1] > 1? dp2[i-1] : 1);
            else
                dp2[i] = nums[i] * (dp1[i-1] > 1? 1 : dp1[i-1]);
        }
        return *max_element(dp2.begin(), dp2.end());
    }
};

确实很复杂

2.一个巧妙的解法
这是我从评论区看来的。差点把我看哭了。
直接先看代码：

int maxProduct(int A[], int n) {
    // store the result that is the max we have found so far
    int r = A[0];

    // imax/imin stores the max/min product of
    // subarray that ends with the current number A[i]
    for (int i = 1, imax = r, imin = r; i < n; i++) {
        // multiplied by a negative makes big number smaller, small number bigger
        // so we redefine the extremums by swapping them
        if (A[i] < 0)
            swap(imax, imin);

        // max/min product for the current number is either the current number itself
        // or the max/min by the previous number times the current one
        imax = max(A[i], imax * A[i]);
        imin = min(A[i], imin * A[i]);

        // the newly computed max value is a candidate for our global result
        r = max(r, imax);
    }
    return r;
}

给我的教训有两点：
1.当使用DP时，如果每次都只用到前面的一个状态，那么不用把所有DP全部存储起来，只需要使用一个变量来存储就可以了。而且如果最终的答案不在最后的位置，那么需要一个额外的变量在每次的迭代中与这次迭代的结果相比较。
2.善用max，min。不是指这两个函数，而是指善用这两个概念，可以避免许多不必要的“斤斤计较”的计算，比如我自己的解法的分析太细致了，但是min，max可以快刀斩乱麻。