面试题43：n个骰子的点数

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

分析：

（1）基于递归的方法

可以将n个骰子分为两堆，第一堆只有1个，第二个堆有n-1个，单独的那一个可能出现的1到6的点数，只需计算1到6的每一种和剩余的n-1个骰子的和，再将n-1个骰子分为1个和n-2个，如此递推，终止条件是最后只剩下一个骰子。代码中定义了6n-n+1长度的数组，和为S的点数保存在数组的下标为S-n的位置。

（2）基于循环的方法

采用两个数组来存储骰子的点数每一个出现的次数，在一次循环中，第一个数组中第n个数字表示骰子和为n出现的次数，在下一次循环中，我们加上一个新的骰子，此时和为n的骰子出现的次数应该为上一次循环中骰子和为n-1，n-2，n-3，n-4，n-5和n-6的次数的总和。例如当有2个骰子时

第一个数组：只有一个骰子的情况下

sum	1	2	3	4	5	6	7	8	9	10	11	12
次数	1	1	1	1	1	1	0	0	0	0	0	0

第二个数组：加了一个骰子时，更新的数据来源于第一个数组，例如和为7时，为第一个数组中和为6,5,4,3,2,1的次数的和，和为8，为第一个数组中和为7,6,5,4,3,2的和，得到5，以此类推。。。

sum	1	2	3	4	5	6	7	8	9	10	11	12
次数	0	1	2	3	4	5	6	5	4	3	2	1

源码：

/**
		* 功能说明：n和骰子的和出现的概率
		* 作者：K0713
		* 日期：2016-10-7
		**/
#include<iostream>
using namespace std;


int g_maxValue = 6;

// ====================方法一====================
void Probability(int number, int* pProbabilities);
void Probability(int original, int current, int sum, int* pProbabilities);

void PrintProbability_Solution1(int number)
{
	if (number < 1)
		return;

	int maxSum = number * g_maxValue;//最大值是6n
	int* pProbabilities = new int[maxSum - number + 1];
	for (int i = number; i <= maxSum; ++i)
		pProbabilities[i - number] = 0;//和为6n对应的数组位置是5n，

	Probability(number, pProbabilities);//统计出现的次数

	int total = pow((double)g_maxValue, number);//排列组合的全部情况
	for (int i = number; i <= maxSum; ++i)
	{
		double ratio = (double)pProbabilities[i - number] / total;
		cout << i << " : " << fixed << ratio << endl;
	}

	delete[] pProbabilities;
}

void Probability(int number, int* pProbabilities)
{
	for (int i = 1; i <= g_maxValue; ++i)//递归的计算各种情况
		Probability(number, number, i, pProbabilities);
}

void Probability(int original, int current, int sum, int* pProbabilities)
{
	if (current == 1)
	{
		pProbabilities[sum - original]++;
	}
	else
	{
		for (int i = 1; i <= g_maxValue; ++i)
		{
			Probability(original, current - 1, i + sum, pProbabilities);//
		}
	}
}

// ====================方法二====================
void PrintProbability_Solution2(int number)
{
	if (number < 1)
		return;

	int* pProbabilities[2];
	pProbabilities[0] = new int[g_maxValue * number + 1];
	pProbabilities[1] = new int[g_maxValue * number + 1];
	for (int i = 0; i < g_maxValue * number + 1; ++i)
	{
		pProbabilities[0][i] = 0;
		pProbabilities[1][i] = 0;
	}

	int flag = 0;//计算交替标志位，第二个数组更新完更新第一个数组，交替进行
	for (int i = 1; i <= g_maxValue; ++i)
		pProbabilities[flag][i] = 1;

	for (int k = 2; k <= number; ++k)
	{
		for (int i = 0; i < k; ++i)
			pProbabilities[1 - flag][i] = 0;

		for (int i = k; i <= g_maxValue * k; ++i)
		{
			pProbabilities[1 - flag][i] = 0;
			for (int j = 1; j <= i && j <= g_maxValue; ++j)
				pProbabilities[1 - flag][i] += pProbabilities[flag][i - j];//后面的数组的元素用前面的数组的值来更新
		}

		flag = 1 - flag;
	}

	double total = pow((double)g_maxValue, number);
	for (int i = number; i <= g_maxValue * number; ++i)
	{
		double ratio = (double)pProbabilities[flag][i] / total;
		cout << i << " : " <<fixed<< ratio << endl;
	}

	delete[] pProbabilities[0];
	delete[] pProbabilities[1];
}

int main()
{
	PrintProbability_Solution1(2);
	cout << "-------------------" << endl;
	PrintProbability_Solution2(3);
	system("PAUSE");
	return 0;
}