Codestin Search App

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
✓ Two-Pass Prefix/Suffix Products	O(nm)	O(nm)	Build prefix and suffix products, then combine them efficiently
Brute Force (Nested Loops)	O(n²m²)	O(1)	For each cell, multiply all other cells in the matrix

Two-Pass Prefix/Suffix Products — Algorithm Steps

Flatten the 2D matrix into 1D conceptually (row by row)
Calculate prefix products: each position stores product of all previous elements
Calculate suffix products: each position stores product of all following elements
For each position, multiply corresponding prefix and suffix products
Apply modulo 12345 to final results
Reshape back to 2D matrix format

Visualization

Tap to expand

Step-by-Step Walkthrough

Flatten Matrix

Convert 2D matrix to 1D array for easier processing

Build Prefix Products

Each position stores product of all previous elements

Build Suffix Products

Process from right to left, combining with prefix

Reshape Result

Convert back to 2D matrix format

Code -

solution.c — C

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

#define MOD 12345

int** constructProductMatrix(int** grid, int n, int m) {
    int totalCells = n * m;
    
    // Flatten matrix
    int* flat = (int*)malloc(totalCells * sizeof(int));
    int idx = 0;
    for (int i = 0; i < n; i++) {
        for (int j = 0; j < m; j++) {
            flat[idx++] = grid[i][j];
        }
    }
    
    // Build prefix products
    long long* prefix = (long long*)malloc(totalCells * sizeof(long long));
    prefix[0] = 1;
    for (int i = 1; i < totalCells; i++) {
        prefix[i] = (prefix[i-1] * flat[i-1]) % MOD;
    }
    
    // Allocate result matrix
    int** result = (int**)malloc(n * sizeof(int*));
    for (int i = 0; i < n; i++) {
        result[i] = (int*)malloc(m * sizeof(int));
    }
    
    // Build suffix products and combine
    long long suffix = 1;
    for (int i = totalCells - 1; i >= 0; i--) {
        int row = i / m, col = i % m;
        result[row][col] = (int)((prefix[i] * suffix) % MOD);
        suffix = (suffix * flat[i]) % MOD;
    }
    
    free(flat);
    free(prefix);
    return result;
}

int main() {
    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(nm)

Two passes through the matrix: one for prefix, one for suffix products

✓ Linear Growth

Space Complexity

O(nm)

Extra arrays to store prefix and suffix products

⚡ Linearithmic 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

Two-Pass Prefix/Suffix Products — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler