結果
| 問題 | No.1678 Coin Trade (Multiple) |
| ユーザー |
 jell
|
| 提出日時 | 2021-09-11 15:02:34 |
| 言語 | C++17 (gcc 12.3.0 + boost 1.83.0) |
| 結果 |
TLE
|
| 実行時間 | - |
| コード長 | 63,934 bytes |
| コンパイル時間 | 6,603 ms |
| コンパイル使用メモリ | 317,220 KB |
| 実行使用メモリ | 26,244 KB |
| 最終ジャッジ日時 | 2024-06-22 23:05:36 |
| 合計ジャッジ時間 | 16,620 ms |
|
ジャッジサーバーID （参考情報） |
judge2 / judge3 |
（要ログイン）
テストケース
テストケース表示| 入力 | 結果 | 実行時間 実行使用メモリ |
|---|---|---|
| testcase_00 | AC | 2 ms
26,244 KB |
| testcase_01 | AC | 2 ms
6,940 KB |
| testcase_02 | AC | 2 ms
6,940 KB |
| testcase_03 | AC | 2,510 ms
14,464 KB |
| testcase_04 | TLE | - |
| testcase_05 | -- | - |
| testcase_06 | -- | - |
| testcase_07 | -- | - |
| testcase_08 | -- | - |
| testcase_09 | -- | - |
| testcase_10 | -- | - |
| testcase_11 | -- | - |
| testcase_12 | -- | - |
| testcase_13 | -- | - |
| testcase_14 | -- | - |
| testcase_15 | -- | - |
| testcase_16 | -- | - |
| testcase_17 | -- | - |
| testcase_18 | -- | - |
| testcase_19 | -- | - |
| testcase_20 | -- | - |
| testcase_21 | -- | - |
| testcase_22 | -- | - |
| testcase_23 | -- | - |
| testcase_24 | -- | - |
| testcase_25 | -- | - |
| testcase_26 | -- | - |
| testcase_27 | -- | - |
| testcase_28 | -- | - |
| testcase_29 | -- | - |
| testcase_30 | -- | - |
| testcase_31 | -- | - |
| testcase_32 | -- | - |
| testcase_33 | -- | - |
| testcase_34 | -- | - |
| testcase_35 | -- | - |
| testcase_36 | -- | - |
| testcase_37 | -- | - |
| testcase_38 | -- | - |
| testcase_39 | -- | - |
| testcase_40 | -- | - |
| testcase_41 | -- | - |
| testcase_42 | -- | - |
| testcase_43 | -- | - |
| testcase_44 | -- | - |
| testcase_45 | -- | - |
| testcase_46 | -- | - |
| testcase_47 | -- | - |
| testcase_48 | -- | - |
| testcase_49 | -- | - |
| testcase_50 | -- | - |
| testcase_51 | -- | - |
| testcase_52 | -- | - |
| testcase_53 | -- | - |
| testcase_54 | -- | - |
| testcase_55 | -- | - |
| testcase_56 | -- | - |
| testcase_57 | -- | - |
| testcase_58 | -- | - |
ソースコード
#line 1 "other-workspace\\y.cc"
#if defined(ONLINE_JUDGE) // && 0
#pragma GCC optimize("Ofast,unroll-loops")
#pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,mmx,avx,avx2")
#endif
// #undef _GLIBCXX_DEBUG
#include <bits/extc++.h>
#line 2 "Library\\lib\\alias"
/**
* @file alias
* @brief Alias
*/
#line 10 "Library\\lib\\alias"
// #include "bit"
#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 13 "Library\\lib\\alias"
namespace workspace {
constexpr static char eol = '\n';
using namespace std;
using i32 = int_least32_t;
using u32 = uint_least32_t;
using i64 = int_least64_t;
using u64 = uint_least64_t;
#ifdef __SIZEOF_INT128__
using i128 = __int128_t;
using u128 = __uint128_t;
#else
#warning 128-bit integer is not available.
#endif
template <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);
}
#ifdef _GLIBCXX_BIT
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;
}
#endif
} // namespace workspace
#line 10 "other-workspace\\y.cc"
// #include "lib/cxx20"
#line 2 "Library\\src\\sys\\call_once.hpp"
/**
* @file call_once.hpp
* @brief Call Once
*/
#line 9 "Library\\src\\sys\\call_once.hpp"
namespace workspace {
/**
* @brief Call once.
*/
template <class _F> void call_once(_F &&__f) {
static std::unordered_set<void *> __called;
if (__called.count(std::addressof(__f))) return;
__called.emplace(std::addressof(__f));
__f();
}
} // namespace workspace
#line 2 "Library\\src\\sys\\clock.hpp"
/**
* @file 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
/**
* @return Elapsed time of the program.
*/
decltype(auto) elapsed() noexcept {
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 1 "Library\\lib\\utils"
// #include "src/utils/cached.hpp"
// #include "src/utils/cat.hpp"
#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 2 "Library\\src\\utils\\fixed_point.hpp"
/**
* @file fixed_point.hpp
* @brief Fixed Point Combinator
*/
#line 9 "Library\\src\\utils\\fixed_point.hpp"
namespace workspace {
/**
* @brief Fixed Point Combinator.
*/
template <class _F> class fixed_point {
struct _wrapper {
_F &__ref;
template <class... _Args>
decltype(auto) operator()(_Args &&...__args) noexcept(
noexcept(__ref(*this, std::forward<_Args>(__args)...))) {
return __ref(*this, std::forward<_Args>(__args)...);
}
};
_F __fn;
public:
// Construct a new fixed-point object.
fixed_point(_F __x) noexcept : __fn(__x) {}
// Function call.
template <class... _Args>
decltype(auto) operator()(_Args &&...__args) noexcept(noexcept(_wrapper{
__fn}(std::forward<_Args>(__args)...))) {
return _wrapper{__fn}(std::forward<_Args>(__args)...);
}
};
} // namespace workspace
#line 5 "Library\\lib\\utils"
// #include "src/utils/hash.hpp"
// #include "src/utils/io/istream.hpp"
// #include "src/utils/io/ostream.hpp"
// #include "src/utils/io/read.hpp"
// #include "src/utils/grid/motion.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 {
/**
* @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 11 "Library\\lib\\utils"
// #include "src/utils/iterator/category.hpp"
// #include "src/utils/iterator/reverse.hpp"
// #include "src/utils/make_vector.hpp"
#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 2 "Library\\src\\utils\\py-like\\reversed.hpp"
/**
* @file reversed.hpp
* @brief Reversed
*/
#line 9 "Library\\src\\utils\\py-like\\reversed.hpp"
#line 2 "Library\\lib\\cxx17"
#line 2 "Library\\lib\\cxx14"
#ifndef _CXX14_CONSTEXPR
#if __cplusplus >= 201402L
#define _CXX14_CONSTEXPR constexpr
#else
#define _CXX14_CONSTEXPR
#endif
#endif
#line 4 "Library\\lib\\cxx17"
#ifndef _CXX17_CONSTEXPR
#if __cplusplus >= 201703L
#define _CXX17_CONSTEXPR constexpr
#else
#define _CXX17_CONSTEXPR
#endif
#endif
#ifndef _CXX17_STATIC_ASSERT
#if __cplusplus >= 201703L
#define _CXX17_STATIC_ASSERT static_assert
#else
#define _CXX17_STATIC_ASSERT assert
#endif
#endif
#line 22 "Library\\lib\\cxx17"
#if __cplusplus < 201703L
namespace std {
/**
* @brief Return the size of a container.
* @param __cont Container.
*/
template <typename _Container>
constexpr auto size(const _Container& __cont) noexcept(noexcept(__cont.size()))
-> decltype(__cont.size()) {
return __cont.size();
}
/**
* @brief Return the size of an array.
*/
template <typename _Tp, size_t _Nm>
constexpr size_t size(const _Tp (&)[_Nm]) noexcept {
return _Nm;
}
/**
* @brief Return whether a container is empty.
* @param __cont Container.
*/
template <typename _Container>
[[nodiscard]] constexpr auto empty(const _Container& __cont) noexcept(
noexcept(__cont.empty())) -> decltype(__cont.empty()) {
return __cont.empty();
}
/**
* @brief Return whether an array is empty (always false).
*/
template <typename _Tp, size_t _Nm>
[[nodiscard]] constexpr bool empty(const _Tp (&)[_Nm]) noexcept {
return false;
}
/**
* @brief Return whether an initializer_list is empty.
* @param __il Initializer list.
*/
template <typename _Tp>
[[nodiscard]] constexpr bool empty(initializer_list<_Tp> __il) noexcept {
return __il.size() == 0;
}
struct monostate {};
} // namespace std
#else
#include <variant>
#endif
#line 11 "Library\\src\\utils\\py-like\\reversed.hpp"
namespace workspace {
// Reversed container.
template <class _Container> class reversed {
_Container __c;
public:
template <class _Tp>
constexpr reversed(_Tp &&__x) noexcept : __c(std::forward<_Container>(__x)) {}
template <class _Tp>
constexpr reversed(std::initializer_list<_Tp> __x) noexcept : __c(__x) {}
constexpr decltype(auto) begin() noexcept { return std::rbegin(__c); }
constexpr decltype(auto) begin() const noexcept { return std::rbegin(__c); }
constexpr decltype(auto) end() noexcept { return std::rend(__c); }
constexpr decltype(auto) end() const noexcept { return std::rend(__c); }
constexpr bool empty() const noexcept { return std::empty(__c); }
constexpr decltype(auto) size() const noexcept { return std::size(__c); }
using iterator = decltype(std::rbegin(__c));
using const_iterator = decltype(std::crbegin(__c));
using size_type = decltype(std::size(__c));
using difference_type =
typename std::iterator_traits<iterator>::difference_type;
using value_type = typename std::iterator_traits<iterator>::value_type;
using reference = typename std::iterator_traits<iterator>::reference;
using const_reference =
typename std::iterator_traits<const_iterator>::reference;
};
#if __cpp_deduction_guides >= 201606L
template <class _Tp> reversed(_Tp &&) -> reversed<_Tp>;
template <class _Tp>
reversed(std::initializer_list<_Tp>) -> reversed<std::initializer_list<_Tp>>;
#endif
} // namespace workspace
#line 9 "Library\\src\\utils\\py-like\\range.hpp"
namespace workspace {
template <class _Index> class range {
_Index __first, __last;
public:
class iterator {
_Index __i;
public:
using difference_type = std::ptrdiff_t;
using value_type = _Index;
using pointer = void;
using reference = value_type;
using iterator_category = std::random_access_iterator_tag;
constexpr iterator() = default;
constexpr iterator(const _Index &__x) noexcept : __i(__x) {}
constexpr bool operator==(const iterator &__x) const noexcept {
return __i == __x.__i;
}
constexpr bool operator!=(const iterator &__x) const noexcept {
return __i != __x.__i;
}
constexpr bool operator<(const iterator &__x) const noexcept {
return __i < __x.__i;
}
constexpr bool operator<=(const iterator &__x) const noexcept {
return __i <= __x.__i;
}
constexpr bool operator>(const iterator &__x) const noexcept {
return __i > __x.__i;
}
constexpr bool operator>=(const iterator &__x) const noexcept {
return __i >= __x.__i;
}
constexpr iterator &operator++() noexcept {
++__i;
return *this;
}
constexpr iterator operator++(int) noexcept {
auto __tmp = *this;
++__i;
return __tmp;
}
constexpr iterator &operator--() noexcept {
--__i;
return *this;
}
constexpr iterator operator--(int) noexcept {
auto __tmp = *this;
--__i;
return __tmp;
}
constexpr difference_type operator-(const iterator &__x) const noexcept {
return __i - __x.__i;
}
constexpr iterator &operator+=(difference_type __x) noexcept {
__i += __x;
return *this;
}
constexpr iterator operator+(difference_type __x) const noexcept {
return iterator(*this) += __x;
}
constexpr iterator &operator-=(difference_type __x) noexcept {
__i -= __x;
return *this;
}
constexpr iterator operator-(difference_type __x) const noexcept {
return iterator(*this) -= __x;
}
constexpr reference operator*() const noexcept { return __i; }
};
using value_type = _Index;
using reference = value_type;
using difference_type = std::ptrdiff_t;
using size_type = std::size_t;
using const_iterator = iterator;
using reverse_iterator = std::reverse_iterator<iterator>;
using const_reverse_iterator = reverse_iterator;
template <class _Tp1, class _Tp2>
constexpr range(const _Tp1 &__first, const _Tp2 &__last) noexcept
: __first(__first), __last(__last) {}
template <class _Tp>
constexpr range(const _Tp &__last) noexcept : __first(), __last(__last) {}
constexpr iterator begin() const noexcept { return {__first}; }
constexpr const_iterator cbegin() const noexcept { return begin(); }
constexpr iterator end() const noexcept { return {__last}; }
constexpr const_iterator cend() const noexcept { return end(); }
constexpr reverse_iterator rbegin() const noexcept {
return reverse_iterator{end()};
}
constexpr const_reverse_iterator crbegin() const noexcept { return rbegin(); }
constexpr reverse_iterator rend() const noexcept {
return reverse_iterator{begin()};
}
constexpr const_reverse_iterator crend() const noexcept { return rend(); }
constexpr size_type size() const noexcept {
return std::distance(__first, __last);
}
};
#if __cpp_deduction_guides >= 201606L
template <class _Tp1, class _Tp2>
range(const _Tp1 &, const _Tp2 &)
-> range<std::decay_t<decltype(++std::declval<_Tp1 &>())>>;
template <class _Tp>
range(const _Tp &) -> range<std::decay_t<decltype(++std::declval<_Tp &>())>>;
#endif
template <class... _Args>
constexpr decltype(auto) rrange(_Args &&...__args) noexcept {
return reversed(range(std::forward<_Args>(__args)...));
}
} // namespace workspace
#line 2 "Library\\src\\utils\\py-like\\zip.hpp"
/**
* @file zip.hpp
* @brief Zip
*/
#line 11 "Library\\src\\utils\\py-like\\zip.hpp"
#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 15 "Library\\src\\utils\\py-like\\zip.hpp"
namespace workspace {
template <class _Tuple> class zipped : protected _Tuple {
public:
zipped(const _Tuple &__x) : _Tuple(__x) {}
template <std::size_t _Nm> constexpr decltype(auto) get() const &noexcept {
return *std::get<_Nm>(*this);
}
template <std::size_t _Nm> constexpr decltype(auto) get() &&noexcept {
auto __tmp = *std::get<_Nm>(*this);
return __tmp;
}
};
template <class... _Containers> class zip {
std::tuple<_Containers...> __c;
template <std::size_t _Nm = 0>
constexpr decltype(auto) begin_cat() const noexcept {
if _CXX17_CONSTEXPR (_Nm != sizeof...(_Containers)) {
return std::tuple_cat(std::tuple(std::begin(std::get<_Nm>(__c))),
begin_cat<_Nm + 1>());
} else
return std::tuple<>();
}
template <std::size_t _Nm = 0>
constexpr decltype(auto) end_cat() const noexcept {
if _CXX17_CONSTEXPR (_Nm != sizeof...(_Containers)) {
return std::tuple_cat(std::tuple(std::end(std::get<_Nm>(__c))),
end_cat<_Nm + 1>());
} else
return std::tuple<>();
}
using _Iterator_tuple =
std::tuple<decltype(std::begin(std::declval<_Containers>()))...>;
public:
using size_type = std::size_t;
class iterator : public zipped<_Iterator_tuple> {
using _Base = zipped<_Iterator_tuple>;
public:
using difference_type = std::ptrdiff_t;
using value_type = _Base;
using pointer = void;
using reference = value_type &;
using iterator_category =
typename common_iterator_category<_Iterator_tuple>::type;
protected:
template <std::size_t _Nm = 0>
constexpr bool equal(const iterator &__x) const noexcept {
if _CXX17_CONSTEXPR (_Nm != sizeof...(_Containers)) {
return std::get<_Nm>(*this) == std::get<_Nm>(__x) ||
equal<_Nm + 1>(__x);
} else
return false;
}
template <std::size_t _Nm = 0> constexpr void increment() noexcept {
if _CXX17_CONSTEXPR (_Nm != sizeof...(_Containers))
++std::get<_Nm>(*this), increment<_Nm + 1>();
}
template <std::size_t _Nm = 0> constexpr void decrement() noexcept {
if _CXX17_CONSTEXPR (_Nm != sizeof...(_Containers))
--std::get<_Nm>(*this), decrement<_Nm + 1>();
}
template <std::size_t _Nm = 0>
constexpr void advance(difference_type __d) noexcept {
if _CXX17_CONSTEXPR (_Nm != sizeof...(_Containers))
std::get<_Nm>(*this) += __d, advance<_Nm + 1>(__d);
}
public:
iterator(const _Iterator_tuple &__x) : _Base(__x) {}
constexpr bool operator==(const iterator &__x) const noexcept {
return equal(__x);
}
constexpr bool operator!=(const iterator &__x) const noexcept {
return !equal(__x);
}
constexpr iterator &operator++() noexcept {
increment();
return *this;
}
constexpr iterator operator++(int) noexcept {
auto __tmp = *this;
increment();
return __tmp;
}
constexpr iterator &operator--() noexcept {
decrement();
return *this;
}
constexpr iterator operator--(int) noexcept {
auto __tmp = *this;
decrement();
return __tmp;
}
constexpr bool operator<(const iterator &__x) const noexcept {
return std::get<0>(*this) < std::get<0>(__x);
}
constexpr bool operator<=(const iterator &__x) const noexcept {
return std::get<0>(*this) <= std::get<0>(__x);
}
constexpr bool operator>(const iterator &__x) const noexcept {
return !operator<=(__x);
}
constexpr bool operator>=(const iterator &__x) const noexcept {
return !operator>(__x);
}
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 &__x) const noexcept {
return std::get<0>(*this) - std::get<0>(__x);
}
constexpr reference operator*() noexcept { return {*this}; }
};
using const_iterator = iterator;
template <class... _Args>
constexpr zip(_Args &&...__args) noexcept
: __c(std::forward<_Args>(__args)...) {}
template <class... _Args>
constexpr zip(std::initializer_list<_Args>... __args) noexcept
: __c(std::forward<_Args>(__args)...) {}
constexpr iterator begin() const noexcept { return {begin_cat()}; }
constexpr iterator end() const noexcept { return {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()};
}
#if __cplusplus >= 201703L
constexpr size_type size() const noexcept {
size_type __n = -1;
std::apply(
[&__n](auto &&__x) {
if (__n < __x.size()) __n = __x.size();
},
__c);
return __n;
}
#endif
};
#if __cpp_deduction_guides >= 201606L
template <class... _Args> zip(_Args &&...) -> zip<_Args...>;
// For gcc version < 10
// https://gcc.gnu.org/bugzilla/show_bug.cgi?id=80438
template <class _Tp, class... _Args>
zip(_Tp &&, _Args &&...) -> zip<_Tp, _Args...>;
template <class... _Args>
zip(std::initializer_list<_Args>...) -> zip<std::initializer_list<_Args>...>;
#endif
} // namespace workspace
namespace std {
template <size_t _Nm, class _Tuple>
struct tuple_element<_Nm, workspace::zipped<_Tuple>> {
using type = remove_reference_t<
typename iterator_traits<tuple_element_t<_Nm, _Tuple>>::reference>;
};
template <class _Tuple>
struct tuple_size<workspace::zipped<_Tuple>> : tuple_size<_Tuple> {};
} // namespace std
#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 17 "Library\\lib\\utils"
// #include "src/utils/py-like/zip.hpp"
// #include "src/utils/rand/rng.hpp"
// #include "src/utils/rand/shuffle.hpp"
#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 = void> struct has_begin : std::false_type {};
template <class _Tp>
struct has_begin<
_Tp, std::__void_t<decltype(std::begin(std::declval<const _Tp&>()))>>
: std::true_type {
using type = decltype(std::begin(std::declval<const _Tp&>()));
};
template <class _Tp, class = void> struct has_size : std::false_type {};
template <class _Tp>
struct has_size<_Tp, std::__void_t<decltype(std::size(std::declval<_Tp>()))>>
: std::true_type {};
template <class _Tp, class = void> struct has_resize : std::false_type {};
template <class _Tp>
struct has_resize<_Tp, std::__void_t<decltype(std::declval<_Tp>().resize(
std::declval<size_t>()))>> : std::true_type {};
template <class _Tp, class = void> struct has_mod : std::false_type {};
template <class _Tp>
struct has_mod<_Tp, std::__void_t<decltype(_Tp::mod)>> : 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>;
};
template <class> struct first_arg { using type = void; };
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;
};
template <class _Tp, class = void> struct parse_compare : first_arg<_Tp> {};
template <class _Tp>
struct parse_compare<_Tp, std::__void_t<decltype(&_Tp::operator())>>
: first_arg<decltype(&_Tp::operator())> {};
template <class _Container, class = void> struct get_dimension {
static constexpr size_t value = 0;
};
template <class _Container>
struct get_dimension<_Container,
std::enable_if_t<has_begin<_Container>::value>> {
static constexpr size_t value =
1 + get_dimension<typename std::iterator_traits<
typename has_begin<_Container>::type>::value_type>::value;
};
} // 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 21 "Library\\lib\\utils"
// #include "src\utils\rand\tree.hpp"
// #include "src\utils\reference_list.hpp"
#line 2 "Library\\src\\utils\\io\\input.hpp"
/**
* @file input.hpp
* @brief Input
*/
#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 16 "Library\\src\\utils\\io\\istream.hpp"
namespace workspace {
namespace _istream_impl {
template <class _Tp, typename = void> struct helper {
helper(std::istream &__is, _Tp &__x) {
if _CXX17_CONSTEXPR (has_begin<_Tp &>::value)
for (auto &&__e : __x) helper<std::decay_t<decltype(__e)>>(__is, __e);
else
static_assert(has_begin<_Tp>::value, "istream unsupported type.");
}
};
template <class _Tp>
struct helper<_Tp, std::__void_t<decltype(std::declval<std::istream &>() >>
std::declval<_Tp &>())>> {
helper(std::istream &__is, _Tp &__x) { __is >> __x; }
};
#ifdef __SIZEOF_INT128__
template <> struct helper<__uint128_t, void> {
helper(std::istream &__is, __uint128_t &__x) {
std::string __s;
__is >> __s;
bool __neg = false;
if (__s.front() == '-') __neg = true, __s.erase(__s.begin());
__x = 0;
for (char __d : __s) {
__x *= 10;
__d -= '0';
if (__neg)
__x -= __d;
else
__x += __d;
}
}
};
template <> struct helper<__int128_t, void> {
helper(std::istream &__is, __int128_t &__x) {
std::string __s;
__is >> __s;
bool __neg = false;
if (__s.front() == '-') __neg = true, __s.erase(__s.begin());
__x = 0;
for (char __d : __s) {
__x *= 10;
__d -= '0';
if (__neg)
__x -= __d;
else
__x += __d;
}
}
};
#endif // INT128
template <class _T1, class _T2> struct helper<std::pair<_T1, _T2>> {
helper(std::istream &__is, std::pair<_T1, _T2> &__x) {
helper<_T1>(__is, __x.first), helper<_T2>(__is, __x.second);
}
};
template <class... _Tp> struct helper<std::tuple<_Tp...>> {
helper(std::istream &__is, std::tuple<_Tp...> &__x) { iterate(__is, __x); }
private:
template <class _Tuple, size_t _Nm = 0>
void iterate(std::istream &__is, _Tuple &__x) {
if _CXX17_CONSTEXPR (_Nm != std::tuple_size<_Tuple>::value) {
helper<typename std::tuple_element<_Nm, _Tuple>::type>(
__is, std::get<_Nm>(__x)),
iterate<_Tuple, _Nm + 1>(__is, __x);
}
}
};
} // namespace _istream_impl
/**
* @brief A wrapper class for std::istream.
*/
class istream : public std::istream {
public:
/**
* @brief Wrapped operator.
*/
template <typename _Tp> istream &operator>>(_Tp &__x) {
_istream_impl::helper<_Tp>(*this, __x);
if (std::istream::fail()) {
static auto once = atexit([] {
std::cerr << "\n\033[43m\033[30mwarning: failed to read \'"
<< abi::__cxa_demangle(typeid(_Tp).name(), 0, 0, 0)
<< "\'.\033[0m\n\n";
});
assert(!once);
}
return *this;
}
};
decltype(auto) cin = static_cast<istream &>(std::cin);
} // namespace workspace
#line 10 "Library\\src\\utils\\io\\input.hpp"
namespace workspace {
namespace _input_impl {
template <class _Tp, bool _Is_class = false> class input {
_Tp __value;
template <class... _Args> struct is_convertible : std::false_type {};
template <class _Arg>
struct is_convertible<_Arg> : std::is_convertible<_Arg, _Tp> {};
public:
operator _Tp &() noexcept { return __value; }
operator const _Tp &() const noexcept { return __value; }
template <class... _Args>
input(_Args &&...__args) noexcept : __value(std::forward<_Args>(__args)...) {
if _CXX17_CONSTEXPR (not is_convertible<_Args...>::value) cin >> __value;
}
};
template <class _Tp> class input<_Tp, true> : public _Tp {
template <class... _Args> struct is_convertible : std::false_type {};
template <class _Arg>
struct is_convertible<_Arg> : std::is_convertible<_Arg, _Tp> {};
public:
operator _Tp &() noexcept { return *this; }
operator const _Tp &() const noexcept { return *this; }
template <class... _Args>
input(_Args &&...__args) noexcept : _Tp(std::forward<_Args>(__args)...) {
if _CXX17_CONSTEXPR (not is_convertible<_Args...>::value) cin >> *this;
}
template <class _E>
input(std::initializer_list<_E> __l) noexcept : _Tp(__l) {}
};
} // namespace _input_impl
// Standard input.
template <class _Tp = int_least64_t>
class input : public _input_impl::input<_Tp, std::is_class<_Tp>::value> {
public:
using _input_impl::input<_Tp, std::is_class<_Tp>::value>::input;
};
// Integrality.
template <class _Tp>
struct is_integral_ext<input<_Tp>> : is_integral_ext<_Tp> {};
} // namespace workspace
#line 2 "Library\\src\\utils\\io\\print.hpp"
/**
* @file print.hpp
* @brief Print
*/
#line 2 "Library\\src\\utils\\io\\ostream.hpp"
/**
* @file ostream.hpp
* @brief Output Stream
*/
#line 9 "Library\\src\\utils\\io\\ostream.hpp"
#line 11 "Library\\src\\utils\\io\\ostream.hpp"
namespace workspace {
template <class _Os> struct is_ostream {
template <typename... _Args>
static std::true_type __test(std::basic_ostream<_Args...> *);
static std::false_type __test(void *);
constexpr static bool value = decltype(__test(std::declval<_Os *>()))::value;
};
template <class _Os>
using ostream_ref =
typename std::enable_if<is_ostream<_Os>::value, _Os &>::type;
/**
* @brief Stream insertion operator for C-style array.
*
* @param __os Output stream
* @param __a Array
* @return Reference to __os.
*/
template <class _Os, class _Tp, size_t _Nm>
typename std::enable_if<bool(sizeof(_Tp) > 2), ostream_ref<_Os>>::type
operator<<(_Os &__os, const _Tp (&__a)[_Nm]) {
if _CXX17_CONSTEXPR (_Nm) {
__os << *__a;
for (auto __i = __a + 1, __e = __a + _Nm; __i != __e; ++__i)
__os << ' ' << *__i;
}
return __os;
}
/**
* @brief Stream insertion operator for std::array.
*
* @param __os Output stream
* @param __a Array
* @return Reference to __os.
*/
template <class _Os, class _Tp, size_t _Nm>
ostream_ref<_Os> operator<<(_Os &__os, const std::array<_Tp, _Nm> &__a) {
if _CXX17_CONSTEXPR (_Nm) {
__os << __a[0];
for (size_t __i = 1; __i != _Nm; ++__i) __os << ' ' << __a[__i];
}
return __os;
}
/**
* @brief Stream insertion operator for std::pair.
*
* @param __os Output stream
* @param __p Pair
* @return Reference to __os.
*/
template <class _Os, class _T1, class _T2>
ostream_ref<_Os> operator<<(_Os &__os, const std::pair<_T1, _T2> &__p) {
return __os << __p.first << ' ' << __p.second;
}
/**
* @brief Stream insertion operator for std::tuple.
*
* @param __os Output stream
* @param __t Tuple
* @return Reference to __os.
*/
template <class _Os, class _Tp, size_t _Nm = 0>
typename std::enable_if<bool(std::tuple_size<_Tp>::value + 1),
ostream_ref<_Os>>::type
operator<<(_Os &__os, const _Tp &__t) {
if _CXX17_CONSTEXPR (_Nm != std::tuple_size<_Tp>::value) {
if _CXX17_CONSTEXPR (_Nm) __os << ' ';
__os << std::get<_Nm>(__t);
operator<<<_Os, _Tp, _Nm + 1>(__os, __t);
}
return __os;
}
template <class _Os, class _Container,
typename = decltype(std::begin(std::declval<_Container>()))>
typename std::enable_if<
!std::is_convertible<std::decay_t<_Container>, std::string>::value &&
!std::is_convertible<std::decay_t<_Container>, char *>::value,
ostream_ref<_Os>>::type
operator<<(_Os &__os, const _Container &__cont) {
bool __h = true;
for (auto &&__e : __cont) __h ? __h = 0 : (__os << ' ', 0), __os << __e;
return __os;
}
#ifdef __SIZEOF_INT128__
/**
* @brief Stream insertion operator for __int128_t.
*
* @param __os Output Stream
* @param __x 128-bit integer
* @return Reference to __os.
*/
template <class _Os> ostream_ref<_Os> operator<<(_Os &__os, __int128_t __x) {
if (!__x) return __os << '0';
if (__x < 0) __os << '-';
char __s[40], *__p = __s;
while (__x) {
auto __d = __x % 10;
*__p++ = '0' + (__x < 0 ? -__d : __d);
__x /= 10;
}
*__p = 0;
for (char *__t = __s; __t < --__p; ++__t) *__t ^= *__p ^= *__t ^= *__p;
return __os << __s;
}
/**
* @brief Stream insertion operator for __uint128_t.
*
* @param __os Output Stream
* @param __x 128-bit unsigned integer
* @return Reference to __os.
*/
template <class _Os> ostream_ref<_Os> operator<<(_Os &__os, __uint128_t __x) {
if (!__x) return __os << '0';
char __s[40], *__p = __s;
while (__x) *__p++ = '0' + __x % 10, __x /= 10;
*__p = 0;
for (char *__t = __s; __t < --__p; ++__t) *__t ^= *__p ^= *__t ^= *__p;
return __os << __s;
}
#endif
} // namespace workspace
#line 9 "Library\\src\\utils\\io\\print.hpp"
namespace workspace {
/**
* @brief Print
* @tparam _Sep
* @tparam _End
*/
template <char _Sep = ' ', char _End = '\n', class _Tp, class... _Args>
void print(_Tp &&__x, _Args &&...__args) noexcept {
if _CXX17_CONSTEXPR (sizeof...(_Args))
cout << __x << _Sep, print(std::forward<_Args>(__args)...);
else
cout << __x << _End;
}
void flush() noexcept { cout << std::flush; }
} // namespace workspace
#line 13 "other-workspace\\y.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\\min_cost_flow.hpp"
/**
* @file min_cost_flow.hpp
* @brief Minimum Cost Flow
*/
#line 10 "Library\\src\\graph\\directed\\flow\\min_cost_flow.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 tail; // Source
size_type head; // Destination
_Cap capacity; // Capacity
_Cap flow; // Flow
unweighted_edge(size_type __s, size_type __d, const _Cap &__u = 1)
: tail(__s), head(__d), capacity(__u), flow(0) {
assert(!(capacity < static_cast<_Cap>(0)));
}
// tail, head, capacity, flow
template <class _Os>
friend _Os &operator<<(_Os &__os, const unweighted_edge &__e) {
return __os << __e.tail << ' ' << __e.head << ' ' << __e.capacity << ' '
<< __e.flow;
}
protected:
unweighted_edge() = default;
unweighted_edge(size_type __s, size_type __d, const _Cap &__u,
const _Cap &__f)
: tail(__s), head(__d), capacity(__u), flow(__f) {}
unweighted_edge make_rev() const { return {head, tail, flow, capacity}; }
};
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) {}
// tail, head, 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 &__e) : edge(__e) {}
edge_impl(edge &&__e) : edge(__e) {}
void push(_Cap __f) {
edge::capacity -= __f;
edge::flow += __f;
if (rev) {
rev->capacity += __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) {
delete[] first;
first = __x.first, __x.first = nullptr;
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; }
};
// 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.tail < size());
assert(__e.head < size());
edge_impl *__p = graph[__e.tail].push(std::move(__e));
// Careful with a self loop.
if (__e.tail != __e.head) __p->rev = graph[__e.head].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.tail < size());
assert(__e.head < size());
(__e.flow += __e.flow) += __e.capacity;
edge_impl *__p = graph[__e.tail].push(std::move(__e));
// Careful with a self loop.
if (__e.tail != __e.head) {
edge_impl __r = __p->make_rev();
__r.aux = false;
__p->rev = graph[__e.head].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 13 "Library\\src\\graph\\directed\\flow\\min_cost_flow.hpp"
namespace workspace {
/**
* @brief Capacity Scaling Algorithm.
*
* @tparam _Cap Capacity type
* @tparam _Cost Cost type
*/
template <class _Cap, class _Cost = _Cap>
class min_cost_flow : public flow_graph<_Cap, _Cost> {
using base = flow_graph<_Cap, _Cost>;
using edge_impl = typename base::edge_impl;
public:
using edge = typename base::edge;
using size_type = typename base::size_type;
/**
* @brief Construct a new min_cost_flow object
*
* @param __n Number of vertices
*/
min_cost_flow(size_type __n = 0) : base::flow_graph(__n), b(__n) {}
std::vector<size_type> add_nodes(size_type __n) override {
b.resize(b.size() + __n);
return base::add_nodes(__n);
}
using base::add_edge;
/**
* @brief Add a directed edge to the graph.
*
* @param __s Source
* @param __d Destination
* @param __l Lower bound of flow
* @param __u Upper bound of flow
* @param __c _Cost
* @return Reference to the edge.
*/
edge &add_edge(size_type __s, size_type __d, _Cap __l, _Cap __u, _Cost __c) {
assert(!(__u < __l));
b[__s] -= __l;
b[__d] += __l;
auto &__e = base::add_edge(__s, __d, __u - __l, __c);
__e.flow = __l;
return __e;
}
/**
* @brief Add an undirected edge to the graph.
*
* @return Reference to the edge.
*/
template <class... _Args> edge &add_undirected_edge(_Args &&...__args) {
auto &__e = static_cast<edge_impl &>(
base::add_undirected_edge(std::forward<_Args>(__args)...));
assert(!(__e.cost < 0));
__e.rev->cost = __e.cost;
return __e;
}
/**
* @brief Increase the balance of a node.
*
* @param node
* @param __f Default: 1
*/
void supply(size_type node, _Cap __f = 1) {
assert(node < b.size());
b[node] += __f;
}
/**
* @brief Decrease the balance of a node.
*
* @param node
* @param __f Default: 1
*/
void demand(size_type node, _Cap __f = 1) {
assert(node < b.size());
b[node] -= __f;
}
/**
* @return Balance.
*/
const auto &balance() const { return b; }
/**
* @param node Node
* @return Balance of the node.
*/
_Cap balance(size_type node) const { return b[node]; }
/**
* @return Potential. The dual solution.
*/
const auto &potential() const { return p; }
/**
* @param node Node
* @return Potential of the node.
*/
_Cost potential(size_type node) const { return p[node]; }
/**
* @return _Cost of current flow.
*/
_Cost cost() const { return current; }
/**
* @brief Run Capacity Scaling Algorithm.
*
* @return Whether a balanced flow exists.
*/
bool run() {
p.resize(b.size());
_Cap delta = 0;
for (auto &&__adj : base::graph)
for (auto &&__e : __adj) delta = std::max(delta, __e.capacity);
if (delta == static_cast<_Cap>(0))
return std::all_of(b.begin(), b.end(),
[](_Cap __x) { return __x == static_cast<_Cap>(0); });
parent.resize(b.size());
while (static_cast<_Cap>(0) < delta) {
delta /= 2;
for (auto &&__adj : base::graph)
for (auto &&__e : __adj)
if (delta < __e.capacity && __e.cost < p[__e.head] - p[__e.tail]) {
b[__e.tail] -= __e.capacity;
b[__e.head] += __e.capacity;
__e.push(__e.capacity);
}
sources.clear();
sinks.clear();
for (size_type __v = 0; __v != b.size(); ++__v)
if (delta < b[__v])
sources.emplace_back(__v);
else if (b[__v] < -delta)
sinks.emplace_back(__v);
while (dual(delta)) {
primal(delta);
sources.erase(
std::remove_if(sources.begin(), sources.end(),
[&](auto __v) { return !(delta < b[__v]); }),
sources.end());
sinks.erase(
std::remove_if(sinks.begin(), sinks.end(),
[&](auto __v) { return !(b[__v] < -delta); }),
sinks.end());
}
}
current = 0;
for (auto &&__adj : base::graph)
for (auto &&__e : __adj)
if (!__e.aux) current += __e.cost * __e.flow;
return sources.empty() && sinks.empty();
}
protected:
// _Cost of flow.
_Cost current{};
// Balance
std::vector<_Cap> b;
// The dual solution.
std::vector<_Cost> p;
std::vector<edge_impl *> parent;
std::vector<size_type> sources, sinks;
// Augment along the dual solution.
void primal(_Cap delta) {
for (auto __t : sinks)
if (parent[__t]) {
auto __f = -b[__t];
auto __s = __t;
while (parent[__s])
__f = std::min(__f, parent[__s]->capacity), __s = parent[__s]->tail;
if (delta < b[__s]) {
__f = std::min(__f, b[__s]);
b[__s] -= __f;
b[__t] += __f;
for (auto *__p = parent[__t]; __p; __p = parent[__p->tail]) {
__p->push(__f);
parent[__p->head] = nullptr;
}
}
}
}
// Improve the dual solution.
bool dual(_Cap delta) {
std::fill(parent.begin(), parent.end(), nullptr);
size_type reachable = 0;
struct state {
size_type __v;
_Cost __d;
state(size_type __v, _Cost __d) : __v(__v), __d(__d) {}
bool operator<(const state &__x) const { return __x.__d < __d; }
};
std::priority_queue<state> __q;
decltype(p) __nx(p.size(), numeric_limits<_Cost>::max());
_Cost __ld = 0;
for (auto __v : sources) {
__nx[__v] = p[__v];
__q.emplace(__v, 0);
}
while (!__q.empty()) {
auto [__v, __d] = __q.top();
__q.pop();
if (__d + p[__v] != __nx[__v]) continue;
__ld = __d;
if (b[__v] < -delta && ++reachable == sinks.size()) break;
for (auto &__e : base::graph[__v])
if (delta < __e.capacity &&
(__d = __nx[__v] + __e.cost) < __nx[__e.head]) {
__q.emplace(__e.head, (__nx[__e.head] = __d) - p[__e.head]);
parent[__e.head] = &__e;
}
}
for (size_type __v = 0; __v != p.size(); ++__v)
p[__v] = std::min(__nx[__v], p[__v] += __ld);
return reachable;
}
};
} // namespace workspace
#line 29 "other-workspace\\y.cc"
namespace workspace {
void main() {
// start here!
input n, k;
min_cost_flow<i32, i64> mcf(n);
mcf.supply(0, k);
mcf.demand(n - 1, k);
vector<i32> rate;
for (auto v : range(n)) {
if (v) {
mcf.add_edge(v - 1, v, k, 0);
}
input a, m;
while (m--) {
input b;
--b;
mcf.add_edge(b, v, 1, rate[b] - a);
}
rate.emplace_back(a);
}
assert(mcf.run());
print(-mcf.cost());
}
} // namespace workspace