代码随想录day27|455分发饼干376摆动序列53最大子序和|01笔记

麟一01
79 阅读2分钟
  • 贪心-代码随想录 (programmercarl.com)

  • 455分发饼干

  • 455-代码随想录 (programmercarl.com)

  • 第一印象

  • 满足最多孩子的方式就是不浪费大块饼干。因此可以排序后从胃口大的孩子遍历。
  • 也可以从饼干的小到达进行遍历。然后顺序满足孩子。

  • 解题代码

  • 从小到大
  •     //排序后，局部最优
    func findContentChildren(g []int, s []int) int {
      sort.Ints(g)
      sort.Ints(s)
    
      // 从小到大
      child := 0
      for sIdx := 0; child < len(g) && sIdx < len(s); sIdx++ {
        if s[sIdx] >= g[child] {//如果饼干的大小大于或等于孩子的为空则给与，否则不给予，继续寻找选一个饼干是否符合
          child++
        }
      }
    
      return child
    }
  • 从大到小
  •     func findContentChildren(g []int, s []int) int {
      sort.Ints(g)
      sort.Ints(s)
    
      //从大到小
      child := 0
      sIdx := len(s)-1
      for gIdx:=len(g)-1;gIdx>=0&&sIdx>=0;gIdx-- {
          if g[gIdx] <= s[sIdx] {
              child++
              sIdx--
          }
      }
      return child
    }

  • 376摆动序列

  • 代码随想录 (programmercarl.com)

  • 第一印象

  • 需要存储之前的的差值来判断子数组的增加。遍历一次即可

  • 遇到问题

  • 错误代码
  •     func wiggleMaxLength(nums []int) int {
        len := len(nums)
        if len==1 || len==0 {
            return len
        }
        if len==2 {
            if nums[0]!=nums[1] {
                return 2
            } else {
                return 1
            }
        }
        ans := 1
        curlenth := 1
        preMinus := nums[1] - nums[0]
        if preMinus!=0 {
            curlenth = 2   
        }
    
        for i:=2;i<len;i++ {
            curMinus := nums[i] - nums[i-1]
            if (curMinus*preMinus) < 0 {
                curlenth++
            } else {
                ans = max(ans, curlenth)
                curlenth = 2
            }
            preMinus = curMinus
        }
        ans = max(curlenth, ans)
        return ans
    }
    
    func max(x int, y int) int {
        if x > y {
            return x    
        } else {
            return y
        }
    }

image.png

  • 错误原因：以上代码是求连续子摆动序列的代码。。。。

  • 讲解观后感

  • 纪录峰值，并讨论峰值情况是自己没有想到的解题思路。出现峰值转换的时候才记录当前值以及pre的更新是逻辑要点。
  • 动态规划的方方法中，

  • 解题代码

  • 贪心
  •      func wiggleMaxLength(nums []int) int {
     	n := len(nums)
     	if n < 2 {
     		return n
     	}
     	ans := 1
     	prevDiff := nums[1] - nums[0]
     	if prevDiff != 0 {
     		ans = 2
     	}
     	for i := 2; i < n; i++ {
     		diff := nums[i] - nums[i-1]
     		if diff > 0 && prevDiff <= 0 || diff < 0 && prevDiff >= 0 {
     			ans++
     			prevDiff = diff// 注意这里，只在摆动变化的时候更新prediff 
     		}
     	}
     	return ans
     }
  • 动态规划
  •      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
     	}
     }

  • 53最大子序和

  • 代码随想录 (programmercarl.com)

  • 第一印象

  • 暴力解法就是用两层for循环求所有子序列的和，然后保留最大值返回。

  • 讲解观后感

  • 贪心的方法就是当前面的he为负数时，直接从当前值重新计算，最后取保留的最大值即可。

  • 解题代码

  • go语言可以直接利用原数组空间进行和的存储，遇到前面和为负数时则重新从当前数字算起。
  •     func maxSubArray(nums []int) int {
        maxSum := nums[0]
        for i := 1; i < len(nums); i++ {
            if nums[i] + nums[i-1] > nums[i] { 
                nums[i] += nums[i-1]
            }
            if nums[i] > maxSum {
                maxSum = nums[i]
            }
        }
        return maxSum
    }
  • 动态规划：
  •     func maxSubArray(nums []int) int {
        if  len(nums) == 0 {
            return 0
        }
        dp := make([]int, len(nums))
        dp[0] = nums[0]
    
        ans := dp[0]
    
        for i:=1;i<len(nums);i++ {
            dp[i] = max(nums[i], dp[i-1] + nums[i])
            if dp[i] > ans {
                ans = dp[i]
            }
        }
        return ans
    }
    
    func max(x int, y int) int {
        if x>y {
            return x
        } else {
            return y
        }
    }
avatar
文章
阅读
粉丝