LeetCode-837.新21点 动态规划

这里是题目描述：LeetCode-837.新21点

本题我们使用动态规划来解决

维护一个长度为N+1的一维表dp，dp[i]存储累计点数为i这种情况的概率。一般的，状态转移方程为：dp[i]=dp[i-1]*(1/M)+dp[i-2]*(1/M)+...+dp[j-W]*(1/w)，解释：每次抽取的数字在1~M之间，累计点数为i这个情况是由若干次独立的抽取数字累计得到的，因此累计点数为i可以被看做——由累计点数为i-1时又抽取了数字1、累计点数为i-2时又抽取了数字2、…累计点数为i-M时又抽取了数字M这些情况得到；因此累计点数为i的概率dp[i]就是dp[i-1]*抽取到数字1概率+dp[i-2]*抽取到数字2概率+...+dp[i-M]*抽取到数字M概率，又因为每次抽取都是独立的，其结果具有相同的概率，所以抽取得到所有数字的概率都是1/M，因此得到了上述的状态转移方程

上述的状态转移方程只是一般情况下的形式，我们需要考虑数组越界问题：

1. 当i小于W时，状态转移方程右边最小只能计算到dp[0]，以避免数组越界，即dp[i]=dp[i-1]*(1/M)+dp[i-2]*(1/M)+...+dp[0]*(1/w)
2. 又题干可知，当累计点数大于等于K时，就不再进行数字抽取，因此如果i大于K，它的状态转移方程中不需要让dp[i-1]*(1/M)~dp[K]*(1/M)这几项参与计算

为了方便计算，我们将dp[0]的值初始化为1

最后输出的结果是i=[K,N]范围内的dp[i]的总和
根据这种方法写的代码如下 （超出时间限制，未通过）：

class Solution {
    public double new21Game(int N, int K, int W) {
        double[] dp=new double[N+1]; //用于动规的一维表，dp[i]存储累计点数为i的概率
        dp[0]=1;
        for(int i=1;i<=N;i++)
        {
            int maxVal=Math.min(i-1,K-1);
            int minVal=Math.max(0,i-W);
            for(int j=minVal;j<=maxVal;j++)
            {
                dp[i]+=(dp[j]*(1.0/W));
            }
        }
        double res=0.0;
        for(int i=K;i<=N;i++)
        {
            res+=dp[i];
        }
        return res;
    }
}

上面代码的时间复杂度为：O(M*N)，空间复杂度为O(N)
由于计算每个dp[i]都需要时间开销 O(M) 来对可能的抽取情况的概率进行逐个相加，超出了时间限制。针对这个问题，我们可以进行优化：只在计算i=1的dp[i]时采用上面的逐个累加方式，并将累加结果记录下来，随着i变化，根据计算dp[i]所需要的前几项dp值的组成变化，加上或减去指定值，这部分的详细情况请看题解代码

题解代码（通过）：

class Solution {
    public double new21Game(int N, int K, int W) {
        double[] dp=new double[N+1]; //用于动规的一维表，dp[i]存储累计点数为i的概率
        dp[0]=1;
        int maxVal=Math.min(0,K-1); //i=1时构建dp[i]用到的最大值和最小值
        int minVal=Math.max(0,1-W);
        double sumP=0;
        for(int j=minVal;j<=maxVal;j++)
        {
            sumP+=(dp[j]*(1.0/W));
        }
        if(dp.length>1) //防止数组长度不够造成越界
        {
            dp[1]=sumP;
        }
        for(int i=2;i<=N;i++)
        {
            int m1=Math.min(i-1,K-1),m2=Math.max(0,i-W); //i为当前值时构建dp[i]需要用到的最大值和最小值
            if(m1!=maxVal)
            {
                sumP+=(dp[m1]*(1.0/W));
            }
            if(m2!=minVal)
            {
                sumP-=(dp[minVal]*(1.0/W));
            }
            dp[i]=sumP;
            maxVal=m1;
            minVal=m2;
        }
        double res=0.0;
        for(int i=K;i<=N;i++) //将所有大于等于K，小于等于N的概率相加
        {
            res+=dp[i];
        }
        return res;
    }
}

时间复杂度：O(N)，空间复杂度：O(N)