Construct 2D Grid Matching Graph Layout

Construct 2D Grid Matching Graph Layout - Problem

You are given a 2D integer array edges representing an undirected graph having n nodes, where edges[i] = [ui, vi] denotes an edge between nodes ui and vi.

Construct a 2D grid that satisfies these conditions:

The grid contains all nodes from 0 to n - 1 in its cells, with each node appearing exactly once.
Two nodes should be in adjacent grid cells (horizontally or vertically) if and only if there is an edge between them in edges.

It is guaranteed that edges can form a 2D grid that satisfies the conditions.

Return a 2D integer array satisfying the conditions above. If there are multiple solutions, return any of them.

Input & Output

Example 1 — Basic 2×2 Grid

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

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

💡 Note: Nodes 0 and 3 are corners (degree 2). Starting from corner 0: build first row [0,1], then second row [2,3]. Adjacent cells match the edges: 0-1, 1-3, 3-2, 2-0.

Example 2 — Single Row

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

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

💡 Note: This forms a single row. Nodes 0 and 3 have degree 1 (endpoints). The path connects 0→1→2→3, so the grid is one row.

Example 3 — 1×3 Grid

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

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

💡 Note: Three nodes in a line. Nodes 0 and 2 are endpoints (degree 1), node 1 is in the middle (degree 2).

Constraints

1 ≤ edges.length ≤ 10⁴
edges[i].length == 2
0 ≤ u_i, v_i ≤ 10⁴
All the edges are distinct

Visualization

Tap to expand

Asked in

G Google 32 f Facebook 28 a Amazon 24 M Microsoft 18

The key insight is to use node degrees to identify grid structure: corners have degree 2, edges have degree 3, interior nodes have degree 4. Find a corner node, then systematically build the grid row by row using neighbor relationships. Best approach is corner-first construction with Time: O(n), Space: O(n).

Common Approaches

✓ Brute Force Backtracking

⏱️ Time: O(n!) Space: O(n²)

Generate all possible rectangular grids and for each arrangement, check if adjacent cells in the grid correspond to edges in the graph. Use backtracking to systematically try different node placements.

Corner-First Construction

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

Use the fact that corner nodes have degree 2, edge nodes have degree 3, and interior nodes have degree 4. Find a corner node, place it, then build the grid row by row using neighbor relationships.

Brute Force Backtracking — Algorithm Steps

Create adjacency list from edges
Try all possible grid dimensions
Use backtracking to place nodes
Verify each placement satisfies adjacency constraints

Visualization

Tap to expand

Step-by-Step Walkthrough

Build Graph

Create adjacency list from edges

Try Dimensions

Test different row×col combinations

Backtrack

Place nodes and verify constraints

Validate

Check if adjacent cells match edges

Code -

solution.c — C

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

#define MAX_NODES 100

typedef struct {
    int adj[MAX_NODES][MAX_NODES];
    int nodes[MAX_NODES];
    int nodeCount;
} Graph;

bool backtrack(int r, int c, int rows, int cols, int grid[][MAX_NODES], Graph* g, bool used[], int nodeIndex);
void parseEdges(char* line, int edges[][2], int* edgeCount);

int** solution(int** edges, int edgesSize, int* edgesColSize, int* returnSize, int** returnColumnSizes) {
    *returnSize = 0;
    if (edgesSize == 0) return NULL;
    
    Graph g = {0};
    bool nodeSet[MAX_NODES] = {0};
    
    // Build adjacency matrix and collect nodes
    for (int i = 0; i < edgesSize; i++) {
        int u = edges[i][0], v = edges[i][1];
        g.adj[u][v] = g.adj[v][u] = 1;
        if (!nodeSet[u]) {
            g.nodes[g.nodeCount++] = u;
            nodeSet[u] = true;
        }
        if (!nodeSet[v]) {
            g.nodes[g.nodeCount++] = v;
            nodeSet[v] = true;
        }
    }
    
    int n = g.nodeCount;
    if (n == 1) {
        *returnSize = 1;
        *returnColumnSizes = malloc(sizeof(int));
        (*returnColumnSizes)[0] = 1;
        int** result = malloc(sizeof(int*));
        result[0] = malloc(sizeof(int));
        result[0][0] = g.nodes[0];
        return result;
    }
    
    // Try different grid dimensions
    for (int rows = 1; rows <= n; rows++) {
        if (n % rows == 0) {
            int cols = n / rows;
            int grid[MAX_NODES][MAX_NODES];
            bool used[MAX_NODES] = {0};
            
            if (backtrack(0, 0, rows, cols, grid, &g, used, 0)) {
                // Construct result
                *returnSize = rows;
                *returnColumnSizes = malloc(rows * sizeof(int));
                int** result = malloc(rows * sizeof(int*));
                
                for (int i = 0; i < rows; i++) {
                    (*returnColumnSizes)[i] = cols;
                    result[i] = malloc(cols * sizeof(int));
                    for (int j = 0; j < cols; j++) {
                        result[i][j] = grid[i][j];
                    }
                }
                
                return result;
            }
        }
    }
    
    return NULL;
}

bool backtrack(int r, int c, int rows, int cols, int grid[][MAX_NODES], Graph* g, bool used[], int nodeIndex) {
    if (r == rows) return true;
    
    int nextR = (c + 1 < cols) ? r : r + 1;
    int nextC = (c + 1 < cols) ? c + 1 : 0;
    
    for (int i = 0; i < g->nodeCount; i++) {
        if (used[i]) continue;
        
        int node = g->nodes[i];
        bool valid = true;
        
        int directions[4][2] = {{-1, 0}, {1, 0}, {0, -1}, {0, 1}};
        for (int d = 0; d < 4; d++) {
            int nr = r + directions[d][0];
            int nc = c + directions[d][1];
            
            if (nr >= 0 && nr < rows && nc >= 0 && nc < cols) {
                if (nr < r || (nr == r && nc < c)) {
                    int neighbor = grid[nr][nc];
                    if (!g->adj[node][neighbor]) {
                        valid = false;
                        break;
                    }
                }
            }
        }
        
        if (valid) {
            grid[r][c] = node;
            used[i] = true;
            
            if (backtrack(nextR, nextC, rows, cols, grid, g, used, nodeIndex + 1)) {
                return true;
            }
            
            used[i] = false;
        }
    }
    
    return false;
}

int main() {
    char line[1000];
    fgets(line, sizeof(line), stdin);
    
    int edges[MAX_NODES][2];
    int edgeCount = 0;
    parseEdges(line, edges, &edgeCount);
    
    // Convert to required format
    int* edgeArray[MAX_NODES];
    for (int i = 0; i < edgeCount; i++) {
        edgeArray[i] = edges[i];
    }
    
    int returnSize;
    int* returnColumnSizes;
    int** result = solution(edgeArray, edgeCount, NULL, &returnSize, &returnColumnSizes);
    
    printf("[");
    for (int i = 0; i < returnSize; i++) {
        printf("[");
        for (int j = 0; j < returnColumnSizes[i]; j++) {
            printf("%d", result[i][j]);
            if (j < returnColumnSizes[i] - 1) printf(",");
        }
        printf("]");
        if (i < returnSize - 1) printf(",");
    }
    printf("]\n");
    
    return 0;
}

void parseEdges(char* line, int edges[][2], int* edgeCount) {
    *edgeCount = 0;
    char* ptr = line + 1; // skip '['
    
    while (*ptr && *ptr != ']') {
        if (*ptr == '[') {
            ptr++;
            edges[*edgeCount][0] = atoi(ptr);
            while (*ptr != ',') ptr++;
            ptr++;
            edges[*edgeCount][1] = atoi(ptr);
            while (*ptr != ']') ptr++;
            ptr++;
            (*edgeCount)++;
        }
        ptr++;
    }
}

Time & Space Complexity

Time Complexity

⏱️

O(n!)

Tries all possible permutations of nodes in grid positions

⚠ Quadratic Growth

Space Complexity

O(n²)

Stores adjacency list and grid, plus recursion stack

⚠ Quadratic Space

12.4K Views

Medium Frequency

~25 min Avg. Time

485 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

Constraints

Visualization

Related Problems

Common Approaches

Brute Force Backtracking — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler