Update 0376.摆动序列.md

按着讲解的原理，分别完善了Golang版本的贪心算法和动态规划算法。

problems/0376.摆动序列.md

@@ -266,22 +266,58 @@ class Solution:
 
 ### Go 
 
+**贪心**
 ```golang
 func wiggleMaxLength(nums []int) int {
-    var count,preDiff,curDiff  int
-    count=1
-    if len(nums)<2{
-        return count
-    }
-    for i:=0;i<len(nums)-1;i++{
-        curDiff=nums[i+1]-nums[i]
-        //如果有正有负则更新下标值||或者只有前一个元素为0（针对两个不等元素的序列也视作摆动序列，且摆动长度为2）
-        if (curDiff > 0 && preDiff <= 0) || (preDiff >= 0 && curDiff < 0){
-            preDiff=curDiff
-            count++
-        }
-    }
-    return count
+	var count, preDiff, curDiff int //初始化默认为0
+	count = 1                       // 初始化为1，因为最小的序列是1个数
+	if len(nums) < 2 {
+		return count
+	}
+	for i := 0; i < len(nums)-1; i++ {
+		curDiff = nums[i+1] - nums[i]
+		if (curDiff > 0 && preDiff <= 0) || (curDiff < 0 && preDiff >= 0) {
+			count++
+		}
+	}
+	return count
+}
+```
+
+**动态规划**
+```golang
+func wiggleMaxLength(nums []int) int {
+	n := len(nums)
+	if n <= 1 {
+		return n
+	}
+	dp := make([][2]int, n)
+	//  i 0 作为波峰的最大长度
+	//  i 1 作为波谷的最大长度
+	dp[0][0] = 1
+	dp[0][1] = 1
+	for i := 0; i < n; i++ {
+		for j := 0; j < i; j++ {
+			if nums[j] > nums[i] { //nums[i]为波谷
+				dp[i][1] = max(dp[i][1], dp[j][0]+1)
+			}
+			if nums[j] < nums[i] { //nums[i]为波峰 或者相等
+				dp[i][0] = max(dp[i][0], dp[j][1]+1)
+			}
+			if nums[j] == nums[i] { //添加一种情况，nums[i]为相等
+				dp[i][0] = max(dp[i][0], dp[j][0]) //波峰
+				dp[i][1] = max(dp[i][1], dp[j][1]) //波谷
+			}
+		}
+	}
+	return max(dp[n-1][0], dp[n-1][1])
+}
+func max(a, b int) int {
+	if a > b {
+		return a
+	} else {
+		return b
+	}
 }
 ```