Question

我有一个任务列表[[5, 9], [1, 2], [3, 4], [0, 6], [5, 7], [8, 9]]。每个子列表都有两个时间间隔。（例如：[5，9]，其中5是开始时间，9是结束时间）。我想获得一个列表，该列表具有不互相重叠的最大时间。在这种情况下，例如：[1, 2],[3, 4],[5, 7],[8, 9]是最好的时间表。

我编写了一个python程序，如果从一个间隔开始，则该程序应该找出其他间隔的组合。例如，如果我以[5,9]开头，则必须返回所有可能的组合。然后，我可以一一输入所有间隔并选择最大的输出。

但是我的代码没有给出预期的输出。请帮助我找出代码有什么问题。

def findMax (tasks):
    maxCount = []
    maxTask = []
    for i in range (len (tasks)):
        if maxTask == []: maxTask.append (tasks [i])
        else:
            count = 0
            for j in range (len (maxTask)):
                if tasks [i] == maxTask [j]: continue
                else:
                    if (tasks [i][0] < maxTask [j][0] and tasks [i][1] <= maxTask [j][0]) or (tasks [i][0] >= maxTask [j][1] and tasks [i][1] > maxTask [j][0]): count += 1
                    if count == len (maxTask): maxTask.append (tasks [i])
        maxCount.append (len (maxTask))
        maxTask = []
    return max (maxCount)

Answer 1

尝试下面的代码，它对我有用：

def getCombi(tasks):
    first = getNext([0,0], tasks)
    combi = [first]
    while True:
        nextTask = getNext(combi[-1],tasks)
        if nextTask != ["EmptyTask"]:
            combi.append(nextTask)
        else: break
    return combi

def getNext(MainTask, tasks):
    i = MainTask[1]

    taskDiffrencesList = []
    for task in tasks:
        if task[0] > i:
            x = task[0]-i
        else: continue
        d = task[1]-task[0]
        taskDiffrencesList.append([[x,d],task])

    smallestDiffrence = [10000, ["EmptyTask"]]

    for entry in taskDiffrencesList:
        if entry[0][0]+entry[0][1] < smallestDiffrence[0]:
            smallestDiffrence[0] = entry[0][0]+entry[0][1]
            smallestDiffrence[1] = entry[1]
    return smallestDiffrence[1]

print(getCombi([[5,9],[1,2],[3,4],[0,6],[5,7],[8,9]]))

因此，存在一个循环，该循环根据与前一个数字的差以及下一个任务的数字之间的差异寻找最佳的下一个任务，例如，如果前一个任务是task1 = [3,5]，另一个任务是task2 = [7,10]的差是2（在task1 [1]和task2 [0]之间）和3（在task2 [0]和task2 [1]之间）。然后，它以两个差异之和最小的方式处理任务。这可能不会总是为您提供正确的列表，但是几乎可以。

希望对您有帮助！

Answer 2

您可以使用一个函数来递归地遍历所有与现有可行任务列表不重叠的其余任务，并在剩余任务中不存在与之不重叠的其他任务时产生可行任务任何可行的任务：

def schedule(tasks, viable_tasks=None):
    if not viable_tasks:
        viable_tasks = []
        tasks = sorted(tasks)
    found_viable = False
    for i, (start, end) in enumerate(tasks):
        for viable_start, viable_end in viable_tasks:
            if viable_start < start < viable_end or viable_start < end < viable_end or start < viable_start < end or start < viable_end < end:
                break
        else:
            found_viable = True
            yield from schedule(tasks[:i] + tasks[i + 1:], viable_tasks + [[start, end]])
    if not found_viable:
        yield viable_tasks

这样：

tasks = [[5, 9], [1, 2], [3, 4], [0, 6], [5, 7], [8, 9]]
max(schedule(tasks), key=len))

返回：[[1, 2], [3, 4], [5, 7], [8, 9]]

找到最大的非重叠间隔

2 个答案: