# Solving Leetcode Interviews in Seconds with AI: Construct 2D Grid Matching Graph Layout


	# Introduction
	In this blog post, we will explore how to solve the LeetCode problem "3311" using AI. LeetCode is a popular platform for preparing for coding interviews, and with the help of AI tools like [Chatmagic](https://www.chatmagic.app), we can generate solutions quickly and efficiently - helping you pass the interviews and get the job offer without having to study for months.

	# Problem Statement
	> 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.   Example 1:  Input: n = 4, edges = [[0,1],[0,2],[1,3],[2,3]] Output: [[3,1],[2,0]] Explanation:   Example 2:  Input: n = 5, edges = [[0,1],[1,3],[2,3],[2,4]] Output: [[4,2,3,1,0]] Explanation:   Example 3:  Input: n = 9, edges = [[0,1],[0,4],[0,5],[1,7],[2,3],[2,4],[2,5],[3,6],[4,6],[4,7],[6,8],[7,8]] Output: [[8,6,3],[7,4,2],[1,0,5]] Explanation:     Constraints:  2 <= n <= 5 * 104 1 <= edges.length <= 105 edges[i] = [ui, vi] 0 <= ui < vi < n All the edges are distinct. The input is generated such that edges can form a 2D grid that satisfies the conditions.  

	# Explanation
	Here's a solution to the problem:

*   **High-Level Approach:**
    *   Find a corner node by checking the degree of each node. Corner nodes have a degree of 2.
    *   Perform a Depth-First Search (DFS) starting from the corner node to trace the grid.  Maintain the dimensions of the grid dynamically during the DFS.
    *   Reconstruct the grid based on the traced path and dimensions.

*   **Complexity:**
    *   Runtime: O(n + m), where n is the number of nodes and m is the number of edges.
    *   Storage: O(n + m)

	
	# Code
	```python
	def find_grid(n: int, edges: list[list[int]]) -> list[list[int]]:
    """
    Constructs a 2D grid from a given set of edges.

    Args:
        n: The number of nodes in the graph.
        edges: A list of edges, where each edge is a list of two nodes.

    Returns:
        A 2D integer array representing the grid.
    """

    graph = [[] for _ in range(n)]
    for u, v in edges:
        graph[u].append(v)
        graph[v].append(u)

    corner = -1
    for i in range(n):
        if len(graph[i]) == 2:
            corner = i
            break

    path = []
    visited = [False] * n

    def dfs(node):
        visited[node] = True
        path.append(node)
        for neighbor in graph[node]:
            if not visited[neighbor]:
                dfs(neighbor)

    dfs(corner)

    # Determine grid dimensions
    rows, cols = 0, 0
    rows_count = 1
    cols_count = 1

    for i in range(1, len(path)):
        neighbors_count = 0
        for neighbor in graph[path[i-1]]:
            if neighbor == path[i]:
                neighbors_count += 1
        
        if neighbors_count > 0:
           is_new_row = False
           is_new_col = False
           
           
           
           neighbor_1_index = i
           if i > 1:
               neighbor_2_candidates = [path[i-2]]
           else:
               neighbor_2_candidates = []
           
           neighbors = graph[path[i-1]]
           
           has_other_neighbor = False
           for neighbor in neighbors:
               if neighbor != path[i] and (i == 1 or neighbor != path[i-2]):
                    has_other_neighbor = True
           if has_other_neighbor:
               rows_count +=1
        
    
    num_edges = len(edges)
    
    degrees = [len(graph[i]) for i in range(n)]
    
    degrees_count_2 = degrees.count(2)
    degrees_count_3 = degrees.count(3)
    degrees_count_4 = degrees.count(4)
    
    if degrees_count_2 == 4 and degrees_count_3 == 0 and degrees_count_4 == 0:
        rows = int(n**0.5)
        cols = int(n**0.5)
    elif degrees_count_2 == 2:
        rows = 1
        cols = n
        for x in range(n):
            if len(graph[x]) > 2:
                rows = int(n/(n - degrees_count_2))
                cols = int(n/rows)
    elif degrees_count_2 == 3 and degrees_count_3 != 0:
         rows = int(n/(n - degrees_count_2 + 1))
         cols = int(n/rows)
    else:
         rows = int(n/(n - degrees_count_2 + 1))
         cols = int(n/rows)
           
    
    
    grid = [[0] * cols for _ in range(rows)]
    node_to_coord = {}
    
    curr_row, curr_col = 0,0
    node_to_coord[path[0]] = (0,0)
    grid[0][0] = path[0]

    
    for i in range(1, len(path)):
      
        prev_row, prev_col = node_to_coord[path[i-1]]
       
        
        placed = False
        
        if prev_row > 0 and grid[prev_row-1][prev_col] == 0 and path[i] in graph[path[i-1]]:
            grid[prev_row-1][prev_col] = path[i]
            node_to_coord[path[i]] = (prev_row-1, prev_col)
            placed = True
        elif prev_row < rows -1 and grid[prev_row+1][prev_col] == 0 and path[i] in graph[path[i-1]]:
            grid[prev_row+1][prev_col] = path[i]
            node_to_coord[path[i]] = (prev_row+1, prev_col)
            placed = True
        elif prev_col > 0 and grid[prev_row][prev_col-1] == 0 and path[i] in graph[path[i-1]]:
            grid[prev_row][prev_col-1] = path[i]
            node_to_coord[path[i]] = (prev_row, prev_col-1)
            placed = True
        elif prev_col < cols - 1 and grid[prev_row][prev_col+1] == 0 and path[i] in graph[path[i-1]]:
            grid[prev_row][prev_col+1] = path[i]
            node_to_coord[path[i]] = (prev_row, prev_col+1)
            placed = True
    

    return grid
	```