結果
| 問題 | No.1479 Matrix Eraser |
| ユーザー |
 jell
|
| 提出日時 | 2021-04-16 21:24:25 |
| 言語 | C++17 (gcc 13.2.0 + boost 1.83.0) |
| 結果 |
AC
|
| 実行時間 | 603 ms / 3,000 ms |
| コード長 | 60,195 bytes |
| コンパイル時間 | 5,102 ms |
| コンパイル使用メモリ | 307,856 KB |
| 実行使用メモリ | 61,832 KB |
| 最終ジャッジ日時 | 2023-09-15 23:27:18 |
| 合計ジャッジ時間 | 22,450 ms |
|
ジャッジサーバーID （参考情報） |
judge14 / judge15 |
テストケース
テストケース表示| 入力 | 結果 | 実行時間 実行使用メモリ |
|---|---|---|
| testcase_00 | AC | 203 ms
38,412 KB |
| testcase_01 | AC | 204 ms
38,220 KB |
| testcase_02 | AC | 203 ms
38,288 KB |
| testcase_03 | AC | 203 ms
38,224 KB |
| testcase_04 | AC | 202 ms
38,156 KB |
| testcase_05 | AC | 204 ms
38,224 KB |
| testcase_06 | AC | 203 ms
38,268 KB |
| testcase_07 | AC | 248 ms
40,984 KB |
| testcase_08 | AC | 281 ms
42,716 KB |
| testcase_09 | AC | 372 ms
47,480 KB |
| testcase_10 | AC | 535 ms
54,192 KB |
| testcase_11 | AC | 405 ms
49,104 KB |
| testcase_12 | AC | 258 ms
41,704 KB |
| testcase_13 | AC | 280 ms
42,812 KB |
| testcase_14 | AC | 261 ms
42,044 KB |
| testcase_15 | AC | 213 ms
39,132 KB |
| testcase_16 | AC | 266 ms
42,300 KB |
| testcase_17 | AC | 597 ms
56,892 KB |
| testcase_18 | AC | 594 ms
57,088 KB |
| testcase_19 | AC | 595 ms
57,068 KB |
| testcase_20 | AC | 600 ms
57,160 KB |
| testcase_21 | AC | 598 ms
56,720 KB |
| testcase_22 | AC | 603 ms
56,824 KB |
| testcase_23 | AC | 601 ms
56,884 KB |
| testcase_24 | AC | 601 ms
56,884 KB |
| testcase_25 | AC | 599 ms
57,024 KB |
| testcase_26 | AC | 594 ms
56,948 KB |
| testcase_27 | AC | 339 ms
44,616 KB |
| testcase_28 | AC | 341 ms
44,776 KB |
| testcase_29 | AC | 340 ms
44,456 KB |
| testcase_30 | AC | 338 ms
44,576 KB |
| testcase_31 | AC | 346 ms
44,484 KB |
| testcase_32 | AC | 289 ms
57,124 KB |
| testcase_33 | AC | 289 ms
56,928 KB |
| testcase_34 | AC | 290 ms
56,932 KB |
| testcase_35 | AC | 290 ms
56,948 KB |
| testcase_36 | AC | 289 ms
57,040 KB |
| testcase_37 | AC | 216 ms
38,300 KB |
| testcase_38 | AC | 366 ms
42,700 KB |
| testcase_39 | AC | 493 ms
61,832 KB |
| testcase_40 | AC | 203 ms
38,212 KB |
ソースコード
#line 1 "other/yuki.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 2 "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 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 __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 __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 _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 2 "Library/lib/limits"
#line 4 "Library/lib/limits"
namespace workspace {
template <class _Tp> struct numeric_limits : std::numeric_limits<_Tp> {};
#ifdef __SIZEOF_INT128__
template <> struct numeric_limits<__uint128_t> {
constexpr static __uint128_t max() { return ~__uint128_t(0); }
constexpr static __uint128_t min() { return 0; }
};
template <> struct numeric_limits<__int128_t> {
constexpr static __int128_t max() {
return numeric_limits<__uint128_t>::max() >> 1;
}
constexpr static __int128_t min() { return -max() - 1; }
};
#endif
} // namespace workspace
#line 16 "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
namespace _alias_impl {
template <class> struct first_arg { using type = void; };
template <class _Tp, class = void> struct parse_comp : first_arg<_Tp> {};
template <class _Tp>
struct parse_comp<_Tp, std::__void_t<decltype(&_Tp::operator())>>
: first_arg<decltype(&_Tp::operator())> {};
template <class _R, class _Tp, class... _Args>
struct first_arg<_R(_Tp, _Args...)> {
using type = _Tp;
};
template <class _R, class _Tp, class... _Args>
struct first_arg<_R (*)(_Tp, _Args...)> {
using type = _Tp;
};
template <class _G, class _R, class _Tp, class... _Args>
struct first_arg<_R (_G::*)(_Tp, _Args...)> {
using type = _Tp;
};
template <class _G, class _R, class _Tp, class... _Args>
struct first_arg<_R (_G::*)(_Tp, _Args...) const> {
using type = _Tp;
};
} // namespace _alias_impl
template <class _Tp = void, class _Compare = std::less<_Tp>>
decltype(auto) make_priority_queue(_Compare __x = _Compare()) noexcept {
using type = std::conditional_t<
std::is_void<_Tp>::value,
std::decay_t<typename _alias_impl::parse_comp<_Compare>::type>, _Tp>;
return std::priority_queue<type, std::vector<type>, _Compare>(__x);
}
template <class _Tp = void, class _Compare = std::less<_Tp>>
decltype(auto) make_set(_Compare __x = _Compare()) noexcept {
using type = std::conditional_t<
std::is_void<_Tp>::value,
std::decay_t<typename _alias_impl::parse_comp<_Compare>::type>, _Tp>;
return std::set<type, _Compare>(__x);
}
template <class _Key, class _Mapped, class _Compare = std::less<_Key>>
decltype(auto) make_map(_Compare __x = _Compare()) noexcept {
return std::map<_Key, _Mapped, _Compare>(__x);
}
template <class _T1, class _T2,
typename = decltype(std::declval<const _T2 &>() <
std::declval<const _T1 &>())>
constexpr
typename std::conditional<std::is_same<_T1, _T2>::value, const _T1 &,
typename std::common_type<_T1, _T2>::type>::type
min(const _T1 &__x, const _T2 &__y) noexcept {
return __y < __x ? __y : __x;
}
template <class _T1, class _T2, class _Compare,
typename = decltype(std::declval<_Compare>()(
std::declval<const _T2 &>(), std::declval<const _T1 &>()))>
constexpr
typename std::conditional<std::is_same<_T1, _T2>::value, const _T1 &,
typename std::common_type<_T1, _T2>::type>::type
min(const _T1 &__x, const _T2 &__y, _Compare __comp) noexcept {
return __comp(__y, __x) ? __y : __x;
}
template <class _Tp, typename = decltype(std::declval<const _Tp &>() <
std::declval<const _Tp &>())>
constexpr _Tp min(std::initializer_list<_Tp> __x) noexcept {
return *std::min_element(__x.begin(), __x.end());
}
template <class _Tp, class _Compare,
typename = decltype(std::declval<_Compare>()(
std::declval<const _Tp &>(), std::declval<const _Tp &>()))>
constexpr _Tp min(std::initializer_list<_Tp> __x, _Compare __comp) noexcept {
return *std::min_element(__x.begin(), __x.end(), __comp);
}
template <class _T1, class _T2,
typename = decltype(std::declval<const _T1 &>() <
std::declval<const _T2 &>())>
constexpr
typename std::conditional<std::is_same<_T1, _T2>::value, const _T1 &,
typename std::common_type<_T1, _T2>::type>::type
max(const _T1 &__x, const _T2 &__y) noexcept {
return __x < __y ? __y : __x;
}
template <class _T1, class _T2, class _Compare,
typename = decltype(std::declval<_Compare>()(
std::declval<const _T1 &>(), std::declval<const _T2 &>()))>
constexpr
typename std::conditional<std::is_same<_T1, _T2>::value, const _T1 &,
typename std::common_type<_T1, _T2>::type>::type
max(const _T1 &__x, const _T2 &__y, _Compare __comp) noexcept {
return __comp(__x, __y) ? __y : __x;
}
template <class _Tp, typename = decltype(std::declval<const _Tp &>() <
std::declval<const _Tp &>())>
constexpr _Tp max(std::initializer_list<_Tp> __x) noexcept {
return *std::max_element(__x.begin(), __x.end());
}
template <class _Tp, class _Compare,
typename = decltype(std::declval<_Compare>()(
std::declval<const _Tp &>(), std::declval<const _Tp &>()))>
constexpr _Tp max(std::initializer_list<_Tp> __x, _Compare __comp) noexcept {
return *std::max_element(__x.begin(), __x.end(), __comp);
}
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 "other/yuki.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 8 "other/yuki.cc"
// #include "lib/opt"
#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/lib/utils"
// #include "src/utils/cached.hpp"
#line 2 "Library/src/utils/cat.hpp"
/**
* @file cat.hpp
* @brief Cat
*/
#line 9 "Library/src/utils/cat.hpp"
namespace workspace {
/**
* @brief Concatenate two sequences.
*
* @param __c1
* @param __c2
* @return Concatenated sequence.
*/
template <class _C1, class _C2>
constexpr decltype(auto) cat(_C1 &&__c1, _C2 &&__c2) noexcept {
auto __c = std::forward<_C1>(__c1);
if constexpr (std::is_rvalue_reference<decltype(__c2)>::value)
__c.insert(std::end(__c), std::move_iterator(std::begin(__c2)),
std::move_iterator(std::end(__c2)));
else
__c.insert(std::end(__c), std::cbegin(__c2), std::cend(__c2));
return __c;
}
/**
* @return Concatenated sequence.
*/
template <class _C1, class _C2, class... _Args>
constexpr decltype(auto) cat(_C1 &&__c1, _C2 &&__c2,
_Args &&...__args) noexcept {
return cat(cat(std::forward<_C1>(__c1), std::forward<_C2>(__c2)),
std::forward<_Args>(__args)...);
}
} // namespace workspace
#line 2 "Library/src/utils/chval.hpp"
/**
* @file chval.hpp
* @brief Change Less/Greater
*/
#line 9 "Library/src/utils/chval.hpp"
namespace workspace {
/**
* @brief Substitute __y for __x if __y < __x.
* @param __x Reference
* @param __y Comparison target
* @return Whether or not __x is updated.
*/
template <class _T1, class _T2,
typename = decltype(std::declval<_T2>() < std::declval<_T1 &>())>
typename std::enable_if<std::is_assignable<_T1 &, _T2>::value, bool>::type chle(
_T1 &__x, _T2 &&__y) noexcept {
return __y < __x ? __x = std::forward<_T2>(__y), true : false;
}
/**
* @brief Substitute __y for __x if __x < __y.
* @param __x Reference
* @param __y Comparison target
* @return Whether or not __x is updated.
*/
template <class _T1, class _T2,
typename = decltype(std::declval<_T1 &>() < std::declval<_T2>())>
typename std::enable_if<std::is_assignable<_T1 &, _T2>::value, bool>::type chgr(
_T1 &__x, _T2 &&__y) noexcept {
return __x < __y ? __x = std::forward<_T2>(__y), true : false;
}
/**
* @brief Substitute __y for __x if __comp(__y, __x) is true.
* @param __x Reference
* @param __y Comparison target
* @param __comp Compare function object
* @return Whether or not __x is updated.
*/
template <class _T1, class _T2, class _Compare,
typename = decltype(std::declval<_Compare>()(std::declval<_T2>(),
std::declval<_T1 &>()))>
typename std::enable_if<std::is_assignable<_T1 &, _T2>::value, bool>::type chle(
_T1 &__x, _T2 &&__y, _Compare __comp) noexcept {
return __comp(__y, __x) ? __x = std::forward<_T2>(__y), true : false;
}
/**
* @brief Substitute __y for __x if __comp(__x, __y) is true.
* @param __x Reference
* @param __y Comparison target
* @param __comp Compare function object
* @return Whether or not __x is updated.
*/
template <class _T1, class _T2, class _Compare,
typename = decltype(std::declval<_Compare>()(std::declval<_T1 &>(),
std::declval<_T2>()))>
typename std::enable_if<std::is_assignable<_T1 &, _T2>::value, bool>::type chgr(
_T1 &__x, _T2 &&__y, _Compare __comp) noexcept {
return __comp(__x, __y) ? __x = std::forward<_T2>(__y), true : false;
}
} // namespace workspace
#line 5 "Library/lib/utils"
// #include "src/utils/fixed_point.hpp"
// #include "src/utils/hash.hpp"
// #include "src/utils/io/istream.hpp"
// #include "src/utils/io/ostream.hpp"
// #include "src/utils/io/read.hpp"
#line 2 "Library/src/utils/grid/motion.hpp"
/**
* @file motion.hpp
* @brief Motion
*/
#line 9 "Library/src/utils/grid/motion.hpp"
namespace workspace {
/**
* @brief Transpose.
*
* @param __grid
*/
template <class _Grid,
typename = decltype(std::declval<std::decay_t<_Grid>>()[0].resize(0))>
constexpr decltype(auto) transpose(_Grid &&__grid) noexcept {
auto __h = std::size(__grid), __w = std::size(__grid[0]);
std::decay_t<_Grid> __t(__w);
for (auto &&__r : __t) __r.resize(__h);
for (size_t __i = 0; __i != __h; ++__i)
for (size_t __j = 0; __j != __w; ++__j)
if constexpr (std::is_rvalue_reference<decltype(__grid)>::value)
__t[__j][__i] = std::move(__grid[__i][__j]);
else
__t[__j][__i] = __grid[__i][__j];
return __t;
}
/**
* @brief Transpose.
*
* @param __grid
*/
template <class _Tp, size_t _Rows, size_t _Cols>
constexpr decltype(auto) transpose(const _Tp (&__grid)[_Rows][_Cols]) noexcept {
std::array<std::array<_Tp, _Rows>, _Cols> __t;
for (size_t __i = 0; __i != _Rows; ++__i)
for (size_t __j = 0; __j != _Cols; ++__j) __t[__j][__i] = __grid[__i][__j];
return __t;
}
/**
* @brief Transpose.
*
* @param __grid
*/
template <class _Tp, size_t _Rows, size_t _Cols>
constexpr decltype(auto) transpose(_Tp(&&__grid)[_Rows][_Cols]) noexcept {
std::array<std::array<_Tp, _Rows>, _Cols> __t;
for (size_t __i = 0; __i != _Rows; ++__i)
for (size_t __j = 0; __j != _Cols; ++__j)
__t[__j][__i] = std::move(__grid[__i][__j]);
return __t;
}
/**
* @brief Transpose.
*
* @param __grid
*/
template <class _Tp, size_t _Rows, size_t _Cols>
constexpr decltype(auto) transpose(
const std::array<std::array<_Tp, _Cols>, _Rows> &__grid) noexcept {
std::array<std::array<_Tp, _Rows>, _Cols> __t;
for (size_t __i = 0; __i != _Rows; ++__i)
for (size_t __j = 0; __j != _Cols; ++__j) __t[__j][__i] = __grid[__i][__j];
return __t;
}
/**
* @brief Transpose.
*
* @param __grid
*/
template <class _Tp, size_t _Rows, size_t _Cols>
constexpr decltype(auto) transpose(
std::array<std::array<_Tp, _Cols>, _Rows> &&__grid) noexcept {
std::array<std::array<_Tp, _Rows>, _Cols> __t;
for (size_t __i = 0; __i != _Rows; ++__i)
for (size_t __j = 0; __j != _Cols; ++__j)
__t[__j][__i] = std::move(__grid[__i][__j]);
return __t;
}
/**
* @brief Roll the grid counter-clockwise.
*
* @param __grid
* @return
*/
template <class _Grid> decltype(auto) roll_ccw(_Grid &&__grid) noexcept {
if constexpr (std::is_rvalue_reference<decltype(__grid)>::value) {
auto __t = transpose(std::move(__grid));
std::reverse(std::begin(__t), std::end(__t));
return __t;
}
else {
auto __t = transpose(__grid);
std::reverse(std::begin(__t), std::end(__t));
return __t;
}
}
/**
* @brief Roll the grid clockwise.
*
* @param __grid
* @return
*/
template <class _Grid> decltype(auto) roll_cw(_Grid &&__grid) noexcept {
if constexpr (std::is_rvalue_reference<decltype(__grid)>::value) {
std::reverse(std::begin(__grid), std::end(__grid));
return transpose(std::move(__grid));
}
else {
auto __t = transpose(__grid);
for (auto &&__r : __t) std::reverse(std::begin(__r), std::end(__r));
return __t;
}
}
} // namespace workspace
#line 2 "Library/src/utils/io/setup.hpp"
/**
* @file setup.hpp
* @brief I/O Setup
*/
#line 10 "Library/src/utils/io/setup.hpp"
namespace workspace {
/**
* @brief Setup I/O.
* @param __n Standard output precision
*/
void io_setup(int __n) {
std::cin.tie(0)->sync_with_stdio(0);
std::cout << std::fixed << std::setprecision(__n);
#ifdef _buffer_check
atexit([] {
char bufc;
if (std::cin >> bufc)
std::cerr << "\n\033[43m\033[30mwarning: buffer not empty.\033[0m\n\n";
});
#endif
}
} // namespace workspace
#line 2 "Library/src/utils/iterator/category.hpp"
/*
* @file category.hpp
* @brief Iterator Category
*/
#line 10 "Library/src/utils/iterator/category.hpp"
namespace workspace {
/*
* @tparam Tuple Tuple of iterator types
*/
template <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.
*
* @param __dim Dimension
* @param __x Initial value
*/
template <typename _Tp, class _Dim, size_t _Nm>
constexpr decltype(auto) make_vector([[maybe_unused]] _Dim* __dim,
const _Tp& __x = _Tp()) {
static_assert(std::is_convertible<_Dim, size_t>::value);
if constexpr (_Nm)
return std::vector(*__dim,
make_vector<_Tp, _Dim, _Nm - 1>(std::next(__dim), __x));
else
return __x;
}
/**
* @brief Make a multi-dimensional vector.
*
* @param __dim Dimension
* @param __x Initial value
*/
template <typename _Tp, class _Dim, size_t _Nm>
constexpr decltype(auto) make_vector(const _Dim (&__dim)[_Nm],
const _Tp& __x = _Tp()) {
return make_vector<_Tp, _Dim, _Nm>((_Dim*)__dim, __x);
}
/**
* @brief Make a multi-dimensional vector.
*
* @param __dim Dimension
* @param __x Initial value
*/
template <typename _Tp, class _Dim, size_t _Nm = 0>
constexpr decltype(auto) make_vector([[maybe_unused]] const _Dim& __dim,
const _Tp& __x = _Tp()) {
if constexpr (_Nm == std::tuple_size<_Dim>::value)
return __x;
else {
static_assert(
std::is_convertible<std::tuple_element_t<_Nm, _Dim>, size_t>::value);
return std::vector(std::get<_Nm>(__dim),
make_vector<_Tp, _Dim, _Nm + 1>(__dim, __x));
}
}
} // 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 _reversed_impl {
template <class _Container> class reversed {
_Container __cont;
public:
constexpr reversed(_Container &&__cont) noexcept : __cont(__cont) {}
constexpr decltype(auto) begin() noexcept { return std::rbegin(__cont); }
constexpr decltype(auto) begin() const noexcept {
return std::rbegin(__cont);
}
constexpr decltype(auto) end() noexcept { return std::rend(__cont); }
constexpr decltype(auto) end() const noexcept { return std::rend(__cont); }
constexpr decltype(auto) size() const noexcept { return std::size(__cont); }
};
} // namespace _reversed_impl
template <class _Container>
constexpr decltype(auto) reversed(_Container &&__cont) noexcept {
return _reversed_impl::reversed<_Container>{std::forward<_Container>(__cont)};
}
template <class _Tp>
constexpr decltype(auto) reversed(
std::initializer_list<_Tp> &&__cont) noexcept {
return _reversed_impl::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(const _Index &__i = _Index()) noexcept : current(__i) {}
constexpr bool operator==(const iterator &__x) const noexcept {
return current == __x.current;
}
constexpr bool operator!=(const iterator &__x) const noexcept {
return current != __x.current;
}
constexpr 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());
}
constexpr size_t size() const noexcept {
return std::distance(__first, __last);
}
};
template <class... _Args>
constexpr decltype(auto) rrange(_Args &&...__args) noexcept {
return 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 {
namespace _enumerate_impl {
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)...));
}
} // namespace _enumerate_impl
template <class... _Args>
constexpr decltype(auto) enumerate(_Args &&... __args) noexcept {
return zip(range(_enumerate_impl::min_size(__args...)),
std::forward<_Args>(__args)...);
}
template <class... _Args>
constexpr decltype(auto) enumerate(
std::initializer_list<_Args> const &... __args) noexcept {
return zip(range(_enumerate_impl::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 _Engine = std::mt19937>
class random_number_generator : uniform_distribution<_Arithmetic> {
using base = uniform_distribution<_Arithmetic>;
_Engine __engine;
public:
random_number_generator(_Arithmetic __min, _Arithmetic __max)
: base(__min, __max), __engine(std::random_device{}()) {}
random_number_generator(_Arithmetic __max = 1)
: random_number_generator(0, __max) {}
random_number_generator(typename base::param_type const& __param)
: base(__param), __engine(std::random_device{}()) {}
decltype(auto) operator()() noexcept { return base::operator()(__engine); }
};
} // namespace workspace
#line 2 "Library/src/utils/rand/shuffle.hpp"
/**
* @file shuffle.hpp
* @brief Shuffle
*/
#line 10 "Library/src/utils/rand/shuffle.hpp"
namespace workspace {
template <class _RAIter, class _Engine = std::mt19937>
void shuffle(_RAIter __first, _RAIter __last) {
static _Engine __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 2 "Library/src/utils/sfinae.hpp"
/**
* @file sfinae.hpp
* @brief SFINAE
*/
#line 10 "Library/src/utils/sfinae.hpp"
#include <type_traits>
#ifndef __INT128_DEFINED__
#ifdef __SIZEOF_INT128__
#define __INT128_DEFINED__ 1
#else
#define __INT128_DEFINED__ 0
#endif
#endif
namespace std {
#if __INT128_DEFINED__
template <> struct make_signed<__uint128_t> { using type = __int128_t; };
template <> struct make_signed<__int128_t> { using type = __int128_t; };
template <> struct make_unsigned<__uint128_t> { using type = __uint128_t; };
template <> struct make_unsigned<__int128_t> { using type = __uint128_t; };
template <> struct is_signed<__uint128_t> : std::false_type {};
template <> struct is_signed<__int128_t> : std::true_type {};
template <> struct is_unsigned<__uint128_t> : std::true_type {};
template <> struct is_unsigned<__int128_t> : std::false_type {};
#endif
} // namespace std
namespace workspace {
template <class Tp, class... Args> struct variadic_front { using type = Tp; };
template <class... Args> struct variadic_back;
template <class Tp> struct variadic_back<Tp> { using type = Tp; };
template <class Tp, class... Args> struct variadic_back<Tp, Args...> {
using type = typename variadic_back<Args...>::type;
};
template <class type, template <class> class trait>
using enable_if_trait_type = typename std::enable_if<trait<type>::value>::type;
/**
* @brief Return type of subscripting ( @c [] ) access.
*/
template <class _Tp>
using subscripted_type =
typename std::decay<decltype(std::declval<_Tp&>()[0])>::type;
template <class Container>
using element_type = typename std::decay<decltype(
*std::begin(std::declval<Container&>()))>::type;
template <class _Tp, class = std::nullptr_t>
struct has_begin : std::false_type {};
template <class _Tp>
struct has_begin<_Tp, decltype(std::begin(std::declval<_Tp>()), nullptr)>
: std::true_type {};
template <class _Tp, class = std::nullptr_t>
struct has_mod : std::false_type {};
template <class _Tp>
struct has_mod<_Tp, decltype(_Tp::mod, nullptr)> : std::true_type {};
template <class _Tp, class = void> struct is_integral_ext : std::false_type {};
template <class _Tp>
struct is_integral_ext<
_Tp, typename std::enable_if<std::is_integral<_Tp>::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 _Tp>
constexpr static bool is_integral_ext_v = is_integral_ext<_Tp>::value;
#endif
template <typename _Tp, typename = void> struct multiplicable_uint {
using type = uint_least32_t;
};
template <typename _Tp>
struct multiplicable_uint<
_Tp,
typename std::enable_if<(2 < sizeof(_Tp)) &&
(!__INT128_DEFINED__ || sizeof(_Tp) <= 4)>::type> {
using type = uint_least64_t;
};
#if __INT128_DEFINED__
template <typename _Tp>
struct multiplicable_uint<_Tp,
typename std::enable_if<(4 < sizeof(_Tp))>::type> {
using type = __uint128_t;
};
#endif
template <typename _Tp> struct multiplicable_int {
using type =
typename std::make_signed<typename multiplicable_uint<_Tp>::type>::type;
};
template <typename _Tp> struct multiplicable {
using type = std::conditional_t<
is_integral_ext<_Tp>::value,
std::conditional_t<std::is_signed<_Tp>::value,
typename multiplicable_int<_Tp>::type,
typename multiplicable_uint<_Tp>::type>,
_Tp>;
};
} // namespace workspace
#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 "other/yuki.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/data_structure/coordinate_compression.hpp"
/**
* @file coordinate_compression.hpp
* @brief Coordinate Compression
*/
#line 10 "Library/src/data_structure/coordinate_compression.hpp"
namespace workspace {
template <class _Tp> class compression {
std::vector<_Tp> __vec;
decltype(auto) begin() { return __vec.begin(); }
decltype(auto) end() { return __vec.end(); }
public:
using size_type = typename std::vector<_Tp>::size_type;
/**
* @brief Construct a new compression object.
*/
compression() = default;
/**
* @brief Construct a new compression object.
*
* @param __first
* @param __last
*/
template <class _IIter>
compression(_IIter __first, _IIter __last) noexcept : __vec(__first, __last) {
make();
}
decltype(auto) begin() const noexcept { return __vec.begin(); }
decltype(auto) end() const noexcept { return __vec.end(); }
decltype(auto) operator[](size_type __i) const noexcept {
assert(__i < size());
return __vec[__i];
}
size_type size() const noexcept { return __vec.size(); }
template <class... _Args> decltype(auto) emplace(_Args&&... __args) noexcept {
return __vec.emplace_back(std::forward<_Args>(__args)...);
}
template <class... _Args> void insert(_Args&&... __args) noexcept {
__vec.insert(end(), std::forward<_Args>(__args)...);
}
/**
* @brief Sort and make unique.
*
* @return Number of different values.
*/
size_type make() noexcept {
std::sort(begin(), end());
__vec.erase(std::unique(begin(), end(),
[](const _Tp& __l, const _Tp& __r) {
return !(__l < __r) && !(__r < __l);
}),
end());
return size();
}
size_type lower_bound(const _Tp& __x) const noexcept {
return std::lower_bound(begin(), end(), __x) - begin();
}
size_type upper_bound(const _Tp& __x) const noexcept {
return std::upper_bound(begin(), end(), __x) - begin();
}
};
template <class _IIter>
compression(_IIter, _IIter)
-> compression<typename std::iterator_traits<_IIter>::value_type>;
} // namespace workspace
#line 2 "Library/src/graph/directed/flow/Dinic.hpp"
/**
* @file Dinic.hpp
* @brief Dinic's Algorithm
*/
#line 9 "Library/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 15 "Library/src/graph/directed/flow/base.hpp"
namespace workspace {
template <class _Cap, class _Cost = void> class flow_graph {
protected:
class adjacency_impl;
public:
using container_type = std::vector<adjacency_impl>;
using size_type = typename container_type::size_type;
class unweighted_edge {
public:
size_type src; // Source
size_type dst; // Destination
_Cap cap; // Capacity
_Cap flow = 0; // Flow
unweighted_edge(size_type __s, size_type __d, const _Cap &__u = 1)
: src(__s), dst(__d), cap(__u) {
assert(!(cap < static_cast<_Cap>(0)));
}
/**
* @brief Source, Destination, Capacity, Flow
*/
template <class _Os>
friend _Os &operator<<(_Os &__os, const unweighted_edge &__e) {
return __os << __e.src << ' ' << __e.dst << ' ' << __e.cap << ' '
<< __e.flow;
}
protected:
unweighted_edge() = default;
unweighted_edge(size_type __s, size_type __d, const _Cap &__u,
const _Cap &__f)
: src(__s), dst(__d), cap(__u), flow(__f) {}
unweighted_edge make_rev() const { return {dst, src, flow, cap}; }
};
class weighted_edge : public unweighted_edge {
public:
_Cost cost; // _Cost
weighted_edge(const unweighted_edge &__e, const _Cost &__c = 0)
: unweighted_edge(__e), cost(__c) {}
weighted_edge(size_type __s, size_type __d, const _Cap &__u = 1,
const _Cost &__c = 0)
: unweighted_edge(__s, __d, __u), cost(__c) {}
/**
* @brief Source, Destination, Capacity, Flow, _Cost
*/
template <class _Os>
friend _Os &operator<<(_Os &__os, const weighted_edge &__e) {
return __os << static_cast<unweighted_edge>(__e) << ' ' << __e.cost;
}
protected:
weighted_edge() = default;
weighted_edge make_rev() const {
return {unweighted_edge::make_rev(), -cost};
}
};
using edge = std::conditional_t<std::is_void<_Cost>::value, unweighted_edge,
weighted_edge>;
protected:
struct edge_impl : edge {
bool aux = false;
edge_impl *rev = nullptr;
edge_impl() = default;
edge_impl(const edge_impl &__e) = default;
edge_impl &operator=(const edge_impl &__e) = default;
edge_impl(edge_impl &&__e) = default;
edge_impl &operator=(edge_impl &&__e) = default;
edge_impl(const edge &__e) : edge(__e) {}
edge_impl(edge &&__e) : edge(__e) {}
void push(_Cap __f) {
edge::cap -= __f;
edge::flow += __f;
if (rev) {
rev->cap += __f;
rev->flow -= __f;
}
}
edge_impl make_rev() {
edge_impl __e = edge::make_rev();
__e.aux = true;
__e.rev = this;
return __e;
}
};
public:
class adjacency {
public:
using value_type = edge;
using reference = edge &;
using const_reference = edge const &;
using pointer = edge *;
using const_pointer = const edge *;
class iterator {
edge_impl *__p;
public:
iterator(edge_impl *__p = nullptr) : __p(__p) {}
bool operator!=(const iterator &__x) const { return __p != __x.__p; }
bool operator==(const iterator &__x) const { return __p == __x.__p; }
iterator &operator++() {
do ++__p;
while (__p->rev && __p->aux);
return *this;
}
iterator operator++(int) {
auto __cp = *this;
do ++__p;
while (__p->rev && __p->aux);
return __cp;
}
iterator &operator--() {
do --__p;
while (__p->aux);
return *this;
}
iterator operator--(int) {
auto __cp = *this;
do --__p;
while (__p->aux);
return __cp;
}
pointer operator->() const { return __p; }
reference operator*() const { return *__p; }
};
class const_iterator {
const edge_impl *__p;
public:
const_iterator(const edge_impl *__p = nullptr) : __p(__p) {}
bool operator!=(const const_iterator &__x) const {
return __p != __x.__p;
}
bool operator==(const const_iterator &__x) const {
return __p == __x.__p;
}
const_iterator &operator++() {
do ++__p;
while (__p->rev && __p->aux);
return *this;
}
const_iterator operator++(int) {
auto __cp = *this;
do ++__p;
while (__p->rev && __p->aux);
return __cp;
}
const_iterator &operator--() {
do --__p;
while (__p->aux);
return *this;
}
const_iterator operator--(int) {
auto __cp = *this;
do --__p;
while (__p->aux);
return __cp;
}
const_pointer operator->() const { return __p; }
const_reference operator*() const { return *__p; }
};
adjacency()
: first(new edge_impl[2]), last(first + 1), __s(first), __t(first) {}
~adjacency() { delete[] first; }
const_reference operator[](size_type __i) const {
assert(__i < size());
return *(first + __i);
}
size_type size() const { return __t - first; }
auto begin() { return iterator{__s}; }
auto begin() const { return const_iterator{__s}; }
auto end() { return iterator{__t}; }
auto end() const { return const_iterator{__t}; }
/**
* @brief Construct a new adjacency object
*
* @param __x Rvalue reference to another object
*/
adjacency(adjacency &&__x) : first(nullptr) { operator=(std::move(__x)); }
/**
* @brief Assignment operator.
*
* @param __x Rvalue reference to another object
* @return Reference to this object.
*/
adjacency &operator=(adjacency &&__x) {
std::swap(first, __x.first);
last = __x.last;
__s = __x.__s;
__t = __x.__t;
return *this;
}
protected:
edge_impl *first, *last, *__s, *__t;
};
using value_type = adjacency;
using reference = adjacency &;
using const_reference = adjacency const &;
protected:
class adjacency_impl : public adjacency {
public:
using base = adjacency;
using base::__s;
using base::__t;
using base::first;
using base::last;
using iterator = edge_impl *;
iterator _push(edge_impl &&__e) {
if (__t == last) {
size_type __n(last - first);
iterator loc = new edge_impl[__n << 1 | 1];
__s += loc - first;
__t = loc;
for (iterator __p{first}; __p != last; ++__p, ++__t) {
*__t = *__p;
if (__p->rev) __p->rev->rev = __t;
}
delete[] first;
first = loc;
last = __t + __n;
}
*__t = std::move(__e);
if (__s->aux) ++__s;
return __t++;
}
iterator begin() const { return first; }
iterator end() const { return __t; }
};
/**
* @brief The only member variable.
*/
container_type graph;
public:
/**
* @brief Construct a new flow graph object
*
* @param __n Number of vertices
*/
flow_graph(size_type __n = 0) : graph(__n) {}
/**
* @brief Construct a new flow graph object
*
* @param __x Const reference to another object
*/
flow_graph(const flow_graph &__x) : graph(__x.size()) {
for (auto &&__adj : __x)
for (auto &&__e : __adj) add_edge(__e);
}
/**
* @brief Construct a new flow graph object
*
* @param __x Rvalue reference to another object
*/
flow_graph(flow_graph &&__x) : graph(std::move(__x.graph)) {}
/**
* @brief Assignment operator.
*
* @param __x Const reference to another object
* @return Reference to this object.
*/
flow_graph &operator=(const flow_graph &__x) {
return operator=(std::move(flow_graph{__x}));
}
/**
* @brief Assignment operator.
*
* @param __x Rvalue reference to another object
* @return Reference to this object.
*/
flow_graph &operator=(flow_graph &&__x) {
graph = std::move(__x.graph);
return *this;
}
/**
* @return Whether the graph is empty.
*/
bool empty() const { return graph.empty(); }
/**
* @return Number of nodes.
*/
size_type size() const { return graph.size(); }
/**
* @param node Node
* @return Referece to the adjacency list of the node.
*/
reference operator[](size_type node) {
assert(node < size());
return graph[node];
}
/**
* @param node Node
* @return Const referece to the adjacency list of the node.
*/
const_reference operator[](size_type node) const {
assert(node < size());
return graph[node];
}
class iterator : public container_type::iterator {
using base = typename container_type::iterator;
public:
using reference = adjacency &;
using pointer = adjacency *;
iterator(const base &__i) : base(__i) {}
pointer operator->() const { return base::operator->(); }
reference operator*() const { return base::operator*(); }
};
class const_iterator : public container_type::const_iterator {
using base = typename container_type::const_iterator;
public:
using const_reference = const adjacency &;
using const_pointer = const adjacency *;
const_iterator(const base &__i) : base(__i) {}
const_pointer operator->() const { return base::operator->(); }
const_reference operator*() const { return base::operator*(); }
};
auto begin() { return iterator{graph.begin()}; }
auto begin() const { return const_iterator{graph.begin()}; }
auto end() { return iterator{graph.end()}; }
auto end() const { return const_iterator{graph.end()}; }
/**
* @brief Add a node to the graph.
*
* @return Index of the node.
*/
size_type add_node() { return add_nodes(1).front(); }
/**
* @brief Add some nodes to the graph.
*
* @param __n Number of nodes added
* @return List of indices of the nodes.
*/
virtual std::vector<size_type> add_nodes(size_type __n) {
std::vector<size_type> __nds(__n);
std::iota(__nds.begin(), __nds.end(), graph.size());
__n += graph.size();
if (__n > graph.capacity()) {
flow_graph __x(__n);
for (auto &&adj : graph)
for (auto &&__e : adj)
if (!__e.aux) __x.add_edge(__e);
graph = std::move(__x.graph);
} else
graph.resize(__n);
return __nds;
}
/**
* @brief Add a directed edge to the graph.
*
* @return Reference to the edge.
*/
template <class... _Args>
typename std::enable_if<std::is_constructible<edge, _Args...>::value,
edge &>::type
add_edge(_Args &&...__args) {
edge_impl __e = edge(std::forward<_Args>(__args)...);
assert(__e.src < size());
assert(__e.dst < size());
edge_impl *__p = graph[__e.src]._push(std::move(__e));
// Careful with a self loop.
if (__e.src != __e.dst) __p->rev = graph[__e.dst]._push(__p->make_rev());
return *__p;
}
/**
* @brief Add a directed edge to the graph.
*
* @return Reference to the edge.
*/
template <class _Tp>
typename std::enable_if<(std::tuple_size<std::decay_t<_Tp>>::value >= 0),
edge &>::type
add_edge(_Tp &&__t) {
return _unpack_directed(std::forward<_Tp>(__t));
}
/**
* @brief Add an undirected edge to the graph. Its cost must be non-negative.
*
* @return Reference to the edge.
*/
template <class... _Args> edge &add_undirected_edge(_Args &&...__args) {
edge_impl __e = edge(std::forward<_Args>(__args)...);
assert(__e.src < size());
assert(__e.dst < size());
(__e.flow += __e.flow) += __e.cap;
edge_impl *__p = graph[__e.src]._push(std::move(__e));
// Careful with a self loop.
if (__e.src != __e.dst) {
edge_impl __r = __p->make_rev();
__r.aux = false;
__p->rev = graph[__e.dst]._push(std::move(__r));
}
return *__p;
}
/**
* @brief Add an undirected edge to the graph. Its cost must be non-negative.
*
* @return Reference to the edge.
*/
template <class _Tp>
typename std::enable_if<(std::tuple_size<std::decay_t<_Tp>>::value >= 0),
edge &>::type
add_undirected_edge(_Tp &&__t) {
return _unpack_undirected(std::forward<_Tp>(__t));
}
protected:
// internal
template <class _Tp, size_t _Nm = 0, class... _Args>
decltype(auto) _unpack_directed(_Tp &&__t, _Args &&...__args) {
if constexpr (_Nm == std::tuple_size<std::decay_t<_Tp>>::value)
return add_edge(std::forward<_Args>(__args)...);
else
return _unpack_directed<_Tp, _Nm + 1>(std::forward<_Tp>(__t),
std::forward<_Args>(__args)...,
std::get<_Nm>(__t));
}
// internal
template <class _Tp, size_t _Nm = 0, class... _Args>
decltype(auto) _unpack_undirected(_Tp &&__t, _Args &&...__args) {
if constexpr (_Nm == std::tuple_size<std::decay_t<_Tp>>::value)
return add_undirected_edge(std::forward<_Args>(__args)...);
else
return _unpack_undirected<_Tp, _Nm + 1>(std::forward<_Tp>(__t),
std::forward<_Args>(__args)...,
std::get<_Nm>(__t));
}
template <class _Os>
friend _Os &operator<<(_Os &__os, flow_graph const &__g) {
for (const auto &adj : __g)
for (const auto &e : adj) __os << e << "\n";
return __os;
}
};
} // namespace workspace
#line 11 "Library/src/graph/directed/flow/Dinic.hpp"
namespace workspace {
/**
* @brief Compute the maximum flow.
*
* @tparam _Cap Capacity type
*/
template <class _Cap> class Dinic : public flow_graph<_Cap> {
using base = flow_graph<_Cap>;
public:
using size_type = typename base::size_type;
protected:
constexpr static size_type nil = -1;
std::vector<size_type> level;
std::vector<typename base::container_type::value_type::iterator> iter;
_Cap dfs(size_type __src, size_type __dst, _Cap __bound) {
if (__src == __dst) return __bound;
_Cap __flow(0);
for (auto &__e{iter[__dst]}; __e != base::graph[__dst].end(); ++__e)
if (static_cast<_Cap>(0) < __e->flow && level[__e->dst] < level[__dst])
if (_Cap achv = dfs(__src, __e->dst, std::min(__bound, __e->flow));
static_cast<_Cap>(0) < achv) {
__e->push(-achv);
__flow += achv, __bound -= achv;
if (__bound == static_cast<_Cap>(0)) break;
}
return __flow;
}
public:
/**
* @brief Construct a new Dinic object.
*
* @param __n Number of nodes
*/
Dinic(size_type __n = 0)
: base::flow_graph(__n), level(__n, nil), iter(__n) {}
/**
* @brief Add some nodes to the graph.
*
* @param __n Number of nodes added
* @return List of indices of the nodes.
*/
std::vector<size_type> add_nodes(size_type __n) override {
auto __nds = base::add_nodes(__n);
level.resize(base::size(), nil);
iter.resize(base::size());
return __nds;
}
/**
* @brief Run Dinic's algorithm.
*
* @param __src Source
* @param __dst Destination
* @return Maximum flow.
*/
_Cap run(size_type __src, size_type __dst) {
assert(__src < base::size());
assert(__dst < base::size());
assert(__src != __dst);
_Cap __flow = 0, __bound = std::numeric_limits<_Cap>::max();
for (std::vector<size_type> __q(base::size());;
std::fill(level.begin(), level.end(), nil)) {
level[__q.front() = __src] = 0;
for (auto __ql{__q.begin()}, __qr{std::next(__ql)};
level[__dst] == nil && __ql != __qr; ++__ql)
for (const auto &__e : base::graph[*__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 __x{}; __x != base::size(); ++__x)
iter[__x] = base::graph[__x].begin();
__flow += dfs(__src, __dst, __bound);
}
return __flow;
}
};
} // namespace workspace
#line 28 "other/yuki.cc"
namespace workspace {
void main() {
// start here!
int h, w;
cin >> h >> w;
vector<compression<int>> rows(501010), cols(rows);
vector<vector<pair<int, int>>> cells(501010);
for (auto i : range(h)) {
for (auto j : range(w)) {
int a;
cin >> a;
if (a) {
cells[a].emplace_back(i, j);
rows[a].insert(i);
cols[a].insert(j);
}
}
}
int ans{};
for (auto &&[rs, cs, ps] : zip(rows, cols, cells)) {
rs.make();
cs.make();
Dinic<int> g;
auto src = g.add_node();
auto dst = g.add_node();
auto rv = g.add_nodes(rs.size());
auto cv = g.add_nodes(cs.size());
for (auto &&v : rv) {
g.add_edge(src, v, 1);
}
for (auto &&v : cv) {
g.add_edge(v, dst, 1);
}
for (auto [x, y] : ps) {
g.add_edge(rv[rs.lower_bound(x)], cv[cs.lower_bound(y)], 1);
}
ans += g.run(src, dst);
}
cout << ans << "\n";
}
} // namespace workspace