feat: add solutions to lc problem: No.2036

No.2036.Maximum Alternating Subarray Sum

Author: yanglbme

solution/2000-2099/2036.Maximum Alternating Subarray Sum/README.md

@@ -55,22 +55,102 @@
 
 <!-- 这里可写通用的实现逻辑 -->
 
+**方法一：动态规划**
+
+定义状态 $a$ 表示以当前元素作为正结尾的最大交替子数组和，状态 $b$ 表示以当前元素作为负结尾的最大交替子数组和。初始时 $a = nums[0]$，$b = -\infty$。
+
+遍历数组，对于当前元素 $nums[i]$，有
+
+$$
+\begin{aligned}
+a = \max(nums[i], b + nums[i]) \\
+b = a - nums[i]
+\end{aligned}
+$$
+
+求出 $a$ 和 $b$ 后，将 $a$ 和 $b$ 中的最大值与当前最大交替子数组和进行比较，更新最大交替子数组和。
+
+时间复杂度 $O(n)$，空间复杂度 $O(1)$。其中 $n$ 为数组长度。
+
 <!-- tabs:start -->
 
 ### **Python3**
 
 <!-- 这里可写当前语言的特殊实现逻辑 -->
 
 ```python
-
+class Solution:
+    def maximumAlternatingSubarraySum(self, nums: List[int]) -> int:
+        ans = nums[0]
+        a, b = nums[0], -inf
+        for v in nums[1:]:
+            a, b = max(v, b + v), a - v
+            ans = max(ans, a, b)
+        return ans
 ```
 
 ### **Java**
 
 <!-- 这里可写当前语言的特殊实现逻辑 -->
 
 ```java
+class Solution {
+    public long maximumAlternatingSubarraySum(int[] nums) {
+        long ans = nums[0];
+        long a = nums[0], b = -(1 << 30);
+        for (int i = 1; i < nums.length; ++i) {
+            long c = a, d = b;
+            a = Math.max(nums[i], d + nums[i]);
+            b = c - nums[i];
+            ans = Math.max(ans, Math.max(a, b));
+        }
+        return ans;
+    }
+}
+```
+
+### **C++**
+
+```cpp
+using ll = long long;
+
+class Solution {
+public:
+    long long maximumAlternatingSubarraySum(vector<int>& nums) {
+        ll ans = nums[0];
+        ll a = nums[0], b = -(1 << 30);
+        for (int i = 1; i < nums.size(); ++i) {
+            ll c = a, d = b;
+            a = max(1ll * nums[i], d + nums[i]);
+            b = c - nums[i];
+            ans = max(ans, max(a, b));
+        }
+        return ans;
+    }
+};
+```
 
+### **Go**
+
+```go
+func maximumAlternatingSubarraySum(nums []int) int64 {
+	ans := nums[0]
+	a, b := nums[0], -(1 << 30)
+	for _, v := range nums[1:] {
+		c, d := a, b
+		a = max(v, d+v)
+		b = c - v
+		ans = max(ans, max(a, b))
+	}
+	return int64(ans)
+}
+
+func max(a, b int) int {
+	if a > b {
+		return a
+	}
+	return b
+}
 ```
 
 ### **...**

solution/2000-2099/2036.Maximum Alternating Subarray Sum/README_EN.md

@@ -58,13 +58,76 @@ The alternating subarray sum is 1.
 ### **Python3**
 
 ```python
-
+class Solution:
+    def maximumAlternatingSubarraySum(self, nums: List[int]) -> int:
+        ans = nums[0]
+        a, b = nums[0], -inf
+        for v in nums[1:]:
+            a, b = max(v, b + v), a - v
+            ans = max(ans, a, b)
+        return ans
 ```
 
 ### **Java**
 
 ```java
+class Solution {
+    public long maximumAlternatingSubarraySum(int[] nums) {
+        long ans = nums[0];
+        long a = nums[0], b = -(1 << 30);
+        for (int i = 1; i < nums.length; ++i) {
+            long c = a, d = b;
+            a = Math.max(nums[i], d + nums[i]);
+            b = c - nums[i];
+            ans = Math.max(ans, Math.max(a, b));
+        }
+        return ans;
+    }
+}
+```
+
+### **C++**
+
+```cpp
+using ll = long long;
+
+class Solution {
+public:
+    long long maximumAlternatingSubarraySum(vector<int>& nums) {
+        ll ans = nums[0];
+        ll a = nums[0], b = -(1 << 30);
+        for (int i = 1; i < nums.size(); ++i) {
+            ll c = a, d = b;
+            a = max(1ll * nums[i], d + nums[i]);
+            b = c - nums[i];
+            ans = max(ans, max(a, b));
+        }
+        return ans;
+    }
+};
+```
 
+### **Go**
+
+```go
+func maximumAlternatingSubarraySum(nums []int) int64 {
+	ans := nums[0]
+	a, b := nums[0], -(1 << 30)
+	for _, v := range nums[1:] {
+		c, d := a, b
+		a = max(v, d+v)
+		b = c - v
+		ans = max(ans, max(a, b))
+	}
+	return int64(ans)
+}
+
+func max(a, b int) int {
+	if a > b {
+		return a
+	}
+	return b
+}
 ```
 
 ### **...**

solution/2000-2099/2036.Maximum Alternating Subarray Sum/Solution.cpp

@@ -0,0 +1,16 @@
+using ll = long long;
+
+class Solution {
+public:
+    long long maximumAlternatingSubarraySum(vector<int>& nums) {
+        ll ans = nums[0];
+        ll a = nums[0], b = -(1 << 30);
+        for (int i = 1; i < nums.size(); ++i) {
+            ll c = a, d = b;
+            a = max(1ll * nums[i], d + nums[i]);
+            b = c - nums[i];
+            ans = max(ans, max(a, b));
+        }
+        return ans;
+    }
+};

solution/2000-2099/2036.Maximum Alternating Subarray Sum/Solution.go

@@ -0,0 +1,18 @@
+func maximumAlternatingSubarraySum(nums []int) int64 {
+	ans := nums[0]
+	a, b := nums[0], -(1 << 30)
+	for _, v := range nums[1:] {
+		c, d := a, b
+		a = max(v, d+v)
+		b = c - v
+		ans = max(ans, max(a, b))
+	}
+	return int64(ans)
+}
+
+func max(a, b int) int {
+	if a > b {
+		return a
+	}
+	return b
+}

solution/2000-2099/2036.Maximum Alternating Subarray Sum/Solution.java

@@ -0,0 +1,13 @@
+class Solution {
+    public long maximumAlternatingSubarraySum(int[] nums) {
+        long ans = nums[0];
+        long a = nums[0], b = -(1 << 30);
+        for (int i = 1; i < nums.length; ++i) {
+            long c = a, d = b;
+            a = Math.max(nums[i], d + nums[i]);
+            b = c - nums[i];
+            ans = Math.max(ans, Math.max(a, b));
+        }
+        return ans;
+    }
+}

solution/2000-2099/2036.Maximum Alternating Subarray Sum/Solution.py

@@ -0,0 +1,8 @@
+class Solution:
+    def maximumAlternatingSubarraySum(self, nums: List[int]) -> int:
+        ans = nums[0]
+        a, b = nums[0], -inf
+        for v in nums[1:]:
+            a, b = max(v, b + v), a - v
+            ans = max(ans, a, b)
+        return ans