[LeetCode][初级算法][动态规划] 打家劫舍

https://leetcode-cn.com/explore/interview/card/top-interview-questions-easy/23/dynamic-programming/57/

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

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

题目的意思就是说不能同时偷相邻的两个房子。也就是说对于当前房子来说，如果偷，则前一个房子不能偷，那么获得的总金额就是前前个房子的金额加上当前房子的金额；如果不偷，则能获得的金额就等于偷前一个房屋时所获得的金额。

也就是：

f(n) = f(n-1) > f(n-2) + V(n) ?  f(n-1) : f(n-2) + V(n)

总结出了这个规律以后，我们发现只需要用两个变量保存上个房子和上上个房子的结果，就可以推导到任意一步的结果。

int rob(int* nums, int numsSize) {
    if(numsSize==0)
        return 0;
    int fn,fn_1,fn_2;
    fn_2 = 0;
    fn_1 = nums[0];
    fn = fn_1;
    
    int i;
    for(i=1;i<numsSize;i++){
        if(fn_2+nums[i] > fn_1){
            fn = fn_2+nums[i];
            fn_2 = fn_1;
            fn_1 = fn;
        }else{
            fn = fn_1;
            fn_2 = fn_1;               
        }        
    }
    return fn;
}

或者我们可以把结果全部保存下来，方便多次查询：

inline int max(int a,int b){
    if(a>b){
        return a;
    }
    else{
        return b;
    }
}
int rob(int* nums, int numsSize) {
    if(numsSize==0)return 0;
    
    int dp[numsSize][2];
    dp[0][0]=0;
    dp[0][1]=nums[0];
    
    for(int i=1;i<numsSize;i++){
        dp[i][0]=max(dp[i-1][0],dp[i-1][1]);
        dp[i][1]=dp[i-1][0]+nums[i];
    }
    
    return max(dp[numsSize-1][0],dp[numsSize-1][1]);
}

这种方法对于每一步的两个可能性都进行了计算。