Ver el código de «Problema de subsecuencia común más larga»

El '''problema de subsecuencia común más larga''' ({{lang-en|longest common subsequence problem}}, abreviado ''LCS problem''), se trata de encontrar una subsecuencia más larga que es común en un conjunto de secuencias (Aunque en la mayor parte solamente se toman dos secuencias). Es diferente del problema de substring común más largo; a diferencia de los substrings, las subsecuencias no necesitan tener posiciones consecutivas en la secuencia original. El problema de LCS es uno de los problemas clásicos de las ciencias computacionales y es la base de programas que comparan datos como la utilidad diff, y ha tenido usos en [[bioinformática]]. También es usado ampliamente para los [[Revision control|sistemas de control de revisión]] como Git para reconciliar múltiples cambios sobre archivos controlados de revisión.  

== Complejidad ==
En los casos generales de un número arbitrario de secuencias de entrada, el problema llega a ser [[NP-hard]].<ref>{{cita publicación| autor = David Maier| título = The Complexity of Some Problems on Subsequences and Supersequences| publicación = J. ACM| volumen = 25| año = 1978| páginas = 322–336| doi = 10.1145/322063.322075| editorial = ACM Press| número = 2}}</ref> Cuando el número de secuencias es constante, el problema se puede resolver en un tiempo polinómico a través de [[programación dinámica]]. Supongamos que se tiene  <math>N</math> secuencias de longitudes <math>n_1, ..., n_N</math>. Una búsqueda nativa probaría los <math>2^{n_1}</math>subsecuancias de la primera secuencia para determinar si son subsecuencias de las otras secuencias. Cada subsecuencia debe ser probado en un tiempo lineal en longitud de las secuencias restantes así que el algoritmo sería como:
:<math>O\left( 2^{n_1} \sum_{i>1} n_i\right).</math>

Para el caso de dos secuencias de n y m elementos, el [[tiempo de ejecución]] para la programación dinámica es de O(''n'' × ''m''). Para un número arbitrario de secuencias, la programación dinámica encontraría la solución en 

:<math>O\left(N \prod_{i=1}^{N} n_i\right).</math>

Existen métodos con una complejidad menor,<ref name="BHR00">
{{cita publicación | autor = L. Bergroth and H. Hakonen and T. Raita | título = A Survey of Longest Common Subsequence Algorithms | publicación = SPIRE | volumen = 00 | año = 2000 | isbn = 0-7695-0746-8 | páginas = 39–48 | doi = 10.1109/SPIRE.2000.878178 | editorial = IEEE Computer Society}}</ref> la cual suele depender de la longitud del LCS, el tamaño del alfabeto o ambos. 

Cabe mencionar que LCS no es único; por ejemplo el LCS de "ABC" y "ACB" son ambos "AB" y "AC". Por eso LCS a veces se define como encontrar todas las subsecuencias comunes en una longitud máxima. Este problema tiene una complejidad mayor ya que los números de estas subsecuencias pueden ser exponenciales en el peor de los casos,<ref name="">{{cite arXiv | author = Ronald I. Greenberg | title = Bounds on the Number of Longest Common Subsequences  | date = 6 de agosto de 2003  | eprint = cs.DM/0301030}}</ref> aun cuando solamente sean dos strings de entrada.

== Solución para dos secuencias ==
El problema de LCS tiene una estructura óptima: el problema puede ser dividido en subproblemas más pequeños y simples, el cual puede ser dividido en subproblemas más simples y así hasta que la solución llega a ser trivial. El problema de LCS también tiene subproblemas que se traslapan: las soluciones de subproblemas de nivel mayor utilizan soluciones de subproblemas menores. Los problemas con estas dos propiedades: estructura óptima y subproblemas que traslapan pueden ser resueltos por una técnica de programación llamada programación dinámica, en la que las soluciones de los subproblemas se almacenan en lugar de ser calculadas una y otra vez. Para esto se necesita la técnica de memoización en la cual se tabulan las soluciones de los subproblemas más pequeños (como si se estuviera tomando una nota "memo" en inglés) para que esas soluciones puedan ser utilizadas para resolver a los de más alto nivel. 

=== Prefijos ===
El subproblema se hace más simple en cuanto la secuencia se hace más corta. Las secuencias cortas pueden ser descritos como prefijos. Un prefijo de la secuencia es una secuencia en donde su parte trasera se corta. Supongamos que S es la secuencia (AGCA). Entonces (AG) es uno de los prefijos de S. Los prefijos se denotan con el nombre de la secuencia seguido por un índice inferior de cuántos caracteres contiene el prefijo.<ref>{{cita libro
 | apellido = Xia | nombre = Xuhua
 | título = Bioinformatics and the Cell:  Modern Computational Approaches in Genomics, Proteomics and Transcriptomics
 | url = https://archive.org/details/bioinformaticsce00xiax_682 | año = 2007
 | editorial = Springer
 | ubicación = Nueva&nbsp;York
 | página = [https://archive.org/details/bioinformaticsce00xiax_682/page/n38 24]
 | isbn = 0-387-71336-0
}}</ref> El prefijo (AG) es denotado como ''S''<sub>2</sub>, ya que contiene a los primeros 2 elementos de la secuencia S. los posibles prefijos de S son:
:''S''<sub>1</sub> = (A)
:''S''<sub>2</sub> = (AG)
:''S''<sub>3</sub> = (AGC)
:''S''<sub>4</sub> = (AGCA).

La solución al problema LCS de dos cadenas arbitrarias X y Y pueden formar una función LCS(X,Y) tal que regrese la subsecuencia común más larga de X y Y. Esta función depende de las siguientes dos propiedades.

=== Primera propiedad ===
Supongamos que las dos secuencias terminan con el mismo elemento. Para encontrar su LCS, podemos acortar las dos secuencias eliminando el último elemento, encontrando el LCS de las dos secuencias acortadas y agregando el elemento eliminado
:Por ejemplo, tenemos dos secuencias que tienen el mismo elemento final: (BANANA) y (ATANA).
:Eliminamos el último elemento en las dos cadenas. Repetimos hasta que lleguemos a un elemento no común. Los elementos removidos son (ANA)
:Ahora las dos secuencias son (BAN) y (AT). 
:El LCS de las dos secuencias es (A).
:Ahora anexamos los elementos eliminados al LCS y obtenemos (AANA), el cual es LCS de las secuencias originales
En términos de los prefijos.
: Si ''x<sub>n</sub>''=''y<sub>m</sub>'', ''LCS''(''X<sub>n</sub>'', ''Y<sub>m</sub>'') = append(''LCS''( ''X<sub>n</sub> ''-1, ''Y<sub>m</sub>''-1), ''x<sub>n</sub>'') 
Nótese que el LCS para ''X<sub>n</sub>'' y ''Y<sub>m</sub>'' involucran determinar el LCS de secuencias más cortas: ''X<sub>n</sub>''-1 and ''Y<sub>m</sub>''-1.

=== Segunda propiedad ===
Supongamos que las dos secuencias X y Y no terminan con el mismo símbolo. Entonces el LCS de X y Y es la más larga de las secuencias LCS(X<sub>n</sub>,Y<sub>m-1</sub>) y LCS(X<sub>n-1</sub>,Y<sub>m</sub>).

Para entender esta propiedad, se considera lo siguiente:

secuencia X: ABCDEFG (n elementos)

secuencia Y: BCDGK (m elementos)

El LCS de estas dos secuencias podría terminar en G (último elemento de X) o puede que no.

'''Caso 1: LCS termina con G'''

Si termina con G no puede terminar con K. Por lo tanto no pasa nada si nosotros eliminamos K de la secuencia Y. Si K estuviera en LCS, tendría que ser el último carácter por eso nosotros sabemos que no está en LCS. Entonces podemos decir que LCS(X<sub>n</sub>,Y<sub>m</sub>) = LCS(X<sub>n</sub>, Y<sub>m-1</sub>).

'''Caso 2: LCS no termina con G'''<br>Si no termina con G, no afectaría en nada eliminar G de la secuencia de X. Por la misma razón. Entonces podemos escribir LCS(X<sub>n</sub>,Y<sub>m</sub>) = LCS(X<sub>n-1</sub>, Y<sub>m</sub>).

En cualquier caso, el LCS que nosotros buscamos es uno de los siguientes LCS(X<sub>n</sub>, Y<sub>m-1</sub>) o LCS(X<sub>n-1</sub>, Y<sub>m</sub>). Ambas funciones van a regresar una subsecuencia común de X y Y. Nada más que para LCS nosotros necesitamos el más largo.

=== Definición de la función LCS ===
Dadas dos secuencias:''X'' = (''x''<sub>1</sub>, ''x''<sub>2</sub>...''x''<sub>m</sub>) y ''Y'' = (''y''<sub>1</sub>, ''y''<sub>2</sub>...''y''<sub>n</sub>). Los prefijos de X son ''X''<sub>1, 2,...m</sub>; los prefijos de Y son ''Y''<sub>1, 2,...n</sub>. Supongamos que ''LCS''(''X''<sub>''i''</sub>, ''Y''<sub>''j''</sub>) representa la subsecuencia común más larga de los prefijos ''X<sub>i</sub>'' y ''Y<sub>j</sub>''. Este conjunto de secuencia se define como el siguiente:

:<math>
LCS\left(X_{i},Y_{j}\right) =
\begin{cases}
  \empty
& \mbox{ if }\ i = 0 \mbox{ or }  j = 0 \\
  \textrm{  } LCS\left(X_{i-1},Y_{j-1}\right) \frown x_{i}
& \mbox{ if } x_i = y_j \\
  \mbox{longest}\left(LCS\left(X_{i},Y_{j-1}\right),LCS\left(X_{i-1},Y_{j}\right)\right)
& \mbox{ if } x_i \ne y_j \\
\end{cases}
</math>

Para encontrar la subsecuencia común más larga de ''X<sub>i</sub>'' y ''Y<sub>j</sub>'', comparamos los elementos ''x<sub>i</sub>'' y ''y<sub>j</sub>''. Si son iguales, entonces la secuencia ''LCS''(''X''<sub>''i''-1</sub>, ''Y''<sub>''j''-1</sub>) será extendido por el elementos ''x<sub>i</sub>''. Si no son iguales, entonces el más largo de ''LCS''(''X''<sub>''i''</sub>, ''Y''<sub>''j''-1</sub>), y ''LCS''(''X''<sub>''i''-1</sub>, ''Y''<sub>''j''</sub>), será la respuesta (Si ambos son del mismo tamaño pero no son idénticos, ambas soluciones serán resultados). Nótese que los subscripts se reducen por 1 en estas fórmulas. Y así se podría llegar a 0. Como las secuencias deben empezar en 1, fue necesario definir que ninguna de las dos secuencias fueran de logintud 0.

=== Ejemplo trabajado ===
La subsecuencia común más larga a C = (AGCAT) y R = (GAC) se está buscando. Como la función LCS utiliza un elemento en la casilla cero, es conveniente definir un zero como prefijo que representará a la [[cadena vacía]]. ''C''<sub>0</sub> =  Ø; y ''R''<sub>0</sub> =  Ø.  Todos los prefijos se colocarán en la tabla siendo C la fila y R la columna

{| class="wikitable" style="text-align:center"
|+ LCS Strings
|-
!   || 0 || A || G || C || A || T
|-
! 0
| Ø || Ø || Ø || Ø || Ø || Ø
|-
! G
| Ø
| 
| 
| 
| 
| 
|-
! A
| Ø
| 
| 
| 
| 
| 
|-
! C
| Ø
| 
| 
| 
| 
| 
|-
|}

Esta tabla se utiliza para almacernar las secuencias LCS para cada paso del cálculo. La segunda columna y la segunda fila se llenaron con Ø porque cuando una secuencia vacía se compara con una no vacía, el LCS siempre será vacía.

''LCS''(''R''<sub>1</sub>, ''C''<sub>1</sub>) se determina comparando el primer elemento de cada secuencia. G y A no son la misma, así que LCS se calcula con la segunda propiedad ''LCS''(''R''<sub>1</sub>, ''C''<sub>0</sub>) y  ''LCS''(''R''<sub>0</sub>, ''C''<sub>1</sub>). Según la tabla, ambos son vacíos por lo tanto ''LCS''(''R''<sub>1</sub>, ''C''<sub>1</sub>) también es vacío como se puede ver en la tabla de abajo. Las flechas indican que la secuencia viene de ambas casillas anteriores, la celda de arriba ''LCS''(''R''<sub>0</sub>, ''C''<sub>1</sub>) y la celda de izquierda ''LCS''(''R''<sub>1</sub>, ''C''<sub>0</sub>).

''LCS''(''R''<sub>1</sub>, ''C''<sub>2</sub>) se determina comparando G con G. Como son idénticas, G se agrega a la secuencia que está arriba a la izquierda ''LCS''(''R''<sub>0</sub>, ''C''<sub>1</sub>), la cual es (Ø), dando (ØG), que sería (G).

Para ''LCS''(''R''<sub>1</sub>, ''C''<sub>3</sub>), G y C no son iguales. La secuencia de arriba es vacío; y la de izquierda contiene el elemento G. Así que la secuencia más larga sería ''LCS''(''R''<sub>1</sub>, ''C''<sub>3</sub>) que es (G). La flecha apunta hacia la izquierda ya que esa es la secuencia más larga.

''LCS''(''R''<sub>1</sub>, ''C''<sub>4</sub>), también, es (G).

''LCS''(''R''<sub>1</sub>, ''C''<sub>5</sub>), también, es (G).

{| class="wikitable" style="text-align:center"
|+ Fila "G" completada
|-
!   || Ø || A || G || C || A || T
|-
! Ø
| Ø || Ø || Ø || Ø || Ø || Ø
|-
! G
| Ø
| <math>\overset{\ \ \uparrow}{\leftarrow}</math>Ø
| <math>\overset{\nwarrow}{\ }</math>(G)
| <math>\overset{\ }{\leftarrow}</math>(G)
| <math>\overset{\ }{\leftarrow}</math>(G)
| <math>\overset{\ }{\leftarrow}</math>(G)
|-
! A
| Ø
| 
| 
| 
| 
| 
|-
! C
| Ø
| 
| 
| 
| 
| 
|-
|}

Para ''LCS''(''R''<sub>2</sub>, ''C''<sub>1</sub>), A se compara con A. Como los elementos son iguales, A se anexa a Ø, dando como resultado (A).

Para ''LCS''(''R''<sub>2</sub>, ''C''<sub>2</sub>), como A y G no son iguales, la secuencia más larga de ''LCS''(''R''<sub>1</sub>, ''C''<sub>2</sub>), la cual es (G), y ''LCS''(''R''<sub>2</sub>, ''C''<sub>1</sub>), la cual es (A), se escribe. En este cado como cada uno contiene a un solo elemento, el LCS son ambos (A) y (G) 

Para ''LCS''(''R''<sub>2</sub>, ''C''<sub>3</sub>), A no es igual que C.  ''LCS''(''R''<sub>2</sub>, ''C''<sub>2</sub>) contiene la secuencia (A) y (G); LCS(''R''<sub>1</sub>, ''C''<sub>3</sub>) es (G), la cual ya está contenido en ''LCS''(''R''<sub>2</sub>, ''C''<sub>2</sub>). Como resultado ''LCS''(''R''<sub>2</sub>, ''C''<sub>3</sub>) también contiene a las dos secuencias (A) y (G)

Para ''LCS''(''R''<sub>2</sub>, ''C''<sub>4</sub>), A es igual que A, entonces A se anexa a la celda superior izquierdo dando como secuencia (GA)

Para ''LCS''(''R''<sub>2</sub>, ''C''<sub>5</sub>), A no es igual que T. Se comparan las dos secuencias (GA) y (G). La secuencia más larga que es (GA) se queda como resultado

{| class="wikitable" style="text-align:center"
|+ Filas "G" & "A" Completeda
|-
!   || Ø || A || G || C || A || T
|-
! Ø
| Ø || Ø || Ø || Ø || Ø || Ø
|-
! G
| Ø
| <math>\overset{\ \ \uparrow}{\leftarrow}</math>Ø
| <math>\overset{\nwarrow}{\ }</math>(G)
| <math>\overset{\ }{\leftarrow}</math>(G)
| <math>\overset{\ }{\leftarrow}</math>(G)
| <math>\overset{\ }{\leftarrow}</math>(G)
|-
! A
| Ø
| <math>\overset{\nwarrow}{\ }</math>(A)
| <math>\overset{\ \ \uparrow}{\leftarrow}</math>(A) & (G)
| <math>\overset{\ \ \uparrow}{\leftarrow}</math>(A) & (G)
| <math>\overset{\nwarrow}{\ }</math>(GA)
| <math>\overset{\ }{\leftarrow}</math>(GA)
|-
! C
| Ø
| 
| 
| 
| 
| 
|-
|}

Para ''LCS''(''R''<sub>3</sub>, ''C''<sub>1</sub>), C y A son diferentes, así que ''LCS''(''R''<sub>3</sub>, ''C''<sub>1</sub>) llega a ser la secuencia más larga que es, (A).

Para ''LCS''(''R''<sub>3</sub>, ''C''<sub>2</sub>), C y G son diferentes. Ambos ''LCS''(''R''<sub>3</sub>, ''C''<sub>1</sub>) y ''LCS''(''R''<sub>2</sub>, ''C''<sub>2</sub>) tienen un elemento. Y da como resultado de ''LCS''(''R''<sub>3</sub>, ''C''<sub>2</sub>) las dos subsecuencias, (A) and (G).

Para ''LCS''(''R''<sub>3</sub>, ''C''<sub>3</sub>), C y C son iguales, así que C se anexa a ''LCS''(''R''<sub>2</sub>, ''C''<sub>2</sub>), la cual contiene dos secuencias, (A) y (G), dando como resultado (AC) y (GC).

Para ''LCS''(''R''<sub>3</sub>, ''C''<sub>4</sub>), C y A no son iguales. Combinanado ''LCS''(''R''<sub>3</sub>, ''C''<sub>3</sub>), que contiene (AC) y (GC), y ''LCS''(''R''<sub>2</sub>, ''C''<sub>4</sub>), que contiene (GA), da como resultado tres secuencias:  (AC), (GC), y (GA).

Finalmente, para ''LCS''(''R''<sub>3</sub>, ''C''<sub>5</sub>), C y T son diferentes. Entonces ''LCS''(''R''<sub>3</sub>, ''C''<sub>5</sub>) también llega a tener tres secuencias, (AC), (GC), y (GA).

{| class="wikitable" style="text-align:center"
|+ Tabla LCS completada
|-
!   || Ø || A || G || C || A || T
|-
! Ø
| Ø || Ø || Ø || Ø || Ø || Ø
|-
! G
| Ø
| <math>\overset{\ \ \uparrow}{\leftarrow}</math>Ø
| <math>\overset{\nwarrow}{\ }</math>(G)
| <math>\overset{\ }{\leftarrow}</math>(G)
| <math>\overset{\ }{\leftarrow}</math>(G)
| <math>\overset{\ }{\leftarrow}</math>(G)
|-
! A
| Ø
| <math>\overset{\nwarrow}{\ }</math>(A)
| <math>\overset{\ \ \uparrow}{\leftarrow}</math>(A) & (G)
| <math>\overset{\ \ \uparrow}{\leftarrow}</math>(A) & (G)
| <math>\overset{\nwarrow}{\ }</math>(GA)
| <math>\overset{\ }{\leftarrow}</math>(GA)
|-
! C
| Ø
| <math>\overset{\ \uparrow}{\ }</math>(A)
| <math>\overset{\ \ \uparrow}{\leftarrow}</math>(A) & (G)
| <math>\overset{\nwarrow}{\ }</math>(AC) & (GC)
| <math>\overset{\ \ \uparrow}{\leftarrow}</math>(AC) & (GC) & (GA)
| <math>\overset{\ \ \uparrow}{\leftarrow}</math>(AC) & (GC) & (GA)
|-
|}

El resultado final es la última celda que contiene la subsecuencia común más larga de (AGCAT) y (GAC); estos son (AC), (GC), y (GA). La tabla también muestra que la subsecuencia común más larga de todas las combinaciones de prefijos. Por ejemplo para (AGC) y (GA), la subsecuencia común más larga son (A) y (G).

=== Reconstrucción de la solución ===
Calculando el LCS de una fila de la tabla solamente requiere la fila actual y la fila anterior. Aun así, para las secuencias largas, estas secuencias pueden ser numerosas y largas. Requeriendo grandes cantidades de espacio de almacenamiento. El espacio de almacenamiento se puede reducir guardando solamente la longitud de la subsecuencia y la dirección de las flechas como se muestra a continuación.

{| class="wikitable" style="text-align:center"
|+ Almacenando longitud y dirección
|-
!|| Ø || A || G || C || A || T
|-
! Ø
| 0 || 0 || 0 || 0 || 0 || 0
|-
! G
| 0
| <math>\overset{\ \ \uparrow}{\leftarrow}</math>0
| <math>\overset{\nwarrow}{\ }</math>1
| <math>\overset{\ }{\leftarrow}</math>1
| <math>\overset{\ }{\leftarrow}</math>1
| <math>\overset{\ }{\leftarrow}</math>1
|-
! A
| 0
| <math>\overset{\nwarrow}{\ }</math>1
| <math>\overset{\ \ \uparrow}{\leftarrow}</math>1
| <math>\overset{\ \ \uparrow}{\leftarrow}</math>1
| <math>\overset{\nwarrow}{\ }</math>2
| <math>\overset{\ }{\leftarrow}</math>2
|-
! C
| 0
| <math>\overset{\ \uparrow}{\ }</math>1
| <math>\overset{\ \ \uparrow}{\leftarrow}</math>1
| <math>\overset{\nwarrow}{\ }</math>2
| <math>\overset{\ \ \uparrow}{\leftarrow}</math>2
| <math>\overset{\ \ \uparrow}{\leftarrow}</math>2
|-
|}

Las subsecuencias pueden ser deducidas en una reconstrucción que sigue las flechas, empezando por la última celda de la tabla. Cuando la longitud decrece, la subsecuencia obtiene un elemento común. Como notamos varios caminos son posibles cuando se muestran dos flechas en la celda. A continuación se muestra el análisis y los números de color son celdas donde su número decrece. Los números en negrita reconstruyen la secuencia (GA)<ref>{{cite book | author = [[Thomas H. Cormen]], [[Charles E. Leiserson]], [[Ronald L. Rivest]] and [[Clifford Stein]] | title = [[Introduction to Algorithms]] | publisher = [[MIT Press]] and McGraw-Hill | year = 2001 | isbn = 0-262-53196-8 | edition = 2nd | chapter = 15.4 | pages = 350–355 }}</ref>

{| class="wikitable" style="text-align:center"
|+ Ejemplo de reconstrucción
|-
!   || Ø || A || G || C || A || T
|-
! Ø
| 0 || style="background:silver" | '''0''' || 0 || 0 || 0 || 0
|-
! G
| style="background:silver" | 0
| <math>\overset{\ \ \uparrow}{\leftarrow}</math>0
| style="background:silver;color:#FF6600" | <math>\overset{\nwarrow}{\ }</math>'''1'''
| style="background:silver" | <math>\overset{\ }{\leftarrow}</math>'''1'''
| <math>\overset{\ }{\leftarrow}</math>1
| <math>\overset{\ }{\leftarrow}</math>1
|-
! A
| 0
| style="background:silver;color:#FF6600" | <math>\overset{\nwarrow}{\ }</math>1
| style="background:silver" | <math>\overset{\ \ \uparrow}{\leftarrow}</math>1
| <math>\overset{\ \ \uparrow}{\leftarrow}</math>1
| style="background:silver;color:#FF6600" | <math>\overset{\nwarrow}{\ }</math>'''2'''
| style="background:silver" | <math>\overset{\ }{\leftarrow}</math>'''2'''
|-
! C
| 0
| <math>\overset{\ \uparrow}{\ }</math>1
| <math>\overset{\ \ \uparrow}{\leftarrow}</math>1
| style="background:silver;color:#FF6600" | <math>\overset{\nwarrow}{\ }</math>2
| style="background:silver" | <math>\overset{\ \ \uparrow}{\leftarrow}</math>2
| style="background:silver" | <math>\overset{\ \ \uparrow}{\leftarrow}</math>'''2'''
|-
|}

== Relación a otros problemas ==
Para dos cadenas <math>X_{1 \dots m}</math> y <math>Y_{1 \dots n}</math>, la longitud de la supersecuencia común más corta (SCS) se relaciona a la longitud del LCS:<ref name="BHR00" />

:<math>\left|SCS(X,Y)\right| = n + m - \left|LCS(X,Y)\right|.</math>

La distancia de edición cuando solamente la inserción y el borrado es permitido (no hay sustitución), o cuando el costo de la sustitución es el doble del costo de inserción o borrado:

:<math>d'(X,Y) = n + m - 2 \cdot \left|LCS(X,Y)\right|.</math>

== Código para solución en programación dinámica ==
=== Calculando la longitud del LCS ===
La función que se muestra en seguida recibe dos secuencias de entrada <code>X[1..m]</code> y <code>Y[1..n]</code> . Y Calcula el LCS entre <code>X[1..i]</code> y <code>Y[1..j]</code> para todo <code>1 ≤ i ≤ m</code> y <code>1 ≤ j ≤ n</code>, Y lo almacena en  <code>C[i,j]</code>. <code>C[m,n]</code> guardará la longitud de LCS de <code>X</code> y <code>Y</code>.

 '''function''' LCSLength(X[1..m], Y[1..n])
     C = array(0..m, 0..n)
     '''for''' i := 0..m
        C[i,0] = 0
     '''for''' j := 0..n
        C[0,j] = 0
     '''for''' i := 1..m
         '''for''' j := 1..n
             '''if''' X[i] = Y[j]
                 C[i,j] := C[i-1,j-1] + 1
             '''else'''
                 C[i,j] := max(C[i,j-1], C[i-1,j])
     '''return''' C[m,n]

Alternativamente, memoización podría ser utilizado.

=== Reconstruyendo un LCS ===
La función que se muestra en seguida reconstruye las decisiones tomadas cuando calculaba la tabla <code>C</code>. Si el último carácter en el prefijo son iguales, entonces deberían ser LCS. Si no, debería verificar cual tiene el mayor LCS almacenando <math>x_i</math> y <math>y_j</math>, y tomando la misma decisión. Solamente elige uno cuando son igual de largos. Se llama la función con <code>i=m</code> y <code>j=n</code>.

 '''function''' backtrack(C[0..m,0..n], X[1..m], Y[1..n], i, j)
     '''if''' i = 0 '''or''' j = 0
         '''return''' ""
     '''else if ''' X[i] = Y[j]
         '''return''' backtrack(C, X, Y, i-1, j-1) + X[i]
     '''else'''
         '''if''' C[i,j-1] > C[i-1,j]
             '''return''' backtrack(C, X, Y, i, j-1)
         '''else'''
             '''return''' backtrack(C, X, Y, i-1, j)

=== Reconstruyendo todos los LCSs ===
Si al elegir <math>x_i</math> y <math>y_j</math> están en una cadena de igual longitud, se leen las dos subsecuencias resultantes. Esto se devuelve como un conjunto por la función. Nótese que la función no es polinomica ya que podría crear ramas en cada paso si las cadenas son parecidas. 

 '''function''' backtrackAll(C[0..m,0..n], X[1..m], Y[1..n], i, j)
     '''if''' i = 0 '''or''' j = 0
         '''return''' {""}
     '''else if''' X[i] = Y[j]
         '''return''' {Z + X[i] '''for all''' Z '''in''' backtrackAll(C, X, Y, i-1, j-1)}
     '''else'''
         R := {}
         '''if''' C[i,j-1] ≥ C[i-1,j]
             R := R ∪ backtrackAll(C, X, Y, i, j-1)
         '''if''' C[i-1,j] ≥ C[i,j-1]
             R := R ∪ backtrackAll(C, X, Y, i-1, j)
         '''return''' R

=== Imprimir las diferencias ===
Esta función recorre la matriz C en reverso e imprime la diferencia entre las dos secuencias. Nótese que se obtendrá un resultado diferentes si se intercambian <code>≥</code> y <code>&lt;</code>, con <code>&gt;</code> y <code>≤</code>

 '''function''' printDiff(C[0..m,0..n], X[1..m], Y[1..n], i, j)
     '''if''' i > 0 '''and''' j > 0 '''and''' X[i] = Y[j]
         printDiff(C, X, Y, i-1, j-1)
         print "  " + X[i]
     '''else if''' j > 0 '''and''' (i = 0 '''or''' C[i,j-1] ≥ C[i-1,j])
         printDiff(C, X, Y, i, j-1)
         print "+ " + Y[j]
     '''else if''' i > 0 '''and''' (j = 0 '''or''' C[i,j-1] < C[i-1,j])
         printDiff(C, X, Y, i-1, j)
         print "- " + X[i]
     '''else'''
         print ""

=== Ejemplo ===
Supongamos que <math>X</math> es “<code>XMJYAUZ</code>” y <math>Y</math> es “<code>MZJAWXU</code>”. el LCS de <math>X</math> y <math>Y</math> es “<code>MJAU</code>”. La tabla <code>C</code> que se muestra a continuación, la cual fue generada por la función <code>LCSLength</code>, muestra las longitudes de las subsecuencias comunes más largas entre los prefijos de <math>X</math> y <math>Y</math>. La fila <math>i</math> y la columna <math>j</math> muestra la longitud de LCS entre <math>X_{1..i}</math> y <math>Y_{1..j}</math>.

{| class="wikitable" style="text-align: center;"
|-
! colspan="2" rowspan="2" |
! 0 !! 1 !! 2 !! 3 !! 4 !! 5 !! 6 !! 7
|-
! Ø !! M !! Z !! J !! A !! W !! X !! U
|-
! 0 !! Ø
| style="background:yellow" | '''0''' || 0 || 0 || 0 || 0 || 0 || 0 || 0
|-
! 1 !! X
| style="background:yellow" | 0 || 0 || 0 || 0 || 0 || 0 || 1 || 1
|-
! 2 !! M
| 0 || style="background:yellow" | '''1''' || style="background:yellow" | 1 || 1 || 1 || 1 || 1 || 1
|-
! 3 !! J
| 0 || 1 || 1 || style="background:yellow" | '''2''' || 2 || 2 || 2 || 2
|-
! 4 !! Y
| 0 || 1 || 1 || style="background:yellow" | 2 || 2 || 2 || 2 || 2
|-
! 5 !! A
| 0 || 1 || 1 || 2 || style="background:yellow" | '''3''' || style="background:yellow" | 3 || style="background:yellow" | 3 || 3
|-
! 6 !! U
| 0 || 1 || 1 || 2 || 3 || 3 || 3 || style="background:yellow" | '''4'''
|-
! 7 !! Z
| 0 || 1 || 2 || 2 || 3 || 3 || 3 || style="background: yellow" | 4
|}

Los números marcados muestran el camino de la función de la reconstrucción que seguiría empezando desde la celda inferior derecha, cuando se está leyendo un LCS. Si los símbolos actuales de <math>X</math> y <math>Y</math> son iguales, se forman parte de LCS y se pasa a la celda superior izquierda (se muestra en negrita). Si no, se pasa hacia la celda superior o a la celda izquierda dependiendo del número que escrito en la celda. Este proceso corresponde a tomar el LCS entre <math>X_{1..i-1}</math> y <math>Y_{1..j}</math>, ó <math>X_{1..i}</math> y <math>Y_{1..j-1}</math>.

== Optimización de código ==
Varias optimizaciones son posibles en el algoritmo para reducir el tiempo en casos reales.

=== Reducir el conjunto del problema ===
La matriz C en el algoritmo original crece cuadráticamente con la longitud de las secuencias. Para dos secuencias de 100 elementos se debe crear una matriz de 10,000 elementos la cual necesitaría el cálculo de 10000 comparaciones. En muchos casos de la vida real, especialmente en los códigos fuente de diff y patch, el comienzo y el fin cambia raramente y casi nunca cambian las dos al mismo tiempo. Si solamente algunos elementos cambiaron en medio de la secuencias, El comienzo y el fin podrían ser eliminados. Esto reduce no solamente la memoria que se requiere para generar la matriz, pero también el número de comparaciones que se deben ejecutar.

 '''function''' LCS(X[1..m], Y[1..n])
     start := 1
     m_end := m
     n_end := n
     ''trim off the matching items at the beginning''
     '''while''' start ≤ m_end '''and''' start ≤ n_end '''and''' X[start] = Y[start]
         start := start + 1
     ''trim off the matching items at the end''
     '''while''' start ≤ m_end '''and''' start ≤ n_end '''and''' X[m_end] = Y[n_end]
         m_end := m_end - 1
         n_end := n_end - 1
     C = array(start-1..m_end, start-1..n_end)
     ''only loop over the items that have changed''
     '''for''' i := start..m_end
         '''for''' j := start..n_end
             ''the algorithm continues as before ...''

En el mejor de los casos, en una secuencia sin cambios, esta optimización eliminaría completamente la necesidad por la matriz C. En el peor de los casos, cuando los cambios están en los primeros elementos y en los últimos elementos solamente dos comparaciones adicionales serán ejecutadas.

=== Reduciendo el tiempo de comparación ===
La mayoría del tiempo es gastado en las comparaciones que se hacen entre dos elementos de las secuencias. Para secuencias textuales como códigos fuente, se quiere ver las líneas como los elementos de las secuencias en lugar de caracteres individuales. Esto hace que se tenga que comparar cadenas relativamente largas para cada paso del algoritmo. Dos optimizaciones se pueden hacer para reducir el tiempo.

=== Reduciendo las cadenas a hash ===
Una función hash puede ser utilizada para reducir el tamaño de las cadenas en las secuencias. Esto es que para códigos fuente donde cada línea es de 60 o más caracteres, el hash podría reducirse a una de 8 a 40 caracteres. Además, la naturaleza aleatorizada de los hashes pueden garantizar que las comparaciones serían más rápidas ya que el los códigos fuentes no cambian frecuentemente desde el principio. 

Pero existen tres desventajas en esta optimización. Primero el tiempo necesario para calcular al hash de las dos secuencias antes de la comparación. Segundo, memoria adicional requerida para alocar las secuencias en hash. Pero aun así estas desventajas son mínimas emparadas al algoritmo original. 

La tercera desventaja son las colisiones. Ya que el hash no garantiza ser único, hay una pequeña probabilidad de que dos cadenas diferentes resultaran en el mismo hash. Esto casi no es susceptible en códigos fuente, pero sí es posible. Un hash criptográfico podría ser más adecuado para esta optimización, ya que la entropía va a ser mucho más alta que la de un hash simple. Aun así, los beneficios podrían no ser suficientemente valiosos en comparación a la preparación y el poder computacional que se requiere.

=== Reduciendo el espacio requerido ===
Si solamente la longitud de LCS es necesario, la matriz puede ser reducida a <math>2\times \min(n,m)</math> con facilidad, o a un vector de <math>\min(m,n)+1</math> ya que la programación dinámica solamente requiere las columna actual y el anterior. El algoritmo de Hirschberg permite la construcción de secuencias óptimas en el mismo tiempo cuadrático y límites de espacio lineal<ref>{{cite journal|authorlink = Dan Hirschberg|author=Hirschberg, D. S.|title=A linear space algorithm for computing maximal common subsequences|journal=Communications of the ACM|volume=18|issue=6|year=1975|pages=341–343|doi=10.1145/360825.360861}}</ref>

=== Algoritmos más optimizados ===
Existen varios algoritmos que son más rápidos que el peor de los casos del algoritmo presentado con programación dinámica.<ref>http://books.google.com/books?id=mFd_grFyiT4C&pg=PA132&lpg=PA132&dq=hunt+szymanski+algorithm&source=bl&ots=sMc-HtvNTQ&sig=FtrZ_b5JdJ25Ighwc1-XOfysaf8&hl=en&sa=X&ei=-BU9VPK7OpS7ggT0gYEQ&ved=0CDsQ6AEwAw#v=onepage&q&f=false</ref> Para problemas con tamaños de alfabeto limitado, el método de los Cuatro Rusos puede ser utilizado para reducir el tiempo de ejecución de la programación dinámica a un factor logarítmico.<ref>{{citation
 | last1 = Masek | first1 = William J.
 | last2 = Paterson | first2 = Michael S. | author2-link = Mike Paterson
 | doi = 10.1016/0022-0000(80)90002-1
 | issue = 1
 | journal = Journal of Computer and System Sciences
 | mr = 566639
 | pages = 18–31
 | title = A faster algorithm computing string edit distances
 | volume = 20
 | year = 1980}}.</ref> Para <math>r</math> (donde <math>n > m</math>), el número de equivalencias entre las dos cadenas, existe un algoritmo que lo hace en un tiempo de  <math>O((n + r)\log(n))</math> <ref>http://www.cs.bgu.ac.il/~dpaa111/wiki.files/HuntSzymanski.pdf</ref>

== Comportamiento en cadenas aleatorias ==
Empezando por{{harvtxt|Chvátal|Sankoff|1975}},<ref>{{citation
 | last1 = Chvatal | first1 = Václáv | author1-link = Václav Chvátal
 | last2 = Sankoff | first2 = David | author2-link = David Sankoff
 | journal = Journal of Applied Probability
 | mr = 0405531
 | pages = 306–315
 | title = Longest common subsequences of two random sequences
 | volume = 12
 | year = 1975 | doi=10.2307/3212444}}.</ref> varios investigadores han trabajado en el comportamiento de la longitud de LCS cuando se tiene dos cadenas aleatorias que se forman del mismo alfabeto. Cuando el tamaño del alfabeto es constante, el número esperado de la longitud de LCS es proporcional a la longitud de dos cadenas, y las constante de la proporción se les conoce como constantes de Chvátal-Sankoff. Sus valores exactos no se conocen pero sus límites superiores e inferiores se han comprobado,<ref>{{citation
 | last = Lueker | first = George S.
 | doi = 10.1145/1516512.1516519
 | issue = 3
 | journal = [[Journal of the ACM]]
 | mr = 2536132
 | at = A17
 | title = Improved bounds on the average length of longest common subsequences
 | volume = 56
 | year = 2009}}.</ref> y también se conoce que crecen inversamente proporcional al la raíz cuadrada del tamaño del alfabeto.<ref>{{citation
 | last1 = Kiwi | first1 = Marcos
 | last2 = Loebl | first2 = Martin
 | last3 = Matoušek | first3 = Jiří | author3-link = Jiří Matoušek (mathematician)
 | doi = 10.1016/j.aim.2004.10.012
 | issue = 2
 | journal = Advances in Mathematics
 | mr = 2173842
 | pages = 480–498
 | title = Expected length of the longest common subsequence for large alphabets
 | volume = 197
 | year = 2005}}.</ref> Modelos simples matemáticos de LCS han sido probados que son regidos por la distribución Tracy-Widom.<ref>{{citation
 | last1 = Majumdar | first1 = Satya N.
 | last2 = Nechaev | first2 = Sergei
 | doi = 10.1103/PhysRevE.72.020901
 | issue = 2
 | journal = Physical Review E
 | mr = 2177365
 | pages = 020901, 4
 | title = Exact asymptotic results for the Bernoulli matching model of sequence alignment
 | volume = 72
 | year = 2005}}.</ref>

== Referencias ==
{{Listaref}}
<!-- Dead note "GJ78": {{cite book|author = [[Michael R. Garey]] and [[David S. Johnson]] | year = 1979 | title = Computers and Intractability: A Guide to the Theory of NP-Completeness|url = https://archive.org/details/computersintract00gare_180 | publisher = W.H. Freeman | isbn = 0-7167-1045-5| pages = [https://archive.org/details/computersintract00gare_180/page/n238 228]}} A421: SR10. -->

== Ligas Externas ==
{{Wikibooks|Algorithm implementation|Strings/Longest common subsequence|Longest common subsequence}}
* [http://nist.gov/dads/HTML/longestCommonSubsequence.html Dictionary of Algorithms and Data Structures: longest common subsequence]
* [http://rosettacode.org/wiki/Longest_common_subsequence A collection of implementations of the longest common subsequence in many programming languages]

 <!-- case of fixed number of input strings -->
 <!-- case of arbitrary number of input strings -->

{{Control de autoridades}}

[[Categoría:Combinatoria]]