Skip to content

Commit 401e997

Browse files
yanglbmeyanglbme
committed
feat: add solutions to lc problem: No.1911
No.1911.Maximum Alternating Subsequence Sum
1 parent fadde48 commit 401e997

File tree

6 files changed

+296
-5
lines changed

6 files changed

+296
-5
lines changed

‎solution/1900-1999/1911.Maximum Alternating Subsequence Sum/README.md

+139
Original file line numberDiff line numberDiff line change
@@ -55,22 +55,161 @@
5555

5656
<!-- 这里可写通用的实现逻辑 -->
5757

58+
**方法一：动态规划**
59+
60+
我们定义 $f[i]$ 表示从前 $i$ 个元素中选出的子序列，且最后一个元素为奇数下标时的最大交替和，定义 $g[i]$ 表示从前 $i$ 个元素中选出的子序列，且最后一个元素为偶数下标时的最大交替和。初始时 $f[0] = g[0] = 0$。答案为 $max(f[n], g[n])$。
61+
62+
我们考虑第 $i$ 个元素 $nums[i - 1]$：
63+
64+
如果选取该元素且该元素为奇数下标，那么上一个元素必须为偶数下标，且只能从前 $i-1$ 个元素中选取，因此 $f[i] = g[i - 1] - nums[i - 1]$；如果不选取该元素，那么 $f[i] = f[i - 1]$。
65+
66+
同理，如果选取该元素且该元素为偶数下标，那么上一个元素必须为奇数下标，且只能从前 $i-1$ 个元素中选取，因此 $g[i] = f[i - 1] + nums[i - 1]$；如果不选取该元素，那么 $g[i] = g[i - 1]$。
67+
68+
综上，我们可以得到状态转移方程：
69+
70+
$$
71+
\begin{aligned}
72+
f[i] &= max(g[i - 1] - nums[i - 1], f[i - 1]) \\
73+
g[i] &= max(f[i - 1] + nums[i - 1], g[i - 1])
74+
\end{aligned}
75+
$$
76+
77+
最终答案为 $max(f[n], g[n])$。
78+
79+
我们注意到 $f[i]$ 和 $g[i]$ 只与 $f[i - 1]$ 和 $g[i - 1]$ 有关，因此我们可以使用两个变量代替数组，将空间复杂度降低到 $O(1)$。
80+
81+
时间复杂度 $O(n)$，其中 $n$ 为数组长度。
82+
5883
<!-- tabs:start -->
5984

6085
### **Python3**
6186

6287
<!-- 这里可写当前语言的特殊实现逻辑 -->
6388

6489
```python
90+
class Solution:
91+
def maxAlternatingSum(self, nums: List[int]) -> int:
92+
n = len(nums)
93+
f = [0] * (n + 1)
94+
g = [0] * (n + 1)
95+
for i, x in enumerate(nums, 1):
96+
f[i] = max(g[i - 1] - x, f[i - 1])
97+
g[i] = max(f[i - 1] + x, g[i - 1])
98+
return max(f[n], g[n])
99+
```
65100

101+
```python
102+
class Solution:
103+
def maxAlternatingSum(self, nums: List[int]) -> int:
104+
f = g = 0
105+
for x in nums:
106+
f, g = max(g - x, f), max(f + x, g)
107+
return max(f, g)
66108
```
67109

68110
### **Java**
69111

70112
<!-- 这里可写当前语言的特殊实现逻辑 -->
71113

72114
```java
115+
class Solution {
116+
public long maxAlternatingSum(int[] nums) {
117+
int n = nums.length;
118+
long[] f = new long[n + 1];
119+
long[] g = new long[n + 1];
120+
for (int i = 1; i <= n; ++i) {
121+
f[i] = Math.max(g[i - 1] - nums[i - 1], f[i - 1]);
122+
g[i] = Math.max(f[i - 1] + nums[i - 1], g[i - 1]);
123+
}
124+
return Math.max(f[n], g[n]);
125+
}
126+
}
127+
```
128+
129+
```java
130+
class Solution {
131+
public long maxAlternatingSum(int[] nums) {
132+
long f = 0, g = 0;
133+
for (int x : nums) {
134+
long ff = Math.max(g - x, f);
135+
long gg = Math.max(f + x, g);
136+
f = ff;
137+
g = gg;
138+
}
139+
return Math.max(f, g);
140+
}
141+
}
142+
```
143+
144+
### **C++**
145+
146+
```cpp
147+
class Solution {
148+
public:
149+
long long maxAlternatingSum(vector<int>& nums) {
150+
int n = nums.size();
151+
vector<long long> f(n + 1), g(n + 1);
152+
for (int i = 1; i <= n; ++i) {
153+
f[i] = max(g[i - 1] - nums[i - 1], f[i - 1]);
154+
g[i] = max(f[i - 1] + nums[i - 1], g[i - 1]);
155+
}
156+
return max(f[n], g[n]);
157+
}
158+
};
159+
```
160+
161+
```cpp
162+
class Solution {
163+
public:
164+
long long maxAlternatingSum(vector<int>& nums) {
165+
long long f = 0, g = 0;
166+
for (int& x : nums) {
167+
long ff = max(g - x, f), gg = max(f + x, g);
168+
f = ff, g = gg;
169+
}
170+
return max(f, g);
171+
}
172+
};
173+
```
174+
175+
### **Go**
176+
177+
```go
178+
func maxAlternatingSum(nums []int) int64 {
179+
n := len(nums)
180+
f := make([]int, n+1)
181+
g := make([]int, n+1)
182+
for i, x := range nums {
183+
i++
184+
f[i] = max(g[i-1]-x, f[i-1])
185+
g[i] = max(f[i-1]+x, g[i-1])
186+
}
187+
return int64(max(f[n], g[n]))
188+
}
189+
190+
func max(a, b int) int {
191+
if a > b {
192+
return a
193+
}
194+
return b
195+
}
196+
```
73197

198+
```go
199+
func maxAlternatingSum(nums []int) int64 {
200+
var f, g int
201+
for _, x := range nums {
202+
f, g = max(g-x, f), max(f+x, g)
203+
}
204+
return int64(max(f, g))
205+
}
206+
207+
func max(a, b int) int {
208+
if a > b {
209+
return a
210+
}
211+
return b
212+
}
74213
```
75214

76215
### **...**

‎solution/1900-1999/1911.Maximum Alternating Subsequence Sum/README_EN.md

+114-5
Original file line numberDiff line numberDiff line change
@@ -7,9 +7,7 @@
77
<p>The <strong>alternating sum</strong> of a <strong>0-indexed</strong> array is defined as the <strong>sum</strong> of the elements at <strong>even</strong> indices <strong>minus</strong> the <strong>sum</strong> of the elements at <strong>odd</strong> indices.</p>
88

99
<ul>
10-
1110
<li>For example, the alternating sum of <code>[4,2,5,3]</code> is <code>(4 + 5) - (2 + 3) = 4</code>.</li>
12-
1311
</ul>
1412

1513
<p>Given an array <code>nums</code>, return <em>the <strong>maximum alternating sum</strong> of any subsequence of </em><code>nums</code><em> (after <strong>reindexing</strong> the elements of the subsequence)</em>.</p>
@@ -63,11 +61,8 @@
6361
<p><strong>Constraints:</strong></p>
6462

6563
<ul>
66-
6764
<li><code>1 &lt;= nums.length &lt;= 10<sup>5</sup></code></li>
68-
6965
<li><code>1 &lt;= nums[i] &lt;= 10<sup>5</sup></code></li>
70-
7166
</ul>
7267

7368
## Solutions
@@ -77,13 +72,127 @@
7772
### **Python3**
7873

7974
```python
75+
class Solution:
76+
def maxAlternatingSum(self, nums: List[int]) -> int:
77+
n = len(nums)
78+
f = [0] * (n + 1)
79+
g = [0] * (n + 1)
80+
for i, x in enumerate(nums, 1):
81+
f[i] = max(g[i - 1] - x, f[i - 1])
82+
g[i] = max(f[i - 1] + x, g[i - 1])
83+
return max(f[n], g[n])
84+
```
8085

86+
```python
87+
class Solution:
88+
def maxAlternatingSum(self, nums: List[int]) -> int:
89+
f = g = 0
90+
for x in nums:
91+
f, g = max(g - x, f), max(f + x, g)
92+
return max(f, g)
8193
```
8294

8395
### **Java**
8496

8597
```java
98+
class Solution {
99+
public long maxAlternatingSum(int[] nums) {
100+
int n = nums.length;
101+
long[] f = new long[n + 1];
102+
long[] g = new long[n + 1];
103+
for (int i = 1; i <= n; ++i) {
104+
f[i] = Math.max(g[i - 1] - nums[i - 1], f[i - 1]);
105+
g[i] = Math.max(f[i - 1] + nums[i - 1], g[i - 1]);
106+
}
107+
return Math.max(f[n], g[n]);
108+
}
109+
}
110+
```
111+
112+
```java
113+
class Solution {
114+
public long maxAlternatingSum(int[] nums) {
115+
long f = 0, g = 0;
116+
for (int x : nums) {
117+
long ff = Math.max(g - x, f);
118+
long gg = Math.max(f + x, g);
119+
f = ff;
120+
g = gg;
121+
}
122+
return Math.max(f, g);
123+
}
124+
}
125+
```
126+
127+
### **C++**
128+
129+
```cpp
130+
class Solution {
131+
public:
132+
long long maxAlternatingSum(vector<int>& nums) {
133+
int n = nums.size();
134+
vector<long long> f(n + 1), g(n + 1);
135+
for (int i = 1; i <= n; ++i) {
136+
f[i] = max(g[i - 1] - nums[i - 1], f[i - 1]);
137+
g[i] = max(f[i - 1] + nums[i - 1], g[i - 1]);
138+
}
139+
return max(f[n], g[n]);
140+
}
141+
};
142+
```
143+
144+
```cpp
145+
class Solution {
146+
public:
147+
long long maxAlternatingSum(vector<int>& nums) {
148+
long long f = 0, g = 0;
149+
for (int& x : nums) {
150+
long ff = max(g - x, f), gg = max(f + x, g);
151+
f = ff, g = gg;
152+
}
153+
return max(f, g);
154+
}
155+
};
156+
```
157+
158+
### **Go**
159+
160+
```go
161+
func maxAlternatingSum(nums []int) int64 {
162+
n := len(nums)
163+
f := make([]int, n+1)
164+
g := make([]int, n+1)
165+
for i, x := range nums {
166+
i++
167+
f[i] = max(g[i-1]-x, f[i-1])
168+
g[i] = max(f[i-1]+x, g[i-1])
169+
}
170+
return int64(max(f[n], g[n]))
171+
}
172+
173+
func max(a, b int) int {
174+
if a > b {
175+
return a
176+
}
177+
return b
178+
}
179+
```
86180

181+
```go
182+
func maxAlternatingSum(nums []int) int64 {
183+
var f, g int
184+
for _, x := range nums {
185+
f, g = max(g-x, f), max(f+x, g)
186+
}
187+
return int64(max(f, g))
188+
}
189+
190+
func max(a, b int) int {
191+
if a > b {
192+
return a
193+
}
194+
return b
195+
}
87196
```
88197

89198
### **...**

‎solution/1900-1999/1911.Maximum Alternating Subsequence Sum/Solution.cpp

+11
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,11 @@
1+
class Solution {
2+
public:
3+
long long maxAlternatingSum(vector<int>& nums) {
4+
long long f = 0, g = 0;
5+
for (int& x : nums) {
6+
long ff = max(g - x, f), gg = max(f + x, g);
7+
f = ff, g = gg;
8+
}
9+
return max(f, g);
10+
}
11+
};

‎solution/1900-1999/1911.Maximum Alternating Subsequence Sum/Solution.go

+14
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,14 @@
1+
func maxAlternatingSum(nums []int) int64 {
2+
var f, g int
3+
for _, x := range nums {
4+
f, g = max(g-x, f), max(f+x, g)
5+
}
6+
return int64(max(f, g))
7+
}
8+
9+
func max(a, b int) int {
10+
if a > b {
11+
return a
12+
}
13+
return b
14+
}

‎solution/1900-1999/1911.Maximum Alternating Subsequence Sum/Solution.java

+12
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,12 @@
1+
class Solution {
2+
public long maxAlternatingSum(int[] nums) {
3+
long f = 0, g = 0;
4+
for (int x : nums) {
5+
long ff = Math.max(g - x, f);
6+
long gg = Math.max(f + x, g);
7+
f = ff;
8+
g = gg;
9+
}
10+
return Math.max(f, g);
11+
}
12+
}

‎solution/1900-1999/1911.Maximum Alternating Subsequence Sum/Solution.py

+6
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,6 @@
1+
class Solution:
2+
def maxAlternatingSum(self, nums: List[int]) -> int:
3+
f = g = 0
4+
for x in nums:
5+
f, g = max(g - x, f), max(f + x, g)
6+
return max(f, g)

0 commit comments

Comments
 (0)