JZ60 [剑指 Offer 60] n个骰子的点数

题目：n个骰子的点数

Category	Difficulty	Likes	Dislikes
lcof	Medium (57.44%)	452	-

 

把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

---

Discussion | Solution

分析：

方法一：遍历

        采用递归每个骰子代表一层循坏，对所有结果遍历，每次结果的概率为，点数相同的概率累加（点数相同，各个骰子点数不同）。

方法二：动态规划

          dp[n][s]代表n个骰子点数为s的概率，点数s由前n-1个骰子的点数t加上第n个骰子的点数组成，第n个骰子的点数k肯定为1~6，所以s的点数=SUM(dp[n-1][s-1],dp[n-1][s-2],...,dp[n-1][s-k])*第n个骰子概率1/6。如dp[5][6]=SUM(dp[4][5], dp[4][4])*1/6 。注意没有dp[4][3]，4个骰子组不成3点。   

代码一：遍历（超时）

//遍历
void getAns(map<int, double>& ans, int n, int layel, int sum){
    if(layel == 0){
        ans[sum] += pow(1.0/6, n);
        return ;
    } 
    
    for(int i=1; i <= 6; i++){
        getAns(ans, n, layel-1, sum + i);
    }
}

vector<double> dicesProbability(int n) {
    vector<double> ans;
    if(n == 0) return ans;
    if(n == 1) return vector<double>(6, 1.0/6);

    //遍历
    map<int, double> tmp;
    getAns(tmp, n, n, 0);
    for(auto it = tmp.begin(); it != tmp.end() ; it++)
    {   
        ans.push_back(it->second);
    }

    return ans;
}

代码二：动态规划

/*
 * @lc app=leetcode.cn id=100339 lang=cpp
 *
 * [剑指 Offer 60] n个骰子的点数
 */

// @lc code=start
/* 
    1、无后性：当前骰子数n的点数s的概率，与n-1的点数s-k有关，k属于1~6
    2、问题分解：转变求n-1的各个概率
    3、相关性：当前概率只与骰子数n和点数s有关，dp为二维数组，即dp[n][s]:为当前n个骰子点数为s的概率
    4、边界：dp[0][6n] = 0; 点数s的范围[n,6n],即 dp[n][0~n-1] = 0; dp[1][1~6] = 1/6;
    5、递推关系：
      s-k >= n-1， dp[n][s] = sum(dp[n-1][s-1], dp[n-1][s-k],...,dp[n-1][s-6])/6; 
                   dp[2][2] = sum(dp[1,1])/6
                   dp[5][6] = sum(dp[4,5],dp[4,4])/6
      s-k < n-1，不存在 如dp[4][3]，四个骰子凑不出3点
*/
class Solution {
public:

    //动态规划-递推
    vector<double> getAns(vector<vector<double>>& dp, int n){
        double sum = 0;
        vector<double> ans;    
        for(int i = 2; i <= n; i++){
            for(int j = i; j <= 6*i; j++){
                //计算概率
                sum = 0;
                for(int k = 1; k <= 6; k++){
                    //
                    if(j-k >= i-1 && j-k <= 6*(i-1))
                        sum += dp[i-1][j-k];
                }
                
                dp[i][j] = sum / 6;
                
                if(i == n){
                    ans.push_back(dp[i][j]);
                    //printf("%d %f\n",j, dp[i][j]);
                }

            }
        }
        return ans;
    }
        

    vector<double> dicesProbability(int n) {
        vector<double> ans;
        if(n == 0) return ans;
        if(n == 1) return vector<double>(6, 1.0/6);

        //动态规划
        vector<vector<double>> dp(n+1, vector<double>(6*n+1));
        //初始化边界，申请内存时默认初始化为0;
        for(int j=1; j <= 6; j++)
            dp[1][j] = 1.0/6;
        ans = getAns(dp, n);

        //递推空间优化
        ans.resize(6*n+1,0);
        //初始化
        for(int j=1; j <= 6; j++)
            ans[j] = 1.0/6;
        ans =  geAnsZoomOptimization(ans, n);

        return ans;
    }
};
// @lc code=end

Accepted

• 11/11 cases passed (0 ms)
• Your runtime beats 100 % of cpp submissions
• Your memory usage beats 19.51 % of cpp submissions (6.3 MB)

空间优化：当前n的结果只用到n-1，空间减少到2行。

//空间优化，时间优化：
    vector<double> geAnsZoomOptimization(vector<double> ans, int n){
        double sum;
        vector<double> tail(6*n+1);
        
        for(int i = 2; i <= n; i++){
            for(int j = i; j <= 6*i; j++){
                //计算概率
                sum = 0;
                for(int k = 1; k <= 6; k++){
                    //可行性剪枝：j-k 符合以下范围，因为不存在超出范围的点数客观上不存在
                    if(j-k >= i-1 && j-k <= 6*(i-1))
                        sum += ans[j-k];
                }

                tail[j] = sum / 6;
            }
            ans.swap(tail);
        }
        //知识点：ans.begin()+n，begin往后2个单位，相当于ans[n]
        return vector<double>(ans.begin()+n, ans.end());
    }

Accepted

• 11/11 cases passed (0 ms)
• Your runtime beats 100 % of cpp submissions
• Your memory usage beats 50.12 % of cpp submissions (6.1 MB)

应试新思路：题解看到思路，对于结果有限的题目可以采用查表的形式。

看到有趣题解，嘿嘿