Construct 2D Grid Matching Graph Layout - Practice Coding Problems

Construct 2D Grid Matching Graph Layout - Problem

Imagine you're an architect tasked with designing a floor plan where rooms must be arranged in a perfect rectangular grid, and hallways connect specific rooms as specified in your blueprint.

You're given a 2D integer array edges representing an undirected graph with n nodes, where edges[i] = [u_i, v_i] denotes a connection between nodes u_i and v_i.

Your challenge is to construct a 2D grid that satisfies these strict conditions:

The grid contains all nodes from 0 to n-1, with each node appearing exactly once
Two nodes are adjacent in the grid (horizontally or vertically) if and only if there's an edge between them
No diagonal connections are allowed - only up, down, left, right adjacency

The problem guarantees that such a valid 2D grid layout always exists for the given edges.

Goal: Return any valid 2D integer array representing this grid layout.

Input & Output

example_1.py — 2×2 Grid

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

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

💡 Note: This forms a 2×2 grid where node 0 connects to nodes 1 and 2, node 1 connects to nodes 0 and 3, node 2 connects to nodes 0 and 3, and node 3 connects to nodes 1 and 2. The adjacency perfectly matches a rectangular grid layout.

example_2.py — Single Row

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

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

💡 Note: This creates a linear path that forms a 1×4 grid (single row). Each node is connected only to its immediate neighbors in the sequence.

example_3.py — Single Node

$ Input: edges = []

› Output: [[0]]

💡 Note: With only one node and no edges, the result is a 1×1 grid containing just node 0.

Time & Space Complexity

Time Complexity

⏱️

O(n)

Each node is visited exactly once during BFS traversal

✓ Linear Growth

Space Complexity

O(n)

Space for adjacency list, visited set, and result grid

⚡ Linearithmic Space

Constraints

1 ≤ n ≤ 5 × 10⁴
0 ≤ edges.length ≤ 5 × 10⁴
edges[i].length == 2
0 ≤ u_i, v_i < n
u_i ≠ v_i
The given edges can always form a valid 2D grid

Asked in

The optimal solution uses BFS from a corner node to construct the grid layer by layer. Key insights: corner nodes have degree 2, end nodes have degree 1, and the grid structure naturally emerges through BFS traversal. Time complexity is O(n) with O(n) space.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Try All Grid Dimensions)	O(n! × n)	O(n²)	Try all possible grid dimensions and arrangements until one matches the graph
BFS Grid Construction (Optimal)	O(n)	O(n)	Use BFS from a corner node to build the grid layer by layer

Brute Force (Try All Grid Dimensions) — Algorithm Steps

Find all possible rectangular dimensions for n nodes
For each dimension (rows × cols), generate all permutations of node arrangements
For each arrangement, check if grid adjacency matches the edge list
Return the first valid arrangement found

Visualization

Tap to expand

Step-by-Step Walkthrough

Generate Dimensions

Find all possible rows × cols combinations

Try Permutations

For each dimension, try all node arrangements

Validate Grid

Check if adjacency matches the edge requirements

Code -

solution.c — C

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

typedef struct {
    int u, v;
} Edge;

int isValidGrid(int** grid, int rows, int cols, Edge* edges, int edgeCount) {
    // Create adjacency representation
    int maxNode = 0;
    for (int i = 0; i < edgeCount; i++) {
        if (edges[i].u > maxNode) maxNode = edges[i].u;
        if (edges[i].v > maxNode) maxNode = edges[i].v;
    }
    
    int** adjMatrix = (int**)calloc(maxNode + 1, sizeof(int*));
    for (int i = 0; i <= maxNode; i++) {
        adjMatrix[i] = (int*)calloc(maxNode + 1, sizeof(int));
    }
    
    for (int i = 0; i < edgeCount; i++) {
        adjMatrix[edges[i].u][edges[i].v] = 1;
        adjMatrix[edges[i].v][edges[i].u] = 1;
    }
    
    int dirs[4][2] = {{0, 1}, {0, -1}, {1, 0}, {-1, 0}};
    
    for (int r = 0; r < rows; r++) {
        for (int c = 0; c < cols; c++) {
            int curr = grid[r][c];
            for (int d = 0; d < 4; d++) {
                int nr = r + dirs[d][0], nc = c + dirs[d][1];
                if (nr >= 0 && nr < rows && nc >= 0 && nc < cols) {
                    int neighbor = grid[nr][nc];
                    if (!adjMatrix[curr][neighbor]) {
                        // Cleanup
                        for (int i = 0; i <= maxNode; i++) {
                            free(adjMatrix[i]);
                        }
                        free(adjMatrix);
                        return 0;
                    }
                }
            }
        }
    }
    
    // Cleanup
    for (int i = 0; i <= maxNode; i++) {
        free(adjMatrix[i]);
    }
    free(adjMatrix);
    
    return 1;
}

void swap(int* a, int* b) {
    int temp = *a;
    *a = *b;
    *b = temp;
}

int** constructGridLayout(int n, Edge* edges, int edgeCount, int* returnRows, int* returnCols) {
    int* nodes = (int*)malloc(n * sizeof(int));
    for (int i = 0; i < n; i++) {
        nodes[i] = i;
    }
    
    for (int rows = 1; rows <= n; rows++) {
        if (n % rows != 0) continue;
        int cols = n / rows;
        
        // Try all permutations (simplified - just try original order for demo)
        int** grid = (int**)malloc(rows * sizeof(int*));
        for (int r = 0; r < rows; r++) {
            grid[r] = (int*)malloc(cols * sizeof(int));
            for (int c = 0; c < cols; c++) {
                grid[r][c] = nodes[r * cols + c];
            }
        }
        
        if (isValidGrid(grid, rows, cols, edges, edgeCount)) {
            *returnRows = rows;
            *returnCols = cols;
            free(nodes);
            return grid;
        }
        
        // Free grid if not valid
        for (int r = 0; r < rows; r++) {
            free(grid[r]);
        }
        free(grid);
    }
    
    free(nodes);
    *returnRows = 0;
    *returnCols = 0;
    return NULL;
}

int main() {
    // Parse input and call constructGridLayout
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n! × n)

n! permutations to try, each taking O(n) time to validate

⚠ Quadratic Growth

Space Complexity

O(n²)

Storage for the grid and adjacency validation

⚠ Quadratic Space

Constraints

1 ≤ n ≤ 5 × 10⁴
0 ≤ edges.length ≤ 5 × 10⁴
edges[i].length == 2
0 ≤ u_i, v_i < n
u_i ≠ v_i
The given edges can always form a valid 2D grid

25.0K Views

Medium Frequency

~15 min Avg. Time

850 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

Time & Space Complexity

Related Problems

Constraints

Common Approaches

Brute Force (Try All Grid Dimensions) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler