leetcode - 1155. 掷骰子的N种方法

这里有 d d d 个一样的骰子,每个骰子上都有 f f f 个面,分别标号为 1 , 2 , . . . , f 1, 2, ..., f 1,2,...,f

我们约定:掷骰子的得到总点数为各骰子面朝上的数字的总和。

如果需要掷出的总点数为 t a r g e t target target,请你计算出有多少种不同的组合情况(所有的组合情况总共有 f d f^d fd 种),模 1 0 9 + 7 10^9 + 7 109+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

——————————
来源:力扣(LeetCode)
链接:https://leetcode-cn.com/problems/number-of-dice-rolls-with-target-sum
著作权归领扣网络所有。商业转载请联系官方授权,非商业转载请注明出处。

解题思路:

状态变量dp[i][j]表示用i个骰子得到的点数总和为j的方法总数;

因为一个骰子能够投掷出的点数的情况为f种,对于dp[i][j],要求得dp[i][j]的方法数,可以通过以下状态转移方程求得:

d p [ i ] [ j ] = d p [ i − 1 ] [ j − 1 ] + d p [ i − 1 ] [ j − 2 ] + . . . + d p [ i − 1 ] [ j − n ] ( j > = n ) dp[i][j] = dp[i-1][j-1] + dp[i-1][j-2] + ... + dp[i-1][j-n](j>=n) dp[i][j]=dp[i1][j1]+dp[i1][j2]+...+dp[i1][jn](j>=n)

因此可以得到C++代码如下:

class Solution {
     
public:
    int numRollsToTarget(int d, int f, int target) {
     
        vector<int> dp(target+1);  #用于存储状态变量,为了方便和从1开始的骰子点数配合,变量设置为target+1
        for(int i=1;i<=target;++i)   #初始化状态变量值,当只有一个骰子时的所有情况
        {
     
            if(i<=f)  #如果需要求的总点数小于等于骰子的点数,则将dp[i]设置为1
                dp[i] = 1;
            else    #如果需要求的总点数大于骰子的点数,则将dp[i]设置为0
                dp[i] = 0;
        }
        for(int i=2;i<=d;i++)  #从第二个骰子开始使用动态转移方程
        {
     
            for(int j=min(i*f,target);j>0;j--)  #两个骰子的最大可能取值的值为i*f,同时也有可能target小于i*f,因此取两者之间的较小值,这样可以减小程序的运行时间
            {
     
                dp[j]=0;  #这里必须将dp[i]重新设置为0,否则会导致错误,可以理解为当要求i个骰子取得j值的方法个数时,首先需要将方法数初始化为0
                for(int k=1;k<=f;k++)  #这里使用动态转移方程
                {
     
                    if(j-k>0)
                        dp[j] = (dp[j] + dp[j-k]) % 1000000007;
                }
            }
        }
        return dp[target];
    }
};

上面的C++代码中使用的是一维数组,如果想更好地理解,可以看下面的使用二维数组的C++代码:

class Solution {
     
public:
    int numRollsToTarget(int d, int f, int target) {
     
        vector<vector<int>> dp(d+1,vector<int>(target+1));  #建立二维数组用于存储状态变量
        for(int i=1;i<=target;++i)  #初始化状态变量
        {
     
            if(i<=f)
                dp[1][i] = 1;
            else
                dp[1][i] = 0;
        }
        for(int i=2;i<=d;i++)  #使用动态转移方程
        {
     
            for(int j=1;j<=min(target,i*f);j++)
            {
     
                for(int k=1;k<=f;k++)
                {
     
                    if(j-k>0)
                        dp[i][j] = (dp[i][j] + dp[i-1][j-k]) % 1000000007;
                }
            }
        }
        return dp[d][target];  #返回d个骰子掷出target点数的方法的个数
    }
};

你可能感兴趣的:(LeetCode算法题)