feat: add solutions to lc problem: No.1230.Toss Strange Coins

Author: yanglbme

solution/1200-1299/1230.Toss Strange Coins/README.md

@@ -35,27 +35,106 @@
 	<li>如果答案与标准答案的误差在&nbsp;<code>10^-5</code>&nbsp;内，则被视为正确答案。</li>
 </ul>
 
-
 ## 解法
 
 <!-- 这里可写通用的实现逻辑 -->
 
+`0-1` 背包问题。
+
 <!-- tabs:start -->
 
 ### **Python3**
 
 <!-- 这里可写当前语言的特殊实现逻辑 -->
 
 ```python
+class Solution:
+    def probabilityOfHeads(self, prob: List[float], target: int) -> float:
+        m = len(prob)
+        dp = [[0] * (target + 1) for _ in range(m + 1)]
+        dp[0][0] = 1
+        for i in range(1, m + 1):
+            for j in range(target + 1):
+                dp[i][j] = dp[i - 1][j] * (1 - prob[i - 1])
+                if j >= 1:
+                    dp[i][j] += dp[i - 1][j - 1] * prob[i - 1]
+        return dp[-1][-1]
+```
+
+空间优化：
 
+```python
+class Solution:
+    def probabilityOfHeads(self, prob: List[float], target: int) -> float:
+        dp = [0] * (target + 1)
+        dp[0] = 1
+        for v in prob:
+            for j in range(target, -1, -1):
+                dp[j] *= (1 - v)
+                if j >= 1:
+                    dp[j] += dp[j - 1] * v
+        return dp[-1]
 ```
 
 ### **Java**
 
 <!-- 这里可写当前语言的特殊实现逻辑 -->
 
 ```java
+class Solution {
+    public double probabilityOfHeads(double[] prob, int target) {
+        double[] dp = new double[target + 1];
+        dp[0] = 1;
+        for (double v : prob) {
+            for (int j = target; j >= 0; --j) {
+                dp[j] *= (1 - v);
+                if (j >= 1) {
+                    dp[j] += dp[j - 1] * v;
+                }
+            }
+        }
+        return dp[target];
+    }
+}
+```
+
+### **C++**
+
+```cpp
+class Solution {
+public:
+    double probabilityOfHeads(vector<double>& prob, int target) {
+        vector<double> dp(target + 1);
+        dp[0] = 1;
+        for (auto v : prob)
+        {
+            for (int j = target; j >= 0; --j)
+            {
+                dp[j] *= (1 - v);
+                if (j >= 1) dp[j] += dp[j - 1] * v;
+            }
+        }
+        return dp[target];
+    }
+};
+```
 
+### **Go**
+
+```go
+func probabilityOfHeads(prob []float64, target int) float64 {
+	dp := make([]float64, target+1)
+	dp[0] = 1
+	for _, v := range prob {
+		for j := target; j >= 0; j-- {
+			dp[j] *= (1 - v)
+			if j >= 1 {
+				dp[j] += dp[j-1] * v
+			}
+		}
+	}
+	return dp[target]
+}
 ```
 
 ### **...**

solution/1200-1299/1230.Toss Strange Coins/README_EN.md

@@ -34,13 +34,89 @@
 ### **Python3**
 
 ```python
+class Solution:
+    def probabilityOfHeads(self, prob: List[float], target: int) -> float:
+        m = len(prob)
+        dp = [[0] * (target + 1) for _ in range(m + 1)]
+        dp[0][0] = 1
+        for i in range(1, m + 1):
+            for j in range(target + 1):
+                dp[i][j] = dp[i - 1][j] * (1 - prob[i - 1])
+                if j >= 1:
+                    dp[i][j] += dp[i - 1][j - 1] * prob[i - 1]
+        return dp[-1][-1]
+```
 
+```python
+class Solution:
+    def probabilityOfHeads(self, prob: List[float], target: int) -> float:
+        dp = [0] * (target + 1)
+        dp[0] = 1
+        for v in prob:
+            for j in range(target, -1, -1):
+                dp[j] *= (1 - v)
+                if j >= 1:
+                    dp[j] += dp[j - 1] * v
+        return dp[-1]
 ```
 
 ### **Java**
 
 ```java
+class Solution {
+    public double probabilityOfHeads(double[] prob, int target) {
+        double[] dp = new double[target + 1];
+        dp[0] = 1;
+        for (double v : prob) {
+            for (int j = target; j >= 0; --j) {
+                dp[j] *= (1 - v);
+                if (j >= 1) {
+                    dp[j] += dp[j - 1] * v;
+                }
+            }
+        }
+        return dp[target];
+    }
+}
+```
+
+### **C++**
+
+```cpp
+class Solution {
+public:
+    double probabilityOfHeads(vector<double>& prob, int target) {
+        vector<double> dp(target + 1);
+        dp[0] = 1;
+        for (auto v : prob)
+        {
+            for (int j = target; j >= 0; --j)
+            {
+                dp[j] *= (1 - v);
+                if (j >= 1) dp[j] += dp[j - 1] * v;
+            }
+        }
+        return dp[target];
+    }
+};
+```
 
+### **Go**
+
+```go
+func probabilityOfHeads(prob []float64, target int) float64 {
+	dp := make([]float64, target+1)
+	dp[0] = 1
+	for _, v := range prob {
+		for j := target; j >= 0; j-- {
+			dp[j] *= (1 - v)
+			if j >= 1 {
+				dp[j] += dp[j-1] * v
+			}
+		}
+	}
+	return dp[target]
+}
 ```
 
 ### **...**

solution/1200-1299/1230.Toss Strange Coins/Solution.cpp

@@ -0,0 +1,16 @@
+class Solution {
+public:
+    double probabilityOfHeads(vector<double>& prob, int target) {
+        vector<double> dp(target + 1);
+        dp[0] = 1;
+        for (auto v : prob)
+        {
+            for (int j = target; j >= 0; --j)
+            {
+                dp[j] *= (1 - v);
+                if (j >= 1) dp[j] += dp[j - 1] * v;
+            }
+        }
+        return dp[target];
+    }
+};

solution/1200-1299/1230.Toss Strange Coins/Solution.go

@@ -0,0 +1,13 @@
+func probabilityOfHeads(prob []float64, target int) float64 {
+	dp := make([]float64, target+1)
+	dp[0] = 1
+	for _, v := range prob {
+		for j := target; j >= 0; j-- {
+			dp[j] *= (1 - v)
+			if j >= 1 {
+				dp[j] += dp[j-1] * v
+			}
+		}
+	}
+	return dp[target]
+}

solution/1200-1299/1230.Toss Strange Coins/Solution.java

@@ -0,0 +1,15 @@
+class Solution {
+    public double probabilityOfHeads(double[] prob, int target) {
+        double[] dp = new double[target + 1];
+        dp[0] = 1;
+        for (double v : prob) {
+            for (int j = target; j >= 0; --j) {
+                dp[j] *= (1 - v);
+                if (j >= 1) {
+                    dp[j] += dp[j - 1] * v;
+                }
+            }
+        }
+        return dp[target];
+    }
+}

solution/1200-1299/1230.Toss Strange Coins/Solution.py

@@ -0,0 +1,10 @@
+class Solution:
+    def probabilityOfHeads(self, prob: List[float], target: int) -> float:
+        dp = [0] * (target + 1)
+        dp[0] = 1
+        for v in prob:
+            for j in range(target, -1, -1):
+                dp[j] *= (1 - v)
+                if j >= 1:
+                    dp[j] += dp[j - 1] * v
+        return dp[-1]