AtCoder Beginner Contest 116 D - Various Sushi

掌握了java，Collections.sort()，第一个参.compare(第二个参) 是按从小到大。

另外，如果需要用到单调队列，java的TreeSet不能满足（因为去重），那么需要每次加入数，都进行重排。实际上单调队列也是如此，只不过b树效率更高。

题意

https://atcoder.jp/contests/abc116/tasks/abc116_d
n个结构体，每个结构体包含x、y两个参数，问：从中选取k个，res = (x的种类)^2 + y的和，求res最大值。

解法

本题运用贪心，先按y从大到小排序，保证优先考虑到的y最大。
假设让res作为最终选中的结果集。那么x种类第一次出现的数，是可以永久保留在res中，因此它的y大，而且占用一个type。第二次出现的数就有可能被替换出去。

c++

#include
using namespace std;
struct node
{
    int x,y;
    bool operator<(const node&o)const
    {
        return y>o.y;
    }
}a[100005];
int n,k,cot=0;
bool vis[100005];

stacks;
int main()
{
    long long ans=0,res=0,type=0;
    scanf("%d%d",&n,&k);
    for(int i=1;i<=n;i++)scanf("%d%d",&a[i].x,&a[i].y);
    sort(a+1,a+1+n);
    for(int i=1;i<=n;i++)
    {
        if(cot

java （wa了 找不出原因）

import java.util.*;
public class Main {
    static class Struct{
        Long x,y;
    }
    public static void main(String[] args) {
        Scanner cin = new Scanner(System.in);
        int n = cin.nextInt(),k = cin.nextInt();
        List list = new ArrayList<>();
        for (int i = 0; i < n; i++) {
            Struct struct = new Struct();
            struct.x = cin.nextLong();
            struct.y = cin.nextLong();
            list.add(struct);
        }
        Collections.sort(list, new Comparator() {
            @Override
            public int compare(Struct o1, Struct o2) {
                return o2.y.compareTo(o1.y);
            }
        });
        int  cnt = 0,type = 0;
        long ans = 0, res =  0;
        Stack stack = new Stack<>();
        Map map = new HashMap<>();
        for (int i = 0; i 1次出现
                    stack.push(item.y);
                }
                res += item.y ;
                ans = Math.max(ans, res + type * type);
                cnt++;
            }else{
                // 满了，需要淘汰
                if (stack.empty()) {
                    break;
                }
                if (map.get(item.x) != null) {
                    continue;
                }
                // 新加类型，由于排序了那么前面的肯定更加优先
                map.put(item.x, 1);
                type++;
                res = res - stack.peek() + item.y;
                stack.pop();
                ans = Math.max(ans, res + type * type);
            }
        }
        System.out.println(ans);
    }
}