Unit 4: Dynamic Programming
․Course contents:





Assembly-line scheduling
Matrix-chain multiplication
Longest common subsequence
Optimal binary search trees
Applications: Cell flipping, rod cutting, optimal polygon
triangulation, flip-chip routing, technology mapping for logic
synthesis
․Reading:

Chapter 15
Unit 4
Y.-W. Chang
1
Dynamic Programming (DP) vs. Divide-and-Conquer
․ Both solve problems by combining the solutions to subproblems.
․ Divide-and-conquer algorithms


Partition a problem into independent subproblems, solve the
subproblems recursively, and then combine their solutions to solve
the original problem.
Inefficient if they solve the same subproblem more than once.
․ Dynamic programming (DP)


Unit 4
Applicable when the subproblems are not independent.
DP solves each subproblem just once.
Y.-W. Chang
2
1
Assembly-line Scheduling
station S1,1 S1,2
line 1
a1,1
e1
chassis
enters
e2
line 2
a1,2
S1,3
S1,n
S1,n-1
a1,3
a1,n-1
a1,n
t1,1
t1,2
t1,n-1
t2,1
t2,2
t2,n-1
a2,1
a2,2
a2,3
a2,n-1
x1
auto
exits
x2
a2,n
S2,n
S2,3
S2,n-1
station S2,1 S2,2
․ An auto chassis enters each assembly line, has parts added at
stations, and a finished auto exits at the end of the line.
 Si,j: the jth station on line i
 ai,j: the assembly time required at station Si,j
 ti,j: transfer time from station Si,j to the j+1 station of the other line.
 ei (xi): time to enter (exit) line i
Unit 4
3
Y.-W. Chang
Optimal Substructure
line 1
e1
chassis
enters
e2
S1,1
S1,2
S1,3
a1,1
a1,2
a1,3
S1,n-1
a1,n-1
t1,1
t1,2
t1,n-1
t2,1
t2,2
t2,n-1
line 2 a2,1
S2,1
a2,2
S2,2
a2,3
a2,n-1
S2,3
S2,n-1
S1,n
a1,n
x1
x2
auto
exits
a2,n
S2,n
․Objective: Determine the stations to choose to minimize the
total manufacturing time for one auto.
Brute force: (2n), why?
 The problem is linearly ordered and cannot be rearranged =>
Dynamic programming?
․ Optimal substructure: If the fastest way through station Si,j is
through S1,j-1, then the chassis must have taken a fastest way from
the starting point through S1,j-1.

Unit 4
Y.-W. Chang
4
2
Overlapping Subproblem: Recurrence
line 1
S1,1
S1,2
S1,3
a1,1
a1,2
a1,3
e1
chassis
enters
e2
S1,n-1
a1,n-1
t1,1
t1,2
t1,n-1
t2,1
t2,2
t2,n-1
line 2 a2,1
S2,1
a2,2
a2,3
S2,2
a2,n-1
S2,3
S2,n-1
S1,n
a1,n
x1
x2
auto
exits
a2,n
S2,n
․ Overlapping subproblem: The fastest way through station S1,j is
either through S1,j-1 and then S1,j , or through S2,j-1 and then transfer to
line 1 and through S1,j.
․ fi[j]: fastest time from the starting point through Si,j
if j  1
e1  a1, 1
f 1[ j ]  
 min( f 1[ j  1]  a1, j , f 2[ j  1]  t 2, j  1  a1, j ) if j  2
․ The fastest time all the way through the factory
f* = min(f1[n] + x1, f2[n] + x2)
Unit 4
5
Y.-W. Chang
Computing the Fastest Time
Fastest-Way(a, t, e, x, n)
1. f1[1] = e1 + a1,1
2. f2[1] = e2 + a2,1
3. for j = 2 to n
4.
if f1[j-1] + a1,j  f2[j-1] + t2,j -1 + a1,j
5.
f1[j] = f1[j-1] + a1,j
6.
l1[j] = 1
7.
else f1[j] = f2[j-1] + t2,j -1 + a1,j
8.
l1[j] = 2
9.
if f2[j-1] + a2,j  f1[j-1] + t1,j -1 + a2,j
10.
f2[j] = f2[j-1] + a2,j
11.
l2[j] = 2
12. else f2[j] = f1[j-1] + t1,j -1 + a2,j
13.
l2[j] = 1
14. if f1[n] + x1  f2[n] + x2
15.
f* = f1[n] + x1
16.
l* = 1
17. else f* = f2[n] + x2
18.
l* = 2
Running time?
Linear time!!
․ li[j]: The line number whose station j-1 is used in a fastest way
Unit 4
through Si,j
Y.-W. Chang
6
3
Constructing the Fastest Way
Print-Station(l, n)
1. i = l*
2. Print “line” i “, station “ n
3. for j = n downto 2
4.
i = li[j]
5.
Print “line “ i “, station “ j-1
line 1, station 6
line 2, station 5
line 2, station 4
line 1, station 3
line 2, station 2
line 1, station 1
S1,1
S1,2
S1,3
S1,4
S1,5
S1,6
7
9
3
4
8
4
line 1
2
chassis
enters
4
2
3
1
3
4
2
1
2
2
1
line 2 8
S2,1
3
2
5
6
4
5
7
S2,2
S2,3
S2,4
S2,5
S2,6
Unit 4
auto
exits
7
Y.-W. Chang
An Example
S1,1
S1,2
S1,3
S1,4
S1,5
S1,6
7
9
3
4
8
4
line 1
2
chassis
enters
4
line 2
2
3
2
1
8
5
S2,1
Unit 4
S2,2
3
1
3
4
2
2
1
6
4
5
7
S2,3
S2,4
S2,5
S2,6
f1[j]
9
18
20
24
32
35
f2[j]
12
16
22
25
30
37
j
1
2
3
4
5
6
l1[j]
1
2
1
1
2
l2[j]
1
2
1
2
2
Y.-W. Chang
2
auto
exits
f* = 38
l* = 1
8
4
Dynamic Programming (DP)
․ Typically apply to optimization problem.
․ Generic approach
Calculate the solutions to all subproblems.
Proceed computation from the small subproblems to
larger subproblems.
 Compute a subproblem based on previously computed
results for smaller subproblems.
 Store the solution to a subproblem in a table and never
recompute.
․ Development of a DP
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 bottom-up.
4. Construct an optimal solution from computed information
(omitted if only the optimal value is required).


Unit 4
Y.-W. Chang
9
When to Use Dynamic Programming (DP)
․DP computes recurrence efficiently by storing partial results 
efficient only when the number of partial results is small.
․Hopeless configurations: n! permutations of an n-element set,
2n subsets of an n-element set, etc.
n
․Promising configurations:  i 1 i  n(n  1) / 2 contiguous
substrings of an n-character string, n(n+1)/2 possible subtrees
of a binary search tree, etc.
․DP works best on objects that are linearly ordered
and cannot be rearranged!!


Unit 4
Linear assembly lines, matrices in a chain, characters in a
string, points around the boundary of a polygon, points on a
line/circle, the left-to-right order of leaves in a search tree,
fixed-order cell flipping, etc.
Objects are ordered left-to-right  Smell DP?
Y.-W. Chang
10
5
DP Example: Matrix-Chain Multiplication
․If A is a p x q matrix and B a q x r matrix, then C = AB is
a p x r matrix
q
C[i, j ]   A[i, k ] B[k , j ]
time complexity: O(pqr).
k 1
Matrix-Multiply(A, B)
1. if A.columns ≠ B.rows
2.
error “incompatible dimensions”
3. else let C be a new A.rows * B.columns matrix
4.
for i = 1 to A.rows
5.
for j = 1 to B.columns
6.
cij = 0
7.
for k = 1 to A.columns
8.
cij = cij + aikbkj
9.
return C
Unit 4
Y.-W. Chang
11
DP Example: Matrix-Chain Multiplication
․The matrix-chain multiplication problem


Input: Given a chain <A1, A2, …, An> of n matrices,
matrix Ai has dimension pi-1 x pi
Objective: Parenthesize the product A1 A2 … An to
minimize the number of scalar multiplications
․Exp: dimensions: A1: 4 x 2; A2: 2 x 5; A3: 5 x 1
(A1A2)A3: total multiplications = 4 x 2 x 5 + 4 x 5 x 1 = 60
A1(A2A3): total multiplications = 2 x 5 x 1 + 4 x 2 x 1 = 18
․So the order of multiplications can make a big difference!
Unit 4
Y.-W. Chang
12
6
Matrix-Chain Multiplication: Brute Force
․A = A1 A2 … An: How to evaluate A using the minimum
number of multiplications?
․Brute force: check all possible orders?
 P(n): number of ways to multiply n matrices.
, exponential in n.
․Any efficient solution?


The matrix chain is linearly ordered and
cannot be rearranged!!

Unit 4
Smell Dynamic programming?
Y.-W. Chang
13
Matrix-Chain Multiplication
․m[i, j]: minimum number of multiplications to compute
matrix Ai..j = Ai Ai +1 … Aj, 1  i  j  n.
 m[1, n]: the cheapest cost to compute A1..n.
matrix Ai has dimension pi-1 x pi
․Applicability of dynamic programming


Unit 4
Optimal substructure: an optimal solution contains
within its optimal solutions to subproblems.
Overlapping subproblem: a recursive algorithm
revisits the same problem over and over again; only
(n2) subproblems.
Y.-W. Chang
14
7
Bottom-Up DP Matrix-Chain Order
Ai dimension
pi-1 x pi
Matrix-Chain-Order(p)
1. n = p.length – 1
2. Let m[1..n, 1..n] and s[1..n-1, 2..n] be new tables
3. for i = 1 to n
4.
m[i, i] = 0
5. for l = 2 to n
// l is the chain length
6.
for i = 1 to n – l +1
7.
j = i + l -1
8.
m[i, j] = 
9.
for k = i to j -1
10.
q = m[i, k] + m[k+1, j] + pi-1pkpj
11.
if q < m[i, j]
12.
m[i, j] = q
13.
s[i, j] = k
14. return m and s
s
Unit 4
15
Y.-W. Chang
Constructing an Optimal Solution
․ s[i, j]: value of k such that the optimal parenthesization of
Ai Ai+1 … Aj splits between Ak and Ak+1
․ Optimal matrix A1..n multiplication: A1..s[1, n]As[1, n] + 1..n
․ Exp: call Print-Optimal-Parens(s, 1, 6): ((A1 (A2 A3))((A4 A5) A6))
Print-Optimal-Parens(s, i, j)
1. if i == j
2.
print “A”i
3. else print “(“
4.
Print-Optimal-Parens(s, i, s[i, j])
5.
Print-Optimal-Parens(s, s[i, j] + 1, j)
6.
print “)“
s
0
Unit 4
Y.-W. Chang
16
8
Top-Down, Recursive Matrix-Chain Order
․Time complexity: (2n) (T(n) >

n 1
(T(k)+T(n-k)+1)).
k 1
Recursive-Matrix-Chain(p, i, j)
1. if i == j
2. return 0
3. m[i, j] = 
4. for k = i to j -1
5
q = Recursive-Matrix-Chain(p,i, k)
+ Recursive-Matrix-Chain(p, k+1, j) + pi-1pkpj
6.
if q < m[i, j]
7.
m[i, j] = q
8. return m[i, j]
Unit 4
Y.-W. Chang
17
Top-Down DP Matrix-Chain Order (Memoization)
․Complexity: O(n2) space for m[] matrix and O(n3) time to fill in
O(n2) entries (each takes O(n) time)
Memoized-Matrix-Chain(p)
1. n = p.length - 1
2. let m[1..n, 1..n] be a new table
2. for i = 1 to n
3.
for j = i to n
4.
m[i, j] = 
5. return Lookup-Chain(m, p,1,n)
Lookup-Chain(m, p, i, j)
1. if m[i, j] < 
2. return m[i, j]
3. if i == j
4.
m[ i, j] = 0
5. else for k = i to j -1
6.
q = Lookup-Chain(m, p, i, k) + Lookup-Chain(m, p, k+1, j) + pi-1pkpj
7.
if q < m[i, j]
8.
m[i, j] = q
9. return m[i, j]
Unit 4
Y.-W. Chang
18
9
Two Approaches to DP
1. Bottom-up iterative approach

Start with recursive divide-and-conquer algorithm.

Find the dependencies between the subproblems (whose
solutions are needed for computing a subproblem).

Solve the subproblems in the correct order.
2. Top-down recursive approach (memoization)

Start with recursive divide-and-conquer algorithm.

Keep top-down approach of original algorithms.

Save solutions to subproblems in a table (possibly a lot of
storage).

Recurse only on a subproblem if the solution is not already
available in the table.
․ If all subproblems must be solved at least once, bottom-up DP is
better due to less overhead for recursion and table maintenance.
․ If many subproblems need not be solved, top-down DP is better
since it computes only those required.
Unit 4
Y.-W. Chang
19
Longest Common Subsequence
․Problem: Given X = <x1, x2, …, xm> and
Y = <y1, y2, …, yn>, find the longest common
subsequence (LCS) of X and Y.
․Exp: X = <a, b, c, b, d, a, b> and Y = <b, d, c, a, b, a>
LCS = <b, c, b, a> (also, LCS = <b, d, a, b>).
․Exp: DNA sequencing:
 S1 = ACCGGTCGAGATGCAG;
S2 = GTCGTTCGGAATGCAT;
LCS S3 = CGTCGGATGCA
․Brute-force method:
 Enumerate all subsequences of X and check if they
appear in Y.
 Each subsequence of X corresponds to a subset of
the indices {1, 2, …, m} of the elements of X.
m subsequences of X. Why?
 There are 2
Unit 4
Y.-W. Chang
20
10
Optimal Substructure for LCS
․Let X = <x1, x2, …, xm> and Y = <y1, y2, …, yn> be
sequences, and Z = <z1, z2, …, zk> be LCS of X and Y.
1. If xm = yn, then zk = xm = yn and Zk-1 is an LCS of Xm-1 and Yn-1.
2. If xm ≠ yn, then zk ≠ xm implies Z is an LCS of Xm-1 and Y.
3. If xm ≠ yn, then zk ≠ yn implies Z is an LCS of X and Yn-1.
․c[i, j]: length of the LCS of Xi and Yj
․c[m, n]: length of LCS of X and Y
․Basis: c[0, j] = 0 and c[i, 0] = 0
Unit 4
Y.-W. Chang
21
Top-Down DP for LCS
․ c[i, j]: length of the LCS of Xi and Yj, where Xi = <x1, x2, …, xi>
and Yj=<y1, y2, …, yj>.
․ c[m, n]: LCS of X and Y.
․ Basis: c[0, j] = 0 and c[i, 0] = 0.
․ The top-down dynamic programming: initialize c[i, 0] = c[0, j] = 0,
c[i, j] = NIL
TD-LCS(i, j)
1. if c[i,j] == NIL
2. if xi == yj
3.
c[i, j] = TD-LCS(i-1, j-1) + 1
4. else c[i, j] = max(TD-LCS(i, j-1), TD-LCS(i-1, j))
5. return c[i, j]
Unit 4
Y.-W. Chang
22
11
Bottom-Up DP for LCS
․Find the right order to
solve the subproblems
․To compute c[i, j], we
need c[i-1, j-1], c[i-1, j],
and c[i, j-1]
․b[i, j]: points to the table
entry w.r.t. the optimal
subproblem solution
chosen when computing
c[i, j]
Unit 4
LCS-Length(X,Y)
1. m = X.length
2. n = Y.length
3. let b[1..m, 1..n] and c[0..m, 0..n]
be new tables
4. for i = 1 to m
5.
c[i, 0] = 0
6. for j = 0 to n
7.
c[0, j] = 0
8. for i = 1 to m
9.
for j = 1 to n
10.
if xi == yj
11.
c[i, j] = c[i-1, j-1]+1
12.
b[i, j] = “↖”
13.
elseif c[i-1,j]  c[i, j-1]
14.
c[i,j] = c[i-1, j]
15.
b[i, j] = ``  ''
16.
else c[i, j] = c[i, j-1]
17.
b[i, j] = “  “
18. return c and b
Y.-W. Chang
23
Example of LCS
․ LCS time and space complexity: O(mn).
․ X = <A, B, C, B, D, A, B> and Y = <B, D, C, A, B, A> 
LCS = <B, C, B, A>.
Unit 4
Y.-W. Chang
24
12
Constructing an LCS
․Trace back from b[m, n] to b[1, 1], following the arrows:
O(m+n) time.
Print-LCS(b, X, i, j)
1. if i == 0 or j == 0
2. return
3. if b[i, j] == “↖ “
4. Print-LCS(b, X, i-1, j-1)
5. print xi
6. elseif b[i, j] == “  “
7. Print-LCS(b, X, i -1, j)
8. else Print-LCS(b, X, i, j-1)
Unit 4
25
Y.-W. Chang
Optimal Binary Search Tree
․Given a sequence K = <k1, k2, …, kn> of n distinct keys in
sorted order (k1 < k2 < … < kn) and a set of probabilities P =
<p1, p2, …, pn> for searching the keys in K and Q = <q0, q1,
q2, …, qn> for unsuccessful searches (corresponding to D =
<d0, d1, d2, …, dn> of n+1 distinct dummy keys with di
representing all values between ki and ki+1), construct a
binary search tree whose expected search cost is smallest.
k 2 p2
k2
p1 k
1
d0
q0
k 4 p4
k 3 p3
d1
q1
d2
q2
Unit 4
d3
q3
k1
k 5 p5
d4
q4
d5
q5
Y.-W. Chang
d0
k5
d4
k3
d2
d5
k4
d1
d3
26
13
An Example
0
i
1
2
3
4
5
pi
0.15 0.10 0.05 0.10 0.20
qi
0.05 0.10 0.05 0.05 0.05 0.10
d0
k3
d1
Cost = 2.80
d2
d0
k5 0.20×3
d3
d5
k4
d1
d4
k3
d2
n
E[search cost in T ] =
i 0
k5
d5 0.10×4
d4
i 1
k1
k4 0.10×2
k1
n
 pi   qi  1
k2
k2 0.10×1 (depth 0)
0.15×2
n
d3
Cost = 2.75
Optimal!!
n
 (depthT (ki)  1)  pi   (depthT (di)  1)  qi
i 1
n
n
i 0
 1   depthT (ki )  pi   depthT (di )  qi
i 1
Unit 4
i 0
Y.-W. Chang
27
Optimal Substructure
․If an optimal binary search tree T has a subtree T’
containing keys ki, …, kj, then this subtree T’ must be
optimal as well for the subproblem with keys ki, …, kj
and dummy keys di-1, …, dj.


Given keys ki, …, kj with kr (i  r  j) as the root, the left subtree
contains the keys ki, …, kr-1 (and dummy keys di-1, …, dr-1) and
the right subtree contains the keys kr+1, …, kj (and dummy keys
dr, …, dj).
For the subtree with keys ki, …, kj with root ki, the left subtree
contains keys ki, .., ki-1 (no key) with the dummy key di-1.
k2
k1
d0
k5
d4
k3
d2
Unit 4
d5
k4
d1
d3
Y.-W. Chang
28
14
Overlapping Subproblem: Recurrence
․e[i, j] : expected cost of searching an optimal binary
search tree containing the keys ki, …, kj.


Want to find e[1, n].
e[i, i -1] = qi-1 (only the dummy key di-1).
Node depths increase
by 1 after merging two
subtrees, and so do
the costs
․If kr (i  r  j) is the root of an optimal subtree containing
keys ki, …, kj and let w(i, j )   p   q then
j
l i
j
l
l  i 1
l
e[i, j] = pr + (e[i, r-1] + w(i, r-1)) + (e[r+1, j] +w(r+1, j))
= e[i, r-1] + e[r+1, j] + w(i, j)
if j  i  1
․Recurrence: e[i, j ]   qi  1
 min{e[i, r  1]  e[r  1, j ]  w(i, j )} if i  j
 i r  j
k4 0.10×1
k3
k5 0.20×2
d2 d3 d4 d5 0.10×3
Unit 4
29
Y.-W. Chang
Computing the Optimal Cost
․ Need a table e[1..n+1, 0..n] for e[i, j] (why e[1, 0] and e[n+1, n]?)
․ Apply the recurrence to compute w(i, j) (why?)
k4
if j  i  1
 qi  1
w[i, j ]  
 w[i, j  1]  pj  qj if i  j
Optimal-BST(p, q, n)
1. let e[1..n+1, 0..n], w[1..n+1, 0..n],
and root[1..n, 1..n] be new tables
2. for i = 1 to n + 1
3.
e[i, i-1] = qi-1
4.
w[i, i-1] = qi-1
5. for l = 1 to n
6.
for i = 1 to n – l + 1
7.
j = i + l -1
8.
e[i, j] = 
9.
w[i, j] = w[i, j-1] + pj + qj
10.
for r = i to j
11.
t = e[i, r-1] + e[r+1, j] + w[i, j]
12.
if t < e[i, j]
13.
e[i, j] = t
14.
root[i, j] = r
15. return e and root
Unit 4
Y.-W. Chang
k3
k5
d2 d3 d4 d5
․root[i, j] : index r for which
kr is the root of an optimal
search tree containing
keys ki, …, kj.
5
e
1
2.75 2
1.75 2.00 3 i
j 3
1.25 1.20 1.30 4
2
0.90 0.70 0.60 0.90 5
1
0.45 0.40 0.25 0.30 0.50 6
0
0.05 0.10 0.05 0.05 0.05 0.10
4
30
15
Example
i
0
1
2
3
4
5
e[1, 1] = e[1, 0] + e[2, 1] + w(1,1)
pi
0.15 0.10 0.05 0.10 0.20
= 0.05 + 0.10 + 0.3
e
= 0.45
0.05
0.10
0.05 0.05 0.05 0.10
q
i
1
5
i
j
root
2.75
2
4
5
1
3 1.75 2.00 3
2 2
4
j
2
4 3i
3
4
2 1.25 1.20 1.30
2
2
2
5
4
1 0.90 0.70 0.60 0.90
5
1
2
4
1
5
5
0.45
0.40
0.30
0.50
0.25
0
6
1 2
4
5
3
0.05
0.10
0.05
5
0.05
w
0.10
0.05
1
1.00
2
0.70 0.80 3
3
0.55 0.50 0.60
4
j
2
i
e[1, 5] = e[1, 1] + e[3, 5] + w(1,5)
= 0.45 + 1.30 + 1.00 = 2.75
k2 (r = 2; r=1, 3?)
k1
4
0.45 0.35 0.30 0.50
5
0.30
0.25
0.20
0.35
0.15
0
6
0.05 0.10 0.05 0.05 0.05 0.10
1
Unit 4
Y.-W. Chang
d0
k5
d4
k3
d2
d5
k4
d1
d3
31
Appendix A: Cell Compaction with Flipping
․Different cell boundaries need different minimum spacing
Optimize cell orientations to get smaller chip area

Flip c2
Smaller spacing
․Consider the cells in a single row with a fixed cell order
Exhibit optimal substructure  Dynamic programming (DP)

,
min
∈
∗
min
,
,
,
,
1 T: cost function
: #cells in row j
1 : minimum spacing
: nodes of cell flipping
graph
∗
: node of optimal solution
, : the two orientations
∈ ,
Y.-W. Chang
16
Example of DP-Based Cell Flipping
0
45
10
Unflipped
Flip c2 and c4
0
39
4
10
3
2
1
3
3
2
1
4
Flipped
4
2
10
6
∗
5
Cell flipping graph
,
min
∈
∗
,
,
,
min
1
0
1
10
,
0
0
3 , 0
2
12
10
0
1 , 0
2
4
12
2 , 11
1
16
4
12
3 , 11
4
19
11
i 1
i 2
i 3
i 4
0
12
16
32
10
16
6 , 19
4
32
29
10
16
3 , 19
5
29
10
32,29
0
11
19
∗
∗
39
39
linear-time dynamic programming
Y.-W. Chang
Appendix B: Rod Cutting
․Cut steel rods into pieces to maximize the revenue

Assumptions: Each cut is free; rod lengths are integral numbers.
․Input: A length n and table of prices pi, for i = 1, 2, …, n.
․Output: The maximum revenue obtainable for rods whose
lengths sum to n, computed as the sum of the prices for the
individual rods.
length i
1
2
3
4
5
6
7
8
9
10
price pi
1
5
8
9
10
17
17
20
24
30
9
1
5
8
8
5
1
length i = 4
max revenue 1 1
r4 = 5+5 =10
5
1
5
1
5
1 1
1
1 1
1
Objects are linearly ordered (and cannot be rearranged)??
Unit 4
Y.-W. Chang
34
17
Optimal Rod Cutting
length i
1
2
3
4
5
6
7
8
9
10
price pi
1
5
8
9
10
17
17
20
24
30
max
revenue ri 1
5
8
10
13
17
18
22
25
30
․ If pn is large enough, an optimal solution might require no cuts, i.e.,
just leave the rod as n unit long.
․ Solution for the maximum revenue ri of length i
rn  max( pn, r1  rn  1, r 2  rn  2,..., rn  1  r1)  max ( pi  rn  i )
r1 = 1
r2 = 5
r3 = 8
r4 = 10
r5 = 13
r6 = 17
r7 = 18
r8 = 22
from solution 1 =
from solution 2 =
from solution 3 =
from solution 4 =
from solution 5 =
from solution 6 =
from solution 7 =
from solution 8 =
1 (no cuts)
2 (no cuts)
3 (no cuts)
2+2
2+3
6 (no cuts)
1 + 6 or 7 = 2 + 2 + 3
2+6
Unit 4
1 i  n
35
Y.-W. Chang
Optimal Substructure
length i
1
2
3
4
5
6
7
8
9
10
price pi
1
5
8
9
10
17
17
20
24
30
max revenue ri
1
5
8
10
13
17
18
22
25
30
․Optimal substructure: To solve the original problem, solve
subproblems on smaller sizes. The optimal solution to the
original problem incorporates optimal solutions to the
subproblems.

We may solve the subproblems independently.
․After making a cut, we have two subproblems.

Max revenue r7: r7 = 18 = r4 + r3 = (r2 + r2) + r3 or r1 + r6
rn  max( pn, r1  rn  1, r 2  rn  2,..., rn  1  r1)
․Decomposition with only one subproblem: Some cut gives a first
piece of length i on the left and a remaining piece of length n - i on
the right.
rn 
( pi  rn  i )
max
1i  n
Unit 4
Y.-W. Chang
36
18
Recursive Top-Down “Solution”
rn  max ( pi  rn  i )
1i  n
Cut-Rod(p, n)
1. if n == 0
2.
return 0
3. q = - ∞
4. for i = 1 to n
5.
q = max(q, p[i] + Cut-Rod(p, n - i))
6. return q
․ Inefficient solution: Cut-Rod calls itself repeatedly, even on
subproblems it has already solved!!
if n  0
 1,
 n 1
T (n)  1  T ( j ), if n  0.
 
j 0
T(n) = 2n
Cut-Rod(p, 1)
Cut-Rod(p, 0)
Unit 4
Cut-Rod(p, 4)
Cut-Rod(p, 3)
Overlapping
subproblems?
Y.-W. Chang
37
Top-Down DP Cut-Rod with Memoization
․Complexity: O(n2) time

Solve each subproblem just once, and solves subproblems for
sizes 0,1, …, n. To solve a subproblem of size n, the for loop
iterates n times.
Memoized-Cut-Rod(p, n)
1. let r[0..n] be a new array
2. for i = 0 to n
3.
r[i] = - 
4. return Memoized-Cut-Rod -Aux(p, n, r)
Memoized-Cut-Rod-Aux(p, n, r)
1. if r[n] ≥ 0
// Each overlapping subproblem
2.
return r[n]
// is solved just once!!
3. if n == 0
4.
q=0
5. else q = - ∞
6.
for i = 1 to n
7.
q = max(q, p[i] + Memoized-Cut-Rod -Aux(p, n-i, r))
8. r[n] = q
9. return q
Unit 4
Y.-W. Chang
38
19
Bottom-Up DP Cut-Rod
․Complexity: O(n2) time


Sort the subproblems by size and solve smaller ones first.
When solving a subproblem, have already solved the
smaller subproblems we need.
Bottom-Up-Cut-Rod(p, n)
1. let r[0..n] be a new array
2. r[0] = 0
3. for j = 1 to n
4.
q= -∞
5.
for i = 1 to j
6.
q = max(q, p[i] + r[j – i])
7.
r[j] = q
8. return r[n]
Unit 4
39
Y.-W. Chang
Bottom-Up DP with Solution Construction
․Extend the bottom-up
approach to record not
just optimal values, but
optimal choices.
․ Saves the first cut made in
an optimal solution for a
problem of size i in s[i].
5
Print-Cut-Rod-Solution(p, n)
1. (r, s) = Extended-Bottom-Up-Cut-Rod(p, n)
2. while n > 0
3.
print s[n]
4.
n = n – s[n]
17
1
Unit 4
5
i
0
1
r[i]
0
1
s[i]
0
1
2
Extended-Bottom-Up-Cut-Rod(p, n)
1. let r[0..n] and s[0..n] be new arrays
2. r[0] = 0
3. for j = 1 to n
4.
q= -∞
5.
for i = 1 to j
6.
if q < p[i] + r[j – i]
7.
q = p[i] + r[j – i]
8.
s[j] = i
9.
r[j] = q
10. return r and s
3
4
5
6
7
8
9
10
5
8
10
13
17
18
22
25
30
2
3
2
2
6
1
2
3
10
Y.-W. Chang
40
20
Appendix C: Optimal Polygon Triangulation
․ Terminology: polygon, interior, exterior, boundary, convex polygon,
triangulation?
․ The Optimal Polygon Triangulation Problem: Given a convex
polygon P = <v0, v1, …, vn-1> and a weight function w defined on
triangles, find a triangulation that minimizes   w().
․ One possible weight function on triangle:
w(vivjvk)=|vivj| + |vjvk| + |vkvi|,
where |vivj| is the Euclidean distance from vi to vj.
Unit 4
Y.-W. Chang
41
Optimal Polygon Triangulation (cont'd)
․ Correspondence between full parenthesization, full binary tree
(parse tree), and triangulation


full parenthesization  full binary tree
full binary tree (n-1 leaves)  triangulation (n sides)
․ t[i, j]: weight of an optimal triangulation of polygon <vi-1, vi, …, vj>.
Unit 4
Y.-W. Chang
42
21
Pseudocode: Optimal Polygon Triangulation
․ Matrix-Chain-Order is a special case of the optimal polygonal
triangulation problem.
․ Only need to modify Line 9 of Matrix-Chain-Order.
․ Complexity: Runs in (n3) time and uses (n2) space.
Optimal-Polygon-Triangulation(P)
1. n = P.length
2. for i = 1 to n
3.
t[i,i] = 0
4. for l = 2 to n
5.
for i = 1 to n – l + 1
6.
j=i+l-1
7.
t[i, j] = 
8.
for k = i to j-1
9.
q = t[i, k] + t[k+1, j ] + w( vi-1 vk vj)
10.
if q < t[i, j]
11.
t[i, j] = q
12.
s[i,j] = k
13. return t and s
Unit 4
43
Y.-W. Chang
Appendix D: LCS for Flip-Chip/InFO Routing
․ Lee, Lin, and Chang, ICCAD-09; Lin, Lin, Chang, ICCAD-16
․ Given: A set of I/O pads on I/O pad rings, a set of bump
pads on bump pad rings, a set of nets/connections
․ Objective: Connect I/O pads and bump pads according
to a predefined assignment between the I/O and bump
pads such that the total wirelength is minimized
I/O pad
bump pad
ring
(1)
Unit 4
net assignment
(2)
Y.-W. Chang
44
22
Minimize # of Detoured Nets by LCS
․ Cut the rings into lines/segments (form linear orders)
d1
d3
d2
n1
d1
d4
n2
b1
d1
n3
n1
n2
d2
d3
n1
d1
n3
d3
n4
d4
n3
d3
n4
b2
(1)
b3
b4
n3 b1
n2 b2
n1 b3
(2)
n4 b4
Sd=[1,2,1,3,4,3]
Sb=[3,2,1,4]
net sequence
d1
Sd 1 2 1 3 4 3
Sb 0 0 0 0 0 0 0
3 0 0 0 0 1 1 1
d1
d2
2 0 0 1 1 1 1 1
d1
n2
1 0 1 1 2 2 2 2
4 0 1 1 2 2 3 3
b1
Unit 4
Need detour for
only n3
d4
d3
n1
b2
n3
(3)
d3
d3
n4
b3
b4
(4)
45
Y.-W. Chang
#Detours Minimization by Dynamic Programming
Longest common subsequence (LCS) computation
d1
d2
d3
d1
d2
d3
d1
d2
d3
b3
b1
b2
b3
b1
b2
b3
b1
b2
(a)
seq.1=<1,2,3>
seq.2=<3,1,2> (b) Common subseq = <3>
(c) LCS= <1,2>
Maximum planar subset of chords (MPSC) computation
d1
d2
d3
d1
d2
d3
d1
d2
d3
b3
b1
b2
b3
b1
b2
b3
b1
b2
b4
b5
b6
b4
b5
b6
b4
b5
b6
(d) chord set: {3,4,5}
(e) subset:{3}
Y.-W. Chang
(f) MPSC = {4,5}
46
23
Supowit's Algorithm for Finding MPSC
․Supowit, “Finding a maximum planar subset of a set of nets
in a channel,” IEEE TCAD, 1987.
․Problem: Given a set of chords, find a maximum planar
subset of chords.



Label the vertices on the circle 0 to 2n-1.
Compute MIS(i, j): size of maximum independent set between
vertices i and j, i < j.
Answer = MIS(0, 2n-1).
Vertices on the circle
Unit 7
Y.-W. Chang
47
Dynamic Programming in Supowit's Algorithm
․Apply dynamic programming to compute MIS(i, j ).
Unit 7
Y.-W. Chang
48
24
Ring-by-Ring Routing
Over 100X speedups over ILP
․Decompose chip into
rings of pads
․Initialize I/O-pad
sequences
․Route from inner rings to
router rings
․Exchange net order on
current ring to be
consistent with I/O pads’

Keep applying LCS and
MPSC algorithms between
two adjacent rings to
minimize #detours
current ring
preceding ring
49
Y.-W. Chang
Global Routing Results
․The global routing result of circuit fc2624
․A routing path for each net is guided by a set of segments
Segment
Unit 4
Y.-W. Chang
50
25
Detailed Routing: Phase 1
․Segment-by-segment routing in counter-clockwise order
․As compacted as possible
Unit 4
Y.-W. Chang
51
Detailed Routing: Phase 2
․Net-by-net re-routing in clockwise order
․Wirelength and number of bends minimizations
Unit 4
Y.-W. Chang
52
26
Appendix E: Cell Based VLSI Design Style
Unit 4
Y.-W. Chang
53
Pattern Graphs for an Example Library
Unit 4
Y.-W. Chang
54
27
Technology Mapping
․Technology Mapping: The optimization problem of
finding a minimum cost covering of the subject graph by
choosing from the collection of pattern graphs for all
gates in the library.
․A cover is a collection of pattern graphs such that
every node of the subject graph is contained in one (or
more) of the pattern graphs.
․The cover is further constrained so that each input
required by a pattern graph is actually an output of
some other pattern graph.
Unit 4
Y.-W. Chang
55
Trivial Covering
․Mapped into 2-input NANDs and 1-input inverters.
․8 2-input NAND-gates and 7 inverters for an area cost
of 23.
․Best covering?
an example subject graph
Unit 4
Y.-W. Chang
56
28
Optimal Tree Covering by Dynamic Programming
․If the subject directed acyclic graph (DAG) is a tree,
then a polynomial-time algorithm to find the minimum
cover exists.

Based on dynamic programming: optimal substructure?
overlapping subproblems?
․Given: subject trees (networks to be mapped), library
cells
․Consider a node n of the subject tree




Unit 4
Recursive assumption: For all children of n, a best match
which implements the node is known.
Cost of a leaf is 0.
Consider each pattern tree which matches at n, compute
cost as the cost of implementing each node which the
pattern requires as an input plus the cost of the pattern.
Choose the lowest-cost matching pattern to implement n.
Y.-W. Chang
57
Best Covering
․A best covering with an area of 15.
․Obtained by the dynamic programming approach.
Unit 4
Y.-W. Chang
58
29