递归调度算法无法正确运行Python

Question

I've created a recursive scheduling algorithm that takes an array of Event objects which hold a start-time and end-time. These times are randomly generated and start-time is always less than end time. The time is a number between 0-24 (24 hours in a day, 24 == 0)

Here is the code to the random event array generator:

def randomEventArray(s):
    e = []
    rand1 = 0
    rand2 = 0
    for i in range(s):
        rand1 = random.randint(0,21)
        rand2 = random.randint(rand1+1,23)
        e.append(Event(rand1,rand2))
    return e

Here is the code for the Event object:

class Event:
    def __init__(self, start, end):
        self.startTime = start
        self.endTime = end
    def __repr__(self):
        return str(self)
    def __str__(self):
        return (str([self.startTime,self.endTime]))

Now here comes the part which is causing issue. I've created a piece of code that recursively goes through a generated array of events, and lists the most events that can be held in a single 24 hours. No event should overlap.

Here is the recursive greedy algorithm created:

def scheduleGD2(E):
    events = []
    scheduleRecGD2(E,0,0, events)

    return events[:]

def scheduleRecGD2(E, eventPos, startTime,events):

    while eventPos < len(E) and E[eventPos].startTime < startTime:

        eventPos += 1
    if eventPos == len(E):
        return []
    minEndPos = eventPos
    for i in range(eventPos+1, len(E)):
        if E[i].endTime < E[minEndPos].endTime:
            minEndPos = i
    events.append(E[minEndPos])
    return scheduleRecGD2(E, minEndPos+1, E[minEndPos].endTime, events)

E = randomEventArray(20)
print(scheduleGD2(E))

The expected output of this algorithm is an array with the most events that can simultaneously occur in a single 24 hours without overlapping. eg

[[0, 1], [1, 3], [4, 8], [9, 17], [17, 24]]

However, I'm receiving the following output:

[[0, 1], [12, 16], [12, 16], [5, 17], [21, 22]]

Which clearly shows Arr[2] overlapping with Arr[1] (Arr[2].StartTime (12) < Arr[1].EndTime [16]) which should not be happening.

What is wrong and why this is happening?

Answer 1

I instrumented your code for debugging, including replacing the Events package with simple pair tuples.

def scheduleRecGD2(E, eventPos, startTime, events):
    print("ENTER Rec", "eventPos", eventPos, "\tstartTime", startTime, "\n\tevents", events)

    while eventPos < len(E) and E[eventPos][0] < startTime:
        eventPos += 1

    if eventPos == len(E):
        return []

    minEndPos = eventPos
    print("\tFIRST: minEndPos", minEndPos, E[minEndPos])

    for i in range(eventPos+1, len(E)):
        if E[i][1] < E[minEndPos][1]:
            minEndPos = i 

    events.append(E[minEndPos])
    print("\tTRACE: minEndPos", minEndPos, E[minEndPos])

    return scheduleRecGD2(E, minEndPos+1, E[minEndPos][1], events)

# Main program
E = randomEventArray(8)
print(E)
print(scheduleGD2(E)) 

Output:

[(15, 20), (4, 7), (17, 20), (18, 23), (2, 7), (8, 23), (15, 23), (18, 20)]
ENTER Rec eventPos 0    startTime 0 
    events []
    FIRST: minEndPos 0 (15, 20)
    TRACE: minEndPos 1 (4, 7)
ENTER Rec eventPos 2    startTime 7 
    events [(4, 7)]
    FIRST: minEndPos 2 (17, 20)
    TRACE: minEndPos 4 (2, 7)
ENTER Rec eventPos 5    startTime 7 
    events [(4, 7), (2, 7)]
    FIRST: minEndPos 5 (8, 23)
    TRACE: minEndPos 7 (18, 20)
ENTER Rec eventPos 8    startTime 20 
    events [(4, 7), (2, 7), (18, 20)]
[(4, 7), (2, 7), (18, 20)]

---

ANALYSIS

Your algorithm trips over itself more than once. Most of all, when you enter the routine a second time, you find the first record with an acceptable start time, and take its ending time as the "figure to beat". From then on, you entirely ignore the start time given in the call, and the start times of the remaining events, looking only for something that beats the end time of a relative arbitrary interval.

You continue through the list this way, changing the given start time somewhat haphazardly, until you reach the end of the list.

---

REPAIR

Follow the many solutions available on line: First, sort your list in order of ending time, then start time. Now it's a simple matter to walk through your list, finding the first available start time that is (a) later in the list than the most recently added tuple; (b) no less than the current end time.

Given the availability of solutions, I'll leave this to as an exercise for the student. Start with the simple change in the randomization routine:

return sorted(e)