LeetCode-198. 打家劫舍

题目描述

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

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

示例 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 。

递归求解

思路：将问题进行分解成两种情况，当前房屋抢或者不抢，如果抢了当前房屋，则下一个房屋不能抢。如果当前房屋不抢，则下一个房屋可以抢。

class Solution {
public:
    int rob(vector<int>& nums) {
         return rob_recusion(nums,nums.size()-1);
    }
private:
    int rob_recusion(vector<int>& nums, int index)
    {
        //递归求解
        if(index < 0)
            return 0;

        //分解成两个子问题
        //当前抢了下一家不能抢
        //当前没有抢下一家可以抢
        int maxres = max(nums[index] + rob_recusion(nums, index-2),rob_recusion(nums, index-1));
        return maxres;
    }
};

把这个答案提交后，发现超出了时间限制，显然是递归的次数太多导致的。继续用记忆路径的方法进行优化。

class Solution 
{
public:
    int rob(vector<int>& nums) 
    {
        m_mem = vector<int>(nums.size()+1, -1);
        return rob_recusion(nums,nums.size()-1);
    }
private:
    int rob_recusion(vector<int>& nums, int index)
    {
        //递归求解
        if(index < 0)
            return 0;

        //分解成两个子问题
        //当前抢了下一家不能抢
        //当前没有抢下一家可以抢
        if(m_mem[index] != -1)
            return m_mem[index];

        int maxres = max(nums[index] + rob_recusion(nums, index-2),rob_recusion(nums, index-1));
        m_mem[index] = maxres;

        return maxres;
    }
    vector<int> m_mem;
};

利用路径记忆的方法进行优化后，再次提交之后就可以正常通过。

动态规划

下面利用动态规划进行进一步的优化。
根据上面路径记忆的递归算法，可以得到动态规划的迭代公式。
resmax[i] = max(nums[i] + resmax[i-2], resmax[i-1])加上对基准情况添加额外的判断，可以得到如下的算法。

class Solution 
{
public:
    int rob(vector<int>& nums) 
    {
        if(nums.size() == 0)
            return 0;
        if(nums.size() == 1)
            return nums[0];
        if(nums.size() == 2)
            return max(nums[0], nums[1]);

        vector<int> resmax(nums.size()+1, 0);
        
        //基准情况
        resmax[0] = nums[0];
        resmax[1] = max(nums[0], nums[1]);
        for(int index=2;index < nums.size();++index)
        {
            resmax[index] =  max(nums[index] + resmax[index-2], resmax[index-1]);
        }

        return resmax[nums.size()-1];
    }
};

动态规划解题步骤

动态规划解题的关键是要能够找到对应的子问题，将原问题进行分解，然后利用递归的方式实现，然后再将递归的解改写成动态规划。

1. 实现递归解
2. 实现带路径记忆的递归解（一般情况下已经可以满足要求）
3. 改写成动态规划算法