Language: C++

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

class UnionFind {
public:
    // 親の番号を格納．親だった場合は-(その集合のサイズ)
    vector<int> Parent;
    // 重さの差を格納
    vector<ll> diffWeight;

    UnionFind(const int N) {
        Parent = vector<int>(N, -1);
        diffWeight = vector<ll>(N, 0);
    }

    // Aがどのグループに属しているか調べる
    int root(const int A) {
        if (Parent[A] < 0) return A;
        int Root = root(Parent[A]);
        diffWeight[A] += diffWeight[Parent[A]];
        return Parent[A] = Root;
    }

    // 自分のいるグループの頂点数を調べる
    int size(const int A) {
        return -Parent[root(A)];
    }

    // 自分の重さを調べる
    ll weight(const int A) {
        root(A); // 経路圧縮
        return diffWeight[A];
    }

    // 重さの差を計算する
    ll diff(const int A, const int B) {
        return weight(B) - weight(A);
    }

    // AとBをくっ付ける
    bool connect(int A, int B, ll W = 0) {
        // Wをrootとの重み差分に変更
        W += weight(A);
        W -= weight(B);

        // AとBを直接つなぐのではなく、root(A)にroot(B)をくっつける
        A = root(A);
        B = root(B);

        if (A == B) {
            //すでにくっついてるからくっ付けない
            return false;
        }

        // 大きい方(A)に小さいほう(B)をくっ付ける
        // 大小が逆だったらひっくり返す
        if (size(A) < size(B)) {
            swap(A, B);
            W = -W;
        }

        // Aのサイズを更新する
        Parent[A] += Parent[B];
        // Bの親をAに変更する
        Parent[B] = A;

        // AはBの親であることが確定しているのでBにWの重みを充てる
        diffWeight[B] = W;

        return true;
    }
};
// Union-Findも呼んで！！そして上の書き換えて！！！
struct kr_edge {
    int u; // 辺の片方，fromではないので二回辺を張る必要はない
    int v; // 辺のもう片方
    int cost;

    // コストの大小で順序定義
    bool operator<(const kr_edge& e) const {
        return cost < e.cost;
    }
};
class Kruskal{
    public:

    bool comp(const kr_edge& e1, const kr_edge& e2) { // sort関数の比較関数
        return e1.cost < e2.cost;
    }

    vector<kr_edge> es; // 辺の集合
    vector<kr_edge> minst; // 最小全域木に用いられる辺の集合
    int V, E; // 頂点数と辺数

    Kruskal(int v) {
        V = v;
    }

    void add(int v, int u, int cost){
        kr_edge e = {v, u, cost};
        es.push_back(e);
    }

    int kruskal(void) {
        sort(es.begin(), es.end()); // kr_edge.costが小さい順にソートされる
        UnionFind uni(V); //union-findの初期化
        int res = 0;
        for(int i = 0; i < es.size(); i++) {
            kr_edge e = es[i];
            if(uni.root(e.u) != uni.root(e.v)) {
                uni.connect(e.u, e.v);
                res += e.cost;
                minst.push_back(e);
            }
        }
        return res;
    }
};
class Solution {
   public:
    
    int minCostConnectPoints(vector<vector<int>>& points) {
        int n = points.size();
        Kruskal kr(n);
        for (int i = 0; i < n; ++i) {
            for (int j = i + 1; j < n; ++j) {
                int d = abs(points[i][0] - points[j][0]) +
                        abs(points[i][1] - points[j][1]);
                kr.add(i, j, d);
                kr.add(j, i, d);
            }
        }
        return kr.kruskal();
    }
};

int main() {
    Solution s;
    int n = 1984 / 2;
    vector<vector<int>> v(n, vector<int>(2));
    for (int i = 0; i < n; i++) {
        int a, b;
        cin >> a >> b;
        v[i][0] = a;
        v[i][1] = b;
    }

    auto ans = s.minCostConnectPoints(v);

    cout << ans << endl;
}

Compiler output:
a.cc: In member function 'int Kruskal::kruskal()':
a.cc:107:9: error: 'sort' was not declared in this scope; did you mean 'short'?
  107 |         sort(es.begin(), es.end()); // kr_edge.costが小さい順にソートされる
      |         ^~~~
      |         short