【Leetcode HOT100】打家劫舍 c++

题目描述：

你是一个专业的小偷，计划偷窃沿街的房屋。每间房内都藏有一定的现金，影响你偷窃的唯一制约因素就是相邻的房屋装有相互连通的防盗系统，如果两间相邻的房屋在同一晚上被小偷闯入，系统会自动报警。

给定一个代表每个房屋存放金额的非负整数数组，计算你 不触动警报装置的情况下 ，一夜之内能够偷窃到的最高金额。

示例1：

输入：[1,2,3,1]
输出：4
解释：偷窃 1 号房屋 (金额 = 1) ，然后偷窃 3 号房屋 (金额 = 3)。
偷窃到的最高金额 = 1 + 3 = 4 。

示例2：

输入：[2,7,9,3,1]
输出：12
解释：偷窃 1 号房屋 (金额 = 2), 偷窃 3 号房屋 (金额 = 9)，接着偷窃 5 号房屋 (金额 = 1)。
偷窃到的最高金额 = 2 + 9 + 1 = 12 。

提示：

1 <= nums.length <= 100
0 <= nums[i] <= 400

基础方法 递归 c++代码：

class Solution {
public:
    int solve(vector<int>& nums,int n,int nn){
        if(nn==0)return nums[0];
        if(nn==1)return max(nums[0],nums[1]);
        return max(nums[nn]+solve(nums,n,nn-2),solve(nums,n,nn-1));//要么选择当前数字不选其后面一个数字（选择后面第二个数字），要么不选当前数字选择其后面数字
    }
    int rob(vector<int>& nums) {
        int n = nums.size();
        return solve(nums,n,n-1);
    }
};

递归：

每次选择数字时有两种选择：选择当前数字，跳过其下一个数字，下一次从后面第二个数字继续查找；不选择当前数字，直接从其下一个数字继续查找。

nn表示从后向前遍历数字的下标。当nn=0，只有一个数字，直接返回nums[0]。当nn=1，只有两个数字，判断哪个数字大就返回哪个。当nn>2，进行递归，判断选择第nn个数字，下次从nn-2处继续查找**【nums[nn]+solve(nums,n,nn-2)】和不选择第nn个数字，下次从nn-1继续查找【solve(nums,n,nn-1)】**哪个结果更大就返回哪个。

递归太慢，超时了。

动态规划 c++代码：

class Solution {
public:
    //动态规划：d[i] = max(nums[i]+d[i+2],d[i+1])
    int rob(vector<int>& nums) {
        int n = nums.size();
        if(n==1)return nums[0];
        if(n==2)return max(nums[0],nums[1]);
        //d[i]记录到第i个数的最大偷窃值，d[n-1]记录整个数组的最大偷窃值
        int d[n]; 
        d[0] = nums[0];
        d[1] = max(nums[0],nums[1]);
        for(int i=2;i<n;i++){
            d[i] = max(nums[i]+d[i-2],d[i-1]);
        }
        return d[n-1];
    }
};

其实在递归中，max( nums[nn]+solve(nums,n,nn-2), solve(nums,n,nn-1))就是状态转移规律，变形一下即可得到动态转移式：

d[0] = nums[0]
d[1] = max(nums[0], nums[1])
d[i] = max(nums[i]+d[i-2], d[i-1)

用状态转移式进行动态规划，把递归部分solve()用数组来代替，把递归的中间结果用数组记录下来，递归是规模从大到小（从n-1到0），而动态规划是规模从小到大（从0到n-1）。

总结：

（1）找最优解问题，最适合使用动态规划。把求解最优解问题，分解为不独立的子问题，自
底向上地计算最优值。

（2）递归，因为在递归过程中重复计算值，所以时间复杂度高。递归是自顶向下，动态规划是自底向上，用数组记录计算的中间结果。通常可以把递归改为动态规划以降低时间复杂度。