对象的重叠列表

Question

我有以下

var list = new List<Schedule>();

Schedule 对象具有以下属性：

• 开始时间（日期时间）
• 结束时间（日期时间）

是否有一行代码可以检查list 中的时间限制是否重叠，同时遍历其所有Schedule 成员？

提前致谢。

我试图在一个名为 EnforceOverlapPolicy() 的方法中使用上述逻辑，如果有任何冲突，从技术上讲，它会抛出一个新的异常。

Answer 1

如果您只关心是否存在重叠而不是哪些时间表重叠，那么您应该能够在 O(n log n) 中执行此操作。关键是通过StartTime 和EndTime（O(n log n) 部分）对时间表进行排序。然后您可以枚举结果并将每个计划的StartTime 与前一个计划的EndTime 进行比较。如果StartTime 早于EndTime，那么您有重叠的时间表。但是，如果没有第三方帮助，我认为它不能在单个查询中完成。我自己是Ix-Main 的粉丝。以下解决方案使用来自Ix-Main 的Buffer 函数：

bool hasOverlap =
    list
    .OrderBy(x => x.StartTime)
    .ThenBy(x => x.EndTime)
    .Buffer(2, 1)
    .Where(x => x.Count == 2)
    .Where(x => x[1].StartTime < x[0].EndTime)
    .Any();

如果您不想使用第三方库，那么您可以使用以下方法执行相同的操作：

Schedule first = null;
bool hasOverlap = false;
using(var enumerator = list.OrderBy(x => x.StartTime).ThenBy(x => x.EndTime).GetEnumerator())
{
    enumerator.MoveNext();
    first = enumerator.Current;
    while(enumerator.MoveNext())
    {
        if(enumerator.Current.StartTime < first.EndTime)
        {
            hasOverlap = true;
            break;
        }
    }
}

Answer 2

假设性能不是问题（否则考虑an algorithm for overlaps）：

var pairs = from f in list 
            from s in list
            where (f.EndTime < s.StartTime) && (f.StartTime < s.EndTime) && (f != s)
            select new {First = f, Second = s };

基本上，我们会检查所有可能的配对是否有重叠。

或者，没有查询语法：

var overlaps = list.SelectMany(l => list, (f, s) => new {f,s})
    .Where(x => (x.f.EndTime < x.s.StartTime) && 
               (x.f.StartTime < x.s.EndTime) && (x.f != x.s));

Answer 3

一种不同的方法，我不确定整个事情的性能，但其想法是在一个 BitArray 中展平您的日程定义的范围，该 BitArray 表示特定分钟是否已被先前的日程使用。

从技术上讲，它也不是一个“单行”的答案，尽管从调用代码的角度来看它只是一行

所以假设已经定义了一个类ScheduleList

public class ScheduleList : List<Schedule>
{
    private BitArray ba = new BitArray(1440);

    // Define own Add method to Add a Schedule to the list
    // Or override the predefined one....
    public Schedule Add(int sh, int sm, int eh, int em)
    {
        Schedule s = new Schedule();
        s.StartTime = new DateTime(1, 1, 1, sh, sm, 0);
        s.EndTime = new DateTime(1, 1, 1, eh, em, 0);

        // Of course, having full control on the Add phase, you
        // could easily enforce your policy at this point. 
        // You could not accept a new schedule if the time slot is busy
        // but we could ignore it at this point

        this.Add(s);
        return s;
    }

    public bool IsTimeSlotBusy(Schedule s)
    {
        int sidx = Convert.ToInt32(TimeSpan.FromMinutes((s.StartTime.Hour * 60) + s.StartTime.Minute).TotalMinutes);
        int eidx = Convert.ToInt32(TimeSpan.FromMinutes((s.EndTime.Hour * 60) + s.EndTime.Minute).TotalMinutes);
        for (int x = sidx; x <= eidx; x++)
        {
            if (ba.Get(x)) return true;
            ba.Set(x, true);
        }
        return false;
    }
}

现在你可以写这样的东西了

ScheduleList schedules = new ScheduleList();
schedules.Add(12, 0, 12, 30);
schedules.Add(15, 10, 15, 30);
schedules.Add(12, 0, 23, 59);
schedules.Add(14, 0, 23, 59);

// The fake 'one liner'
bool overlap = schedules.Any(s => schedules.IsTimeSlotBusy(s));
Console.WriteLine(overlap);

在这里等待数学家告诉我为什么这是最糟糕的。 （不讽刺，我真的很想知道从数学的角度来看这是否不好）