Leetcode 1223. 掷骰子模拟【动态规划】

有一个骰子模拟器会每次投掷的时候生成一个 1 到 6 的随机数。

不过我们在使用它时有个约束，就是使得投掷骰子时，连续 掷出数字 i 的次数不能超过 rollMax[i]（i 从 1 开始编号）。

现在，给你一个整数数组 rollMax 和一个整数 n，请你来计算掷 n 次骰子可得到的不同点数序列的数量。

假如两个序列中至少存在一个元素不同，就认为这两个序列是不同的。由于答案可能很大，所以请返回 模 10^9 + 7 之后的结果。

示例 1：

输入：n = 2, rollMax = [1,1,2,2,2,3]
输出：34
解释：我们掷 2 次骰子，如果没有约束的话，共有 6 * 6 = 36 种可能的组合。但是根据 rollMax 数组，数字 1 和 2 最多连续出现一次，所以不会出现序列 (1,1) 和 (2,2)。因此，最终答案是 36-2 = 34。
示例 2：

输入：n = 2, rollMax = [1,1,1,1,1,1]
输出：30
示例 3：

输入：n = 3, rollMax = [1,1,1,2,2,3]
输出：181
 

提示：

1 <= n <= 5000
rollMax.length == 6
1 <= rollMax[i] <= 15

来源：力扣（LeetCode）
链接：https://leetcode.cn/problems/dice-roll-simulation
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

解法：
看到题第一反应就知道是动态规划，可能是直觉吧。。
但是想了很久都没有想出转移方程，还是太菜了。最后看到评论区有个老哥说可以用dp[i][j]来代表以连续j个i来结尾的方案数。

我朝着这个方向想了一会儿，但还是想不明白怎么二维DP就把这个搞定了。。

最后我推出来的是一个3维DP，用dp[n][m][k]来代表以k个m结尾的总长度为n的方案数

这个DP的方程要比那个题评论区的老哥好理解一些：
比如现在的希望求的是dp[5][1][3]
意思是3个1结尾的长度为5的方案数，我们具体比划一下，就是想知道这个方案数：XX111，XX是两个未知的序列

这里很明显XX111的方案数就等于XX的方案数减去第二个X不能为1的方案数。换句话说，XX111的方案数和X2、X3、X4、X5、X6的方案数之和是一样多的。

那X2的方案数是多少呢？这个很简单，要么是12,22,32,42,52,62这几种，这里需要考虑22是否满足题目的限制。

最后我们得到的转移方程是这样的：

含义，以k个m结尾的长度为n的方案数，其实就是在不以m结尾的，长度只有n-k的所有情况之和，这里所有情况其实就是以i结尾，且结尾的长度从1到限制条件rollMax[i]的所有方案。

最后，注意一下边界条件，比如当n==k的时候，答案就是1，当n<k的时候答案是0，然后判断一下n-k不要为负

理解了这些，我们就可以编写代码了。注意，动态规划的实现不一定靠递推，这个题因为边界条件不太容易写，需要考虑n和k的各种关系。一般遇到这种我更喜欢用递归的方式写出，只要做好记忆化搜索即可。看代码：

class Solution
{
    private int[][][] dp=new int[5001][7][16];
    private int mod=1000000007;
    private int[] rollMax;

    //扔n次，最后有k个连续m的方案数
    private int dfs(int n,int m,int k)
    {
        if(n<0)
            return 0;
        if(dp[n][m][k]!=-1)
            return dp[n][m][k];
        else
        {
            if(n==k)
            {
                dp[n][m][k]=1;
                return 1;
            }
            else if(k>n)
            {
                dp[n][m][k]=0;
                return 0;
            }
            else
            {
                int result=0;
                for(int i=1;i<=6;++i)
                {
                    if(i!=m)
                    {
                        for(int j=1;j<=rollMax[i-1];++j)
                            result=(result+dfs(n-k,i,j))%mod;
                    }
                }
                dp[n][m][k]=result;
                return result;
            }
        }
    }

    private void init(int n)
    {
        for(int i=0;i<=n;++i)
            for(int j=1;j<=6;j++)
                for(int k=0;k<=rollMax[j-1];++k)
                    dp[i][j][k]=-1;
    }

    public int dieSimulator(int n,int[] rollMax)
    {
        this.rollMax=rollMax;
        int result=0;
        this.init(n);
        for(int i=1;i<=6;++i)
        {
            for(int j=1;j<=rollMax[i-1];++j)
                result=(result+dfs(n,i,j))%mod;
        }
        return result;
    }
}