feat: add solutions to lc problem: No.0198

No.0198.House Robber

Author: yanglbme

solution/0100-0199/0198.House Robber/README.md

@@ -42,123 +42,86 @@
 
 <!-- 这里可写通用的实现逻辑 -->
 
-**方法一：记忆化搜索**
+**方法一：动态规划**
 
-我们设计函数 $dfs(i)$ 表示从第 $i$ 间房屋开始偷窃，能偷窃到的最高金额。答案为 $dfs(0)$。
+我们定义 $f[i]$ 表示前 $i$ 间房屋能偷窃到的最高总金额，初始时 $f[0]=0$, $f[1]=nums[0]$。
 
-对于第 $i$ 间房屋，有偷窃和不偷窃两种选择。如果偷窃，那么下一间房屋就不能偷窃，偷窃总金额为当前房屋金额加上下下间房屋开始的偷窃最高金额，即 $nums[i] + dfs(i + 2)$。如果不偷窃，那么下一间房屋就可以偷窃，偷窃总金额为下一间房屋开始的偷窃最高金额，即 $dfs(i + 1)$。两种选择取最大值作为函数 $dfs(i)$ 的返回值。
+考虑 $i \gt 1$ 的情况，第 $i$ 间房屋有两个选项：
 
-我们可以使用记忆化搜索，避免重复计算。
+-   不偷窃第 $i$ 间房屋，偷窃总金额为 $f[i-1]$；
+-   偷窃第 $i$ 间房屋，偷窃总金额为 $f[i-2]+nums[i-1]$；
 
-时间复杂度 $O(n)$，空间复杂度 $O(n)$。其中 $n$ 为房屋数量。
+因此，我们可以得到状态转移方程：
 
-**方法二：动态规划**
+$$
+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}
+$$
 
-我们也可以将记忆化搜索改成动态规划。
+最终的答案即为 $f[n]$，其中 $n$ 是数组的长度。
 
-定义 $dp[i]$ 表示偷窃前 $i$ 个房屋能得到的最高金额。答案为 $dp[n]$。
+时间复杂度 $O(n)$，空间复杂度 $O(n)$。其中 $n$ 是数组长度。
 
-状态转移方程为 $dp[i] = max(dp[i - 1], dp[i - 2] + nums[i - 1])$。
-
-时间复杂度 $O(n)$，空间复杂度 $O(n)$。其中 $n$ 为房屋数量。
-
-**方法三：动态规划（空间优化）**
-
-注意到方法二中的状态转移方程只和 $dp[i - 1]$ 和 $dp[i - 2]$ 有关，因此我们可以只用两个变量来维护这两个状态，从而将空间复杂度优化到 $O(1)$。
-
-时间复杂度 $O(n)$，空间复杂度 $O(1)$。其中 $n$ 为房屋数量。
+注意到当 $i \gt 2$ 时，$f[i]$ 只和 $f[i-1]$ 与 $f[i-2]$ 有关，因此我们可以使用两个变量代替数组，将空间复杂度降到 $O(1)$。
 
 <!-- tabs:start -->
 
 ### **Python3**
 
 <!-- 这里可写当前语言的特殊实现逻辑 -->
 
-```python
-class Solution:
-    def rob(self, nums: List[int]) -> int:
-        @cache
-        def dfs(i):
-            if i >= len(nums):
-                return 0
-            return max(nums[i] + dfs(i + 2), dfs(i + 1))
-
-        return dfs(0)
-```
-
 ```python
 class Solution:
     def rob(self, nums: List[int]) -> int:
         n = len(nums)
-        dp = [0] * (n + 1)
-        dp[1] = nums[0]
+        f = [0] * (n + 1)
+        f[1] = nums[0]
         for i in range(2, n + 1):
-            dp[i] = max(nums[i - 1] + dp[i - 2], dp[i - 1])
-        return dp[n]
+            f[i] = max(f[i - 1], f[i - 2] + nums[i - 1])
+        return f[n]
 ```
 
 ```python
 class Solution:
     def rob(self, nums: List[int]) -> int:
-        a, b = 0, nums[0]
-        for num in nums[1:]:
-            a, b = b, max(num + a, b)
-        return b
+        f, g = 0, nums[0]
+        for x in nums[1:]:
+            f, g = g, max(f + x, g)
+        return g
 ```
 
 ### **Java**
 
 <!-- 这里可写当前语言的特殊实现逻辑 -->
 
-```java
-class Solution {
-    private int[] f;
-    private int[] nums;
-
-    public int rob(int[] nums) {
-        this.nums = nums;
-        f = new int[nums.length];
-        Arrays.fill(f, -1);
-        return dfs(0);
-    }
-
-    private int dfs(int i) {
-        if (i >= nums.length) {
-            return 0;
-        }
-        if (f[i] != -1) {
-            return f[i];
-        }
-        f[i] = Math.max(nums[i] + dfs(i + 2), dfs(i + 1));
-        return f[i];
-    }
-}
-```
-
 ```java
 class Solution {
     public int rob(int[] nums) {
         int n = nums.length;
-        int[] dp = new int[n + 1];
-        dp[1] = nums[0];
+        int[] f = new int[n + 1];
+        f[1] = nums[0];
         for (int i = 2; i <= n; ++i) {
-            dp[i] = Math.max(nums[i - 1] + dp[i - 2], dp[i - 1]);
+            f[i] = Math.max(f[i - 1], f[i - 2] + nums[i - 1]);
         }
-        return dp[n];
+        return f[n];
     }
 }
 ```
 
 ```java
 class Solution {
     public int rob(int[] nums) {
-        int a = 0, b = nums[0];
+        int f = 0, g = nums[0];
         for (int i = 1; i < nums.length; ++i) {
-            int c = Math.max(nums[i] + a, b);
-            a = b;
-            b = c;
+            int t = g;
+            g = Math.max(g, f + nums[i]);
+            f = t;
         }
-        return b;
+        return g;
     }
 }
 ```
@@ -170,29 +133,13 @@ class Solution {
 public:
     int rob(vector<int>& nums) {
         int n = nums.size();
-        vector<int> f(n, -1);
-        function<int(int)> dfs = [&](int i) -> int {
-            if (i >= n) return 0;
-            if (f[i] != -1) return f[i];
-            f[i] = max(nums[i] + dfs(i + 2), dfs(i + 1));
-            return f[i];
-        };
-        return dfs(0);
-    }
-};
-```
-
-```cpp
-class Solution {
-public:
-    int rob(vector<int>& nums) {
-        int n = nums.size();
-        vector<int> dp(n + 1);
-        dp[1] = nums[0];
+        int f[n + 1];
+        memset(f, 0, sizeof(f));
+        f[1] = nums[0];
         for (int i = 2; i <= n; ++i) {
-            dp[i] = max(nums[i - 1] + dp[i - 2], dp[i - 1]);
+            f[i] = max(f[i - 1], f[i - 2] + nums[i - 1]);
         }
-        return dp[n];
+        return f[n];
     }
 };
 ```
@@ -201,14 +148,13 @@ public:
 class Solution {
 public:
     int rob(vector<int>& nums) {
-        int n = nums.size();
-        int a = 0, b = nums[0];
-        for (int i = 1; i < n; ++i) {
-            int c = max(nums[i] + a, b);
-            a = b;
-            b = c;
+        int f = 0, g = nums[0];
+        for (int i = 1; i < nums.size(); ++i) {
+            int t = g;
+            g = max(g, f + nums[i]);
+            f = t;
         }
-        return b;
+        return g;
     }
 };
 ```
@@ -218,41 +164,12 @@ public:
 ```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] != -1 {
-			return f[i]
-		}
-		f[i] = max(nums[i]+dfs(i+2), dfs(i+1))
-		return f[i]
-	}
-	return dfs(0)
-}
-
-func max(a, b int) int {
-	if a > b {
-		return a
-	}
-	return b
-}
-```
-
-```go
-func rob(nums []int) int {
-	n := len(nums)
-	dp := make([]int, n+1)
-	dp[1] = nums[0]
+	f := make([]int, n+1)
+	f[1] = nums[0]
 	for i := 2; i <= n; i++ {
-		dp[i] = max(nums[i-1]+dp[i-2], dp[i-1])
+		f[i] = max(f[i-1], f[i-2]+nums[i-1])
 	}
-	return dp[n]
+	return f[n]
 }
 
 func max(a, b int) int {
@@ -265,11 +182,11 @@ func max(a, b int) int {
 
 ```go
 func rob(nums []int) int {
-	a, b, n := 0, nums[0], len(nums)
-	for i := 1; i < n; i++ {
-		a, b = b, max(nums[i]+a, b)
+	f, g := 0, nums[0]
+	for _, x := range nums[1:] {
+		f, g = g, max(f+x, g)
 	}
-	return b
+	return g
 }
 
 func max(a, b int) int {
@@ -285,40 +202,22 @@ func max(a, b int) int {
 ```ts
 function rob(nums: number[]): number {
     const n = nums.length;
-    const f = new Array(n).fill(-1);
-    function dfs(i) {
-        if (i >= n) {
-            return 0;
-        }
-        if (f[i] != -1) {
-            return f[i];
-        }
-        f[i] = Math.max(nums[i] + dfs(i + 2), dfs(i + 1));
-        return f[i];
-    }
-    return dfs(0);
-}
-```
-
-```ts
-function rob(nums: number[]): number {
-    const n = nums.length;
-    const dp = new Array(n + 1).fill(0);
-    dp[1] = nums[0];
+    const f: number[] = Array(n + 1).fill(0);
+    f[1] = nums[0];
     for (let i = 2; i <= n; ++i) {
-        dp[i] = Math.max(nums[i - 1] + dp[i - 2], dp[i - 1]);
+        f[i] = Math.max(f[i - 1], f[i - 2] + nums[i - 1]);
     }
-    return dp[n];
+    return f[n];
 }
 ```
 
 ```ts
 function rob(nums: number[]): number {
-    const dp = [0, 0];
-    for (const num of nums) {
-        [dp[0], dp[1]] = [dp[1], Math.max(dp[1], dp[0] + num)];
+    let [f, g] = [0, nums[0]];
+    for (let i = 1; i < nums.length; ++i) {
+        [f, g] = [g, Math.max(f + nums[i], g)];
     }
-    return dp[1];
+    return g;
 }
 ```
 
@@ -327,11 +226,11 @@ function rob(nums: number[]): number {
 ```rust
 impl Solution {
     pub fn rob(nums: Vec<i32>) -> i32 {
-        let mut dp = [0, 0];
-        for num in nums {
-            dp = [dp[1], dp[1].max(dp[0] + num)]
+        let mut f = [0, 0];
+        for x in nums {
+            f = [f[1], f[1].max(f[0] + x)]
         }
-        dp[1]
+        f[1]
     }
 }
 ```