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 dfs(i), which represents the maximum amount of money that can be stolen starting from the i-th house. Thus, the answer is dfs(0).
The execution process of the function dfs(i) is as follows:
- If i \ge len(nums), it means all houses have been considered, and we directly return 0;
- Otherwise, consider stealing from the i-th house, then dfs(i) = nums[i] + dfs(i+2); if not stealing from the i-th house, then dfs(i) = dfs(i+1).
- Return max(nums[i] + dfs(i+2), dfs(i+1)).
To avoid repeated calculations, we use memoization search. The result of 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.
PythonJavaC++GoTypeScriptRustJavaScript
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)(code-box)
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];
}
}(code-box)
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);
}
};(code-box)
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)
}(code-box)
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);
}(code-box)
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)
}
}(code-box)
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);
}(code-box)
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 ith house has two options:
- Do not rob the ith house, the total amount of robbery is f[i-1];
- Rob the ith 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.
PythonJavaC++GoTypeScriptRustJavaScript
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](code-box)
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];
}
}(code-box)
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];
}
};(code-box)
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]
}(code-box)
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];
}(code-box)
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]
}
}(code-box)
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];
}(code-box)
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).
PythonJavaC++GoTypeScriptRustJavaScript
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)(code-box)
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);
}
}(code-box)
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);
}
};(code-box)
func rob(nums []int) int {
f, g := 0, 0
for _, x := range nums {
f, g = max(f, g), f+x
}
return max(f, g)
}(code-box)
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);
}(code-box)
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])
}
}(code-box)
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);
}(code-box)
