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^4

思路：题目中给了我们一堆字母排列的规则，我们需要维护这个生成规则--

用dp[i][j]来表示在第i个位置放置第j个元音字母，则很容易得到转移方程，具体代码如下：

class Solution {
public:
    int countVowelPermutation(int n) {
        const int maxn = 2e4 + 7, mod = 1e9 + 7;
        int dp[maxn][5], ans = 0, i, j;//'a':0, 'e':1, 'i':2, 'o':3, 'u':4
        memset(dp, 0, sizeof(dp));
        dp[0][0] = dp[0][1] = dp[0][2] = dp[0][3] = dp[0][4] = 1;
        for(i = 0; i < n - 1; ++ i){
            //每个元音 'a' 后面都只能跟着 'e'
            dp[i + 1][1] = (dp[i + 1][1] + dp[i][0]) % mod;
            //每个元音 'e' 后面只能跟着 'a' 或者是 'i'
            dp[i + 1][0] = (dp[i + 1][0] + dp[i][1]) % mod;
            dp[i + 1][2] = (dp[i + 1][2] + dp[i][1]) % mod;
            //每个元音 'i' 后面 不能 再跟着另一个 'i'
            dp[i + 1][0] = (dp[i + 1][0] + dp[i][2]) % mod;
            dp[i + 1][1] = (dp[i + 1][1] + dp[i][2]) % mod;
            dp[i + 1][3] = (dp[i + 1][3] + dp[i][2]) % mod;
            dp[i + 1][4] = (dp[i + 1][4] + dp[i][2]) % mod;
            //每个元音 'o' 后面只能跟着 'i' 或者是 'u'
            dp[i + 1][2] = (dp[i + 1][2] + dp[i][3]) % mod;
            dp[i + 1][4] = (dp[i + 1][4] + dp[i][3]) % mod;
            //每个元音 'u' 后面只能跟着 'a'
            dp[i + 1][0] = (dp[i + 1][0] + dp[i][4]) % mod;
        }
        for(j = 0; j < 5; ++ j){
            ans = (ans + dp[n - 1][j]) % mod;
        }
        return ans;
    }
};

小改进：题目中的规则是从当前向后生成，而我们希望一种更便捷的方式，即看到当前位置的状态是由哪些状态转移而来，事实上，简单画个图就很明了了

接下来我们看对于当前位置的某个字符，它的上一个字符是什么：

​​​​​​​  

因此我们可以得到状态转移方程：

class Solution {
public:
    int countVowelPermutation(int n) {
        const int maxn = 2e4 + 7, mod = 1e9 + 7;
        int dp[maxn][5], ans = 0, i, j;//'a':0, 'e':1, 'i':2, 'o':3, 'u':4
        memset(dp, 0, sizeof(dp));
        dp[0][0] = dp[0][1] = dp[0][2] = dp[0][3] = dp[0][4] = 1;
        for(i = 1; i < n; ++ i){
            dp[i][0] = ((dp[i - 1][1] + dp[i - 1][2]) % mod + 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];
            dp[i][4] = (dp[i - 1][2] + dp[i - 1][3]) % mod;
        }
        for(j = 0; j < 5; ++ j){
            ans = (ans + dp[n - 1][j]) % mod;
        }
        return ans;
    }
};