剑指offer-60

把n个骰子置于地上，所有骰子朝上一面的点数之和为S，输入N，打印出所有可能值出现的规律

每个骰子6种可能，n个骰子有6^n个结果，结果分为n~6n，统计每种结果出现的次数，即可算出概率

解法一：用递归，每次递归分成两组，直至最后一个骰子，次数+1，直至算出所有结果，可能会栈溢出，效率低下

解法二：通过骰子数递增来解决，如果是1个骰子会有1-6种情况，2个骰子有2-12种情况，3个骰子。。。记录当前骰子和出现的次数，每次递增一个骰子，用前一个骰子累加

如：

当前记录1个骰子时的结果 f(1)=1 f(2)=1 f(3)=1 f(4)=1 f(5)=1 f(6)=1

记录2个骰子结果，增加了一个骰子，结果数应该是只有一个骰子的结果+新骰子的结果，应满足g(n)=f(n-1)+f(n-2)+f(n-3)+f(n-4)+f(n-5)+f(n-6),分别代表了新骰子为1~6时的结果

g(1)=0 g(2)=f(2-1) g(3)=f(3-1)+f(3-2) g(4)=f(4-1)+f(4-2)+f(4-3)…

应该满足一个公式，当前n-1个骰子和结果已记录，即增加一个骰子后，新的n个骰子和满足f(n)=f(n-1)+f(n-2)+f(n-3)+f(n-4)+f(n-5)+f(n-6)，每一次结果都会用到上一层结果，应该避免重复计算，由下往上

解法一：
void PrintProbability_Solution3_core(int* tempArr, int tempArrLen, int currnumber, int* retArr, int retArrLen)//diy
{
	if (currnumber < 0)
	{
		int sum = 0;
		for (int i = 0; i < tempArrLen; i++)
			sum += tempArr[i];
		retArr[sum - tempArrLen]++;
		return;
	}

	for (int i = 1; i <= 6; i++)
	{
		tempArr[currnumber] = i;
		PrintProbability_Solution3_core(tempArr, tempArrLen, currnumber - 1, retArr, retArrLen);
	}
}
void PrintProbability_Solution3(int number)//diy
{
	if (number <= 0) return;
	int* retArr = new int[5*number + 1]();
	int* tempArr = new int[number]();

	PrintProbability_Solution3_core(tempArr,number, number-1, retArr, 5 * number + 1);
	int baseNum = 1;
	for (int i = 0; i < number;i++)
		baseNum *= 6;
	
	for (int i = 0; i < 5 * number + 1;i++)
	{
		printf("%d: %e\n", i + number, (double)retArr[i] /baseNum );
	}
	delete[] retArr;
	delete[] tempArr;

}

解法二：
void PrintProbability_Solution4(int Cnt, int DiceMaxNum)//diy
{
	if (Cnt <= 0) return;
	int* Arr[2];
	Arr[0] = new int[DiceMaxNum*Cnt + 1]();
	Arr[1] = new int[DiceMaxNum*Cnt + 1]();
	int currArr =0;
	for (int i = 1; i <= DiceMaxNum; i++)
		Arr[currArr][i] = 1;
	currArr = !currArr;
	for (int currDiceCnt = 2; currDiceCnt <= Cnt;currDiceCnt++)
	{
		int minSum = currDiceCnt;
		int maxSum = currDiceCnt*DiceMaxNum;
		for (int i = minSum; i <= maxSum;i++)
		{
			int currSum = 0;
			for (int tempDice = 1; tempDice <= DiceMaxNum;tempDice++)
			{
				if (i-tempDice>0)
					currSum += Arr[!currArr][i - tempDice];
				else
					break;
			}
			Arr[currArr][i] = currSum;
		}
		currArr = !currArr;
	}
	currArr = !currArr;
	int baseNum = 1;
	int tempCnt = Cnt;
	while (tempCnt > 0)
	{
		baseNum *= DiceMaxNum;
		tempCnt--;
	}
	for (int i = Cnt; i <= DiceMaxNum*Cnt;i++)
		printf("%d: %e\n", i, (double)Arr[currArr][i] / baseNum);

	delete[] Arr[0];
	delete[] Arr[1];
}