feat: add solutions to lcof problem: No.60

Author: yanglbme

lcof/面试题60. n个骰子的点数/README.md

@@ -33,27 +33,21 @@
 
 <!-- 这里可写通用的实现逻辑 -->
 
-动态规划求解。
+**方法一：动态规划**
 
-扔 n 个骰子，点数之和的范围在 `[n, 6n]` 之间，总共有 `5n+1` 种，即为最后结果数组的长度。
+我们定义 $f[i][j]$ 表示投掷 $i$ 个骰子，点数和为 $j$ 的方案数。那么我们可以写出状态转移方程：
 
-假设 `dp[i][j]` 表示扔 i 个骰子，出现点数之和 j 的次数。n 个骰子，所以 i 的范围在 `1~n`，j 的范围在 `[1, 6n]`。
+$$
+f[i][j] = \sum_{k=1}^6 f[i-1][j-k]
+$$
 
-单看第 n 枚骰子，它的点数可能为 `1,2,3,...,6`，因此扔完 n 枚骰子后点数之和 j 出现的次数，可以由扔完 n-1 枚骰子后，对应点数 `j−1,j−2,j−3,...,j−6` 出现的次数之和转化过来。即：
+其中 $k$ 表示当前骰子的点数，$f[i-1][j-k]$ 表示投掷 $i-1$ 个骰子，点数和为 $j-k$ 的方案数。
 
-```
-for (第n枚骰子的点数 i = 1; i <= 6; i ++) {
-    dp[n][j] += dp[n-1][j - i]
-}
-```
+最终我们需要求的是 $f[n][n \sim 6n]$ 的和，即投掷 $n$ 个骰子，点数和为 $n \sim 6n$ 的方案数之和。
 
-扔 1 枚骰子，点数可能是 `1,2,3,4,5,6`，且每个点数出现的次数均为 1。所以初始化如下：
+注意到 $f[i][j]$ 的值只与 $f[i-1][j-k]$ 有关，因此我们可以使用滚动数组的方法将空间复杂度降低到 $O(6n)$。
 
-```
-for (int j = 1; j <= 6; ++j) {
-    dp[1][j] = 1;
-}
-```
+时间复杂度 $O(n^2)$，空间复杂度 $O(6n)$。其中 $n$ 为骰子个数。
 
 <!-- tabs:start -->
 
@@ -63,20 +57,32 @@ for (int j = 1; j <= 6; ++j) {
 
 ```python
 class Solution:
-    def twoSum(self, n: int) -> List[float]:
-        dp = [[0 for _ in range(6 * n + 1)] for _ in range(n + 1)]
+    def dicesProbability(self, n: int) -> List[float]:
+        f = [[0] * (6 * n + 1) for _ in range(n + 1)]
         for j in range(1, 7):
-            dp[1][j] = 1
+            f[1][j] = 1
+        for i in range(2, n + 1):
+            for j in range(i, 6 * i + 1):
+                for k in range(1, 7):
+                    if j - k >= 0:
+                        f[i][j] += f[i - 1][j - k]
+        m = pow(6, n)
+        return [f[n][i] / m for i in range(n, 6 * n + 1)]
+```
+
+```python
+class Solution:
+    def dicesProbability(self, n: int) -> List[float]:
+        f = [0] + [1] * 6
         for i in range(2, n + 1):
+            g = [0] * (6 * i + 1)
             for j in range(i, 6 * i + 1):
                 for k in range(1, 7):
-                    if j <= k:
-                        break
-                    dp[i][j] += dp[i - 1][j - k]
-        res, total = [], pow(6, n)
-        for i in range(5 * n + 1):
-            res.append(dp[n][n + i] / total)
-        return res
+                    if 0 <= j - k < len(f):
+                        g[j] += f[j - k]
+            f = g
+        m = pow(6, n)
+        return [f[j] / m for j in range(n, 6 * n + 1)]
 ```
 
 ### **Java**
@@ -85,55 +91,88 @@ class Solution:
 
 ```java
 class Solution {
-    public double[] twoSum(int n) {
-        int[][] dp = new int[n + 1][6 * n + 1];
+    public double[] dicesProbability(int n) {
+        int[][] f = new int[n + 1][6 * n + 1];
         for (int j = 1; j <= 6; ++j) {
-            dp[1][j] = 1;
+            f[1][j] = 1;
         }
         for (int i = 2; i <= n; ++i) {
             for (int j = i; j <= 6 * i; ++j) {
-                for (int k = 1; k <= 6 && j > k; ++k) {
-                    dp[i][j] += dp[i - 1][j - k];
+                for (int k = 1; k <= 6; ++k) {
+                    if (j >= k) {
+                        f[i][j] += f[i - 1][j - k];
+                    }
                 }
             }
         }
-        double[] res = new double[5 * n + 1];
-        double all = Math.pow(6, n);
-        for (int i = 0; i <= 5 * n; ++i) {
-            res[i] = dp[n][n + i] * 1.0 / all;
+        double m = Math.pow(6, n);
+        double[] ans = new double[5 * n + 1];
+        for (int i = 0; i < ans.length; ++i) {
+            ans[i] = f[n][n + i] / m;
         }
-        return res;
+        return ans;
     }
 }
 ```
 
-### **JavaScript**
+### **C++**
 
-```js
-/**
- * @param {number} n
- * @return {number[]}
- */
-var twoSum = function (n) {
-    function backtrack(sum, time) {
-        if (time === n) {
-            res[sum]++;
-            return;
+```cpp
+class Solution {
+public:
+    vector<double> dicesProbability(int n) {
+        int f[n + 1][6 * n + 1];
+        memset(f, 0, sizeof f);
+        for (int j = 1; j <= 6; ++j) {
+            f[1][j] = 1;
         }
-        for (let i = 1; i <= 6; i++) {
-            backtrack(sum + i, time + 1);
+        for (int i = 2; i <= n; ++i) {
+            for (int j = i; j <= 6 * i; ++j) {
+                for (int k = 1; k <= 6; ++k) {
+                    if (j >= k) {
+                        f[i][j] += f[i - 1][j - k];
+                    }
+                }
+            }
+        }
+        vector<double> ans(5 * n + 1);
+        double m = pow(6, n);
+        for (int i = 0; i < ans.size(); ++i) {
+            ans[i] = f[n][n + i] / m;
         }
+        return ans;
     }
-    let len = n * 6;
-    let t = 6 ** n;
-    let res = new Array(len + 1).fill(0);
-    backtrack(0, 0);
-    return res.slice(n).map(e => e / t);
 };
 ```
 
 ### **Go**
 
+```go
+func dicesProbability(n int) (ans []float64) {
+	f := make([][]int, n+1)
+	for i := range f {
+		f[i] = make([]int, 6*n+1)
+	}
+	for j := 1; j <= 6; j++ {
+		f[1][j] = 1
+	}
+	for i := 2; i <= n; i++ {
+		for j := i; j <= 6*i; j++ {
+			for k := 1; k <= 6; k++ {
+				if j >= k {
+					f[i][j] += f[i-1][j-k]
+				}
+			}
+		}
+	}
+	m := math.Pow(6, float64(n))
+	for j := n; j <= 6*n; j++ {
+		ans = append(ans, float64(f[n][j])/m)
+	}
+	return
+}
+```
+
 ```go
 func dicesProbability(n int) []float64 {
 	dp := make([]float64, 7)
@@ -154,6 +193,36 @@ func dicesProbability(n int) []float64 {
 }
 ```
 
+### **JavaScript**
+
+```js
+/**
+ * @param {number} n
+ * @return {number[]}
+ */
+var dicesProbability = function (n) {
+    const f = Array.from({ length: n + 1 }, () => Array(6 * n + 1).fill(0));
+    for (let j = 1; j <= 6; ++j) {
+        f[1][j] = 1;
+    }
+    for (let i = 2; i <= n; ++i) {
+        for (let j = i; j <= 6 * i; ++j) {
+            for (let k = 1; k <= 6; ++k) {
+                if (j >= k) {
+                    f[i][j] += f[i - 1][j - k];
+                }
+            }
+        }
+    }
+    const ans = [];
+    const m = Math.pow(6, n);
+    for (let j = n; j <= 6 * n; ++j) {
+        ans.push(f[n][j] / m);
+    }
+    return ans;
+};
+```
+
 ### **C#**
 
 ```cs

lcof/面试题60. n个骰子的点数/Solution.cpp

@@ -0,0 +1,25 @@
+class Solution {
+public:
+    vector<double> dicesProbability(int n) {
+        int f[n + 1][6 * n + 1];
+        memset(f, 0, sizeof f);
+        for (int j = 1; j <= 6; ++j) {
+            f[1][j] = 1;
+        }
+        for (int i = 2; i <= n; ++i) {
+            for (int j = i; j <= 6 * i; ++j) {
+                for (int k = 1; k <= 6; ++k) {
+                    if (j >= k) {
+                        f[i][j] += f[i - 1][j - k];
+                    }
+                }
+            }
+        }
+        vector<double> ans(5 * n + 1);
+        double m = pow(6, n);
+        for (int i = 0; i < ans.size(); ++i) {
+            ans[i] = f[n][n + i] / m;
+        }
+        return ans;
+    }
+};

lcof/面试题60. n个骰子的点数/Solution.go

@@ -1,17 +1,23 @@
-func dicesProbability(n int) []float64 {
-	dp := make([]float64, 7)
-	for i := 1; i <= 6; i++ {
-		dp[i] = 1.0 / 6.0
+func dicesProbability(n int) (ans []float64) {
+	f := make([][]int, n+1)
+	for i := range f {
+		f[i] = make([]int, 6*n+1)
+	}
+	for j := 1; j <= 6; j++ {
+		f[1][j] = 1
 	}
 	for i := 2; i <= n; i++ {
-		n := len(dp)
-		tmp := make([]float64, 6*i+1)
-		for j := 0; j < n; j++ {
+		for j := i; j <= 6*i; j++ {
 			for k := 1; k <= 6; k++ {
-				tmp[j+k] += dp[j] / 6.0
+				if j >= k {
+					f[i][j] += f[i-1][j-k]
+				}
 			}
 		}
-		dp = tmp
 	}
-	return dp[n:]
-}
+	m := math.Pow(6, float64(n))
+	for j := n; j <= 6*n; j++ {
+		ans = append(ans, float64(f[n][j])/m)
+	}
+	return
+}

lcof/面试题60. n个骰子的点数/Solution.java

@@ -1,21 +1,23 @@
 class Solution {
-    public double[] twoSum(int n) {
-        int[][] dp = new int[n + 1][6 * n + 1];
+    public double[] dicesProbability(int n) {
+        int[][] f = new int[n + 1][6 * n + 1];
         for (int j = 1; j <= 6; ++j) {
-            dp[1][j] = 1;
+            f[1][j] = 1;
         }
         for (int i = 2; i <= n; ++i) {
             for (int j = i; j <= 6 * i; ++j) {
-                for (int k = 1; k <= 6 && j > k; ++k) {
-                    dp[i][j] += dp[i - 1][j - k];
+                for (int k = 1; k <= 6; ++k) {
+                    if (j >= k) {
+                        f[i][j] += f[i - 1][j - k];
+                    }
                 }
             }
         }
-        double[] res = new double[5 * n + 1];
-        double all = Math.pow(6, n);
-        for (int i = 0; i <= 5 * n; ++i) {
-            res[i] = dp[n][n + i] * 1.0 / all;
+        double m = Math.pow(6, n);
+        double[] ans = new double[5 * n + 1];
+        for (int i = 0; i < ans.length; ++i) {
+            ans[i] = f[n][n + i] / m;
         }
-        return res;
+        return ans;
     }
 }

lcof/面试题60. n个骰子的点数/Solution.js

@@ -2,19 +2,24 @@
  * @param {number} n
  * @return {number[]}
  */
-var twoSum = function (n) {
-    function backtrack(sum, time) {
-        if (time === n) {
-            res[sum]++;
-            return;
-        }
-        for (let i = 1; i <= 6; i++) {
-            backtrack(sum + i, time + 1);
+var dicesProbability = function (n) {
+    const f = Array.from({ length: n + 1 }, () => Array(6 * n + 1).fill(0));
+    for (let j = 1; j <= 6; ++j) {
+        f[1][j] = 1;
+    }
+    for (let i = 2; i <= n; ++i) {
+        for (let j = i; j <= 6 * i; ++j) {
+            for (let k = 1; k <= 6; ++k) {
+                if (j >= k) {
+                    f[i][j] += f[i - 1][j - k];
+                }
+            }
         }
     }
-    let len = n * 6;
-    let t = 6 ** n;
-    let res = new Array(len + 1).fill(0);
-    backtrack(0, 0);
-    return res.slice(n).map(e => e / t);
+    const ans = [];
+    const m = Math.pow(6, n);
+    for (let j = n; j <= 6 * n; ++j) {
+        ans.push(f[n][j] / m);
+    }
+    return ans;
 };

lcof/面试题60. n个骰子的点数/Solution.py

@@ -1,15 +1,12 @@
 class Solution:
-    def twoSum(self, n: int) -> List[float]:
-        dp = [[0 for _ in range(6 * n + 1)] for _ in range(n + 1)]
+    def dicesProbability(self, n: int) -> List[float]:
+        f = [[0] * (6 * n + 1) for _ in range(n + 1)]
         for j in range(1, 7):
-            dp[1][j] = 1
+            f[1][j] = 1
         for i in range(2, n + 1):
             for j in range(i, 6 * i + 1):
                 for k in range(1, 7):
-                    if j <= k:
-                        break
-                    dp[i][j] += dp[i - 1][j - k]
-        res, total = [], pow(6, n)
-        for i in range(5 * n + 1):
-            res.append(dp[n][n + i] / total)
-        return res
+                    if j - k >= 0:
+                        f[i][j] += f[i - 1][j - k]
+        m = pow(6, n)
+        return [f[n][i] / m for i in range(n, 6 * n + 1)]