lintcode打劫房屋

原题地址

题目：

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

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

您在真实的面试中是否遇到过这个题？ Yes

样例

给定 [3, 8, 4], 返回 8.

分析：

简单dp题。当前房屋 i 的最大可达钱取决于dp[i - 2]和dp[i - 3]的最大值（dp[i - 4]的情况属于dp[i - 2]）。

注意返回值要为long型。

时间复杂度o(n)，空间o(n)

public long houseRobber(int[] A) {
long[] dp = new long[A.length];
if (A.length < 1) {
return 0;
}
if (A.length == 1) return A[0];
dp[0] = A[0];
dp[1] = A[1];
long max = Math.max(dp[0], dp[1]);
if (A.length <= 2) {
return max;
}
dp[2] = dp[0] + A[2];
if (dp[2] > max) max = dp[2];
for (int i = 3; i < A.length; i++) {
dp[i] = (dp[i - 2] > dp[i - 3] ? dp[i - 2] : dp[i - 3]) + A[i];
if (dp[i] > max) {
max = dp[i];
}
}
return max;
}

改进的时间复杂度o(n)，空间o(1)，用dp1和dp2保存dp[i - 3]和dp[i - 2]。

public long houseRobber(int[] A) {
if (A.length < 1) {
return 0;
}
if (A.length < 2) {
return A[0];
}
long dp1 = A[0];
long dp2 = A[1];
long max = Math.max(dp1, dp2);
if (A.length == 2) {
return max;
}
max = (dp1 + A[2]) > dp2 ? (dp1 + A[2]) : dp2;
long temp = max;
long tempLast = temp;
for (int i = 3; i < A.length; i++) {
temp = (dp1 > dp2 ? dp1 : dp2) + A[i];
if(temp > max) max = temp;
dp1 = dp2;
dp2 = tempLast;
tempLast = temp;
}
return max;
}

另外一种思路：

参考网址

用一个二维数组dp[A.length][2]，其中对于第i所房子，dp[i][0]表示不打劫i，此时其能获得的最大钱数为：

dp[i][0] = max(dp[i - 1][0] ,dp[i - 1][1])

dp[i][1]表示打劫i，其等于不打劫上一家的情况下，再加上i的钱数：

dp[i][1] = dp[i - 1][0] + A[i];

public long houseRobber(int[] A) {
if(A.length==0)
return 0;
long[][] dp = new long[A.length][2];
dp[0][1] = A[0];
for(int i=1;i<A.length;++i){
dp[i][0] = Math.max(dp[i-1][0],dp[i-1][1]);
dp[i][1] = dp[i-1][0]+A[i];
}
return Math.max(dp[A.length-1][0],dp[A.length-1][1]);
}