"在 Python 中合并重叠区间"

Question

我正在尝试解决需要合并重叠间隔的问题。 问题是<\/a>：

给定一组区间，合并所有重叠区间。

例如，给定 [1,3],[2,6],[8,10],[15,18]，返回 [1,6],[8,10],[15,18]。

我尝试了我的解决方案：

但是，它显然缺少最后一个间隔：
不确定如何包括最后一个间隔，因为重叠只能在转发模式下检查。
如何修复我的算法，使其工作到最后一个插槽？

Answer 1

我正在尝试解决一个问题，其中重叠的间隔需要合并： https : //leetcode.com/problems/merge-intervals/description/

问题是：

给定间隔的集合，合并所有重叠的间隔。

例如，给定[1,3]，[2,6]，[8,10]，[15,18]，返回[1,6]，[8,10]，[15,18]。

我尝试了我的解决方案：

# Definition for an interval.
# class Interval:
#     def __init__(self, s=0, e=0):
#         self.start = s
#         self.end = e

class Solution:
    def merge(self, intervals):
        """
        :type intervals: List[Interval]
        :rtype: List[Interval]
        """
        start = sorted([x.start for x in intervals])
        end = sorted([x.end for x in intervals])

        merged = []
        j = 0
        new_start = 0

        for i in range(len(start)):
            if start[i]<end[j]:
                continue
            else:
                j = j + 1
                merged.append([start[new_start], end[j]])
                new_start = i


        return merged

但是，它显然缺少最后一个时间间隔，因为：

Input : [[1,3],[2,6],[8,10],[15,18]]

Answer :[[1,6],[8,10]]

Expected answer: [[1,6],[8,10],[15,18]]

不确定如何包括最后一个间隔作为重叠，只能在正向模式下检查。

如何解决我的算法，使其工作到最后一个时隙？

谢谢你的帮助。

Answer 2

我正在尝试解决一个问题，其中重叠的间隔需要合并： https : //leetcode.com/problems/merge-intervals/description/

问题是：

给定间隔的集合，合并所有重叠的间隔。

例如，给定[1,3]，[2,6]，[8,10]，[15,18]，返回[1,6]，[8,10]，[15,18]。

我尝试了我的解决方案：

# Definition for an interval.
# class Interval:
#     def __init__(self, s=0, e=0):
#         self.start = s
#         self.end = e

class Solution:
    def merge(self, intervals):
        """
        :type intervals: List[Interval]
        :rtype: List[Interval]
        """
        start = sorted([x.start for x in intervals])
        end = sorted([x.end for x in intervals])

        merged = []
        j = 0
        new_start = 0

        for i in range(len(start)):
            if start[i]<end[j]:
                continue
            else:
                j = j + 1
                merged.append([start[new_start], end[j]])
                new_start = i


        return merged

但是，它显然缺少最后一个时间间隔，因为：

Input : [[1,3],[2,6],[8,10],[15,18]]

Answer :[[1,6],[8,10]]

Expected answer: [[1,6],[8,10],[15,18]]

不确定如何包括最后一个间隔作为重叠，只能在正向模式下检查。

如何解决我的算法，使其工作到最后一个时隙？

谢谢你的帮助。

Answer 3

我正在尝试解决一个问题，其中重叠的间隔需要合并： https : //leetcode.com/problems/merge-intervals/description/

问题是：

给定间隔的集合，合并所有重叠的间隔。

例如，给定[1,3]，[2,6]，[8,10]，[15,18]，返回[1,6]，[8,10]，[15,18]。

我尝试了我的解决方案：

# Definition for an interval.
# class Interval:
#     def __init__(self, s=0, e=0):
#         self.start = s
#         self.end = e

class Solution:
    def merge(self, intervals):
        """
        :type intervals: List[Interval]
        :rtype: List[Interval]
        """
        start = sorted([x.start for x in intervals])
        end = sorted([x.end for x in intervals])

        merged = []
        j = 0
        new_start = 0

        for i in range(len(start)):
            if start[i]<end[j]:
                continue
            else:
                j = j + 1
                merged.append([start[new_start], end[j]])
                new_start = i


        return merged

但是，它显然缺少最后一个时间间隔，因为：

Input : [[1,3],[2,6],[8,10],[15,18]]

Answer :[[1,6],[8,10]]

Expected answer: [[1,6],[8,10],[15,18]]

不确定如何包括最后一个间隔作为重叠，只能在正向模式下检查。

如何解决我的算法，使其工作到最后一个时隙？

谢谢你的帮助。

Answer 4

我正在尝试解决一个问题，其中重叠的间隔需要合并： https : //leetcode.com/problems/merge-intervals/description/

问题是：

给定间隔的集合，合并所有重叠的间隔。

例如，给定[1,3]，[2,6]，[8,10]，[15,18]，返回[1,6]，[8,10]，[15,18]。

我尝试了我的解决方案：

# Definition for an interval.
# class Interval:
#     def __init__(self, s=0, e=0):
#         self.start = s
#         self.end = e

class Solution:
    def merge(self, intervals):
        """
        :type intervals: List[Interval]
        :rtype: List[Interval]
        """
        start = sorted([x.start for x in intervals])
        end = sorted([x.end for x in intervals])

        merged = []
        j = 0
        new_start = 0

        for i in range(len(start)):
            if start[i]<end[j]:
                continue
            else:
                j = j + 1
                merged.append([start[new_start], end[j]])
                new_start = i


        return merged

但是，它显然缺少最后一个时间间隔，因为：

Input : [[1,3],[2,6],[8,10],[15,18]]

Answer :[[1,6],[8,10]]

Expected answer: [[1,6],[8,10],[15,18]]

不确定如何包括最后一个间隔作为重叠，只能在正向模式下检查。

如何解决我的算法，使其工作到最后一个时隙？

谢谢你的帮助。

Answer 5

聚会迟到了，但这是我的解决方案。 我通常发现带有不变量的递归更容易概念化。 在这种情况下，不变的是head总是被合并，而tail总是等待被合并，你将head的最后一个元素与tail的第一个元素进行比较。

绝对应该使用sorted with key参数而不是使用列表理解。

不确定切片和连接列表的效率如何。

def _merge(head, tail):
    if tail == []:
        return head

    a, b = head[-1]
    x, y = tail[0]

    do_merge = b > x
    if do_merge:
        head_ = head[:-1] + [(a, max(b, y))]
        tail_ = tail[1:]
        return _merge(head_, tail_)
    else:
        head_ = head + tail[:1]
        tail_ = tail[1:]
        return _merge(head_, tail_)


def merge_intervals(lst):
    if len(lst) <= 1:
        return lst
    lst = sorted(lst, key=lambda x: x[0])
    return _merge(lst[:1], lst[1:])

Answer 6

我知道这个问题很老，但如果它可能有帮助，我写了一个 Python 库来处理（一组）间隔。 它的名字是portion并且可以很容易地合并区间：

>>> import portion as P
>>> inputs = [[1,3],[2,6],[8,10],[15,18]]
>>> # Convert each input to an interval
>>> intervals = [P.closed(a, b) for a, b in inputs]
>>> # Merge these intervals
>>> merge = P.Interval(*intervals)
>>> merge
[1,6] | [8,10] | [15,18]
>>> # Output as a list of lists
>>> [[i.lower, i.upper] for i in merge]
[[1,6],[8,10],[15,18]]

文档可以在这里找到： https ://github.com/AlexandreDecan/portion