n个骰子的点数

求n个骰子朝上一面的点数和s

求s所有值出现的概率
n个骰子的最大值为6n，最小值为n，n个骰子排列组合为6^n，统计每个点数的次数，然后除以6的n次方才能得到概率
如果递归来思考，把骰子分成两堆，一堆为1个，另一堆为n-1个，所以计算这个骰子分别出现1到6再加上f（n-1）的和s。
定义一个长度为6n-n+1的数组来保存和s的次数，然后递归遍历每一个和s，出现则加上。最后循环数组算出概率。
递归求和的过程是每一个和s都是由所有n个骰子相加得到的，一开始和s等于的是第一个单独的骰子的点数，然后加上下一个骰子的点数。一直循环到只剩最后一个骰子算出这种情况的s，并在数组的这个位置加1。
第二种求的方法是利用循环。用两个数组来存储骰子点数的每个s出现的次数。首先是只有一个骰子，此时就是和为1到6的次数都为1，循环赋值给第一个数组来表示前一个骰子存储的值。
然后从i等于2也就是有两个骰子时开始算一直循环到n个骰子。在循环中给第二个数组赋值当前骰子的值从0到6k，从0到i这段次数都为0（因为有两个骰子，所以这段不可能有次数），从i到6k这一段，此时的和s可以由上一轮中arr[i-1],arr[i-2]一直到arr[i-6]加起来得到，因为这都是它可能出现的次数。
在赋值完这个之后在下一次循环中把这个数组当成上次的数组，把第一个数组当成上一次的数组进行赋值。就是弄一个arr[][]来存储，用flag和1-flag来表示此时操作的是哪个数组。

public class N个骰子的点数{
    private static final int sDiceMaxValue = 6;

    public static void PrintProbability(int diceNumber) {
        if (diceNumber <= 0) {
            return;
        }

        int[][] probabilities = new int[2][sDiceMaxValue * diceNumber + 1];
        int flag = 0;

        // 只有一个骰子的时候我们将各个和的值都初始化为1
        for (int i = 1; i <= sDiceMaxValue; i++) {
            probabilities[flag][i] = 1;
        }

        for (int k = 2; k <= diceNumber; k++) {
            // 1-flag表示当前我们需要计算的k个骰子的点数和
            for (int i = 0; i < k; i++) {
                probabilities[1 - flag][i] = 0; // 当有k个节点的时候得到的和不可能是小于k的
            }
            for (int i = k; i <= sDiceMaxValue * k; i++) {
                probabilities[1 - flag][i] = 0;
                for (int j = 1; j <= i && j <= sDiceMaxValue; j++) {
                    probabilities[1 - flag][i] += probabilities[flag][i - j];
                }
            }
            flag = 1 - flag;
        }
        double total = Math.pow(sDiceMaxValue, diceNumber);
        for (int i = diceNumber; i <= sDiceMaxValue * diceNumber; i++) {
            System.out.println(probabilities[flag][i] / total);
        }
    }

    public static void main(String[] args) {
        PrintProbability(11);
    }
}