2023-10-24 leetcode 每日一题 掷骰子等于目标和的方法数

题目内容

这里有 n 个一样的骰子，每个骰子上都有 k 个面，分别标号为 1 到 k 。

给定三个整数 n , k 和 target ，返回可能的方式(从总共 kn 种方式中)滚动骰子的数量，使正面朝上的数字之和等于 target 。

答案可能很大，你需要对 109 + 7 取模 。

示例 ：

示例 1：

输入：n = 1, k = 6, target = 3
输出：1
解释：你扔一个有 6 个面的骰子。
得到 3 的和只有一种方法。
示例 2：

输入：n = 2, k = 6, target = 7
输出：6
解释：你扔两个骰子，每个骰子有 6 个面。
得到 7 的和有 6 种方法：1+6 2+5 3+4 4+3 5+2 6+1。
示例 3：

输入：n = 30, k = 30, target = 500
输出：222616187
解释：返回的结果必须是对 109 + 7 取模。

提示：

标签

动态规划

思路解析 暴力递归:

 * 由题目可得 当滚动骰子n次时，这n次的总和为target 为一次，所以递归的终止条件为和大于target 或者n等于1时
 * n等于1时，如果target-之前的和<=k，则这次尝试成功 结果加1
 *

代码 暴力递归

    private Integer MOD = 1000000007;
    public int numRollsToTarget(int n, int k, int target) {
        int num = 0;

        return numRollsToTargetD(n, k, target, 0);
    }

    private int numRollsToTargetD(int n, int k, int target, int num) {
        if (n == 1 && target - num <= k)
            return 1;
        else if (n == 1)
         	return 0;    
        int jg = 0;
        for (int i = 1; i <= k; i++) {
           if (num + i < target){
                jg += numRollsToTargetD(n-1, k, target, num + i);
                jg= jg%MOD;
            }
        }

        return jg;
    }

思路解析 暴力递归 加缓存:

 * 在暴力递归的基础上 增加map缓存，key为当前n的次数以及之前滚动骰子的和,vaule为次数
 * 避免重复计算

代码 暴力递归 加缓存

    private Integer MOD = 1000000007;
    private HashMap<String,Integer> map=new HashMap();
    public int numRollsToTarget(int n, int k, int target) {
        int num = 0;

        return numRollsToTargetD(n, k, target, 0);
    }

    private int numRollsToTargetD(int n, int k, int target, int num) {
        if (n == 1 && target - num <= k)
            return 1;
        else if (n == 1)
         	return 0;  
        if (map.containsKey(num+"_"+n))
            return map.get(num+"_"+n);
        
        int jg = 0;
        for (int i = 1; i <= k; i++) {
            if (num + i < target){
                jg += numRollsToTargetD(n-1, k, target, num + i);
                jg= jg%MOD;
            }
        }
        map.put(num+"_"+n,jg);
        return jg;
    }

思路解析 动态规划:

 * 在前面两个代码的基础上，知道可以将当前n的次数以及之前滚动骰子的和作为动态规划的两个维度
 * 所以dp[1][0]~dp[1][k]都等于1,代表滚动1次时结果为1~k的可能为1次
 * 
 * 这样dp[n][target]就是结果

代码 动态规划

    private Integer MOD = 1000000007;
    public int numRollsToTarget(int n, int k, int target) {
        int [][] dp=new int[n+1][target+1];
         for (int i = 1; i <= k; i++) {
            dp[1][i]=1;
         }
        for (int i = 2; i <= n; i++) {
            for (int j= 0; j<= target; j++) {
                for (int i2 = 1; i2 <= k; i2++) {
                	//骰子的和不能小于 0
                    if (j-i2<0)
                        continue;
                    
                    dp[i][j]=(ints[i][j]+ints[i-1][j-i2])%MOD;
                }
            }
        }
        return dp[n][target];
    }