0

I have a data set of events (start date, end date, location). These events move in the country and I need to figure out which event should go where after it ends.

Exemple:

  1. [1/7, 6/7, Toronto] (Starts the 1st of July, ends the 6th of July)
  2. [2/7, 4/7, Montreal]
  3. [4/7, 11/7, Ottawa]
  4. [17/7, 22/7, Vancouver]

..etc (Data set will be around 100 entries, so performance is not really an issue)

In this exemple, Event 1 could move and do Event 4, since it ends on the 6th of July and Event 4 starts on the 17th. (Assuming transit in the same day)

All Events that couldn't find a suitable match will be stored in a report for someone to match manually.

This optimization code will be done in javascript.

My first thought was to have 2 arrays, with the same data. First array sorted by Start Date, 2nd array sorted by End Date. Then go through the list of End Dates and try to find an appropriate Start Date for it, then remove these entries from the array and continue like that until no more matching is possible.

Anybody has a better idea on how to approach this problem ? If you need more details let me know!

J V
  • 92
  • 9
Yannick
  • 184
  • 1
  • 3
  • 10
  • sounds like a typical interval scheduling problem, and seems like you are already doing the "default" greedy algorithm approach, which can be seen as optimal, except that you actually don't need the first sorted array – xvatar Jul 13 '12 at 22:17

1 Answers1

1

Your question isn't very clear. If I understand correctly, your goal is to choose a subset of events such that your selection maximizes the number of events (and there are not overlapping events). If so, your problem can be seen as an Activity Selection Problem. There is a simple greedy algorithm to solve that.

Let 

event[1..n] the n events
start[i] the start time of the event number i
finish[i] the finish time of the event number i

and assume that you already sorted the events by end time.

The following greedy algorithm will find the largest subset S of non overlapping events: (note that lse is the Last Selected Event)

S = {event[1]}
lse = 1

foreach event[i] do:
     if start[i] > finish[lse]:
         S = S + {event[i]}
         lse = i

return S

Basically:

  1. you sort the events by end time
  2. you select the 1st event
  3. you loop on the events, greedily choosing the 1st one that doesn't overlap with the last one you choose
Haile
  • 3,120
  • 3
  • 24
  • 40
  • Whaaa, glad I learned this type of algorithm has a name! I'm pondering what the implications are if the events are overlapping though. As you can see from my example, event #2 is contained in the time frame of event #1. My thoughts for the 2 arrays is that what remains in the array that is sorted by Start Date is to be able to figure which events could not find another suitableevent that ends where this remaining event would start. exemple: Event #1 cannot be started by any other event in the list since all End Dates are > than Event1's Start Date. – Yannick Jul 14 '12 at 12:21
  • Well, the greedy algorithm will find the **maximum** set of events you can attend. All the events you didn't choose **cannot be attended**, if you don't want events to overlap. So, if the algorithm selects event #1, event #2 cannot be attended. If you allow events to overlap, you don't need any algorithm: just pick all the events ;) – Haile Jul 15 '12 at 12:40