Python 最长重复（k次）子串

我知道这是一个有点老生常谈的话题，但我已经达到了从已经得到的答案中得到的帮助的极限

这是给孩子们的。我试图在字符串中找到最长的k重复子字符串，我得到了后缀树，这很好。我知道我需要用每个节点的子代叶数注释后缀表，然后找到子代数

>=k

的节点，最后找到这些节点中最深的节点。理论上我已经准备好了

我从以下资源中得到了很多帮助（哦，我只能发布2条）：

我可以得到从根到每个叶的路径，但我不知道如何预处理树，以便从每个节点获得后代的数量。我有一个单独的算法，可以处理小序列，但它的复杂度是指数级的，所以对于较大的序列，它需要的时间太长了。我知道使用DFS，我应该能够以线性复杂度完成整个任务。为了使该算法能够工作，我需要能够在不到5分钟的时间内获得~40000长度字符串的最长k-peat

以下是一些示例数据（第一行：

sequence

，第二行：

k

，后缀表格式：

父子位置长度

）：

此操作的输出应为

CATAC

使用下面的代码（修改自），我已经能够获得路径，但是在较长的序列上解析每个节点的路径仍然需要很长时间

#authors listed at
#http://en.literateprograms.org/Depth-first_search_(Python)?action=history&offset=20081013235803
class Vertex:
    def __init__(self, data):
        self.data = data
        self.successors = []

def depthFirstSearch(start, isGoal, result):
    if start in result:
        return False

    result.append(start)

    if isGoal(start):
        return True
    for v in start.successors:
        if depthFirstSearch(v, isGoal, result):
            return True

    # No path was found
    result.pop()
    return False

def lrep(seq,reps,tree):
    n = 2 * len(seq) - 1
    v = [Vertex(i) for i in xrange(n)]
    edges = [(int(x[0]),int(x[1])) for x in tree]
    for a, b in edges:
        v[a].successors.append(v[b])

    paths = {}
    for x in v:
        result = []
        paths[x.data] = []
        if depthFirstSearch(v[1], (lambda v: v.data == x.data), result):
            path = [u.data for u in result]
            paths[x.data] = path

我想做的是在查找深度之前，对树进行预处理，以查找满足

子体>=k

要求的节点。我甚至还没有弄清楚我将如何计算深度。虽然我想我会有一些字典来跟踪路径中每个节点的深度，然后求和

所以，我的第一个最重要的问题是：“如何预处理带有后代叶子的树？”

我的第二个不太重要的问题是：“在那之后，我如何快速计算深度？”

---

另外，我应该声明，这不是家庭作业或诸如此类的事情。我只是一个生物化学家，试图通过一些计算挑战来拓展我的视野。

对于基本弦运算的练习来说，这是个不错的问题。我不再记得后缀树了；）但正如你所说：从理论上讲，你已经准备好了

如何对具有后代叶子的树进行预处理？ 关于这个话题的讨论有点混乱。您只需要知道，您是否是

n>=k

child的最外层非叶节点。如果您在整个字符串中找到了从根节点到这个节点的子字符串，后缀树会告诉您，有

n

可能的连续体。因此，必须有

n

个地方出现这个字符串

之后，如何快速计算深度？ 对于这一问题和许多类似问题，一个简单的关键概念是进行深度优先搜索：在每个节点中，询问子元素的值，并将最大值返回给父元素。根节点将获得最终结果

计算值的方式因问题而异。在这里，每个节点都有三种可能：

该节点没有子节点。它是叶节点，结果无效

每个子级都返回一个无效的结果。它是最后一个非叶节点，结果为零（此节点后不再有字符）。如果此节点有

n

child，则从根到此节点的每条边的浓缩字符串在整个字符串中出现

n

次。如果我们至少需要

k

节点和

k>n

，结果也是无效的

一个或多个leaf返回有效的内容。结果是返回值的最大值加上附加到边缘的字符串长度

当然，还必须返回对应的节点。否则，您将知道最长的重复子串有多长，但不知道它在哪里

代码 您应该先尝试自己编写代码。如果您想收集所有必要的信息，那么构建树很简单，但不是很简单。然而，这里有一个简单的例子。请注意：如果输入无效，每一次健全性检查都会被取消，一切都会严重失败。例如，不要尝试使用除一个之外的任何其他根索引，不要将节点作为父节点引用，这些节点以前没有作为子节点引用过，等等。有很大的改进空间*提示；）*

---

当我深入研究这一点时，我意识到我得到的是一个边列表，而不是树本身。因此，我需要从边缘生成树，同时在每个节点上用后代叶子进行注释。我只是不知道怎么开始，你也可以问。

#authors listed at
#http://en.literateprograms.org/Depth-first_search_(Python)?action=history&offset=20081013235803
class Vertex:
    def __init__(self, data):
        self.data = data
        self.successors = []

def depthFirstSearch(start, isGoal, result):
    if start in result:
        return False

    result.append(start)

    if isGoal(start):
        return True
    for v in start.successors:
        if depthFirstSearch(v, isGoal, result):
            return True

    # No path was found
    result.pop()
    return False

def lrep(seq,reps,tree):
    n = 2 * len(seq) - 1
    v = [Vertex(i) for i in xrange(n)]
    edges = [(int(x[0]),int(x[1])) for x in tree]
    for a, b in edges:
        v[a].successors.append(v[b])

    paths = {}
    for x in v:
        result = []
        paths[x.data] = []
        if depthFirstSearch(v[1], (lambda v: v.data == x.data), result):
            path = [u.data for u in result]
            paths[x.data] = path

class Node(object):
    def __init__(self, idx):
        self.idx = idx     # not needed but nice for prints 
        self.parent = None # edge to parent or None
        self.childs = []   # list of edges

    def get_deepest(self, k = 2):
        max_value = -1
        max_node = None
        for edge in self.childs:
            r = edge.n2.get_deepest()
            if r is None: continue # leaf
            value, node = r
            value += len(edge.s)
            if value > max_value: # new best result
                max_value = value
                max_node = node
        if max_node is None:
            # we are either a leaf (no edge connected) or 
            # the last non-leaf.
            # The number of childs have to be k to be valid.
            return (0, self) if len(self.childs) == k else None
        else:
            return (max_value, max_node)

    def get_string_to_root(self):
        if self.parent is None: return "" 
        return self.parent.n1.get_string_to_root() + self.parent.s

class Edge(object):
    # creating the edge also sets the correspondending
    # values in the nodes
    def __init__(self, n1, n2, s):
        #print "Edge %d -> %d [ %s]" % (n1.idx, n2.idx, s)
        self.n1, self.n2, self.s = n1, n2, s
        n1.childs.append(self)
        n2.parent = self

nodes = {1 : Node(1)} # root-node
string = sys.stdin.readline()
k = int(sys.stdin.readline())
for line in sys.stdin:
    parent_idx, child_idx, start, length = [int(x) for x in line.split()]
    s = string[start-1:start-1+length]
    # every edge constructs a Node
    nodes[child_idx] = Node(child_idx)
    Edge(nodes[parent_idx], nodes[child_idx], s)

(depth, node) = nodes[1].get_deepest(k)
print node.get_string_to_root()