leetcode 213. House Robber II

和第198题没有本质区别。

定义dp数组，n是房间总个数。dp[i]表示从第0号房间一直到第i号房间（包含第i号房间）可以偷到的最大金额，按照这个定义，dp[n-1]就是答案。dp[0]一直到dp[n-2]的求法和第198题一模一样，唯独dp[n-1]需要特别考虑。

对于最后一个房间（即第n-1号房间），只有两种可能，偷或者不偷。

1. 如果不偷第n-1号房间，则dp[n-1] = dp[n-1-1]。
2. 如果偷第n-1号房间，则除了像第198题一样不能偷第n-2号房间外，还要求一定不能偷第0号房间。问题可以转化为，不考虑第0号房间，只考虑从第1号房间一直到第n-1-2号房间。因此另外定义一个dp2数组。dp2[i]表示从第1号房间一直到第i号房间（包含第i号房间）可以偷到的最大金额，dp2[0]不定义。dp[n-1] = dp2[n-1-2] + nums[n-1]。

dp[n-1]取前述两种情况的最大值，dp[n-1] = max(dp[n-1-1], dp2[n-1-2] + nums[n-1]);

第一版代码

class Solution {
public:
    int rob(vector<int>& nums) {
        int n = nums.size();
        //dp[i]表示从第0号房间一直到第i号房间（包含第i号房间）可以偷到的最大金额
        //按照这个定义，dp[n-1]就是答案。
        vector<int> dp(n);
        dp[0] = nums[0];
        if(n ==1)   return dp[0];
        dp[1] = max(nums[0],nums[1]);
        if(n ==2)   return dp[1];
        //dp[0]一直到dp[n-2]的求法和第198题一模一样，唯独dp[n-1]需要特别考虑。
        for(int i = 2;i < n -1;i++){
            dp[i] = max(dp[i-2]+nums[i],dp[i-1]);
        }

        //dp2[i]表示从第1号房间一直到第i号房间（包含第i号房间）可以偷到的最大金额，dp2[0]不定义
        vector<int> dp2(n);
        dp2[1] = nums[1];
        dp2[2] = max(nums[1],nums[2]);
        for(int i = 3; i < n;i++){
            dp2[i] = max(dp2[i-2]+nums[i],dp2[i-1]);
        }

        dp[n-1] = max(dp2[n-1-2]+nums[n-1],dp[n-1-1]);
        return dp[n-1];
    }
};

求dp2和求dp可以在一次遍历中求取。

class Solution {
public:
    int rob(vector<int>& nums) {
        int n = nums.size();
        //dp[i]表示从第0号房间一直到第i号房间（包含第i号房间）可以偷到的最大金额
        //按照这个定义，dp[n-1]就是答案。
        vector<int> dp(n);
        dp[0] = nums[0];
        if(n ==1)   return dp[0];
        dp[1] = max(nums[0],nums[1]);
        if(n ==2)   return dp[1];
        if(n ==3)   return max(max(nums[0],nums[1]),nums[2]);

        //dp2[i]表示从第1号房间一直到第i号房间（包含第i号房间）可以偷到的最大金额，dp2[0]不定义
        vector<int> dp2(n);
        dp2[1] = nums[1];
        dp2[2] = max(nums[1],nums[2]);
        for(int i = 2;i < n -1;i++){
            if(i>=3)
                dp2[i] = max(dp2[i-2]+nums[i],dp2[i-1]);
            dp[i] = max(dp[i-2]+nums[i],dp[i-1]);
        }
        //dp[n-1]需要特别考虑
        dp[n-1] = max(dp2[n-1-2]+nums[n-1],dp[n-1-1]);
        return dp[n-1];
    }
};