- Editing operations:
- A source (text) string
x[0..(n-1)]
- A target (destination) string
y[0..(m-1)]
- Possible editing operations
on strings:
- del(k): delete the
kth character
in
x[0..(n-1)]
Example:
0123456 del(3) abcdefg ----------> abcefg
- ins(c, k): insert
c as the
kth character
in
x[0..(n-1)]
Example:
0123456 ins(x,3) 01234567 abcdefg ------------> abcxdefg
- sub(c, k): replace
the
kth character
in
x[0..(n-1)] by
c
Example:
0123456 sub(x,3) 0123456 abcdefg ------------> abcxefg
- del(k): delete the
kth character
in
x[0..(n-1)]
- A source (text) string
x[0..(n-1)]
- Edit distance:
- The edit distance = the number of edit operations used to transform the source string x[0..(n-1)] into the target string y[0..(m-1)]
- Examples:
- Edit distance from:
man ⇒ moon
012 del(1) man -------------> mn 01 ins('o',2) mn -------------> mon 012 ins('o',2) mon -------------> moonEditDistance( "man", "moon" ) = 3
- Another way
to edit from:
man ⇒ moon is:
012 sub('o',1) man -------------> mon 012 ins('o',2) mon -------------> moonWhich gives EditDistance( "man", "moon" ) = 2
- Edit distance from:
man ⇒ moon
- Minimum edit distance between x[1..(n-1)] and y[0..(m-1)]:
- Minimum edit distance = minumum # edit operations used to transform source string x[0..(n-1)] to the target string y[0..(m-1)]
- Levenshtein distance:
- The minimum edit distance
(based
on the above 3 editing operations)
is
called: the
Levenshtein distance
Wikipedia page: click here
(Named after Vladimir Levenshtein)
- The minimum edit distance
(based
on the above 3 editing operations)
is
called: the
Levenshtein distance
- Finding a
divide and conquer
procedure to edit strings
----- part 1
- Case 1:
last characters are
equal
-
Divide and conquer strategy:
- Fact:
- I do not need to
perform any editing on
the last letters
- I can remove both letters.... (and have a smaller problem too !)
- I do not need to
perform any editing on
the last letters
- The following
smaller problem will
help me solve the
original problem:
- How to solve the
orginal problem with
his solution:
- Fact:
- Case 1:
last characters are
equal
- Finding a
divide and conquer
procedure to edit strings
----- part 2
- Case 2:
last characters are
not equal
- Divide and conquer strategy:
- Fact:
- We must perform some editing operation of the last character position in the source string
- The editing operation
that can be performed on the
last letter position in
the source string
can be
one of the following:
- A delete operation:
- An insert operation:
- A substitute operation:
- A delete operation:
- We must find a
smaller (size) problem
to help us
solve the
original problem in
each case !!!
- The smaller problems
that will help us
solve the
original problem:
- If the
editing operation
is a delete operation:
How to use the solution to solve the original problem:
- If the
editing operation
is an insert operation:
How to use the solution to solve the original problem:
- If the
editing operation
is a substitute operation:
How to use the solution to solve the original problem:
- If the
editing operation
is a delete operation:
- How to
obtain the
final answer:
- Fact:
- Case 2:
last characters are
not equal
- Define:
- T(i,j) =
the minumum # edit operations
needed to transform:
x[0..(i-1)] -----> y[0..(j-1)] (length=i) (length=j)
- T(i,j) =
the minumum # edit operations
needed to transform:
- The minimum edit distance problem:
- Given a source and
target string:
x = x[0..(n-1)] (length = n) y = y[0..(m-1)] (length = m)
- Find:
T(n,m)
- Given a source and
target string:
- Summary of the
divide and conquer procedure:
- Psuedo code
of the algorithm in the
above diagram:
T( x, y, n, m ) { // I wull ignore the base cases for now.... /* ================================== The divide and conquer procedure =================================== */ if ( last char in x == last char in y ) { /* ------------------------------------ Last char's in strings are equal ------------------------------------ */ sol1 = T( x, y, n-1, m-1 ); // Solve smaller problem MySol = sol1 + 1; // Use solution to solve my problem return(MySol); } else { /* ------------------------------------------- Last char's in strings are NOT equal Divide: Try: delete, insert or substitute ------------------------------------------- */ sol1 = T(x, y, i-1, j); // Subproblem when edit oper is delete sol2 = T(x, y, i, j-1); // Subproblem when edit oper is insert sol3 = T(x, y, i-1, j-1); // Subproblem when edit oper is substit /* ------------------------------------------- Conquer: solve original problem using solution from smaller problems ------------------------------------------- */ MySol1 = sol1 + 1; // Cost of my solution if I used delete MySol2 = sol2 + 1; // Cost of my solution if I used insert MySol3 = sol3 + 1; // Cost of my solution if I usde substitute MySol = min( MySol1, MySol2, MySol3 ); return(MySol); } }
- The Base Case(s):
- If string x is
empty,
then only way to
edit x to y is:
- Insert the characters
of y
- We will need to use m insert operations
Example:
- Insert the characters
of y
- If string y is
empty,
then only way to
edit x to y is:
- Delete the characters
in x
- We will need to use n delete operations
Example:
- Delete the characters
in x
- If string x is
empty,
then only way to
edit x to y is:
- Therefore:
T(0, m) = m (we need to insert m characters into x to get y) T(n, 0) = n (we need to delete n characters from x to get y)
- The recursive solution
(divide and conquer) is:
int MinEditDistance(A, B, i, j) { int sol1, sol2, sol3; /* --------------------------- Base cases --------------------------- */ if ( i == 0 ) // x = "" { return(j); // Uses j insertions } if ( j == 0 ) // y = "" { return(i); // Uses i deletions... } /* -------------------------------------------------- The other cases.... -------------------------------------------------- */ if ( A[i] == B[j] ) { /* ------------------------ Divide step ------------------------ */ sol1 = T(i-1, j-1); /* --------------------------------------- Conquer: solve original problem using solution from smaller problems --------------------------------------- */ return(sol1); } else { /* ------------------------ Divide step ------------------------ */ sol1 = T(i-1, j); // Try delete step as last sol2 = T(i, j-1); // Try insert step as last sol3 = T(i-1, j-1); // Try replace step as last /* --------------------------------------- Conquer: solve original problem using solution from smaller problems --------------------------------------- */ sol1 = sol1 + 1; sol2 = sol2 + 1; sol3 = sol3 + 1; /* --------------------------------------- Return min(sol1, sol2, sol3) --------------------------------------- */ if ( sol1 <= sol2 && sol1 <= sol3 ) return(sol1); if ( sol2 <= sol1 && sol2 <= sol3 ) return(sol2); if ( sol3 <= sol1 && sol3 <= sol2 ) return(sol3); } return(0); // This dummy statement is needed to Java compiler happy... }
- Example Program:
(Demo above code)
- Prog file: click here
How to run the program:
- Right click on link(s) and
save in a scratch directory
- To compile: javac MED.java
- To run: java MED
Sample output:
String x = man String y = moon Min. Edit Distance = 2
String x = mad String y = moon Min. Edit Distance = 3
- The Computer Science way to do this is to use a
similar approach as
Hirschberg's algorithm for LCS.
- Here, I like to show you an
easier way
by passing intermediate solution
to the recursive call
The added code is highlighted in RED:
static int min = Integer.MAX_VALUE; static String ans = ""; static int T(String x, String y, int i, int j, int n, String s) { int sol1, sol2, sol3; /* --------------------------- Base cases --------------------------- */ if ( i == 0 ) { if ( n + j <= min ) { min = n + j; // Remember the current min if ( j > 0 ) ans = s + j + " ins()"; else ans = s; } return(j); } if ( j == 0 ) { if ( n + i <= min ) { min = n + i; // Remember the current min if ( i > 0 ) ans = s + i + " del()"; else ans = s; } return(i); } /* =========================================== The other cases =========================================== */ if ( x.charAt(i-1) == y.charAt(j-1) ) { sol1 = T(x, y, i-1, j-1, n, s /* No addition edit ops */); return(sol1); } else { /* ------------------------ Divide step ------------------------ */ sol1 = T(x, y, i-1, j, n+1, s + "del(" + (i-1) + ");"); // Try delete step as last sol2 = T(x, y, i, j-1, n+1, s + "ins("+ y.charAt(j-1)+"," + (i-1) + ");"); // Try insert step as last sol3 = T(x, y, i-1, j-1, n+1, s + "sub("+ x.charAt(i-1) + "->"+ y.charAt(j-1)+"," + (i-1) + ");"); // Try replace step as last /* --------------------------------------- Conquer: solve original problem using solution from smaller problems --------------------------------------- */ sol1 = sol1 + 1; sol2 = sol2 + 1; sol3 = sol3 + 1; if ( sol1 <= sol2 && sol1 <= sol3 ) return(sol1); if ( sol2 <= sol1 && sol2 <= sol3 ) return(sol2); if ( sol3 <= sol1 && sol3 <= sol2 ) return(sol3); } return(0); // To please the stupid Java compiler }
- Example Program:
(Demo above code)
- Prog file: click here
- Can be easily obtianed
from the recursive solution
using this formula:
- Initialize
the base cases in the
T[][]
- Compute the value in T[][] starting from the smaller indices to larger indices
- Initialize
the base cases in the
T[][]
- Botton-up Dynamic Programming for Min. Edit Distance:
static int[][] T; // Store the result of T(i,j) static int compT(String x, String y) { int sol1, sol2, sol3; int i, j; /* --------------------------- Base cases --------------------------- */ for ( i = 0; i <= x.length(); i++ ) T[i][0] = i; for ( j = 0; j <= y.length(); j++ ) T[0][j] = j; /* ------------------------ The other cases... ------------------------ */ for ( i = 1; i <= x.length(); i++ ) for ( j = 1; j <= y.length(); j++ ) { if ( x.charAt(i-1) == y.charAt(j-1) ) { sol1 = T[i-1][j-1]; T[i][j] = sol1; } else { /* ------------------------ Divide step ------------------------ */ sol1 = T[i-1][j]; // Try delete step as last step sol2 = T[i][j-1]; // Try insert step as last step sol3 = T[i-1][j-1]; // Try replace step as last step /* --------------------------------------- Conquer: solve original problem using solution from smaller problems --------------------------------------- */ sol1 = sol1 + 1; sol2 = sol2 + 1; sol3 = sol3 + 1; if ( sol1 <= sol2 && sol1 <= sol3 ) T[i][j] = sol1; if ( sol2 <= sol1 && sol2 <= sol3 ) T[i][j] = sol2; if ( sol3 <= sol1 && sol3 <= sol2 ) T[i][j] = sol3; } } /* ----------------------------- Return the final answer... ----------------------------- */ return(T[x.length()][y.length()]); }
- Example Program:
(Demo above code)
- Prog file: click here
- The subproblems that the
program solves are:
- L(i,j) where i = 1..n and j = 1..m
- So there are n × m
subproblems
Each subproblem can be solved with O(1) time (find the minimum of 3 numbers)
- Hence:
- running time = O(n × m)