LC-1641. 统计字典序元音字符串的数目（记忆化搜索 ==＞ 动态规划）

1641. 统计字典序元音字符串的数目

难度中等87

给你一个整数 n，请返回长度为 n 、仅由元音 (a, e, i, o, u) 组成且按 字典序排列 的字符串数量。

字符串 s 按 字典序排列 需要满足：对于所有有效的 i，s[i] 在字母表中的位置总是与 s[i+1] 相同或在 s[i+1] 之前。

示例 1：

输入：n = 1
输出：5
解释：仅由元音组成的 5 个字典序字符串为 ["a","e","i","o","u"]

示例 2：

输入：n = 2
输出：15
解释：仅由元音组成的 15 个字典序字符串为
["aa","ae","ai","ao","au","ee","ei","eo","eu","ii","io","iu","oo","ou","uu"]
注意，"ea" 不是符合题意的字符串，因为 'e' 在字母表中的位置比 'a' 靠后

示例 3：

输入：n = 33
输出：66045

提示：

• 1 <= n <= 50

记忆化搜索

class Solution {
    int n;
    int[][] cache;
    public int countVowelStrings(int n) {
        if(n == 0) return 0;
        this.n = n;
        cache = new int[n+1][6];
        for(int i = 0; i < n; i++) Arrays.fill(cache[i], -1);
        // 把字母等价为从小到大的五位数字，就直接用1~5代替
        // 题目转换为：求n位非递减的数字排列之和。
        return dfs(0, 1);
    }
    // 组合型回溯，枚举i位置选哪个，区别就是 每个数可以选多次
    // 因此要额外添加参数pre表示上一次选了哪个，这一次还能从这个数开始枚举
    public int dfs(int i, int pre){
        if(i == n){
            return 1;
        }
        if(cache[i][pre] != -1) return cache[i][pre];
        int res = 0;
        for(int d = pre; d < 6; d++){
            res += dfs(i+1, d);
        }
        return cache[i][pre] = res;
    }
}

动态规划

class Solution {
    public int countVowelStrings(int n) {
        // dp[i][j]的意思是长度为i的字符串，以元音字符j为结尾时有效字符串的个数。
        int[][] dp = new int[n+1][5];
        //初始化n=1的情况
        for(int i = 0; i < 5; i++){
            dp[1][i] = 1; // if(i == n) return 1;
        }

        for(int i = 2; i <= n; i++){
            //长度i的以u结尾的字符串可以由任意一个长度i-1的字符串结尾加个u得到
            dp[i][4]=dp[i-1][0]+dp[i-1][1]+dp[i-1][2]+dp[i-1][3]+dp[i-1][4];
            dp[i][3]=dp[i-1][0]+dp[i-1][1]+dp[i-1][2]+dp[i-1][3];
            dp[i][2]=dp[i-1][0]+dp[i-1][1]+dp[i-1][2];
            dp[i][1]=dp[i-1][0]+dp[i-1][1];
            //长度i的以a结尾的字符串只能由长度i-1的以a结尾的字符串结尾加个a得到
            dp[i][0]=dp[i-1][0];
        }
        //最终答案求个和
        return dp[n][0]+dp[n][1]+dp[n][2]+dp[n][3]+dp[n][4];
    }
}

Go的记忆化搜索优雅写法

func countVowelStrings(n int) int {
    cache := make([][6]int, n+1)
    var dfs func(i, pre int) int
    dfs = func(i, pre int) int {
        if i == n {
            return 1
        }
        if cache[i][pre] != 0 {
            return cache[i][pre]
        }
        res := 0
        for j := pre; j < 6; j++ {
            res += dfs(i+1, j)
        }
        cache[i][pre] = res
        return res
    }
    return dfs(0, 1)
}