Dynamic Programming Questions at Swiggy: What to Expect

Dynamic Programming (DP) is a core algorithmic technique for optimizing complex decisions, making it highly relevant for a tech-driven logistics and delivery platform like Swiggy. Swiggy's systems must constantly solve problems involving optimal routing for thousands of delivery partners, efficient order batching, inventory management for cloud kitchens, and resource allocation—all under real-time constraints. These are classic optimization challenges where DP excels. By testing DP in interviews (with 11 out of 41 total questions dedicated to it), Swiggy assesses a candidate's ability to break down a large, seemingly intractable problem into manageable overlapping subproblems, cache results, and build an optimal solution. This skill directly translates to writing efficient, scalable backend services that can handle the company's massive operational scale.

What to Expect — Types of Problems

Swiggy's DP questions tend to focus on practical patterns applicable to real-world systems. You can expect a strong emphasis on:

• Knapsack & Subset Problems: Modeling resource allocation, such as optimizing delivery load or selecting feature sets within a budget.
• String & Sequence DP: Relevant for tasks like order matching, sequence alignment in data pipelines, or similarity checks.
• Grid & Pathfinding: Fundamental for modeling movement on a map or through a grid-like system, a direct analog for routing.
• DP on Intervals or Partitions: Useful for problems involving scheduling time slots or batching orders into efficient delivery windows. The problems often have a narrative tied to logistics, ordering, or partitioning, but the underlying patterns are standard.

How to Prepare — Study Tips with One Code Example

Start by mastering the core principle: optimal substructure and overlapping subproblems. Don't jump straight to tabulation; first, learn to write a brute-force recursive solution, identify the repeated work, and then add memoization (top-down DP). This thought process is crucial in interviews. Finally, derive the bottom-up tabulation approach for space optimization.

A fundamental pattern is the 0/1 Knapsack Problem, which models selecting items with given weights and values to maximize total value without exceeding a capacity. Here is the memoized (top-down) solution:

def knapsack_memo(weights, values, capacity):
    n = len(weights)
    memo = [[-1] * (capacity + 1) for _ in range(n)]

    def dfs(i, remaining_cap):
        if i == n or remaining_cap == 0:
            return 0
        if memo[i][remaining_cap] != -1:
            return memo[i][remaining_cap]
        # Skip item i
        skip = dfs(i + 1, remaining_cap)
        # Take item i if possible
        take = 0
        if weights[i] <= remaining_cap:
            take = values[i] + dfs(i + 1, remaining_cap - weights[i])
        memo[i][remaining_cap] = max(skip, take)
        return memo[i][remaining_cap]

    return dfs(0, capacity)

Recommended Practice Order

1. Foundations: Fibonacci, Climbing Stairs, 0/1 Knapsack (memoization and tabulation).
2. Core Patterns: Unbounded Knapsack, Longest Common Subsequence, Longest Increasing Subsequence, Coin Change, Edit Distance.
3. Swiggy-Relevant: Grid-based problems (Unique Paths, Minimum Path Sum), Partition problems, and string DP variations.
4. Integration: Practice problems that combine DP with other concepts, like DP on trees or with bitmasking, to tackle more complex Swiggy-style scenarios.

Focus on understanding why the DP state works before coding. For each problem, articulate the recurrence relation clearly.

Practice Dynamic Programming at Swiggy