【leetcode】打家劫舍

打家劫舍

题目： 你是一个专业的小偷，计划偷窃沿街的房屋。每间房内都藏有一定的现金，影响你偷窃的唯一制约因素就是相邻的房屋装有相互连通的防盗系统，如果两间相邻的房屋在同一晚上被小偷闯入，系统会自动报警。给定一个代表每个房屋存放金额的非负整数数组，计算你 不触动警报装置的情况下 ，一夜之内能够偷窃到的最高金额。
示例：

输入：[1,2,3,1]
输出：4
解释：偷窃 1 号房屋 (金额 = 1) ，然后偷窃 3 号房屋 (金额 = 3)。
     偷窃到的最高金额 = 1 + 3 = 4 。
     
输入：[2,7,9,3,1]
输出：12
解释：偷窃 1 号房屋 (金额 = 2), 偷窃 3 号房屋 (金额 = 9)，接着偷窃 5 号房屋 (金额 = 1)。
     偷窃到的最高金额 = 2 + 9 + 1 = 12 。

题解： dp[i]表示0-i能偷的最大金额，dp[i]由两种情况中的最大值转移过来

• dp[i - 2] + nums[i] 表示偷当前位置，那么i-1的位置不能偷，而且需要加上dp[i-2],也就是前i-2个房间的金钱
• dp[i - 1]表示偷当前位置，只偷i-1的房间
• 复杂度：时间复杂度O(n)，遍历一次数组，空间复杂度O(1)，状态压缩之后是O(1)，没有状态压缩是O(n)

/**
 * @param {number[]} nums
 * @return {number}
 */
var rob = function(nums) {
    //dp[i]:表示0-i所能偷的最大金额
    //dp[i]分为两种情况，①偷当前i家，则i-1家就不能偷,dp[i]=dp[i-2]+nums[i]
    //②不偷第i家,dp[i]=dp[i-1]
    let dp = new Array(nums.length);
    dp[0] = nums[0];
    dp[1] = Math.max(nums[0],nums[1])

    for(let i=2;i<nums.length;i++){
        dp[i] = Math.max(dp[i-2]+nums[i],dp[i-1]);
    }
    return dp[nums.length-1];
};

打家劫舍II

题目： 你是一个专业的小偷，计划偷窃沿街的房屋，每间房内都藏有一定的现金。这个地方所有的房屋都 围成一圈 ，这意味着第一个房屋和最后一个房屋是紧挨着的。同时，相邻的房屋装有相互连通的防盗系统，如果两间相邻的房屋在同一晚上被小偷闯入，系统会自动报警 。给定一个代表每个房屋存放金额的非负整数数组，计算你 在不触动警报装置的情况下 ，今晚能够偷窃到的最高金额。
示例：

输入：nums = [2,3,2]
输出：3
解释：你不能先偷窃 1 号房屋（金额 = 2），然后偷窃 3 号房屋（金额 = 2）, 因为他们是相邻的。

输入：nums = [1,2,3,1]
输出：4
解释：你可以先偷窃 1 号房屋（金额 = 1），然后偷窃 3 号房屋（金额 = 3）。
     偷窃到的最高金额 = 1 + 3 = 4 。

题解： 这道题分为三种情况

• 如果只有一家人，则直接返回
• 如果有两家人，则返回存放金额大的
• 如果大于两家人，则又分为两种情况
  • 偷第一家人，则最后一家不能偷，那么则要从num的0到n-1家dp
  • 偷最后一家人，则第一家人不能偷，那么则要从num的1到n家dp

/**
 * @param {number[]} nums
 * @return {number}
 */
var rob = function(nums) {
    let n = nums.length;
    if(n==1){
        return nums[0];
    }
    if(n==2){
        return Math.max(nums[0],nums[1]);
    }
    
    return Math.max(robRange(nums, 0, n-1), robRange(nums, 1, n))
};

function robRange (nums, start, end){
    let n = nums.length;
    let dp = new Array(n).fill(0);
    dp[start]=nums[start];
    dp[start+1]=Math.max(nums[start],nums[start+1]);

    for(let i=start+2;i<end;i++){
        dp[i] = Math.max(dp[i-1],dp[i-2]+nums[i])
    }
    return dp[end-1];
}

打家劫舍III

题解： 简化这个问题，二叉树上的每个节点都有对应权值，每个点都有两个状态（选中和不选中），在不能同时选中有父子关系的点的情况下，能选中的点的最大权值和是多少
$f(o)$ 表示选择 $o$节点的情况下，$o$ 节点的子树上被选择的节点的最大权值和；$g(o)$ 表示不选择 $o$节点的情况下，$o$ 节点的子树上被选择的节点的最大权值和；$l$ 和 $r$ 代表$o$的左右孩子。

• 当 $o$被选中时，$o$ 的左右孩子都不能被选中，故 $o$ 被选中情况下子树上被选中点的最大权值和为 $l$ 和 $rr=$ 不被选中的最大权值和相加，即 $f(o)=g(l)+g(r)$。
• 当 $o$不被选中时，$o$ 的左右孩子可以被选中，也可以不被选中。对于 $o$ 的某个具体的孩子 xx，它对 $o$ 的贡献是 xx 被选中和不被选中情况下权值和的较大值。故 g ( o ) = m a x { f ( l ) , g ( l ) } + m a x { f ( r ) , g ( r ) } g(o) = max \{ f(l) , g(l) \}+ max\{ f(r) , g(r) \} g(o)=max{f(l),g(l)}+max{f(r),g(r)}。
• 可以用哈希表来存 ff 和 gg 的函数值，用深度优先搜索的办法后序遍历这棵二叉树，我们就可以得到每一个节点的 ff 和 gg。根节点的 ff 和 gg 的最大值就是我们要找的答案。

var rob = function(root) {
    const f = new Map();
    const g = new Map();

    const dfs = (node) => {
        if (node === null) {
            return;
        }
        dfs(node.left);
        dfs(node.right);
        f.set(node, node.val + (g.get(node.left) || 0) + (g.get(node.right) || 0));
        g.set(node, Math.max(f.get(node.left) || 0, g.get(node.left) || 0) + Math.max(f.get(node.right) || 0, g.get(node.right) || 0));
    }
    
    dfs(root);
    return Math.max(f.get(root) || 0, g.get(root) || 0);
};