查找“n”个二进制字符串中最长的公共子串的长度

Question

我得到了n 字符串（n>=2 和 na 和 b。在这组字符串中，我必须找到所有字符串中存在的最长公共子字符串的长度。保证存在解决方案。我们来看一个例子：

n=4
abbabaaaaabb
aaaababab
bbbbaaaab
aaaaaaabaaab

The result is 5 (because the longest common substring is "aaaab").

我不必打印（甚至知道）子字符串，我只需要打印它的长度。

同时给出结果不能大于60，即使每个字符串的长度可以高达13 000。

我尝试的是：我找到给定字符串中任何字符串的最小长度，然后将其与60 进行比较，然后选择两者之间的最小值为starting point。然后我开始取第一个字符串的序列，第一个字符串的每个序列的长度为len，其中len 取值从starting point 到1。在每次迭代中，我采用长度为len 的第一个字符串的所有可能序列，并将其用作pattern。使用 KMP 算法（因此，复杂度为 O(n+m)），我遍历所有其他字符串（从 2 到 n）并检查是否在字符串 i 中找到 pattern。每当找不到时，我会中断迭代并尝试下一个长度为len 的可用序列，或者，如果没有，我减少len 并尝试所有长度为新的、减少的值@ 的序列987654344@。但是如果它匹配，我停止程序并打印长度len，因为我们从可能的最长长度开始，每一步递减，所以我们找到的第一个匹配代表最大可能的长度是合乎逻辑的。这是代码（但这并不重要，因为这种方法不够好；我知道我不应该使用using namespace std，但它并没有真正影响这个程序，所以我只是没有打扰）：

#include <iostream>
#include <string>
#define nmax 50001
#define result_max 60

using namespace std;

int n,m,lps[nmax],starting_point,len;
string a[nmax],pattern,str;

void create_lps() {
    lps[0]=0;
    unsigned int len=0,i=1;
    while (i < pattern.length()) {
        if (pattern[i] == pattern[len]) {
            len++;
            lps[i] = len;
            i++;
        }
        else {
            if (len != 0) {
                len = lps[len-1];
            }
            else {
                lps[i] = 0;
                i++;
            }
        }
    }
}

bool kmp_MatchOrNot(int index) {
    unsigned int i=0,j=0;
    while (i < a[index].length()) {
        if (pattern[j] == a[index][i]) {
            j++;
            i++;
        }
        if (j == pattern.length()) {
            return true;
        }
        else if (i<a[index].length() && pattern[j]!=a[index][i]){
            if (j != 0) {
                j = lps[j-1];
            }
            else {
                i++;
            }
        }
    }
    return false;
}

int main()
{
    int i,left,n;
    unsigned int minim = nmax;
    bool solution;
    cin>>n;
    for (i=1;i<=n;i++) {
        cin>>a[i];
        if (a[i].length() < minim) {
            minim = a[i].length();
        }
    }

    if (minim < result_max) starting_point = minim;
    else starting_point = result_max;

    for (len=starting_point; len>=1; len--) {
        for (left=0; (unsigned)left<=a[1].length()-len; left++) {
            pattern = a[1].substr(left,len);
            solution = true;
            for (i=2;i<=n;i++) {
                if (pattern.length() > a[i].length()) {
                    solution = false;
                    break;
                }
                else {
                    create_lps();
                    if (kmp_MatchOrNot(i) == false) {
                        solution = false;
                        break;
                    }
                }
            }
            if (solution == true) {
                cout<<len;
                return 0;
            }
        }
    }
    return 0;
}

事情是这样的：程序运行正常并且给出了正确的结果，但是当我在网站上发送代码时，它给出了“超出时间限制”的错误，所以我只得到了一半的分数。

这让我相信，为了以更好的时间复杂度解决问题，我必须利用字符串的字母只能是a或b这一事实，因为它看起来就像我没有使用的一个非常大的东西，但我不知道我该如何使用这些信息。我将不胜感激。

Answer 1

答案是单独构建所有字符串的后缀树，然后将它们相交。后缀树就像一个trie，同时包含一个字符串的所有后缀。

为固定字母构建后缀树是O(n) 和Ukkonen's algorithm。 （如果你不喜欢这个解释，你可以用 google 找其他的。）如果你有 m 大小为 n 的树，那么现在是 O(nm)。

相交后缀树是并行遍历它们的问题，只有当你可以在所有树中走得更远时才会走得更远。如果你有m 大小为n 的树，则此操作可以在不超过O(nm) 的时间内完成。

这个算法的总时间是时间O(nm)。鉴于仅仅读取字符串是时间O(nm)，你不能做得比这更好。

---

添加少量细节，假设您的后缀树被写为每个节点一个字符。所以每个节点只是一个字典，其键是字符，其值是树的其余部分。因此，以我们为例，对于字符串ABABA，https://imgur.com/a/tnVlSI1 处的图表将变成类似于（见下文）这样的数据结构：

{
    'A': {
        'B': {
            '': None,
            'A': {
                'B': {
                    '': None
                }
            }
        }
    },
    'B': {
        '': None
        'A': {
            'B': {
                '': None
            }
        }
    }
}

同样BABA 会变成：

{
    'A': {
        '': None
        'B': {
            'A': {
                '': None
            }
        }
    },
    'B': {
        'A': {
            '': None,
            'B': {
                'A': {
                    '': None
                }
            }
        }
    }
}

对于看起来像这样的数据结构，天真的 Python 比较它们看起来像：

def tree_intersection_depth (trees):
    best_depth = 0
    for (char, deeper) in trees[0].items():
        if deeper is None:
            continue
        failed = False

        deepers = [deeper]
        for tree in trees[1:]:
            if char in tree:
                deepers.append(tree[char])
            else:
                failed = True
                break

        if failed:
            continue

        depth = 1 + tree_intersection_depth(deepers)
        if best_depth < depth:
            best_depth = depth

    return best_depth

你可以这样称呼它tree_intersection_depth([tree1, tree2, tree3, ...])。

对于上述两棵树，它确实给出了3 作为答案。

现在我实际上是在写出那个数据结构时作弊。使后缀树高效的原因在于您实际上并没有看起来像那样的数据结构。你有一个重用所有重复结构的。所以模拟设置数据结构并调用它的代码如下所示：

b_ = {'B': {'': None}}
ab_ = {'': None, 'A': b_}
bab_ = {'B': ab_}
abab = {'A': bab_, 'B': ab_}

a_ = {'A': {'': None}}
ba_ = {'': None, 'B': a_}
aba_ = {'A': ba_}
baba = {'B': aba_, 'A': ba_}

print(tree_intersection_depth([abab, baba]))

现在我们可以看到，要获得承诺的性能，还缺少一个步骤。问题是虽然树的大小是O(n)，但在搜索它时，我们可能会访问O(n^2) 子字符串。在您的情况下，您不必担心，因为保证子字符串的深度永远不会超过 60。但在完全一般的情况下，您需要添加记忆，以便当递归导致比较数据结构时，您以前见过，您立即返回旧答案，而不是新答案。 （在 Python 中，您将使用 id() 方法将对象的地址与您之前看到的地址进行比较。在 C++ 中，有一组用于相同目的的指针元组。）