【Leetcode】198. House Robber

题目地址：

https://leetcode.com/problems/house-robber/

有一个数组$A$代表每个房子的财富值。有个小偷想偷尽可能多的财富，但他不能同时偷相邻的两个房子。问他最多能偷多少钱。

法1：动态规划。设$f[i]$代表到第$i$个房子为止，他能偷的最大财富。设每个房子的财富值为$h[i]$。如果已知到第$i-1$个房子为止，他能偷的最大财富值，那么到第$i$个房子为止，能偷的最大财富值有两种情况：
1、他偷第$i$个房子，那么最大是$f[i-2]+h[i]$；
2、他不偷第$i$个房子，那么最大是$f[i-1]$。
取两者较大的即可。代码如下：

public class Solution {
    public int rob(int[] nums) {
        if (nums == null || nums.length == 0) {
            return 0;
        }
        
        // dp代表第i栋房子为止，小偷能偷到的最大财富值（i从1开始计算）
        int[] dp = new int[nums.length + 1];
        dp[1] = nums[0];
        
        for (int i = 1; i < nums.length; i++) {
            dp[i + 1] = Math.max(nums[i] + dp[i - 1], dp[i]);
        }
        
        return dp[nums.length];
    }
}

时空复杂度$O(n)$。

观察得出，当前的值只依赖于前两个位置的值，所以可以用滚动数组的方式优化空间。

public class Solution {
    public int rob(int[] nums) {
        if (nums == null || nums.length == 0) {
            return 0;
        }
        
        int[] dp = new int[3];
        dp[1] = nums[0];
        // ind记录当前更新到哪儿了
		int ind = 1;
        for (int i = 1; i < nums.length; i++) {
        	// 滚动一下，然后更新
            ind = (ind + 1) % 3;
            dp[ind] = Math.max(dp[(ind + 1) % 3] + nums[i], dp[(ind + 2) % 3]);
        }
        
        return dp[ind];
    }
}

时间复杂度不变，空间$O(1)$。

法2：状态机（本质上其实还是动态规划）。下面用图论的语言来叙述这个问题。考虑一个两个顶点的图$G$，两个顶点分别为$v_1$和$v_2$，其中$v_1$表示“最后一个房屋要选”这个状态，$v_2$表示“最后一个房屋不选”这个状态。那么，存在的有向边就是$(v_0,v_0)$，$(v_0,v_1)$和$(v_1,v_0)$，因为如果某个房子不选，那么下一个房子可以选或者不选；而某个房子选了，下一个房子就不能选。所以整个题目就相当于，在这个图上走$n$步，所能得到的最大收益是多少（注意这里和图论里的边权并不一样，这里的边权是跟走的步数相关的，并不是个确定值）。设$f[i][0]$表示走了$i$步停留在$v_0$时获得的最大收益，$f[i][1]$表示走了$i$步停留在$v_1$时获得的最大收益。那么就有： { f [ i ] [ 0 ] = max ⁡ { f [ i − 1 ] [ 0 ] , f [ i − 1 ] [ 1 ] } f [ i ] [ 1 ] = f [ i − 1 ] [ 0 ] + A [ i ] \begin{cases}f[i][0]=\max\{f[i-1][0],f[i-1][1]\}\\f[i][1]=f[i-1][0] +A[i] \end{cases} {f[i][0]=max{f[i−1][0],f[i−1][1]}f[i][1]=f[i−1][0]+A[i]​最后要返回的结果就是 max ⁡ { f [ n ] [ 0 ] , f [ n ] [ 1 ] } \max\{f[n][0],f[n][1]\} max{f[n][0],f[n][1]}。其中$f[0][0]=0,f[0][1]=A[0]$。代码如下：

public class Solution {
    public int rob(int[] nums) {
    	if (nums == null || nums.length == 0) {
    		return 0;
    	}
    	
    	int len = nums.length;
        int[][] dp = new int[len][2];
        dp[0][0] = 0;
        dp[0][1] = nums[0];
    
        for (int i = 1; i < len; i++) {
            dp[i][0] = Math.max(dp[i - 1][0], dp[i - 1][1]);
            dp[i][1] = dp[i - 1][0] + nums[i];
        }
        
        return Math.max(dp[len - 1][0], dp[len - 1][1]);
    }
}

时空复杂度$O(n)$。

C++：

class Solution {
 public:
  int rob(vector<int>& nums) {
    int n = nums.size();
    vector<int> f(n + 1), g(n + 1);
    for (int i = 1; i <= n; i++) {
      f[i] = nums[i - 1] + g[i - 1];
      g[i] = max(f[i - 1], g[i - 1]);
    }

    return max(f[n], g[n]);
  }
};

时空复杂度一样。