60. n 个骰子的点数【难】

已于 2024-09-12 23:24:32 修改
阅读量461 收藏 6
点赞数 10
文章标签： 算法
于 2024-09-12 23:18:57 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_42889517/article/details/142153396
版权

comments: true
difficulty: 简单
edit_url: https://github.com/doocs/leetcode/edit/main/lcof/%E9%9D%A2%E8%AF%95%E9%A2%9860.%20n%E4%B8%AA%E9%AA%B0%E5%AD%90%E7%9A%84%E7%82%B9%E6%95%B0/README.md

面试题 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]

 

限制：

1 <= n <= 11

解法

1.题目不太好理解，可以先看这个题：https://www.acwing.com/problem/content/76/
2.促进一点理解的题解：https://leetcode.cn/problems/nge-tou-zi-de-dian-shu-lcof/solutions/637778/jian-zhi-offer-60-n-ge-tou-zi-de-dian-sh-z36d/

方法一：动态规划

我们定义 f [ i ] [ j ] f[i][j] f[i][j] 表示投掷 i i i 个骰子，点数和为 j j j 的方案数。那么我们可以写出状态转移方程：

f [ i ] [ j ] = ∑ k = 1 6 f [ i − 1 ] [ j − k ] f[i][j] = \sum_{k=1}^6 f[i-1][j-k] f[i][j]=k=1∑6​f[i−1][j−k]

其中 k k k 表示当前骰子的点数，而 f [ i − 1 ] [ j − k ] f[i-1][j-k] f[i−1][j−k] 表示投掷 i − 1 i-1 i−1 个骰子，点数和为 j − k j-k j−k 的方案数。

初始条件为 f [ 1 ] [ j ] = 1 f[1][j] = 1 f[1][j]=1，表示投掷一个骰子，点数和为 j j j 的方案数为 1 1 1。

最终，我们要求的答案即为 f [ n ] [ j ] 6 n \frac{f[n][j]}{6^n} 6nf[n][j]​，其中 n n n 为骰子个数，而 j j j 的取值范围为 [ n , 6 n ] [n, 6n] [n,6n]。

时间复杂度 O ( n 2 ) O(n^2) O(n2)，空间复杂度 O ( 6 n ) O(6n) O(6n)。其中 n n n 为骰子个数。

Python3
class Solution:
    def dicesProbability(self, n: int) -> List[float]:
        f = [[0] * (6 * n + 1) for _ in range(n + 1)] #最大情况：投掷n个骰子，最大和为6n
        for j in range(1, 7):
            f[1][j] = 1 #投掷1个骰子，各个和的方案数都是1
            
        for i in range(2, n + 1):
            for j in range(i, 6 * i + 1): #1)投掷i个筛子，和的范围为[i,6*i]
                for k in range(1, 7): #2）核心递推：方案数的累加
                    if j - k >= 0:
                        f[i][j] += f[i - 1][j - k]
        m = pow(6, n) #3)n个骰子的总方案数
        return [f[n][j] / m for j in range(n, 6 * n + 1)]
Java
class Solution {
    public double[] dicesProbability(int n) {
        int[][] f = new int[n + 1][6 * n + 1];
        for (int j = 1; j <= 6; ++j) {
            f[1][j] = 1;
        }
        for (int i = 2; i <= n; ++i) {
            for (int j = i; j <= 6 * i; ++j) {
                for (int k = 1; k <= 6; ++k) {
                    if (j >= k) {
                        f[i][j] += f[i - 1][j - k];
                    }
                }
            }
        }
        double m = Math.pow(6, n);
        double[] ans = new double[5 * n + 1];
        for (int j = n; j <= 6 * n; ++j) {
            ans[j - n] = f[n][j] / m;
        }
        return ans;
    }
}
C++
class Solution {
public:
    vector<double> dicesProbability(int n) {
        int f[n + 1][6 * n + 1];
        memset(f, 0, sizeof f);
        for (int j = 1; j <= 6; ++j) {
            f[1][j] = 1;
        }
        for (int i = 2; i <= n; ++i) {
            for (int j = i; j <= 6 * i; ++j) {
                for (int k = 1; k <= 6; ++k) {
                    if (j >= k) {
                        f[i][j] += f[i - 1][j - k];
                    }
                }
            }
        }
        vector<double> ans;
        double m = pow(6, n);
        for (int j = n; j <= 6 * n; ++j) {
            ans.push_back(f[n][j] / m);
        }
        return ans;
    }
};
Go
func dicesProbability(n int) (ans []float64) {
	f := make([][]int, n+1)
	for i := range f {
		f[i] = make([]int, 6*n+1)
	}
	for j := 1; j <= 6; j++ {
		f[1][j] = 1
	}
	for i := 2; i <= n; i++ {
		for j := i; j <= 6*i; j++ {
			for k := 1; k <= 6; k++ {
				if j >= k {
					f[i][j] += f[i-1][j-k]
				}
			}
		}
	}
	m := math.Pow(6, float64(n))
	for j := n; j <= 6*n; j++ {
		ans = append(ans, float64(f[n][j])/m)
	}
	return
}
JavaScript
/**
 * @param {number} n
 * @return {number[]}
 */
var dicesProbability = function (n) {
    const f = Array.from({ length: n + 1 }, () => Array(6 * n + 1).fill(0));
    for (let j = 1; j <= 6; ++j) {
        f[1][j] = 1;
    }
    for (let i = 2; i <= n; ++i) {
        for (let j = i; j <= 6 * i; ++j) {
            for (let k = 1; k <= 6; ++k) {
                if (j >= k) {
                    f[i][j] += f[i - 1][j - k];
                }
            }
        }
    }
    const ans = [];
    const m = Math.pow(6, n);
    for (let j = n; j <= 6 * n; ++j) {
        ans.push(f[n][j] / m);
    }
    return ans;
};
C#
public class Solution {
    public double[] DicesProbability(int n) {
        int[,] f = new int[n + 1, 6 * n + 1];

        for (int j = 1; j <= 6; ++j) {
            f[1, j] = 1;
        }

        for (int i = 2; i <= n; ++i) {
            for (int j = i; j <= 6 * i; ++j) {
                for (int k = 1; k <= 6; ++k) {
                    if (j >= k) {
                        f[i, j] += f[i - 1, j - k];
                    }
                }
            }
        }

        double m = Math.Pow(6, n);
        double[] ans = new double[5 * n + 1];

        for (int j = n; j <= 6 * n; ++j) {
            ans[j - n] = f[n, j] / m;
        }

        return ans;
    }
}
Swift
class Solution {
    func dicesProbability(_ n: Int) -> [Double] {
        var f = Array(repeating: Array(repeating: 0, count: 6 * n + 1), count: n + 1)
        for j in 1...6 {
            f[1][j] = 1
        }
        if n > 1 {
            for i in 2...n {
                for j in i...(6 * i) {
                    for k in 1...6 {
                        if j >= k {
                            f[i][j] += f[i - 1][j - k]
                        }
                    }
                }
            }
        }
        var m = 1.0
        for _ in 0..<n {
            m *= 6.0
        }
        var ans = Array(repeating: 0.0, count: 5 * n + 1)
        for j in n...(6 * n) {
            ans[j - n] = Double(f[n][j]) / m
        }
        return ans
    }
}

方法二：动态规划（空间优化）

我们可以发现，上述方法中的 f [ i ] [ j ] f[i][j] f[i][j] 的值仅与 f [ i − 1 ] [ j − k ] f[i-1][j-k] f[i−1][j−k] 有关，因此我们可以使用滚动数组的方式，将空间复杂度优化至 O ( 6 n ) O(6n) O(6n)。

Python3
class Solution:
    def dicesProbability(self, n: int) -> List[float]:
        f = [0] + [1] * 6
        for i in range(2, n + 1):
            g = [0] * (6 * i + 1)
            for j in range(i, 6 * i + 1):
                for k in range(1, 7):
                    if 0 <= j - k < len(f):
                        g[j] += f[j - k]  #仅仅与投掷n-1个骰子的方案数 数组有关
            f = g
        m = pow(6, n)
        return [f[j] / m for j in range(n, 6 * n + 1)]
Java
class Solution {
    public double[] dicesProbability(int n) {
        int[] f = new int[7];
        Arrays.fill(f, 1);
        f[0] = 0;
        for (int i = 2; i <= n; ++i) {
            int[] g = new int[6 * i + 1];
            for (int j = i; j <= 6 * i; ++j) {
                for (int k = 1; k <= 6; ++k) {
                    if (j - k >= 0 && j - k < f.length) {
                        g[j] += f[j - k];
                    }
                }
            }
            f = g;
        }
        double m = Math.pow(6, n);
        double[] ans = new double[5 * n + 1];
        for (int j = n; j <= 6 * n; ++j) {
            ans[j - n] = f[j] / m;
        }
        return ans;
    }
}
Go
func dicesProbability(n int) (ans []float64) {
	f := make([]int, 7)
	for i := 1; i <= 6; i++ {
		f[i] = 1
	}

	for i := 2; i <= n; i++ {
		g := make([]int, 6*i+1)
		for j := i; j <= 6*i; j++ {
			for k := 1; k <= 6; k++ {
				if j-k >= 0 && j-k < len(f) {
					g[j] += f[j-k]
				}
			}
		}
		f = g
	}

	m := math.Pow(6, float64(n))
	for j := n; j <= 6*n; j++ {
		ans = append(ans, float64(f[j])/m)
	}
	return
}
JavaScript
/**
 * @param {number} num
 * @return {number[]}
 */
var dicesProbability = function (n) {
    let f = Array(7).fill(1);
    f[0] = 0;
    for (let i = 2; i <= n; ++i) {
        let g = Array(6 * i + 1).fill(0);
        for (let j = i; j <= 6 * i; ++j) {
            for (let k = 1; k <= 6; ++k) {
                if (j - k >= 0 && j - k < f.length) {
                    g[j] += f[j - k];
                }
            }
        }
        f = g;
    }

    const ans = [];
    const m = Math.pow(6, n);
    for (let j = n; j <= 6 * n; ++j) {
        ans.push(f[j] / m);
    }
    return ans;
};
C#
public class Solution {
    public double[] DicesProbability(int n) {
        int[] f = new int[7];
        for (int i = 1; i <= 6; ++i) {
            f[i] = 1;
        }
        f[0] = 0;

        for (int i = 2; i <= n; ++i) {
            int[] g = new int[6 * i + 1];
            for (int j = i; j <= 6 * i; ++j) {
                for (int k = 1; k <= 6; ++k) {
                    if (j - k >= 0 && j - k < f.Length) {
                        g[j] += f[j - k];
                    }
                }
            }
            f = g;
        }

        double m = Math.Pow(6, n);
        double[] ans = new double[5 * n + 1];
        for (int j = n; j <= 6 * n; ++j) {
            ans[j - n] = f[j] / m;
        }
        return ans;
    }
}
常某某的好奇心
关注
  • 10
    点赞
  • 踩
  • 6
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
剑指offer实践 ——60.n个骰子的点数（python版)
weixin_41651734的博客
04-19 591
文章目录题目一、递归二、动态规划 题目 n个骰子的点数 一、递归 二、动态规划 假设投第一个骰子，可能的点数和为：1，2，3，4，5，6，概率都为1/6 投第二个骰子，可能的点数和为2～12 点数和为2，第一个骰子只能为1， 第二个骰子也只能为1，概率=1/6^2 点数和为3，第一个骰子可以为1，2，第二个骰子分别为2，1， 概率=2*1/6^2 点数和为4，第一个骰子可以为1，2，3，第二个骰子分别为3，2，1，概率= 3*1/6^2 点数和为5，第一个骰子可以为1，2，3，4，第二个骰子分
剑指 Offer 60. n个骰子的点数（概率DP）
祝如愿的博客
02-25 90
剑指 Offer 60. n个骰子的点数：n个骰子所能掷出的点数之和的所有可能性的概率。
【剑指Offer】60. n个骰子的点数
Do Better
08-07 261
思路 第一步：定义数组元素的含义 dp[i][j]，表示投掷完i枚骰子后，点数j的出现次数 第二步：找出关系数组元素间的关系式 最后一个阶段也就是投掷完 n 枚骰子后的这个阶段，我们用dp[n][j] 来表示最后一个阶段点数 j 出现的次数。 单单看第 n 枚骰子，它的点数可能为 1 , 2, 3, ... , 6 ，因此投掷完 n 枚骰子后点数 j 出现的次数，可以由投掷完 n-1 枚骰子后，对应点数 j-1, j-2, j-3, ... , j-6 出现的次数之和转化过来。因此，第i枚骰子投掷后，出现的
剑指 Offer 60. n个骰子的点数
庄小焱
03-12 183
例如，若希望递推计算 f(2,2) ，由于一个骰子的点数和范围为 [1,6]，因此只应求和 f(1,1)，即 f(1,0) , f(1,−1) , ... , f(1,−4) 皆无意义。同理，当此骰子为 2时，前n−1 个骰子应为 x−2；根据以上分析，得知通过子问题的解f(n−1) 可递推计算出 f(n)，而输入一个骰子的解 f(1)已知，因此可通过解 f(1)依次递推出任意解 f(n)。假设已知n−1个骰子的解 f(n−1)，此时添加一枚骰子，求n个骰子的点数和为x 的概率f(n,x)。
60. n个骰子的点数
YouMing_Li的博客
03-13 492
文章目录剑指 Offer 60. n个骰子的点数解题思路Java代码 剑指 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.0
剑指offer60.n个骰子的点数（动态规划）
华辰烟雨的博客
08-04 244
题目： 把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...
《剑指Offer》刷题笔记——面试题60. n给骰子的点数
01-20
def twoSum(self, n: int) -> List[float]: if n==1: s = 6**1 return [round(1/s,5) for i in range(6)] def func(n:int): if n==1: #递归终止条件 return {key:1 for key in range(1,7)}
ZhuoZhuoCrayon#CS-Notes#60. n 个骰子的点数1
07-25
j++) /* 使用 i 个骰子最小点数为 i */final double totalNum = Math.pow(6, n);/* 旋转标记 *//* 旋转
剑指 Offer 60. n个骰子的点数（python+java）
cy_believ的博客
07-12 327
思路: 采用动态规求解，有以下理解： 状态转移方程： 把n个骰子分为第n个骰子和前n-1个骰子，求n个骰子的点数和S，等于第n个骰子的点数m+(S - m),s-m表示前n-1个骰子的点数和为s-m； 因此求n个骰子的点数和的公式如下所示： n表示n个骰子，j表示n个骰子取得的点数和，i表示第n骰子的点数； 初始化操作： 一个骰子的时候点数为1到6，出现的和也为1到6；因此次数均为1； 注意的点： n个骰子的和，其值最小为n, 最大为6*n+1，且是连续的，间隔为1； 骰子的个数从1开始，因此dp[0].
dp算法练习【7】
MADAO的博客
09-08 1255
给你一个按排序的整数数组nums，返回组成的新数组，要求也按排序。平方后，数组变为 [16,1,0,9,100]排序后，数组变为 [0,1,9,16,100]非常简单，思路平方后排序。优化：插入法。
树状数组记录
volcan的博客
09-06 714
树状数组（Fenwick Tree）是一种用于维护数组前缀和的数据结构，支持高效的单点更新和区间查询操作。它的查询和更新时间复杂度为Ologn，适用于需要频繁更新和查询的场景。
【Python 千题 —— 算法篇】寻找两个正序数组的中位数
繁依Fanyi的博客
09-07 1234
合并排序法：易于理解，但时间复杂度较高，适合小规模数据。双指针法：通过双指针合并数组，时间复杂度 O(m + n)，适合中等规模数据。二分查找法：通过二分查找，在较短数组上进行划分，时间复杂度为 O(log(min(m, n)))，是处理大规模数据的最佳选择。对于这种涉及高效搜索和排序的题目，掌握二分查找的应用至关重要。通过本题目，我们不仅能够提升对数组和中位数的理解，还能够学到如何优化时间复杂度，使算法在处理大规模数据时更加高效。
专题一_双指针_算法专题详细总结
2301_80636070的博客
09-06 977
利用双指针，cur=0，dest=-1，只要nums[cur]==0 dest就走两格；否则 dest走一格；但是无论怎么样cur都走一格。直到dest到达结尾处n-1 停止，即 判断dest>=n-1 处 break；
洛谷刷题之B2089 数组逆序重存放
resco的博客
09-07 1144
洛谷刷题之B2089 数组逆序重存放
算法练习题22——解码
最新发布
hello77的blogggg 祝你得偿所愿
09-11 243
小明有一串很长的英文字母，其中可能包含大写和小写字母。在这串字母中，有很多字母是连续且重复的。为了压缩这串字母的表达形式，小明决定将连续相同的字母用“字母 + 出现次数”的形式表示。
算法 | 基础 | 出现奇数次的数字
蘑菇蘑菇不会开花的专栏
09-07 679
本篇是关于异或（）运算的运用。后期看算法过程中如果再碰到异或的都会收录到本篇中。
优先级队列：295. 数据流的中位数
li209779的博客
09-05 927
本题是我对写题的思路总结295.数据流的中位数以上就是我对于如何使用优先级队列来处理数据流的中位数。
一天一道算法题day02
m0_74004434的博客
09-06 1219
对于 mm 个数组对 (c[i],b)(c[i],b)，即 (c[1],b),(c[2],b),…,(c[m],b)(c[1],b),(c[2],b),…,(c[m],b) ，根据前面的问题要求，分别计算出它们的答案，最后，你要给出所有答案的总和。注意，数组 c[i]c[i] 是从 aa 数组转化而来的。现在，你需要找到最小的操作次数，使得对于所有的 1≤i≤k1≤i≤k ，都有 ai<biai​<bi​。对于每个测试样例，第一行包含两个整数 n,m，表示数组 a,b的大小，以及元素 a1值的上限。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值