Construct Product Matrix

Construct Product Matrix - Problem

Given a 0-indexed 2D integer matrix grid of size n * m, we define a 0-indexed 2D matrix p of size n * m as the product matrix of grid if the following condition is met:

Each element p[i][j] is calculated as the product of all elements in grid except for the element grid[i][j]. This product is then taken modulo 12345.

Return the product matrix of grid.

Input & Output

Example 1 — Basic 2x3 Matrix

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

› Output: [[720,360,240],[180,144,120]]

💡 Note: For grid[0][0]=1: product of all others = 2×3×4×5×6 = 720. For grid[1][1]=5: product = 1×2×3×4×6 = 144. Each result taken modulo 12345.

Example 2 — Single Row

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

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

💡 Note: For each element, multiply all others: 2×3×4=24, 1×3×4=12, 1×2×4=8, 1×2×3=6

Example 3 — Contains Zero

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

› Output: [[120,0,0],[0,0,0]]

💡 Note: When matrix contains zero, only the zero position gets non-zero result (product of all non-zero elements). All other positions get 0 since they exclude the zero.

Constraints

1 ≤ n, m ≤ 10⁵
1 ≤ n * m ≤ 10⁵
-10⁹ ≤ grid[i][j] ≤ 10⁹
The answer is taken modulo 12345

Visualization

Tap to expand

Asked in

G Google 35 a Amazon 28 M Microsoft 22 A Apple 18

The key insight is to avoid recalculating products by using prefix and suffix arrays. Instead of computing O(nm) products for each cell, we precompute prefix products (left to right) and suffix products (right to left), then combine them. Best approach uses prefix product technique with Time: O(nm), Space: O(nm).

Common Approaches

✓ Bit Manipulation

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

Brute Force - Calculate Each Product Separately

⏱️ Time: O(n²m²) Space: O(1)

For each position (i,j), iterate through the entire matrix and multiply all elements except grid[i][j]. This requires nested loops for each cell position.

Prefix Product Approach

⏱️ Time: O(nm) Space: O(nm)

Flatten the 2D matrix into 1D, calculate prefix products from left and suffix products from right. For each position, multiply corresponding prefix and suffix products to get the result.

Algorithm Steps — Algorithm Steps

Code -

solution.c — C

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

int* solution(int* nums, int numsSize, int* returnSize) {
    int* result = (int*)malloc(numsSize * sizeof(int));
    *returnSize = numsSize;
    
    for (int idx = 0; idx < numsSize; idx++) {
        int num = nums[idx];
        if (num == 2) {
            result[idx] = -1;
            continue;
        }
        
        // Find the rightmost 0 bit in num
        int rightmostZeroPos = -1;
        for (int i = 0; i < 32; i++) {
            if ((num & (1 << i)) == 0) {
                rightmostZeroPos = i;
                break;
            }
        }
        
        // If rightmost 0 is at position 0, impossible
        if (rightmostZeroPos == 0) {
            result[idx] = -1;
            continue;
        }
        
        // The answer is num with the bit at (rightmostZeroPos - 1) cleared
        int ans = num & ~(1 << (rightmostZeroPos - 1));
        result[idx] = ans;
    }
    
    return result;
}

int main() {
    char line[10000];
    fgets(line, sizeof(line), stdin);
    
    // Simple JSON array parsing
    int nums[1000];
    int count = 0;
    char* token = strtok(line, "[,]");
    while (token != NULL) {
        if (strlen(token) > 0 && token[0] != '\n' && token[0] != ']') {
            nums[count++] = atoi(token);
        }
        token = strtok(NULL, "[,]");
    }
    
    int returnSize;
    int* result = solution(nums, count, &returnSize);
    
    printf("[");
    for (int i = 0; i < returnSize; i++) {
        if (i > 0) printf(",");
        printf("%d", result[i]);
    }
    printf("]\n");
    
    free(result);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

✓ Linear Growth

Space Complexity

⚡ Linearithmic Space

28.5K Views

Medium Frequency

~25 min Avg. Time

890 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