Sum of indices of Characters removed to obtain an Empty String based on given conditions

// C# program to implement
// the above approach
using System;
using System.Collections.Generic;
using System.Linq;
class GFG {
   
    // Function to add index of the deleted character
    static void add_seg(int[] seg, int start, int end,
                        int current, int index)
    {
         
        // If index is beyond the range
        if (index > end || index < start)
            return;
     
        // Insert the index of the deleted
        // character
        if (start == end)
        {
            seg[current] = 1;
            return;
        }
        int mid = (start + end) / 2;
     
        // Search over the subtrees to find the
        // desired index
        add_seg(seg, start, mid, 2 * current + 1, index);
        add_seg(seg, mid + 1, end, 2 * current + 2, index);
        seg[current] = seg[2 * current + 1] + seg[2 * current + 2];
    }
     
    // Function to return count of deleted indices
    // which are to the left of the current index
    static int deleted(int[] seg, int l, int r, int start, int end, int current)
    {
        if (end < l || start > r)
            return 0;
        if (start >= l && end <= r)
            return seg[current];
             
        int mid = (start + end) / 2;
         
        return deleted(seg, l, r, start, mid, 2 * current + 1) +
               deleted(seg, l, r, mid + 1, end, 2 * current + 2);
    }
     
    // Function to generate the
    // sum of indices
    static void sumOfIndices(string s)
    {
        int N = s.Length;
        int x = (int)(Math.Ceiling(Math.Log(N) / Math.Log(2)));
        int seg_size = 2 * (int)Math.Pow(2, x) - 1;
        int[] segment = new int[seg_size];
     
        int count = 4;
     
        // Stores the original index of the
        // characters in sorted order of key
        Dictionary<int, List<int>> fre = new Dictionary<int, List<int>>();
        for(int i = 0; i < N; i++)
        {
            int key = (int)(s[i]);
            List<int> que = new List<int>();
            if(fre.ContainsKey(key))
            {
                que = fre[key];
            }
            que.Add(i);
            fre[key] = que;
        }
     
        // Traverse the map
        while (fre.Count > 0)
        {
             
            // Extract smallest index
            // of smallest character
            int it = fre.Keys.First();
     
            // Delete the character from the map
            // if it has no remaining occurrence
            if (fre[it].Count == 0)
                fre.Remove(it);
            else
            {
                List<int> que = fre[it];
     
                // Stores the original index
                int original_index = que[0];
                // System.out.println(original_index);
     
                // Count of elements removed to
                // the left of current character
                int curr_index = deleted(segment, 0, original_index - 1, 0, N - 1, 0);
     
                // Current index of the current character
                int new_index = original_index - curr_index;
     
                // For 1-based indexing
                count += new_index + 1;
     
                // Insert the deleted index
                // in the segment tree
                add_seg(segment, 0, N - 1, 0, original_index);
     
                que.RemoveAt(0);
                fre[it] = que;
            }
        }
     
        // Final answer
        Console.Write(count);
    }
  
  static void Main() {
    string s = "geeksforgeeks";
    sumOfIndices(s);
  }
}

// This code is contributed by divyeshrabadiya07.