198. House Robber
Description
You are a professional robber planning to rob houses along a street. Each house has a certain amount of money stashed, the only constraint stopping you from robbing each of them is that adjacent houses have security systems connected and it will automatically contact the police if two adjacent houses were broken into on the same night.
Given an integer array nums representing the amount of money of each house, return the maximum amount of money you can rob tonight without alerting the police.
Example 1:
Input: nums = [1,2,3,1] Output: 4 Explanation: Rob house 1 (money = 1) and then rob house 3 (money = 3). Total amount you can rob = 1 + 3 = 4.
Example 2:
Input: nums = [2,7,9,3,1] Output: 12 Explanation: Rob house 1 (money = 2), rob house 3 (money = 9) and rob house 5 (money = 1). Total amount you can rob = 2 + 9 + 1 = 12.
Constraints:
1 <= nums.length <= 1000 <= nums[i] <= 400
Solutions
Solution 1: Memoization Search
We design a function $\textit{dfs}(i)$, which represents the maximum amount of money that can be stolen starting from the $i$-th house. Thus, the answer is $\textit{dfs}(0)$.
The execution process of the function $\textit{dfs}(i)$ is as follows:
If $i \ge \textit{len}(\textit{nums})$, it means all houses have been considered, and we directly return $0$;
Otherwise, consider stealing from the $i$-th house, then $\textit{dfs}(i) = \textit{nums}[i] + \textit{dfs}(i+2)$; if not stealing from the $i$-th house, then $\textit{dfs}(i) = \textit{dfs}(i+1)$.
Return $\max(\textit{nums}[i] + \textit{dfs}(i+2), \textit{dfs}(i+1))$.
To avoid repeated calculations, we use memoization search. The result of $\textit{dfs}(i)$ is saved in an array or hash table. Before each calculation, we first check if it has been calculated. If so, we directly return the result.
The time complexity is $O(n)$, and the space complexity is $O(n)$, where $n$ is the length of the array.
Python3
class Solution:
def rob(self, nums: List[int]) -> int:
@cache
def dfs(i: int) -> int:
if i >= len(nums):
return 0
return max(nums[i] + dfs(i + 2), dfs(i + 1))
return dfs(0)
Java
class Solution {
private Integer[] f;
private int[] nums;
public int rob(int[] nums) {
this.nums = nums;
f = new Integer[nums.length];
return dfs(0);
}
private int dfs(int i) {
if (i >= nums.length) {
return 0;
}
if (f[i] == null) {
f[i] = Math.max(nums[i] + dfs(i + 2), dfs(i + 1));
}
return f[i];
}
}
C++
class Solution {
public:
int rob(vector<int>& nums) {
int n = nums.size();
int f[n];
memset(f, -1, sizeof(f));
auto dfs = [&](this auto&& dfs, int i) -> int {
if (i >= n) {
return 0;
}
if (f[i] < 0) {
f[i] = max(nums[i] + dfs(i + 2), dfs(i + 1));
}
return f[i];
};
return dfs(0);
}
};
Go
func rob(nums []int) int {
n := len(nums)
f := make([]int, n)
for i := range f {
f[i] = -1
}
var dfs func(int) int
dfs = func(i int) int {
if i >= n {
return 0
}
if f[i] < 0 {
f[i] = max(nums[i]+dfs(i+2), dfs(i+1))
}
return f[i]
}
return dfs(0)
}
TypeScript
function rob(nums: number[]): number {
const n = nums.length;
const f: number[] = Array(n).fill(-1);
const dfs = (i: number): number => {
if (i >= n) {
return 0;
}
if (f[i] < 0) {
f[i] = Math.max(nums[i] + dfs(i + 2), dfs(i + 1));
}
return f[i];
};
return dfs(0);
}
Rust
impl Solution {
pub fn rob(nums: Vec<i32>) -> i32 {
fn dfs(i: usize, nums: &Vec<i32>, f: &mut Vec<i32>) -> i32 {
if i >= nums.len() {
return 0;
}
if f[i] < 0 {
f[i] = (nums[i] + dfs(i + 2, nums, f)).max(dfs(i + 1, nums, f));
}
f[i]
}
let n = nums.len();
let mut f = vec![-1; n];
dfs(0, &nums, &mut f)
}
}
JavaScript
function rob(nums) {
const n = nums.length;
const f = Array(n).fill(-1);
const dfs = i => {
if (i >= n) {
return 0;
}
if (f[i] < 0) {
f[i] = Math.max(nums[i] + dfs(i + 2), dfs(i + 1));
}
return f[i];
};
return dfs(0);
}
Solution 2: Dynamic Programming
We define $f[i]$ as the maximum total amount that can be robbed from the first $i$ houses, initially $f[0]=0$, $f[1]=nums[0]$.
Consider the case where $i \gt 1$, the $i$th house has two options:
Do not rob the $i$th house, the total amount of robbery is $f[i-1]$;
Rob the $i$th house, the total amount of robbery is $f[i-2]+nums[i-1]$;
Therefore, we can get the state transition equation:
$$ f[i]= \begin{cases} 0, & i=0 \ nums[0], & i=1 \ \max(f[i-1],f[i-2]+nums[i-1]), & i \gt 1 \end{cases} $$
The final answer is $f[n]$, where $n$ is the length of the array.
The time complexity is $O(n)$, and the space complexity is $O(n)$. Where $n$ is the length of the array.
Python3
class Solution:
def rob(self, nums: List[int]) -> int:
n = len(nums)
f = [0] * (n + 1)
f[1] = nums[0]
for i in range(2, n + 1):
f[i] = max(f[i - 1], f[i - 2] + nums[i - 1])
return f[n]
Java
class Solution {
public int rob(int[] nums) {
int n = nums.length;
int[] f = new int[n + 1];
f[1] = nums[0];
for (int i = 2; i <= n; ++i) {
f[i] = Math.max(f[i - 1], f[i - 2] + nums[i - 1]);
}
return f[n];
}
}
C++
class Solution {
public:
int rob(vector<int>& nums) {
int n = nums.size();
int f[n + 1];
memset(f, 0, sizeof(f));
f[1] = nums[0];
for (int i = 2; i <= n; ++i) {
f[i] = max(f[i - 1], f[i - 2] + nums[i - 1]);
}
return f[n];
}
};
Go
func rob(nums []int) int {
n := len(nums)
f := make([]int, n+1)
f[1] = nums[0]
for i := 2; i <= n; i++ {
f[i] = max(f[i-1], f[i-2]+nums[i-1])
}
return f[n]
}
TypeScript
function rob(nums: number[]): number {
const n = nums.length;
const f: number[] = Array(n + 1).fill(0);
f[1] = nums[0];
for (let i = 2; i <= n; ++i) {
f[i] = Math.max(f[i - 1], f[i - 2] + nums[i - 1]);
}
return f[n];
}
Rust
impl Solution {
pub fn rob(nums: Vec<i32>) -> i32 {
let n = nums.len();
let mut f = vec![0; n + 1];
f[1] = nums[0];
for i in 2..=n {
f[i] = f[i - 1].max(f[i - 2] + nums[i - 1]);
}
f[n]
}
}
JavaScript
function rob(nums) {
const n = nums.length;
const f = Array(n + 1).fill(0);
f[1] = nums[0];
for (let i = 2; i <= n; ++i) {
f[i] = Math.max(f[i - 1], f[i - 2] + nums[i - 1]);
}
return f[n];
}
Solution 3: Dynamic Programming (Space Optimization)
We notice that when $i \gt 2$, $f[i]$ is only related to $f[i-1]$ and $f[i-2]$. Therefore, we can use two variables instead of an array to reduce the space complexity to $O(1)$.
Python3
class Solution:
def rob(self, nums: List[int]) -> int:
f = g = 0
for x in nums:
f, g = max(f, g), f + x
return max(f, g)
Java
class Solution {
public int rob(int[] nums) {
int f = 0, g = 0;
for (int x : nums) {
int ff = Math.max(f, g);
g = f + x;
f = ff;
}
return Math.max(f, g);
}
}
C++
class Solution {
public:
int rob(vector<int>& nums) {
int f = 0, g = 0;
for (int& x : nums) {
int ff = max(f, g);
g = f + x;
f = ff;
}
return max(f, g);
}
};
Go
func rob(nums []int) int {
f, g := 0, 0
for _, x := range nums {
f, g = max(f, g), f+x
}
return max(f, g)
}
TypeScript
function rob(nums: number[]): number {
let [f, g] = [0, 0];
for (const x of nums) {
[f, g] = [Math.max(f, g), f + x];
}
return Math.max(f, g);
}
Rust
impl Solution {
pub fn rob(nums: Vec<i32>) -> i32 {
let mut f = [0, 0];
for x in nums {
f = [f[0].max(f[1]), f[0] + x];
}
f[0].max(f[1])
}
}
JavaScript
function rob(nums) {
let [f, g] = [0, 0];
for (const x of nums) {
[f, g] = [Math.max(f, g), f + x];
}
return Math.max(f, g);
}