Build a Matrix With Conditions - Practice Coding Problems

Build a Matrix With Conditions - Problem

Imagine you're organizing a seating arrangement where specific people must sit in particular positions relative to each other! 🪑

You are given a positive integer k and need to build a k × k matrix containing each number from 1 to k exactly once, with remaining cells filled with 0.

You must satisfy two types of ordering constraints:

Row Conditions: rowConditions[i] = [above_i, below_i] means above_i must appear in a row strictly above below_i
Column Conditions: colConditions[i] = [left_i, right_i] means left_i must appear in a column strictly to the left of right_i

Goal: Return any valid matrix that satisfies all conditions, or an empty matrix if impossible.

This is essentially a 2D topological sorting problem! 🎯

Input & Output

example_1.py — Basic Case

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

› Output: [[3,0,0],[0,0,1],[0,2,0]] (or any valid arrangement)

💡 Note: Number 1 must be above 2, and 3 must be above 2 in rows. Number 2 must be left of 1, and 3 must be left of 2 in columns. The output satisfies: row order (3,1,2) and column order (2,1,3).

example_2.py — Impossible Case

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

› Output: []

💡 Note: Row conditions create a cycle: 1→2→3→1, making it impossible to arrange numbers in rows. When there's a cycle in dependencies, no valid arrangement exists.

example_3.py — No Constraints

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

› Output: [[1,0],[0,2]] (or any valid arrangement)

💡 Note: With no constraints, any arrangement of numbers 1 and 2 in the 2×2 matrix is valid. Each number appears exactly once with zeros filling remaining positions.

Visualization

Tap to expand

Understanding the Visualization

Analyze Dependencies

Identify which numbers must come before others in rows and columns

Check for Conflicts

Use topological sorting to detect impossible circular dependencies

Determine Orderings

Find valid sequences for both row positions and column positions

Place Numbers

Position each number at the intersection of its assigned row and column

Key Takeaway

🎯 Key Insight: This problem cleverly combines two independent topological sorting problems - one for rows and one for columns. The beauty is recognizing that 2D constraints can be decomposed into separate 1D ordering problems, then recombined into the final matrix solution.

Time & Space Complexity

Time Complexity

⏱️

O(k + n + m)

k nodes, n row conditions, m column conditions - each processed once

✓ Linear Growth

Space Complexity

O(k + n + m)

Space for graphs, queues, and result arrays

⚡ Linearithmic Space

Constraints

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

Asked in

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

The optimal solution uses topological sorting to solve this as two separate 1D ordering problems. First, we perform topological sort on row conditions to get valid row ordering, then on column conditions for column ordering. If either has a cycle (impossible ordering), we return empty matrix. Finally, we place each number at the intersection of its computed row and column positions. Time complexity is O(k + n + m) where n and m are the number of conditions.

Common Approaches

Approach	Time	Space	Notes
✓ Topological Sort (Optimal)	O(k + n + m)	O(k + n + m)	Use topological sorting to find valid row and column orderings efficiently
Brute Force (Try All Arrangements)	O(k! × k²)	O(k²)	Generate all possible matrix arrangements and check constraints

Topological Sort (Optimal) — Algorithm Steps

Build directed graphs from row and column conditions
Perform topological sort using Kahn's algorithm for both graphs
Check if both sorts are valid (no cycles detected)
Create mapping from each number to its row and column position
Construct the final matrix by placing numbers at computed positions

Visualization

Tap to expand

Step-by-Step Walkthrough

Build Dependency Graphs

Create directed graphs from row and column conditions

Topological Sort

Use Kahn's algorithm to find valid orderings

Detect Cycles

If sort fails, return empty matrix (impossible)

Place Numbers

Position each number at intersection of its row/column

Code -

solution.c — C

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

typedef struct Node {
    int val;
    struct Node* next;
} Node;

typedef struct {
    Node* head;
    Node* tail;
} Queue;

void enqueue(Queue* q, int val) {
    Node* node = (Node*)malloc(sizeof(Node));
    node->val = val;
    node->next = NULL;
    if (!q->tail) {
        q->head = q->tail = node;
    } else {
        q->tail->next = node;
        q->tail = node;
    }
}

int dequeue(Queue* q) {
    if (!q->head) return -1;
    Node* node = q->head;
    int val = node->val;
    q->head = q->head->next;
    if (!q->head) q->tail = NULL;
    free(node);
    return val;
}

bool isEmpty(Queue* q) {
    return q->head == NULL;
}

int* topologicalSort(int k, int** conditions, int conditionsSize, int* returnSize) {
    int** graph = (int**)calloc(k + 1, sizeof(int*));
    int* graphSize = (int*)calloc(k + 1, sizeof(int));
    int* indegree = (int*)calloc(k + 1, sizeof(int));
    
    // Build graph
    for (int i = 0; i < conditionsSize; i++) {
        int u = conditions[i][0], v = conditions[i][1];
        graph[u] = (int*)realloc(graph[u], (graphSize[u] + 1) * sizeof(int));
        graph[u][graphSize[u]++] = v;
        indegree[v]++;
    }
    
    Queue queue = {NULL, NULL};
    for (int i = 1; i <= k; i++) {
        if (indegree[i] == 0) {
            enqueue(&queue, i);
        }
    }
    
    int* result = (int*)malloc(k * sizeof(int));
    int count = 0;
    
    while (!isEmpty(&queue)) {
        int node = dequeue(&queue);
        result[count++] = node;
        
        for (int i = 0; i < graphSize[node]; i++) {
            int neighbor = graph[node][i];
            indegree[neighbor]--;
            if (indegree[neighbor] == 0) {
                enqueue(&queue, neighbor);
            }
        }
    }
    
    // Cleanup
    for (int i = 1; i <= k; i++) {
        if (graph[i]) free(graph[i]);
    }
    free(graph);
    free(graphSize);
    free(indegree);
    
    *returnSize = (count == k) ? k : 0;
    if (*returnSize == 0) {
        free(result);
        return NULL;
    }
    return result;
}

int** buildMatrix(int k, int** rowConditions, int rowConditionsSize, int* rowConditionsColSize,
                  int** colConditions, int colConditionsSize, int* colConditionsColSize,
                  int* returnSize, int** returnColumnSizes) {
    int rowOrderSize, colOrderSize;
    int* rowOrder = topologicalSort(k, rowConditions, rowConditionsSize, &rowOrderSize);
    int* colOrder = topologicalSort(k, colConditions, colConditionsSize, &colOrderSize);
    
    if (rowOrderSize == 0 || colOrderSize == 0) {
        *returnSize = 0;
        *returnColumnSizes = NULL;
        if (rowOrder) free(rowOrder);
        if (colOrder) free(colOrder);
        return NULL;
    }
    
    // Create position mappings
    int* rowPos = (int*)malloc((k + 1) * sizeof(int));
    int* colPos = (int*)malloc((k + 1) * sizeof(int));
    
    for (int i = 0; i < k; i++) {
        rowPos[rowOrder[i]] = i;
        colPos[colOrder[i]] = i;
    }
    
    // Build matrix
    int** matrix = (int**)malloc(k * sizeof(int*));
    *returnColumnSizes = (int*)malloc(k * sizeof(int));
    
    for (int i = 0; i < k; i++) {
        matrix[i] = (int*)calloc(k, sizeof(int));
        (*returnColumnSizes)[i] = k;
    }
    
    for (int num = 1; num <= k; num++) {
        matrix[rowPos[num]][colPos[num]] = num;
    }
    
    *returnSize = k;
    
    // Cleanup
    free(rowOrder);
    free(colOrder);
    free(rowPos);
    free(colPos);
    
    return matrix;
}

Time & Space Complexity

Time Complexity

⏱️

O(k + n + m)

k nodes, n row conditions, m column conditions - each processed once

✓ Linear Growth

Space Complexity

O(k + n + m)

Space for graphs, queues, and result arrays

⚡ Linearithmic Space

Constraints

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

52.4K Views

Medium Frequency

~25 min Avg. Time

1.8K 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

Visualization

Time & Space Complexity

Related Problems

Constraints

Common Approaches

Topological Sort (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler