打家劫舍1

問題描述

你是一個專業的小偷，計劃偷竊沿街的房屋。每間房內都藏有一定的現金，影響你偷竊的唯一制約因素就是相鄰的房屋裝有相互連通的防盜系統，如果兩間相鄰的房屋在同一晚上被小偷闖入，系統會自動報警。

給定一個代表每個房屋存放金額的非負整數數組，計算你 不觸動警報裝置的情況下 ，一夜之內能夠偷竊到的最高金額。

思路

動態規劃的思路
1 確定dp
dp[i] 指的是有i間房，此時偷取的最高金額

2 確實狀態變化規則
dp[i]: 有i間房，偷取的最高金額
dp[i-1] : 有i-1間房，。。。。。
dp[i-2] : 有i-2 間房，。。。。。
value [i] :第i間房的金額
因為不能相鄰，dp[i] 和 dp[i-1] 以及dp[i-2]有關
第i間房偷取：dp[i] = dp[i-2] + value[i]
第i間房不偷取： dp[i] = dp [i-1]

dp [i] = max(d[i-1] ,dp[i-2]+value[i]

3 初始化
dp[0] =0
dp[1] = value [0]

4 確定遍歷的順序
從前往后
‘5 舉例
。。。。。。

go語言實現

func rob(nums []int) int {
    res := make([]int,len(nums)+1)
    res[0] = 0 //表示沒房的時候，偷取金額為0
    res[1] = nums[0]
    for i:=2; i<len(res); i++ {
        res[i] = max(res[i-1],res[i-2]+nums[i-1])
    }
    return res[len(nums)]
}
func max(a,b int) int {
    if a>b {
        return a
    } else {
        return b
    }
}

打家劫舍2

問題描述

你是一個專業的小偷，計劃偷竊沿街的房屋，每間房內都藏有一定的現金。這個地方所有的房屋都 圍成一圈 ，這意味著第一個房屋和最后一個房屋是緊挨著的。同時，相鄰的房屋裝有相互連通的防盜系統，如果兩間相鄰的房屋在同一晚上被小偷闖入，系統會自動報警 。

給定一個代表每個房屋存放金額的非負整數數組，計算你 在不觸動警報裝置的情況下 ，今晚能夠偷竊到的最高金額。

思路

這個和上面的類似。
不過要考慮到首尾的情況

1 首部不偷取， 即只需 rob( nums[1:])
2 尾部不偷取，rob （nums[:len(nums)-1)
3 都不偷取， rob(nums[1:len(nums)-1)

1和2 包含第三種情況
動態規劃思路和第一個一樣

go語言實現

func rob(nums []int) int {
    if len(nums) == 1 {
        return nums[0]
    }
    res1 , res2 := 0, 0
    res1 = robOne(nums,0,len(nums)-1)
    res2 = robOne(nums,1,len(nums))
    return max(res1,res2)
}
//把代碼抽離出來，避免重復代碼
func robOne(nums []int, start,end int) int {
    res := make([]int,end-start+1)
    res[0] = 0
    res[1] = nums[start]
    start++
    for i:=2; i<len(res); i++ {
        res[i] = max(res[i-1],res[i-2]+nums[start])
        start++
    }
    return res[len(res)-1]
}
func max(a,b int) int {
    if a>b {
        return a
    } else {
        return b
    }
}

打家劫舍3

問題描述

小偷又發現了一個新的可行竊的地區。這個地區只有一個入口，我們稱之為 root 。

除了 root 之外，每棟房子有且只有一個“父“房子與之相連。一番偵察之后，聰明的小偷意識到“這個地方的所有房屋的排列類似于一棵二叉樹”。 如果 兩個直接相連的房子在同一天晚上被打劫 ，房屋將自動報警。

給定二叉樹的 root 。返回 在不觸動警報的情況下 ，小偷能夠盜取的最高金額 。

思路

1 二叉樹遍歷+記憶法
采用中序遍歷：根 + 左 + 右
用 resmap 記錄遍歷過 的樹節點
在遍歷之前，先判斷當前的root（樹）是否以及遍歷過。

   if root== nil {
        return 0
    }
    if _, ok := resmap[root]; ok { 
        return resmap[root]
    } 

2 動態規劃

一個節點有兩個狀態，即偷還是不偷，而這個狀態有左右子節點所決定，
root： value[x,y] #x是當前節點偷的最大金額，y是不偷
root.Left: value[x1,y1]
root.Right: value[x2,y2]

x = root.val + x1 + x2
y = max(x1,y1) + max(x2,y2)
這里需要用到后序遍歷： 左右根

葉子節點往上遍歷，

go語言實現

/**
 * Definition for a binary tree node.
 * type TreeNode struct {
 *     Val int
 *     Left *TreeNode
 *     Right *TreeNode
 * }
 */
var resmap = make(map[*TreeNode]int)
func rob(root *TreeNode) int {
      res := dan(root)
      return max(res[0],res[1])
}
//動態規劃
func dan(root *TreeNode) []int {
    if root== nil { return []int{0,0} }
    left := dan(root.Left)
    right := dan(root.Right)

    v1 := root.Val + left[0] + right[0]
    v2 := max(left[0],left[1]) + max(right[0],right[1])

    return []int{v2, v1}
}
func max(a,b int) int {
    if a>b {
        return a
    }
    return b
}
//遍歷，記憶
func memory(root *TreeNode) int {
    if root== nil {
        return 0
    }
    if _, ok := resmap[root]; ok { 
        return resmap[root]
    } 
    if root.Left==nil && root.Right == nil {
        return root.Val
    }
    value1 := root.Val
    if root.Left != nil {
        value1 += rob(root.Left.Left) + rob(root.Left.Right)
    }
    if root.Right != nil  {
        value1 += rob(root.Right.Left) + rob(root.Right.Right)
    }

    value2 := rob(root.Left) + rob(root.Right)
    resmap[root] = max(value2,value1)
    return max(value1,value2) 
}