算法编程题-矩阵的最大非负积

原题描述

有一个大小为m * n的矩阵，从（0， 0）位置处出发，每次只能向右或者向下走，一直走到（m - 1, n - 1）位置，现在计算路径上所有数字的乘积，求最大非负积。如果最大非负积小于0，返回-1，否则返回其对 $10^9+7$取模后的结果。
数据范围：1 <= m, n <= 15, -4 <= grid[i][j] <=4
原题链接：leetcode1594

解题思路

关键思路：动态规划
熟悉动态规划的同学看到这道题目，立马就能想到动态规划。但是矩阵里有负数，如果只维护每一个位置的最大值的话，是不行的，因为最大值乘以一个负数就变成最小值了，所以要在每一个位置维护一个最小值和一个最大值。
关于取模的问题，笔者觉得这道题目有意思的点是，数据的范围保证了数据不会超出64位整数的范围$4^{15}=2^{30}$。如果数据范围超出了64位整数范围，由于是在最后取模，这题就会变得相当复杂。
复杂度分析：

• 时间复杂度：$O(m\ast n)$
• 空间复杂度：$O(m\ast n)$

代码

func maxProductPath(grid [][]int) int {
    m := len(grid)
    n := len(grid[0])
    mod := int64(1e9+7)
    // 初始化一个m * n * 2 大小的dp数组
    dp := make([][][]int64, m)
    for i := 0; i < m; i++ {
        dp[i] = make([][]int64, n)
        for j := 0; j < n; j++ {
            // 形式为[max, min]
            dp[i][j] = make([]int64, 2)
        }
    }
    // 边界值设定
    dp[0][0] = []int64{int64(grid[0][0]), int64(grid[0][0])}
    for i := 1; i < m; i++ {
        if grid[i][0] >= 0 {
            dp[i][0][0] = dp[i - 1][0][0] * int64(grid[i][0])
            dp[i][0][1] = dp[i - 1][0][1] * int64(grid[i][0])
        } else {
            dp[i][0][0] = dp[i - 1][0][1] * int64(grid[i][0])
            dp[i][0][1] = dp[i - 1][0][0] * int64(grid[i][0])
        }
    }

    for i := 1; i < n; i++ {
        if grid[0][i] >= 0 {
            dp[0][i][0] = dp[0][i - 1][0] * int64(grid[0][i])
            dp[0][i][1] = dp[0][i - 1][1] * int64(grid[0][i])
        } else {
            dp[0][i][0] = dp[0][i - 1][1] * int64(grid[0][i])
            dp[0][i][1] = dp[0][i - 1][0] * int64(grid[0][i])
        }
    }

    // 正常dp

    for i := 1; i < m; i++ {
        for j := 1; j < n; j++ {
            if grid[i][j] >= 0 {
                dp[i][j][0] = max(dp[i - 1][j][0], dp[i][j - 1][0]) * int64(grid[i][j])
                dp[i][j][1] = min(dp[i - 1][j][1], dp[i][j - 1][1]) * int64(grid[i][j])
            } else {
                dp[i][j][0] = min(dp[i - 1][j][1], dp[i][j - 1][1]) * int64(grid[i][j])
                dp[i][j][1] = max(dp[i - 1][j][0], dp[i][j - 1][0]) * int64(grid[i][j])
            }
        }
    }  

    if dp[m - 1][n - 1][0] < 0 {
        return -1
    } 
    return int(dp[m - 1][n - 1][0] % mod)
}