Maximum Non Negative Product in a Matrix

Maximum Non Negative Product in a Matrix - Problem

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

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

Return the maximum non-negative product modulo 10⁹ + 7. If the maximum product is negative, return -1.

Notice that the modulo is performed after getting the maximum product.

Input & Output

Example 1 — All Negative Numbers

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

› Output: 36

💡 Note: Path: (-1) → (-2) → (-3) → (-3) → (-2). Product = (-1) × (-2) × (-3) × (-3) × (-2) = 36

Example 2 — Mix of Positive and Negative

$ Input: grid = [[1,-2,1],[1,-2,1],[3,-4,1]]

› Output: 8

💡 Note: Path: (1) → (1) → (3) → (-4) → (1). Product = 1 × 1 × 3 × (-4) × 1 = -12, but best path gives 8

Example 3 — All Negative Result

$ Input: grid = [[-1,-1],[-1,-1]]

› Output: -1

💡 Note: All possible paths result in negative products: (-1) × (-1) × (-1) = -1

Constraints

m == grid.length
n == grid[i].length
1 ≤ m, n ≤ 15
-4 ≤ grid[i][j] ≤ 4

Visualization

Tap to expand

Asked in

G Google 25 a Amazon 18 M Microsoft 15

Use 2D Dynamic Programming to track both maximum and minimum products at each cell. The key insight is that negative numbers can become positive when multiplied together. Best approach: O(m×n) time, O(m×n) space.

Common Approaches

✓ Optimized

⏱️ Time: N/A Space: N/A

2D Dynamic Programming

⏱️ Time: O(m×n) Space: O(m×n)

Use dynamic programming to track both maximum and minimum products at each cell, since negative numbers can turn into positive when multiplied.

Brute Force DFS

⏱️ Time: O(2^(m+n)) Space: O(m+n)

Generate all possible paths from top-left to bottom-right, calculate the product for each path, and return the maximum non-negative product.

Algorithm Steps — Algorithm Steps

Code -

solution.c — C

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

#define MOD 1000000007

long long dp_max[50][50];
long long dp_min[50][50];

long long max(long long a, long long b) {
    return a > b ? a : b;
}

long long min(long long a, long long b) {
    return a < b ? a : b;
}

long long solution(int grid[][50], int m, int n) {
    dp_max[0][0] = dp_min[0][0] = grid[0][0];
    
    // Fill first row
    for (int j = 1; j < n; j++) {
        dp_max[0][j] = dp_min[0][j] = dp_max[0][j-1] * grid[0][j];
    }
    
    // Fill first column
    for (int i = 1; i < m; i++) {
        dp_max[i][0] = dp_min[i][0] = dp_max[i-1][0] * grid[i][0];
    }
    
    // Fill rest of the grid
    for (int i = 1; i < m; i++) {
        for (int j = 1; j < n; j++) {
            if (grid[i][j] >= 0) {
                dp_max[i][j] = max(dp_max[i-1][j], dp_max[i][j-1]) * grid[i][j];
                dp_min[i][j] = min(dp_min[i-1][j], dp_min[i][j-1]) * grid[i][j];
            } else {
                dp_max[i][j] = min(dp_min[i-1][j], dp_min[i][j-1]) * grid[i][j];
                dp_min[i][j] = max(dp_max[i-1][j], dp_max[i][j-1]) * grid[i][j];
            }
        }
    }
    
    long long result = dp_max[m-1][n-1];
    return result >= 0 ? result % MOD : -1;
}

int grid[50][50];

int main() {
    char line[10000];
    fgets(line, sizeof(line), stdin);
    
    int m = 0, n = 0;
    char* p = line;
    
    // Skip initial '['
    while (*p && *p != '[') p++;
    if (*p == '[') p++;
    
    // Parse the 2D array
    while (*p && *p != ']') {
        if (*p == '[') {
            p++;
            n = 0;
            while (*p && *p != ']') {
                while (*p == ' ' || *p == ',') p++;
                if (*p == ']' || *p == '\0') break;
                
                int num = 0;
                int sign = 1;
                if (*p == '-') {
                    sign = -1;
                    p++;
                }
                while (*p >= '0' && *p <= '9') {
                    num = num * 10 + (*p - '0');
                    p++;
                }
                grid[m][n++] = sign * num;
            }
            if (*p == ']') p++;
            m++;
        } else {
            p++;
        }
    }
    
    long long result = solution(grid, m, n);
    printf("%lld\n", result);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

✓ Linear Growth

Space Complexity

⚡ Linearithmic Space

35.0K Views

Medium Frequency

~25 min Avg. Time

892 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