Maximum number of intersections possible for any of the N given segments

// C# program for the above approach
using System;
using System.Collections.Generic; 

class GFG{
    
static int lower_bound(int[] a, int low, 
                       int high, long element)
{
    while(low < high)
    {
        int middle = low + (high - low) / 2;
        
        if (element > a[middle])
            low = middle + 1;
        else
            high = middle;
    }
    return low;
}

static int maximumIntersections(int [,]arr,
                                int N)
{
    
    // Stores the resultant maximum count
    int count = 0;
  
    // Stores the starting and the
    // ending points
    int[] L = new int[N];
    int[] R = new int[N];
    for(int i = 0; i < N; i++) 
    {
        L[i] = arr[i, 0];
        R[i] = arr[i, 1];
    }
  
    // Sort arrays points in the
    // ascending order
    Array.Sort(L);
    Array.Sort(R);
  
    // Traverse the array arr[]
    for(int i = 0; i < N; i++)
    {
        int l = arr[i, 0];
        int r = arr[i, 1];
  
        // Find the count of segments
        // on left of ith segment
        int x = lower_bound(L, 0, N, l);
  
        // Find the count of segments
        // on right of ith segment
        int y = N-lower_bound(R, 0, N, r + 1);
  
        // Find the total segments not
        // intersecting with the current
        // segment
        int cnt = x + y;
      
        // Store the count of segments
        // that intersect with the
        // ith segment
        cnt = N - cnt - 1;
  
        // Update the value of count
        count = Math.Max(count, cnt);
    }
    
    // Return the resultant count
    return count;
}

// Driver Code
public static void Main() 
{ 
    int [,]arr = new int[3, 2]{ { 1, 6 }, 
                                { 5, 5 }, 
                                { 2, 3 } };
    int N = 3;
    
    Console.Write(maximumIntersections(arr, N));
}
}

// This code is contributed by SURENDRA_GANGWAR    

using System;
using System.Collections.Generic;

class GFG
{
    // Function to find the maximum number of intersections 
    // one segment has with all the other given segments
    public static int MaximumIntersections(int[][] arr, int N)
    {
        // Stores the resultant maximum count
        int count = 0;

        // Create a SortedDictionary
        SortedDictionary<int, int> pointCount = new SortedDictionary<int, int>();

        // Traverse the array
        for (int i = 0; i < N; i++)
        {
            // Increment the count of L
            if (!pointCount.ContainsKey(arr[i][0]))
                pointCount[arr[i][0]] = 1;
            else
                pointCount[arr[i][0]]++;

            // Decrement the count of (R+1)
            if (!pointCount.ContainsKey(arr[i][1] + 1))
                pointCount[arr[i][1] + 1] = -1;
            else
                pointCount[arr[i][1] + 1]--;
        }

        // Store the current sum
        int currSum = 0;
        foreach (var value in pointCount.Values)
        {
            currSum += value;

            // Taking the max of sum
            count = Math.Max(count, currSum);
        }

        // Return the resultant count
        return count;
    }

    // Driver Code
    public static void Main(string[] args)
    {
        int[][] arr = { new int[] { 1, 6 }, new int[] { 5, 5 }, new int[] { 2, 3 } };
        int N = arr.Length;
        Console.WriteLine(MaximumIntersections(arr, N));
    }
}

using System;
using System.Collections.Generic;

// Comparison function for sorting events
class EventComparator : IComparer<KeyValuePair<int, int>>
{
    public int Compare(KeyValuePair<int, int> a, KeyValuePair<int, int> b)
    {
        return a.Key.CompareTo(b.Key);
    }
}

public class MaximumIntersections
{
    // Function to find the maximum number of intersections
    public static int MaxIntersections(List<KeyValuePair<int, int>> segments)
    {
        int n = segments.Count;

        List<KeyValuePair<int, int>> events = new List<KeyValuePair<int, int>>();
        for (int i = 0; i < n; i++)
        {
            events.Add(new KeyValuePair<int, int>(segments[i].Key, 1));
            events.Add(new KeyValuePair<int, int>(segments[i].Value, -1));
        }

        // Sort the events
        events.Sort(new EventComparator());

        // Traverse the events and keep track of the maximum
        // number of intersections
        int ans = 0, cnt = 0;
        for (int i = 0; i < 2 * n; i++)
        {
            cnt += events[i].Value;
            ans = Math.Max(ans, cnt);
        }
        // Return the maximum number of intersections
        return ans;
    }

    public static void Main(string[] args)
    {
        List<KeyValuePair<int, int>> segments = new List<KeyValuePair<int, int>>();
        segments.Add(new KeyValuePair<int, int>(1, 6));
        segments.Add(new KeyValuePair<int, int>(5, 5));
        segments.Add(new KeyValuePair<int, int>(2, 3));

        int maxIntersect = MaxIntersections(segments);
        Console.WriteLine(maxIntersect);
    }
}