Language: C++

#include <algorithm>
#include <bitset>
#include <cmath>
#include <cstring>
#include <iostream>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <vector>

const long long int MOD = 1e9 + 7;
const int iINF = 1000000000;
const long long int INF = 1000000000000000000;

using namespace std;
using ll = long long int;
using edge = struct {
  ll to;
  ll cost;
};
#define REP(i, n) for (ll i = 0; i < (n); i++)
#define FOR(i, a, b) for (ll i = (a); i < (b); i++)
#define AUTO(i, m) for (auto &i : m)
#define ALL(a) (a).begin(), (a).end()
#define MAX(vec) *std::max_element(vec.begin(), vec.end());
#define MIN(vec) *std::min_element(vec.begin(), vec.end());
#define MAXI(vec)                                                              \
  std::distance(vec.begin(), *std::max_element(vec.begin(), vec.end()));
#define MINI(vec)                                                              \
  std::distance(vec.begin(), *std::min_element(vec.begin(), vec.end()));
#define BIT(n, num) std::bitset<(n)>((num)).to_string()
#define MATMUL(a, b, c)                                                        \
  REP(i, a.size())                                                             \
  REP(j, b[0].size()) REP(k, a[0].size()) c[i][j] += a[i][k] * b[k][j];
#define CLA2(a) REP(i, a.size()) REP(j, a[0].size()) a[i][j] = 0;
#define REV(T) greater<T>()

ll pow_(ll a, ll n) {
  ll x = 1;
  while (n > 0) {
    if (n & 1)
      x = (x * a) % MOD;
    a = (a * a) % MOD;
    n >>= 1;
  }
  return x;
}

vector<ll> divisor(ll n) {
  vector<ll> ret;
  for (ll i = 1; i * i <= n; i++) {
    if (n % i == 0) {
      ret.push_back(i);
      if (i * i != n)
        ret.push_back(n / i);
    }
  }
  sort(begin(ret), end(ret));
  return (ret);
}

map<ll, ll> prime_factor(ll n) {
  map<ll, ll> ret;
  for (ll i = 2; i * i <= n; i++) {
    while (n % i == 0) {
      ret[i]++;
      n /= i;
    }
  }
  if (n != 1)
    ret[n] = 1;
  return ret;
}

ll factorial(ll n) {
  ll ans = 1;
  for (ll i = 2; i <= n; i++) {
    ans *= i;
    ans %= MOD;
  }
  return ans;
}
ll P(ll n, ll m) {
  ll ans = 1;
  for (ll i = m + 1; i <= n; i++) {
    ans *= i;
    ans %= MOD;
  }
  return ans;
}
ll power(ll n, ll m) {
  if (m == 0) {
    return 1;
  } else if (m % 2 == 0) {
    ll tmp = power(n, m / 2);
    return (tmp * tmp) % MOD;
  } else {
    return (n * power(n, m - 1)) % MOD;
  }
}
ll C(ll n, ll m) { return (P(n, n - m) * power(factorial(m), MOD - 2)) % MOD; }
ll dx[4] = {1, 0, -1, 0};
ll dy[4] = {0, 1, 0, -1};

struct UnionFind {
  vector<ll> par;  // par[i]:iの親の番号　(例) par[3] = 2 : 3の親が2
  vector<ll> size; // 大きさ

  UnionFind(ll N) : par(N), size(N) { //最初は全てが根であるとして初期化
    for (ll i = 0; i < N; i++) {
      par[i] = i;
      size[i] = 1;
    }
  }

  ll root(ll x) { // データxが属する木の根を再帰で得る：root(x) = {xの木の根}
    if (par[x] == x)
      return x;
    return par[x] = root(par[x]);
  }

  void unite(ll x, ll y) { // xとyの木を併合
    ll rx = root(x);       // xの根をrx
    ll ry = root(y);       // yの根をry
    if (rx == ry)
      return; // xとyの根が同じ(=同じ木にある)時はそのまま
    par[rx] =
        ry; // xとyの根が同じでない(=同じ木にない)時：xの根rxをyの根ryにつける
    size[rx] += size[ry];
  }

  bool same(ll x, ll y) { // 2つのデータx, yが属する木が同じならtrueを返す
    ll rx = root(x);
    ll ry = root(y);
    return rx == ry;
  }

  ll size(ll x) { return size[root(x)]; }
};

int main() {
  ll N, M;
  ll ans = 0;
  vector<ll> A, B;
  cin >> N >> M;
  auto uf = UnionFind(N);
  REP(i, M) {
    ll a, b;
    cin >> a >> b;
    A.push_back(a - 1);
    B.push_back(b - 1);
  }
  ll old = 0;
  vector<ll> ANS;
  FOR(i, 1, M) {
    if (uf.same(A[M - i], B[M - i])) {
      ANS.push_back((N * (N - 1) / 2) - old);
      uf.unite(A[M - i], B[M - i]);
    } else {
      uf.unite(A[M - i], B[M - i]);
      ll L[N];
      ans = 0;
      REP(k, N) L[k] = 0;
      REP(k, N) { L[uf.root(k)]++; }
      REP(k, N) {
        if (L[k] > 1) {
          ans += L[k] * (L[k] - 1) / 2;
        }
      }
      old = ANS;
      ANS.push_back((N * (N - 1) / 2) - ans);
    }
  }
  REP(i, M - 1) { cout << ANS[M - i - 2] << endl; }
  cout << (N * (N - 1) / 2) << endl;

  return 0;
}


Compiler output:
a.cc:141:41: error: 'll UnionFind::size(ll)' conflicts with a previous declaration
  141 |   ll size(ll x) { return size[root(x)]; }
      |                                         ^
a.cc:110:14: note: previous declaration 'std::vector<long long int> UnionFind::size'
  110 |   vector<ll> size; // 大きさ
      |              ^~~~
a.cc: In function 'int main()':
a.cc:173:13: error: cannot convert 'std::vector<long long int>' to 'll' {aka 'long long int'} in assignment
  173 |       old = ANS;
      |             ^~~
      |             |
      |             std::vector<long long int>