n 个骰子点数和及各自出现的概率

最新推荐文章于 2024-03-08 10:20:08 发布

恋喵大鲤鱼

最新推荐文章于 2024-03-08 10:20:08 发布

阅读量1.6w

点赞数 19

分类专栏：算法与数据结构

本文链接：https://blog.csdn.net/k346k346/article/details/50988681

版权

算法与数据结构专栏收录该内容

53 篇文章 31 订阅

订阅专栏

题目：
把 n 个骰子扔在地上，所有骰子朝上一面的点数之和为 S。输入 n，打印出S的所有可能的值出现的概率。

这道算法题可采取动态规划法来求解。鉴于《剑指Offer》中对该题的解法晦涩难懂，尤其是代码，也没有指明解题的思路本质上就是动态规划，所以提出自己的理解和答案。

动态规划法简介：
动态规划法求解的总体过程就是将问题分为多个不同的阶段的问题，根据最开始阶段已知的问题的解逐步推导出最终解。即动态规划算法通常基于一个递推公式及一个或多个初始状态。

过程细化为：
第一步，确定问题的解的表达式，称之为状态。
第二步，将最终问题的构造成上一阶段问题的解（可能被拆分为多个子问题的解），即根据当前阶段问题的解求出下一阶段问题的解方法，即递推公式，称之为状态转移方程。

已知初始状态的解，有了状态和状态转移方程，逐步递推，即可求出最终的解。

动态规划法求解过程可以使用递归来实现，也可以使用迭代来实现。递归的优势就是代码简洁明了，但是递归有时会对不同阶段的子问题重复求解，所以效率低于迭代。

解题思路：
第一步，确定问题解的表达式。可将f(n, s) 表示n个骰子点数的和为s的排列情况总数。
第二步，确定状态转移方程。n个骰子点数和为s的种类数只与n-1个骰子的和有关。因为一个骰子有六个点数，那么第n个骰子可能出现1到6的点数。所以第n个骰子点数为1的话，f(n,s)=f(n-1,s-1)，当第n个骰子点数为2的话，f(n,s)=f(n-1,s-2)，…，依次类推。在n-1个骰子的基础上，再增加一个骰子出现点数和为s的结果只有这6种情况！那么有：

f(n,s)=f(n-1,s-1)+f(n-1,s-2)+f(n-1,s-3)+f(n-1,s-4)+f(n-1,s-5)+f(n-1,s-6) ，0< n<=6n
f(n,s)=0,   s< n or s>6n

上面是状态转移方程，已知初始阶段的解为：

当 n = 1 时, f(1,1)=f(1,2)=f(1,3)=f(1,4)=f(1,5)=f(1,6)=1

代码实现：
递归版本：

#include <stdio.h>
#include <string.h>

#include <iostream>
using namespace std;

/****************************
func:获取n个骰子指定点数和出现的次数
para:n:骰子个数;sum:指定的点数和
return:点数和为sum的排列数
*****************************/
int getNSumCount(int n, int sum)
{
	if(n<1||sum<n||sum>6*n)
	{
		return 0;
	}
	if(n==1)
	{
		return  1;
	}
	int resCount=0;
	resCount=getNSumCount(n-1,sum-1)+getNSumCount(n-1,sum-2)+
			 getNSumCount(n-1,sum-3)+getNSumCount(n-1,sum-4)+
			 getNSumCount(n-1,sum-5)+getNSumCount(n-1,sum-6);
	return resCount;
}

//验证
int main()
{
	int n = 0;
	while(true)
	{
		cout<<"input dice num：";
		cin>>n;
		for(int i=n;i<=6*n;++i)
		{
			cout<<"f("<<n<<","<<i<<")="<<getNSumCount(n,i)<<endl;
		}
	}
}

当输入骰子的个数为3时，实验结果如下：
这里写图片描述
非递归迭代版本：

/****************************************
func:给定骰子数目n，求所有可能点数和的种类数
para：n:骰子个数;count:存放各种点数和的种类数，下标i表示点数和为（i+n）
return:出错返回-1，成功返回0
****************************************/
int getNSumCountNotRecusion(int n, int* count){
	if(n<1) return -1;
	
	// 初始化最初状态
	count[0]=count[1]=count[2]=count[3]=count[4]=count[5]=1;
	if(n==1) return 0;

	for(int i=2;i<=n;++i)
	{
		for(int sum=6*i;sum>=i;--sum)
		{
			int tmp1=((sum-1-(i-1))>=0?count[sum-1-(i-1)]:0); //上一阶段点数和sum-1的排列总数
			int tmp2=(sum-2-(i-1)>=0?count[sum-2-(i-1)]:0);
			int tmp3=(sum-3-(i-1)>=0?count[sum-3-(i-1)]:0);
			int tmp4(sum-4-(i-1)>=0?count[sum-4-(i-1)]:0);
			int tmp5=(sum-5-(i-1)>=0?count[sum-5-(i-1)]:0);
			int tmp6=(sum-6-(i-1)>=0?count[sum-6-(i-1)]:0);
			count[sum-i]=tmp1+tmp2+tmp3+tmp4+tmp5+tmp6;
		}
	}
	return 0;
}

//验证
int main()
{
	int n;
	while(true)
	{
		cout<<"iteration input dice num：";
		cin>>n;
		int* count=new int[5*n+1];
		memset(count,0,(5*n+1)*sizeof(int));
		getNSumCountNotRecusion(n,count);
		int allCount=0;
		for(int i=0;i<5*n+1;++i)
		{
			cout<<"f("<<n<<","<<i+n<<")="<<count[i]<<endl;
			allCount+=count[i];
		}
		delete[] count;
	}
}

当输入骰子个数为 3 时，所有可能的点数和的排列情况如下图：
这里写图片描述

小结
实验至此，给定 n 个骰子，求各个点数和出现的概率就不难求，只需要除以总的排列数 $6^n$ 就可以了。参考如下代码：

	// n 骰子数目
	int total = pow((float)6, n);
    for(int i = n; i <= 6*n; ++i)
    {
        float ratio = (float)getNSumCount(n,i)/total;  
        printf("%d: %f\n", i, ratio);  
    }