查找输入字符串和一组固定字符串之间的匹配项

Question

我需要将一个输入字符串与多个我称为固定字符串的字符串进行比较，您可以假设后者在执行期间不会改变。比较忽略带有特殊字符的字母，只考虑从 A 到 Z 的字母，但不区分大小写。我需要尝试将我的输入字符串与每个固定字符串的开头匹配，即使不是所有字符都匹配，与approximate string matching 不同。 换句话说，想要识别输入字符串中的每个单词和固定字符串中的每个单词之间的重叠。我对完整的比赛特别感兴趣，例如(love) 和 (love) 在下面的第二个示例中。

我实际上并不想显示匹配项，而是根据它们进行一些计算：每当有完全匹配时，我想增加一个具有特定值的计数器，并且只要有部分匹配，我想增加另一个值。计数是我真正想要的，但我需要先匹配字符串。

下面是如何匹配的说明：

如果我的固定字符串是“apple”、“bullcrap”、“tomato”、“apricot”，我应该能够搜索“Applecrab”并获得以下匹配项：

(Apple)crab App(l)ecrab Applecrab   (Ap)plecrab 
    
(apple)     bul(l)crap  tomato      (ap)ricot

我也应该能够输入多个单词，例如：

固定字符串：“i love books”、“book fair”；输入字符串：“I love”；匹配：

(I) I    I      |  love  (love)  l(o)ve
(i) love books  |  I     (love)  b(o)oks
   
I     I     |  l(o)ve love
book  fair  |  b(o)ok fair

---

比较两个字符串的简单、简单的算法如下所示：

inputString = "love".lower()
fixedString = "love".lower()
lenComp = min(len(inputString), len(fixedString))
counter = 0
for i in range(lenComp):
    if inputString[i] == fixedString[i]:  # Partial match
        counter += 1  
if counter == len(inputString):  # Full match
    counter += 10
print(counter)  # 14

由于固定字符串的数量不是非常少，因此解决方案应该采用合适的数据结构。我在考虑树：prefix tree 似乎很合适，但它对字符串中间的松散匹配没有帮助，例如l(o)ve 和 b(o)oks，Aho–Corasick algorithm 也不会。我认为Hamming distance 也无济于事。我可以使用哪些数据结构/算法来实现这一目标？

---

我用 Python 标记它，因为我可能会使用它，但我现在不太关心实现。

Answer 1

只是一个需要探索的想法，也许修改后的前缀树可以完成这项工作，您需要添加每个字符串及其所有子字符串，并跟踪每个字符在树中其他位置的位置。

例如：ABD、BAD、RCDB可以添加到前缀树如下

假设您想查找 CAB 的匹配项，您需要一个带有字符串和起始位置的搜索函数

search(CAB,0)  -- this will try to find a first node C with position 0 but won't find one

然后您将删除 C 并搜索位置为 1 的 AB

search(AB,1)

这将找到 A 节点，该节点表示 A 存在于 BAD 节点的位置 1 中，您将遵循该链接。等等……

编辑：

您可以通过从根节点开始并将字母表中的所有字母添加到该节点来创建树。每个字母都有一个位置字典

node = { ...
   pos : { }
}

最初，所有字母的位置字典都是空的，即它们不被用作任何单词的起始字符或中间字符

要添加单词 ABD，逻辑将类似于

Letter 0 - A
    update pos dict for A to be {0 : []}
    the contents of the array for pos 0 are not used (i think)
Letter 1 - B
    add node B under A
    update pos for node B under root to {1 : ['A']}
Letter 2 - D
    add node D under B
    update pos for node D under root to {2 : ['AB']}
    note: it is set to AB so it helps you walk down the 
          tree quicker when doing a search

接下来我们添加 BAD

Letter 0 - B
    update pos for node B to be {0:[], 1:['A']}
Letter 1 - A
    add node A under B
    update pos for Node A under root to be {0:[],1:['B']}
letter 2 - D
    add node D under B of the chain BA
    update pos for node D under root to be {2 : ['AB','BA']}

搜索 CAD 一词

• 检查顶级根目录下的节点C，它有空的pos dict {} 所以没有单词以 C 开头，所以我们可以跳过 C
• 对于 pos = 1，移动到根下的下一个字符检查节点 A，它有 pos = {0:[],1:['B']} 所以取键 1 的数组，这告诉你你会在根 B 节点下找到一个 A，从这里遍历树以找到最长的匹配，这将为您提供 A(BD)
• 移动到下一个字符 D，检查根节点 D 的位置 2，它有 {2 : ['AB','BA']}，所以你遍历树找到匹配的 AB(D) 和 BA( D)

编辑 2：

这是一个非常简单（而且效率低下）的 python 实现：

import string, pprint

pp = pprint.PrettyPrinter(indent=4)

root = {x:{} for x in string.ascii_lowercase}

def add_word(word):
    def _add_word(node, hist, word, pos):
        if word[0] not in node:
            node[word[0]] = {}
        root[word[0]].setdefault("pos",{}).setdefault(pos,set()).add(hist+word[0])
        if len(word) == 1:
            node[word[0]]['is_word'] = True
        else:
            _add_word(node[word[0]], hist+word[0], word[1:], pos+1)

    _add_word(root, "", word.lower(), 0)


def search(word):
    found_words = set()
    def find(node,prefix,word,pos,result):
        # print("prefix:",prefix,", word:",word,", pos:", pos,", result:",result)
        if prefix:
            find(node[prefix[0]], prefix[1:], word, pos, result+prefix[0])
        else:
            if node.get('is_word',False): found_words.add(result)
            for x in string.ascii_lowercase:
                if x in node: find(node[x], "", "", pos, result+x)

    for i in range(len(word)):
        if i in root[word[i]].get("pos",{}):
            for prefix in root[word[i]]["pos"][i]:
                # print("calling find with: ", prefix, word, i)
                find(root,prefix,word[i:],i,"")

    print(f"result for {word}:", found_words)


add_word('apple')
add_word('bullcrap')
add_word('tomato')
add_word('apricot')
# pp.pprint(root)
search('applecrab')
search('dove')

上面运行的输出是：

result for applecrab: {'apple', 'bullcrap', 'apricot'}
result for dove: {'tomato'}