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') = arraay 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

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

[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 2

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

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 3

这里有一个 ~~O（n）~~ O（n + k）解决方案，用于两个字符串A和B，其长度总和为n，并且具有k这样的最大匹配子串：

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

对于小数字＆gt; = 3个字符串，这也可以轻松工作：计算并存储在当前节点下面有叶子的输入字符串的 set ，并且＆＃34; fire＆＃34;当这个集合变满时。

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

3 个答案: