1220. 统计元音字母序列的数目

1220. 统计元音字母序列的数目
给你一个整数 n，请你帮忙统计一下我们可以按下述规则形成多少个长度为 n 的字符串：

字符串中的每个字符都应当是小写元音字母（‘a’, ‘e’, ‘i’, ‘o’, ‘u’）

• 每个元音 ‘a’ 后面都只能跟着 ‘e’
• 每个元音 ‘e’ 后面只能跟着 ‘a’ 或者是 ‘i’
• 每个元音 ‘i’ 后面 不能 再跟着另一个 ‘i’
• 每个元音 ‘o’ 后面只能跟着 ‘i’ 或者是 ‘u’
• 每个元音 ‘u’ 后面只能跟着 ‘a’
• 由于答案可能会很大，所以请你返回 模 10^9 + 7 之后的结果。

示例 1：

输入：n = 1
输出：5
解释：所有可能的字符串分别是："a", "e", "i" , "o" 和 "u"。

示例 2：

输入：n = 2
输出：10
解释：所有可能的字符串分别是："ae", "ea", "ei", "ia", "ie", "io", "iu", "oi", "ou" 和 "ua"。

示例 3：

输入：n = 5
输出：68

提示：

• 1 <= n <= 2 * 10⁴

解题思路：
线性DP

• 每个元音 ‘a’ 后面都只能跟着 ‘e’
• 每个元音 ‘e’ 后面只能跟着 ‘a’ 或者是 ‘i’
• 每个元音 ‘i’ 后面 不能 再跟着另一个 ‘i’
• 每个元音 ‘o’ 后面只能跟着 ‘i’ 或者是 ‘u’
• 每个元音 ‘u’ 后面只能跟着 ‘a’

有上述选择可以得出结论

• 每个元音 ‘a’ 前面都只能跟着 ‘e’ 或者 ‘i’ 或者 ‘u’
• 每个元音 ‘e’ 前面只能跟着 ‘a’ 或者是 ‘i’
• 每个元音 ‘i’ 前面只能跟着’e’或者‘o’
• 每个元音 ‘o’ 前面只能跟着 ‘i’
• 每个元音 ‘u’ 前面只能跟着 ‘o’ 或者 ‘i’

则可得出公式
dp[i][0] = (dp[i-1][1] + dp[i-1][2] + dp[i-1][4]) % mod;
dp[i][1] = (dp[i-1][0] + dp[i-1][2]) % mod;
dp[i][2] = (dp[i-1][1] + dp[i-1][3]) % mod;
dp[i][3] = dp[i-1][2] % mod;
dp[i][4] = (dp[i-1][2] + dp[i-1][3]) % mod;

最终对所有的求和 再对mod取余即可得出答案。

代码：
c++

class Solution {
public:
    int countVowelPermutation(int n) {
        long long dp[20001][5];
        int mod = 1000000007;
        for(int i = 0; i < 5; i++)
        {
            dp[1][i] = 1;
        }
        for(int i = 2; i <= n; i++)
        {
            dp[i][0] = (dp[i-1][1] + dp[i-1][2] + dp[i-1][4]) % mod;
            dp[i][1] = (dp[i-1][0] + dp[i-1][2]) % mod;
            dp[i][2] = (dp[i-1][1] + dp[i-1][3]) % mod;
            dp[i][3] = dp[i-1][2] % mod;
            dp[i][4] = (dp[i-1][2] + dp[i-1][3]) % mod;
        }
        int sum = 0;
        for(int i = 0; i < 5; i++)
        {
            sum = (dp[n][i] + sum)% mod;
        }
        return sum % mod;
    }
};

py3

class Solution:
    def countVowelPermutation(self, n: int) -> int:
        dp = (1,1,1,1,1)
        mod = 1000000007
        for _ in range(n - 1):
            dp = (dp[1] + dp[2] + dp[4]) % mod, (dp[0] + dp[2]) % mod, (dp[1] + dp[3]) % mod, dp[2] % mod, \
            (dp[2] + dp[3])%mod
        return sum(dp) % mod

总结：

时间复杂度： O(n)
空间复杂度： O(1)