String 最长子串对序列是最长公共子序列还是什么？

我有一对字符串，例如：

abcabc

和

abcxxabc

以及公共子字符串对列表（LCSP），在本例中，LCSP是6对，因为第一个字符串中的三个

abc

映射到第二个字符串中的两个

abc

。现在我需要找到最长的有效（递增）对序列，在这种情况下，有三个同样长的解：

0:0,3:6；0:0,6:6; 3:0,6:6

（这些数字是原始字符串中每对的起始位置，子字符串的长度为3，即“abc”的长度）。我称之为最长子串对序列或LSPQ。（Q不是为了混淆字符串和序列）

以下是本例的LCSP：

LCSP('abcabcabc', 'abcxxxabc') = 
[ [ 6, 6, 3 ],
  [ 6, 0, 3 ],
  [ 3, 6, 3 ],
  [ 0, 6, 3 ],
  [ 3, 0, 3 ],
  [ 0, 0, 3 ] ]


LSPQ(LCSP('abcabcabc', 'abcxxxabc'), 0, 0, 0) = 
   [ { a: 0, b: 0, size: 3 }, { a: 3, b: 6, size: 3 } ]

现在我发现它使用蛮力递归地尝试所有组合。所以我限制在25对左右，否则这是不现实的<代码>大小=[10,15,20,25,26,30]，时间ms=[0,153001000200019000]

有没有一种方法可以在线性时间或至少不是二次复杂度的情况下实现这一点，以便可以使用更长的输入LCSP（公共子串对列表）

这个问题与“最长公共子序列”类似，但并不完全相同，因为输入不是两个字符串，而是按长度排序的公共子字符串列表。因此，我不知道在哪里寻找现有的解决方案，甚至不知道它们是否存在

以下是我的特定代码（JavaScript）：

函数getChainSize（T）{
var R=0
对于（var i=0；i=x和&T[x][1]>=Y）返回x
x++
}
返回-1
}
var id=findnextmable（）
如果（id<0）返回[]
var C=[{a:T[id][0]，b:T[id][1]，size:T[id][2]}]
//有电流
var o=T[id]
变量A=C.concat（LSPQ（T，o[0]+o[2]，o[1]+o[2]，id+1））
//无电流
var B=LSPQ（T，X，Y，id+1）
if（getChainSize（A）

function getChainSize(T) {
    var R = 0
    for (var i = 0; i < T.length; i++) R += T[i].size
    return R
}
function LSPQ(T, X, Y, id) {
  // X,Y are first unused character is str1,str2
  //id is current pair
    function findNextPossible() {
        var x = id
        while (x < T.length) {
            if (T[x][0] >= X && T[x][1] >= Y) return x
            x++
        }
        return -1
    }
    var id = findNextPossible()
    if (id < 0) return []
    var C = [{a:T[id][0], b:T[id][1], size:T[id][2] }]
    // with current
    var o = T[id]
    var A = C.concat(LSPQ(T, o[0]+o[2], o[1]+o[2], id+1))
    // without current
    var B = LSPQ(T, X, Y, id+1)
    if (getChainSize(A) < getChainSize(B)) return B
    return A
}