結果
| 問題 | No.1341 真ん中を入れ替えて門松列 |
| ユーザー |
 jell
|
| 提出日時 | 2021-01-16 00:50:00 |
| 言語 | C++17 (gcc 12.3.0 + boost 1.83.0) |
| 結果 |
WA
|
| 実行時間 | - |
| コード長 | 62,559 bytes |
| コンパイル時間 | 5,262 ms |
| コンパイル使用メモリ | 308,472 KB |
| 実行使用メモリ | 5,376 KB |
| 最終ジャッジ日時 | 2024-05-05 02:19:30 |
| 合計ジャッジ時間 | 5,876 ms |
|
ジャッジサーバーID （参考情報） |
judge3 / judge5 |
（要ログイン）
テストケース
テストケース表示| 入力 | 結果 | 実行時間 実行使用メモリ |
|---|---|---|
| testcase_00 | AC | 2 ms
5,248 KB |
| testcase_01 | AC | 2 ms
5,376 KB |
| testcase_02 | AC | 1 ms
5,376 KB |
| testcase_03 | AC | 2 ms
5,376 KB |
| testcase_04 | AC | 2 ms
5,376 KB |
| testcase_05 | AC | 2 ms
5,376 KB |
| testcase_06 | AC | 2 ms
5,376 KB |
| testcase_07 | AC | 4 ms
5,376 KB |
| testcase_08 | AC | 3 ms
5,376 KB |
| testcase_09 | WA | - |
| testcase_10 | AC | 11 ms
5,376 KB |
| testcase_11 | AC | 11 ms
5,376 KB |
| testcase_12 | AC | 11 ms
5,376 KB |
| testcase_13 | AC | 11 ms
5,376 KB |
| testcase_14 | AC | 10 ms
5,376 KB |
| testcase_15 | AC | 12 ms
5,376 KB |
| testcase_16 | AC | 11 ms
5,376 KB |
| testcase_17 | AC | 11 ms
5,376 KB |
| testcase_18 | AC | 11 ms
5,376 KB |
ソースコード
#line 1 "atcoder-workspace/17.cc"
// #undef _GLIBCXX_DEBUG
// #define NDEBUG
#include <bits/extc++.h>
#line 2 "Library/lib/alias"
/**
* @file alias
* @brief Alias
*/
#line 13 "Library/lib/alias"
#line 1 "Library/lib/bit"
#if __cplusplus > 201703L
#include <bit>
#else
#ifndef _GLIBCXX_BIT
#define _GLIBCXX_BIT 1
#include <limits>
#include <type_traits>
namespace std {
template <typename _Tp> 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 <typename _Tp> 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 <typename _Tp> 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<unsigned long long>::digits;
constexpr auto _Nd_ul = numeric_limits<unsigned long>::digits;
constexpr auto _Nd_u = numeric_limits<unsigned>::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<unsigned long long>::max();
unsigned long long __low = __x & __max_ull;
return (_Nd - _Nd_ull) + __builtin_clzll(__low);
}
}
template <typename _Tp> 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 <typename _Tp> 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<unsigned long long>::digits;
constexpr auto _Nd_ul = numeric_limits<unsigned long>::digits;
constexpr auto _Nd_u = numeric_limits<unsigned>::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<unsigned long long>::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 <typename _Tp> constexpr int __countr_one(_Tp __x) noexcept {
if (__x == numeric_limits<_Tp>::max()) return numeric_limits<_Tp>::digits;
return __countr_zero((_Tp)~__x);
}
template <typename _Tp> constexpr int __popcount(_Tp __x) noexcept {
constexpr auto _Nd = numeric_limits<_Tp>::digits;
if (__x == 0) return 0;
constexpr auto _Nd_ull = numeric_limits<unsigned long long>::digits;
constexpr auto _Nd_ul = numeric_limits<unsigned long>::digits;
constexpr auto _Nd_u = numeric_limits<unsigned>::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<unsigned long long>::max();
unsigned long long __low = __x & __max_ull;
unsigned long long __high = __x >> _Nd_ull;
return __builtin_popcountll(__low) + __builtin_popcountll(__high);
}
}
template <typename _Tp> constexpr bool __has_single_bit(_Tp __x) noexcept {
return __popcount(__x) == 1;
}
template <typename _Tp> 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 <typename _Tp> 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 <typename _Tp> 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 <class T, class Comp = less<T>>
using priority_queue = std::priority_queue<T, vector<T>, Comp>;
template <class T> using stack = std::stack<T, vector<T>>;
template <typename _Tp> constexpr _Tp __bsf(_Tp __x) noexcept {
return std::__countr_zero(__x);
}
template <typename _Tp> 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 <class Iter, class Pred>
typename std::enable_if<
std::is_convertible<decltype(std::declval<Pred>()(std::declval<Iter>())),
bool>::value,
Iter>::type
binary_search(Iter ok, Iter ng, Pred pred) {
assert(ok != ng);
typename std::make_signed<decltype(ng - ok)>::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 <class Real, class Pred>
typename std::enable_if<
std::is_convertible<decltype(std::declval<Pred>()(std::declval<Real>())),
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<Real>::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 <class Array,
class Iter = typename std::decay<
decltype(std::get<0>(std::declval<Array>()[0]))>::type,
class Pred>
typename std::enable_if<
std::is_convertible<
decltype(std::declval<Pred>()(std::declval<std::vector<Iter>>())[0]),
bool>::value,
std::vector<Iter>>::type
parallel_binary_search(Array ends, Pred pred) {
std::vector<Iter> 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<decltype(ng - ok)>::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 <class Array,
class Real = typename std::decay<
decltype(std::get<0>(std::declval<Array>()[0]))>::type,
class Pred>
typename std::enable_if<
std::is_convertible<
decltype(std::declval<Pred>()(std::declval<std::vector<Real>>())[0]),
bool>::value,
std::vector<Real>>::type
parallel_binary_search(Array ends, const Real eps, Pred pred) {
std::vector<Real> mids(std::size(ends));
for (auto loops = 0; loops != std::numeric_limits<Real>::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 <class Index, class Pred>
typename std::enable_if<
std::is_convertible<decltype(std::declval<Pred>()(std::declval<Index>())),
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 <class Real, class Pred>
typename std::enable_if<
std::is_convertible<decltype(std::declval<Pred>()(std::declval<Real>())),
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 <type_traits>
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 <class Iter, class Comp>
typename std::enable_if<
std::is_convertible<decltype(std::declval<Comp>()(std::declval<Iter>(),
std::declval<Iter>())),
bool>::value,
Iter>::type
trinary_search(Iter first, Iter last, Comp comp) {
assert(first < last);
typename std::make_signed<decltype(last - first)>::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 <class Iter, class Func>
typename std::enable_if<
std::is_same<decltype(std::declval<Func>()(std::declval<Iter>()), 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 <class Real, class Comp>
typename std::enable_if<
std::is_convertible<decltype(std::declval<Comp>()(std::declval<Real>(),
std::declval<Real>())),
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 <class Real, class Func>
typename std::enable_if<
std::is_same<decltype(std::declval<Func>()(std::declval<Real>()), 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<milliseconds>(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 <class Tp> 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 <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 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 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
template <typename T> struct multiplicable_int {
using type =
typename std::make_signed<typename multiplicable_uint<T>::type>::type;
};
} // namespace workspace
#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 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/src/graph/directed/flow/Dinic.hpp"
/**
* @file Dinic.hpp
* @brief Dinic's Algorithm
* @date 2021-01-15
*
*
*/
#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 Cap, class Cost> class flow_graph {
protected:
class adjacency;
public:
using value_type = adjacency;
using reference = adjacency &;
using const_reference = adjacency const &;
using container_type = std::vector<value_type>;
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 <class... Args> 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<Cap>(0)));
if (!(static_cast<Cap>(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 12 "Library/src/graph/directed/flow/Dinic.hpp"
namespace workspace {
/**
* @brief Compute the maximum flow.
*
* @tparam Cap Capacity type.
*/
template <class Cap = int> class Dinic : public flow_graph<Cap, bool> {
using base = flow_graph<Cap, bool>;
using base::adjs;
using base::nil;
public:
using edge = typename base::edge;
using size_type = typename base::size_type;
protected:
std::vector<size_type> level;
std::vector<edge *> itr;
Cap dfs(size_type src, size_type dst, Cap bound) {
if (src == dst || bound == 0) return bound;
Cap flow(0);
for (edge *&e{itr[dst]}; e != adjs[dst].end(); ++e)
if (static_cast<Cap>(0) < e->rev->cap && level[e->dst] < level[dst])
if (Cap achv = dfs(src, e->dst, std::min(bound, e->rev->cap));
achv > 0) {
e->rev->flow(achv);
flow += achv, bound -= achv;
if (bound == 0) break;
}
return flow;
}
public:
Dinic(size_type n = 0) : base::flow_graph(n), level(n, nil), itr(n) {}
Dinic(const Dinic &other)
: base::flow_graph(other), level(other.level), itr(other.itr) {}
Dinic &operator=(const Dinic &rhs) {
if (this != &rhs) base::operator=(rhs), level = rhs.level, itr = rhs.itr;
return *this;
}
void add_edge(size_type src, size_type dst, Cap cap) {
base::add_edge(src, dst, cap, false);
}
// void add_undirected_edge(size_type src, size_type dst, Cap cap) {
// base::add_undirected_edge(src, dst, cap, false);
// }
Cap max_flow(size_type src, size_type dst) {
assert(src < base::size());
assert(dst < base::size());
Cap flow(0), bound(0);
for (const edge &e : adjs[src]) bound += e.cap;
for (std::vector<size_type> que(base::size());;
std::fill(level.begin(), level.end(), nil)) {
level[que.front() = src] = 0;
for (auto ql{que.begin()}, qr{std::next(ql)};
level[dst] == nil && ql != qr; ++ql)
for (const edge &e : adjs[*ql])
if (static_cast<Cap>(0) < e.cap && level[e.dst] == nil)
level[ *qr++ = e.dst] = level[*ql] + 1;
if (level[dst] == nil) break;
for (size_type node{}; node != base::size(); ++node)
itr[node] = adjs[node].begin();
flow += dfs(src, dst, bound);
}
return flow;
}
};
} // 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 Cap, class Cost, bool Density_tag = false>
class min_cost_flow : public flow_graph<Cap, Cost> {
using base = flow_graph<Cap, Cost>;
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<Cap> supp;
std::vector<Cost> 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<edge *> &last) {
const Cost infty(total_cost + 1);
std::vector<Cost> nptnl(size(), infty);
if constexpr (Density_tag) { // O(V^2)
std::vector<bool> used(size());
for (size_type src{}; src != size(); ++src) {
if (static_cast<Cap>(0) < supp[src]) {
used[src] = true;
nptnl[src] = 0;
for (edge &e : adjs[src]) {
if (static_cast<Cap>(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<node_t> que;
for (size_type src{}; src != size(); ++src) {
if (supp[src] > static_cast<Cap>(0)) {
nptnl[src] = 0;
for (edge &e : adjs[src])
if (!(static_cast<Cap>(0) < supp[e.dst]) &&
static_cast<Cap>(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<Cap>(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<Cost>(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<edge *> last(size());
Dijkstra(last);
std::vector<bool> shut(size());
for (size_type dst{}; dst != size(); ++dst) {
if (supp[dst] < static_cast<Cap>(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<Cap>(0) || static_cast<Cap>(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); }
constexpr i64 inf = 4e12;
void main() {
// start here!
int n;
i64 m;
cin >> n >> m;
vector<pair<int, int>> itvs(n);
vector<int> c(n);
for (auto &&[b, p] : zip(c, itvs)) {
auto &[a, c] = p;
cin >> a >> b >> c;
if (a > c) swap(a, c);
}
sort(begin(c), end(c));
sort(begin(itvs), end(itvs)
/* ,[](auto p1, auto p2) { return p1.second < p2.second; }*/
);
i64 ans = -1, sum = 0;
vector<i64> cur(n, -inf);
set<pair<i64, int>> ex;
queue<int> red;
{
priority_queue<i64> pq;
auto iter = itvs.rbegin();
for (auto &&[i, v] : reversed(enumerate(c))) {
while (iter != rend(itvs) && iter->first > c[i]) {
pq.emplace(iter->second);
++iter;
}
if (!pq.empty()) {
cur[i] = pq.top();
pq.pop();
}
ex.emplace(cur[i], i);
sum += cur[i];
}
while (iter != rend(itvs)) {
red.emplace(iter->second);
++iter;
}
}
for (auto k : rrange(n + 1)) {
if (k < n) { // move one
// delete
sum -= cur[k];
ex.erase({cur[k], k});
if (!ex.empty()) {
auto iter = ex.begin();
auto [c, i] = *iter;
if (c < cur[k]) {
ex.erase(iter);
ex.emplace(cur[k], i);
sum -= cur[i];
sum += cur[k];
swap(cur[i], cur[k]);
}
}
// add
sum += c[k];
bool fail = 0;
while (!red.empty()) {
cur[k] = red.front();
red.pop();
}
for (auto pos : range(k, n)) {
if (pos + 1 < n && cur[pos] > cur[pos + 1]) {
swap(cur[pos], cur[pos + 1]);
}
if (!(cur[pos] < c[pos])) {
fail = 1;
}
}
if (fail) break;
}
chge(ans, sum);
}
if (ans < 0) {
cout << "NO"
<< "\n";
} else {
cout << "YES"
<< "\n";
if (ans < m)
cout << "NO"
<< "\n";
else
cout << "KADOMATSU!"
<< "\n";
}
}
} // namespace workspace