Leetcode 152&1594 maximum product (python)

Leetcode 152. Maximum Product Subarray

解法：

同时储存最大的正值和最小的负值，下一个最大值一定会在跟这两个的乘积中出现

class Solution(object):
    def maxProduct(self, nums):
        """
        :type nums: List[int]
        :rtype: int
        """
        if not nums:
            return 0
        
        max_so_far = min_so_far = nums[0]
        
        ans = max_so_far
        
        for num in nums[1:]:
            max_so_far,min_so_far = max(num,max_so_far*num,min_so_far*num),min(num,min_so_far*num,max_so_far*num)

            
            ans = max(max_so_far,ans)
        return ans
            

解法2：标准的dp解法

解法1是解法2的空间压缩版

class Solution {
public:
    int maxProduct(vector<int>& nums) {
        if(nums.empty()){
            return 0;
        }
        int n = nums.size();
        vector<int> dp_max(n,0);
        dp_max[0] = nums[0];
        vector<int> dp_min(n,0);
        dp_min[0] = nums[0];
        
        for(int i=1;i<n;i++){
            dp_max[i] = max(nums[i],max(dp_max[i-1]*nums[i],dp_min[i-1]*nums[i]));
            dp_min[i] = min(nums[i],min(dp_max[i-1]*nums[i],dp_min[i-1]*nums[i]));
        }
        int ans = -INT_MAX;
        for(auto num : dp_max){
            ans = max(ans,num);
        }
        return ans;
    }
};

1594. Maximum Non Negative Product in a Matrix

题目

解法：

只是把上一题扩展成了二维而已，解法一模一样

class Solution:
    def maxProductPath(self, grid: List[List[int]]) -> int:
        if not grid:
            return 0
        m,n = len(grid),len(grid[0])
        
        dp_nega = [[0]*n for _ in range(m)]
        dp_posi = [[0]*n for _ in range(m)]
        tmp = 1
        for i in range(m):
            tmp *= grid[i][0]
            dp_nega[i][0] = tmp 
            dp_posi[i][0] = tmp
        
        tmp = 1
        for i in range(n):
            tmp *= grid[0][i]
            dp_nega[0][i] = tmp
            dp_posi[0][i] = tmp
        
        for i in range(1,m):
            for j in range(1,n):
                min_val = min(grid[i][j]*dp_nega[i-1][j],grid[i][j]*dp_nega[i][j-1],grid[i][j]*dp_posi[i-1][j],grid[i][j]*dp_posi[i][j-1])
                
                dp_nega[i][j] = min_val
                max_val = max(grid[i][j]*dp_nega[i-1][j],grid[i][j]*dp_nega[i][j-1],grid[i][j]*dp_posi[i-1][j],grid[i][j]*dp_posi[i][j-1])
                
                dp_posi[i][j] = max_val
        
        return dp_posi[-1][-1]%(10**9+7) if dp_posi[-1][-1]>=0 else -1