1155. 掷骰子的N种方法

暑假刷题水题居多，多数都没有什么记录的价值，不过还是有题目是有必要写下来供自己以后复习的。

先上一题前几天写的题目
1155. 掷骰子的N种方法
这里有 d 个一样的骰子，每个骰子上都有 f 个面，分别标号为 1, 2, …, f。
我们约定：掷骰子的得到总点数为各骰子面朝上的数字的总和。
如果需要掷出的总点数为 target，请你计算出有多少种不同的组合情况（所有的组合情况总共有 f^d 种），模 10^9 + 7 后返回。

示例 1：
输入：d = 1, f = 6, target = 3
输出：1
示例 2：
输入：d = 2, f = 6, target = 7
输出：6
示例 3：
输入：d = 2, f = 5, target = 10
输出：1
示例 4：
输入：d = 1, f = 2, target = 3
输出：0
示例 5：
输入：d = 30, f = 30, target = 500
输出：222616187

提示：
1 <= d, f <= 30
1 <= target <= 1000

应该第一眼就可以想到递归了，但是看一下数据 d f 在30 target在1000
甚至有的时候需要mod 10000000007这个数字，说明一定是非常非常大的计算量。
不存状态的递归一定是算不出来的，会超时的。
存状态可以在递归中存，也可以用动态规划。

我们先撸一下，寻常递归该怎么写

class Solution {
    public int numRollsToTarget(int d, int f, int target) {
        return dfs(d, f, target, 1);
    }
    public int dfs(int d, int f, int target, int index) {
        if(index > d && target == 0)
            return 1;
        if(index > d || target < 0)
            return 0;
        int ans = 0;
        for(int i = 1; i <= f; i ++) {
            if(target >= i) {
                ans += dfs(d, f, target - i, index + 1);
                ans %= 1000000007;
            }
        }
        return ans;
    }
}

这样不难，加一个index条件限制到了d然后判定target == 0就行，意料之中的超时。
那就考虑用一个数组来存中间状态，这和动态规划的思想可以说是很像了。
这样的方法以前讲过。

class Solution {
    
    public static final int[][] t = new int[31][1001]; 
    
    public int numRollsToTarget(int d, int f, int target) {
        for(int i = 0; i < 31; i ++) {
            for(int j = 0; j < 1001; j ++)
                t[i][j] = -1;
        }
        return dfs(d, f, target, 1);
    }
    public int dfs(int d, int f, int target, int index) {
        if(index > d && target == 0)
            return 1;
        if(index > d || target < 0)
            return 0;
        if(t[index][target] != -1)
            return t[index][target];
        int ans = 0;
        for(int i = 1; i <= f; i ++) {
            if(target >= i) {
                ans += dfs(d, f, target - i, index + 1);
                ans %= 1000000007;
            }
        }
        t[index][target] = ans;
        return ans;
    }
}

比动态规划稍慢。

class Solution {
    public int numRollsToTarget(int d, int f, int target) {
         int[][] dp = new int[d + 1][target + 1];
        
        dp[0][0] = 1;
        for(int i = 1; i <= d; i ++) {
            for(int j = 1; j <= f; j ++) {
                for(int k = 1; k <= target; k ++) {
                    if(k >= j)
                        dp[i][k] = (dp[i][k] + dp[i - 1][k - j]) % (int)(Math.pow(10, 9) + 7);
                }
            }
        }
        return dp[d][target];
        
    }
}

动态规划的写法。