《leetCode》：House Robber

题目

You are a professional robber planning to rob houses along a street. Each house has a certain amount of money stashed, the only constraint stopping you from robbing each of them is that adjacent houses have security system connected and it will automatically contact the police if two adjacent houses were broken into on the same night.

Given a list of non-negative integers representing the amount of money of each house, determine the maximum amount of money you can rob tonight without alerting the police.

思路：超时

思路：有两种情况可能产生最大值，第一种是第一个元素参与计算，第二种是第二个元素参与计算。而无论是那种情况参与计算，参与产生最大值的第二个元素应该是在距离这个元素位置的第2个或第3个位置上。

实现代码如下：

/*
函数功能：
第start个元素被盗可能产生的最大值 */
int max(int a,int b){
    return a>b?a:b;
}
int robHelper(int* nums, int numsSize,int start){
    if(nums==NULL||numsSize<1||numsSize<=start){
        return 0;
    }
    return nums[start]+max(robHelper(nums,numsSize,start+2),robHelper(nums,numsSize,start+3));
}

int rob(int* nums, int numsSize) {  
    int fristElementMax=robHelper(nums,numsSize,0);//第一个元素被盗后产生的最大值 
    int secondElementMax=robHelper(nums,numsSize,1);//第二个元素被盗后可能产生的最大值 
    return fristElementMax>secondElementMax?fristElementMax:secondElementMax;
}

很遗憾，报超时错误，原因是我们重复计算了很多次，因此，借用一个数组空间来保存计算过的值就可以了。

思路二：借用数组空间

实现代码如下：

int *result;
int max(int a,int b){
    return a>b?a:b;
}
int robHelper(int* nums, int numsSize,int start){
    if(nums==NULL||numsSize<1||numsSize<=start){
        return 0;
    }
    if(result[start]!=0){
        return result[start];
    }
    int res1=robHelper(nums,numsSize,start+2);
    int res2=robHelper(nums,numsSize,start+3);
    int res=nums[start]+max(res1,res2);
    result[start]=res;
    return ;
}

int rob(int* nums, int numsSize) {  
    if(nums==NULL||numsSize<1){
        return 0;
    }
    result=(int *)malloc(numsSize*sizeof(int));
    if(result==NULL){
        exit(EXIT_FAILURE);
    } 
    memset(result,0,numsSize*sizeof(int));//初始化为零 
    int fristElementMax=robHelper(nums,numsSize,0);//第一个元素被盗后产生的最大值 
    int secondElementMax=robHelper(nums,numsSize,1);//第二个元素被盗后可能产生的最大值 
    return fristElementMax>secondElementMax?fristElementMax:secondElementMax;
}

很可惜，依然还是报超时。没有AC。确实很纠结也。超时用例如下：

我就改变了下

memset(result,-1,numsSize*sizeof(int));//初始化为-1.
//并在robHelper函数中修改了相应的判断条件。
if(result[start]!=-1){
        return result[start];
    }

结果出乎我的意料，居然AC了。

思路三

上面的递归是从第一个、第二个元素参与可能产生最大值来进行递归，下面将换一种思路，从后往前，求出第i个位置往后可能产生的最大值。

int max(int a,int b){
    return a>b?a:b;
}
int rob(int* nums, int numsSize) {  
    if(nums==NULL||numsSize<1){
        return 0;
    }
    int *result=(int *)malloc(numsSize*sizeof(int));
    if(result==NULL){
        exit(EXIT_FAILURE);
    } 
    memset(result,-1,numsSize*sizeof(int));//初始化为-1     
    for(int i=numsSize-1;i>=0;i--){
        if(i==numsSize-1){
            result[numsSize-1]=nums[numsSize-1];
        }
        else if(i==numsSize-2){
            result[numsSize-2]=nums[numsSize-2];
        }
        else if(i==numsSize-3){
            result[i]=nums[i]+nums[i+2];
        }
        else {
            result[i]=nums[i]+max(result[i+2],result[i+3]);
        }
    }
    return max(result[0],result[1]);
}