criyle/codenet-compile-errors huggingface dataset:
Language: C++

#include <iostream>
#include <vector>
#include <map>
#include <algorithm>
typedef long long ll;
using namespace std;


int main(){
  //入力の受け取り
  int N, K;cin>>N>>K;
  //設定
  vector <pair<ll, int> > sushi_list;
  for (int n=0;n<N;n++){
    int t; cin>>t;
    ll d;cin>> d;
    pair<ll, int> p=make_pair(d, t);
    sushi_list.push_back(p);
  }

  //sushi_listを、美味しい順にソート
  sort(sushi_list.begin(), sushi_list.end(), greater<pair<int, int> >() );

  //初期値を設定
  //スコア
  ll score=0;
  //選んだ寿司の種類数
  ll num_unique=0;
  //選ばれた寿司のリストと、その個数
  map<int, int> used;
  //全て0に初期化しておく。
  for (int t=0;t<N;t++){
    used[t]=0;
  }
  //まず、個数を無視して美味しい順にk個を選択。
  for (int k=0;k<K;k++){
    ll d=sushi_list[k].first
    int t=sushi_list[k].second
    //スコアに美味しさをたす。
    score+=d;
    //リストを更新
    used[t]++;
    //種類tがここで出て来たのしかなければ,
    if (used[t]==1){
      //種類すうを一つ増やす。
      num_unique++;
    }
  }
  //種類ボーナス=num_unique
  ll x=num_unique;
  //score=美味しさ+bonus
  score+=x*x;

  //値をより良いものに更新して行く。
  //新しく増やしたものと、交換する寿司の番号
  int position=K-1;
  //追加するネタの美味しさ
  ll add=0;
  //捨てるネタの美味しさ
  ll rem=0;
  //左から順番に、とるか取らぬか
  for (int k=K;k<N;k++){
    pair<ll, int> p=sushi_list[k];
    ll d=p.first;
    int t=p.second;
    //とることを検討するのは、初出かつ種類すうがKになっていない時に限る
    if((used[t]==0)&&(num_unique<K)){
      //今の美味しさをたす。
      add+=d;
      //選んだリストを更新
      used[t]++;
      //選んだ数を増やす。
      num_unique++;
      //捨てる寿司を選ぶ。捨てるべきは、2個以上選んだ種類の中で、最も右にあるもの。
      while(used[sushi_list[position].second]<=1){
        //1個しかないうちは、どんどん左へ。
        position--;
      }
      //てめえはだめだ！
      pair<ll, int> q=sushi_list[position];
      ll d_=q.first;
      int t_=q.second;
      //捨てよう。
      rem+=d_;
      //捨てよう。
      used[t_]--;
      //交換するとしたら、次の特典は次の通りです。
      ll tmp_score=score-x*x+num_unique*num_unique+add-rem;
      //もしも浮気相手の方がよければ、
      if(tmp_score>=score){
        //実際に交換。
        score=tmp_score;
        x=num_unique;
        add=0;
        rem=0;
      }
    }
  }
  cout << score;
  return 0;
}


Compiler output:
a.cc: In function 'int main()':
a.cc:38:5: error: expected ',' or ';' before 'int'
   38 |     int t=sushi_list[k].second
      |     ^~~
a.cc:42:10: error: 't' was not declared in this scope
   42 |     used[t]++;
      |          ^
Language: C++

#include <iostream>
#include <vector>
#include <map>
using namespace std;


int main(){
  //入力の受け取り
  int N, K;cin>>N>>K;
  //設定
  vector <pair<int, int> > sushi_list;
  for (int n=0;n<N;n++){
    int t, d;cin>>t>> d;
    pair<int, int> p=make_pair(d, t);
    sushi_list.push_back(p);
  }

  //sushi_listを、美味しい順にソート
  sort(sushi_list.begin(), sushi_list.end(), greater<pair<int, int> >() );

  //初期値を設定
  //スコア
  int score=0;
  //選んだ寿司の種類数
  int num_unique=0;
  //選ばれた寿司のリストと、その個数
  map<int, int> used;
  //全て0に初期化しておく。
  for (int t=0;t<N;t++){
    used[t]=0;
  }
  //まず、個数を無視して美味しい順にk個を選択。
  for (int k=0;k<K;k++){
    int d=sushi_list[k].first
    int t=sushi_list[k].second
    //スコアに美味しさをたす。
    score+=d;
    //リストを更新
    used[t]++;
    //種類tがここで出て来たのしかなければ,
    if (used[t]==1){
      //種類すうを一つ増やす。
      num_unique++;
    }
  }
  //種類ボーナス=num_unique
  int x=num_unique;
  //score=美味しさ+bonus
  score+=x*x;

  //値をより良いものに更新して行く。
  //新しく増やしたものと、交換する寿司の番号
  int position=K-1;
  //追加するネタの美味しさ
  int add=0;
  //捨てるネタの美味しさ
  int rem=0;
  //左から順番に、とるか取らぬか
  for (int k=K;k<N;k++){
    pair<int, int> p=sushi_list[k];
    int d=p.first;
    int t=p.second;
    //とることを検討するのは、初出かつ種類すうがKになっていない時に限る
    if((used[t]==0)&&(num_unique<K)){
      //今の美味しさをたす。
      add+=d;
      //選んだリストを更新
      used[t]++;
      //選んだ数を増やす。
      num_unique++;
      //捨てる寿司を選ぶ。捨てるべきは、2個以上選んだ種類の中で、最も右にあるもの。
      while(used[sushi_list[position].second]<=1){
        //1個しかないうちは、どんどん左へ。
        position--;
      }
      //てめえはだめだ！
      pair<int, int> q=sushi_list[position];
      int d_=q.first;
      int t_=q.second;
      //捨てよう。
      rem+=d_;
      //捨てよう。
      used[t_]--;
      //交換するとしたら、次の特典は次の通りです。
      int tmp_score=score-x*x+num_unique*num_unique+add-rem;
      //もしも浮気相手の方がよければ、
      if(tmp_score>score){
        //実際に交換。
        score=tmp_score;
        x=num_unique;
        add=0;
        rem=0;
      }
    }
  }
  cout << score;
  return 0;
}


Compiler output:
a.cc: In function 'int main()':
a.cc:19:3: error: 'sort' was not declared in this scope; did you mean 'short'?
   19 |   sort(sushi_list.begin(), sushi_list.end(), greater<pair<int, int> >() );
      |   ^~~~
      |   short
a.cc:35:5: error: expected ',' or ';' before 'int'
   35 |     int t=sushi_list[k].second
      |     ^~~
a.cc:39:10: error: 't' was not declared in this scope
   39 |     used[t]++;
      |          ^
Language: C++

#include <iostream>
#include <vector>
#include <map>
#include <algorithm>
typedef long long ll;
using namespace std;


int main(){
  //入力の受け取り
  int N, K;cin>>N>>K;
  //設定
  vector <pair<ll, int> > sushi_list;
  for (int n=0;n<N;n++){
    int t;cin>> t;
    ll d;cin>> d;
    pair<ll, int> p=make_pair(d, t);
    sushi_list.push_back(p);
  }

  //sushi_listを、美味しい順にソート
  sort(sushi_list.begin(), sushi_list.end(), greater<pair<ll, int> >() );

  //初期値を設定
  //スコア
  ll score=0;
  //選んだ寿司の種類数
  ll num_unique=0;
  //選ばれた寿司のリストと、その個数
  map<int, int> used;
  //全て0に初期化しておく。
  for (int t=0;t<N;t++){
    used[t]=0;
  }

  //まず、個数を無視して美味しい順にk個を選択。
  for (int k=0;k<K;k++){
    ll d=sushi_list[k].first;
    int t=sushi_list[k].second;
    //スコアに美味しさをたす。
    score+=d;
    //リストを更新
    used[t]++;
    //種類tがここで出て来たのしかなければ,
    if (used[t]==1){
      //種類すうを一つ増やす。
      num_unique++;
    }
  }
  //種類ボーナス=num_unique
  ll x=num_unique;
  //score=美味しさ+bonus
  score+=x*x;

  //値をより良いものに更新して行く。
  //新しく増やしたものと、交換する寿司の番号
  int position=K-1;
  //追加するネタの美味しさ
  ll add=0;
  //捨てるネタの美味しさ
  ll rem=0;
  int tmp_score;

  //左から順番に、とるか取らぬか
  for (int k=K;k<N;k++){
    d=sushi_list[k].first;
    t=sushi_list[k].second;
    //とることを検討するのは、初出かつ種類すうがKになっていない時に限る
    if((used[t]==0)&&(num_unique<K)){
      //今の美味しさをたす。
      add+=d;
      //選んだリストを更新
      used[t]++;
      //選んだ数を増やす。
      num_unique++;
      //捨てる寿司を選ぶ。捨てるべきは、2個以上選んだ種類の中で、最も右にあるもの。
      while(used[sushi_list[position].second]<=1){
        //1個しかないうちは、どんどん左へ。
        position--;
      }
      //てめえはだめだ！
      ll d_=sushi_list[position].first;
      int t_=sushi_list[position].second;
      //捨てよう。
      rem+=d_;
      //捨てよう。
      used[t_]--;
      //交換するとしたら、次の特典は次の通りです。
      tmp_score=score-x*x+num_unique*num_unique+add-rem;
      //もしも浮気相手の方がよければ、
      if(tmp_score>score){
        //実際に交換。
        score=tmp_score;
        x=num_unique;
        add=0;
        rem=0;
      }
    }
  }
  cout << score;
  return 0;
}

Compiler output:
a.cc: In function 'int main()':
a.cc:66:5: error: 'd' was not declared in this scope
   66 |     d=sushi_list[k].first;
      |     ^
a.cc:67:5: error: 't' was not declared in this scope
   67 |     t=sushi_list[k].second;
      |     ^
Language: C++

#include <iostream>
#include <vector>
#include <map>
typedef long long ll;
using namespace std;


int main(){
  //入力の受け取り
  ll N, K;cin>>N>>K;
  //設定
  vector <pair<ll, ll> > sushi_list;
  for (int n=0;n<N;n++){
    ll t, d;cin>>t>> d;
    pair<ll, ll> p=make_pair(d, t);
    sushi_list.push_back(p);
  }

  //sushi_listを、美味しい順にソート
  sort(sushi_list.begin(), sushi_list.end(), greater<pair<ll, ll> >() );

  //初期値を設定
  //スコア
  ll score=0;
  //選んだ寿司の種類数
  ll num_unique=0;
  //選ばれた寿司のリストと、その個数
  map<ll, ll> used;
  //全て0に初期化しておく。
  for (ll t=0;t<N;t++){
    used[t]=0;
  }
  //まず、個数を無視して美味しい順にk個を選択。
  for (ll k=0;k<K;k++){
    ll d=sushi_list[k].first
    ll t=sushi_list[k].second
    //スコアに美味しさをたす。
    score+=d;
    //リストを更新
    used[t]++;
    //種類tがここで出て来たのしかなければ,
    if (used[t]==1){
      //種類すうを一つ増やす。
      num_unique++;
    }
  }
  //種類ボーナス=num_unique
  ll x=num_unique;
  //score=美味しさ+bonus
  score+=x*x;

  //値をより良いものに更新して行く。
  //新しく増やしたものと、交換する寿司の番号
  ll position=K-1;
  //追加するネタの美味しさ
  ll add=0;
  //捨てるネタの美味しさ
  ll rem=0;
  //左から順番に、とるか取らぬか
  for (ll k=K;k<N;k++){
    pair<ll, ll> p=sushi_list[k];
    ll d=p.first;
    ll t=p.second;
    //とることを検討するのは、初出かつ種類すうがKになっていない時に限る
    if((used[t]==0)&&(num_unique<K)){
      //今の美味しさをたす。
      add+=d;
      //選んだリストを更新
      used[t]++;
      //選んだ数を増やす。
      num_unique++;
      //捨てる寿司を選ぶ。捨てるべきは、2個以上選んだ種類の中で、最も右にあるもの。
      while(used[sushi_list[position].second]<=1){
        //1個しかないうちは、どんどん左へ。
        position--;
      }
      //てめえはだめだ！
      pair<ll, ll> q=sushi_list[position];
      ll d_=q.first;
      ll t_=q.second;
      //捨てよう。
      rem+=d_;
      //捨てよう。
      used[t_]--;
      //交換するとしたら、次の特典は次の通りです。
      ll tmp_score=score-x*x+num_unique*num_unique+add-rem;
      //もしも浮気相手の方がよければ、
      if(tmp_score>score){
        //実際に交換。
        score=tmp_score;
        x=num_unique;
        add=0;
        rem=0;
      }
    }
  }
  cout << score;
  return 0;
}


Compiler output:
a.cc: In function 'int main()':
a.cc:20:3: error: 'sort' was not declared in this scope; did you mean 'short'?
   20 |   sort(sushi_list.begin(), sushi_list.end(), greater<pair<ll, ll> >() );
      |   ^~~~
      |   short
a.cc:36:5: error: expected ',' or ';' before 'll'
   36 |     ll t=sushi_list[k].second
      |     ^~
a.cc:40:10: error: 't' was not declared in this scope
   40 |     used[t]++;
      |          ^
Language: C++

#include <bits/stdc++.h>
using namespace std;
using ll = long long;

ll N, K, sum, ans;
int t, d
vector<int> F, S;
vector<pair<int, int>> v;
map<int, int> mp;

main() {
    cin >> N >> K;
    for (int i = 0; i < N; i++) {
        cin >> t >> d;
        v.push_back(make_pair(t, d));
    }
    sort(v.rbegin(), v.rend());
    for (int i = 0; i < v.size(); i++) {
        pair<int, int> p = v[i];
        if (mp[p.first] == 0) F.push_back(p.second);
        else S.push_back(p.second);
        mp[p.first]++;
    }
    sort(F.rbegin(), F.rend());
    sort(S.rbegin(), S.rend());
    ll L = F.size(), M = S.size();
    for (ll i = 0; i < min(K, L); i++) sum += F[i];
    if (K > L) {
        ll check = 0;
        for (ll i = 0; i < K - L; i++) sum += S[i], check = i;
        check++, ans = sum + L * L;
        for (ll j = L - 1; j > 0 && check < M; j--) {
            sum = sum - F[j] + S[check];
            check++;
            ans = max(ans, sum + j * j);
        }
        cout << ans << endl;
    }
    else {
        ans = sum + K * K;
        for (ll i = 0; i < K - 1 && i < M; i++) {
            sum -= F[K - 1 - i];
            sum += S[i];
            ans = max(ans, sum + (K - i - 1) * (K - i - 1));
        }
        cout << ans << endl;
    }
}

Compiler output:
a.cc:7:1: error: expected initializer before 'vector'
    7 | vector<int> F, S;
      | ^~~~~~
a.cc:11:1: warning: ISO C++ forbids declaration of 'main' with no type [-Wreturn-type]
   11 | main() {
      | ^~~~
a.cc: In function 'int main()':
a.cc:14:21: error: 'd' was not declared in this scope
   14 |         cin >> t >> d;
      |                     ^
a.cc:20:31: error: 'F' was not declared in this scope
   20 |         if (mp[p.first] == 0) F.push_back(p.second);
      |                               ^
a.cc:21:14: error: 'S' was not declared in this scope
   21 |         else S.push_back(p.second);
      |              ^
a.cc:24:10: error: 'F' was not declared in this scope
   24 |     sort(F.rbegin(), F.rend());
      |          ^
a.cc:25:10: error: 'S' was not declared in this scope
   25 |     sort(S.rbegin(), S.rend());
      |          ^
a.cc:32:45: error: 'M' was not declared in this scope
   32 |         for (ll j = L - 1; j > 0 && check < M; j--) {
      |                                             ^
a.cc:41:41: error: 'M' was not declared in this scope
   41 |         for (ll i = 0; i < K - 1 && i < M; i++) {
      |                                         ^
Language: C++

#include<bits/stdc++.h>
using namespace std;
typedef long long int ll;
#define rep(i, n) for(ll i = 0; i < ll(n); i++)
ll a,b,c,d,e,f,g,ans=0;
const ll INF=99999999999999999;
int main(){
    ll n,k;
    pair<ll,ll> neta[200000];
    stack<ll> q;
    ll used[200000]={};
    ll u[200000]={};
    ll v=0;
    
    cin>>n>>k;

    rep(i,n){
        cin>>neta[i].second>>neta[i].first;
    }

    sort(neta,neta+n);
    reverse(neta,neta+n);

    for(a=0;a<n&&v<k;a++){
        if(used[neta[a].second]==0){
            v++;
            used[neta[a].second]++;
            q.push(neta[a].first);
            ans+=neta[a].first;
            u[a]=1;
        }
    }

  ans+=v*v;
    b=v;
    c=0;
    while(b<k){
        if(used[neta[c].second]>0){
            ans+=neta[c].first;
            b++;
            u[c]=1;
        }
        c++;
    }

    for(int i=0;i<n&&!q.empty();i++){
        if(u[i]==0){
            d=q.top();
          q.pop()
            e=neta[i].first;
            if(e-d-(2*v-1)>0){
                ans+=e-d-(2*v-1);
                v--;
            }
            else{
                break;
            }
        }
    }
        
        cout<<ans<<endl;
}





    

Compiler output:
a.cc: In function 'int main()':
a.cc:49:18: error: expected ';' before 'e'
   49 |           q.pop()
      |                  ^
      |                  ;
   50 |             e=neta[i].first;
      |             ~
Language: C++

#include<bits/stdc++.h>
using namespace std;
typedef long long int ll;
#define rep(i, n) for(ll i = 0; i < ll(n); i++)
ll a,b,c,d,e,f,g,ans=0;
const ll INF=99999999999999999;
int main(){
    ll n,k;
    pair<ll,ll> neta[200000];
    stack<ll> q;
    ll used[200000]={};
    ll v=0;
    
    cin>>n>>k;
 
    rep(i,n){
        cin>>neta[i].second>>neta[i].first;
    }
 
    sort(neta,neta+n);
    reverse(neta,neta+n);
 
    rep(i,k){
        if(used[neta[i].second]==0){
            v++;
        }
        else{
            q.push(i);
        }
        ans+=neta[i].first;
        used[neta[i].second]++;
    }
  ans+=v*v;
 
    for(int i=k;i<n;i++){
      while(!q.empty(){
        if(used[neta[i].second]==0){
            a=neta[q.top()].first;
            b=neta[i].first;
            if(b*b-a*a+2*v+1>0){
                q.pop();
                ans+=b*b-a*a+2*v+1;
                v++;
                used[neta[i].second]++;
              cout<<"yes"<<endl;
            }
            else break;
        }
      }
    }
 
    cout<<ans<<endl;
}

Compiler output:
a.cc: In function 'int main()':
a.cc:36:23: error: expected ')' before '{' token
   36 |       while(!q.empty(){
      |            ~          ^
      |                       )
Language: C++

#include <iostream>
#include <vector>
#include <set>
#include <map>
using namespace std;

using P = pair<int, long>;

int main() {
  int N, K;
  cin >> N >> K;
  vector<P> td(N);
  for (int i{}; i < N; ++i) {
    int t, d;
    cin >> t >> d;
    td[i] = P{t, d};
  }
  sort(td.begin(), td.end(), [](P l, P r) {
    return l.second > r.second;
  });

  map<int, vector<long >> choice;
  long point{};
  int type{};
  for (int i{}; i < K; ++i) {
    choice[td[i].first].push_back(td[i].second);
    point += td[i].second;
  }
  type = choice.size();
  point += type * type;

  for (auto &p : choice) {
    auto &v = p.second;
    if (v.size() > 1)
      sort(v.begin(), v.end(), greater<long>());
  }

  int alt{K};
  long ans{point};
  for (int i{K - 1}; i >= 0; --i) {
    int t = td[i].first;
    int d = td[i].second;
    if (choice[t].size() == 1)
      continue;
    while (alt < N) {
      int nt = td[alt].first;
      int nd = td[alt].second;
      ++alt;
      if (choice.find(nt) == choice.end()) {
        point += (nd - d) + ((type + 1) * (type + 1) - type * type);
        if (ans < point) {
          ans = point;
        }
        assert(choice[t].back() == d);
        choice[t].pop_back();
        choice[nt].push_back(nd);
        ++type;
        break;
      }
    }
  }

  cout << ans << endl;
  return 0;
}


Compiler output:
a.cc: In function 'int main()':
a.cc:18:3: error: 'sort' was not declared in this scope; did you mean 'short'?
   18 |   sort(td.begin(), td.end(), [](P l, P r) {
      |   ^~~~
      |   short
a.cc:54:9: error: 'assert' was not declared in this scope
   54 |         assert(choice[t].back() == d);
      |         ^~~~~~
a.cc:5:1: note: 'assert' is defined in header '<cassert>'; this is probably fixable by adding '#include <cassert>'
    4 | #include <map>
  +++ |+#include <cassert>
    5 | using namespace std;
Language: C++

#include <iostream>
#include <string>
#include <cstring>
#include <vector>
#include <algorithm>
#include <set>
#include <stack>
#include <deque>
#include <cmath>
#include <map>
using namespace std;
typedef long long ll;

int main() {
    ll n, k;
    cin >> n >> k;
    vector<ll> maxd(n, -1LL<<60), vals;
    multiset<ll> se;
    for (ll i = 0; i < N; i++) {
        ll s, v;
        cin >> s >> v;
        s--;
        maxd[s] = max(maxd[s], v);
        vals.push_back(v);
    }
    sort(vals.begin(), vals.end(), greater<ll>());
    sort(maxd.begin(), maxd.end(), greater<ll>());
    ll sum = 0;
    for (ll i = 0; i < k; i++) sum += vals[i], se.insert(vals[i]);

    ll ans = 0, tmp = sum;
    for (ll x = 1; x <= k; x++) {
        ll add = maxd[x-1];
        ll back = *se.begin();
        tmp += add;
        if (back > add) {
            se.erase(se.begin());    
            tmp -= back;
        } else {
            se.erase(se.find(add));
            tmp -= add;
        }
        ans = max(ans, tmp + x * x);
    }
    cout << ans << endl;
}

Compiler output:
a.cc: In function 'int main()':
a.cc:19:24: error: 'N' was not declared in this scope
   19 |     for (ll i = 0; i < N; i++) {
      |                        ^
Language: C++

#include <iostream>
#include <vector>
#include <tuple>
#include <queue>
using namespace std;
typedef long long ll;

int N, K;
int t[100010];
ll  d[100010];
 
typedef tuple<ll, int> sushi;
vector<sushi> V;
priority_queue<sushi, vector<sushi>, greater<sushi>> Q;
int cnt[100010];

int main() {
    cin >> N >> K;
    for (auto i = 0; i < N; i++)
    {
        cin >> t[i] >> d[i];
        t[i]--;
        V.push_back(sushi(d[i], t[i]));
    }
    sort(V.begin(), V.end());
    reverse(V.begin(), V.end());
    fill(cnt, cnt + N, 0);
  
    ll ans = 0;
    ll tans = 0;
    for (auto i = 0; i < K; i++)
    {
        ll cost = get<0>(V[i]);
        int val = get<1>(V[i]);
        tans += cost;
        cnt[val]++;
        Q.push(V[i]);
    }
    ll v = 0;
    for (auto i = 0; i < N; i++)
    {
        if (cnt[i] > 0)
        {
             v++;
        }
    }
    ans = tans + v * v;
    for (auto i = K; i < N; i++)
    {
        ll cost = get<0>(V[i]);
        int val = get<1>(V[i]);
        if (cnt[val] == 0)
        {
            while (!Q.empty())
            {
                ll cost_q = get<0>(Q.top());
                int val_q = get<1>(Q.top());
                Q.pop();
                if (cnt[val_q] >= 2)
                {
                    cnt[val_q]--;
                    tans -= cost_q;
                    cnt[val]++;
                    tans += cost;
                    v++;
                    ans = max(ans, tans + v * v);
                    break;
                }
            }
        }
    }
    cout << ans << endl;
}

Compiler output:
a.cc: In function 'int main()':
a.cc:25:5: error: 'sort' was not declared in this scope; did you mean 'short'?
   25 |     sort(V.begin(), V.end());
      |     ^~~~
      |     short
a.cc:26:5: error: 'reverse' was not declared in this scope
   26 |     reverse(V.begin(), V.end());
      |     ^~~~~~~
Language: C++

#include<bits/stdc++.h>
using namespace std;
typedef signed long long int ll;
int n,k;
priority_queue<ll> v[n];
ll d[100005];
int main(){
    cin>>n>>k;
    for(int i=0;i<n;i++){
        int t;
        ll d;
        cin>>t>>d;
        v[t-1].push(d);
    }
    priority_queue<ll> best,remain;
    for(int i=0;i<n;i++){
        if(!v[i].empty()){
            best.push(v[i].top());
            v[i].pop();
            while(!v[i].empty()){
                remain.push(v[i].top());
                v[i].pop();
            }
        }
    }
    vector<ll> bestsum={0};
    while(!best.empty()){
        bestsum.push_back(best.top()+bestsum.back());
        best.pop();
    }
    
    vector<ll> remainsum={0};
    while(!remain.empty()){
        remainsum.push_back(remain.top()+remainsum.back());
        remain.pop();
    }
    ll ans=0;
    for(int i=1;i<=k;i++){
        if (i >= bestsum.size()) break;
        
        // 種類が少なすぎて、余り物が足りないケース
        if (k - i >= remainsum.size()) continue;
        
        // bestからx個、remainからK-x個貪欲に選ぶ
        ans = max(ans, bestsum[i] + remainsum[k - i] + i * i);
    }
    
    cout << ans << endl;
    
    return 0;
}


Compiler output:
a.cc:5:22: error: size of array 'v' is not an integral constant-expression
    5 | priority_queue<ll> v[n];
      |                      ^
Language: C++

#include<bits/stdc++.h>
using namespace std;
typedef signed long long int ll;
int n,k;
priority_queue<ll> v[100005];
ll d[100005];
int main(){
    cin>>n>>k;
    for(int i=0;i<n;i++){
        int t;
        ll d;
        cin>>t>>d;
        v[t-1].push(d);
    }
    priority_queue<ll> best,remain;
    for(int i=0;i<n;i++){
        if(!v[i].empty()){
            best.push(v[i].top());
            v[i].pop();
            while(!v[i].empty()){
                remain.push(v[i].top());
                v[i].pop();
            }
        }
    }
    vector<ll> bestsum={0};
    while(!best.empty()){
        bestsum.push_back(best.top());
        best.pop();
    }
    
    vector<ll> remainsum={0};
    while(!remain.empty()){
        remainsum.push_back(remain.top());
        remain.pop();
    }
    ll ans=0;
    for(int i=1;i<=k;i++){
        if (i >= bestsum.size()) break;
        
        // 種類が少なすぎて、余り物が足りないケース
        if (k - i >= remainsum.size()) continue;
        
        // bestからx個、remainからK-x個貪欲に選ぶ
        ans = max(ans, bestsum[i] + remainsum[k - i] + i * i);
    }
    
    cout << ans << endl;
    }
    return 0;
}


Compiler output:
a.cc:50:5: error: expected unqualified-id before 'return'
   50 |     return 0;
      |     ^~~~~~
a.cc:51:1: error: expected declaration before '}' token
   51 | }
      | ^
Language: C++

#include <bits/stdc++.h>
using namespace std;
using ll = long long int;
using P = pair<ll,ll>;
int INF = 1e9+7;

int main() {
    int n,k; cin>>n>>k;
    priority_queue<P> q;
    priority_queue<P,vector<P>,greater<P>> q2;
    vector<int> f(n+10);

    for (int i=0;i<n;i++) {
        int t,d; cin>>t>>d;
        q.push(P(d,t));
    }

    ll sum=0,x=0;
    for (int i=0;i<k;i++) {
        P p = q.top(); q.pop();
        q2.push(p);
        sum += p.first;
        if(f[p.second]==0) x++;
        f[p.second]++;
    }
    sum += x*x;

    ll = s=0;
    while(!q.empty()) {
        P p = q.top(); q.pop();
        if (f[p.second]) continue;
        int m=-1;
        while(!q2.empty()) {
            P p2 = q2.top(); q2.pop();
            if (f[p2.second] > 1) {
                f[p2.second]--;
                m = p2.second;
                break;
            }
        }
        if (m==-1) break;
        x++;
        f[p.second]++;
        s += p.first-m;
        sum = max(sum,s+x*x)
    }
    cout << sum << endl;
}


Compiler output:
a.cc: In function 'int main()':
a.cc:28:8: error: expected unqualified-id before '=' token
   28 |     ll = s=0;
      |        ^
a.cc:44:9: error: 's' was not declared in this scope
   44 |         s += p.first-m;
      |         ^
Language: C++

#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef pair<int, int> pii;
typedef pair<ll, ll> pll;
#define rep(i, n) for(ll i = 0;i < n;i++)
template<class T, class U> void cmax(T& a, U b) { if (a<b) a = b; }
template<class T, class U> void cmin(T& a, U b) { if (a>b) a = b; }

int main() {
  cin.tie(0); ios::sync_with_stdio(false);

  int N, K;
  cin >> N >> K;

  vector<pll> sushi(N);
  rep(i, N) {
    cin >> sushi[i].first >> sushi[i].second;
  }

  sort(sushi.begin(), sushi.end(), [](pll l, pll r){return l.second > r.second;});

  vector<ll> max_sushi, else_sushi;
  vector<bool> used(N);
  int max_cnt = 0, else_cnt = 0;
  rep(i, N) {
    if (used[sushi[i].first]) {
      else_sushi.push_back(sushi[i].second);
      ++else_cnt;
    } else {
      used[sushi[i].first] = 1;
      max_sushi.push_back(sushi[i].second);
      ++max_cnt;
    }
  }

  sort(max_sushi.rbegin(), max_sushi.rend());
  sort(else_sushi.rbegin(), else_sushi.rend());

//  for (auto&& i : max_sushi) {
//    cerr << i.first << " " << i.second << endl;
//  }
//  cerr << endl;
//  for (auto&& i : else_sushi) {
//    cerr << i.first << " " << i.second<< endl;
//  }

  // 累積和 1-indexed
  vector<ll> max_sum(max_cnt+1), else_sum(else_cnt+1);
  rep(i, max_cnt) max_sum[i+1] = max_sum[i] + max_sushi[i];
  rep(i, else_cnt) else_sum[i+1] = else_sum[i] + else_sushi[i];

//  for (auto&& i : max_sum) {
//    cerr << i << endl;
//  }
//  cerr << endl;
//  for (auto&& i : else_sum) {
//    cerr << i << endl;
//  }

  ll ans = 0;
  // i種類で
  rep(i, K+1) {
    if (i == max_cnt) break;
    if (K-i == else_cnt) continue;
    cmax(ans, max_sum[i]+else_sum[K-i]+i*i;
  }
  cout << ans << endl;
}


Compiler output:
a.cc: In function 'int main()':
a.cc:66:43: error: expected ')' before ';' token
   66 |     cmax(ans, max_sum[i]+else_sum[K-i]+i*i;
      |         ~                                 ^
      |                                           )
Language: C++

#include <iostream>
#include <string>
#include <sstream>
#include <vector>
#include <tuple>
#include <algorithm>
using namespace std;
#define REP(n) for(int i=0;i<n;i++)

int flowers[101] = { 0 };

bool pairCompare(const pair<int, long long> &firstElof, const pair<int, long long> &secondElof) {
	return firstElof.second > secondElof.second;
}

int type_cnt[100001] = { 0 };
int main() {
	long long N,K;
	vector < pair<int,long long> > all_sushi;
	vector < pair<int, long long> > y0_sushi;
	vector < pair<int, long long> > y1_sushi;

	cin >> N >> K;
	int type_cnt_ofs = 0;
	long long ans = 0;
	REP(N) {
		int t, d;
		cin >> t >> d;
		all_sushi.push_back(make_pair(t, d));
	}
	

	sort(all_sushi.begin(), all_sushi.end(), pairCompare);
	REP(N) {
		if (type_cnt[all_sushi.at(i).first]==0) {
			y1_sushi.push_back(all_sushi.at(i));
		}
		else {
			y0_sushi.push_back(all_sushi.at(i));
		}
		type_cnt[all_sushi.at(i).first] += 1;
	}
	REP(N + 1) {
		if (i > 0) {
			type_cnt[i] += type_cnt[i - 1];
			if (type_cnt[i] == 0) {
				type_cnt_ofs = i;
			}
		}
	}
	

	for(int i=1;i<=K;i++) {
		long long tmp = 0;
		int capable_type[100001] = { 0 };
		int skip = 0;
		//if (type_cnt[i+ type_cnt_ofs]>=K) 
		{
			if (K - i > y0_sushi.size() || i > y1_sushi.size()) {
				continue;
			}
			for (int j = 0; j < i; j++) {
				tmp += y1_sushi.at(j).second;
				capable_type[y1_sushi.at(j).first] += 1;
			}
			for (int j = 0; j < K-i; j++) {
				if (capable_type[y0_sushi.at(j).first] == 0) {
					tmp = -INFINITY;
					break;
				}
				tmp += y0_sushi.at(j).second;
			}
			tmp += i*i;
		}
		//else {
		//	continue;
		//}

		if (ans < tmp) {
			ans = tmp;
		}
	}
	cout << ans;
	return 0;
}

Compiler output:
a.cc: In function 'int main()':
a.cc:68:48: error: 'INFINITY' was not declared in this scope
   68 |                                         tmp = -INFINITY;
      |                                                ^~~~~~~~
Language: C++

#include<iostream>
#include<queue>
#include<vector>
#include<map>
#include<algorithm>
#include<cmath>
using namespace std;
typedef long long ll;
typedef pair<ll, int> P;


int main(){
  int N,K;
  cin >>N>>K;
  vector<pair<ll, int>> list;

  for (int i=0;i<N;i++){
    ll d;
    int t;
    cin >> t>> d;
    P p=make_pair(d,t);
    list.push_back(p);
  }
  sort(list.begin(), list.end(), greater<P>());

  //countは，答えに，何が何個使われているかをcountしている。
  int used[N];
  int nxt[N];
  for (int i=0;i<N;i++){
    nxt[i]=0;
  }
  ll ans=0;

  for (int p=1;p<=K;p++){
    ll p_largest=0;
    used=nxt;
    for (int i=0;i<N;i++){
      int count=0;
      if (count==p){
        break;
      }
      if(used[list[i].second]==0){
        used[list[i].second]++;
        count++;
        p_largest+=list[i].first;
      }
    }
   
    ans=max(ans, p_largest+p*p);
  }

  cout << ans;
  return 0;
}

Compiler output:
a.cc: In function 'int main()':
a.cc:36:9: error: invalid array assignment
   36 |     used=nxt;
      |     ~~~~^~~~
Language: C++

#include<iostream>
#include<queue>
#include<vector>
#include<map>
#include<algorithm>
#include<cmath>
using namespace std;
typedef long long ll;
typedef pair<ll, int> P;


int main(){
  int N,K;
  cin >>N>>K;
  vector<pair<ll, int>> list;

  for (int i=0;i<N;i++){
    ll d;
    int t;
    cin >> t>> d;
    P p=make_pair(d,t);
    list.push_back(p);
  }
  sort(list.begin(), list.end(), greater<P>());

  //countは，答えに，何が何個使われているかをcountしている。
  int used[N];
  ll ans=0;

  for (int p=1;p<=K;p++){
    ll p_largest=0;
    fill(used, 0);
    for (int i=0;i<N;i++){
      int count=0;
      if (count==p){
        break;
      }
      if(used[list[i].second]==0){
        used[list[i].second]++;
        count++;
        p_largest+=list[i].first;
      }
    }
   
    ans=max(ans, p_largest+p*p);
  }

  cout << ans;
  return 0;
}

Compiler output:
a.cc: In function 'int main()':
a.cc:32:9: error: no matching function for call to 'fill(int [N], int)'
   32 |     fill(used, 0);
      |     ~~~~^~~~~~~~~
In file included from /usr/include/c++/14/string:51,
                 from /usr/include/c++/14/bits/locale_classes.h:40,
                 from /usr/include/c++/14/bits/ios_base.h:41,
                 from /usr/include/c++/14/ios:44,
                 from /usr/include/c++/14/ostream:40,
                 from /usr/include/c++/14/iostream:41,
                 from a.cc:1:
/usr/include/c++/14/bits/stl_algobase.h:1022:5: note: candidate: 'template<class _ForwardIterator, class _Tp> void std::fill(_ForwardIterator, _ForwardIterator, const _Tp&)'
 1022 |     fill(_ForwardIterator __first, _ForwardIterator __last, const _Tp& __value)
      |     ^~~~
/usr/include/c++/14/bits/stl_algobase.h:1022:5: note:   candidate expects 3 arguments, 2 provided
In file included from /usr/include/c++/14/algorithm:86,
                 from a.cc:5:
/usr/include/c++/14/pstl/glue_algorithm_defs.h:191:1: note: candidate: 'template<class _ExecutionPolicy, class _ForwardIterator, class _Tp> __pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, void> std::fill(_ExecutionPolicy&&, _ForwardIterator, _ForwardIterator, const _Tp&)'
  191 | fill(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last, const _Tp& __value);
      | ^~~~
/usr/include/c++/14/pstl/glue_algorithm_defs.h:191:1: note:   candidate expects 4 arguments, 2 provided
Language: C++

#include<iostream>
#include<queue>
#include<vector>
#include<map>
#include<algorithm>
#include<cmath>
using namespace std;
typedef long long ll;
typedef pair<ll, int> P;


int main(){
  int N,K;
  cin >>N>>K;
  vector<pair<ll, int>> list;

  for (int i=0;i<N;i++){
    ll d;
    int t;
    cin >> t>> d;
    P p=make_pair(d,t);
    list.push_back(p);
  }
  sort(list.begin(), list.end(), greater<P>());

  //countは，答えに，何が何個使われているかをcountしている。
  int used[N];
  ll ans=0;

  for (int p=1;p<=K;p++){
    ll p_largest=0;
    fill(used; 0);
    for (int i=0;i<N;i++){
      int count=0;
      if (count==p){
        break;
      }
      if(used[list[i].second]==0){
        used[list[i].second]++;
        count++;
        p_largest+=list[i].first;
      }
    }
   
    ans=max(ans, p_largest+p*p);
  }

  cout << ans;
  return 0;
}


Compiler output:
a.cc: In function 'int main()':
a.cc:32:14: error: expected ')' before ';' token
   32 |     fill(used; 0);
      |         ~    ^
      |              )
a.cc:32:17: error: expected ';' before ')' token
   32 |     fill(used; 0);
      |                 ^
      |                 ;
Language: C++

// ConsoleApplication1.cpp : このファイルには 'main' 関数が含まれています。プログラム実行の開始と終了がそこで行われます。
//


#include <iostream>
#include<algorithm>
#include<cstdio>
#include<cmath>
#include<cctype>
#include<math.h>
#include<string>
#include<string.h>
#include<stack>
#include<queue>
#include<vector>
#include<utility>
#include<set>
#include<map>
#include<stdlib.h>
#include<iomanip>
using namespace std;
#define rep(i, n) for(long i = 0; i < n; i++)
#define erep(i, n) for(long i = 1; i <= n; i++)
#define show(ans) cout << ans << endl
const long MOD = 1000000007;

int main() {
	long N; long K;
	cin >> N >> K;
	vector<pair<long, long>> v;
	//vector<pair<long, long>> v2;
	vector<long> vfst;
	vector<long> vscd;
	rep(i, N) {
		long a2, b2;
		cin >> a2 >> b2;
		v.push_back(make_pair(a2, b2));
	}
	sort(v.begin(), v.end());
	reverse(v.begin(), v.end());
	//v2.push_back(make_pair(1, v[0].second));
	vfst.push_back(v[0].second);
	rep(i, v.size()-1) {
		if (v[i].first == v[i + 1].first) {
			//v2.push_back(make_pair(0, v[i + 1].second));
			vscd.push_back(v[i + 1].second);
		}
		else {
			//v2.push_back(make_pair(1, v[i + 1].second));
			vfst.push_back(v[i + 1].second);
		}
	}
	sort(vfst.begin(), vfst.end());
	reverse(vfst.begin(), vfst.end());
	sort(vscd.begin(), vscd.end());
	reverse(vscd.begin(), vscd.end());
	long ans = 0;
	erep(i, min(K, vfst.size()) {//i is the number of type
		long tmp = 0;
		rep(j, i) {
			tmp += vfst[j];
		}
		rep(j, K - i) {
			tmp += vscd[j];
		}
		tmp += i * i;
		ans = max(ans, tmp);
	}
	show(ans);

	return 0;

}
// プログラムの実行: Ctrl + F5 または [デバッグ] > [デバッグなしで開始] メニュー
// プログラムのデバッグ: F5 または [デバッグ] > [デバッグの開始] メニュー

// 作業を開始するためのヒント: 
//    1. ソリューション エクスプローラー ウィンドウを使用してファイルを追加/管理します 
//   2. チーム エクスプローラー ウィンドウを使用してソース管理に接続します
//   3. 出力ウィンドウを使用して、ビルド出力とその他のメッセージを表示します
//   4. エラー一覧ウィンドウを使用してエラーを表示します
//   5. [プロジェクト] > [新しい項目の追加] と移動して新しいコード ファイルを作成するか、[プロジェクト] > [既存の項目の追加] と移動して既存のコード ファイルをプロジェクトに追加します
//   6. 後ほどこのプロジェクトを再び開く場合、[ファイル] > [開く] > [プロジェクト] と移動して .sln ファイルを選択します


Compiler output:
a.cc:83:120: error: unterminated argument list invoking macro "erep"
   83 | //   6. 後ほどこのプロジェクトを再び開く場合、[ファイル] > [開く] > [プロジェクト] と移動して .sln ファイルを選択します
      |                                                                                                                        ^
a.cc: In function 'int main()':
a.cc:58:9: error: 'erep' was not declared in this scope
   58 |         erep(i, min(K, vfst.size()) {//i is the number of type
      |         ^~~~
a.cc:58:13: error: expected '}' at end of input
   58 |         erep(i, min(K, vfst.size()) {//i is the number of type
      |             ^
a.cc:27:12: note: to match this '{'
   27 | int main() {
      |            ^
Language: C++

#include<iostream>
#include<queue>
#include<vector>
#include<map>
#include<algorithm>
#include<cmath>
using namespace std;
typedef long long ll;
typedef pair<ll, int> P;


int main(){
  int N,K;
  cin >>N>>K;
  vector<pair<ll, ll>> list;
  
  for (int i=0;i<N;i++){
    int t, d;
    cin >> t>> d;
    P p=make_pair(t,d);
    list.push_back(p);
  }

  //queue は，今使っている寿司番号を格納している。
  priority_queue<pair<ll, int>> que;
  //countは，答えに，何が何個使われているかをcountしている。
  map<ll, int> count;
  //初期化しておく
  for (int i=0;i<N;i++){
    count[list[i].first]=0;
  }
  
  ll bonus=0;
  ll delicious=0;

  //はじめの状態
  for (int i=0;i<K;i++){
    delicious+=list[i].second;
    P r=make_pair(list[i].second, i);
    que.push(r);
    count[list[i].first]++;
    if (count[list[i].first]==1){
      bonus++;
    }
  }

  ll ans=pow(bonus, 2)+delicious;

  for (int i=K;i<N;i++){
    if (count[list[i+1].first]==0){
      P r=que.top();
      int k=r.second;
      ll ans_2=pow(bonus+1, 2)+delicious-list[k].second+list[i].second;
      if (ans_2>ans){
        count[list[i].first]++;
        r=make_pair(list[i].second, i);
        que.pop();que.push(r);
        bonus++;
        delicious+=list[i].second-list[k].second;
        count[list[k].first]--;
        ans=pow(bonus, 2)+delicious;
      }
    }
    cout << ans;
    return 0;
  }
  

Compiler output:
a.cc: In function 'int main()':
a.cc:66:4: error: expected '}' at end of input
   66 |   }
      |    ^
a.cc:12:11: note: to match this '{'
   12 | int main(){
      |           ^
Language: C++

#include<iostream>
#include<queue>
#include<vector>
#include<map>
#include<algorithm>
#include<cmath>
using namespace std;
typedef long long ll;
typedef pair<ll, int> P;


int main(){
  int N,K;
  cin >>N>>K;
  vector<pair<ll, ll>> list;
  
  for (int i=0;i<N;i++){
    int t, d;
    cin >> t>> d;
    P p=make_pair(t,d);
    list.push_back(p);
  }

  //queue は，今使っている寿司番号を格納している。
  priority_queue<pair<ll, int>> que;
  //countは，答えに，何が何個使われているかをcountしている。
  map<ll, int> count;
  //初期化しておく
  for (int i=0;i<N;i++){
    count[list[i].first]=0;
  }
  
  ll bonus=0;
  ll delicious=0;

  //はじめの状態
  for (int i=0;i<K;i++){
    delicious+=list[i].second;
    P r=make_pair(list[i].second, i);
    que.push(r);
    count[list[i].first]++;
    if (count[list[i].first]==1){
      bonus++;
    }
  }

  ll ans=pow(bonus, 2)+delicious;

  for (int i=K;i<N;i++){
    if (count[list[i+1].first]==0){
      P r=que.top();
      int k=r.second
      int ans_2=pow(bonus+1, 2)+delicious-list[k].second+list[i].second;
      if (ans_2>ans){
        count[list[i].first]++;
        r=make_pair(list[i].second, i);
        que.pop();que.push(r);
        bonus++;
        delicious+=list[i].second-list[k].second;
        count[list[k].first]--;
        ans=pow(bonus, 2)+delicious;
      }
    }
    cout << ans;
    return 0;
  }

Compiler output:
a.cc: In function 'int main()':
a.cc:53:7: error: expected ',' or ';' before 'int'
   53 |       int ans_2=pow(bonus+1, 2)+delicious-list[k].second+list[i].second;
      |       ^~~
a.cc:54:11: error: 'ans_2' was not declared in this scope; did you mean 'ans'?
   54 |       if (ans_2>ans){
      |           ^~~~~
      |           ans
a.cc:66:4: error: expected '}' at end of input
   66 |   }
      |    ^
a.cc:12:11: note: to match this '{'
   12 | int main(){
      |           ^
Language: C++

#include<iostream>
#include<queue>
#include<vector>
#include<map>
#include<algorithm>
#include<cmath>
using namespace std;
typedef long long ll;
typedef pair<ll, int> P;


int main(){
  int N,K;
  cin >>N>>K;
  vector<pair<ll, ll>> list;
  
  for (int i=0;i<N;i++){
    int t, d;
    cin >> t>> d;
    P p=make_pair(t,d);
    list.push_back(p);
  }

  //queue は，今使っている寿司番号を格納している。
  priority_queue<pair<ll, int>> que;
  //countは，答えに，何が何個使われているかをcountしている。
  map<ll, int> count;
  //初期化しておく
  for (int i=0;i<N;i++){
    count[list[i].first]=0;
  }
  
  ll bonus=0;
  ll delicious=0;

  //はじめの状態
  for (int i=0;i<K;i++){
    delicious+=list[i].second;
    P r=make_pair(list[i].second, i);
    que.push(r);
    count[list[i].first++;
    if (count[list[i].first==1){
      bonus++;
    }
  }

  ll ans=pow(bonus, 2)+delicious;

  for (int i=K;i<N;i++){
    if (count[list[i+1].first==0){
      P r=que.top();
      int k=r.second
      int ans_2=pow(bonus+1, 2)+delicious-list[k].second+list[i].second;
      if (ans_2>ans){
        count[list[i].first++;
        r=make_pair(list[i].second, i);
        que.pop();que.push(r);
        bonus++;
        delicious+=list[i].second-list[k].second;
        count[list[k].first--;
        ans=pow(bonus, 2)+delicious;
      }
    }
    cout << ans;
    return 0;
  }


Compiler output:
a.cc: In function 'int main()':
a.cc:41:26: error: expected ']' before ';' token
   41 |     count[list[i].first++;
      |                          ^
      |                          ]
a.cc:42:31: error: expected ']' before ')' token
   42 |     if (count[list[i].first==1){
      |                               ^
      |                               ]
a.cc:50:33: error: expected ']' before ')' token
   50 |     if (count[list[i+1].first==0){
      |                                 ^
      |                                 ]
a.cc:53:7: error: expected ',' or ';' before 'int'
   53 |       int ans_2=pow(bonus+1, 2)+delicious-list[k].second+list[i].second;
      |       ^~~
a.cc:54:11: error: 'ans_2' was not declared in this scope; did you mean 'ans'?
   54 |       if (ans_2>ans){
      |           ^~~~~
      |           ans
a.cc:55:30: error: expected ']' before ';' token
   55 |         count[list[i].first++;
      |                              ^
      |                              ]
a.cc:60:30: error: expected ']' before ';' token
   60 |         count[list[k].first--;
      |                              ^
      |                              ]
a.cc:66:4: error: expected '}' at end of input
   66 |   }
      |    ^
a.cc:12:11: note: to match this '{'
   12 | int main(){
      |           ^
Language: C++

#include <iostream>
#include <vector>
#include <queue>
#include <set>

#define p pair<int,int>
#define mp(a,b) make_pair(a,b)
using namespace std;

int main()
{
	int n, k;
	cin >> n >> k;
	vector<p> sushi(n);
	for (int i = 0; i < n; i++)
	{
		int t, d;
		cin >> t >> d;
		sushi[i] = mp(d,t);
	}
	sort(sushi.begin(), sushi.end());
	reverse(sushi.begin(), sushi.end());
	long long sum = 0;
	set<int> kind;
	priority_queue<int, vector<int>, greater<>> doub;
	for (int i = 0; i < k; i++)
	{
		sum += sushi[i].first;
		if (kind.find(sushi[i].second) != kind.end())doub.push(sushi[i].first);
		else kind.insert(sushi[i].second);
	}
	long long changesum = 0;
	int count = kind.size();
	for (int i = k; i < n; i++)
	{
		if (kind.find(sushi[i].second) != kind.end())continue;
		if (doub.empty())break;
		changesum += sushi[i].first - doub.top();
		doub.pop();
		kind.insert(sushi[i].second);
		if (sum + count * count <
			sum + changesum + kind.size() * kind.size())
		{
			sum += changesum;
			count = kind.size();
		}
	}
	cout << sum + count * count << endl;
	return 0;
}


Compiler output:
a.cc: In function 'int main()':
a.cc:21:9: error: 'sort' was not declared in this scope; did you mean 'short'?
   21 |         sort(sushi.begin(), sushi.end());
      |         ^~~~
      |         short
a.cc:22:9: error: 'reverse' was not declared in this scope
   22 |         reverse(sushi.begin(), sushi.end());
      |         ^~~~~~~
Language: C++

import java.util.*;
import java.awt.*;
import static java.lang.System.*;
import static java.lang.Math.*;
public class Main {
    public static void main(String[] $) {
        Scanner sc = new Scanner(in);
        int n = sc.nextInt();
        int k = sc.nextInt();
        long[] f=new long[k+1];
        Point[] sushi = new Point[n];
        for (int i = 0; i < n; i++) {
            sushi[i]=(new Point(sc.nextInt(), sc.nextInt()));
        }
        HashSet<Integer> S=new HashSet<>();
        Arrays.sort(sushi,(p1, p2) -> p2.y - p1.y);
        long temp=0;
        int[] s=new int[n+1];
        for (int i = 0; i < k; i++) {
            temp += (long) sushi[i].y;
            S.add(sushi[i].x);
            s[sushi[i].x]++;
        }
        int size=S.size();
        f[size]=temp;
        int left=k-1,right=k;
        while (0<=left&&right<n){
            while (0<=left&&s[sushi[left].x]==1){
                left--;
            }
            while (right<n&&s[sushi[right].x]>0){
                right++;
            }
            if(0<=left&&right<n){
                f[size+1]=f[size]-sushi[left].y+sushi[right].y;
                size++;
                s[sushi[right].x]++;
                s[sushi[left].x]--;
              left--;
            }
        }
        long ans=0;
        for (long i = 1; i <= k; i++) {
            if(f[(int)i]>0)ans=max(ans,f[(int)i]+i*i);
        }
        out.println(ans);
    }
}


Compiler output:
a.cc:1:1: error: 'import' does not name a type
    1 | import java.util.*;
      | ^~~~~~
a.cc:1:1: note: C++20 'import' only available with '-fmodules-ts'
a.cc:2:1: error: 'import' does not name a type
    2 | import java.awt.*;
      | ^~~~~~
a.cc:2:1: note: C++20 'import' only available with '-fmodules-ts'
a.cc:3:1: error: 'import' does not name a type
    3 | import static java.lang.System.*;
      | ^~~~~~
a.cc:3:1: note: C++20 'import' only available with '-fmodules-ts'
a.cc:4:1: error: 'import' does not name a type
    4 | import static java.lang.Math.*;
      | ^~~~~~
a.cc:4:1: note: C++20 'import' only available with '-fmodules-ts'
a.cc:5:1: error: expected unqualified-id before 'public'
    5 | public class Main {
      | ^~~~~~
Language: C++

#include<iostream>
#include<string>
#include<vector>
#include<iomanip>
#include<algorithm>
#include<queue>
#include<stack>
#include<map>
using namespace std;
#define ll long long
int main(){
      ll N,K;
      cin >> N >>K;
      vector<pair<int,int> > sushi(N);
      ll i;
      ll pre_eaten[N];
      for(i=0;i<N;i++){
        cin >> sushi[i].second >> sushi[i].first;
        pre_eaten[i]=0;
      }
      sort(sushi.begin(),sushi.end());
      ll type=0;
      ll sum=0;
      stack<ll> sushistack;
      for(i=N-1;i>=N-K;i--){
        if(pre_eaten[sushi[i].second-1]==0){
          pre_eaten[sushi[i].second-1]=1;
          type++;
        }else{
          sushistack.push_back(sushi[i].first);
        }
        sum+=sushi[i].first;
      }
      ll ans = sum + type*type;
      while(sushistack.size()!=0&&i>=0){
        if(pre_eaten[sushi[i].second-1]==0){
          pre_eaten[sushi[i].second-1]=1;
          sum+=sushi[i].first-sushistack.back();
          sushistack.pop_back();
          type++;
          ans=max(ans,sum+type*type);
        }
        i--;
      }
      cout << ans;
      return 0;
}


Compiler output:
a.cc: In function 'int main()':
a.cc:30:22: error: 'class std::stack<long long int>' has no member named 'push_back'
   30 |           sushistack.push_back(sushi[i].first);
      |                      ^~~~~~~~~
a.cc:38:42: error: 'class std::stack<long long int>' has no member named 'back'
   38 |           sum+=sushi[i].first-sushistack.back();
      |                                          ^~~~
a.cc:39:22: error: 'class std::stack<long long int>' has no member named 'pop_back'
   39 |           sushistack.pop_back();
      |                      ^~~~~~~~
Language: C++

#include<iostream>
#include<string>
#include<vector>
#include<iomanip>
#include<algorithm>
#include<queue>
#include<stack>
#include<map>
using namespace std;
#define ll long long
int main(){
      ll N,K;
      cin >> N >>K;
      vector<pair<int,int> > sushi(N);
      ll i;
      ll pre_eaten[N];
      for(i=0;i<N;i++){
        cin >> sushi[i].second >> sushi[i].first;
        pre_eaten[i]=0;
      }
      sort(sushi.begin(),sushi.end());
      ll type=0;
      ll sum=0;
      stack<ll> sushistack;
      for(i=N-1;i>=N-K;i--){
        if(pre_eaten[sushi[i].second-1]==0){
          pre_eaten[sushi[i].second-1]=1;
          type++;
        }else{
          sushistack.push_back(sushi[i].first);
        }
        sum+=sushi[i].first;
      }
      ll ans = sum + type*type;
      while(sushique.size()!=0&&i>=0){
        if(pre_eaten[sushi[i].second-1]==0){
          pre_eaten[sushi[i].second-1]=1;
          sum+=sushi[i].first-sushistack.back();
          sushistack.pop_back();
          type++;
          ans=max(ans,sum+type*type);
        }
        i--;
      }
      cout << ans;
      return 0;
}


Compiler output:
a.cc: In function 'int main()':
a.cc:30:22: error: 'class std::stack<long long int>' has no member named 'push_back'
   30 |           sushistack.push_back(sushi[i].first);
      |                      ^~~~~~~~~
a.cc:35:13: error: 'sushique' was not declared in this scope; did you mean 'sushi'?
   35 |       while(sushique.size()!=0&&i>=0){
      |             ^~~~~~~~
      |             sushi
a.cc:38:42: error: 'class std::stack<long long int>' has no member named 'back'
   38 |           sum+=sushi[i].first-sushistack.back();
      |                                          ^~~~
a.cc:39:22: error: 'class std::stack<long long int>' has no member named 'pop_back'
   39 |           sushistack.pop_back();
      |                      ^~~~~~~~