【剑指Offer】个人学习笔记_60_n个骰子的点数

刷题日期：下午7:43 2021年5月25日星期二

个人刷题记录，代码收集，来源皆为leetcode

经过多方讨论和请教，现在打算往Java方向发力

主要答题语言为Java

题目：

剑指 Offer 60. n个骰子的点数

难度中等235

把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

题目分析

最多11个骰子，每加一个骰子，要计算的结果就加6。

还不能这样算，两个筛子则为2到12，三个则3到18，四个则4到24，分别是6，11，16，21，为

5 * n + 1

点数之和的话是一个数学公式，这题还是考数学多一点吧，虽然题目中说的是浮点数，但是代码中给的却是double类型。

看网上有说和杨辉三角有关， 没有固定的公式可以计算。

最小的是1/6^n，然后是统计学中的公式。

结果中每大1，结果就多一种可能，所以为2时是共11种，分别1，2，3，4，5，6，5，4，3，2，1。

再往三递增就不好求了。

求结果得时候也只用找前一半，后一般倒着复制即可。

通用得规律还是想不到什么思路，看了眼评论区也是很炸锅哈哈。

初始解答：

看了K神的解答

class Solution {
    public double[] dicesProbability(int n) {
        double[] res = new double[6];
        Arrays.fill(res, 1.0 / 6.0);
        for (int i = 2; i <= n; i++) {
            double[] tmp = new double[5 * i + 1];
            for (int j = 0; j < res.length; j++) {
                for (int k = 0; k < 6; k++) {
                    tmp[j + k] += res[j] / 6.0;
                }
            }
            res = tmp;
        }
        return res;
    }
}

执行结果：通过

显示详情 添加备注

执行用时：0 ms, 在所有 Java 提交中击败了100.00%的用户

内存消耗：38.5 MB, 在所有 Java 提交中击败了81.34%的用户

学习他人：

方法一:

算法岗从零到无穷L4

（编辑过）2020-02-17

#### 解法1：动态规划（二维数组） 【核心思想】

• f(n,s)=f(n-1,s-1)+f(n-1,s-2)+f(n-1,s-3)+f(n-1,s-4)+f(n-1,s-5)+f(n-1,s-6)

【数据结构】

• 二维数组

【思路】

• 确定问题解的表达式。可将f(n, s) 表示n个骰子点数的和为s的排列情况总数
• 确定状态转移方程。n个骰子点数和为s的种类数只与n-1个骰子的和有关。因为一个骰子有六个点数，那么第n个骰子可能出现1到6的点数。所以第n个骰子点数为1的话，f(n,s)=f(n-1,s-1)，当第n个骰子点数为2的话，f(n,s)=f(n-1,s-2)，…，依次类推。在n-1个骰子的基础上，再增加一个骰子出现点数和为s的结果只有这6种情况！那么有：f(n,s)=f(n-1,s-1)+f(n-1,s-2)+f(n-1,s-3)+f(n-1,s-4)+f(n-1,s-5)+f(n-1,s-6)
• 上面就是状态转移方程，已知初始阶段的解为：当n=1时, f(1,1)=f(1,2)=f(1,3)=f(1,4)=f(1,5)=f(1,6)=1。

【代码】

public double[] twoSum(int n) {
    int[][] dp=new int[n+1][6*n+1];
    double[] ans=new double[5*n+1];
    double all=Math.pow(6,n);
    for(int i=1;i<=6;i++)
        dp[1][i]=1;
    for(int i=1;i<=n;i++){
        for(int j=i;j<=6*n;j++){
            for(int k=1;k<=6;k++){
                dp[i][j]+=j>=k?dp[i-1][j-k]:0;
                if(i==n)
                    ans[j-i]=dp[i][j]/all;
            }
        }
    }
    return ans;
}

【备注】

• 由于每个dp[i][j]只于i-1时刻的状态有关，所以可以删去一个维度，简化算法

#### 解法2：动态规划（一维数组）

【数据结构】

• 一维数组

【思路】

• 在上述解法的基础上，删去一个维度
• 第二个循环从后往前遍历，避免覆盖

【代码】

public double[] twoSum(int n) {
    if(n==0)
        return new double[0];
    double[] dp=new double[6*n+1];
    double[] ans=new double[5*n+1];
    double all=Math.pow(6,n);
    for(int i=1;i<=6;i++){
        dp[i]=1;
        ans[i-1]=1.0/6;
    }
    for(int i=2;i<=n;i++){
        for(int j=6*n;j>=1;j--){
            int temp=0;
            for(int k=1;k<=6;k++){
                temp+=(j>=k)?dp[j-k]:0;
            }
            dp[j]=temp;
            if(i==n && j>=n){
                ans[j-i]=dp[j]/all;
            }
        }
    }
    return ans;
}

方法二：

yuchen

（编辑过）2 天前

class Solution {
    public double[] dicesProbability(int n) {
        double[][]dp =new double [n+1][n*6+1];
        for(int i = 1 ; i <= 6;i++){
            dp[1][i] = 1d/6;
        }
        for(int i = 2 ; i <= n; i++){
            for(int j = i ; j <= i*6;j++){
                for(int k = i-1 ; k < j;k++){
                    if(k+6<j){continue;}
                    dp[i][j] += dp[i-1][k]*1d/6;
                } 
            } 
        }
        return Arrays.copyOfRange(dp[n],n,n*6+1);
    }
}

方法三：

K神

方法一：暴力法

此方法超时，但为便于理解「方法二」，建议先理解此方法。

暴力统计： 每个「点数组合」都对应一个「点数和」，考虑遍历所有点数组合，统计每个点数和的出现次数，最后除以点数组合的总数（即除以 6^n ），即可得到每个点数和的出现概率。

如下图所示，为输入 n = 2时，点数组合、点数和、各点数概率的计算过程。

作者：jyd
链接：https://leetcode-cn.com/problems/nge-tou-zi-de-dian-shu-lcof/solution/jian-zhi-offer-60-n-ge-tou-zi-de-dian-sh-z36d/
来源：力扣（LeetCode）

暴力法需要遍历所有点数组合，因此时间复杂度为 O(6^n) ，观察本题输入取值范围 n≤11 ，可知此复杂度是无法接受的。

方法二：动态规划

此越界问题导致代码编写的难度提升。

如下图所示，以上递推公式是 “逆向” 的，即为了计算 f(n, x) ，将所有与之有关的情况求和；而倘若改换为 “正向” 的递推公式，便可解决越界问题。

代码：

class Solution {
    public double[] dicesProbability(int n) {
        double[] dp = new double[6];
        Arrays.fill(dp, 1.0 / 6.0);
        for (int i = 2; i <= n; i++) {
            double[] tmp = new double[5 * i + 1];
            for (int j = 0; j < dp.length; j++) {
                for (int k = 0; k < 6; k++) {
                    tmp[j + k] += dp[j] / 6.0;
                }
            }
            dp = tmp;
        }
        return dp;
    }
}

WealesonL1 2021-04-10

在K神的推理的指导下加上自己的理解打上了注释，希望对其他人有帮助

public double[] dicesProbability(int n) {
        //因为最后的结果只与前一个动态转移数组有关，所以这里只需要设置一个一维的动态转移数组
        //原本dp[i][j]表示的是前i个骰子的点数之和为j的概率，现在只需要最后的状态的数组，所以就只用一个一维数组dp[j]表示n个骰子下每个结果的概率。
        //初始是1个骰子情况下的点数之和情况，就只有6个结果，所以用dp的初始化的size是6个
        double[] dp = new double[6];
        //只有一个数组
        Arrays.fill(dp,1.0/6.0);
        //从第2个骰子开始，这里n表示n个骰子，先从第二个的情况算起，然后再逐步求3个、4个···n个的情况
        //i表示当总共i个骰子时的结果
        for(int i=2;i<=n;i++){
        //每次的点数之和范围会有点变化，点数之和的值最大是i*6，最小是i*1，i之前的结果值是不会出现的；
        //比如i=3个骰子时，最小就是3了，不可能是2和1，所以点数之和的值的个数是6*i-(i-1)，化简：5*i+1
            //当有i个骰子时的点数之和的值数组先假定是temp
            double[] temp = new double[5*i+1];
            //从i-1个骰子的点数之和的值数组入手，计算i个骰子的点数之和数组的值
            //先拿i-1个骰子的点数之和数组的第j个值，它所影响的是i个骰子时的temp[j+k]的值
            for(int j=0;j<dp.length;j++){
            //比如只有1个骰子时，dp[1]是代表当骰子点数之和为2时的概率，它会对当有2个骰子时的点数之和为3、4、5、6、7、8产生影响，因为当有一个骰子的值为2时，另一个骰子的值可以为1~6，产生的点数之和相应的就是3~8；比如dp[2]代表点数之和为3，它会对有2个骰子时的点数之和为4、5、6、7、8、9产生影响；所以k在这里就是对应着第i个骰子出现时可能出现六种情况，这里可能画一个K神那样的动态规划逆推的图就好理解很多
                for(int k=0;k<6;k++){
                    //这里记得是加上dp数组值与1/6的乘积，1/6是第i个骰子投出某个值的概率
                    temp[j+k]+=dp[j]*(1.0/6.0);
                }
            }
            //i个骰子的点数之和全都算出来后，要将temp数组移交给dp数组，dp数组就会代表i个骰子时的可能出现的点数之和的概率；用于计算i+1个骰子时的点数之和的概率
            dp = temp;
        }
        return dp;
    }   

给大佬跪了。

总结

以上就是本题的内容和学习过程了，为什么一开始就没有意识到这是动态规划的题目，反思。

欢迎讨论，共同进步。