Dynamic Programming

An algorithm design technique (like divide and

conquer)

Divide and conquer

Partition the problem into independent subproblems

Solve the subproblems recursively

Combine the solutions to solve the original problem

1
 DP - Two key ingredients
Two key ingredients for an optimization problem
to be suitable for a dynamic-programming
solution:

1. optimal substructures 2. overlapping subproblems

Subproblems are dependent.

Each substructure is (otherwise, a divide-and-
optimal. conquer approach is the
(Principle of optimality) choice.) 2
 Three basic components

The development of a dynamic-programming

algorithm has three basic components:
The recurrence relation (for defining the value of an
optimal solution);
The tabular computation (for computing the value of
an optimal solution);
The traceback (for delivering an optimal solution).

3
 Fibonacci numbers

The Fibonacci numbers are defined by the

following recurrence:

F =0
0
F =1
1
F = F - + F - for i>1 .
i i 1 i 2

4
How to compute F10

F8
F9
F7
F10
F7
F8
F6

5
 Dynamic Programming
Applicable when subproblems are not independent
Subproblems share subsubproblems
E.g.: Fibonacci numbers:
Recurrence: F(n) = F(n-1) + F(n-2)
Boundary conditions: F(1) = 0, F(2) = 1
Compute: F(5) = 3, F(3) = 1, F(4) = 2
A divide and conquer approach would repeatedly solve the
common subproblems
Dynamic programming solves every subproblem just once and
stores the answer in a table
More work in DC than DP

6
 Tabular computation
The tabular computation can avoid
recompuation.

F0 F1 F2 F3 F4 F5 F6 F7 F8 F9 F10

0 1 1 2 3 5 8 13 21 34 55

Result

7
 Dynamic Programming Algorithm
1. Characterize the structure of an optimal solution
2. Recursively define the value of an optimal solution
3. Compute the value of an optimal solution in a bottom-
up fashion
4. Construct an optimal solution from computed
information
Steps 1-3 form the basis of a dynamic-programming solution to a problem. Step
4 can be omitted if only the value of an optimal solution is required. When
we do perform step 4, we sometimes maintain additional information
during the computation in step 3 to ease the construction of an optimal
solution.

8
Longest increasing subsequence(LIS)

The longest increasing subsequence is to find

a longest increasing subsequence of a given
sequence of distinct integers a1a2an .
e.g. 9 2 5 3 7 11 8 10 13 6
2 3 7
are increasing subsequences.
5 7 10 13
9 7 11 We want to find a longest one.

3 5 11 13 are not increasing subsequences.

9
 A naive approach for LIS
Let L[ i ] be the length of a longest increasing
subsequence ending at position i.
L[i] = 1 + max j = 0..i-1{L[j] | aj < ai}
(use a dummy a0 = minimum, and L[0]=0)
Index 0 1 2 3 4 5 6 7 8 9 10

Input 0 9 2 5 3 7 11 8 10 13 6

Length 0 1 1 2 2 3 4 4 5 6 3

Prev -1 0 0 2 2 4 5 5 7 8 4

Path 1 1 1 1 1 2 2 2 2 2 2

The subsequence 2, 3, 7, 8, 10, 13 is a

longest increasing subsequence.
This method runs in O(n2) time. 10
 An O(n log n) method for LIS

Define BestEnd[k] to be the smallest number

of an increasing subsequence of length k.
9 2 5 3 7 11 8 10 13 6
9 2 2 2 2 2 2 2 2 2 BestEnd[1]

5 3 3 3 3 3 3 3 BestEnd[2]

7 7 7 7 7 6 BestEnd[3]

11 8 8 8 8 BestEnd[4]
For each position, we perform
a binary search to update 10 10 10 BestEnd[5]
BestEnd. Therefore, the
13 13 BestEnd[6]
running time is O(n log n).
11
 The 0-1 Knapsack Problem
Thief has a knapsack of capacity W

There are n items: for i-th item value vi and

weight wi

Goal:
find xi such that for all xi = {0, 1}, i = 1, 2, .., n

wixi W and

xivi is maximum

12
 0-1 Knapsack - Greedy Strategy
E.g.:

Item 3 30 $120

Item 2 50 50 +
20 $100
Item 1 30
20 + 20 $100
10 10 $60

$60 $100 $120 $160 $220

$6/pound $5/pound $4/pound

None of the solutions involving the greedy

choice (item 1) leads to an optimal solution
The greedy choice property does not hold

13
0-1 Knapsack - Dynamic Programming

P(i, w) the maximum profit that can be

obtained from items 1 to i, if the
knapsack has size w

Case 1: thief takes item i

P(i, w) = vi + P(i - 1, w-wi)

Case 2: thief does not take item i

P(i, w) = P(i - 1, w)
14
 0-1 Knapsack - Dynamic Programming

Item i was taken Item i was not taken

P(i, w) = max {vi + P(i - 1, w-wi), P(i - 1, w) }

0: 1 w - wi w W

0 0 0 0 0 0 0 0 0 0 0 0
0 first

0 second
i-1 0
i 0
0
n 0
15
 W=5 Item Weight Value
Example: 0-1 Knapsack
P(i, w) = max {vi + P(i - 1, w-wi), P(i - 1, w) } 1 2 12
2 1 10
3 3 20
w 0 1 2 3 4 5
i 4 2 15
0 0 0 0 0 0 0 P(1, 1) = P(0, 1) = 0
1 0 0 12 12 12 12 P(1, 2) = max{12+0, 0} = 12
2 0 10 12 22 22 22 P(1, 3) = max{12+0, 0} = 12
3 0 10 12 22 30 32 P(1, 4) = max{12+0, 0} = 12
4 0 10 15 25 30 37 P(1, 5) = max{12+0, 0} = 12

P(2, 1)= max{10+0, 0} = 10 P(3, 1)= P(2,1) = 10 P(4, 1)= P(3,1) = 10

P(2, 2)= max{10+0, 12} = 12 P(3, 2)= P(2,2) = 12 P(4, 2)= max{15+0, 12} = 15
P(2, 3)= max{10+12, 12} = 22 P(3, 3)= max{20+0, 22}=22 P(4, 3)= max{15+10, 22}=25
P(2, 4)= max{10+12, 12} = 22 P(3, 4)= max{20+10,22}=30 P(4, 4)= max{15+12, 30}=30
P(2, 5)= max{10+12, 12} = 22 P(3, 5)= max{20+12,22}=32 P(4, 5)= max{15+22, 32}=37
16
Reconstructing the Optimal Solution
0 1 2 3 4 5
0 0 0 0 0 0 0 Item 4
1 0 0 12 12 12 12
Item 2
2 0 10 12 22 22 22
3 0 10 12 22 30 32 Item 1
4 0 10 15 25 30 37

Start at P(n, W)
When you go left-up item i has been taken
When you go straight up item i has not been
taken
17
 Overlapping Subproblems
P(i, w) = max {vi + P(i - 1, w-wi), P(i - 1, w) }
0: 1 w W

0 0 0 0 0 0 0 0 0 0 0 0
0
0
i-1 0
i 0
0
n 0
E.g.: all the subproblems shown in red may
depend on P(i-1, w)
18
 In Class Exercise

i\W 0 1 2 3 4 5
0 0 0 0 0 0 0
1 0
2 0
3 0
4 0

Lets run the algorithm on the following data:

n = 4 (# of elements), W = 5 (max weight)

Elements (weight, profit (benefit) ): (2,3), (3,4), (4,5), (5,6)
 Items:
In Class Exercise 1: (2,3)
2: (3,4)
3: (4,5)
i\W 0 1 2 3 4 5 i=1 4: (5,6)
0 0 0 0 0 0 0 bi=3
1 0 0
wi=2
2 0
w=1
3 0
w-wi =-1
4 0
 Items:
In Class Exercise 1: (2,3)
2: (3,4)
3: (4,5)
i\W 0 1 2 3 4 5 i=1 4: (5,6)
0 0 0 0 0 0 0 bi=3
1 0 0 3
wi=2
2 0
w=2
3 0
w-wi =0
4 0
 Items:
In Class Exercise 1: (2,3)
2: (3,4)
3: (4,5)
i\W 0 1 2 3 4 5 i=1 4: (5,6)
0 0 0 0 0 0 0 bi=3
1 0 0 3 3
wi=2
2 0
w=3
3 0
w-wi =1
4 0
if wi <= w // item i can be part of the solution
if bi + V[i-1,w-wi] > V[i-1,w]
V[i,w] = bi + V[i-1,w- wi]
else
V[i,w] = V[i-1,w]
else V[i,w] = V[i-1,w] // wi > w
 Items:
In Class Exercise 1: (2,3)
2: (3,4)
3: (4,5)
i\W 0 1 2 3 4 5 i=1 4: (5,6)
0 0 0 0 0 0 0 bi=3
1 0 0 3 3 3
wi=2
2 0
w=4
3 0
w-wi =2
4 0
if wi <= w // item i can be part of the solution
if bi + V[i-1,w-wi] > V[i-1,w]
V[i,w] = bi + V[i-1,w- wi]
else
V[i,w] = V[i-1,w]
else V[i,w] = V[i-1,w] // wi > w
 Items:
In Class Exercise 1: (2,3)
2: (3,4)
3: (4,5)
i\W 0 1 2 3 4 5 i=1 4: (5,6)
0 0 0 0 0 0 0 bi=3
1 0 0 3 3 3 3
wi=2
2 0
w=5
3 0
w-wi =3
4 0
if wi <= w // item i can be part of the solution
if bi + V[i-1,w-wi] > V[i-1,w]
V[i,w] = bi + V[i-1,w- wi]
else
V[i,w] = V[i-1,w]
else V[i,w] = V[i-1,w] // wi > w
 Items:
In Class Exercise 1: (2,3)
2: (3,4)
3: (4,5)
i\W 0 1 2 3 4 5 i=2 4: (5,6)
0 0 0 0 0 0 0 bi=4
1 0 0 3 3 3 3
wi=3
2 0 0
w=1
3 0
w-wi =-2
4 0
if wi <= w // item i can be part of the solution
if bi + V[i-1,w-wi] > V[i-1,w]
V[i,w] = bi + V[i-1,w- wi]
else
V[i,w] = V[i-1,w]
else V[i,w] = V[i-1,w] // wi > w
 Items:
In Class Exercise 1: (2,3)
2: (3,4)
3: (4,5)
i\W 0 1 2 3 4 5 i=2 4: (5,6)
0 0 0 0 0 0 0 bi=4
1 0 0 3 3 3 3
wi=3
2 0 0 3
w=2
3 0
w-wi =-1
4 0
if wi <= w // item i can be part of the solution
if bi + V[i-1,w-wi] > V[i-1,w]
V[i,w] = bi + V[i-1,w- wi]
else
V[i,w] = V[i-1,w]
else V[i,w] = V[i-1,w] // wi > w
 Items:
In Class Exercise 1: (2,3)
2: (3,4)
3: (4,5)
i\W 0 1 2 3 4 5 i=2 4: (5,6)
0 0 0 0 0 0 0 bi=4
1 0 0 3 3 3 3
wi=3
2 0 0 3 4
w=3
3 0
w-wi =0
4 0
if wi <= w // item i can be part of the solution
if bi + V[i-1,w-wi] > V[i-1,w]
V[i,w] = bi + V[i-1,w- wi]
else
V[i,w] = V[i-1,w]
else V[i,w] = V[i-1,w] // wi > w
 Items:
In Class Exercise 1: (2,3)
2: (3,4)
3: (4,5)
i\W 0 1 2 3 4 5 i=2 4: (5,6)
0 0 0 0 0 0 0 bi=4
1 0 0 3 3 3 3
wi=3
2 0 0 3 4 4
w=4
3 0
w-wi =1
4 0
if wi <= w // item i can be part of the solution
if bi + V[i-1,w-wi] > V[i-1,w]
V[i,w] = bi + V[i-1,w- wi]
else
V[i,w] = V[i-1,w]
else V[i,w] = V[i-1,w] // wi > w
 Items:
In Class Exercise 1: (2,3)
2: (3,4)
3: (4,5)
i\W 0 1 2 3 4 5 i=2 4: (5,6)
0 0 0 0 0 0 0 bi=4
1 0 0 3 3 3 3
wi=3
2 0 0 3 4 4 7
w=5
3 0
w-wi =2
4 0
if wi <= w // item i can be part of the solution
if bi + V[i-1,w-wi] > V[i-1,w]
V[i,w] = bi + V[i-1,w- wi]
else
V[i,w] = V[i-1,w]
else V[i,w] = V[i-1,w] // wi > w
 Items:
In Class Exercise 1: (2,3)
2: (3,4)
3: (4,5)
i\W 0 1 2 3 4 5 i=3 4: (5,6)
0 0 0 0 0 0 0 bi=5
1 0 0 3 3 3 3
wi=4
2 0 0 3 4 4 7
w= 1..3
3 0 0 3 4
4 0
if wi <= w // item i can be part of the solution
if bi + V[i-1,w-wi] > V[i-1,w]
V[i,w] = bi + V[i-1,w- wi]
else
V[i,w] = V[i-1,w]
else V[i,w] = V[i-1,w] // wi > w
 Items:
In Class Exercise 1: (2,3)
2: (3,4)
3: (4,5)
i\W 0 1 2 3 4 5 i=3 4: (5,6)
0 0 0 0 0 0 0 bi=5
1 0 0 3 3 3 3
wi=4
2 0 0 3 4 4 7
w= 4
3 0 0 3 4 5
w- wi=0
4 0
if wi <= w // item i can be part of the solution
if bi + V[i-1,w-wi] > V[i-1,w]
V[i,w] = bi + V[i-1,w- wi]
else
V[i,w] = V[i-1,w]
else V[i,w] = V[i-1,w] // wi > w
 Items:
In Class Exercise 1: (2,3)
2: (3,4)
3: (4,5)
i\W 0 1 2 3 4 5 i=3 4: (5,6)
0 0 0 0 0 0 0 bi=5
1 0 0 3 3 3 3
wi=4
2 0 0 3 4 4 7
w= 5
3 0 0 3 4 5 7
w- wi=1
4 0
if wi <= w // item i can be part of the solution
if bi + V[i-1,w-wi] > V[i-1,w]
V[i,w] = bi + V[i-1,w- wi]
else
V[i,w] = V[i-1,w]
else V[i,w] = V[i-1,w] // wi > w
 Items:
In Class Exercise 1: (2,3)
2: (3,4)
3: (4,5)
i\W 0 1 2 3 4 5 i=4 4: (5,6)
0 0 0 0 0 0 0 bi=6
1 0 0 3 3 3 3
wi=5
2 0 0 3 4 4 7
w= 1..4
3 0 0 3 4 5 7
4 0 0 3 4 5
if wi <= w // item i can be part of the solution
if bi + V[i-1,w-wi] > V[i-1,w]
V[i,w] = bi + V[i-1,w- wi]
else
V[i,w] = V[i-1,w]
else V[i,w] = V[i-1,w] // wi > w
 Items:
In Class Exercise 1: (2,3)
2: (3,4)
3: (4,5)
i\W 0 1 2 3 4 5 i=4 4: (5,6)
0 0 0 0 0 0 0 bi=6
1 0 0 3 3 3 3
wi=5
2 0 0 3 4 4 7
w= 5
3 0 0 3 4 5 7
w- wi=0
4 0 0 3 4 5 7
if wi <= w // item i can be part of the solution
if bi + V[i-1,w-wi] > V[i-1,w]
V[i,w] = bi + V[i-1,w- wi]
else
V[i,w] = V[i-1,w]
else V[i,w] = V[i-1,w] // wi > w
 0-1 Knapsack Algorithm
for w = 0 to W
V[0,w] = 0
for i = 1 to n
V[i,0] = 0
for i = 1 to n
for w = 0 to W
if wi <= w // item i can be part of the solution
if bi + V[i-1,w-wi] > V[i-1,w]
V[i,w] = bi + V[i-1,w- wi]
else
V[i,w] = V[i-1,w]
else V[i,w] = V[i-1,w] // wi > w
 Running time

for w = 0 to W
O(W)
V[0,w] = 0
for i = 1 to n
V[i,0] = 0
for i = 1 to n Repeat n times
for w = 0 to W O(W)
< the rest of the code >
What is the running time of this algorithm?
O(n*W)
Remember that the brute-force algorithm
takes O(2n)
 Conclusion we achieved till now

Dynamic programming is a useful technique

of solving certain kind of problems
When the solution can be recursively
described in terms of partial solutions, we can
store these partial solutions and re-use them
as necessary (memorization)
Running time of dynamic programming
algorithm vs. nave algorithm:
0-1 Knapsack problem: O(W*n) vs. O(2n)
 Rock Climbing Problem

A rock climber wants to get

from the bottom of a rock to
the top by the safest possible
path.

At every step, he reaches for

handholds above him; some
holds are safer than other.

From every place, he can only

reach a few nearest
handholds.
 Rock climbing (cont)

Suppose we have a
wall instead of the rock. 4
5 3
2
At every step our climber can reach exactly three
handholds: above, above and to the right and
above and to the left.

There is a table of danger ratings provided. The

Danger of a path is the sum of danger ratings of
all handholds on the path.
 Rock Climbing (cont)
We represent the wall as a 22 8 9 55 8
table.
4 44 6 22 3
Every cell of the table contains 5 7 5 6 11
the danger rating of the 3 22 5 44 8
corresponding block.
The obvious greedy algorithm does not give an
optimal solution.The rating of this path is 13.
The rating of an optimal path is 12.
However, we can solve this problem by a
dynamic programming strategy in polynomial
time.
Idea: once we know the rating of a path to
every handhold on a layer, we can easily
compute the ratings of the paths to the
holds on the next layer.

For the top layer, that gives us an

answer to the problem itself.
For every handhold, there is only one
path rating. Once we have reached a
hold, we dont need to know how we got
there to move to the next level.

This is called an optimal substructure property.

Once we know optimal solutions to
subproblems, we can compute an optimal
solution to the problem itself.
Recursive solution:

To find the best way to get to stone j in row

i, check the cost of getting to the stones
(i-1,j-1),
(i-1,j) and
(i-1,j+1), and take the cheapest.

Problem: each recursion level makes three

calls for itself, making a total of 3n calls
too much!
Solution - memorization

We query the value of A(i,j) over and over

again.
Instead of computing it each time, we can
compute it once, and remember the value.

A simple recurrence allows us to compute

A(i,j) from values below.
 Dynamic programming

Step 1: Describe an array of values you want

to compute.

Step 2: Give a recurrence for computing later

values from earlier (bottom-up).

Step 3: Give a high-level program.

Step 4: Show how to use values in the array

to compute an optimal solution.
 Rock climbing: step 1.

Step 1: Describe an array of values you want

to compute.

For 1 i n and 1 j m, define A(i,j) to be

the cumulative rating of the least dangerous
path from the bottom to the hold (i,j).

The rating of the best path to the top will be

the minimal value in the last row of the array.
 Rock climbing: step 2.
Step 2: Give a recurrence for computing later values from
earlier (bottom-up).

Let C(i,j) be the rating of the hold (i,j). There are three
cases for A(i,j):

Left (j=1): C(i,j)+min{A(i-1,j),A(i-1,j+1)}

Right (j=m): C(i,j)+min{A(i-1,j-1),A(i-1,j)}

Middle: C(i,j)+min{A(i-1,j-1),A(i-1,j),A(i-1,j+1)}

For the first row (i=1), A(i,j)=C(i,j).

 Rock climbing: simpler step 2

Add initialization row: A(0,j)=0. No danger to

stand on the ground.

Add two initialization columns:

A(i,0)=A(i,m+1)=. It is infinitely dangerous to
try to hold on to the air where the wall ends.

Now the recurrence becomes, for every i,j:

A(i,j) = C(i,j)+min{A(i-1,j-1),A(i-1,j),A(i-1,j+1)}
 Rock climbing: example
C(i,j): A(i,j):

3 2 5 4 8 i\j 0 1 2 3 4 5 6
5 7 5 6 1 0 0 0 0 0 0
4 4 6 2 3 1
2 8 9 5 8 2
3
4

Initialization: A(i,0)=A(i,m+1)=, A(0,j)=0

 Rock climbing: example
C(i,j): A(i,j):

3 2 5 4 8 i\j 0 1 2 3 4 5 6
5 7 5 6 1 0 0 0 0 0 0
4 4 6 2 3 1 3 2 5 4 8
2 8 9 5 8 2
3
4

The values in the first row are the same as C(i,j).

 Rock climbing: example
C(i,j): A(i,j):

3 2 5 4 8 i\j 0 1 2 3 4 5 6
5 7 5 6 1 0 0 0 0 0 0
4 4 6 2 3 1 3 2 5 4 8
2 8 9 5 8 2 7
3
4

A(2,1)=5+min{,3,2}=7.
 Rock climbing: example
C(i,j): A(i,j):

3 2 5 4 8 i\j 0 1 2 3 4 5 6
5 7 5 6 1 0 0 0 0 0 0
4 4 6 2 3 1 3 2 5 4 8
2 8 9 5 8 2 7 9
3
4

A(2,1)=5+min{,3,2}=7. A(2,2)=7+min{3,2,5}=9
 Rock climbing: example
C(i,j): A(i,j):

3 2 5 4 8 i\j 0 1 2 3 4 5 6
5 7 5 6 1 0 0 0 0 0 0
4 4 6 2 3 1 3 2 5 4 8
2 8 9 5 8 2 7 9 7
3
4

A(2,1)=5+min{,3,2}=7. A(2,2)=7+min{3,2,5}=9
A(2,3)=5+min{2,5,4}=7.
 Rock climbing: example
C(i,j): A(i,j):

3 2 5 4 8 i\j 0 1 2 3 4 5 6
5 7 5 6 1 0 0 0 0 0 0
4 4 6 2 3 1 3 2 5 4 8
2 8 9 5 8 2 7 9 7 10 5
3
4

The best cumulative rating on the second row is 5.

 Rock climbing: example
C(i,j): A(i,j):

3 2 5 4 8 i\j 0 1 2 3 4 5 6
5 7 5 6 1 0 0 0 0 0 0
4 4 6 2 3 1 3 2 5 4 8
2 8 9 5 8 2 7 9 7 10 5
3 11 11 13 7 8
4

The best cumulative rating on the third row is 7.

 Rock climbing: example
C(i,j): A(i,j):

3 2 5 4 8 i\j 0 1 2 3 4 5 6
5 7 5 6 1 0 0 0 0 0 0
4 4 6 2 3 1 3 2 5 4 8
2 8 9 5 8 2 7 9 7 10 5
3 11 11 13 7 8
4 13 19 16 12 15

The best cumulative rating on the last row is 12.

 Rock climbing: example
C(i,j): A(i,j):

3 2 5 4 8 i\j 0 1 2 3 4 5 6
5 7 5 6 1 0 0 0 0 0 0
4 4 6 2 3 1 3 2 5 4 8
2 8 9 5 8 2 7 9 7 10 5
3 11 11 13 7 8
4 13 19 16 12 15

The best cumulative rating on the last row is 12.

So the rating of the best path to the top
is 12.
 Rock climbing example: step 4
C(i,j): A(i,j):

3 2 5 4 8 i\j 0 1 2 3 4 5 6
5 7 5 6 1 0 0 0 0 0 0
4 4 6 2 3 1 3 2 5 4 8
2 8 9 5 8 2 7 9 7 10 5
3 11 11 13 7 8
4 13 19 16 12 15

To find the actual path we need to retrace backwards

the decisions made during the calculation of A(i,j).
 Rock climbing example: step 4
C(i,j): A(i,j):
i\j 0 1 2 3 4 5 6
3 2 5 4 8
0 0 0 0 0 0
5 7 5 6 1
1 3 2 5 4 8
4 4 6 2 3
2 7 9 7 10 5
2 8 9 5 8
3 11 11 13 7 8
The last hold was (4,4). 4 13 19 16 12 15

To find the actual path we need to retrace backwards

the decisions made during the calculation of A(i,j).
 Rock climbing example: step 4
C(i,j): A(i,j):
i\j 0 1 2 3 4 5 6
3 2 5 4 8
0 0 0 0 0 0
5 7 5 6 1
1 3 2 5 4 8
4 4 6 2 3
2 7 9 7 10 5
2 8 9 5 8
3 11 11 13 7 8
The hold before the last 4 13 19 16 12 15
was (3,4), since
min{13,7,8} was 7.

To find the actual path we need to retrace backwards

the decisions made during the calculation of A(i,j).
 Rock climbing example: step 4
C(i,j): A(i,j):
i\j 0 1 2 3 4 5 6
3 2 5 4 8
0 0 0 0 0 0
5 7 5 6 1
1 3 2 5 4 8
4 4 6 2 3
2 7 9 7 10 5
2 8 9 5 8
3 11 11 13 7 8
The hold before that 4 13 19 16 12 15
was (2,5), since
min{7,10,5} was 5.

To find the actual path we need to retrace backwards

the decisions made during the calculation of A(i,j).
 Rock climbing example: step 4
C(i,j): A(i,j):
i\j 0 1 2 3 4 5 6
3 2 5 4 8
0 0 0 0 0 0
5 7 5 6 1
1 3 2 5 4 8
4 4 6 2 3
2 7 9 7 10 5
2 8 9 5 8
3 11 11 13 7 8
Finally, the first hold 4 13 19 16 12 15
was (1,4), since
min{5,4,8} was 4.

To find the actual path we need to retrace backwards

the decisions made during the calculation of A(i,j).
 Rock climbing example: step 4
C(i,j): A(i,j):
i\j 0 1 2 3 4 5 6
3 2 5 4 8
0 0 0 0 0 0
5 7 5 6 1
1 3 2 5 4 8
4 4 6 2 3
2 7 9 7 10 5
2 8 9 5 8
3 11 11 13 7 8
4 13 19 16 12 15

We are done!