在两个（或更多）数组中查找匹配的单元格序列的最有效方法是什么？

Question

示例 1

假设我有两个数组：

('n','v','a','n','i','n','n','v','a','n')
('a','n','n','n','v','a','n','v','n')

并且我想找到两者之间的所有匹配序列（可能超过两个单元格长左右），它们不是其他较长匹配的子匹配。以下是我认为匹配的内容：

('n','n','v','a','n') = 数组 1 中的位置 5 和数组 2 中的位置 3

数组1：('n','v','a','n','i','n','n','v','a','n')

数组2：('a','n','n','n','v','a','n','v','n')

示例 2

('n','v','a','n','i','n','n','v','i','n')
('a','n','i','n','p','v','i','n','v','n')

在这里，我们有不止一个序列，但它们更短，如下所示：

('a','n','i','n') = 数组 1 中的位置 2 和数组 2 中的位置 0

('v','i','n') = 数组 1 中的位置 7 和数组 2 中的位置 5

数组1：('n','v','a','n','i','n','a','v',' i','n')

数组2：('a','n','i','n','p','v','i','n'强>,'v','n')

总结

两个示例中有多个匹配项，但它们都存在于至少一个数组中的较大匹配项中。

那么，可以实现这一目标的最有效（低内存和高速的平衡，想想移动设备）代码是什么？ JavaScript 代码示例会很棒！

Answer 1

这是我在通用 LCS 上的 JavaScript 尝试，O(mn) 时空版本。由于我们逐行进行，因此可以通过仅重用两行来减少空间，完成后将第二行复制到第一行。

var example1 = [['n','v','a','n','i','n','n','v','a','n']
               ,['a','n','n','n','v','a','n','v','n']],

    example2 = [['n','v','a','n','i','n','n','v','i','n']
               ,['a','n','i','n','v','i','n','v','n']];

function f(as){
  var M = new Array(as[0].length),
      result = [];

  for (var i=0; i<as[0].length; i++){
    M[i] = new Array(as[1].length).fill(0);

    for (var j=0; j<as[1].length; j++){
      if (as[0][i] == as[1][j]){
        M[i][j] = M[i-1] && M[j-1] ? 1 + M[i-1][j-1] : 1;
      }
      if ((i == as[0].length - 1 || j == as[1].length - 1) && M[i][j] > 2){
        result.push([i - M[i][j] + 1,j - M[i][j] + 1,M[i][j]]);
      } else if (i > 1 && j > 1 && M[i][j] < M[i-1][j-1] && M[i-1][j-1] > 2){
        result.push([i - M[i-1][j-1],j - M[i-1][j-1],M[i-1][j-1]]);
      }
    }
  }

  return result;
}

console.log(JSON.stringify(f(example2))); // [[2,0,4],[6,3,4]]

Answer 2

如果这两个数组的长度分别为m 和n，我认为在一般情况下你不可能比O(mn) 做得更好。假设您的数组具有交替的 as 但其他不同的字符，像这样

[a, b, a, c, a, d, a, e, a, f, a, g]
[a, h, a, i, a, j, a, k, a, l, a, m]

匹配数为(m/2)*(n/2)。如果你想把它们都找出来，你的算法最好是O(mn)。

您可以在O(mn) 时间进行如下操作。想象一下像这样将一个数组滑过另一个数组：

[a, b, c, d, e]
            [f, g, h, i, j]

   [a, b, c, d, e]
            [f, g, h, i, j]

      [a, b, c, d, e]
            [f, g, h, i, j]

                  ...
                        [a, b, c, d, e]
            [f, g, h, i, j] 

有m + n - 1 可能的职位。对于每个位置，您必须遍历对齐的字符对（这些对中最坏的情况是 min(m, n)）并找到最长的匹配字符链。这有时间复杂度

O((m + n) * min(m, n)) = O(mn)

这种解决方案的缺点是所花费的时间实际上只取决于数组的长度，而不是内容。例如，即使数组相等，它仍然需要O(nm) 时间（显然只需要O(n) 时间来检查并返回一个答案）。如另一个答案所示，如果匹配序列的数量很少，则有更聪明的解决方案将花费更少的时间。

Answer 3

对于两个字符串 A 和 B 的 O(n)O(n+k) 解决方案，其长度总和为 n，并且有 k 个这样的最大匹配子字符串：

1. 在您的两个字符串A 和B 上构建generalised suffix tree。 （这只是单个字符串A$B# 上的普通后缀树，其中$ 和# 是不会出现在A 或B 中的任何位置的单个字符。）这可以在O 中完成(n) 时间使用例如Ukkonen 算法。
2. 通过此树执行自下而上的 DFS，在每个节点上执行两件事：
   • 判断并记录该节点下是否有后缀A对应的叶子，以及该节点下是否有后缀B对应的叶子。 （练习：如何为一片叶子回答这个问题？）
   • 如果两种叶子都存在，并且任何子节点都不是这样，然后报告对应于该节点的子字符串作为解决方案。 （如果条件对某个子节点也成立，则该节点对应的子串是该子节点对应的子串的子串，您只需要最大子串。）

这也适用于>= 3 个字符串的小数字：计算并存储在当前节点下方有叶子的输入字符串的集合，并在该集合变满时“触发”。