198. House Robber
213. House Robber II
337. House Robber III
256. Paint House
265. Paint House II
276. Paint Fence
198. House Robber
- 一个array，每个值代表该house的value，不能偷相邻的house，最多偷多少
- every house has two possible states, rob/not rob
- if we don't rob the current house, the value we can rob is max(rob-pre-house, don't-rob-pre-house)
- if we rob the current house (we cannot rob the previous house), the value is
(don't-rob-pre-house + the value in the current house)
class Solution {
public int rob(int[] nums) {
int n = nums.length;
int[][] dp = new int[n + 1][2]; //two states, 0 is not rob, 1 is rob
for (int i = 1; i <= n; i++) {
dp[i][0] = Math.max(dp[i-1][0], dp[i-1][1]);
dp[i][1] = dp[i-1][0] + nums[i-1];
}
return Math.max(dp[n][0], dp[n][1]);
}
}
213. House Robber II
- 这些房子构成环，第一个房子和最后一个房子相邻
- 两种方式，第1个到n-1个，第2个到第n个
class Solution {
//house[1] and house[n] are adjacent
//so we can rob from house[1] to house[n-1];
//or rob from house[2] to house[n]
public int rob(int[] nums) {
if (nums == null || nums.length == 0) return 0;
if (nums.length == 1) return nums[0];
int n = nums.length;
int first = robFromTo(nums, 1, n-1);
int second = robFromTo(nums, 2, n);
return Math.max(first, second);
}
private int robFromTo(int[] nums, int from, int to) {
int n = nums.length;
int[][] dp = new int[n+1][2];
for (int i = from; i <= to; i++) {
dp[i][0] = Math.max(dp[i-1][0], dp[i-1][1]);
dp[i][1] = dp[i-1][0] + nums[i-1];
}
return Math.max(dp[to][0], dp[to][1]);
}
}
337. House Robber III
- 所有的房子构成一个binary tree，相邻的两个房子不能都偷
- up down 的方式，调用很多次dfs
- bottom up 利用返回的int[]存储信息
a good explanation
//这种方法调用过多dfs，我一直在想有没有memorization的方法，记住某个node选和不选时最多能rob的数
class Solution {
int sum = 0;
public int rob(TreeNode root) {
if (root == null) return 0;
int first = dfs(root, false);
int second = dfs(root, true);
return Math.max(first, second);
}
private int dfs(TreeNode root, boolean select) {
if (root == null) return 0;
int sum = 0;
if (select) {
sum += root.val;
//自己选了，child就不能选
sum += dfs(root.left, false);
sum += dfs(root.right, false);
} else {
//自己没选，child可选可不选
sum += Math.max(dfs(root.left, false), dfs(root.left, true));
sum += Math.max(dfs(root.right, false), dfs(root.right, true));
}
return sum;
}
}
//当从一个node返回时，要携带什么信息？
//how much i can rob if i select this node, and
//how much i can rob if i don't select this node
class Solution {
public int rob(TreeNode root) {
int[] res = dfs(root);
return Math.max(res[0], res[1]);
}
private int[] dfs(TreeNode root) {
if (root == null) {
return new int[2];
}
//[0] not choose the node, [1]choose the node
int[] left = dfs(root.left);
int[] right = dfs(root.right);
int[] cur = new int[2];
//if we do not choose the current node, we can either choose or not the left, right
cur[0] = Math.max(left[0], left[1]) + Math.max(right[0], right[1]);
//if we choose the current node, we cannot choose the left, right
cur[1] = left[0] + right[0] + root.val;
return cur;
}
}
256. Paint House
- 与House Robber非常像，不允许相邻house被染成同样的颜色
- paint每个房子每种颜色的价格都不一样，找最小需要多少钱将其全染完
- key point，2D Araay， record the minimum cost with house i and color j
class Solution {
public int minCost(int[][] costs) {
int n = costs.length;
int[][] dp = new int[n+1][3];
for (int i = 1; i <= n; i++) {
dp[i][0] = Math.min(dp[i-1][1], dp[i-1][2]) + costs[i-1][0];
dp[i][1] = Math.min(dp[i-1][0], dp[i-1][2]) + costs[i-1][1];
dp[i][2] = Math.min(dp[i-1][0], dp[i-1][1]) + costs[i-1][2];
}
return Math.min(Math.min(dp[n][0], dp[n][1]), dp[n][2]);
}
}
265. Paint House II
- Paint House的提高版，可以用O(nk2)，其中k2是k个现在房子color和k个前一个房子color的组合
- 其实只需要最低和第二低的前一个房子的color， 这样的是O(nk)
class Solution {
//O(kn)
//two pinters point to the corresponding color of the lowest cost
//and the correspongding color of second lowest cost
public int minCostII(int[][] costs) {
if (costs == null || costs.length == 0) return 0;
int n = costs.length, k = costs[0].length;
int[] pre = new int[k];
int[] cur = new int[k];
int min1 = -1, min2 = -1;
for (int j = 0; j < k; j++) {
pre[j] = costs[0][j];
if (min1 == -1 || pre[j] < pre[min1]) {
min2 = min1; min1 = j;
} else if (min2 == -1 || pre[j] < pre[min2]) {
min2 = j;
}
}
for (int i = 1; i < n; i++) {
int last1 = min1, last2 = min2;
min1 = -1; min2 = -1;
for (int j = 0; j < k; j++) {
if (j != last1) {
cur[j] = pre[last1] + costs[i][j];
} else {
cur[j] = pre[last2] + costs[i][j];
}
//update min1, min2
if (min1 == -1 || cur[j] < cur[min1]) {
min2 = min1; min1 = j;
} else if (min2 == -1 || cur[j] < cur[min2]) {
min2 = j;
}
}
//update pre
for (int j = 0; j < k; j++) {
pre[j] = cur[j];
}
}
return pre[min1];
}
}
276. Paint Fence
- 不能有连续3个相同的颜色
- 第 i 和 i-1 post颜色不同时所有的可能性
- 第 i 和 i-1 post颜色相同时所有的可能性
class Solution {
public int numWays(int n, int k) {
if (n == 0) return 0;
if (n == 1) return k;
int[] dp = new int[n+1];
dp[0] = 0;
dp[1] = k;
dp[2] = k * k;
for (int i = 3; i <= n; i++) {
dp[i] += dp[i-1] * (k-1); //第i和第i-1个不同时有多少情况
dp[i] += dp[i-2] * (k-1); //第i和第i-1相同，so 第i-2必须和第i-1不同
}
return dp[n];
}
}