結果
| 問題 |
No.2797 Square Tile
|
| コンテスト | |
| ユーザー |
 zer0-star
|
| 提出日時 | 2024-06-28 22:04:18 |
| 言語 | C++23 (gcc 13.3.0 + boost 1.87.0) |
| 結果 |
AC
|
| 実行時間 | 79 ms / 2,000 ms |
| コード長 | 9,902 bytes |
| コンパイル時間 | 4,836 ms |
| コンパイル使用メモリ | 355,916 KB |
| 実行使用メモリ | 5,376 KB |
| 最終ジャッジ日時 | 2024-06-28 22:04:53 |
| 合計ジャッジ時間 | 6,659 ms |
|
ジャッジサーバーID （参考情報） |
judge4 / judge1 |
（要ログイン）
| ファイルパターン | 結果 |
|---|---|
| sample | AC * 2 |
| other | AC * 21 |
ソースコード
#if __has_include("all.hpp")
#include "all.hpp"
#else
#include <bits/extc++.h>
// #include <atcoder/all>
#endif
using ll = long long int;
template <class T>
bool chmin(T &x, const T val) {
if (x > val) {
x = val;
return true;
} else {
return false;
}
}
template <class T>
bool chmax(T &x, const T val) {
if (x < val) {
x = val;
return true;
} else {
return false;
}
}
template <class T, class U>
std::istream &operator>>(std::istream &is, std::pair<T, U> &p) {
return is >> p.first >> p.second;
}
template <class... T>
std::istream &operator>>(std::istream &is, std::tuple<T...> &tpl) {
std::apply([&](auto &&...args) { (is >> ... >> args); }, tpl);
return is;
}
// template <class mint, atcoder::internal::is_static_modint_t<mint> * =
// nullptr> std::ostream &operator<<(std::ostream &os, const mint &v) {
// return os << v.val();
// }
//
// template <class mint, atcoder::internal::is_static_modint_t<mint> * =
// nullptr> std::istream &operator>>(std::istream &is, mint &v) {
// int tmp;
// is >> tmp;
// v = tmp;
// return is;
// }
template <class T>
std::istream &operator>>(std::istream &is, std::vector<T> &v) {
for (T &x : v) is >> x;
return is;
}
template <class T>
std::ostream &operator<<(std::ostream &os, const std::vector<T> &v) {
for (int i = 0; i < v.size(); i++)
os << v[i] << (i == v.size() - 1 ? "" : " ");
return os;
}
struct Initialization {
Initialization() {
std::ios_base::sync_with_stdio(false);
std::cin.tie(nullptr);
}
} initialization;
constexpr std::pair<int, int> dir[] = {{0, 1}, {1, 0}, {0, -1}, {-1, 0}};
template <typename T>
using infs = std::numeric_limits<T>;
template <typename T>
class factorials {
public:
static size_t n;
static std::vector<T> fact, inv_fact;
static void extend(size_t m) {
if (m <= n) return;
fact.resize(m + 1);
inv_fact.resize(m + 1);
for (size_t i = n + 1; i <= m; i++) fact[i] = fact[i - 1] * i;
inv_fact[m] = fact[m].inv();
for (size_t i = m; i > n + 1; i--) inv_fact[i - 1] = inv_fact[i] * i;
n = m;
}
static T inv(int k) {
extend(k);
return inv_fact[k];
}
static T get(int k) {
extend(k);
return fact[k];
}
static T perm(int n, int k) {
if (n < k) return 0;
if (k < 0) return 0;
extend(n);
return fact[n] * inv_fact[n - k];
}
static T choose(int n, int k) {
if (n < k) return 0;
if (k < 0) return 0;
extend(n);
return fact[n] * inv_fact[n - k] * inv_fact[k];
}
};
template <typename T>
size_t factorials<T>::n = 0;
template <typename T>
std::vector<T> factorials<T>::fact = {1};
template <typename T>
std::vector<T> factorials<T>::inv_fact = {1};
// template <typename T>
// class fps {
// std::vector<T> v;
//
// public:
// using value_type = T;
// using reference = T &;
// using const_reference = const T &;
// using iterator = typename std::vector<T>::iterator;
// using const_iterator = typename std::vector<T>::const_iterator;
//
// size_t size() const { return v.size(); }
//
// const std::vector<T> &data() const { return v; }
//
// explicit fps(int n) : v(n) {}
//
// fps(const std::vector<T> &v) : v(v) {}
// fps(std::vector<T> &&v) : v(v) {}
//
// template <class InputIterator>
// fps(InputIterator first, InputIterator last) : v(first, last) {}
//
// fps(std::initializer_list<T> init) : v(init) {}
//
// void resize(int n) { v.resize(n); }
//
// T &operator[](int i) { return v[i]; }
//
// iterator begin() { return v.begin(); }
//
// iterator end() { return v.end(); }
//
// fps take(int n) const {
// return fps(v.begin(), v.begin() + std::min(n, (int)v.size()));
// }
//
// fps diff() const {
// std::vector<T> res(v.size() - 1);
// for (int i = 0; i < res.size(); i++) res[i] = v[i + 1] * (i + 1);
// return fps(res);
// }
//
// fps integral() const {
// std::vector<T> res(v.size() + 1);
// for (int i = 0; i < v.size(); i++) res[i + 1] = v[i] / (i + 1);
// return fps(res);
// }
//
// fps inv(int deg = -1) const {
// assert(v[0] != 0);
//
// if (deg == -1) deg = size();
// std::vector<T> res(deg);
//
// res[0] = v[0].inv();
//
// T inv4 = T(4).inv(), invd = inv4;
//
// for (int d = 1; d < deg; d <<= 1) {
// std::vector<T> f(2 * d), g(2 * d);
//
// std::copy(v.begin(), v.begin() + std::min(2 * d, (int)v.size()),
// f.begin());
// std::copy(res.begin(), res.begin() + d, g.begin());
//
// atcoder::internal::butterfly(f);
// atcoder::internal::butterfly(g);
//
// for (int i = 0; i < 2 * d; i++) f[i] *= g[i];
//
// atcoder::internal::butterfly_inv(f);
//
// for (int i = 0; i < d; i++) f[i] = 0;
//
// atcoder::internal::butterfly(f);
//
// for (int i = 0; i < 2 * d; i++) f[i] *= g[i];
//
// atcoder::internal::butterfly_inv(f);
//
// for (int i = d; i < std::min(2 * d, deg); i++) res[i] = -f[i] * invd;
//
// invd *= inv4;
// }
//
// return res;
// }
//
// fps shift(T c) const {
// std::vector<T> res(size()), ifacts(size());
//
// T x = 1;
//
// for (int i = 0; i < size(); i++) {
// ifacts[i] = x * factorials<T>::inv(i);
// x *= c;
// }
//
// for (int i = 0; i < size(); i++) {
// res[size() - 1 - i] = v[i] * factorials<T>::get(i);
// }
//
// res = atcoder::convolution(res, ifacts);
//
// res.resize(size());
//
// std::ranges::reverse(res);
//
// for (int i = 0; i < size(); i++) {
// res[i] *= factorials<T>::inv(i);
// }
//
// return res;
// }
//
// fps operator-() const {
// fps res(v.size());
// for (int i = 0; i < v.size(); i++) res[i] = -v[i];
// return res;
// }
//
// fps &operator+=(const fps &rhs) {
// if (v.size() < rhs.v.size()) v.resize(rhs.v.size());
// for (int i = 0; i < rhs.v.size(); i++) v[i] += rhs.v[i];
// return *this;
// }
//
// fps &operator-=(const fps &rhs) {
// if (v.size() < rhs.v.size()) v.resize(rhs.v.size());
// for (int i = 0; i < rhs.v.size(); i++) v[i] -= rhs.v[i];
// return *this;
// }
//
// fps &operator*=(const fps &rhs) {
// return *this = atcoder::convolution(v, rhs.v);
// }
//
// fps &operator/=(const fps &rhs) { return *this *= rhs.inv(); }
//
// fps &operator+=(const T &rhs) {
// if (v.size() == 0) v.resize(1);
// v[0] += rhs;
// return *this;
// }
//
// fps &operator-=(const T &rhs) {
// if (v.size() == 0) v.resize(1);
// v[0] -= rhs;
// return *this;
// }
//
// fps &operator*=(const T &rhs) {
// for (int i = 0; i < v.size(); i++) v[i] *= rhs;
// return *this;
// }
//
// fps &operator/=(const T &rhs) {
// T rhs_inv = rhs.inv();
// for (int i = 0; i < v.size(); i++) v[i] *= rhs_inv;
// return *this;
// }
//
// friend fps operator+(const fps &lhs, const fps &rhs) {
// return fps(lhs) += rhs;
// }
//
// friend fps operator-(const fps &lhs, const fps &rhs) {
// return fps(lhs) -= rhs;
// }
//
// friend fps operator*(const fps &lhs, const fps &rhs) {
// return fps(lhs) *= rhs;
// }
//
// friend fps operator/(const fps &lhs, const fps &rhs) {
// return fps(lhs) /= rhs;
// }
//
// friend fps operator+(const fps &lhs, const T &rhs) { return fps(lhs) +=
// rhs; }
//
// friend fps operator-(const fps &lhs, const T &rhs) { return fps(lhs) -=
// rhs; }
//
// friend fps operator*(const fps &lhs, const T &rhs) { return fps(lhs) *=
// rhs; }
//
// friend fps operator/(const fps &lhs, const T &rhs) { return fps(lhs) /=
// rhs; }
//
// friend fps operator+(const T &lhs, const fps &rhs) { return fps(rhs) +=
// lhs; }
//
// friend fps operator-(const T &lhs, const fps &rhs) {
// return -(fps(rhs) -= lhs);
// }
//
// friend fps operator*(const T &lhs, const fps &rhs) { return fps(rhs) *=
// lhs; }
// };
//
// template <typename T>
// T bostan_mori(int n, fps<T> P, fps<T> Q) {
// assert(P.size() < Q.size());
//
// P.resize(Q.size() - 1);
//
// while (n) {
// fps qm = Q;
// for (int i = 1; i < Q.size(); i += 2) qm[i] = -qm[i];
//
// fps U = P * qm;
// fps V = Q * qm;
//
// for (int i = n & 1; i < U.size(); i += 2) P[i / 2] = U[i];
// for (int i = 0; i < V.size(); i += 2) Q[i / 2] = V[i];
//
// n /= 2;
// }
//
// return P[0] / Q[0];
// }
// using mint = atcoder::modint998244353;
// using mint = atcoder::modint1000000007;
// using fs = factorials<mint>;
int main() {
int A, B;
std::cin >> A >> B;
int L = A * A + B * B;
auto mod = [&](int x) { return (x % L + L) % L; };
bool swapped = false;
if (A > B) {
std::swap(A, B);
swapped = true;
}
std::set<std::pair<int, int>> as, bs;
std::queue<std::pair<int, int>> qa, qb;
qb.emplace(0, 0);
bs.emplace(0, 0);
while (as.size() < L || bs.size() < L) {
while (!qa.empty()) {
auto [x, y] = qa.front();
qa.pop();
std::pair<int, int> next[] = {
{x + A, y}, {x + A - B, y + A}, {x - B, y + A - B}, {x, y - B}};
for (auto [nx, ny] : next) {
nx = mod(nx);
ny = mod(ny);
if (!bs.contains({nx, ny})) {
bs.emplace(nx, ny);
qb.emplace(nx, ny);
}
}
}
while (!qb.empty()) {
auto [x, y] = qb.front();
qb.pop();
std::pair<int, int> next[] = {
{x + B, y + B - A}, {x, y + B}, {x - A, y}, {x + B - A, y - A}};
for (auto [nx, ny] : next) {
nx = mod(nx);
ny = mod(ny);
if (!as.contains({nx, ny})) {
as.emplace(nx, ny);
qa.emplace(nx, ny);
}
}
}
}
if (swapped) {
std::swap(as, bs);
}
for (auto [x, y] : as) {
std::cout << x << " " << y << std::endl;
}
for (auto [x, y] : bs) {
std::cout << x << " " << y << std::endl;
}
}