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];
    }

你可能感兴趣的:(leetcode,每日一题,leetcode,算法)