题目描述
这里有 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 个面。
有 6 种方式得到总和为 7 的结果: 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 <= 301 <= target <= 1000
解法
方法一：动态规划
我们定义 $f[i][j]$ 表示使用 $i$ 个骰子，和为 $j$ 的方案数。那么我们可以得到状态转移方程：
$$
f[i][j] = \sum_{h=1}^{\min(j, k)} f[i-1][j-h]
$$
其中 $h$ 表示第 $i$ 个骰子的点数。
初始时 $f[0][0] = 1$，最终的答案即为 $f[n][target]$。
时间复杂度 $O(n \times k \times target)$，空间复杂度 $O(n \times target)$。
我们注意到，状态 $f[i][j]$ 只和 $f[i-1][]$ 有关，因此我们可以使用滚动数组的方式，将空间复杂度优化到 $O(target)$。
| class Solution:
def numRollsToTarget(self, n: int, k: int, target: int) -> int:
f = [[0] * (target + 1) for _ in range(n + 1)]
f[0][0] = 1
mod = 10**9 + 7
for i in range(1, n + 1):
for j in range(1, min(i * k, target) + 1):
for h in range(1, min(j, k) + 1):
f[i][j] = (f[i][j] + f[i - 1][j - h]) % mod
return f[n][target]
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15 | class Solution {
public int numRollsToTarget(int n, int k, int target) {
final int mod = (int) 1e9 + 7;
int[][] f = new int[n + 1][target + 1];
f[0][0] = 1;
for (int i = 1; i <= n; ++i) {
for (int j = 1; j <= Math.min(target, i * k); ++j) {
for (int h = 1; h <= Math.min(j, k); ++h) {
f[i][j] = (f[i][j] + f[i - 1][j - h]) % mod;
}
}
}
return f[n][target];
}
}
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17 | class Solution {
public:
int numRollsToTarget(int n, int k, int target) {
const int mod = 1e9 + 7;
int f[n + 1][target + 1];
memset(f, 0, sizeof f);
f[0][0] = 1;
for (int i = 1; i <= n; ++i) {
for (int j = 1; j <= min(target, i * k); ++j) {
for (int h = 1; h <= min(j, k); ++h) {
f[i][j] = (f[i][j] + f[i - 1][j - h]) % mod;
}
}
}
return f[n][target];
}
};
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16 | func numRollsToTarget(n int, k int, target int) int {
const mod int = 1e9 + 7
f := make([][]int, n+1)
for i := range f {
f[i] = make([]int, target+1)
}
f[0][0] = 1
for i := 1; i <= n; i++ {
for j := 1; j <= min(target, i*k); j++ {
for h := 1; h <= min(j, k); h++ {
f[i][j] = (f[i][j] + f[i-1][j-h]) % mod
}
}
}
return f[n][target]
}
|
1
2
3
4
5
6
7
8
9
10
11
12
13 | function numRollsToTarget(n: number, k: number, target: number): number {
const f = Array.from({ length: n + 1 }, () => Array(target + 1).fill(0));
f[0][0] = 1;
const mod = 1e9 + 7;
for (let i = 1; i <= n; ++i) {
for (let j = 1; j <= Math.min(i * k, target); ++j) {
for (let h = 1; h <= Math.min(j, k); ++h) {
f[i][j] = (f[i][j] + f[i - 1][j - h]) % mod;
}
}
}
return f[n][target];
}
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20 | impl Solution {
pub fn num_rolls_to_target(n: i32, k: i32, target: i32) -> i32 {
let _mod = 1_000_000_007;
let n = n as usize;
let k = k as usize;
let target = target as usize;
let mut f = vec![vec![0; target + 1]; n + 1];
f[0][0] = 1;
for i in 1..=n {
for j in 1..=target.min(i * k) {
for h in 1..=j.min(k) {
f[i][j] = (f[i][j] + f[i - 1][j - h]) % _mod;
}
}
}
f[n][target]
}
}
|
方法二
| class Solution:
def numRollsToTarget(self, n: int, k: int, target: int) -> int:
f = [1] + [0] * target
mod = 10**9 + 7
for i in range(1, n + 1):
g = [0] * (target + 1)
for j in range(1, min(i * k, target) + 1):
for h in range(1, min(j, k) + 1):
g[j] = (g[j] + f[j - h]) % mod
f = g
return f[target]
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17 | class Solution {
public int numRollsToTarget(int n, int k, int target) {
final int mod = (int) 1e9 + 7;
int[] f = new int[target + 1];
f[0] = 1;
for (int i = 1; i <= n; ++i) {
int[] g = new int[target + 1];
for (int j = 1; j <= Math.min(target, i * k); ++j) {
for (int h = 1; h <= Math.min(j, k); ++h) {
g[j] = (g[j] + f[j - h]) % mod;
}
}
f = g;
}
return f[target];
}
}
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18 | class Solution {
public:
int numRollsToTarget(int n, int k, int target) {
const int mod = 1e9 + 7;
vector<int> f(target + 1);
f[0] = 1;
for (int i = 1; i <= n; ++i) {
vector<int> g(target + 1);
for (int j = 1; j <= min(target, i * k); ++j) {
for (int h = 1; h <= min(j, k); ++h) {
g[j] = (g[j] + f[j - h]) % mod;
}
}
f = move(g);
}
return f[target];
}
};
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15 | func numRollsToTarget(n int, k int, target int) int {
const mod int = 1e9 + 7
f := make([]int, target+1)
f[0] = 1
for i := 1; i <= n; i++ {
g := make([]int, target+1)
for j := 1; j <= min(target, i*k); j++ {
for h := 1; h <= min(j, k); h++ {
g[j] = (g[j] + f[j-h]) % mod
}
}
f = g
}
return f[target]
}
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15 | function numRollsToTarget(n: number, k: number, target: number): number {
const f = Array(target + 1).fill(0);
f[0] = 1;
const mod = 1e9 + 7;
for (let i = 1; i <= n; ++i) {
const g = Array(target + 1).fill(0);
for (let j = 1; j <= Math.min(i * k, target); ++j) {
for (let h = 1; h <= Math.min(j, k); ++h) {
g[j] = (g[j] + f[j - h]) % mod;
}
}
f.splice(0, target + 1, ...g);
}
return f[target];
}
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22 | impl Solution {
pub fn num_rolls_to_target(n: i32, k: i32, target: i32) -> i32 {
let _mod = 1_000_000_007;
let n = n as usize;
let k = k as usize;
let target = target as usize;
let mut f = vec![0; target + 1];
f[0] = 1;
for i in 1..=n {
let mut g = vec![0; target + 1];
for j in 1..=target {
for h in 1..=j.min(k) {
g[j] = (g[j] + f[j - h]) % _mod;
}
}
f = g;
}
f[target]
}
}
|