Scribd
Upload
121 views36 pages

04 Dynamic Programming JG

Dynamic programming is a method for solving complex problems by breaking them down into simpler subproblems. There are three key steps: 1) defining the subproblems, 2) writing recurrences relating the subproblems, and 3) solving base cases. The document provides examples of dynamic programming applied to 1D, 2D, interval, tree, and subset problems. It also discusses representations for subsets using bitmasks which can compactly represent solutions to subset problems.

Uploaded by

Nikhil Sharma Rayaprolu
Copyright
© © All Rights Reserved
Available Formats
Download as PDF, TXT or read online on Scribd
Download as pdf or txt
121 views36 pages

04 Dynamic Programming JG

Dynamic programming is a method for solving complex problems by breaking them down into simpler subproblems. There are three key steps: 1) defining the subproblems, 2) writing recurrences relating the subproblems, and 3) solving base cases. The document provides examples of dynamic programming applied to 1D, 2D, interval, tree, and subset problems. It also discusses representations for subsets using bitmasks which can compactly represent solutions to subset problems.

Uploaded by

Nikhil Sharma Rayaprolu
Copyright
© © All Rights Reserved
Available Formats
Download as PDF, TXT or read online on Scribd
Download as pdf or txt
Download as pdf or txt
You are on page 1/ 36

Dynamic Programming

Jaehyun Park
CS 97SI
Stanford University

June 29, 2015

Outline

Dynamic Programming
1-dimensional DP
2-dimensional DP
Interval DP
Tree DP
Subset DP

Dynamic Programming

What is DP?

Wikipedia definition: method for solving complex problems


by breaking them down into simpler subproblems

This definition will make sense once we see some examples


Actually, well only see problem solving examples today

Dynamic Programming

Steps for Solving DP Problems

1. Define subproblems
2. Write down the recurrence that relates subproblems
3. Recognize and solve the base cases

Each step is very important!

Dynamic Programming

Outline

Dynamic Programming
1-dimensional DP
2-dimensional DP
Interval DP
Tree DP
Subset DP

1-dimensional DP

1-dimensional DP Example

Problem: given n, find the number of different ways to write


n as the sum of 1, 3, 4

Example: for n = 5, the answer is 6


5 = 1+1+1+1+1
= 1+1+3
= 1+3+1
= 3+1+1
= 1+4
= 4+1

1-dimensional DP

1-dimensional DP Example

Define subproblems
Let Dn be the number of ways to write n as the sum of 1, 3, 4

Find the recurrence


Consider one possible solution n = x1 + x2 + + xm
If xm = 1, the rest of the terms must sum to n 1
Thus, the number of sums that end with xm = 1 is equal to
Dn1
Take other cases into account (xm = 3, xm = 4)

1-dimensional DP

1-dimensional DP Example

Recurrence is then
Dn = Dn1 + Dn3 + Dn4

Solve the base cases


D0 = 1
Dn = 0 for all negative n
Alternatively, can set: D0 = D1 = D2 = 1, and D3 = 2

Were basically done!

1-dimensional DP

Implementation

D[0] = D[1] = D[2] = 1; D[3] = 2;


for(i = 4; i <= n; i++)
D[i] = D[i-1] + D[i-3] + D[i-4];

Very short!
Extension: solving this for huge n, say n 1012
Recall the matrix form of Fibonacci numbers

1-dimensional DP

POJ 2663: Tri Tiling

Given n, find the number of ways to fill a 3 n board with


dominoes

Here is one possible solution for n = 12

1-dimensional DP

10

POJ 2663: Tri Tiling

Define subproblems
Define Dn as the number of ways to tile a 3 n board

Find recurrence
Uuuhhhhh...

1-dimensional DP

11

Troll Tiling

1-dimensional DP

12

Defining Subproblems

Obviously, the previous definition didnt work very well

Dn s dont relate in simple terms

What if we introduce more subproblems?

1-dimensional DP

13

Defining Subproblems

1-dimensional DP

14

Finding Recurrences

1-dimensional DP

15

Finding Recurrences

Consider different ways to fill the nth column

Exercise:

And see what the remaining shape is


Finding recurrences for An , Bn , Cn
Just for fun, why is Bn and En always zero?

Extension: solving the problem for n m grids, where n is


small, say n 10
How many subproblems should we consider?

1-dimensional DP

16

Outline

Dynamic Programming
1-dimensional DP
2-dimensional DP
Interval DP
Tree DP
Subset DP

2-dimensional DP

17

2-dimensional DP Example

Problem: given two strings x and y, find the longest common


subsequence (LCS) and print its length
Example:
x: ABCBDAB
y: BDCABC
BCAB is the longest subsequence found in both sequences, so
the answer is 4

2-dimensional DP

18

Solving the LCS Problem

Define subproblems
Let Dij be the length of the LCS of x1...i and y1...j

Find the recurrence


If xi = yj , they both contribute to the LCS

Dij = Di1,j1 + 1

Otherwise, either xi or yj does not contribute to the LCS, so


one can be dropped

Dij = max{Di1,j , Di,j1 }

Find and solve the base cases: Di0 = D0j = 0

2-dimensional DP

19

Implementation

for(i = 0; i <= n; i++) D[i][0] = 0;


for(j = 0; j <= m; j++) D[0][j] = 0;
for(i = 1; i <= n; i++) {
for(j = 1; j <= m; j++) {
if(x[i] == y[j])
D[i][j] = D[i-1][j-1] + 1;
else
D[i][j] = max(D[i-1][j], D[i][j-1]);
}
}

2-dimensional DP

20

Outline

Dynamic Programming
1-dimensional DP
2-dimensional DP
Interval DP
Tree DP
Subset DP

Interval DP

21

Interval DP Example

Problem: given a string x = x1...n , find the minimum number


of characters that need to be inserted to make it a palindrome

Example:
x: Ab3bd
Can get dAb3bAd or Adb3bdA by inserting 2 characters
(one d, one A)

Interval DP

22

Interval DP Example

Define subproblems
Let Dij be the minimum number of characters that need to be
inserted to make xi...j into a palindrome

Find the recurrence


Consider a shortest palindrome y1...k containing xi...j
Either y1 = xi or yk = xj (why?)
y2...k1 is then an optimal solution for xi+1...j or xi...j1 or
xi+1...j1

Interval DP

Last case possible only if y1 = yk = xi = xj

23

Interval DP Example

Find the recurrence


Dij =

1 + min{Di+1,j , Di,j1 }
Di+1,j1

xi 6= xj
xi = xj

Find and solve the base cases: Dii = Di,i1 = 0 for all i

The entries of D must be filled in increasing order of j i

Interval DP

24

Interval DP Example

// fill in base cases here


for(t = 2; t <= n; t++)
for(i = 1, j = t; j <= n; i++, j++)
// fill in D[i][j] here

Note how we use an additional variable t to fill the table in


correct order

And yes, for loops can work with multiple variables

Interval DP

25

An Alternate Solution

Reverse x to get xR

The answer is n L, where L is the length of the LCS of x


and xR

Exercise: Think about why this works

Interval DP

26

Outline

Dynamic Programming
1-dimensional DP
2-dimensional DP
Interval DP
Tree DP
Subset DP

Tree DP

27

Tree DP Example

Problem: given a tree, color nodes black as many as possible


without coloring two adjacent nodes

Subproblems:
First, we arbitrarily decide the root node r
Bv : the optimal solution for a subtree having v as the root,
where we color v black
Wv : the optimal solution for a subtree having v as the root,
where we dont color v
Answer is max{Br , Wr }

Tree DP

28

Tree DP Example

Find the recurrence


Crucial observation: once vs color is determined, subtrees can
be solved independently
If v is colored, its children must not be colored
X
Bv = 1 +
Wu
uchildren(v)

If v is not colored, its children can have any color


X
Wv = 1 +
max{Bu , Wu }
uchildren(v)

Base cases: leaf nodes

Tree DP

29

Outline

Dynamic Programming
1-dimensional DP
2-dimensional DP
Interval DP
Tree DP
Subset DP

Subset DP

30

Subset DP Example

Problem: given a weighted graph with n nodes, find the


shortest path that visits every node exactly once (Traveling
Salesman Problem)

Wait, isnt this an NP-hard problem?


Yes, but we can solve it in O(n2 2n ) time
Note: brute force algorithm takes O(n!) time

Subset DP

31

Subset DP Example

Define subproblems
DS,v : the length of the optimal path that visits every node in
the set S exactly once and ends at v
There are approximately n2n subproblems
Answer is minvV DV,v , where V is the given set of nodes

Lets solve the base cases first


For each node v, D{v},v = 0

Subset DP

32

Subset DP Example

Find the recurrence


Consider a path that visits all nodes in S exactly once and
ends at v
Right before arriving v, the path comes from some u in
S {v}
And that subpath has to be the optimal one that covers
S {v}, ending at u
We just try all possible candidates for u

DS,v =

Subset DP

min

uS{v}

DS{v},u + cost(u, v)

33

Working with Subsets

When working with subsets, its good to have a nice


representation of sets
Idea: Use an integer to represent a set

Subset DP

Concise representation of subsets of small integers {0, 1, . . .}


If the ith (least significant) digit is 1, i is in the set
If the ith digit is 0, i is not in the set
e.g., 19 = 010011(2) in binary represent a set {0, 1, 4}

34

Using Bitmasks

Union of two sets x and y: x | y

Intersection: x & y

Symmetric difference: x y

Singleton set {i}: 1 << i

Membership test: x & (1 << i) != 0

Subset DP

35

Conclusion

Wikipedia definition: a method for solving complex problems


by breaking them down into simpler subproblems
Does this make sense now?

Remember the three steps!


1. Defining subproblems
2. Finding recurrences
3. Solving the base cases

Subset DP

36

You might also like