如何处理时间表冲突事件？

Question

I have a question that that has more to do with logic/algorithm rather than the actual code (PHP/JS).

Say you have a bunch of events, happening within a week. Each event's metadata is stored in the DB. (Wordpress + Event Espresso)

Ie, Event A, Mon-Fri 8-5. Event B, Tue-Fri 11-4. Etc.

Users can go on the website and purchase these events. I need to make sure they can't purchase at least 2 events that have conflicting schedule.

I wanna avoid trips to the DB as much as possible. Someone suggested that I check the conflicting event IDs in the shopping cart at checkout and throw the error. That works, but what if I have about 12 events within the week? I can't deal with (12 choose 2, that 66, I think) cases, worst case.

What's the quickest and dirtiest way to solve this? Or rather, what's a good way to solve this?

I'm on a time crunch, so client-side-only solution maybe acceptable for now.

Thank you!

EDIT: This may be a better question: Say you have a list of event metadata, consisting of start date/time, and end date/time. How do you check for conflict from each of the event?

I've never done this kind of time/schedule conflict checking, so whatever you have in mind, please fire away!

Thank you!

Answer 1

Sort events by start time

Your problem can be answered with a very simple algorithm --- but as I am not familiar with your DB , you will have to translate this algorithm to code yourself:

Let's say your events are accessible as objects in a list: event[0], event[1],... with members envent[i].start and event[i].end for start and end time (always assuming event[i].start <= event[i].end). In order to check for any overlapping events, you first sort the events by their start time so that

event[i].start <= event[i+1].start

Now, checking for overlaps means just comparing the end time of each event with the next start time:

event[i].end <= event[i+1].start

If the above relation holds for all indices i, then (obviously) no events overlap each other. But if for some index i this relation doesn't hold then you have an overlap:

event[i].start <= event[i+1].start < event[i].end

Note regarding equal times:

I formulated the algorithm under the assumption that it is ok for one event to start exactly when the previous event stopped. But if you would consider this as an overlap, you just need to change the condition to check:

event[i].end < event[i+1].start    (use < instead of <=)