<p>You are given a <code>m x n</code> matrix <code>grid</code>. Initially, you are located at the top-left corner <code>(0, 0)</code>, and in each step, you can only <strong>move right or down</strong> in the matrix.</p>

<p>Among all possible paths starting from the top-left corner <code>(0, 0)</code> and ending in the bottom-right corner <code>(m - 1, n - 1)</code>, find the path with the <strong>maximum non-negative product</strong>. The product of a path is the product of all integers in the grid cells visited along the path.</p>

<p>Return the <em>maximum non-negative product <strong>modulo</strong> </em><code>10<sup>9</sup> + 7</code>. <em>If the maximum product is <strong>negative</strong>, return </em><code>-1</code>.</p>

<p>Notice that the modulo is performed after getting the maximum product.</p>

<p>&nbsp;</p>
<p><strong class="example">Example 1:</strong></p>
<img alt="" src="https://assets.leetcode.com/uploads/2021/12/23/product1.jpg" style="width: 244px; height: 245px;" />
<pre>
<strong>Input:</strong> grid = [[-1,-2,-3],[-2,-3,-3],[-3,-3,-2]]
<strong>Output:</strong> -1
<strong>Explanation:</strong> It is not possible to get non-negative product in the path from (0, 0) to (2, 2), so return -1.
</pre>

<p><strong class="example">Example 2:</strong></p>
<img alt="" src="https://assets.leetcode.com/uploads/2021/12/23/product2.jpg" style="width: 244px; height: 245px;" />
<pre>
<strong>Input:</strong> grid = [[1,-2,1],[1,-2,1],[3,-4,1]]
<strong>Output:</strong> 8
<strong>Explanation:</strong> Maximum non-negative product is shown (1 * 1 * -2 * -4 * 1 = 8).
</pre>

<p><strong class="example">Example 3:</strong></p>
<img alt="" src="https://assets.leetcode.com/uploads/2021/12/23/product3.jpg" style="width: 164px; height: 165px;" />
<pre>
<strong>Input:</strong> grid = [[1,3],[0,-4]]
<strong>Output:</strong> 0
<strong>Explanation:</strong> Maximum non-negative product is shown (1 * 0 * -4 = 0).
</pre>

<p>&nbsp;</p>
<p><strong>Constraints:</strong></p>

<ul>
	<li><code>m == grid.length</code></li>
	<li><code>n == grid[i].length</code></li>
	<li><code>1 &lt;= m, n &lt;= 15</code></li>
	<li><code>-4 &lt;= grid[i][j] &lt;= 4</code></li>
</ul>

class Solution:
    def maxProductPath(self, grid: List[List[int]]) -> int:
        n=len(grid)
        m=len(grid[0])
        ans=[-1]
        MOD = 10**9+7
        @lru_cache(None)
        def f(i,j):
            if i==0 and j==0:
                return [grid [i][j], grid [i][j]]
            if i < 0 or j < 0: 
                return -inf, inf     
            max1,min1 = f(i-1,j) 
            max2,min2=f(i,j-1) 
            # max1=max1% MOD
            # max2=max2% MOD
            # print(max1)
            # min1%=MOD
            # min2%=MOD

            maxm = (max(max1,max2) * grid [i][j]) 
            minm = (min(min1,min2) * grid [i][j])
            if grid [i][j]<0:
                maxm,minm = minm, maxm
            
            return [maxm,minm]
        ans = f(n-1,m-1)
        print(ans)
        if ans[0]<0:
            return -1
        else:
            return ans[0] % MOD
# class Solution:
    # def maxProductPath(self, grid: List[List[int]]) -> int:
    #     m, n = len(grid), len(grid[0])
        
    #     @lru_cache(None)
    #     def fn(i, j): 
    #         """Return maximum & minimum products ending at (i, j)."""
    #         if i == 0 and j == 0: return grid[0][0], grid[0][0]
    #         if i < 0 or j < 0: return -inf, inf
    #         if grid[i][j] == 0: return 0, 0
    #         mx1, mn1 = fn(i-1, j) # from top
    #         mx2, mn2 = fn(i, j-1) # from left 
    #         mx, mn = max(mx1, mx2)*grid[i][j], min(mn1, mn2)*grid[i][j]
    #         return (mx, mn) if grid[i][j] > 0 else (mn, mx)
        
    #     mx, _ = fn(m-1, n-1)
    #     return -1 if mx < 0 else mx % 1_000_000_007
17000