Question

我有以下

var list = new List<Schedule>();

Schedule对象具有以下属性：

StartTime（DateTime）
EndTime（DateTime）

是否存在一行代码，可以在list遍历所有Schedule成员时检查时间约束是否重叠？

提前致谢。

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

Answer 1

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

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中平衡由您的日程表定义的范围，该信号表示前一个日程表是否已经使用了特定分钟。

从技术上讲，它也不是一个'单线'答案，虽然从调用代码的立场来看它只是一行

所以假设定义了一个类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);

等待数学家在这里向我展示为什么这是最糟糕的。（不具讽刺意味的是，我真的希望从数学的角度来看这是不是很糟糕）

重叠的对象列表

3 个答案: