LeeCode 198——打家劫舍，求数组中不相邻的数的最大和

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

给定一个代表每个房屋存放金额的非负整数数组，计算你不触动警报装置的情况下 ，一夜之内能够偷窃到的最高金额。
输入: [2,7,9,3,1]
输出: 12
输入: [1,2,3,1]
输出: 4

分析：
我最开始的思想就是求一个数组中的奇数和与偶数和，看哪个比较大，然后没有AC，所以看了评论用动态规划。打算好好理一下动态规划思路。

动态规划：设len为打算要盗窃的房屋数，当len=0时，结果dp[0]=0；len=1时，dp[1]=nums[0];当len=2时开始有选择了，选择哪个价值最大的房屋实施盗窃dp[2] = max(nums[0], nums[1])；当len=3时，选择dp[3] = max(nums[0]+nums[2], nums[1]) = max(dp(3-2)+nums(3-1), dp[2])；以此类推，因此动态规划的主角就从2开始计算，先给i=0与i=1时的dp[i]赋初值。
最终得出len>=2时dp[i+1] = max(dp[i], dp[i-1]+nums[i]);dp[8]最优=dp[7]与dp[6]+nums[i]的最大值。

C代码：

int rob(int* nums, int numsSize)
{
	int *dp = (int*)malloc(sizeof(int)*numsSize);//dp[i]表从i+1间房能盗走钱财的最大数值
	int max = 0;
	if(numsSize == 0)
		return 0;
	if(numsSize == 1)
		return nums[0];
	
	dp[0] = nums[0];
	dp[1] = max(nums[0], nums[1]);
	for(int i=2;i<numsSize;i++)
	{
		dp[i] = max(dp[i-1], dp[i-2]+nums[i]);
	}
	max = dp[numsSize-1]
	free(dp);
	return max;
}

C++代码：

#include<iostream>
#include<Windows.h>
#include<vector>
using namespace std;

int rob(vector<int>& nums) 
{
    int n = nums.size(),maxed=0;
    vector<int> dp(n+1);//dp[i]表从i间房能盗走钱财的最大数值
    if(n==0) 
        return 0;
    if(n==1) 
        return nums[0];
    if(n==2) 
        return max(nums[0], nums[1]);
     
	dp[0] = 0;
    dp[1] = nums[0];
    for(int i=1;i<n;i++)
    {
        dp[i+1] = max(dp[i], dp[i-1]+nums[i]);
    }
    maxed = dp[n];
    return maxed;
}

int main()
{
	int num[4] = {1,2,3,1};
	vector<int> nums(num,num+4);
	
	//nums[4]={1,2,3,1};
	int m = rob(nums);
	
	cout<<m;
	return 0;

}

笔记：

• vector的定义：

int num[4] = {1,2,3,1};
vector<int> nums(num,num+4);

• 求vector的size大小

n = nums.size()