n个骰子的点数（暴力递归--记忆化搜索--动态规划）

题目描述：

把n个骰子扔在地上，所有骰子朝上一面的点数之和为s。输入n，打印出s的所有可能的值出现的概率。
你需要用一个浮点数数组返回答案，其中第 i 个元素代表这 n 个骰子所能掷出的点数集合中第 i 小的那个的概率
示例：
输入: 1
输出: [0.16667,0.16667,0.16667,0.16667,0.16667,0.16667]
输入: 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

暴力方法

• 首先对于有n个骰子，总共有Math.pow(6, n) 中可能的情况。 而且，所有可能出现的点数的情况总共有5n + 1。（例如对于 n = 3, 点数的情况是 3, 4,5, ··· , 18 ）
• 所以对于一种点数的情况，只要求出在点数为m时，在有n个骰子的情况下总共有多少种情况可以构成m个点数，之后再除以所有可能的情况即为当前点数的概率。
• 而对于有n个骰子总共有多少情况可以构成m个点数的情况，又可以转化为在有 n - 1 个骰子的情况下，构成 m - 1 点数的情况 + 构成 m - 2 点数的情况 + 构成 m - 3 点数的情况 + 构成 m - 4 点数的情况 + 构成 m - 5 点数的情况 + 构成 m - 6 点数的情况。 而针对于这种，可以使用递归来处理。递归出口为 n < 0 || 点数 < 0 时返回0， 而 n == 0 && 点数 == 0 时表示找到一种情况，返回1。

class Solution {
	public double[] dicesProbability(int n) {
        int possibility = 5 * n + 1;
        double total = Math.pow(6, n);
        double[] result = new double[possibility];
        for (int i = 0; i < possibility; i++) {
            int cur = process(n, i + n);
            result[i] = cur / total;
        }
        return result;
    }
    // n 表示骰子的个数  i 表示当前可能投出的点数
    private int process(int n, int i) {
        System.out.println(n + "\t" + i);
        if (n < 0 || i < 0) {
            return 0;
        }
        if (n == 0 && i == 0) {
            return 1;
        }
        int res = 0;
        for (int j = 1; j <= 6; j++) {
            res += process(n - 1, i - j);
        }
        return res;
    }
}

但是这种情况无法ac，超时。

记忆化搜索

对于暴力递归超时，可以在代码中加入傻缓存来保证不要重复计算。

• 而对于暴力递归的分析，process 方法的可变参数为两个， 分别为 n 和 i。 所以可以建立二维的傻缓存来避免重复计算。

class Solution {
	public double[] dicesProbability(int n) {

        int possibility = 5 * n + 1;
        double total = Math.pow(6, n);
        double[] result = new double[possibility];

        int[][] dp = new int[n + 1][6 * n + 1];
        for (int i = 0; i < n + 1; i++) {
            for (int j = 0; j < 6 * n + 1; j++) {
                dp[i][j] = -1;
            }
        }
        for (int i = 0; i < possibility; i++) {
            int cur = process(n, i + n, dp);
            result[i] = cur / total;
        }
        return result;
    }

    // n 表示骰子的个数  i 表示当前可能投出的点数
    private int process(int n, int i, int[][] dp) {
        if (n < 0 || i < 0) {
            return 0;
        }
        if (dp[n][i] != -1) {
            return dp[n][i];
        }
        if (n == 0 && i == 0) {
            dp[n][i] = 1;
            return dp[n][i];
        }
        int res = 0;
        for (int j = 1; j <= 6; j++) {
            res += process(n - 1, i - j, dp);
        }
        dp[n][i] = res;
        return dp[n][i];
    }

}

动态规划

由暴力递归可以得到动态转移方程为：
dp[n][i] = dp[n - 1][i - 1] + dp[n - 1][i - 2] + dp[n - 1][i - 3] + dp[n - 1][i - 4] + dp[n - 1][i - 5] + dp[n - 1][i - 6]
举例：n = 2 （第一行与第一列均为下标）

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

class Solution {

	public double[] dicesProbability(int n) {
        int possibility = 5 * n + 1;
        double total = Math.pow(6, n);

        int[][] dp = new int[n + 1][6 * n + 1];
        dp[0][0] = 1;

        for (int i = 1; i < n + 1; i++) {
            for (int j = 1; j < 6 * n + 1; j++) {
                int cur = 0;
                for (int k = 1; k <= 6; k++) {
                    if (j - k >= 0) {
                        cur += dp[i - 1][j - k];
                    }
                }
                dp[i][j] = cur;
            }
        }

        double[] result = new double[possibility];
        for (int i = 0; i < possibility; i++) {
            int cur = dp[n][i + n];
            result[i] = cur / total;
        }
        return result;
        
    }
}

记忆化搜索与动态规划均超过100%