Maximum Non Negative Product in a Matrix - Practice Coding Problems

Maximum Non Negative Product in a Matrix - Problem

You're navigating through a numerical matrix from the top-left corner to the bottom-right corner, but there's a catch - you can only move right or down!

Your goal is to find the path that gives you the maximum non-negative product by multiplying all the numbers you encounter along your journey. If all possible paths result in negative products, return -1.

Key Points:

Start at position (0, 0) and reach (m-1, n-1)
Only move right or down in each step
Calculate the product of all numbers in your path
Return the maximum non-negative product modulo 10^9 + 7
If no non-negative product exists, return -1

Example: In a 2x3 grid [[1, -2, 1], [1, -1, 1]], the optimal path might be 1 → 1 → -1 → 1 = -1, but we need to find the best non-negative path!

Input & Output

example_1.py — Basic Negative Path

$ Input: [[-1,-2,-3],[-2,-3,-3],[-3,-3,-2]]

› Output: 18

💡 Note: The optimal path is (-1) × (-2) × (-3) × (-3) = 18. Even though we start with negative numbers, multiplying negatives can create positive products.

example_2.py — Mixed Values

$ Input: [[1,-2,1],[1,-1,1]]

› Output: 1

💡 Note: The best path is 1 → 1 → 1 → 1 = 1, avoiding the negative numbers entirely when possible to maintain a positive product.

example_3.py — All Negative Result

$ Input: [[1,3],[0,-4]]

› Output: -1

💡 Note: Any path through this matrix will include the 0, making the final product 0. Since 0 is non-negative but we want maximum non-negative, and other paths are negative, we return -1.

Constraints

m == grid.length
n == grid[i].length
1 ≤ m, n ≤ 15
-4 ≤ grid[i][j] ≤ 4
Important: The answer is guaranteed to fit in a 32-bit integer

Visualization

Tap to expand

Understanding the Visualization

Setup DP Tables

Create matrices to track maximum and minimum products at each position

Initialize Boundaries

Fill first row and column with cumulative products

Process Each Cell

For positive numbers, max stays max, min stays min. For negative numbers, they swap!

Extract Result

Return the maximum product from bottom-right cell, or -1 if negative

Key Takeaway

🎯 Key Insight: By tracking both maximum and minimum products at each step, we can handle the sign-flipping nature of negative number multiplication to find optimal paths that might not be obvious at first glance.

Asked in

G Google 45 a Amazon 38 f Meta 32 ⊞ Microsoft 28

The optimal solution uses dynamic programming to track both maximum and minimum products at each cell. Since negative numbers can flip the max/min relationship when multiplied, we need both values to handle all cases correctly. Time complexity is O(m×n) and space complexity is O(m×n).

Common Approaches

Approach	Time	Space	Notes
✓ Dynamic Programming (Optimal)	O(m*n)	O(m*n)	Track both maximum and minimum products at each cell for optimal results

Dynamic Programming (Optimal) — Algorithm Steps

Create DP tables for maximum and minimum products at each cell
Initialize first cell with grid[0][0] for both max and min
For each cell, calculate max/min from top and left neighbors
Handle negative numbers by potentially swapping max and min
Return maximum non-negative product from bottom-right cell

Visualization

Tap to expand

Step-by-Step Walkthrough

Initialize

Set first cell with grid[0][0] for both max and min

Fill Borders

Calculate products along first row and column

Process Cells

For each cell, compute max/min from possible predecessors

Handle Negatives

Negative numbers swap the max/min relationship

Code -

solution.c — C

#include <stdio.h>
#include <stdlib.h>

#define MOD 1000000007
#define max(a,b) ((a) > (b) ? (a) : (b))
#define min(a,b) ((a) < (b) ? (a) : (b))

int maxProductPath(int** grid, int m, int n) {
    long long** maxDp = malloc(m * sizeof(long long*));
    long long** minDp = malloc(m * sizeof(long long*));
    
    for (int i = 0; i < m; i++) {
        maxDp[i] = malloc(n * sizeof(long long));
        minDp[i] = malloc(n * sizeof(long long));
    }
    
    maxDp[0][0] = minDp[0][0] = grid[0][0];
    
    // Fill first row
    for (int j = 1; j < n; j++) {
        maxDp[0][j] = minDp[0][j] = maxDp[0][j-1] * grid[0][j];
    }
    
    // Fill first column
    for (int i = 1; i < m; i++) {
        maxDp[i][0] = minDp[i][0] = maxDp[i-1][0] * grid[i][0];
    }
    
    // Fill the rest
    for (int i = 1; i < m; i++) {
        for (int j = 1; j < n; j++) {
            if (grid[i][j] >= 0) {
                maxDp[i][j] = max(maxDp[i-1][j], maxDp[i][j-1]) * grid[i][j];
                minDp[i][j] = min(minDp[i-1][j], minDp[i][j-1]) * grid[i][j];
            } else {
                maxDp[i][j] = min(minDp[i-1][j], minDp[i][j-1]) * grid[i][j];
                minDp[i][j] = max(maxDp[i-1][j], maxDp[i][j-1]) * grid[i][j];
            }
        }
    }
    
    long long result = maxDp[m-1][n-1];
    
    // Free memory
    for (int i = 0; i < m; i++) {
        free(maxDp[i]);
        free(minDp[i]);
    }
    free(maxDp);
    free(minDp);
    
    return result >= 0 ? (int)(result % MOD) : -1;
}

int main() {
    int m = 3, n = 3;
    int** grid = malloc(m * sizeof(int*));
    for (int i = 0; i < m; i++) {
        grid[i] = malloc(n * sizeof(int));
    }
    
    int values[3][3] = {{-1,-2,-3},{-2,-3,-3},{-3,-3,-2}};
    for (int i = 0; i < m; i++) {
        for (int j = 0; j < n; j++) {
            grid[i][j] = values[i][j];
        }
    }
    
    printf("%d\n", maxProductPath(grid, m, n));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(m*n)

Visit each cell exactly once and perform constant time operations

✓ Linear Growth

Space Complexity

O(m*n)

Two DP arrays to store max and min products for each cell

⚡ Linearithmic Space

41.4K Views

Medium-High Frequency

~25 min Avg. Time

1.4K Likes

Ln 1, Col 1

Smart Actions

💡 Explanation

AI Ready

💡 Suggestion Tab to accept Esc to dismiss

// Output will appear here after running code

Code Editor Closed

Click the red button to reopen

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Dynamic Programming (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler