Најдужи заједнички подниз

Проблем проналаска најдужег заједничког подниза или најдуже заједничке подниске (енгл. longest common subsequence problem) представља алгоритамски проблем у којем је потребно одредити најдужу подниску која је заједничка свим нискама у скупу ниски (који чине најчешће две ниске). Подниска неке ниске симбола се добија уклањањем нула или више симбола из дате ниске, при чему неуклоњени симболи задржавају свој оригинални међусобни редослед. На пример, за две ниске "бтматмац" и "мтамтаб", најдуже заједничке подниске су, између осталих, "мата" и "мама". Проблем проналаска најдуже заједничке подниске има примену у програмима који се баве компресијом података, као и у биоинформатици.

Увод

Подниз датог низа је једноставно дати низ са нула или више изостављених елемената. Формално, уколико имамо низ $X=\left\{x_{1},x_{2},\dots ,x_{m}\right\}$ тада је низ $Z=\left\{z_{1},z_{2},\dots ,z_{k}\right\}$ подниз низа $X$ ако постоји строго растући низ индекса $(i_{1},\dots ,i_{k})$ низа $X$ такав да за свако $j=1,\dots ,k$ важи $x_{i_{j}}=z_{j}$. На пример, низ $Z=\left({\text{B,C,D,B}}\right)$ је подниз низа $X=\left({\text{A,B,C,D,B,A,B}}\right)$ са одговарајућим низом индекса $(2,3,5,7)$.

Уколико имамо два низа $X$ и $Y$, низ $Z$ називамо заједничким поднизом низова $X$ и $Y$ уколико је низ $Z$ уједно подниз низа $X$ и подниз низа $Y$. На пример, ако је $X=\left({\text{A,B,C,D,B,A,B}}\right)$ и $Y=\left({\text{B,D,C,A,B,A}}\right)$ тада је низ $\left({\text{B,C,A}}\right)$ заједнички подниз низова $X$ и $Y$. Међутим, низ $\left({\text{B,C,A}}\right)$ није најдужи заједнички подниз низова $X$ и $Y$. Низ $\left({\text{B,C,B,A}}\right)$ је најдужи заједнички подниз низова $X$ и $Y$, као што је и низ $\left({\text{B,D,A,B}}\right)$ јер низови $X$ и $Y$ немају зајеничких поднизова дужине 5 или веће.

Проблем најдужи заједнички подниз (НЗП) представља проналажење заједничког подниза максималне дужине унапред задатих низова $X=\left\{x_{1},x_{2},\dots ,x_{m}\right\}$ и $Y=\left\{y_{1},y_{2},\dots ,y_{n}\right\}$.

Карактеризација најдужег заједничког подниза

У покушају да решимо НЗП проблем грубом силом, прво бисмо нумерисали све поднизове низа $X$ и онда бисмо проверили да ли је сваки од њих уједно и подниз низа $Y$, памтећи најдужи који смо до тог тренутка пронашли. Сваком поднизу низа $X$ одговара подскуп индекса $\left\{1,\dots ,m\right\}$ низа $X$. Обзиром да низ $X$ има $2^{m}$ поднизова, овакав приступ захтева експоненцијално време што га чини непрактичним за дугачке низове.

НЗП проблем има својство оптималног потпроблема, што доказује следећа теорема. Природне класе потпроблема одговорају паровима префикса полазних низова. Прецизније, ако имамо низ $X=\left\{x_{1},x_{2},\dots ,x_{m}\right\}$ дефинишимо $i$-ти префикс од $X$ за свако $i=1,\dots ,m$ као $X_{i}=\left(x_{1},\dots ,x_{i}\right)$. На пример, ако је $X=\left({\text{A,B,C,D,B,A,B}}\right)$ тада је $X_{4}=\left({\text{A,B,C,D}}\right)$ и $X_{0}$ је празан низ.

Теорема

Нека су дати низови $X=\left\{x_{1},x_{2},\dots ,x_{m}\right\}$ и $Y=\left\{y_{1},y_{2},\dots ,y_{n}\right\}$, и нека је $Z=\left(z_{1},\dots ,z_{k}\right)$ било који најдужи заједнички подниз (НЗП) низова $X$ и $Y$. Тада:

1. Ако $x_{m}=y_{n}$, онда $z_{k}=x_{m}=y_{n}$ и $Z_{k-1}$ је НЗП низова $X_{m-1}$ и $Y_{n-1}$.
2. Ако $x_{m}\neq y_{n}$, онда $z_{k}\neq x_{m}$ и $Z$ је НЗП низова $X_{m-1}$ и $Y$.
3. Ако $x_{m}\neq y_{n}$, онда $z_{k}\neq y_{n}$ и $Z$ је НЗП низова $X$ и $Y_{n-1}$.

Доказ

(1) Ako je $z_{k}\neq x_{m}$ онда можемо да надовежемо $x_{m}=y_{n}$ на $Z$ чиме бисмо добили заједнички подниз низова $X$ и $Y$ дужине $k+1$, што је у контрадикцији са претпоставком да је $Z$ најдужи заједнички подниз. Стога, мора да важи $z_{k}=x_{m}=y_{n}$. Префикс $Z_{k-1}$ је заједнички подниз низова $X_{m-1}$ и $Y_{n-1}$ дужине $k-1$, и још остаје да се покаже да је НЗП. Претпоставимо да постоји заједнички подниз $W$ низова $X_{m-1}$ и $Y_{n-1}$ са дужином већом од $k-1$. Тада, надовезујући $x_{m}=y_{n}$ на $W$ добијамо заједнички подниз дужине веће од $k$, што је у контрадикцији са претпоставком да је $Z$ НЗП.

(2) Ако $z_{k}\neq x_{m}$, онда је $Z$ је заједнички подниз низова $X_{m-1}$ и $Y$. Ако би постојао заједнички подниз $W$ низова $X_{m-1}$ и $Y$ дужине веће од $k$, онда би $W$ био заједнички подниз низова $X_{m}$ и $Y$, што је у контрадикцији са претпоставком да је $Z$ НЗП низова $X$ и $Y$.

(3) Симетрично другом случају.

Начин на који теорема карактерише најдужи заједнички подниз говори нам да НЗП два низа у себи садржи и НЗП префикса та два низа. Стога, прблем НЗП има својство оптималног потпроблема.

Рекурзивно решење

Теорема нам говори да треба да испитамо или једно или два потпроблема када проналазимо најдужи заједнички подниз низова $X=\left\{x_{1},x_{2},\dots ,x_{m}\right\}$ и $Y=\left\{y_{1},y_{2},\dots ,y_{n}\right\}$. Ако је $x_{m}=y_{n}$ онда морамо да пронађемо НЗП низова $X_{m-1}$ и $Y_{n-1}$. Надовезујући $x_{m}=y_{n}$ на пронађени НЗП добићемо најдужи заједнички подниз низова $X$ и $Y$. Ако $x_{m}\neq y_{n}$, онда морамо да решимо два потпроблема: морамо да пронађемо НЗП низова $X_{m-1}$ и $Y$ и НЗП низова $X$ и $Y_{n-1}$. Дужи од два пронађена најмања заједничка подниза је НЗП полазних низова $X$ и $Y$.

Лако се уочава да се потпроблеми проблема НЗП међусобно преплићу. Како бисмо пронашли НЗП низова $X$ и $Y$, можда треба да пронађемо и најдуже заједничке поднизове низова $X_{m-1}$ и $Y$ и низова $X$ и $Y_{n-1}$. Али, сваки од ова два потпроблема за потпроблем има проналазак најмањег заједничког подниза низова $X_{m-1}$ и $Y_{n-1}$. Многи други потпроблеми деле своје потпроблеме.

Рекурзивно решење НЗП проблема обухвата и креирање рекурентне релације за проналажење оптималног решења. Дефинишимо $c\left[i,j\right]$ као дужину НЗП низова $X_{i}$ и $Y_{j}$. Ако је $i=0$ или $j=0$, онда један од низова има дужину $0$, чиме је и НЗП дужине $0$. Опитимални потпроблем НЗП проблема даје следећу рекурентну релацију:

$c\left[i,j\right]={\begin{cases}0,&{\text{ako }}i=0{\text{ ili }}j=0\\c\left[i-1,j-1\right]+1&{\text{ako }}i,j>0{\text{ i }}x_{i}=y_{j}\\\max \left(c\left[i,j-1\right],c\left[i-1,j\right]\right)&{\text{ako }}i,j>0{\text{ i }}x_{i}\neq y_{j}\end{cases}}$

Приметимо да у рекурентној релацији услов у проблему одређује који потпроблем ћемо да разматрамо. Када је $x_{i}=y_{j}$, тада треба да разматрамо потпроблем који представња тражење најдужег заједничког подниза низова $X_{i-1}$ и $Y_{j-1}$. У супротном, разматраћемо два потпроблема, један је проналажење НЗП низова $X_{i}$ и $Y_{j-1}$ и НЗП низова $X_{i-1}$ и $Y_{j}$.

Израчунавање дужине најдужег заједничког подниза

Уз помоћ горе наведене рекурентне релације лако можемо да напишемо рекурзивни алгоритам који ће израчунавати дужину најдужег заједничког подниза два низа у експоненцијалном времену. Обзиром да НЗП проблем има само $\Theta \left(mn\right)$ различитих потпроблема можемо да искористимо динамичко програмирање за израчунавање решења одоздо нагоре.

Процедура LCS_length као улазне аргументе има два низа $X=\left\{x_{1},x_{2},\dots ,x_{m}\right\}$ и $Y=\left\{y_{1},y_{2},\dots ,y_{n}\right\}$. Процедура чува вредности $c\left[i,j\right]$ у матрици $c\left[0\dots m,0\dots n\right]$, тако што редом по врстама слева надесно израчунава дужине најдужих заједничких поднизова низова $X_{i}$ и $Y_{j}$. Процедура такође одржава и помоћну матрицу $b\left[1\dots m,1\dots n\right]$ коју користимо при конструкцији најдужег заједничког подниза. Интуитивно, $b\left[i,j\right]$ показује на запис у матрици који одговара оптималном решењу изабраног потпроблема приликом израчунавања $c\left[i,j\right]$. Процедура враћа матрице $b$ и $c$, при чему $c\left[m,n\right]$ садржи дужину најдужег заједничког подниза низова $X$ и $Y$.

Дефинишимо следеће симболе:

${\text{GORELEVO }}\nwarrow$

${\text{GORE }}\uparrow$

${\text{LEVO }}\leftarrow$

LCS_length(X, Y)

m = X.dužina
n = Y.dužina
neka su b[1 .. m, 1 .. n] i c[0 .. m, 1 .. n] prazne matrice

for i = 1 do m
   c[i,0] = 0
for j = 0 do n
   c[0,j] = 0

for i = 1 do m
   for j = 1 do n
      if x[i] == y[j]
         c[i,j] = c[i-1,j-1] + 1
         b[i,j] = GORELEVO
      else if c[i-1,j] >= c[i, j-1]
         c[i,j] = c[i-1, j]
         b[i,j] = GORE
      else
         c[i,j] = c[i, j-1]
         b[i,j] = LEVO

return b i c

Време извршавања приказане процедуре је $\Theta \left(mn\right)$, јер сваки унос у матрицу захтева $\Theta \left(1\right)$ корака приликом извршавања.

Конструисање најдужег заједничког подниза

Матрица $b$ коју враћа процедура LCS_length омогућава нам да брзо конструишемо НЗП низова $X=\left\{x_{1},x_{2},\dots ,x_{m}\right\}$ и $Y=\left\{y_{1},y_{2},\dots ,y_{n}\right\}$. Једноставно кренемо од $b\left[m,n\right]$ и само се крећемо кроз матрицу пратећи стрелице. Када год наиђемо на стрелицу $\nwarrow$ на пољу $b\left[i,j\right]$ то значи да је $x_{i}=y_{j}$ елемент најдужег заједничког подниза низова $X$ и $Y$ који је процедура LCS_length пронашла. Овим приступом откривамо елементе НЗП низова $X$ и $Y$ у обрнутом поретку. Следећа рекурзивна процедура штампа елементе НЗП низова $X$ и $Y$ у оригиналном поретку. Позив процедуре је следећи LCS_print(b, X, X.dužina, Y.dužina).

LCS_print(b,X,i,j)

if i == 0 ili j == 0
   return
if b[i,j] == GORELEVO
   LCS_print(b, X, i-1, j-1)
   print X[i]
else if b[i,j] == GORE
   LCS_print(b, X, i-1, j)
else
   LCS_print(b, X, i, j-1)

Процедури LCS_print је потребно $\mathrm {O} \left(m+n\right)$ корака за извршавање, јер се у сваком рекурзивном позиву смањује барем један од индекса $i$ и $j$.

Унапређења

У НЗП алгоритму могуће је потпуно елиминисати матрицу $b$. Сваки $c\left[i,j\right]$ зависи само од још три записа у матрици $c$: $c\left[i-1,j-1\right]$,$c\left[i-1,j\right]$ и $c\left[i,j-1\right]$. Уколико имамо вредност $c\left[i,j\right]$, онда можемо у константном времену да утврдимо која од ове три вредности је била искоришћена приликом израчунавања $c\left[i,j\right]$ без потребе да приступамо елементима матрице $b$. Стога можемо да реконструишемо НЗП у времену $\mathrm {O} \left(m+n\right)$. Иако ћемо на овај начин уштедети $\Theta \left(mn\right)$ простора, додатни простор за израчунавање најдужег заједничког подниза не опада асимптотски, јер нам и даље треба $\Theta \left(mn\right)$ простора за складиштење матрице $c$.

Ипак, можемо асимптотски да смањимо потребан простор за израчунавање дужине најдужег заједничког подниза, јер су нам у сваком тренутку потребне само две врсте матрице $c$: врста која се израчунава и претходно израчуната врста. Ово унапређење је корисно само ако нам треба дужина најдужег заједничког подниза, јер смањена матрица не садржи довољно информација за реконструкцију самог НЗП-а у времену $\mathrm {O} \left(m+n\right)$.

Примене

Апликације у биологији често треба да пореде ДНК ланце два или више различитих организама. ДНК ланци могу да се представе као коначне речи над језиком $\mathrm {L} =\left\{A,C,G,T\right\}$. Један од разлога за поређење ДНК ланаца различитих организама је утврђивање њихове међусобне сличности, што може да буде мера сродности различитих организама. Сличност два ланца може да се мери на различите начине. Један од начина како можемо да измеримо сличност два ДНК ланца $S_{1}$ и $S_{2}$ је да пронађемо трећи ланац $S_{3}$ у коме се симболи из језика $\mathrm {L}$ појављују и у ланцима $S_{1}$ и $S_{2}$; симболи морају да се појављују у истом редоследу али не и узастопно. Што је дужи пронађени ланац $S_{3}$, то су ланци $S_{1}$ и $S_{2}$ сличнији.

Опис решења за две ниске

За проналазак најдуже заједничке подниске две ниске x и y, израчунавају се дужине најдужих заједничких подниски свих могућих парова префикса, једног из ниске x и другог из ниске y. Нека је x = x₁...x_m и y = y₁...y_n. За свако i = 0,1,...,m и j = 0,1,...,n, најдужа заједничка подниска префикса x₁...x_i ниске x и префикса y₁...y_j ниске y се може одредити на следећи начин. Пре свега, уколико је i или j једнако 0, тада један од ових префикса мора бити празна реч, па је једина могућа заједничка подниска таква два префикса празна реч.

Уколико су i и j оба већи од 0, посматрају се два случаја у зависности од тога да ли су последњи знакови две ниске једнаки:

1. Ако је x_i ≠ y_j, тада најдужа заједничка подниска два префикса не може укључити x_i и y_j, већ је она једнака дужој од две најдуже заједничке подниске - за префиксе x₁...x_i-1 и y₁...y_j, односно x₁...x_i и y₁...y_j-1.
2. Ако је x_i = y_j, тада најдужа заједничка подниска може укључити x_i и y_j, који неће реметити друга потенцијална везивања симбола у два префикса. То значи да је најдужа заједничка подниска за префиксе x₁...x_i и y₁...y_j заправо најдужа заједничка подниска за префиксе x₁...x_i-1 и y₁...y_j-1 на које је надовезан последњи симбол који је исти у два префикса - x_i, односно y_j.

На основу ових запажања може се извести рекурзивна дефиниција за дужину најдуже заједничке подниске префикса x₁...x_i и y₁...y_j. Ако ту дужину означимо са L(i,j), тада је:

$L(i,j)=\left\{{\begin{matrix}0&i=0\lor j=0\\\max\{L(i,j-1),L(i-1,j)\}&i>0\land j>0\land x_{i}\neq y_{j}\\1+L(i-1,j-1)&i>0\land j>0\land x_{i}=y_{j}\end{matrix}}\right.$

Дужина најдуже заједничке подниске за две целе ниске x и y је L(m,n), што се може израчунати једноставним рекурзивним алгоритмом на основу претходне формуле. Међутим, време извршавања таквог алгоритма би било експоненцијално, а разлог за то је чињеница да алгоритам више пута рачуна дужину најдуже заједничке подниске за исте парове префикса.

Рекурзивни алгоритам се може знатно убрзати ако се примени приступ динамичког програмирања и конструише табела L вредности дужина L(i,j) за i=0,1,...,m и j=0,1,...,n. Пошто у израчунавању дужине L(i,j) учествују вредности L(i,j-1), L(i-1,j) и L(i-1,j-1), табела се може попуњавати ред по ред и тако обезбедити да се потребне вредности за L(i,j) налазе у табели. Ово је илустровано на следећој слици:

L(i-1,j-1)	L(i-1,j)
L(i,j-1)	L(i,j)

Табела L се може искористити за одређивање симбола који чине најдужу заједничку подниску. Пошто табела L садржи дужине најдужих заједничких подниски свих парова префикса две дате ниске, од доњег десног угла табеле се може формирати пут кроз ову табелу и на том путу узимати одређени симболи. Тако одабрани симболи у обрнутом редоследу представљају најдужу заједничку подниску за две дате ниске. Ако претпоставимо да на путу од доњег десног угла табеле L долазимо до тачке пресека i-те врсте и j-те колоне која одговара пару знакова x_i и y_j. Ако је x_i=y_j, онда знакове x_i и y_j сматрамо упареним и знак x_i=y_j додајемо испред свих знакова најдуже заједничке подниске који су до тада нађени. На путу у наредном кораку се прелази дијагонално лево на горњи ред, тј. у ред i-1 и колону j-1. Ако је x_i≠y_j, вредност L(i,j) мора бити једнака једној од дужина L(i-1,j) или L(i,j-1) (или обема). У првом случају, потребно је прећи на позицију (i-1,j), а у другом случају на позицију (i,j-1). У случају једнаких вредности, на произвољан начин се бира једна од две позиције.

Пример

На слици је приказан резултат верзије алгоритма која користи динамичко програмирање за ниске "бтматмац" и "мтамтаб". Вредности у матрици које су означене жутом бојом представљају пут којим се одређује најдужа заједничка подниска, па је једно од могућих решења за овај пример подниска "мата".

			б	т	м	а	т	м	а	ц
	j\i	0	1	2	3	4	5	6	7	8
	0	0	0	0	0	0	0	0	0	0
м	1	0	0	0	1	1	1	1	1	1
т	2	0	0	1	1	1	2	2	2	2
а	3	0	0	1	1	2	2	3	3	3
м	4	0	0	1	2	2	2	3	3	3
т	5	0	0	1	2	2	3	3	3	3
а	6	0	0	1	2	3	3	3	4	4
б	7	0	1	1	2	3	3	3	4	4

Имплементација алгоритма у програмском језику Јава

Рекурзивни алгоритам

public static String najduzaZajednickaPodniska(String a, String b){
	 int duzinaA = a.length();
	 int duzinaB = b.length();
	 if(duzinaA == 0 || duzinaB == 0){
	 return "";
	 }else if(a.charAt(duzinaA-1) == b.charAt(duzinaB-1)){
	 return najduzaZajednickaPodniska(a.substring(0,duzinaA-1),b.substring(0,duzinaB-1))
	 + a.charAt(duzinaA-1);
	 }else{
	 String x = najduzaZajednickaPodniska(a, b.substring(0,duzinaB-1));
	 String y = najduzaZajednickaPodniska(a.substring(0,duzinaA-1), b);
	 return (x.length() > y.length()) ? x : y;
	 }
}

Алгоритам заснован на динамичком програмирању

public static String najduzaZajednickaPodniska(String a, String b) {
	 int[][] duzine = new int[a.length()+1][b.length()+1];
	 
	 // red 0 and kolona 0 su vec inicijalizovane na 0
	 
	 for (int i = 0; i < a.length(); i++)
	 for (int j = 0; j < b.length(); j++)
	 if (a.charAt(i) == b.charAt(j))
	 	duzine[i+1][j+1] = duzine[i][j] + 1;
	 else
	 	duzine[i+1][j+1] =
	 Math.max(duzine[i+1][j], duzine[i][j+1]);
	 
	 // citamo simbole koji cine najduzu zajednicku podnisku
	 StringBuffer sb = new StringBuffer();
	 for (int x = a.length(), y = b.length();
	 x != 0 && y != 0; ) {
	 if (duzine[x][y] == duzine[x-1][y])
	 x--;
	 else if (duzine[x][y] == duzine[x][y-1])
	 y--;
	 else {
	 assert a.charAt(x-1) == b.charAt(y-1);
	 sb.append(a.charAt(x-1));
	 x--;
	 y--;
	 }
	 }
	 
	 return sb.reverse().toString();
}

Имплементација алгоритма у програмском језику C

Имплементација је у програмском језику C уз претпоставку о максималној дужини низова и уз претпоставку да се ради о низовима који садрже целобројне вредности.

#include <stdio.h>
#include <stdlib.h>
#define UP 1
#define LEFT 2
#define UPLEFT 3
#define MAX_LENGTH 10000

int c[MAX_LENGTH][MAX_LENGTH];
int b[MAX_LENGTH][MAX_LENGTH];
int n;
int m;

void LCS_length(int* x, int *y, int m, int n){
     int i,j;
     
     for (i=0; i<=m; i++){
         for (j=0; j<=n; j++){
             c[i][j] = b[i][j] = 0;    
         }
     }     
     
     for (i=1; i<=m; i++){
         c[i][0] = 0;
         b[i][0] = UP;
     }
         
     for (j=0; j<=n; j++){
         c[0][j] = 0;
         b[0][j] = LEFT;    
     }
         
     for (i=1; i<=m; i++){
         for (j=1; j<=n; j++){
         
             if (x[i-1] == y[j-1]){
                c[i][j] = c[i-1][j-1] + 1;
                b[i][j] = UPLEFT;         
             }
             else if (c[i-1][j] >= c[i][j-1]){
                  c[i][j] = c[i-1][j];
                  b[i][j] = UP;     
             }
             else {
                  c[i][j] = c[i][j-1];
                  b[i][j] = LEFT;     
             }
         }
     }
}

void LCS_print(int b[][MAX_LENGTH], int* x, int i, int j){
     
     if (i==0 || j == 0)
        return;
     
     if (b[i][j] == UPLEFT){
        LCS_print(b, x, i-1, j-1);
        printf("%d ", x[i]);            
     }
     else if (b[i][j] == UP)
          LCS_print(b, x, i-1, j);
     else
         LCS_print(b, x, i, j-1);
}

int main(int argc, char** argv){
    
    int *x;
    int *y;
    int i;
    
    scanf("%d", &m);
    
    if (m > MAX_LENGTH - 1)
    	m = MAX_LENGTH-1;
    
    if ((x = (int*)malloc(m*sizeof(int))) == NULL)
       exit(EXIT_FAILURE);
       
    for (i=0; i<m; i++)
        scanf("%d", &x[i]);
    
    scanf("%d", &n);
    
    if (n > MAX_LENGTH - 1)
    	n = MAX_LENGTH-1;
    
    if ((y = (int*)malloc(n*sizeof(int))) == NULL)
       exit(EXIT_FAILURE);
       
    for (i=0; i<n; i++)
        scanf("%d", &y[i]);
        
    LCS_length(x,y,m,n);
    LCS_print(b, x, m, n);
    
    free(x);
    free(y);
    
    exit(EXIT_SUCCESS);    
}

Сложеност алгоритама

Рекурзивни алгоритам којим се одређује најдужа заједничка подниска две ниске има експоненцијалну сложеност. Ако две ниске, за које је потребно одредити најдужу заједничку подниску, имају дужине m, односно n и нека је k = m + n, време извршавања таквог алгоритма је θ(2^k).

Сложеност алгоритма заснованом на динамичком програмирању за одређивање најдуже заједничке подниске две ниске износи Ο(mn).

Литература

• Дејан Живковић, (2007). Основе дизајна и анализе алгоритама. ЦЕТ. ISBN 978-86-7991-327-2.  Поглавље 7.

Спољашње везе

• Имплементација алгоритма за одређивање најдуже заједничке подниске у многим програмским језицима
• Dictionary of Algorithms and Data Structures: longest common subsequence
• Implementation of Longest Common Subsequence Algorithm in C Programming Language