【LeetCode】1223. 掷骰子模拟

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

算法一：动态规划

思路

• 首先，创建一个二维 dp 数组；

• dp[i][j] 表示第 i 次掷骰子时，数字 j 出现的可能的序列总数，也就是说，第 i 次掷出的数字是 j 所有可能的序列数 ， 其中 1 <= i <= n ， 1 <= j <= 6 。

• 显然， dp[1][1],dp[1][2]… dp[1][6]均为 1 ，所以，最后结果有效序列总数就是 sum (dp[n][1] + dp[n][2] + … + dp[n][6]) ， sum为求和函数 。

• 那么，如何计算第i次骰子掷出时，掷出数字为j的序列总数为多少呢？ 仔细思考一下dp[i][j]和什么有关?

  • 第一: dp[i][j] 和dp[i-1][j]有关，不仅如此，dp[i][j] 和 dp[i-1][1], dp[i-1][2],…dp[i-1][6]都有关；
  • 第二: 由于连续数字限制，dp[i][j]还和 dp[i-rollMax[j-1]][1],…,dp[i-rollMax[j-1]][6]均有关；
  • 所以，第i次掷出骰子的序列总数只和第i-1次掷出骰子的序列总数，以及第i-rollMax[j-1]次掷出骰子的序列总数有关。
  • 详细例子看题解。
  • 状态方程为 ：
    

• 需要主要对大数的处理， 使用 int 型很容易越界；

• 另外，代码中有一个特殊条件的判断，当 idx == 0 时，ans 直接减一 ；此时，第 1 次 ~ 第 i - 1次掷出的都是 k ，即出现了序列 kkk…kk ，因此不合法的情况只有一种，所以减一。

算法情况

• 时间复杂度：O（6n），即O（n）；
• 空间复杂度：O（7（n+1）），即 O（n）。

代码

class Solution {
public:
    const int MOD = 1e9 + 7;
    typedef long long LL;

    int dieSimulator(int n, vector<int>& rollMax) {
        vector<vector<LL> > dp(n+1, vector<LL>(7));
        // 初始化
        for (int j = 1; j <= 6; j++) {
            dp[1][j] = 1;
        }
        for (int i = 2; i <= n; i++) {
            for (int j = 1; j <= 6; j++) {
                // 加入第 i-1 次得所有可能序列总数
                LL ans = accumulate(dp[i-1].begin(), dp[i-1].end(), 0LL);
                int idx = i - 1 - rollMax[j-1];
                if (idx >= 1) {
                    // 减去 i - 1 - rollMax[j-1]次掷出除j外其他五个数的所有序列总数
                    ans = accumulate(dp[idx].begin(), dp[idx].end(), ans, [&](LL init, LL e) {
                        return init + MOD - e;
                    });
                    ans += dp[idx][j];
                }else if (idx == 0) {
                    // 特殊情况处理
                    ans -= 1;
                }
                dp[i][j] = ans % MOD;
            }
        }
        return accumulate(dp[n].begin(), dp[n].end(), 0LL) % MOD;
    }
};

参考资料：

1. 超简单动态规划！ 复杂度O(n)