feat: add solutions to lc problem: No.0343. Integer Break

Author: yanglbme

README.md

@@ -201,6 +201,7 @@
 - [零钱兑换](./solution/0300-0399/0322.Coin%20Change/README.md)
 - [零钱兑换 II](./solution/0500-0599/0518.Coin%20Change%202/README.md)
 - [组合总和 Ⅳ](./solution/0300-0399/0377.Combination%20Sum%20IV/README.md)
+- [整数拆分](./solution/0300-0399/0343.Integer%20Break/README.md)
 - [礼物的最大价值](./lcof/面试题47.%20礼物的最大价值/README.md)
 - [俄罗斯套娃信封问题](./solution/0300-0399/0354.Russian%20Doll%20Envelopes/README.md)
 

README_EN.md

@@ -195,6 +195,7 @@ Complete solutions to [LeetCode](https://leetcode.com/problemset/all/), [LCOF](h
 - [Coin Change](./solution/0300-0399/0322.Coin%20Change/README_EN.md)
 - [Coin Change 2](./solution/0500-0599/0518.Coin%20Change%202/README_EN.md)
 - [Combination Sum IV](./solution/0300-0399/0377.Combination%20Sum%20IV/README_EN.md)
+- [Integer Break](./solution/0300-0399/0343.Integer%20Break/README_EN.md)
 - [Russian Doll Envelopes](./solution/0300-0399/0354.Russian%20Doll%20Envelopes/README_EN.md)
 
 ### Backtracking

solution/0300-0399/0343.Integer Break/README.md

@@ -22,27 +22,89 @@
 
 <p><strong>说明: </strong>你可以假设&nbsp;<em>n&nbsp;</em>不小于 2 且不大于 58。</p>
 
-
 ## 解法
 
 <!-- 这里可写通用的实现逻辑 -->
 
+动态规划。
+
+设 dp[i] 表示正整数 n 能获得的最大乘积，初始化 `dp[1] = 1`。
+
+`i >= 2` 时，`dp[i] = max(dp[i], dp[i - j] * j, (i - j) * j)`（`j∈[0, i)`）。
+
 <!-- tabs:start -->
 
 ### **Python3**
 
 <!-- 这里可写当前语言的特殊实现逻辑 -->
 
 ```python
-
+class Solution:
+    def integerBreak(self, n: int) -> int:
+        dp = [1] * (n + 1)
+        for i in range(2, n + 1):
+            for j in range(1, i):
+                dp[i] = max(dp[i], dp[i - j] * j, (i - j) * j)
+        return dp[n]
 ```
 
 ### **Java**
 
 <!-- 这里可写当前语言的特殊实现逻辑 -->
 
 ```java
+class Solution {
+    public int integerBreak(int n) {
+        int[] dp = new int[n + 1];
+        dp[1] = 1;
+        for (int i = 2; i <= n; ++i) {
+            for (int j = 1; j < i; ++j) {
+                dp[i] = Math.max(Math.max(dp[i], dp[i - j] * j), (i - j) * j);
+            }
+        }
+        return dp[n];
+    }
+}
+```
+
+### **C++**
+
+```cpp
+class Solution {
+public:
+    int integerBreak(int n) {
+        vector<int> dp(n + 1);
+        dp[1] = 1;
+        for (int i = 2; i <= n; ++i) {
+            for (int j = 1; j < i; ++j) {
+                dp[i] = max(max(dp[i], dp[i - j] * j), (i - j) * j);
+            }
+        }
+        return dp[n];
+    }
+};
+```
 
+### **Go**
+
+```go
+func integerBreak(n int) int {
+	dp := make([]int, n+1)
+	dp[1] = 1
+	for i := 2; i <= n; i++ {
+		for j := 1; j < i; j++ {
+			dp[i] = max(max(dp[i], dp[i-j]*j), (i-j)*j)
+		}
+	}
+	return dp[n]
+}
+
+func max(a, b int) int {
+	if a > b {
+		return a
+	}
+	return b
+}
 ```
 
 ### **...**

solution/0300-0399/0343.Integer Break/README_EN.md

@@ -32,21 +32,79 @@
 	<li><code>2 &lt;= n &lt;= 58</code></li>
 </ul>
 
-
 ## Solutions
 
+Dynamic programming.
+
 <!-- tabs:start -->
 
 ### **Python3**
 
 ```python
-
+class Solution:
+    def integerBreak(self, n: int) -> int:
+        dp = [1] * (n + 1)
+        for i in range(2, n + 1):
+            for j in range(1, i):
+                dp[i] = max(dp[i], dp[i - j] * j, (i - j) * j)
+        return dp[n]
 ```
 
 ### **Java**
 
 ```java
+class Solution {
+    public int integerBreak(int n) {
+        int[] dp = new int[n + 1];
+        dp[1] = 1;
+        for (int i = 2; i <= n; ++i) {
+            for (int j = 1; j < i; ++j) {
+                dp[i] = Math.max(Math.max(dp[i], dp[i - j] * j), (i - j) * j);
+            }
+        }
+        return dp[n];
+    }
+}
+```
+
+### **C++**
+
+```cpp
+class Solution {
+public:
+    int integerBreak(int n) {
+        vector<int> dp(n + 1);
+        dp[1] = 1;
+        for (int i = 2; i <= n; ++i) {
+            for (int j = 1; j < i; ++j) {
+                dp[i] = max(max(dp[i], dp[i - j] * j), (i - j) * j);
+            }
+        }
+        return dp[n];
+    }
+};
+```
 
+### **Go**
+
+```go
+func integerBreak(n int) int {
+	dp := make([]int, n+1)
+	dp[1] = 1
+	for i := 2; i <= n; i++ {
+		for j := 1; j < i; j++ {
+			dp[i] = max(max(dp[i], dp[i-j]*j), (i-j)*j)
+		}
+	}
+	return dp[n]
+}
+
+func max(a, b int) int {
+	if a > b {
+		return a
+	}
+	return b
+}
 ```
 
 ### **...**

solution/0300-0399/0343.Integer Break/Solution.cpp

@@ -0,0 +1,13 @@
+class Solution {
+public:
+    int integerBreak(int n) {
+        vector<int> dp(n + 1);
+        dp[1] = 1;
+        for (int i = 2; i <= n; ++i) {
+            for (int j = 1; j < i; ++j) {
+                dp[i] = max(max(dp[i], dp[i - j] * j), (i - j) * j);
+            }
+        }
+        return dp[n];
+    }
+};

solution/0300-0399/0343.Integer Break/Solution.go

@@ -0,0 +1,17 @@
+func integerBreak(n int) int {
+	dp := make([]int, n+1)
+	dp[1] = 1
+	for i := 2; i <= n; i++ {
+		for j := 1; j < i; j++ {
+			dp[i] = max(max(dp[i], dp[i-j]*j), (i-j)*j)
+		}
+	}
+	return dp[n]
+}
+
+func max(a, b int) int {
+	if a > b {
+		return a
+	}
+	return b
+}

solution/0300-0399/0343.Integer Break/Solution.java

@@ -1,17 +1,12 @@
 class Solution {
     public int integerBreak(int n) {
-        if (n < 2) {
-            return 0;
+        int[] dp = new int[n + 1];
+        dp[1] = 1;
+        for (int i = 2; i <= n; ++i) {
+            for (int j = 1; j < i; ++j) {
+                dp[i] = Math.max(Math.max(dp[i], dp[i - j] * j), (i - j) * j);
+            }
         }
-        if (n < 4) {
-            return n - 1;
-        }
-
-        int timesOf3 = n / 3;
-        if (n % 3 == 1) {
-            --timesOf3;
-        }
-        int timesOf2 = (n - timesOf3 * 3) >> 1;
-        return (int) (Math.pow(2, timesOf2) * Math.pow(3, timesOf3));
+        return dp[n];
     }
 }

solution/0300-0399/0343.Integer Break/Solution.py

@@ -0,0 +1,7 @@
+class Solution:
+    def integerBreak(self, n: int) -> int:
+        dp = [1] * (n + 1)
+        for i in range(2, n + 1):
+            for j in range(1, i):
+                dp[i] = max(dp[i], dp[i - j] * j, (i - j) * j)
+        return dp[n]