2813.子序列最大优雅度-优快云博客

解题思路

暴力超时。

贪心

如何找出最大的优雅度的子序列，根据优雅度计算公式，可以的值profit和category越大，则优雅度越大，因此可以利用贪心，先按照profit进行降序排序，选择的子序列也是满足条件的。
然后选择前k个item，对于剩余的n-k个item，如果能够增加category数量，使得优雅度提升，则可以替换该item。
这里就需要明确有哪几种情况了，每次新增一个item时，只有一种情况（符合不同种类，且现有k个种类中有的种类出现两次以上，选择利润最小的进行替换）。
利用栈来维护选择的k个项目。

C++

代码应用熟练程度不够。

class Solution {
public:
    long long findMaximumElegance(vector<vector<int>>& items, int k) {
        // 二维数组排序，降序排序，所以要自己写cmp
        sort(items.begin(), items.end(), [&](const vector<int>&item1, const vector<int>&item2) -> bool{return item1[0] > item2[0];});
        // 初始化一些必要值
        long long res = 0, profit = 0;
        // 种类数量用集合更好
        unordered_set<int> categorySet;
        // 前k个使用栈维护
        stack<int> st;
        // 入栈进行维护
        for (int i = 0; i < items.size(); i++){
            if (i < k){
                //先维护前k个
                // 利润增加
                profit += items[i][0];
                // 不能直接下面两行，要保证st中维护的是种类数出现两次的最小的利润的那个
                //st.push(items[i][0]);
                //categorySet.insert(items[i][1]);
                if (categorySet.count(items[i][1]) == 0){
                    categorySet.insert(items[i][1]);
                }else{
                    // 说明出现两次
                    st.push(items[i][0]);
                }
            }// 超出k个
            else if(categorySet.count(items[i][1]) == 0 && !st.empty()) {
                // 这个时候满足种类能够增加，替换掉栈顶，利润最小的
                // 更新profit
                profit += items[i][0] - st.top();
                st.pop();
                categorySet.insert(items[i][1]);
            }
            res = max(res, (long long)(profit + categorySet.size() * categorySet.size()));
        }
        return res;
    }
};

python

class Solution:
    def findMaximumElegance(self, items: List[List[int]], k: int) -> int:
        items.sort(key = lambda item: -item[0])
        res, profit = 0, 0
        categorySet = set() # 集合
        # 列表模拟栈
        st = []
        for i, item in enumerate(items):
            if i < k:
                profit += item[0]
                if item[1] in categorySet:
                    st.append(item[0])
                else:
                    categorySet.add(item[1])
            elif item[1] not in categorySet and len(st) >0:
                profit += item[0] - st.pop()
                categorySet.add(item[1])
            res = max(res, profit+len(categorySet) * len(categorySet))
        return res

扩展

子序列

遇到好几个子序列的概念的题，这里记录一下：

数组的子序列，是从数组中删除一些元素（可能不删除元素）得到的序列，且删除不改变元素的相对顺序。

vector二维数组排序

sort()函数，默认对二维数组按照第一列的大小对每行的数组进行排序。可以设置cmp函数来指定按照哪一列排序。

#include<bits/stdc++.h>
using namespace std;
// 如果第一列相同，则按照第二列进行降序排序
bool cmp(vector<int>&a, vector<int>&b){
    // a,b是行
    if (a[0] != b[0]) return a[0] < b[0];
    else return a[1] > b[1];
}

int main(){
    vector<vector<int>> a(6);
    
    int x;
    for (int i = 0; i < 6; i++){
        for (int j = 0; j < 2; j++){
            cin >> x;
            a[i].push_back(x);
        }
    }
    cout<< endl;
    // 下面就是sort了
    sort(a.begin(), a.end(), cmp); 
}