DYNAMIC PROGRAMMING STUDY GUIDE

UNDER CONSTRUCTION

Dynamic programming can be applied to optimization problems that exhibit two properties:

• Optimal structure the optimal solution to a problem can be computed from optimal solutions to smaller subproblems.
• Overlapping subproblems the process of recursively breaking the problem into subproblems, subproblems of subproblems, subproblems of subproblems of subproblems and so on, results in some subproblems being repeated.

There are two implementation strategies for dynamic programming: top-down (memoization) and bottom-up (tabulation).

Memoization. Implements dynamic programming as a recursive procedure. To solve a sub-problem, we simply call the recursive procedure on the subproblem, with one crucial optimization: whenever we finish a recursive call, we cache its result, and whenever we begin a recursive call, we return the cached result if there is one.

Bottom-up dynamic programming. Implements dynamic programming by identifying all the subproblems of a given problem and the dependencies among subproblems. The subproblems are then solved in dependency order (i.e., starting a problem that has no subproblems, and working up to the original problem). Bottom-up dynamic programming is typically implemented using loops rather than recursion.

Backtracing. It is often convenient to solve optimization problems in two steps. The first step computes the optimal value of the solution using dynamic programming. The second step, backtracing, computes the optimal solution by using a top-down procedure. Backtracing saves the cost of computing and storing the optimal solution to every subproblem.
Top-down computation of the optimal solution to the problem typically involves selecting among a set of alternative subproblems for a problem. Since we have already cached the optimal values to each subproblem, we may use the optimal value to select among the alternatives rather than searching through all of them.

Recommended Problems

C level

1. Consider the following recursive function:

         public int f(int n, int m) {
           if (n == 0) {
             return m;
           }
           return f(n - 1, m + 1) + f(n - 1, m);
         }
       

   What is the time complexity (in Θ notation) of f, as a function of n and m? What is its time complexity if the function is memoized?
   Answers
   The function takes Θ(2ⁿ) time: its recursion tree corresponds to a full binary tree of height n, which has size 2ⁿ.
   If the function is memoized, then it can be evaluated in Θ(n²) time, since it needs only to evaluate f(i, j) once for every i between 0 and n and every j between m and m + n - i.

B level

1. Let G be a directed graph with vertices 1, 2, ... n and with positive edge weights. For any vertices x, m, y, let d(x,m,y) be the weight of the shortest path from x to y that does not pass through any vertex greater than or equal to m. Write a dynamic programming recurrence for d(x,m,y).
   Answers
   • d(x,0,y) = the weight of the edge (x,y) if it belongs to G, ∞ otherwise
   • d(x,m,y) = min (d(x,m-1,y), d(x,m-1,m) + d(m,m-1,y))

   For the base case: the only paths that do not pass through a vertex greater than or equal to zero (that is, any vertex at all) are those consisting of a single edge. For the recursive case: the shortest path from x to y that does not pass through any vertex greater than m must pass through m either 0 times (in which case d(x,m,y) = d(x,m-1,y)) or 1 time (in which case the shortest path consist of a shortest path from x to m followed by a shortest path from m to y, which has weight d(x,m-1,m) + d(m,m-1,y)).
   This recurrence corresponds to the Floyd-Warshall all-pairs shortest path algorithm.

A level

1. A subsequence of a string a = a₀a₁...a_n is a string of the form a = a_i1a_i2...a_im where 0 <= i₁ < i₂ ... < i_m < n. That is, a subsequence consists of characters that belong to the original string, in the same order that they are in the original string. For example, subsequences of "Hello, world" include "Hello", "Held", "lord", ...
   The longest common subsequence of a pair of strings a and b is a string that is a subsequence of both a and b, and which has maximal length among all common subsequences of a and b. Develop an efficient algorithm for computing the length of the longest common subsequence of two strings. The time complexity must not exceed O(nm) where m and n are the lengths of the a and b.
   Answers
   Let s(i,j) be the length of the longest common subsequence of the strings a₀a₁...a_i-1 and b₀b₁...b_j-1. It satisfies the following recurrence:

   • s(i,0) = 0
   • s(0,j) = 0
   • s(i,j) = s(i-1,j-1) + 1 if a_i = b_j
   • s(i,j) = max(s(i-1,j), s(i,j-1)) if a_i != b_j

   The rationale for the above recurrence is that that longest common subsequence of a string and an empty string is the empty string (so s(i,0) = s(0,j) = 0 for all i and j), and the longest common subsequence of a₀a₁...a_i and and b₀b₁...b_j either (1) includes both a_i-1 and b_j-1 (in which case a_i-1 = b_j-1 and s(i,j) = s(i-1,j-1) + 1), or (2) does not include a_i-1 (in which case s(i,j) = s(i-1,j)), or (3) does not include b_j-1 (in which case s(i,j) = s(i,j-1)). The length of the longest common subsequence of a and b can be computed by the following bottom-up dynamic programming algorithm:

       // Initialize base case
       for i = 0 to m
         s[i][0] = 0
       for j = 0 to n
         s[0][j] = 0
       // recursive case
       for i = 1 to m
         for j = 1 to n
           if a[i-1] = b[j-1] then
             s[i][j] = s[i-1][j-1] + 1
           else
             s[i][j] = max(s[i-1][j], s[i][j-1])
       return s[m][n]
   

2. Use your solution to the previous exercise to compute the longest common subsequence of two strings.
   Answers

       // s[i][j] is the length of the longest common subsequence of
       // a[0]a[2]...a[i] and b[0]b[2]...b[j]
       i = m
       j = n
       stack = empty
       while (i > 0 && j > 0):
         if s[i][j] == s[i-1][j] then
           i--
         else if s[i][j] == s[i][j-1] then
           j--
         else // s[i][j] must be s[i-1][j-1] + 1, and a[i-1] must be equal to b[j-1]
           stack.push(a[i-1])
           i--
           j--
       return stack