Depth-First Search DFS: Complete Search Algorithm Guide

1. Introduction and Core Concepts

Depth-first search dfs is one of the most fundamental graph traversal algorithms in computer science, forming the backbone of countless applications from web crawling to dependency resolution. At its core, depth-first search dfs is a strategy for systematically exploring a graph or tree data structure by diving as deep as possible along each branch before backtracking. Unlike breadth-first approaches that explore level by level, depth-first search dfs prioritizes depth over breadth, following a path to its end before considering alternatives.

The elegance of depth-first search dfs lies in its simplicity and its natural recursive structure. The algorithm can be conceptualized as exploring a maze by always taking the first unexplored corridor you encounter, marking your path, and backtracking only when you hit a dead end. This "go deep first" philosophy makes depth-first search dfs exceptionally intuitive to implement using either recursion and the call stack or an explicit stack data structure. The algorithm's behavior mirrors how a human might explore a file system — opening a folder, then a subfolder, then a sub-subfolder, until there are no more subfolders to explore before returning to try another branch.

Understanding depth-first search dfs is essential for every software engineer because it is not merely a standalone algorithm but a paradigm that underpins more complex algorithms. Topological sorting, strongly connected components, cycle detection, solving puzzles like Sudoku and N-Queens, and finding connected components all rely on depth-first search dfs as a subroutine. Its importance in technical interviews, competitive programming, and production systems cannot be overstated. Mastering depth-first search dfs provides a mental model for backtracking, recursive problem solving, and graph theory that extends far beyond the algorithm itself.

Why Depth-First Search Matters

Depth-first search dfs matters because graphs are ubiquitous in modern computing. Social networks, road maps, the World Wide Web, dependency graphs in package managers, state spaces in artificial intelligence, and control flow graphs in compilers are all naturally modeled as graphs. Efficiently traversing these structures is a prerequisite for answering critical questions: Is there a path between two nodes? Are all nodes reachable? Does the graph contain a cycle? Depth-first search dfs answers these questions with minimal memory overhead compared to its breadth-first counterpart.

Another reason depth-first search dfs is so valuable is its memory efficiency for deep, narrow graphs. While breadth-first search must store an entire frontier of nodes at a given depth, depth-first search dfs only needs to store the current path from the root to the leaf plus unexplored siblings. This makes it the preferred choice when the search space is vast and memory is constrained, such as in game tree search or exhaustive combinatorial search where the branching factor is large.

2. How It Works

Depth-first search dfs operates on a simple but powerful principle: from a starting node, repeatedly move to an unvisited adjacent node, marking nodes as visited to avoid revisiting them and to prevent infinite loops in cyclic graphs. When no unvisited neighbors remain, the algorithm backtracks to the most recent node that still has unexplored neighbors. This process continues until all nodes reachable from the starting node have been visited. The algorithm's use of a Last-In-First-Out (LIFO) stack — whether implicit via recursion or explicit via an iterative implementation — is what enforces the depth-first order.

The mechanism can be broken down into three core states for each node: unvisited, visiting, and visited. In the classic recursive formulation, a node is marked as visiting when the recursive call begins and as visited when all its descendants have been fully explored. This three-color marking (often called white, gray, and black) is crucial for advanced applications like cycle detection in directed graphs and for computing discovery and finish times. Discovery time records when a node is first encountered, while finish time records when its entire subtree has been explored, enabling topological sorting and classification of edges into tree, back, forward, and cross edges.

Conceptually, depth-first search dfs traverses the graph by building a depth-first forest. For an undirected connected graph, this forest is a single depth-first tree that spans all vertices. For a disconnected graph or a directed graph, repeated depth-first searches from unvisited nodes produce a forest of trees. The parent pointers established during traversal define this forest, and the structure of the forest reveals deep properties of the original graph. For example, in an undirected graph, every edge is either a tree edge or a back edge, which directly leads to algorithms for finding articulation points and bridges.

The Role of the Stack

The stack is the defining data structure of depth-first search dfs. In the recursive version, the system call stack automatically handles backtracking: each recursive call pushes a new frame, and returning from the call pops the frame, effectively moving back to the parent node. In the iterative version, you manually maintain a stack of nodes to visit. The order in which neighbors are pushed onto the stack determines the traversal order, which is why implementations often push neighbors in reverse order to visit them in the natural left-to-right order.

It is important to distinguish depth-first search dfs from simple backtracking, although they are closely related. Depth-first search dfs is the traversal strategy, while backtracking is a general algorithmic technique that uses depth-first search dfs to prune search spaces. When depth-first search dfs is used for backtracking, the algorithm not only marks nodes as visited but also undoes choices (un-marks or restores state) upon backtracking, allowing it to explore all possible configurations, such as in constraint satisfaction problems.

3. Implementation

Implementing depth-first search dfs in Python can be done recursively or iteratively, each with distinct trade-offs. The recursive implementation is more concise and mirrors the mathematical definition, while the iterative implementation avoids recursion depth limits and gives you explicit control over the stack. Both approaches require an adjacency list representation for efficiency and a visited set or array to prevent revisiting nodes.

Below are four production-quality implementations covering the most common use cases. Note that all code examples use an adjacency list, which is optimal for sparse graphs encountered in most real-world scenarios. Each implementation includes detailed comments explaining the purpose of every step and handles edge cases such as disconnected graphs and self-loops.

Recursive DFS for Graph Traversal

from collections import defaultdict

def dfs_recursive(graph, start, visited=None):
    """
    Recursive Depth-First Search traversal.
    graph: dict mapping node -> list of neighbors (adjacency list)
    start: starting node
    visited: set to track visited nodes
    Returns: list of nodes in DFS order
    """
    if visited is None:
        visited = set()
    
    # Mark current node as visited
    visited.add(start)
    order = [start]
    
    # Explore each unvisited neighbor depth-first
    for neighbor in graph.get(start, []):
        if neighbor not in visited:
            # Recurse depth-first into neighbor's subtree
            order.extend(dfs_recursive(graph, neighbor, visited))
    
    return order

# Example usage:
# graph = {'A': ['B', 'C'], 'B': ['D', 'E'], 'C': ['F'], 'D': [], 'E': [], 'F': []}
# print(dfs_recursive(graph, 'A'))  # Output: ['A', 'B', 'D', 'E', 'C', 'F']

Iterative DFS Using Explicit Stack

def dfs_iterative(graph, start):
    """
    Iterative Depth-First Search using explicit stack.
    Avoids recursion limit issues for deep graphs.
    graph: adjacency list dict
    start: starting node
    Returns: list of nodes in DFS order
    """
    visited = set()
    stack = [start]
    order = []
    
    while stack:
        node = stack.pop()  # LIFO - pop from top for depth-first behavior
        
        if node not in visited:
            visited.add(node)
            order.append(node)
            
            # Push neighbors in reverse order to visit in original order
            # Using reversed() ensures left-to-right traversal
            for neighbor in reversed(graph.get(node, [])):
                if neighbor not in visited:
                    stack.append(neighbor)
    
    return order

def dfs_iterative_with_parent(graph, start):
    """
    Iterative DFS that also tracks parent pointers and discovery order.
    Useful for path reconstruction and building DFS tree.
    """
    visited = set()
    parent = {start: None}
    stack = [start]
    discovery_time = {}
    time = 0
    
    while stack:
        node = stack.pop()
        if node not in visited:
            visited.add(node)
            discovery_time[node] = time
            time += 1
            for neighbor in reversed(graph.get(node, [])):
                if neighbor not in visited:
                    parent[neighbor] = node
                    stack.append(neighbor)
    
    return parent, discovery_time

DFS for Grid and Matrix Problems

def dfs_grid(grid, row, col, visited):
    """
    DFS on a 2D grid (e.g., number of islands, flood fill).
    grid: 2D list where '1' is land / traversable, '0' is water / blocked
    row, col: current position
    visited: 2D boolean matrix or set of (r,c) tuples
    """
    rows = len(grid)
    cols = len(grid[0]) if rows > 0 else 0
    
    # Boundary checks and visited / water checks
    if row < 0 or row >= rows or col < 0 or col >= cols:
        return
    if (row, col) in visited or grid[row][col] == '0':
        return
    
    visited.add((row, col))
    
    # Explore 4-directionally (up, down, left, right)
    # For 8-directional, add diagonals
    dfs_grid(grid, row + 1, col, visited)  # down
    dfs_grid(grid, row - 1, col, visited)  # up
    dfs_grid(grid, row, col + 1, visited)  # right
    dfs_grid(grid, row, col - 1, visited)  # left

def count_islands(grid):
    """Count number of islands using DFS."""
    if not grid:
        return 0
    visited = set()
    islands = 0
    for r in range(len(grid)):
        for c in range(len(grid[0])):
            if grid[r][c] == '1' and (r, c) not in visited:
                dfs_grid(grid, r, c, visited)
                islands += 1
    return islands

DFS with Cycle Detection and Topological Sort

def dfs_cycle_detection_and_topo(graph):
    """
    DFS with three-color marking for cycle detection and topological sort.
    graph: adjacency list for directed graph
    Returns: (has_cycle, topo_order)
    WHITE = 0 (unvisited), GRAY = 1 (visiting), BLACK = 2 (finished)
    """
    WHITE, GRAY, BLACK = 0, 1, 2
    color = {node: WHITE for node in graph}
    topo_order = []
    has_cycle = False
    
    def dfs_visit(node):
        nonlocal has_cycle
        color[node] = GRAY
        
        for neighbor in graph.get(node, []):
            if color.get(neighbor, WHITE) == GRAY:
                # Back edge found -> cycle exists
                has_cycle = True
                return
            if color.get(neighbor, WHITE) == WHITE:
                dfs_visit(neighbor)
                if has_cycle:
                    return
        
        color[node] = BLACK
        topo_order.append(node)  # Add after exploring descendants
    
    for node in list(graph.keys()):
        if color[node] == WHITE:
            dfs_visit(node)
            if has_cycle:
                break
    
    topo_order.reverse()  # Reverse finish order for topological sort
    return has_cycle, topo_order

# Example: Course schedule
# graph = {'A': ['B', 'C'], 'B': ['D'], 'C': ['D'], 'D': []}
# has_cycle, order = dfs_cycle_detection_and_topo(graph)
# print(order)  # Valid topo order e.g., ['A', 'C', 'B', 'D']

4. Step-by-Step Example

To solidify understanding, let us walk through depth-first search dfs on a concrete undirected graph. Consider the following graph with six nodes labeled A through F. The adjacency list is: A connects to B and C, B connects to A, D, and E, C connects to A and F, D connects to B, E connects to B and F, and F connects to C and E. We will start depth-first search dfs from node A and assume neighbors are visited in alphabetical order.

We maintain a visited set and a stack that represents the recursion path. The algorithm begins by marking A as visited. From A, the first unvisited neighbor is B, so we move to B and mark it visited. The current path is A -> B. From B, the first unvisited neighbor is D, so we move to D. Path is now A -> B -> D. D has only one neighbor, B, which is already visited, so D is a dead end. We backtrack to B. This backtracking is automatic in recursion when the loop over D's neighbors completes.

Back at B, the next unvisited neighbor is E, so we traverse to E and mark it visited. Path becomes A -> B -> E. From E, the unvisited neighbor is F (B is already visited), so we move to F. Path is A -> B -> E -> F. From F, neighbors are C and E. E is visited, but C is unvisited, so we move to C. Path is A -> B -> E -> F -> C. From C, neighbors are A and F, both visited, so C is a dead end. We backtrack to F, then to E, then to B, then to A. At A, the next neighbor after B is C, but C is now visited, so traversal is complete.

Traversal Order and DFS Tree

The final visitation order is A, B, D, E, F, C. The parent pointers established are: parent of B is A, parent of D is B, parent of E is B, parent of F is E, and parent of C is F. This forms a depth-first tree that is essentially a single chain with a small branch to D. If we had used an iterative implementation with a stack, the order would be identical provided we push neighbors in reverse alphabetical order. Changing the neighbor order would yield a different but equally valid depth-first traversal, such as A, C, F, E, B, D if we had prioritized C over B at the start.

Notice how depth-first search dfs explored the entire B-E-F-C chain before ever returning to consider A's other child C directly. This is the hallmark of depth-first behavior. If this were breadth-first search, the order would have been A, B, C, D, E, F — level by level. The discovery and finish times for this traversal would be: A discovered at time 1 and finished at time 12, B at 2/11, D at 3/4, E at 5/10, F at 6/9, and C at 7/8, illustrating the nested parenthesis structure where each node's interval fully contains its descendants' intervals.

5. Complexity Analysis

The time and space complexity of depth-first search dfs depends heavily on the graph representation and whether the graph is a tree or a general graph. In the most common case — an adjacency list representation — depth-first search dfs runs in linear time relative to the size of the graph. Each vertex is visited exactly once, and each edge is examined at most twice in an undirected graph (once from each endpoint) or once in a directed graph. This yields a time complexity of O(V + E), where V is the number of vertices and E is the number of edges, which is optimal since any traversal must at least look at every vertex and edge.

When an adjacency matrix is used, the complexity degrades to O(V²) because to find all neighbors of a vertex, the algorithm must scan an entire row of the matrix of size V, and this is done for each of the V vertices. For dense graphs where E is close to V², the difference between O(V + E) and O(V²) is negligible, but for sparse graphs — which dominate real-world applications like social networks and web graphs — the adjacency list is dramatically more efficient. For trees, where E = V - 1, the complexity simplifies to O(V).

Space complexity is O(V) in all cases for the visited set and the stack. In the worst case of a path graph or a highly skewed tree, the recursion stack or explicit stack will hold V frames simultaneously. In the best case of a star graph where the start node connects directly to all other nodes, the stack depth is O(1) after the initial expansion, but the visited set still requires O(V) space. Recursive implementations also incur hidden overhead from Python's call stack, which has a default recursion limit of around 1000, making iterative versions mandatory for deep graphs with more than 1000 nodes in a single path.

Best, Average, and Worst Case Nuances

Unlike sorting algorithms where best, average, and worst cases differ significantly, depth-first search dfs has the same asymptotic complexity in all cases because it must visit every reachable vertex and explore every outgoing edge from those vertices regardless of graph structure. The only variation is in constant factors and stack depth. The worst-case stack depth occurs in a linear chain, while the best-case stack depth occurs in a shallow, bushy graph. However, both still visit all nodes.

For disconnected graphs, the algorithm must be wrapped in an outer loop that initiates depth-first search dfs from every unvisited node to ensure full coverage. This does not change the overall O(V + E) complexity, as each vertex and edge is still processed exactly once across all DFS trees in the forest. The space remains O(V) because the visited set is shared across all iterations.

6. Variations and Optimizations

While the classic depth-first search dfs is powerful, several variations adapt it to specific constraints and improve its behavior in practice. The most important variant is Iterative Deepening Depth-First Search (IDDFS), which combines the memory efficiency of depth-first search dfs with the optimality and completeness of breadth-first search for unweighted shortest paths. IDDFS repeatedly runs depth-limited DFS with increasing depth limits until the goal is found, yielding O(b^d) time where b is branching factor and d is depth, but only O(d) space.

Another critical optimization is early termination and pruning. In many search problems, you are not interested in traversing the entire graph but in finding a specific target node or path. Depth-first search dfs can be modified to return immediately upon finding the goal, which in the best case can be dramatically faster than full traversal. When combined with heuristics to order neighbors by promise (e.g., exploring more promising branches first), this can lead to exponential speedups in practice, forming the basis of backtracking algorithms for SAT solving and constraint programming.

For very large graphs that do not fit in memory, external memory DFS and iterative deepening are used to limit RAM usage. Additionally, parallel DFS can be employed on multi-core systems by exploring different subtrees concurrently, though careful load balancing is required because subtree sizes can vary wildly. In Python, recursion depth optimization via sys.setrecursionlimit and using iterative stacks are practical optimizations to avoid stack overflow on deep graphs.

Advanced Variants

Depth-Limited DFS imposes a maximum depth L and refuses to explore beyond that depth, which is useful for avoiding infinite loops in graphs with cycles or infinite state spaces. Depth-first search dfs with memoization (also called DFS + DP) caches results for visited states to avoid recomputing overlapping subproblems, which is essential for problems like counting paths in a DAG or solving games with repeated states. This transforms exponential brute force into polynomial time.

Another sophisticated variant is DFS with discovery and finish timestamps, which enables classification of edges and applications like finding strongly connected components via Kosaraju's or Tarjan's algorithm. Both algorithms run two passes of depth-first search dfs and rely on the finish order from the first pass. Similarly, DFS can be augmented to find articulation points and bridges in undirected graphs by tracking low-link values during traversal, all in O(V + E) time.

• IDDFS: Optimal for large search spaces with unknown solution depth; uses O(d) memory.
• Backtracking DFS: Explores all possibilities with pruning; essential for N-Queens, Sudoku, and permutations.
• DFS with Memoization: Caches visited states to handle overlapping subproblems efficiently.
• Bidirectional DFS: Runs DFS from both start and goal simultaneously for faster path finding in some topologies.

7. Real-World Applications

Depth-first search dfs is not an academic curiosity; it powers critical infrastructure across the technology stack. One of its most visible applications is web crawling and indexing. Search engines use depth-first search dfs strategies to follow hyperlinks deep into a website's structure before moving to sibling pages, which helps discover deeply nested content and efficiently crawl sites with hierarchical URL structures. Combined with politeness constraints and depth limits, DFS-based crawlers can systematically explore billions of pages.

In compilers and build systems, depth-first search dfs is used for dependency resolution and topological sorting. Tools like Make, npm, pip, and Maven must determine the correct order to compile files or install packages such that dependencies are satisfied before dependents. This is precisely a topological sort of a directed acyclic graph, computed via depth-first search dfs finish times. Cycle detection via DFS also identifies circular dependencies, which would otherwise cause infinite build loops and must be reported as errors.

File systems and version control systems rely heavily on depth-first search dfs. Commands like `find`, `du`, and `grep -r` perform a depth-first traversal of directory trees. Git uses depth-first search dfs to traverse commit graphs for operations like `git log`, `git blame`, and garbage collection. Similarly, social networks use DFS to find connected components, recommend friends, and detect communities by exploring friendship graphs depth-first.

In networking, depth-first search dfs is used for network topology discovery, deadlock detection in operating systems, and solving mazes and puzzles. Artificial intelligence and game playing, from chess engines to puzzle solvers, use depth-first search dfs with backtracking and alpha-beta pruning to explore game trees. Even in databases, DFS helps with query optimization for recursive queries and with serialization of hierarchical data like JSON and XML.

8. Comparison with Alternatives

Choosing between depth-first search dfs and its alternatives requires understanding their trade-offs in completeness, optimality, time, and space. The primary competitor is Breadth-First Search (BFS), which explores level by level using a queue. While both run in O(V + E) time for adjacency lists, their space and solution quality differ dramatically. DFS uses O(V) space in the worst case but typically O(H) where H is depth, while BFS uses O(V) in the worst case but often O(b^d) where b is branching factor, which can be orders of magnitude larger for wide graphs.

For unweighted shortest path problems, BFS is optimal — it guarantees the shortest path in terms of number of edges — while DFS does not. However, DFS will often find *a* path faster if the goal is deep along the first branch explored, whereas BFS will waste time exploring all shallow nodes. For weighted graphs, neither DFS nor BFS is appropriate; Dijkstra's algorithm or A* search must be used to account for edge weights. DFS is also incomplete in infinite graphs or graphs with cycles if visited tracking is omitted, whereas BFS is complete for finite branching factors.

Iterative Deepening DFS offers a compelling middle ground, providing BFS-like optimality and completeness with DFS-like memory usage, at the cost of revisiting nodes multiple times. For exhaustive search and enumeration problems, DFS with backtracking is the undisputed choice because it naturally supports state restoration upon backtracking. Understanding these distinctions is critical for system design: use DFS when memory is limited, when you need to detect cycles or perform topological sorting, or when you need to explore all possibilities; use BFS when you need the shortest path in an unweighted graph or when the solution is expected to be shallow.

9. Common Mistakes and Best Practices

Even experienced developers make subtle errors when implementing depth-first search dfs. The most common and catastrophic mistake is forgetting to mark nodes as visited before recursing, or marking them at the wrong time. In cyclic graphs, this leads to infinite recursion and stack overflow. In the iterative version, a related mistake is pushing neighbors onto the stack without checking visited status, causing exponential duplication of work and potentially revisiting the same nodes thousands of times. The correct pattern is to mark a node as visited immediately upon popping it (or before pushing, depending on implementation) and to check membership before pushing.

Another frequent pitfall is hitting Python's recursion limit on deep graphs. Python's default recursion limit is 1000, so a path graph with 2000 nodes will crash a recursive DFS with RecursionError. The best practice is to either increase the limit with sys.setrecursionlimit for controlled environments or, preferably, use an iterative implementation with an explicit stack for production code that must handle arbitrary graph sizes. Additionally, recursion incurs function call overhead that can make it significantly slower than iteration for large graphs.

A third common mistake is not handling disconnected graphs. A single call to dfs(graph, start) only visits nodes reachable from start. To visit all nodes, you must loop over all vertices and initiate DFS from each unvisited one. Failing to do so leads to incomplete traversals and incorrect results for tasks like counting connected components or performing a full topological sort. Similarly, confusing directed and undirected edge handling — for example, adding edges in both directions for a directed graph — produces incorrect traversals.

Best Practices for Robust DFS

To write production-ready depth-first search dfs, follow these practices: always use a set or boolean array for O(1) visited checks, choose adjacency lists over matrices for sparse graphs, and clearly document whether your graph is directed or undirected. For grid problems, define directions as arrays and use bounds checking helper functions to keep code clean. When you need path reconstruction, maintain a parent dictionary during traversal. For cycle detection in directed graphs, use three-color marking rather than a simple visited set, because a simple visited set cannot distinguish between a cross edge and a back edge.

Test your implementation on edge cases: empty graph, single node, two nodes with no edge, two nodes with one edge, a complete graph, a linear chain, a graph with a self-loop, and a graph with multiple components. Use iterative DFS when depth is unpredictable, and consider adding a depth limit parameter for safety in infinite or very large state spaces. Finally, when using DFS for backtracking, ensure you correctly undo state changes upon backtracking — for example, removing a node from the current path or resetting a board cell — otherwise subsequent branches will see polluted state.

• Always mark visited before exploring neighbors to prevent cycles.
• Prefer iterative stack for deep graphs to avoid RecursionError.
• Loop over all vertices to handle disconnected graphs.
• Use three-color marking for directed cycle detection.
• Restore state correctly when backtracking.

10. Interview Questions

Depth-first search dfs is a staple of coding interviews, and interviewers use it to assess understanding of recursion, graph representation, and complexity analysis. Below are five common interview questions with strategic guidance on how to approach them, what interviewers look for, and key pitfalls to avoid. Practicing these will prepare you for both whiteboard and take-home challenges.

Q1: Number of Islands — Count connected components in a grid

Problem: Given an m x n grid of '1's (land) and '0's (water), count the number of islands. An island is formed by connecting adjacent lands horizontally or vertically. This is a classic DFS grid traversal problem. The optimal solution iterates over every cell, and when an unvisited land cell is found, it launches DFS to flood-fill the entire island, marking all its cells as visited, and increments the count. Complexity is O(R*C) time and O(R*C) space for the visited set and recursion stack. Interviewers check if you handle boundaries correctly and whether you mutate the grid in place (allowed if specified) or use extra visited space.

Q2: Clone Graph — Deep copy a graph using DFS

Problem: Given a reference to a node in a connected undirected graph, return a deep copy of the graph. Each node contains a value and a list of neighbors. The DFS solution uses a hash map from original node to cloned node to handle cycles and avoid infinite loops. Recursively clone the node, then for each neighbor, if it has not been cloned, recursively clone it, and add the cloned neighbor to the cloned node's neighbor list. This tests your ability to handle object graphs, hash maps, and visited tracking with object identity rather than simple integers. Time O(V+E), Space O(V).

Q3: Course Schedule — Detect cycle and return topological order

Problem: There are n courses labeled 0 to n-1, with prerequisites given as pairs [a, b] meaning b must be taken before a. Determine if you can finish all courses and return an order to do so. This requires cycle detection in a directed graph and topological sorting, both naturally solved with DFS three-color marking. If a back edge (GRAY to GRAY) is found, a cycle exists and no order is possible. Otherwise, the reverse of the finish order is a valid topological order. Interviewers expect you to explain why DFS works and to compare with Kahn's BFS algorithm. Complexity O(V+E).

Q4: Word Search — Find if a word exists in a 2D board

Problem: Given an m x n board and a word, find if the word exists by sequentially adjacent cells (horizontally or vertically), where each cell may be used only once per word. This is a backtracking DFS problem. For each cell matching the first character, launch DFS that tries to match the next character in four directions, marking the current cell as visited (e.g., temporarily replacing it with '#') and unmarking upon backtracking. Pruning by early termination when the word is found is essential. Worst-case time is O(R*C*4^L) where L is word length, but pruning makes it efficient in practice. Space is O(L) for recursion stack.

Q5: Lowest Common Ancestor in a Binary Tree

Problem: Given a binary tree and two nodes p and q, find their lowest common ancestor (LCA). While this is a tree problem, DFS is the natural traversal. The recursive DFS solution returns the LCA directly: if the current node is null, return null; if it equals p or q, return it; recursively search left and right subtrees; if both sides return non-null, the current node is the LCA; otherwise return the non-null side. This elegant O(N) time, O(H) space solution tests understanding of DFS return values and tree recursion. Interviewers often follow up with variants for BSTs (use property) or with parent pointers.

For all these questions, be prepared to discuss iterative versus recursive implementations, to analyze time and space complexity precisely, and to handle follow-ups like "What if the graph is very large?" or "How would you parallelize this?" Demonstrating knowledge of visited set management, backtracking state restoration, and edge case handling will set you apart.