Lexicographically smallest string obtained after concatenating array

• Difficulty Level : Medium
• Last Updated : 15 Sep, 2021

Given n strings, concatenate them in an order that produces the lexicographically smallest possible string.
Examples:

Input :  a[] = ["c", "cb", "cba"]
Output : cbacbc
Possible strings are ccbcba, ccbacb,
cbccba, cbcbac, cbacbc and cbaccb.
Among all these strings, cbacbc is
the lexicographically smallest.

Input :  a[] = ["aa", "ab", "aaa"]
Output : aaaaaab

One might think that sorting the given strings in the lexicographical order and then concatenating them produces the correct output. This approach produces the correct output for inputs like [“a”, “ab”, “abc”]. However, applying this method on [“c”, “cb”, “cba”] produces the wrong input and hence this approach is incorrect.
The correct approach is to use a regular sorting algorithm. When two strings a and b are compared to decide if they have to be swapped or not, do not check if a is lexicographically smaller than b or not. Instead check if appending b at the end of a produces a lexicographically smaller string or appending a at the end of b does. This approach works because we want the concatenated string to be lexicographically small, not the individual strings to be in the lexicographical order.

C++

 // CPP code to find the lexicographically// smallest string#include using namespace std; // Compares two strings by checking if// which of the two concatenations causes// lexicographically smaller string.bool compare(string a, string b){    return (a+b < b+a);} string lexSmallest(string a[], int n){    // Sort strings using above compare()    sort(a, a+n, compare);     // Concatenating sorted strings    string answer = "";    for (int i = 0; i < n; i++)        answer += a[i];     return answer;} // Driver codeint main(){    string a[] = { "c", "cb", "cba" };    int n = sizeof(a)/sizeof(a);    cout << lexSmallest(a, n);    return 0;}

Java

 // Java code to find the lexicographically// smallest string class GFG {     // function to sort the// array of stringstatic void sort(String a[], int n){         //sort the array    for(int i = 0;i < n;i++)    {        for(int j = i + 1;j < n;j++)        {                         // comparing which of the            // two concatenation causes            // lexicographically smaller            // string            if((a[i] + a[j]).compareTo(a[j] + a[i]) > 0)            {                String s = a[i];                a[i] = a[j];                a[j] = s;            }        }    }}     static String lexsmallest(String a[], int n){         // Sort strings    sort(a,n);     // Concatenating sorted strings    String answer = "";    for (int i = 0; i < n; i++)        answer += a[i];     return answer;} // Driver codepublic static void main(String args[]){    String a[] = {"c", "cb", "cba"};    int n = 3;    System.out.println("lexicographically smallest string = "                                      + lexsmallest(a, n)); }} // This code is contributed by Arnab Kundu

Python 3

 # Python 3 code to find the lexicographically# smallest stringdef lexSmallest(a, n):  # Sort strings using above compare()  for i in range(0,n):    for j in range(i+1,n):      if(a[i]+a[j]>a[j]+a[i]):        s=a[i]        a[i]=a[j]        a[j]=s   # Concatenating sorted strings  answer = ""  for i in range( n):    answer += a[i]  return answer # Driver codeif __name__ == "__main__":         a = [ "c", "cb", "cba" ]    n = len(a)    print(lexSmallest(a, n)) # This code is contributed by vibhu karnwal

C#

 // C# code to find// the lexicographically// smallest stringusing System; class GFG {     // function to sort the// array of stringstatic void sort(String []a, int n){         //sort the array    for(int i = 0;i < n;i++)    {        for(int j = i + 1;j < n;j++)        {                         // comparing which of the            // two concatenation causes            // lexicographically smaller            // string            if((a[i] + a[j]).CompareTo(a[j] +                                  a[i]) > 0)            {                String s = a[i];                a[i] = a[j];                a[j] = s;            }        }    }}     static String lexsmallest(String []a, int n){         // Sort strings    sort(a,n);     // Concatenating sorted    // strings    String answer = "";    for (int i = 0; i < n; i++)        answer += a[i];     return answer;} // Driver codepublic static void Main(){    String []a = {"c", "cb", "cba"};    int n = 3;    Console.Write("lexicographically smallest string = "                                 + lexsmallest(a, n)); }} // This code is contributed by nitin mittal

Javascript


Output:
cbacbc

Time complexity : The above code runs in O(M * N * logN) where N is number of strings and M is maximum length of a string.

My Personal Notes arrow_drop_up