diff --git a/solution/0100-0199/0198.House Robber/README.md b/solution/0100-0199/0198.House Robber/README.md index 4ea557cf7233d..a8efc584f4e79 100644 --- a/solution/0100-0199/0198.House Robber/README.md +++ b/solution/0100-0199/0198.House Robber/README.md @@ -55,7 +55,174 @@ tags: -### 方法一：动态规划 +### 方法一：记忆化搜索 + +我们设计一个函数 $\textit{dfs}(i)$，表示从第 $i$ 间房屋开始偷窃能够得到的最高金额。那么答案即为 $\textit{dfs}(0)$。 + +函数 $\textit{dfs}(i)$ 的执行过程如下： + +- 如果 $i \ge \textit{len}(\textit{nums})$，表示所有房屋都被考虑过了，直接返回 $0$； +- 否则，考虑偷窃第 $i$ 间房屋，那么 $\textit{dfs}(i) = \textit{nums}[i] + \textit{dfs}(i+2)$；不偷窃第 $i$ 间房屋，那么 $\textit{dfs}(i) = \textit{dfs}(i+1)$。 +- 返回 $\max(\textit{nums}[i] + \textit{dfs}(i+2), \textit{dfs}(i+1))$。 + +为了避免重复计算，我们使用记忆化搜索的方法，将 $\textit{dfs}(i)$ 的结果保存在一个数组或哈希表中，每次计算前先查询是否已经计算过，如果计算过直接返回结果。 + +时间复杂度 $O(n)$，空间复杂度 $O(n)$。其中 $n$ 是数组长度。 + + + +#### Python3 + +```python +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 + +```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++ + +```cpp +class Solution { +public: + int rob(vector& nums) { + int n = nums.size(); + int f[n]; + memset(f, -1, sizeof(f)); + auto dfs = [&](auto&& dfs, int i) -> int { + if (i >= n) { + return 0; + } + if (f[i] < 0) { + f[i] = max(nums[i] + dfs(dfs, i + 2), dfs(dfs, i + 1)); + } + return f[i]; + }; + return dfs(dfs, 0); + } +}; +``` + +#### Go + +```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 + +```ts +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 + +```rust +impl Solution { + pub fn rob(nums: Vec) -> i32 { + fn dfs(i: usize, nums: &Vec, f: &mut Vec) -> 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 + +```js +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); +} +``` + + + + + + + +### 方法二：动态规划 我们定义 $f[i]$ 表示前 $i$ 间房屋能偷窃到的最高总金额，初始时 $f[0]=0$, $f[1]=nums[0]$。 @@ -161,12 +328,28 @@ function rob(nums: number[]): number { ```rust impl Solution { pub fn rob(nums: Vec) -> i32 { - let mut f = [0, 0]; - for x in nums { - f = [f[0].max(f[1]), f[0] + x]; + 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[0].max(f[1]) + f[n] + } +} +``` + +#### JavaScript + +```js +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]; } ``` @@ -176,7 +359,7 @@ impl Solution { -### 方法二：动态规划（空间优化） +### 方法三：动态规划（空间优化） 我们注意到，当 $i \gt 2$ 时，$f[i]$ 只和 $f[i-1]$ 与 $f[i-2]$ 有关，因此我们可以使用两个变量代替数组，将空间复杂度降到 $O(1)$。 @@ -250,6 +433,32 @@ function rob(nums: number[]): number { } ``` +#### Rust + +```rust +impl Solution { + pub fn rob(nums: Vec) -> 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 + +```js +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); +} +``` + diff --git a/solution/0100-0199/0198.House Robber/README_EN.md b/solution/0100-0199/0198.House Robber/README_EN.md index 3544d3f77536f..cefa367aedd9c 100644 --- a/solution/0100-0199/0198.House Robber/README_EN.md +++ b/solution/0100-0199/0198.House Robber/README_EN.md @@ -54,7 +54,174 @@ Total amount you can rob = 2 + 9 + 1 = 12. -### Solution 1: Dynamic Programming +### 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 + +```python +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 + +```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++ + +```cpp +class Solution { +public: + int rob(vector& nums) { + int n = nums.size(); + int f[n]; + memset(f, -1, sizeof(f)); + auto dfs = [&](auto&& dfs, int i) -> int { + if (i >= n) { + return 0; + } + if (f[i] < 0) { + f[i] = max(nums[i] + dfs(dfs, i + 2), dfs(dfs, i + 1)); + } + return f[i]; + }; + return dfs(dfs, 0); + } +}; +``` + +#### Go + +```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 + +```ts +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 + +```rust +impl Solution { + pub fn rob(nums: Vec) -> i32 { + fn dfs(i: usize, nums: &Vec, f: &mut Vec) -> 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 + +```js +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]$. @@ -160,22 +327,38 @@ function rob(nums: number[]): number { ```rust impl Solution { pub fn rob(nums: Vec) -> i32 { - let mut f = [0, 0]; - for x in nums { - f = [f[0].max(f[1]), f[0] + x]; + 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[0].max(f[1]) + f[n] } } ``` +#### JavaScript + +```js +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 2: Dynamic Programming (Space Optimization) +### 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)$. @@ -249,6 +432,32 @@ function rob(nums: number[]): number { } ``` +#### Rust + +```rust +impl Solution { + pub fn rob(nums: Vec) -> 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 + +```js +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); +} +``` + diff --git a/solution/0100-0199/0198.House Robber/Solution.cpp b/solution/0100-0199/0198.House Robber/Solution.cpp index 2ecfee368e8fa..0bd38434ce2ad 100644 --- a/solution/0100-0199/0198.House Robber/Solution.cpp +++ b/solution/0100-0199/0198.House Robber/Solution.cpp @@ -2,12 +2,17 @@ class Solution { public: int rob(vector& 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]; + int f[n]; + memset(f, -1, sizeof(f)); + auto dfs = [&](auto&& dfs, int i) -> int { + if (i >= n) { + return 0; + } + if (f[i] < 0) { + f[i] = max(nums[i] + dfs(dfs, i + 2), dfs(dfs, i + 1)); + } + return f[i]; + }; + return dfs(dfs, 0); } -}; \ No newline at end of file +}; diff --git a/solution/0100-0199/0198.House Robber/Solution.go b/solution/0100-0199/0198.House Robber/Solution.go index 52f08ae2d5f14..76ab49daa5b0b 100644 --- a/solution/0100-0199/0198.House Robber/Solution.go +++ b/solution/0100-0199/0198.House Robber/Solution.go @@ -1,9 +1,18 @@ 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]) + f := make([]int, n) + for i := range f { + f[i] = -1 } - return f[n] -} \ No newline at end of file + 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) +} diff --git a/solution/0100-0199/0198.House Robber/Solution.java b/solution/0100-0199/0198.House Robber/Solution.java index e493219c3617c..b887b3edbfea8 100644 --- a/solution/0100-0199/0198.House Robber/Solution.java +++ b/solution/0100-0199/0198.House Robber/Solution.java @@ -1,11 +1,20 @@ class Solution { + private Integer[] f; + private int[] nums; + 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]); + 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[n]; + return f[i]; } -} \ No newline at end of file +} diff --git a/solution/0100-0199/0198.House Robber/Solution.js b/solution/0100-0199/0198.House Robber/Solution.js new file mode 100644 index 0000000000000..7bc5eccc00e60 --- /dev/null +++ b/solution/0100-0199/0198.House Robber/Solution.js @@ -0,0 +1,14 @@ +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); +} diff --git a/solution/0100-0199/0198.House Robber/Solution.py b/solution/0100-0199/0198.House Robber/Solution.py index c270a36802c3a..21cd5401dec8e 100644 --- a/solution/0100-0199/0198.House Robber/Solution.py +++ b/solution/0100-0199/0198.House Robber/Solution.py @@ -1,8 +1,9 @@ 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] + @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) diff --git a/solution/0100-0199/0198.House Robber/Solution.rs b/solution/0100-0199/0198.House Robber/Solution.rs index d1b3a459ce727..a808361adf5ef 100644 --- a/solution/0100-0199/0198.House Robber/Solution.rs +++ b/solution/0100-0199/0198.House Robber/Solution.rs @@ -1,9 +1,17 @@ impl Solution { pub fn rob(nums: Vec) -> i32 { - let mut f = [0, 0]; - for x in nums { - f = [f[0].max(f[1]), f[0] + x]; + fn dfs(i: usize, nums: &Vec, f: &mut Vec) -> 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] } - f[0].max(f[1]) + + let n = nums.len(); + let mut f = vec![-1; n]; + dfs(0, &nums, &mut f) } } diff --git a/solution/0100-0199/0198.House Robber/Solution.ts b/solution/0100-0199/0198.House Robber/Solution.ts index f603cd3876e25..92f8665b086b7 100644 --- a/solution/0100-0199/0198.House Robber/Solution.ts +++ b/solution/0100-0199/0198.House Robber/Solution.ts @@ -1,9 +1,14 @@ 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]; + 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); } diff --git a/solution/0100-0199/0198.House Robber/Solution2.cpp b/solution/0100-0199/0198.House Robber/Solution2.cpp index 10928ea139406..41df1c663a2fb 100644 --- a/solution/0100-0199/0198.House Robber/Solution2.cpp +++ b/solution/0100-0199/0198.House Robber/Solution2.cpp @@ -1,12 +1,13 @@ class Solution { public: int rob(vector& nums) { - int f = 0, g = 0; - for (int& x : nums) { - int ff = max(f, g); - g = f + x; - f = ff; + 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 max(f, g); + return f[n]; } -}; \ No newline at end of file +}; diff --git a/solution/0100-0199/0198.House Robber/Solution2.go b/solution/0100-0199/0198.House Robber/Solution2.go index 35cc30969e50b..85ba1d737bf16 100644 --- a/solution/0100-0199/0198.House Robber/Solution2.go +++ b/solution/0100-0199/0198.House Robber/Solution2.go @@ -1,7 +1,9 @@ func rob(nums []int) int { - f, g := 0, 0 - for _, x := range nums { - f, g = max(f, g), f+x + 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 max(f, g) -} \ No newline at end of file + return f[n] +} diff --git a/solution/0100-0199/0198.House Robber/Solution2.java b/solution/0100-0199/0198.House Robber/Solution2.java index d6491685a06e3..6e8c1bb34ca54 100644 --- a/solution/0100-0199/0198.House Robber/Solution2.java +++ b/solution/0100-0199/0198.House Robber/Solution2.java @@ -1,11 +1,11 @@ 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; + 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 Math.max(f, g); + return f[n]; } -} \ No newline at end of file +} diff --git a/solution/0100-0199/0198.House Robber/Solution2.js b/solution/0100-0199/0198.House Robber/Solution2.js new file mode 100644 index 0000000000000..e237fbd3c8bd5 --- /dev/null +++ b/solution/0100-0199/0198.House Robber/Solution2.js @@ -0,0 +1,9 @@ +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]; +} diff --git a/solution/0100-0199/0198.House Robber/Solution2.py b/solution/0100-0199/0198.House Robber/Solution2.py index b1afd4af8730f..c270a36802c3a 100644 --- a/solution/0100-0199/0198.House Robber/Solution2.py +++ b/solution/0100-0199/0198.House Robber/Solution2.py @@ -1,6 +1,8 @@ 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) + 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] diff --git a/solution/0100-0199/0198.House Robber/Solution2.rs b/solution/0100-0199/0198.House Robber/Solution2.rs new file mode 100644 index 0000000000000..f3db9ae71ede1 --- /dev/null +++ b/solution/0100-0199/0198.House Robber/Solution2.rs @@ -0,0 +1,11 @@ +impl Solution { + pub fn rob(nums: Vec) -> 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] + } +} diff --git a/solution/0100-0199/0198.House Robber/Solution2.ts b/solution/0100-0199/0198.House Robber/Solution2.ts index 37f93d27df129..f603cd3876e25 100644 --- a/solution/0100-0199/0198.House Robber/Solution2.ts +++ b/solution/0100-0199/0198.House Robber/Solution2.ts @@ -1,7 +1,9 @@ function rob(nums: number[]): number { - let [f, g] = [0, 0]; - for (const x of nums) { - [f, g] = [Math.max(f, g), f + x]; + 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 Math.max(f, g); + return f[n]; } diff --git a/solution/0100-0199/0198.House Robber/Solution3.cpp b/solution/0100-0199/0198.House Robber/Solution3.cpp new file mode 100644 index 0000000000000..b5d4640232ceb --- /dev/null +++ b/solution/0100-0199/0198.House Robber/Solution3.cpp @@ -0,0 +1,12 @@ +class Solution { +public: + int rob(vector& nums) { + int f = 0, g = 0; + for (int& x : nums) { + int ff = max(f, g); + g = f + x; + f = ff; + } + return max(f, g); + } +}; diff --git a/solution/0100-0199/0198.House Robber/Solution3.go b/solution/0100-0199/0198.House Robber/Solution3.go new file mode 100644 index 0000000000000..9c621cfc37c81 --- /dev/null +++ b/solution/0100-0199/0198.House Robber/Solution3.go @@ -0,0 +1,7 @@ +func rob(nums []int) int { + f, g := 0, 0 + for _, x := range nums { + f, g = max(f, g), f+x + } + return max(f, g) +} diff --git a/solution/0100-0199/0198.House Robber/Solution3.java b/solution/0100-0199/0198.House Robber/Solution3.java new file mode 100644 index 0000000000000..16344c0cd140f --- /dev/null +++ b/solution/0100-0199/0198.House Robber/Solution3.java @@ -0,0 +1,11 @@ +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); + } +} diff --git a/solution/0100-0199/0198.House Robber/Solution3.js b/solution/0100-0199/0198.House Robber/Solution3.js new file mode 100644 index 0000000000000..74747f355d42d --- /dev/null +++ b/solution/0100-0199/0198.House Robber/Solution3.js @@ -0,0 +1,7 @@ +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); +} diff --git a/solution/0100-0199/0198.House Robber/Solution3.py b/solution/0100-0199/0198.House Robber/Solution3.py new file mode 100644 index 0000000000000..b1afd4af8730f --- /dev/null +++ b/solution/0100-0199/0198.House Robber/Solution3.py @@ -0,0 +1,6 @@ +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) diff --git a/solution/0100-0199/0198.House Robber/Solution3.rs b/solution/0100-0199/0198.House Robber/Solution3.rs new file mode 100644 index 0000000000000..d1b3a459ce727 --- /dev/null +++ b/solution/0100-0199/0198.House Robber/Solution3.rs @@ -0,0 +1,9 @@ +impl Solution { + pub fn rob(nums: Vec) -> i32 { + let mut f = [0, 0]; + for x in nums { + f = [f[0].max(f[1]), f[0] + x]; + } + f[0].max(f[1]) + } +} diff --git a/solution/0100-0199/0198.House Robber/Solution3.ts b/solution/0100-0199/0198.House Robber/Solution3.ts new file mode 100644 index 0000000000000..37f93d27df129 --- /dev/null +++ b/solution/0100-0199/0198.House Robber/Solution3.ts @@ -0,0 +1,7 @@ +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); +}