leetcode题：213. 打家劫舍 II（中等）

一、题目描述：213. 打家劫舍 II（中等）

你是一个专业的小偷，计划偷窃沿街的房屋，每间房内都藏有一定的现金。这个地方所有的房屋都围成一圈，这意味着第一个房屋和最后一个房屋是紧挨着的。同时，相邻的房屋装有相互连通的防盗系统，如果两间相邻的房屋在同一晚上被小偷闯入，系统会自动报警。

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

示例 1:

输入: [2,3,2]
输出: 3
解释: 你不能先偷窃 1 号房屋（金额 = 2），然后偷窃 3 号房屋（金额 = 2）, 因为他们是相邻的。
示例 2:

输入: [1,2,3,1]
输出: 4
解释: 你可以先偷窃 1 号房屋（金额 = 1），然后偷窃 3 号房屋（金额 = 3）。
     偷窃到的最高金额 = 1 + 3 = 4 。

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/house-robber-ii
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

二、解题思路

动态规划、

1、由于首尾不能同时访问。所有分为两部分，一部分是包含第一个节点，一部分是包含第二个节点。分别计算第一部分的最大值，和第二部分的最大值。

2、第一部分：由于不能连续访问两个节点，需要定义pre0，pre_pre0表示当前节点的前一个节点的最大值，以及前前一个节点（包含前面）最大值。pre0初始化为nums[1],pre_pre0初始化为nums[0]。

3、第二部分，定义pre0，pre_pre0表示当前节点的前一个节点的最大值，以及前前一个节点（包含前面）最大值。pre0初始化为nums[2],pre_pre0初始化为nums[1]。第二部分不能包含第一个节点，所以从1开始。

4、从三个节点开始遍历数组，如果计算当前节点的最大值int tmp0 = pre_pre0 + nums[i]，前前一个节点的最大值和当前节点值之和。然后pre_pre0，pre_pre0往前挪，即pre_pre_pre0 = max(pre0,pre_pre0),pre0 = tmp0。同理计算pre1，pre_pre1。

当到最后一个节点的时候只计算pre1，pre_pre1，因为第一部分不能包含最后的节点。

三、代码

class Solution {
public:
    int rob(vector<int>& nums) {
        int len = nums.size();
        if(len == 0)
            return 0;
        if(len == 1)
            return nums[0];
        int pre0 = 0;
        int pre1 = 0;
        int pre_pre0 = 0;
        int pre_pre1 = 0;

        for(int i = 0; i < len; i++)
        {
            if(i == 0)
            {
                pre0 = nums[0];
                continue;
            }
            if(i == 1)
            {
                pre1 = nums[1];
                pre_pre1 = pre1;
                pre_pre0 = pre0;
                pre0 = pre0;
                continue;
            }
            if(i == 2)
            {
                if (len -1 == 2)
                {
                    pre_pre0 = pre0;
                    pre0 = nums[i];
                    break;
                }
                pre_pre1 = pre1;
                pre1 = nums[2];
                int tmp = pre_pre0 + nums[i];
                if(pre0 > pre_pre0)
                {
                    pre_pre0 = pre0;
                }
                pre0 = tmp;
                continue;
            }
            if(i == len -1)
            {
                int tmp1 = pre_pre1 + nums[i];
                if(pre1 > pre_pre1)
                {
                    pre_pre1 = pre1;
                    pre1 = tmp1;
                }
                else
                {
                    pre1 = tmp1;
                }
            }
            if(i > 2 && i < len -1)
            {
                int tmp = nums[i] + pre_pre0;
                int tmp1 = nums[i] + pre_pre1;
                if(pre0 > pre_pre0)
                {
                    
                    pre_pre0 = pre0;
                    pre0 = tmp;
                }
                else
                {
                    pre0 = tmp;
                }
  
                if(pre1 > pre_pre1)
                {
                    pre_pre1 = pre1;
                    pre1 = tmp1;
                }
                else
                {
                    pre1 = tmp1;
                }
                /*
                cout<<"i="<<i<<endl;
                cout<<"pre0="<<pre0<<",pre_pre0="<<pre_pre0<<endl;
                cout<<"pre1="<<pre1<<",pre_pre1="<<pre_pre1<<endl;
                */
            }    
        }
        int max0 = max(pre0,pre_pre0);
        int max1 = max(pre1,pre_pre1);
      
        return max(max0,max1);
    }
 
};