在一组字符串中查找子字符串

Question

我有一大组 (50k-100k) 字符串 mystrings。 mystrings 中的某些字符串可能是其他字符串的确切子字符串，我想折叠这些字符串（丢弃子字符串并只保留最长的字符串）。现在我正在使用一种简单的方法，它具有O(N^2) 的复杂性。

unique_strings = set()
for s in sorted(mystrings, key=len, reverse=True):
    keep = True
    for us in unique_strings:
        if s in us:
            keep = False
            break
    if keep:
        unique_strings.add(s)

哪些数据结构或算法可以使这项任务更容易，并且不需要O(N^2) 操作。库还可以，但我需要保持纯 Python。

Answer 1

在 set() 中查找子字符串：

name = set()
name.add('Victoria Stuart')                         ## add single element
name.update(('Carmine Wilson', 'Jazz', 'Georgio'))  ## add multiple elements
name
{'Jazz', 'Georgio', 'Carmine Wilson', 'Victoria Stuart'}

me = 'Victoria'
if str(name).find(me):
    print('{} in {}'.format(me, name))
# Victoria in {'Jazz', 'Georgio', 'Carmine Wilson', 'Victoria Stuart'}

这很容易——但如果你想返回匹配的字符串，那就有点问题了：

for item in name:
    if item.find(me):
            print(item)
'''
Jazz
Georgio
Carmine Wilson
'''

print(str(name).find(me))
# 39    ## character offset for match (i.e., not a string)

如你所见，上面的循环只执行直到条件为True，在打印我们想要的项目（匹配字符串）之前终止。

使用regex（正则表达式）可能更好，更容易：

import re

for item in name:
    if re.match(me, item):
            full_name = item
            print(item)
# Victoria Stuart
print(full_name)
# Victoria Stuart

for item in name:
    if re.search(me, item):
            print(item)
# Victoria Stuart

来自Python docs：

search() 与 match()

Python 提供了两种不同的基于常规的原始操作 表达式：re.match() 仅在开头检查匹配 字符串，而 re.search() 检查 字符串...

Answer 2

一种天真的方法：

1. sort strings by length, longest first  # `O(N*log_N)`
2. foreach string:  # O(N)
    3. insert each suffix into tree structure: first letter -> root, and so on.  
       # O(L) or O(L^2) depending on string slice implementation, L: string length
    4. if inserting the entire string (the longest suffix) creates a new 
       leaf node, keep it!

O[N*(log_N + L)]  or  O[N*(log_N + L^2)]

这可能远非最佳，但对于较大的N（字符串数量）和较小的L（平均字符串长度）应该明显优于O(N^2)。

您还可以按长度降序遍历字符串，并将每个字符串的所有子字符串添加到一个集合中，并且只保留那些不在集合中的字符串。算法大 O 应该与上述最坏情况 (O[N*(log_N + L^2)]) 相同，但实现要简单得多：

seen_strings, keep_strings = set(), set()
for s in sorted(mystrings, key=len, reverse=True):
    if s not in seen_strings:
        keep_strings.add(s)
        l = len(s)
        for start in range(0, l-1):
            for end in range(start+1, l):
                seen_strings.add(s[start:end])

Answer 3

与此同时，我想出了这种方法。

from Bio.trie import trie
unique_strings = set()
suffix_tree = trie()
for s in sorted(mystrings, key=len, reverse=True):
    if suffix_tree.with_prefix(contig) == []:
        unique_strings.add(s)
        for i in range(len(s)):
            suffix_tree[s[i:]] = 1

优点：对于我正在使用的数据集而言，≈15 分钟 --> ≈20 秒。 坏处：引入biopython 作为依赖项，它既不是轻量级也不是纯python（正如我最初问的那样）。

Answer 4

您可以对字符串进行预排序并创建一个字典，将字符串映射到排序列表中的位置。然后您可以遍历字符串列表 (O(N)) 和后缀 (O(L)) 并将这些条目设置为位置字典中存在的None (O(1) 字典查找和 O(1)列表更新）。所以总的来说，这具有 O(N*L) 复杂度，其中 L 是平均字符串长度。

strings = sorted(mystrings, key=len, reverse=True)
index_map = {s: i for i, s in enumerate(strings)}
unique = set()
for i, s in enumerate(strings):
    if s is None:
        continue
    unique.add(s)
    for k in range(1, len(s)):
        try:
            index = index_map[s[k:]]
        except KeyError:
            pass
        else:
            if strings[index] is None:
                break
            strings[index] = None

对以下示例数据进行测试得出的加速因子约为 21：

import random
from string import ascii_lowercase

mystrings = [''.join(random.choices(ascii_lowercase, k=random.randint(1, 10)))
             for __ in range(1000)]
mystrings = set(mystrings)