152. Maximum Product Subarray**(乘积最大子数组)

152. Maximum Product Subarray**(乘积最大子数组)

https://leetcode.com/problems/maximum-product-subarray/

题目描述

Given an integer array nums, find a contiguous non-empty subarray within the array that has the largest product, and return the product.

It is guaranteed that the answer will fit in a 32-bit integer.

A subarray is a contiguous subsequence of the array.

Example 1:

Input: nums = [2,3,-2,4]
Output: 6
Explanation: [2,3] has the largest product 6.

Example 2:

Input: nums = [-2,0,-1]
Output: 0
Explanation: The result cannot be 2, because [-2,-1] is not a subarray.

Constraints:

• 1 <= nums.length <= 2 * 10^4
• -10 <= nums[i] <= 10
• The product of any prefix or suffix of nums is guaranteed to fit in a 32-bit integer.

代码实现

乘积最大子数组 是一道经典的动态规划题目, 它和 53. Maximum Subarray*(最大子序和)
以及 300. **Longest Increasing Subsequence (最长递增子序列) 这几道题给我留下的印象太深刻了, 看到名字就知道需用动态规划的方法 🤣🤣🤣

做这道题之前, 可以看看另外两道题, 找找用动态规划进行求解的感觉. 做这题时, 很容易将它和 53. Maximum Subarray*(最大子序和) 联系起来, 因为它们的思路很类似: 先定义状态转移方程, 比如 dp[i] 表示以 nums[i] 结尾的子数组的最大值 (乘积或者求和), 那么更新 dp[i + 1] 时, 对于 53. Maximum Subarray*(最大子序和) , 状态方程为 dp[i + 1] = max(dp[i] + nums[i], nums[i]);, 然而对于本题来说, 求最大乘积, 我们却不能直接使用 dp[i + 1] = max(dp[i] * nums[i], nums[i]); 原因是本题数组中是存在负数的, 即使 dp[i] 是负数, 也可能通过和 nums[i] 进行乘积, 从而得到正数. 那么矛盾就出现了, 我们在定义时, 希望 dp[i] 始终保存最大值, 但是就算 dp[i] 不是最大值, 也有可能在 dp[i + 1] 取得最大值 (通过负负得正的方式).

那如何解决这个矛盾呢 ? 方法是使用两个 dp 数组, 其中数组 A 维护以 nums[i] 结尾的子数组的最大乘积值, 而引入数组 B 来维护以 nums[i] 结尾的子数组的最小值. 之后写状态方程时, 需要同步更新两个数组的状态.

对于数组 A, 要维护每个元素始终表示 “以 nums[i] 结尾的子数组的最大乘积值”, 除了要比较 A[i - 1] * nums[i] 和 nums[i] 大小外, 还需要考虑 B[i - 1] 这个最小值可能通过和 nums[i] 进行乘积的方式 (比如负负得正) 得到较大的正数, 因此更新 A[i] 时, 要比较 A[i - 1] * nums[i] 和 B[i - 1] * nums[i] 以及 nums[i] 的大小:

A[i] = max(max(A[i - 1] * nums[i], B[i - 1] * nums[i]), nums[i]);

同理对于数组 B, 要维护每个元素始终表示 “以 nums[i] 结尾的子数组的最小乘积值”, 也要比较 A[i - 1] * nums[i] 和 B[i - 1] * nums[i] 以及 nums[i] 的大小, 不过这里是比较它们中的最小值, 毕竟 A[i - 1] * nums[i] 也可能因为 A[i - 1] 为正数而 nums[i] 为负数, 导致得到的乘积结果最小:

B[i] = min(min(A[i - 1] * nums[i], B[i - 1] * nums[i]), nums[i]);

在实际编码时, 需要注意:

• 考虑到遍历数组时 i 从 0 开始, 那么当 i == 0 时, A[i - 1] 就是 A[-1], 越界了, 为此, 我们可以定义 A[i + 1] 表示以 nums[i] 结尾的子数组的最大乘积, 这种技巧应该很容易就想到;
• A 和 B 的初始化, 比如 A[0] 和 B[0] 均初始化为 1, 用于乘积;

下面看具体代码:

class Solution {
public:
    int maxProduct(vector<int>& nums) {
        vector<int> A(nums.size() + 1, 1), B(nums.size() + 1, 1);
        int res = nums[0];
        for (int i = 0; i < nums.size(); ++ i) {
            A[i + 1] = max(max(A[i] * nums[i], B[i] * nums[i]), nums[i]);
            B[i + 1] = min(min(A[i] * nums[i], B[i] * nums[i]), nums[i]);
            res = max(res, A[i + 1]);
        }
        return res;
    }
};

由于 A 维护最大值, 所以最后其实是求 A 中的最大值, 使用 *std::max_element(A.begin(), A.end()) 来得到结果也是可以的.

写完代码后, 观察下是否能再优化一下, 比如 A[i + 1] 只和 A[i] 相关, 只需要使用一个变量来表示 A[i] 即可, 同理 B[i] 也如此, 这样可以优化空间的占用. 代码如下:

class Solution {
public:
    int maxProduct(vector<int>& nums) {
        int A = 1, nA = 1, B = 1, nB = 1;
        int res = nums[0];
        for (int i = 0; i < nums.size(); ++ i) {
            nA = max(max(A * nums[i], B * nums[i]), nums[i]);
            nB = min(min(A * nums[i], B * nums[i]), nums[i]);
            A = nA;
            B = nB;
            res = max(res, A);
        }
        return res;
    }
};

下面另一种解法更为巧妙一些:

class Solution {
public:
    int maxProduct(vector<int>& nums) {
        if (nums.empty()) return 0;
        int imax = nums[0], imin = nums[0];
        int res = nums[0];
        for (int i = 1; i < nums.size(); ++i) {
            if (nums[i] < 0) std::swap(imax, imin);
            imax = max(nums[i], imax * nums[i]);
            imin = min(nums[i], imin * nums[i]);
            res = max(res, imax);
        }
        return res;
    }
};