Problem p03682 (C++)

Buggy submission (status: Runtime Error):
#include <algorithm>
#include <cassert>
#include <cmath>
#include <iomanip>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <sstream>
#include <string>
#include <utility>
#include <vector>

using namespace std;
using ll = long long;

constexpr ll infl = 10000000000000007LL;
constexpr int inf = 1000000007;

using Point = tuple<int, int, int>;

class UnionFind {
  vector<int> parent;
  vector<int> rank;

public:
  int root(int x) { return parent[x] >= 0 ? parent[x] = root(parent[x]) : x; }

  void unite(int x, int y) {
    int rootX = root(x);
    int rootY = root(y);
    if (rootX == rootY)
      return;

    if (rank[rootX] > rank[rootY]) {
      parent[rootX] += parent[rootY];
      parent[rootY] = rootX;
    } else {
      if (rank[rootX] == rank[rootY])
        ++rank[rootY];

      parent[rootY] += parent[rootX];
      parent[rootX] = rootY;
    }
  }

  bool same(int x, int y) { return root(x) == root(y); }

  int groupSize(int x) { return -parent[root(x)]; }

  int numGroup() {
    int num = 0;
    for (int k : parent) {
      num += k < 0;
    }
    return num;
  }

  UnionFind(int size) : parent(size + 1, -1), rank(size + 1, 1) {
    parent[0] = rank[0] = 0;
  }
};

bool point_comp(const Point &l, const Point &r) {
  int u, sx, sy, v, tx, ty;
  tie(sx, sy, u) = l;
  tie(tx, ty, v) = r;
  return sy < ty || sx < tx;
}

int main() {
  int n;
  cin >> n;
  vector<Point> p(n);
  for (int i = 0; i < n; ++i) {
    int x, y;
    cin >> x >> y;
    p[i] = make_tuple(x, y, i + 1);
  }
  vector<tuple<int, Point, Point>> edges;
  sort(p.begin(), p.end());
  for (int i = 0; i < n - 1; ++i) {
    int u, sx, sy, v, tx, ty;
    tie(sx, sy, u) = p[i];
    tie(tx, ty, v) = p[i + 1];
    int dist = min(abs(sx - tx), abs(sy - ty));
    edges.push_back(make_tuple(dist, p[i], p[i + 1]));
  }

  sort(p.begin(), p.end(), point_comp);

  for (int i = 0; i < n - 1; ++i) {
    int u, sx, sy, v, tx, ty;
    tie(sx, sy, u) = p[i];
    tie(tx, ty, v) = p[i + 1];
    int dist = min(abs(sx - tx), abs(sy - ty));
    edges.push_back(make_tuple(dist, p[i], p[i + 1]));
  }

  sort(edges.begin(), edges.end());
  UnionFind uf(n);
  ll ans = 0;
  for (int i = 0; i < edges.size(); ++i) {
    int dist;
    Point p1, p2;
    tie(dist, p1, p2) = edges[i];
    if (!uf.same(get<2>(p1), get<2>(p2))) {
      uf.unite(get<2>(p1), get<2>(p2));
      ans += dist;
    }
  }
  cout << ans << endl;

  return 0;
}

Fixed submission:
#include <algorithm>
#include <cassert>
#include <cmath>
#include <iomanip>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <sstream>
#include <string>
#include <utility>
#include <vector>

using namespace std;
using ll = long long;

constexpr ll infl = 10000000000000007LL;
constexpr int inf = 1000000007;

using Point = tuple<int, int, int>;

class UnionFind {
  vector<int> parent;
  vector<int> rank;

public:
  int root(int x) { return parent[x] >= 0 ? parent[x] = root(parent[x]) : x; }

  void unite(int x, int y) {
    int rootX = root(x);
    int rootY = root(y);
    if (rootX == rootY)
      return;

    if (rank[rootX] > rank[rootY]) {
      parent[rootX] += parent[rootY];
      parent[rootY] = rootX;
    } else {
      if (rank[rootX] == rank[rootY])
        ++rank[rootY];

      parent[rootY] += parent[rootX];
      parent[rootX] = rootY;
    }
  }

  bool same(int x, int y) { return root(x) == root(y); }

  int groupSize(int x) { return -parent[root(x)]; }

  int numGroup() {
    int num = 0;
    for (int k : parent) {
      num += k < 0;
    }
    return num;
  }

  UnionFind(int size) : parent(size + 1, -1), rank(size + 1, 1) {
    parent[0] = rank[0] = 0;
  }
};

bool point_comp(const Point &l, const Point &r) {
  int u, sx, sy, v, tx, ty;
  tie(sx, sy, u) = l;
  tie(tx, ty, v) = r;
  return sy < ty || ((sy == ty) && (sx < tx));
}

int main() {
  int n;
  cin >> n;
  vector<Point> p(n);
  for (int i = 0; i < n; ++i) {
    int x, y;
    cin >> x >> y;
    p[i] = make_tuple(x, y, i + 1);
  }
  vector<tuple<int, Point, Point>> edges;
  sort(p.begin(), p.end());
  for (int i = 0; i < n - 1; ++i) {
    int u, sx, sy, v, tx, ty;
    tie(sx, sy, u) = p[i];
    tie(tx, ty, v) = p[i + 1];
    int dist = min(abs(sx - tx), abs(sy - ty));
    edges.push_back(make_tuple(dist, p[i], p[i + 1]));
  }

  sort(p.begin(), p.end(), point_comp);

  for (int i = 0; i < n - 1; ++i) {
    int u, sx, sy, v, tx, ty;
    tie(sx, sy, u) = p[i];
    tie(tx, ty, v) = p[i + 1];
    int dist = min(abs(sx - tx), abs(sy - ty));
    edges.push_back(make_tuple(dist, p[i], p[i + 1]));
  }

  sort(edges.begin(), edges.end());
  UnionFind uf(n);
  ll ans = 0;
  for (int i = 0; i < edges.size(); ++i) {
    int dist;
    Point p1, p2;
    tie(dist, p1, p2) = edges[i];
    if (!uf.same(get<2>(p1), get<2>(p2))) {
      uf.unite(get<2>(p1), get<2>(p2));
      ans += dist;
    }
  }
  cout << ans << endl;

  return 0;
}