关于不可以用动态规划的细节

1383. 最大的团队表现值

难度困难

公司有编号为 1 到 n 的 n 个工程师，给你两个数组 speed 和 efficiency ，其中 speed[i] 和 efficiency[i] 分别代表第 i 位工程师的速度和效率。请你返回由最多 k 个工程师组成的 最大团队表现值 ，由于答案可能很大，请你返回结果对 10^9 + 7 取余后的结果。

团队表现值 的定义为：一个团队中「所有工程师速度的和」乘以他们「效率值中的最小值」。

示例 1：

输入：n = 6, speed = [2,10,3,1,5,8], efficiency = [5,4,3,9,7,2], k = 2
输出：60
解释：
我们选择工程师 2（speed=10 且 efficiency=4）和工程师 5（speed=5 且 efficiency=7）。他们的团队表现值为 performance = (10 + 5) * min(4, 7) = 60 。

示例 2：

输入：n = 6, speed = [2,10,3,1,5,8], efficiency = [5,4,3,9,7,2], k = 3
输出：68
解释：
此示例与第一个示例相同，除了 k = 3 。我们可以选择工程师 1 ，工程师 2 和工程师 5 得到最大的团队表现值。表现值为 performance = (2 + 10 + 5) * min(5, 4, 7) = 68 。

示例 3：

 输入：n = 6, speed = [2,10,3,1,5,8], efficiency = [5,4,3,9,7,2], k = 4
输出：72

提示：

• 1 <= n <= 10^5

• speed.length == n

• efficiency.length == n

• 1 <= speed[i] <= 10^5

• 1 <= efficiency[i] <= 10^8

• 1 <= k <= n

1、超时解答：指数时间复杂度 暴力搜索

class Solution {
public:
/*
1、首先记忆的值是否是子问题的解
2、以做过的选择为状态其实是没有重复子问题的，状态位上必定不完全相同，所以一定是指数级别时间复杂度 超时
3、这题的后面的选择和当前的选择是有关系的，所以不可以用动态规划求解
4、复习一下动态规划的要求：当前的选择对 子问题的求解 不造成影响
5、只能暴力深搜，指数时间;如果当前的选择 对子问题的选择不造成影响，则可以用动态规划或深搜求解
6、只能另辟蹊径
*/
    int mod=1E9+7;
    unordered_map<string,int> memo;
    long long dfs(vector<int>& speed, vector<int>& efficiency, int k,int n,vector<int>&select,unsigned int& state){
        //选和不选
        if(k<=0){
            long long a=0,b=INT_MAX;
           // cout<<select.size()<<endl;
            for(int i=0;i<select.size();i++){
                b=min(b,(long long)efficiency[select[i]]);
                a+=speed[select[i]];
                a=a%mod;
                b%=mod;
            }
            return (a*b)%mod;
        }
        if(n<0) return 0;
        string tmp=to_string(state)+","+to_string(n)+to_string(k);
        if(memo[tmp]!=0)  return memo[tmp];
        long long res=dfs(speed,efficiency,k,n-1,select,state);        
        select.push_back(n);
        state=state|(1<<n);
        res=max(dfs(speed,efficiency,k-1,n-1,select,state),res);
        state=state^(1<<n);
        memo[tmp]=res;
        select.pop_back();
        return res;
    }
    int maxPerformance(int n, vector<int>& speed, vector<int>& efficiency, int k) {
        //dfs
        vector<int>select;
        unsigned int state=0;
        int res=INT_MIN;
        for(int k1=k;k1>0;k1--){
            memo.clear();
            res=max(res,(int)dfs(speed,efficiency,k1,n-1,select,state)) ;
        }
        return res;;
    }
};

---

2、正确解答：贪心

class Solution {
public:
    using LL = long long;

    struct Staff {
        int s, e;
        bool operator < (const Staff& rhs) const {
            return s > rhs.s;
        }
    };

    int maxPerformance(int n, vector<int>& speed, vector<int>& efficiency, int k) {
        vector<Staff> v;
        priority_queue<Staff> q;
        for (int i = 0; i < n; ++i) {
            v.push_back({speed[i], efficiency[i]});
        }
        sort(v.begin(), v.end(), [] (const Staff& u, const Staff& v) { return u.e > v.e; });
        LL ans = 0, sum = 0;
        for (int i = 0; i < n; ++i) {
            LL minE = v[i].e;
            LL sumS = sum + v[i].s;
            ans = max(ans, sumS * minE);
            q.push(v[i]); 
            sum += v[i].s;
            if (q.size() == k) {
                sum -= q.top().s;
                q.pop();
            }
        }
        return ans % (int(1E9) + 7);
    }
};