Chap12 slides

Dynamic Programming
Ananth Grama, Anshul Gupta, George
Karypis, and Vipin Kumar
To accompany the text ``Introduction to Parallel Computing'', Addison Wesley, 2003

Topic Overview
• Overview of Serial Dynamic Programming
• Serial Monadic DP Formulations
• Nonserial Monadic DP Formulations
• Serial Polyadic DP Formulations
• Nonserial Polyadic DP Formulations

Overview of Serial Dynamic Programming
• Dynamic programming (DP) is used to solve a wide
variety of discrete optimization problems such as
scheduling, string-editing, packaging, and inventory
management.
• Break problems into subproblems and combine their
solutions into solutions to larger problems.
• In contrast to divide-and-conquer, there may be
relationships across subproblems.

Dynamic Programming: Example
• Consider the problem of finding a shortest path between
a pair of vertices in an acyclic graph.
• An edge connecting node i to node j has cost c(i,j).
• The graph contains n nodes numbered 0,1,…, n-1, and
has an edge from node i to node j only if i < j. Node 0 is
source and node n-1 is the destination.
• Let f(x) be the cost of the shortest path from node 0 to
node x.

• A graph for which the shortest path between nodes 0
and 4 is to be computed.

Dynamic Programming
• The solution to a DP problem is typically expressed as a
minimum (or maximum) of possible alternate solutions.
• If r represents the cost of a solution composed of
subproblems x1, x2,…, xl, then r can be written as
Here, g is the composition function.
• If the optimal solution to each problem is determined by
composing optimal solutions to the subproblems and
selecting the minimum (or maximum), the formulation is
said to be a DP formulation.

The computation and composition of subproblem solutions
to solve problem f(x8).

Dynamic Programming
• The recursive DP equation is also called the functional
equation or optimization equation.
• In the equation for the shortest path problem the
composition function is f(j) + c(j,x). This contains a single
recursive term (f(j)). Such a formulation is called
monadic.
• If the RHS has multiple recursive terms, the DP
formulation is called polyadic.

Dynamic Programming
• The dependencies between subproblems can be
expressed as a graph.
• If the graph can be levelized (i.e., solutions to problems
at a level depend only on solutions to problems at the
previous level), the formulation is called serial, else it is
called non-serial.
• Based on these two criteria, we can classify DP
formulations into four categories - serial-monadic, serial-
polyadic, non-serial-monadic, non-serial-polyadic.
• This classification is useful since it identifies concurrency
and dependencies that guide parallel formulations.

Serial Monadic DP Formulations
• It is difficult to derive canonical parallel formulations for
the entire class of formulations.
• For this reason, we select two representative examples,
the shortest-path problem for a multistage graph and the
0/1 knapsack problem.
• We derive parallel formulations for these problems and
identify common principles guiding design within the
class.

Shortest-Path Problem
• Special class of shortest path problem where the graph
is a weighted multistage graph of r + 1 levels.
• Each level is assumed to have n levels and every node
at level i is connected to every node at level i + 1.
• Levels zero and r contain only one node, the source and
destination nodes, respectively.
• The objective of this problem is to find the shortest path
from S to R.

An example of a serial monadic DP formulation for finding
the shortest path in a graph whose nodes can be
organized into levels.

• The ith node at level l in the graph is labeled vi
l and the
cost of an edge connecting vi
l to node vj
l+1 is labeled ci
l
,j.
• The cost of reaching the goal node R from any node vi
l is
represented by Ci
l.
• If there are n nodes at level l, the vector
[C0
l, C1
l,…,
Cn
l
-1]T is referred to as Cl. Note that
C0 = [C0
0].
• We have Ci
l = min {(ci
l
,j + Cj
l+1) | j is a node at level l + 1}

• Since all nodes vj
r-1 have only one edge connecting them
to the goal node R at level r, the cost Cj
r-1 is equal to cj
r
,
-
R
1.
• We have:
Notice that this problem is serial and monadic.

• The cost of reaching the goal node R from any node at
level l is (0 < l < r – 1) is

• We can express the solution to the problem as a
modified sequence of matrix-vector products.
• Replacing the addition operation by minimization and the
multiplication operation by addition, the preceding set of
equations becomes:
where Cl and Cl+1 are n x 1 vectors representing the cost
of reaching the goal node from each node at levels l and
l + 1.

• Matrix Ml,l+1 is an n x n matrix in which entry (i, j) stores
the cost of the edge connecting node i at level l to node j
at level l + 1.
• The shortest path problem has been formulated as a
sequence of r matrix-vector products.

Parallel Shortest-Path
• We can parallelize this algorithm using the parallel
algorithms for the matrix-vector product.
• Θ(n) processing elements can compute each vector Cl in
time Θ(n) and solve the entire problem in time Θ(rn).
• In many instances of this problem, the matrix M may be
sparse. For such problems, it is highly desirable to use
sparse matrix techniques.

0/1 Knapsack Problem
• We are given a knapsack of capacity c and a set of n objects
numbered 1,2,…,n. Each object i has weight wi and profit pi.
• Let v = [v1, v2,…, vn] be a solution vector in which vi = 0 if object i is
not in the knapsack, and vi = 1 if it is in the knapsack.
• The goal is to find a subset of objects to put into the knapsack so
that
(that is, the objects fit into the knapsack) and
is maximized (that is, the profit is maximized).

• The naive method is to consider all 2n possible subsets
of the n objects and choose the one that fits into the
knapsack and maximizes the profit.
• Let F[i,x] be the maximum profit for a knapsack of
capacity x using only objects {1,2,…,i}. The DP
formulation is:

• Construct a table F of size n x c in row-major order.
• Filling an entry in a row requires two entries from the
previous row: one from the same column and one from
the column offset by the weight of the object
corresponding to the row.
• Computing each entry takes constant time; the
sequential run time of this algorithm is Θ(nc).
• The formulation is serial-monadic.

Computing entries of table F for the 0/1 knapsack problem. The computation of
entry F[i,j] requires communication with processing elements containing
entries F[i-1,j] and F[i-1,j-wi].

• Using c processors in a PRAM, we can derive a simple
parallel algorithm that runs in O(n) time by partitioning
the columns across processors.
• In a distributed memory machine, in the jth iteration, for
computing F[j,r] at processing element Pr-1, F[j-1,r] is
available locally but F[j-1,r-wj] must be fetched.
• The communication operation is a circular shift and the
time is given by (ts + tw) log c. The total time is therefore
tc + (ts + tw) log c.
• Across all n iterations (rows), the parallel time is O(n log
c). Note that this is not cost optimal.

• Using p-processing elements, each processing element
computes c/p elements of the table in each iteration.
• The corresponding shift operation takes time (2ts + twc/p),
since the data block may be partitioned across two
processors, but the total volume of data is c/p.
• The corresponding parallel time is n(tcc/p + 2ts + twc/p),
or O(nc/p) (which is cost-optimal).
• Note that there is an upper bound on the efficiency of
this formulation.

Nonserial Monadic DP Formulations: Longest-Common-
Subsequence
• Given a sequence A = <a1, a2,…, an>, a subsequence of
A can be formed by deleting some entries from A.
• Given two sequences A = <a1, a2,…, an> and B = <b1,
b2,…, bm>, find the longest sequence that is a
subsequence of both A and B.
• If A = <c,a,d,b,r,z> and B = <a,s,b,z>, the longest
common subsequence of A and B is <a,b,z>.

Longest-Common-Subsequence Problem
• Let F[i,j] denote the length of the longest common
subsequence of the first i elements of A and the first j
elements of B. The objective of the LCS problem is to
find F[n,m].
• We can write:

• The algorithm computes the two-dimensional F table in a
row- or column-major fashion. The complexity is Θ(nm).
• Treating nodes along a diagonal as belonging to one
level, each node depends on two subproblems at the
preceding level and one subproblem two levels prior.
• This DP formulation is nonserial monadic.

(a) Computing entries of table for the longest-common-
subsequence problem. Computation proceeds along the dotted
diagonal lines. (b) Mapping elements of the table to processing
elements.

Longest-Common-Subsequence: Example
• Consider the LCS of two amino-acid sequences H E A G A W G H E E and P A W H E A E. For the interested
reader, the names of the corresponding amino-acids are A: Alanine, E: Glutamic acid, G: Glycine, H: Histidine, P:
Proline, and W: Tryptophan.
• The F table for computing the LCS of the sequences. The LCS is A W H E E.

Parallel Longest-Common-Subsequence
• Table entries are computed in a diagonal sweep from the
top-left to the bottom-right corner.
• Using n processors in a PRAM, each entry in a diagonal
can be computed in constant time.
• For two sequences of length n, there are 2n-1 diagonals.
• The parallel run time is Θ(n) and the algorithm is cost-
optimal.

Parallel Longest-Common-Subsequence
• Consider a (logical) linear array of processors.
Processing element Pi is responsible for the (i+1)th
column of the table.
• To compute F[i,j], processing element Pj-1 may need
either F[i-1,j-1] or F[i,j-1] from the processing element to
its left. This communication takes time ts + tw.
• The computation takes constant time (tc).
• We have:
• Note that this formulation is cost-optimal, however, its
efficiency is upper-bounded by 0.5!
• Can you think of how to fix this?

Serial Polyadic DP Formulation: Floyd's All-Pairs
Shortest Path
• Given weighted graph G(V,E), Floyd's algorithm
determines the cost di,j of the shortest path between
each pair of nodes in V.
• Let di
k
,j be the minimum cost of a path from node i to
node j, using only nodes v0,v1,…,vk-1.
• We have:
• Each iteration requires time Θ(n2) and the overall run
time of the sequential algorithm is Θ(n3).

Serial Polyadic DP Formulation: Floyd's All-Pairs
Shortest Path
• A PRAM formulation of this algorithm uses n2 processors
in a logical 2D mesh. Processor Pi,j computes the value
of di
k
,j for k=1,2,…,n in constant time.
• The parallel runtime is Θ(n) and it is cost-optimal.
• The algorithm can easily be adapted to practical
architectures, as discussed in our treatment of Graph
Algorithms.

Nonserial Polyadic DP Formulation: Optimal Matrix-
Parenthesization Problem
• When multiplying a sequence of matrices, the order of
multiplication significantly impacts operation count.
• Let C[i,j] be the optimal cost of multiplying the matrices
Ai,…Aj.
• The chain of matrices can be expressed as a product of
two smaller chains, Ai,Ai+1,…,Ak and Ak+1,…,Aj.
• The chain Ai,Ai+1,…,Ak results in a matrix of dimensions
ri-1 x rk, and the chain Ak+1,…,Aj results in a matrix of
dimensions rk x rj.
• The cost of multiplying these two matrices is ri-1rkrj.

Optimal Matrix-Parenthesization Problem
• We have:

A nonserial polyadic DP formulation for finding an optimal matrix
parenthesization for a chain of four matrices. A square node
represents the optimal cost of multiplying a matrix chain. A circle
node represents a possible parenthesization.

• The goal of finding C[1,n] is accomplished in a bottom-up
fashion.
• Visualize this by thinking of filling in the C table
diagonally. Entries in diagonal l corresponds to the cost
of multiplying matrix chains of length l+1.
• The value of C[i,j] is computed as min{C[i,k] + C[k+1,j] +
ri-1rkrj}, where k can take values from i to j-1.
• Computing C[i,j] requires that we evaluate (j-i) terms and
select their minimum.
• The computation of each term takes time tc, and the
computation of C[i,j] takes time (j-i)tc. Each entry in
diagonal l can be computed in time ltc.

• The algorithm computes (n-1) chains of length two. This
takes time (n-1)tc; computing n-2 chains of length three
takes time (n-2)tc. In the final step, the algorithm
computes one chain of length n in time (n-1)tc.
• It follows that the serial time is Θ(n3).

The diagonal order of computation for the optimal matrix-
parenthesization problem.

Parallel Optimal Matrix-Parenthesization Problem
• Consider a logical ring of processors. In step l, each processor computes a
single element belonging to the lth diagonal.
• On computing the assigned value of the element in table C, each processor
sends its value to all other processors using an all-to-all broadcast.
• The next value can then be computed locally.
• The total time required to compute the entries along diagonal l is ltc+tslog
n+tw(n-1).
• The corresponding parallel time is given by:

Parallel Optimal Matrix-Parenthesization Problem
• When using p (<n) processors, each processor stores n/p nodes.
• The time taken for all-to-all broadcast of n/p words is
and the time to compute n/p entries of the table in the lth diagonal is
ltcn/p.
• This formulation can be improved to use up to n(n+1)/2 processors
using pipelining.

Discussion of Parallel Dynamic Programming
Algorithms
• By representing computation as a graph, we identify
three sources of parallelism: parallelism within nodes,
parallelism across nodes at a level, and pipelining nodes
across multiple levels. The first two are available in serial
formulations and the third one in non-serial formulations.
• Data locality is critical for performance. Different DP
formulations, by the very nature of the problem instance,
have different degrees of locality.

Chap12 slides

More Related Content

Similar to Chap12 slides (20)

More from BaliThorat1 (20)

Recently uploaded (20)

Chap12 slides