我试图找到3个或更多字符串的最长公共子序列。维基百科的文章对how to do this for 2 strings有很好的描述，但我不太清楚如何将其扩展为3个或更多字符串。
有很多库可以找到2个字符串的LCS，所以我想尽可能使用其中一个。如果我有3个字符串A，B和C，找到A和B的LCS作为X是否有效，然后找到X和C的LCS，或者这是错误的方法吗？
我在Python中实现了它，如下所示：
import difflib
def lcs(str1, str2):
sm = difflib.SequenceMatcher()
sm.set_seqs(str1, str2)
matching_blocks = [str1[m.a:m.a+m.size] for m in sm.get_matching_blocks()]
return "".join(matching_blocks)
print reduce(lcs, ['abacbdab', 'bdcaba', 'cbacaa'])
输出“ba”，但它应该是“baa”。
答案 0 :(得分：23)
只是概括了递归关系。
三个字符串：
dp[i, j, k] = 1 + dp[i - 1, j - 1, k - 1] if A[i] = B[j] = C[k]
max(dp[i - 1, j, k], dp[i, j - 1, k], dp[i, j, k - 1]) otherwise
应该很容易从这里推广到更多的字符串。
答案 1 :(得分：5)
要查找2个字符串A和B的最长公共子序列（LCS），您可以对角地遍历2维数组，如您发布的链接中所示。数组中的每个元素都对应于找到子串A'和B'的LCS的问题（A由其行号切割，B由其列号切割）。可以通过计算数组中所有元素的值来解决此问题。您必须确定在计算数组元素的值时，计算该给定值所需的所有子问题都已解决。这就是你沿对角线遍历二维数组的原因。
这个解决方案可以缩放以找到N个字符串之间最长的公共子序列，但是这需要一种通用的方法来迭代N个维度的数组，这样只有当元素需要解决方案的所有子问题时才能到达任何元素已经解决了。
您可以递归地解决问题，而不是以特殊顺序迭代N维数组。通过递归，保存中间解决方案非常重要，因为许多分支机构需要相同的中间解决方案。我在C＃中写了一个小例子：
string lcs(string[] strings)
{
if (strings.Length == 0)
return "";
if (strings.Length == 1)
return strings[0];
int max = -1;
int cacheSize = 1;
for (int i = 0; i < strings.Length; i++)
{
cacheSize *= strings[i].Length;
if (strings[i].Length > max)
max = strings[i].Length;
}
string[] cache = new string[cacheSize];
int[] indexes = new int[strings.Length];
for (int i = 0; i < indexes.Length; i++)
indexes[i] = strings[i].Length - 1;
return lcsBack(strings, indexes, cache);
}
string lcsBack(string[] strings, int[] indexes, string[] cache)
{
for (int i = 0; i < indexes.Length; i++ )
if (indexes[i] == -1)
return "";
bool match = true;
for (int i = 1; i < indexes.Length; i++)
{
if (strings[0][indexes[0]] != strings[i][indexes[i]])
{
match = false;
break;
}
}
if (match)
{
int[] newIndexes = new int[indexes.Length];
for (int i = 0; i < indexes.Length; i++)
newIndexes[i] = indexes[i] - 1;
string result = lcsBack(strings, newIndexes, cache) + strings[0][indexes[0]];
cache[calcCachePos(indexes, strings)] = result;
return result;
}
else
{
string[] subStrings = new string[strings.Length];
for (int i = 0; i < strings.Length; i++)
{
if (indexes[i] <= 0)
subStrings[i] = "";
else
{
int[] newIndexes = new int[indexes.Length];
for (int j = 0; j < indexes.Length; j++)
newIndexes[j] = indexes[j];
newIndexes[i]--;
int cachePos = calcCachePos(newIndexes, strings);
if (cache[cachePos] == null)
subStrings[i] = lcsBack(strings, newIndexes, cache);
else
subStrings[i] = cache[cachePos];
}
}
string longestString = "";
int longestLength = 0;
for (int i = 0; i < subStrings.Length; i++)
{
if (subStrings[i].Length > longestLength)
{
longestString = subStrings[i];
longestLength = longestString.Length;
}
}
cache[calcCachePos(indexes, strings)] = longestString;
return longestString;
}
}
int calcCachePos(int[] indexes, string[] strings)
{
int factor = 1;
int pos = 0;
for (int i = 0; i < indexes.Length; i++)
{
pos += indexes[i] * factor;
factor *= strings[i].Length;
}
return pos;
}
我的代码示例可以进一步优化。缓存的许多字符串都是重复的，有些是重复的，只添加了一个附加字符。当输入字符串变大时，这会占用比所需更多的空间。
输入：“666222054263314443712”，“5432127413542377777”，“6664664565464057425”
返回的LCS是“54442”
答案 2 :(得分：4)
我只需要做一个功课，所以这里是我在python中的动态编程解决方案非常有效。它是O（nml），其中n，m和l是三个序列的长度。
该解决方案的工作原理是创建一个3D数组，然后枚举所有三个序列，以计算最长子序列的路径。然后，您可以回溯数组以从其路径重建实际子序列。
因此，您将数组初始化为全零，然后枚举三个序列。在枚举的每一步中，您要么在最长子序列的长度上添加一个（如果匹配），或者只是继承枚举的上一步中最长的子序列。
枚举完成后，您现在可以追溯数组以重建您所执行步骤的子序列。也就是说，当你从数组中的最后一个条目向后移动时，每次遇到匹配时，你都会在任何序列中查找它（使用数组中的坐标）并将其添加到子序列中。
def lcs3(a, b, c):
m = len(a)
l = len(b)
n = len(c)
subs = [[[0 for k in range(n+1)] for j in range(l+1)] for i in range(m+1)]
for i, x in enumerate(a):
for j, y in enumerate(b):
for k, z in enumerate(c):
if x == y and y == z:
subs[i+1][j+1][k+1] = subs[i][j][k] + 1
else:
subs[i+1][j+1][k+1] = max(subs[i+1][j+1][k],
subs[i][j+1][k+1],
subs[i+1][j][k+1])
# return subs[-1][-1][-1] #if you only need the length of the lcs
lcs = ""
while m > 0 and l > 0 and n > 0:
step = subs[m][l][n]
if step == subs[m-1][l][n]:
m -= 1
elif step == subs[m][l-1][n]:
l -= 1
elif step == subs[m][l][n-1]:
n -= 1
else:
lcs += str(a[m-1])
m -= 1
l -= 1
n -= 1
return lcs[::-1]
答案 3 :(得分：1)
这里是解决方案的链接view explanation here输出为Length of LCS is 2
# Python program to find
# LCS of three strings
# Returns length of LCS
# for X[0..m-1], Y[0..n-1]
# and Z[0..o-1]
def lcsOf3(X, Y, Z, m, n, o):
L = [[[0 for i in range(o+1)] for j in range(n+1)]
for k in range(m+1)]
''' Following steps build L[m+1][n+1][o+1] in
bottom up fashion. Note that L[i][j][k]
contains length of LCS of X[0..i-1] and
Y[0..j-1] and Z[0.....k-1] '''
for i in range(m+1):
for j in range(n+1):
for k in range(o+1):
if (i == 0 or j == 0 or k == 0):
L[i][j][k] = 0
elif (X[i-1] == Y[j-1] and
X[i-1] == Z[k-1]):
L[i][j][k] = L[i-1][j-1][k-1] + 1
else:
L[i][j][k] = max(max(L[i-1][j][k],
L[i][j-1][k]),
L[i][j][k-1])
# L[m][n][o] contains length of LCS for
# X[0..n-1] and Y[0..m-1] and Z[0..o-1]
return L[m][n][o]
# Driver program to test above function
X = 'AGGT12'
Y = '12TXAYB'
Z = '12XBA'
m = len(X)
n = len(Y)
o = len(Z)
print('Length of LCS is', lcsOf3(X, Y, Z, m, n, o))
# This code is contributed by Soumen Ghosh.
答案 4 :(得分：0)
下面的代码可以找到N个字符串中最长的公共子序列。它使用itertools生成所需的索引组合，然后使用这些索引查找公用子字符串。
执行示例：
输入：
输入序列号：3
输入序列1：83217
输入序列2：8213897
输入序列3：683147
输出：
837
dockerize -wait tcp://127.0.0.1:9200 -timeout 2m