Leetcode 【1155. 掷骰子等于目标和的方法数】

这里有 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 取模。

提示：

• 1 <= n, k <= 30
• 1 <= target <= 1000

方法一：动态规划

class Solution:
    def numRollsToTarget(self, n: int, k: int, target: int) -> int:
        mod = 10**9 + 7
        #dp[i][j]表示用i个骰子掷出数字和为j的方案数
        #dp[i][j]=dp[i-1][j-1]+dp[i-1][j-2]+...+dp[i-1][j-k]
        dp = [[0] * (target + 1) for _ in range(n + 1)]
        dp[0][0] = 1
 
        for i in range(1, n + 1):
            for j in range(1, target + 1):
                for x in range(1, k + 1):
                    if j - x >= 0:
                        dp[i][j] = (dp[i][j] + dp[i - 1][j - x]) % mod
 
        return dp[n][target]

方法二：缓存优化

class Solution:
    def numRollsToTarget(self, n: int, k: int, target: int) -> int:
        mod = 10**9 + 7
 
        def dfs(n, target):
            if n == 0 and target == 0:
                return 1
            if n == 0 or target <= 0:
                return 0
            if (n, target) in memo:
                return memo[(n, target)]
 
            ways = 0
            for i in range(1, k + 1):
                ways += dfs(n - 1, target - i)
            memo[(n, target)] = ways
            return ways
 
        memo = {}
        return dfs(n, target) % mod

中心思想还是dp的那个递归方程，方法二用了缓存来避免重复计算。