Dynamic Programming Min Edit Distance Longest Increasing Subsequence Climbing Stairs Minimum Path...
-
Upload
chester-ryan -
Category
Documents
-
view
234 -
download
2
description
Transcript of Dynamic Programming Min Edit Distance Longest Increasing Subsequence Climbing Stairs Minimum Path...
Dynamic ProgrammingMin Edit Distance
Longest Increasing SubsequenceClimbing Stairs
Minimum Path Sum
Min Edit Distance• Given two words X and Y, find the minimum number of steps required
to convert X to Y.
• You have the following 3 operations permitted on a word:• a) Insert a character• b) Delete a character• c) Replace a character
Min Edit Distance• For two strings• X of length n• Y of length m
• We define D(i,j)• the minimum edit distance between X[1..i] and Y[1..j]
• i.e., the first i characters of X and the first j characters of Y• the min edit distance between X and Y is thus D(n, m)
Min Edit Distance• Initialization• D(i, 0) = i
• converting X[1..i] to Y[1..0] (empty string) requires at least i Delete steps• D(0, j) = j
• converting X[1..0] (empty string) to Y[1..j] requires at least j Insert steps
• Recurrent Relation (i,j>0)• D(i, j) = min(
• D(i – 1, j) + 1,• D(i, j – 1) + 1,• D(i – 1, j – 1) + (1 if X(i) != X(j), or 0 if X(i) == X(j))
• )
Min Edit Distance• Recurrent Relation• D(i, j) = the minimum value of the three• D(i – 1, j) + 1
• Converting X[1..i] to Y[1..j] by Delete step• D(i, j – 1) + 1
• Converting X[1..i] to Y[1..j] by Insert step• D(i – 1, j – 1) + (1 if X(i) != X(j), or 0 if X(i) == X(j))
• Converting X[1..i] to Y[1..j] by Replace step if X(i) != X(j)• Or, do nothing if X(i) == X(j)
Min Edit Distance• Initialization• Recurrent Relation• Termination• D(n, m) is the minimum edit distance
Min Edit Distance• How to Implement?• Top-down: Recursion• Bottom-up: Dynamic programming
Min Edit Distance• Top-down solution
• int MED(string X, string Y, int i, int j)• if i == 0 return j• if j == 0 return i
• min_val = MED(X, Y, i – 1, j – 1)• if X.charAt(i-1) != Y.charAt(j-1):
• min_val += 1
• A = MED(X, Y, i – 1, j) + 1• B = MED(X, Y, i, j – 1) + 1• if a < min_val: min_val = a• if b < min_val: min_val = b
• return min_val
Min Edit Distance• Top-down solution• The time complexity of this solution is exponential• In worst case, we may end up doing O(3^m) operations
• The worst case happens when none of characters of two strings match
• Worst case example• X=“abc”• Y=“xyz"
Min Edit Distance• Top-down solution• Worst case example
• X=“abc”• Y=“xyz"
Min Edit Distance• Dynamic Programming
• Bottom-up solution
• int MED(String X, String Y)• m = int[X.length + 1][Y.length + 1]• for i = 0 to X.length + 1:
• for j = 0 to Y.length + 1:• if i == 0: m[0][j] = j• else if j == 0: m[i][0] = i• else:
• min_val = m[i – 1][j – 1]• if X.charAt(i – 1) != Y.charAt(j – 1):
• min_val += 1• if m[i – 1][j] + 1 < min_val: min_val = m[i – 1][j] + 1• if m[i][j – 1] + 1 < min_val: min_val = m[i][j – 1] + 1• m[i][j] = min_val
• return m[X.length][Y.length]
Min Edit Distance• Example• X=“PARK”• Y=“SPAKE”
Min Edit Distance• Example• X=“PARK”• Y=“SPAKE”
Min Edit Distance• Question• How to trace the solution?• R(i, j) = {“R”, “B”, “R-B”}
Longest Increasing Subsequence• For example,• Given K=[10, 9, 2, 5, 3, 7, 101, 18],• The longest increasing subsequence is [2, 3, 7, 101], therefore the
length is 4. Note that there may be more than one LIS combination, it is only necessary for you to return the length.
• We define F(i)• The length of the longest increasing subsequence ending with K(i)• The length of the longest increasing subsequence thus is the maximum value
in array F
Longest Increasing Subsequence• Initialization• F(i) = 1, i=1..n
• Recurrent Relation (0<=j<i)• F(i) = max (
• F(j) + 1, if K(i)>K(j)• )
Longest Increasing Subsequence• LIT(int [] K)
• F = int[K.length]• for i = 0 to K.length:
• F[i] = 1
• for i = 1 to K.length:• for j = 0 to i:
• if K[j] < K[i] and F[j] + 1 > F[i]:• F[i] = F[j] + 1
• int max_l = 0• for i = 0 to F.length:
• if F[i] > max_l:• max_l = F[i]
• return max_l
Climbing Stairs (Fibonacci Sequence)• You are climbing a stair case. It takes n steps to reach to the top.• Each time you can either climb 1 or 2 steps. In how many distinct
ways can you climb to the top?
• We define F(i)• the number of distinct ways we can climb to the i-th step
Climbing Stairs (Fibonacci Sequence)• Initialization
• F(1) = 1• F(2) = 2
• Recurrent Relation (i>2)• F(i) = F(i – 1) + F(i – 2)
• int climbStairs(int n)• if n == 1: return 1• if n == 2: return 2• int a = 1, b = 2;• for i = 2 to n:
• b = a + b• a = b – a
• return b
Minimum Path Sum (Practice)• Given a n x m grid filled(G) with non-negative numbers, find a path
from top left to bottom right which minimizes the sum of all numbers along its path.• Note: You can only move either down or right at any point in time.
Minimum Path Sum• Given a n x m grid filled(G) with non-negative numbers, find a path
from top left to bottom right which minimizes the sum of all numbers along its path.• Note: You can only move either down or right at any point in time.
• We define K(i, j)• The minimum path sum along the path from G(0, 0) to G(i, j) (0 <=i<n,
0<=j<m)• The minimum path sum thus is K(n - 1, m - 1)
Minimum Path Sum• Initialization• K(0, 0) = G(0, 0)• K(0, j) = sum(G(0, 0)...G(0, j)), (0 < j < m)• K(i, 0) = sum(G(0, 0)…G(i, 0)), (0 < i < n)
• Recurrent Relation (0 < i < n, 0 < j < m)• K(i, j) = min (
• K(i – 1, j) + G(i, j),• K(i, j – 1) + G(i, j)
• )
Minimum Path Sum• int MPS(int [][] G):
• n = G.rows, m = G.cols• K = int[n][m]• K[0][0] = G[0][0]
• for i = 1 to n:• K[i][0] = K[i – 1][0] + G[i][0]
• for j = 1 to m:• K[0][j] = k[0][j – 1] + G[0][j]
• for i = 1 to n:• for j = 1 to m:
• K[i][j] = min(K[i – 1][j], K[i][j – 1]) + G[i][j]
• return K[n – 1][m – 1]
Conclusion• Dynamic programming is a method for solving a complex problem by • breaking it down into a collection of simpler subproblems• solving each of those subproblems just once, and storing their solutions -
ideally, using a memory-based data structure• The next time the same subproblem occurs, instead of recomputing its
solution, one simply looks up the previously computed solution, thereby saving computation time at the expense of a (hopefully) modest expenditure in storage space.