Update 0376.摆动序列.md

problems/0376.摆动序列.md

@@ -305,21 +305,43 @@ class Solution {
 
 ### Python
 
-**贪心**
+贪心（版本一）
+
+```python
+class Solution:
+    def wiggleMaxLength(self, nums):
+        if len(nums) <= 1:
+            return len(nums)  # 如果数组长度为0或1，则返回数组长度
+        curDiff = 0  # 当前一对元素的差值
+        preDiff = 0  # 前一对元素的差值
+        result = 1  # 记录峰值的个数，初始为1（默认最右边的元素被视为峰值）
+        for i in range(len(nums) - 1):
+            curDiff = nums[i + 1] - nums[i]  # 计算下一个元素与当前元素的差值
+            # 如果遇到一个峰值
+            if (preDiff <= 0 and curDiff > 0) or (preDiff >= 0 and curDiff < 0):
+                result += 1  # 峰值个数加1
+                preDiff = curDiff  # 注意这里，只在摆动变化的时候更新preDiff
+        return result  # 返回最长摆动子序列的长度
+
+```
+贪心（版本二）
 
 ```python
 class Solution:
     def wiggleMaxLength(self, nums: List[int]) -> int:
-        preC,curC,res = 0,0,1  #题目里nums长度大于等于1，当长度为1时，其实到不了for循环里去，所以不用考虑nums长度
+        if len(nums) <= 1:
+            return len(nums)  # 如果数组长度为0或1，则返回数组长度
+        preDiff,curDiff ,result  = 0,0,1  #题目里nums长度大于等于1，当长度为1时，其实到不了for循环里去，所以不用考虑nums长度
         for i in range(len(nums) - 1):
-            curC = nums[i + 1] - nums[i]
+            curDiff = nums[i + 1] - nums[i]
-            if curC * preC <= 0 and curC !=0:  #差值为0时，不算摆动
+            if curDiff * preDiff <= 0 and curDiff !=0:  #差值为0时，不算摆动
-                res += 1
+                result += 1
-                preC = curC  #如果当前差值和上一个差值为一正一负时，才需要用当前差值替代上一个差值
+                preDiff = curDiff  #如果当前差值和上一个差值为一正一负时，才需要用当前差值替代上一个差值
-        return res
+        return result
+
 ```
 
-**动态规划**
+动态规划（版本一）
 
 ```python
 class Solution:
@@ -341,25 +363,44 @@ class Solution:
         return max(dp[-1][0], dp[-1][1])
 ```
 
+动态规划（版本二）
+
 ```python
 class Solution:
-    def wiggleMaxLength(self, nums: List[int]) -> int:
+    def wiggleMaxLength(self, nums):
-        # up i作为波峰最长的序列长度
+        dp = [[0, 0] for _ in range(len(nums))]  # 创建二维dp数组，用于记录摆动序列的最大长度
-	# down i作为波谷最长的序列长度
+        dp[0][0] = dp[0][1] = 1  # 初始条件，序列中的第一个元素默认为峰值，最小长度为1
-        n = len(nums)
+        for i in range(1, len(nums)):
-	# 长度为0和1的直接返回长度
+            dp[i][0] = dp[i][1] = 1  # 初始化当前位置的dp值为1
-	if n<2: return n
+            for j in range(i):
-        for i in range(1,n):
+                if nums[j] > nums[i]:
-            if nums[i]>nums[i-1]:
+                    dp[i][1] = max(dp[i][1], dp[j][0] + 1)  # 如果前一个数比当前数大，可以形成一个上升峰值，更新dp[i][1]
-	    # nums[i] 为波峰，1. 前面是波峰，up值不变，2. 前面是波谷，down值加1
+            for j in range(i):
-	    # 目前up值取两者的较大值(其实down+1即可，可以推理前一步down和up最多相差1，所以down+1>=up)
+                if nums[j] < nums[i]:
-                up = max(up, down+1)
+                    dp[i][0] = max(dp[i][0], dp[j][1] + 1)  # 如果前一个数比当前数小，可以形成一个下降峰值，更新dp[i][0]
-            elif nums[i]<nums[i-1]:
+        return max(dp[-1][0], dp[-1][1])  # 返回最大的摆动序列长度
-	    # nums[i] 为波谷，1. 前面是波峰，up+1，2. 前面是波谷，down不变，取较大值
+
-                down = max(down, up+1)
-        return max(up, down)
 ```
 
+动态规划（版本三）优化
+
+```python
+class Solution:
+    def wiggleMaxLength(self, nums):
+        if len(nums) <= 1:
+            return len(nums)  # 如果数组长度为0或1，则返回数组长度
+        
+        up = down = 1  # 记录上升和下降摆动序列的最大长度
+        for i in range(1, len(nums)):
+            if nums[i] > nums[i-1]:
+                up = down + 1  # 如果当前数比前一个数大，则可以形成一个上升峰值
+            elif nums[i] < nums[i-1]:
+                down = up + 1  # 如果当前数比前一个数小，则可以形成一个下降峰值
+        
+        return max(up, down)  # 返回上升和下降摆动序列的最大长度
+
+
+```
 ### Go
 
 **贪心**