统计元音字母序列的数目 -- 动态规划 路径相加，反向逆推

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

字符串中的每个字符都应当是小写元音字母（'a', 'e', 'i', 'o', 'u'）
每个元音 'a' 后面都只能跟着 'e'
每个元音 'e' 后面只能跟着 'a' 或者是 'i'
每个元音 'i' 后面 不能 再跟着另一个 'i'
每个元音 'o' 后面只能跟着 'i' 或者是 'u'
每个元音 'u' 后面只能跟着 'a'
由于答案可能会很大，所以请你返回 模 10^9 + 7 之后的结果。

 

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

---

一般意识流直接迭代统计叶子节点的数量。但是这样会导致复杂度过高，耗时过不了。

class Solution {
public:
    int countVowelPermutation(int n) {
    	if (n < 0)
    		return 0;
        if (n == 1)
            return 5;
    	vv = n;
    	numscout('a', 2);
    	numscout('e', 2);
    	numscout('i', 2);
    	numscout('o', 2);
    	numscout('u', 2);

    	return count % (long)(pow(10,9)+7);
    }

    void numscout(char p,int level)
    {
    	switch(p)
    	{
    		case 'a':
    			if(level == vv)
    			{
    				count += 1;
    				break;
    			}
    			numscout('e', level+1);
    			break;
    		case 'e':
    			if(level == vv)
    			{
    				count += 2;
    				break;
    			}
    			numscout('a', level+1);
    			numscout('i', level+1);
    			break;
    		case 'i':
    			if(level == vv)
    			{
    				count += 4;
    				break;
    			}
    			numscout('a', level+1);
    			numscout('e', level+1);
    			numscout('o', level+1);
    			numscout('u', level+1);
    			break;
    		case 'o':
    			if(level == vv)
    			{
    				count += 2;
    				break;
    			}
    			numscout('i', level+1);
    			numscout('u', level+1);
    			break;
    		case 'u':
    			if(level == vv)
    			{
    				count += 1;
    				break;
    			}
    			numscout('a', level+1);
    			break;
    		default:
    			break;
    	}
    }
private:
	long count = 0;
	int vv = 0;
};

如果使用动态规划，就会降低复杂度。

整体思想就是 路径相加，反向逆推

for(int j=1; j<n; j++) {
            long long a1, e1, i1, o1, u1;
            a1 = (e + i + u) % mod;
            e1 = (a + i) % mod;
            i1 = (e + o) % mod;
            o1 = i;
            u1 = (i + o) % mod;
            a = a1, e = e1, i = i1, o = o1, u = u1;
        }