Scribd
Upload
23 views

DynamicProgramming1

The document discusses various dynamic programming problems and algorithms. It covers topics like rod cutting, stamp problem, matrix chain multiplication, longest common subsequence, weighted interval scheduling, knapsack problem, and Fibonacci numbers. It also discusses the concepts of optimal subproblems and memoization in dynamic programming.

Uploaded by

59xxq2xd8q
Copyright
© © All Rights Reserved
Available Formats
Download as PDF, TXT or read online on Scribd
23 views

DynamicProgramming1

The document discusses various dynamic programming problems and algorithms. It covers topics like rod cutting, stamp problem, matrix chain multiplication, longest common subsequence, weighted interval scheduling, knapsack problem, and Fibonacci numbers. It also discusses the concepts of optimal subproblems and memoization in dynamic programming.

Uploaded by

59xxq2xd8q
Copyright
© © All Rights Reserved
Available Formats
Download as PDF, TXT or read online on Scribd
You are on page 1/ 15

Slides credited from Hsueh-I Lu, Hsu-Chun Hsiao, & Michael Tsai

 Dynamic Programming
 DP #1: Rod Cutting
 DP #2: Stamp Problem
 DP #3: Matrix-Chain Multiplication
 DP #4: Sequence Alignment Problem
 Longest Common Subsequence (LCS) / Edit Distance
 Viterbi Algorithm
 Space Efficient Algorithm

 DP #5: Weighted Interval Scheduling


 DP #6: Knapsack Problem
 0/1 Knapsack
 Unbounded Knapsack
 Multidimensional Knapsack
 Fractional Knapsack 2
 Do not focus on “specific algorithms”
 But “some strategies” to “design” algorithms

 First Skill: Divide-and-Conquer (各個擊破)


 Second Skill: Dynamic Programming (動態規劃)

3
4

Textbook Chapter 15 – Dynamic Programming


Textbook Chapter 15.3 – Elements of dynamic programming
 Dynamic programming, like the divide-and-conquer
method, solves problems by combining the solutions to
subproblems
 用空間換取時間
 讓走過的留下痕跡

 “Dynamic”: time-varying
 “Programming”: a tabular method
Dynamic Programming: planning over time

5
 Divide-and-Conquer  Dynamic Programming
 partition the problem into  partition the problem into
independent or disjoint dependent or overlapping
subproblems subproblems
 repeatedly solving the common  avoid recomputation
subsubproblems  Top-down with memoization
 more work than necessary  Bottom-up method

6
 Apply four steps
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, typically in a bottom-
up fashion
4. Construct an optimal solution from computed information

7
Fibonacci(n)
 Fibonacci sequence (費波那契數列) if n < 2 // base case
 Base case: F(0) = F(1) = 1 return 1
// recursive case
 Recursive case: F(n) = F(n-1) + F(n-2) return Fibonacci(n-1)+Fibonacci(n-2)

F(5)
 F(3) was computed twice
F(4) F(3)
 F(2) was computed 3 times

F(3) F(2) F(2) F(1)

F(2) F(1) F(1) F(0) F(1) F(0)

F(1) F(0) Calling overlapping subproblems result in poor efficiency 8


 Solve the overlapping subproblems recursively with memoization
 Check the memo before making the calls

F(5)

F(4) F(3) 備忘錄

F(3) F(2)

n 0 1 2 3 4 5
F(2) F(1)
F(n) 1 1 ?2 3? ?5 ?8

F(1) F(0)

9
Avoid recomputation of the same subproblems using memo
Memoized-Fibonacci(n)
// initialize memo (array a[])
a[0] = 1
a[1] = 1
for i = 2 to n
a[i] = 0
return Memoized-Fibonacci-Aux(n, a)

Memoized-Fibonacci-Aux(n, a)
if a[n] > 0
return a[n]
// save the result to avoid recomputation
a[n] = Memoized-Fibonacci-Aux(n-1, a) + Memoized-Fibonacci-Aux(n-2, a)
return a[n]

10
 Building up solutions to larger and larger subproblems

F(5)
Bottom-Up-Fibonacci(n)
if n < 2
F(4) return 1
a[0] = 1
a[1] = 1
F(3) for i = 2 … n
a[i] = a[i-1] + a[i-2]
return a[n]
F(2)

F(1)

F(0)

11
Avoid recomputation of the same subproblems
 Principle of Optimality
 Any subpolicy of an optimum policy must itself be an optimum policy with
regard to the initial and terminal states of the subpolicy
 Two key properties of DP for optimization
 Overlapping subproblems
 Optimal substructure – an optimal solution can be constructed from optimal
solutions to subproblems
 Reduce search space (ignore non-optimal solutions)

If the optimal substructure (principle of optimality)


does not hold, then it is incorrect to use DP

12
 Shortest Path Problem
 Input: a graph where the edges have positive costs
 Output: a path from S to T with the smallest cost

The path costing CSM+ CMT is the shortest path from S to T


 The path with the cost CSM must be a shortest path from S to M
Taipei (T)
CMT
CSM

M
C’SM < CSM?

Proof by “Cut-and-Paste” argument (proof by contradiction):


Suppose that it exists a path with smaller cost C’SM, then we can
Tainan (S) “cut” CSM and “paste” C’SM to make the original cost smaller 13
14
15

Important announcement will be sent to @ntu.edu.tw mailbox


& post to the course website

Course Website: http://ada.miulab.tw


Email: [email protected]

You might also like