Count Vowels Permutation

Count Vowels Permutation - Problem

Dynamic Programming Hard

Given an integer n, your task is to count how many strings of length n can be formed under the following rules:

Each character is a lower case vowel ('a', 'e', 'i', 'o', 'u')
Each vowel 'a' may only be followed by an 'e'
Each vowel 'e' may only be followed by an 'a' or an 'i'
Each vowel 'i' may not be followed by another 'i'
Each vowel 'o' may only be followed by an 'i' or a 'u'
Each vowel 'u' may only be followed by an 'a'

Since the answer may be too large, return it modulo 10⁹ + 7.

Input & Output

Example 1 — Small Input

$ Input: n = 1

› Output: 5

💡 Note: For length 1, all vowels are valid: 'a', 'e', 'i', 'o', 'u'. Total = 5 strings.

Example 2 — Medium Input

$ Input: n = 2

› Output: 10

💡 Note: Valid strings: 'ae', 'ea', 'ei', 'ia', 'ie', 'io', 'iu', 'oi', 'ou', 'ua'. Total = 10 strings.

Example 3 — Larger Input

$ Input: n = 5

› Output: 68

💡 Note: Following the transition rules through 5 levels, we get 68 valid vowel permutation strings.

Constraints

1 ≤ n ≤ 2 × 10⁴

Visualization

Tap to expand

Asked in

G Google 12 f Facebook 8 a Amazon 6

The key insight is to model this as a state machine where each vowel represents a state, and transitions follow the given rules. The optimal approach uses dynamic programming to count valid strings ending with each vowel at each length. Time: O(n), Space: O(1).

Common Approaches

✓ Dynamic Programming (Bottom-Up)

⏱️ Time: O(n) Space: O(1)

Use a DP array where dp[i] represents number of valid strings of length i ending with vowel i. For each position, calculate next state based on transition rules.

Memoized Recursion

⏱️ Time: O(n × 5) Space: O(n × 5)

Same recursive approach but store results of (position, last_vowel) pairs to avoid redundant calculations. This transforms exponential time to polynomial.

Recursive Enumeration

⏱️ Time: O(5ⁿ) Space: O(n)

For each position, try all 5 vowels and recursively build the rest of the string. Check transition rules at each step and count valid complete strings.

Dynamic Programming (Bottom-Up) — Algorithm Steps

Initialize DP for length 1
For each length, calculate next vowel counts
Apply transition rules
Sum all possibilities at final length

Visualization

Tap to expand

Step-by-Step Walkthrough

Initialize

Length 1: all vowels have count 1

Transitions

Apply rules to get counts for next length

Final Sum

Sum all vowel counts for length n

Code -

solution.c — C

#include <stdio.h>

const int MOD = 1000000007;

int solution(int n) {
    long long dp[5] = {1, 1, 1, 1, 1};  // a, e, i, o, u
    
    for (int length = 2; length <= n; length++) {
        long long newDp[5] = {0, 0, 0, 0, 0};
        
        newDp[1] += dp[0];  // a -> e
        newDp[0] += dp[1];  // e -> a
        newDp[2] += dp[1];  // e -> i
        newDp[0] += dp[2];  // i -> a
        newDp[1] += dp[2];  // i -> e
        newDp[3] += dp[2];  // i -> o
        newDp[4] += dp[2];  // i -> u
        newDp[2] += dp[3];  // o -> i
        newDp[4] += dp[3];  // o -> u
        newDp[0] += dp[4];  // u -> a
        
        for (int i = 0; i < 5; i++) {
            dp[i] = newDp[i] % MOD;
        }
    }
    
    long long result = 0;
    for (int i = 0; i < 5; i++) {
        result = (result + dp[i]) % MOD;
    }
    
    return (int) result;
}

int main() {
    int n;
    scanf("%d", &n);
    printf("%d\n", solution(n));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

Single loop through n positions, constant work per position

✓ Linear Growth

Space Complexity

O(1)

Only store counts for current and previous vowel states (5 values each)

⚡ Linearithmic Space

32.0K Views

Medium Frequency

~25 min Avg. Time

892 Likes

Ln 1, Col 1

Smart Actions

💡 Explanation

AI Ready

💡 Suggestion Tab to accept Esc to dismiss

// Output will appear here after running code

Code Editor Closed

Click the red button to reopen

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Dynamic Programming (Bottom-Up) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler