Lexicographically smallest string of maximum length made up of first K alphabets that does not contain any repeating substring

In this problem, we need to generate a lexicographically smallest string using the first K characters of alphabets so that it doesn?t contain any repeated substring. We can generate a string so that all substrings of length 2 are unique. So, if all substrings of length 2 are unique, all substrings of length 3 or more are also unique.

Problem statement - We have given a positive integer K. We need to generate a new string using the first K alphabets so that generated string can?t contain any repeated substring of length 2 or more and is lexicographically smallest.

Sample examples

Input- K = 1

Output- ?aa?

Explanation- We can generate ?aa? using only ?a? so that the resultant string contains all unique substrings of length 2 or more.

Input- K = 2

Output- ?aabba?

Explanation- The ?aabba? is the lexicographically smallest string that we can generate using ?a? and ?b? only.

Input- K = 4

Output- ?aabacadbbcbdccdda?

Explanation- The ?aabacadbbcbdccdda? is the smallest string we can generate using the first 4 alphabetical characters.

Approach 1

This approach will use two nested loops to generate a new string containing unique substrings of length 2.

Algorithm

• Initialize the ?str? variable with the empty string.

• Iterate in the range 97 to 97 + k, where 97 is the ASCII value of the ?a?.

• Append the current character in the ?str?.

• Iterate in the range I to 97 + k.

• Convert i and j to character value and append to the str.

• When iteration of both nested loops completes, append ?a? at the end of the str.

• Return str, which is a newly generated string using the first K alphabets.

Example

#include <bits/stdc++.h>
using namespace std;

// function to return the lexicographically smallest string of length K
string getTheString(int K){
   // to store the resultant string
   string str = "";
   // Iterating over the range [97, 97 + K]
   for (int i = 97; i < 97 + K; i++){
      // appending the ith character to the string
      str = str + char(i);
      // Create a substring of length 2 consisting of the ith character and the jth character
      for (int j = i + 1; j < 97 + K; j++){
          // appending i and j to str
          str += char(i);
          str += char(j);
      }
   }
   // appending the last character to the string
   str += char(97);
   // return the resultant string
   return str;
}
int main(){
   int K = 2;
   cout << "The lexicographically smallest string is " << getTheString(K);
   return 0;
}

Output

The lexicographically smallest string is aabba

Time complexity - O(K * K) as both loop traverse the first K characters.

Space complexity - O(K * K) as we store the newly generated string to the ?str? variable.

In the above code, we generate all the unique substrings of length 2 using the first k character. We need to create unique pairs of characters to create a unique substring of length 2, and that logic is followed in the solution approach.