Dynamic Programming: Solving Optimization Problems with Recurrences, Study notes of Data Structures and Algorithms

An overview of dynamic programming, a method for solving optimization problems using recurrences. The steps involved in dynamic programming, including obtaining a formulation for the problem state, setting up the recurrence equations, and solving them iteratively. The document also includes an example of the 0/1 knapsack problem and its iterative solution.

Typology: Study notes

Pre 2010

Uploaded on 09/17/2009

koofers-user-emz
koofers-user-emz 🇺🇸

9 documents

1 / 5

Toggle sidebar

This page cannot be seen from the preview

Don't miss anything!

bg1
Dynamic Programming
Steps.
9
View the problem solution as the result of a sequence
of decisions.
9
Obtain a formulation for the problem state.
9
Verify that the principle of optimality holds.
9
Set up the dynamic programming recurrence
equations.
9
Solve these equations for the value of the optimal
solution.
Perform a traceback to determine the optimal
solution.
Dynamic Programming
When solving the dynamic programming
recurrence recursively, be sure to avoid the
recomputation of the optimal value for the
same problem state.
To minimize run time overheads, and hence
to reduce actual run time, dynamic
programming recurrences are almost always
solved iteratively (no recursion).
0/1 Knapsack Recurrence
If wn<= y, f(n,y) = pn.
If wn> y, f(n,y) = 0.
When i < n
f(i,y) = f(i+1,y) whenever y < wi.
f(i,y) = max{f(i+1,y), f(i+1,y-wi) + pi}, y >= wi.
Assume the weights and capacity are integers.
Only f(i,y)s with 1 <= i <= n and 0 <= y <= c
are of interest.
Iterative Solution Example
n = 5, c = 8, w = [4,3,5,6,2], p = [9,7,10,9,3]
y
5
4
3
2
1
f[i][y] 0 1 2 3 4 5 6 7 8
i
Compute f[5][*]
n = 5, c = 8, w = [4,3,5,6,2], p = [9,7,10,9,3]
y
5
4
3
2
1
f[i][y] 0 1 2 3 4 5 6 7 8
i
003333333
Compute f[4][*]
n = 5, c = 8, w = [4,3,5,6,2], p = [9,8,10,9,3]
y
5
4
3
2
1
f[i][y] 0 1 2 3 4 5 6 7 8
i
003333333
0 0 3 3 3 3 9 9 12
f(i,y) = max{f(i+1,y), f(i+1,y-wi) + pi}, y >= wi
pf3
pf4
pf5

Partial preview of the text

Download Dynamic Programming: Solving Optimization Problems with Recurrences and more Study notes Data Structures and Algorithms in PDF only on Docsity!

Dynamic Programming

  • Steps. 9 View the problem solution as the result of a sequence of decisions. 9 Obtain a formulation for the problem state. 9 Verify that the principle of optimality holds. 9 Set up the dynamic programming recurrence equations. 9 Solve these equations for the value of the optimal solution. ƒ Perform a traceback to determine the optimal solution.

Dynamic Programming

  • When solving the dynamic programming recurrence recursively, be sure to avoid the recomputation of the optimal value for the same problem state.
  • To minimize run time overheads, and hence to reduce actual run time, dynamic programming recurrences are almost always solved iteratively (no recursion).

0/1 Knapsack Recurrence

  • If wn <= y, f(n,y) = pn.
  • If wn > y, f(n,y) = 0.
  • When i < n ƒ f(i,y) = f(i+1,y) whenever y < wi. ƒ f(i,y) = max{f(i+1,y), f(i+1,y-wi) + pi}, y >= wi.
  • Assume the weights and capacity are integers.
  • Only f(i,y)s with 1 <= i <= n and 0 <= y <= c are of interest.

Iterative Solution Example

  • n = 5, c = 8, w = [4,3,5,6,2], p = [9,7,10,9,3]

y

f[i][y] 0 1 2 3 4 5 6 7 8

i

Compute f[5][*]

  • n = 5, c = 8, w = [4,3,5,6, 2 ], p = [9,7,10,9, 3 ]

y

f[i][y] 0 1 2 3 4 5 6 7 8

i

0 0 3 3 3 3 3 3 3

Compute f[4][*]

  • n = 5, c = 8, w = [4,3,5, 6 ,2], p = [9,8,10, 9 ,3]

y

f[i][y] 0 1 2 3 4 5 6 7 8

i

0 0 3 3 3 3 3 3 3 0 0 3 3 3 3 9 9 12

f(i,y) = max{f(i+1,y), f(i+1,y-wi) + pi}, y >= wi

Compute f[3][*]

  • n = 5, c = 8, w = [4,3, 5 ,6,2], p = [9,8, 10 ,9,3]

y

f[i][y] 0 1 2 3 4 5 6 7 8

i

0 0 3 3 3 3 3 3 3 0 0 3 3 3 3 9 9 12 0 0 3 3 3 10 10 13 13

f(i,y) = max{f(i+1,y), f(i+1,y-wi) + pi}, y >= wi

Compute f[2][*]

  • n = 5, c = 8, w = [4, 3 ,5,6,2], p = [9, 8 ,10,9,3]

y

f[i][y] 0 1 2 3 4 5 6 7 8

i

0 0 3 3 3 3 3 3 3 0 0 3 3 3 3 9 9 12 0 0 3 3 3 10 10 13 13 0 0 3 8 8 11 11 13 18

f(i,y) = max{f(i+1,y), f(i+1,y-wi) + pi}, y >= wi

Compute f[1][c]

  • n = 5, c = 8, w = [ 4 ,3,5,6,2], p = [ 9 ,8,10,9,3]

y

f[i][y] 0 1 2 3 4 5 6 7 8

i

0 0 3 3 3 3 3 3 3 0 0 3 3 3 3 9 9 12 0 0 3 3 3 10 10 13 13 0 0 3 8 8 11 11 13 18 18

f(i,y) = max{f(i+1,y), f(i+1,y-wi) + pi}, y >= wi

Iterative Implementation

// initialize f[n][] int yMax = Math.min(w[n] - 1, c); for (int y = 0; y <= yMax; y++) f[n][y] = 0; for (int y = w[n]; y <= c; y++) f[n][y] = p[n];

Iterative Implementation

// compute f[i][y], 1 < i < n for (int i = n - 1; i > 1; i--) { yMax = Math.min(w[i] - 1, c); for (int y = 0; y <= yMax; y++) f[i][y] = f[i + 1][y]; for (int y = w[i]; y <= c; y++) f[i][y] = Math.max(f[i + 1][y], f[i + 1][y - w[i]] + p[i]); }

Iterative Implementation

// compute f[1][c] f[1][c] = f[2][c]; if (c >= w[1]) f[1][c] = Math.max(f[1][c], f[2][c-w[1]] + p[1]); }

Complexity Of Traceback

  • O(n)

Matrix Multiplication Chains

  • Multiply an m x n matrix A and an n x p matrix B to get an m x p matrix C.

k = 1

n C(i,j) = A(i,k) * B(k,j)

  • We shall use the number of multiplications as our complexity measure.
  • n multiplications are needed to compute one C(i,j).
  • mnp multiplicatons are needed to compute all mp terms of C.

Matrix Multiplication Chains

  • Suppose that we are to compute the product XYZ of three matrices X, Y and Z.
  • The matrix dimensions are: ƒ X:(100 x 1), Y:(1 x 100), Z:(100 x 1)
  • Multiply X and Y to get a 100 x 100 matrix T. ƒ 100 * 1 * 100 = 10,000 multiplications.
  • Multiply T and Z to get the 100 x 1 answer. ƒ 100 * 100 * 1 = 10,000 multiplications.
  • Total cost is 20,000 multiplications.
  • 10,000 units of space are needed for T.

Matrix Multiplication Chains

  • The matrix dimensions are: ƒ X:(100 x 1) ƒ Y:(1 x 100) ƒ Z:(100 x 1)
  • Multiply Y and Z to get a 1 x 1 matrix T. ƒ 1 * 100 * 1 = 100 multiplications.
  • Multiply X and T to get the 100 x 1 answer. ƒ 100 * 1 * 1 = 100 multiplications.
  • Total cost is 200 multiplications.
  • 1 unit of space is needed for T.

Product Of 5 Matrices

  • Some of the ways in which the product of 5 matrices may be computed. ƒ A(B(C(DE))) right to left ƒ (((AB)C)D)E left to right ƒ (AB)((CD)E) ƒ (AB)(C(DE)) ƒ (A(BC))(DE) ƒ ((AB)C)(DE)

Find Best Multiplication Order

  • Number of ways to compute the product of q matrices is O(4q/q1.5).
  • Evaluating all ways to compute the product takes O(4q/q0.5) time.

An Application

  • Registration of pre- and post-operative 3D brain MRI images to determine volume of removed tumor.

3D Registration

3D Registration

  • Each image has 256 x 256 x 256 voxels.
  • In each iteration of the registration algorithm, the product of three matrices is computed at each voxel … (12 x 3) * (3 x 3) * (3 x 1)
  • Left to right computation => 12 * 3 * 3 + 12 * 3* = 144 multiplications per voxel per iteration.
  • 100 iterations to converge.

3D Registration

  • Total number of multiplications is about 2.4 *
  • Right to left computation => 3 * 3*1 + 12 * 3 * 1 = 45 multiplications per voxel per iteration.
  • Total number of multiplications is about 7.5 *
  • With 108 multiplications per second, time is 40 min vs 12.5 min.