文章提供了三个使用动态规划解决的打家劫舍问题的代码实现，分别是基于数组的一维动态规划、考虑首尾两种情况的二维动态规划，以及处理二叉树结构的递归方法。每个问题都涉及到在给定序列或树结构中选择部分元素以最大化收益的决策过程。
198 打家劫舍
代码如下
func rob(nums []int) int {
if len(nums) == 1 {
return nums[0]
}
dp := make([]int,len(nums))
dp[0] = nums[0]
dp[1] = max(nums[0],nums[1])
for i := 2 ; i < len(nums) ; i++ { //如果选择偷这个房间，那么这个房间的前一个房间就不能够偷，所以就要取前两个房间的最大值加上这个房间的值，如果不偷这个房间，取得就是到前一个房间所能取得最大值
dp[i] = max(dp[i-1],dp[i-2]+nums[i])
}
return dp[len(nums)-1]
}
func max(a,b int) int {
if a > b {
return a
}else {
return b
}
}
213 打家劫舍二
代码如下
func rob(nums []int) int { //这里和前面的思路是类似的，只不过需要分成2种情况讨论，即去掉首元素或者去掉最后一个元素两种情况 其他和打家劫舍1相同
if len(nums) == 1 {
return nums[0]
}
if len(nums) == 2 {
return max(nums[0],nums[1])
}
result1 := robrange(nums[:len(nums)-1])
result2 := robrange(nums[1:])
return max(result1,result2)
}
func robrange(nums []int) int {
dp := make([]int,len(nums))
dp[0] = nums[0]
dp[1] = max(nums[0],nums[1])
for i := 2 ; i < len(nums) ; i++ {
dp[i] = max(dp[i-1],dp[i-2]+nums[i])
}
return dp[len(nums)-1]
}
func max(a,b int) int {
if a > b {
return a
}else {
return b
}
}
337 打家劫舍3
代码如下
/**
* Definition for a binary tree node.
* type TreeNode struct {
* Val int
* Left *TreeNode
* Right *TreeNode
* }
*/
func rob(root *TreeNode) int {
res := robtree(root)
return max(res[0],res[1])
}
func max(a,b int) int {
if a > b {
return a
}else {
return b
}
}
func robtree(cur *TreeNode) []int { //用后续遍历遍历这个二叉树，返回值为一个切片，切片里含有两个元素，一个是偷当前节点的值，一个是不偷当前节点的值，记作dp[0]和dp[1]
if cur == nil {
return []int{0,0}
}
leftdp := robtree(cur.Left) //遍历左子树
rightdp := robtree(cur.Right) //遍历右子树
robcur := cur.Val + leftdp[0] + rightdp[0] //如果偷当前节点的值，那么就要加上当前节点的值，并且左右子树都要选择不偷的状态
norobcur := max(leftdp[0],leftdp[1]) + max(rightdp[0],rightdp[1]) //如果不偷当前节点的值，那么就要取选择是否偷左右子树，在偷与不偷左右子树中选择一个最大值
return []int{norobcur,robcur} //最后将当前节点偷与不偷的两种情况返回上一层
}
扫一扫
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
