[230525 剑指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
二 整体思路
最容易想到的是暴力法:一个骰子有 6 种点数组合,两个骰子有 6 ^ 2 种点数组合,则 n 个骰子有 6 ^ n 种点数组合;对每一个点数组合进行相加,得到结果和,然后对相同的结果和进行统计,除以 6 ^ n,就可以得到每一种结果的概率。这样做的时间复杂度是 O(6 ^ n),n 最大为 11,这个时间复杂度是不可接受的。
要求 n 个骰子的结果概率,可以用动态规划的方法,通过 n - 1 个骰子的结果概率来求。具体的方法是,当求 n 个骰子的结果概率时,固定 n - 1 个骰子结果为 x,利用 n - 1 个骰子结果为 x 的概率乘以 1 / 6,分别计算 x + 1、x + 2、… 一直到 x + 6 的结果概率。从 n 个骰子的角度来说,n 个骰子的某一个结果的概率不是一次性算出的,而是通过累加得到的。
三 关键点/重点/难点
难点在递推公式,如上。
四 代码分析
class Solution {
public:
//n -> 6 * n:对于n个骰子,结果总共有(6 * n - n + 1)种可能
vector<double> dicesProbability(int n) {
vector<double> dp(6, 1.0 / 6.0);
//dp[i]:对于n个骰子,结果为n+i的概率为dp[i]
//初始化为:当n为1时,结果为1-6的概率均是1/6
//遍历骰子个数,当前有k个骰子
for(int k = 2; k <= n; ++k) {
vector<double> tmp(5 * k + 1, 0.0);
//遍历有k-1个骰子时的所有结果
for(int i = 0; i < dp.size(); ++i) {
//当第k个骰子的结果为1、2、3、4、5、6时,计算对应的概率
for(int j = 0; j < 6; ++j) {
//使用加法:从k-1个骰子的各结果,
//推得各结果+1、+2、+3、+4、+5、+6的结果,对tmp的各结果进行累加
tmp[i + j] += dp[i] * (1.0 / 6.0);
//tmp记录k个骰子的结果,dp记录k-1个骰子的结果
//tmp[i + j]是k个骰子和为(k + i + j)的概率
//dp[i]是(k-1)个骰子和为(k - 1 + i)的概率
}
}
dp = tmp;
}
return dp;
}
};
(五)一题多解
无
(六) 知识扩展
C++ 中 vector 的直接赋值:
当两个 vector 容器中存放的类型是相同的的时候,是可以直接赋值的。
下面实现一下 vector 赋值符号的重载。(两个点)
- 传统写法中的深浅拷贝
- 现代写法的妙处
传统写法:
// 传统写法
vector<valueType>& operator=(const vector<valueType>& obj){
// 判断是否给自己赋值
if (this == &obj){
return *this;
}
//释放旧空间
delete[] _start;
//开辟新空间
//_start = (valueType*)calloc(obj.capacity(), sizeof(valueType));
_start = new valueType[obj.capacity()];
_finish = _start + obj.size();
_endOfStorage = _start + obj.capacity();
//浅拷贝
memcpy(_start, obj._start, sizeof(obj) * obj.size());
return *this;
}
上面的写法是 memcpy 的浅拷贝,我们使用for循环自己进行深拷贝:
思考:memcpy 执行位复制,是浅拷贝,浅拷贝会带来什么问题呢?
- 如果 vector 容器中所装载的是 int 这样的内置类型,那么 memcpy 时就会直接复制整型值,不会出现问题。
- 但如果 vector 容器中所装载的是 string 这样的复杂类型,string 类成员是指针类型,那么 memcpy 在复制时复制的只是 string 的类成员的值,也就是指针的值。当 rhs 被释放时,指针所指向的内存空间被释放,那么当 lhs 再去访问时,程序就会崩溃了。
- 所以我们要使用 for 循环来进行深拷贝,这个重载的赋值运算符也会对 string 类进行深拷贝,就不会出现访问非法内存的问题。
// 传统写法
vector<valueType>& operator=(const vector<valueType>& obj){
// 判断是否给自己赋值
if (this == &obj){
return *this;
}
//释放旧空间
delete[] _start;
//开辟新空间
//_start = (valueType*)calloc(obj.capacity(), sizeof(valueType));
_start = new valueType[obj.capacity()];
_finish = _start + obj.size();
_endOfStorage = _start + obj.capacity();
//深拷贝
//memcpy(_start, obj._start, sizeof(obj) * obj.size());
for (size_t i = 0; i < obj.size(); i++){
_start[i] = obj._start[i];
}
return *this;
}
现代写法:这种写法很巧妙地使用了传值传参需要进行拷贝构造的特点,利用这一点在传参的时候就可以深拷贝出来一个 obj,这样进行交换的时候就不会把原来的 obj 更改。
// 现代写法:把rhs以值的形式传参
// 当作参数传入函数的时候,自动调用了vector的拷贝构造函数拷贝生成一个“新的obj”
// 然后将“新的obj”swap到lhs
// 最后在离开重载赋值函数时,“新的obj”被自动销毁
vector<valueType>& operator=(vector<valueType> obj){
swap(obj);
return *this;
}
// 实现swap
void swap(vector<valueType>& tmp) {
std::swap(tmp._start, _start);
std::swap(tmp._finish, _finish);
std::swap(tmp._endOfStorage, _endOfStorage);
}