数组区间和的一种变体

最新推荐文章于 2025-11-11 16:01:52 发布

原创最新推荐文章于 2025-11-11 16:01:52 发布 · 483 阅读

0 ·

CC 4.0 BY-SA版权

文章标签：

#leetcode

Algorithm 专栏收录该内容

9 篇文章

订阅专栏

这组问题依然来自leetcode，题目的背景是这样的：给定一个数组代表一个街上的所有人家，每个数字代表小偷可以从这家得到的钱数，并且侵入相连的两家都会导致他们报警，那么问题来了，这篇文章的题目应该是如何抢劫吗？不瞒您说，还真是。

那怎么安排“做事”的顺序才能使得今晚得到的财富最多呢？如果允许连续抢劫，那不就是数组区间和的问题么(有关数组区间和的问题，见另一篇博客如何找到区间数组的最大和？最大积？)，与之相同，这也是一个简单的动态规划问题。递归的公式是： dp[k] = max(dp[k-1],dp[k-2]+nums[i]),代码如下：

public int rob(int[] nums) {
        int n = nums.length;
        if(n == 0) return 0;
        if(n == 1) return nums[0];
        int[] dp = new int[n];
        dp[0] = nums[0];
        dp[1] = Math.max(nums[0], nums[1]);

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

因为每次计算只需要dp数组中的两个值所以空间复杂度还可以继续优化。如果对这个街区的形状变通一下，让他们首位相连形成一个环状，那么上面的解法就不再适用了，这是因为第一个居民和最后一个居民有可能同事被抢劫，这在直线的街道中不会触发警报，但是在环状的街区就不行了。

我们可以这样想，以最后的一个房子为例，可以将所有的抢劫方案分成两种，一种是包含最后一间房子，另一种就是不包含最后一个房子。如果方案中不包含最后一个房子，那问题实际上就变成了之前的样子了，如果包含了最后一间房子，那么肯定就不会包括第一间房子了，所以这个大问题包含了这样两个可能的方案，而这两个方案实际上和前面的问题是一致的。代码如下：

public int rob(int[] nums) {
        if(nums.length == 1) return nums[0];
        int x = rob(nums, 0, nums.length - 2);
        int y = rob(nums, 1, nums.length - 1);
        return Math.max(x,y);
    }

    public int rob(int[] nums, int s, int e) {
        int p = 0, q = 0;
        for(int i = s; i <= e; i++) {
            int t = Math.max(q, p + nums[i]);
            p = q;
            q = t;
        }
        return q;
    }

在这里我们使用了之前提到的空间复杂度的优化方法。还可以继续改变街区的形状，让其变成一棵二叉树。如果街道的形状变成这样，那之前的方法就都不适用了，应该转到二叉树的领域思考这个问题，可以看到，这个问题还是有子结构的，所以可以用递归的方法做：

public int rob(TreeNode root) {
        if(root == null) return 0;
        int x = 0, y = 0, p = 0, q = 0;
        if(root.left != null) {
            x = rob(root.left.left);
            y = rob(root.left.right);
        }
        if(root.right != null) {
            p = rob(root.right.left);
            q = rob(root.right.right);
        }

        return Math.max(root.val+x+y+p+q, rob(root.left)+rob(root.right));
    }

从运行结果看，时间复杂度是很低的，这是因为我们从树根节点开始，对同一个节点可能重复递归，所以时间复杂度很高，为了避免重复递归，我们用一个map保存之前的结果，可以迅速将时间降下来。

public int rob(TreeNode root) {
        Map<TreeNode, Integer> map = new HashMap<TreeNode, Integer>();
        return rob(root, map);
    }
    public int rob(TreeNode root, Map<TreeNode, Integer> map) {
        if(root == null) return 0;
        if(map.containsKey(root)) return map.get(root);

        int val = 0;

        if(root.left != null) {
            val += rob(root.left.left, map) + rob(root.left.right, map); 
        }
        if(root.right != null) {
            val += rob(root.right.left, map) + rob(root.right.right, map);
        }

        val = Math.max(root.val + val, rob(root.left, map) + rob(root.right, map));
        map.put(root, val);
        return val;
    }