（C++/Python）LeetCode 1223 掷骰子模拟

自言自语：
做很多动规的题目了，但是总是感觉拿到题目没有思路；
动态规划，就是从0开始变化，或者从后开始变化
所以就是要找到转移方程，dp[i]、dp[i][j]、dp[i][j][k]中i、j、k代表的含义
题目描述：
有一个骰子模拟器会每次投掷的时候生成一个 1 到 6 的随机数。

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

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

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

思路：
dp[i][j][k]表示当掷 i 次的时候，数字 j 连续 出现k 次的个数
所以当 i1时，只掷一次，数字连续出现的次数只能是1
dp[i][j][1]=1
然后讨论 i>1的时候，那么有些数字就会连续出现,
这里又分为 k1 和 k>2的情况
k==1的时候，前一次可以是任意个数字
k>1的时候，前一次的数字必须要跟这次一样

代码如下：
C++

class Solution {
public:
    int dieSimulator(int n, vector<int>& rollMax) {
        vector<vector<vector<int>>>dp(n+1,vector<vector<int>>(7,vector<int>(16,0)));
        int mod=1e9+7;
        for(int i=1;i<=n;i++){
            for(int j=1;j<7;j++){
                if(i==1){
                    dp[i][j][1]=1;//只掷一次，那么连续出现的数只能是1（即k==1）
                    continue;
                }
                for(int k=2;k<=rollMax[j-1];k++){//当i>=2的时候，可能会出现连续一样的数字，且前一个数跟当前的数字一样，即k>=2
                    dp[i][j][k]=dp[i-1][j][k-1];
                }
                int s=0;
                for(int t=1;t<7;t++){//但是只连续出现一次时，前一个数可以是任意一个数
                    if(t==j){
                        continue;
                    }
                    else {
                        for(int k=1;k<=rollMax[t-1];k++){
                            s+=dp[i-1][t][k];
                            s%=mod;
                        }
                    }
                }
                dp[i][j][1]=s;
            }
        }
        int res=0;
        for(int j=1;j<7;j++){
            for(int k=1;k<=rollMax[j-1];k++){
                res+=dp[n][j][k];
                res%=mod;
            }
        }
        return res;
    }
};

python

class Solution:
    def dieSimulator(self, n: int, rollMax: List[int]) -> int:
        dp = [[[0 for _ in range(16)] for _ in range(7)] for _ in range(n+1)]
        mod = 10**9+7
        for i in range(1, n+1):
            for j in range(1, 7):
                if i == 1:
                    dp[i][j][1] = 1
                    continue
                for k in range(2,rollMax[j-1]+1):
                    dp[i][j][k] = dp[i-1][j][k-1]
                s = 0
                for t in range(1,7):
                    if t == j:
                        continue
                    for k in range(1,16):
                        s += dp[i-1][t][k]
                        s %= mod
                dp[i][j][1] = s
        res = 0
        for j in range(1,7):
            for k in range(1,16):
                res += dp[n][j][k]
                res %= mod
        return res