Construct Product Matrix - Practice Coding Problems

Construct Product Matrix - Problem

Imagine you're a data analyst tasked with creating a special product matrix where each cell contains the product of all other elements except itself!

Given a 2D integer matrix grid of size n × m, you need to construct a new matrix p where:

Each element p[i][j] equals the product of all elements in the original grid except grid[i][j]
Each product is taken modulo 12345 to keep numbers manageable

Goal: Return this product matrix efficiently without using division operations.

Example: For grid [[1,2],[3,4]], the product matrix would be [[24,12],[8,6]] because:

p[0][0] = 2×3×4 = 24
p[0][1] = 1×3×4 = 12
p[1][0] = 1×2×4 = 8
p[1][1] = 1×2×3 = 6

Input & Output

example_1.py — Small 2×2 Matrix

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

› Output: [[24,12],[8,6]]

💡 Note: For each cell, we multiply all other elements: p[0][0] = 2×3×4 = 24, p[0][1] = 1×3×4 = 12, p[1][0] = 1×2×4 = 8, p[1][1] = 1×2×3 = 6

example_2.py — Single Row Matrix

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

› Output: [[24,12,8,6]]

💡 Note: Each element is the product of all others in the matrix: 24 = 2×3×4, 12 = 1×3×4, 8 = 1×2×4, 6 = 1×2×3

example_3.py — Matrix with Zeros

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

› Output: [[0,6],[0,0]]

💡 Note: When one element is 0, all other cells become 0 except the cell where 0 was originally located: p[0][1] = 1×2×3 = 6, all others are 0

Constraints

1 ≤ n, m ≤ 10⁵
1 ≤ n × m ≤ 10⁵
1 ≤ grid[i][j] ≤ 10⁹
All calculations must be done modulo 12345

Visualization

Tap to expand

Understanding the Visualization

Initial Setup

We have a 2×2 studio with photographers earning $1, $2, $3, $4 respectively

Calculate Products

For each photographer, multiply all other earnings to get potential revenue

Apply Business Rules

Take modulo 12345 to normalize large numbers for accounting

Generate Report

Create final matrix showing impact of each photographer's absence

Key Takeaway

🎯 Key Insight: Instead of recalculating products for each cell from scratch, we can build cumulative products from both directions and combine them efficiently, reducing time complexity from O(n²m²) to O(nm)!

Asked in

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

The optimal solution uses the two-pass prefix/suffix technique to avoid redundant calculations. By treating the 2D matrix as a flattened 1D array, we can build prefix products (product of all elements before each position) and suffix products (product of all elements after each position) in just O(nm) time, eliminating the need for nested loops.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Nested Loops)	O(n²m²)	O(1)	For each cell, multiply all other cells in the matrix
Two-Pass Prefix/Suffix Products	O(nm)	O(nm)	Build prefix and suffix products, then combine them efficiently

Brute Force (Nested Loops) — Algorithm Steps

Create result matrix of same dimensions
For each cell (i,j) in the matrix
Initialize product = 1
Iterate through all cells (x,y)
If (x,y) != (i,j), multiply product by grid[x][y]
Set result[i][j] = product % 12345

Visualization

Tap to expand

Step-by-Step Walkthrough

Select target cell

Choose the cell we want to calculate product for

Iterate all other cells

Visit every cell except the target cell

Multiply values

Accumulate product of all visited cells

Apply modulo

Take result modulo 12345 and store

Code -

solution.c — C

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

#define MOD 12345

int** constructProductMatrix(int** grid, int n, int m) {
    int** result = (int**)malloc(n * sizeof(int*));
    for (int i = 0; i < n; i++) {
        result[i] = (int*)malloc(m * sizeof(int));
    }
    
    for (int i = 0; i < n; i++) {
        for (int j = 0; j < m; j++) {
            long long product = 1;
            for (int x = 0; x < n; x++) {
                for (int y = 0; y < m; y++) {
                    if (!(x == i && y == j)) {
                        product = (product * grid[x][y]) % MOD;
                    }
                }
            }
            result[i][j] = (int)product;
        }
    }
    
    return result;
}

int main() {
    // Example usage
    int n = 2, m = 2;
    int** grid = (int**)malloc(n * sizeof(int*));
    for (int i = 0; i < n; i++) {
        grid[i] = (int*)malloc(m * sizeof(int));
    }
    
    grid[0][0] = 1; grid[0][1] = 2;
    grid[1][0] = 3; grid[1][1] = 4;
    
    int** result = constructProductMatrix(grid, n, m);
    
    for (int i = 0; i < n; i++) {
        for (int j = 0; j < m; j++) {
            printf("%d ", result[i][j]);
        }
        printf("\n");
    }
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n²m²)

For each of n×m cells, we iterate through all n×m cells again

⚠ Quadratic Growth

Space Complexity

O(1)

Only using constant extra space besides the result matrix

✓ Linear Space

23.4K Views

Medium Frequency

~15 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

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Brute Force (Nested Loops) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler