Complejidad del espacio para calcular la alineación de cadena óptima para la distancia de edición de Levenshtein

Si nos dan dos cadenas de tamaño y n 2 , la Levenshtein cálculo de distancia de edición estándar es mediante un algoritmo dinámico con el tiempo complejidad O ( n 1 n 2 ) y el espacio complejidad O ( n 1 n 2 ) . (Se pueden hacer algunas mejoras en función de la distancia de edición d , pero no suponemos que $n_1$$n_2$$O(n_1 n_2)$$O(n_1 n_2)$$d$$d$$O(\max(n_1, n_2))$

Sin embargo, si desea obtener las ediciones reales de un script de edición óptimo, ¿es posible hacerlo mejor que el uso de memoria , posiblemente a expensas del tiempo de ejecución?$O(n_1 n_2)$

No hay necesidad de la compensación que sugiere Yuval. La secuencia de edición óptima completa se puede calcular en tiempo y espacio , utilizando una mezcla de programación dinámica y divide y vencerás descrita por primera vez por Dan Hirschberg. ( Un algoritmo de espacio lineal para calcular subsecuencias comunes máximas. Commun. ACM 18 (6): 341–343, 1975.)O ( n + m $O(nm)$$O(n+m)$

Intuitivamente, la idea de Hirschberg es calcular una sola operación de edición a la mitad de la secuencia de edición óptima, y ​​luego calcular recursivamente las dos mitades de la secuencia. Si pensamos en la secuencia de edición óptima como una ruta desde una esquina de la tabla de memorización a la otra, necesitamos una recurrencia modificada para registrar dónde esta ruta cruza la fila central de la tabla. Una recurrencia que funciona es la siguiente:

$$Half(i,j) = \begin{cases} \infty & \text{if $i<m/2$}\\ j & \text{if $i=m/2$}\\ Half(i-1,j) & \text{if $i>m/2$ and $Edit(i,j) = Edit(i-1,j)+1$}\\ Half(i,j-1) & \text{if $i>m/2$ and $Edit(i,j) = Edit(i,j-1)+1$}\\ Half(i-1,j-1) & \text{otherwise} \end{cases}$$

Los valores de pueden calcularse al mismo tiempo que la tabla de distancia de edición , utilizando el tiempo . Como cada fila de la tabla de memorización depende solo de la fila que se encuentra sobre ella, calcular tanto la como la requiere solo espacio .$Half(i,j)$$Edit(i,j)$$O(mn)$$Edit(m,n)$$Half(m,n)$$O(m+n)$

Finalmente, la secuencia de edición óptima que transforma las cadenas de entrada en consiste en las secuencias óptimas que transforman en seguido de la secuencia óptima que transforma en . Si calculamos esas dos subsecuencias de forma recursiva, el tiempo de ejecución general obedece a la siguiente recurrencia: No es difícil demostrar que$A[1..m]$$B[1..n]$$A[1 .. m/2]$$B[1 .. Half(m, n)]$$A[m/2 + 1 .. m]$$B[Half(m, n) + 1 .. n]$

$$T(m,n) = \begin{cases} O(n) & \text{if $m\le 1$}\\ O(m) & \text{if $n\le 1$}\\ O(mn) + \max_h \left( T(m/2,h) + T (m/2, n−h)\right) & \text{otherwise} \end{cases}$$ O ( m + n $T(m,n) = O(mn)$. Del mismo modo, dado que solo necesitamos espacio para un pase de programación dinámica a la vez, el espacio total limitado sigue siendo . (El espacio para la pila de recursión es insignificante).$O(m+n)$

El algoritmo que describe que se ejecuta en el espacio realidad recupera la edición final y el estado justo antes de la edición final. Entonces, si ejecuta este algoritmo veces, puede recuperar toda la secuencia de edición, a expensas de aumentar el tiempo de ejecución. En general, hay una compensación de espacio-tiempo que está controlada por el número de filas que retiene en ese momento. Los dos puntos extremos de esta compensación son el espacio y el espacio , y entre estos, el producto del tiempo y el espacio es constante (hasta el gran O).O ( n 1 + n 2 ) O ( n 1 n 2 ) O ( n 1 + n 2$O(n_1 + n_2)$$O(n_1 + n_2)$$O(n_1n_2)$$O(n_1+n_2)$