在 C# 中合并间隔与合并距离

Question

给定一个区间列表 [start, end] 我必须根据指定的合并距离合并它们。间隔以特定顺序到达，并且当它们到达时，它应该在收到每个间隔时根据指定的合并距离合并它们。其中一些间隔将被删除（在到达流中它们将被标记为已删除）——在这种情况下，我必须将原始间隔视为从未存在过。示例：

合并距离为 7 - 在以下示例中，输入按顺序到达

我尝试了以下算法来合并它们，但我的输出与上面的示例不同。有人可以帮助我吗，我在这里缺少什么！

这是我的代码。

class Program
    {
        static void Main(string[] args)
        {
            var intervals = new List<Interval>
            {
                new Interval
                {
                    start = 1,
                    end = 20
                },
                new Interval
                {
                    start = 55,
                    end = 58
                },
                new Interval
                {
                    start = 60,
                    end = 89
                },
                new Interval
                {
                    start = 15,
                    end = 31
                },
                new Interval
                {
                    start = 10,
                    end = 15
                },
                new Interval
                {
                    start = 1,
                    end = 20
                }
            };

            var mergedIntervals = Merge(intervals, 7);

            foreach (var item in mergedIntervals)
            {
                Console.WriteLine($"[{item.start}, {item.end}]");
            }

            Console.ReadKey();
        }

        public static List<Interval> Merge(List<Interval> intervals, int mergeDistance)
        {
            var result = new List<Interval>();

            for (int i = 0; i < intervals.Count; i++)
            {
                var newInterval = new Interval(intervals[i].start, intervals[i].end);
                //while (i < intervals.Count - 1 && newInterval.end >= intervals[i + 1].start)
                while (i < intervals.Count - 1 && newInterval.end <= mergeDistance) //  intervals[i + 1].start)
                {
                    newInterval.end = Math.Max(newInterval.end, intervals[i + 1].end);
                    i++;
                }

                result.Add(newInterval);
            }

            return result;
        }
    }

 

public class Interval
    {
        public int start { get; set; }
        public int end { get; set; }

        public Interval()
        {

        }

        public Interval(int start, int end)
        {
            this.start = start;
            this.end = end;
        }
    }

Answer 1

你能试试这个代码吗，工作演示代码here

 class Program
    {
        static void Main(string[] args)
        {
            var intervals = new List<Interval>
            {
                new Interval
                {
                    start = 1,
                    end = 20,
                    isAdded = true
                },
                new Interval
                {
                    start = 55,
                    end = 58,
                    isAdded = true
                },
                new Interval
                {
                    start = 60,
                    end = 89,
                    isAdded = true
                },
                new Interval
                {
                    start = 15,
                    end = 31,
                    isAdded = true
                },
                new Interval
                {
                    start = 10,
                    end = 15,
                    isAdded = true
                },
                new Interval
                {
                    start = 1,
                    end = 20,
                    isAdded = false
                }
            };

            var mergedIntervals = Merge(intervals, 7);

            foreach (var item in mergedIntervals)
            {
                Console.WriteLine($"[{item.start}, {item.end}]");
            }

            Console.ReadKey();
        }

        public static List<Interval> Merge(List<Interval> intervals, int mergeDistance)
        {
            var result = new List<IntervalGroup>();
            var group = new IntervalGroup();
            foreach (var item in intervals)
            {
                group = result.Where(c => c.Groups.Any(g =>
                Math.Abs(g.end - item.start) <= mergeDistance ||
                Math.Abs(g.end - item.end) <= mergeDistance)).FirstOrDefault();
                if (group != null && item.isAdded)
                {
                    group.Groups.Add(item);
                }
                else if(item.isAdded)
                {
                    group = new IntervalGroup();
                    group.Groups = new List<Interval>();
                    result.Add(group);
                    group.Groups.Add(item);
                }
                else if(item.isAdded == false)
                {
                    group.Groups.Remove(group.Groups.Where(c => c.start == item.start && c.end == item.end).First());
                }
            }

            var finalResult = result.Select(s => new Interval { start = s.Groups.Min(min => min.start), end = s.Groups.Max(min => min.end) });
            return finalResult.ToList();
        }
    }

    public class Interval
    {
        public int start { get; set; }
        public int end { get; set; }

        public bool isAdded { get; set; }

        public Interval()
        {

        }

        public Interval(int start, int end, bool isAdded)
        {
            this.start = start;
            this.end = end;
            this.isAdded = isAdded;
        }
    }

    public class IntervalGroup
    {
        public List<Interval> Groups { get; set; }
    }

Answer 2

当一个问题超出您的掌握范围时，将其分解为更小的部分并编码您确实理解的部分是非常有帮助的。这是我如何逐步分解的。

首先，我认为能够检查间隔的长度会很方便，所以让我们添加一个属性。

class Interval
{
    /* Prior code */

    public int Length => this.end - this.start;

现在让我们编写一个合并两个区间的方法：

class Interval
{
    /* Prior code */

    static public Interval Merge(Interval a, Interval b )
    {
        return new Interval(Math.Min(a.start, b.start), Math.Max(a.end, b.end));
    }

现在我们需要编写代码来确定两个区间是否能够合并。原型可能如下所示：

static public bool CanMerge(Interval a, Interval b, int mergeDistance)

我们内部需要什么逻辑？好吧，我们可以检查重叠并检查两端的合并距离，但我知道一个捷径。给定合并 A + B = C，当且仅当 C 的长度小于或等于 A + B + 合并距离的总和时才允许合并。所以我们可以这样写：

class Interval
{
    /* Prior code */

    static public bool CanMerge(Interval a, Interval b, int mergeDistance)
    {
        var merged = Merge(a,b);
        var canMerge = merged.Length <= a.Length + b.Length + mergeDistance;

        return canMerge;
    }

您可以从那里通过检查可合并项目来添加到列表中。请注意，递归是必需的，因为合并一个区间的行为可能会导致另一个区间变得可合并。

void AddToList(List<Interval> list, Interval newInterval, int mergeDistance)
{
    var target = list.FirstOrDefault( x => Interval.CanMerge(x, newInterval, mergeDistance) );
    if (target == null)
    {
        list.Add(newInterval);
        return;
    }
    list.Remove(target);
    AddToList(list, Interval.Merge(target, newInterval), mergeDistance);
}