LeetCode--198. House Robber & 213. House Robber II

题目链接：https://leetcode.com/problems/house-robber/和https://leetcode.com/problems/house-robber-ii/

问题一思路：很显然是一个动态规划问题，我们先用暴力搜索来做一遍，类似于Fibonacci数列的暴力求法，代码如下，是不是感觉跟Fibonacci数列求法基本一致呀：

public static int recursive(int idx,int[] nums)
	{
		if(idx==0)
			return nums[0];
		if(idx==1)
			return Math.max(nums[0], nums[1]);
		return Math.max(recursive(idx-2,nums)+nums[idx],recursive(idx-1,nums));
	}
	

	public static int rob(int[] nums) {
        if(nums.length==0)
			return 0;
		if(nums.length==1)
			return nums[0];
		return recursive(nums.length-1,nums);
    }

当然有了暴力求法和十分显然的递推公式，动态规划解法也不是很难想，设置一个当前最有解数组OPT来作为memo存储，这里的OPT[i]表示对于第i个屋子取或者不取两种决策获得的最优收益的较大值，也就是第i步决策后的最大收益。代码如下：

public static int rob(int[] nums) {
		if(nums.length==0)
			return 0;
		if(nums.length==1)
			return nums[0];
		int[] OPT=new int[nums.length+1];
		OPT[0]=nums[0];
		OPT[1]=Math.max(nums[0],nums[1]);
		
		for(int i=2;i<=nums.length;i++)
		{
			int value=(i==nums.length)?0:nums[i];				
			OPT[i]=Math.max(OPT[i-2]+value,OPT[i-1]);
		}
		return OPT[nums.length];
    }

问题二思路：因为最后一个屋子与第一个屋子相邻了，所以第一个取不取就是很关键，因为它涉及到最后一个屋子能不能取到，那就分两次动态规划来做，最后取两个DP最优解的较大值。值得注意的是，第一个屋子到底取不取，动态规划的初值是不一样的。举个栗子，帮大家理解一下：nums:[1,2,3,1]

nums[0]不取，OPT[0]=0,OPT[1]=nums[1]=2,OPT[2]=max(OPT[1],OPT[0]+nums[2])=3,OPT[3]=max(OPT[1]+nums[3],OPT[2])=3(最后一个取还是不取看情况，如果不取的解最大就不取，如果取的解最大则取)，OPT[4]=max(OPT[3],OPT[2])=3。

nums[0]取，OPT[0]=nums[0],OPT[1]=OPT[0],OPT[2]=max(OPT[1],OPT[0]+nums[2])=4,OPT[3]=OPT[2](最后一个不取)

详细代码如下：

lass Solution {
    public int rob(int[] nums) {
        
        if(nums.length==0)
            return 0;
        if(nums.length==1)
            return nums[0];
        int[] skipFirstDP=new int[nums.length+1];
        skipFirstDP[0]=0;
        skipFirstDP[1]=nums[1];
        for(int i=2;i<skipFirstDP.length;i++)
        {
            int val=i==nums.length?0:nums[i];
            skipFirstDP[i]=Math.max(val+skipFirstDP[i-2],skipFirstDP[i-1]);
        }
        
        int[] DP=new int[nums.length];
        DP[0]=nums[0];
        DP[1]=nums[0];
        for(int i=2;i<nums.length;i++)
        {
            int val=i==nums.length-1?0:nums[i];
            DP[i]=Math.max(val+DP[i-2],DP[i-1]);
        }
        
        return Math.max(skipFirstDP[skipFirstDP.length-1],DP[DP.length-1]);
    }
}