LeetCode1090. 受标签影响的最大值

问题：

我们有一个项的集合，其中第 i 项的值为 values[i]，标签为 labels[i]。

我们从这些项中选出一个子集 S，这样一来：

• |S| <= num_wanted
• 对于任意的标签 L，子集 S 中标签为 L 的项的数目总满足 <= use_limit。

返回子集 S 的最大可能的 和。

示例 1：

输入：values = [5,4,3,2,1], labels = [1,1,2,2,3], num_wanted = 3, use_limit = 1
输出：9
解释：选出的子集是第一项，第三项和第五项。

示例 2：

输入：values = [5,4,3,2,1], labels = [1,3,3,3,2], num_wanted = 3, use_limit = 2
输出：12
解释：选出的子集是第一项，第二项和第三项。

示例 3：

输入：values = [9,8,8,7,6], labels = [0,0,0,1,1], num_wanted = 3, use_limit = 1
输出：16
解释：选出的子集是第一项和第四项。

示例 4：

输入：values = [9,8,8,7,6], labels = [0,0,0,1,1], num_wanted = 3, use_limit = 2
输出：24
解释：选出的子集是第一项，第二项和第四项。

提示：

1. 1 <= values.length == labels.length <= 20000
2. 0 <= values[i], labels[i] <= 20000
3. 1 <= num_wanted, use_limit <= values.length

---

 

链接：https://leetcode-cn.com/contest/weekly-contest-141/problems/largest-values-from-labels/

分析：

给出一个项的集合，选出子集，要求和的最大值，其中选出至多num_wanted个数字，并且同一标签的个数不超过use_limit。

可以将原始输出的数据按照label作为可以，重构为map数据，value按照值排序。

那么可以从每个lable中选出不超过use_limit个数据，构架一个vector，最终结果出自这个vector，将vector排序，选出最大的num_wanted个求和即可。

AC Code：

 class Solution {
 public:
 int largestValsFromLabels(vector<int>& values, vector<int>& labels, int num_wanted, int use_limit) {
         int ret = ;
         map<int, vector<int> > alldata;
         vector<int> opdata;         for (int i = ; i < values.size(); i++)
         {
             alldata[labels[i]].emplace_back(values[i]);
         }
         for (map<int,vector<int> >::iterator it = alldata.begin(); it != alldata.end(); it++)
         {
             sort((*it).second.begin(), (*it).second.end());
             reverse((*it).second.begin(), (*it).second.end());
             int num = ;
             for (int i = ; i < (*it).second.size() && i < use_limit; i++)
             {
                 opdata.emplace_back((*it).second[i]);
             }
         }
         sort(opdata.begin(), opdata.end());
         reverse(opdata.begin(), opdata.end());
         for (int i = ; i < num_wanted && i<opdata.size(); i++)
         {
             ret += opdata[i];
         }
         return ret;
     }
 };

其他：

1，第一code：

    class Solution {
        public int largestValsFromLabels(int[] values, int[] labels, int num_wanted, int use_limit) {
            int n = values.length;
            int[][] ai = new int[n][];
            for(int i = ;i < n;i++){
                ai[i] = new int[]{values[i], labels[i]};
            }
            Arrays.sort(ai, new Comparator<int[]>() {
                public int compare(int[] a, int[] b) {
                    return a[] - b[];
                }
            });
            int[] f = new int[];
            int sum = ;
            int used = ;
            for(int i = n-;i >= ;i--){
                if(used < num_wanted && ++f[ai[i][]] <= use_limit){
                    sum += ai[i][];
                    used++;
                }
            }
            return sum;
        }
    }

第二C++代码：

class Solution {
public:
    int largestValsFromLabels(vector<int>& values, vector<int>& labels, int num_wanted, int use_limit) {
        vector< pair<int, int> > v;
        for(int i =  ; i < values.size() ; i++)
            v.push_back({values[i], labels[i]});
        sort(v.rbegin(), v.rend());
        int lc[] = {};
        int ans = ;
        int cc = ;
        for(int i =  ; i < v.size() ; i++){
            if( cc +  > num_wanted ) continue;
            int vv = v[i].first;
            int ll = v[i].second;
            if( lc[ll] +  > use_limit ){
                continue;
            }
            ans += vv;
            lc[ll]++;
            cc++;
        }

        return ans;

    }
};

2  vector sort默认升序，如果想要降序需要编写自定义比较函数，可以sort后reverse。