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

#include <algorithm>
#include <array>
#include <bitset>
#include <cassert>
#include <cmath>
#include <complex>
#include <cstdint>
#include <deque>
#include <fstream>
#include <functional>
#include <iomanip>
#include <iostream>
#include <list>
#include <map>
#include <numeric>
#include <queue>
#include <regex>
#include <set>
#include <stack>
#include <string>
#include <tuple>
#include <unordered_map>
#include <unordered_set>
#include <utility>
#include <vector>

using namespace std;
using ll = long long;
using ull = unsigned long long;

namespace utils {
#define ALL(x) begin(x), end(x)
#define RALL(x) rbegin(x), rend(x)
template <class T, class Compare>
using p_queue = priority_queue<T, vector<T>, Compare>;
template <class T> using min_queue = p_queue<T, greater<T>>;
template <class T> using max_queue = p_queue<T, less<T>>;

template <class T> inline bool UPMIN(T &X, const T &A) {
  if (X > A) {
    X = A;
    return true;
  }
  return false;
}
template <class T> inline bool UPMAX(T &X, const T &A) {
  if (X < A) {
    X = A;
    return true;
  }
  return false;
}

template <class T> vector<T> VEC(int n, T t) { return vector<T>(n, t); }
template <class... Ts> auto VEC(int n, Ts... ts) {
  return vector<decltype(VEC(ts...))>(n, VEC(ts...));
}

template <class S, class T> istream &operator>>(istream &is, tuple<S, T> &t) {
  return is >> get<0>(t) >> get<1>(t);
}

template <class S, class T, class U>
istream &operator>>(istream &is, tuple<S, T, U> &t) {
  return is >> get<0>(t) >> get<1>(t) >> get<2>(t);
}

template <class S, class T>
ostream &operator<<(ostream &os, const tuple<S, T> &t) {
  return os << get<0>(t) << ' ' << get<1>(t);
}

template <class S, class T, class U>
ostream &operator<<(ostream &os, const tuple<S, T, U> &t) {
  return os << get<0>(t) << ' ' << get<1>(t) << ' ' << get<2>(t);
}

template <class T> istream &operator>>(istream &is, vector<T> &v) {
  for (auto &&x : v) {
    is >> x;
  }
  return is;
}

template <class T> ostream &operator<<(ostream &os, const vector<T> &v) {
  auto p = v.begin();
  assert(p != v.end());
  os << *p++;
  while (p != v.end()) {
    os << ' ' << *p++;
  }
  return os;
}

template <class T>
ostream &operator<<(ostream &os, const vector<vector<T>> &v) {
  auto p = v.begin();
  assert(p != v.end());
  os << *p++;
  while (p != v.end()) {
    os << '\\n' << *p++;
  }
  return os;
}

template <class... Ts>
ostream &operator<<(ostream &os, const vector<tuple<Ts...>> &v) {
  auto p = v.begin();
  assert(p != v.end());
  os << *p++;
  while (p != v.end()) {
    os << '\\n' << *p++;
  }
  return os;
}

constexpr long long INFLL = 1'000'000'000'000'000'000ll;
constexpr int INF = 1'000'000'000;
constexpr double PI = 3.14'159'265'358'973;
constexpr double EPS = 1e-10;
} // namespace utils
using namespace utils;

namespace xelm_ModInt {
class ModInt {
  static constexpr ll NIL = -1;
  static constexpr int64_t MOD = 1'000'000'007;
  //        static constexpr int64_t MOD = 998'244'353;

  ll val;

public:
  ModInt(ll x) : val(x >= 0 ? x % MOD : MOD - (-x) % MOD) {}
  ModInt(signed x) : val(x >= 0 ? x % MOD : MOD - (-x) % MOD) {}
  ModInt(ull x) : val(x % MOD) {}
  ModInt(unsigned x) : val(x % MOD) {}
  ModInt() : val{NIL} {}

  bool is_nil() { return val == NIL; }

  ModInt pow(ll n) const {
    ll r = 1, a = val;
    while (n) {
      if (n & 1) {
        r *= a;
        r %= MOD;
      }
      a *= a;
      a %= MOD;
      n /= 2;
    }
    return {r};
  }
  ModInt inv() const { /* return Inverse */
    assert(val != 0);
    return this->pow(MOD - 2);
  }

  void operator+=(const ModInt &a) {
    val += a.val;
    if (val >= MOD)
      val -= MOD;
  }
  void operator-=(const ModInt &a) {
    val -= a.val;
    if (val < 0)
      val += MOD;
  }
  void operator*=(const ModInt &a) {
    val *= a.val;
    val %= MOD;
  }
  void operator/=(const ModInt &a) {
    val *= a.inv().val;
    val %= MOD;
  }

  ModInt operator+(const ModInt &x) const {
    ll v = val + x.val;
    return {v};
  }
  ModInt operator-(const ModInt &x) const {
    ll v = val - x.val;
    return {v};
  }
  ModInt operator*(const ModInt &x) const {
    ll v = val * x.val;
    return {v};
  }
  ModInt operator/(const ModInt &x) const {
    ll v = val * x.inv().val;
    return {v};
  }

  bool operator==(const ModInt &x) const { return x.val == val; }
  bool operator!=(const ModInt &x) const { return x.val != val; }

  friend istream &operator>>(istream &is, ModInt &r) {
    ll tmp;
    is >> tmp;
    r = tmp;
    return is;
  }
  friend ostream &operator<<(ostream &os, const ModInt &r) {
    return os << r.val;
  }
};

ModInt fact(ll N) {
  /* N -> N! */
  static vector<ModInt> cal(1, ModInt{1});
  assert(N >= 0);

  if (cal.size() > N)
    return cal[N];
  else {
    ModInt nm = fact(N - 1);
    assert(cal.size() == N);
    cal.push_back(nm * N);
    return cal.back();
  }
}

/* N, k -> N C k */
ModInt choose(ll N, ll k) {
  // N! / k!(N-k!)
  ModInt ans = fact(N) / (fact(k) * fact(N - k));
  return ans;
}

ModInt operator"" _mod(unsigned long long x) { return ModInt{x}; }
} // namespace xelm_ModInt
using namespace xelm_ModInt;

ll gcd(ll a, ll b) {
  if (b == 0)
    return a;
  return gcd(b, a % b);
}

class solver {
  istream &is;
  ostream &os;

public:
  solver(istream &I, ostream &O) : is(I), os(O) {}

  int N;
  vector<tuple<ll, ll>> AB;
  bool input() {
    is >> N;
    AB.resize(N);
    is >> AB;
    return !!is;
  }

  void run();
};

int main(int argc, char *argv[]) {
  cin.tie(nullptr);
  ios::sync_with_stdio(false);
  cout << setprecision(16) << scientific;
#ifdef XELMH
  string test_cases = "test_E.txt";
  cerr << test_cases << " -->" << endl;
  auto fs = fstream(test_cases, fstream::in);
  int loop = 0;
  while (fs) {
    loop++;
    cout << '#' << loop << "#------\\n";
    solver(fs, cout).run();
  }
  if (loop <= 1) {
    cout << "===" << endl;
    while (cin)
      solver(cin, cout).run();
  }
#else
  solver(cin, cout).run();
#endif
  return 0;
}

void solver::run() {
  if (!input())
    return;
  map<tuple<ll, ll>, int> nm;
  ll zerozero = 0;
  for (auto &&ab : AB) {
    ll a, b;
    tie(a, b) = ab;
    if (b < 0) {
      a *= -1;
      b *= -1;
    }
    if (a == 0 or b == 0) {
      if (a == 0 and b == 0) {
        zerozero++;
        continue;
      }
      if (a == 0) {
        nm[{0, 1}]++;
        nm[{-1, 0}];
        continue;
      }
      if (b == 0) {
        nm[{-1, 0}]++;
        nm[{0, 1}];
        continue;
      }
    }
    ll g = gcd(abs(a), abs(b));
    ab = {a / g, b / g};
    nm[{-a / g, b / g}];
    nm[ab]++;
  } // end ab

  vector<ModInt> dp(2, 0);
  dp[0] = 1;
  for (auto x : nm) {
    if (x.first == make_tuple(0, 0)) {
      continue;
    }
    if (x.second == 0)
      continue;
    vector<ModInt> dp2(2, 1);
    auto y = x.first;
    y = {get<1>(y), get<0>(y)};
    if (get<1>(y) < 0) {
      get<1>(y) *= -1;
    } else
      get<0>(y) *= -1;

    dp2[1] *= (dp[1] + dp[0]) * ((2_mod).pow(x.second) - 1);
    dp2[0] *= (dp[1] + dp[0]) * ((2_mod).pow(nm[y]));
    nm[y] = 0;
    x.second = 0;
    dp = dp2;
  } // end x
  dp[0] = dp[0] - 1;
  auto ans = (dp[0] + dp[1]) + zerozero;
  cout << ans << endl;
}


Error: 0

Fixed submission:

#include <algorithm>
#include <array>
#include <bitset>
#include <cassert>
#include <cmath>
#include <complex>
#include <cstdint>
#include <deque>
#include <fstream>
#include <functional>
#include <iomanip>
#include <iostream>
#include <list>
#include <map>
#include <numeric>
#include <queue>
#include <regex>
#include <set>
#include <stack>
#include <string>
#include <tuple>
#include <unordered_map>
#include <unordered_set>
#include <utility>
#include <vector>

using namespace std;
using ll = long long;
using ull = unsigned long long;

namespace utils {
#define ALL(x) begin(x), end(x)
#define RALL(x) rbegin(x), rend(x)
template <class T, class Compare>
using p_queue = priority_queue<T, vector<T>, Compare>;
template <class T> using min_queue = p_queue<T, greater<T>>;
template <class T> using max_queue = p_queue<T, less<T>>;

template <class T> inline bool UPMIN(T &X, const T &A) {
  if (X > A) {
    X = A;
    return true;
  }
  return false;
}
template <class T> inline bool UPMAX(T &X, const T &A) {
  if (X < A) {
    X = A;
    return true;
  }
  return false;
}

template <class T> vector<T> VEC(int n, T t) { return vector<T>(n, t); }
template <class... Ts> auto VEC(int n, Ts... ts) {
  return vector<decltype(VEC(ts...))>(n, VEC(ts...));
}

template <class S, class T> istream &operator>>(istream &is, tuple<S, T> &t) {
  return is >> get<0>(t) >> get<1>(t);
}

template <class S, class T, class U>
istream &operator>>(istream &is, tuple<S, T, U> &t) {
  return is >> get<0>(t) >> get<1>(t) >> get<2>(t);
}

template <class S, class T>
ostream &operator<<(ostream &os, const tuple<S, T> &t) {
  return os << get<0>(t) << ' ' << get<1>(t);
}

template <class S, class T, class U>
ostream &operator<<(ostream &os, const tuple<S, T, U> &t) {
  return os << get<0>(t) << ' ' << get<1>(t) << ' ' << get<2>(t);
}

template <class T> istream &operator>>(istream &is, vector<T> &v) {
  for (auto &&x : v) {
    is >> x;
  }
  return is;
}

template <class T> ostream &operator<<(ostream &os, const vector<T> &v) {
  auto p = v.begin();
  assert(p != v.end());
  os << *p++;
  while (p != v.end()) {
    os << ' ' << *p++;
  }
  return os;
}

template <class T>
ostream &operator<<(ostream &os, const vector<vector<T>> &v) {
  auto p = v.begin();
  assert(p != v.end());
  os << *p++;
  while (p != v.end()) {
    os << '\\n' << *p++;
  }
  return os;
}

template <class... Ts>
ostream &operator<<(ostream &os, const vector<tuple<Ts...>> &v) {
  auto p = v.begin();
  assert(p != v.end());
  os << *p++;
  while (p != v.end()) {
    os << '\\n' << *p++;
  }
  return os;
}

constexpr long long INFLL = 1'000'000'000'000'000'000ll;
constexpr int INF = 1'000'000'000;
constexpr double PI = 3.14'159'265'358'973;
constexpr double EPS = 1e-10;
} // namespace utils
using namespace utils;

namespace xelm_ModInt {
class ModInt {
  static constexpr ll NIL = -1;
  static constexpr int64_t MOD = 1'000'000'007;
  //        static constexpr int64_t MOD = 998'244'353;

  ll val;

public:
  ModInt(ll x) : val(x >= 0 ? x % MOD : MOD - (-x) % MOD) {}
  ModInt(signed x) : val(x >= 0 ? x % MOD : MOD - (-x) % MOD) {}
  ModInt(ull x) : val(x % MOD) {}
  ModInt(unsigned x) : val(x % MOD) {}
  ModInt() : val{NIL} {}

  bool is_nil() { return val == NIL; }

  ModInt pow(ll n) const {
    ll r = 1, a = val;
    while (n) {
      if (n & 1) {
        r *= a;
        r %= MOD;
      }
      a *= a;
      a %= MOD;
      n /= 2;
    }
    return {r};
  }
  ModInt inv() const { /* return Inverse */
    assert(val != 0);
    return this->pow(MOD - 2);
  }

  void operator+=(const ModInt &a) {
    val += a.val;
    if (val >= MOD)
      val -= MOD;
  }
  void operator-=(const ModInt &a) {
    val -= a.val;
    if (val < 0)
      val += MOD;
  }
  void operator*=(const ModInt &a) {
    val *= a.val;
    val %= MOD;
  }
  void operator/=(const ModInt &a) {
    val *= a.inv().val;
    val %= MOD;
  }

  ModInt operator+(const ModInt &x) const {
    ll v = val + x.val;
    return {v};
  }
  ModInt operator-(const ModInt &x) const {
    ll v = val - x.val;
    return {v};
  }
  ModInt operator*(const ModInt &x) const {
    ll v = val * x.val;
    return {v};
  }
  ModInt operator/(const ModInt &x) const {
    ll v = val * x.inv().val;
    return {v};
  }

  bool operator==(const ModInt &x) const { return x.val == val; }
  bool operator!=(const ModInt &x) const { return x.val != val; }

  friend istream &operator>>(istream &is, ModInt &r) {
    ll tmp;
    is >> tmp;
    r = tmp;
    return is;
  }
  friend ostream &operator<<(ostream &os, const ModInt &r) {
    return os << r.val;
  }
};

ModInt fact(ll N) {
  /* N -> N! */
  static vector<ModInt> cal(1, ModInt{1});
  assert(N >= 0);

  if (cal.size() > N)
    return cal[N];
  else {
    ModInt nm = fact(N - 1);
    assert(cal.size() == N);
    cal.push_back(nm * N);
    return cal.back();
  }
}

/* N, k -> N C k */
ModInt choose(ll N, ll k) {
  // N! / k!(N-k!)
  ModInt ans = fact(N) / (fact(k) * fact(N - k));
  return ans;
}

ModInt operator"" _mod(unsigned long long x) { return ModInt{x}; }
} // namespace xelm_ModInt
using namespace xelm_ModInt;

ll gcd(ll a, ll b) {
  if (b == 0)
    return a;
  return gcd(b, a % b);
}

class solver {
  istream &is;
  ostream &os;

public:
  solver(istream &I, ostream &O) : is(I), os(O) {}

  int N;
  vector<tuple<ll, ll>> AB;
  bool input() {
    is >> N;
    AB.resize(N);
    is >> AB;
    return !!is;
  }

  void run();
};

int main(int argc, char *argv[]) {
  cin.tie(nullptr);
  ios::sync_with_stdio(false);
  cout << setprecision(16) << scientific;
#ifdef XELMH
  string test_cases = "test_E.txt";
  cerr << test_cases << " -->" << endl;
  auto fs = fstream(test_cases, fstream::in);
  int loop = 0;
  while (fs) {
    loop++;
    cout << '#' << loop << "#------\\n";
    solver(fs, cout).run();
  }
  if (loop <= 1) {
    cout << "===" << endl;
    while (cin)
      solver(cin, cout).run();
  }
#else
  solver(cin, cout).run();
#endif
  return 0;
}

void solver::run() {
  if (!input())
    return;
  map<tuple<ll, ll>, int> nm;
  ll zerozero = 0;
  for (auto &&ab : AB) {
    ll a, b;
    tie(a, b) = ab;
    if (b < 0) {
      a *= -1;
      b *= -1;
    }
    if (a == 0 or b == 0) {
      if (a == b == 0) {
        zerozero++;
        continue;
      }
    }
    ll g = gcd(abs(a), abs(b));
    ab = {a / g, b / g};
    nm[{-a / g, b / g}];
    nm[ab]++;
  } // end ab

  vector<ModInt> dp(2, 0);
  dp[0] = 1;
  for (auto x : nm) {
    if (x.first == make_tuple(0, 0)) {
      continue;
    }
    if (x.second == 0)
      continue;
    vector<ModInt> dp2(2, 1);
    auto y = x.first;
    y = {get<1>(y), get<0>(y)};
    if (get<1>(y) < 0) {
      get<1>(y) *= -1;
    } else
      get<0>(y) *= -1;

    dp2[1] *= (dp[1] + dp[0]) * ((2_mod).pow(x.second) - 1);
    dp2[0] *= (dp[1] + dp[0]) * ((2_mod).pow(nm[y]));
    nm[y] = 0;
    x.second = 0;
    dp = dp2;
  } // end x
  dp[0] = dp[0] - 1;
  auto ans = (dp[0] + dp[1]) + zerozero;
  cout << ans << endl;
}