携手创作，共同成长！这是我参与「掘金日新计划 · 8 月更文挑战」的第12天，点击查看活动详情
Leetcode : leetcode-cn.com/problems/ng…
GitHub : github.com/nateshao/le…
剑指 Offer 60. n个骰子的点数
题目描述 ：把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]
java
labuladong
// 自底向上的迭代解法
class Solution {
public double[] dicesProbability(int n) {
// n 个骰子可能扔出的结果的最大值和最小值
int min = n, max = n * 6;
// 定义：用 n 个骰子，凑出 point 的点数的概率是 dp[n][point]
double[][] dp = new double[n + 1][max + 1];
// base case，一个骰子扔出点数 1~6 的概率是 1/6
for (int j = 1; j <= 6; j++) {
dp[1][j] = 1 / 6.0;
}
// 状态转移
for (int i = 2; i <= n; i++) {
for (int j = i * 1; j <= i * 6; j++) {
for (int k = 1; k <= 6; k++) {
if (j - k <= 0) {
break;
}
// i 个骰子扔出点数 j 的概率
// 可以通过 i - 1 个骰子认出点数 j - k 的概率推倒出来
dp[i][j] += dp[i - 1][j - k] * 1 / 6.0;
}
}
}
double[] res = new double[max - min + 1];
for (int i = 0; i < res.length; i++) {
res[i] = dp[n][min + i];
}
return res;
}
}
// 自顶向下的递归解法
class Solution2 {
public double[] dicesProbability(int n) {
// n 个骰子可能扔出的结果的最大值和最小值
int min = n, max = n * 6;
memo = new double[n + 1][max + 1];
double[] res = new double[max - min + 1];
for (int i = 0; i < res.length; i++) {
res[i] = dp(n, min + i);
}
return res;
}
// 备忘录
double[][] memo;
// 定义：用 n 个骰子，抛出 point 点数的概率
double dp(int n, int point) {
// base case
if (point <= 0) {
return 0;
}
if (n == 1) {
if (point > 6) {
return 0;
}
return 1 / 6.0;
}
// 通过备忘录避免冗余计算
if (memo[n][point] != 0) {
return memo[n][point];
}
// 进行状态转移
double prob = 0;
for (int i = 1; i <= 6; i++) {
prob += dp(n - 1, point - i) * 1 / 6;
}
// 结果存入备忘录
memo[n][point] = prob;
return prob;
}
}
Go
func dicesProbability(n int) []float64 {
dp := make([][]float64, n)
for i := range dp{
dp[i] = make([]float64, (i + 1) * 6 - i)
}
for i := range dp[0]{
dp[0][i] = float64(1) / float64(6)
}
for i := 1; i < len(dp); i ++{
for j := range dp[i - 1]{
for k := range dp[0]{
dp[i][j + k] += float64(dp[i - 1][j]) * float64(dp[0][k])
}
}
}
return dp[n - 1]
}
方法一：暴力法
给定n个骰子，可得:
- 每个骰子摇到1至6的概率相等，都为1/6
- 将每个骰子的点数看作独立情况，共有6n种「 点数组合」。例如n = 2时的点数组合为： (1,1),(1,2)... ,(2, 1),(2,2),，.. ,(6,1),... ,(6,6)
- n个骰子「点数和」的范围为[n, 6n]，数量为6n-n+1=5n+ 1种。 暴力统计：每个「 点数组合」都对应一个「点数和」，考虑遍历所有点数组合,统计每个点数和的出现次数,最后除以点数组合的总数(即除以6n )，即呵得到每个点数和的出现概率。
如下图所际，为输入n=2时，点数组合、点数和、各点数概率的计算过程。
暴力法需要遍历所有点数组合，因此时间复杂度为 O(6^n) ，观察本题输入取值范围 1≤n≤11
方法二：动态规划
设输入 n个骰子的解（即概率列表）为 f(n) ，其中「点数和」 x 的概率为 f(n, x) 。
假设已知n - 1个骰子的解f(n - 1)，此时添加一枚骰子，求n个骰子的点数和为x的概率f(n, x) 当添加骰子的点数为1时，前n- 1个骰子的点数和应为x- 1，可组成点数和x ;同理，当此骰 子为2时,前n-1个骰子应为x- 2 ;以此类推，直至此骰子点数为6。将这6种情况的概率相加，即可得到概率f(n. x)。递推公式如下所示：
根据以上分析,知通过子问题的解f(n- 1)可递推计算出f(n)，而输入一个骰子的解f(1)已知,因此可通过解f(1)依次递推出任意解f(n)。如下图所际，为n=2,x= 7的递推计算示例。
观察发现，以上递推公式虽然可行，但f(n- 1,x- i)中的x- i会有越界问题。例如，若希望递推计 算f(2,2),由于一个骰子的点数和范围为[1,6] ，因此只应求和f(1,1)，即f(1,0)，f(1,-1)...f(1,-4)皆无意义。此越界问题导致代码编写的难度提升。
如下图所示，以上递推公式是“逆向”的，即为了计算f(n,x)，将所有与之有关的情况求和;而 倘若改换为“正向”的递推公式，可解决越界问题。
具体来看，由于新增骰子的点数只可能为1至6，因此概率f(n-1,x)仅与f(n,x+ 1), f(n,x + 2), ... f(n,x +6)相关。而，遍历f(n- 1)中各点数和的概率,并将其相加至f(n)中所有相关项，即可完成f(n- 1)至f(n)的递推。
将f(i)记为动态规划列表形式dp[i，则i= 1, 2, ... n的状态转移过程如下图所示。
复杂度分析：
- 时间复杂度O(n^2)
- 空间复杂度O(n)
代码：通常做法是声明一个二维数组dp，dp [i] [j] 代表前i个骰子的点数和j的概率,并执行状态转移。而 于dp[i]仅由dp[i-1]递推得出，为降低空间复杂度，只建立两个一维数组dp,tmp交替前进即可。
class Solution {
public double[] dicesProbability(int n) {
double[] dp = new double[6];
Arrays.fill(dp, 1.0 / 6.0);
for (int i = 2; i <= n; i++) {
double[] tmp = new double[5 * i + 1];
for (int j = 0; j < dp.length; j++) {
for (int k = 0; k < 6; k++) {
tmp[j + k] += dp[j] / 6.0;
}
}
dp = tmp;
}
return dp;
}
}
