結果
| 問題 | No.1600 Many Shortest Path Problems |
| ユーザー |
 jell
|
| 提出日時 | 2021-07-10 13:43:02 |
| 言語 | C++17 (gcc 12.3.0 + boost 1.83.0) |
| 結果 |
AC
|
| 実行時間 | 638 ms / 4,000 ms |
| コード長 | 63,734 bytes |
| コンパイル時間 | 4,970 ms |
| コンパイル使用メモリ | 303,324 KB |
| 実行使用メモリ | 47,524 KB |
| 最終ジャッジ日時 | 2023-09-14 19:08:18 |
| 合計ジャッジ時間 | 20,013 ms |
|
ジャッジサーバーID （参考情報） |
judge11 / judge14 |
（要ログイン）
テストケース
テストケース表示| 入力 | 結果 | 実行時間 実行使用メモリ |
|---|---|---|
| testcase_00 | AC | 1 ms
4,356 KB |
| testcase_01 | AC | 2 ms
4,356 KB |
| testcase_02 | AC | 1 ms
4,352 KB |
| testcase_03 | AC | 1 ms
4,356 KB |
| testcase_04 | AC | 638 ms
46,064 KB |
| testcase_05 | AC | 635 ms
45,992 KB |
| testcase_06 | AC | 1 ms
4,360 KB |
| testcase_07 | AC | 2 ms
4,360 KB |
| testcase_08 | AC | 2 ms
4,352 KB |
| testcase_09 | AC | 2 ms
4,356 KB |
| testcase_10 | AC | 189 ms
6,616 KB |
| testcase_11 | AC | 240 ms
7,736 KB |
| testcase_12 | AC | 339 ms
17,684 KB |
| testcase_13 | AC | 514 ms
34,724 KB |
| testcase_14 | AC | 611 ms
45,836 KB |
| testcase_15 | AC | 2 ms
4,380 KB |
| testcase_16 | AC | 1 ms
4,380 KB |
| testcase_17 | AC | 426 ms
27,024 KB |
| testcase_18 | AC | 617 ms
45,932 KB |
| testcase_19 | AC | 2 ms
4,380 KB |
| testcase_20 | AC | 1 ms
4,380 KB |
| testcase_21 | AC | 404 ms
26,300 KB |
| testcase_22 | AC | 1 ms
4,380 KB |
| testcase_23 | AC | 1 ms
4,376 KB |
| testcase_24 | AC | 621 ms
45,992 KB |
| testcase_25 | AC | 1 ms
4,376 KB |
| testcase_26 | AC | 2 ms
4,380 KB |
| testcase_27 | AC | 1 ms
4,380 KB |
| testcase_28 | AC | 2 ms
4,380 KB |
| testcase_29 | AC | 243 ms
30,476 KB |
| testcase_30 | AC | 248 ms
30,336 KB |
| testcase_31 | AC | 333 ms
26,084 KB |
| testcase_32 | AC | 343 ms
25,964 KB |
| testcase_33 | AC | 2 ms
4,380 KB |
| testcase_34 | AC | 2 ms
4,380 KB |
| testcase_35 | AC | 363 ms
47,524 KB |
| testcase_36 | AC | 239 ms
46,912 KB |
| testcase_37 | AC | 2 ms
4,380 KB |
| testcase_38 | AC | 231 ms
29,740 KB |
| testcase_39 | AC | 2 ms
4,376 KB |
| testcase_40 | AC | 255 ms
29,824 KB |
| testcase_41 | AC | 210 ms
30,628 KB |
| testcase_42 | AC | 218 ms
30,036 KB |
| testcase_43 | AC | 224 ms
30,212 KB |
| testcase_44 | AC | 262 ms
28,856 KB |
| testcase_45 | AC | 253 ms
30,836 KB |
| testcase_46 | AC | 240 ms
30,020 KB |
| testcase_47 | AC | 278 ms
30,048 KB |
| testcase_48 | AC | 269 ms
29,464 KB |
| testcase_49 | AC | 2 ms
4,380 KB |
| testcase_50 | AC | 2 ms
4,380 KB |
| testcase_51 | AC | 1 ms
4,376 KB |
| testcase_52 | AC | 2 ms
4,384 KB |
| testcase_53 | AC | 1 ms
4,380 KB |
ソースコード
#line 1 "atcoder-workspace\\yuki2.cc"
// #undef _GLIBCXX_DEBUG
// #define NDEBUG
#include <bits/extc++.h>
#line 2 "Library\\lib\\alias"
/**
* @file alias
* @brief Alias
*/
#line 10 "Library\\lib\\alias"
#line 2 "Library\\lib\\bit"
#if __cplusplus > 201703L
#include <bit>
#elif __cplusplus > 201402L
#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 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 6 "atcoder-workspace\\yuki2.cc"
// #include "lib/cxx20"
// #include "lib/direct"
// #include "lib/opt"
#line 2 "Library\\src\\sys\\call_once.hpp"
/**
* @file call_once.hpp
* @brief Call Once
*/
#line 9 "Library\\src\\sys\\call_once.hpp"
namespace workspace {
/**
* @brief Call once.
*/
template <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"
#line 2 "Library\\src\\utils\\cat.hpp"
/**
* @file cat.hpp
* @brief Cat
*/
#line 9 "Library\\src\\utils\\cat.hpp"
#line 2 "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
#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;
}
} // namespace std
#endif
#line 11 "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 _CXX17_CONSTEXPR (std::is_rvalue_reference<decltype(__c2)>::value)
__c.insert(std::end(__c), std::make_move_iterator(std::begin(__c2)),
std::make_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 1 "Library\\src\\utils\\compare.hpp"
/**
* @file compare.hpp
* @brief Compare
*/
#line 2 "Library\\src\\utils\\sfinae.hpp"
/**
* @file sfinae.hpp
* @brief SFINAE
*/
#line 10 "Library\\src\\utils\\sfinae.hpp"
#include <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 = 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())> {};
} // namespace workspace
#line 7 "Library\\src\\utils\\compare.hpp"
#if __cplusplus >= 201703L
namespace workspace {
/**
* @brief Compare 2 points by their value of `atan2`.
*
* @return
*/
template <class _Tp>
bool compare_arg(const _Tp& __p1, const _Tp& __p2) noexcept {
const auto& [__x1, __y1] = __p1;
const auto& [__x2, __y2] = __p2;
using value_type = std::decay_t<decltype(__x1)>;
using mul_type = typename multiplicable<value_type>::type;
if (__y1 == value_type(0))
return value_type(0) <= __x1 &&
(value_type(0) < __y2 ||
(__y2 == value_type(0) && __x2 < value_type(0)));
return value_type(0) < __y1
? value_type(0) <= __y2 &&
mul_type(__y1) * __x2 < mul_type(__x1) * __y2
: value_type(0) <= __y2 ||
mul_type(__y1) * __x2 < mul_type(__x1) * __y2;
}
} // namespace workspace
#endif
#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 6 "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"
#line 2 "Library\\src\\utils\\grid\\motion.hpp"
/**
* @file motion.hpp
* @brief Motion
*/
#line 9 "Library\\src\\utils\\grid\\motion.hpp"
#line 11 "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 {
#if __cplusplus < 201703L
auto __h = __grid.size(), __w = __grid[0].size();
#else
auto __h = std::size(__grid), __w = std::size(__grid[0]);
#endif
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 _CXX17_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
*/
template <class _Grid> decltype(auto) roll_ccw(_Grid &&__grid) noexcept {
if _CXX17_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
*/
template <class _Grid> decltype(auto) roll_cw(_Grid &&__grid) noexcept {
if _CXX17_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 14 "Library\\lib\\utils"
// #include "src/utils/make_vector.hpp"
// #include "src/utils/py-like/enumerate.hpp"
#line 2 "Library\\src\\utils\\py-like\\range.hpp"
/**
* @file range.hpp
* @brief Range
*/
#line 9 "Library\\src\\utils\\py-like\\range.hpp"
#line 2 "Library\\src\\utils\\py-like\\reversed.hpp"
/**
* @file reversed.hpp
* @brief Reversed
*/
#include <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
#if __cplusplus < 201703L
__cont.size();
#else
std::size(__cont);
#endif
}
};
} // 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::random_access_iterator_tag;
constexpr iterator(const _Index &__i = _Index()) noexcept : current(__i) {}
constexpr bool operator==(const iterator &__x) const noexcept {
return current == __x.current;
}
constexpr bool operator!=(const iterator &__x) const noexcept {
return current != __x.current;
}
constexpr bool operator<(const iterator &__x) const noexcept {
return current < __x.current;
}
constexpr bool operator<=(const iterator &__x) const noexcept {
return current <= __x.current;
}
constexpr bool operator>(const iterator &__x) const noexcept {
return current > __x.current;
}
constexpr bool operator>=(const iterator &__x) const noexcept {
return current >= __x.current;
}
constexpr iterator &operator++() noexcept {
++current;
return *this;
}
constexpr iterator &operator++(int) noexcept {
auto __tmp = *this;
++current;
return __tmp;
}
constexpr iterator &operator--() noexcept {
--current;
return *this;
}
constexpr iterator &operator--(int) noexcept {
auto __tmp = *this;
--current;
return __tmp;
}
constexpr difference_type operator-(const iterator &__x) const noexcept {
return current - __x.current;
}
constexpr iterator &operator+=(difference_type __x) noexcept {
current += __x;
return *this;
}
constexpr iterator operator+(difference_type __x) const noexcept {
return iterator(*this) += __x;
}
constexpr iterator &operator-=(difference_type __x) noexcept {
current -= __x;
return *this;
}
constexpr iterator operator-(difference_type __x) const noexcept {
return iterator(*this) -= __x;
}
constexpr reference operator*() const noexcept { return current; }
};
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 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 _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 &>())>>;
template <class... _Args>
constexpr decltype(auto) rrange(_Args &&...__args) noexcept {
return reversed(range(std::forward<_Args>(__args)...));
}
template <class _Container>
constexpr decltype(auto) iterate(_Container &&__cont) noexcept {
return range(std::begin(__cont), std::end(__cont));
}
template <class _Container>
constexpr decltype(auto) riterate(_Container &&__cont) noexcept {
return range(std::rbegin(__cont), std::rend(__cont));
}
} // namespace workspace
#endif
#line 17 "Library\\lib\\utils"
// #include "src/utils/py-like/reversed.hpp"
// #include "src/utils/py-like/zip.hpp"
#line 2 "Library\\src\\utils\\rand\\rng.hpp"
/**
* @file rng.hpp
* @brief Random Number Generator
*/
#line 9 "Library\\src\\utils\\rand\\rng.hpp"
namespace workspace {
template <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 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 22 "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 9 "Library\\src\\utils\\io\\input.hpp"
namespace workspace {
namespace _input_impl {
template <class _Tp, bool _Is_class = false> class input {
_Tp __value;
template <class _Arg, class... _Args> struct is_same : std::false_type {};
template <class _Arg> struct is_same<_Arg, _Arg> : std::true_type {};
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 (!is_same<decltype(*this), _Args...>::value &&
!is_same<_Tp, _Args...>::value)
cin >> __value;
}
input &operator=(const _Tp &__x) noexcept { return __value = __x, *this; }
};
template <class _Tp> class input<_Tp, true> : public _Tp {
template <class _Arg, class... _Args> struct is_same : std::false_type {};
template <class _Arg> struct is_same<_Arg, _Arg> : std::true_type {};
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 (!is_same<decltype(*this), _Args...>::value &&
!is_same<_Tp, _Args...>::value)
cin >> *this;
}
input &operator=(const _Tp &__x) noexcept {
_Tp::operator=(__x);
return *this;
}
};
} // namespace _input_impl
template <class _Tp>
using input = _input_impl::input<_Tp, std::is_class<_Tp>::value>;
} // namespace workspace
#line 11 "atcoder-workspace\\yuki2.cc"
// #include "lib/algebra"
// #include "lib/graph"
// #include "lib/modular"
// #include "lib/combinatorics"
// #include "lib/data_structure"
// #include "lib/number_theory"
// #include "lib/string"
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\\segment_tree\\dual.hpp"
/**
* @file dual.hpp
* @brief Dual Segment Tree
*/
namespace workspace {
template <class _Tp> class dual_segment_tree {
public:
using container_type = std::vector<_Tp>;
using size_type = typename container_type::size_type;
dual_segment_tree() noexcept = default;
dual_segment_tree(size_type __n) noexcept
: __len(__n),
__data(2 << (__n > 1 ? 64 - __builtin_clzll(__n - 1) : 0)) {}
dual_segment_tree(size_type __n, const _Tp &__x) noexcept
: __len(__n),
__data(2 << (__n > 1 ? 64 - __builtin_clzll(__n - 1) : 0), __x) {}
template <class _Op> void point(size_type __i, _Op &&__op) {
assert(__i < __len);
for (__i += __data.size() >> 1; __i; __i >>= 1) __op(__data[__i]);
}
template <class _Op> void range(size_type __l, size_type __r, _Op &&__op) {
assert(__l <= __r), assert(__r <= __len);
for (__l += __data.size() >> 1, __r += __data.size() >> 1; __l != __r;
__l >>= 1, __r >>= 1) {
if (__l & 1) __op(__data[__l++]);
if (__r & 1) __op(__data[--__r]);
}
}
private:
size_type __len;
container_type __data;
};
} // namespace workspace
#line 2 "Library\\src\\data_structure\\union_find\\basic.hpp"
/**
* @file basic.hpp
* @brief Union-Find
*/
#line 10 "Library\\src\\data_structure\\union_find\\basic.hpp"
namespace workspace {
class union_find {
protected:
using signed_type = int32_t;
using unsigned_type = uint32_t;
mutable std::vector<signed_type> __p;
public:
/**
* @brief Construct a new union find object
*/
union_find() = default;
/**
* @brief Construct a new union-find object
*
* @param __n Number of nodes.
*/
union_find(unsigned_type __n) : __p(__n, 1) {}
/**
* @param __x A node.
*
* @return The representative of the group.
*/
virtual unsigned_type find(unsigned_type __x) const {
assert(__x < size());
return 0 < __p[__x] ? __x : -(__p[__x] = -(signed_type)find(-__p[__x]));
}
bool empty() const { return __p.empty(); }
/**
* @return The number of nodes.
*/
unsigned_type size() const { return __p.size(); }
/**
* @param __x A node.
*
* @return Number of nodes in the group.
*/
virtual unsigned_type size(unsigned_type __x) const {
assert(__x < size());
return __p[find(__x)];
}
/**
* @param __x 1st node.
* @param __y 2nd node.
*
* @return Whether or not the two nodes belong to the same group.
*/
bool same(unsigned_type __x, unsigned_type __y) const {
assert(__x < size());
assert(__y < size());
return find(__x) == find(__y);
}
/**
* @param __x 1st node.
* @param __y 2nd node.
*
* @return Whether or not the two groups were merged anew.
*/
virtual bool unite(unsigned_type __x, unsigned_type __y) {
assert(__x < size()), __x = find(__x);
assert(__y < size()), __y = find(__y);
if (__x == __y) return false;
if (__p[__x] < __p[__y]) std::swap(__x, __y);
__p[__x] += __p[__y];
__p[__y] = -(signed_type)__x;
return true;
}
};
} // namespace workspace
#line 2 "Library\\src\\graph\\undirected\\tree\\heavy_light_decomposition.hpp"
/**
* @file heavy_light_decomposition.hpp
* @brief Heavy-Light Decomposition
*/
#line 11 "Library\\src\\graph\\undirected\\tree\\heavy_light_decomposition.hpp"
class heavy_light_decomposition {
constexpr static size_t __nil = -1;
std::vector<std::vector<size_t>> __tree;
std::vector<size_t> __sorted, __in, __out, __head, __depth;
size_t sort_children(size_t node, size_t prev) {
size_t sum = 1, max_size = 0;
for (size_t &to : __tree[node]) {
if (to == prev) continue;
__depth[to] = __depth[node] + 1;
size_t child_size = sort_children(to, node);
sum += child_size;
if (max_size < child_size) {
max_size = child_size;
std::swap(__tree[node].front(), to);
}
}
return sum;
}
void traverse(size_t node, size_t prev) {
__in[node] = __sorted.size();
__sorted.emplace_back(node);
if (!__tree[node].empty() && __tree[node].front() != prev) {
for (const size_t to : __tree[node])
if (to != prev) __head[to] = node + size();
__head[__tree[node].front()] =
__head[node] < size() ? __head[node] : node;
for (const size_t to : __tree[node])
if (to != prev) traverse(to, node);
}
__out[node] = __sorted.size();
}
bool made() const { return !__sorted.empty(); }
public:
using interval = std::pair<size_t, size_t>;
heavy_light_decomposition() = default;
heavy_light_decomposition(size_t __n) : __tree(__n) {}
/**
* @return The size of the __tree.
*/
size_t size() const { return __tree.size(); }
/**
* @param node The root of the subtree
* @return The size of the subtree.
*/
size_t size(size_t node) const {
assert(made());
return __out[node] - __in[node];
}
void add_edge(size_t __u, size_t __v) {
assert(__u < size());
assert(__v < size());
__tree[__u].emplace_back(__v);
__tree[__v].emplace_back(__u);
}
const decltype(__tree) &tree() const { return __tree; }
/**
* @brief Run HLD with given root __in linear time.
* @param root The root node.
*/
void make(size_t __root) {
__sorted.clear(), __in.resize(size()), __out.resize(size()),
__head.resize(size()), __depth.resize(size());
__head[__root] = __root + size(), __depth[__root] = 0;
sort_children(__root, __nil);
traverse(__root, __root);
}
size_t prev_node(size_t node) const {
assert(made());
return __in[node] ? __sorted[__in[node] - 1] : __nil;
}
size_t next_node(size_t node) const {
assert(made());
return __in[node] + 1 < size() ? __sorted[__in[node] + 1] : __nil;
}
size_t index(size_t node) const {
assert(made());
return __in[node];
}
size_t node(size_t __i) const {
assert(made());
return __sorted[__i];
}
/**
* @return The current root of the __tree.
*/
size_t root() const {
assert(made());
return __sorted.front();
}
/**
* @param root The root of the subtree.
* @return The interval representing the subtree.
*/
interval subtree(size_t __v) const {
assert(made());
return {__in[__v], __out[__v]};
}
/**
* @param __v
* @return Return v if v is the root.
*/
size_t parent(size_t __v) const {
assert(made());
return __head[__v] < size() ? prev_node(__v) : __head[__v] - size();
}
size_t top(size_t __v) const {
assert(made());
return __head[__v] < size() ? __head[__v] : __v;
}
/**
* @brief Get LCA __in O(log(size)) time.
* @param __u 1st node
* @param __v 2nd node
* @return Lowest Common Ancestor of the two.
*/
size_t lca(size_t __u, size_t __v) const {
assert(made());
if (__in[__v] < __in[__u]) std::swap(__u, __v);
if (__in[__v] < __out[__u]) return __u;
while (__in[__u] < __in[__v]) __v = parent(top(__v));
return __v;
}
size_t ancestor(size_t __v, size_t __k) const {
assert(made());
while (__k) {
assert(__in[__v]);
auto __t = top(__v);
auto __d = __in[__v] - __in[__t];
if (__d < __k) {
__k -= __d + 1;
__v = __head[__t] - size();
} else {
__v = __sorted[__in[__v] - __k];
__k = 0;
}
}
return __v;
}
size_t depth(size_t __v) const { return __depth[__v]; }
size_t distance(size_t __u, size_t __v) const {
return __depth[__u] + __depth[__v] - __depth[lca(__u, __v)] * 2;
}
// O(log(size))
std::pair<std::vector<interval>, std::vector<interval>> path_decomposition(
size_t __u, size_t __v) const {
assert(made());
if (__in[__v] < __in[__u]) std::swap(__u, __v);
std::vector<interval> left, right;
size_t utop = top(__u), vtop = top(__v);
while (utop != vtop) {
left.emplace_back(__in[vtop], __in[__v] + 1);
vtop = top(__v = parent(vtop));
if (__in[__v] < __in[__u]) {
std::swap(__u, __v);
std::swap(utop, vtop);
std::swap(left, right);
}
}
left.emplace_back(__in[__u], __in[__v] + 1);
return std::make_pair(left, right);
}
// O(log(size))
std::vector<interval> path_decomposition(size_t __v) const {
assert(made());
auto [left, right] = path_decomposition(root(), __v);
right.insert(right.begin(), left.begin(), left.end());
return right;
}
};
#line 2 "Library\\src\\modular\\modint.hpp"
/**
* @file modint.hpp
*
* @brief Modular Arithmetic
*/
#line 12 "Library\\src\\modular\\modint.hpp"
#line 2 "Library\\src\\number_theory\\sqrt_mod.hpp"
/**
* @file sqrt_mod.hpp
* @brief Tonelli-Shanks Algorithm
*/
#line 2 "Library\\src\\number_theory\\pow_mod.hpp"
/**
* @file mod_pow.hpp
* @brief Modular Exponentiation
*/
#line 9 "Library\\src\\number_theory\\pow_mod.hpp"
#line 11 "Library\\src\\number_theory\\pow_mod.hpp"
namespace workspace {
/**
* @brief Compile time modular exponentiation.
*
* @param __x
* @param __n Exponent
* @param __mod Modulus
* @return
*/
template <class _Tp>
constexpr std::enable_if_t<(is_integral_ext<_Tp>::value), _Tp> pow_mod(
_Tp __x, _Tp __n, _Tp __mod) noexcept {
assert(__mod > 0);
using mul_type = typename multiplicable_uint<_Tp>::type;
if ((__x %= __mod) < 0) __x += __mod;
mul_type __y{1};
while (__n) {
if (__n & 1) (__y *= __x) %= __mod;
__x = (mul_type)__x * __x % __mod;
__n >>= 1;
}
return __y;
};
} // namespace workspace
#line 10 "Library\\src\\number_theory\\sqrt_mod.hpp"
namespace workspace {
/**
* @brief Compile time modular square root.
*
* @param __x
* @param __mod Modulus
* @return One if it exists. Otherwise -1.
*/
template <class _Tp>
constexpr std::enable_if_t<(is_integral_ext<_Tp>::value), _Tp> sqrt_mod(
_Tp __x, _Tp __mod) noexcept {
assert(__mod > 0);
using mul_type = typename multiplicable_uint<_Tp>::type;
if ((__x %= __mod) < 0) __x += __mod;
if (!__x) return 0;
if (__mod == 2) return __x;
if (pow_mod(__x, __mod >> 1, __mod) != 1) return -1;
_Tp __z = __builtin_ctz(__mod - 1), __q = __mod >> __z;
mul_type __a = pow_mod(__x, (__q + 1) >> 1, __mod), __b = 2;
while (pow_mod<_Tp>(__b, __mod >> 1, __mod) == 1) ++__b;
__b = pow_mod<_Tp>(__b, __q, __mod);
_Tp __shift = 0;
for (auto __r = __a * __a % __mod * pow_mod(__x, __mod - 2, __mod) % __mod;
__r != 1; (__r *= (__b *= __b) %= __mod) %= __mod) {
auto __bsf = __z;
for (auto __e = __r; __e != 1; --__bsf) (__e *= __e) %= __mod;
while (++__shift != __bsf) (__b *= __b) %= __mod;
(__a *= __b) %= __mod;
}
return __a;
};
} // namespace workspace
#line 15 "Library\\src\\modular\\modint.hpp"
namespace workspace {
namespace _modint_impl {
template <auto _Mod, unsigned _Storage> struct modint {
static_assert(is_integral_ext<decltype(_Mod)>::value,
"_Mod must be integral type.");
using mod_type = std::make_signed_t<typename std::conditional<
0 < _Mod, std::add_const_t<decltype(_Mod)>, decltype(_Mod)>::type>;
using value_type = std::decay_t<mod_type>;
using mul_type = typename multiplicable_uint<value_type>::type;
// Modulus
static mod_type mod;
static unsigned storage;
private:
value_type value = 0;
struct direct_ctor_t {};
constexpr static direct_ctor_t direct_ctor_tag{};
// Direct constructor
template <class _Tp>
constexpr modint(_Tp __n, direct_ctor_t) noexcept : value(__n) {}
public:
constexpr modint() noexcept = default;
template <class _Tp>
constexpr modint(_Tp __n) noexcept
: value((__n %= mod) < 0 ? __n + mod : __n) {}
constexpr modint(bool __n) noexcept : value(__n) {}
constexpr operator value_type() const noexcept { return value; }
// unary operators {{
constexpr modint operator++(int) noexcept {
modint __t{*this};
operator++();
return __t;
}
constexpr modint operator--(int) noexcept {
modint __t{*this};
operator--();
return __t;
}
constexpr modint &operator++() noexcept {
if (++value == mod) value = 0;
return *this;
}
constexpr modint &operator--() noexcept {
if (!value)
value = mod - 1;
else
--value;
return *this;
}
constexpr modint operator+() const noexcept { return *this; }
constexpr modint operator-() const noexcept {
return {value ? mod - value : 0, direct_ctor_tag};
}
// }} unary operators
// operator+= {{
constexpr modint &operator+=(const modint &__x) noexcept {
if ((value += __x.value) >= mod) value -= mod;
return *this;
}
template <class _Tp>
constexpr std::enable_if_t<is_integral_ext<_Tp>::value, modint> &operator+=(
_Tp __x) noexcept {
__x %= mod, value += __x;
if (value < 0)
value += mod;
else if (value >= mod)
value -= mod;
return *this;
}
// }} operator+=
// operator+ {{
template <class _Tp>
constexpr std::enable_if_t<is_integral_ext<_Tp>::value, modint> operator+(
_Tp const &__x) const noexcept {
return modint{*this} += __x;
}
constexpr modint operator+(modint __x) const noexcept { return __x += *this; }
template <class _Tp>
constexpr friend std::enable_if_t<is_integral_ext<_Tp>::value, modint>
operator+(_Tp const &__x, modint __y) noexcept {
return __y += __x;
}
// }} operator+
// operator-= {{
constexpr modint &operator-=(const modint &__x) noexcept {
if ((value -= __x.value) < 0) value += mod;
return *this;
}
template <class _Tp>
constexpr std::enable_if_t<is_integral_ext<_Tp>::value, modint> &operator-=(
_Tp __x) noexcept {
__x %= mod, value -= __x;
if (value < 0)
value += mod;
else if (value >= mod)
value -= mod;
return *this;
}
// }} operator-=
// operator- {{
template <class _Tp>
constexpr std::enable_if_t<is_integral_ext<_Tp>::value, modint> operator-(
_Tp const &__x) const noexcept {
return modint{*this} -= __x;
}
constexpr modint operator-(const modint &__x) const noexcept {
return modint{*this} -= __x;
}
template <class _Tp>
constexpr friend std::enable_if_t<is_integral_ext<_Tp>::value, modint>
operator-(_Tp __x, const modint &__y) noexcept {
if (((__x -= __y.value) %= mod) < 0) __x += mod;
return {__x, direct_ctor_tag};
}
// }} operator-
// operator*= {{
constexpr modint &operator*=(const modint &__x) noexcept {
value =
static_cast<value_type>(value * static_cast<mul_type>(__x.value) % mod);
return *this;
}
template <class _Tp>
constexpr std::enable_if_t<is_integral_ext<_Tp>::value, modint> &operator*=(
_Tp __x) noexcept {
value = static_cast<value_type>(
value * mul_type((__x %= mod) < 0 ? __x + mod : __x) % mod);
return *this;
}
// }} operator*=
// operator* {{
constexpr modint operator*(const modint &__x) const noexcept {
return {static_cast<mul_type>(value) * __x.value % mod, direct_ctor_tag};
}
template <class _Tp>
constexpr std::enable_if_t<is_integral_ext<_Tp>::value, modint> operator*(
_Tp __x) const noexcept {
__x %= mod;
if (__x < 0) __x += mod;
return {static_cast<mul_type>(value) * __x % mod, direct_ctor_tag};
}
template <class _Tp>
constexpr friend std::enable_if_t<is_integral_ext<_Tp>::value, modint>
operator*(_Tp __x, const modint &__y) noexcept {
__x %= mod;
if (__x < 0) __x += mod;
return {static_cast<mul_type>(__x) * __y.value % mod, direct_ctor_tag};
}
// }} operator*
protected:
static value_type _mem(value_type __x) {
static std::vector<value_type> __m{0, 1};
static value_type __i = (__m.reserve(storage), 1);
while (__i < __x) {
++__i;
__m.emplace_back(mod - mul_type(mod / __i) * __m[mod % __i] % mod);
}
return __m[__x];
}
static value_type _div(mul_type __r, value_type __x) noexcept {
assert(__x != value_type(0));
if (!__r) return 0;
std::make_signed_t<value_type> __v{};
bool __neg = __x < 0 ? __x = -__x, true : false;
if (static_cast<decltype(storage)>(__x) < storage)
__v = _mem(__x);
else {
value_type __y{mod}, __u{1}, __t;
while (__x)
__t = __y / __x, __y ^= __x ^= (__y -= __t * __x) ^= __x,
__v ^= __u ^= (__v -= __t * __u) ^= __u;
if (__y < 0) __neg ^= 1;
}
if (__neg)
__v = 0 < __v ? mod - __v : -__v;
else if (__v < 0)
__v += mod;
return __r == mul_type(1) ? static_cast<value_type>(__v)
: static_cast<value_type>(__r * __v % mod);
}
public:
// operator/= {{
constexpr modint &operator/=(const modint &__x) noexcept {
if (value) value = _div(value, __x.value);
return *this;
}
template <class _Tp>
constexpr std::enable_if_t<is_integral_ext<_Tp>::value, modint> &operator/=(
_Tp __x) noexcept {
if (value) value = _div(value, __x %= mod);
return *this;
}
// }} operator/=
// operator/ {{
constexpr modint operator/(const modint &__x) const noexcept {
if (!value) return {};
return {_div(value, __x.value), direct_ctor_tag};
}
template <class _Tp>
constexpr std::enable_if_t<is_integral_ext<_Tp>::value, modint> operator/(
_Tp __x) const noexcept {
if (!value) return {};
return {_div(value, __x %= mod), direct_ctor_tag};
}
template <class _Tp>
constexpr friend std::enable_if_t<is_integral_ext<_Tp>::value, modint>
operator/(_Tp __x, const modint &__y) noexcept {
if (!__x) return {};
if ((__x %= mod) < 0) __x += mod;
return {_div(__x, __y.value), direct_ctor_tag};
}
// }} operator/
constexpr modint inv() const noexcept { return _div(1, value); }
template <class _Tp>
constexpr std::enable_if_t<is_integral_ext<_Tp>::value, modint> pow(
_Tp __e) const noexcept {
modint __r{mod != 1, direct_ctor_tag};
for (modint __b{__e < 0 ? __e = -__e, _div(1, value) : value,
direct_ctor_tag};
__e; __e >>= 1, __b *= __b)
if (__e & 1) __r *= __b;
return __r;
}
template <class _Tp>
constexpr friend std::enable_if_t<is_integral_ext<_Tp>::value, modint> pow(
modint __b, _Tp __e) noexcept {
if (__e < 0) {
__e = -__e;
__b.value = _div(1, __b.value);
}
modint __r{mod != 1, direct_ctor_tag};
for (; __e; __e >>= 1, __b *= __b)
if (__e & 1) __r *= __b;
return __r;
}
constexpr modint sqrt() const noexcept {
return {sqrt_mod(value, mod), direct_ctor_tag};
}
friend constexpr modint sqrt(const modint &__x) noexcept {
return {sqrt_mod(__x.value, mod), direct_ctor_tag};
}
friend std::istream &operator>>(std::istream &__is, modint &__x) noexcept {
std::string __s;
__is >> __s;
bool __neg = false;
if (__s.front() == '-') {
__neg = true;
__s.erase(__s.begin());
}
__x = 0;
for (char __c : __s) __x = __x * 10 + (__c - '0');
if (__neg) __x = -__x;
return __is;
}
};
template <auto _Mod, unsigned _Storage>
typename modint<_Mod, _Storage>::mod_type modint<_Mod, _Storage>::mod =
_Mod > 0 ? _Mod : 0;
template <auto _Mod, unsigned _Storage>
unsigned modint<_Mod, _Storage>::storage = _Storage;
} // namespace _modint_impl
template <auto _Mod, unsigned _Storage = 0,
typename = std::enable_if_t<(_Mod > 0)>>
using modint = _modint_impl::modint<_Mod, _Storage>;
template <unsigned _Id = 0>
using modint_runtime = _modint_impl::modint<-(signed)_Id, 0>;
} // namespace workspace
#line 38 "atcoder-workspace\\yuki2.cc"
namespace workspace {
using mint = modint<1000000007>;
void main() {
// start here!
int n, m;
cin >> n >> m;
vector<pair<int, int>> edges(m);
vector<vector<pair<int, pair<mint, int>>>> tree(n);
{
for (auto &&[a, b] : edges) {
cin >> a >> b;
--a, --b;
}
for (auto i : range(1, n)) {
edges.emplace_back(0, i);
}
}
heavy_light_decomposition hld(n);
union_find uf(n);
vector<int> adopt;
{
int i = 0;
mint c = 1;
for (auto &&[a, b] : edges) {
c += c;
if (adopt.emplace_back(uf.unite(a, b))) {
hld.add_edge(a, b);
pair cost{c, i >= m};
tree[a].emplace_back(b, cost);
tree[b].emplace_back(a, cost);
}
i++;
}
}
const auto root = 0;
hld.make(root);
vector<pair<mint, int>> wd(n);
// BFS
{
queue<int> Q;
Q.push(root);
while (!Q.empty()) {
for (auto [to, e] : tree[Q.front()]) {
if (hld.depth(to) < hld.depth(Q.front())) continue;
Q.push(to);
wd[to].first = wd[Q.front()].first + e.first;
wd[to].second = wd[Q.front()].second + e.second;
}
Q.pop();
}
}
auto dist = [&](auto x, auto y) -> auto {
auto tmp = wd[x];
tmp.first += wd[y].first;
tmp.second += wd[y].second;
auto lca = hld.lca(x, y);
tmp.first -= 2 * wd[lca].first;
tmp.second -= 2 * wd[lca].second;
return tmp;
};
dual_segment_tree<u32> dus(n, -1);
for (auto i : range(edges.size())) {
auto &[a, b] = edges[i];
if (adopt[i]) {
if (hld.depth(a) > hld.depth(b)) {
swap(a, b);
}
} else {
auto [p1, p2] = hld.path_decomposition(a, b);
p1.back().first++;
for (auto p : {p1, p2}) {
for (auto [s, t] : p) {
dus.range(s, t, [&](auto &x) { chle(x, i); });
}
}
}
}
int ans;
for (input<int> q; q--; cout << ans << "\n", ans = 0) {
input<int> x, y, z;
--x, --y, --z;
auto [a, b] = edges[z];
if (adopt[z] &&
hld.distance(x, a) + hld.distance(a, y) == hld.distance(x, y) &&
hld.distance(x, b) + hld.distance(b, y) ==
hld.distance(x, y)) { // avoid (a, b)!
u32 e = -1;
dus.point(hld.index(b), [&](auto &x) { chle(e, x); });
if (e >= m) {
ans = -1;
continue;
}
auto [c, d] = pair(a, b);
tie(a, b) = pair(edges[e]);
if (hld.distance(x, c) + hld.distance(c, a) == hld.distance(x, a) &&
hld.distance(x, d) + hld.distance(d, a) == hld.distance(x, a)) {
swap(a, b);
}
auto dx = dist(x, a), dy = dist(y, b);
dx.first += dy.first;
dx.second += dy.second;
if (dx.second) {
ans = -1;
} else {
ans = dx.first + mint(2).pow(e + 1);
}
}
else { // easy!
auto tmp = dist(x, y);
if (tmp.second)
ans = -1;
else
ans = tmp.first;
}
}
}
} // namespace workspace