暑假刷题水题居多,多数都没有什么记录的价值,不过还是有题目是有必要写下来供自己以后复习的。
先上一题前几天写的题目
1155. 掷骰子的N种方法
这里有 d 个一样的骰子,每个骰子上都有 f 个面,分别标号为 1, 2, …, f。
我们约定:掷骰子的得到总点数为各骰子面朝上的数字的总和。
如果需要掷出的总点数为 target,请你计算出有多少种不同的组合情况(所有的组合情况总共有 f^d 种),模 10^9 + 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
应该第一眼就可以想到递归了,但是看一下数据 d f 在30 target在1000
甚至有的时候需要mod 10000000007这个数字,说明一定是非常非常大的计算量。
不存状态的递归一定是算不出来的,会超时的。
存状态可以在递归中存,也可以用动态规划。
我们先撸一下,寻常递归该怎么写
class Solution {
public int numRollsToTarget(int d, int f, int target) {
return dfs(d, f, target, 1);
}
public int dfs(int d, int f, int target, int index) {
if(index > d && target == 0)
return 1;
if(index > d || target < 0)
return 0;
int ans = 0;
for(int i = 1; i <= f; i ++) {
if(target >= i) {
ans += dfs(d, f, target - i, index + 1);
ans %= 1000000007;
}
}
return ans;
}
}
这样不难,加一个index条件限制到了d然后判定target == 0就行,意料之中的超时。
那就考虑用一个数组来存中间状态,这和动态规划的思想可以说是很像了。
这样的方法以前讲过。
class Solution {
public static final int[][] t = new int[31][1001];
public int numRollsToTarget(int d, int f, int target) {
for(int i = 0; i < 31; i ++) {
for(int j = 0; j < 1001; j ++)
t[i][j] = -1;
}
return dfs(d, f, target, 1);
}
public int dfs(int d, int f, int target, int index) {
if(index > d && target == 0)
return 1;
if(index > d || target < 0)
return 0;
if(t[index][target] != -1)
return t[index][target];
int ans = 0;
for(int i = 1; i <= f; i ++) {
if(target >= i) {
ans += dfs(d, f, target - i, index + 1);
ans %= 1000000007;
}
}
t[index][target] = ans;
return ans;
}
}
比动态规划稍慢。
class Solution {
public int numRollsToTarget(int d, int f, int target) {
int[][] dp = new int[d + 1][target + 1];
dp[0][0] = 1;
for(int i = 1; i <= d; i ++) {
for(int j = 1; j <= f; j ++) {
for(int k = 1; k <= target; k ++) {
if(k >= j)
dp[i][k] = (dp[i][k] + dp[i - 1][k - j]) % (int)(Math.pow(10, 9) + 7);
}
}
}
return dp[d][target];
}
}
动态规划的写法。