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

动态规划：

设输入$n$ 个骰子的解（即概率列表）为 $f(n)$ ，其中「点数和」 $x$的概率为 $f(n,x)$

假设已知 $n-1$ 个骰子的解 $f(n-1)$ ，此时添加一枚骰子，求 $n$ 个骰子的点数和为 $x$ 的概率 $f(n,x)$ 。

当添加骰子的点数为 1 时，前 $n-1$ 个骰子的点数和应为 $x-1$ ，方可组成点数和 $x$ ；以此类推，直至此骰子点数为 6 。将这 6 种情况的概率相加，即可得到概率 $f(n,x)$。递推公式如下所示：

$f(n,x)={\sum }_{i=1}^{6}f(n-1,x-i)\times \frac{1}{6}$

根据以上分析，得知通过子问题的解$f(n-1$可递推计算出 $f(n)$，而输入一个骰子的解 $f(1)$ 已知，因此可通过解 f$(1)$依次递推出任意解 $f(n)$ 。

如下图所示，为 $n=2$ , $x=7$的递推计算示例。

逆向递推（有越界问题）

$f(n-1,x-i)$中的 $x-i$会有越界问题

class Solution {
    public double[] dicesProbability(int n) {
        double res[] = new double[n * 5 + 1];
        double dp[][] = new double[n + 1][n * 6 + 1];
        for (int i = 1;i <= 6;i++) {
            dp[1][i] = 1.0/6;
        }
        for (int i = 2; i <= n; i++) {
            for (int j = i; j <= i * 6; j++) {
                //第i枚筛子的点数
                for (int k = 1; k <= 6; k++){
                    //越界处理
                    if(j - k >= i - 1)
                        dp[i][j] += dp[i - 1][j - k] / 6;
                    else
                        break;
                }
            }
        }
        for (int i = 0; i < 5 * n + 1; i++) {
            res[i] = dp[n][n + i];
        }
        return res;
    }
}

//空间优化
class Solution {
    public double[] dicesProbability(int n) {
        double res[] = new double[n * 5 + 1];
        double dp[] = new double[n * 6 + 1];
        for (int i = 1;i <= 6;i++) {
            dp[i] = 1.0/6;
        }
        for (int i = 2; i <= n; i++) {
            for (int j = i * 6; j >= i; j--) {
                dp[j] = 0;
                //第i枚筛子的点数
                for (int k = 1; k <= 6; k++){
                    //越界处理
                    if(j - k >= i - 1)
                        dp[j] += dp[j - k] / 6;
                    else
                        break;
                }
            }
        }
        for (int i = 0; i < 5 * n + 1; i++) {
            res[i] = dp[n + i];
        }
        return res;
    }
}

正向递推（无越界问题）

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

具体来看，由于新增骰子的点数只可能为 1至 6 ，因此概率 $f(n-1,x)$仅与 $f(n,x+1),f(n,x+2),...,f(n,x+6)$ 相关。因而，遍历 $f(n-1)$中各点数和的概率，并将其相加至 $f(n)$ 中所有相关项，即可完成 $f(n-1)$至 $f(n)$的递推。

class Solution {
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个骰子时的点数之和的值数组先假定是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；
                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;
    }   
}