#line 1 "atcoder-workspace/17.cc" // #undef _GLIBCXX_DEBUG // #define NDEBUG #include #line 2 "Library/lib/alias" /** * @file alias * @brief Alias */ #line 13 "Library/lib/alias" #line 1 "Library/lib/bit" #if __cplusplus > 201703L #include #else #ifndef _GLIBCXX_BIT #define _GLIBCXX_BIT 1 #include #include namespace std { template constexpr _Tp __rotl(_Tp __x, int __s) noexcept { constexpr auto _Nd = numeric_limits<_Tp>::digits; const int __r = __s % _Nd; if (__r == 0) return __x; else if (__r > 0) return (__x << __r) | (__x >> ((_Nd - __r) % _Nd)); else return (__x >> -__r) | (__x << ((_Nd + __r) % _Nd)); // rotr(x, -r) } template constexpr _Tp __rotr(_Tp __x, int __s) noexcept { constexpr auto _Nd = numeric_limits<_Tp>::digits; const int __r = __s % _Nd; if (__r == 0) return __x; else if (__r > 0) return (__x >> __r) | (__x << ((_Nd - __r) % _Nd)); else return (__x << -__r) | (__x >> ((_Nd + __r) % _Nd)); // rotl(x, -r) } 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 __countl_one(_Tp __x) noexcept { if (__x == numeric_limits<_Tp>::max()) return numeric_limits<_Tp>::digits; return __countl_zero<_Tp>((_Tp)~__x); } 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 __countr_one(_Tp __x) noexcept { if (__x == numeric_limits<_Tp>::max()) return numeric_limits<_Tp>::digits; return __countr_zero((_Tp)~__x); } 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 bool __has_single_bit(_Tp __x) noexcept { return __popcount(__x) == 1; } 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 15 "Library/lib/alias" namespace workspace { constexpr 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 128bit integer is not available. #endif template > using priority_queue = std::priority_queue, Comp>; template using stack = std::stack>; 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 "atcoder-workspace/17.cc" // #include "lib/cxx20" #line 2 "Library/lib/direct" /* * @file direct * @brief Pragma Directive */ #ifdef ONLINE_JUDGE #pragma GCC optimize("O3") #pragma GCC target("avx,avx2") #pragma GCC optimize("unroll-loops") #endif #line 2 "Library/src/opt/binary_search.hpp" /* * @file binary_search.hpp * @brief Binary Search */ #line 12 "Library/src/opt/binary_search.hpp" namespace workspace { /* * @fn binary_search * @brief binary search on a discrete range. * @param ok pred(ok) is true * @param ng pred(ng) is false * @param pred the predicate * @return the closest point to (ng) where pred is true */ template typename std::enable_if< std::is_convertible()(std::declval())), bool>::value, Iter>::type binary_search(Iter ok, Iter ng, Pred pred) { assert(ok != ng); typename std::make_signed::type dist(ng - ok); while (1 < dist || dist < -1) { const Iter mid(ok + dist / 2); if (pred(mid)) ok = mid, dist -= dist / 2; else ng = mid, dist /= 2; } return ok; } /* * @fn binary_search * @brief binary search on the real number line. * @param ok pred(ok) is true * @param ng pred(ng) is false * @param eps the error tolerance * @param pred the predicate * @return the boundary point */ template typename std::enable_if< std::is_convertible()(std::declval())), bool>::value, Real>::type binary_search(Real ok, Real ng, const Real eps, Pred pred) { assert(ok != ng); for (auto loops = 0; loops != std::numeric_limits::digits && (ok + eps < ng || ng + eps < ok); ++loops) { const Real mid{(ok + ng) / 2}; (pred(mid) ? ok : ng) = mid; } return ok; } /* * @fn parallel_binary_search * @brief parallel binary search on discrete ranges. * @param ends a vector of pairs; pred(first) is true, pred(second) is false * @param pred the predicate * @return the closest points to (second) where pred is true */ template (std::declval()[0]))>::type, class Pred> typename std::enable_if< std::is_convertible< decltype(std::declval()(std::declval>())[0]), bool>::value, std::vector>::type parallel_binary_search(Array ends, Pred pred) { std::vector mids(std::size(ends)); for (;;) { bool all_found = true; for (size_t i{}; i != std::size(ends); ++i) { const Iter &ok = std::get<0>(ends[i]); const Iter &ng = std::get<1>(ends[i]); const Iter mid( ok + typename std::make_signed::type(ng - ok) / 2); if (mids[i] != mid) { all_found = false; mids[i] = mid; } } if (all_found) break; const auto res = pred(mids); for (size_t i{}; i != std::size(ends); ++i) { (res[i] ? std::get<0>(ends[i]) : std::get<1>(ends[i])) = mids[i]; } } return mids; } /* * @fn parallel_binary_search * @brief parallel binary search on the real number line. * @param ends a vector of pairs; pred(first) is true, pred(second) is false * @param eps the error tolerance * @param pred the predicate * @return the boundary points */ template (std::declval()[0]))>::type, class Pred> typename std::enable_if< std::is_convertible< decltype(std::declval()(std::declval>())[0]), bool>::value, std::vector>::type parallel_binary_search(Array ends, const Real eps, Pred pred) { std::vector mids(std::size(ends)); for (auto loops = 0; loops != std::numeric_limits::digits; ++loops) { bool all_found = true; for (size_t i{}; i != std::size(ends); ++i) { const Real ok = std::get<0>(ends[i]); const Real ng = std::get<1>(ends[i]); if (ok + eps < ng || ng + eps < ok) { all_found = false; mids[i] = (ok + ng) / 2; } } if (all_found) break; const auto res = pred(mids); for (size_t i{}; i != std::size(ends); ++i) { (res[i] ? std::get<0>(ends[i]) : std::get<1>(ends[i])) = mids[i]; } } return mids; } } // namespace workspace #line 2 "Library/src/opt/exponential_search.hpp" /* * @file exponential_search.hpp * @brief Exponential Search */ #line 9 "Library/src/opt/exponential_search.hpp" namespace workspace { /* * @fn exponential_search * @brief Exponential search on a discrete range. * @param range Range of search, exclusive * @param pred Predicate * @return Minimum non-negative integer where pred is false. */ template typename std::enable_if< std::is_convertible()(std::declval())), bool>::value, Index>::type exponential_search(Index range, Pred pred) { Index step(1); while (step < range && pred(step)) step <<= 1; if (range < step) step = range; return binary_search(Index(0), step, pred); } /* * @fn exponential_search * @brief Exponential search on the real number line. * @param range Range of search * @param eps Error tolerance * @param pred Predicate * @return Boundary point. */ template typename std::enable_if< std::is_convertible()(std::declval())), bool>::value, Real>::type exponential_search(Real range, Real const &eps, Pred pred) { Real step(1); while (step < range && pred(step)) step += step; if (range < step) step = range; return binary_search(Real(0), step, eps, pred); } } // namespace workspace #line 2 "Library/src/opt/trinary_search.hpp" /* * @file trinary_search.hpp * @brief Trinary Search */ #line 9 "Library/src/opt/trinary_search.hpp" #include namespace workspace { /* * @brief Trinary search on discrete range. * @param first Left end, inclusive * @param last Right end, exclusive * @param comp Compare function * @return Local minimal point. */ template typename std::enable_if< std::is_convertible()(std::declval(), std::declval())), bool>::value, Iter>::type trinary_search(Iter first, Iter last, Comp comp) { assert(first < last); typename std::make_signed::type dist(last - first); while (2 < dist) { Iter left(first + dist / 3), right(first + dist * 2 / 3); if (comp(left, right)) last = right, dist = (dist + dist) / 3; else first = left, dist -= dist / 3; } if (1 < dist && comp(first + 1, first)) ++first; return first; } /* * @brief Trinary search on discrete range. * @param first Left end, inclusive * @param last Right end, exclusive * @param func Function * @return Local minimal point. */ template typename std::enable_if< std::is_same()(std::declval()), nullptr), std::nullptr_t>::value, Iter>::type trinary_search(Iter const &first, Iter const &last, Func func) { return trinary_search(first, last, [&](Iter const &__i, Iter const &__j) { return func(__i) < func(__j); }); } /* * @brief Trinary search on the real number line. * @param first Left end * @param last Right end * @param eps Error tolerance * @param comp Compare function * @return Local minimal point. */ template typename std::enable_if< std::is_convertible()(std::declval(), std::declval())), bool>::value, Real>::type trinary_search(Real first, Real last, Real const &eps, Comp comp) { assert(first < last); while (eps < last - first) { Real left{(first * 2 + last) / 3}, right{(first + last * 2) / 3}; if (comp(left, right)) last = right; else first = left; } return first; } /* * @brief Trinary search on the real number line. * @param first Left end * @param last Right end * @param eps Error tolerance * @param func Function * @return Local minimal point. */ template typename std::enable_if< std::is_same()(std::declval()), nullptr), std::nullptr_t>::value, Real>::type trinary_search(Real const &first, Real const &last, Real const &eps, Func func) { return trinary_search( first, last, eps, [&](Real const &__i, Real const &__j) { return func(__i) < func(__j); }); } } // 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/src/utils/cat.hpp" /** * @file cat.hpp * @brief Cat */ #line 9 "Library/src/utils/cat.hpp" namespace workspace { template 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 > 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 > 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 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 auto operator()(Args &&... args) const { return func(*this, std::forward(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 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::type{}); __i->insert(__i->end(), __x); ++__i; } } return __t; } // template // std::array, _Col> transpose(_Tp (&__g)[_Row][_Col]) {} template Grid roll_ccw(Grid const &grid) { auto __t = transpose(grid); std::reverse(std::begin(__t), std::end(__t)); return __t; } template 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 2 "Library/src/utils/sfinae.hpp" /** * @file sfinae.hpp * @brief SFINAE */ #line 11 "Library/src/utils/sfinae.hpp" #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 trait> using enable_if_trait_type = typename std::enable_if::value>::type; template using element_type = typename std::decay()))>::type; template struct has_begin : std::false_type {}; template struct has_begin()), nullptr)> : std::true_type {}; template struct mapped_of { using type = element_type; }; template struct mapped_of::first_type> { using type = typename T::mapped_type; }; template using mapped_type = typename mapped_of::type; template struct is_integral_ext : std::false_type {}; template struct is_integral_ext< T, 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::value; #endif template struct multiplicable_uint { using type = uint_least32_t; }; template 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 struct multiplicable_uint::type> { using type = __uint128_t; }; #endif template struct multiplicable_int { using type = typename std::make_signed::type>::type; }; } // namespace workspace #line 10 "Library/src/utils/hash.hpp" namespace workspace { template struct hash : std::hash {}; #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 internal { template struct istream_helper { istream_helper(std::istream &is, Tp &x) { if constexpr (has_begin::value) for (auto &&e : x) istream_helper::type>(is, e); else static_assert(has_begin::value, "istream unsupported type."); } }; template struct istream_helper< Tp, decltype(std::declval() >> std::declval())>>(), 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 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::value) return; else istream_helper::type>(is, std::get(x)), iterate(is, x); } }; } // namespace internal /** * @brief A wrapper class for std::istream. */ class istream : public std::istream { public: /** * @brief Wrapped operator. */ template istream &operator>>(Tp &x) { internal::istream_helper(*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 std::ostream &operator<<(std::ostream &os, const std::pair &p) { return os << p.first << ' ' << p.second; } template struct tuple_os { static std::ostream &apply(std::ostream &os, const tuple_t &t) { tuple_os::apply(os, t); return os << ' ' << std::get(t); } }; template struct tuple_os { static std::ostream &apply(std::ostream &os, const tuple_t &t) { return os << std::get<0>(t); } }; template struct tuple_os { static std::ostream &apply(std::ostream &os, const tuple_t &t) { return os; } }; template std::ostream &operator<<(std::ostream &os, const std::tuple &t) { return tuple_os, std::tuple_size>::value - 1>::apply(os, t); } template ()))> typename std::enable_if< !std::is_same::type, std::string>::value && !std::is_same::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 ::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 2 "Library/src/utils/make_vector.hpp" /* * @file make_vector.hpp * @brief Multi-dimensional Vector */ #if __cplusplus >= 201703L #include #include 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 constexpr auto make_vector([[maybe_unused]] S* sizes, Tp const& init = Tp()) { static_assert(std::is_convertible_v); if constexpr (N) return std::vector(*sizes, make_vector(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 constexpr auto make_vector(const S (&sizes)[N], Tp const& init = Tp()) { return make_vector((S*)sizes, init); } /* * @brief Make a multi-dimensional vector. * @param sizes The size of each dimension * @param init The initial value */ template constexpr auto make_vector([[maybe_unused]] std::array const& sizes, Tp const& init = Tp()) { static_assert(std::is_convertible_v); if constexpr (I == N) return init; else return std::vector(sizes[I], make_vector(sizes, init)); } /* * @brief Make a multi-dimensional vector. * @param sizes The size of each dimension * @param init The initial value */ template constexpr auto make_vector([[maybe_unused]] std::tuple const& sizes, Tp const& init = Tp()) { using tuple_type = std::tuple; if constexpr (I == std::tuple_size_v || I == N) return init; else { static_assert( std::is_convertible_v, size_t>); return std::vector(std::get(sizes), make_vector(sizes, init)); } } /* * @brief Make a multi-dimensional vector. * @param sizes The size of each dimension * @param init The initial value */ template constexpr auto make_vector(std::pair const& sizes, Tp const& init = Tp()) { static_assert(std::is_convertible_v); static_assert(std::is_convertible_v); 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 #line 10 "Library/src/utils/py-like/reversed.hpp" namespace workspace { namespace internal { template 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 constexpr auto reversed(Container &&cont) noexcept { return internal::reversed{std::forward(cont)}; } template constexpr auto reversed(std::initializer_list &&cont) noexcept { return internal::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::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 rbegin() const noexcept { return reverse_iterator(end()); } constexpr reverse_iterator rend() const noexcept { return reverse_iterator(begin()); } }; template constexpr auto rrange(Args &&... args) noexcept { return internal::reversed(range(std::forward(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 struct zipped_iterator; template struct zipped_iterator_tuple; template class zipped { using ref_tuple = std::tuple; ref_tuple args; template constexpr auto begin_cat() const noexcept { if constexpr (N != std::tuple_size::value) { return std::tuple_cat(std::tuple(std::begin(std::get(args))), begin_cat()); } else return std::tuple<>(); } template constexpr auto end_cat() const noexcept { if constexpr (N != std::tuple_size::value) { return std::tuple_cat(std::tuple(std::end(std::get(args))), end_cat()); } else return std::tuple<>(); } public: constexpr zipped(Args &&... args) noexcept : args(args...) {} class iterator { using base_tuple = typename zipped_iterator_tuple::type; public: using iterator_category = typename common_iterator_category::type; using difference_type = std::ptrdiff_t; using value_type = zipped_iterator; using reference = zipped_iterator &; using pointer = iterator; protected: value_type current; template constexpr bool equal(const iterator &rhs) const noexcept { if constexpr (N != std::tuple_size::value) { return std::get(current) == std::get(rhs.current) || equal(rhs); } else return false; } template constexpr void increment() noexcept { if constexpr (N != std::tuple_size::value) { ++std::get(current); increment(); } } template constexpr void decrement() noexcept { if constexpr (N != std::tuple_size::value) { --std::get(current); decrement(); } } template constexpr void advance(difference_type __d) noexcept { if constexpr (N != std::tuple_size::value) { std::get(current) += __d; advance(__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 rbegin() const noexcept { return reverse_iterator{end()}; } constexpr reverse_iterator rend() const noexcept { return reverse_iterator{begin()}; } }; template struct zipped_iterator_tuple { using type = decltype(std::tuple_cat( std::declval()))>>(), std::declval::type>())); }; template <> struct zipped_iterator_tuple<> { using type = std::tuple<>; }; template 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(__t)) {} // Avoid move assignment. zipped_iterator &operator=(zipped_iterator &&__t) { return operator=(static_cast(__t)); } template friend constexpr auto &get(zipped_iterator const &__z) noexcept { return *std::get(__z); } template friend constexpr auto get(zipped_iterator &&__z) noexcept { return *std::get(__z); } }; } // namespace internal } // namespace workspace namespace std { template struct tuple_element> { using type = typename remove_reference::type>::reference>::type; }; template struct tuple_size> : tuple_size {}; } // namespace std namespace workspace { template constexpr auto zip(Args &&... args) noexcept { return internal::zipped(std::forward(args)...); } template constexpr auto zip(std::initializer_list const &... args) noexcept { return internal::zipped...>(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 constexpr size_t min_size(Container const &cont, Args &&... args) noexcept { return std::min(std::size(cont), min_size(std::forward(args)...)); } template constexpr auto enumerate(Args &&... args) noexcept { return zip(range(min_size(args...)), std::forward(args)...); } template constexpr auto enumerate(std::initializer_list 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 using uniform_distribution = typename std::conditional::value, std::uniform_int_distribution, std::uniform_real_distribution>::type; template class random_number_generator : uniform_distribution { using base = uniform_distribution; std::mt19937 engine; public: template 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 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 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 11 "atcoder-workspace/17.cc" signed main() { using namespace workspace; io_setup(15); /* given case_info.read(); //*/ /* unspecified case_info.total = -1; //*/ return case_info.iterate(); } #line 2 "Library/lib/graph" // #include "src/graph/directed/flow/Dinic.hpp" #line 2 "Library/src/graph/directed/flow/base.hpp" /** * @file base.hpp * @brief Flow Graph * @date 2021-01-15 * * */ #line 13 "Library/src/graph/directed/flow/base.hpp" // the base class of flow algorithms. namespace workspace { template class flow_graph { protected: class adjacency; public: using value_type = adjacency; using reference = adjacency &; using const_reference = adjacency const &; using container_type = std::vector; using size_type = typename container_type::size_type; protected: /** * @brief Edge of flow graph. * */ struct edge { size_type src, dst; Cap cap; Cost cost; edge *rev; edge() = default; edge(size_type src, size_type dst, const Cap &cap, edge *rev) : src(src), dst(dst), cap(cap), rev(rev) {} edge(size_type src, size_type dst, const Cap &cap, const Cost &cost, edge *rev) : src(src), dst(dst), cap(cap), cost(cost), rev(rev) {} const Cap &flow(const Cap &f = 0) { return cap -= f, rev->cap += f; } }; class adjacency { edge *fst, *lst, *clst; public: using value_type = edge; using reference = edge &; using const_reference = edge const &; adjacency() : fst(new edge[1]), lst(fst), clst(fst + 1) {} ~adjacency() { delete[] fst; } template edge *emplace(Args &&... args) { if (lst == clst) { size_type len(clst - fst); edge *nfst = lst = new edge[len << 1]; for (edge *p{fst}; p != clst; ++p, ++lst) p->rev->rev = lst, *lst = *p; delete[] fst; fst = nfst; clst = lst + len; } *lst = edge(args...); return lst++; } edge &operator[](size_type i) { assert(i < size()); return *(fst + i); } size_type size() const { return lst - fst; } edge *begin() const { return fst; } edge *end() const { return lst; } }; public: /** * @brief Construct a new flow base object * * @param n Number of vertices */ flow_graph(size_type n = 0) : adjs(n) {} flow_graph(const flow_graph &other) : adjs(other.size()) { for (size_type node{}; node != size(); ++node) for (const auto &[src, dst, cap, cost, rev] : other[node]) if (src == node) { edge *ptr = adjs[src].emplace(src, dst, cap, cost, nullptr); ptr->rev = adjs[dst].emplace(dst, src, rev->cap, -cost, ptr); rev->src = nil; } else { rev->rev->src = node; } } flow_graph &operator=(const flow_graph &rhs) { if (this != &rhs) adjs.swap(flow_graph(rhs).adjs); return *this; } size_type size() const { return adjs.size(); } reference operator[](size_type node) { assert(node < size()); return adjs[node]; } const_reference &operator[](size_type node) const { assert(node < size()); return adjs[node]; } typename container_type::iterator begin() { return adjs.begin(); } typename container_type::iterator end() { return adjs.end(); } typename container_type::const_iterator begin() const { return adjs.begin(); } typename container_type::const_iterator end() const { return adjs.end(); } virtual edge *add_edge(size_type src, size_type dst, const Cap &cap, const Cost &cost) { assert(src < size()); assert(dst < size()); assert(!(cap < static_cast(0))); if (!(static_cast(0) < cap) || src == dst) return nullptr; edge *ptr = adjs[src].emplace(src, dst, cap, cost, nullptr); ptr->rev = adjs[dst].emplace(dst, src, 0, -cost, ptr); return ptr; } protected: constexpr static size_type nil = -1; container_type adjs; }; } // namespace workspace #line 2 "Library/src/graph/directed/flow/min_cost_flow.hpp" /** * @file min_cost_flow.hpp * @brief Minimum Cost Flow * @date 2021-01-15 * * */ #line 13 "Library/src/graph/directed/flow/min_cost_flow.hpp" #line 15 "Library/src/graph/directed/flow/min_cost_flow.hpp" namespace workspace { // Successive shortest paths algorithm. template class min_cost_flow : public flow_graph { using base = flow_graph; using base::adjs; using base::nil; public: using edge = typename base::edge; using size_type = typename base::size_type; protected: Cost min_cost, total_cost; std::vector supp; std::vector ptnl; void copy_member(const min_cost_flow &other) { min_cost = other.min_cost; total_cost = other.total_cost; supp = other.supp; ptnl = other.ptnl; } void Dijkstra(std::vector &last) { const Cost infty(total_cost + 1); std::vector nptnl(size(), infty); if constexpr (Density_tag) { // O(V^2) std::vector used(size()); for (size_type src{}; src != size(); ++src) { if (static_cast(0) < supp[src]) { used[src] = true; nptnl[src] = 0; for (edge &e : adjs[src]) { if (static_cast(0) < supp[e.dst]) continue; if (e.avbl() && e.cost < nptnl[e.dst]) { nptnl[e.dst] = e.cost; last[e.dst] = &e; } } } } for (;;) { size_type src{nil}; Cost sp{infty}; for (size_type node{}; node != size(); ++node) { if (used[node] || nptnl[node] == infty) continue; Cost dist{nptnl[node] - ptnl[node]}; if (dist < sp) { sp = dist; src = node; } } if (src == nil) break; used[src] = true; for (edge &e : adjs[src]) { if (e.avbl() && nptnl[src] + e.cost < nptnl[e.dst]) { nptnl[e.dst] = nptnl[src] + e.cost; last[e.dst] = &e; } } } } else { // O((V + E)logV) struct node_t { size_type id; Cost dist; node_t(size_type id, Cost dist) : id(id), dist(dist) {} bool operator<(const node_t &rhs) const { return rhs.dist < dist; } }; std::priority_queue que; for (size_type src{}; src != size(); ++src) { if (supp[src] > static_cast(0)) { nptnl[src] = 0; for (edge &e : adjs[src]) if (!(static_cast(0) < supp[e.dst]) && static_cast(0) < e.cap && nptnl[e.dst] > e.cost) { que.emplace(e.dst, (nptnl[e.dst] = e.cost) - ptnl[e.dst]); last[e.dst] = &e; } } } while (!que.empty()) { auto [src, ndist] = que.top(); que.pop(); if (ndist + ptnl[src] != nptnl[src]) continue; for (edge &e : adjs[src]) if (static_cast(0) < e.cap && nptnl[e.dst] > nptnl[src] + e.cost) { que.emplace(e.dst, (nptnl[e.dst] = nptnl[src] + e.cost) - ptnl[e.dst]); last[e.dst] = &e; } } } ptnl.swap(nptnl); } public: using base::size; min_cost_flow(size_type n = 0) : base::flow_graph(n), min_cost(0), total_cost(0), supp(n), ptnl(n) {} min_cost_flow(const min_cost_flow &other) : base::flow_graph(other) { copy_member(other); } min_cost_flow &operator=(const min_cost_flow &other) { base::operator=(other); copy_member(other); return *this; } // infinity capatity // edge *add_edge(size_type src, size_type dst, const Cost &cost); edge *add_edge(size_type src, size_type dst, const Cap &cap, const Cost &cost) override { assert(src != dst); if (cost < static_cast(0)) { supp[src] -= cap; supp[dst] += cap; min_cost += cap * cost; total_cost -= cap * cost; return base::add_edge(dst, src, cap, -cost); } total_cost += cap * cost; return base::add_edge(src, dst, cap, cost); } edge *add_edge(size_type src, size_type dst, const Cap &lower, const Cap &upper, const Cost &cost) { assert(!(upper < lower)); supp[src] -= lower; supp[dst] += lower; min_cost += lower * cost; return add_edge(src, dst, upper - lower, cost); } const Cap &supply(size_type node, const Cap &vol = 0) { assert(node < size()); return supp[node] += vol; } const Cap &demand(size_type node, const Cap &vol) { return supply(node, -vol); } bool flow() { for (bool aug = true; aug;) { aug = false; std::vector last(size()); Dijkstra(last); std::vector shut(size()); for (size_type dst{}; dst != size(); ++dst) { if (supp[dst] < static_cast(0) and last[dst]) { Cap resid{-supp[dst]}; size_type src{dst}, block{nil}; while (last[src] && !shut[src]) { if (!(resid < last[src]->cap)) resid = last[block = src]->cap; src = last[src]->src; } if (shut[src]) block = src; else { if (!(resid < supp[src])) { resid = supp[src]; block = src; } for (edge *e{last[dst]}; e; e = last[e->src]) { e->cap -= resid; e->rev->cap += resid; } supp[src] -= resid; supp[dst] += resid; min_cost += ptnl[dst] * resid; aug = true; } if (~block) { for (size_type node{dst};; node = last[node]->src) { shut[node] = true; if (node == block) break; } } } } } return std::none_of(begin(supp), end(supp), [](const Cap &s) { return s < static_cast(0) || static_cast(0) < s; }); } Cost optimal() { assert(flow()); return min_cost; } }; } // namespace workspace #line 5 "Library/lib/graph" // #include "src/graph/directed/strongly_connected_components.hpp" // #include "src/graph/undirected/tree/centroid_decomposition.hpp" // #include "src/graph/undirected/tree/diameter.hpp" // #include "src/graph/undirected/tree/heavy_light_decomposition.hpp" // #include "src/graph/undirected/tree/lowest_common_ancestor.hpp" // #include "src/graph/undirected/two_edge_connected_components.hpp" #line 27 "atcoder-workspace/17.cc" namespace workspace { bool ok(int a, int b, int c) { return a != b && b != c && (a > b || b > c); } void main() { // start here! int n; i64 m; cin >> n >> m; min_cost_flow mcf(n * 2 + 2); const auto src = mcf.size() - 1, dst = src - 1; vector> bs; for (auto i : range(n)) { mcf.add_edge(src, i, 1, 0); mcf.add_edge(i + n, dst, 1, 0); int a, b, c; cin >> a >> b >> c; if (a > c) swap(a, c); bs.emplace_back(a, b, c); } mcf.supply(src, n); mcf.demand(dst, n); for (auto &&[i, t] : enumerate(bs)) { auto [a, b, c] = t; for (auto &&[j, s] : enumerate(bs)) { auto [a2, b2, c2] = s; if (ok(a2, b, c2)) { mcf.add_edge(i, j + n, 1, -max(c2, b)); } } } if (mcf.flow()) { cout << "YES" << "\n"; auto opt = -mcf.optimal(); cout << (opt < m ? "NO" : "KADOMATSU!") << "\n"; } else { cout << "NO" << "\n"; } } } // namespace workspace