結果
問題 | No.40 多項式の割り算 |
ユーザー | not_522 |
提出日時 | 2020-01-03 23:43:52 |
言語 | C++17 (gcc 12.3.0 + boost 1.83.0) |
結果 |
AC
|
実行時間 | 3 ms / 5,000 ms |
コード長 | 25,093 bytes |
コンパイル時間 | 1,502 ms |
コンパイル使用メモリ | 127,500 KB |
実行使用メモリ | 5,248 KB |
最終ジャッジ日時 | 2024-11-22 19:49:09 |
合計ジャッジ時間 | 2,647 ms |
ジャッジサーバーID (参考情報) |
judge5 / judge3 |
(要ログイン)
テストケース
テストケース表示入力 | 結果 | 実行時間 実行使用メモリ |
---|---|---|
testcase_00 | AC | 1 ms
5,248 KB |
testcase_01 | AC | 2 ms
5,248 KB |
testcase_02 | AC | 2 ms
5,248 KB |
testcase_03 | AC | 2 ms
5,248 KB |
testcase_04 | AC | 2 ms
5,248 KB |
testcase_05 | AC | 3 ms
5,248 KB |
testcase_06 | AC | 3 ms
5,248 KB |
testcase_07 | AC | 3 ms
5,248 KB |
testcase_08 | AC | 1 ms
5,248 KB |
testcase_09 | AC | 2 ms
5,248 KB |
testcase_10 | AC | 2 ms
5,248 KB |
testcase_11 | AC | 2 ms
5,248 KB |
testcase_12 | AC | 2 ms
5,248 KB |
testcase_13 | AC | 3 ms
5,248 KB |
testcase_14 | AC | 2 ms
5,248 KB |
testcase_15 | AC | 3 ms
5,248 KB |
testcase_16 | AC | 3 ms
5,248 KB |
testcase_17 | AC | 2 ms
5,248 KB |
testcase_18 | AC | 3 ms
5,248 KB |
testcase_19 | AC | 3 ms
5,248 KB |
testcase_20 | AC | 3 ms
5,248 KB |
testcase_21 | AC | 2 ms
5,248 KB |
testcase_22 | AC | 2 ms
5,248 KB |
testcase_23 | AC | 3 ms
5,248 KB |
testcase_24 | AC | 3 ms
5,248 KB |
testcase_25 | AC | 1 ms
5,248 KB |
testcase_26 | AC | 2 ms
5,248 KB |
testcase_27 | AC | 2 ms
5,248 KB |
testcase_28 | AC | 2 ms
5,248 KB |
testcase_29 | AC | 1 ms
5,248 KB |
testcase_30 | AC | 2 ms
5,248 KB |
testcase_31 | AC | 1 ms
5,248 KB |
testcase_32 | AC | 2 ms
5,248 KB |
testcase_33 | AC | 2 ms
5,248 KB |
testcase_34 | AC | 2 ms
5,248 KB |
ソースコード
/****************/ /* math/fft.hpp */ /****************/ #include <complex> // This is free and unencumbered software released into the public domain. // Anyone is free to copy, modify, publish, use, compile, sell, or // distribute this software, either in source code form or as a compiled // binary, for any purpose, commercial or non-commercial, and by any // means. // In jurisdictions that recognize copyright laws, the author or authors // of this software dedicate any and all copyright interest in the // software to the public domain. We make this dedication for the benefit // of the public at large and to the detriment of our heirs and // successors. We intend this dedication to be an overt act of // relinquishment in perpetuity of all present and future rights to this // software under copyright law. // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, // EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF // MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. // IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR // OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, // ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR // OTHER DEALINGS IN THE SOFTWARE. // For more information, please refer to <http://unlicense.org> /****************/ /* template.hpp */ /****************/ #include <algorithm> #include <cassert> #include <functional> #include <iomanip> #include <iostream> #include <limits> using std::cerr; using std::cout; using std::endl; using std::max; using std::min; using std::swap; struct BoolName : std::numpunct<char> { std::string t, f; BoolName(std::string t, std::string f) : t(t), f(f) {} std::string do_truename() const { return t; } std::string do_falsename() const { return f; } }; void setBoolName(std::string t, std::string f) { cout.imbue(std::locale(cout.getloc(), new BoolName(t, f))); } struct Initializer { Initializer() { cout << std::fixed << std::setprecision(15) << std::boolalpha; setBoolName("Yes", "No"); } } initializer; struct Input { bool eof; Input() : eof(false) {} operator char() { char v; while (!(this->eof = (std::scanf("%c", &v) != 1)) && std::isspace(v)) { } return v; } operator int() { int v; this->eof = (std::scanf("%d", &v) != 1); return v; } operator long() { long v; this->eof = (std::scanf("%ld", &v) != 1); return v; } operator long long() { long long v; this->eof = (std::scanf("%lld", &v) != 1); return v; } operator unsigned int() { unsigned int v; this->eof = (std::scanf("%u", &v) != 1); return v; } operator unsigned long() { unsigned long v; this->eof = (std::scanf("%lu", &v) != 1); return v; } operator unsigned long long() { unsigned long long v; this->eof = (std::scanf("%llu", &v) != 1); return v; } operator double() { double v; this->eof = (std::scanf("%lf", &v) != 1); return v; } operator long double() { long double v; this->eof = (std::scanf("%Lf", &v) != 1); return v; } void ignore() const { getchar(); } } in; template <typename T> T abs(T a) { return a >= 0 ? a : -a; } template <typename T, typename S> bool chmin(T &a, const S &b) { return a > b ? a = b, true : false; } template <typename T, typename S> bool chmax(T &a, const S &b) { return a < b ? a = b, true : false; } template <typename T, typename S> std::function<S(T)> cast() { return [](const T &t) { return static_cast<S>(t); }; } template <typename T> T copy(const T &a) { return T(a); } class ZeroPadding { public: ZeroPadding(int n) : n(n) {} int n; }; std::ostream &operator<<(std::ostream &os, const ZeroPadding &z) { os << std::setw(z.n) << std::setfill('0'); return os; } template <typename T> constexpr T inf() { return std::numeric_limits<T>::max() / 2 - 1; } /*********************/ /* bit_operation.hpp */ /*********************/ template <typename T> int least_bit(T n) { static_assert(sizeof(T) == 4 || sizeof(T) == 8, "unsupported size"); if (sizeof(T) == 4) { return __builtin_ffs(n) - 1; } if (sizeof(T) == 8) { return __builtin_ffsll(n) - 1; } } // n must be greater than 0. template <typename T> int least_bit_fast(T n) { static_assert(sizeof(T) == 4 || sizeof(T) == 8, "unsupported size"); if (sizeof(T) == 4) { return __builtin_ctz(n); } if (sizeof(T) == 8) { return __builtin_ctzll(n); } } template <typename T> int most_bit(T n) { static_assert(sizeof(T) == 4 || sizeof(T) == 8, "unsupported size"); if (sizeof(T) == 4) { return n ? 31 - __builtin_clz(n) : -1; } if (sizeof(T) == 8) { return n ? 63 - __builtin_clzll(n) : -1; } } template <typename T> int count_bit(T n) { static_assert(sizeof(T) == 4 || sizeof(T) == 8, "unsupported size"); if (sizeof(T) == 4) { return __builtin_popcount(n); } if (sizeof(T) == 8) { return __builtin_popcountll(n); } } template <typename T> int bit_parity(T n) { static_assert(sizeof(T) == 4 || sizeof(T) == 8, "unsupported size"); if (sizeof(T) == 4) { return __builtin_parity(n); } if (sizeof(T) == 8) { return __builtin_parityll(n); } } /*************/ /* tuple.hpp */ /*************/ #include <tuple> template <typename... T> class Tuple : public std::tuple<T...> { public: Tuple(Input &in) : std::tuple<T...>() { (void)in; } }; template <typename T, typename... S> class Tuple<T, S...> : public std::tuple<T, S...> { public: Tuple() : std::tuple<T, S...>() {} Tuple(T t, S... s) : std::tuple<T, S...>(t, s...) {} Tuple(const std::tuple<T, S...> &t) : std::tuple<T, S...>(t) {} Tuple(Input &in) { auto a = std::tuple<T>(in); std::tuple<S...> b = Tuple<S...>(in); std::tuple<T, S...> c = std::tuple_cat(a, b); *this = c; } template <int n> auto &get() { return std::get<n>(*this); } template <int n> const auto &get() const { return std::get<n>(*this); } }; template <typename... T> Tuple<T...> makeTuple(const T &... args) { return Tuple<T...>(args...); } namespace std { template <typename... T> class tuple_size<Tuple<T...>> : public std::integral_constant<size_t, sizeof...(T)> {}; template <std::size_t I, typename... T> class tuple_element<I, Tuple<T...>> { public: using type = tuple_element_t<I, std::tuple<T...>>; }; } // namespace std /*****************/ /* container.hpp */ /*****************/ #include <vector> template <typename T> class Container : public T { private: using S = typename T::value_type; using Itr = typename T::iterator; public: Container() : T() {} Container(int n) : T(n) {} Container(int n, S s) : T(n, s) {} template <typename Itr> Container(Itr first, Itr last) : T(first, last) {} Container(const std::initializer_list<S> &v) : T(v) {} Container(int n, Input &in) { std::vector<S> v(n); for (auto &i : v) { i = in; } *this = Container<T>(v.begin(), v.end()); } S max() const { return *std::max_element(this->begin(), this->end()); } template <typename Function> auto max(Function func) const { std::vector<std::pair<decltype(func(S())), S>> res; for (const auto &i : *this) { res.emplace_back(func(i), i); } return std::max_element(res.begin(), res.end())->second; } S min() const { return *std::min_element(this->begin(), this->end()); } Tuple<S, S> minmax() const { auto itrs = std::minmax_element(this->begin(), this->end()); return Tuple<S, S>(*itrs.first, *itrs.second); } template <typename Function> auto min(Function func) const { std::vector<std::pair<decltype(func(S())), S>> res; for (const auto &i : *this) { res.emplace_back(func(i), i); } return std::min_element(res.begin(), res.end())->second; } int argmax() const { return std::distance(this->begin(), std::max_element(this->begin(), this->end())); } int argmin() const { return std::distance(this->begin(), std::min_element(this->begin(), this->end())); } int find(const S &a) const { return std::distance(this->begin(), std::find(this->begin(), this->end(), a)); } bool contains(const S &a) const { return std::find(this->begin(), this->end(), a) != this->end(); } int size() const { return T::size(); } std::pair<Itr, Itr> equal_range(const S &a) { return std::equal_range(this->begin(), this->end(), a); } template <typename Function> bool all_of(Function func) const { return std::all_of(this->begin(), this->end(), func); } template <typename Function> bool any_of(Function func) const { return std::any_of(this->begin(), this->end(), func); } template <typename Function> bool none_of(Function func) const { return std::none_of(this->begin(), this->end(), func); } int count(const S &s) const { return std::count(this->begin(), this->end(), s); } bool is_sorted() const { return std::is_sorted(this->begin(), this->end()); } void output(std::string sep = "\n", std::string end = "\n") const { bool first = true; for (const auto &i : *this) { if (!first) { cout << sep; } first = false; cout << i; } cout << end; } }; /***********/ /* map.hpp */ /***********/ #include <map> template <typename T, typename S> class Map : public Container<std::map<T, S>> { public: Map() : Container<std::map<T, S>>() {} bool contains(const T &a) const { return this->count(a) != 0; } int count(const T &t) const { return std::map<T, S>::count(t); } }; /***************/ /* ordered.hpp */ /***************/ template <typename T> class Ordered { public: template <typename V> bool operator==(const V &v) const { return !(static_cast<T>(v) < static_cast<const T &>(*this) || static_cast<const T &>(*this) < static_cast<T>(v)); } template <typename V> bool operator!=(const V &v) const { return static_cast<T>(v) < static_cast<const T &>(*this) || static_cast<const T &>(*this) < static_cast<T>(v); } template <typename V> bool operator>(const V &v) const { return static_cast<T>(v) < static_cast<const T &>(*this); } template <typename V> bool operator<=(const V &v) const { return !(static_cast<T>(v) < static_cast<const T &>(*this)); } template <typename V> bool operator>=(const V &v) const { return !(static_cast<const T &>(*this) < static_cast<T>(v)); } }; /**************/ /* vector.hpp */ /**************/ #include <numeric> template <typename T> class Vector : public Container<std::vector<T>>, public Ordered<Vector<T>> { public: Vector() = default; Vector(const Vector<T> &v) = default; Vector(int n) : Container<std::vector<T>>(n) {} Vector(int n, T t) : Container<std::vector<T>>(n, t) {} template <typename Itr> Vector(Itr first, Itr last) : Container<std::vector<T>>(first, last) {} Vector(const std::initializer_list<T> &v) : Container<std::vector<T>>(v) {} Vector(int n, Input &in) : Container<std::vector<T>>(n, in) {} Vector &operator+=(const Vector &v) { if (this->size() < v.size()) { this->resize(v.size()); } for (int i = 0; i < v.size(); ++i) { (*this)[i] += v[i]; } return *this; } Vector &operator+=(const T &v) { for (auto &i : *this) { i += v; } return *this; } Vector &operator-=(const Vector &v) { if (this->size() < v.size()) { this->resize(v.size()); } for (int i = 0; i < v.size(); ++i) { (*this)[i] -= v[i]; } return *this; } Vector &operator-=(const T &v) { for (auto &i : *this) { i -= v; } return *this; } Vector &operator*=(const Vector &v) { for (int i = 0; i < this->size(); ++i) { (*this)[i] *= v[i]; } return *this; } Vector &operator*=(const T &v) { for (auto &i : *this) { i *= v; } return *this; } Vector &operator/=(const Vector &v) { for (int i = 0; i < this->size(); ++i) { (*this)[i] /= v[i]; } return *this; } Vector &operator/=(const T &v) { for (auto &i : *this) { i /= v; } return *this; } Vector &operator%=(const Vector &v) { for (int i = 0; i < this->size(); ++i) { (*this)[i] %= v[i]; } return *this; } Vector &operator%=(const T &v) { for (auto &i : *this) { i %= v; } return *this; } Vector operator+(const Vector &v) const { return Vector(*this) += v; } Vector operator+(const T &v) const { return Vector(*this) += v; } Vector operator-(const Vector &v) const { return Vector(*this) -= v; } Vector operator-(const T &v) const { return Vector(*this) -= v; } Vector operator*(const Vector &v) const { return Vector(*this) *= v; } Vector operator*(const T &v) const { return Vector(*this) *= v; } Vector operator/(const Vector &v) const { return Vector(*this) /= v; } Vector operator/(const T &v) const { return Vector(*this) /= v; } Vector operator%(const Vector &v) const { return Vector(*this) %= v; } Vector operator%(const T &v) const { return Vector(*this) %= v; } bool operator<(const Vector &v) const { if (this->size() != v.size()) { return this->size() < v.size(); } for (int i = 0; i < this->size(); ++i) { if ((*this)[i] != v[i]) { return (*this)[i] < v[i]; } } return false; } Vector operator-() const { return *this * -1; } T inner_product(const Vector<T> &v) const { return std::inner_product(this->begin(), this->end(), v.begin(), T(0)); } Vector<T> &partial_sort(int k, bool reverse = false) { if (!reverse) { std::partial_sort(this->begin(), this->begin() + k, this->end()); } else { std::partial_sort(this->begin(), this->begin() + k, this->end(), std::greater<T>()); } return *this; } Vector<T> &sort() { std::sort(this->begin(), this->end()); return *this; } template <typename Function> Vector<T> &sort(Function func) { std::sort(this->begin(), this->end(), func); return *this; } Vector<T> &rsort() { std::sort(this->rbegin(), this->rend()); return *this; } Vector<int> argsort() const { Vector<Tuple<T, int>> v; for (int i = 0; i < this->size(); ++i) { v.emplace_back((*this)[i], i); } v.sort(); auto f = [](const Tuple<T, int> &t) { return t.template get<1>(); }; return v.transform(f); } Vector<T> &nth_element(int n, bool reverse = false) { if (!reverse) { std::nth_element(this->begin(), this->begin() + n, this->end()); } else { std::nth_element(this->begin(), this->begin() + n, this->end(), std::greater<T>()); } return *this; } Vector<T> subvector(int a) const { return Vector<T>(this->begin(), this->begin() + a); } Vector<T> subvector(int a, int b) const { return Vector<T>(this->begin() + a, this->begin() + b); } template <typename Function> auto transform(Function func) const { Vector<decltype(func(T()))> res; std::transform(this->begin(), this->end(), std::back_inserter(res), func); return res; } Vector<T> partial_sum() const { Vector<T> res; std::partial_sum(this->begin(), this->end(), std::back_inserter(res)); return res; } template <typename Function> Vector<T> partial_sum(Function func) const { Vector<T> res; std::partial_sum(this->begin(), this->end(), std::back_inserter(res), func); return res; } Vector<T> &reverse() { std::reverse(this->begin(), this->end()); return *this; } template <typename Function> int count_if(Function func) const { return std::count_if(this->begin(), this->end(), func); } Vector<T> adjacent_difference() const { Vector<T> res; std::adjacent_difference(this->begin(), this->end(), std::back_inserter(res)); return res; } T lower_bound(T t) const { return std::lower_bound(this->begin(), this->end(), t) - this->begin(); } T upper_bound(T t) const { return std::upper_bound(this->begin(), this->end(), t) - this->begin(); } T accumulate() const { return std::accumulate(this->begin(), this->end(), T()); } template <typename S, typename Function> S accumulate(S n, Function func) const { return std::accumulate(this->begin(), this->end(), n, func); } template <typename Int> static Vector<T> makeVector(Int n) { return Vector<T>(n); } template <typename Int> static Vector<T> makeVector(Input &in, Int n) { return Vector<T>(n, in); } template <typename Int, typename... Ints> static auto makeVector(Input &in, Int n, Ints... ints) { Vector<decltype(makeVector(in, ints...))> res; for (int i = 0; i < n; ++i) { res.emplace_back(makeVector(in, ints...)); } return res; } template <typename Int, typename... Ints> static auto makeVector(Int n, Ints... ints) { Vector<decltype(makeVector(ints...))> res; for (int i = 0; i < n; ++i) { res.emplace_back(makeVector(ints...)); } return res; } Vector<T> &unique() { this->erase(std::unique(this->begin(), this->end()), this->end()); return *this; } bool next_permutation() { return std::next_permutation(this->begin(), this->end()); } Vector<T> &rotate(int n) { std::rotate(this->begin(), this->begin() + n, this->end()); return *this; } Map<T, int> countAll() const { Map<T, int> res; for (const auto &i : *this) { ++res[i]; } return res; } T matmul(const T &a) const { return this->transform([&](const T &i) { return i.inner_product(a); }); } }; template <typename T> Vector<T> iota(int n, T m = 0) { Vector<T> v(n); std::iota(v.begin(), v.end(), m); return v; } template <typename T, typename S> void read(Vector<T> &t, Vector<S> &s) { for (int i = 0; i < t.size(); ++i) { t[i] = T(in); s[i] = S(in); } } template <typename T, typename S, typename U> void read(Vector<T> &t, Vector<S> &s, Vector<U> &u) { for (int i = 0; i < t.size(); ++i) { t[i] = T(in); s[i] = S(in); u[i] = U(in); } } template <typename T> Vector<T> operator+(const T &a, const Vector<T> &b) { return b + a; } template <typename T> Vector<T> operator-(const T &a, const Vector<T> &b) { return -b + a; } template <typename T> Vector<T> operator*(const T &a, const Vector<T> &b) { return b * a; } /************/ /* math.hpp */ /************/ #include <cmath> template <typename T = double> constexpr T pi() { return acos(T(-1)); } template <typename T> T gcd(T t) { return abs(t); } template <typename T, typename... S> T gcd(T a, S... s) { a = abs(a); auto b = gcd(s...); if (a == 0 || b == 0) { return max(a, b); } int fa = least_bit_fast(a); int fb = least_bit_fast(b); a >>= fa; b >>= fb; while (a != b) { auto &c = a > b ? a : b; c = abs(a - b); c >>= least_bit_fast(c); } return a << min(fa, fb); } template <typename T> T gcd(const Vector<T> &v) { T g = abs(v[0]); for (int i = 1; i < int(v.size()); ++i) { g = gcd(g, v[i]); } return g; } template <typename T> T lcm(T t) { return abs(t); } template <typename T, typename... S> T lcm(T t, S... s) { T l = lcm(s...); return abs(t) / gcd(t, l) * l; } template <typename T> T lcm(const Vector<T> &v) { T l = abs(v[0]); for (int i = 1; i < int(v.size()); ++i) { l = lcm(l, v[i]); } return l; } template <typename T> T floor(T a, T b) { auto d = std::div(a, b); return d.quot - (d.rem && (a < 0) != (b < 0) ? 1 : 0); } template <typename T> T ceil(T a, T b) { auto d = std::div(a, b); return d.quot + (d.rem && (a > 0) == (b > 0) ? 1 : 0); } template <typename T> T round(T a) { return std::round(a); } template <typename T> T round(T a, T b) { return floor(a + b / 2, b); } template <typename T> T mod(T a, T b) { T c = a % b; return c < 0 ? c + abs(b) : c; } template <typename T> T factorial(T n) { return n <= 1 ? 1 : factorial(n - 1) * n; } template <typename T> Vector<T> factorial_vector(int n) { Vector<T> v(n + 1, 1); for (int i = 1; i <= n; ++i) { v[i] = v[i - 1] * i; } return v; } template <typename T> T square(T n) { return n * n; } template <typename T> T cube(T n) { return n * n * n; } template <typename T> T norm(T x1, T y1, T x2, T y2) { return square(x1 - x2) + square(y1 - y2); } template <typename T> bool isSquare(T n) { return square(T(sqrt(n))) == n; } template <typename T> T clamp(T v, T l, T u) { return v < l ? l : v > u ? u : v; } template <typename T> auto hypot(T a, T b) { return std::hypot(a, b); } template <typename T> auto pow(T a, T b) { return std::pow(a, b); } template <typename T> auto log10(T a) { return std::log10(a); } void fft(Vector<std::complex<long double>> &a, int n, int dir) { long double theta = dir * 2 * pi() / n; for (int m = n; m > 1; m /= 2) { int mh = m / 2; for (int i = 0; i < mh; i++) { auto w = exp(i * theta * std::complex<long double>(0, 1)); for (int j = i; j < n; j += m) { int k = j + mh; auto x = a[j] - a[k]; a[j] += a[k]; a[k] = w * x; } } theta *= 2; } int i = 0; for (int j = 1; j < n - 1; j++) { for (int k = n / 2; k > (i ^= k); k /= 2) { ; } if (j < i) { swap(a[i], a[j]); } } } template <typename T> Vector<T> convolution(const Vector<T> &aa, const Vector<T> &bb) { Vector<std::complex<long double>> a(begin(aa), end(aa)), b(begin(bb), end(bb)); int n = 2 << most_bit(a.size() + b.size()); a.resize(n); b.resize(n); fft(a, n, 1); fft(b, n, 1); for (int i = 0; i < n; ++i) { a[i] *= b[i]; } fft(a, n, -1); Vector<T> res(n); for (int i = 0; i < n; ++i) { res[i] = round(real(a[i]) / n); } return res; } /***********************/ /* math/polynomial.hpp */ /***********************/ template <typename T> class Polynomial : public Vector<T> { private: void normalize() { while (this->size() > 1 && this->back() == 0) { this->pop_back(); } if (this->empty()) { this->emplace_back(0); } } public: Polynomial() { normalize(); } Polynomial(const Vector<T> &v) : Vector<T>(v) { normalize(); } Polynomial(const int n) : Vector<T>(n) {} Polynomial(const int n, const T val) : Vector<T>(n, val) {} Polynomial(const int n, Input &in) : Vector<T>(n, in) {} Polynomial &operator+=(const Polynomial &p) { for (int i = 0; i < p.size(); ++i) { if (int(this->size()) == i) { this->emplace_back(p[i]); } else { (*this)[i] += p[i]; } } normalize(); return *this; } Polynomial &operator-=(const Polynomial &p) { for (int i = 0; i < p.size(); ++i) { if (int(this->size()) == i) { (*this).emplace_back(-p[i]); } else { (*this)[i] -= p[i]; } } normalize(); return *this; } Polynomial &operator*=(const Polynomial &p) { int a = this->size(), b = p.size(); if (min(a, b) <= 256) { Polynomial res(a + b - 1); for (int i = 0; i < a; ++i) { for (int j = 0; j < b; ++j) { res[i + j] += (*this)[i] * p[j]; } } *this = res; normalize(); return *this; } int m = (max(a, b) + 1) / 2; Polynomial a0(m), a1(m), b0(m), b1(m); for (int i = 0; i < min(m, a); ++i) { a0[i] = (*this)[i]; } for (int i = m; i < a; ++i) { a1[i - m] = (*this)[i]; } for (int i = 0; i < min(m, b); ++i) { b0[i] = p[i]; } for (int i = m; i < b; ++i) { b1[i - m] = p[i]; } auto z0 = a0 * b0, z2 = a1 * b1, z1 = z0 + z2 - (a1 - a0) * (b1 - b0); *this = Vector<T>(a + b); for (int i = 0; i < z0.size(); ++i) { (*this)[i] += z0[i]; } for (int i = 0; i < z1.size(); ++i) { (*this)[i + m] += z1[i]; } for (int i = 0; i < z2.size(); ++i) { (*this)[i + 2 * m] += z2[i]; } normalize(); return *this; } Polynomial &operator/=(const Polynomial &p) { Polynomial res; for (int i = this->size() - p.size(); i >= 0; --i) { res[i] = (*this)[p.size() + i - 1] / p.back(); for (int j = 0; j < p.size(); ++j) { (*this)[i + j] -= res[i] * p[j]; } } *this = res; normalize(); return *this; } Polynomial &operator%=(const Polynomial &p) { for (int i = int(this->size()) - int(p.size()); i >= 0; --i) { T d = (*this)[p.size() + i - 1] / p.back(); for (int j = 0; j < p.size(); ++j) { (*this)[i + j] -= d * p[j]; } } normalize(); return *this; } static constexpr Polynomial identity() { return Polynomial(1, 1); } }; /************/ /* main.cpp */ /************/ int main() { int d(in); Polynomial<int> poly(d + 1, in); poly %= Polynomial<int>(Vector<int>({0, -1, 0, 1})); cout << poly.size() - 1 << endl; poly.output(" "); }