1402. 做菜顺序 贪心\动态规划\排序 困难

题目描述：

一个厨师收集了他 n 道菜的满意程度 satisfaction ，这个厨师做出每道菜的时间都是 1 单位时间。

一道菜的 「 like-time 系数 」定义为烹饪这道菜结束的时间（包含之前每道菜所花费的时间）乘以这道菜的满意程度，也就是 time[i]*satisfaction[i] 。

返回厨师在准备了一定数量的菜肴后可以获得的最大 like-time 系数 总和。

你可以按 任意 顺序安排做菜的顺序，你也可以选择放弃做某些菜来获得更大的总和。

样例数据：

示例 1：

输入：satisfaction = [-1,-8,0,5,-9]
输出：14
解释：去掉第二道和最后一道菜，最大的 like-time 系数和为 (-1*1 + 0*2 + 5*3 = 14) 。每道菜都需要花费 1 单位时间完成。

示例 2：

输入：satisfaction = [4,3,2]
输出：20
解释：可以按照任意顺序做菜 (2*1 + 3*2 + 4*3 = 20)

示例 3：

输入：satisfaction = [-1,-4,-5]
输出：0
解释：大家都不喜欢这些菜，所以不做任何菜就可以获得最大的 like-time 系数。

提示：

• n == satisfaction.length
• 1 <= n <= 500
• -1000 <= satisfaction[i] <= 1000

解法一：贪心+排序+后缀和

首先，我们可以轻易得到结论：

对于满意度为正数的菜品，一定会制作；满意度越高的菜品，制作顺序越靠后。

所以，我们先对菜品满意度序列进行升序排序。

排序后，起始的菜品满意度一定是最小的，而且可能小于0，对于小于0的菜品，我们又如何确定其是否应该制作呢？

我们先假设某个最终的菜品制作序列如下，一共有六道菜品，用字母代表满意度：

A B C D E F （A最小，F最大）

那么我们计算其 like-time系数总和的结果即为：

A+2*B+3*C+4*D+5*E+6*F

换一种写法，其结果就等价于:

（A+B+C+D+E+F）+（B+C+D+E+D）+（C+D+E+F）+（D+E+F）+（E+F）+（F）  

通过观察可知，like-time系数总和就等价于每个元素的后缀和（包括该元素）之和。

那么我们就可以用每个元素的后缀和来作为将该菜品加入制作序列得到的收益。

也就是说，对于当前元素，如果其后缀之和大于等于0，那么其对于最终结果的收益就是正向的，我们就将其加入制作序列。

 这就是我们对负数元素的判定标准。

代码：

class Solution {
public:
    int maxSatisfaction(vector<int>& satisfaction) {
        int n= satisfaction.size();
        sort(satisfaction.begin(),satisfaction.end());
        int add[502]={0};
        for(int i=n-1;i>=0;i--)
        {
            add[i]=add[i+1]+satisfaction[i];
        }
        int t=1;
        int ans = 0;
        for(int i=0;i<n;i++)
        if(satisfaction[i]>=0||add[i]>=0)
        {
            ans+=satisfaction[i]*t;
            t++;
        }
        return ans;
    }
};

运行结果：

优化思路：

因为我们排序后的数组是单调递增的， 如果当前元素的后缀和大于等于0，那么下一个元素的后缀后一定也大于等于0,所以我们只需要确定第一个后缀和小于0的元素的位置即可，不需要保存所有的后缀和。

class Solution {
public:
    int maxSatisfaction(vector<int>& satisfaction) {
        int n= satisfaction.size();
        sort(satisfaction.begin(),satisfaction.end());
        int sum=0;
        int mark=n;
        for(int i=n-1;i>=0;i--)
        {
            sum+=satisfaction[i];
            mark--;
            if(sum<0)
            {
                mark=i+1;
                break;
            }
        }
        int t=1;
        int ans = 0;
        for(int i=mark;i<n;i++)
        {
            ans+=satisfaction[i]*t;
            t++;
        }
        return ans;
    }
};

优化掉了add[]数组，但是提交结果没有什么提升（悲）。

解法二：动态规划+排序

官方题解给出思路已经很详尽了，这里简单复述一下：

先对序列进行排序，假设 dp[i][j] 表示前 i 道菜品选了 j 道菜进行制作后得到的 time-like系数之和，那么就存在两种情况：

1. 第 i 道菜品没有被选择，那么就要在前 i-1 道菜品中选择 j 道：

dp[i][j] = dp[i-1][j]

2. 第 i 道菜品被选择，那么前 i-1 道菜品中要选择 j-1 道制作，并且当前菜品的 time-like系数也要加入到结果中：

dp[i][j] = dp[i-1][j-1]+satisfaction[i]*j;

3. 最终 dp[i][j] 的值为前两种情况中的较大值

dp[i][j] = max( dp[i-1][j] , dp[i-1][j-1]+satisfaction[i]*j );

 结果就是max(dp[x][y]），其中x,y表示0到n-1的任何数。

代码：

注意当 j==i 时不存在不选取第 i 个菜品的情况。

class Solution {
public:
    int maxSatisfaction(vector<int>& satisfaction) {
        int n= satisfaction.size();
        sort(satisfaction.begin(),satisfaction.end());
        int dp[501][501];
        int ans = 0;
        for(int i=1;i<=n;i++){
            for(int j=1;j<=i;j++)
            {
                dp[i][j]=dp[i-1][j-1]+satisfaction[i-1]*j;
                if(j<i)
                {
                    dp[i][j]=max(dp[i-1][j],dp[i][j]);
                }
                ans = max(ans,dp[i][j]);
            }
        }
        return ans;
    }
};