Dynamic Programming Questions at Adobe: What to Expect

Dynamic Programming (DP) is a cornerstone of Adobe's technical interviews. With 30 DP-specific questions in their known problem set—over 13% of their total—it's clear the company values candidates who can optimize recursive solutions and think in overlapping subproblems. This emphasis stems from Adobe's core work in large-scale creative software, data analytics, and real-time processing systems, where efficient algorithms directly impact performance in rendering, data pipelines, and user experience. Mastering DP demonstrates you can move beyond brute-force thinking to build optimized, scalable solutions, a critical skill for their engineering roles.

What to Expect — Types of Problems

Adobe's DP questions tend to focus on practical, pattern-based applications rather than obscure puzzles. You can expect a strong leaning toward:

• String & Sequence Problems: Edit distance, longest common subsequence, palindromic substrings, and string matching. These are directly relevant to text processing in documents (PDF, InDesign) and data validation.
• Knapsack & Partition Problems: Subset sum, partitioning, and resource allocation variants. These test your ability to handle constraints, mirroring scenarios in resource management for rendering jobs or server loads.
• 1D/2D Array & Grid DP: Unique paths, minimum path sum, and house robber-style problems. These often model navigation or optimization within a structured canvas or grid, a concept familiar in graphics and UI layout.
• State Machine DP: Problems like buy/sell stock with cooldown, which require tracking multiple states. This pattern is useful for modeling user interaction states or complex transaction logic.

The problems are designed to assess both your pattern recognition and your ability to implement an efficient solution under interview conditions.

How to Prepare — Study Tips with One Code Example

Start by learning the core patterns (0/1 knapsack, LCS, unbounded knapsack, Fibonacci, etc.), not just memorizing problems. For each pattern, internalize the recurrence relation. Always ask: 1) What is the state? (What does dp[i] represent?) 2) What is the base case? 3) How do states transition? Practice translating top-down (memoized) recursion to bottom-up (tabular) DP. This proves you understand the underlying subproblem structure.

A fundamental pattern is the Fibonacci-style sequence, which builds the foundation for understanding state transitions. Here is the bottom-up approach:

def climb_stairs(n: int) -> int:
    if n <= 2:
        return n
    dp = [0] * (n + 1)
    dp[1], dp[2] = 1, 2
    for i in range(3, n + 1):
        dp[i] = dp[i - 1] + dp[i - 2]
    return dp[n]

Recommended Practice Order

1. Foundation: Master Fibonacci, Climbing Stairs, and Min Cost Climbing Stairs to grasp state definition and simple transitions.
2. 1D Arrays: Solve House Robber and its variants to learn dealing with adjacency constraints.
3. Classic String DP: Practice Longest Common Subsequence and Edit Distance. These are high-frequency at Adobe.
4. Knapsack Fundamentals: Solve 0/1 Knapsack and Partition Equal Subset Sum. Understand the "include/exclude" decision.
5. 2D Grids: Solve Unique Paths and Minimum Path Sum to handle 2D state transitions.
6. Adobe-Specific Set: Finally, target the 30 known Adobe DP questions. Apply the patterns you've learned to these problems efficiently.

Practice Dynamic Programming at Adobe