Problem p02573 (C++) — buggy submission, verdict: Time Limit Exceeded


#include <algorithm>
#include <bitset>
#include <deque>
#include <iostream>
#include <map>
#include <math.h>
#include <queue>
#include <set>
#include <stack>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unordered_map>
#include <vector>

long long mod = 1e9 + 7;
class Mint {
public:
  long long x;
  Mint(){}; // 引数なしでも定義できるように引数なしコンストラクタも用意しておく
  Mint(long long a) {
    x = a % mod;
    while (x < 0) {
      x += mod;
    }
  };
  Mint &operator+=(const Mint &a) {
    x += a.x;
    x %= mod;
    return *this;
  }
  Mint &operator-=(const Mint &a) {
    x += (mod - a.x);
    x %= mod;
    return *this;
  }
  Mint &operator*=(const Mint &a) {
    x *= a.x;
    x %= mod;
    return *this;
  }

  // a^n mod を計算する
  // Useaeg: Mint z = Mint(2).pow(n);
  Mint pow(long long n) const {
    if (n == 0)
      return Mint(1);
    Mint y = pow(n >> 1); // pow(n/2)を計算する
    y *= y;
    if (n % 2 == 1)
      y *= *this;
    return y;
  }

  // a^{-1} mod を計算する
  Mint modinv(const Mint &a) const { return a.pow(mod - 2); }

  Mint &operator/=(const Mint &a) {
    x *= modinv(a).x;
    x %= mod;
    return *this;
  }

  Mint operator+(Mint &a) const {
    Mint y(*this);
    y += a;
    return y;
  }

  Mint operator-(Mint &a) const {
    Mint y(*this);
    y -= a;
    return y;
  }

  Mint operator*(Mint &a) const {
    Mint y(*this);
    y *= a;
    return y;
  }

  Mint operator/(Mint &a) const {
    Mint y(*this);
    y /= a;
    return y.x;
  }

  // nCk @mod を計算する
  Mint nCk(Mint &n, const long long k) const {
    Mint y = Mint(1);
    Mint one = Mint(1);
    for (Mint i(0); (i.x) < k; i.x++) {
      y *= (n - i);
      y /= (i + one);
    }
    return y;
  }

  // nPk @mod を計算する
  Mint nPk(Mint &n, long long k) const {
    Mint y(1);
    for (Mint i(0); (i.x) < k; i.x++) {
      y *= (n - i);
    }
    return y;
  }
};

int parent[200004];
int length[200004];
int num[200004];

void init() {
  for (int i = 0; i < 200004; i++) {
    parent[i] = i;
    length[i] = 1;
    num[i] = 1;
  }
  return;
}

int getroot(int n) {
  int orig = n;
  while (n != parent[n]) {
    n = parent[n];
  }
  parent[orig] = n;
  return n;
}

bool samegroup(int n, int m) {
  n = getroot(n);
  m = getroot(m);
  return n == m;
}

void unite(int n, int m) {
  n = getroot(n);
  m = getroot(m);
  if (samegroup(n, m))
    return;
  if (length[n] > length[m]) {
    parent[m] = n;
    num[n] += num[m];
  } else if (length[m] > length[n]) {
    parent[n] = m;
    num[m] += num[n];
  } else {
    parent[n] = m;
    length[n]++;
    num[m] += num[n];
  }
}

int main() {
  int N, M;
  std::cin >> N >> M;
  init();
  int A, B;
  for (int i = 0; i < M; i++) {
    std::cin >> A >> B;
    A--;
    B--;
    unite(A, B);
  }
  int max = 0;
  for (int i = 0; i < N; i++) {
    max = std::max(max, num[i]);
    // printf("root of %d = %d, num=%d\\n", i, getroot(i), num[getroot(i)]);
  }
  std::cout << max << std::endl;
  return 0;
}


Error: TLE

Fixed submission:


#include <algorithm>
#include <bitset>
#include <deque>
#include <iostream>
#include <map>
#include <math.h>
#include <queue>
#include <set>
#include <stack>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unordered_map>
#include <vector>

long long mod = 1e9 + 7;
class Mint {
public:
  long long x;
  Mint(){}; // 引数なしでも定義できるように引数なしコンストラクタも用意しておく
  Mint(long long a) {
    x = a % mod;
    while (x < 0) {
      x += mod;
    }
  };
  Mint &operator+=(const Mint &a) {
    x += a.x;
    x %= mod;
    return *this;
  }
  Mint &operator-=(const Mint &a) {
    x += (mod - a.x);
    x %= mod;
    return *this;
  }
  Mint &operator*=(const Mint &a) {
    x *= a.x;
    x %= mod;
    return *this;
  }

  // a^n mod を計算する
  // Useaeg: Mint z = Mint(2).pow(n);
  Mint pow(long long n) const {
    if (n == 0)
      return Mint(1);
    Mint y = pow(n >> 1); // pow(n/2)を計算する
    y *= y;
    if (n % 2 == 1)
      y *= *this;
    return y;
  }

  // a^{-1} mod を計算する
  Mint modinv(const Mint &a) const { return a.pow(mod - 2); }

  Mint &operator/=(const Mint &a) {
    x *= modinv(a).x;
    x %= mod;
    return *this;
  }

  Mint operator+(Mint &a) const {
    Mint y(*this);
    y += a;
    return y;
  }

  Mint operator-(Mint &a) const {
    Mint y(*this);
    y -= a;
    return y;
  }

  Mint operator*(Mint &a) const {
    Mint y(*this);
    y *= a;
    return y;
  }

  Mint operator/(Mint &a) const {
    Mint y(*this);
    y /= a;
    return y.x;
  }

  // nCk @mod を計算する
  Mint nCk(Mint &n, const long long k) const {
    Mint y = Mint(1);
    Mint one = Mint(1);
    for (Mint i(0); (i.x) < k; i.x++) {
      y *= (n - i);
      y /= (i + one);
    }
    return y;
  }

  // nPk @mod を計算する
  Mint nPk(Mint &n, long long k) const {
    Mint y(1);
    for (Mint i(0); (i.x) < k; i.x++) {
      y *= (n - i);
    }
    return y;
  }
};

int parent[200004];
int length[200004];
int num[200004];

void init() {
  for (int i = 0; i < 200004; i++) {
    parent[i] = i;
    length[i] = 1;
    num[i] = 1;
  }
  return;
}

int getroot(int n) {
  int orig = n;
  while (n != parent[n]) {
    n = parent[n];
  }
  parent[orig] = n;
  return n;
}

bool samegroup(int n, int m) {
  n = getroot(n);
  m = getroot(m);
  return n == m;
}

void unite(int n, int m) {
  if (samegroup(n, m))
    return;
  n = getroot(n);
  m = getroot(m);
  if (length[n] > length[m]) {
    parent[m] = n;
    num[n] += num[m];
  } else if (length[m] > length[n]) {
    parent[n] = m;
    num[m] += num[n];
  } else {
    parent[n] = m;
    length[n]++;
    num[m] += num[n];
  }
}

int main() {
  int N, M;
  std::cin >> N >> M;
  init();
  int A, B;
  for (int i = 0; i < M; i++) {
    std::cin >> A >> B;
    A--;
    B--;
    unite(A, B);
  }
  int max = 0;
  for (int i = 0; i < N; i++) {
    max = std::max(max, num[getroot(i)]);
    // printf("root of %d = %d, num=%d\\n", i, getroot(i), num[getroot(i)]);
  }
  std::cout << max << std::endl;
  return 0;
}