Partitions in Arrays with at least K-Size and M-Difference Rules (Array Partition)

//code by flutterfly
using System;
using System.Collections.Generic;

class Program
{
    static List<int> seg = new List<int>();
    static List<bool> marked = new List<bool>();

    static void Push(int v)
    {
        // If the node is marked, propagate the changes to its children
        if (marked[v])
        {
            seg[2 * v] |= seg[v];
            seg[2 * v + 1] |= seg[v];
            marked[v] = false;
            marked[2 * v] = marked[2 * v + 1] = true;
        }
    }

    static int GetSegment(int v, int l, int r, int pos)
    {
        // If leaf node, return segment value
        if (l == r)
        {
            return seg[v];
        }
        else
        {
            // Push changes and recursively search for the value
            // in the left or right subtree
            Push(v);
            int m = (l + r) / 2;
            if (pos <= m)
            {
                return GetSegment(2 * v, l, m, pos);
            }
            else
            {
                return GetSegment(2 * v + 1, m + 1, r, pos);
            }
        }
    }

    static void UpdateSegment(int v, int l, int r, int query_l, int query_r)
    {
        // If range matches exactly with the node, update the
        // segment value and mark it
        if (l == query_l && r == query_r)
        {
            seg[v] |= 1;
            marked[v] = true;
        }
        else
        {
            // Push changes and recursively update the left or
            // right subtree
            Push(v);
            int m = (l + r) / 2;
            if (query_r <= m)
            {
                UpdateSegment(2 * v, l, m, query_l, query_r);
            }
            else if (query_l > m)
            {
                UpdateSegment(2 * v + 1, m + 1, r, query_l, query_r);
            }
            else
            {
                UpdateSegment(2 * v, l, m, query_l, m);
                UpdateSegment(2 * v + 1, m + 1, r, m + 1, query_r);
            }
            // Update the segment value based on the values in
            // the left and right subtree
            seg[v] = seg[2 * v] | seg[2 * v + 1];
        }
    }

    static void Main()
    {
        int N = 5;
        int K = 2;
        int M = 3;
        List<int> A = new List<int> { 8, 3, 9, 1, 2 };

        // Initializing segment tree and marked array
        seg = new List<int>(new int[4 * N + 1]);
        marked = new List<bool>(new bool[4 * N + 1]);

        // Sorting the array in ascending order
        A.Sort();

        // Iterating over the array
        for (int i = 0; i < N; i++)
        {
            int right = A.BinarySearch(A[i] + M);
            right = (right < 0) ? ~right - 1 : right;
            int left = K + i - 1;

            // If the first element, update the segment tree for the
            // given left and right range
            if (i == 0)
            {
                if (left <= right)
                {
                    UpdateSegment(1, 1, N, left + 1, right + 1);
                }
            }
            // If the previous element can be partitioned,
            // update the segment tree for the given range
            else if (GetSegment(1, 1, N, i) != 0)
            {
                if (left <= right)
                {
                    UpdateSegment(1, 1, N, left + 1, right + 1);
                }
            }
        }

        // Check if the last element can be partitioned
        if (GetSegment(1, 1, N, N) != 0)
        {
            Console.WriteLine("YES");
        }
        else
        {
            Console.WriteLine("NO");
        }
    }
}