Francais | English | Espanõl

Levenshtein distance

From Wikipedia, the free encyclopedia

Jump to: navigation, search

In information theory and computer science, the Levenshtein distance or edit distance between two strings is given by the minimum number of operations needed to transform one string into the other, where an operation is an insertion, deletion, or substitution of a single character. It is named after Vladimir Levenshtein, who considered this distance in 1965. It is useful in applications that need to determine how similar two strings are, such as spell checkers.

For example, the Levenshtein distance between "kitten" and "sitting" is 3, since these three edits change one into the other, and there is no way to do it with fewer than three edits:

  1. kitten → sitten (substitution of 'k' for 's')
  2. sitten → sittin (substitution of 'e' for 'i')
  3. sittin → sitting (insert 'g' at the end)

It can be considered a generalization of the Hamming distance, which is used for strings of the same length and only considers substitution edits. There are also further generalizations of the Levenshtein distance that consider, for example, exchanging two characters as an operation, like in the Damerau-Levenshtein distance algorithm.

Contents

[edit] The algorithm

A commonly-used bottom-up dynamic programming algorithm for computing the Levenshtein distance involves the use of an (n + 1) × (m + 1) matrix, where n and m are the lengths of the two strings. Here is pseudocode for a function LevenshteinDistance that takes two strings, str1 of length lenStr1, and str2 of length lenStr2, and computes the Levenshtein distance between them: 

int LevenshteinDistance(char str1[1..lenStr1], char str2[1..lenStr2])
   // d is a table with lenStr1+1 rows and lenStr2+1 columns
   declare int d[0..lenStr1, 0..lenStr2]
   // i and j are used to iterate over str1 and str2
   declare int i, j, cost
 
   for i from 0 to lenStr1
       d[i, 0] := i
   for j from 0 to lenStr2
       d[0, j] := j
 
   for i from 1 to lenStr1
       for j from 1 to lenStr2
           if str1[i] = str2[j] then cost := 0
                                else cost := 1
           d[i, j] := minimum(
                                d[i-1, j] + 1,     // deletion
                                d[i, j-1] + 1,     // insertion
                                d[i-1, j-1] + cost   // substitution
                            )
 
   return d[lenStr1, lenStr2]

Two examples of the resulting matrix (the minimum steps to be taken are highlighted):

k i t t e n
0 1 2 3 4 5 6
s 1 1 2 3 4 5 6
i 2 2 1 2 3 4 5
t 3 3 2 1 2 3 4
t 4 4 3 2 1 2 3
i 5 5 4 3 2 2 3
n 6 6 5 4 3 3 2
g 7 7 6 5 4 4 3
S a t u r d a y
0 1 2 3 4 5 6 7 8
S 1 0 1 2 3 4 5 6 7
u 2 1 1 2 2 3 4 5 6
n 3 2 2 2 3 3 4 5 6
d 4 3 3 3 3 4 3 4 5
a 5 4 3 4 4 4 4 3 4
y 6 5 4 4 5 5 5 4 3


The invariant maintained throughout the algorithm is that we can transform the initial segment str1[1..i] into str2[1..j] using a minimum of d[i,j] operations. At the end, the bottom-right element of the array contains the answer.


This algorithm is essentially part of a solution to the Longest common subsequence problem (LCS), in the particular case of 2 input lists.

[edit] Possible improvements

Possible improvements 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 give different penalty costs to insertion, deletion and substitution.
  • The initialization of d[i,0] can be moved inside the main outer loop.
  • This algorithm parallelizes poorly, due to a large number of data dependencies. However, all the costs can be computed in parallel, and the algorithm can be adapted to perform the minimum function in phases to eliminate dependencies.

[edit] 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.
  • The minimum is taken over three distances, each of which is feasible:
    • 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.
    • If we can transform s[1..i-1] to t[1..j] in k operations, then we can do the same operations on s[1..i] and then remove the original s[i] at the end in k+1 operations.
    • If we can transform s[1..i-1] to t[1..j-1] in k operations, we can do the same to s[1..i] and then do a substitution of t[j] for the original s[i] at the end if necessary, requiring k+cost operations.
  • 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.

[edit] Upper and lower bounds

The Levenshtein distance has several simple upper and lower bounds that are useful in applications which compute many of them and compare them. These include:

  • It is always at least the difference of the sizes of the two strings.
  • It is at most the length of the longer string.
  • It is zero if and only if the strings are identical.
  • If the strings are the same size, the Hamming distance is an upper bound on the Levenshtein distance.
  • If the strings are called s and t, the number of characters (not counting duplicates) found in s but not in t is a lower bound.

[edit] Implementations

The implementations of the Levenshtein algorithm on this page are illustrative only. Applications will, in most cases, use implementations which use heap allocations sparingly, in particular when large lists of words are compared to each other. The following remarks indicate some of the variations on this and related topics:

1. Most implementations use one- or two-dimensional arrays to store the distances of prefixes of the words compared. In most applications the size of these structures is previously known. This is the case, when, for instance the distance is relevant only if it is below a certain maximally allowed distance (this happens when words are selected from a dictionary to approximately match a given word). In this case the arrays can be preallocated and reused over the various runs of the algorithm over successive words.

2. Using maximally allowed distances reduces the search. To achieve this, include the maximal distance in the parameter list to the algorithm and keep track of the shortest found distance of prefixes of the words compared.

3. Deletion/Insertion and replacement of characters can be assigned different weights. The usual choice is to set them both to 1 (this is the choice for all of the algorithms on this page). Different values for these weights allows for more flexible search strategies in lists of words.

[edit] C++

const unsigned int cost_del = 1;
const unsigned int cost_ins = 1;
const unsigned int cost_sub = 1;

unsigned int edit_distance( const std::string& s1, const std::string& s2 )
{
  unsigned int n1 = s1.length();
  unsigned int n2 = s2.length();

  unsigned int* p = new unsigned int[n2+1];
  unsigned int* q = new unsigned int[n2+1];
  unsigned int* r;

  p[0] = 0;
  for( unsigned int j = 1; j <= n2; ++j )
    p[j] = p[j-1] + cost_ins;

  for( unsigned int i = 1; i <= n1; ++i )
    {
      q[0] = p[0] + cost_del;
      for( unsigned int j = 1; j <= n2; ++j )
        {
          unsigned int d_del = p[j] + cost_del;
          unsigned int d_ins = q[j-1] + cost_ins;
          unsigned int d_sub = p[j-1] + ( s1[i-1] == s2[j-1] ? 0 : cost_sub );
          q[j] = std::min( std::min( d_del, d_ins ), d_sub );
      }
      r = p;
      p = q;
      q = r;
    }

  unsigned int tmp = p[n2];
  delete[] p;
  delete[] q;

  return tmp;
}

[edit] Java

public class LevenshteinDistance {
    private static int minimum(int a, int b, int c){
        if (a<=b && a<=c)
            return a;
        if (b<=a && b<=c)
            return b;
        return c;
    }

    public static int computeLevenshteinDistance(char[] str1, char[] str2) {
        int[][] distance = new int[str1.length+1][];

        for(int i=0; i<=str1.length; i++){
            distance[i] = new int[str2.length+1];
            distance[i][0] = i;
        }
        for(int j=0; j<str2.length+1; j++)
            distance[0][j]=j;

        for(int i=1; i<=str1.length; i++)
            for(int j=1;j<=str2.length; j++)
                  distance[i][j]= minimum(distance[i-1][j]+1, distance[i][j-1]+1, 
                                          distance[i-1][j-1]+((str1[i-1]==str2[j-1])?0:1));
       
        return distance[str1.length][str2.length];
    }
}

[edit] Octave

GNU Octave is a highlevel programming environment which implements Matlab programming language, mostly useful for scientific computation. 

function [dist,L]=levenstein_distance(str1,str2)
    L1=length(str1)+1;
    L2=length(str2)+1;
    L=zeros(L1,L2);

    g=+1;%just constant
    m=+0;%match is cheaper, we seek to minimize
    d=+1;%not-a-match is more costly.
    
    %do BC's
    L(:,1)=[0:L1-1]*g;
    L(1,:)=[0:L2-1]*g;
    
    m4=0;%loop invariant
    for idx=2:L1;
        for idy=2:L2
            if(str1(idx-1)==str2(idy-1))
                score=m;
            else
                score=d;
            end
            m1=L(idx-1,idy-1) + score;
            m2=L(idx-1,idy) + g;
            m3=L(idx,idy-1) + g;
            L(idx,idy)=min(m1,min(m2,m3));
        end
    end
    
    dist=L(L1,L2);
    return
end

[edit] Ocaml

Uses linear space, and can be curried with just one string to factor arrays allocations. 

 type levenshtein_costs = {
   insert_cost : int;
   delete_cost : int;
   replace_cost : int;
 }
 
 let levenshtein_distance lc =
   fun s1 ->
     let l1 = String.length s1 in
     let m = Array.make (l1 + 1) 0 in
     let n = Array.make (l1 + 1) 0 in
     fun s2 ->
       let l2 = String.length s2 in
       m.(0) <- 0;
       for i = 1 to l1 do
         m.(i) <- m.(i - 1) + lc.delete_cost
       done;
       let rec aux j m n =
         if j = l2 then m.(l1)
         else
           let c2 = s2.[j] in
           n.(0) <- m.(0) + lc.insert_cost;
           for i = 1 to l1 do
             let i1 = i - 1 in
             n.(i) <-
               min
                 (min (n.(i1) + lc.delete_cost)
                      (m.(i) + lc.insert_cost))
                 (m.(i1) + 
                   (if s1.[i1] <> c2 then lc.replace_cost else 0))
           done;
           aux (j + 1) n m in
       aux 0 m n


[edit] Ruby

This Ruby version compares self against other. 

 class String
   def levenshtein(other)
     a, b = self.unpack('U*'), other.unpack('U*')
     n, m = a.length, b.length
     a, b, n, m = b, a, m, n if n > m
     current = [*0..n]
     1.upto(m) do |i|
       previous, current = current, [i]+[0]*n
       1.upto(n) do |j|
         add, delete = previous[j]+1, current[j-1]+1
         change = previous[j-1]
         change += 1 if a[j-1] != b[i-1]
         current[j] = [add, delete, change].min
       end
     end
     current[n]
   end
 end

[edit] See also

[edit] External links

de:Levenshtein-Distanz es:Distancia de Levenshtein fr:Distance de Levenshtein it:Distanza di Levenshtein nl:Levenshteinafstand ja:レーベンシュタイン距離 lv:Levenšteina attālums nn:Levenshtein-distanse pl:Odległość Levenshteina pt:Distância Levenshtein ru:Расстояние Левенштейна fi:Levenšteinin etäisyys uk:Відстань Левенштейна zh:編輯距離

Retrieved from "http://en.wikivisual.com/index.php/Levenshtein_distance"
Personal tools