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 = 2Output:15Explanation: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 = 1Output:5Explanation: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**.

- Count of lexicographically sorted strings of length
- 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++

`// C++ program for the above approach` `#include <bits/stdc++.h>` `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<vector<` `int` `> > 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;` `}` |

*chevron_right*

*filter_none*

## Java

`// 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` |

*chevron_right*

*filter_none*

## Python3

`# 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` |

*chevron_right*

*filter_none*

## C#

`// 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` |

*chevron_right*

*filter_none*

**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.