Wagner–Fischer algorithm

In computer science, the Wagner–Fischer algorithm is a dynamic programming algorithm that computes the edit distance between two strings of characters.

History
The Wagner–Fischer algorithm has a history of multiple invention. Navarro lists the following inventors of it, with date of publication, and acknowledges that the list is incomplete:
 * Vintsyuk, 1968
 * Needleman and Wunsch, 1970
 * Sankoff, 1972
 * Sellers, 1974
 * Wagner and Fischer, 1974
 * Lowrance and Wagner, 1975

Calculating distance
The Wagner–Fischer algorithm computes edit distance based on the observation that if we reserve a matrix to hold the edit distances between all prefixes of the first string and all prefixes of the second, then we can compute the values in the matrix by flood filling the matrix, and thus find the distance between the two full strings as the last value computed.

A straightforward implementation, as pseudocode for a function Distance that takes two strings, s of length m, and t of length n, and returns the Levenshtein distance between them, looks as follows. The input strings are one-indexed, while the matrix d is zero-indexed, and  is a closed range.

Two examples of the resulting matrix (hovering over an underlined number reveals the operation performed to get that number):

The invariant maintained throughout the algorithm is that we can transform the initial segment  into   using a minimum of   operations. At the end, the bottom-right element of the array contains the answer.

Proof of correctness
As mentioned earlier, the invariant is that we can transform the initial segment  into   using a minimum of   operations. This invariant holds since:
 * It is initially true on row and column 0 because  can be transformed into the empty string   by simply dropping all   characters. Similarly, we can transform   to   by simply adding all   characters.
 * If, and we can transform   to   in   operations, then we can do the same to   and just leave the last character alone, giving   operations.
 * Otherwise, the distance is the minimum of the three possible ways to do the transformation:
 * If we can transform  to   in   operations, then we can simply add   afterwards to get   in   operations (insertion).
 * If we can transform  to   in   operations, then we can remove   and then do the same transformation, for a total of   operations (deletion).
 * If we can transform  to   in   operations, then we can do the same to , and exchange the original   for   afterwards, for a total of   operations (substitution).
 * The operations required to transform  into   is of course the number required to transform all of   into all of , and so   holds our result.

This proof fails to validate that the number placed in  is in fact minimal; this is more difficult to show, and involves an argument by contradiction in which we assume   is smaller than the minimum of the three, and use this to show one of the three is not minimal.

Possible modifications
Possible modifications to this algorithm include:
 * We can adapt the algorithm to use less space, O(m) instead of O(mn), since it only requires that the previous row and current row be stored at any one time.
 * We can store the number of insertions, deletions, and substitutions separately, or even the positions at which they occur, which is always.
 * We can normalize the distance to the interval.
 * If we are only interested in the distance if it is smaller than a threshold $k$, then it suffices to compute a diagonal stripe of width $2k+1$ in the matrix. In this way, the algorithm can be run in $O(kl)$ time, where $l$ is the length of the shortest string.
 * We can give different penalty costs to insertion, deletion and substitution. We can also give penalty costs that depend on which characters are inserted, deleted or substituted.
 * This algorithm parallelizes poorly, due to a large number of data dependencies. However, all the  values can be computed in parallel, and the algorithm can be adapted to perform the   function in phases to eliminate dependencies.
 * By examining diagonals instead of rows, and by using lazy evaluation, we can find the Levenshtein distance in O(m (1 + d)) time (where d is the Levenshtein distance), which is much faster than the regular dynamic programming algorithm if the distance is small.

Seller's variant for string search
By initializing the first row of the matrix with zeros, we obtain a variant of the Wagner–Fischer algorithm that can be used for fuzzy string search of a string in a text. This modification gives the end-position of matching substrings of the text. To determine the start-position of the matching substrings, the number of insertions and deletions can be stored separately and used to compute the start-position from the end-position.

The resulting algorithm is by no means efficient, but was at the time of its publication (1980) one of the first algorithms that performed approximate search.