# Levenshtein-Distanz

Die Levenshtein-Distanz (auch Editierdistanz) zwischen zwei Zeichenketten ist die minimale Anzahl einfügender, löschender und ersetzender Operationen, um die erste Zeichenkette in die zweite umzuwandeln. Benannt ist die Distanz nach dem russischen Wissenschaftler Wladimir Lewenstein (engl. Levenshtein), der sie 1965 einführte. Mathematisch ist die Levenshtein-Distanz eine Metrik auf dem Raum der Symbolsequenzen.
Beispielsweise entspricht die Levenshtein-Distanz zwischen „Bar“ und „Bier“ zwei. Eine mögliche Folge von zwei Operationen ist:
| Wort | Operation | Anzahl |
| Bar | keine (Ausgangswort) | 0 |
| Bir | Ersetzung (a → i) | 1 |
| Bier | Einfügung (e) | 2 |
Ein anderes Beispiel ist die Distanz von eins zwischen „uninformiert“ und „uniformiert“:
| Wort | Operation | Anzahl |
| uninformiert | keine (Ausgangswort) | 0 |
| uniformiert | Löschung (n) | 1 |
In der Praxis wird die Levenshtein-Distanz zur Bestimmung der Ähnlichkeit von Zeichenketten beispielsweise zur Rechtschreibprüfung oder bei der Duplikaterkennung angewandt.

## Algorithmus

In dem Levenshtein-Artikel von 1965 wird die Levenshtein-Distanz definiert, aber es wird kein Algorithmus zur Berechnung der Distanz angegeben. In der Literatur wird ein Algorithmus zur Berechnung der Levenshtein-Distanz, der die Methode der dynamischen Programmierung verwendet, als Levenshtein-Algorithmus bezeichnet.
Der Algorithmus ist durch folgende Matrix-Rekurrenzen spezifiziert, wobei $u$ und $v$ die beiden Eingabe-Zeichenketten bezeichnen:
    $m=|u|$
    $n=|v|$
    $D_{0,0}=0$
    $D_{i,0}=i,1\leq i\leq m$
    $D_{0,j}=j,1\leq j\leq n$
    $D_{i,j}=\min {\begin{cases}D_{i-1,j-1}&+0\ {\rm {falls}}\ u_{i}=v_{j}\\D_{i-1,j-1}&+1\ {\rm {(Ersetzung)}}\\D_{i,j-1}&+1\ {\rm {(Einf{\ddot {u}}gung)}}\\D_{i-1,j}&+1\ {\rm {(L{\ddot {o}}schung)}}\end{cases}}$,
       $1\leq i\leq m,1\leq j\leq n$
Nachdem die Matrix $D$ berechnet ist, steht die Levenshtein-Distanz, d. h. die minimale Anzahl der Edit-Operationen, in der Matrix-Zelle $D_{m,n}$. In jeder Zelle $D_{i,j}$ steht die Levenshtein-Distanz der Präfixe $u_{0,i}$ und $v_{0,j}$. Bei einer weiteren Löschung bzw. Einfügung wird nun nur ein weiteres Zeichen von $u$ bzw. $v$ verbraucht. D.h. das Resultat wird in $D_{i+1,j}$ bzw. $D_{i,j+1}$ gespeichert. Also lassen sich die Kosten für eine Löschung bzw. Einfügung in Zelle $D_{i,j}$ rekurrent durch $D_{i-1,j}+1$ bzw. $D_{i,j-1}+1$ berechnen. Analog ist der Fall der Ersetzung zu erklären.
Wenn nicht nur die Levenshtein-Distanz berechnet werden soll, sondern auch die Folge der Operationen, die zu dem Ergebnis geführt hat, muss ein „Backtrace“ auf der berechneten Matrix durchgeführt werden. D.h. beginnend von $D_{i,j-1}$ werden rekursiv die Optimierungsentscheidungen zurückverfolgt. Im Pseudocode ist der Backtrace-Algorithmus:
Um den Pseudo-Code zu vereinfachen, wird nur ein möglicher Backtrace berechnet.

## Beispiel

Das Verfahren lässt sich nun leicht in einer Tabelle durchführen. Hier ein Beispiel mit den beiden Zeichenketten „Tier“ und „Tor“.
Der Abstand der beiden Zeichenketten ist 2. ε steht hierbei für die leere Zeichenkette "".

## Komplexität

Die Laufzeit des Algorithmus ist in O$(mn)$, da alle Zellen der $(m+1)\times (n+1)$-Matrix berechnet werden und der Rechenaufwand pro Zelle konstant ist.
Der Speicherbedarf ist in $O(nm)$, da die Matrix $m+1$ Zeilen und $n+1$ Spalten hat. Wenn allerdings kein Backtracing durchgeführt wird, dann wird zur zeilen- bzw. spaltenweisen Berechnung der Matrix nur die jeweils letzte Zeile bzw. Spalte zur Berechnung der nächsten Zeile bzw. Spalte benötigt. Der Speicherbedarf liegt in dem Fall also in $O(\min(m,n))$.
Der Hirschberg-Algorithmus ermöglicht die Berechnung der Levenshtein-Distanz und eines „Backtrace“ in quadratischer Zeit und mit linearem Speicherverbrauch.

## Schranken

Für die Levenshtein-Distanz gelten einige obere und untere Schranken:
* sie beträgt mindestens den Unterschied der Längen beider Zeichenketten
* sie beträgt höchstens die Länge der längeren Zeichenkette
* sie ist dann und nur dann 0, wenn beide Zeichenketten identisch sind (Definition Metrik)
* sie ist nicht größer als die Hamming-Distanz plus dem Längenunterschied der Zeichenketten

## Abgrenzung

Die Levenshtein-Distanz kann als Erweiterung des Hamming-Abstands angesehen werden, welcher sich auf Ersetzungen beschränkt und daher nur Zeichenketten gleicher Länge bemessen kann. Eine Phonetische Suche kann die Levenshtein-Distanz verwenden, um Fehler zu erlauben. Zu vergleichende Wörter können vor einer Distanzberechnung beispielsweise mit dem Kölner-Phonetik- oder dem Soundex-Algorithmus in eine Lautsymbol-Zeichenkette überführt werden.
Der DP-Algorithmus zur Berechnung der Levenshtein-Distanz ist mit dem Needleman-Wunsch-Algorithmus zur Berechnung des Sequenzalignments zweier Zeichenketten verwandt. Der Needleman-Wunsch-Algorithmus ist in $O(n^{3})$ und lässt beliebige Kostenfunktionen für Einfüge- bzw. Löschoperationen der Länge $\geq 1$ zu. Bei dem Levenshtein-Algorithmus besteht eine Einfüge- bzw. Löschoperation aus maximal einem Zeichen. Varianten des Needleman-Wunsch Algorithmus beschränken die Wahl der Kostenfunktion, so dass deren Laufzeit in $O(n^{2})$ liegt.
Der Smith-Waterman-Algorithmus optimiert die Kosten der Edit-Operationen nach dem gleichen DP-Schema wie der Needleman-Wunsch- bzw. der Levenshtein-Algorithmus, allerdings werden Einfüge- bzw. Lösch-Operationen am Anfang bzw. Ende einer Sequenz mit $0$ bewertet und im Backtrace ignoriert. D.h. der Smith-Waterman-Algorithmus berechnet das lokale „sequence alignment“. Seine Laufzeit liegt in $O(n^{2})$.
Die Levenshtein-Distanz kann als Sonderform der Dynamic-Time-Warping-Distanz (DTW) betrachtet werden.

## Varianten
### Gewichtete Levenshtein-Distanz

Die Kosten der einzelnen Einfüge-, Lösch- und Ersetzungsoperationen können auch unterschiedlich oder sogar abhängig von den jeweiligen beteiligten Zeichen gewichtet werden. Das so verallgemeinerte Verfahren wird als gewichtete Levenshtein-Distanz, Weighted Levenshtein Distance oder kurz WLD-Algorithmus bezeichnet.
Ein Beispiel für gewichtete Kosten für Distanzoperationen, die mit dem WLD-Algorithmus minimiert werden können, sind die Kosten der Schreibmaschinendistanz.

### Damerau-Levenshtein-Distanz

Damerau-Levenshtein erweitert die Funktionalität von Levenshtein um die Fähigkeit, zwei vertauschte Zeichen zu identifizieren, beispielsweise „Raisch“ ↔ „Rasich“. Um die eine Zeichenfolge in die andere zu überführen, wären mit Levenshtein zwei Operationen notwendig. Damerau-Levenshtein benötigt nur eine einzige.
Folgende Matrix-Rekurrenzen spezifizieren die Algorithmus-Variante.
    $m=|u|$
    $n=|v|$
    $D_{0,0}=0$
    $D_{i,0}=i$, $1\leq i\leq m$
    $D_{0,j}=j$, $1\leq j\leq n$
    $D_{i,j}=\min {\begin{cases}D_{i-1,j-1}&+0\ {\rm {falls}}\ u_{i}=v_{j}\\D_{i-1,j-1}&+1\ {\rm {(Ersetzung)}}\\D_{i,j-1}&+1\ {\rm {(Einf{\ddot {u}}gung)}}\\D_{i-1,j}&+1\ {\rm {(L{\ddot {o}}schung)}}\end{cases}}$
       $(i=1,1\leq j\leq n)\vee (1\leq i\leq m,j=1)$
    $D_{i,j}=\min {\begin{cases}D_{i-1,j-1}&+0\ {\rm {falls}}\ u_{i}=v_{j}\\D_{i-1,j-1}&+1\ {\rm {(Ersetzung)}}\\D_{i,j-1}&+1\ {\rm {(Einf{\ddot {u}}gung)}}\\D_{i-1,j}&+1\ {\rm {(L{\ddot {o}}schung)}}\\D_{i-2,j-2}&+c\ {\rm {Vertauschung,falls}}\ u_{i}=v_{j-1}\wedge u_{i-1}=v_{j}\\\end{cases}}$
       $2\leq i\leq m,2\leq j\leq n$
Wobei $c$ die Kosten für eine Vertauschung von zwei Zeichen bezeichnet.