# Count N-length strings consisting only of vowels sorted lexicographically

Given an integer N, the task is to count all possible strings of length N consisting of vowels {a, e, i, o, u} that can be formed such that each string is sorted in lexicographical order.

Examples:

Input: N = 2
Output: 15
Explanation: The strings of length 2 which are sorted in lexicographical order are [“aa”, “ae”, “ai”, “ao”, “au”, “ee”, “ei”, “eo”, “eu”, “ii”, “io”, “iu”, “oo”, “ou”, “uu”].

Input: N = 1
Output: 5
Explanation: The strings of length 1 which are sorted in lexicographical order are [“a”, “e”, “i”, “o”, “u”].

Naive Approach: The simplest approach is to generate all possible strings of length N consisting only of vowels and count only those string that is sorted in lexicographical order. Print the count obtained after completing the steps.
Time Complexity: O(N*N!)
Auxiliary Space: O(1)

Efficient Approach: To optimize the above approach, the idea is to use Dynamic Programming. Below are some observations to solve the given problem:

• Count of lexicographically sorted strings of length 1 starting from characters a, e, i, o, and u is 1.
• Count of strings of length 2 that are in lexicographical order starting from characters a, e, i, o, and u is given by:
• Count of lexicographically sorted strings of length 2 starting from characters a is given by the count of the lexicographical strings of length 1 starting from character greater than or equal to a. Therefore, the count is 5.
• Count of lexicographically sorted strings of length 2 starting from characters e is given by the count of the lexicographical strings of length 1 starting from character greater than or equal to e. Therefore, the count is 4.
• Count of lexicographically sorted strings of length 2 starting from characters i is given by the count of the lexicographical strings of length 1 starting from character greater than or equal to i. Therefore, the count is 3.
• Count of lexicographically sorted strings of length 2 starting from characters o is given by the count of the lexicographical strings of length 1 starting from character greater than or equal to o. Therefore, the count is 2.
• Count of lexicographically sorted strings of length 2 starting from characters u is given by the count of the lexicographical strings of length 1 starting from character greater than or equal to u. Therefore, the count is 1.
• Therefore, the total count of strings length 2 is given by: 5 + 4 + 3 + 2 + 1 = 15.
• By observing the above pattern the count of strings of length N starting from each vowel character ch is given by the sum of the count of the lexicographical strings of length (N – 1) starting from character greater than or equal to ch.

Follow the steps below to solve the problem:

• Create a 2D array, dp[N + 1][6] where dp[i][j] represents the number of lexicographically sorted strings of length i that can be constructed using the first j vowels and initialize dp[1][1] with 1.
• Iterate over the first row using variable j, set dp[1][j] = dp[1][j – 1] + 1 as the string of length 1 are always sorted in lexicographically order.
• Traverse the 2D array dp[][] and update each dp state as dp[i][j] = dp[i][j – 1] + dp[i – 1][j], where dp[i][j – 1] will give the count of lexicographical string length N and dp[i – 1][j] will give the count of lexicographical string length (N – 1).
• After the above steps, print the value of dp[N][5] as the total count of resultant strings.

Below is the implementation of the above approach:

 `// C++ program for the above approach` `#include ` `using` `namespace` `std;`   `// Function to count N-length strings` `// consisting of vowels only sorted` `// lexicographically` `int` `findNumberOfStrings(``int` `n)` `{` `    ``// Stores count of strings consisting` `    ``// of vowels sorted lexiographically` `    ``// of all possible lengths` `    ``vector > DP(n + 1,` `                            ``vector<``int``>(6));`   `    ``// Initialize DP[1][1]` `    ``DP[1][1] = 1;`   `    ``// Traverse the matrix row-wise` `    ``for` `(``int` `i = 1; i < n + 1; i++) {`   `        ``for` `(``int` `j = 1; j < 6; j++) {`   `            ``// Base Case` `            ``if` `(i == 1) {` `                ``DP[i][j] = DP[i][j - 1] + 1;` `            ``}`   `            ``else` `{` `                ``DP[i][j] = DP[i][j - 1]` `                           ``+ DP[i - 1][j];` `            ``}` `        ``}` `    ``}`   `    ``// Return the result` `    ``return` `DP[n][5];` `}`   `// Driver Code` `int` `main()` `{` `    ``int` `N = 2;`   `    ``// Function Call` `    ``cout << findNumberOfStrings(N);`   `    ``return` `0;` `}`

 `// Java program to implement` `// the above approach` `import` `java.util.*;` `class` `GFG{` `  `  `// Function to count N-length strings` `// consisting of vowels only sorted` `// lexicographically` `static` `int` `findNumberOfStrings(``int` `n)` `{` `  ``// Stores count of strings consisting` `  ``// of vowels sorted lexiographically` `  ``// of all possible lengths` `  ``int` `DP[][] = ``new` `int` `[n + ``1``][``6``];`   `  ``// Initialize DP[1][1]` `  ``DP[``1``][``1``] = ``1``;`   `  ``// Traverse the matrix row-wise` `  ``for` `(``int` `i = ``1``; i < n + ``1``; i++) ` `  ``{` `    ``for` `(``int` `j = ``1``; j < ``6``; j++) ` `    ``{` `      ``// Base Case` `      ``if` `(i == ``1``) ` `      ``{` `        ``DP[i][j] = DP[i][j - ``1``] + ``1``;` `      ``}`   `      ``else` `      ``{` `        ``DP[i][j] = DP[i][j - ``1``] + ` `                   ``DP[i - ``1``][j];` `      ``}` `    ``}` `  ``}`   `  ``// Return the result` `  ``return` `DP[n][``5``];` `}`   `// Driver Code` `public` `static` `void` `main(String[] args)` `{` `  ``int` `N = ``2``;`   `  ``// Function Call` `  ``System.out.print(findNumberOfStrings(N));` `}` `}`   `// This code is contributed by sanjoy_62`

 `# Python3 program for the ` `# above approach`   `# Function to count N-length ` `# strings consisting of vowels ` `# only sorted lexicographically` `def` `findNumberOfStrings(n):` `  `  `    ``# Stores count of strings ` `    ``# consisting of vowels ` `    ``# sorted lexiographically` `    ``# of all possible lengths` `    ``DP ``=` `[[``0` `for` `i ``in` `range``(``6``)] ` `             ``for` `i ``in` `range``(n ``+` `1``)]`   `    ``# Initialize DP[1][1]` `    ``DP[``1``][``1``] ``=` `1`   `    ``# Traverse the matrix row-wise` `    ``for` `i ``in` `range``(``1``, n ``+` `1``):` `        ``for` `j ``in` `range``(``1``, ``6``):`   `            ``#Base Case` `            ``if` `(i ``=``=` `1``):` `                ``DP[i][j] ``=` `DP[i][j ``-` `1``] ``+` `1` `            ``else``:` `                ``DP[i][j] ``=` `DP[i][j ``-` `1``]``+` `DP[i ``-` `1``][j]`   `    ``# Return the result` `    ``return` `DP[n][``5``]`   `# Driver Code` `if` `__name__ ``=``=` `'__main__'``:` `  `  `    ``N ``=` `2`   `    ``# Function Call` `    ``print``(findNumberOfStrings(N))`   `# This code is contributed by Mohit Kumar 29`

 `// C# program to implement` `// the above approach` `using` `System;` `class` `GFG{` `  `  `// Function to count N-length strings` `// consisting of vowels only sorted` `// lexicographically` `static` `int` `findNumberOfStrings(``int` `n)` `{` `  ``// Stores count of strings consisting` `  ``// of vowels sorted lexiographically` `  ``// of all possible lengths` `  ``int``[,] DP = ``new` `int` `[n + 1, 6];`   `  ``// Initialize DP[1][1]` `  ``DP[1, 1] = 1;`   `  ``// Traverse the matrix row-wise` `  ``for` `(``int` `i = 1; i < n + 1; i++) ` `  ``{` `    ``for` `(``int` `j = 1; j < 6; j++) ` `    ``{` `      ``// Base Case` `      ``if` `(i == 1) ` `      ``{` `        ``DP[i, j] = DP[i, j - 1] + 1;` `      ``}`   `      ``else` `      ``{` `        ``DP[i, j] = DP[i, j - 1] + ` `                   ``DP[i - 1, j];` `      ``}` `    ``}` `  ``}`   `  ``// Return the result` `  ``return` `DP[n, 5];` `}`   `// Driver Code` `public` `static` `void` `Main(``string``[] args)` `{` `  ``int` `N = 2;`   `  ``// Function Call` `  ``Console.Write(findNumberOfStrings(N));` `}` `}`   `// This code is contributed by Chitranayal`

Output:
```15

```

Time Complexity: O(N*5)
Auxiliary Space: O(N*5)

Attention reader! Don’t stop learning now. Get hold of all the important DSA concepts with the DSA Self Paced Course at a student-friendly price and become industry ready.