// For all i and j, d[i,j] will hold the Levenshtein distance between   // the first i characters of s and the first j characters of t.   // Note that d has (m+1) x (n+1) values.   let d be a 2-d array of int with dimensions [0..m, 0..n]     for i in [0..m]     d[i, 0] ← i // the distance of any first string to an empty second string                 // (transforming the string of the first i characters of s into                 // the empty string requires i deletions)   for j in [0..n]     d[0, j] ← j // the distance of any second string to an empty first string     for j in [1..n]     for i in [1..m]       if s[i] = t[j] then           d[i, j] ← d[i-1, j-1]        // no operation required       else         d[i, j] ← minimum of                    (                      d[i-1, j] + 1,  // a deletion                      d[i, j-1] + 1,  // an insertion                      d[i-1, j-1] + 1 // a substitution                    )     return d[m,n]

The invariant maintained throughout the algorithm is that we can transform the initial segment s[1..i] into t[1..j] using a minimum of d[i,j] 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 s[1..i] into t[1..j] using a minimum of d[i,j] operations. This invariant holds since:

• It is initially true on row and column 0 because s[1..i] can be transformed into the empty string t[1..0] by simply dropping all i characters. Similarly, we can transform s[1..0] to t[1..j] by simply adding all j characters.
• If s[i] = t[j], and we can transform s[1..i-1] to t[1..j-1] in k operations, then we can do the same to s[1..i] and just leave the last character alone, giving k operations.
• Otherwise, the distance is the minimum of the three possible ways to do the transformation:
  • If we can transform s[1..i] to t[1..j-1] in k operations, then we can simply add t[j] afterwards to get t[1..j] in k+1 operations (insertion).
  • If we can transform s[1..i-1] to t[1..j] in k operations, then we can remove s[i] and then do the same transformation, for a total of k+1 operations (deletion).
  • If we can transform s[1..i-1] to t[1..j-1] in k operations, then we can do the same to s[1..i], and exchange the original s[i] for t[j] afterwards, for a total of k+1 operations (substitution).
• The operations required to transform s[1..n] into t[1..m] is of course the number required to transform all of s into all of t, and so d[n,m] holds our result.

This proof fails to validate that the number placed in d[i,j] is in fact minimal; this is more difficult to show, and involves an argument by contradiction in which we assume d[i,j] 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 j.
• We can normalize the distance to the interval [0,1].
• 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.^[1]
• 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 cost values can be computed in parallel, and the algorithm can be adapted to perform the minimum 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.^[2]

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.^[3] 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.^[4]

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.^[3]

References

• 1963 in Turkey
• 1963 in video gaming
• 1963 Iowa Hawkeyes football team
• 1963 Iraqi coup d'etat
• 1963 Iraqi coup d'état
• 1963 Iraqi coup d'état (disambiguation)
• 1963 Italian general election in Veneto
• 1963 Italian regional elections
• 1963 Italian Senate election in Lombardy
• 1963 June Sprints
• 1963 Leeds City Council election
• 1963 Leeds South by-election
• 1963 Lime Rock SCCA National Race
• 1963 Liverpool City Council election
• 1963 LLWS
• 1963 Louisiana Tech Bulldogs football team
• 1963 LPGA Championship
• 1963 LSU Tigers football team
• 1963 lunar eclipse
• 1963 Luton by-election
• 1963 Malaysian local elections
• 1963 Manchester Openshaw by-election
• 1963 March Revolution
• 1963 Marlboro SCCA National Race
• 1963 Meadowdale SCCA National Championships

开放百科全书收录14589846条英语、德语、日语等多语种百科知识，基本涵盖了大多数领域的百科知识，是一部内容自由、开放的电子版国际百科全书。