Depth-First Search Questions at Adobe: What to Expect

Depth-First Search (DFS) is a fundamental algorithm that Adobe interviewers use to assess your grasp of recursion, tree/graph traversal, and systematic problem-solving. With 20 specific DFS questions in their known problem set, it's a clearly tested competency. For a company like Adobe, which develops complex software for graphics, documents, and digital experiences, the ability to navigate hierarchical data structures (like document object models, scene graphs, or file systems) is directly relevant. Mastering DFS demonstrates you can think recursively and handle problems involving paths, combinations, or connected components—skills applicable to features in Photoshop, Acrobat, or Experience Manager.

What to Expect — Types of Problems

Adobe's DFS questions typically fall into three categories. First, classic tree traversal: you'll encounter problems involving binary trees, n-ary trees, or trie structures, requiring pre-order, in-order, or post-order traversals to find paths, calculate sums, or serialize data. Second, graph exploration: these problems involve grids (like image pixels) or node-edge graphs, where you must find connected components, detect cycles, or check for valid paths, mirroring real-world scenarios like content-aware fill or dependency resolution. Third, backtracking and generation: this is where DFS is most powerful. You'll solve problems requiring you to generate all possible combinations, permutations, or partitions (e.g., all palindromic partitions of a string, all subsets), which tests your ability to prune search spaces efficiently—a key skill for optimization tasks.

How to Prepare — Study Tips with One Code Example

Focus on internalizing the recursive DFS template and its iterative stack-based variant. Practice drawing the recursion tree or call stack for small inputs. The core pattern involves a base case, recursive exploration, and state management (passing down a path or modifying a visited set). Always analyze time/space complexity, as interviewers will ask.

A key pattern is the "Path Finder" DFS, used to find if a path exists between two nodes or to collect all root-to-leaf paths. Here is the template for a binary tree:

def has_path_sum(root, target_sum):
    def dfs(node, current_sum):
        if not node:
            return False
        current_sum += node.val
        # If it's a leaf node, check the sum
        if not node.left and not node.right:
            return current_sum == target_sum
        # Recursively check left and right subtrees
        return dfs(node.left, current_sum) or dfs(node.right, current_sum)
    return dfs(root, 0)

Recommended Practice Order

Start with foundational tree problems (e.g., maximum depth, path sum). Move to graph traversal on grids (number of islands, flood fill). Then tackle backtracking problems (subsets, permutations). Finally, attempt Adobe's specific tagged questions, which often combine these concepts. For each problem, write the solution recursively first, then iteratively if time permits. Time yourself to build speed.

Practice Depth-First Search at Adobe