#line 1 "other-workspace\\yuki.cc" // #undef _GLIBCXX_DEBUG // #define NDEBUG #include #line 2 "Library\\lib\\alias" /** * @file alias * @brief Alias */ #line 10 "Library\\lib\\alias" #line 2 "Library\\lib\\bit" #if __cplusplus > 201703L #include #else #ifndef _GLIBCXX_BIT #define _GLIBCXX_BIT 1 #include #include namespace std { template constexpr int __countl_zero(_Tp __x) noexcept { constexpr auto _Nd = numeric_limits<_Tp>::digits; if (__x == 0) return _Nd; constexpr auto _Nd_ull = numeric_limits::digits; constexpr auto _Nd_ul = numeric_limits::digits; constexpr auto _Nd_u = numeric_limits::digits; if _GLIBCXX17_CONSTEXPR(_Nd <= _Nd_u) { constexpr int __diff = _Nd_u - _Nd; return __builtin_clz(__x) - __diff; } else if _GLIBCXX17_CONSTEXPR(_Nd <= _Nd_ul) { constexpr int __diff = _Nd_ul - _Nd; return __builtin_clzl(__x) - __diff; } else if _GLIBCXX17_CONSTEXPR(_Nd <= _Nd_ull) { constexpr int __diff = _Nd_ull - _Nd; return __builtin_clzll(__x) - __diff; } else // (_Nd > _Nd_ull) { static_assert(_Nd <= (2 * _Nd_ull), "Maximum supported integer size is 128-bit"); unsigned long long __high = __x >> _Nd_ull; if (__high != 0) { constexpr int __diff = (2 * _Nd_ull) - _Nd; return __builtin_clzll(__high) - __diff; } constexpr auto __max_ull = numeric_limits::max(); unsigned long long __low = __x & __max_ull; return (_Nd - _Nd_ull) + __builtin_clzll(__low); } } template constexpr int __countr_zero(_Tp __x) noexcept { constexpr auto _Nd = numeric_limits<_Tp>::digits; if (__x == 0) return _Nd; constexpr auto _Nd_ull = numeric_limits::digits; constexpr auto _Nd_ul = numeric_limits::digits; constexpr auto _Nd_u = numeric_limits::digits; if _GLIBCXX17_CONSTEXPR(_Nd <= _Nd_u) return __builtin_ctz(__x); else if _GLIBCXX17_CONSTEXPR(_Nd <= _Nd_ul) return __builtin_ctzl(__x); else if _GLIBCXX17_CONSTEXPR(_Nd <= _Nd_ull) return __builtin_ctzll(__x); else // (_Nd > _Nd_ull) { static_assert(_Nd <= (2 * _Nd_ull), "Maximum supported integer size is 128-bit"); constexpr auto __max_ull = numeric_limits::max(); unsigned long long __low = __x & __max_ull; if (__low != 0) return __builtin_ctzll(__low); unsigned long long __high = __x >> _Nd_ull; return __builtin_ctzll(__high) + _Nd_ull; } } template constexpr int __popcount(_Tp __x) noexcept { constexpr auto _Nd = numeric_limits<_Tp>::digits; if (__x == 0) return 0; constexpr auto _Nd_ull = numeric_limits::digits; constexpr auto _Nd_ul = numeric_limits::digits; constexpr auto _Nd_u = numeric_limits::digits; if _GLIBCXX17_CONSTEXPR(_Nd <= _Nd_u) return __builtin_popcount(__x); else if _GLIBCXX17_CONSTEXPR(_Nd <= _Nd_ul) return __builtin_popcountl(__x); else if _GLIBCXX17_CONSTEXPR(_Nd <= _Nd_ull) return __builtin_popcountll(__x); else // (_Nd > _Nd_ull) { static_assert(_Nd <= (2 * _Nd_ull), "Maximum supported integer size is 128-bit"); constexpr auto __max_ull = numeric_limits::max(); unsigned long long __low = __x & __max_ull; unsigned long long __high = __x >> _Nd_ull; return __builtin_popcountll(__low) + __builtin_popcountll(__high); } } template constexpr _Tp __bit_ceil(_Tp __x) noexcept { constexpr auto _Nd = numeric_limits<_Tp>::digits; if (__x == 0 || __x == 1) return 1; auto __shift_exponent = _Nd - __countl_zero((_Tp)(__x - 1u)); #ifdef _GLIBCXX_HAVE_BUILTIN_IS_CONSTANT_EVALUATED if (!__builtin_is_constant_evaluated()) { __glibcxx_assert(__shift_exponent != numeric_limits<_Tp>::digits); } #endif using __promoted_type = decltype(__x << 1); if _GLIBCXX17_CONSTEXPR(!is_same<__promoted_type, _Tp>::value) { const int __extra_exp = sizeof(__promoted_type) / sizeof(_Tp) / 2; __shift_exponent |= (__shift_exponent & _Nd) << __extra_exp; } return (_Tp)1u << __shift_exponent; } template constexpr _Tp __bit_floor(_Tp __x) noexcept { constexpr auto _Nd = numeric_limits<_Tp>::digits; if (__x == 0) return 0; return (_Tp)1u << (_Nd - __countl_zero((_Tp)(__x >> 1))); } template constexpr _Tp __bit_width(_Tp __x) noexcept { constexpr auto _Nd = numeric_limits<_Tp>::digits; return _Nd - __countl_zero(__x); } } // namespace std #endif #endif #line 2 "Library\\lib\\limits" #line 4 "Library\\lib\\limits" namespace workspace { template struct numeric_limits : std::numeric_limits<_Tp> {}; #ifdef __SIZEOF_INT128__ template <> struct numeric_limits<__uint128_t> { constexpr static __uint128_t max() { return ~__uint128_t(0); } constexpr static __uint128_t min() { return 0; } }; template <> struct numeric_limits<__int128_t> { constexpr static __int128_t max() { return numeric_limits<__uint128_t>::max() >> 1; } constexpr static __int128_t min() { return -max() - 1; } }; #endif } // namespace workspace #line 13 "Library\\lib\\alias" namespace workspace { constexpr static char eol = '\n'; using namespace std; using i32 = int_least32_t; using u32 = uint_least32_t; using i64 = int_least64_t; using u64 = uint_least64_t; #ifdef __SIZEOF_INT128__ using i128 = __int128_t; using u128 = __uint128_t; #else #warning 128-bit integer is not available. #endif template () < std::declval())> constexpr typename std::conditional::value, const _T1 &, typename std::common_type<_T1, _T2>::type>::type min(const _T1 &__x, const _T2 &__y) noexcept { return __y < __x ? __y : __x; } template ()( std::declval(), std::declval()))> constexpr typename std::conditional::value, const _T1 &, typename std::common_type<_T1, _T2>::type>::type min(const _T1 &__x, const _T2 &__y, _Compare __comp) noexcept { return __comp(__y, __x) ? __y : __x; } template () < std::declval())> constexpr _Tp min(std::initializer_list<_Tp> __x) noexcept { return *std::min_element(__x.begin(), __x.end()); } template ()( std::declval(), std::declval()))> constexpr _Tp min(std::initializer_list<_Tp> __x, _Compare __comp) noexcept { return *std::min_element(__x.begin(), __x.end(), __comp); } template () < std::declval())> constexpr typename std::conditional::value, const _T1 &, typename std::common_type<_T1, _T2>::type>::type max(const _T1 &__x, const _T2 &__y) noexcept { return __x < __y ? __y : __x; } template ()( std::declval(), std::declval()))> constexpr typename std::conditional::value, const _T1 &, typename std::common_type<_T1, _T2>::type>::type max(const _T1 &__x, const _T2 &__y, _Compare __comp) noexcept { return __comp(__x, __y) ? __y : __x; } template () < std::declval())> constexpr _Tp max(std::initializer_list<_Tp> __x) noexcept { return *std::max_element(__x.begin(), __x.end()); } template ()( std::declval(), std::declval()))> constexpr _Tp max(std::initializer_list<_Tp> __x, _Compare __comp) noexcept { return *std::max_element(__x.begin(), __x.end(), __comp); } template constexpr _Tp __bsf(_Tp __x) noexcept { return std::__countr_zero(__x); } template constexpr _Tp __bsr(_Tp __x) noexcept { return std::__bit_width(__x) - 1; } } // namespace workspace #line 6 "other-workspace\\yuki.cc" // #include "lib/cxx20" #line 1 "Library\\lib\\direct" #ifdef ONLINE_JUDGE #pragma GCC optimize("O3") #pragma GCC target("avx,avx2") #pragma GCC optimize("unroll-loops") #endif #line 8 "other-workspace\\yuki.cc" // #include "lib/opt" #line 2 "Library\\src\\sys\\call_once.hpp" /** * @file call_once.hpp * @brief Call Once */ #line 9 "Library\\src\\sys\\call_once.hpp" namespace workspace { /** * @brief Call once. */ template void call_once(_F &&__f) { static std::unordered_set __called; if (__called.count(std::addressof(__f))) return; __called.emplace(std::addressof(__f)); __f(); } } // namespace workspace #line 2 "Library\\src\\sys\\clock.hpp" /* * @fn clock.hpp * @brief Clock */ #line 9 "Library\\src\\sys\\clock.hpp" namespace workspace { using namespace std::chrono; namespace internal { // The start time of the program. const auto start_time{system_clock::now()}; } // namespace internal /* * @fn elapsed * @return elapsed time of the program */ int64_t elapsed() { const auto end_time{system_clock::now()}; return duration_cast(end_time - internal::start_time).count(); } } // namespace workspace #line 2 "Library\\src\\sys\\ejection.hpp" /** * @file ejection.hpp * @brief Ejection */ #line 9 "Library\\src\\sys\\ejection.hpp" namespace workspace { namespace internal { struct ejection { bool exit = 0; }; } // namespace internal /** * @brief eject from a try block, throw nullptr * @param arg output */ template void eject(Tp const &arg) { std::cout << arg << "\n"; throw internal::ejection{}; } void exit() { throw internal::ejection{true}; } } // namespace workspace #line 2 "Library\\src\\sys\\iteration.hpp" /** * @file iteration.hpp * @brief Case Iteration */ #line 9 "Library\\src\\sys\\iteration.hpp" #line 11 "Library\\src\\sys\\iteration.hpp" namespace workspace { void main(); struct { // 1-indexed unsigned current{0}; unsigned total{1}; void read() { (std::cin >> total).ignore(); } int iterate() { static bool once = false; assert(!once); once = true; while (current++ < total) { try { main(); } catch (internal::ejection const& status) { if (status.exit) break; } } return 0; } } case_info; } // namespace workspace #line 2 "Library\\lib\\utils" // #include "src/utils/cached.hpp" #line 2 "Library\\src\\utils\\cat.hpp" /** * @file cat.hpp * @brief Cat */ #line 9 "Library\\src\\utils\\cat.hpp" namespace workspace { /** * @brief Concatenate two sequences. * * @param __c1 * @param __c2 * @return Concatenated sequence. */ template constexpr decltype(auto) cat(_C1 &&__c1, _C2 &&__c2) noexcept { auto __c = std::forward<_C1>(__c1); if constexpr (std::is_rvalue_reference::value) __c.insert(std::end(__c), std::move_iterator(std::begin(__c2)), std::move_iterator(std::end(__c2))); else __c.insert(std::end(__c), std::cbegin(__c2), std::cend(__c2)); return __c; } /** * @return Concatenated sequence. */ template constexpr decltype(auto) cat(_C1 &&__c1, _C2 &&__c2, _Args &&...__args) noexcept { return cat(cat(std::forward<_C1>(__c1), std::forward<_C2>(__c2)), std::forward<_Args>(__args)...); } } // 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 { /** * @brief Substitute __y for __x if __y < __x. * @param __x Reference * @param __y Comparison target * @return Whether or not __x is updated. */ template () < std::declval<_T1 &>())> typename std::enable_if::value, bool>::type chle( _T1 &__x, _T2 &&__y) noexcept { return __y < __x ? __x = std::forward<_T2>(__y), true : false; } /** * @brief Substitute __y for __x if __x < __y. * @param __x Reference * @param __y Comparison target * @return Whether or not __x is updated. */ template () < std::declval<_T2>())> typename std::enable_if::value, bool>::type chgr( _T1 &__x, _T2 &&__y) noexcept { return __x < __y ? __x = std::forward<_T2>(__y), true : false; } /** * @brief Substitute __y for __x if __comp(__y, __x) is true. * @param __x Reference * @param __y Comparison target * @param __comp Compare function object * @return Whether or not __x is updated. */ template ()(std::declval<_T2>(), std::declval<_T1 &>()))> typename std::enable_if::value, bool>::type chle( _T1 &__x, _T2 &&__y, _Compare __comp) noexcept { return __comp(__y, __x) ? __x = std::forward<_T2>(__y), true : false; } /** * @brief Substitute __y for __x if __comp(__x, __y) is true. * @param __x Reference * @param __y Comparison target * @param __comp Compare function object * @return Whether or not __x is updated. */ template ()(std::declval<_T1 &>(), std::declval<_T2>()))> typename std::enable_if::value, bool>::type chgr( _T1 &__x, _T2 &&__y, _Compare __comp) noexcept { return __comp(__x, __y) ? __x = std::forward<_T2>(__y), true : false; } } // namespace workspace #line 1 "Library\\src\\utils\\compare.hpp" /** * @file compare.hpp * @brief Compare */ #line 2 "Library\\src\\utils\\sfinae.hpp" /** * @file sfinae.hpp * @brief SFINAE */ #line 10 "Library\\src\\utils\\sfinae.hpp" #include #ifndef __INT128_DEFINED__ #ifdef __SIZEOF_INT128__ #define __INT128_DEFINED__ 1 #else #define __INT128_DEFINED__ 0 #endif #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; }; template <> struct is_signed<__uint128_t> : std::false_type {}; template <> struct is_signed<__int128_t> : std::true_type {}; template <> struct is_unsigned<__uint128_t> : std::true_type {}; template <> struct is_unsigned<__int128_t> : std::false_type {}; #endif } // namespace std namespace workspace { template struct variadic_front { using type = Tp; }; template struct variadic_back; template struct variadic_back { using type = Tp; }; template struct variadic_back { using type = typename variadic_back::type; }; template class trait> using enable_if_trait_type = typename std::enable_if::value>::type; /** * @brief Return type of subscripting ( @c [] ) access. */ template using subscripted_type = typename std::decay()[0])>::type; template using element_type = typename std::decay()))>::type; template struct has_begin : std::false_type {}; template struct has_begin<_Tp, decltype(std::begin(std::declval<_Tp>()), nullptr)> : std::true_type {}; template struct has_mod : std::false_type {}; template struct has_mod<_Tp, std::__void_t> : std::true_type {}; template struct is_integral_ext : std::false_type {}; template struct is_integral_ext< _Tp, typename std::enable_if::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 constexpr static bool is_integral_ext_v = is_integral_ext<_Tp>::value; #endif template struct multiplicable_uint { using type = uint_least32_t; }; template struct multiplicable_uint< _Tp, typename std::enable_if<(2 < sizeof(_Tp)) && (!__INT128_DEFINED__ || sizeof(_Tp) <= 4)>::type> { using type = uint_least64_t; }; #if __INT128_DEFINED__ template struct multiplicable_uint<_Tp, typename std::enable_if<(4 < sizeof(_Tp))>::type> { using type = __uint128_t; }; #endif template struct multiplicable_int { using type = typename std::make_signed::type>::type; }; template struct multiplicable { using type = std::conditional_t< is_integral_ext<_Tp>::value, std::conditional_t::value, typename multiplicable_int<_Tp>::type, typename multiplicable_uint<_Tp>::type>, _Tp>; }; template struct first_arg { using type = void; }; template struct first_arg<_R(_Tp, _Args...)> { using type = _Tp; }; template struct first_arg<_R (*)(_Tp, _Args...)> { using type = _Tp; }; template struct first_arg<_R (_G::*)(_Tp, _Args...)> { using type = _Tp; }; template struct first_arg<_R (_G::*)(_Tp, _Args...) const> { using type = _Tp; }; template struct parse_compare : first_arg<_Tp> {}; template struct parse_compare<_Tp, std::__void_t> : first_arg {}; } // namespace workspace #line 7 "Library\\src\\utils\\compare.hpp" namespace workspace { /** * @brief Compare 2 points by their value of `atan2`. * * @return */ template bool compare_arg(const _Tp& __p1, const _Tp& __p2) noexcept { const auto& [__x1, __y1] = __p1; const auto& [__x2, __y2] = __p2; using value_type = std::decay_t; using mul_type = typename multiplicable::type; if (__y1 == value_type(0)) return value_type(0) <= __x1 && (value_type(0) < __y2 || (__y2 == value_type(0) && __x2 < value_type(0))); return value_type(0) < __y1 ? value_type(0) <= __y2 && mul_type(__y1) * __x2 < mul_type(__x1) * __y2 : value_type(0) <= __y2 || mul_type(__y1) * __x2 < mul_type(__x1) * __y2; } } // 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 { /** * @brief Fixed Point Combinator */ template class fixed_point { _F __fn; public: /** * @brief Construct a new fixed point object * * @param __fn 1st argument callable with the rest of its arguments. * Return type specified. */ fixed_point(_F __fn) noexcept : __fn(std::forward<_F>(__fn)) {} /** * @brief Apply *this to 1st argument. * @param __args Rest of arguments. */ template decltype(auto) operator()(_Args &&...__args) const { return __fn(*this, std::forward<_Args>(__args)...); } }; } // 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 struct hash : std::hash {}; template struct hash<_Tp *> : std::hash<_Tp *> {}; #if __cplusplus >= 201703L template struct hash> { 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 size_t hash_combine(const size_t &seed, const Key &key) { return seed ^ (hash()(key) + 0x9e3779b9 /* + (seed << 6) + (seed >> 2) */); } template struct hash> { size_t operator()(const std::pair &pair) const { return hash_combine(hash()(pair.first), pair.second); } }; template class hash> { template ::value - 1> struct tuple_hash { static uint64_t apply(const Tuple &t) { return hash_combine(tuple_hash::apply(t), std::get(t)); } }; template struct tuple_hash { static uint64_t apply(const Tuple &t) { return 0; } }; public: uint64_t operator()(const std::tuple &t) const { return tuple_hash>::apply(t); } }; template 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 auto emplace(Args &&... args) { return hash_table::insert(typename hash_table::value_type(args...)); } }; template using cc_hash_table = hash_table_wrapper<__gnu_pbds::cc_hash_table>>; template using gp_hash_table = hash_table_wrapper<__gnu_pbds::gp_hash_table>>; template using unordered_map = std::unordered_map>; template using unordered_set = std::unordered_set>; } // namespace workspace #line 2 "Library\\src\\utils\\io\\istream.hpp" /** * @file istream.hpp * @brief Input Stream */ #include #line 13 "Library\\src\\utils\\io\\istream.hpp" #line 15 "Library\\src\\utils\\io\\istream.hpp" namespace workspace { namespace _istream_impl { template struct istream_helper { istream_helper(std::istream &__is, _Tp &__x) { if constexpr (has_begin<_Tp>::value) for (auto &&__e : __x) istream_helper>(__is, __e); else static_assert(has_begin<_Tp>::value, "istream unsupported type."); } }; template struct istream_helper< _Tp, decltype(std::declval() >> std::declval<_Tp &>())>>(), nullptr)> { istream_helper(std::istream &__is, _Tp &__x) { __is >> __x; } }; #ifdef __SIZEOF_INT128__ template <> struct istream_helper<__uint128_t, std::nullptr_t> { istream_helper(std::istream &__is, __uint128_t &__x) { std::string __s; __is >> __s; bool __neg = false; if (__s.front() == '-') __neg = true, __s.erase(__s.begin()); __x = 0; for (char __d : __s) { __x *= 10; __d -= '0'; if (__neg) __x -= __d; else __x += __d; } } }; template <> struct istream_helper<__int128_t, std::nullptr_t> { istream_helper(std::istream &__is, __int128_t &__x) { std::string __s; __is >> __s; bool __neg = false; if (__s.front() == '-') __neg = true, __s.erase(__s.begin()); __x = 0; for (char __d : __s) { __x *= 10; __d -= '0'; if (__neg) __x -= __d; else __x += __d; } } }; #endif // INT128 template struct istream_helper> { istream_helper(std::istream &__is, std::pair &__x) { istream_helper(__is, __x.first), istream_helper(__is, __x.second); } }; template struct istream_helper> { istream_helper(std::istream &__is, std::tuple &__x) { iterate(__is, __x); } private: template void iterate(std::istream &__is, _Tp &__x) { if constexpr (N == std::tuple_size<_Tp>::value) return; else istream_helper::type>( __is, std::get(__x)), iterate<_Tp, N + 1>(__is, __x); } }; } // namespace _istream_impl /** * @brief A wrapper class for std::istream. */ class istream : public std::istream { public: /** * @brief Wrapped operator. */ template istream &operator>>(_Tp &__x) { _istream_impl::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; } }; decltype(auto) cin = static_cast(std::cin); } // namespace workspace #line 9 "Library\\lib\\utils" // #include "src/utils/io/ostream.hpp" // #include "src/utils/io/read.hpp" #line 2 "Library\\src\\utils\\grid\\motion.hpp" /** * @file motion.hpp * @brief Motion */ #line 9 "Library\\src\\utils\\grid\\motion.hpp" namespace workspace { /** * @brief Transpose. * * @param __grid */ template >()[0].resize(0))> constexpr decltype(auto) transpose(_Grid &&__grid) noexcept { auto __h = std::size(__grid), __w = std::size(__grid[0]); std::decay_t<_Grid> __t(__w); for (auto &&__r : __t) __r.resize(__h); for (size_t __i = 0; __i != __h; ++__i) for (size_t __j = 0; __j != __w; ++__j) if constexpr (std::is_rvalue_reference::value) __t[__j][__i] = std::move(__grid[__i][__j]); else __t[__j][__i] = __grid[__i][__j]; return __t; } /** * @brief Transpose. * * @param __grid */ template constexpr decltype(auto) transpose(const _Tp (&__grid)[_Rows][_Cols]) noexcept { std::array, _Cols> __t; for (size_t __i = 0; __i != _Rows; ++__i) for (size_t __j = 0; __j != _Cols; ++__j) __t[__j][__i] = __grid[__i][__j]; return __t; } /** * @brief Transpose. * * @param __grid */ template constexpr decltype(auto) transpose(_Tp(&&__grid)[_Rows][_Cols]) noexcept { std::array, _Cols> __t; for (size_t __i = 0; __i != _Rows; ++__i) for (size_t __j = 0; __j != _Cols; ++__j) __t[__j][__i] = std::move(__grid[__i][__j]); return __t; } /** * @brief Transpose. * * @param __grid */ template constexpr decltype(auto) transpose( const std::array, _Rows> &__grid) noexcept { std::array, _Cols> __t; for (size_t __i = 0; __i != _Rows; ++__i) for (size_t __j = 0; __j != _Cols; ++__j) __t[__j][__i] = __grid[__i][__j]; return __t; } /** * @brief Transpose. * * @param __grid */ template constexpr decltype(auto) transpose( std::array, _Rows> &&__grid) noexcept { std::array, _Cols> __t; for (size_t __i = 0; __i != _Rows; ++__i) for (size_t __j = 0; __j != _Cols; ++__j) __t[__j][__i] = std::move(__grid[__i][__j]); return __t; } /** * @brief Roll the grid counter-clockwise. * * @param __grid * @return */ template decltype(auto) roll_ccw(_Grid &&__grid) noexcept { if constexpr (std::is_rvalue_reference::value) { auto __t = transpose(std::move(__grid)); std::reverse(std::begin(__t), std::end(__t)); return __t; } else { auto __t = transpose(__grid); std::reverse(std::begin(__t), std::end(__t)); return __t; } } /** * @brief Roll the grid clockwise. * * @param __grid * @return */ template decltype(auto) roll_cw(_Grid &&__grid) noexcept { if constexpr (std::is_rvalue_reference::value) { std::reverse(std::begin(__grid), std::end(__grid)); return transpose(std::move(__grid)); } else { auto __t = transpose(__grid); for (auto &&__r : __t) std::reverse(std::begin(__r), std::end(__r)); return __t; } } } // namespace workspace #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 { /** * @brief Setup I/O. * @param __n Standard output precision */ void io_setup(int __n) { std::cin.tie(0)->sync_with_stdio(0); std::cout << std::fixed << std::setprecision(__n); #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 ::value - 1> struct common_iterator_category { using type = typename std::common_type< typename common_iterator_category::type, typename std::iterator_traits::type>::iterator_category>::type; }; template struct common_iterator_category { 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 #include namespace workspace { /* * @class reverse_iterator * @brief Wrapper class for `std::reverse_iterator`. * @see http://gcc.gnu.org/PR51823 */ template class reverse_iterator : public std::reverse_iterator { using base_std = std::reverse_iterator; std::optional 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 15 "Library\\lib\\utils" // #include "src/utils/make_vector.hpp" // #include "src/utils/py-like/enumerate.hpp" #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 #line 10 "Library\\src\\utils\\py-like\\reversed.hpp" namespace workspace { namespace _reversed_impl { template class reversed { _Container __cont; public: constexpr reversed(_Container &&__cont) noexcept : __cont(__cont) {} constexpr decltype(auto) begin() noexcept { return std::rbegin(__cont); } constexpr decltype(auto) begin() const noexcept { return std::rbegin(__cont); } constexpr decltype(auto) end() noexcept { return std::rend(__cont); } constexpr decltype(auto) end() const noexcept { return std::rend(__cont); } constexpr decltype(auto) size() const noexcept { return std::size(__cont); } }; } // namespace _reversed_impl template constexpr decltype(auto) reversed(_Container &&__cont) noexcept { return _reversed_impl::reversed<_Container>{std::forward<_Container>(__cont)}; } template constexpr decltype(auto) reversed( std::initializer_list<_Tp> &&__cont) noexcept { return _reversed_impl::reversed>{ std::forward>(__cont)}; } } // namespace workspace #line 12 "Library\\src\\utils\\py-like\\range.hpp" #if __cplusplus >= 201703L namespace workspace { template 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::random_access_iterator_tag; constexpr iterator(const _Index &__i = _Index()) noexcept : current(__i) {} constexpr bool operator==(const iterator &__x) const noexcept { return current == __x.current; } constexpr bool operator!=(const iterator &__x) const noexcept { return current != __x.current; } constexpr bool operator<(const iterator &__x) const noexcept { return current < __x.current; } constexpr bool operator<=(const iterator &__x) const noexcept { return current <= __x.current; } constexpr bool operator>(const iterator &__x) const noexcept { return current > __x.current; } constexpr bool operator>=(const iterator &__x) const noexcept { return current >= __x.current; } constexpr iterator &operator++() noexcept { ++current; return *this; } constexpr iterator &operator++(int) noexcept { auto __tmp = *this; ++current; return __tmp; } constexpr iterator &operator--() noexcept { --current; return *this; } constexpr iterator &operator--(int) noexcept { auto __tmp = *this; --current; return __tmp; } constexpr difference_type operator-(const iterator &__x) const noexcept { return current - __x.current; } constexpr iterator &operator+=(difference_type __x) noexcept { current += __x; return *this; } constexpr iterator operator+(difference_type __x) const noexcept { return iterator(*this) += __x; } constexpr iterator &operator-=(difference_type __x) noexcept { current -= __x; return *this; } constexpr iterator operator-(difference_type __x) const noexcept { return iterator(*this) -= __x; } 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 rbegin() const noexcept { return reverse_iterator(end()); } constexpr reverse_iterator rend() const noexcept { return reverse_iterator(begin()); } constexpr size_t size() const noexcept { return std::distance(__first, __last); } }; template constexpr decltype(auto) rrange(_Args &&...__args) noexcept { return reversed(range(std::forward<_Args>(__args)...)); } template constexpr decltype(auto) iterate(_Container &&__cont) noexcept { return range(std::begin(__cont), std::end(__cont)); } template constexpr decltype(auto) riterate(_Container &&__cont) noexcept { return range(std::rbegin(__cont), std::rend(__cont)); } } // namespace workspace #endif #line 18 "Library\\lib\\utils" // #include "src/utils/py-like/reversed.hpp" // #include "src/utils/py-like/zip.hpp" #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 using uniform_distribution = typename std::conditional< std::is_integral<_Arithmetic>::value, std::uniform_int_distribution<_Arithmetic>, std::uniform_real_distribution<_Arithmetic>>::type; template class random_number_generator : uniform_distribution<_Arithmetic> { using base = uniform_distribution<_Arithmetic>; _Engine __engine; public: random_number_generator(_Arithmetic __min, _Arithmetic __max) : base(__min, __max), __engine(std::random_device{}()) {} random_number_generator(_Arithmetic __max = 1) : random_number_generator(0, __max) {} random_number_generator(typename base::param_type const& __param) : base(__param), __engine(std::random_device{}()) {} decltype(auto) operator()() noexcept { 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 void shuffle(_RAIter __first, _RAIter __last) { static _Engine __engine(std::random_device{}()); std::shuffle(__first, __last, __engine); } } // namespace workspace #line 2 "Library\\src\\utils\\rand\\tree.hpp" #line 4 "Library\\src\\utils\\rand\\tree.hpp" #line 6 "Library\\src\\utils\\rand\\tree.hpp" namespace workspace { auto random_tree(std::size_t __n) { std::vector> __edges; random_number_generator rng(std::size_t(0), __n); for (std::size_t __i = 1; __i != __n; ++__i) __edges.emplace_back(__i + 1, rng() % __i + 1); return __edges; } } // 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 constexpr typename std::enable_if<(is_integral_ext::value && is_integral_ext::value), typename std::common_type::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 constexpr typename std::enable_if<(is_integral_ext::value && is_integral_ext::value), typename std::common_type::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 24 "Library\\lib\\utils" // #include "src\utils\reference_list.hpp" #line 11 "other-workspace\\yuki.cc" signed main() { using namespace workspace; io_setup(15); /* given case_info.read(); //*/ /* unspecified case_info.total = -1; //*/ return case_info.iterate(); } namespace workspace { void main() { // start here! int n; cin >> n; vector> tree(n); for (auto i : range(1, n)) { int p; cin >> p; --p; tree[p].emplace_back(i); } vector a(n), b(n); cin >> a >> b; for (auto&& x : a) { x = n + 1 - x; } using mp = map; auto meld = [&](mp & a, mp & b) -> auto { if (a.size() < b.size()) { a.swap(b); } for (auto&& [x, y] : b) { a[x] += y; } }; vector dp(n); fixed_point([&](const auto& dfs, int now) -> void { mp& here = dp[now]; for (auto&& to : tree[now]) { dfs(to); meld(here, dp[to]); } auto A = a[now], B = b[now]; i64 add = 0; while (true) { auto lb = here.lower_bound(A); if (lb == here.end()) break; lb->second += add; if (0 < lb->second - B) { lb->second -= B; break; } add = lb->second; here.erase(lb); } here.emplace(A, B); })(0); auto ret = dp[0]; i64 ans{}; for (auto&& [a, b] : ret) { ans += b; } cout << ans << "\n"; } } // namespace workspace