Open In App

We use cookies to ensure you have the best browsing experience on our website. By using our site, you acknowledge that you have read and understood our Cookie Policy & Privacy Policy

Minimize Cost to sort a String in Increasing Order of Frequencies of Characters

Given a string S, the task is to calculate the minimum cost to sort the string in increasing order of their frequencies by swapping a block of repeated characters with another block of different repeated characters. The cost of each operation is the absolute difference of the two blocks.
Examples: 

Input: S = “aabbcccdeffffggghhhhhii” 
Output: 5 
Explanation: 



  • Swap ‘d’ with ‘aa’. The Cost of this Operation is 1
  • Swap ‘e’ with ‘bb’. The Cost of this Operation is 1
  • Swap ‘ii’ with ‘ccc’. The Cost of this Operation is cost is 1
  • Swap ‘ccc’ with ‘ffff’. The Cost of this Operation is 1
  • Swap ‘ffff’ with ‘hhhhh’. The Cost of this Operation is 1

Input : S = “aaaa” 
Output : 0 

 

Approach: 
 Follow the steps below to solve the problem:



Below is the implementation of the above approach: 




// C++ program to implement
// above approach
#include <bits/stdc++.h>
using namespace std;
 
int sortString(string S)
{
    vector<int> sorted, original;
    bool insert = false;
     
    // For a single character
    if (S.length() == 1)
    {
        cout << 0 << endl;
    }
     
    // Stores count of repetitions
    // of a character
    int curr = 1;
     
    for(int i = 0; i < (S.length() - 1); i++)
    {
         
        // If repeating character
        if (S[i] == S[i + 1])
        {
            curr += 1;
            insert = false;
        }
         
        // Otherwise
        else
        {
         
            // Store frequency
            sorted.push_back(curr);
            original.push_back(curr);
             
            // Reset count
            curr = 1;
            insert = true;
        }
    }
     
    // Insert the last character block
    if ((S[(S.length() - 1)] !=
         S[(S.length() - 2)]) || insert == false)
    {
        sorted.push_back(curr);
        original.push_back(curr);
    }
     
    // Sort the frequencies
    sort(sorted.begin(), sorted.end());
     
    // Stores the minimum cost of all operations
    int t_cost = 0;
     
    for(int i = 0; i < sorted.size(); i++)
    {
         
        // Store the absolute difference of
        // i-th frequencies of ordered and
        // unordered sequences
        t_cost += abs(sorted[i] -
                      original[i]);
    }
     
    // Return the minimum cost
    return (t_cost / 2);
}
           
// Driver Code
int main()
{
    string S = "aabbcccdeffffggghhhhhii";
     
    cout << sortString(S);
     
    return 0;
}
 





                        























                                    



                                    




                                    




                                    


                                



















// Java program to implement 


// above approach



import java.util.*;



 



class GFG{



 



public static int sortString(String S) 



{ 



    Vector<Integer> sorted = new Vector<Integer>();




    Vector<Integer> original = new Vector<Integer>(); 




    boolean insert = false; 




     



    // For a single character 




    if (S.length() == 1) 




    { 




        System.out.println(0);




    } 




     



    // Stores count of repetitions 




    // of a character 




    int curr = 1; 




    for(int i = 0; i < (S.length() - 1); i++)




    {




         



        // If repeating character 




        if (S.charAt(i) == S.charAt(i + 1))




        { 




            curr += 1; 




            insert = false; 




        } 




         



        // Otherwise 




        else




        {




             



            // Store frequency 




            sorted.add(curr); 




            original.add(curr);




             



            // Reset count 




            curr = 1; 




            insert = true; 




        } 




    } 




     



    // Insert the last character block 




    if ((S.charAt(S.length() - 1) != 




         S.charAt(S.length() - 2)) || 




         insert == false) 




    { 




        sorted.add(curr); 




        original.add(curr); 




    } 




     



    // Sort the frequencies 




    Collections.sort(sorted); 




     



    // Stores the minimum cost of all operations 




    int t_cost = 0; 




    for(int i = 0; i < sorted.size(); i++)




    {




         



        // Store the absolute difference of 




        // i-th frequencies of ordered and 




        // unordered sequences 




        t_cost += Math.abs(sorted.get(i) - 




                           original.get(i)); 




    } 




     



    // Return the minimum cost 




    return (t_cost / 2); 



} 


 


// Driver code



public static void main(String[] args)



{



    String S = "aabbcccdeffffggghhhhhii"; 




    System.out.print(sortString(S));



}


}



  


// This code is contributed by divyeshrabadiya07


















                        






                        























                                    



                                    




                                    




                                    


                                



















# Python3 program to implement


# the above approach



def sortString(S):




   



    sorted1 = []




    original = []




    insert = False



 



    # For a single character




    if (len(S) == 1):




        print(0)



 



    # Stores count of repetitions




    # of a character




    curr = 1



 



    for i in range(len(S) - 1):




        # If repeating character




        if (S[i] == S[i + 1]):




            curr += 1




            insert = False



 



        # Otherwise




        else:




            # Store frequency




            sorted1.append(curr)




            original.append(curr)



 



            # Reset count




            curr = 1




            insert = True



 



    # Insert the last character block




    if ((S[(len(S) - 1)] != S[(len(S) - 2)]) or




         insert == False):




        sorted1.append(curr)




        original.append(curr)



 



    # Sort the frequencies




    sorted1.sort()



 



    # Stores the minimum cost of all operations




    t_cost = 0



 



    for i in range(len(sorted1)):




       



        # Store the absolute difference of




        # i-th frequencies of ordered and




        # unordered sequences




        t_cost += abs(sorted1[i] - original[i])



 



    # Return the minimum cost




    return (t_cost // 2)



 


# Driver Code



if __name__ == "__main__":




    S = "aabbcccdeffffggghhhhhii"




    print(sortString(S))



 


# This code is contributed by Chitranayal


















                        






                        























                                    



                                    




                                    




                                    


                                



















// C# program to implement 


// above approach



using System;




using System.Collections.Generic;



 



class GFG{




     



public static int sortString(string S) 



{



    List<int> sorted = new List<int>();




    List<int> original = new List<int>();




     



    bool insert = false; 




  



    // For a single character 




    if (S.Length == 1) 




    {




        Console.WriteLine(0);




    } 




  



    // Stores count of repetitions 




    // of a character 




    int curr = 1; 




  



    for(int i = 0; i < (S.Length - 1); i++)




    {




         



        // If repeating character 




        if (S[i] == S[i + 1])




        { 




            curr += 1; 




            insert = false; 




        } 




         



        // Otherwise 




        else




        {




             



            // Store frequency 




            sorted.Add(curr); 




            original.Add(curr); 




             



            // Reset count 




            curr = 1; 




            insert = true; 




        } 




    } 




     



    // Insert the last character block 




    if ((S[S.Length - 1] != 




         S[S.Length - 2]) || insert == false) 




    { 




        sorted.Add(curr); 




        original.Add(curr); 




    } 




  



    // Sort the frequencies 




    sorted.Sort(); 




  



    // Stores the minimum cost of all operations 




    int t_cost = 0; 




  



    for(int i = 0; i < sorted.Count; i++)




    {




         



        // Store the absolute difference of 




        // i-th frequencies of ordered and 




        // unordered sequences 




        t_cost += Math.Abs(sorted[i] - 




                         original[i]); 




    } 




     



    // Return the minimum cost 




    return (t_cost / 2); 



}


 


// Driver Code    



static void Main() 



{



    string S = "aabbcccdeffffggghhhhhii"; 




     



    Console.Write(sortString(S));



}


}


 


// This code is contributed by divyesh072019


















                        






                        























                                    



                                    




                                    




                                    


                                



















<script>


 



    // Javascript program to implement above approach




     



    function sortString(S)




    {




        let sorted = [];




        let original = [];



 



        let insert = false;



 



        // For a single character




        if (S.length == 1)




        {




            document.write(0 + "</br>");




        }



 



        // Stores count of repetitions




        // of a character




        let curr = 1;



 



        for(let i = 0; i < (S.length - 1); i++)




        {



 



            // If repeating character




            if (S[i] == S[i + 1])




            {




                curr += 1;




                insert = false;




            }



 



            // Otherwise




            else




            {



 



                // Store frequency




                sorted.push(curr);




                original.push(curr);



 



                // Reset count




                curr = 1;




                insert = true;




            }




        }



 



        // Insert the last character block




        if ((S[S.length - 1] !=




             S[S.length - 2]) || insert == false)




        {




            sorted.push(curr);




            original.push(curr);




        }



 



        // Sort the frequencies




        sorted.sort(function(a, b){return a - b});



 



        // Stores the minimum cost of all operations




        let t_cost = 0;



 



        for(let i = 0; i < sorted.length; i++)




        {



 



            // Store the absolute difference of




            // i-th frequencies of ordered and




            // unordered sequences




            t_cost += Math.abs(sorted[i] - original[i]);




        }



 



        // Return the minimum cost




        return parseInt(t_cost / 2, 10);




    }




     



    let S = "aabbcccdeffffggghhhhhii";




      



    document.write(sortString(S));



 


</script>


















                        






                        








Output: 

5


 


Time Complexity: O(NlogN) 
Auxiliary Space: O(N)

	

        Article Tags : 
        

            DSA
Greedy
Mathematical
Sorting
Strings        


		
	

	


      

      

          
Recommended Articles

      

      

          
          
1. Minimize cost to make all characters of a Binary String equal to '1' by reversing or flipping characters of substrings

          
2. Minimize cost to sort an Array by swapping any pair of element (X, Y) with cost as (X + Y)

          
3. Minimize cost to sort the Array by moving elements with cost as the value itself

          
4. Generate a Number in Decreasing order of Frequencies of characters of a given String

          
5. Sort array of strings after sorting each string after removing characters whose frequencies are not a powers of 2

          
6. Sort an array of strings having characters at odd and even indices sorted in decreasing and increasing order respectively

          
7. Sort an array of strings in increasing order of sum of ASCII values of characters

          
8. Print characters and their frequencies in order of occurrence using a LinkedHashMap in Java

          
9. Print characters having even frequencies in order of occurrence

          
10. Print characters having prime frequencies in order of occurrence

          
11. Print characters and their frequencies in order of occurrence using Binary Tree

          
12. Print characters having odd frequencies in order of occurrence

          
13. Print characters and their frequencies in order of occurrence

          
14. Sum of frequencies of characters of a string present in another string

          
15. Sort all even numbers in ascending order and then sort all odd numbers in descending order

          
16. Minimize cost to empty a given string by removing characters alphabetically

          
17. Minimize cost to convert all characters of a binary string to 0s

          
18. Minimize cost of removals required to make all remaining characters of the string unique

          
19. Minimum number of characters required to be added to a String such that all lowercase alphabets occurs as a subsequence in increasing order

          
20. Minimize cost to sort Binary String by swapping pairs or reversing prefix at most once

          
21. Sort a string in increasing order of given priorities

          
22. Minimize cost to empty given array where cost of removing an element is its absolute difference with Time instant

          
23. Minimize cost to split an array into K subsets such that the cost of each element is its product with its position in the subset

          
24. Minimize cost to connect the graph by connecting any pairs of vertices having cost at least 0

          
25. Minimize cost to convert all 0s to 1s with cost of converting 0s group be X and that of 1 be X/3