查找最小子集前缀

Question

这是我解决这个问题的代码。我正在为这个解决方案使用 Trie 树，并想知道在更好的时间复杂度或空间复杂度方面是否还有其他更好的想法。也感谢任何错误和代码风格的建议。

问题：

给定一组字符串，返回给定输入词集的最小子集 --- 包含给定输入词集中每个输入词的前缀。前缀应该是给定输入集中的完整输入词，而不是给定词的前缀，对于没有前缀的词， 返回自己。

如果列表是 ['foo', 'foog', 'food', 'asdf'] 返回 ['foo', 'asdf']

返回是foo，因为foo 是foo（本身）的前缀，foog 的前缀和food 的前缀（换句话说，foo 可以“表示”更长的字符串，例如@ 987654327@ 和 food)。输出还包含asdf，因为它不是输入列表中任何其他单词的前缀，所以输出本身。

空集不是正确答案，因为它不包含可能的最长前缀。

源代码：

from collections import defaultdict
class TrieNode:
    def __init__(self):
        self.children = defaultdict(TrieNode)
        self.isEnd = False
    def insert(self, word):
        node = self
        for w in word:
            node = node.children[w]
        node.isEnd = True
    def find_prefix(self, prefix, result):
        if self.isEnd:
            result.append(prefix[:])
            return
        for k,v in self.children.items():
            prefix.append(k)
            v.find_prefix(prefix, result)
            prefix.pop(-1)

if __name__ == "__main__":
    words = ['foo', 'foog', 'food', 'asdf']
    root = TrieNode()
    for w in words:
        root.insert(w)
    result = []
    root.find_prefix([], result)
    print result

Answer 1

我认为这个问题是明确的。 （也许在编辑之前更难）。答案是 trie 似乎完全正确。

从输入的单词构建一个 trie，然后先深度遍历它。每次在输入集中找到一个节点（内部节点或叶子）时，将该节点处的单词添加到输出中并停止搜索它的子节点。

Answer 2

我更喜欢简单的while-loop 方法，开头有一个排序：

minimal = []
words = ['foo', 'foog', 'food', 'asdf']
words.sort(key=lambda x: (len(x), x))
while words:
    word = words[0]
    minimal.append(word)
    words = [ x for x in words[1:] if not x.startswith(word) ]
print minimal

当没有字符串是任何其他字符串的前缀时，这是一个相当有效的实现，在最坏的情况下运行 O(n**2)。

---

附言 #1：您可以通过仅按单词的长度而不是长度和字母顺序排序来稍微提高排序效率。例如，改变这一行：

    words.sort(key=lambda x: (len(x), x))

到：

    words.sort(key=lambda x: len(x))

当然，排序是 O(n(log n))，它是运行时间/复杂度的下限。

---

后记 #2：

如果您更喜欢定义的内存特性，您可以使用标记而不是在words 列表上进行过滤。该算法的标记版本如下所示：

    words = [ 'foo', 'foog', 'food', 'asdf' ]
    words.sort(key=lambda x: len(x))
    marked = [ False for _ in words ]
    for i in range(0, len(words)):
        is_marked = marked[i]
        if is_marked: continue 
        word = words[i]

        for j in range(i + 1, len(words)):
            if not marked[j] and words[j].startswith(word):
                marked[j] = True
    minimal = [ word for word, is_marked in zip(words, marked) if not is_marked ]

它比我喜欢的过滤版本稍微冗长，但它的好处是不会在循环的每次连续传递中不断地创建/销毁单词数组。