Computer Science 514
Lab 5: Dynamic Programming
Edit Distance Algorithm Tutorial

The Problem

Determine the shortest edit distance between two strings, a source and a target, that transforms the source into the target. There are three allowable operations that obey a "forward cursor model", i.e. there's a cursor that begins on the first character in the source string and always advances forward to the next character after an edit.

1. Delete: delete a character from the source string and advance to the next character for the next edit operation.
2. Insert: insert a character from the target string before the character at the current cursor location, and advance past the inserted character to the original character for the next edit operation.
3. Change/Match: replace a character from the source string with one from the target string (if the characters are not the same), and advance past the replaced character to the next character for the next edit operation.

The Algorithm

Let the source string be represented by an array of characters S[1..n] and the target string be represented by an array of characters T[1..m]. Then, let the alignment table A be a table with n+1 rows and m+1 columns [0..n, 0..m] filled according to the following rules:

	A[i,j] 	= 0			if i=0 and j=0
		= A[i,j-1]+1		if i=0
		= A[i-1,j]+1		if j=0
		= min{A[i,j-1]+1,	else
		      A[i-1,j]+1,
		      A[i-1,j-1]+match(S[i],T[j])}

	match(S[i],T[j]) = 0 if S[i] = T[j]
			 = 1 otherwise

The value A[i,j] is interpreted as the shortest edit distance between the substrings S[1..i] and T[1..j]. When i=0 or j=0, the corresponding substring is interpreted as empty.

Keeping the Back Pointers

Similar to the knapsack algorithm, we can keep a B table consisting of back pointers. This is similar to the knapsack problem, but we need a different approach since the pointers point to one of two rows and one of two columns. However, there are only three possibilities. One is as follows:

	B[i,j]	= 1 if the value of A[i,j] was taken as A[i-1,j] + 1
		= 2 if the value of A[i,j] was taken as A[i,j-1] + 1
		= 3 if the value of A[i,j] was taken as A[i-1,j-1] + match

Fill in the B table concurrently with the A table. If there are multiple possible ways to fill in an entry in the B table, favor 3 over 1, and favor 1 over 2 (i.e. favor changes over deletes, and deletes over inserts). The fill order, again, is left to right, top to bottom.

Interpreting the Results

Similar to the knapsack algorithm, we follow the pointers from the B table starting at B[n,m] and going until we find a path back to B[0,0]. Each move corresponds to a different edit operation.

• When we go from B[i,j] to B[i-1,j] (i.e. B[i,j] = 1), it means that we skipped past character i in the source, and that character does not correspond to any character in the target; this is a delete operation.
• When we go from B[i,j] to B[i,j-1] (i.e. B[i,j] = 2), it means that we skipped past character j in the target, and that character does not correspond to any character in the source; this is an insert operation.
• When we go from B[i,j] to B[i-1,j-1] (i.e. B[i,j] = 3), it means that we set up a correspondence between character i in the source and character j in the target; this is a match or change operation depending on whether S[i] = T[j] or not.

Following the pointers backwards from B[n,m] to B[0,0] yields the edit operations in reverse (i.e. the first pointer you follow is the last edit operation, the second is the second-to-last, etc.). You can also correlate the edit operations to the line numbers from the original files by using the "forward cursor model" described above. Keep two line number counters, one for the source and one for the target. Both start at 1.

• When you encounter a delete operation, the current value of the source counter is the line number to be deleted from the source; the source counter is then incremented by 1 for the next edit operation.
• When you encounter an insert operation, the current value of the target counter is the line to be inserted into the source and the source counter is the source line immediately before which the line from the target is to be inserted; the target counter is then incremented by 1 for the next edit operation.
• When you encounter a match/change operation, the current value of the target counter is the line to be matched with the source; if the lines are not the same, then there is a change to record, otherwise there is no change. (To tell whether they are the same, you can examine the corresponding values in the A table -- if they are the same, then no change occurred.) The target and source counters are then both incremented by 1 for the next edit operation.

Programming References

If you forget how to use, or need a quick reference for, any functions and classes in Java and C++, many good resources are available on the Internet. For Java programmers, I highly recommend always having the JDK1.3 API Reference handy at any given time. For C++, I personally like cplusplus.com's online reference, but your tastes may vary. Both links above will open in a new window.

Back to lab