面试题17,16.按摩师

题目

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

注意：本题相对原题稍作改动

示例 1：

输入： [1,2,3,1]
输出： 4
解释： 选择 1 号预约和 3 号预约，总时长 = 1 + 3 = 4。
示例 2：

输入： [2,7,9,3,1]
输出： 12
解释： 选择 1 号预约、 3 号预约和 5 号预约，总时长 = 2 + 9 + 1 = 12。
示例 3：

输入： [2,1,4,5,3,1,1,3]
输出： 12
解释： 选择 1 号预约、 3 号预约、 5 号预约和 8 号预约，总时长 = 2 + 4 + 3 + 3 = 12。

思路

首先想到用深度优先搜索（dfs），按摩师每次按摩完有两种选择，休息一个时段以及休息两个时段，从起点 0 或 1 出发可以构成一个二叉树，对二叉树进行深度优先遍历。但是该二叉树深度最大为 n/2 对其遍历时间复杂度高达 O(2^(n/2)) ，复杂度太高无法通过所有测试用例。

class Solution {
private:
    int msum;
public:
    int massage(vector<int>& nums) {
        if(nums.empty())
            return 0;
        if(nums.size()==1)
            return nums[0];

        msum=0;
        int sum=0;
        dfs(0, sum, nums);
        dfs(1, sum, nums);
        return msum;
    }

    void dfs(int start, int sum, vector<int>& nums){
        sum+=nums[start];
        if(sum > msum)
            msum=sum;
        if(start+2<nums.size())
            dfs(start+2, sum, nums);
        if(start+3<nums.size())
            dfs(start+3, sum, nums);
    }
};

于是，想到动态规划解法。dp[i] 表示以 i 作为结束位置时的最长时长。根据 dp[i] = max(dp[i-2]+nums[i], dp[i-3]+nums[i]) 写出动态规划解法，复杂度只要 O(n)：

class Solution {
public:
    int massage(vector<int>& nums) {
        int n=nums.size();
        if(n==0)
            return 0;
        if(n==1)
            return nums[0];
        if(n==2)
            return max(nums[0], nums[1]);
        if(n==3)
            return max(nums[0]+nums[2], nums[1]);

        vector<int> dp(n, 0);
        dp[0]=nums[0], dp[1]=nums[1], dp[2]=nums[0]+nums[2];
        for(int i=3; i<n; i++){
            dp[i]=max(dp[i-2]+nums[i], dp[i-3]+nums[i]);
        }
        return max(dp[n-1], dp[n-2]);
    }
};