力扣--动态规划198.打家劫舍

思路分析：

1. 创建一个二维向量 dp 用于存储动态规划的结果，其中 dp[i][0] 表示在不抢劫当前房屋的情况下到达第 i 个房屋时的最大金额，dp[i][1] 表示在抢劫当前房屋的情况下到达第 i 个房屋时的最大金额。
2. 初始化基本情况：如果没有房屋，则不抢劫的最大金额为 0，如果只有一间房屋，则抢劫的最大金额为该房屋的价值。
3. 从第二个房屋开始迭代，根据状态转移方程更新 dp[i][0] 和 dp[i][1]：
   • 不抢劫当前房屋时，dp[i][0] 取前一个房屋抢或不抢的最大金额。
   • 抢劫当前房屋时，dp[i][1] 取前一个房屋不抢的最大金额加上当前房屋的价值。
4. 最终结果是最后一个房屋抢或不抢的最大金额，即 max(dp[nums.size() - 1][0], dp[nums.size() - 1][1])。

class Solution {
public:
    // 计算能够抢劫的最大金额的函数
    int rob(vector<int>& nums) {
        // 创建一个二维向量用于存储动态规划的结果
        // dp[i][0] 表示在不抢劫当前房屋的情况下到达第 i 个房屋时的最大金额
        // dp[i][1] 表示在抢劫当前房屋的情况下到达第 i 个房屋时的最大金额
        vector<vector<int>> dp(nums.size(), vector<int>(2, 0));
        
        // 基本情况：如果没有房屋，则不抢劫的最大金额为 0
        dp[0][0] = 0;
        // 如果只有一间房屋，则抢劫的最大金额为该房屋的价值
        dp[0][1] = nums[0];
        
        // 从第二个房屋开始迭代
        for (int i = 1; i < nums.size(); i++) {
            // 如果不抢劫当前房屋，最大金额取前一个房屋抢或不抢的最大金额
            dp[i][0] = max(dp[i - 1][0], dp[i - 1][1]);
            // 如果抢劫当前房屋，最大金额取前一个房屋不抢的最大金额加上当前房屋的价值
            dp[i][1] = dp[i - 1][0] + nums[i];
        }
        
        // 最终结果是最后一个房屋抢或不抢的最大金额
        return max(dp[nums.size() - 1][0], dp[nums.size() - 1][1]);
    }
};

---------------------------------------------------------------------------------------------------------------------------------
以上思路较为简单，下面是更加高效的做法以供学习参考：

思路分析：

1. 首先检查特殊情况，如果没有房屋，则返回抢劫金额为 0；如果只有一间房屋，则返回抢劫该房屋的金额。
2. 创建一个一维向量 dp 用于存储动态规划的结果，其中 dp[i] 表示抢劫前 i 个房屋能够得到的最大金额。
3. 初始化前两个房屋的抢劫金额，分别为第一个房屋的价值和前两个房屋中的最大价值。
4. 从第三个房屋开始迭代，每个房屋的抢劫金额取决于前两个房屋抢劫或不抢劫的最大金额。
5. 最终结果是最后一个房屋抢或不抢的最大金额，即 dp[nums.size() - 1]。

class Solution {
public:
    // 计算能够抢劫的最大金额的函数
    int rob(vector<int>& nums) {
        // 如果没有房屋，则返回抢劫金额为 0
        if (nums.size() == 0) return 0;
        // 如果只有一间房屋，则返回抢劫该房屋的金额
        if (nums.size() == 1) return nums[0];
        
        // 创建一个一维向量用于存储动态规划的结果
        vector<int> dp(nums.size());
        
        // 初始化前两个房屋的抢劫金额
        dp[0] = nums[0];
        dp[1] = max(nums[0], nums[1]);
        
        // 从第三个房屋开始迭代
        for (int i = 2; i < nums.size(); i++) {
            // 当前房屋的抢劫金额为前两个房屋抢劫或不抢劫的最大金额
            dp[i] = max(dp[i - 2] + nums[i], dp[i - 1]);
        }
        
        // 最终结果是最后一个房屋抢或不抢的最大金额
        return dp[nums.size() - 1];
    }
};