动态规划-打劫房屋

1 描述

假设你是一个专业的窃贼，准备沿着一条街打劫房屋。每个房子都存放着特定金额的钱。你面临的唯一约束条件是：相邻的房子装着相互联系的防盗系统，且 当相邻的两个房子同一天被打劫时，该系统会自动报警。

给定一个非负整数列表，表示每个房子中存放的钱， 算一算，如果今晚去打劫，在不触动报警装置的情况下, 你最多可以得到多少钱 。

2 样例

2.1 样例 1:

输入: [3, 8, 4]
输出: 8
解释: 仅仅打劫第二个房子.

2.2 样例 2:

输入: [5, 2, 1, 3]
输出: 8
解释: 抢第一个和最后一个房子

2.3 挑战

O(n) 时间复杂度 且 O(1) 存储。

3 题解

3.1 解题思路

3.1.1 标记当前的状态

开一个二维数组，用二维的数据值表示是否要偷当前的房子的金币：
f[i][0] 表示不偷房子i - 1的前提下，前i栋房子最多能偷的金币数
f[i][1] 表示偷房子i - 1的前提下，前i栋房子最多能偷的金币数
则转移方程可以列为如下：
f[i][0] = max{f[i-1][0], f[i-1][1]} 因为不偷房子i - 1，所以房子i - 2可以选择偷与不偷
f[i][1] = f[i-1][0] + a[i - 1] 因为要偷房子i - 1，所以房子i - 2必须不偷

3.1.2 简化方法

在不偷房子i - 1的前提下，前i栋房子中最多可以偷多少金币：其实就是前 i - 1栋房子最多可以偷多少金币；
因此我们可以将转化方程改为：
f[i]表示可以在前i栋房子最多偷的金币数
f[i] = max{f[i - 1], f[i - 2] + a[i - 1]} 表示在我不偷i - 1栋房子的时的最多金币数和偷第i - 1栋房子金币的最多金币数

3.2 实现方法

• 若为空，则直接返回0
• 初始化条件dp[0] = 0, dp[1] = a[0]
• dp[i] = Math.max(dp[i - 1], dp[i - 2] + a[i - 1]);
• 该算法的时间负责度为O(n)，空间复杂度为O(n)

public class Solution {
    /**
     * @param a: An array of non-negative integers
     * @return: The maximum amount of money you can rob tonight
     */
    public long houseRobber(int[] a) {
        // write your code here
        int n = a.length;
        if (n == 0) {
            return 0;
        }

        long[] dp = new long[n + 1];
        dp[0] = 0;
        dp[1] = a[0];
        for (int i = 2; i <= n; i++) {
            dp[i] = Math.max(dp[i - 1], dp[i - 2] + a[i - 1]);
        }

        return dp[n];
    }
}

3.2 优化空间复杂度的视线方法

要优化空间复杂度需要借助于滚动数组的方法去实现

public class Solution {
    /**
     * @param a: An array of non-negative integers
     * @return: The maximum amount of money you can rob tonight
     */
    public long houseRobber(int[] a) {
        // write your code here
        int n = a.length;
        if (n == 0) {
            return 0;
        }

        if (n == 1) {
            return a[0];
        }
        /************* 空间复杂度为O(n)
        long[] dp = new long[n + 1];
        dp[0] = 0;
        dp[1] = a[0];
        for (int i = 2; i <= n; i++) {
            dp[i] = Math.max(dp[i - 1], dp[i - 2] + a[i - 1]);
        }

        return dp[n];
        *************************/

        /* 滚动数组的实现方法，空间复杂度为O(1) */
        //long tmp = 0;
        long old = 0;
        long now = a[0];
        for (int i = 2; i <= n; i++) {
            long tmp = Math.max(now, old + a[i - 1]);
            old = now;
            now = tmp;
        }

        return now;
    }
}