Определить, есть ли участки длины, содержащие определенное количество точек

using System;
using System.Collections.Generic;
using System.Drawing;
using System.Linq;
using System.Text;
using System.Text.RegularExpressions;
 
namespace TestConsole
{
    static class MathExt
    {
        public const double Accuracy = 1e-15;
        
        public static bool IsZero(this double x)
        { 
            return Math.Abs(x) < Accuracy; 
        }
 
        public static bool Eq(this double x, double y)
        {
            return (x - y).IsZero();
        }
    }
 
    struct Point
    {
        public double X;
        public double Y;
 
        public Point(double X, double Y) 
        { 
            this.X = X; 
            this.Y = Y; 
        }
 
        public static Point operator +(Point a, Point b)
        {
            return new Point(a.X + b.X, a.Y + b.Y);
        }
 
        public static Point operator -(Point a, Point b)
        {
            return new Point(a.X - b.X, a.Y - b.Y);
        }
 
        public static Point operator *(Point p, double k)
        {
            return new Point(p.X * k, p.Y * k);
        }
 
        public static double Distance(Point a, Point b)
        {
            double dx = a.X - b.X, dy = a.Y - b.Y;
            return Math.Sqrt(dx * dx + dy * dy);
        }
 
        // override Equals by Accuracy
    }
 
    class Path
    {
        Point[] Points;
        double[] Segments;
        
        public Path(params Point[] InitialPoints)
        {
            int n = InitialPoints.Length;
            Points = new Point[n];
            Array.Copy(InitialPoints, Points, n);
 
            Segments = new double[n];
            for (int i = 1; i < n; i++)
            {
                Segments[i] = Segments[i - 1] + Point.Distance(Points[i - 1], Points[i]);
            }
        }
 
        /// <summary>
        /// Возвращает натуральный параметр точки на ломаной,
        /// если точка принадлежит ломаной, иначе -1.0d
        /// </summary>
        public double this[Point p]
        {
            get
            {
                for (int i = 0; i < Points.Length - 1; i++)
                {
                    double a = Point.Distance(Points[i], p);
                    double b = Point.Distance(p, Points[i + 1]);
                    double c = Segments[i + 1] - Segments[i];
                    if (c.Eq(a + b))
                    {
                        return a + i;
                    }
                }
                return -1.0;
            }
        }
 
        /// <summary>Возвращает точку ломаной по натуральному параметру</summary>
        public Point this[double p]
        {
            get
            {
                // Идекс ближайшего левого узла ломаной
                int ip = 0;
                while (Segments[ip + 1] < p) ip++;
 
                // ближайшие левый и правый узел ломаной
                Point L = Points[ip], R = Points[ip + 1]; 
 
                // Длина сегмента ломаной и участка от левого узла до точки
                double sz = Segments[ip + 1] - Segments[ip];
                return sz.IsZero() ? L : L + (R - L) * ((p - Segments[ip]) / sz);
            }
        }
 
        public IEnumerable<Point> AllPoints { get { foreach (var p in Points) yield return p; } }
    }
 
    static class Task
    {
        static void GetRandomInput(out Path Path, out Point[] Points)
        {
            Random rnd = new Random();
            int n = rnd.Next(20, 50);      // Число точек ломаной
            int m = n + rnd.Next(10);   // Число "других" точек
            int k = rnd.Next(n);        // Число "других" точек, которые будут принадлежать ломаной
            double w = 10.0;            // размер квадрата откуда будут браться точки
            
            List<Point> toPath = new List<Point>();
            List<Point> toPoints = new List<Point>();
 
            // Формируем ломаную
            for (int i = 0; i < n; i++)
            {
                toPath.Add(new Point(rnd.NextDouble() * w, rnd.NextDouble() * w));
            }
 
            Path = new Path(toPath.ToArray());
               
            // Добавляем точки с ломаной к "другим"
            for (int i = 0; i < k; i++)
            {
                toPoints.Insert(rnd.Next(toPoints.Count), Path[rnd.NextDouble() * (n - 1)]);
            }
 
            // Добавляем еще несколько произвольных точек к "другим"
            for (int i = k + 1; i < m; i++ )
            {
                toPoints.Insert(rnd.Next(toPoints.Count),
                    new Point(rnd.NextDouble() * w, rnd.NextDouble() * w));
            }
 
            Points = toPoints.ToArray();
        }
 
        static void DrawInput(Path Path, Point[] Points)
        {
            HashSet<Point> hs = new HashSet<Point>();
            foreach (Point p in Path.AllPoints) hs.Add(p);
            foreach (Point p in Points) hs.Add(p);
 
            string tmpl = "{0,6:F2} | {1,6:F2} | {2,-6} | {3,-6}";
            Console.WriteLine(tmpl, "X", "Y", "Кривая", "Другие");
            foreach(Point p in hs)
            {
                Console.WriteLine(tmpl, p.X, p.Y,
                    Path[p] > -1 ? "  +" : "", 
                    Array.IndexOf(Points, p) > -1 ? "  +" : "");
            }
        }
 
        static bool Solve(Path Path, Point[] Points, double l, int m)
        {
            // Параметризуем все точки на кривой
            List<double> D = new List<double>();
            foreach (Point p in Points)
            {
                // Натуральный параметр точки на ломаной
                double d = Path[p];
                if (d < 0) continue;
 
                // Вставляем в порядке возрастания
                bool fl = false;
                for (int i = 0; i < D.Count && !fl; i++)
                    if (fl = D[i] >= d) D.Insert(i, d);
 
                if (!fl) D.Add(d);
            }
 
            bool r = false;
            for (int i = 0; i < D.Count - m && !r; i++)
                r |= (D[i + m] - D[i]) <= l;
 
            return r;
        }
 
        static void Main()
        {
            Point[] points;
            Path path;
 
            GetRandomInput(out path, out points);
            DrawInput(path, points);
 
            Console.WriteLine();
            Console.WriteLine(Solve(path, points, 10.0, 4) ? "Существуют" : "Не существуют");
            Console.ReadLine();
        }
    }
}