Language: C++

#include <stdio.h>  
#include <algorithm>  
#include <assert.h>
#include <bitset>
#include <cmath>  
#include <complex>  
#include <deque>  
#include <functional>  
#include <iostream>  
#include <limits.h>  
#include <map>  
#include <math.h>  
#include <queue>  
#include <set>  
#include <stdlib.h>  
#include <string.h>  
#include <string>  
#include <time.h>  
#include <unordered_map>  
#include <unordered_set>  
#include <vector>  
#include <chrono>
#include <random>
#include <time.h>
#include <fstream>
#define ll long long
#define rep2(i,a,b) for(ll i=a;i<=b;++i)
#define rep(i,n) for(ll i=0;i<n;i++)
#define rep3(i,a,b) for(ll i=a;i>=b;i--)
#define pii pair<int,int>
#define pll pair<ll,ll>
#define pq priority_queue<int>
#define pqg priority_queue<int,vector<int>,greater<int>>
#define pb push_back
#define vec vector<int>
#define vecll vector<ll>
#define vecpii vector<pii>
#define endl "\n"
#define all(c) begin(c),end(c)
using namespace std;
int in() {int x;scanf("%d",&x);return x;}
ll lin() {ll x;scanf("%lld",&x);return x;}
void print(vec v){for(auto e:v)cout<<e<<" ";cout<<endl;}
void print(map<int,int> mp){for(auto e:mp)cout<<e.first<<" "<<e.second<<endl;cout<<endl;}
ll MOD=998244353;
#define N 11000000

ll int inv[N],comb[N],prd[N],invprd[N];
void calc_inv(){
    inv[1]=1;
    rep2(i,2,N-1){
        inv[i]=((-(MOD/i)*inv[MOD%i])%MOD+MOD)%MOD;
    }
    return;
}
void calc_comb(ll int n){
    comb[0]=1;
    rep2(i,1,n){
        comb[i]=comb[i-1]*(n+1-i)*inv[i]%MOD;
    }
    return;
}
void calc_product(){
    prd[0]=prd[1]=1;
    invprd[0]=invprd[1]=1;
    rep2(i,2,N-1){
        prd[i]=i*prd[i-1]%MOD;
        invprd[i]=inv[i]*invprd[i-1]%MOD;
    }
    return ;
}
ll cmb(int a,int b){
    if(a<b)return 0;
    if(a<0||b<0)return 0;
    return prd[a]*invprd[b]%MOD*invprd[a-b]%MOD;
}
ll modpow(ll x,ll n){
    if(n==0) return 1;
    ll res=modpow(x*x%MOD,n/2);
    if(n&1) res=res*x%MOD;
    return res;
}
ll p[N+100],a[N],b[N];

struct UnionFind {
  vector< int > data;
 
  UnionFind(int sz) {
    data.assign(sz, -1);
  }
 
  bool unite(int x, int y) {
    x = find(x), y = find(y);
    if(x == y) return (false);
    if(data[x] > data[y]) swap(x, y);
    data[x] += data[y];
    data[y] = x;
    return (true);
  }
 
  int find(int k) {
    if(data[k] < 0) return (k);
    return (data[k] = find(data[k]));
  }
 
  int size(int k) {
    return (-data[find(k)]);
  }
};

struct querry{
  int a,b;
  ll c;
  int ato;
  bool operator<(const querry &x,const querry &y){
  return x.c<y.c;};
};
main(){
  int n,q;
  priority_queue<querry,vector<querry> pq;
  UnionFind uf(n);
  ll ans=0;
  rep(i,n){
    int a,b,c;
    cin>>a>>b>>c;
    pq.emplace(querry{a,b,c,1});
  }
  while(1){
    querry now=pq.top();
    pq.pop();
    if(uf.same(now.a,now.b)){
      swap(now.a,now.b);
      now.b++;now.c++;
      if(now.ato){now.ato=0;pq.emplace(now);}
    }
    else{
      uf.unite(now.a,now.b);
      now.a++;
      swap(now.a,now.b);
      now.ato=1;
      ans+=now.c;
      now.c++;
      pq.emplace(now);
      if(uf.size(now.a)==n){
      cout<<ans;return 0;}
    }
  }
}


Compiler output:
a.cc:115:8: error: 'bool querry::operator<(const querry&, const querry&)' must have exactly one argument
  115 |   bool operator<(const querry &x,const querry &y){
      |        ^~~~~~~~
a.cc:118:1: warning: ISO C++ forbids declaration of 'main' with no type [-Wreturn-type]
  118 | main(){
      | ^~~~
a.cc: In function 'int main()':
a.cc:120:25: error: two or more data types in declaration of 'type name'
  120 |   priority_queue<querry,vector<querry> pq;
      |                         ^~~~~~~~~~~~~~
a.cc:32:12: error: template argument 2 is invalid
   32 | #define pq priority_queue<int>
      |            ^~~~~~~~~~~~~~~~~~~
a.cc:120:40: note: in expansion of macro 'pq'
  120 |   priority_queue<querry,vector<querry> pq;
      |                                        ^~
a.cc:32:12: error: template argument 3 is invalid
   32 | #define pq priority_queue<int>
      |            ^~~~~~~~~~~~~~~~~~~
a.cc:120:40: note: in expansion of macro 'pq'
  120 |   priority_queue<querry,vector<querry> pq;
      |                                        ^~
a.cc:126:7: error: expected unqualified-id before '.' token
  126 |     pq.emplace(querry{a,b,c,1});
      |       ^
a.cc:126:31: error: expected primary-expression before ')' token
  126 |     pq.emplace(querry{a,b,c,1});
      |                               ^
a.cc:129:18: error: expected primary-expression before '.' token
  129 |     querry now=pq.top();
      |                  ^
a.cc:130:7: error: expected unqualified-id before '.' token
  130 |     pq.pop();
      |       ^
a.cc:131:11: error: 'struct UnionFind' has no member named 'same'
  131 |     if(uf.same(now.a,now.b)){
      |           ^~~~
a.cc:134:31: error: expected unqualified-id before '.' token
  134 |       if(now.ato){now.ato=0;pq.emplace(now);}
      |                               ^
a.cc:143:9: error: expected unqualified-id before '.' token
  143 |       pq.emplace(now);
      |         ^