Python：如何使用连接的间隔开始和结束查找最长的连续间隔

如何找到最长连接间隔链的长度

例如：

[-4,1][1,5][2,10][3,5][1,3][3,8][8,12][5,11]

这里最长的链条是：

[-4,1][1,3][3,8][8,12]

如您所见，当前间隔的结束应该是下一个间隔的开始。 我想找出最长链的长度：

length=（12-（-4））=16

我认为这涉及到递归？但我不知道如何用Python实现它

提前感谢

动态规划：

from collections import defaultdict

intervals = [-4,1][1,5][2,10][3,5][1,3][3,8][8,12][5,11]
intervals = sorted(intervals, key=lambda x: (x[1], x[0]))  # will sort by end, then start

distances = defaultdict(int)
for start, end in intervals:
    # this is the key step: at each point, the max length interval up to here
    # is max combined length of all intervals that end here
    distances[end] = max(distances[end], distances[start] + end-start)
print(max(distances.values()))

---

更复杂的解决方案

example = [[-4,1],[1,5],[2,10],[3,5],[1,3],[3,8],[8,12],[5,11]]

# we create a simple tree structure
tree = {}
for v2 in example:
    tree[tuple(v2)] = ([v3 for v3 in example if v3[0] == v2[1]], 
                       [v3 for v3 in example if v3[1] == v2[0]])

def is_ancestor(n1, n2, tree):
    """check if a node is ancestral to another"""
    if n1 in tree[tuple(n2)][1]:
        return True
    for n3 in tree[tuple(n2)][1]:
        return is_ancestor(n1, n3, tree)
    return False

def get_longest(example, tree, result=None, v=None):
    """searches for longest path"""
    if not result:
        result = [[v]]
    for desc in tree[tuple(v)][0]:
        if result[-1][-1] not in tree[tuple(desc)][1]:
            result.append([r for r in result[-1] 
                           if is_ancestor(r, desc, tree)])
        result[-1].append(desc)
        get_longest(example, tree, result, desc)
    return result

# check from each starting point
max_dist = 0
for n in example:
    for intervals in get_longest(example, tree, [], n):
        print (intervals, intervals[-1][1] , intervals[0][0])
        dist = intervals[-1][1] - intervals[0][0]
        if dist > max_dist:
            max_dist = dist
print(max_dist)

以下是一种递归（回溯）方法：

正如预期的那样：

(15, [[-4, 1], [1, 3], [3, 5], [5, 11]])

---

这个问题可以通过在有向无环图中寻找最长路径来解决。看见那篇文章提到了寻找一个拓扑排序，但在本例中，这完全是微不足道的。只需按端点的自然顺序对其排序。请查看以下内容：。它回答了你的问题吗？因为我在这里找不到两种合理简单而又有效的方法，所以我只使用递归方法

(15, [[-4, 1], [1, 3], [3, 5], [5, 11]])