最长重复(k次)子串

时间:2012-11-09 15:47:13

标签: python algorithm bioinformatics longest-substring

我知道这是一个有点被打败的话题,但我已经达到了可以从已经回答的内容中获得帮助的极限。

这是针对Rosalind project problem LREP的。我正在尝试在字符串中找到最长的k-peated子字符串,并且我已经提供后缀树,这很好。我知道我需要使用每个节点的后代叶子数来注释后缀表,然后查找具有>=k后代的节点,最后找到这些节点中最深的节点。理论上我已经确定了。

我从以下资源中获得了很多帮助(哎呀,我只能发布2个):

我可以获取从根到每个叶子的路径,但我无法弄清楚如何以这样的方式预处理树,以便我可以从每个节点获得后代的数量。我有一个单独的算法,适用于小序列,但它具有指数复杂性,所以对于较大的东西,它需要太长时间。我知道使用DFS我应该能够以线性复杂度执行整个任务。为了使这个算法起作用,我需要能够在不到5分钟的时间内获得长度约为40,000的最长k-peat。

以下是一些示例数据(第一行:sequence,第二行:k,后缀表格式:parent child location length):

CATACATAC$
2
1 2 1 1
1 7 2 1
1 14 3 3
1 17 10 1
2 3 2 4
2 6 10 1
3 4 6 5
3 5 10 1
7 8 3 3
7 11 5 1
8 9 6 5
8 10 10 1
11 12 6 5
11 13 10 1
14 15 6 5
14 16 10 1

此输出应为CATAC

使用以下代码(从LiteratePrograms修改)我已经能够获取路径,但是为了解析每个节点的路径,仍然需要很长时间才能解析出路径。

#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

我想要做的是在找到深度之前预处理树以找到满足descendants >= k要求的节点。我还没有知道我将如何计算深度。虽然我想我会有一些字典来跟踪路径中每个节点的深度然后总结。

所以,我的第一个最重要的问题是:“如何使用后代叶子预处理树?”

我的第二个不那么重要的问题是:“之后,我怎样才能快速计算深度?”

P.S。我应该说这不是作业或任何类似的东西。我只是一名生物化学家,试图通过一些计算挑战扩大我的视野。

1 个答案:

答案 0 :(得分:4)

基本字符串操作练习的好问题。我不再记得后缀树;)但正如你所说的那样:理论上,你已经确定了。

如何使用后代叶子预处理树?

此主题的wikipedia-stub有点令人困惑。如果您是具有n >= k子项的最外层非叶节点,您只需要知道。如果您在整个字符串中找到了从根节点到此节点的子字符串,则后缀树会告诉您,n可能存在连续性。所以必须有n个地方,这个字符串出现。

之后,如何快速计算深度?

这个和许多类似问题的一个简单的关键概念是进行深度优先搜索:在每个Node中,询问子元素的值并将其最大值返回给父元素。根节点将获得最终结果。

如何计算值在问题之间有所不同。每个节点都有三种可能性:

  1. 节点没有子节点。它是一个叶子节点,结果无效。
  2. 每个孩子都会返回无效结果。它是最后一个非叶子节点,结果为零(此节点后不再有字符)。如果此节点具有n个子节点,则从根节点到此节点的每个边的串联字符串在整个字符串中显示n次。如果我们至少需要k个节点和k > n,则结果也无效。
  3. 一个或多个叶子返回有效的内容。结果是返回值的最大值加上附加边缘的字符串的长度。
  4. 当然,您还必须返回相应的节点。否则你会知道,最长的重复子串是多久但不是它的位置。

    代码

    你应该先尝试自己编码。如果你想收集所有必要的信息,构建树很简单,但不是微不足道的。不过这是一个简单的例子。请注意:如果输入无效,那么每次完整性检查都会被删除,一切都会失败。例如。不要尝试使用任何其他根索引而不是一个,不要将节点作为父节点引用,之前没有被引用为子节点等。还有很大的改进空间* 提示;)*

    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()