Наибольшая общая подстрока

Наибольшая общая подстрока (longest common substring) — подстрока двух или более строк, имеющая максимальную длину.

Формально, наибольшей общей подстрокой строк $s_{1},s_{2},\ldots s_{n}$ называется строка $\left.w^{*}\right.$, которая удовлетворяет условию $\|w^{*}\|=\max(\{\|w\||w\sqsubseteq s_{i},i=1,\ldots n\})$, операция $w\sqsubseteq s_{i}$ обозначает что строка $\left.w\right.$ является (возможно несобственной) подстрокой строки $\left.s_{i}\right.$.

Алгоритмы поиска наибольшей общей подстроки

Наивный алгоритм

Решение задачи поиска наибольшей общей подстроки для двух строк $\left.s_{1}\right.$ и $\left.s_{2}\right.$, длины которых $\left.m\right.$ и $\left.n\right.$ соответственно, заключается в заполнении таблицы $\left.A_{ij}\right.$ размером $(m+1)\times (n+1)$ по следующему правилу, принимая, что символы в строке нумеруются от единицы.

$\left\{{\begin{array}{rclr}A_{0j}&=&0,&j=0\ldots n,\\A_{i0}&=&0,&i=0\ldots m,\\A_{ij}&=&0,&s_{1}[i]\neq s_{2}[j],i\neq 0,j\neq 0,\\A_{ij}&=&A_{i-1j-1}+1,&s_{1}[i]=s_{2}[j],i\neq 0,j\neq 0.\end{array}}\right.$

Максимальное число $\left.A_{uv}\right.$ в таблице это и есть длина наибольшей общей подстроки, сама подстрока:

$s_{1}[u-A_{uv}+1]\ldots s_{1}[u]$ и $s_{2}[v-A_{uv}+1]\ldots s_{2}[vu]$.

В таблице заполнены значения для строк SUBSEQUENCE и SUBEUENCS:

   SUBSEQUENCE
  000000000000
S 010010000000
U 002000010000
B 000300000000
E 000001001001
U 001000010000
E 000001002001
N 000000000300
C 000000000040
S 010010000000

Получаем наибольшую общую подстроку UENC

Очевидно, трудоемкость такого алгоритма составляет O(mn).

Реализация на C++

string
LCS(const string& s1, const string& s2)
{
    string ret;
    int maxlen = 0, mi, mj;
    int **dt;
    
    dt = new int*[s1.length() + 1];
    dt[0] = new int[s2.length() + 1];
    memset(dt[0], 0, (s2.length() + 1)*sizeof(int));
    for (int i = 1; i <= (int) s1.length(); ++i)
    {
        dt[i] = new int[s2.length() + 1];
        memset(dt[i], 0, (s2.length() + 1)*sizeof(int));
        for (int j = 1; j <= (int) s2.length(); ++j)
        {
            if (s1[i-1] == s2[j-1])
            {
                dt[i][j] = dt[i-1][j-1] + 1;
                if (maxlen < dt[i][j])
                {
                    maxlen = dt[i][j];
                    mi = i;
                    mj = j;
                }
            }
        }
        delete dt[i-1];
    }
    delete dt[s1.length()];
    delete dt;
    for (; maxlen > 0; --maxlen)
        ret = s1[--mi] + ret;
    return ret;
}

Реализация на C#

 public static int LongestCommonSubstring( string str1, string str2 )
    {
      if( String.IsNullOrEmpty( str1 ) || String.IsNullOrEmpty( str2 ) )
        return 0;

      List<int[]> num = new List<int[]>();
      int maxlen = 0;
      for( int i = 0; i < str1.Length; i++ )
      {
        num.Add( new int[ str2.Length ] );
        for( int j = 0; j < str2.Length; j++ )
        {
          if( str1[ i ] != str2[ j ] )
            num[ i ][ j ] = 0;
          else
          {
            if( ( i == 0 ) || ( j == 0 ) )
              num[ i ][ j ] = 1;
            else
              num[ i ][ j ] = 1 + num[ i - 1 ][ j - 1 ];
            if( num[ i ][ j ] > maxlen )
              maxlen = num[ i ][ j ];
          }
          if( i >= 2 )
            num[ i - 2 ] = null;
        }
      }
      return maxlen;
    }

Реализация на Haskell

import Data.List
import Data.Function

lcstr xs ys = maximumBy (compare `on` length) . concat $ [f xs' ys | xs' <- tails xs] ++ [f xs ys' | ys' <- drop 1 $ tails ys]
  where f xs ys = scanl g [] $ zip xs ys
        g z (x, y) = if x == y then z ++ [x] else []

См. также

• Суффиксное дерево
• Алгоритмы на строках
• Наибольшая общая подпоследовательность