n个骰子的点数【LeetCode】【暴力递归转化为动态规划】

n个骰子的点数

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

 

你需要用一个浮点数数组返回答案，其中第 i 个元素代表这 n 个骰子所能掷出的点数集合中第 i 小的那个的概率。

 

示例 1:

输入: 1
输出: [0.16667,0.16667,0.16667,0.16667,0.16667,0.16667]

示例 2:

输入: 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次骰子，n次骰子之和为s，打印s所有可能的值出现的概率

说明：n个骰子，s的范围为：n -> 6 * n，因此需要开辟的数组大小为5 * n + 1。另外，一个骰子总共有6种情况，n个骰子就有，所以分母为，我们就只需要计算分子即可，分子表示：和为s的掷法有几种。

思路：首先我们可能会想到一种暴力的方式，就是我一个骰子一个骰子掷，每个骰子都有1-6这6种情况，掷6次累加和为s时，对应的方法数就加一，掷完n次得到答案。

递归出口条件：当掷的骰子为第n个时，且和为s，则s对应的方法数+1

代码如下：

class Solution {
    public int cnt = 0;
    public double[] twoSum(int n) {
        int sum = n * 5 + 1;
        double[] res = new double[sum];

        for (int i = n; i <= 6 * n; i++){
            cnt = 0;
            solve(n, 0, i);
            res[i - n] = 1.0 * cnt / (Math.pow(6,n));
        }
        return res;
    }

    public void solve(int n, int cur, int target){
        if(target < 0){
            return;
        }
        if(cur == n){
            if(target == 0){
                cnt++;
            }
            return;
        }
        for(int i = 1; i <= 6; i++){
            if(target - i < 0) return;
            solve(n, cur+1, target - i);

        }
    }
}

 上面这种方式可能会超时，中间重复的状态不知道计算了多少次。

仔细观察，我们会发现一个状态只与两个变量有关：n和s，即n和s确定后，答案可能唯一，这就无后效性，可以通过记忆化搜索和动态规划来优化。

首先将上面的递归方式修改一下，减少递归函数的参数。代码如下。

public class Solution {
    public double[] twoSum(int n) {
        int sum = n * 5 + 1;
        double[] res = new double[sum];

        for (int i = n; i <= 6 * n; i++){
            int cnt = 0;
            cnt = solve(n, i);
            res[i - n] = 1.0 * cnt / (Math.pow(6,n));
        }
        return res;
    }

    public int solve(int n, int target){
        if(n == 0){
            if(target == 0){
                return 1;
            }
            return 0;
        }
        int res = 0;
        for(int i = 1; i <= 6; i++){
            if(target - i < 0){
                break;
            }
            res += solve(n - 1, target - i);
        }
        return res;
    }
}

然后我们可以把所有计算过的(n, s)的值用Map存起来，这也是套路。两个参数使用下划线拼接在一起。

AC代码如下。【记忆化搜索】

HashMap<String, Integer> map = new HashMap<>();
    public double[] twoSum(int n) {
        int sum = n * 5 + 1;
        double[] res = new double[sum];

        for (int i = n; i <= 6 * n; i++){
            int cnt = 0;
            cnt = solve(n, i);
            res[i - n] = 1.0 * cnt / (Math.pow(6,n));
        }
        return res;
    }

    public int solve(int n, int target){
        if(n == 0){
            if(target == 0){
                return 1;
            }
            return 0;
        }
        int res = 0;
        for(int i = 1; i <= 6; i++){
            if(target - i < 0){
                break;
            }
            String str = (n - 1) + "_" + (target - i);
            if(!map.containsKey(str)){
                res += solve(n - 1, target - i);
            } else {
                res += map.get(str);
            }
        }
        map.put(n + "_" + target, res);
        return res;
    }
}

最后通过搭积木的方式，首先查看出口位置，即不需要依赖别的状态就可以得到答案的位置，然后找到一个特殊的位置，看一下它依赖上一行的哪些位置，计算出这个值，最后循环得到我们要的状态，也就是最初调用递归的n和s。

代码如下。【动态规划】

public class Solution {    
    public double[] twoSum(int n) {
        double num = Math.pow(6, n);
        double[] res = new double[5 * n + 1];
        int[][] dp = new int[n + 1][6 * n + 1];
        for (int i = 0; i <= 6 * n; i++) {
            dp[0][i] = 0;
        }
        dp[0][0] = 1;
        int cur = 0;
        for(int i = 1; i <= n; i++){
            dp[i][0] = 0;
            for (int j = 1; j <= 6 * n; j++){
                int sum = 0;
                for (int k = 1; k <= 6; k++) {
                    if(j - k < 0) break;
                    sum += dp[i-1][j-k];
                }
                dp[i][j] = sum;
                if(i == n && j >= n){
                    res[cur++] = 1.0 * sum / num;
                }
            }
        }
        return res;
    }
}