Problem p02539 (C++) — buggy submission, verdict: Runtime Error

#include <bits/stdc++.h>
// #include <chrono>
// #pragma GCC optimize("Ofast")
using namespace std;
#define reps(i, s, n) for (int i = s; i < n; i++)
#define rep(i, n) reps(i, 0, n)
#define Rreps(i, n, e) for (int i = n - 1; i >= e; --i)
#define Rrep(i, n) Rreps(i, n, 0)
#define ALL(a) a.begin(), a.end()
#define fi first
#define se second

using ll = long long;
using vec = vector<ll>;
using mat = vector<vec>;

ll N, M, H, W, Q, K, A, B;
string S;
typedef pair<ll, ll> P;
const ll INF = (1LL << 58);

template <class T> bool chmin(T &a, const T &b) {
  if (a > b) {
    a = b;
    return true;
  } else
    return false;
}
template <class T> bool chmax(T &a, const T &b) {
  if (a < b) {
    a = b;
    return true;
  } else
    return false;
}

template <unsigned long long mod> class modint {
public:
  ll x;
  constexpr modint() { x = 0; }
  constexpr modint(ll _x)
      : x((_x < 0 ? ((_x += (LLONG_MAX / mod) * mod) < 0
                         ? _x + (LLONG_MAX / mod) * mod
                         : _x)
                  : _x) %
          mod) {}
  constexpr void set_raw(ll _x) {
    //_x in [0, mod)
    x = _x;
  }
  constexpr modint operator-() { return x == 0 ? 0 : mod - x; }
  constexpr modint &operator+=(const modint &a) {
    if ((x += a.x) >= mod)
      x -= mod;
    return *this;
  }
  constexpr modint operator+(const modint &a) const {
    return modint(*this) += a;
  }
  constexpr modint &operator-=(const modint &a) {
    if ((x -= a.x) < 0)
      x += mod;
    return *this;
  }
  constexpr modint operator-(const modint &a) const {
    return modint(*this) -= a;
  }
  constexpr modint &operator*=(const modint &a) {
    (x *= a.x) %= mod;
    return *this;
  }
  constexpr modint operator*(const modint &a) const {
    return modint(*this) *= a;
  }
  constexpr modint pow(unsigned long long pw) const {
    modint res(1), comp(*this);
    while (pw) {
      if (pw & 1)
        res *= comp;
      comp *= comp;
      pw >>= 1;
    }
    return res;
  }
  // 以下、modが素数のときのみ
  constexpr modint inv() const { return modint(*this).pow(mod - 2); }
  constexpr modint &operator/=(const modint &a) {
    (x *= a.inv().x) %= mod;
    return *this;
  }
  constexpr modint operator/(const modint &a) const {
    return modint(*this) /= a;
  }
};
#define mod1 998244353
using mint = modint<mod1>;

ostream &operator<<(ostream &os, const mint &a) {
  os << a.x;
  return os;
}
using vm = vector<mint>;
class NTT {
  const int root;

  void make_root_pow(int n, vm &root_pow) {
    root_pow.resize(n + 1);
    mint new_root = mint(root).pow((mod1 - 1) / n);
    root_pow[0].x = 1;
    rep(i, n) { root_pow[i + 1] = root_pow[i] * new_root; }
  }
  static void make_bit_reverse(int n, vector<int> &v) {
    v.resize(n);
    iota(ALL(v), 0);
    for (int i = 1; (1 << i) <= n; ++i) {
      int l = 1 << (i - 1), r = 1 << i;
      int plus = n >> i;
      for (int j = l; j < r; ++j) {
        int temp = v[j - l] + plus;
        if (j < temp)
          swap(v[j], v[temp]);
      }
    }
  }
  static void dft(int n, vm &f, bool inv, vm &root_pow, vector<int> &id) {
    vm g(n);
    rep(i, n) g[i] = f[id[i]];
    swap(f, g);
    for (int l = n / 2, len = 1; l >= 1; l /= 2, len *= 2) {
      for (int i = 0; i < n; i += len * 2) {
        rep(j, len) {
          mint z_f =
              (inv ? root_pow[n - l * j] : root_pow[l * j]) * f[i + len + j];
          g[i + j] = f[i + j] + z_f;
          g[i + len + j] = f[i + j] - z_f;
        }
      }
      swap(f, g);
    }
    if (inv) {
      mint n_inv = mint(n).inv();
      rep(i, n) f[i] *= n_inv;
    }
  }

public:
  NTT(int _x = 3) : root(_x) {}
  vm convolution(vm &a, vm &b, int size_a = INT_MAX, int size_b = INT_MAX) {
    chmin(size_a, (int)a.size());
    chmin(size_b, (int)b.size());
    int sz = size_a + size_b - 1, n = 1;
    while (sz > n)
      n *= 2;
    vm g(n), h(n), root_pow, gh(n);
    vector<int> id;
    copy(a.begin(), a.begin() + size_a, g.begin());
    copy(b.begin(), b.begin() + size_b, h.begin());
    make_root_pow(n, root_pow);
    make_bit_reverse(n, id);
    dft(n, g, false, root_pow, id);
    dft(n, h, false, root_pow, id);
    rep(i, n) gh[i] = g[i] * h[i];
    dft(n, gh, true, root_pow, id);
    gh.resize(sz);
    return gh;
  }
};

vm polynomial_product(vector<vm> &polys) {
  // time complexity : O(N log^2 N) (N : sum of polys[i].size())
  struct _cmp {
    int sz;
    vm a;
    _cmp(int _sz, vm _a) : sz(_sz), a(_a) {}
    bool operator>(const _cmp &b) { return sz > b.sz; }
  };
  priority_queue<_cmp, vector<_cmp>, greater<>> pque;
  for (vm &a : polys)
    pque.emplace((int)a.size(), a);
  NTT ntt;
  while (pque.size() > 1) {
    _cmp c = pque.top();
    pque.pop();
    _cmp d = pque.top();
    pque.pop();
    vm res = ntt.convolution(c.a, d.a);
    pque.emplace(res.size(), res);
  }
  return pque.top().a;
}

const ll MAX_N = ll(4e+5) + 10;
vm fact(MAX_N, mint(1)), fact_inv(MAX_N, mint(1)), n_inv(MAX_N, mint(1)),
    two_inv(MAX_N, mint(1));
void makefact() {
  two_inv[1] = mint(2).inv();
  reps(i, 2, MAX_N) {
    fact[i] = fact[i - 1] * mint(i);
    n_inv[i] = mint(i).inv();
    fact_inv[i] = fact_inv[i - 1] * n_inv[i];
    two_inv[i] = two_inv[i - 1] * two_inv[1];
  }
}
mint nCm(ll n, ll m) { return fact[n] * fact_inv[n - m] * fact_inv[m]; }
mint nCm_inv(ll n, ll m) { return fact[n - m] * fact[m] * fact_inv[n]; }

int main() {
  makefact();
  cin >> N;
  vec h(N * 2), num(100000, 0);
  rep(i, N * 2) {
    cin >> h[i];
    --h[i];
    ++num[h[i]];
  }

  vector<vm> polys(0);
  rep(i, 100000) {
    int k = 1;
    vm temp(1, 1);
    while (num[i] >= k * 2) {
      temp.push_back(fact[num[i]] * fact_inv[k] * fact_inv[num[i] - k * 2] *
                     two_inv[k]);
      ++k;
    }
    if (temp.size() != 1)
      polys.push_back(temp);
  }
  mint res = fact[N * 2] * two_inv[N] * fact_inv[N];

  if (polys.empty()) {
    cout << res << endl;
    return 0;
  }

  vm polv = polynomial_product(polys);
  reps(k, 1, (int)polv.size()) {
    if (k > N)
      break;
    res += mint(k & 1 ? -1 : 1) * polv[k] * fact[(N - k) * 2] * two_inv[N - k] *
           fact_inv[N - k];
  }
  cout << res << endl;
}


Error: 0

Fixed submission:

#include <bits/stdc++.h>
// #include <chrono>
// #pragma GCC optimize("Ofast")
using namespace std;
#define reps(i, s, n) for (int i = s; i < n; i++)
#define rep(i, n) reps(i, 0, n)
#define Rreps(i, n, e) for (int i = n - 1; i >= e; --i)
#define Rrep(i, n) Rreps(i, n, 0)
#define ALL(a) a.begin(), a.end()
#define fi first
#define se second

using ll = long long;
using vec = vector<ll>;
using mat = vector<vec>;

ll N, M, H, W, Q, K, A, B;
string S;
typedef pair<ll, ll> P;
const ll INF = (1LL << 58);

template <class T> bool chmin(T &a, const T &b) {
  if (a > b) {
    a = b;
    return true;
  } else
    return false;
}
template <class T> bool chmax(T &a, const T &b) {
  if (a < b) {
    a = b;
    return true;
  } else
    return false;
}

template <unsigned long long mod> class modint {
public:
  ll x;
  constexpr modint() { x = 0; }
  constexpr modint(ll _x)
      : x((_x < 0 ? ((_x += (LLONG_MAX / mod) * mod) < 0
                         ? _x + (LLONG_MAX / mod) * mod
                         : _x)
                  : _x) %
          mod) {}
  constexpr void set_raw(ll _x) {
    //_x in [0, mod)
    x = _x;
  }
  constexpr modint operator-() { return x == 0 ? 0 : mod - x; }
  constexpr modint &operator+=(const modint &a) {
    if ((x += a.x) >= mod)
      x -= mod;
    return *this;
  }
  constexpr modint operator+(const modint &a) const {
    return modint(*this) += a;
  }
  constexpr modint &operator-=(const modint &a) {
    if ((x -= a.x) < 0)
      x += mod;
    return *this;
  }
  constexpr modint operator-(const modint &a) const {
    return modint(*this) -= a;
  }
  constexpr modint &operator*=(const modint &a) {
    (x *= a.x) %= mod;
    return *this;
  }
  constexpr modint operator*(const modint &a) const {
    return modint(*this) *= a;
  }
  constexpr modint pow(unsigned long long pw) const {
    modint res(1), comp(*this);
    while (pw) {
      if (pw & 1)
        res *= comp;
      comp *= comp;
      pw >>= 1;
    }
    return res;
  }
  // 以下、modが素数のときのみ
  constexpr modint inv() const { return modint(*this).pow(mod - 2); }
  constexpr modint &operator/=(const modint &a) {
    (x *= a.inv().x) %= mod;
    return *this;
  }
  constexpr modint operator/(const modint &a) const {
    return modint(*this) /= a;
  }
};
#define mod1 998244353
using mint = modint<mod1>;

ostream &operator<<(ostream &os, const mint &a) {
  os << a.x;
  return os;
}
using vm = vector<mint>;
class NTT {
  const int root;

  void make_root_pow(int n, vm &root_pow) {
    root_pow.resize(n + 1);
    mint new_root = mint(root).pow((mod1 - 1) / n);
    root_pow[0].x = 1;
    rep(i, n) { root_pow[i + 1] = root_pow[i] * new_root; }
  }
  static void make_bit_reverse(int n, vector<int> &v) {
    v.resize(n);
    iota(ALL(v), 0);
    for (int i = 1; (1 << i) <= n; ++i) {
      int l = 1 << (i - 1), r = 1 << i;
      int plus = n >> i;
      for (int j = l; j < r; ++j) {
        int temp = v[j - l] + plus;
        if (j < temp)
          swap(v[j], v[temp]);
      }
    }
  }
  static void dft(int n, vm &f, bool inv, vm &root_pow, vector<int> &id) {
    vm g(n);
    rep(i, n) g[i] = f[id[i]];
    swap(f, g);
    for (int l = n / 2, len = 1; l >= 1; l /= 2, len *= 2) {
      for (int i = 0; i < n; i += len * 2) {
        rep(j, len) {
          mint z_f =
              (inv ? root_pow[n - l * j] : root_pow[l * j]) * f[i + len + j];
          g[i + j] = f[i + j] + z_f;
          g[i + len + j] = f[i + j] - z_f;
        }
      }
      swap(f, g);
    }
    if (inv) {
      mint n_inv = mint(n).inv();
      rep(i, n) f[i] *= n_inv;
    }
  }

public:
  NTT(int _x = 3) : root(_x) {}
  vm convolution(vm &a, vm &b, int size_a = INT_MAX, int size_b = INT_MAX) {
    chmin(size_a, (int)a.size());
    chmin(size_b, (int)b.size());
    int sz = size_a + size_b - 1, n = 1;
    while (sz > n)
      n *= 2;
    vm g(n), h(n), root_pow, gh(n);
    vector<int> id;
    copy(a.begin(), a.begin() + size_a, g.begin());
    copy(b.begin(), b.begin() + size_b, h.begin());
    make_root_pow(n, root_pow);
    make_bit_reverse(n, id);
    dft(n, g, false, root_pow, id);
    dft(n, h, false, root_pow, id);
    rep(i, n) gh[i] = g[i] * h[i];
    dft(n, gh, true, root_pow, id);
    gh.resize(sz);
    return gh;
  }
};

vm polynomial_product(vector<vm> &polys) {
  // time complexity : O(N log^2 N) (N : sum of polys[i].size())
  struct _cmp {
    int sz;
    vm a;
    _cmp(int _sz, vm _a) : sz(_sz), a(_a) {}
    bool operator>(const _cmp &b) { return sz > b.sz; }
  };
  priority_queue<_cmp, vector<_cmp>, greater<>> pque;
  for (vm &a : polys)
    pque.emplace((int)a.size(), a);
  NTT ntt;
  while (pque.size() > 1) {
    _cmp c = pque.top();
    pque.pop();
    _cmp d = pque.top();
    pque.pop();
    vm res = ntt.convolution(c.a, d.a);
    pque.emplace(res.size(), res);
  }
  return pque.top().a;
}

const ll MAX_N = ll(4e+5) + 10;
vm fact(MAX_N, mint(1)), fact_inv(MAX_N, mint(1)), n_inv(MAX_N, mint(1)),
    two_inv(MAX_N, mint(1));
void makefact() {
  two_inv[1] = mint(2).inv();
  reps(i, 2, MAX_N) {
    fact[i] = fact[i - 1] * mint(i);
    n_inv[i] = mint(i).inv();
    fact_inv[i] = fact_inv[i - 1] * n_inv[i];
    two_inv[i] = two_inv[i - 1] * two_inv[1];
  }
}
mint nCm(ll n, ll m) { return fact[n] * fact_inv[n - m] * fact_inv[m]; }
mint nCm_inv(ll n, ll m) { return fact[n - m] * fact[m] * fact_inv[n]; }

int main() {
  makefact();
  cin >> N;
  vec h(N * 2), num(100000, 0);
  rep(i, N * 2) {
    cin >> h[i];
    --h[i];
    ++num[h[i]];
  }
  vector<vm> polys(0);
  rep(i, 100000) {
    int k = 1;
    vm temp(1, 1);
    while (num[i] >= k * 2) {
      temp.push_back(fact[num[i]] * fact_inv[k] * fact_inv[num[i] - k * 2] *
                     two_inv[k]);
      ++k;
    }
    if (temp.size() != 1)
      polys.push_back(temp);
  }
  vm polv = polynomial_product(polys);
  mint res = fact[N * 2] * two_inv[N] * fact_inv[N];
  reps(k, 1, (int)polv.size()) {
    res += mint(k & 1 ? -1 : 1) * polv[k] * fact[(N - k) * 2] * two_inv[N - k] *
           fact_inv[N - k];
  }
  cout << res << endl;
}