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

#include <bits/stdc++.h>
using namespace std;

using i64 = int64_t;

#define rep(i, x, y)                                                           \\
  for (i64 i = i64(x), i##_max_for_repmacro = i64(y);                          \\
       i < i##_max_for_repmacro; ++i)
#define debug(x) #x << "=" << (x)

#ifdef DEBUG
#define _GLIBCXX_DEBUG
#define print(x) std::cerr << debug(x) << " (L:" << __LINE__ << ")" << std::endl
#else
#define print(x)
#endif

template <i64 p> class fp {
public:
  i64 x;
  fp() : x(0) {}
  fp(i64 x_) : x((x_ % p + p) % p) {}
  fp operator+() const { return fp(x); }
  fp operator-() const { return fp(-x); }
  fp &operator+=(const fp &y) {
    x += y.x;
    if (x >= p)
      x -= p;
    return *this;
  }
  fp &operator-=(const fp &y) { return *this += -y; }
  fp &operator*=(const fp &y) {
    x = x * y.x % p;
    return *this;
  }
  fp &operator/=(const fp &y) { return *this *= fp(inverse(y.x)); }
  fp operator+(const fp &y) const { return fp(x) += y; }
  fp operator-(const fp &y) const { return fp(x) -= y; }
  fp operator*(const fp &y) const { return fp(x) *= y; }
  fp operator/(const fp &y) const { return fp(x) /= y; }
  bool operator==(const fp &y) const { return x == y.x; }
  bool operator!=(const fp &y) const { return !(*this == y); }
  i64 extgcd(i64 a, i64 b, i64 &x, i64 &y) {
    i64 d = a;
    if (b != 0) {
      d = extgcd(b, a % b, y, x);
      y -= (a / b) * x;
    } else {
      x = 1;
      y = 0;
    }
    return d;
  }
  i64 inverse(i64 a) {
    i64 x, y;
    extgcd(a, p, x, y);
    return (x % p + p) % p;
  }
};

template <i64 p> i64 abs(const fp<p> &x) { return x.x; }

template <i64 p> istream &operator>>(istream &is, fp<p> &x) {
  is >> x.x;
  return is;
}

template <i64 p> ostream &operator<<(ostream &os, const fp<p> &x) {
  os << x.x;
  return os;
}

template <typename T, typename U>
ostream &operator<<(ostream &os, const pair<T, U> &p) {
  os << "(" << p.first << ", " << p.second << ")";
  return os;
}

template <typename T> ostream &operator<<(ostream &os, const vector<T> &vec) {
  os << "[";
  for (const auto &v : vec) {
    os << v << ",";
  }
  os << "]";
  return os;
}

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

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

template <typename A, typename T, size_t size>
void fill(A (&ary)[size], const T &val) {
  fill((T *)ary, (T *)(ary + size), val);
}

constexpr int inf = 1.01e9;
constexpr i64 inf64 = 4.01e18;
constexpr long double eps = 1e-9;

// double(64bit浮動小数)のn分探索のループ回数の上限(2分探索なら50でも十分かもしれない).
// long double(80ビットの x87 浮動小数点型?)だと,
// 2分探索であってもこれだと足りないケースがある気がするので,
// もうちょっと余裕を持たせた方が良さそう.
constexpr i64 max_loop = 100;

void solve() {
  // constexpr i64 mod = 1'000'000'007;
  i64 N, M;
  cin >> N >> M;

  vector<pair<i64, i64>> ans;
  if (N % 2 == 1) {
    for (i64 l = 0, r = N - 1; l < r; ++l, --r) {
      ans.emplace_back(l, r);
    }
  } else {
    bool f = true;
    for (i64 l = 0, r = N - 1; l < r; ++l, --r) {
      if (f and r - l <= N / 2) {
        f = false;
        --r;
      }
      ans.emplace_back(l, r);
    }
  }

  rep(i, 0, M) { cout << ans[i].first + 1 << " " << ans[i].second + 1 << endl; }
}

int main() {
  std::cin.tie(0);
  std::ios::sync_with_stdio(false);
  cout.setf(ios::fixed);
  cout.precision(16);
  solve();
  return 0;
}


Error: WA

Fixed submission:

#include <bits/stdc++.h>
using namespace std;

using i64 = int64_t;

#define rep(i, x, y)                                                           \\
  for (i64 i = i64(x), i##_max_for_repmacro = i64(y);                          \\
       i < i##_max_for_repmacro; ++i)
#define debug(x) #x << "=" << (x)

#ifdef DEBUG
#define _GLIBCXX_DEBUG
#define print(x) std::cerr << debug(x) << " (L:" << __LINE__ << ")" << std::endl
#else
#define print(x)
#endif

template <i64 p> class fp {
public:
  i64 x;
  fp() : x(0) {}
  fp(i64 x_) : x((x_ % p + p) % p) {}
  fp operator+() const { return fp(x); }
  fp operator-() const { return fp(-x); }
  fp &operator+=(const fp &y) {
    x += y.x;
    if (x >= p)
      x -= p;
    return *this;
  }
  fp &operator-=(const fp &y) { return *this += -y; }
  fp &operator*=(const fp &y) {
    x = x * y.x % p;
    return *this;
  }
  fp &operator/=(const fp &y) { return *this *= fp(inverse(y.x)); }
  fp operator+(const fp &y) const { return fp(x) += y; }
  fp operator-(const fp &y) const { return fp(x) -= y; }
  fp operator*(const fp &y) const { return fp(x) *= y; }
  fp operator/(const fp &y) const { return fp(x) /= y; }
  bool operator==(const fp &y) const { return x == y.x; }
  bool operator!=(const fp &y) const { return !(*this == y); }
  i64 extgcd(i64 a, i64 b, i64 &x, i64 &y) {
    i64 d = a;
    if (b != 0) {
      d = extgcd(b, a % b, y, x);
      y -= (a / b) * x;
    } else {
      x = 1;
      y = 0;
    }
    return d;
  }
  i64 inverse(i64 a) {
    i64 x, y;
    extgcd(a, p, x, y);
    return (x % p + p) % p;
  }
};

template <i64 p> i64 abs(const fp<p> &x) { return x.x; }

template <i64 p> istream &operator>>(istream &is, fp<p> &x) {
  is >> x.x;
  return is;
}

template <i64 p> ostream &operator<<(ostream &os, const fp<p> &x) {
  os << x.x;
  return os;
}

template <typename T, typename U>
ostream &operator<<(ostream &os, const pair<T, U> &p) {
  os << "(" << p.first << ", " << p.second << ")";
  return os;
}

template <typename T> ostream &operator<<(ostream &os, const vector<T> &vec) {
  os << "[";
  for (const auto &v : vec) {
    os << v << ",";
  }
  os << "]";
  return os;
}

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

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

template <typename A, typename T, size_t size>
void fill(A (&ary)[size], const T &val) {
  fill((T *)ary, (T *)(ary + size), val);
}

constexpr int inf = 1.01e9;
constexpr i64 inf64 = 4.01e18;
constexpr long double eps = 1e-9;

// double(64bit浮動小数)のn分探索のループ回数の上限(2分探索なら50でも十分かもしれない).
// long double(80ビットの x87 浮動小数点型?)だと,
// 2分探索であってもこれだと足りないケースがある気がするので,
// もうちょっと余裕を持たせた方が良さそう.
constexpr i64 max_loop = 100;

void solve() {
  // constexpr i64 mod = 1'000'000'007;
  i64 N, M;
  cin >> N >> M;

  vector<pair<i64, i64>> ans;
  vector<bool> used(N);
  i64 diff = 1, i = 0;
  while (ans.size() < M) {
    while (used[i] or used[(i + diff) % N]) {
      ++i;
      assert(i < N);
    }

    ans.emplace_back(i, (i + diff) % N);
    used[i] = used[(i + diff) % N] = true;
    ++diff;
  }

  rep(i, 0, M) { cout << ans[i].first + 1 << " " << ans[i].second + 1 << endl; }
}

int main() {
  std::cin.tie(0);
  std::ios::sync_with_stdio(false);
  cout.setf(ios::fixed);
  cout.precision(16);
  solve();
  return 0;
}