Build a Matrix With Conditions

Build a Matrix With Conditions - Problem

You are given a positive integer k. You are also given:

a 2D integer array rowConditions of size n where rowConditions[i] = [above_i, below_i], and
a 2D integer array colConditions of size m where colConditions[i] = [left_i, right_i].

The two arrays contain integers from 1 to k.

You have to build a k x k matrix that contains each of the numbers from 1 to k exactly once. The remaining cells should have the value 0.

The matrix should also satisfy the following conditions:

The number above_i should appear in a row that is strictly above the row at which the number below_i appears for all i from 0 to n - 1.
The number left_i should appear in a column that is strictly left of the column at which the number right_i appears for all i from 0 to m - 1.

Return any matrix that satisfies the conditions. If no answer exists, return an empty matrix.

Input & Output

Example 1 — Basic Case

$ Input: k = 3, rowConditions = [[1,2],[3,2]], colConditions = [[2,1],[3,2]]

› Output: [[3,0,0],[2,0,0],[1,0,0]]

💡 Note: Number 1 must be above 2, and 3 must be above 2 (row constraints). Number 2 must be left of 1, and 3 must be left of 2 (column constraints). One valid arrangement places 1 at (2,0), 2 at (1,0), and 3 at (0,0).

Example 2 — No Solution

$ Input: k = 3, rowConditions = [[1,2],[2,1]], colConditions = []

› Output: []

💡 Note: Impossible constraints: 1 must be above 2 AND 2 must be above 1. This creates a cycle, so no valid matrix exists.

Example 3 — Single Element

$ Input: k = 1, rowConditions = [], colConditions = []

› Output: [[1]]

💡 Note: Only one number to place with no constraints, so place 1 at position (0,0).

Constraints

2 ≤ k ≤ 400
1 ≤ rowConditions.length, colConditions.length ≤ 10⁴
rowConditions[i] = [above_i, below_i]
colConditions[i] = [left_i, right_i]
1 ≤ above_i, below_i, left_i, right_i ≤ k

Visualization

Tap to expand

Asked in

G Google 35 f Facebook 28 a Amazon 22 M Microsoft 18

The key insight is to convert positioning constraints into directed graphs and use topological sorting to find valid orderings. Best approach uses topological sort to determine row and column orderings separately, then construct the matrix. Time: O(k + n + m), Space: O(k + n + m)

Common Approaches

✓ Binary Search

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

Brute Force

⏱️ Time: O(k! × k²) Space: O(k²)

Generate all possible k×k matrices with numbers 1 to k placed exactly once, then check if each satisfies all row and column conditions. This involves trying k! different arrangements.

Topological Sort

⏱️ Time: O(k + n + m) Space: O(k + n + m)

Convert row and column constraints into directed graphs, then use topological sort to find valid orderings. If both orderings exist without cycles, construct the matrix by placing numbers according to these orderings.

Algorithm Steps — Algorithm Steps

Code -

solution.c — C

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

int triangular(int k) {
    return k * (k + 1) / 2;
}

long long maxBoxesWithFloor(int floorBoxes) {
    // Given floorBoxes on floor, what's the max total boxes we can fit?
    // Find largest triangular number <= floorBoxes
    int level = 1;
    while (triangular(level) <= floorBoxes) {
        level++;
    }
    level--;
    
    if (level == 0) {
        return floorBoxes;
    }
    
    // Build pyramid with this base level
    long long total = 0;
    int currentLevel = level;
    while (currentLevel > 0) {
        total += triangular(currentLevel);
        currentLevel--;
    }
    
    // Add any remaining floor boxes that couldn't form a complete level
    int remaining = floorBoxes - triangular(level);
    return total + remaining;
}

int solution(int n) {
    if (n == 1) return 1;
    
    int left = 1, right = n;
    int result = n;
    
    while (left <= right) {
        int mid = (left + right) / 2;
        if (maxBoxesWithFloor(mid) >= n) {
            result = mid;
            right = mid - 1;
        } else {
            left = mid + 1;
        }
    }
    
    return result;
}

int main() {
    int n;
    scanf("%d", &n);
    int result = solution(n);
    printf("%d\n", result);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

✓ Linear Growth

Space Complexity

✓ Linear Space

28.4K Views

Medium Frequency

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