从TimeSpans列表中找到不同的TimeSpan持续时间

如何解决从TimeSpans列表中找到不同的TimeSpan持续时间

我在尝试处理TimeSpan对象列表时遇到了一些麻烦，而没有很多代码似乎仍然无法解决所有可能的情况，所以我想我已经有点代码/逻辑上的盲点了现在！

我有一个TimeSpans列表，其中可能会发生重叠，但是我需要一个TimeSpans列表，这些列表没有重叠，但要覆盖所有TimeSpans的整个持续时间。

例如（请注意，日期采用ddMMyyyy格式）：

TS1: 01/01/2020 to 01/02/2020 (1 month)
TS2: 01/03/2020 to 01/05/2020 (2 months)
TS3: 01/04/2020 to 01/07/2020 (3 months with a 1 month overlap with TS2)
TS4: 01/10/2020 to 01/12/2020 (2 months)
TS5: 01/09/2020 to 01/01/2021 (4 months with a 2 month overlap with TS4)

因此，在这种情况下，我希望获得3个TimeSpans：

TSA: 01/01/2020 to 01/02/2020 (1 month - same as TS1 as there are no overlaps)
TSB: 01/03/2020 to 01/07/2020 (4 months - combination of TS2 and TS3)
TSC: 01/09/2020 to 01/01/2021 (4 months - combination of TS4 and TS5,technically only TS5 as TS4 is fully encompassed by TS5)

我尝试过在线研究算法，但是没有任何运气。

任何建议都将受到欢迎。

解决方法

这根本没有优化，但是 ememically 您可以通过添加块并查找重叠，然后合并这些重叠来完成此操作；像这样：

using System;
using System.Collections.Generic;
using System.Globalization;

static class P
{

    static void Main()
    {
        var results = new List<(DateTime From,DateTime To)>();

        Add("01/01/2020","01/02/2020");
        Add("01/03/2020","01/05/2020");
        Add("01/04/2020","01/07/2020");
        Add("01/10/2020","01/12/2020");
        Add("01/09/2020","01/01/2021");

        // SEE BELOW,IMPORTANT
        results.Sort(); // initial sort
        while (MergeOneOverlap()) { }
        foreach (var range in results)
        {
            Console.WriteLine($"{range.From:dd/MM/yyyy} - {range.To:dd/MM/yyyy}");
        }

        bool MergeOneOverlap()
        {
            for (int i = 0; i < results.Count; i++)
            {
                var x = results[i];
                for (int j = i + 1; j < results.Count; j++)
                {
                    var y = results[j];
                    if (x.Intersects(y))
                    {
                        results[i] = x.Merge(y);
                        results.RemoveAt(j);
                        results.Sort(); // retain sort while making progress
                        return true;
                    }
                }
            }
            return false;
        }
        void Add(string from,string to)
            => results.Add(
                (DateTime.ParseExact(from,"dd/MM/yyyy",CultureInfo.InvariantCulture),DateTime.ParseExact(to,CultureInfo.InvariantCulture)));
    }
    static bool ContainsInclusive(this (DateTime From,DateTime To) range,DateTime when)
    => when >= range.From && when <= range.To;

    static bool Intersects(this (DateTime From,DateTime To) x,(DateTime From,DateTime To) y)
        => x.ContainsInclusive(y.From) || x.ContainsInclusive(y.To) || y.ContainsInclusive(x.From) || y.ContainsInclusive(x.To);

    static (DateTime From,DateTime To) Merge(this (DateTime From,DateTime To) y)
        => (x.From < y.From ? x.From : y.From,x.To > y.To ? x.To : y.To);

}

如果这是用于大量数据，则必须考虑变得更加聪明，以避免O（N ^ 3）问题。 可能有助于合并每个添加项，如果这样做通常会使项目数量减少。

也有可能将复杂度降低到O（N ^ 2）并纯粹合并转发（即在成功合并时不要中断），但是我还没有运用足够的思想来了解其含义。而且O（N ^ 2）仍然很糟糕。

对于大数据，使用排序列表可能会有所帮助，因此您可以在开始日期进行二进制搜索以找到插入点。不过，这比我在这里写的要复杂。

---

我有95％的把握也可以，即O（N ^ 2）：

        MergeOverlaps();
        foreach (var range in results)
        {
            Console.WriteLine($"{range.From:dd/MM/yyyy} - {range.To:dd/MM/yyyy}");
        }

        void MergeOverlaps()
        {
            results.Sort();
            for (int i = 0; i < results.Count; i++)
            {
                var x = results[i];
                for (int j = i + 1; j < results.Count; j++)
                {
                    var y = results[j];
                    if (x.Intersects(y))
                    {
                        results[i] = x = x.Merge(y);
                        results.RemoveAt(j--);
                    }
                }
            }
        }

,

我建议尝试使用蛮力搜索或深度优先搜索算法。

首先，您需要按开始日期对时间范围进行排序。

暴力力： 您可以尝试所有组合，并按重叠/不重叠对它们进行评分，并且您可能想对覆盖的总时间跨度进行评分。

深度优先搜索： 编写一个递归算法，该算法从添加第一个间隔开始，然后在出现重叠时添加更多的间隔和回溯。