打家劫舍

你是一个专业的小偷，计划偷窃沿街的房屋。每间房内都藏有一定的现金，影响你偷窃的唯一制约因素就是相邻

的房屋装有相互连通的防盗系统，如果两间相邻的房屋在同一晚上被小偷闯入，系统会自动报警。 

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

	public static int[] result; // 定义一个备忘录
	public int rob(int[] nums)
	{
		result = new int[nums.length];
		for (int i=0; i<nums.length; i++)
		{
			result[i] = -1; // 表示还没有算过
		}
		return solve(nums.length-1, nums);
	}
	
	/**
	 * @param idx 现在抢到的第几家店
	 * @param nums 
	 * @return
	 */
	public int solve(int idx, int[] nums)
	{
		if (idx < 0)
			return 0;
		// 大于等于0，表示该状态已经计算过了
		if (result[idx] >= 0)
			return result[idx];
		
		// 对于每一家店，只有两种决策，抢或者不抢，将计算过的值保存起来
		result[idx] = Math.max(nums[idx] + solve(idx-2, nums), solve(idx-1, nums));
		return result[idx];
	}

假设题目稍微有些变动，这个地方所有的房屋都围成一圈，这意味着第一个房屋和最后一个房屋是紧挨着的。

同时，相邻的房屋装有相互连通的防盗系统，如果两间相邻的房屋在同一晚上被小偷闯入，系统会自动报警。 

	public int[] result1; // 定义一个备忘录
	public int[] result2; // 定义一个备忘录
	public int rob(int[] nums)
	{
		if (nums == null || nums.length == 0)
			return 0;
		
		if (nums.length == 1)
			return nums[0];
		
		if (nums.length == 2)
			return Math.max(nums[0], nums[1]);
		
		result1 = new int[nums.length];
		result2 = new int[nums.length];
		
		for (int i=0; i<nums.length; i++)
		{
			result1[i] = -1; // 表示还没有算过
			result2[i] = -1; // 表示还没有算过
		}
		// 抢第一家店1,[3,n-2]和不抢第一家店[2,n]                {3,n-2}
		int a = solve1(2, nums) + nums[0];
		int b = solve2(1, nums);
		return Math.max(a, b);
	}
	
	
	public int solve1(int idx, int[] nums)
	{
		if (idx > nums.length-2)
			return 0;
		
		// 大于等于0，表示该状态已经计算过了
		if (result1[idx] >= 0)
			return result1[idx];
		
		result1[idx] = Math.max(nums[idx]+solve1(idx+2, nums), solve1(idx+1, nums));
		return result1[idx];
	}
	
	public int solve2(int idx, int[] nums)
	{
		if (idx >= nums.length)
			return 0;
		// 大于等于0，表示该状态已经计算过了
		if (result2[idx] >= 0)
			return result2[idx];
		
		// 对于每一家店，只有两种决策，抢或者不抢，将计算过的值保存起来
		result2[idx] = Math.max(nums[idx] + solve2(idx+2, nums), solve2(idx+1, nums));
		return result2[idx];
	}