【Leetcode】1155. Number of Dice Rolls With Target Sum

题目地址：

https://leetcode.com/problems/number-of-dice-rolls-with-target-sum/

有$d$个骰子，每个骰子有$f$个面，每个面是$1\sim f$，问其有多少个排列使得骰子之和恰好等于给定数$t$（这里顺序不同认为是不同的）。将答案模$10^9+7$后返回。

思路是动态规划。令$g[i][j]$是共$i+1$个骰子的情况下，和为$j$的排列数。那么按照最后一个骰子的情况，可知：$$g[i][j]=\sum _{k=1}^{f}g[i-1][j-k]$$初始条件$g[0][j]=1,j=1,2,...,f$，否则$g[0][j]=0$。代码如下：

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

时间复杂度$O(dtf)$，$t$是target，空间$O(dt)$。

可以用滚动数组优化：

import java.util.Arrays;

public class Solution {
    public int numRollsToTarget(int d, int f, int target) {
        if (target < d || target > d * f) {
            return 0;
        }
        
        int[][] dp = new int[2][target + 1];
        for (int i = 1; i <= Math.min(f, target); i++) {
            dp[0][i] = 1;
        }
        
        int MOD = (int) (1E9 + 7);
        
        for (int i = 1; i < d; i++) {
        	// 先要清零，不能把旧值留着
            Arrays.fill(dp[i & 1], 0);
            for (int j = i + 1; j <= target; j++) {
                for (int k = 1; k <= f; k++) {
                    if (j > k) {
                        dp[i & 1][j] += dp[i - 1 & 1][j - k];
                        dp[i & 1][j] %= MOD;
                    }
                }
            }
        }
        
        return dp[d - 1 & 1][target];
    }
}

时间复杂度不变，空间$O(t)$。