【LeetCode - 每日一题】1090. 受标签影响的最大值 （2023.05.23）

1090. 受标签影响的最大值

题意

• 涉及两个数组的排序
• 分别对两个数组的选择有不同的要求

解法1 排序 + 哈希

这道题本质上其实很简单，首先根据 labels 排序，当 labels 相同时，根据 values 从大到小排序，然后将每个 labels 的前 useLimit 个取出来，再将这些取出来的值按从大到小排序，再取前 numWanted 作和即可。

道理也很简单，因为规定了每个 labels 最多只能取 useLimit 次，而要求的又是 values 的最大值，所以结果只和每个 labels 的前 useLimit 个最大的 values 有关。

又由于数据没有负数，所以直接将每个 labels 的前 useLimit 个取出来，直接排序然后无脑求前 numWanted 个数的和即可。

class Solution {
public:

    int largestValsFromLabels(vector<int>& values, vector<int>& labels, int numWanted, int useLimit) {
        unordered_map<int, vector<int> > mp;
        int ans = 0;

        for(int i = 0; i < values.size(); i++)
        {
            mp[labels[i]].push_back(values[i]);
        }
        for(auto &[label, value] : mp)
        {
            sort(value.begin(), value.end(), greater<int>());
        }
        vector<int> tmp;
        for(auto &[label, value] : mp)
        {
            int n = useLimit > value.size() ? value.size() : useLimit;
            for(int i = 0; i < n; i++)
            {
                tmp.push_back(value[i]);
            }
        }
        sort(tmp.begin(), tmp.end(), greater<int>());
        int n = numWanted > tmp.size() ? tmp.size() : numWanted;
        for(int i = 0; i < n; i++)
        {   
            ans += tmp[i];
        }   
        return ans;
    }
};

解法2 只排序 values + 哈希

基于额外空间，利用下标同时排序两个数组。

只根据 values 排序，对于 useLimit 这个要求，通过 哈希表 进行维护。

class Solution {
public:

    int largestValsFromLabels(vector<int>& values, vector<int>& labels, int numWanted, int useLimit) {
        vector<int> ids(values.size());
        unordered_map<int,int> mp;
        int ans = 0;
        iota(ids.begin(), ids.end(), 0);    // 从 0 开始递增扩充
		
		// 这是个匿名函数啊害怕
        sort(ids.begin(), ids.end(), [&](int a, int b){
            return values[a] > values[b];
        });

        int cnt = 0;
        for(int i = 0; i < values.size(); i++)
        {
            mp[labels[ids[i]]]++;
            if(mp[labels[ids[i]]] > useLimit)
            {
                continue;
            }
            else
            {
                ans += values[ids[i]];
                cnt ++;
            }
            if(cnt == numWanted) break;
        }
        return ans;
    }
};

解法3 dfs（TLE）

没注意到数据规模，开头直接无脑 dfs 了，喜提超时。

class Solution {
public:
    int ans=0;
    void dfs(vector<int>& values, vector<int>& labels, int idx, int numWanted, int num_cnt, int useLimit, unordered_map<int,int>& mp, int sum)
    {
        int max_cnt = 0;
        for(auto &[k,v]:mp)
        {
            max_cnt = max(max_cnt, v);
        }
        
        // 不满足条件
        if(num_cnt > numWanted || max_cnt > useLimit || idx > values.size())
        {
            return ;
        }
        if(idx == values.size())
        {
            ans = max(ans, sum);
            return;
        }
    
        //选
        mp[labels[idx]]++;
        sum+=values[idx];
        num_cnt++;
        idx++;
        dfs(values, labels, idx, numWanted, num_cnt, useLimit, mp, sum);

        //不选
        mp[labels[idx-1]]--;
        sum-=values[idx-1];
        num_cnt--;
        dfs(values, labels, idx, numWanted, num_cnt, useLimit, mp, sum);
    }
    int largestValsFromLabels(vector<int>& values, vector<int>& labels, int numWanted, int useLimit) {
        unordered_map<int, int> mp;
        dfs(values, labels, 0, numWanted, 0, useLimit, mp, 0);
        return ans;
    }
};

---