把n个骰子扔在地上,所有骰子朝上一面的点数之和为s。输入n,打印出s的所有可能的值出现的概率。
你需要用一个浮点数数组返回答案,其中第 i 个元素代表这 n 个骰子所能掷出的点数集合中第 i 小的那个的概率。
示例 1:
输入: 1
输出: [0.16667,0.16667,0.16667,0.16667,0.16667,0.16667]
示例 2:
输入: 2
输出: [0.02778,0.05556,0.08333,0.11111,0.13889,0.16667,0.13889,0.11111,0.08333,0.05556,0.02778]
限制:
1 <= n <= 11
题意:掷n次骰子,n次骰子之和为s,打印s所有可能的值出现的概率
说明:n个骰子,s的范围为:n -> 6 * n,因此需要开辟的数组大小为5 * n + 1。另外,一个骰子总共有6种情况,n个骰子就有,所以分母为
,我们就只需要计算分子即可,分子表示:和为s的掷法有几种。
思路:首先我们可能会想到一种暴力的方式,就是我一个骰子一个骰子掷,每个骰子都有1-6这6种情况,掷6次累加和为s时,对应的方法数就加一,掷完n次得到答案。
递归出口条件:当掷的骰子为第n个时,且和为s,则s对应的方法数+1
代码如下:
class Solution {
public int cnt = 0;
public double[] twoSum(int n) {
int sum = n * 5 + 1;
double[] res = new double[sum];
for (int i = n; i <= 6 * n; i++){
cnt = 0;
solve(n, 0, i);
res[i - n] = 1.0 * cnt / (Math.pow(6,n));
}
return res;
}
public void solve(int n, int cur, int target){
if(target < 0){
return;
}
if(cur == n){
if(target == 0){
cnt++;
}
return;
}
for(int i = 1; i <= 6; i++){
if(target - i < 0) return;
solve(n, cur+1, target - i);
}
}
}
上面这种方式可能会超时,中间重复的状态不知道计算了多少次。
仔细观察,我们会发现一个状态只与两个变量有关:n和s,即n和s确定后,答案可能唯一,这就无后效性,可以通过记忆化搜索和动态规划来优化。
首先将上面的递归方式修改一下,减少递归函数的参数。代码如下。
public class Solution {
public double[] twoSum(int n) {
int sum = n * 5 + 1;
double[] res = new double[sum];
for (int i = n; i <= 6 * n; i++){
int cnt = 0;
cnt = solve(n, i);
res[i - n] = 1.0 * cnt / (Math.pow(6,n));
}
return res;
}
public int solve(int n, int target){
if(n == 0){
if(target == 0){
return 1;
}
return 0;
}
int res = 0;
for(int i = 1; i <= 6; i++){
if(target - i < 0){
break;
}
res += solve(n - 1, target - i);
}
return res;
}
}
然后我们可以把所有计算过的(n, s)的值用Map存起来,这也是套路。两个参数使用下划线拼接在一起。
AC代码如下。【记忆化搜索】
HashMap<String, Integer> map = new HashMap<>();
public double[] twoSum(int n) {
int sum = n * 5 + 1;
double[] res = new double[sum];
for (int i = n; i <= 6 * n; i++){
int cnt = 0;
cnt = solve(n, i);
res[i - n] = 1.0 * cnt / (Math.pow(6,n));
}
return res;
}
public int solve(int n, int target){
if(n == 0){
if(target == 0){
return 1;
}
return 0;
}
int res = 0;
for(int i = 1; i <= 6; i++){
if(target - i < 0){
break;
}
String str = (n - 1) + "_" + (target - i);
if(!map.containsKey(str)){
res += solve(n - 1, target - i);
} else {
res += map.get(str);
}
}
map.put(n + "_" + target, res);
return res;
}
}
最后通过搭积木的方式,首先查看出口位置,即不需要依赖别的状态就可以得到答案的位置,然后找到一个特殊的位置,看一下它依赖上一行的哪些位置,计算出这个值,最后循环得到我们要的状态,也就是最初调用递归的n和s。
代码如下。【动态规划】
public class Solution {
public double[] twoSum(int n) {
double num = Math.pow(6, n);
double[] res = new double[5 * n + 1];
int[][] dp = new int[n + 1][6 * n + 1];
for (int i = 0; i <= 6 * n; i++) {
dp[0][i] = 0;
}
dp[0][0] = 1;
int cur = 0;
for(int i = 1; i <= n; i++){
dp[i][0] = 0;
for (int j = 1; j <= 6 * n; j++){
int sum = 0;
for (int k = 1; k <= 6; k++) {
if(j - k < 0) break;
sum += dp[i-1][j-k];
}
dp[i][j] = sum;
if(i == n && j >= n){
res[cur++] = 1.0 * sum / num;
}
}
}
return res;
}
}