按摩师

题目：按摩师

题目链接

题目描述：

一个有名的按摩师会收到源源不断的预约请求，每个预约都可以选择接或不接。在每次预约服务之间要有休息时间，因此她不能接受相邻的预约。给定一个预约请求序列，替按摩师找到最优的预约集合（总预约时间最长），返回总的分钟数。
示例：

题解：

这道题可以用递归和动态规划来写（虽然我用递归超时了，但是该题还是可以练习递归思维的）。
首先说一下递归的解法。用递归首先要找到递归出口，和如何减小规模。
递归出口很明显，向量的size（我们称为n），当n为0,1，2等等都可以成为出口。但是如何减小规模呢？我们可以想到，如果选择了最后一个预约，那么倒数第二个肯定不能再选了，那么返回值就为nums[n-1]+f(n-2).如果不选最后一个预约，那么肯定返回f(n-1). 我们要比较这两个哪个比较大，然后就返回哪个。
然后再说一下动态规划的解法。其实两者的思想是差不多的，只不过递归是从后面逐渐缩小规模，而动态规划是从前面逐渐增大规模。当n=0时，返回0，当n=1时，dp[0]=nums[0],当n=2时，只能选择二者最大的，即dp[1]=max(nums[0],nums[1]),当n=3时，只能选择第一个加第三个或者只选择第二个,所以选择二者中较大者，即dp[2]=max(num[2]+dp[0],dp[1]).由此递推dp[i]=max(nums[i]+dp(i-2),dp(i-1))，最后返回dp[n-1]即可。

代码1：（递归）

class Solution {
public:
int max(int a,int b)
{
    return a>b?a:b;
}
int f(vector<int>& nums,int n)
{
    if(n==0)
    {
        return 0;
    }
    else if(n==1)
    {
         return nums[0];
    }
    else if(n==2)
    {
        return max(nums[0],nums[1]);
    }
    else
    {
        return max(nums[n-1]+f(nums,n-2),f(nums,n-1));//选择最后一个或者不选择最后一个
    }
}
    int massage(vector<int>& nums) {
        return f(nums,nums.size());
    }
};

代码2：（动态规划）

class Solution {
public:
int max(int a,int b)
{
    return a>b?a:b;
}
    int massage(vector<int>& nums) {
        int n=nums.size();
        if(n==0)
        {
            return 0;
        }
        else if(n==1)
        {
            return nums[0];
        }
        else
        {
            int *dp=new int[n];
            dp[0]=nums[0];
            dp[1]=max(nums[0],nums[1]);
            int i;
            for(i=2;i<n;i++)
            {
                dp[i]=max(dp[i-1],nums[i]+dp[i-2]);
            }
            return dp[n-1];
        }
    }
};