But many DP problems follow the same patterns.

In this blog, we will look at 5 common forms of DP:

1. Knapsack Form

2. Ending Form

3. Multi-sequence / Matching Form

4. Interval DP

5. Game DP

The main idea is simple:

Before writing the code, try to identify which DP form the problem belongs to.

Once the form is identified, finding the state and transition becomes much easier.

1. Knapsack Form

This is probably the most common DP form.

You usually have something like:

• An array

• A set of items

• Some choices

For every item, we usually have two options:

• Take it

• Don't take it

For example:

Given some items and a limited capacity, find the maximum value.

At every index, we decide:

Take the current item
OR
Skip the current item

So the transition usually looks like:

dp(i, remaining) =
    max(
        take current item,
        skip current item
    )

The exact meaning of remaining depends on the problem.

It can be:

• Remaining capacity

• Remaining sum

• Remaining operations

• Some other restriction

The important thing is:

Knapsack problems usually have a take / not take choice.

Example State

dp(i, capacity)

This can mean:

Maximum answer we can get using items from index i onwards with capacity left.

For every item:

Skip:
dp(i + 1, capacity)

Take:
value[i] + dp(i + 1, capacity - weight[i])

Then:

dp(i, capacity) =
max(
    dp(i + 1, capacity),
    value[i] + dp(i + 1, capacity - weight[i])
)

2. Ending Form

The second form is used when we are building a:

• Subsequence

• Partition

• Sequence

The important idea here is:

Instead of asking for the answer of the whole array, ask for the answer ending at index i.

For example:

dp(i)

can mean:

Longest valid subsequence ending at index i.

This makes the transition easier.

Example: Longest Increasing Subsequence

Suppose:

arr[j] < arr[i]

Then we can put arr[i] after the subsequence ending at j.

So:

dp(i) = max(dp(j) + 1)

for every:

j < i

such that:

arr[j] < arr[i]

The base case is:

dp(i) = 1

because every element can form a subsequence of length 1.

So the full transition becomes:

dp(i) = 1

for every j < i:
    if arr[j] < arr[i]:
        dp(i) = max(dp(i), dp(j) + 1)

The final answer is:

max(dp(i))

for every i.

Extra States

Sometimes just dp(i) is not enough.

We may need extra information.

For example:

dp(i, peakFound)

This can mean:

Longest sequence ending at i, and whether a peak has already been found or not.

This is useful in problems like Longest Bitonic Subsequence.

So the Ending Form usually looks like:

dp(index, some extra restriction)

The notes describe this form as building a subsequence or partition and using a state based on what ends at the current position.

3. Multi-sequence / Matching Form

This form is used when we have:

• Two strings

• Two arrays

• Multiple sequences

The most common example is:

Longest Common Subsequence

Suppose we have:

s = "abc"
t = "ac"

We define:

dp(i, j)

as:

Answer using the sequences starting from index i and j.

Now there are two cases.

Case 1: Characters are Equal

If:

s[i] == t[j]

Then we can use both characters.

So:

dp(i, j) = 1 + dp(i + 1, j + 1)

Case 2: Characters are Different

If:

s[i] != t[j]

Then we try skipping one character.

dp(i, j) =
max(
    dp(i + 1, j),
    dp(i, j + 1)
)

The state is usually:

dp(i, j)

because we are tracking positions in two sequences.

The notes use LCS as the main example for this form and define the state using positions in both sequences.

Complexity

If both sequences have length N and M:

States = N × M

Each state is calculated once.

So:

Time Complexity = O(NM)
Memory = O(NM)

4. Interval DP

Interval DP is also called:

• Range DP

• LR DP

Here, instead of working on one index, we work on a range.

The state usually looks like:

dp(L, R)

This means:

Answer for the part of the array from L to R.

The notes describe this form as LRDP / Interval DP and mention three common styles: Delete and Squeeze, Merge, and Group Delete.

Example: Burst Balloons

Suppose we have:

3 1 5 8

When we burst a balloon, the answer depends on its neighbours.

This makes the problem difficult because the neighbours keep changing.

So instead of thinking:

Which balloon should I burst first?

We think:

Which balloon should I burst last?

This is the main trick.

State

dp(L, R)

means:

Maximum coins we can get by bursting balloons from L to R.

Now assume balloon mid is the last balloon burst inside this range.

Before bursting mid:

• Everything from L to mid - 1 is already removed.

• Everything from mid + 1 to R is already removed.

So we get:

dp(L, mid - 1)
+
dp(mid + 1, R)

Then we add the coins for bursting mid.

So:

dp(L, R) =
max over every mid:

dp(L, mid - 1)
+
dp(mid + 1, R)
+
coins from bursting mid

This is the main idea behind many Interval DP problems.

The Burst Balloons notes specifically use the idea of choosing the balloon deleted last inside a range.

Another Way to Identify Interval DP

Ask yourself:

Is the problem asking me to perform operations on a subarray or range?

For example:

[L, R]

Then try:

dp(L, R)

Also check if:

• We split the range.

• We delete something from the range.

• We merge two parts.

If yes, it might be Interval DP.

5. Game DP

Game DP problems usually have:

• Two players

• Alternate turns

• Some possible moves

Usually, the question is:

Can the first player win?

The notes classify these as combinatorial impartial two-player games.

The most important idea is very simple.

Winning and Losing States

Suppose it is your turn.

If you have at least one move that puts your opponent in a losing state:

You are in a winning state.

If every possible move puts your opponent in a winning state:

You are in a losing state.

That is basically the whole idea behind many Game DP problems.

The notes state the same winning/losing rule for Game DP.

Example

Suppose there are N marbles.

A player can take:

1 marble
OR
2 marbles

Define:

dp(n)

as:

Can the current player win with n marbles left?

Now:

dp(n) = true

if we can make a move to a losing state.

So:

if dp(n - 1) == false:
    dp(n) = true

if dp(n - 2) == false:
    dp(n) = true

Otherwise:

dp(n) = false

How to Identify the DP Form

When you see a DP problem, don't immediately start writing:

dp[i]

First ask:

Question 1

Do I have a choice like:

Take
OR
Don't take?

Then it might be:

Knapsack Form

Question 2

Am I building a:

Subsequence
OR
Partition?

Then it might be:

Ending Form

Try defining:

dp(i) = answer ending at i

Question 3

Am I working with:

Two strings?
Two arrays?
Two sequences?

Then it might be:

Matching / Multi-sequence DP

Try:

dp(i, j)

Question 4

Am I performing operations on:

A subarray [L, R]?

Then it might be:

Interval DP

Try:

dp(L, R)

Question 5

Is this a:

Two-player game?

Then it might be:

Game DP

Try to identify:

Winning states
Losing states

A Simple DP Checklist

Whenever I solve a DP problem, I try to find these things:

1. What does my DP state mean?

For example:

dp(i)

or:

dp(i, j)

or:

dp(L, R)

The most important thing is:

You should be able to explain the meaning of your state in one sentence.

2. What choices do I have?

For example:

Take / Don't take

or:

Move forward

or:

Split at mid

or:

Choose one move in a game

3. What is the base case?

Ask:

When does the problem become so small that I already know the answer?

4. What is the transition?

Ask:

How can I build the answer for the current state using smaller states?

5. What is the final answer?

Sometimes it is:

dp(n)

Sometimes:

max(dp(i))

Sometimes:

dp(0, n - 1)

It depends on the problem.

Final Thoughts

Dynamic Programming problems can look very different on the surface.

But many of them follow the same patterns.

The five forms are:

1. Knapsack
   → Take / Don't take

2. Ending Form
   → Build a subsequence or partition

3. Matching Form
   → Work with multiple sequences

4. Interval DP
   → Work on a range [L, R]

5. Game DP
   → Winning and losing states

So next time you see a DP problem, first try to identify its form.

Once you know the form, you can usually start thinking about:

State
→ Choices
→ Transition
→ Base Case
→ Answer

That's it. Cheerio!

Instead of moving one step at a time, we jump in powers of two. This reduces the traversal time complexity to O(log N) and is generally used in graph/tree problems.

For example, let

par[i][k] = 2^k-th parent of node i

Then moving k levels up becomes:

for (int j = 19; j >= 0; j--) {

    if (k & (1 << j)) {      // check if j-th bit is set
        i = par[i][j];       // binary lifting step
    }

}

Path Aggregates

We can also use binary lifting to pre-compute path aggregates while traversing a tree.

The idea is exactly the same—we just store some extra information along with every jump.

Precomputation for Path Aggregates

1. Base Case

For j = 0, the 2^0-th ancestor is simply the immediate parent.

So,

agg[u][0]

stores the property of the direct edge (or node value, depending on the problem) between u and its parent.

2. Recursive Relation

For j > 0, the aggregate for the 2^j-th ancestor is obtained by combining two 2^(j-1) jumps.

agg[u][j] = combine(
                agg[u][j-1],
                agg[parent[u][j-1]][j-1]
            )

The combine() function depends on what property you're computing.

For example,

• Sum

combine(x, y) = x + y

• GCD

combine(x, y) = gcd(x, y)

• Maximum

combine(x, y) = max(x, y)

Code Example (Path GCD)

vector<vector<int>> adj;
vector<vector<int>> parent, dp;
vector<int> depth, arr;

int n;
const int LOG = 20;

// DFS to compute depth and binary lifting table
void dfs(int node, int par, int dep) {

    depth[node] = dep;
    parent[node][0] = par;
    dp[node][0] = arr[node];

    // Build parent and aggregate tables
    for (int i = 1; i < LOG; i++) {
        parent[node][i] = parent[parent[node][i - 1]][i - 1];
        dp[node][i] = __gcd(
            dp[node][i - 1],
            dp[parent[node][i - 1]][i - 1]
        );
    }

    for (auto v : adj[node]) {
        if (v != par)
            dfs(v, node, dep + 1);
    }
}

Path GCD Query

int pathGCD(int u, int v) {

    if (depth[u] < depth[v])
        swap(u, v);

    int ans = 0;

    // Bring u to the same level as v
    int diff = depth[u] - depth[v];

    for (int i = LOG - 1; i >= 0; i--) {

        if (diff & (1 << i)) {
            ans = __gcd(ans, dp[u][i]);
            u = parent[u][i];
        }

    }

    // If u == v, we've already reached the LCA.
    // GCD has been calculated just before this node.
    if (u == v)
        return __gcd(ans, arr[u]);

    // Lift both nodes together until just below the LCA
    for (int i = LOG - 1; i >= 0; i--) {

        if (parent[u][i] != parent[v][i]) {

            ans = __gcd(ans, dp[u][i]);
            ans = __gcd(ans, dp[v][i]);

            u = parent[u][i];
            v = parent[v][i];
        }
    }

    // We stopped one step before the LCA,
    // so we still need to include u, v and the LCA itself.

    ans = __gcd(ans, arr[u]);
    ans = __gcd(ans, arr[v]);

    return __gcd(ans, arr[parent[u][0]]);
}

Complexity