Codestin Search App

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.

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
✓ 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)	O(n! × n)	O(n²)	Try all possible grid dimensions and arrangements until one matches the graph

BFS Grid Construction (Optimal) — Algorithm Steps

Build adjacency list from edges
Identify corner nodes (nodes with exactly 2 neighbors)
Start BFS from any corner node
Place nodes level by level, maintaining grid adjacency
Determine grid dimensions during construction

Visualization

Tap to expand

Step-by-Step Walkthrough

Identify Corner

Find a node with degree 2 (corner of the grid)

Start BFS

Begin BFS from the corner, placing it at position (0,0)

Place Neighbors

Add connected nodes to adjacent grid positions

Expand Grid

Continue BFS, maintaining grid structure

Code -

solution.c — C

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

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

typedef struct {
    int node;
    int r, c;
} QueueItem;

typedef struct {
    QueueItem* items;
    int front, rear, capacity;
} Queue;

Queue* createQueue(int capacity) {
    Queue* q = (Queue*)malloc(sizeof(Queue));
    q->items = (QueueItem*)malloc(capacity * sizeof(QueueItem));
    q->front = q->rear = 0;
    q->capacity = capacity;
    return q;
}

void enqueue(Queue* q, int node, int r, int c) {
    q->items[q->rear] = (QueueItem){node, r, c};
    q->rear = (q->rear + 1) % q->capacity;
}

QueueItem dequeue(Queue* q) {
    QueueItem item = q->items[q->front];
    q->front = (q->front + 1) % q->capacity;
    return item;
}

int isEmpty(Queue* q) {
    return q->front == q->rear;
}

void addEdge(Node** adj, int u, int v) {
    Node* newNode = (Node*)malloc(sizeof(Node));
    newNode->val = v;
    newNode->next = adj[u];
    adj[u] = newNode;
}

int** constructGridLayout(int n, int** edges, int edgeCount, int* returnRows, int* returnCols) {
    if (n == 1) {
        int** result = (int**)malloc(sizeof(int*));
        result[0] = (int*)malloc(sizeof(int));
        result[0][0] = 0;
        *returnRows = 1;
        *returnCols = 1;
        return result;
    }
    
    Node** adj = (Node**)calloc(n, sizeof(Node*));
    int* degrees = (int*)calloc(n, sizeof(int));
    
    // Build adjacency list
    for (int i = 0; i < edgeCount; i++) {
        addEdge(adj, edges[i][0], edges[i][1]);
        addEdge(adj, edges[i][1], edges[i][0]);
        degrees[edges[i][0]]++;
        degrees[edges[i][1]]++;
    }
    
    // Find starting node
    int start = 0;
    for (int i = 0; i < n; i++) {
        if (degrees[i] <= 2) {
            start = i;
            if (degrees[i] == 2) break;
        }
    }
    
    if (degrees[start] == 1) {
        // Single row
        int* row = (int*)malloc(n * sizeof(int));
        int* visited = (int*)calloc(n, sizeof(int));
        int current = start;
        
        for (int i = 0; i < n; i++) {
            row[i] = current;
            visited[current] = 1;
            
            Node* temp = adj[current];
            while (temp) {
                if (!visited[temp->val]) {
                    current = temp->val;
                    break;
                }
                temp = temp->next;
            }
        }
        
        int** result = (int**)malloc(sizeof(int*));
        result[0] = row;
        *returnRows = 1;
        *returnCols = n;
        
        free(degrees);
        free(visited);
        return result;
    }
    
    // BFS construction for 2D grid
    Queue* queue = createQueue(n);
    int* visited = (int*)calloc(n, sizeof(int));
    int positions[n][2]; // Store positions for each node
    
    enqueue(queue, start, 0, 0);
    visited[start] = 1;
    positions[start][0] = 0;
    positions[start][1] = 0;
    
    int directions[4][2] = {{0, 1}, {0, -1}, {1, 0}, {-1, 0}};
    
    while (!isEmpty(queue)) {
        QueueItem curr = dequeue(queue);
        
        Node* temp = adj[curr.node];
        while (temp) {
            if (!visited[temp->val]) {
                for (int d = 0; d < 4; d++) {
                    int nr = curr.r + directions[d][0];
                    int nc = curr.c + directions[d][1];
                    
                    // Check if position is occupied
                    int occupied = 0;
                    for (int i = 0; i < n; i++) {
                        if (visited[i] && positions[i][0] == nr && positions[i][1] == nc) {
                            occupied = 1;
                            break;
                        }
                    }
                    
                    if (!occupied) {
                        positions[temp->val][0] = nr;
                        positions[temp->val][1] = nc;
                        visited[temp->val] = 1;
                        enqueue(queue, temp->val, nr, nc);
                        break;
                    }
                }
            }
            temp = temp->next;
        }
    }
    
    // Calculate bounds and build result
    int minR = positions[start][0], maxR = positions[start][0];
    int minC = positions[start][1], maxC = positions[start][1];
    
    for (int i = 0; i < n; i++) {
        if (visited[i]) {
            if (positions[i][0] < minR) minR = positions[i][0];
            if (positions[i][0] > maxR) maxR = positions[i][0];
            if (positions[i][1] < minC) minC = positions[i][1];
            if (positions[i][1] > maxC) maxC = positions[i][1];
        }
    }
    
    int rows = maxR - minR + 1;
    int cols = maxC - minC + 1;
    
    int** result = (int**)malloc(rows * sizeof(int*));
    for (int i = 0; i < rows; i++) {
        result[i] = (int*)malloc(cols * sizeof(int));
    }
    
    for (int i = 0; i < n; i++) {
        if (visited[i]) {
            int r = positions[i][0] - minR;
            int c = positions[i][1] - minC;
            result[r][c] = i;
        }
    }
    
    *returnRows = rows;
    *returnCols = cols;
    
    // Cleanup
    free(queue->items);
    free(queue);
    free(visited);
    free(degrees);
    
    return result;
}

int main() {
    // Parse input and call constructGridLayout
    return 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

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