给你一个大小为 rows x cols 的矩阵 grid 。最初，你位于左上角 (0, 0) ，每一步，你可以在矩阵中 向右 或 向下 移动。

在从左上角 (0, 0) 开始到右下角 (rows - 1, cols - 1) 结束的所有路径中，找出具有 最大非负积 的路径。路径的积是沿路径访问的单元格中所有整数的乘积。

返回 最大非负积 对 109 + 7 取余 的结果。如果最大积为负数，则返回 -1 。

注意，取余是在得到最大积之后执行的。

 

示例 1：

输入：grid = [[-1,-2,-3],
             [-2,-3,-3],
             [-3,-3,-2]]
输出：-1
解释：从 (0, 0) 到 (2, 2) 的路径中无法得到非负积，所以返回 -1

示例 2：

输入：grid = [[1,-2,1],
             [1,-2,1],
             [3,-4,1]]
输出：8
解释：最大非负积对应的路径已经用粗体标出 (1 * 1 * -2 * -4 * 1 = 8)

示例 3：

输入：grid = [[1, 3],
             [0,-4]]
输出：0
解释：最大非负积对应的路径已经用粗体标出 (1 * 0 * -4 = 0)

示例 4：

输入：grid = [[ 1, 4,4,0],
             [-2, 0,0,1],
             [ 1,-1,1,1]]
输出：2
解释：最大非负积对应的路径已经用粗体标出 (1 * -2 * 1 * -1 * 1 * 1 = 2)

由于如果乘积只能是负数，那就输出-1，所以每个位置我们绝对值最大的负数和最大的正数，最后做判断。
代码：
class Solution {
public:
    int maxProductPath(vector<vector<int>>& grid) {
        int n = grid.size(),m = grid[0].size(),flag = 0;
        long long mp[20][20][2] = {0};//0positive 1negative
        long long d = grid[0][0];
        if(d > 0) mp[0][0][0] = d;
        else mp[0][0][1] = d;
        for(int i = 1;i < n;i ++) {
            d *= grid[i][0];
            if(d >= 0) mp[i][0][0] = d;
            else mp[i][0][1] = d;
        }
        d = grid[0][0];
        for(int i = 1;i < m;i ++) {
            d *= grid[0][i];
            if(d >= 0) mp[0][i][0] = d;
            else mp[0][i][1] = d;
        }
        for(int i = 1;i < n;i ++) {
            for(int j = 1;j < m;j ++) {
                if(grid[i][j] < 0) {
                    mp[i][j][0] = min(mp[i - 1][j][1],mp[i][j - 1][1]) * grid[i][j];
                    mp[i][j][1] = max(mp[i - 1][j][0],mp[i][j - 1][0]) * grid[i][j];
                }
                else {
                    mp[i][j][1] = min(mp[i - 1][j][1],mp[i][j - 1][1]) * grid[i][j];
                    mp[i][j][0] = max(mp[i - 1][j][0],mp[i][j - 1][0]) * grid[i][j];
                }
            }
        }
        for(int i = 0;i < n;i ++) {
            for(int j = 0;j < m;j ++) {
                if(grid[i][j] == 0) {
                    flag = 1;
                    break;
                }
            }
        }
        if(mp[n - 1][m - 1][0]) return mp[n - 1][m - 1][0] % 1000000007;
        if(flag) return 0;
        return -1;
    }
};