feat: add solutions to lc problem: No.1262

No.1262.Greatest Sum Divisible by Three

Author: yanglbme

Diff for: solution/1200-1299/1262.Greatest Sum Divisible by Three/README.md

@@ -48,11 +48,24 @@
 
 **方法一：动态规划**
 
-我们定义 $f[j]$ 表示前 $i-1$ 个数中，余数为 $j$ 的最大和。那么对于当前的数 $x$，我们可以将其加入到前面的数中，得到的和为 $f[j] + x$，其中 $j$ 为 $(f[j] + x) \bmod 3$。
+我们定义 $f[i][j]$ 表示前 $i$ 个数中选取若干个数，使得这若干个数的和模 $3$ 余 $j$ 的最大值。初始时 $f[0][0]=0$，其余为 $-\infty$。
 
-最后，我们返回 $f[0]$ 即可。
+对于 $f[i][j]$，我们可以考虑第 $i$ 个数 $x$ 的状态：
 
-时间复杂度 $O(n)$，空间复杂度 $O(1)$。其中 $n$ 为数组 `nums` 的长度。
+-   如果我们不选 $x$，那么 $f[i][j]=f[i-1][j]$；
+-   如果我们选 $x$，那么 $f[i][j]=f[i-1][(j-x \bmod 3 + 3)\bmod 3]+x$。
+
+因此我们可以得到状态转移方程：
+
+$$
+f[i][j]=\max\{f[i-1][j],f[i-1][(j-x \bmod 3 + 3)\bmod 3]+x\}
+$$
+
+最终答案为 $f[n][0]$。
+
+时间复杂度 $O(n)$，空间复杂度 $O(n)$。其中 $n$ 为数组 $nums$ 的长度。
+
+注意到 $f[i][j]$ 的值只与 $f[i-1][j]$ 和 $f[i-1][(j-x \bmod 3 + 3)\bmod 3]$ 有关，因此我们可以使用滚动数组优化空间复杂度，使空间复杂度降低为 $O(1)$。
 
 <!-- tabs:start -->
 
@@ -63,12 +76,24 @@
 ```python
 class Solution:
     def maxSumDivThree(self, nums: List[int]) -> int:
-        f = [0] * 3
+        n = len(nums)
+        f = [[-inf] * 3 for _ in range(n + 1)]
+        f[0][0] = 0
+        for i, x in enumerate(nums, 1):
+            for j in range(3):
+                f[i][j] = max(f[i - 1][j], f[i - 1][(j - x) % 3] + x)
+        return f[n][0]
+```
+
+```python
+class Solution:
+    def maxSumDivThree(self, nums: List[int]) -> int:
+        f = [0, -inf, -inf]
         for x in nums:
-            a, b, c = f[0] + x, f[1] + x, f[2] + x
-            f[a % 3] = max(f[a % 3], a)
-            f[b % 3] = max(f[b % 3], b)
-            f[c % 3] = max(f[c % 3], c)
+            g = f[:]
+            for j in range(3):
+                g[j] = max(f[j], f[(j - x) % 3] + x)
+            f = g
         return f[0]
 ```
 
@@ -79,12 +104,32 @@ class Solution:
 ```java
 class Solution {
     public int maxSumDivThree(int[] nums) {
-        int[] f = new int[3];
+        int n = nums.length;
+        final int inf = 1 << 30;
+        int[][] f = new int[n + 1][3];
+        f[0][1] = f[0][2] = -inf;
+        for (int i = 1; i <= n; ++i) {
+            int x = nums[i - 1];
+            for (int j = 0; j < 3; ++j) {
+                f[i][j] = Math.max(f[i - 1][j], f[i - 1][(j - x % 3 + 3) % 3] + x);
+            }
+        }
+        return f[n][0];
+    }
+}
+```
+
+```java
+class Solution {
+    public int maxSumDivThree(int[] nums) {
+        final int inf = 1 << 30;
+        int[] f = new int[] {0, -inf, -inf};
         for (int x : nums) {
-            int a = f[0] + x, b = f[1] + x, c = f[2] + x;
-            f[a % 3] = Math.max(f[a % 3], a);
-            f[b % 3] = Math.max(f[b % 3], b);
-            f[c % 3] = Math.max(f[c % 3], c);
+            int[] g = f.clone();
+            for (int j = 0; j < 3; ++j) {
+                g[j] = Math.max(f[j], f[(j - x % 3 + 3) % 3] + x);
+            }
+            f = g;
         }
         return f[0];
     }
@@ -97,12 +142,34 @@ class Solution {
 class Solution {
 public:
     int maxSumDivThree(vector<int>& nums) {
-        int f[3]{};
-        for (int x : nums) {
-            int a = f[0] + x, b = f[1] + x, c = f[2] + x;
-            f[a % 3] = max(f[a % 3], a);
-            f[b % 3] = max(f[b % 3], b);
-            f[c % 3] = max(f[c % 3], c);
+        int n = nums.size();
+        const int inf = 1 << 30;
+        int f[n + 1][3];
+        f[0][0] = 0;
+        f[0][1] = f[0][2] = -inf;
+        for (int i = 1; i <= n; ++i) {
+            int x = nums[i - 1];
+            for (int j = 0; j < 3; ++j) {
+                f[i][j] = max(f[i - 1][j], f[i - 1][(j - x % 3 + 3) % 3] + x);
+            }
+        }
+        return f[n][0];
+    }
+};
+```
+
+```cpp
+class Solution {
+public:
+    int maxSumDivThree(vector<int>& nums) {
+        const int inf = 1 << 30;
+        vector<int> f = {0, -inf, -inf};
+        for (int& x : nums) {
+            vector<int> g = f;
+            for (int j = 0; j < 3; ++j) {
+                g[j] = max(f[j], f[(j - x % 3 + 3) % 3] + x);
+            }
+            f = move(g);
         }
         return f[0];
     }
@@ -113,12 +180,37 @@ public:
 
 ```go
 func maxSumDivThree(nums []int) int {
-	f := [3]int{}
+	n := len(nums)
+	const inf = 1 << 30
+	f := make([][3]int, n+1)
+	f[0] = [3]int{0, -inf, -inf}
+	for i, x := range nums {
+		i++
+		for j := 0; j < 3; j++ {
+			f[i][j] = max(f[i-1][j], f[i-1][(j-x%3+3)%3]+x)
+		}
+	}
+	return f[n][0]
+}
+
+func max(a, b int) int {
+	if a > b {
+		return a
+	}
+	return b
+}
+```
+
+```go
+func maxSumDivThree(nums []int) int {
+	const inf = 1 << 30
+	f := [3]int{0, -inf, -inf}
 	for _, x := range nums {
-		a, b, c := f[0]+x, f[1]+x, f[2]+x
-		f[a%3] = max(f[a%3], a)
-		f[b%3] = max(f[b%3], b)
-		f[c%3] = max(f[c%3], c)
+		g := [3]int{}
+		for j := range f {
+			g[j] = max(f[j], f[(j-x%3+3)%3]+x)
+		}
+		f = g
 	}
 	return f[0]
 }
@@ -131,6 +223,43 @@ func max(a, b int) int {
 }
 ```
 
+### **TypeScript**
+
+```ts
+function maxSumDivThree(nums: number[]): number {
+    const n = nums.length;
+    const inf = 1 << 30;
+    const f: number[][] = Array(n + 1)
+        .fill(0)
+        .map(() => Array(3).fill(-inf));
+    f[0][0] = 0;
+    for (let i = 1; i <= n; ++i) {
+        const x = nums[i - 1];
+        for (let j = 0; j < 3; ++j) {
+            f[i][j] = Math.max(
+                f[i - 1][j],
+                f[i - 1][(j - (x % 3) + 3) % 3] + x,
+            );
+        }
+    }
+    return f[n][0];
+}
+```
+
+```ts
+function maxSumDivThree(nums: number[]): number {
+    const inf = 1 << 30;
+    const f: number[] = [0, -inf, -inf];
+    for (const x of nums) {
+        const g = [...f];
+        for (let j = 0; j < 3; ++j) {
+            f[j] = Math.max(g[j], g[(j - (x % 3) + 3) % 3] + x);
+        }
+    }
+    return f[0];
+}
+```
+
 ### **...**
 
 ```