結果
問題 | No.344 ある無理数の累乗 |
ユーザー | jell |
提出日時 | 2021-01-11 15:30:20 |
言語 | C++17 (gcc 12.3.0 + boost 1.83.0) |
結果 |
AC
|
実行時間 | 2 ms / 2,000 ms |
コード長 | 42,539 bytes |
コンパイル時間 | 4,478 ms |
コンパイル使用メモリ | 267,336 KB |
実行使用メモリ | 6,948 KB |
最終ジャッジ日時 | 2024-05-01 06:49:02 |
合計ジャッジ時間 | 5,293 ms |
ジャッジサーバーID (参考情報) |
judge5 / judge3 |
(要ログイン)
テストケース
テストケース表示入力 | 結果 | 実行時間 実行使用メモリ |
---|---|---|
testcase_00 | AC | 1 ms
6,812 KB |
testcase_01 | AC | 2 ms
6,816 KB |
testcase_02 | AC | 2 ms
6,940 KB |
testcase_03 | AC | 2 ms
6,944 KB |
testcase_04 | AC | 1 ms
6,944 KB |
testcase_05 | AC | 1 ms
6,940 KB |
testcase_06 | AC | 1 ms
6,944 KB |
testcase_07 | AC | 1 ms
6,944 KB |
testcase_08 | AC | 2 ms
6,940 KB |
testcase_09 | AC | 1 ms
6,944 KB |
testcase_10 | AC | 2 ms
6,944 KB |
testcase_11 | AC | 2 ms
6,944 KB |
testcase_12 | AC | 2 ms
6,944 KB |
testcase_13 | AC | 1 ms
6,944 KB |
testcase_14 | AC | 1 ms
6,940 KB |
testcase_15 | AC | 1 ms
6,944 KB |
testcase_16 | AC | 1 ms
6,940 KB |
testcase_17 | AC | 1 ms
6,940 KB |
testcase_18 | AC | 1 ms
6,940 KB |
testcase_19 | AC | 1 ms
6,944 KB |
testcase_20 | AC | 1 ms
6,940 KB |
testcase_21 | AC | 2 ms
6,940 KB |
testcase_22 | AC | 1 ms
6,944 KB |
testcase_23 | AC | 1 ms
6,944 KB |
testcase_24 | AC | 2 ms
6,944 KB |
testcase_25 | AC | 2 ms
6,940 KB |
testcase_26 | AC | 2 ms
6,944 KB |
testcase_27 | AC | 1 ms
6,944 KB |
testcase_28 | AC | 2 ms
6,940 KB |
testcase_29 | AC | 2 ms
6,948 KB |
ソースコード
#line 1 "atcoder-workspace/a.cc" // #undef _GLIBCXX_DEBUG // #define NDEBUG #include <bits/extc++.h> #line 2 "Library/src/modular/inverse.hpp" /* * @file inverse.hpp * @brief Inverse Table */ #line 9 "Library/src/modular/inverse.hpp" #line 2 "Library/src/modular/modint.hpp" /** * @file modint.hpp * * @brief Modular Arithmetic */ #line 12 "Library/src/modular/modint.hpp" #line 2 "Library/src/utils/sfinae.hpp" /* * @file sfinae.hpp * @brief SFINAE */ #line 10 "Library/src/utils/sfinae.hpp" #include <type_traits> #ifdef __SIZEOF_INT128__ #define __INT128_DEFINED__ 1 #else #define __INT128_DEFINED__ 0 #endif namespace std { #if __INT128_DEFINED__ template <> struct make_signed<__uint128_t> { using type = __int128_t; }; template <> struct make_signed<__int128_t> { using type = __int128_t; }; template <> struct make_unsigned<__uint128_t> { using type = __uint128_t; }; template <> struct make_unsigned<__int128_t> { using type = __uint128_t; }; #endif } // namespace std namespace workspace { template <class type, template <class> class trait> using enable_if_trait_type = typename std::enable_if<trait<type>::value>::type; template <class Container> using element_type = typename std::decay<decltype( *std::begin(std::declval<Container&>()))>::type; template <class T, class = std::nullptr_t> struct has_begin : std::false_type {}; template <class T> struct has_begin<T, decltype(std::begin(std::declval<T>()), nullptr)> : std::true_type {}; template <class T, class = int> struct mapped_of { using type = element_type<T>; }; template <class T> struct mapped_of<T, typename std::pair<int, typename T::mapped_type>::first_type> { using type = typename T::mapped_type; }; template <class T> using mapped_type = typename mapped_of<T>::type; template <class T, class = void> struct is_integral_ext : std::false_type {}; template <class T> struct is_integral_ext< T, typename std::enable_if<std::is_integral<T>::value>::type> : std::true_type {}; #if __INT128_DEFINED__ template <> struct is_integral_ext<__int128_t> : std::true_type {}; template <> struct is_integral_ext<__uint128_t> : std::true_type {}; #endif #if __cplusplus >= 201402 template <class T> constexpr static bool is_integral_ext_v = is_integral_ext<T>::value; #endif template <typename T, typename = void> struct multiplicable_uint { using type = uint_least32_t; }; template <typename T> struct multiplicable_uint< T, typename std::enable_if<(2 < sizeof(T)) && (!__INT128_DEFINED__ || sizeof(T) <= 4)>::type> { using type = uint_least64_t; }; #if __INT128_DEFINED__ template <typename T> struct multiplicable_uint<T, typename std::enable_if<(4 < sizeof(T))>::type> { using type = __uint128_t; }; #endif } // namespace workspace #line 14 "Library/src/modular/modint.hpp" namespace workspace { namespace internal { /** * @brief Base of modular arithmetic. * * @tparam Mod identifier, which represents modulus if positive * @tparam Storage Reserved size for inverse calculation */ template <auto Mod, unsigned Storage> struct modint_base { static_assert(is_integral_ext<decltype(Mod)>::value, "Mod must be integral type."); using mod_type = typename std::make_signed<typename std::conditional< 0 < Mod, typename std::add_const<decltype(Mod)>::type, decltype(Mod)>::type>::type; using value_type = typename std::decay<mod_type>::type; using mul_type = typename multiplicable_uint<value_type>::type; static mod_type mod; static value_type storage; constexpr static void reserve(unsigned __n) noexcept { storage = __n; } protected: value_type value = 0; public: constexpr modint_base() noexcept = default; template <class int_type, typename std::enable_if<is_integral_ext<int_type>::value>::type * = nullptr> constexpr modint_base(int_type n) noexcept : value((n %= mod) < 0 ? n += mod : n) {} constexpr modint_base(bool n) noexcept : value(n) {} constexpr operator value_type() const noexcept { return value; } constexpr static modint_base one() noexcept { return 1; } // unary operators {{ constexpr modint_base operator++(int) noexcept { modint_base __t{*this}; operator++(); return __t; } constexpr modint_base operator--(int) noexcept { modint_base __t{*this}; operator--(); return __t; } constexpr modint_base &operator++() noexcept { if (++value == mod) value = 0; return *this; } constexpr modint_base &operator--() noexcept { if (!value) value = mod; --value; return *this; } constexpr modint_base operator-() const noexcept { modint_base __t; __t.value = value ? mod - value : 0; return __t; } // }} unary operators // operator+= {{ constexpr modint_base &operator+=(modint_base const &rhs) noexcept { if ((value += rhs.value) >= mod) value -= mod; return *this; } template <class int_type> constexpr typename std::enable_if<is_integral_ext<int_type>::value, modint_base>::type & operator+=(int_type const &rhs) noexcept { if (((value += rhs) %= mod) < 0) value += mod; return *this; } // }} operator+= // operator+ {{ template <class int_type> constexpr typename std::enable_if<is_integral_ext<int_type>::value, modint_base>::type operator+(int_type const &rhs) const noexcept { return modint_base{*this} += rhs; } constexpr modint_base operator+(modint_base rhs) const noexcept { return rhs += *this; } template <class int_type> constexpr friend typename std::enable_if<is_integral_ext<int_type>::value, modint_base>::type operator+(int_type const &lhs, modint_base rhs) noexcept { return rhs += lhs; } // }} operator+ // operator-= {{ constexpr modint_base &operator-=(modint_base const &rhs) noexcept { if ((value -= rhs.value) < 0) value += mod; return *this; } template <class int_type> constexpr typename std::enable_if<is_integral_ext<int_type>::value, modint_base>::type & operator-=(int_type rhs) noexcept { if (((value -= rhs) %= mod) < 0) value += mod; return *this; } // }} operator-= // operator- {{ template <class int_type> constexpr typename std::enable_if<is_integral_ext<int_type>::value, modint_base>::type operator-(int_type const &rhs) const noexcept { return modint_base{*this} -= rhs; } constexpr modint_base operator-(modint_base const &rhs) const noexcept { modint_base __t; if (((__t.value = value) -= rhs.value) < 0) __t.value += mod; return __t; } template <class int_type> constexpr friend typename std::enable_if<is_integral_ext<int_type>::value, modint_base>::type operator-(int_type lhs, modint_base const &rhs) noexcept { if (((lhs -= rhs.value) %= mod) < 0) lhs += mod; modint_base __t; __t.value = lhs; return __t; } // }} operator- // operator*= {{ constexpr modint_base &operator*=(modint_base const &rhs) noexcept { if (!rhs.value) { value = 0; } else if (value) { mul_type __r(value); value = static_cast<value_type>((__r *= rhs.value) %= mod); } return *this; } template <class int_type> constexpr typename std::enable_if<is_integral_ext<int_type>::value, modint_base>::type & operator*=(int_type rhs) noexcept { if (!rhs) value = 0; else if (value) { if ((rhs %= mod) < 0) rhs += mod; mul_type __r(value); value = static_cast<value_type>((__r *= rhs) %= mod); } return *this; } // }} operator*= // operator* {{ constexpr modint_base operator*(modint_base const &rhs) const noexcept { if (!value or !rhs.value) return {}; mul_type __r(value); modint_base __t; __t.value = static_cast<value_type>((__r *= rhs.value) %= mod); return __t; } template <class int_type> constexpr typename std::enable_if<is_integral_ext<int_type>::value, modint_base>::type operator*(int_type rhs) const noexcept { if (!value or !rhs) return {}; if ((rhs %= mod) < 0) rhs += mod; mul_type __r(value); modint_base __t; __t.value = static_cast<value_type>((__r *= rhs) %= mod); return __t; } template <class int_type> constexpr friend typename std::enable_if<is_integral_ext<int_type>::value, modint_base>::type operator*(int_type lhs, modint_base const &rhs) noexcept { if (!lhs or !rhs.value) return {}; if ((lhs %= mod) < 0) lhs += mod; mul_type __r(lhs); modint_base __t; __t.value = (__r *= rhs.value) %= mod; return __t; } // }} operator* protected: static value_type _mem(value_type __x) { static std::vector<value_type> __m{0, 1}; static value_type __i = (__m.reserve(Storage), 1); while (__i < __x) { ++__i; __m.emplace_back(mod - mul_type(mod / __i) * __m[mod % __i] % mod); } return __m[__x]; } template <class int_type> constexpr static typename std::enable_if<is_integral_ext<int_type>::value, value_type>::type _div(mul_type __r, int_type __x) noexcept { assert(__x); if (!__r) return 0; int_type __v{}; bool __neg = __x < 0 ? __x = -__x, true : false; if (__x < storage) { __v = _mem(__x); } else { int_type __y{mod}, __u{1}, __t; while (__x) __t = __y / __x, __y ^= __x ^= (__y -= __t * __x) ^= __x, __v ^= __u ^= (__v -= __t * __u) ^= __u; if (__y < 0) __neg ^= 1; } if (__neg) __v = 0 < __v ? mod - __v : -__v; else if (__v < 0) __v += mod; if (__r == 1) return static_cast<value_type>(__v); return static_cast<value_type>((__r *= __v) %= mod); } public: // operator/= {{ constexpr modint_base &operator/=(modint_base const &rhs) noexcept { if (value) value = _div(value, rhs.value); return *this; } template <class int_type> constexpr typename std::enable_if<is_integral_ext<int_type>::value, modint_base>::type & operator/=(int_type rhs) noexcept { if (value) value = _div(value, rhs %= mod); return *this; } // }} operator/= // operator/ {{ constexpr modint_base operator/(modint_base const &rhs) const noexcept { if (!value) return {}; modint_base __t; __t.value = _div(value, rhs.value); return __t; } template <class int_type> constexpr typename std::enable_if<is_integral_ext<int_type>::value, modint_base>::type operator/(int_type rhs) const noexcept { if (!value) return {}; modint_base __t; __t.value = _div(value, rhs %= mod); return __t; } template <class int_type> constexpr friend typename std::enable_if<is_integral_ext<int_type>::value, modint_base>::type operator/(int_type lhs, modint_base const &rhs) noexcept { if (!lhs) return {}; if ((lhs %= mod) < 0) lhs += mod; modint_base __t; __t.value = _div(lhs, rhs.value); return __t; } // }} operator/ constexpr modint_base inv() const noexcept { return _div(1, value); } template <class int_type> friend constexpr typename std::enable_if<is_integral_ext<int_type>::value, modint_base>::type pow(modint_base b, int_type e) noexcept { if (e < 0) { e = -e; b.value = _div(1, b.value); } modint_base __r; for (__r.value = 1; e; e >>= 1, b *= b) if (e & 1) __r *= b; return __r; } template <class int_type> constexpr typename std::enable_if<is_integral_ext<int_type>::value, modint_base>::type pow(int_type e) const noexcept { modint_base __r, b; __r.value = 1; for (b.value = e < 0 ? e = -e, _div(1, value) : value; e; e >>= 1, b *= b) if (e & 1) __r *= b; return __r; } friend std::ostream &operator<<(std::ostream &os, const modint_base &rhs) noexcept { return os << rhs.value; } friend std::istream &operator>>(std::istream &is, modint_base &rhs) noexcept { intmax_t value; rhs = (is >> value, value); return is; } }; template <auto Mod, unsigned Storage> typename modint_base<Mod, Storage>::mod_type modint_base<Mod, Storage>::mod = Mod > 0 ? Mod : 0; template <auto Mod, unsigned Storage> typename modint_base<Mod, Storage>::value_type modint_base<Mod, Storage>::storage = Storage; } // namespace internal /** * @brief Modular arithmetic. * * @tparam Mod modulus * @tparam Storage Reserved size for inverse calculation */ template <auto Mod, unsigned Storage = 0, typename std::enable_if<(Mod > 0)>::type * = nullptr> using modint = internal::modint_base<Mod, Storage>; /** * @brief Runtime modular arithmetic. * * @tparam type_id uniquely assigned * @tparam Storage Reserved size for inverse calculation */ template <unsigned type_id = 0, unsigned Storage = 0> using modint_runtime = internal::modint_base<-(signed)type_id, Storage>; // #define modint_newtype modint_runtime<__COUNTER__> } // namespace workspace #line 11 "Library/src/modular/inverse.hpp" namespace workspace { // Modulus must be prime. template <class Modint> struct inverse_table { static_assert(std::is_same<std::nullptr_t, decltype((void *)Modint::mod, nullptr)>::value); using value_type = Modint; constexpr value_type operator()(int n) const { constexpr int_fast64_t mod = value_type::mod; assert(n %= mod); if (n < 0) n += mod; if (inv.empty()) inv = {1, mod != 1}; for (int m(inv.size()); m <= n; ++m) inv.emplace_back(mod / m * -inv[mod % m]); return inv[n]; } private: static std::vector<value_type> inv; }; template <class Modint> std::vector<Modint> inverse_table<Modint>::inv; } // namespace workspace #line 2 "Library/src/utils/cat.hpp" /** * @file cat.hpp * @brief Cat */ #line 9 "Library/src/utils/cat.hpp" namespace workspace { template <class C1, class C2> constexpr C1 &&cat(C1 &&__c1, C2 const &__c2) noexcept { __c1.insert(__c1.end(), std::begin(__c2), std::end(__c2)); return __c1; } } // namespace workspace #line 2 "Library/src/utils/chval.hpp" /* * @file chval.hpp * @brief Change Less/Greater */ #line 9 "Library/src/utils/chval.hpp" namespace workspace { /* * @fn chle * @brief Substitute y for x if comp(y, x) is true. * @param x Reference * @param y Const reference * @param comp Compare function * @return Whether or not x is updated */ template <class Tp, class Comp = std::less<Tp>> bool chle(Tp &x, const Tp &y, Comp comp = Comp()) { return comp(y, x) ? x = y, true : false; } /* * @fn chge * @brief Substitute y for x if comp(x, y) is true. * @param x Reference * @param y Const reference * @param comp Compare function * @return Whether or not x is updated */ template <class Tp, class Comp = std::less<Tp>> bool chge(Tp &x, const Tp &y, Comp comp = Comp()) { return comp(x, y) ? x = y, true : false; } } // namespace workspace #line 2 "Library/src/utils/fixed_point.hpp" /* * @file fixed_point.hpp * @brief Fixed Point Combinator */ #line 9 "Library/src/utils/fixed_point.hpp" namespace workspace { /* * @class fixed_point * @brief Recursive calling of lambda expression. */ template <class lambda_type> class fixed_point { lambda_type func; public: /* * @param func 1st arg callable with the rest of args, and the return type * specified. */ fixed_point(lambda_type &&func) : func(std::move(func)) {} /* * @brief Recursively apply *this to 1st arg of func. * @param args Arguments of the recursive method. */ template <class... Args> auto operator()(Args &&... args) const { return func(*this, std::forward<Args>(args)...); } }; } // namespace workspace #line 2 "Library/src/utils/grid.hpp" /** * @file grid.hpp * @brief Grid * @date 2021-01-09 */ #line 10 "Library/src/utils/grid.hpp" namespace workspace { template <class Grid> Grid transpose(Grid const &grid) { Grid __t; for (auto &&__r : grid) { auto __i = std::begin(__t); for (auto &&__x : __r) { if (__i == std::end(__t)) __i = __t.insert(__t.end(), typename std::decay<decltype(__r)>::type{}); __i->insert(__i->end(), __x); ++__i; } } return __t; } // template <class _Tp, size_t _Row, size_t _Col> // std::array<std::array<_Tp, _Row>, _Col> transpose(_Tp (&__g)[_Row][_Col]) {} template <class Grid> Grid roll_ccw(Grid const &grid) { auto __t = transpose(grid); std::reverse(std::begin(__t), std::end(__t)); return __t; } template <class Grid> Grid roll_cw(Grid const &grid) { auto __t = grid; std::reverse(std::begin(__t), std::end(__t)); return transpose(__t); } } // namespace workspace #line 2 "Library/src/utils/hash.hpp" #line 8 "Library/src/utils/hash.hpp" #line 10 "Library/src/utils/hash.hpp" namespace workspace { template <class T, class = void> struct hash : std::hash<T> {}; #if __cplusplus >= 201703L template <class Unique_bits_type> struct hash<Unique_bits_type, enable_if_trait_type<Unique_bits_type, std::has_unique_object_representations>> { size_t operator()(uint64_t x) const { static const uint64_t m = std::random_device{}(); x ^= x >> 23; x ^= m; x ^= x >> 47; return x - (x >> 32); } }; #endif template <class Key> size_t hash_combine(const size_t &seed, const Key &key) { return seed ^ (hash<Key>()(key) + 0x9e3779b9 /* + (seed << 6) + (seed >> 2) */); } template <class T1, class T2> struct hash<std::pair<T1, T2>> { size_t operator()(const std::pair<T1, T2> &pair) const { return hash_combine(hash<T1>()(pair.first), pair.second); } }; template <class... T> class hash<std::tuple<T...>> { template <class Tuple, size_t index = std::tuple_size<Tuple>::value - 1> struct tuple_hash { static uint64_t apply(const Tuple &t) { return hash_combine(tuple_hash<Tuple, index - 1>::apply(t), std::get<index>(t)); } }; template <class Tuple> struct tuple_hash<Tuple, size_t(-1)> { static uint64_t apply(const Tuple &t) { return 0; } }; public: uint64_t operator()(const std::tuple<T...> &t) const { return tuple_hash<std::tuple<T...>>::apply(t); } }; template <class hash_table> struct hash_table_wrapper : hash_table { using key_type = typename hash_table::key_type; size_t count(const key_type &key) const { return hash_table::find(key) != hash_table::end(); } template <class... Args> auto emplace(Args &&... args) { return hash_table::insert(typename hash_table::value_type(args...)); } }; template <class Key, class Mapped = __gnu_pbds::null_type> using cc_hash_table = hash_table_wrapper<__gnu_pbds::cc_hash_table<Key, Mapped, hash<Key>>>; template <class Key, class Mapped = __gnu_pbds::null_type> using gp_hash_table = hash_table_wrapper<__gnu_pbds::gp_hash_table<Key, Mapped, hash<Key>>>; template <class Key, class Mapped> using unordered_map = std::unordered_map<Key, Mapped, hash<Key>>; template <class Key> using unordered_set = std::unordered_set<Key, hash<Key>>; } // namespace workspace #line 2 "Library/src/utils/io/istream.hpp" /** * @file istream.hpp * @brief Input Stream */ #include <cxxabi.h> #line 13 "Library/src/utils/io/istream.hpp" #line 15 "Library/src/utils/io/istream.hpp" namespace workspace { namespace internal { template <class Tp, typename = std::nullptr_t> struct istream_helper { istream_helper(std::istream &is, Tp &x) { if constexpr (has_begin<Tp>::value) for (auto &&e : x) istream_helper<typename std::decay<decltype(e)>::type>(is, e); else static_assert(has_begin<Tp>::value, "istream unsupported type."); } }; template <class Tp> struct istream_helper< Tp, decltype(std::declval<std::decay<decltype(std::declval<std::istream &>() >> std::declval<Tp &>())>>(), nullptr)> { istream_helper(std::istream &is, Tp &x) { is >> x; } }; #ifdef __SIZEOF_INT128__ template <> struct istream_helper<__int128_t, std::nullptr_t> { istream_helper(std::istream &is, __int128_t &x) { std::string s; is >> s; bool negative = s.front() == '-' ? s.erase(s.begin()), true : false; x = 0; for (char e : s) x = x * 10 + e - '0'; if (negative) x = -x; } }; template <> struct istream_helper<__uint128_t, std::nullptr_t> { istream_helper(std::istream &is, __uint128_t &x) { std::string s; is >> s; bool negative = s.front() == '-' ? s.erase(s.begin()), true : false; x = 0; for (char e : s) x = x * 10 + e - '0'; if (negative) x = -x; } }; #endif // INT128 template <class T1, class T2> struct istream_helper<std::pair<T1, T2>> { istream_helper(std::istream &is, std::pair<T1, T2> &x) { istream_helper<T1>(is, x.first), istream_helper<T2>(is, x.second); } }; template <class... Tps> struct istream_helper<std::tuple<Tps...>> { istream_helper(std::istream &is, std::tuple<Tps...> &x) { iterate(is, x); } private: template <class Tp, size_t N = 0> void iterate(std::istream &is, Tp &x) { if constexpr (N == std::tuple_size<Tp>::value) return; else istream_helper<typename std::tuple_element<N, Tp>::type>(is, std::get<N>(x)), iterate<Tp, N + 1>(is, x); } }; } // namespace internal /** * @brief A wrapper class for std::istream. */ class istream : public std::istream { public: /** * @brief Wrapped operator. */ template <typename Tp> istream &operator>>(Tp &x) { internal::istream_helper<Tp>(*this, x); if (std::istream::fail()) { static auto once = atexit([] { std::cerr << "\n\033[43m\033[30mwarning: failed to read \'" << abi::__cxa_demangle(typeid(Tp).name(), 0, 0, 0) << "\'.\033[0m\n\n"; }); assert(!once); } return *this; } }; namespace internal { auto *const cin_ptr = (istream *)&std::cin; } auto &cin = *internal::cin_ptr; } // namespace workspace #line 2 "Library/src/utils/io/ostream.hpp" /* * @file ostream.hpp * @brief Output Stream */ #line 10 "Library/src/utils/io/ostream.hpp" namespace workspace { template <class T, class U> std::ostream &operator<<(std::ostream &os, const std::pair<T, U> &p) { return os << p.first << ' ' << p.second; } template <class tuple_t, size_t index> struct tuple_os { static std::ostream &apply(std::ostream &os, const tuple_t &t) { tuple_os<tuple_t, index - 1>::apply(os, t); return os << ' ' << std::get<index>(t); } }; template <class tuple_t> struct tuple_os<tuple_t, 0> { static std::ostream &apply(std::ostream &os, const tuple_t &t) { return os << std::get<0>(t); } }; template <class tuple_t> struct tuple_os<tuple_t, SIZE_MAX> { static std::ostream &apply(std::ostream &os, const tuple_t &t) { return os; } }; template <class... T> std::ostream &operator<<(std::ostream &os, const std::tuple<T...> &t) { return tuple_os<std::tuple<T...>, std::tuple_size<std::tuple<T...>>::value - 1>::apply(os, t); } template <class Container, typename = decltype(std::begin(std::declval<Container>()))> typename std::enable_if< !std::is_same<typename std::decay<Container>::type, std::string>::value && !std::is_same<typename std::decay<Container>::type, char *>::value, std::ostream &>::type operator<<(std::ostream &os, const Container &cont) { bool head = true; for (auto &&e : cont) head ? head = 0 : (os << ' ', 0), os << e; return os; } } // namespace workspace #line 9 "Library/lib\\utils" // #include "src/utils/io/read.hpp" #line 2 "Library/src/utils/io/setup.hpp" /* * @file setup.hpp * @brief I/O Setup */ #line 10 "Library/src/utils/io/setup.hpp" namespace workspace { /* * @fn io_setup * @brief Setup I/O. * @param precision Standard output precision */ void io_setup(int precision) { std::ios::sync_with_stdio(false); std::cin.tie(nullptr); std::cout << std::fixed << std::setprecision(precision); #ifdef _buffer_check atexit([] { char bufc; if (std::cin >> bufc) std::cerr << "\n\033[43m\033[30mwarning: buffer not empty.\033[0m\n\n"; }); #endif } } // namespace workspace #line 2 "Library/src/utils/iterator/category.hpp" /* * @file category.hpp * @brief Iterator Category */ #line 10 "Library/src/utils/iterator/category.hpp" namespace workspace { /* * @tparam Tuple Tuple of iterator types */ template <class Tuple, size_t N = std::tuple_size<Tuple>::value - 1> struct common_iterator_category { using type = typename std::common_type< typename common_iterator_category<Tuple, N - 1>::type, typename std::iterator_traits<typename std::tuple_element< N, Tuple>::type>::iterator_category>::type; }; template <class Tuple> struct common_iterator_category<Tuple, 0> { using type = typename std::iterator_traits< typename std::tuple_element<0, Tuple>::type>::iterator_category; }; } // namespace workspace #line 2 "Library/src/utils/iterator/reverse.hpp" /* * @file reverse_iterator.hpp * @brief Reverse Iterator */ #if __cplusplus >= 201703L #include <iterator> #include <optional> namespace workspace { /* * @class reverse_iterator * @brief Wrapper class for `std::reverse_iterator`. * @see http://gcc.gnu.org/PR51823 */ template <class Iterator> class reverse_iterator : public std::reverse_iterator<Iterator> { using base_std = std::reverse_iterator<Iterator>; std::optional<typename base_std::value_type> deref; public: using base_std::reverse_iterator; constexpr typename base_std::reference operator*() noexcept { if (!deref) { Iterator tmp = base_std::current; deref = *--tmp; } return deref.value(); } constexpr reverse_iterator &operator++() noexcept { base_std::operator++(); deref.reset(); return *this; } constexpr reverse_iterator &operator--() noexcept { base_std::operator++(); deref.reset(); return *this; } constexpr reverse_iterator operator++(int) noexcept { base_std::operator++(); deref.reset(); return *this; } constexpr reverse_iterator operator--(int) noexcept { base_std::operator++(); deref.reset(); return *this; } }; } // namespace workspace #endif #line 2 "Library/src/utils/make_vector.hpp" /* * @file make_vector.hpp * @brief Multi-dimensional Vector */ #if __cplusplus >= 201703L #include <tuple> #include <vector> namespace workspace { /* * @brief Make a multi-dimensional vector. * @tparam Tp type of the elements * @tparam N dimension * @tparam S integer type * @param sizes The size of each dimension * @param init The initial value */ template <typename Tp, size_t N, typename S> constexpr auto make_vector([[maybe_unused]] S* sizes, Tp const& init = Tp()) { static_assert(std::is_convertible_v<S, size_t>); if constexpr (N) return std::vector(*sizes, make_vector<Tp, N - 1, S>(std::next(sizes), init)); else return init; } /* * @brief Make a multi-dimensional vector. * @param sizes The size of each dimension * @param init The initial value */ template <typename Tp, size_t N, typename S> constexpr auto make_vector(const S (&sizes)[N], Tp const& init = Tp()) { return make_vector<Tp, N, S>((S*)sizes, init); } /* * @brief Make a multi-dimensional vector. * @param sizes The size of each dimension * @param init The initial value */ template <typename Tp, size_t N, typename S, size_t I = 0> constexpr auto make_vector([[maybe_unused]] std::array<S, N> const& sizes, Tp const& init = Tp()) { static_assert(std::is_convertible_v<S, size_t>); if constexpr (I == N) return init; else return std::vector(sizes[I], make_vector<Tp, N, S, I + 1>(sizes, init)); } /* * @brief Make a multi-dimensional vector. * @param sizes The size of each dimension * @param init The initial value */ template <typename Tp, size_t N = SIZE_MAX, size_t I = 0, class... Args> constexpr auto make_vector([[maybe_unused]] std::tuple<Args...> const& sizes, Tp const& init = Tp()) { using tuple_type = std::tuple<Args...>; if constexpr (I == std::tuple_size_v<tuple_type> || I == N) return init; else { static_assert( std::is_convertible_v<std::tuple_element_t<I, tuple_type>, size_t>); return std::vector(std::get<I>(sizes), make_vector<Tp, N, I + 1>(sizes, init)); } } /* * @brief Make a multi-dimensional vector. * @param sizes The size of each dimension * @param init The initial value */ template <typename Tp, class Fst, class Snd> constexpr auto make_vector(std::pair<Fst, Snd> const& sizes, Tp const& init = Tp()) { static_assert(std::is_convertible_v<Fst, size_t>); static_assert(std::is_convertible_v<Snd, size_t>); return make_vector({(size_t)sizes.first, (size_t)sizes.second}, init); } } // namespace workspace #endif #line 2 "Library/src/utils/py-like/enumerate.hpp" /* * @file enumerate.hpp * @brief Enumerate */ #line 2 "Library/src/utils/py-like/range.hpp" /** * @file range.hpp * @brief Range */ #line 9 "Library/src/utils/py-like/range.hpp" #line 2 "Library/src/utils/py-like/reversed.hpp" /** * @file reversed.hpp * @brief Reversed */ #include <initializer_list> #line 10 "Library/src/utils/py-like/reversed.hpp" namespace workspace { namespace internal { template <class Container> class reversed { Container cont; public: constexpr reversed(Container &&cont) : cont(cont) {} constexpr auto begin() { return std::rbegin(cont); } constexpr auto end() { return std::rend(cont); } }; } // namespace internal template <class Container> constexpr auto reversed(Container &&cont) noexcept { return internal::reversed<Container>{std::forward<Container>(cont)}; } template <class Tp> constexpr auto reversed(std::initializer_list<Tp> &&cont) noexcept { return internal::reversed<std::initializer_list<Tp>>{ std::forward<std::initializer_list<Tp>>(cont)}; } } // namespace workspace #line 12 "Library/src/utils/py-like/range.hpp" #if __cplusplus >= 201703L namespace workspace { template <class Index> class range { Index first, last; public: class iterator { Index current; public: using difference_type = std::ptrdiff_t; using value_type = Index; using reference = typename std::add_const<Index>::type &; using pointer = iterator; using iterator_category = std::bidirectional_iterator_tag; constexpr iterator(Index const &__i = Index()) noexcept : current(__i) {} constexpr bool operator==(iterator const &rhs) const noexcept { return current == rhs.current; } constexpr bool operator!=(iterator const &rhs) const noexcept { return current != rhs.current; } constexpr iterator &operator++() noexcept { ++current; return *this; } constexpr iterator &operator--() noexcept { --current; return *this; } constexpr reference operator*() const noexcept { return current; } }; constexpr range(Index first, Index last) noexcept : first(first), last(last) {} constexpr range(Index last) noexcept : first(), last(last) {} constexpr iterator begin() const noexcept { return iterator{first}; } constexpr iterator end() const noexcept { return iterator{last}; } constexpr reverse_iterator<iterator> rbegin() const noexcept { return reverse_iterator<iterator>(end()); } constexpr reverse_iterator<iterator> rend() const noexcept { return reverse_iterator<iterator>(begin()); } }; template <class... Args> constexpr auto rrange(Args &&... args) noexcept { return internal::reversed(range(std::forward<Args>(args)...)); } } // namespace workspace #endif #line 2 "Library/src/utils/py-like/zip.hpp" /** * @file zip.hpp * @brief Zip */ #line 11 "Library/src/utils/py-like/zip.hpp" #line 14 "Library/src/utils/py-like/zip.hpp" #if __cplusplus >= 201703L namespace workspace { namespace internal { template <class> struct zipped_iterator; template <class...> struct zipped_iterator_tuple; template <class... Args> class zipped { using ref_tuple = std::tuple<Args...>; ref_tuple args; template <size_t N = 0> constexpr auto begin_cat() const noexcept { if constexpr (N != std::tuple_size<ref_tuple>::value) { return std::tuple_cat(std::tuple(std::begin(std::get<N>(args))), begin_cat<N + 1>()); } else return std::tuple<>(); } template <size_t N = 0> constexpr auto end_cat() const noexcept { if constexpr (N != std::tuple_size<ref_tuple>::value) { return std::tuple_cat(std::tuple(std::end(std::get<N>(args))), end_cat<N + 1>()); } else return std::tuple<>(); } public: constexpr zipped(Args &&... args) noexcept : args(args...) {} class iterator { using base_tuple = typename zipped_iterator_tuple<Args...>::type; public: using iterator_category = typename common_iterator_category<base_tuple>::type; using difference_type = std::ptrdiff_t; using value_type = zipped_iterator<base_tuple>; using reference = zipped_iterator<base_tuple> &; using pointer = iterator; protected: value_type current; template <size_t N = 0> constexpr bool equal(const iterator &rhs) const noexcept { if constexpr (N != std::tuple_size<base_tuple>::value) { return std::get<N>(current) == std::get<N>(rhs.current) || equal<N + 1>(rhs); } else return false; } template <size_t N = 0> constexpr void increment() noexcept { if constexpr (N != std::tuple_size<base_tuple>::value) { ++std::get<N>(current); increment<N + 1>(); } } template <size_t N = 0> constexpr void decrement() noexcept { if constexpr (N != std::tuple_size<base_tuple>::value) { --std::get<N>(current); decrement<N + 1>(); } } template <size_t N = 0> constexpr void advance(difference_type __d) noexcept { if constexpr (N != std::tuple_size<base_tuple>::value) { std::get<N>(current) += __d; advance<N + 1>(__d); } } public: constexpr iterator() noexcept = default; constexpr iterator(base_tuple const ¤t) noexcept : current(current) {} constexpr bool operator==(const iterator &rhs) const noexcept { return equal(rhs); } constexpr bool operator!=(const iterator &rhs) const noexcept { return !equal(rhs); } constexpr iterator &operator++() noexcept { increment(); return *this; } constexpr iterator &operator--() noexcept { decrement(); return *this; } constexpr bool operator<(const iterator &rhs) const noexcept { return std::get<0>(current) < std::get<0>(rhs.current); } constexpr bool operator<=(const iterator &rhs) const noexcept { return std::get<0>(current) <= std::get<0>(rhs.current); } constexpr iterator &operator+=(difference_type __d) noexcept { advance(__d); return *this; } constexpr iterator &operator-=(difference_type __d) noexcept { advance(-__d); return *this; } constexpr iterator operator+(difference_type __d) const noexcept { return iterator{*this} += __d; } constexpr iterator operator-(difference_type __d) const noexcept { return iterator{*this} -= __d; } constexpr difference_type operator-(const iterator &rhs) const noexcept { return std::get<0>(current) - std::get<0>(rhs.current); } constexpr reference operator*() noexcept { return current; } }; constexpr iterator begin() const noexcept { return iterator{begin_cat()}; } constexpr iterator end() const noexcept { return iterator{end_cat()}; } constexpr reverse_iterator<iterator> rbegin() const noexcept { return reverse_iterator<iterator>{end()}; } constexpr reverse_iterator<iterator> rend() const noexcept { return reverse_iterator<iterator>{begin()}; } }; template <class Tp, class... Args> struct zipped_iterator_tuple<Tp, Args...> { using type = decltype(std::tuple_cat( std::declval<std::tuple<decltype(std::begin(std::declval<Tp>()))>>(), std::declval<typename zipped_iterator_tuple<Args...>::type>())); }; template <> struct zipped_iterator_tuple<> { using type = std::tuple<>; }; template <class Iter_tuple> struct zipped_iterator : Iter_tuple { constexpr zipped_iterator(Iter_tuple const &__t) noexcept : Iter_tuple::tuple(__t) {} constexpr zipped_iterator(zipped_iterator const &__t) = default; constexpr zipped_iterator &operator=(zipped_iterator const &__t) = default; // Avoid move initialization. constexpr zipped_iterator(zipped_iterator &&__t) : zipped_iterator(static_cast<zipped_iterator const &>(__t)) {} // Avoid move assignment. zipped_iterator &operator=(zipped_iterator &&__t) { return operator=(static_cast<zipped_iterator const &>(__t)); } template <size_t N> friend constexpr auto &get(zipped_iterator<Iter_tuple> const &__z) noexcept { return *std::get<N>(__z); } template <size_t N> friend constexpr auto get(zipped_iterator<Iter_tuple> &&__z) noexcept { return *std::get<N>(__z); } }; } // namespace internal } // namespace workspace namespace std { template <size_t N, class Iter_tuple> struct tuple_element<N, workspace::internal::zipped_iterator<Iter_tuple>> { using type = typename remove_reference<typename iterator_traits< typename tuple_element<N, Iter_tuple>::type>::reference>::type; }; template <class Iter_tuple> struct tuple_size<workspace::internal::zipped_iterator<Iter_tuple>> : tuple_size<Iter_tuple> {}; } // namespace std namespace workspace { template <class... Args> constexpr auto zip(Args &&... args) noexcept { return internal::zipped<Args...>(std::forward<Args>(args)...); } template <class... Args> constexpr auto zip(std::initializer_list<Args> const &... args) noexcept { return internal::zipped<const std::initializer_list<Args>...>(args...); } } // namespace workspace #endif #line 10 "Library/src/utils/py-like/enumerate.hpp" #if __cplusplus >= 201703L namespace workspace { constexpr size_t min_size() noexcept { return SIZE_MAX; } template <class Container, class... Args> constexpr size_t min_size(Container const &cont, Args &&... args) noexcept { return std::min(std::size(cont), min_size(std::forward<Args>(args)...)); } template <class... Args> constexpr auto enumerate(Args &&... args) noexcept { return zip(range(min_size(args...)), std::forward<Args>(args)...); } template <class... Args> constexpr auto enumerate(std::initializer_list<Args> const &... args) noexcept { return zip(range(min_size(args...)), std::vector(args)...); } } // namespace workspace #endif #line 2 "Library/src/utils/rand/rng.hpp" /** * @file rng.hpp * @brief Random Number Generator */ #line 9 "Library/src/utils/rand/rng.hpp" namespace workspace { template <typename Arithmetic> using uniform_distribution = typename std::conditional<std::is_integral<Arithmetic>::value, std::uniform_int_distribution<Arithmetic>, std::uniform_real_distribution<Arithmetic>>::type; template <typename Arithmetic> class random_number_generator : uniform_distribution<Arithmetic> { using base = uniform_distribution<Arithmetic>; std::mt19937 engine; public: template <class... Args> random_number_generator(Args&&... args) : base(args...), engine(std::random_device{}()) {} auto operator()() { return base::operator()(engine); } }; } // namespace workspace #line 2 "Library/src/utils/rand/shuffle.hpp" /** * @file shuffle.hpp * @brief Shuffle */ #line 10 "Library/src/utils/rand/shuffle.hpp" namespace workspace { template <class RAIter> void shuffle(RAIter const& __first, RAIter const& __last) { static std::mt19937 engine(std::random_device{}()); std::shuffle(__first, __last, engine); } } // namespace workspace #line 2 "Library/src/utils/round_div.hpp" /* * @file round_div.hpp * @brief Round Integer Division */ #line 9 "Library/src/utils/round_div.hpp" #line 11 "Library/src/utils/round_div.hpp" namespace workspace { /* * @fn floor_div * @brief floor of fraction. * @param x the numerator * @param y the denominator * @return maximum integer z s.t. z <= x / y * @note y must be nonzero. */ template <typename T1, typename T2> constexpr typename std::enable_if<(is_integral_ext<T1>::value && is_integral_ext<T2>::value), typename std::common_type<T1, T2>::type>::type floor_div(T1 x, T2 y) { assert(y != 0); if (y < 0) x = -x, y = -y; return x < 0 ? (x - y + 1) / y : x / y; } /* * @fn ceil_div * @brief ceil of fraction. * @param x the numerator * @param y the denominator * @return minimum integer z s.t. z >= x / y * @note y must be nonzero. */ template <typename T1, typename T2> constexpr typename std::enable_if<(is_integral_ext<T1>::value && is_integral_ext<T2>::value), typename std::common_type<T1, T2>::type>::type ceil_div(T1 x, T2 y) { assert(y != 0); if (y < 0) x = -x, y = -y; return x < 0 ? x / y : (x + y - 1) / y; } } // namespace workspace #line 7 "atcoder-workspace/a.cc" namespace workspace { using namespace std; using mint = modint<1000>; void main() { // start here! int n; cin >> n; bool even = !(n % 2); valarray<valarray<mint>> a = {{0, 2}, {1, 2}}; valarray<mint> v = {2, 2}; while (n) { if (n % 2) v = v[0] * a[0] + v[1] * a[1]; valarray nx(valarray<mint>(2), 2); for (auto i : range(2)) for (auto j : range(2)) nx[i] += a[i][j] * a[j]; a.swap(nx); n /= 2; } cout << v[0] - even << "\n"; } } // namespace workspace int main() { workspace::main(); }