regular backup
This commit is contained in:
parent
9781e95bb5
commit
07df2a05a1
60
src/bin/a.cc
60
src/bin/a.cc
|
@ -25,7 +25,7 @@ using ull = unsigned long long;
|
||||||
#endif
|
#endif
|
||||||
using int128 = __int128_t;
|
using int128 = __int128_t;
|
||||||
using uint128 = __uint128_t;
|
using uint128 = __uint128_t;
|
||||||
using ld = long double;
|
using ld = __float128; // up to 1e-9 precision in binary search
|
||||||
using pii = pair<int, int>; using pil = pair<int, ll>; using pid = pair<int, ld>;
|
using pii = pair<int, int>; using pil = pair<int, ll>; using pid = pair<int, ld>;
|
||||||
using pli = pair<ll, int>; using pll = pair<ll, ll>; using pld = pair<ll, ld>;
|
using pli = pair<ll, int>; using pll = pair<ll, ll>; using pld = pair<ll, ld>;
|
||||||
using pdi = pair<ld, int>; using pdl = pair<ld, ll>; using pdd = pair<ld, ld>;
|
using pdi = pair<ld, int>; using pdl = pair<ld, ll>; using pdd = pair<ld, ld>;
|
||||||
|
@ -48,6 +48,7 @@ constexpr int INF = 0x3f3f3f3f;
|
||||||
constexpr ll INFLL = 0x3f3f3f3f3f3f3f3fLL;
|
constexpr ll INFLL = 0x3f3f3f3f3f3f3f3fLL;
|
||||||
constexpr ll MDL = 1e9 + 7;
|
constexpr ll MDL = 1e9 + 7;
|
||||||
constexpr ll PRIME = 998'244'353;
|
constexpr ll PRIME = 998'244'353;
|
||||||
|
constexpr ll PRIMELL = 901017227882342239LL;
|
||||||
constexpr ll MDL1 = 8784491;
|
constexpr ll MDL1 = 8784491;
|
||||||
constexpr ll MDL2 = PRIME;
|
constexpr ll MDL2 = PRIME;
|
||||||
constexpr int128 INT128_MAX = numeric_limits<int128>::max();
|
constexpr int128 INT128_MAX = numeric_limits<int128>::max();
|
||||||
|
@ -96,9 +97,9 @@ struct igt {
|
||||||
|
|
||||||
/* conditions */
|
/* conditions */
|
||||||
#define loop while (1)
|
#define loop while (1)
|
||||||
#define if_or(var, val) if (!(var == val)) var = val; else
|
#define if_or(var, val) if (!((var) == (val))) (var) = (val); else
|
||||||
#define continue_or(var, val) __AS_PROCEDURE(if (var == val) continue; var = val;)
|
#define continue_or(var, val) __AS_PROCEDURE(if ((var) == (val)) continue; (var) = (val);)
|
||||||
#define break_or(var, val) __AS_PROCEDURE(if (var == val) break; var = val;)
|
#define break_or(var, val) __AS_PROCEDURE(if ((var) == (val)) break; (var) = (val);)
|
||||||
|
|
||||||
/* hash */
|
/* hash */
|
||||||
struct safe_hash {
|
struct safe_hash {
|
||||||
|
@ -132,13 +133,15 @@ struct pair_hash {
|
||||||
uniform_int_distribution<mt19937::result_type> dist(PRIME);
|
uniform_int_distribution<mt19937::result_type> dist(PRIME);
|
||||||
const size_t __array_hash_b = 31, __array_hash_mdl1 = dist(rd), __array_hash_mdl2 = dist(rd);
|
const size_t __array_hash_b = 31, __array_hash_mdl1 = dist(rd), __array_hash_mdl2 = dist(rd);
|
||||||
struct array_hash {
|
struct array_hash {
|
||||||
|
safe_hash hasher;
|
||||||
template <typename Sequence>
|
template <typename Sequence>
|
||||||
size_t operator()(const Sequence& arr) const {
|
size_t operator()(const Sequence& arr) const {
|
||||||
size_t pw1 = 1, pw2 = 1;
|
size_t pw1 = 1, pw2 = 1;
|
||||||
size_t res1 = 0, res2 = 0;
|
size_t res1 = 0, res2 = 0;
|
||||||
for (auto&& x : arr) {
|
for (auto&& x : arr) {
|
||||||
res1 = (res1 + x * pw1) % __array_hash_mdl1;
|
auto h = hasher(x);
|
||||||
res2 = (res2 + x * pw2) % __array_hash_mdl2;
|
res1 = (res1 + h * pw1) % __array_hash_mdl1;
|
||||||
|
res2 = (res2 + h * pw2) % __array_hash_mdl2;
|
||||||
pw1 = (pw1 * __array_hash_b) % __array_hash_mdl1;
|
pw1 = (pw1 * __array_hash_b) % __array_hash_mdl1;
|
||||||
pw2 = (pw2 * __array_hash_b) % __array_hash_mdl2;
|
pw2 = (pw2 * __array_hash_b) % __array_hash_mdl2;
|
||||||
}
|
}
|
||||||
|
@ -173,7 +176,7 @@ template <typename T, typename Iterator> pair<size_t, unordered_map<T, size_t, s
|
||||||
/* io */
|
/* io */
|
||||||
#define untie __AS_PROCEDURE(ios_base::sync_with_stdio(0), cin.tie(NULL))
|
#define untie __AS_PROCEDURE(ios_base::sync_with_stdio(0), cin.tie(NULL))
|
||||||
|
|
||||||
// add declarations to avoid cyclic dependency
|
// add declarations to avoid circular dependency
|
||||||
template<typename T, typename U> istream& operator>>(istream&, pair<T, U>&);
|
template<typename T, typename U> istream& operator>>(istream&, pair<T, U>&);
|
||||||
template<typename T, typename U> ostream& operator<<(ostream&, const pair<T, U>&);
|
template<typename T, typename U> ostream& operator<<(ostream&, const pair<T, U>&);
|
||||||
template<typename T, size_t N> istream& operator>>(istream&, array<T, N>&);
|
template<typename T, size_t N> istream& operator>>(istream&, array<T, N>&);
|
||||||
|
@ -239,14 +242,14 @@ std::ostream& operator<<(std::ostream& dest, const int128& value) {
|
||||||
template<typename T> void __read(T& x) { cin >> x; }
|
template<typename T> void __read(T& x) { cin >> x; }
|
||||||
template<typename T, typename... U> void __read(T& x, U&... args) { cin >> x; __read(args...); }
|
template<typename T, typename... U> void __read(T& x, U&... args) { cin >> x; __read(args...); }
|
||||||
#define read(t, ...) __AS_PROCEDURE(argument_type<void(t)>::type __VA_ARGS__; __read(__VA_ARGS__);)
|
#define read(t, ...) __AS_PROCEDURE(argument_type<void(t)>::type __VA_ARGS__; __read(__VA_ARGS__);)
|
||||||
#define readvec(t, a, n) __AS_PROCEDURE(vector<argument_type<void(t)>::type> a(n); for (auto& x : a) cin >> x;)
|
#define readvec(t, a, n) __AS_PROCEDURE(vector<argument_type<void(t)>::type> a(n); for (auto& x : (a)) cin >> x;)
|
||||||
#define readvec1(t, a, n) __AS_PROCEDURE(vector<argument_type<void(t)>::type> a((n) + 1); copy_n(ii<argument_type<void(t)>::type>(cin), (n), a.begin() + 1);)
|
#define readvec1(t, a, n) __AS_PROCEDURE(vector<argument_type<void(t)>::type> a((n) + 1); copy_n(ii<argument_type<void(t)>::type>(cin), (n), (a).begin() + 1);)
|
||||||
#define putvec(a) __AS_PROCEDURE(copy(a.begin(), a.end(), oi<__as_typeof(a)::value_type>(cout, " ")); cout << endl;)
|
#define putvec(a) __AS_PROCEDURE(copy((a).begin(), (a).end(), oi<__as_typeof(a)::value_type>(cout, " ")); cout << endl;)
|
||||||
#define putvec1(a) __AS_PROCEDURE(copy(a.begin() + 1, a.end(), oi<__as_typeof(a)::value_type>(cout, " ")); cout << endl;)
|
#define putvec1(a) __AS_PROCEDURE(copy((a).begin() + 1, (a).end(), oi<__as_typeof(a)::value_type>(cout, " ")); cout << endl;)
|
||||||
#define putvec_eol(a) __AS_PROCEDURE(copy(a.begin(), a.end(), oi<__as_typeof(a)::value_type>(cout, "\n"));)
|
#define putvec_eol(a) __AS_PROCEDURE(copy((a).begin(), (a).end(), oi<__as_typeof(a)::value_type>(cout, "\n"));)
|
||||||
#define putvec1_eol(a) __AS_PROCEDURE(copy(a.begin() + 1, a.end(), oi<__as_typeof(a)::value_type>(cout, "\n"));)
|
#define putvec1_eol(a) __AS_PROCEDURE(copy((a).begin() + 1, (a).end(), oi<__as_typeof(a)::value_type>(cout, "\n"));)
|
||||||
#define debug(x) __AS_PROCEDURE(cerr << #x" = " << (x) << endl;)
|
#define debug(x) __AS_PROCEDURE(cerr << #x" = " << (x) << endl;)
|
||||||
#define debugvec(a) __AS_PROCEDURE(cerr << #a" = "; for (auto&& x : a) cerr << x << ' '; cerr << endl;)
|
#define debugvec(a) __AS_PROCEDURE(cerr << #a" = "; for (auto&& x : (a)) cerr << x << ' '; cerr << endl;)
|
||||||
#define deb(...) debug(make_tuple(__VA_ARGS__))
|
#define deb(...) debug(make_tuple(__VA_ARGS__))
|
||||||
|
|
||||||
/* pops */
|
/* pops */
|
||||||
|
@ -293,7 +296,7 @@ ll qpow(ll b, ll p, ll mod) {
|
||||||
#pragma GCC diagnostic ignored "-Wparentheses"
|
#pragma GCC diagnostic ignored "-Wparentheses"
|
||||||
// Accurately find `i` 'th root of `n` (taking the floor)
|
// Accurately find `i` 'th root of `n` (taking the floor)
|
||||||
inline ll root(ll n, ll i) {
|
inline ll root(ll n, ll i) {
|
||||||
ll l = 0, r = pow(LLONG_MAX, ld(1) / i);
|
ll l = 0, r = pow(LLONG_MAX, (long double)(1) / i);
|
||||||
while (l < r) {
|
while (l < r) {
|
||||||
ll mid = l + r + 1 >> 1;
|
ll mid = l + r + 1 >> 1;
|
||||||
if (qpow<int128>(mid, i) <= n) {
|
if (qpow<int128>(mid, i) <= n) {
|
||||||
|
@ -393,7 +396,7 @@ vector<int> calc_z(string t) { // z function of t
|
||||||
}
|
}
|
||||||
return z;
|
return z;
|
||||||
}
|
}
|
||||||
vector<int> kmp(string s, string t) { // find all t in s
|
vector<int> kmp(const string& s, const string& t) { // find all t in s
|
||||||
string cur = t + '#' + s;
|
string cur = t + '#' + s;
|
||||||
int sz1 = s.size(), sz2 = t.size();
|
int sz1 = s.size(), sz2 = t.size();
|
||||||
vector<int> v;
|
vector<int> v;
|
||||||
|
@ -403,7 +406,7 @@ vector<int> kmp(string s, string t) { // find all t in s
|
||||||
}
|
}
|
||||||
return v;
|
return v;
|
||||||
}
|
}
|
||||||
int period(string s) { // find the length of shortest recurring period
|
int period(const string& s) { // find the length of shortest recurring period
|
||||||
int n = s.length();
|
int n = s.length();
|
||||||
auto z = calc_z(s);
|
auto z = calc_z(s);
|
||||||
for (int i = 1; i <= n / 2; ++i) {
|
for (int i = 1; i <= n / 2; ++i) {
|
||||||
|
@ -421,8 +424,8 @@ template <ll mdl> struct MLL {
|
||||||
MLL(const MLL<mdl>& other) : val(other.val) {}
|
MLL(const MLL<mdl>& other) : val(other.val) {}
|
||||||
friend MLL operator+(const MLL& lhs, const MLL& rhs) { return mod(lhs.val + rhs.val, mdl); }
|
friend MLL operator+(const MLL& lhs, const MLL& rhs) { return mod(lhs.val + rhs.val, mdl); }
|
||||||
friend MLL operator-(const MLL& lhs, const MLL& rhs) { return mod(lhs.val - rhs.val, mdl); }
|
friend MLL operator-(const MLL& lhs, const MLL& rhs) { return mod(lhs.val - rhs.val, mdl); }
|
||||||
friend MLL operator*(const MLL& lhs, const MLL& rhs) { return mod(lhs.val * rhs.val, mdl); }
|
friend MLL operator*(const MLL& lhs, const MLL& rhs) { return mod(int128(lhs.val) * rhs.val, mdl); }
|
||||||
friend MLL operator/(const MLL& lhs, const MLL& rhs) { return mod(lhs.val * mod(inverse(rhs.val, mdl), mdl), mdl); }
|
friend MLL operator/(const MLL& lhs, const MLL& rhs) { return lhs * mod(inverse(rhs.val, mdl), mdl); }
|
||||||
friend MLL operator%(const MLL& lhs, const MLL& rhs) { return mod(lhs.val - (lhs / rhs).val, mdl); }
|
friend MLL operator%(const MLL& lhs, const MLL& rhs) { return mod(lhs.val - (lhs / rhs).val, mdl); }
|
||||||
friend bool operator==(const MLL& lhs, const MLL& rhs) { return lhs.val == rhs.val; }
|
friend bool operator==(const MLL& lhs, const MLL& rhs) { return lhs.val == rhs.val; }
|
||||||
friend bool operator!=(const MLL& lhs, const MLL& rhs) { return lhs.val != rhs.val; }
|
friend bool operator!=(const MLL& lhs, const MLL& rhs) { return lhs.val != rhs.val; }
|
||||||
|
@ -537,26 +540,13 @@ void prep() {
|
||||||
|
|
||||||
// __attribute__((target("popcnt")))
|
// __attribute__((target("popcnt")))
|
||||||
void solve() {
|
void solve() {
|
||||||
read(int, n, k);
|
read(int, x, y, z);
|
||||||
readvec(int, a, n);
|
cout << min({x / 2, y, z}) << '\n';
|
||||||
for (int i = 0; i < n; ++i) {
|
|
||||||
int has = 0;
|
|
||||||
for (int j = 0; j < n; ++j) {
|
|
||||||
if (i == j) continue;
|
|
||||||
has |= abs(a[i] - a[j]) % k == 0;
|
|
||||||
}
|
|
||||||
if (has == 0) {
|
|
||||||
cout << "YES\n";
|
|
||||||
cout << i + 1 << '\n';
|
|
||||||
return;
|
|
||||||
}
|
|
||||||
}
|
|
||||||
cout << "NO\n";
|
|
||||||
}
|
}
|
||||||
|
|
||||||
int main() {
|
int main() {
|
||||||
#if __cplusplus < 201402L or defined(_MSC_VER) and not defined(__clang__)
|
#if __cplusplus < 201402L or defined(_MSC_VER) and not defined(__clang__)
|
||||||
assert(false && "incompatible compiler variant detected.");
|
static_assert(false, "incompatible compiler variant detected.");
|
||||||
#endif
|
#endif
|
||||||
untie;
|
untie;
|
||||||
prep();
|
prep();
|
||||||
|
|
54
src/bin/b.cc
54
src/bin/b.cc
|
@ -25,7 +25,7 @@ using ull = unsigned long long;
|
||||||
#endif
|
#endif
|
||||||
using int128 = __int128_t;
|
using int128 = __int128_t;
|
||||||
using uint128 = __uint128_t;
|
using uint128 = __uint128_t;
|
||||||
using ld = long double;
|
using ld = __float128; // up to 1e-9 precision in binary search
|
||||||
using pii = pair<int, int>; using pil = pair<int, ll>; using pid = pair<int, ld>;
|
using pii = pair<int, int>; using pil = pair<int, ll>; using pid = pair<int, ld>;
|
||||||
using pli = pair<ll, int>; using pll = pair<ll, ll>; using pld = pair<ll, ld>;
|
using pli = pair<ll, int>; using pll = pair<ll, ll>; using pld = pair<ll, ld>;
|
||||||
using pdi = pair<ld, int>; using pdl = pair<ld, ll>; using pdd = pair<ld, ld>;
|
using pdi = pair<ld, int>; using pdl = pair<ld, ll>; using pdd = pair<ld, ld>;
|
||||||
|
@ -48,6 +48,7 @@ constexpr int INF = 0x3f3f3f3f;
|
||||||
constexpr ll INFLL = 0x3f3f3f3f3f3f3f3fLL;
|
constexpr ll INFLL = 0x3f3f3f3f3f3f3f3fLL;
|
||||||
constexpr ll MDL = 1e9 + 7;
|
constexpr ll MDL = 1e9 + 7;
|
||||||
constexpr ll PRIME = 998'244'353;
|
constexpr ll PRIME = 998'244'353;
|
||||||
|
constexpr ll PRIMELL = 901017227882342239LL;
|
||||||
constexpr ll MDL1 = 8784491;
|
constexpr ll MDL1 = 8784491;
|
||||||
constexpr ll MDL2 = PRIME;
|
constexpr ll MDL2 = PRIME;
|
||||||
constexpr int128 INT128_MAX = numeric_limits<int128>::max();
|
constexpr int128 INT128_MAX = numeric_limits<int128>::max();
|
||||||
|
@ -96,9 +97,9 @@ struct igt {
|
||||||
|
|
||||||
/* conditions */
|
/* conditions */
|
||||||
#define loop while (1)
|
#define loop while (1)
|
||||||
#define if_or(var, val) if (!(var == val)) var = val; else
|
#define if_or(var, val) if (!((var) == (val))) (var) = (val); else
|
||||||
#define continue_or(var, val) __AS_PROCEDURE(if (var == val) continue; var = val;)
|
#define continue_or(var, val) __AS_PROCEDURE(if ((var) == (val)) continue; (var) = (val);)
|
||||||
#define break_or(var, val) __AS_PROCEDURE(if (var == val) break; var = val;)
|
#define break_or(var, val) __AS_PROCEDURE(if ((var) == (val)) break; (var) = (val);)
|
||||||
|
|
||||||
/* hash */
|
/* hash */
|
||||||
struct safe_hash {
|
struct safe_hash {
|
||||||
|
@ -132,13 +133,15 @@ struct pair_hash {
|
||||||
uniform_int_distribution<mt19937::result_type> dist(PRIME);
|
uniform_int_distribution<mt19937::result_type> dist(PRIME);
|
||||||
const size_t __array_hash_b = 31, __array_hash_mdl1 = dist(rd), __array_hash_mdl2 = dist(rd);
|
const size_t __array_hash_b = 31, __array_hash_mdl1 = dist(rd), __array_hash_mdl2 = dist(rd);
|
||||||
struct array_hash {
|
struct array_hash {
|
||||||
|
safe_hash hasher;
|
||||||
template <typename Sequence>
|
template <typename Sequence>
|
||||||
size_t operator()(const Sequence& arr) const {
|
size_t operator()(const Sequence& arr) const {
|
||||||
size_t pw1 = 1, pw2 = 1;
|
size_t pw1 = 1, pw2 = 1;
|
||||||
size_t res1 = 0, res2 = 0;
|
size_t res1 = 0, res2 = 0;
|
||||||
for (auto&& x : arr) {
|
for (auto&& x : arr) {
|
||||||
res1 = (res1 + x * pw1) % __array_hash_mdl1;
|
auto h = hasher(x);
|
||||||
res2 = (res2 + x * pw2) % __array_hash_mdl2;
|
res1 = (res1 + h * pw1) % __array_hash_mdl1;
|
||||||
|
res2 = (res2 + h * pw2) % __array_hash_mdl2;
|
||||||
pw1 = (pw1 * __array_hash_b) % __array_hash_mdl1;
|
pw1 = (pw1 * __array_hash_b) % __array_hash_mdl1;
|
||||||
pw2 = (pw2 * __array_hash_b) % __array_hash_mdl2;
|
pw2 = (pw2 * __array_hash_b) % __array_hash_mdl2;
|
||||||
}
|
}
|
||||||
|
@ -173,7 +176,7 @@ template <typename T, typename Iterator> pair<size_t, unordered_map<T, size_t, s
|
||||||
/* io */
|
/* io */
|
||||||
#define untie __AS_PROCEDURE(ios_base::sync_with_stdio(0), cin.tie(NULL))
|
#define untie __AS_PROCEDURE(ios_base::sync_with_stdio(0), cin.tie(NULL))
|
||||||
|
|
||||||
// add declarations to avoid cyclic dependency
|
// add declarations to avoid circular dependency
|
||||||
template<typename T, typename U> istream& operator>>(istream&, pair<T, U>&);
|
template<typename T, typename U> istream& operator>>(istream&, pair<T, U>&);
|
||||||
template<typename T, typename U> ostream& operator<<(ostream&, const pair<T, U>&);
|
template<typename T, typename U> ostream& operator<<(ostream&, const pair<T, U>&);
|
||||||
template<typename T, size_t N> istream& operator>>(istream&, array<T, N>&);
|
template<typename T, size_t N> istream& operator>>(istream&, array<T, N>&);
|
||||||
|
@ -239,14 +242,14 @@ std::ostream& operator<<(std::ostream& dest, const int128& value) {
|
||||||
template<typename T> void __read(T& x) { cin >> x; }
|
template<typename T> void __read(T& x) { cin >> x; }
|
||||||
template<typename T, typename... U> void __read(T& x, U&... args) { cin >> x; __read(args...); }
|
template<typename T, typename... U> void __read(T& x, U&... args) { cin >> x; __read(args...); }
|
||||||
#define read(t, ...) __AS_PROCEDURE(argument_type<void(t)>::type __VA_ARGS__; __read(__VA_ARGS__);)
|
#define read(t, ...) __AS_PROCEDURE(argument_type<void(t)>::type __VA_ARGS__; __read(__VA_ARGS__);)
|
||||||
#define readvec(t, a, n) __AS_PROCEDURE(vector<argument_type<void(t)>::type> a(n); for (auto& x : a) cin >> x;)
|
#define readvec(t, a, n) __AS_PROCEDURE(vector<argument_type<void(t)>::type> a(n); for (auto& x : (a)) cin >> x;)
|
||||||
#define readvec1(t, a, n) __AS_PROCEDURE(vector<argument_type<void(t)>::type> a((n) + 1); copy_n(ii<argument_type<void(t)>::type>(cin), (n), a.begin() + 1);)
|
#define readvec1(t, a, n) __AS_PROCEDURE(vector<argument_type<void(t)>::type> a((n) + 1); copy_n(ii<argument_type<void(t)>::type>(cin), (n), (a).begin() + 1);)
|
||||||
#define putvec(a) __AS_PROCEDURE(copy(a.begin(), a.end(), oi<__as_typeof(a)::value_type>(cout, " ")); cout << endl;)
|
#define putvec(a) __AS_PROCEDURE(copy((a).begin(), (a).end(), oi<__as_typeof(a)::value_type>(cout, " ")); cout << endl;)
|
||||||
#define putvec1(a) __AS_PROCEDURE(copy(a.begin() + 1, a.end(), oi<__as_typeof(a)::value_type>(cout, " ")); cout << endl;)
|
#define putvec1(a) __AS_PROCEDURE(copy((a).begin() + 1, (a).end(), oi<__as_typeof(a)::value_type>(cout, " ")); cout << endl;)
|
||||||
#define putvec_eol(a) __AS_PROCEDURE(copy(a.begin(), a.end(), oi<__as_typeof(a)::value_type>(cout, "\n"));)
|
#define putvec_eol(a) __AS_PROCEDURE(copy((a).begin(), (a).end(), oi<__as_typeof(a)::value_type>(cout, "\n"));)
|
||||||
#define putvec1_eol(a) __AS_PROCEDURE(copy(a.begin() + 1, a.end(), oi<__as_typeof(a)::value_type>(cout, "\n"));)
|
#define putvec1_eol(a) __AS_PROCEDURE(copy((a).begin() + 1, (a).end(), oi<__as_typeof(a)::value_type>(cout, "\n"));)
|
||||||
#define debug(x) __AS_PROCEDURE(cerr << #x" = " << (x) << endl;)
|
#define debug(x) __AS_PROCEDURE(cerr << #x" = " << (x) << endl;)
|
||||||
#define debugvec(a) __AS_PROCEDURE(cerr << #a" = "; for (auto&& x : a) cerr << x << ' '; cerr << endl;)
|
#define debugvec(a) __AS_PROCEDURE(cerr << #a" = "; for (auto&& x : (a)) cerr << x << ' '; cerr << endl;)
|
||||||
#define deb(...) debug(make_tuple(__VA_ARGS__))
|
#define deb(...) debug(make_tuple(__VA_ARGS__))
|
||||||
|
|
||||||
/* pops */
|
/* pops */
|
||||||
|
@ -293,7 +296,7 @@ ll qpow(ll b, ll p, ll mod) {
|
||||||
#pragma GCC diagnostic ignored "-Wparentheses"
|
#pragma GCC diagnostic ignored "-Wparentheses"
|
||||||
// Accurately find `i` 'th root of `n` (taking the floor)
|
// Accurately find `i` 'th root of `n` (taking the floor)
|
||||||
inline ll root(ll n, ll i) {
|
inline ll root(ll n, ll i) {
|
||||||
ll l = 0, r = pow(LLONG_MAX, ld(1) / i);
|
ll l = 0, r = pow(LLONG_MAX, (long double)(1) / i);
|
||||||
while (l < r) {
|
while (l < r) {
|
||||||
ll mid = l + r + 1 >> 1;
|
ll mid = l + r + 1 >> 1;
|
||||||
if (qpow<int128>(mid, i) <= n) {
|
if (qpow<int128>(mid, i) <= n) {
|
||||||
|
@ -393,7 +396,7 @@ vector<int> calc_z(string t) { // z function of t
|
||||||
}
|
}
|
||||||
return z;
|
return z;
|
||||||
}
|
}
|
||||||
vector<int> kmp(string s, string t) { // find all t in s
|
vector<int> kmp(const string& s, const string& t) { // find all t in s
|
||||||
string cur = t + '#' + s;
|
string cur = t + '#' + s;
|
||||||
int sz1 = s.size(), sz2 = t.size();
|
int sz1 = s.size(), sz2 = t.size();
|
||||||
vector<int> v;
|
vector<int> v;
|
||||||
|
@ -403,7 +406,7 @@ vector<int> kmp(string s, string t) { // find all t in s
|
||||||
}
|
}
|
||||||
return v;
|
return v;
|
||||||
}
|
}
|
||||||
int period(string s) { // find the length of shortest recurring period
|
int period(const string& s) { // find the length of shortest recurring period
|
||||||
int n = s.length();
|
int n = s.length();
|
||||||
auto z = calc_z(s);
|
auto z = calc_z(s);
|
||||||
for (int i = 1; i <= n / 2; ++i) {
|
for (int i = 1; i <= n / 2; ++i) {
|
||||||
|
@ -421,8 +424,8 @@ template <ll mdl> struct MLL {
|
||||||
MLL(const MLL<mdl>& other) : val(other.val) {}
|
MLL(const MLL<mdl>& other) : val(other.val) {}
|
||||||
friend MLL operator+(const MLL& lhs, const MLL& rhs) { return mod(lhs.val + rhs.val, mdl); }
|
friend MLL operator+(const MLL& lhs, const MLL& rhs) { return mod(lhs.val + rhs.val, mdl); }
|
||||||
friend MLL operator-(const MLL& lhs, const MLL& rhs) { return mod(lhs.val - rhs.val, mdl); }
|
friend MLL operator-(const MLL& lhs, const MLL& rhs) { return mod(lhs.val - rhs.val, mdl); }
|
||||||
friend MLL operator*(const MLL& lhs, const MLL& rhs) { return mod(lhs.val * rhs.val, mdl); }
|
friend MLL operator*(const MLL& lhs, const MLL& rhs) { return mod(int128(lhs.val) * rhs.val, mdl); }
|
||||||
friend MLL operator/(const MLL& lhs, const MLL& rhs) { return mod(lhs.val * mod(inverse(rhs.val, mdl), mdl), mdl); }
|
friend MLL operator/(const MLL& lhs, const MLL& rhs) { return lhs * mod(inverse(rhs.val, mdl), mdl); }
|
||||||
friend MLL operator%(const MLL& lhs, const MLL& rhs) { return mod(lhs.val - (lhs / rhs).val, mdl); }
|
friend MLL operator%(const MLL& lhs, const MLL& rhs) { return mod(lhs.val - (lhs / rhs).val, mdl); }
|
||||||
friend bool operator==(const MLL& lhs, const MLL& rhs) { return lhs.val == rhs.val; }
|
friend bool operator==(const MLL& lhs, const MLL& rhs) { return lhs.val == rhs.val; }
|
||||||
friend bool operator!=(const MLL& lhs, const MLL& rhs) { return lhs.val != rhs.val; }
|
friend bool operator!=(const MLL& lhs, const MLL& rhs) { return lhs.val != rhs.val; }
|
||||||
|
@ -538,18 +541,17 @@ void prep() {
|
||||||
// __attribute__((target("popcnt")))
|
// __attribute__((target("popcnt")))
|
||||||
void solve() {
|
void solve() {
|
||||||
read(int, n);
|
read(int, n);
|
||||||
int res = 1;
|
read(string, a);
|
||||||
int curr = 1;
|
if (a[0] == '1' or a[n - 1] == '1') {
|
||||||
while (curr < n) {
|
cout << "Alice\n";
|
||||||
res += 1;
|
} else {
|
||||||
curr += curr + 2;
|
cout << "Bob\n";
|
||||||
}
|
}
|
||||||
cout << res << '\n';
|
|
||||||
}
|
}
|
||||||
|
|
||||||
int main() {
|
int main() {
|
||||||
#if __cplusplus < 201402L or defined(_MSC_VER) and not defined(__clang__)
|
#if __cplusplus < 201402L or defined(_MSC_VER) and not defined(__clang__)
|
||||||
assert(false && "incompatible compiler variant detected.");
|
static_assert(false, "incompatible compiler variant detected.");
|
||||||
#endif
|
#endif
|
||||||
untie;
|
untie;
|
||||||
prep();
|
prep();
|
||||||
|
|
139
src/bin/c.cc
139
src/bin/c.cc
|
@ -25,7 +25,7 @@ using ull = unsigned long long;
|
||||||
#endif
|
#endif
|
||||||
using int128 = __int128_t;
|
using int128 = __int128_t;
|
||||||
using uint128 = __uint128_t;
|
using uint128 = __uint128_t;
|
||||||
using ld = long double;
|
using ld = __float128; // up to 1e-9 precision in binary search
|
||||||
using pii = pair<int, int>; using pil = pair<int, ll>; using pid = pair<int, ld>;
|
using pii = pair<int, int>; using pil = pair<int, ll>; using pid = pair<int, ld>;
|
||||||
using pli = pair<ll, int>; using pll = pair<ll, ll>; using pld = pair<ll, ld>;
|
using pli = pair<ll, int>; using pll = pair<ll, ll>; using pld = pair<ll, ld>;
|
||||||
using pdi = pair<ld, int>; using pdl = pair<ld, ll>; using pdd = pair<ld, ld>;
|
using pdi = pair<ld, int>; using pdl = pair<ld, ll>; using pdd = pair<ld, ld>;
|
||||||
|
@ -48,6 +48,7 @@ constexpr int INF = 0x3f3f3f3f;
|
||||||
constexpr ll INFLL = 0x3f3f3f3f3f3f3f3fLL;
|
constexpr ll INFLL = 0x3f3f3f3f3f3f3f3fLL;
|
||||||
constexpr ll MDL = 1e9 + 7;
|
constexpr ll MDL = 1e9 + 7;
|
||||||
constexpr ll PRIME = 998'244'353;
|
constexpr ll PRIME = 998'244'353;
|
||||||
|
constexpr ll PRIMELL = 901017227882342239LL;
|
||||||
constexpr ll MDL1 = 8784491;
|
constexpr ll MDL1 = 8784491;
|
||||||
constexpr ll MDL2 = PRIME;
|
constexpr ll MDL2 = PRIME;
|
||||||
constexpr int128 INT128_MAX = numeric_limits<int128>::max();
|
constexpr int128 INT128_MAX = numeric_limits<int128>::max();
|
||||||
|
@ -96,9 +97,9 @@ struct igt {
|
||||||
|
|
||||||
/* conditions */
|
/* conditions */
|
||||||
#define loop while (1)
|
#define loop while (1)
|
||||||
#define if_or(var, val) if (!(var == val)) var = val; else
|
#define if_or(var, val) if (!((var) == (val))) (var) = (val); else
|
||||||
#define continue_or(var, val) __AS_PROCEDURE(if (var == val) continue; var = val;)
|
#define continue_or(var, val) __AS_PROCEDURE(if ((var) == (val)) continue; (var) = (val);)
|
||||||
#define break_or(var, val) __AS_PROCEDURE(if (var == val) break; var = val;)
|
#define break_or(var, val) __AS_PROCEDURE(if ((var) == (val)) break; (var) = (val);)
|
||||||
|
|
||||||
/* hash */
|
/* hash */
|
||||||
struct safe_hash {
|
struct safe_hash {
|
||||||
|
@ -132,13 +133,15 @@ struct pair_hash {
|
||||||
uniform_int_distribution<mt19937::result_type> dist(PRIME);
|
uniform_int_distribution<mt19937::result_type> dist(PRIME);
|
||||||
const size_t __array_hash_b = 31, __array_hash_mdl1 = dist(rd), __array_hash_mdl2 = dist(rd);
|
const size_t __array_hash_b = 31, __array_hash_mdl1 = dist(rd), __array_hash_mdl2 = dist(rd);
|
||||||
struct array_hash {
|
struct array_hash {
|
||||||
|
safe_hash hasher;
|
||||||
template <typename Sequence>
|
template <typename Sequence>
|
||||||
size_t operator()(const Sequence& arr) const {
|
size_t operator()(const Sequence& arr) const {
|
||||||
size_t pw1 = 1, pw2 = 1;
|
size_t pw1 = 1, pw2 = 1;
|
||||||
size_t res1 = 0, res2 = 0;
|
size_t res1 = 0, res2 = 0;
|
||||||
for (auto&& x : arr) {
|
for (auto&& x : arr) {
|
||||||
res1 = (res1 + x * pw1) % __array_hash_mdl1;
|
auto h = hasher(x);
|
||||||
res2 = (res2 + x * pw2) % __array_hash_mdl2;
|
res1 = (res1 + h * pw1) % __array_hash_mdl1;
|
||||||
|
res2 = (res2 + h * pw2) % __array_hash_mdl2;
|
||||||
pw1 = (pw1 * __array_hash_b) % __array_hash_mdl1;
|
pw1 = (pw1 * __array_hash_b) % __array_hash_mdl1;
|
||||||
pw2 = (pw2 * __array_hash_b) % __array_hash_mdl2;
|
pw2 = (pw2 * __array_hash_b) % __array_hash_mdl2;
|
||||||
}
|
}
|
||||||
|
@ -173,7 +176,7 @@ template <typename T, typename Iterator> pair<size_t, unordered_map<T, size_t, s
|
||||||
/* io */
|
/* io */
|
||||||
#define untie __AS_PROCEDURE(ios_base::sync_with_stdio(0), cin.tie(NULL))
|
#define untie __AS_PROCEDURE(ios_base::sync_with_stdio(0), cin.tie(NULL))
|
||||||
|
|
||||||
// add declarations to avoid cyclic dependency
|
// add declarations to avoid circular dependency
|
||||||
template<typename T, typename U> istream& operator>>(istream&, pair<T, U>&);
|
template<typename T, typename U> istream& operator>>(istream&, pair<T, U>&);
|
||||||
template<typename T, typename U> ostream& operator<<(ostream&, const pair<T, U>&);
|
template<typename T, typename U> ostream& operator<<(ostream&, const pair<T, U>&);
|
||||||
template<typename T, size_t N> istream& operator>>(istream&, array<T, N>&);
|
template<typename T, size_t N> istream& operator>>(istream&, array<T, N>&);
|
||||||
|
@ -239,14 +242,14 @@ std::ostream& operator<<(std::ostream& dest, const int128& value) {
|
||||||
template<typename T> void __read(T& x) { cin >> x; }
|
template<typename T> void __read(T& x) { cin >> x; }
|
||||||
template<typename T, typename... U> void __read(T& x, U&... args) { cin >> x; __read(args...); }
|
template<typename T, typename... U> void __read(T& x, U&... args) { cin >> x; __read(args...); }
|
||||||
#define read(t, ...) __AS_PROCEDURE(argument_type<void(t)>::type __VA_ARGS__; __read(__VA_ARGS__);)
|
#define read(t, ...) __AS_PROCEDURE(argument_type<void(t)>::type __VA_ARGS__; __read(__VA_ARGS__);)
|
||||||
#define readvec(t, a, n) __AS_PROCEDURE(vector<argument_type<void(t)>::type> a(n); for (auto& x : a) cin >> x;)
|
#define readvec(t, a, n) __AS_PROCEDURE(vector<argument_type<void(t)>::type> a(n); for (auto& x : (a)) cin >> x;)
|
||||||
#define readvec1(t, a, n) __AS_PROCEDURE(vector<argument_type<void(t)>::type> a((n) + 1); copy_n(ii<argument_type<void(t)>::type>(cin), (n), a.begin() + 1);)
|
#define readvec1(t, a, n) __AS_PROCEDURE(vector<argument_type<void(t)>::type> a((n) + 1); copy_n(ii<argument_type<void(t)>::type>(cin), (n), (a).begin() + 1);)
|
||||||
#define putvec(a) __AS_PROCEDURE(copy(a.begin(), a.end(), oi<__as_typeof(a)::value_type>(cout, " ")); cout << endl;)
|
#define putvec(a) __AS_PROCEDURE(copy((a).begin(), (a).end(), oi<__as_typeof(a)::value_type>(cout, " ")); cout << endl;)
|
||||||
#define putvec1(a) __AS_PROCEDURE(copy(a.begin() + 1, a.end(), oi<__as_typeof(a)::value_type>(cout, " ")); cout << endl;)
|
#define putvec1(a) __AS_PROCEDURE(copy((a).begin() + 1, (a).end(), oi<__as_typeof(a)::value_type>(cout, " ")); cout << endl;)
|
||||||
#define putvec_eol(a) __AS_PROCEDURE(copy(a.begin(), a.end(), oi<__as_typeof(a)::value_type>(cout, "\n"));)
|
#define putvec_eol(a) __AS_PROCEDURE(copy((a).begin(), (a).end(), oi<__as_typeof(a)::value_type>(cout, "\n"));)
|
||||||
#define putvec1_eol(a) __AS_PROCEDURE(copy(a.begin() + 1, a.end(), oi<__as_typeof(a)::value_type>(cout, "\n"));)
|
#define putvec1_eol(a) __AS_PROCEDURE(copy((a).begin() + 1, (a).end(), oi<__as_typeof(a)::value_type>(cout, "\n"));)
|
||||||
#define debug(x) __AS_PROCEDURE(cerr << #x" = " << (x) << endl;)
|
#define debug(x) __AS_PROCEDURE(cerr << #x" = " << (x) << endl;)
|
||||||
#define debugvec(a) __AS_PROCEDURE(cerr << #a" = "; for (auto&& x : a) cerr << x << ' '; cerr << endl;)
|
#define debugvec(a) __AS_PROCEDURE(cerr << #a" = "; for (auto&& x : (a)) cerr << x << ' '; cerr << endl;)
|
||||||
#define deb(...) debug(make_tuple(__VA_ARGS__))
|
#define deb(...) debug(make_tuple(__VA_ARGS__))
|
||||||
|
|
||||||
/* pops */
|
/* pops */
|
||||||
|
@ -293,7 +296,7 @@ ll qpow(ll b, ll p, ll mod) {
|
||||||
#pragma GCC diagnostic ignored "-Wparentheses"
|
#pragma GCC diagnostic ignored "-Wparentheses"
|
||||||
// Accurately find `i` 'th root of `n` (taking the floor)
|
// Accurately find `i` 'th root of `n` (taking the floor)
|
||||||
inline ll root(ll n, ll i) {
|
inline ll root(ll n, ll i) {
|
||||||
ll l = 0, r = pow(LLONG_MAX, ld(1) / i);
|
ll l = 0, r = pow(LLONG_MAX, (long double)(1) / i);
|
||||||
while (l < r) {
|
while (l < r) {
|
||||||
ll mid = l + r + 1 >> 1;
|
ll mid = l + r + 1 >> 1;
|
||||||
if (qpow<int128>(mid, i) <= n) {
|
if (qpow<int128>(mid, i) <= n) {
|
||||||
|
@ -393,7 +396,7 @@ vector<int> calc_z(string t) { // z function of t
|
||||||
}
|
}
|
||||||
return z;
|
return z;
|
||||||
}
|
}
|
||||||
vector<int> kmp(string s, string t) { // find all t in s
|
vector<int> kmp(const string& s, const string& t) { // find all t in s
|
||||||
string cur = t + '#' + s;
|
string cur = t + '#' + s;
|
||||||
int sz1 = s.size(), sz2 = t.size();
|
int sz1 = s.size(), sz2 = t.size();
|
||||||
vector<int> v;
|
vector<int> v;
|
||||||
|
@ -403,7 +406,7 @@ vector<int> kmp(string s, string t) { // find all t in s
|
||||||
}
|
}
|
||||||
return v;
|
return v;
|
||||||
}
|
}
|
||||||
int period(string s) { // find the length of shortest recurring period
|
int period(const string& s) { // find the length of shortest recurring period
|
||||||
int n = s.length();
|
int n = s.length();
|
||||||
auto z = calc_z(s);
|
auto z = calc_z(s);
|
||||||
for (int i = 1; i <= n / 2; ++i) {
|
for (int i = 1; i <= n / 2; ++i) {
|
||||||
|
@ -421,8 +424,8 @@ template <ll mdl> struct MLL {
|
||||||
MLL(const MLL<mdl>& other) : val(other.val) {}
|
MLL(const MLL<mdl>& other) : val(other.val) {}
|
||||||
friend MLL operator+(const MLL& lhs, const MLL& rhs) { return mod(lhs.val + rhs.val, mdl); }
|
friend MLL operator+(const MLL& lhs, const MLL& rhs) { return mod(lhs.val + rhs.val, mdl); }
|
||||||
friend MLL operator-(const MLL& lhs, const MLL& rhs) { return mod(lhs.val - rhs.val, mdl); }
|
friend MLL operator-(const MLL& lhs, const MLL& rhs) { return mod(lhs.val - rhs.val, mdl); }
|
||||||
friend MLL operator*(const MLL& lhs, const MLL& rhs) { return mod(lhs.val * rhs.val, mdl); }
|
friend MLL operator*(const MLL& lhs, const MLL& rhs) { return mod(int128(lhs.val) * rhs.val, mdl); }
|
||||||
friend MLL operator/(const MLL& lhs, const MLL& rhs) { return mod(lhs.val * mod(inverse(rhs.val, mdl), mdl), mdl); }
|
friend MLL operator/(const MLL& lhs, const MLL& rhs) { return lhs * mod(inverse(rhs.val, mdl), mdl); }
|
||||||
friend MLL operator%(const MLL& lhs, const MLL& rhs) { return mod(lhs.val - (lhs / rhs).val, mdl); }
|
friend MLL operator%(const MLL& lhs, const MLL& rhs) { return mod(lhs.val - (lhs / rhs).val, mdl); }
|
||||||
friend bool operator==(const MLL& lhs, const MLL& rhs) { return lhs.val == rhs.val; }
|
friend bool operator==(const MLL& lhs, const MLL& rhs) { return lhs.val == rhs.val; }
|
||||||
friend bool operator!=(const MLL& lhs, const MLL& rhs) { return lhs.val != rhs.val; }
|
friend bool operator!=(const MLL& lhs, const MLL& rhs) { return lhs.val != rhs.val; }
|
||||||
|
@ -524,7 +527,7 @@ constexpr std::array<T, N> __initarray(const T& value) {
|
||||||
}
|
}
|
||||||
/*******************************************************/
|
/*******************************************************/
|
||||||
|
|
||||||
// #define SINGLE_TEST_CASE
|
#define SINGLE_TEST_CASE
|
||||||
// #define DUMP_TEST_CASE 7219
|
// #define DUMP_TEST_CASE 7219
|
||||||
// #define TOT_TEST_CASE 10000
|
// #define TOT_TEST_CASE 10000
|
||||||
|
|
||||||
|
@ -535,42 +538,92 @@ void dump_ignore() {}
|
||||||
void prep() {
|
void prep() {
|
||||||
}
|
}
|
||||||
|
|
||||||
|
template<typename T>
|
||||||
|
struct BIT {
|
||||||
|
int n;
|
||||||
|
vector<T> c;
|
||||||
|
BIT(size_t n) : n(n), c(n + 1) {}
|
||||||
|
void add(size_t i, const T& k) {
|
||||||
|
while (i <= n) {
|
||||||
|
c[i] += k;
|
||||||
|
i += lowbit(i);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
T getsum(size_t i) {
|
||||||
|
T res = {};
|
||||||
|
while (i) {
|
||||||
|
res += c[i];
|
||||||
|
i -= lowbit(i);
|
||||||
|
}
|
||||||
|
return res;
|
||||||
|
}
|
||||||
|
};
|
||||||
|
|
||||||
|
|
||||||
// __attribute__((target("popcnt")))
|
// __attribute__((target("popcnt")))
|
||||||
void solve() {
|
void solve() {
|
||||||
read(int, n);
|
read(int, n, m);
|
||||||
read(ll, k);
|
n += 1;
|
||||||
k -= 1;
|
vector cntrj(n, vector<int>(26));
|
||||||
vector<int> res(n);
|
vector ac(n, vector<bool>(26));
|
||||||
int l = 0, r = n - 1;
|
vector<pil> status(n);
|
||||||
for (int i = n - 2; ~i; --i) {
|
|
||||||
int bit;
|
vector<tuple<string, int, ll, int>> events;
|
||||||
if (i > 63) {
|
vector<ll> oc = { ll(26) << 32 };
|
||||||
bit = 0;
|
for (int i = 0; i < m; ++i) {
|
||||||
|
ll time = 0;
|
||||||
|
read(string, raw_time);
|
||||||
|
time += stoi(raw_time.substr(0, 2)) * 60 + stoi(raw_time.substr(3, 2));
|
||||||
|
read(int, team);
|
||||||
|
read(char, raw_no);
|
||||||
|
int no = raw_no - 'A';
|
||||||
|
read(string, raw_stat);
|
||||||
|
int stat = raw_stat == "AC";
|
||||||
|
bool upd = team == 0 and stat and not ac[team][no];
|
||||||
|
if (stat) {
|
||||||
|
if (ac[team][no]) {
|
||||||
|
;;
|
||||||
} else {
|
} else {
|
||||||
bit = k >> i & 1;
|
ac[team][no] = 1;
|
||||||
k ^= ll(bit) << i;
|
status[team].first += 1;
|
||||||
|
status[team].second += time + ll(1) * 20 * cntrj[team][no];
|
||||||
}
|
}
|
||||||
if (bit == 0) {
|
|
||||||
res[l++] = n - 1 - i;
|
|
||||||
} else {
|
} else {
|
||||||
res[r--] = n - 1 - i;
|
cntrj[team][no] += 1;
|
||||||
}
|
}
|
||||||
|
// deb(team, status[team]);
|
||||||
|
ll currstatus = (26 - ll(1) * status[team].first) << 32 bitor status[team].second;
|
||||||
|
oc.emplace_back(currstatus);
|
||||||
|
events.emplace_back(raw_time, team, currstatus, upd ? no : -1);
|
||||||
}
|
}
|
||||||
if (k) {
|
|
||||||
cout << -1 << '\n';
|
sort(oc.begin(), oc.end());
|
||||||
} else {
|
int t = unique(oc.begin(), oc.end()) - oc.begin();
|
||||||
assert(l == r);
|
oc.resize(t);
|
||||||
res[l] = n;
|
auto get = [&] (ll x) { return lower_bound(oc.begin(), oc.end(), x) - oc.begin(); };
|
||||||
for (auto&& x : res) {
|
|
||||||
cout << x << ' ';
|
BIT<int> tr(t);
|
||||||
|
|
||||||
|
vector<ll> curr(n, (ll(1) * 26) << 32);
|
||||||
|
tr.add((ll(1) * 26) << 32, n);
|
||||||
|
|
||||||
|
for (auto&& [raw_time, team, penalty, no] : events) {
|
||||||
|
int old;
|
||||||
|
if (no != -1) {
|
||||||
|
old = tr.getsum(get(curr[0])) + 1;
|
||||||
|
}
|
||||||
|
tr.add(get(curr[team]) + 1, -1);
|
||||||
|
curr[team] = penalty;
|
||||||
|
tr.add(get(curr[team]) + 1, 1);
|
||||||
|
if (no != -1) {
|
||||||
|
cout << raw_time << ' ' << char(no + 'A') << " #" << old << " -> #" << tr.getsum(get(curr[0])) + 1 << '\n';
|
||||||
}
|
}
|
||||||
cout << '\n';
|
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
int main() {
|
int main() {
|
||||||
#if __cplusplus < 201402L or defined(_MSC_VER) and not defined(__clang__)
|
#if __cplusplus < 201402L or defined(_MSC_VER) and not defined(__clang__)
|
||||||
assert(false && "incompatible compiler variant detected.");
|
static_assert(false, "incompatible compiler variant detected.");
|
||||||
#endif
|
#endif
|
||||||
untie;
|
untie;
|
||||||
prep();
|
prep();
|
||||||
|
|
|
@ -0,0 +1,632 @@
|
||||||
|
// #pragma GCC target("popcnt,lzcnt,abm,bmi,bmi2")
|
||||||
|
#pragma GCC optimize("Ofast,unroll-loops")
|
||||||
|
/************* This code requires C++17. ***************/
|
||||||
|
|
||||||
|
#include<bits/stdc++.h>
|
||||||
|
using namespace std;
|
||||||
|
|
||||||
|
/* macro helpers */
|
||||||
|
#define __NARGS(...) std::tuple_size<decltype(std::make_tuple(__VA_ARGS__))>::value
|
||||||
|
#define __DECOMPOSE_S(a, x) auto x = a;
|
||||||
|
#define __DECOMPOSE_N(a, ...) auto [__VA_ARGS__] = a;
|
||||||
|
constexpr void __() {}
|
||||||
|
#define __AS_PROCEDURE(...) __(); __VA_ARGS__; __()
|
||||||
|
#define __as_typeof(container) remove_reference<decltype(container)>::type
|
||||||
|
template <typename T> struct argument_type;
|
||||||
|
template <typename T, typename U> struct argument_type<T(U)> { using type = U; };
|
||||||
|
|
||||||
|
/* type aliases */
|
||||||
|
#if LONG_LONG_MAX != INT64_MAX
|
||||||
|
using ll = int64_t;
|
||||||
|
using ull = uint64_t;
|
||||||
|
#else
|
||||||
|
using ll = long long;
|
||||||
|
using ull = unsigned long long;
|
||||||
|
#endif
|
||||||
|
using int128 = __int128_t;
|
||||||
|
using uint128 = __uint128_t;
|
||||||
|
using ld = __float128; // up to 1e-9 precision in binary search
|
||||||
|
using pii = pair<int, int>; using pil = pair<int, ll>; using pid = pair<int, ld>;
|
||||||
|
using pli = pair<ll, int>; using pll = pair<ll, ll>; using pld = pair<ll, ld>;
|
||||||
|
using pdi = pair<ld, int>; using pdl = pair<ld, ll>; using pdd = pair<ld, ld>;
|
||||||
|
using tiii = tuple<int, int, int>; using tiil = tuple<int, int, ll>; using tiid = tuple<int, int, ld>;
|
||||||
|
using tili = tuple<int, ll, int>; using till = tuple<int, ll, ll>; using tild = tuple<int, ll, ld>;
|
||||||
|
using tidi = tuple<int, ld, int>; using tidl = tuple<int, ld, ll>; using tidd = tuple<int, ld, ld>;
|
||||||
|
using tlii = tuple<ll, int, int>; using tlil = tuple<ll, int, ll>; using tlid = tuple<ll, int, ld>;
|
||||||
|
using tlli = tuple<ll, ll, int>; using tlll = tuple<ll, ll, ll>; using tlld = tuple<ll, ll, ld>;
|
||||||
|
using tldi = tuple<ll, ld, int>; using tldl = tuple<ll, ld, ll>; using tldd = tuple<ll, ld, ld>;
|
||||||
|
using tdii = tuple<ld, int, int>; using tdil = tuple<ld, int, ll>; using tdid = tuple<ld, int, ld>;
|
||||||
|
using tdli = tuple<ld, ll, int>; using tdll = tuple<ld, ll, ll>; using tdld = tuple<ld, ll, ld>;
|
||||||
|
using tddi = tuple<ld, ld, int>; using tddl = tuple<ld, ld, ll>; using tddd = tuple<ld, ld, ld>;
|
||||||
|
template <typename T> using max_heap = priority_queue<T>;
|
||||||
|
template <typename T> using min_heap = priority_queue<T, vector<T>, greater<>>;
|
||||||
|
template <typename T> using oi = ostream_iterator<T>;
|
||||||
|
template <typename T> using ii = istream_iterator<T>;
|
||||||
|
|
||||||
|
/* constants */
|
||||||
|
constexpr int INF = 0x3f3f3f3f;
|
||||||
|
constexpr ll INFLL = 0x3f3f3f3f3f3f3f3fLL;
|
||||||
|
constexpr ll MDL = 1e9 + 7;
|
||||||
|
constexpr ll PRIME = 998'244'353;
|
||||||
|
constexpr ll PRIMELL = 901017227882342239LL;
|
||||||
|
constexpr ll MDL1 = 8784491;
|
||||||
|
constexpr ll MDL2 = PRIME;
|
||||||
|
constexpr int128 INT128_MAX = numeric_limits<int128>::max();
|
||||||
|
constexpr uint128 UINT128_MAX = numeric_limits<uint128>::max();
|
||||||
|
constexpr int128 INT128_MIN = numeric_limits<int128>::min();
|
||||||
|
constexpr uint128 UINT128_MIN = numeric_limits<uint128>::min();
|
||||||
|
|
||||||
|
/* random */
|
||||||
|
|
||||||
|
mt19937_64 rd(chrono::duration_cast<chrono::milliseconds>(chrono::system_clock::now().time_since_epoch()).count());
|
||||||
|
|
||||||
|
/* bit-wise operations */
|
||||||
|
#define lowbit(x) ((x) & -(x))
|
||||||
|
#define popcount(x) (__builtin_popcountll(ll(x)))
|
||||||
|
#define parity(x) (__builtin_parityll(ll(x)))
|
||||||
|
#define msp(x) (63LL - __builtin_clzll(ll(x)))
|
||||||
|
#define lsp(x) (__builtin_ctzll(ll(x)))
|
||||||
|
|
||||||
|
/* arithmetic operations */
|
||||||
|
#define mod(x, y) ((((x) % (y)) + (y)) % (y))
|
||||||
|
|
||||||
|
/* fast pairs */
|
||||||
|
#define upair ull
|
||||||
|
#define umake(x, y) (ull(x) << 32 | (ull(y) & ((1ULL << 32) - 1)))
|
||||||
|
#define u1(p) ((p) >> 32)
|
||||||
|
#define u2(p) ((p) & ((1ULL << 32) - 1))
|
||||||
|
#define ult std::less<upair>
|
||||||
|
#define ugt std::greater<upair>
|
||||||
|
|
||||||
|
#define ipair ull
|
||||||
|
#define imake(x, y) (umake(x, y))
|
||||||
|
#define i1(p) (int(u1(ll(p))))
|
||||||
|
#define i2(p) (ll(u2(p) << 32) >> 32)
|
||||||
|
struct ilt {
|
||||||
|
bool operator()(const ipair& a, const ipair& b) const {
|
||||||
|
if (i1(a) == i1(b)) return i2(a) < i2(b);
|
||||||
|
else return i1(a) < i1(b);
|
||||||
|
}
|
||||||
|
};
|
||||||
|
struct igt {
|
||||||
|
bool operator()(const ipair& a, const ipair& b) const {
|
||||||
|
if (i1(a) == i1(b)) return i2(a) > i2(b);
|
||||||
|
else return i1(a) > i1(b);
|
||||||
|
}
|
||||||
|
};
|
||||||
|
|
||||||
|
/* conditions */
|
||||||
|
#define loop while (1)
|
||||||
|
#define if_or(var, val) if (!((var) == (val))) (var) = (val); else
|
||||||
|
#define continue_or(var, val) __AS_PROCEDURE(if ((var) == (val)) continue; (var) = (val);)
|
||||||
|
#define break_or(var, val) __AS_PROCEDURE(if ((var) == (val)) break; (var) = (val);)
|
||||||
|
|
||||||
|
/* hash */
|
||||||
|
struct safe_hash {
|
||||||
|
// https://codeforces.com/blog/entry/62393
|
||||||
|
static uint64_t splitmix64(uint64_t x) {
|
||||||
|
// http://xorshift.di.unimi.it/splitmix64.c
|
||||||
|
x += 0x9e3779b97f4a7c15;
|
||||||
|
x = (x ^ (x >> 30)) * 0xbf58476d1ce4e5b9;
|
||||||
|
x = (x ^ (x >> 27)) * 0x94d049bb133111eb;
|
||||||
|
return x ^ (x >> 31);
|
||||||
|
}
|
||||||
|
|
||||||
|
size_t operator()(uint64_t x) const {
|
||||||
|
static const uint64_t FIXED_RANDOM = chrono::steady_clock::now().time_since_epoch().count();
|
||||||
|
return splitmix64(x + FIXED_RANDOM);
|
||||||
|
}
|
||||||
|
};
|
||||||
|
|
||||||
|
struct pair_hash {
|
||||||
|
template <typename T, typename U>
|
||||||
|
size_t operator()(const pair<T, U>& a) const {
|
||||||
|
auto hash1 = safe_hash()(a.first);
|
||||||
|
auto hash2 = safe_hash()(a.second);
|
||||||
|
if (hash1 != hash2) {
|
||||||
|
return hash1 ^ hash2;
|
||||||
|
}
|
||||||
|
return hash1;
|
||||||
|
}
|
||||||
|
};
|
||||||
|
|
||||||
|
uniform_int_distribution<mt19937::result_type> dist(PRIME);
|
||||||
|
const size_t __array_hash_b = 31, __array_hash_mdl1 = dist(rd), __array_hash_mdl2 = dist(rd);
|
||||||
|
struct array_hash {
|
||||||
|
safe_hash hasher;
|
||||||
|
template <typename Sequence>
|
||||||
|
size_t operator()(const Sequence& arr) const {
|
||||||
|
size_t pw1 = 1, pw2 = 1;
|
||||||
|
size_t res1 = 0, res2 = 0;
|
||||||
|
for (auto&& x : arr) {
|
||||||
|
auto h = hasher(x);
|
||||||
|
res1 = (res1 + h * pw1) % __array_hash_mdl1;
|
||||||
|
res2 = (res2 + h * pw2) % __array_hash_mdl2;
|
||||||
|
pw1 = (pw1 * __array_hash_b) % __array_hash_mdl1;
|
||||||
|
pw2 = (pw2 * __array_hash_b) % __array_hash_mdl2;
|
||||||
|
}
|
||||||
|
return res1 + res2;
|
||||||
|
}
|
||||||
|
};
|
||||||
|
|
||||||
|
/* build data structures */
|
||||||
|
#define faster(um) __AS_PROCEDURE((um).reserve(1024); (um).max_load_factor(0.25);)
|
||||||
|
#define unordered_counter(from, to) __AS_PROCEDURE(unordered_map<__as_typeof(from), size_t, safe_hash> to; for (auto&& x : from) ++to[x];)
|
||||||
|
#define counter(from, to, cmp) __AS_PROCEDURE(map<__as_typeof(from), size_t, cmp> to; for (auto&& x : from) ++to[x];)
|
||||||
|
#define adj(ch, n) __AS_PROCEDURE(vector<vector<int>> ch((n) + 1);)
|
||||||
|
#define edge(ch, u, v) __AS_PROCEDURE(ch[u].push_back(v), ch[v].push_back(u);)
|
||||||
|
#define edgew(ch, u, v, ...) __AS_PROCEDURE(ch[u].emplace_back(v, __VA_ARGS__), ch[v].emplace_back(u, __VA_ARGS__);)
|
||||||
|
#define Edge(ch, u, v) __AS_PROCEDURE(ch[u].push_back(v);)
|
||||||
|
#define Edgew(ch, u, v, ...) __AS_PROCEDURE(ch[u].emplace_back(v, __VA_ARGS__);)
|
||||||
|
template <typename T, typename Iterator> pair<size_t, map<T, size_t>> discretize(Iterator __first, Iterator __last) {
|
||||||
|
set<T> st(__first, __last);
|
||||||
|
size_t N = 0;
|
||||||
|
map<T, size_t> mp;
|
||||||
|
for (auto&& x : st) mp[x] = ++N;
|
||||||
|
return {N, mp};
|
||||||
|
}
|
||||||
|
template <typename T, typename Iterator> pair<size_t, unordered_map<T, size_t, safe_hash>> unordered_discretize(Iterator __first, Iterator __last) {
|
||||||
|
set<T> st(__first, __last);
|
||||||
|
size_t N = 0;
|
||||||
|
unordered_map<T, size_t, safe_hash> mp;
|
||||||
|
for (auto&& x : st) mp[x] = ++N;
|
||||||
|
return {N, mp};
|
||||||
|
}
|
||||||
|
|
||||||
|
/* io */
|
||||||
|
#define untie __AS_PROCEDURE(ios_base::sync_with_stdio(0), cin.tie(NULL))
|
||||||
|
|
||||||
|
// add declarations to avoid circular dependency
|
||||||
|
template<typename T, typename U> istream& operator>>(istream&, pair<T, U>&);
|
||||||
|
template<typename T, typename U> ostream& operator<<(ostream&, const pair<T, U>&);
|
||||||
|
template<typename T, size_t N> istream& operator>>(istream&, array<T, N>&);
|
||||||
|
template <typename T, size_t N> ostream& operator<<(ostream&, const array<T, N>&);
|
||||||
|
template<typename Char, typename Traits, typename... Args>
|
||||||
|
decltype(auto) operator<<(std::basic_ostream<Char, Traits>&, const std::tuple<Args...>&);
|
||||||
|
template<typename T> ostream& operator<<(ostream&, const vector<T>&);
|
||||||
|
std::ostream& operator<<(std::ostream&, const int128&);
|
||||||
|
|
||||||
|
template<typename T, typename U> istream& operator>>(istream& in, pair<T, U>& p) {
|
||||||
|
return in >> p.first >> p.second;
|
||||||
|
}
|
||||||
|
template<typename T, typename U> ostream& operator<<(ostream& out, const pair<T, U>& p) {
|
||||||
|
out << "{" << p.first << ", " << p.second << "}";
|
||||||
|
return out;
|
||||||
|
}
|
||||||
|
template<typename T, size_t N> istream& operator>>(istream& in, array<T, N>& a) {
|
||||||
|
for (size_t i = 0; i < N; ++i) in >> a[i];
|
||||||
|
return in;
|
||||||
|
}
|
||||||
|
template <typename T, size_t N> ostream& operator<<(ostream& out, const array<T, N>& a) {
|
||||||
|
for (auto&& i : a) out << i << ' ';
|
||||||
|
return out;
|
||||||
|
}
|
||||||
|
template<typename Char, typename Traits, typename Tuple, std::size_t... Index>
|
||||||
|
void print_tuple_impl(std::basic_ostream<Char, Traits>& os, const Tuple& t, std::index_sequence<Index...>) {
|
||||||
|
using swallow = int[]; // guaranties left to right order
|
||||||
|
(void)swallow { 0, (void(os << (Index == 0 ? "" : ", ") << std::get<Index>(t)), 0)... };
|
||||||
|
}
|
||||||
|
template<typename Char, typename Traits, typename... Args>
|
||||||
|
decltype(auto) operator<<(std::basic_ostream<Char, Traits>& os, const std::tuple<Args...>& t) {
|
||||||
|
os << "{";
|
||||||
|
print_tuple_impl(os, t, std::index_sequence_for<Args...>{});
|
||||||
|
return os << "}";
|
||||||
|
}
|
||||||
|
template<typename T> ostream& operator<<(ostream& out, const vector<T>& vec) {
|
||||||
|
for (auto&& i : vec) out << i << ' ';
|
||||||
|
return out;
|
||||||
|
}
|
||||||
|
std::ostream& operator<<(std::ostream& dest, const int128& value) {
|
||||||
|
// https://stackoverflow.com/a/25115163/23881100
|
||||||
|
std::ostream::sentry s( dest );
|
||||||
|
if ( s ) {
|
||||||
|
uint128 tmp = value < 0 ? -value : value;
|
||||||
|
char buffer[ 128 ];
|
||||||
|
char* d = std::end( buffer );
|
||||||
|
do {
|
||||||
|
-- d;
|
||||||
|
*d = "0123456789"[ tmp % 10 ];
|
||||||
|
tmp /= 10;
|
||||||
|
} while ( tmp != 0 );
|
||||||
|
if ( value < 0 ) {
|
||||||
|
-- d;
|
||||||
|
*d = '-';
|
||||||
|
}
|
||||||
|
int len = std::end( buffer ) - d;
|
||||||
|
if ( dest.rdbuf()->sputn( d, len ) != len ) {
|
||||||
|
dest.setstate( std::ios_base::badbit );
|
||||||
|
}
|
||||||
|
}
|
||||||
|
return dest;
|
||||||
|
}
|
||||||
|
template<typename T> void __read(T& x) { cin >> x; }
|
||||||
|
template<typename T, typename... U> void __read(T& x, U&... args) { cin >> x; __read(args...); }
|
||||||
|
#define read(t, ...) __AS_PROCEDURE(argument_type<void(t)>::type __VA_ARGS__; __read(__VA_ARGS__);)
|
||||||
|
#define readvec(t, a, n) __AS_PROCEDURE(vector<argument_type<void(t)>::type> a(n); for (auto& x : (a)) cin >> x;)
|
||||||
|
#define readvec1(t, a, n) __AS_PROCEDURE(vector<argument_type<void(t)>::type> a((n) + 1); copy_n(ii<argument_type<void(t)>::type>(cin), (n), (a).begin() + 1);)
|
||||||
|
#define putvec(a) __AS_PROCEDURE(copy((a).begin(), (a).end(), oi<__as_typeof(a)::value_type>(cout, " ")); cout << endl;)
|
||||||
|
#define putvec1(a) __AS_PROCEDURE(copy((a).begin() + 1, (a).end(), oi<__as_typeof(a)::value_type>(cout, " ")); cout << endl;)
|
||||||
|
#define putvec_eol(a) __AS_PROCEDURE(copy((a).begin(), (a).end(), oi<__as_typeof(a)::value_type>(cout, "\n"));)
|
||||||
|
#define putvec1_eol(a) __AS_PROCEDURE(copy((a).begin() + 1, (a).end(), oi<__as_typeof(a)::value_type>(cout, "\n"));)
|
||||||
|
#define debug(x) __AS_PROCEDURE(cerr << #x" = " << (x) << endl;)
|
||||||
|
#define debugvec(a) __AS_PROCEDURE(cerr << #a" = "; for (auto&& x : (a)) cerr << x << ' '; cerr << endl;)
|
||||||
|
#define deb(...) debug(make_tuple(__VA_ARGS__))
|
||||||
|
|
||||||
|
/* pops */
|
||||||
|
template <typename Container>
|
||||||
|
inline auto poptop(Container& q) {
|
||||||
|
auto ret = q.top();
|
||||||
|
q.pop();
|
||||||
|
return ret;
|
||||||
|
}
|
||||||
|
template <typename Container>
|
||||||
|
inline auto popback(Container& q) {
|
||||||
|
auto ret = q.back();
|
||||||
|
q.pop_back();
|
||||||
|
return ret;
|
||||||
|
}
|
||||||
|
template <typename Container>
|
||||||
|
inline auto popfront(Container& q) {
|
||||||
|
auto ret = q.front();
|
||||||
|
q.pop_front();
|
||||||
|
return ret;
|
||||||
|
}
|
||||||
|
|
||||||
|
/* math */
|
||||||
|
template <typename return_t>
|
||||||
|
return_t qpow(ll b, ll p) {
|
||||||
|
if (b == 0 and p != 0) return 0;
|
||||||
|
if (p == 0) return 1;
|
||||||
|
return_t half = qpow<return_t>(b, p / 2);
|
||||||
|
if (p % 2 == 1) return half * half * b;
|
||||||
|
else return half * half;
|
||||||
|
}
|
||||||
|
|
||||||
|
// dynamic modulus
|
||||||
|
ll qpow(ll b, ll p, ll mod) {
|
||||||
|
if (b == 0 and p != 0) return 0;
|
||||||
|
if (p == 0) return 1;
|
||||||
|
ll half = qpow(b, p / 2, mod);
|
||||||
|
if (p % 2 == 1) return (int128(half) * half % mod) * b % mod;
|
||||||
|
else return half * half % mod;
|
||||||
|
}
|
||||||
|
|
||||||
|
|
||||||
|
#pragma GCC diagnostic push
|
||||||
|
#pragma GCC diagnostic ignored "-Wparentheses"
|
||||||
|
// Accurately find `i` 'th root of `n` (taking the floor)
|
||||||
|
inline ll root(ll n, ll i) {
|
||||||
|
ll l = 0, r = pow(LLONG_MAX, (long double)(1) / i);
|
||||||
|
while (l < r) {
|
||||||
|
ll mid = l + r + 1 >> 1;
|
||||||
|
if (qpow<int128>(mid, i) <= n) {
|
||||||
|
l = mid;
|
||||||
|
} else {
|
||||||
|
r = mid - 1;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
return l;
|
||||||
|
}
|
||||||
|
#pragma GCC diagnostic pop
|
||||||
|
|
||||||
|
|
||||||
|
#define comb(n, k) ((n) < 0 or (k) < 0 or (n) < (k) ? 0 : fact[n] / fact[k] / fact[(n) - (k)])
|
||||||
|
#define fastcomb(n, k) ((n) < 0 or (k) < 0 or (n) < (k) ? 0 : fact[n] * factrev[k] * factrev[(n) - (k)])
|
||||||
|
|
||||||
|
__attribute__((target("lzcnt")))
|
||||||
|
constexpr inline int lg2(ll x) { return x == 0 ? -1 : sizeof(ll) * 8 - 1 - __builtin_clzll(x); }
|
||||||
|
|
||||||
|
template <typename T>
|
||||||
|
T mygcd(T a, T b) { return b == 0 ? a : mygcd(b, a % b); }
|
||||||
|
|
||||||
|
void __exgcd(ll a, ll b, ll& x, ll& y) {
|
||||||
|
if (b == 0) {
|
||||||
|
x = 1, y = 0;
|
||||||
|
return;
|
||||||
|
}
|
||||||
|
__exgcd(b, a % b, y, x);
|
||||||
|
y -= a / b * x;
|
||||||
|
}
|
||||||
|
|
||||||
|
ll inverse(ll a, ll b) {
|
||||||
|
ll x, y;
|
||||||
|
__exgcd(a, b, x, y);
|
||||||
|
return mod(x, b);
|
||||||
|
}
|
||||||
|
|
||||||
|
vector<tuple<int, int, ll>> decompose(ll x) {
|
||||||
|
// return (factor, count, factor ** count)
|
||||||
|
vector<tuple<int, int, ll>> res;
|
||||||
|
for (int i = 2; i * i <= x; i++) {
|
||||||
|
if (x % i == 0) {
|
||||||
|
int cnt = 0;
|
||||||
|
ll pw = 1;
|
||||||
|
while (x % i == 0) ++cnt, x /= i, pw *= i;
|
||||||
|
res.emplace_back(i, cnt, pw);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
if (x != 1) {
|
||||||
|
res.emplace_back(x, 1, x);
|
||||||
|
}
|
||||||
|
return res;
|
||||||
|
}
|
||||||
|
|
||||||
|
vector<pii> decompose_prime(int N) {
|
||||||
|
// return (factor, count)
|
||||||
|
vector<pii> result;
|
||||||
|
for (int i = 2; i * i <= N; i++) {
|
||||||
|
if (N % i == 0) {
|
||||||
|
int cnt = 0;
|
||||||
|
while (N % i == 0) N /= i, ++cnt;
|
||||||
|
result.emplace_back(i, cnt);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
if (N != 1) {
|
||||||
|
result.emplace_back(N, 1);
|
||||||
|
}
|
||||||
|
return result;
|
||||||
|
}
|
||||||
|
|
||||||
|
/* string algorithms */
|
||||||
|
vector<int> calc_next(string t) { // pi function of t
|
||||||
|
int n = (int)t.length();
|
||||||
|
vector<int> pi(n);
|
||||||
|
for (int i = 1; i < n; i++) {
|
||||||
|
int j = pi[i - 1];
|
||||||
|
while (j > 0 && t[i] != t[j]) j = pi[j - 1];
|
||||||
|
if (t[i] == t[j]) j++;
|
||||||
|
pi[i] = j;
|
||||||
|
}
|
||||||
|
return pi;
|
||||||
|
}
|
||||||
|
vector<int> calc_z(string t) { // z function of t
|
||||||
|
int m = t.length();
|
||||||
|
vector<int> z;
|
||||||
|
z.push_back(m);
|
||||||
|
pair<int, int> prev = {1, -1};
|
||||||
|
for (int i = 1; i < m; ++i) {
|
||||||
|
if (z[i - prev.first] + i <= prev.second) {
|
||||||
|
z.push_back(z[i - prev.first]);
|
||||||
|
} else {
|
||||||
|
int j = max(i, prev.second + 1);
|
||||||
|
while (j < m && t[j] == t[j - i]) ++j;
|
||||||
|
z.push_back(j - i);
|
||||||
|
prev = {i, j - 1};
|
||||||
|
}
|
||||||
|
}
|
||||||
|
return z;
|
||||||
|
}
|
||||||
|
vector<int> kmp(const string& s, const string& t) { // find all t in s
|
||||||
|
string cur = t + '#' + s;
|
||||||
|
int sz1 = s.size(), sz2 = t.size();
|
||||||
|
vector<int> v;
|
||||||
|
vector<int> lps = calc_next(cur);
|
||||||
|
for (int i = sz2 + 1; i <= sz1 + sz2; i++) {
|
||||||
|
if (lps[i] == sz2) v.push_back(i - 2 * sz2);
|
||||||
|
}
|
||||||
|
return v;
|
||||||
|
}
|
||||||
|
int period(const string& s) { // find the length of shortest recurring period
|
||||||
|
int n = s.length();
|
||||||
|
auto z = calc_z(s);
|
||||||
|
for (int i = 1; i <= n / 2; ++i) {
|
||||||
|
if (n % i == 0 && z[i] == n - i) {
|
||||||
|
return i;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
return n;
|
||||||
|
}
|
||||||
|
|
||||||
|
/* modular arithmetic */
|
||||||
|
template <ll mdl> struct MLL {
|
||||||
|
ll val;
|
||||||
|
MLL(ll v = 0) : val(mod(v, mdl)) {}
|
||||||
|
MLL(const MLL<mdl>& other) : val(other.val) {}
|
||||||
|
friend MLL operator+(const MLL& lhs, const MLL& rhs) { return mod(lhs.val + rhs.val, mdl); }
|
||||||
|
friend MLL operator-(const MLL& lhs, const MLL& rhs) { return mod(lhs.val - rhs.val, mdl); }
|
||||||
|
friend MLL operator*(const MLL& lhs, const MLL& rhs) { return mod(int128(lhs.val) * rhs.val, mdl); }
|
||||||
|
friend MLL operator/(const MLL& lhs, const MLL& rhs) { return lhs * mod(inverse(rhs.val, mdl), mdl); }
|
||||||
|
friend MLL operator%(const MLL& lhs, const MLL& rhs) { return mod(lhs.val - (lhs / rhs).val, mdl); }
|
||||||
|
friend bool operator==(const MLL& lhs, const MLL& rhs) { return lhs.val == rhs.val; }
|
||||||
|
friend bool operator!=(const MLL& lhs, const MLL& rhs) { return lhs.val != rhs.val; }
|
||||||
|
MLL& operator+=(const MLL& rhs) { return *this = *this + rhs; }
|
||||||
|
MLL& operator-=(const MLL& rhs) { return *this = *this - rhs; }
|
||||||
|
MLL& operator*=(const MLL& rhs) { return *this = *this * rhs; }
|
||||||
|
MLL& operator/=(const MLL& rhs) { return *this = *this / rhs; }
|
||||||
|
MLL& operator%=(const MLL& rhs) { return *this = *this % rhs; }
|
||||||
|
};
|
||||||
|
|
||||||
|
template <ll mdl>
|
||||||
|
ostream& operator<<(ostream& out, const MLL<mdl>& num) {
|
||||||
|
return out << num.val;
|
||||||
|
}
|
||||||
|
|
||||||
|
template <ll mdl>
|
||||||
|
istream& operator>>(istream& in, MLL<mdl>& num) {
|
||||||
|
return in >> num.val;
|
||||||
|
}
|
||||||
|
|
||||||
|
// miscancellous
|
||||||
|
template <typename T, typename U>
|
||||||
|
bool chmax(T& lhs, const U& rhs) {
|
||||||
|
bool ret = lhs < rhs;
|
||||||
|
if (ret) {
|
||||||
|
lhs = rhs;
|
||||||
|
}
|
||||||
|
return ret;
|
||||||
|
}
|
||||||
|
template <typename T, typename U>
|
||||||
|
bool chmin(T& lhs, const U& rhs) {
|
||||||
|
bool ret = lhs > rhs;
|
||||||
|
if (ret) {
|
||||||
|
lhs = rhs;
|
||||||
|
}
|
||||||
|
return ret;
|
||||||
|
}
|
||||||
|
|
||||||
|
#define functor(func) ([&](auto&&... val) \
|
||||||
|
noexcept(noexcept(func(std::forward<decltype(val)>(val)...))) -> decltype(auto) \
|
||||||
|
{return func(std::forward<decltype(val)>(val)...);})
|
||||||
|
#define expr(ret, ...) ([&] (__VA_ARGS__) { return (ret); })
|
||||||
|
template <typename Func, typename RandomIt> void sort_by_key(RandomIt first, RandomIt last, Func extractor) {
|
||||||
|
std::sort(first, last, [&] (auto&& a, auto&& b) { return std::less<>()(extractor(a), extractor(b)); });
|
||||||
|
}
|
||||||
|
template <typename Func, typename RandomIt, typename Compare> void sort_by_key(RandomIt first, RandomIt last, Func extractor, Compare comp) {
|
||||||
|
std::sort(first, last, [&] (auto&& a, auto&& b) { return comp(extractor(a), extractor(b)); });
|
||||||
|
}
|
||||||
|
template <typename T, typename U, typename Iterator_T, typename Iterator_U>
|
||||||
|
vector<pair<T, U>> zip(Iterator_T a_first, Iterator_T a_last, Iterator_U b_first, Iterator_U b_last) {
|
||||||
|
vector<pair<T, U>> res;
|
||||||
|
auto a_it = a_first;
|
||||||
|
auto b_it = b_first;
|
||||||
|
for (; not (a_it == a_last) and not (b_it == b_last); ++a_it, ++b_it) {
|
||||||
|
res.emplace_back(*a_it, *b_it);
|
||||||
|
}
|
||||||
|
return res;
|
||||||
|
}
|
||||||
|
template <typename T, typename U, typename Iterator_T, typename Iterator_U>
|
||||||
|
vector<pair<T, U>> zip_n(Iterator_T a_first, Iterator_U b_first, size_t n) {
|
||||||
|
vector<pair<T, U>> res;
|
||||||
|
if (n > 0) {
|
||||||
|
res.emplace_back(*a_first, *b_first);
|
||||||
|
for (size_t i = 1; i != n; ++i) {
|
||||||
|
res.emplace_back(*++a_first, *++b_first);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
return res;
|
||||||
|
}
|
||||||
|
template <typename T>
|
||||||
|
class ArithmeticIterator : bidirectional_iterator_tag {
|
||||||
|
public:
|
||||||
|
using difference_type = ptrdiff_t;
|
||||||
|
using value_type = T;
|
||||||
|
private:
|
||||||
|
value_type value;
|
||||||
|
public:
|
||||||
|
ArithmeticIterator(const T& value) : value(value) {}
|
||||||
|
value_type operator*() const { return value; }
|
||||||
|
ArithmeticIterator<T>& operator++() { ++value; return *this; }
|
||||||
|
ArithmeticIterator<T>& operator--() { --value; return *this; }
|
||||||
|
bool operator==(const ArithmeticIterator<T>& rhs) const { return value == rhs.value; }
|
||||||
|
};
|
||||||
|
template <typename T> vector<pair<int, T>> enumerate(const vector<T>& container) {
|
||||||
|
return zip<int, T>(ArithmeticIterator<int>(0), ArithmeticIterator<int>(INT_MAX), container.begin(), container.end());
|
||||||
|
}
|
||||||
|
#define initarray(init, N) (__initarray<decay<decltype(init)>::type, (N)>(init))
|
||||||
|
namespace detail {
|
||||||
|
template <typename T, std::size_t...Is>
|
||||||
|
constexpr std::array<T, sizeof...(Is)>
|
||||||
|
make_array(const T& value, std::index_sequence<Is...>) {
|
||||||
|
return {{(static_cast<void>(Is), value)...}};
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
template <typename T, std::size_t N>
|
||||||
|
constexpr std::array<T, N> __initarray(const T& value) {
|
||||||
|
return detail::make_array(value, std::make_index_sequence<N>());
|
||||||
|
}
|
||||||
|
/*******************************************************/
|
||||||
|
|
||||||
|
#define SINGLE_TEST_CASE
|
||||||
|
// #define DUMP_TEST_CASE 7219
|
||||||
|
// #define TOT_TEST_CASE 10000
|
||||||
|
|
||||||
|
void dump() {}
|
||||||
|
|
||||||
|
void dump_ignore() {}
|
||||||
|
|
||||||
|
void prep() {
|
||||||
|
}
|
||||||
|
|
||||||
|
constexpr int N = 5010;
|
||||||
|
ll dp[N][N][2];
|
||||||
|
|
||||||
|
// __attribute__((target("popcnt")))
|
||||||
|
void solve() {
|
||||||
|
memset(dp, 0x3f, sizeof(dp));
|
||||||
|
|
||||||
|
read(int, n, tot);
|
||||||
|
vector<int> a(n + 1), b(n + 1);
|
||||||
|
adj(ch, n);
|
||||||
|
|
||||||
|
for (int i = 1; i <= n; ++i) {
|
||||||
|
read(int, c, d);
|
||||||
|
a[i] = c, b[i] = c - d;
|
||||||
|
if (i >= 2) {
|
||||||
|
read(int, j);
|
||||||
|
edge(ch, i, j);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
vector<int> sz(n + 1);
|
||||||
|
{
|
||||||
|
auto dfs = [&] (auto dfs, int v, int pa) -> void {
|
||||||
|
sz[v] = 1;
|
||||||
|
for (auto&& u : ch[v]) {
|
||||||
|
if (u == pa) continue;
|
||||||
|
dfs(dfs, u, v);
|
||||||
|
sz[v] += sz[u];
|
||||||
|
}
|
||||||
|
};
|
||||||
|
dfs(dfs, 1, 0);
|
||||||
|
}
|
||||||
|
|
||||||
|
// vector dp(n + 1, vector(n + 1, vector<ll>(2, INFLL)));
|
||||||
|
{
|
||||||
|
auto dfs = [&] (auto dfs, int v, int pa) -> void {
|
||||||
|
for (auto&& u : ch[v]) {
|
||||||
|
if (u == pa) continue;
|
||||||
|
dfs(dfs, u, v);
|
||||||
|
}
|
||||||
|
int curr = 1;
|
||||||
|
dp[v][0][0] = 0;
|
||||||
|
dp[v][1][0] = a[v];
|
||||||
|
dp[v][1][1] = b[v];
|
||||||
|
for (auto&& u : ch[v]) {
|
||||||
|
if (u == pa) continue;
|
||||||
|
for (int j = curr; ~j; --j) {
|
||||||
|
for (int k = 0; k <= sz[u]; ++k) {
|
||||||
|
chmin(dp[v][j + k][0], dp[u][k][0] + dp[v][j][0]);
|
||||||
|
chmin(dp[v][j + k][1], min(dp[u][k][0], dp[u][k][1]) + dp[v][j][1]);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
curr += sz[u];
|
||||||
|
}
|
||||||
|
};
|
||||||
|
dfs(dfs, 1, 0);
|
||||||
|
}
|
||||||
|
|
||||||
|
for (int i = n; ~i; --i) {
|
||||||
|
if (min(dp[1][i][0], dp[1][i][1]) <= tot) {
|
||||||
|
cout << i << '\n';
|
||||||
|
return;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
}
|
||||||
|
|
||||||
|
int main() {
|
||||||
|
#if __cplusplus < 201402L or defined(_MSC_VER) and not defined(__clang__)
|
||||||
|
static_assert(false, "incompatible compiler variant detected.");
|
||||||
|
#endif
|
||||||
|
untie;
|
||||||
|
prep();
|
||||||
|
#ifdef SINGLE_TEST_CASE
|
||||||
|
solve();
|
||||||
|
#else
|
||||||
|
read(int, t);
|
||||||
|
for (int i = 0; i < t; ++i) {
|
||||||
|
#ifdef DUMP_TEST_CASE
|
||||||
|
if (t != (TOT_TEST_CASE)) {
|
||||||
|
solve();
|
||||||
|
} else if (i + 1 == (DUMP_TEST_CASE)) {
|
||||||
|
dump();
|
||||||
|
} else {
|
||||||
|
dump_ignore();
|
||||||
|
}
|
||||||
|
#else
|
||||||
|
solve();
|
||||||
|
#endif
|
||||||
|
}
|
||||||
|
#endif
|
||||||
|
}
|
|
@ -0,0 +1,636 @@
|
||||||
|
// #pragma GCC target("popcnt,lzcnt,abm,bmi,bmi2")
|
||||||
|
#pragma GCC optimize("Ofast,unroll-loops")
|
||||||
|
/************* This code requires C++17. ***************/
|
||||||
|
|
||||||
|
#include<bits/stdc++.h>
|
||||||
|
using namespace std;
|
||||||
|
|
||||||
|
/* macro helpers */
|
||||||
|
#define __NARGS(...) std::tuple_size<decltype(std::make_tuple(__VA_ARGS__))>::value
|
||||||
|
#define __DECOMPOSE_S(a, x) auto x = a;
|
||||||
|
#define __DECOMPOSE_N(a, ...) auto [__VA_ARGS__] = a;
|
||||||
|
constexpr void __() {}
|
||||||
|
#define __AS_PROCEDURE(...) __(); __VA_ARGS__; __()
|
||||||
|
#define __as_typeof(container) remove_reference<decltype(container)>::type
|
||||||
|
template <typename T> struct argument_type;
|
||||||
|
template <typename T, typename U> struct argument_type<T(U)> { using type = U; };
|
||||||
|
|
||||||
|
/* type aliases */
|
||||||
|
#if LONG_LONG_MAX != INT64_MAX
|
||||||
|
using ll = int64_t;
|
||||||
|
using ull = uint64_t;
|
||||||
|
#else
|
||||||
|
using ll = long long;
|
||||||
|
using ull = unsigned long long;
|
||||||
|
#endif
|
||||||
|
using int128 = __int128_t;
|
||||||
|
using uint128 = __uint128_t;
|
||||||
|
using ld = __float128; // up to 1e-9 precision in binary search
|
||||||
|
using pii = pair<int, int>; using pil = pair<int, ll>; using pid = pair<int, ld>;
|
||||||
|
using pli = pair<ll, int>; using pll = pair<ll, ll>; using pld = pair<ll, ld>;
|
||||||
|
using pdi = pair<ld, int>; using pdl = pair<ld, ll>; using pdd = pair<ld, ld>;
|
||||||
|
using tiii = tuple<int, int, int>; using tiil = tuple<int, int, ll>; using tiid = tuple<int, int, ld>;
|
||||||
|
using tili = tuple<int, ll, int>; using till = tuple<int, ll, ll>; using tild = tuple<int, ll, ld>;
|
||||||
|
using tidi = tuple<int, ld, int>; using tidl = tuple<int, ld, ll>; using tidd = tuple<int, ld, ld>;
|
||||||
|
using tlii = tuple<ll, int, int>; using tlil = tuple<ll, int, ll>; using tlid = tuple<ll, int, ld>;
|
||||||
|
using tlli = tuple<ll, ll, int>; using tlll = tuple<ll, ll, ll>; using tlld = tuple<ll, ll, ld>;
|
||||||
|
using tldi = tuple<ll, ld, int>; using tldl = tuple<ll, ld, ll>; using tldd = tuple<ll, ld, ld>;
|
||||||
|
using tdii = tuple<ld, int, int>; using tdil = tuple<ld, int, ll>; using tdid = tuple<ld, int, ld>;
|
||||||
|
using tdli = tuple<ld, ll, int>; using tdll = tuple<ld, ll, ll>; using tdld = tuple<ld, ll, ld>;
|
||||||
|
using tddi = tuple<ld, ld, int>; using tddl = tuple<ld, ld, ll>; using tddd = tuple<ld, ld, ld>;
|
||||||
|
template <typename T> using max_heap = priority_queue<T>;
|
||||||
|
template <typename T> using min_heap = priority_queue<T, vector<T>, greater<>>;
|
||||||
|
template <typename T> using oi = ostream_iterator<T>;
|
||||||
|
template <typename T> using ii = istream_iterator<T>;
|
||||||
|
|
||||||
|
/* constants */
|
||||||
|
constexpr int INF = 0x3f3f3f3f;
|
||||||
|
constexpr ll INFLL = 0x3f3f3f3f3f3f3f3fLL;
|
||||||
|
constexpr ll MDL = 1e9 + 7;
|
||||||
|
constexpr ll PRIME = 998'244'353;
|
||||||
|
constexpr ll PRIMELL = 901017227882342239LL;
|
||||||
|
constexpr ll MDL1 = 8784491;
|
||||||
|
constexpr ll MDL2 = PRIME;
|
||||||
|
constexpr int128 INT128_MAX = numeric_limits<int128>::max();
|
||||||
|
constexpr uint128 UINT128_MAX = numeric_limits<uint128>::max();
|
||||||
|
constexpr int128 INT128_MIN = numeric_limits<int128>::min();
|
||||||
|
constexpr uint128 UINT128_MIN = numeric_limits<uint128>::min();
|
||||||
|
|
||||||
|
/* random */
|
||||||
|
|
||||||
|
mt19937_64 rd(chrono::duration_cast<chrono::milliseconds>(chrono::system_clock::now().time_since_epoch()).count());
|
||||||
|
|
||||||
|
/* bit-wise operations */
|
||||||
|
#define lowbit(x) ((x) & -(x))
|
||||||
|
#define popcount(x) (__builtin_popcountll(ll(x)))
|
||||||
|
#define parity(x) (__builtin_parityll(ll(x)))
|
||||||
|
#define msp(x) (63LL - __builtin_clzll(ll(x)))
|
||||||
|
#define lsp(x) (__builtin_ctzll(ll(x)))
|
||||||
|
|
||||||
|
/* arithmetic operations */
|
||||||
|
#define mod(x, y) ((((x) % (y)) + (y)) % (y))
|
||||||
|
|
||||||
|
/* fast pairs */
|
||||||
|
#define upair ull
|
||||||
|
#define umake(x, y) (ull(x) << 32 | (ull(y) & ((1ULL << 32) - 1)))
|
||||||
|
#define u1(p) ((p) >> 32)
|
||||||
|
#define u2(p) ((p) & ((1ULL << 32) - 1))
|
||||||
|
#define ult std::less<upair>
|
||||||
|
#define ugt std::greater<upair>
|
||||||
|
|
||||||
|
#define ipair ull
|
||||||
|
#define imake(x, y) (umake(x, y))
|
||||||
|
#define i1(p) (int(u1(ll(p))))
|
||||||
|
#define i2(p) (ll(u2(p) << 32) >> 32)
|
||||||
|
struct ilt {
|
||||||
|
bool operator()(const ipair& a, const ipair& b) const {
|
||||||
|
if (i1(a) == i1(b)) return i2(a) < i2(b);
|
||||||
|
else return i1(a) < i1(b);
|
||||||
|
}
|
||||||
|
};
|
||||||
|
struct igt {
|
||||||
|
bool operator()(const ipair& a, const ipair& b) const {
|
||||||
|
if (i1(a) == i1(b)) return i2(a) > i2(b);
|
||||||
|
else return i1(a) > i1(b);
|
||||||
|
}
|
||||||
|
};
|
||||||
|
|
||||||
|
/* conditions */
|
||||||
|
#define loop while (1)
|
||||||
|
#define if_or(var, val) if (!((var) == (val))) (var) = (val); else
|
||||||
|
#define continue_or(var, val) __AS_PROCEDURE(if ((var) == (val)) continue; (var) = (val);)
|
||||||
|
#define break_or(var, val) __AS_PROCEDURE(if ((var) == (val)) break; (var) = (val);)
|
||||||
|
|
||||||
|
/* hash */
|
||||||
|
struct safe_hash {
|
||||||
|
// https://codeforces.com/blog/entry/62393
|
||||||
|
static uint64_t splitmix64(uint64_t x) {
|
||||||
|
// http://xorshift.di.unimi.it/splitmix64.c
|
||||||
|
x += 0x9e3779b97f4a7c15;
|
||||||
|
x = (x ^ (x >> 30)) * 0xbf58476d1ce4e5b9;
|
||||||
|
x = (x ^ (x >> 27)) * 0x94d049bb133111eb;
|
||||||
|
return x ^ (x >> 31);
|
||||||
|
}
|
||||||
|
|
||||||
|
size_t operator()(uint64_t x) const {
|
||||||
|
static const uint64_t FIXED_RANDOM = chrono::steady_clock::now().time_since_epoch().count();
|
||||||
|
return splitmix64(x + FIXED_RANDOM);
|
||||||
|
}
|
||||||
|
};
|
||||||
|
|
||||||
|
struct pair_hash {
|
||||||
|
template <typename T, typename U>
|
||||||
|
size_t operator()(const pair<T, U>& a) const {
|
||||||
|
auto hash1 = safe_hash()(a.first);
|
||||||
|
auto hash2 = safe_hash()(a.second);
|
||||||
|
if (hash1 != hash2) {
|
||||||
|
return hash1 ^ hash2;
|
||||||
|
}
|
||||||
|
return hash1;
|
||||||
|
}
|
||||||
|
};
|
||||||
|
|
||||||
|
uniform_int_distribution<mt19937::result_type> dist(PRIME);
|
||||||
|
const size_t __array_hash_b = 31, __array_hash_mdl1 = dist(rd), __array_hash_mdl2 = dist(rd);
|
||||||
|
struct array_hash {
|
||||||
|
safe_hash hasher;
|
||||||
|
template <typename Sequence>
|
||||||
|
size_t operator()(const Sequence& arr) const {
|
||||||
|
size_t pw1 = 1, pw2 = 1;
|
||||||
|
size_t res1 = 0, res2 = 0;
|
||||||
|
for (auto&& x : arr) {
|
||||||
|
auto h = hasher(x);
|
||||||
|
res1 = (res1 + h * pw1) % __array_hash_mdl1;
|
||||||
|
res2 = (res2 + h * pw2) % __array_hash_mdl2;
|
||||||
|
pw1 = (pw1 * __array_hash_b) % __array_hash_mdl1;
|
||||||
|
pw2 = (pw2 * __array_hash_b) % __array_hash_mdl2;
|
||||||
|
}
|
||||||
|
return res1 + res2;
|
||||||
|
}
|
||||||
|
};
|
||||||
|
|
||||||
|
/* build data structures */
|
||||||
|
#define faster(um) __AS_PROCEDURE((um).reserve(1024); (um).max_load_factor(0.25);)
|
||||||
|
#define unordered_counter(from, to) __AS_PROCEDURE(unordered_map<__as_typeof(from), size_t, safe_hash> to; for (auto&& x : from) ++to[x];)
|
||||||
|
#define counter(from, to, cmp) __AS_PROCEDURE(map<__as_typeof(from), size_t, cmp> to; for (auto&& x : from) ++to[x];)
|
||||||
|
#define adj(ch, n) __AS_PROCEDURE(vector<vector<int>> ch((n) + 1);)
|
||||||
|
#define edge(ch, u, v) __AS_PROCEDURE(ch[u].push_back(v), ch[v].push_back(u);)
|
||||||
|
#define edgew(ch, u, v, ...) __AS_PROCEDURE(ch[u].emplace_back(v, __VA_ARGS__), ch[v].emplace_back(u, __VA_ARGS__);)
|
||||||
|
#define Edge(ch, u, v) __AS_PROCEDURE(ch[u].push_back(v);)
|
||||||
|
#define Edgew(ch, u, v, ...) __AS_PROCEDURE(ch[u].emplace_back(v, __VA_ARGS__);)
|
||||||
|
template <typename T, typename Iterator> pair<size_t, map<T, size_t>> discretize(Iterator __first, Iterator __last) {
|
||||||
|
set<T> st(__first, __last);
|
||||||
|
size_t N = 0;
|
||||||
|
map<T, size_t> mp;
|
||||||
|
for (auto&& x : st) mp[x] = ++N;
|
||||||
|
return {N, mp};
|
||||||
|
}
|
||||||
|
template <typename T, typename Iterator> pair<size_t, unordered_map<T, size_t, safe_hash>> unordered_discretize(Iterator __first, Iterator __last) {
|
||||||
|
set<T> st(__first, __last);
|
||||||
|
size_t N = 0;
|
||||||
|
unordered_map<T, size_t, safe_hash> mp;
|
||||||
|
for (auto&& x : st) mp[x] = ++N;
|
||||||
|
return {N, mp};
|
||||||
|
}
|
||||||
|
|
||||||
|
/* io */
|
||||||
|
#define untie __AS_PROCEDURE(ios_base::sync_with_stdio(0), cin.tie(NULL))
|
||||||
|
|
||||||
|
// add declarations to avoid circular dependency
|
||||||
|
template<typename T, typename U> istream& operator>>(istream&, pair<T, U>&);
|
||||||
|
template<typename T, typename U> ostream& operator<<(ostream&, const pair<T, U>&);
|
||||||
|
template<typename T, size_t N> istream& operator>>(istream&, array<T, N>&);
|
||||||
|
template <typename T, size_t N> ostream& operator<<(ostream&, const array<T, N>&);
|
||||||
|
template<typename Char, typename Traits, typename... Args>
|
||||||
|
decltype(auto) operator<<(std::basic_ostream<Char, Traits>&, const std::tuple<Args...>&);
|
||||||
|
template<typename T> ostream& operator<<(ostream&, const vector<T>&);
|
||||||
|
std::ostream& operator<<(std::ostream&, const int128&);
|
||||||
|
|
||||||
|
template<typename T, typename U> istream& operator>>(istream& in, pair<T, U>& p) {
|
||||||
|
return in >> p.first >> p.second;
|
||||||
|
}
|
||||||
|
template<typename T, typename U> ostream& operator<<(ostream& out, const pair<T, U>& p) {
|
||||||
|
out << "{" << p.first << ", " << p.second << "}";
|
||||||
|
return out;
|
||||||
|
}
|
||||||
|
template<typename T, size_t N> istream& operator>>(istream& in, array<T, N>& a) {
|
||||||
|
for (size_t i = 0; i < N; ++i) in >> a[i];
|
||||||
|
return in;
|
||||||
|
}
|
||||||
|
template <typename T, size_t N> ostream& operator<<(ostream& out, const array<T, N>& a) {
|
||||||
|
for (auto&& i : a) out << i << ' ';
|
||||||
|
return out;
|
||||||
|
}
|
||||||
|
template<typename Char, typename Traits, typename Tuple, std::size_t... Index>
|
||||||
|
void print_tuple_impl(std::basic_ostream<Char, Traits>& os, const Tuple& t, std::index_sequence<Index...>) {
|
||||||
|
using swallow = int[]; // guaranties left to right order
|
||||||
|
(void)swallow { 0, (void(os << (Index == 0 ? "" : ", ") << std::get<Index>(t)), 0)... };
|
||||||
|
}
|
||||||
|
template<typename Char, typename Traits, typename... Args>
|
||||||
|
decltype(auto) operator<<(std::basic_ostream<Char, Traits>& os, const std::tuple<Args...>& t) {
|
||||||
|
os << "{";
|
||||||
|
print_tuple_impl(os, t, std::index_sequence_for<Args...>{});
|
||||||
|
return os << "}";
|
||||||
|
}
|
||||||
|
template<typename T> ostream& operator<<(ostream& out, const vector<T>& vec) {
|
||||||
|
for (auto&& i : vec) out << i << ' ';
|
||||||
|
return out;
|
||||||
|
}
|
||||||
|
std::ostream& operator<<(std::ostream& dest, const int128& value) {
|
||||||
|
// https://stackoverflow.com/a/25115163/23881100
|
||||||
|
std::ostream::sentry s( dest );
|
||||||
|
if ( s ) {
|
||||||
|
uint128 tmp = value < 0 ? -value : value;
|
||||||
|
char buffer[ 128 ];
|
||||||
|
char* d = std::end( buffer );
|
||||||
|
do {
|
||||||
|
-- d;
|
||||||
|
*d = "0123456789"[ tmp % 10 ];
|
||||||
|
tmp /= 10;
|
||||||
|
} while ( tmp != 0 );
|
||||||
|
if ( value < 0 ) {
|
||||||
|
-- d;
|
||||||
|
*d = '-';
|
||||||
|
}
|
||||||
|
int len = std::end( buffer ) - d;
|
||||||
|
if ( dest.rdbuf()->sputn( d, len ) != len ) {
|
||||||
|
dest.setstate( std::ios_base::badbit );
|
||||||
|
}
|
||||||
|
}
|
||||||
|
return dest;
|
||||||
|
}
|
||||||
|
template<typename T> void __read(T& x) { cin >> x; }
|
||||||
|
template<typename T, typename... U> void __read(T& x, U&... args) { cin >> x; __read(args...); }
|
||||||
|
#define read(t, ...) __AS_PROCEDURE(argument_type<void(t)>::type __VA_ARGS__; __read(__VA_ARGS__);)
|
||||||
|
#define readvec(t, a, n) __AS_PROCEDURE(vector<argument_type<void(t)>::type> a(n); for (auto& x : (a)) cin >> x;)
|
||||||
|
#define readvec1(t, a, n) __AS_PROCEDURE(vector<argument_type<void(t)>::type> a((n) + 1); copy_n(ii<argument_type<void(t)>::type>(cin), (n), (a).begin() + 1);)
|
||||||
|
#define putvec(a) __AS_PROCEDURE(copy((a).begin(), (a).end(), oi<__as_typeof(a)::value_type>(cout, " ")); cout << endl;)
|
||||||
|
#define putvec1(a) __AS_PROCEDURE(copy((a).begin() + 1, (a).end(), oi<__as_typeof(a)::value_type>(cout, " ")); cout << endl;)
|
||||||
|
#define putvec_eol(a) __AS_PROCEDURE(copy((a).begin(), (a).end(), oi<__as_typeof(a)::value_type>(cout, "\n"));)
|
||||||
|
#define putvec1_eol(a) __AS_PROCEDURE(copy((a).begin() + 1, (a).end(), oi<__as_typeof(a)::value_type>(cout, "\n"));)
|
||||||
|
#define debug(x) __AS_PROCEDURE(cerr << #x" = " << (x) << endl;)
|
||||||
|
#define debugvec(a) __AS_PROCEDURE(cerr << #a" = "; for (auto&& x : (a)) cerr << x << ' '; cerr << endl;)
|
||||||
|
#define deb(...) debug(make_tuple(__VA_ARGS__))
|
||||||
|
|
||||||
|
/* pops */
|
||||||
|
template <typename Container>
|
||||||
|
inline auto poptop(Container& q) {
|
||||||
|
auto ret = q.top();
|
||||||
|
q.pop();
|
||||||
|
return ret;
|
||||||
|
}
|
||||||
|
template <typename Container>
|
||||||
|
inline auto popback(Container& q) {
|
||||||
|
auto ret = q.back();
|
||||||
|
q.pop_back();
|
||||||
|
return ret;
|
||||||
|
}
|
||||||
|
template <typename Container>
|
||||||
|
inline auto popfront(Container& q) {
|
||||||
|
auto ret = q.front();
|
||||||
|
q.pop_front();
|
||||||
|
return ret;
|
||||||
|
}
|
||||||
|
|
||||||
|
/* math */
|
||||||
|
template <typename return_t>
|
||||||
|
return_t qpow(ll b, ll p) {
|
||||||
|
if (b == 0 and p != 0) return 0;
|
||||||
|
if (p == 0) return 1;
|
||||||
|
return_t half = qpow<return_t>(b, p / 2);
|
||||||
|
if (p % 2 == 1) return half * half * b;
|
||||||
|
else return half * half;
|
||||||
|
}
|
||||||
|
|
||||||
|
// dynamic modulus
|
||||||
|
ll qpow(ll b, ll p, ll mod) {
|
||||||
|
if (b == 0 and p != 0) return 0;
|
||||||
|
if (p == 0) return 1;
|
||||||
|
ll half = qpow(b, p / 2, mod);
|
||||||
|
if (p % 2 == 1) return (int128(half) * half % mod) * b % mod;
|
||||||
|
else return half * half % mod;
|
||||||
|
}
|
||||||
|
|
||||||
|
|
||||||
|
#pragma GCC diagnostic push
|
||||||
|
#pragma GCC diagnostic ignored "-Wparentheses"
|
||||||
|
// Accurately find `i` 'th root of `n` (taking the floor)
|
||||||
|
inline ll root(ll n, ll i) {
|
||||||
|
ll l = 0, r = pow(LLONG_MAX, (long double)(1) / i);
|
||||||
|
while (l < r) {
|
||||||
|
ll mid = l + r + 1 >> 1;
|
||||||
|
if (qpow<int128>(mid, i) <= n) {
|
||||||
|
l = mid;
|
||||||
|
} else {
|
||||||
|
r = mid - 1;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
return l;
|
||||||
|
}
|
||||||
|
#pragma GCC diagnostic pop
|
||||||
|
|
||||||
|
|
||||||
|
#define comb(n, k) ((n) < 0 or (k) < 0 or (n) < (k) ? 0 : fact[n] / fact[k] / fact[(n) - (k)])
|
||||||
|
#define fastcomb(n, k) ((n) < 0 or (k) < 0 or (n) < (k) ? 0 : fact[n] * factrev[k] * factrev[(n) - (k)])
|
||||||
|
|
||||||
|
__attribute__((target("lzcnt")))
|
||||||
|
constexpr inline int lg2(ll x) { return x == 0 ? -1 : sizeof(ll) * 8 - 1 - __builtin_clzll(x); }
|
||||||
|
|
||||||
|
template <typename T>
|
||||||
|
T mygcd(T a, T b) { return b == 0 ? a : mygcd(b, a % b); }
|
||||||
|
|
||||||
|
void __exgcd(ll a, ll b, ll& x, ll& y) {
|
||||||
|
if (b == 0) {
|
||||||
|
x = 1, y = 0;
|
||||||
|
return;
|
||||||
|
}
|
||||||
|
__exgcd(b, a % b, y, x);
|
||||||
|
y -= a / b * x;
|
||||||
|
}
|
||||||
|
|
||||||
|
ll inverse(ll a, ll b) {
|
||||||
|
ll x, y;
|
||||||
|
__exgcd(a, b, x, y);
|
||||||
|
return mod(x, b);
|
||||||
|
}
|
||||||
|
|
||||||
|
vector<tuple<int, int, ll>> decompose(ll x) {
|
||||||
|
// return (factor, count, factor ** count)
|
||||||
|
vector<tuple<int, int, ll>> res;
|
||||||
|
for (int i = 2; i * i <= x; i++) {
|
||||||
|
if (x % i == 0) {
|
||||||
|
int cnt = 0;
|
||||||
|
ll pw = 1;
|
||||||
|
while (x % i == 0) ++cnt, x /= i, pw *= i;
|
||||||
|
res.emplace_back(i, cnt, pw);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
if (x != 1) {
|
||||||
|
res.emplace_back(x, 1, x);
|
||||||
|
}
|
||||||
|
return res;
|
||||||
|
}
|
||||||
|
|
||||||
|
vector<pii> decompose_prime(int N) {
|
||||||
|
// return (factor, count)
|
||||||
|
vector<pii> result;
|
||||||
|
for (int i = 2; i * i <= N; i++) {
|
||||||
|
if (N % i == 0) {
|
||||||
|
int cnt = 0;
|
||||||
|
while (N % i == 0) N /= i, ++cnt;
|
||||||
|
result.emplace_back(i, cnt);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
if (N != 1) {
|
||||||
|
result.emplace_back(N, 1);
|
||||||
|
}
|
||||||
|
return result;
|
||||||
|
}
|
||||||
|
|
||||||
|
/* string algorithms */
|
||||||
|
vector<int> calc_next(string t) { // pi function of t
|
||||||
|
int n = (int)t.length();
|
||||||
|
vector<int> pi(n);
|
||||||
|
for (int i = 1; i < n; i++) {
|
||||||
|
int j = pi[i - 1];
|
||||||
|
while (j > 0 && t[i] != t[j]) j = pi[j - 1];
|
||||||
|
if (t[i] == t[j]) j++;
|
||||||
|
pi[i] = j;
|
||||||
|
}
|
||||||
|
return pi;
|
||||||
|
}
|
||||||
|
vector<int> calc_z(string t) { // z function of t
|
||||||
|
int m = t.length();
|
||||||
|
vector<int> z;
|
||||||
|
z.push_back(m);
|
||||||
|
pair<int, int> prev = {1, -1};
|
||||||
|
for (int i = 1; i < m; ++i) {
|
||||||
|
if (z[i - prev.first] + i <= prev.second) {
|
||||||
|
z.push_back(z[i - prev.first]);
|
||||||
|
} else {
|
||||||
|
int j = max(i, prev.second + 1);
|
||||||
|
while (j < m && t[j] == t[j - i]) ++j;
|
||||||
|
z.push_back(j - i);
|
||||||
|
prev = {i, j - 1};
|
||||||
|
}
|
||||||
|
}
|
||||||
|
return z;
|
||||||
|
}
|
||||||
|
vector<int> kmp(const string& s, const string& t) { // find all t in s
|
||||||
|
string cur = t + '#' + s;
|
||||||
|
int sz1 = s.size(), sz2 = t.size();
|
||||||
|
vector<int> v;
|
||||||
|
vector<int> lps = calc_next(cur);
|
||||||
|
for (int i = sz2 + 1; i <= sz1 + sz2; i++) {
|
||||||
|
if (lps[i] == sz2) v.push_back(i - 2 * sz2);
|
||||||
|
}
|
||||||
|
return v;
|
||||||
|
}
|
||||||
|
int period(const string& s) { // find the length of shortest recurring period
|
||||||
|
int n = s.length();
|
||||||
|
auto z = calc_z(s);
|
||||||
|
for (int i = 1; i <= n / 2; ++i) {
|
||||||
|
if (n % i == 0 && z[i] == n - i) {
|
||||||
|
return i;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
return n;
|
||||||
|
}
|
||||||
|
|
||||||
|
/* modular arithmetic */
|
||||||
|
template <ll mdl> struct MLL {
|
||||||
|
ll val;
|
||||||
|
MLL(ll v = 0) : val(mod(v, mdl)) {}
|
||||||
|
MLL(const MLL<mdl>& other) : val(other.val) {}
|
||||||
|
friend MLL operator+(const MLL& lhs, const MLL& rhs) { return mod(lhs.val + rhs.val, mdl); }
|
||||||
|
friend MLL operator-(const MLL& lhs, const MLL& rhs) { return mod(lhs.val - rhs.val, mdl); }
|
||||||
|
friend MLL operator*(const MLL& lhs, const MLL& rhs) { return mod(int128(lhs.val) * rhs.val, mdl); }
|
||||||
|
friend MLL operator/(const MLL& lhs, const MLL& rhs) { return lhs * mod(inverse(rhs.val, mdl), mdl); }
|
||||||
|
friend MLL operator%(const MLL& lhs, const MLL& rhs) { return mod(lhs.val - (lhs / rhs).val, mdl); }
|
||||||
|
friend bool operator==(const MLL& lhs, const MLL& rhs) { return lhs.val == rhs.val; }
|
||||||
|
friend bool operator!=(const MLL& lhs, const MLL& rhs) { return lhs.val != rhs.val; }
|
||||||
|
MLL& operator+=(const MLL& rhs) { return *this = *this + rhs; }
|
||||||
|
MLL& operator-=(const MLL& rhs) { return *this = *this - rhs; }
|
||||||
|
MLL& operator*=(const MLL& rhs) { return *this = *this * rhs; }
|
||||||
|
MLL& operator/=(const MLL& rhs) { return *this = *this / rhs; }
|
||||||
|
MLL& operator%=(const MLL& rhs) { return *this = *this % rhs; }
|
||||||
|
};
|
||||||
|
|
||||||
|
template <ll mdl>
|
||||||
|
ostream& operator<<(ostream& out, const MLL<mdl>& num) {
|
||||||
|
return out << num.val;
|
||||||
|
}
|
||||||
|
|
||||||
|
template <ll mdl>
|
||||||
|
istream& operator>>(istream& in, MLL<mdl>& num) {
|
||||||
|
return in >> num.val;
|
||||||
|
}
|
||||||
|
|
||||||
|
// miscancellous
|
||||||
|
template <typename T, typename U>
|
||||||
|
bool chmax(T& lhs, const U& rhs) {
|
||||||
|
bool ret = lhs < rhs;
|
||||||
|
if (ret) {
|
||||||
|
lhs = rhs;
|
||||||
|
}
|
||||||
|
return ret;
|
||||||
|
}
|
||||||
|
template <typename T, typename U>
|
||||||
|
bool chmin(T& lhs, const U& rhs) {
|
||||||
|
bool ret = lhs > rhs;
|
||||||
|
if (ret) {
|
||||||
|
lhs = rhs;
|
||||||
|
}
|
||||||
|
return ret;
|
||||||
|
}
|
||||||
|
|
||||||
|
#define functor(func) ([&](auto&&... val) \
|
||||||
|
noexcept(noexcept(func(std::forward<decltype(val)>(val)...))) -> decltype(auto) \
|
||||||
|
{return func(std::forward<decltype(val)>(val)...);})
|
||||||
|
#define expr(ret, ...) ([&] (__VA_ARGS__) { return (ret); })
|
||||||
|
template <typename Func, typename RandomIt> void sort_by_key(RandomIt first, RandomIt last, Func extractor) {
|
||||||
|
std::sort(first, last, [&] (auto&& a, auto&& b) { return std::less<>()(extractor(a), extractor(b)); });
|
||||||
|
}
|
||||||
|
template <typename Func, typename RandomIt, typename Compare> void sort_by_key(RandomIt first, RandomIt last, Func extractor, Compare comp) {
|
||||||
|
std::sort(first, last, [&] (auto&& a, auto&& b) { return comp(extractor(a), extractor(b)); });
|
||||||
|
}
|
||||||
|
template <typename T, typename U, typename Iterator_T, typename Iterator_U>
|
||||||
|
vector<pair<T, U>> zip(Iterator_T a_first, Iterator_T a_last, Iterator_U b_first, Iterator_U b_last) {
|
||||||
|
vector<pair<T, U>> res;
|
||||||
|
auto a_it = a_first;
|
||||||
|
auto b_it = b_first;
|
||||||
|
for (; not (a_it == a_last) and not (b_it == b_last); ++a_it, ++b_it) {
|
||||||
|
res.emplace_back(*a_it, *b_it);
|
||||||
|
}
|
||||||
|
return res;
|
||||||
|
}
|
||||||
|
template <typename T, typename U, typename Iterator_T, typename Iterator_U>
|
||||||
|
vector<pair<T, U>> zip_n(Iterator_T a_first, Iterator_U b_first, size_t n) {
|
||||||
|
vector<pair<T, U>> res;
|
||||||
|
if (n > 0) {
|
||||||
|
res.emplace_back(*a_first, *b_first);
|
||||||
|
for (size_t i = 1; i != n; ++i) {
|
||||||
|
res.emplace_back(*++a_first, *++b_first);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
return res;
|
||||||
|
}
|
||||||
|
template <typename T>
|
||||||
|
class ArithmeticIterator : bidirectional_iterator_tag {
|
||||||
|
public:
|
||||||
|
using difference_type = ptrdiff_t;
|
||||||
|
using value_type = T;
|
||||||
|
private:
|
||||||
|
value_type value;
|
||||||
|
public:
|
||||||
|
ArithmeticIterator(const T& value) : value(value) {}
|
||||||
|
value_type operator*() const { return value; }
|
||||||
|
ArithmeticIterator<T>& operator++() { ++value; return *this; }
|
||||||
|
ArithmeticIterator<T>& operator--() { --value; return *this; }
|
||||||
|
bool operator==(const ArithmeticIterator<T>& rhs) const { return value == rhs.value; }
|
||||||
|
};
|
||||||
|
template <typename T> vector<pair<int, T>> enumerate(const vector<T>& container) {
|
||||||
|
return zip<int, T>(ArithmeticIterator<int>(0), ArithmeticIterator<int>(INT_MAX), container.begin(), container.end());
|
||||||
|
}
|
||||||
|
#define initarray(init, N) (__initarray<decay<decltype(init)>::type, (N)>(init))
|
||||||
|
namespace detail {
|
||||||
|
template <typename T, std::size_t...Is>
|
||||||
|
constexpr std::array<T, sizeof...(Is)>
|
||||||
|
make_array(const T& value, std::index_sequence<Is...>) {
|
||||||
|
return {{(static_cast<void>(Is), value)...}};
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
template <typename T, std::size_t N>
|
||||||
|
constexpr std::array<T, N> __initarray(const T& value) {
|
||||||
|
return detail::make_array(value, std::make_index_sequence<N>());
|
||||||
|
}
|
||||||
|
/*******************************************************/
|
||||||
|
|
||||||
|
#define SINGLE_TEST_CASE
|
||||||
|
// #define DUMP_TEST_CASE 7219
|
||||||
|
// #define TOT_TEST_CASE 10000
|
||||||
|
|
||||||
|
void dump() {}
|
||||||
|
|
||||||
|
void dump_ignore() {}
|
||||||
|
|
||||||
|
void prep() {
|
||||||
|
}
|
||||||
|
|
||||||
|
// __attribute__((target("popcnt")))
|
||||||
|
void solve() {
|
||||||
|
read(int, n);
|
||||||
|
read(ll, k);
|
||||||
|
readvec(int, a, n);
|
||||||
|
|
||||||
|
map<int, vector<int>, greater<>> events;
|
||||||
|
for (int i = 0; i < n; ++i) {
|
||||||
|
int x = a[i];
|
||||||
|
for (ll l = 1, r; l <= x; l = r + 1) {
|
||||||
|
ll val = (x + l - 1) / l;
|
||||||
|
r = val == 1 ? x : (x - 1) / (val - 1);
|
||||||
|
if (val > 1) {
|
||||||
|
events[r].emplace_back(i);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
int mx = *max_element(a.begin(), a.end());
|
||||||
|
ll sum = accumulate(a.begin(), a.end(), ll(0));
|
||||||
|
ll tot = ll(1) * mx * n - sum;
|
||||||
|
|
||||||
|
if (tot <= k) {
|
||||||
|
ll extra = (k - tot) / n;
|
||||||
|
cout << mx + extra << '\n';
|
||||||
|
// debug(1);
|
||||||
|
return;
|
||||||
|
}
|
||||||
|
|
||||||
|
vector<int> last(n, mx + 1);
|
||||||
|
tot = ll(1) * (mx + 1) * n;
|
||||||
|
|
||||||
|
vector<int> diff(n, 1);
|
||||||
|
ll tot_diff = n;
|
||||||
|
|
||||||
|
int lastpos = mx + 1;
|
||||||
|
while (events.size()) {
|
||||||
|
auto [r, v] = *events.begin();
|
||||||
|
// deb(r, v);
|
||||||
|
tot -= tot_diff * (lastpos - r);
|
||||||
|
lastpos = r;
|
||||||
|
for (auto&& i : v) {
|
||||||
|
tot -= (diff[i] == 1 ? last[i] : ll(1) * diff[i] * last[i]) - ll(1) * diff[i] * (last[i] - r);
|
||||||
|
tot_diff -= diff[i];
|
||||||
|
diff[i] = (a[i] + r - 1) / r;
|
||||||
|
tot_diff += diff[i];
|
||||||
|
tot += ll(1) * diff[i] * r;
|
||||||
|
last[i] = r;
|
||||||
|
}
|
||||||
|
// debug(tot);
|
||||||
|
// debug(diff);
|
||||||
|
events.erase(events.begin());
|
||||||
|
// debugvec(events);
|
||||||
|
if (events.empty()) {
|
||||||
|
cout << 1 << '\n';
|
||||||
|
return;
|
||||||
|
} else if (tot_diff != 0) {
|
||||||
|
int nxt = events.begin()->first;
|
||||||
|
ll t = (tot - sum - k + tot_diff - 1) / tot_diff;
|
||||||
|
if (r - t > nxt) {
|
||||||
|
// deb(r, t, nxt);
|
||||||
|
cout << r - t << '\n';
|
||||||
|
return;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
assert(false);
|
||||||
|
|
||||||
|
}
|
||||||
|
|
||||||
|
int main() {
|
||||||
|
#if __cplusplus < 201402L or defined(_MSC_VER) and not defined(__clang__)
|
||||||
|
static_assert(false, "incompatible compiler variant detected.");
|
||||||
|
#endif
|
||||||
|
untie;
|
||||||
|
prep();
|
||||||
|
#ifdef SINGLE_TEST_CASE
|
||||||
|
solve();
|
||||||
|
#else
|
||||||
|
read(int, t);
|
||||||
|
for (int i = 0; i < t; ++i) {
|
||||||
|
#ifdef DUMP_TEST_CASE
|
||||||
|
if (t != (TOT_TEST_CASE)) {
|
||||||
|
solve();
|
||||||
|
} else if (i + 1 == (DUMP_TEST_CASE)) {
|
||||||
|
dump();
|
||||||
|
} else {
|
||||||
|
dump_ignore();
|
||||||
|
}
|
||||||
|
#else
|
||||||
|
solve();
|
||||||
|
#endif
|
||||||
|
}
|
||||||
|
#endif
|
||||||
|
}
|
148
src/bin/d.cc
148
src/bin/d.cc
|
@ -25,7 +25,7 @@ using ull = unsigned long long;
|
||||||
#endif
|
#endif
|
||||||
using int128 = __int128_t;
|
using int128 = __int128_t;
|
||||||
using uint128 = __uint128_t;
|
using uint128 = __uint128_t;
|
||||||
using ld = long double;
|
using ld = __float128; // up to 1e-9 precision in binary search
|
||||||
using pii = pair<int, int>; using pil = pair<int, ll>; using pid = pair<int, ld>;
|
using pii = pair<int, int>; using pil = pair<int, ll>; using pid = pair<int, ld>;
|
||||||
using pli = pair<ll, int>; using pll = pair<ll, ll>; using pld = pair<ll, ld>;
|
using pli = pair<ll, int>; using pll = pair<ll, ll>; using pld = pair<ll, ld>;
|
||||||
using pdi = pair<ld, int>; using pdl = pair<ld, ll>; using pdd = pair<ld, ld>;
|
using pdi = pair<ld, int>; using pdl = pair<ld, ll>; using pdd = pair<ld, ld>;
|
||||||
|
@ -48,6 +48,7 @@ constexpr int INF = 0x3f3f3f3f;
|
||||||
constexpr ll INFLL = 0x3f3f3f3f3f3f3f3fLL;
|
constexpr ll INFLL = 0x3f3f3f3f3f3f3f3fLL;
|
||||||
constexpr ll MDL = 1e9 + 7;
|
constexpr ll MDL = 1e9 + 7;
|
||||||
constexpr ll PRIME = 998'244'353;
|
constexpr ll PRIME = 998'244'353;
|
||||||
|
constexpr ll PRIMELL = 901017227882342239LL;
|
||||||
constexpr ll MDL1 = 8784491;
|
constexpr ll MDL1 = 8784491;
|
||||||
constexpr ll MDL2 = PRIME;
|
constexpr ll MDL2 = PRIME;
|
||||||
constexpr int128 INT128_MAX = numeric_limits<int128>::max();
|
constexpr int128 INT128_MAX = numeric_limits<int128>::max();
|
||||||
|
@ -96,9 +97,9 @@ struct igt {
|
||||||
|
|
||||||
/* conditions */
|
/* conditions */
|
||||||
#define loop while (1)
|
#define loop while (1)
|
||||||
#define if_or(var, val) if (!(var == val)) var = val; else
|
#define if_or(var, val) if (!((var) == (val))) (var) = (val); else
|
||||||
#define continue_or(var, val) __AS_PROCEDURE(if (var == val) continue; var = val;)
|
#define continue_or(var, val) __AS_PROCEDURE(if ((var) == (val)) continue; (var) = (val);)
|
||||||
#define break_or(var, val) __AS_PROCEDURE(if (var == val) break; var = val;)
|
#define break_or(var, val) __AS_PROCEDURE(if ((var) == (val)) break; (var) = (val);)
|
||||||
|
|
||||||
/* hash */
|
/* hash */
|
||||||
struct safe_hash {
|
struct safe_hash {
|
||||||
|
@ -132,13 +133,15 @@ struct pair_hash {
|
||||||
uniform_int_distribution<mt19937::result_type> dist(PRIME);
|
uniform_int_distribution<mt19937::result_type> dist(PRIME);
|
||||||
const size_t __array_hash_b = 31, __array_hash_mdl1 = dist(rd), __array_hash_mdl2 = dist(rd);
|
const size_t __array_hash_b = 31, __array_hash_mdl1 = dist(rd), __array_hash_mdl2 = dist(rd);
|
||||||
struct array_hash {
|
struct array_hash {
|
||||||
|
safe_hash hasher;
|
||||||
template <typename Sequence>
|
template <typename Sequence>
|
||||||
size_t operator()(const Sequence& arr) const {
|
size_t operator()(const Sequence& arr) const {
|
||||||
size_t pw1 = 1, pw2 = 1;
|
size_t pw1 = 1, pw2 = 1;
|
||||||
size_t res1 = 0, res2 = 0;
|
size_t res1 = 0, res2 = 0;
|
||||||
for (auto&& x : arr) {
|
for (auto&& x : arr) {
|
||||||
res1 = (res1 + x * pw1) % __array_hash_mdl1;
|
auto h = hasher(x);
|
||||||
res2 = (res2 + x * pw2) % __array_hash_mdl2;
|
res1 = (res1 + h * pw1) % __array_hash_mdl1;
|
||||||
|
res2 = (res2 + h * pw2) % __array_hash_mdl2;
|
||||||
pw1 = (pw1 * __array_hash_b) % __array_hash_mdl1;
|
pw1 = (pw1 * __array_hash_b) % __array_hash_mdl1;
|
||||||
pw2 = (pw2 * __array_hash_b) % __array_hash_mdl2;
|
pw2 = (pw2 * __array_hash_b) % __array_hash_mdl2;
|
||||||
}
|
}
|
||||||
|
@ -173,7 +176,7 @@ template <typename T, typename Iterator> pair<size_t, unordered_map<T, size_t, s
|
||||||
/* io */
|
/* io */
|
||||||
#define untie __AS_PROCEDURE(ios_base::sync_with_stdio(0), cin.tie(NULL))
|
#define untie __AS_PROCEDURE(ios_base::sync_with_stdio(0), cin.tie(NULL))
|
||||||
|
|
||||||
// add declarations to avoid cyclic dependency
|
// add declarations to avoid circular dependency
|
||||||
template<typename T, typename U> istream& operator>>(istream&, pair<T, U>&);
|
template<typename T, typename U> istream& operator>>(istream&, pair<T, U>&);
|
||||||
template<typename T, typename U> ostream& operator<<(ostream&, const pair<T, U>&);
|
template<typename T, typename U> ostream& operator<<(ostream&, const pair<T, U>&);
|
||||||
template<typename T, size_t N> istream& operator>>(istream&, array<T, N>&);
|
template<typename T, size_t N> istream& operator>>(istream&, array<T, N>&);
|
||||||
|
@ -239,14 +242,14 @@ std::ostream& operator<<(std::ostream& dest, const int128& value) {
|
||||||
template<typename T> void __read(T& x) { cin >> x; }
|
template<typename T> void __read(T& x) { cin >> x; }
|
||||||
template<typename T, typename... U> void __read(T& x, U&... args) { cin >> x; __read(args...); }
|
template<typename T, typename... U> void __read(T& x, U&... args) { cin >> x; __read(args...); }
|
||||||
#define read(t, ...) __AS_PROCEDURE(argument_type<void(t)>::type __VA_ARGS__; __read(__VA_ARGS__);)
|
#define read(t, ...) __AS_PROCEDURE(argument_type<void(t)>::type __VA_ARGS__; __read(__VA_ARGS__);)
|
||||||
#define readvec(t, a, n) __AS_PROCEDURE(vector<argument_type<void(t)>::type> a(n); for (auto& x : a) cin >> x;)
|
#define readvec(t, a, n) __AS_PROCEDURE(vector<argument_type<void(t)>::type> a(n); for (auto& x : (a)) cin >> x;)
|
||||||
#define readvec1(t, a, n) __AS_PROCEDURE(vector<argument_type<void(t)>::type> a((n) + 1); copy_n(ii<argument_type<void(t)>::type>(cin), (n), a.begin() + 1);)
|
#define readvec1(t, a, n) __AS_PROCEDURE(vector<argument_type<void(t)>::type> a((n) + 1); copy_n(ii<argument_type<void(t)>::type>(cin), (n), (a).begin() + 1);)
|
||||||
#define putvec(a) __AS_PROCEDURE(copy(a.begin(), a.end(), oi<__as_typeof(a)::value_type>(cout, " ")); cout << endl;)
|
#define putvec(a) __AS_PROCEDURE(copy((a).begin(), (a).end(), oi<__as_typeof(a)::value_type>(cout, " ")); cout << endl;)
|
||||||
#define putvec1(a) __AS_PROCEDURE(copy(a.begin() + 1, a.end(), oi<__as_typeof(a)::value_type>(cout, " ")); cout << endl;)
|
#define putvec1(a) __AS_PROCEDURE(copy((a).begin() + 1, (a).end(), oi<__as_typeof(a)::value_type>(cout, " ")); cout << endl;)
|
||||||
#define putvec_eol(a) __AS_PROCEDURE(copy(a.begin(), a.end(), oi<__as_typeof(a)::value_type>(cout, "\n"));)
|
#define putvec_eol(a) __AS_PROCEDURE(copy((a).begin(), (a).end(), oi<__as_typeof(a)::value_type>(cout, "\n"));)
|
||||||
#define putvec1_eol(a) __AS_PROCEDURE(copy(a.begin() + 1, a.end(), oi<__as_typeof(a)::value_type>(cout, "\n"));)
|
#define putvec1_eol(a) __AS_PROCEDURE(copy((a).begin() + 1, (a).end(), oi<__as_typeof(a)::value_type>(cout, "\n"));)
|
||||||
#define debug(x) __AS_PROCEDURE(cerr << #x" = " << (x) << endl;)
|
#define debug(x) __AS_PROCEDURE(cerr << #x" = " << (x) << endl;)
|
||||||
#define debugvec(a) __AS_PROCEDURE(cerr << #a" = "; for (auto&& x : a) cerr << x << ' '; cerr << endl;)
|
#define debugvec(a) __AS_PROCEDURE(cerr << #a" = "; for (auto&& x : (a)) cerr << x << ' '; cerr << endl;)
|
||||||
#define deb(...) debug(make_tuple(__VA_ARGS__))
|
#define deb(...) debug(make_tuple(__VA_ARGS__))
|
||||||
|
|
||||||
/* pops */
|
/* pops */
|
||||||
|
@ -293,7 +296,7 @@ ll qpow(ll b, ll p, ll mod) {
|
||||||
#pragma GCC diagnostic ignored "-Wparentheses"
|
#pragma GCC diagnostic ignored "-Wparentheses"
|
||||||
// Accurately find `i` 'th root of `n` (taking the floor)
|
// Accurately find `i` 'th root of `n` (taking the floor)
|
||||||
inline ll root(ll n, ll i) {
|
inline ll root(ll n, ll i) {
|
||||||
ll l = 0, r = pow(LLONG_MAX, ld(1) / i);
|
ll l = 0, r = pow(LLONG_MAX, (long double)(1) / i);
|
||||||
while (l < r) {
|
while (l < r) {
|
||||||
ll mid = l + r + 1 >> 1;
|
ll mid = l + r + 1 >> 1;
|
||||||
if (qpow<int128>(mid, i) <= n) {
|
if (qpow<int128>(mid, i) <= n) {
|
||||||
|
@ -393,7 +396,7 @@ vector<int> calc_z(string t) { // z function of t
|
||||||
}
|
}
|
||||||
return z;
|
return z;
|
||||||
}
|
}
|
||||||
vector<int> kmp(string s, string t) { // find all t in s
|
vector<int> kmp(const string& s, const string& t) { // find all t in s
|
||||||
string cur = t + '#' + s;
|
string cur = t + '#' + s;
|
||||||
int sz1 = s.size(), sz2 = t.size();
|
int sz1 = s.size(), sz2 = t.size();
|
||||||
vector<int> v;
|
vector<int> v;
|
||||||
|
@ -403,7 +406,7 @@ vector<int> kmp(string s, string t) { // find all t in s
|
||||||
}
|
}
|
||||||
return v;
|
return v;
|
||||||
}
|
}
|
||||||
int period(string s) { // find the length of shortest recurring period
|
int period(const string& s) { // find the length of shortest recurring period
|
||||||
int n = s.length();
|
int n = s.length();
|
||||||
auto z = calc_z(s);
|
auto z = calc_z(s);
|
||||||
for (int i = 1; i <= n / 2; ++i) {
|
for (int i = 1; i <= n / 2; ++i) {
|
||||||
|
@ -421,8 +424,8 @@ template <ll mdl> struct MLL {
|
||||||
MLL(const MLL<mdl>& other) : val(other.val) {}
|
MLL(const MLL<mdl>& other) : val(other.val) {}
|
||||||
friend MLL operator+(const MLL& lhs, const MLL& rhs) { return mod(lhs.val + rhs.val, mdl); }
|
friend MLL operator+(const MLL& lhs, const MLL& rhs) { return mod(lhs.val + rhs.val, mdl); }
|
||||||
friend MLL operator-(const MLL& lhs, const MLL& rhs) { return mod(lhs.val - rhs.val, mdl); }
|
friend MLL operator-(const MLL& lhs, const MLL& rhs) { return mod(lhs.val - rhs.val, mdl); }
|
||||||
friend MLL operator*(const MLL& lhs, const MLL& rhs) { return mod(lhs.val * rhs.val, mdl); }
|
friend MLL operator*(const MLL& lhs, const MLL& rhs) { return mod(int128(lhs.val) * rhs.val, mdl); }
|
||||||
friend MLL operator/(const MLL& lhs, const MLL& rhs) { return mod(lhs.val * mod(inverse(rhs.val, mdl), mdl), mdl); }
|
friend MLL operator/(const MLL& lhs, const MLL& rhs) { return lhs * mod(inverse(rhs.val, mdl), mdl); }
|
||||||
friend MLL operator%(const MLL& lhs, const MLL& rhs) { return mod(lhs.val - (lhs / rhs).val, mdl); }
|
friend MLL operator%(const MLL& lhs, const MLL& rhs) { return mod(lhs.val - (lhs / rhs).val, mdl); }
|
||||||
friend bool operator==(const MLL& lhs, const MLL& rhs) { return lhs.val == rhs.val; }
|
friend bool operator==(const MLL& lhs, const MLL& rhs) { return lhs.val == rhs.val; }
|
||||||
friend bool operator!=(const MLL& lhs, const MLL& rhs) { return lhs.val != rhs.val; }
|
friend bool operator!=(const MLL& lhs, const MLL& rhs) { return lhs.val != rhs.val; }
|
||||||
|
@ -524,7 +527,7 @@ constexpr std::array<T, N> __initarray(const T& value) {
|
||||||
}
|
}
|
||||||
/*******************************************************/
|
/*******************************************************/
|
||||||
|
|
||||||
// #define SINGLE_TEST_CASE
|
#define SINGLE_TEST_CASE
|
||||||
// #define DUMP_TEST_CASE 7219
|
// #define DUMP_TEST_CASE 7219
|
||||||
// #define TOT_TEST_CASE 10000
|
// #define TOT_TEST_CASE 10000
|
||||||
|
|
||||||
|
@ -532,25 +535,7 @@ void dump() {}
|
||||||
|
|
||||||
void dump_ignore() {}
|
void dump_ignore() {}
|
||||||
|
|
||||||
constexpr int N = 4e5 + 10;
|
|
||||||
bool not_prime[N + 1];
|
|
||||||
|
|
||||||
void soe(int n) {
|
|
||||||
vector<int> res;
|
|
||||||
for (int i = 2; i <= n; ++i) {
|
|
||||||
if (not not_prime[i]) {
|
|
||||||
res.emplace_back(i);
|
|
||||||
}
|
|
||||||
for (auto&& x : res) {
|
|
||||||
if (i * x > n) break;
|
|
||||||
not_prime[i * x] = 1;
|
|
||||||
if (i % x == 0) break;
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
void prep() {
|
void prep() {
|
||||||
soe(N);
|
|
||||||
}
|
}
|
||||||
|
|
||||||
// __attribute__((target("popcnt")))
|
// __attribute__((target("popcnt")))
|
||||||
|
@ -561,44 +546,87 @@ void solve() {
|
||||||
read(int, u, v);
|
read(int, u, v);
|
||||||
edge(ch, u, v);
|
edge(ch, u, v);
|
||||||
}
|
}
|
||||||
array<vector<int>, 2> bk;
|
|
||||||
vector<int> fa(n + 1);
|
vector<int> sz(n + 1);
|
||||||
{
|
{
|
||||||
auto dfs = [&] (auto dfs, int v, int pa, int par) -> void {
|
auto dfs = [&] (auto dfs, int v, int pa) -> void {
|
||||||
fa[v] = pa;
|
sz[v] = 1;
|
||||||
bk[par].emplace_back(v);
|
|
||||||
for (auto&& u : ch[v]) {
|
for (auto&& u : ch[v]) {
|
||||||
if (u == pa) continue;
|
if (u == pa) continue;
|
||||||
dfs(dfs, u, v, 1 - par);
|
dfs(dfs, u, v);
|
||||||
|
sz[v] += sz[u];
|
||||||
}
|
}
|
||||||
};
|
};
|
||||||
dfs(dfs, 1, 0, 0);
|
dfs(dfs, 1, 0);
|
||||||
}
|
}
|
||||||
vector<int> res(n + 1);
|
|
||||||
int curr = 2;
|
vector<pll> down(n + 1);
|
||||||
for (auto&& v : bk[0]) {
|
{
|
||||||
res[v] = curr;
|
auto dfs = [&] (auto dfs, int v, int pa) -> void {
|
||||||
curr += 2;
|
down[v].second = sz[v] - 1;
|
||||||
|
int tot_sz = 0;
|
||||||
|
for (auto&& u : ch[v]) {
|
||||||
|
if (u == pa) continue;
|
||||||
|
dfs(dfs, u, v);
|
||||||
|
down[v].first += down[u].first + down[u].second;
|
||||||
|
down[v].second += down[u].second;
|
||||||
|
down[v].second += ll(1) * tot_sz * sz[u];
|
||||||
|
tot_sz += sz[u];
|
||||||
}
|
}
|
||||||
curr = 2 * n;
|
};
|
||||||
for (auto&& v : bk[1]) {
|
dfs(dfs, 1, 0);
|
||||||
res[v] = curr;
|
|
||||||
curr -= 2;
|
|
||||||
}
|
}
|
||||||
for (int i = 2; i <= n; ++i) {
|
|
||||||
if (abs(res[fa[i]] - res[i]) == 2) {
|
vector<pll> up(n + 1);
|
||||||
res[i] = res[fa[i]] > res[i] ? res[i] + 1 : res[i] - 1;
|
{
|
||||||
break;
|
auto dfs = [&] (auto dfs, int v, int pa) -> void {
|
||||||
|
// up[v].second += n - sz[v];
|
||||||
|
for (auto&& u : ch[v]) {
|
||||||
|
if (u == pa) continue;
|
||||||
|
// up[v].first += down[u].first;
|
||||||
|
// up[v].second += down[u].second;
|
||||||
}
|
}
|
||||||
|
up[v].second += n - sz[v];
|
||||||
|
up[v].second += ll(1) * (n - sz[v]) * (sz[v] - 1);
|
||||||
|
// if (v == 1) {
|
||||||
|
// debug(up[v]);
|
||||||
|
// debug(down[v]);
|
||||||
|
// }
|
||||||
|
for (auto&& u : ch[v]) {
|
||||||
|
if (u == pa) continue;
|
||||||
|
up[v].second -= ll(1) * sz[u] * (n - sz[v]);
|
||||||
|
down[v].second -= ll(1) * sz[u] * (sz[v] - sz[u]);
|
||||||
|
down[v].first -= down[u].first + down[u].second;
|
||||||
|
down[v].second -= down[u].second;
|
||||||
|
// if (v == 1) {
|
||||||
|
// debug(u);
|
||||||
|
// debug(up[v]);
|
||||||
|
// debug(down[v]);
|
||||||
|
// }
|
||||||
|
|
||||||
|
up[u].first += up[v].first + up[v].second;
|
||||||
|
up[u].first += down[v].first + down[v].second;
|
||||||
|
up[u].second += up[v].second;
|
||||||
|
up[u].second += down[v].second;
|
||||||
|
dfs(dfs, u, v);
|
||||||
|
|
||||||
|
up[v].second += ll(1) * sz[u] * (n - sz[v]);
|
||||||
|
down[v].second += ll(1) * sz[u] * (sz[v] - sz[u]);
|
||||||
|
down[v].first += down[u].first + down[u].second;
|
||||||
|
down[v].second += down[u].second;
|
||||||
}
|
}
|
||||||
|
};
|
||||||
|
dfs(dfs, 1, 0);
|
||||||
|
}
|
||||||
|
|
||||||
for (int i = 1; i <= n; ++i) {
|
for (int i = 1; i <= n; ++i) {
|
||||||
cout << res[i] << " \n"[i == n];
|
cout << up[i].first + down[i].first << '\n';
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
int main() {
|
int main() {
|
||||||
#if __cplusplus < 201402L or defined(_MSC_VER) and not defined(__clang__)
|
#if __cplusplus < 201402L or defined(_MSC_VER) and not defined(__clang__)
|
||||||
assert(false && "incompatible compiler variant detected.");
|
static_assert(false, "incompatible compiler variant detected.");
|
||||||
#endif
|
#endif
|
||||||
untie;
|
untie;
|
||||||
prep();
|
prep();
|
||||||
|
|
111
src/bin/g.cc
111
src/bin/g.cc
|
@ -1,5 +1,5 @@
|
||||||
// #pragma GCC target("popcnt,lzcnt,abm,bmi,bmi2")
|
// #pragma GCC target("popcnt,lzcnt,abm,bmi,bmi2")
|
||||||
#pragma GCC optimize("Ofast")
|
#pragma GCC optimize("Ofast,unroll-loops")
|
||||||
/************* This code requires C++17. ***************/
|
/************* This code requires C++17. ***************/
|
||||||
|
|
||||||
#include<bits/stdc++.h>
|
#include<bits/stdc++.h>
|
||||||
|
@ -25,7 +25,7 @@ using ull = unsigned long long;
|
||||||
#endif
|
#endif
|
||||||
using int128 = __int128_t;
|
using int128 = __int128_t;
|
||||||
using uint128 = __uint128_t;
|
using uint128 = __uint128_t;
|
||||||
using ld = long double;
|
using ld = __float128; // up to 1e-9 precision in binary search
|
||||||
using pii = pair<int, int>; using pil = pair<int, ll>; using pid = pair<int, ld>;
|
using pii = pair<int, int>; using pil = pair<int, ll>; using pid = pair<int, ld>;
|
||||||
using pli = pair<ll, int>; using pll = pair<ll, ll>; using pld = pair<ll, ld>;
|
using pli = pair<ll, int>; using pll = pair<ll, ll>; using pld = pair<ll, ld>;
|
||||||
using pdi = pair<ld, int>; using pdl = pair<ld, ll>; using pdd = pair<ld, ld>;
|
using pdi = pair<ld, int>; using pdl = pair<ld, ll>; using pdd = pair<ld, ld>;
|
||||||
|
@ -48,6 +48,7 @@ constexpr int INF = 0x3f3f3f3f;
|
||||||
constexpr ll INFLL = 0x3f3f3f3f3f3f3f3fLL;
|
constexpr ll INFLL = 0x3f3f3f3f3f3f3f3fLL;
|
||||||
constexpr ll MDL = 1e9 + 7;
|
constexpr ll MDL = 1e9 + 7;
|
||||||
constexpr ll PRIME = 998'244'353;
|
constexpr ll PRIME = 998'244'353;
|
||||||
|
constexpr ll PRIMELL = 901017227882342239LL;
|
||||||
constexpr ll MDL1 = 8784491;
|
constexpr ll MDL1 = 8784491;
|
||||||
constexpr ll MDL2 = PRIME;
|
constexpr ll MDL2 = PRIME;
|
||||||
constexpr int128 INT128_MAX = numeric_limits<int128>::max();
|
constexpr int128 INT128_MAX = numeric_limits<int128>::max();
|
||||||
|
@ -96,9 +97,9 @@ struct igt {
|
||||||
|
|
||||||
/* conditions */
|
/* conditions */
|
||||||
#define loop while (1)
|
#define loop while (1)
|
||||||
#define if_or(var, val) if (!(var == val)) var = val; else
|
#define if_or(var, val) if (!((var) == (val))) (var) = (val); else
|
||||||
#define continue_or(var, val) __AS_PROCEDURE(if (var == val) continue; var = val;)
|
#define continue_or(var, val) __AS_PROCEDURE(if ((var) == (val)) continue; (var) = (val);)
|
||||||
#define break_or(var, val) __AS_PROCEDURE(if (var == val) break; var = val;)
|
#define break_or(var, val) __AS_PROCEDURE(if ((var) == (val)) break; (var) = (val);)
|
||||||
|
|
||||||
/* hash */
|
/* hash */
|
||||||
struct safe_hash {
|
struct safe_hash {
|
||||||
|
@ -132,13 +133,15 @@ struct pair_hash {
|
||||||
uniform_int_distribution<mt19937::result_type> dist(PRIME);
|
uniform_int_distribution<mt19937::result_type> dist(PRIME);
|
||||||
const size_t __array_hash_b = 31, __array_hash_mdl1 = dist(rd), __array_hash_mdl2 = dist(rd);
|
const size_t __array_hash_b = 31, __array_hash_mdl1 = dist(rd), __array_hash_mdl2 = dist(rd);
|
||||||
struct array_hash {
|
struct array_hash {
|
||||||
|
safe_hash hasher;
|
||||||
template <typename Sequence>
|
template <typename Sequence>
|
||||||
size_t operator()(const Sequence& arr) const {
|
size_t operator()(const Sequence& arr) const {
|
||||||
size_t pw1 = 1, pw2 = 1;
|
size_t pw1 = 1, pw2 = 1;
|
||||||
size_t res1 = 0, res2 = 0;
|
size_t res1 = 0, res2 = 0;
|
||||||
for (auto&& x : arr) {
|
for (auto&& x : arr) {
|
||||||
res1 = (res1 + x * pw1) % __array_hash_mdl1;
|
auto h = hasher(x);
|
||||||
res2 = (res2 + x * pw2) % __array_hash_mdl2;
|
res1 = (res1 + h * pw1) % __array_hash_mdl1;
|
||||||
|
res2 = (res2 + h * pw2) % __array_hash_mdl2;
|
||||||
pw1 = (pw1 * __array_hash_b) % __array_hash_mdl1;
|
pw1 = (pw1 * __array_hash_b) % __array_hash_mdl1;
|
||||||
pw2 = (pw2 * __array_hash_b) % __array_hash_mdl2;
|
pw2 = (pw2 * __array_hash_b) % __array_hash_mdl2;
|
||||||
}
|
}
|
||||||
|
@ -173,7 +176,7 @@ template <typename T, typename Iterator> pair<size_t, unordered_map<T, size_t, s
|
||||||
/* io */
|
/* io */
|
||||||
#define untie __AS_PROCEDURE(ios_base::sync_with_stdio(0), cin.tie(NULL))
|
#define untie __AS_PROCEDURE(ios_base::sync_with_stdio(0), cin.tie(NULL))
|
||||||
|
|
||||||
// add declarations to avoid cyclic dependency
|
// add declarations to avoid circular dependency
|
||||||
template<typename T, typename U> istream& operator>>(istream&, pair<T, U>&);
|
template<typename T, typename U> istream& operator>>(istream&, pair<T, U>&);
|
||||||
template<typename T, typename U> ostream& operator<<(ostream&, const pair<T, U>&);
|
template<typename T, typename U> ostream& operator<<(ostream&, const pair<T, U>&);
|
||||||
template<typename T, size_t N> istream& operator>>(istream&, array<T, N>&);
|
template<typename T, size_t N> istream& operator>>(istream&, array<T, N>&);
|
||||||
|
@ -239,14 +242,14 @@ std::ostream& operator<<(std::ostream& dest, const int128& value) {
|
||||||
template<typename T> void __read(T& x) { cin >> x; }
|
template<typename T> void __read(T& x) { cin >> x; }
|
||||||
template<typename T, typename... U> void __read(T& x, U&... args) { cin >> x; __read(args...); }
|
template<typename T, typename... U> void __read(T& x, U&... args) { cin >> x; __read(args...); }
|
||||||
#define read(t, ...) __AS_PROCEDURE(argument_type<void(t)>::type __VA_ARGS__; __read(__VA_ARGS__);)
|
#define read(t, ...) __AS_PROCEDURE(argument_type<void(t)>::type __VA_ARGS__; __read(__VA_ARGS__);)
|
||||||
#define readvec(t, a, n) __AS_PROCEDURE(vector<argument_type<void(t)>::type> a(n); for (auto& x : a) cin >> x;)
|
#define readvec(t, a, n) __AS_PROCEDURE(vector<argument_type<void(t)>::type> a(n); for (auto& x : (a)) cin >> x;)
|
||||||
#define readvec1(t, a, n) __AS_PROCEDURE(vector<argument_type<void(t)>::type> a((n) + 1); copy_n(ii<argument_type<void(t)>::type>(cin), (n), a.begin() + 1);)
|
#define readvec1(t, a, n) __AS_PROCEDURE(vector<argument_type<void(t)>::type> a((n) + 1); copy_n(ii<argument_type<void(t)>::type>(cin), (n), (a).begin() + 1);)
|
||||||
#define putvec(a) __AS_PROCEDURE(copy(a.begin(), a.end(), oi<__as_typeof(a)::value_type>(cout, " ")); cout << endl;)
|
#define putvec(a) __AS_PROCEDURE(copy((a).begin(), (a).end(), oi<__as_typeof(a)::value_type>(cout, " ")); cout << endl;)
|
||||||
#define putvec1(a) __AS_PROCEDURE(copy(a.begin() + 1, a.end(), oi<__as_typeof(a)::value_type>(cout, " ")); cout << endl;)
|
#define putvec1(a) __AS_PROCEDURE(copy((a).begin() + 1, (a).end(), oi<__as_typeof(a)::value_type>(cout, " ")); cout << endl;)
|
||||||
#define putvec_eol(a) __AS_PROCEDURE(copy(a.begin(), a.end(), oi<__as_typeof(a)::value_type>(cout, "\n"));)
|
#define putvec_eol(a) __AS_PROCEDURE(copy((a).begin(), (a).end(), oi<__as_typeof(a)::value_type>(cout, "\n"));)
|
||||||
#define putvec1_eol(a) __AS_PROCEDURE(copy(a.begin() + 1, a.end(), oi<__as_typeof(a)::value_type>(cout, "\n"));)
|
#define putvec1_eol(a) __AS_PROCEDURE(copy((a).begin() + 1, (a).end(), oi<__as_typeof(a)::value_type>(cout, "\n"));)
|
||||||
#define debug(x) __AS_PROCEDURE(cerr << #x" = " << (x) << endl;)
|
#define debug(x) __AS_PROCEDURE(cerr << #x" = " << (x) << endl;)
|
||||||
#define debugvec(a) __AS_PROCEDURE(cerr << #a" = "; for (auto&& x : a) cerr << x << ' '; cerr << endl;)
|
#define debugvec(a) __AS_PROCEDURE(cerr << #a" = "; for (auto&& x : (a)) cerr << x << ' '; cerr << endl;)
|
||||||
#define deb(...) debug(make_tuple(__VA_ARGS__))
|
#define deb(...) debug(make_tuple(__VA_ARGS__))
|
||||||
|
|
||||||
/* pops */
|
/* pops */
|
||||||
|
@ -289,11 +292,11 @@ ll qpow(ll b, ll p, ll mod) {
|
||||||
}
|
}
|
||||||
|
|
||||||
|
|
||||||
// Accurately find `i` 'th root of `n` (taking the floor)
|
|
||||||
#pragma GCC diagnostic push
|
#pragma GCC diagnostic push
|
||||||
#pragma GCC diagnostic ignored "-Wparentheses"
|
#pragma GCC diagnostic ignored "-Wparentheses"
|
||||||
|
// Accurately find `i` 'th root of `n` (taking the floor)
|
||||||
inline ll root(ll n, ll i) {
|
inline ll root(ll n, ll i) {
|
||||||
ll l = 0, r = pow(LLONG_MAX, ld(1) / i);
|
ll l = 0, r = pow(LLONG_MAX, (long double)(1) / i);
|
||||||
while (l < r) {
|
while (l < r) {
|
||||||
ll mid = l + r + 1 >> 1;
|
ll mid = l + r + 1 >> 1;
|
||||||
if (qpow<int128>(mid, i) <= n) {
|
if (qpow<int128>(mid, i) <= n) {
|
||||||
|
@ -393,7 +396,7 @@ vector<int> calc_z(string t) { // z function of t
|
||||||
}
|
}
|
||||||
return z;
|
return z;
|
||||||
}
|
}
|
||||||
vector<int> kmp(string s, string t) { // find all t in s
|
vector<int> kmp(const string& s, const string& t) { // find all t in s
|
||||||
string cur = t + '#' + s;
|
string cur = t + '#' + s;
|
||||||
int sz1 = s.size(), sz2 = t.size();
|
int sz1 = s.size(), sz2 = t.size();
|
||||||
vector<int> v;
|
vector<int> v;
|
||||||
|
@ -403,7 +406,7 @@ vector<int> kmp(string s, string t) { // find all t in s
|
||||||
}
|
}
|
||||||
return v;
|
return v;
|
||||||
}
|
}
|
||||||
int period(string s) { // find the length of shortest recurring period
|
int period(const string& s) { // find the length of shortest recurring period
|
||||||
int n = s.length();
|
int n = s.length();
|
||||||
auto z = calc_z(s);
|
auto z = calc_z(s);
|
||||||
for (int i = 1; i <= n / 2; ++i) {
|
for (int i = 1; i <= n / 2; ++i) {
|
||||||
|
@ -421,8 +424,8 @@ template <ll mdl> struct MLL {
|
||||||
MLL(const MLL<mdl>& other) : val(other.val) {}
|
MLL(const MLL<mdl>& other) : val(other.val) {}
|
||||||
friend MLL operator+(const MLL& lhs, const MLL& rhs) { return mod(lhs.val + rhs.val, mdl); }
|
friend MLL operator+(const MLL& lhs, const MLL& rhs) { return mod(lhs.val + rhs.val, mdl); }
|
||||||
friend MLL operator-(const MLL& lhs, const MLL& rhs) { return mod(lhs.val - rhs.val, mdl); }
|
friend MLL operator-(const MLL& lhs, const MLL& rhs) { return mod(lhs.val - rhs.val, mdl); }
|
||||||
friend MLL operator*(const MLL& lhs, const MLL& rhs) { return mod(lhs.val * rhs.val, mdl); }
|
friend MLL operator*(const MLL& lhs, const MLL& rhs) { return mod(int128(lhs.val) * rhs.val, mdl); }
|
||||||
friend MLL operator/(const MLL& lhs, const MLL& rhs) { return mod(lhs.val * mod(inverse(rhs.val, mdl), mdl), mdl); }
|
friend MLL operator/(const MLL& lhs, const MLL& rhs) { return lhs * mod(inverse(rhs.val, mdl), mdl); }
|
||||||
friend MLL operator%(const MLL& lhs, const MLL& rhs) { return mod(lhs.val - (lhs / rhs).val, mdl); }
|
friend MLL operator%(const MLL& lhs, const MLL& rhs) { return mod(lhs.val - (lhs / rhs).val, mdl); }
|
||||||
friend bool operator==(const MLL& lhs, const MLL& rhs) { return lhs.val == rhs.val; }
|
friend bool operator==(const MLL& lhs, const MLL& rhs) { return lhs.val == rhs.val; }
|
||||||
friend bool operator!=(const MLL& lhs, const MLL& rhs) { return lhs.val != rhs.val; }
|
friend bool operator!=(const MLL& lhs, const MLL& rhs) { return lhs.val != rhs.val; }
|
||||||
|
@ -524,7 +527,7 @@ constexpr std::array<T, N> __initarray(const T& value) {
|
||||||
}
|
}
|
||||||
/*******************************************************/
|
/*******************************************************/
|
||||||
|
|
||||||
// #define SINGLE_TEST_CASE
|
#define SINGLE_TEST_CASE
|
||||||
// #define DUMP_TEST_CASE 7219
|
// #define DUMP_TEST_CASE 7219
|
||||||
// #define TOT_TEST_CASE 10000
|
// #define TOT_TEST_CASE 10000
|
||||||
|
|
||||||
|
@ -535,52 +538,52 @@ void dump_ignore() {}
|
||||||
void prep() {
|
void prep() {
|
||||||
}
|
}
|
||||||
|
|
||||||
|
constexpr int M = 500;
|
||||||
|
constexpr int N = 1e5 + 1;
|
||||||
|
constexpr int S = 1 << 17;
|
||||||
|
int pre[(N + M) / M][S], a[N];
|
||||||
|
|
||||||
// __attribute__((target("popcnt")))
|
// __attribute__((target("popcnt")))
|
||||||
void solve() {
|
void solve() {
|
||||||
read(int, n);
|
read(int, n, k);
|
||||||
adj(ch, n);
|
for (int i = 0; i < n; ++i) {
|
||||||
for (int i = 0; i < n - 1; ++i) {
|
cin >> a[i];
|
||||||
read(int, u, v);
|
|
||||||
edge(ch, u, v);
|
|
||||||
}
|
}
|
||||||
vector<int> f(n + 1);
|
int t = (n + M - 1) / M;
|
||||||
{
|
for (int i = 0; i < n; ++i) {
|
||||||
auto dfs = [&] (auto dfs, int v, int pa) -> void {
|
int c = i / M;
|
||||||
for (auto&& u : ch[v]) {
|
for (int j = i; j < min(n, i + M); ++j) {
|
||||||
if (u == pa) continue;
|
for (int k = 0; k < S; ++k) {
|
||||||
dfs(dfs, u, v);
|
pre[c][k] xor_eq a[j] - k;
|
||||||
f[v] += 1;
|
|
||||||
}
|
}
|
||||||
f[v] -= 1;
|
|
||||||
};
|
|
||||||
dfs(dfs, 1, 0);
|
|
||||||
}
|
}
|
||||||
|
i += M - 1;
|
||||||
|
}
|
||||||
|
|
||||||
|
while (k--) {
|
||||||
|
read(int, d, l, r);
|
||||||
|
--l, --r;
|
||||||
|
int left = l;
|
||||||
int res = 0;
|
int res = 0;
|
||||||
{
|
while (left <= r and left % M != 0) {
|
||||||
auto dfs = [&] (auto dfs, int v, int pa, int up) -> int {
|
res xor_eq a[left] - d;
|
||||||
int curr = up + f[v];
|
left += 1;
|
||||||
int mx = curr;
|
|
||||||
multiset<int> sub;
|
|
||||||
for (auto&& u : ch[v]) {
|
|
||||||
if (u == pa) continue;
|
|
||||||
sub.emplace(dfs(dfs, u, v, curr));
|
|
||||||
}
|
}
|
||||||
if (sub.size()) chmax(mx, *sub.rbegin());
|
while (r - left + 1 >= M) {
|
||||||
chmax(res, mx - up + 1 + (v != 1));
|
res xor_eq pre[left / M][d];
|
||||||
if (sub.size() >= 2) {
|
left += M;
|
||||||
int l = *sub.rbegin(), r = *next(sub.rbegin());
|
|
||||||
chmax(res, (l - curr + 1) + (r - curr + 1) + (f[v] - 1) + (v != 1));
|
|
||||||
}
|
}
|
||||||
return mx;
|
for (int j = left; j <= r; ++j) {
|
||||||
};
|
res xor_eq a[j] - d;
|
||||||
dfs(dfs, 1, 0, 0);
|
|
||||||
}
|
}
|
||||||
cout << res << '\n';
|
cout << res << '\n';
|
||||||
|
}
|
||||||
|
|
||||||
}
|
}
|
||||||
|
|
||||||
int main() {
|
int main() {
|
||||||
#if __cplusplus < 201402L or defined(_MSC_VER) and not defined(__clang__)
|
#if __cplusplus < 201402L or defined(_MSC_VER) and not defined(__clang__)
|
||||||
assert(false && "incompatible compiler variant detected.");
|
static_assert(false, "incompatible compiler variant detected.");
|
||||||
#endif
|
#endif
|
||||||
untie;
|
untie;
|
||||||
prep();
|
prep();
|
||||||
|
|
|
@ -0,0 +1,571 @@
|
||||||
|
// #pragma GCC target("popcnt,lzcnt,abm,bmi,bmi2")
|
||||||
|
#pragma GCC optimize("Ofast,unroll-loops")
|
||||||
|
/************* This code requires C++17. ***************/
|
||||||
|
|
||||||
|
#include<bits/stdc++.h>
|
||||||
|
using namespace std;
|
||||||
|
|
||||||
|
/* macro helpers */
|
||||||
|
#define __NARGS(...) std::tuple_size<decltype(std::make_tuple(__VA_ARGS__))>::value
|
||||||
|
#define __DECOMPOSE_S(a, x) auto x = a;
|
||||||
|
#define __DECOMPOSE_N(a, ...) auto [__VA_ARGS__] = a;
|
||||||
|
constexpr void __() {}
|
||||||
|
#define __AS_PROCEDURE(...) __(); __VA_ARGS__; __()
|
||||||
|
#define __as_typeof(container) remove_reference<decltype(container)>::type
|
||||||
|
template <typename T> struct argument_type;
|
||||||
|
template <typename T, typename U> struct argument_type<T(U)> { using type = U; };
|
||||||
|
|
||||||
|
/* type aliases */
|
||||||
|
#if LONG_LONG_MAX != INT64_MAX
|
||||||
|
using ll = int64_t;
|
||||||
|
using ull = uint64_t;
|
||||||
|
#else
|
||||||
|
using ll = long long;
|
||||||
|
using ull = unsigned long long;
|
||||||
|
#endif
|
||||||
|
using int128 = __int128_t;
|
||||||
|
using uint128 = __uint128_t;
|
||||||
|
using ld = __float128; // up to 1e-9 precision in binary search
|
||||||
|
using pii = pair<int, int>; using pil = pair<int, ll>; using pid = pair<int, ld>;
|
||||||
|
using pli = pair<ll, int>; using pll = pair<ll, ll>; using pld = pair<ll, ld>;
|
||||||
|
using pdi = pair<ld, int>; using pdl = pair<ld, ll>; using pdd = pair<ld, ld>;
|
||||||
|
using tiii = tuple<int, int, int>; using tiil = tuple<int, int, ll>; using tiid = tuple<int, int, ld>;
|
||||||
|
using tili = tuple<int, ll, int>; using till = tuple<int, ll, ll>; using tild = tuple<int, ll, ld>;
|
||||||
|
using tidi = tuple<int, ld, int>; using tidl = tuple<int, ld, ll>; using tidd = tuple<int, ld, ld>;
|
||||||
|
using tlii = tuple<ll, int, int>; using tlil = tuple<ll, int, ll>; using tlid = tuple<ll, int, ld>;
|
||||||
|
using tlli = tuple<ll, ll, int>; using tlll = tuple<ll, ll, ll>; using tlld = tuple<ll, ll, ld>;
|
||||||
|
using tldi = tuple<ll, ld, int>; using tldl = tuple<ll, ld, ll>; using tldd = tuple<ll, ld, ld>;
|
||||||
|
using tdii = tuple<ld, int, int>; using tdil = tuple<ld, int, ll>; using tdid = tuple<ld, int, ld>;
|
||||||
|
using tdli = tuple<ld, ll, int>; using tdll = tuple<ld, ll, ll>; using tdld = tuple<ld, ll, ld>;
|
||||||
|
using tddi = tuple<ld, ld, int>; using tddl = tuple<ld, ld, ll>; using tddd = tuple<ld, ld, ld>;
|
||||||
|
template <typename T> using max_heap = priority_queue<T>;
|
||||||
|
template <typename T> using min_heap = priority_queue<T, vector<T>, greater<>>;
|
||||||
|
template <typename T> using oi = ostream_iterator<T>;
|
||||||
|
template <typename T> using ii = istream_iterator<T>;
|
||||||
|
|
||||||
|
/* constants */
|
||||||
|
constexpr int INF = 0x3f3f3f3f;
|
||||||
|
constexpr ll INFLL = 0x3f3f3f3f3f3f3f3fLL;
|
||||||
|
constexpr ll MDL = 1e9 + 7;
|
||||||
|
constexpr ll PRIME = 998'244'353;
|
||||||
|
constexpr ll PRIMELL = 901017227882342239LL;
|
||||||
|
constexpr ll MDL1 = 8784491;
|
||||||
|
constexpr ll MDL2 = PRIME;
|
||||||
|
constexpr int128 INT128_MAX = numeric_limits<int128>::max();
|
||||||
|
constexpr uint128 UINT128_MAX = numeric_limits<uint128>::max();
|
||||||
|
constexpr int128 INT128_MIN = numeric_limits<int128>::min();
|
||||||
|
constexpr uint128 UINT128_MIN = numeric_limits<uint128>::min();
|
||||||
|
|
||||||
|
/* random */
|
||||||
|
|
||||||
|
mt19937_64 rd(chrono::duration_cast<chrono::milliseconds>(chrono::system_clock::now().time_since_epoch()).count());
|
||||||
|
|
||||||
|
/* bit-wise operations */
|
||||||
|
#define lowbit(x) ((x) & -(x))
|
||||||
|
#define popcount(x) (__builtin_popcountll(ll(x)))
|
||||||
|
#define parity(x) (__builtin_parityll(ll(x)))
|
||||||
|
#define msp(x) (63LL - __builtin_clzll(ll(x)))
|
||||||
|
#define lsp(x) (__builtin_ctzll(ll(x)))
|
||||||
|
|
||||||
|
/* arithmetic operations */
|
||||||
|
#define mod(x, y) ((((x) % (y)) + (y)) % (y))
|
||||||
|
|
||||||
|
/* fast pairs */
|
||||||
|
#define upair ull
|
||||||
|
#define umake(x, y) (ull(x) << 32 | (ull(y) & ((1ULL << 32) - 1)))
|
||||||
|
#define u1(p) ((p) >> 32)
|
||||||
|
#define u2(p) ((p) & ((1ULL << 32) - 1))
|
||||||
|
#define ult std::less<upair>
|
||||||
|
#define ugt std::greater<upair>
|
||||||
|
|
||||||
|
#define ipair ull
|
||||||
|
#define imake(x, y) (umake(x, y))
|
||||||
|
#define i1(p) (int(u1(ll(p))))
|
||||||
|
#define i2(p) (ll(u2(p) << 32) >> 32)
|
||||||
|
struct ilt {
|
||||||
|
bool operator()(const ipair& a, const ipair& b) const {
|
||||||
|
if (i1(a) == i1(b)) return i2(a) < i2(b);
|
||||||
|
else return i1(a) < i1(b);
|
||||||
|
}
|
||||||
|
};
|
||||||
|
struct igt {
|
||||||
|
bool operator()(const ipair& a, const ipair& b) const {
|
||||||
|
if (i1(a) == i1(b)) return i2(a) > i2(b);
|
||||||
|
else return i1(a) > i1(b);
|
||||||
|
}
|
||||||
|
};
|
||||||
|
|
||||||
|
/* conditions */
|
||||||
|
#define loop while (1)
|
||||||
|
#define if_or(var, val) if (!((var) == (val))) (var) = (val); else
|
||||||
|
#define continue_or(var, val) __AS_PROCEDURE(if ((var) == (val)) continue; (var) = (val);)
|
||||||
|
#define break_or(var, val) __AS_PROCEDURE(if ((var) == (val)) break; (var) = (val);)
|
||||||
|
|
||||||
|
/* hash */
|
||||||
|
struct safe_hash {
|
||||||
|
// https://codeforces.com/blog/entry/62393
|
||||||
|
static uint64_t splitmix64(uint64_t x) {
|
||||||
|
// http://xorshift.di.unimi.it/splitmix64.c
|
||||||
|
x += 0x9e3779b97f4a7c15;
|
||||||
|
x = (x ^ (x >> 30)) * 0xbf58476d1ce4e5b9;
|
||||||
|
x = (x ^ (x >> 27)) * 0x94d049bb133111eb;
|
||||||
|
return x ^ (x >> 31);
|
||||||
|
}
|
||||||
|
|
||||||
|
size_t operator()(uint64_t x) const {
|
||||||
|
static const uint64_t FIXED_RANDOM = chrono::steady_clock::now().time_since_epoch().count();
|
||||||
|
return splitmix64(x + FIXED_RANDOM);
|
||||||
|
}
|
||||||
|
};
|
||||||
|
|
||||||
|
struct pair_hash {
|
||||||
|
template <typename T, typename U>
|
||||||
|
size_t operator()(const pair<T, U>& a) const {
|
||||||
|
auto hash1 = safe_hash()(a.first);
|
||||||
|
auto hash2 = safe_hash()(a.second);
|
||||||
|
if (hash1 != hash2) {
|
||||||
|
return hash1 ^ hash2;
|
||||||
|
}
|
||||||
|
return hash1;
|
||||||
|
}
|
||||||
|
};
|
||||||
|
|
||||||
|
uniform_int_distribution<mt19937::result_type> dist(PRIME);
|
||||||
|
const size_t __array_hash_b = 31, __array_hash_mdl1 = dist(rd), __array_hash_mdl2 = dist(rd);
|
||||||
|
struct array_hash {
|
||||||
|
safe_hash hasher;
|
||||||
|
template <typename Sequence>
|
||||||
|
size_t operator()(const Sequence& arr) const {
|
||||||
|
size_t pw1 = 1, pw2 = 1;
|
||||||
|
size_t res1 = 0, res2 = 0;
|
||||||
|
for (auto&& x : arr) {
|
||||||
|
auto h = hasher(x);
|
||||||
|
res1 = (res1 + h * pw1) % __array_hash_mdl1;
|
||||||
|
res2 = (res2 + h * pw2) % __array_hash_mdl2;
|
||||||
|
pw1 = (pw1 * __array_hash_b) % __array_hash_mdl1;
|
||||||
|
pw2 = (pw2 * __array_hash_b) % __array_hash_mdl2;
|
||||||
|
}
|
||||||
|
return res1 + res2;
|
||||||
|
}
|
||||||
|
};
|
||||||
|
|
||||||
|
/* build data structures */
|
||||||
|
#define faster(um) __AS_PROCEDURE((um).reserve(1024); (um).max_load_factor(0.25);)
|
||||||
|
#define unordered_counter(from, to) __AS_PROCEDURE(unordered_map<__as_typeof(from), size_t, safe_hash> to; for (auto&& x : from) ++to[x];)
|
||||||
|
#define counter(from, to, cmp) __AS_PROCEDURE(map<__as_typeof(from), size_t, cmp> to; for (auto&& x : from) ++to[x];)
|
||||||
|
#define adj(ch, n) __AS_PROCEDURE(vector<vector<int>> ch((n) + 1);)
|
||||||
|
#define edge(ch, u, v) __AS_PROCEDURE(ch[u].push_back(v), ch[v].push_back(u);)
|
||||||
|
#define edgew(ch, u, v, ...) __AS_PROCEDURE(ch[u].emplace_back(v, __VA_ARGS__), ch[v].emplace_back(u, __VA_ARGS__);)
|
||||||
|
#define Edge(ch, u, v) __AS_PROCEDURE(ch[u].push_back(v);)
|
||||||
|
#define Edgew(ch, u, v, ...) __AS_PROCEDURE(ch[u].emplace_back(v, __VA_ARGS__);)
|
||||||
|
template <typename T, typename Iterator> pair<size_t, map<T, size_t>> discretize(Iterator __first, Iterator __last) {
|
||||||
|
set<T> st(__first, __last);
|
||||||
|
size_t N = 0;
|
||||||
|
map<T, size_t> mp;
|
||||||
|
for (auto&& x : st) mp[x] = ++N;
|
||||||
|
return {N, mp};
|
||||||
|
}
|
||||||
|
template <typename T, typename Iterator> pair<size_t, unordered_map<T, size_t, safe_hash>> unordered_discretize(Iterator __first, Iterator __last) {
|
||||||
|
set<T> st(__first, __last);
|
||||||
|
size_t N = 0;
|
||||||
|
unordered_map<T, size_t, safe_hash> mp;
|
||||||
|
for (auto&& x : st) mp[x] = ++N;
|
||||||
|
return {N, mp};
|
||||||
|
}
|
||||||
|
|
||||||
|
/* io */
|
||||||
|
#define untie __AS_PROCEDURE(ios_base::sync_with_stdio(0), cin.tie(NULL))
|
||||||
|
|
||||||
|
// add declarations to avoid circular dependency
|
||||||
|
template<typename T, typename U> istream& operator>>(istream&, pair<T, U>&);
|
||||||
|
template<typename T, typename U> ostream& operator<<(ostream&, const pair<T, U>&);
|
||||||
|
template<typename T, size_t N> istream& operator>>(istream&, array<T, N>&);
|
||||||
|
template <typename T, size_t N> ostream& operator<<(ostream&, const array<T, N>&);
|
||||||
|
template<typename Char, typename Traits, typename... Args>
|
||||||
|
decltype(auto) operator<<(std::basic_ostream<Char, Traits>&, const std::tuple<Args...>&);
|
||||||
|
template<typename T> ostream& operator<<(ostream&, const vector<T>&);
|
||||||
|
std::ostream& operator<<(std::ostream&, const int128&);
|
||||||
|
|
||||||
|
template<typename T, typename U> istream& operator>>(istream& in, pair<T, U>& p) {
|
||||||
|
return in >> p.first >> p.second;
|
||||||
|
}
|
||||||
|
template<typename T, typename U> ostream& operator<<(ostream& out, const pair<T, U>& p) {
|
||||||
|
out << "{" << p.first << ", " << p.second << "}";
|
||||||
|
return out;
|
||||||
|
}
|
||||||
|
template<typename T, size_t N> istream& operator>>(istream& in, array<T, N>& a) {
|
||||||
|
for (size_t i = 0; i < N; ++i) in >> a[i];
|
||||||
|
return in;
|
||||||
|
}
|
||||||
|
template <typename T, size_t N> ostream& operator<<(ostream& out, const array<T, N>& a) {
|
||||||
|
for (auto&& i : a) out << i << ' ';
|
||||||
|
return out;
|
||||||
|
}
|
||||||
|
template<typename Char, typename Traits, typename Tuple, std::size_t... Index>
|
||||||
|
void print_tuple_impl(std::basic_ostream<Char, Traits>& os, const Tuple& t, std::index_sequence<Index...>) {
|
||||||
|
using swallow = int[]; // guaranties left to right order
|
||||||
|
(void)swallow { 0, (void(os << (Index == 0 ? "" : ", ") << std::get<Index>(t)), 0)... };
|
||||||
|
}
|
||||||
|
template<typename Char, typename Traits, typename... Args>
|
||||||
|
decltype(auto) operator<<(std::basic_ostream<Char, Traits>& os, const std::tuple<Args...>& t) {
|
||||||
|
os << "{";
|
||||||
|
print_tuple_impl(os, t, std::index_sequence_for<Args...>{});
|
||||||
|
return os << "}";
|
||||||
|
}
|
||||||
|
template<typename T> ostream& operator<<(ostream& out, const vector<T>& vec) {
|
||||||
|
for (auto&& i : vec) out << i << ' ';
|
||||||
|
return out;
|
||||||
|
}
|
||||||
|
std::ostream& operator<<(std::ostream& dest, const int128& value) {
|
||||||
|
// https://stackoverflow.com/a/25115163/23881100
|
||||||
|
std::ostream::sentry s( dest );
|
||||||
|
if ( s ) {
|
||||||
|
uint128 tmp = value < 0 ? -value : value;
|
||||||
|
char buffer[ 128 ];
|
||||||
|
char* d = std::end( buffer );
|
||||||
|
do {
|
||||||
|
-- d;
|
||||||
|
*d = "0123456789"[ tmp % 10 ];
|
||||||
|
tmp /= 10;
|
||||||
|
} while ( tmp != 0 );
|
||||||
|
if ( value < 0 ) {
|
||||||
|
-- d;
|
||||||
|
*d = '-';
|
||||||
|
}
|
||||||
|
int len = std::end( buffer ) - d;
|
||||||
|
if ( dest.rdbuf()->sputn( d, len ) != len ) {
|
||||||
|
dest.setstate( std::ios_base::badbit );
|
||||||
|
}
|
||||||
|
}
|
||||||
|
return dest;
|
||||||
|
}
|
||||||
|
template<typename T> void __read(T& x) { cin >> x; }
|
||||||
|
template<typename T, typename... U> void __read(T& x, U&... args) { cin >> x; __read(args...); }
|
||||||
|
#define read(t, ...) __AS_PROCEDURE(argument_type<void(t)>::type __VA_ARGS__; __read(__VA_ARGS__);)
|
||||||
|
#define readvec(t, a, n) __AS_PROCEDURE(vector<argument_type<void(t)>::type> a(n); for (auto& x : (a)) cin >> x;)
|
||||||
|
#define readvec1(t, a, n) __AS_PROCEDURE(vector<argument_type<void(t)>::type> a((n) + 1); copy_n(ii<argument_type<void(t)>::type>(cin), (n), (a).begin() + 1);)
|
||||||
|
#define putvec(a) __AS_PROCEDURE(copy((a).begin(), (a).end(), oi<__as_typeof(a)::value_type>(cout, " ")); cout << endl;)
|
||||||
|
#define putvec1(a) __AS_PROCEDURE(copy((a).begin() + 1, (a).end(), oi<__as_typeof(a)::value_type>(cout, " ")); cout << endl;)
|
||||||
|
#define putvec_eol(a) __AS_PROCEDURE(copy((a).begin(), (a).end(), oi<__as_typeof(a)::value_type>(cout, "\n"));)
|
||||||
|
#define putvec1_eol(a) __AS_PROCEDURE(copy((a).begin() + 1, (a).end(), oi<__as_typeof(a)::value_type>(cout, "\n"));)
|
||||||
|
#define debug(x) __AS_PROCEDURE(cerr << #x" = " << (x) << endl;)
|
||||||
|
#define debugvec(a) __AS_PROCEDURE(cerr << #a" = "; for (auto&& x : (a)) cerr << x << ' '; cerr << endl;)
|
||||||
|
#define deb(...) debug(make_tuple(__VA_ARGS__))
|
||||||
|
|
||||||
|
/* pops */
|
||||||
|
template <typename Container>
|
||||||
|
inline auto poptop(Container& q) {
|
||||||
|
auto ret = q.top();
|
||||||
|
q.pop();
|
||||||
|
return ret;
|
||||||
|
}
|
||||||
|
template <typename Container>
|
||||||
|
inline auto popback(Container& q) {
|
||||||
|
auto ret = q.back();
|
||||||
|
q.pop_back();
|
||||||
|
return ret;
|
||||||
|
}
|
||||||
|
template <typename Container>
|
||||||
|
inline auto popfront(Container& q) {
|
||||||
|
auto ret = q.front();
|
||||||
|
q.pop_front();
|
||||||
|
return ret;
|
||||||
|
}
|
||||||
|
|
||||||
|
/* math */
|
||||||
|
template <typename return_t>
|
||||||
|
return_t qpow(ll b, ll p) {
|
||||||
|
if (b == 0 and p != 0) return 0;
|
||||||
|
if (p == 0) return 1;
|
||||||
|
return_t half = qpow<return_t>(b, p / 2);
|
||||||
|
if (p % 2 == 1) return half * half * b;
|
||||||
|
else return half * half;
|
||||||
|
}
|
||||||
|
|
||||||
|
// dynamic modulus
|
||||||
|
ll qpow(ll b, ll p, ll mod) {
|
||||||
|
if (b == 0 and p != 0) return 0;
|
||||||
|
if (p == 0) return 1;
|
||||||
|
ll half = qpow(b, p / 2, mod);
|
||||||
|
if (p % 2 == 1) return (int128(half) * half % mod) * b % mod;
|
||||||
|
else return half * half % mod;
|
||||||
|
}
|
||||||
|
|
||||||
|
|
||||||
|
#pragma GCC diagnostic push
|
||||||
|
#pragma GCC diagnostic ignored "-Wparentheses"
|
||||||
|
// Accurately find `i` 'th root of `n` (taking the floor)
|
||||||
|
inline ll root(ll n, ll i) {
|
||||||
|
ll l = 0, r = pow(LLONG_MAX, (long double)(1) / i);
|
||||||
|
while (l < r) {
|
||||||
|
ll mid = l + r + 1 >> 1;
|
||||||
|
if (qpow<int128>(mid, i) <= n) {
|
||||||
|
l = mid;
|
||||||
|
} else {
|
||||||
|
r = mid - 1;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
return l;
|
||||||
|
}
|
||||||
|
#pragma GCC diagnostic pop
|
||||||
|
|
||||||
|
|
||||||
|
#define comb(n, k) ((n) < 0 or (k) < 0 or (n) < (k) ? 0 : fact[n] / fact[k] / fact[(n) - (k)])
|
||||||
|
#define fastcomb(n, k) ((n) < 0 or (k) < 0 or (n) < (k) ? 0 : fact[n] * factrev[k] * factrev[(n) - (k)])
|
||||||
|
|
||||||
|
__attribute__((target("lzcnt")))
|
||||||
|
constexpr inline int lg2(ll x) { return x == 0 ? -1 : sizeof(ll) * 8 - 1 - __builtin_clzll(x); }
|
||||||
|
|
||||||
|
template <typename T>
|
||||||
|
T mygcd(T a, T b) { return b == 0 ? a : mygcd(b, a % b); }
|
||||||
|
|
||||||
|
void __exgcd(ll a, ll b, ll& x, ll& y) {
|
||||||
|
if (b == 0) {
|
||||||
|
x = 1, y = 0;
|
||||||
|
return;
|
||||||
|
}
|
||||||
|
__exgcd(b, a % b, y, x);
|
||||||
|
y -= a / b * x;
|
||||||
|
}
|
||||||
|
|
||||||
|
ll inverse(ll a, ll b) {
|
||||||
|
ll x, y;
|
||||||
|
__exgcd(a, b, x, y);
|
||||||
|
return mod(x, b);
|
||||||
|
}
|
||||||
|
|
||||||
|
vector<tuple<int, int, ll>> decompose(ll x) {
|
||||||
|
// return (factor, count, factor ** count)
|
||||||
|
vector<tuple<int, int, ll>> res;
|
||||||
|
for (int i = 2; i * i <= x; i++) {
|
||||||
|
if (x % i == 0) {
|
||||||
|
int cnt = 0;
|
||||||
|
ll pw = 1;
|
||||||
|
while (x % i == 0) ++cnt, x /= i, pw *= i;
|
||||||
|
res.emplace_back(i, cnt, pw);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
if (x != 1) {
|
||||||
|
res.emplace_back(x, 1, x);
|
||||||
|
}
|
||||||
|
return res;
|
||||||
|
}
|
||||||
|
|
||||||
|
vector<pii> decompose_prime(int N) {
|
||||||
|
// return (factor, count)
|
||||||
|
vector<pii> result;
|
||||||
|
for (int i = 2; i * i <= N; i++) {
|
||||||
|
if (N % i == 0) {
|
||||||
|
int cnt = 0;
|
||||||
|
while (N % i == 0) N /= i, ++cnt;
|
||||||
|
result.emplace_back(i, cnt);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
if (N != 1) {
|
||||||
|
result.emplace_back(N, 1);
|
||||||
|
}
|
||||||
|
return result;
|
||||||
|
}
|
||||||
|
|
||||||
|
/* string algorithms */
|
||||||
|
vector<int> calc_next(string t) { // pi function of t
|
||||||
|
int n = (int)t.length();
|
||||||
|
vector<int> pi(n);
|
||||||
|
for (int i = 1; i < n; i++) {
|
||||||
|
int j = pi[i - 1];
|
||||||
|
while (j > 0 && t[i] != t[j]) j = pi[j - 1];
|
||||||
|
if (t[i] == t[j]) j++;
|
||||||
|
pi[i] = j;
|
||||||
|
}
|
||||||
|
return pi;
|
||||||
|
}
|
||||||
|
vector<int> calc_z(string t) { // z function of t
|
||||||
|
int m = t.length();
|
||||||
|
vector<int> z;
|
||||||
|
z.push_back(m);
|
||||||
|
pair<int, int> prev = {1, -1};
|
||||||
|
for (int i = 1; i < m; ++i) {
|
||||||
|
if (z[i - prev.first] + i <= prev.second) {
|
||||||
|
z.push_back(z[i - prev.first]);
|
||||||
|
} else {
|
||||||
|
int j = max(i, prev.second + 1);
|
||||||
|
while (j < m && t[j] == t[j - i]) ++j;
|
||||||
|
z.push_back(j - i);
|
||||||
|
prev = {i, j - 1};
|
||||||
|
}
|
||||||
|
}
|
||||||
|
return z;
|
||||||
|
}
|
||||||
|
vector<int> kmp(const string& s, const string& t) { // find all t in s
|
||||||
|
string cur = t + '#' + s;
|
||||||
|
int sz1 = s.size(), sz2 = t.size();
|
||||||
|
vector<int> v;
|
||||||
|
vector<int> lps = calc_next(cur);
|
||||||
|
for (int i = sz2 + 1; i <= sz1 + sz2; i++) {
|
||||||
|
if (lps[i] == sz2) v.push_back(i - 2 * sz2);
|
||||||
|
}
|
||||||
|
return v;
|
||||||
|
}
|
||||||
|
int period(const string& s) { // find the length of shortest recurring period
|
||||||
|
int n = s.length();
|
||||||
|
auto z = calc_z(s);
|
||||||
|
for (int i = 1; i <= n / 2; ++i) {
|
||||||
|
if (n % i == 0 && z[i] == n - i) {
|
||||||
|
return i;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
return n;
|
||||||
|
}
|
||||||
|
|
||||||
|
/* modular arithmetic */
|
||||||
|
template <ll mdl> struct MLL {
|
||||||
|
ll val;
|
||||||
|
MLL(ll v = 0) : val(mod(v, mdl)) {}
|
||||||
|
MLL(const MLL<mdl>& other) : val(other.val) {}
|
||||||
|
friend MLL operator+(const MLL& lhs, const MLL& rhs) { return mod(lhs.val + rhs.val, mdl); }
|
||||||
|
friend MLL operator-(const MLL& lhs, const MLL& rhs) { return mod(lhs.val - rhs.val, mdl); }
|
||||||
|
friend MLL operator*(const MLL& lhs, const MLL& rhs) { return mod(int128(lhs.val) * rhs.val, mdl); }
|
||||||
|
friend MLL operator/(const MLL& lhs, const MLL& rhs) { return lhs * mod(inverse(rhs.val, mdl), mdl); }
|
||||||
|
friend MLL operator%(const MLL& lhs, const MLL& rhs) { return mod(lhs.val - (lhs / rhs).val, mdl); }
|
||||||
|
friend bool operator==(const MLL& lhs, const MLL& rhs) { return lhs.val == rhs.val; }
|
||||||
|
friend bool operator!=(const MLL& lhs, const MLL& rhs) { return lhs.val != rhs.val; }
|
||||||
|
MLL& operator+=(const MLL& rhs) { return *this = *this + rhs; }
|
||||||
|
MLL& operator-=(const MLL& rhs) { return *this = *this - rhs; }
|
||||||
|
MLL& operator*=(const MLL& rhs) { return *this = *this * rhs; }
|
||||||
|
MLL& operator/=(const MLL& rhs) { return *this = *this / rhs; }
|
||||||
|
MLL& operator%=(const MLL& rhs) { return *this = *this % rhs; }
|
||||||
|
};
|
||||||
|
|
||||||
|
template <ll mdl>
|
||||||
|
ostream& operator<<(ostream& out, const MLL<mdl>& num) {
|
||||||
|
return out << num.val;
|
||||||
|
}
|
||||||
|
|
||||||
|
template <ll mdl>
|
||||||
|
istream& operator>>(istream& in, MLL<mdl>& num) {
|
||||||
|
return in >> num.val;
|
||||||
|
}
|
||||||
|
|
||||||
|
// miscancellous
|
||||||
|
template <typename T, typename U>
|
||||||
|
bool chmax(T& lhs, const U& rhs) {
|
||||||
|
bool ret = lhs < rhs;
|
||||||
|
if (ret) {
|
||||||
|
lhs = rhs;
|
||||||
|
}
|
||||||
|
return ret;
|
||||||
|
}
|
||||||
|
template <typename T, typename U>
|
||||||
|
bool chmin(T& lhs, const U& rhs) {
|
||||||
|
bool ret = lhs > rhs;
|
||||||
|
if (ret) {
|
||||||
|
lhs = rhs;
|
||||||
|
}
|
||||||
|
return ret;
|
||||||
|
}
|
||||||
|
|
||||||
|
#define functor(func) ([&](auto&&... val) \
|
||||||
|
noexcept(noexcept(func(std::forward<decltype(val)>(val)...))) -> decltype(auto) \
|
||||||
|
{return func(std::forward<decltype(val)>(val)...);})
|
||||||
|
#define expr(ret, ...) ([&] (__VA_ARGS__) { return (ret); })
|
||||||
|
template <typename Func, typename RandomIt> void sort_by_key(RandomIt first, RandomIt last, Func extractor) {
|
||||||
|
std::sort(first, last, [&] (auto&& a, auto&& b) { return std::less<>()(extractor(a), extractor(b)); });
|
||||||
|
}
|
||||||
|
template <typename Func, typename RandomIt, typename Compare> void sort_by_key(RandomIt first, RandomIt last, Func extractor, Compare comp) {
|
||||||
|
std::sort(first, last, [&] (auto&& a, auto&& b) { return comp(extractor(a), extractor(b)); });
|
||||||
|
}
|
||||||
|
template <typename T, typename U, typename Iterator_T, typename Iterator_U>
|
||||||
|
vector<pair<T, U>> zip(Iterator_T a_first, Iterator_T a_last, Iterator_U b_first, Iterator_U b_last) {
|
||||||
|
vector<pair<T, U>> res;
|
||||||
|
auto a_it = a_first;
|
||||||
|
auto b_it = b_first;
|
||||||
|
for (; not (a_it == a_last) and not (b_it == b_last); ++a_it, ++b_it) {
|
||||||
|
res.emplace_back(*a_it, *b_it);
|
||||||
|
}
|
||||||
|
return res;
|
||||||
|
}
|
||||||
|
template <typename T, typename U, typename Iterator_T, typename Iterator_U>
|
||||||
|
vector<pair<T, U>> zip_n(Iterator_T a_first, Iterator_U b_first, size_t n) {
|
||||||
|
vector<pair<T, U>> res;
|
||||||
|
if (n > 0) {
|
||||||
|
res.emplace_back(*a_first, *b_first);
|
||||||
|
for (size_t i = 1; i != n; ++i) {
|
||||||
|
res.emplace_back(*++a_first, *++b_first);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
return res;
|
||||||
|
}
|
||||||
|
template <typename T>
|
||||||
|
class ArithmeticIterator : bidirectional_iterator_tag {
|
||||||
|
public:
|
||||||
|
using difference_type = ptrdiff_t;
|
||||||
|
using value_type = T;
|
||||||
|
private:
|
||||||
|
value_type value;
|
||||||
|
public:
|
||||||
|
ArithmeticIterator(const T& value) : value(value) {}
|
||||||
|
value_type operator*() const { return value; }
|
||||||
|
ArithmeticIterator<T>& operator++() { ++value; return *this; }
|
||||||
|
ArithmeticIterator<T>& operator--() { --value; return *this; }
|
||||||
|
bool operator==(const ArithmeticIterator<T>& rhs) const { return value == rhs.value; }
|
||||||
|
};
|
||||||
|
template <typename T> vector<pair<int, T>> enumerate(const vector<T>& container) {
|
||||||
|
return zip<int, T>(ArithmeticIterator<int>(0), ArithmeticIterator<int>(INT_MAX), container.begin(), container.end());
|
||||||
|
}
|
||||||
|
#define initarray(init, N) (__initarray<decay<decltype(init)>::type, (N)>(init))
|
||||||
|
namespace detail {
|
||||||
|
template <typename T, std::size_t...Is>
|
||||||
|
constexpr std::array<T, sizeof...(Is)>
|
||||||
|
make_array(const T& value, std::index_sequence<Is...>) {
|
||||||
|
return {{(static_cast<void>(Is), value)...}};
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
template <typename T, std::size_t N>
|
||||||
|
constexpr std::array<T, N> __initarray(const T& value) {
|
||||||
|
return detail::make_array(value, std::make_index_sequence<N>());
|
||||||
|
}
|
||||||
|
/*******************************************************/
|
||||||
|
|
||||||
|
// #define SINGLE_TEST_CASE
|
||||||
|
// #define DUMP_TEST_CASE 7219
|
||||||
|
// #define TOT_TEST_CASE 10000
|
||||||
|
|
||||||
|
void dump() {}
|
||||||
|
|
||||||
|
void dump_ignore() {}
|
||||||
|
|
||||||
|
void prep() {
|
||||||
|
}
|
||||||
|
|
||||||
|
// __attribute__((target("popcnt")))
|
||||||
|
void solve() {
|
||||||
|
read(int, x, y, z);
|
||||||
|
cout << min({x / 2, y, z}) << '\n';
|
||||||
|
}
|
||||||
|
|
||||||
|
int main() {
|
||||||
|
#if __cplusplus < 201402L or defined(_MSC_VER) and not defined(__clang__)
|
||||||
|
static_assert(false, "incompatible compiler variant detected.");
|
||||||
|
#endif
|
||||||
|
untie;
|
||||||
|
prep();
|
||||||
|
#ifdef SINGLE_TEST_CASE
|
||||||
|
solve();
|
||||||
|
#else
|
||||||
|
read(int, t);
|
||||||
|
for (int i = 0; i < t; ++i) {
|
||||||
|
#ifdef DUMP_TEST_CASE
|
||||||
|
if (t != (TOT_TEST_CASE)) {
|
||||||
|
solve();
|
||||||
|
} else if (i + 1 == (DUMP_TEST_CASE)) {
|
||||||
|
dump();
|
||||||
|
} else {
|
||||||
|
dump_ignore();
|
||||||
|
}
|
||||||
|
#else
|
||||||
|
solve();
|
||||||
|
#endif
|
||||||
|
}
|
||||||
|
#endif
|
||||||
|
}
|
|
@ -0,0 +1,576 @@
|
||||||
|
// #pragma GCC target("popcnt,lzcnt,abm,bmi,bmi2")
|
||||||
|
#pragma GCC optimize("Ofast,unroll-loops")
|
||||||
|
/************* This code requires C++17. ***************/
|
||||||
|
|
||||||
|
#include<bits/stdc++.h>
|
||||||
|
using namespace std;
|
||||||
|
|
||||||
|
/* macro helpers */
|
||||||
|
#define __NARGS(...) std::tuple_size<decltype(std::make_tuple(__VA_ARGS__))>::value
|
||||||
|
#define __DECOMPOSE_S(a, x) auto x = a;
|
||||||
|
#define __DECOMPOSE_N(a, ...) auto [__VA_ARGS__] = a;
|
||||||
|
constexpr void __() {}
|
||||||
|
#define __AS_PROCEDURE(...) __(); __VA_ARGS__; __()
|
||||||
|
#define __as_typeof(container) remove_reference<decltype(container)>::type
|
||||||
|
template <typename T> struct argument_type;
|
||||||
|
template <typename T, typename U> struct argument_type<T(U)> { using type = U; };
|
||||||
|
|
||||||
|
/* type aliases */
|
||||||
|
#if LONG_LONG_MAX != INT64_MAX
|
||||||
|
using ll = int64_t;
|
||||||
|
using ull = uint64_t;
|
||||||
|
#else
|
||||||
|
using ll = long long;
|
||||||
|
using ull = unsigned long long;
|
||||||
|
#endif
|
||||||
|
using int128 = __int128_t;
|
||||||
|
using uint128 = __uint128_t;
|
||||||
|
using ld = __float128; // up to 1e-9 precision in binary search
|
||||||
|
using pii = pair<int, int>; using pil = pair<int, ll>; using pid = pair<int, ld>;
|
||||||
|
using pli = pair<ll, int>; using pll = pair<ll, ll>; using pld = pair<ll, ld>;
|
||||||
|
using pdi = pair<ld, int>; using pdl = pair<ld, ll>; using pdd = pair<ld, ld>;
|
||||||
|
using tiii = tuple<int, int, int>; using tiil = tuple<int, int, ll>; using tiid = tuple<int, int, ld>;
|
||||||
|
using tili = tuple<int, ll, int>; using till = tuple<int, ll, ll>; using tild = tuple<int, ll, ld>;
|
||||||
|
using tidi = tuple<int, ld, int>; using tidl = tuple<int, ld, ll>; using tidd = tuple<int, ld, ld>;
|
||||||
|
using tlii = tuple<ll, int, int>; using tlil = tuple<ll, int, ll>; using tlid = tuple<ll, int, ld>;
|
||||||
|
using tlli = tuple<ll, ll, int>; using tlll = tuple<ll, ll, ll>; using tlld = tuple<ll, ll, ld>;
|
||||||
|
using tldi = tuple<ll, ld, int>; using tldl = tuple<ll, ld, ll>; using tldd = tuple<ll, ld, ld>;
|
||||||
|
using tdii = tuple<ld, int, int>; using tdil = tuple<ld, int, ll>; using tdid = tuple<ld, int, ld>;
|
||||||
|
using tdli = tuple<ld, ll, int>; using tdll = tuple<ld, ll, ll>; using tdld = tuple<ld, ll, ld>;
|
||||||
|
using tddi = tuple<ld, ld, int>; using tddl = tuple<ld, ld, ll>; using tddd = tuple<ld, ld, ld>;
|
||||||
|
template <typename T> using max_heap = priority_queue<T>;
|
||||||
|
template <typename T> using min_heap = priority_queue<T, vector<T>, greater<>>;
|
||||||
|
template <typename T> using oi = ostream_iterator<T>;
|
||||||
|
template <typename T> using ii = istream_iterator<T>;
|
||||||
|
|
||||||
|
/* constants */
|
||||||
|
constexpr int INF = 0x3f3f3f3f;
|
||||||
|
constexpr ll INFLL = 0x3f3f3f3f3f3f3f3fLL;
|
||||||
|
constexpr ll MDL = 1e9 + 7;
|
||||||
|
constexpr ll PRIME = 998'244'353;
|
||||||
|
constexpr ll PRIMELL = 901017227882342239LL;
|
||||||
|
constexpr ll MDL1 = 8784491;
|
||||||
|
constexpr ll MDL2 = PRIME;
|
||||||
|
constexpr int128 INT128_MAX = numeric_limits<int128>::max();
|
||||||
|
constexpr uint128 UINT128_MAX = numeric_limits<uint128>::max();
|
||||||
|
constexpr int128 INT128_MIN = numeric_limits<int128>::min();
|
||||||
|
constexpr uint128 UINT128_MIN = numeric_limits<uint128>::min();
|
||||||
|
|
||||||
|
/* random */
|
||||||
|
|
||||||
|
mt19937_64 rd(chrono::duration_cast<chrono::milliseconds>(chrono::system_clock::now().time_since_epoch()).count());
|
||||||
|
|
||||||
|
/* bit-wise operations */
|
||||||
|
#define lowbit(x) ((x) & -(x))
|
||||||
|
#define popcount(x) (__builtin_popcountll(ll(x)))
|
||||||
|
#define parity(x) (__builtin_parityll(ll(x)))
|
||||||
|
#define msp(x) (63LL - __builtin_clzll(ll(x)))
|
||||||
|
#define lsp(x) (__builtin_ctzll(ll(x)))
|
||||||
|
|
||||||
|
/* arithmetic operations */
|
||||||
|
#define mod(x, y) ((((x) % (y)) + (y)) % (y))
|
||||||
|
|
||||||
|
/* fast pairs */
|
||||||
|
#define upair ull
|
||||||
|
#define umake(x, y) (ull(x) << 32 | (ull(y) & ((1ULL << 32) - 1)))
|
||||||
|
#define u1(p) ((p) >> 32)
|
||||||
|
#define u2(p) ((p) & ((1ULL << 32) - 1))
|
||||||
|
#define ult std::less<upair>
|
||||||
|
#define ugt std::greater<upair>
|
||||||
|
|
||||||
|
#define ipair ull
|
||||||
|
#define imake(x, y) (umake(x, y))
|
||||||
|
#define i1(p) (int(u1(ll(p))))
|
||||||
|
#define i2(p) (ll(u2(p) << 32) >> 32)
|
||||||
|
struct ilt {
|
||||||
|
bool operator()(const ipair& a, const ipair& b) const {
|
||||||
|
if (i1(a) == i1(b)) return i2(a) < i2(b);
|
||||||
|
else return i1(a) < i1(b);
|
||||||
|
}
|
||||||
|
};
|
||||||
|
struct igt {
|
||||||
|
bool operator()(const ipair& a, const ipair& b) const {
|
||||||
|
if (i1(a) == i1(b)) return i2(a) > i2(b);
|
||||||
|
else return i1(a) > i1(b);
|
||||||
|
}
|
||||||
|
};
|
||||||
|
|
||||||
|
/* conditions */
|
||||||
|
#define loop while (1)
|
||||||
|
#define if_or(var, val) if (!((var) == (val))) (var) = (val); else
|
||||||
|
#define continue_or(var, val) __AS_PROCEDURE(if ((var) == (val)) continue; (var) = (val);)
|
||||||
|
#define break_or(var, val) __AS_PROCEDURE(if ((var) == (val)) break; (var) = (val);)
|
||||||
|
|
||||||
|
/* hash */
|
||||||
|
struct safe_hash {
|
||||||
|
// https://codeforces.com/blog/entry/62393
|
||||||
|
static uint64_t splitmix64(uint64_t x) {
|
||||||
|
// http://xorshift.di.unimi.it/splitmix64.c
|
||||||
|
x += 0x9e3779b97f4a7c15;
|
||||||
|
x = (x ^ (x >> 30)) * 0xbf58476d1ce4e5b9;
|
||||||
|
x = (x ^ (x >> 27)) * 0x94d049bb133111eb;
|
||||||
|
return x ^ (x >> 31);
|
||||||
|
}
|
||||||
|
|
||||||
|
size_t operator()(uint64_t x) const {
|
||||||
|
static const uint64_t FIXED_RANDOM = chrono::steady_clock::now().time_since_epoch().count();
|
||||||
|
return splitmix64(x + FIXED_RANDOM);
|
||||||
|
}
|
||||||
|
};
|
||||||
|
|
||||||
|
struct pair_hash {
|
||||||
|
template <typename T, typename U>
|
||||||
|
size_t operator()(const pair<T, U>& a) const {
|
||||||
|
auto hash1 = safe_hash()(a.first);
|
||||||
|
auto hash2 = safe_hash()(a.second);
|
||||||
|
if (hash1 != hash2) {
|
||||||
|
return hash1 ^ hash2;
|
||||||
|
}
|
||||||
|
return hash1;
|
||||||
|
}
|
||||||
|
};
|
||||||
|
|
||||||
|
uniform_int_distribution<mt19937::result_type> dist(PRIME);
|
||||||
|
const size_t __array_hash_b = 31, __array_hash_mdl1 = dist(rd), __array_hash_mdl2 = dist(rd);
|
||||||
|
struct array_hash {
|
||||||
|
safe_hash hasher;
|
||||||
|
template <typename Sequence>
|
||||||
|
size_t operator()(const Sequence& arr) const {
|
||||||
|
size_t pw1 = 1, pw2 = 1;
|
||||||
|
size_t res1 = 0, res2 = 0;
|
||||||
|
for (auto&& x : arr) {
|
||||||
|
auto h = hasher(x);
|
||||||
|
res1 = (res1 + h * pw1) % __array_hash_mdl1;
|
||||||
|
res2 = (res2 + h * pw2) % __array_hash_mdl2;
|
||||||
|
pw1 = (pw1 * __array_hash_b) % __array_hash_mdl1;
|
||||||
|
pw2 = (pw2 * __array_hash_b) % __array_hash_mdl2;
|
||||||
|
}
|
||||||
|
return res1 + res2;
|
||||||
|
}
|
||||||
|
};
|
||||||
|
|
||||||
|
/* build data structures */
|
||||||
|
#define faster(um) __AS_PROCEDURE((um).reserve(1024); (um).max_load_factor(0.25);)
|
||||||
|
#define unordered_counter(from, to) __AS_PROCEDURE(unordered_map<__as_typeof(from), size_t, safe_hash> to; for (auto&& x : from) ++to[x];)
|
||||||
|
#define counter(from, to, cmp) __AS_PROCEDURE(map<__as_typeof(from), size_t, cmp> to; for (auto&& x : from) ++to[x];)
|
||||||
|
#define adj(ch, n) __AS_PROCEDURE(vector<vector<int>> ch((n) + 1);)
|
||||||
|
#define edge(ch, u, v) __AS_PROCEDURE(ch[u].push_back(v), ch[v].push_back(u);)
|
||||||
|
#define edgew(ch, u, v, ...) __AS_PROCEDURE(ch[u].emplace_back(v, __VA_ARGS__), ch[v].emplace_back(u, __VA_ARGS__);)
|
||||||
|
#define Edge(ch, u, v) __AS_PROCEDURE(ch[u].push_back(v);)
|
||||||
|
#define Edgew(ch, u, v, ...) __AS_PROCEDURE(ch[u].emplace_back(v, __VA_ARGS__);)
|
||||||
|
template <typename T, typename Iterator> pair<size_t, map<T, size_t>> discretize(Iterator __first, Iterator __last) {
|
||||||
|
set<T> st(__first, __last);
|
||||||
|
size_t N = 0;
|
||||||
|
map<T, size_t> mp;
|
||||||
|
for (auto&& x : st) mp[x] = ++N;
|
||||||
|
return {N, mp};
|
||||||
|
}
|
||||||
|
template <typename T, typename Iterator> pair<size_t, unordered_map<T, size_t, safe_hash>> unordered_discretize(Iterator __first, Iterator __last) {
|
||||||
|
set<T> st(__first, __last);
|
||||||
|
size_t N = 0;
|
||||||
|
unordered_map<T, size_t, safe_hash> mp;
|
||||||
|
for (auto&& x : st) mp[x] = ++N;
|
||||||
|
return {N, mp};
|
||||||
|
}
|
||||||
|
|
||||||
|
/* io */
|
||||||
|
#define untie __AS_PROCEDURE(ios_base::sync_with_stdio(0), cin.tie(NULL))
|
||||||
|
|
||||||
|
// add declarations to avoid circular dependency
|
||||||
|
template<typename T, typename U> istream& operator>>(istream&, pair<T, U>&);
|
||||||
|
template<typename T, typename U> ostream& operator<<(ostream&, const pair<T, U>&);
|
||||||
|
template<typename T, size_t N> istream& operator>>(istream&, array<T, N>&);
|
||||||
|
template <typename T, size_t N> ostream& operator<<(ostream&, const array<T, N>&);
|
||||||
|
template<typename Char, typename Traits, typename... Args>
|
||||||
|
decltype(auto) operator<<(std::basic_ostream<Char, Traits>&, const std::tuple<Args...>&);
|
||||||
|
template<typename T> ostream& operator<<(ostream&, const vector<T>&);
|
||||||
|
std::ostream& operator<<(std::ostream&, const int128&);
|
||||||
|
|
||||||
|
template<typename T, typename U> istream& operator>>(istream& in, pair<T, U>& p) {
|
||||||
|
return in >> p.first >> p.second;
|
||||||
|
}
|
||||||
|
template<typename T, typename U> ostream& operator<<(ostream& out, const pair<T, U>& p) {
|
||||||
|
out << "{" << p.first << ", " << p.second << "}";
|
||||||
|
return out;
|
||||||
|
}
|
||||||
|
template<typename T, size_t N> istream& operator>>(istream& in, array<T, N>& a) {
|
||||||
|
for (size_t i = 0; i < N; ++i) in >> a[i];
|
||||||
|
return in;
|
||||||
|
}
|
||||||
|
template <typename T, size_t N> ostream& operator<<(ostream& out, const array<T, N>& a) {
|
||||||
|
for (auto&& i : a) out << i << ' ';
|
||||||
|
return out;
|
||||||
|
}
|
||||||
|
template<typename Char, typename Traits, typename Tuple, std::size_t... Index>
|
||||||
|
void print_tuple_impl(std::basic_ostream<Char, Traits>& os, const Tuple& t, std::index_sequence<Index...>) {
|
||||||
|
using swallow = int[]; // guaranties left to right order
|
||||||
|
(void)swallow { 0, (void(os << (Index == 0 ? "" : ", ") << std::get<Index>(t)), 0)... };
|
||||||
|
}
|
||||||
|
template<typename Char, typename Traits, typename... Args>
|
||||||
|
decltype(auto) operator<<(std::basic_ostream<Char, Traits>& os, const std::tuple<Args...>& t) {
|
||||||
|
os << "{";
|
||||||
|
print_tuple_impl(os, t, std::index_sequence_for<Args...>{});
|
||||||
|
return os << "}";
|
||||||
|
}
|
||||||
|
template<typename T> ostream& operator<<(ostream& out, const vector<T>& vec) {
|
||||||
|
for (auto&& i : vec) out << i << ' ';
|
||||||
|
return out;
|
||||||
|
}
|
||||||
|
std::ostream& operator<<(std::ostream& dest, const int128& value) {
|
||||||
|
// https://stackoverflow.com/a/25115163/23881100
|
||||||
|
std::ostream::sentry s( dest );
|
||||||
|
if ( s ) {
|
||||||
|
uint128 tmp = value < 0 ? -value : value;
|
||||||
|
char buffer[ 128 ];
|
||||||
|
char* d = std::end( buffer );
|
||||||
|
do {
|
||||||
|
-- d;
|
||||||
|
*d = "0123456789"[ tmp % 10 ];
|
||||||
|
tmp /= 10;
|
||||||
|
} while ( tmp != 0 );
|
||||||
|
if ( value < 0 ) {
|
||||||
|
-- d;
|
||||||
|
*d = '-';
|
||||||
|
}
|
||||||
|
int len = std::end( buffer ) - d;
|
||||||
|
if ( dest.rdbuf()->sputn( d, len ) != len ) {
|
||||||
|
dest.setstate( std::ios_base::badbit );
|
||||||
|
}
|
||||||
|
}
|
||||||
|
return dest;
|
||||||
|
}
|
||||||
|
template<typename T> void __read(T& x) { cin >> x; }
|
||||||
|
template<typename T, typename... U> void __read(T& x, U&... args) { cin >> x; __read(args...); }
|
||||||
|
#define read(t, ...) __AS_PROCEDURE(argument_type<void(t)>::type __VA_ARGS__; __read(__VA_ARGS__);)
|
||||||
|
#define readvec(t, a, n) __AS_PROCEDURE(vector<argument_type<void(t)>::type> a(n); for (auto& x : (a)) cin >> x;)
|
||||||
|
#define readvec1(t, a, n) __AS_PROCEDURE(vector<argument_type<void(t)>::type> a((n) + 1); copy_n(ii<argument_type<void(t)>::type>(cin), (n), (a).begin() + 1);)
|
||||||
|
#define putvec(a) __AS_PROCEDURE(copy((a).begin(), (a).end(), oi<__as_typeof(a)::value_type>(cout, " ")); cout << endl;)
|
||||||
|
#define putvec1(a) __AS_PROCEDURE(copy((a).begin() + 1, (a).end(), oi<__as_typeof(a)::value_type>(cout, " ")); cout << endl;)
|
||||||
|
#define putvec_eol(a) __AS_PROCEDURE(copy((a).begin(), (a).end(), oi<__as_typeof(a)::value_type>(cout, "\n"));)
|
||||||
|
#define putvec1_eol(a) __AS_PROCEDURE(copy((a).begin() + 1, (a).end(), oi<__as_typeof(a)::value_type>(cout, "\n"));)
|
||||||
|
#define debug(x) __AS_PROCEDURE(cerr << #x" = " << (x) << endl;)
|
||||||
|
#define debugvec(a) __AS_PROCEDURE(cerr << #a" = "; for (auto&& x : (a)) cerr << x << ' '; cerr << endl;)
|
||||||
|
#define deb(...) debug(make_tuple(__VA_ARGS__))
|
||||||
|
|
||||||
|
/* pops */
|
||||||
|
template <typename Container>
|
||||||
|
inline auto poptop(Container& q) {
|
||||||
|
auto ret = q.top();
|
||||||
|
q.pop();
|
||||||
|
return ret;
|
||||||
|
}
|
||||||
|
template <typename Container>
|
||||||
|
inline auto popback(Container& q) {
|
||||||
|
auto ret = q.back();
|
||||||
|
q.pop_back();
|
||||||
|
return ret;
|
||||||
|
}
|
||||||
|
template <typename Container>
|
||||||
|
inline auto popfront(Container& q) {
|
||||||
|
auto ret = q.front();
|
||||||
|
q.pop_front();
|
||||||
|
return ret;
|
||||||
|
}
|
||||||
|
|
||||||
|
/* math */
|
||||||
|
template <typename return_t>
|
||||||
|
return_t qpow(ll b, ll p) {
|
||||||
|
if (b == 0 and p != 0) return 0;
|
||||||
|
if (p == 0) return 1;
|
||||||
|
return_t half = qpow<return_t>(b, p / 2);
|
||||||
|
if (p % 2 == 1) return half * half * b;
|
||||||
|
else return half * half;
|
||||||
|
}
|
||||||
|
|
||||||
|
// dynamic modulus
|
||||||
|
ll qpow(ll b, ll p, ll mod) {
|
||||||
|
if (b == 0 and p != 0) return 0;
|
||||||
|
if (p == 0) return 1;
|
||||||
|
ll half = qpow(b, p / 2, mod);
|
||||||
|
if (p % 2 == 1) return (int128(half) * half % mod) * b % mod;
|
||||||
|
else return half * half % mod;
|
||||||
|
}
|
||||||
|
|
||||||
|
|
||||||
|
#pragma GCC diagnostic push
|
||||||
|
#pragma GCC diagnostic ignored "-Wparentheses"
|
||||||
|
// Accurately find `i` 'th root of `n` (taking the floor)
|
||||||
|
inline ll root(ll n, ll i) {
|
||||||
|
ll l = 0, r = pow(LLONG_MAX, (long double)(1) / i);
|
||||||
|
while (l < r) {
|
||||||
|
ll mid = l + r + 1 >> 1;
|
||||||
|
if (qpow<int128>(mid, i) <= n) {
|
||||||
|
l = mid;
|
||||||
|
} else {
|
||||||
|
r = mid - 1;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
return l;
|
||||||
|
}
|
||||||
|
#pragma GCC diagnostic pop
|
||||||
|
|
||||||
|
|
||||||
|
#define comb(n, k) ((n) < 0 or (k) < 0 or (n) < (k) ? 0 : fact[n] / fact[k] / fact[(n) - (k)])
|
||||||
|
#define fastcomb(n, k) ((n) < 0 or (k) < 0 or (n) < (k) ? 0 : fact[n] * factrev[k] * factrev[(n) - (k)])
|
||||||
|
|
||||||
|
__attribute__((target("lzcnt")))
|
||||||
|
constexpr inline int lg2(ll x) { return x == 0 ? -1 : sizeof(ll) * 8 - 1 - __builtin_clzll(x); }
|
||||||
|
|
||||||
|
template <typename T>
|
||||||
|
T mygcd(T a, T b) { return b == 0 ? a : mygcd(b, a % b); }
|
||||||
|
|
||||||
|
void __exgcd(ll a, ll b, ll& x, ll& y) {
|
||||||
|
if (b == 0) {
|
||||||
|
x = 1, y = 0;
|
||||||
|
return;
|
||||||
|
}
|
||||||
|
__exgcd(b, a % b, y, x);
|
||||||
|
y -= a / b * x;
|
||||||
|
}
|
||||||
|
|
||||||
|
ll inverse(ll a, ll b) {
|
||||||
|
ll x, y;
|
||||||
|
__exgcd(a, b, x, y);
|
||||||
|
return mod(x, b);
|
||||||
|
}
|
||||||
|
|
||||||
|
vector<tuple<int, int, ll>> decompose(ll x) {
|
||||||
|
// return (factor, count, factor ** count)
|
||||||
|
vector<tuple<int, int, ll>> res;
|
||||||
|
for (int i = 2; i * i <= x; i++) {
|
||||||
|
if (x % i == 0) {
|
||||||
|
int cnt = 0;
|
||||||
|
ll pw = 1;
|
||||||
|
while (x % i == 0) ++cnt, x /= i, pw *= i;
|
||||||
|
res.emplace_back(i, cnt, pw);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
if (x != 1) {
|
||||||
|
res.emplace_back(x, 1, x);
|
||||||
|
}
|
||||||
|
return res;
|
||||||
|
}
|
||||||
|
|
||||||
|
vector<pii> decompose_prime(int N) {
|
||||||
|
// return (factor, count)
|
||||||
|
vector<pii> result;
|
||||||
|
for (int i = 2; i * i <= N; i++) {
|
||||||
|
if (N % i == 0) {
|
||||||
|
int cnt = 0;
|
||||||
|
while (N % i == 0) N /= i, ++cnt;
|
||||||
|
result.emplace_back(i, cnt);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
if (N != 1) {
|
||||||
|
result.emplace_back(N, 1);
|
||||||
|
}
|
||||||
|
return result;
|
||||||
|
}
|
||||||
|
|
||||||
|
/* string algorithms */
|
||||||
|
vector<int> calc_next(string t) { // pi function of t
|
||||||
|
int n = (int)t.length();
|
||||||
|
vector<int> pi(n);
|
||||||
|
for (int i = 1; i < n; i++) {
|
||||||
|
int j = pi[i - 1];
|
||||||
|
while (j > 0 && t[i] != t[j]) j = pi[j - 1];
|
||||||
|
if (t[i] == t[j]) j++;
|
||||||
|
pi[i] = j;
|
||||||
|
}
|
||||||
|
return pi;
|
||||||
|
}
|
||||||
|
vector<int> calc_z(string t) { // z function of t
|
||||||
|
int m = t.length();
|
||||||
|
vector<int> z;
|
||||||
|
z.push_back(m);
|
||||||
|
pair<int, int> prev = {1, -1};
|
||||||
|
for (int i = 1; i < m; ++i) {
|
||||||
|
if (z[i - prev.first] + i <= prev.second) {
|
||||||
|
z.push_back(z[i - prev.first]);
|
||||||
|
} else {
|
||||||
|
int j = max(i, prev.second + 1);
|
||||||
|
while (j < m && t[j] == t[j - i]) ++j;
|
||||||
|
z.push_back(j - i);
|
||||||
|
prev = {i, j - 1};
|
||||||
|
}
|
||||||
|
}
|
||||||
|
return z;
|
||||||
|
}
|
||||||
|
vector<int> kmp(const string& s, const string& t) { // find all t in s
|
||||||
|
string cur = t + '#' + s;
|
||||||
|
int sz1 = s.size(), sz2 = t.size();
|
||||||
|
vector<int> v;
|
||||||
|
vector<int> lps = calc_next(cur);
|
||||||
|
for (int i = sz2 + 1; i <= sz1 + sz2; i++) {
|
||||||
|
if (lps[i] == sz2) v.push_back(i - 2 * sz2);
|
||||||
|
}
|
||||||
|
return v;
|
||||||
|
}
|
||||||
|
int period(const string& s) { // find the length of shortest recurring period
|
||||||
|
int n = s.length();
|
||||||
|
auto z = calc_z(s);
|
||||||
|
for (int i = 1; i <= n / 2; ++i) {
|
||||||
|
if (n % i == 0 && z[i] == n - i) {
|
||||||
|
return i;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
return n;
|
||||||
|
}
|
||||||
|
|
||||||
|
/* modular arithmetic */
|
||||||
|
template <ll mdl> struct MLL {
|
||||||
|
ll val;
|
||||||
|
MLL(ll v = 0) : val(mod(v, mdl)) {}
|
||||||
|
MLL(const MLL<mdl>& other) : val(other.val) {}
|
||||||
|
friend MLL operator+(const MLL& lhs, const MLL& rhs) { return mod(lhs.val + rhs.val, mdl); }
|
||||||
|
friend MLL operator-(const MLL& lhs, const MLL& rhs) { return mod(lhs.val - rhs.val, mdl); }
|
||||||
|
friend MLL operator*(const MLL& lhs, const MLL& rhs) { return mod(int128(lhs.val) * rhs.val, mdl); }
|
||||||
|
friend MLL operator/(const MLL& lhs, const MLL& rhs) { return lhs * mod(inverse(rhs.val, mdl), mdl); }
|
||||||
|
friend MLL operator%(const MLL& lhs, const MLL& rhs) { return mod(lhs.val - (lhs / rhs).val, mdl); }
|
||||||
|
friend bool operator==(const MLL& lhs, const MLL& rhs) { return lhs.val == rhs.val; }
|
||||||
|
friend bool operator!=(const MLL& lhs, const MLL& rhs) { return lhs.val != rhs.val; }
|
||||||
|
MLL& operator+=(const MLL& rhs) { return *this = *this + rhs; }
|
||||||
|
MLL& operator-=(const MLL& rhs) { return *this = *this - rhs; }
|
||||||
|
MLL& operator*=(const MLL& rhs) { return *this = *this * rhs; }
|
||||||
|
MLL& operator/=(const MLL& rhs) { return *this = *this / rhs; }
|
||||||
|
MLL& operator%=(const MLL& rhs) { return *this = *this % rhs; }
|
||||||
|
};
|
||||||
|
|
||||||
|
template <ll mdl>
|
||||||
|
ostream& operator<<(ostream& out, const MLL<mdl>& num) {
|
||||||
|
return out << num.val;
|
||||||
|
}
|
||||||
|
|
||||||
|
template <ll mdl>
|
||||||
|
istream& operator>>(istream& in, MLL<mdl>& num) {
|
||||||
|
return in >> num.val;
|
||||||
|
}
|
||||||
|
|
||||||
|
// miscancellous
|
||||||
|
template <typename T, typename U>
|
||||||
|
bool chmax(T& lhs, const U& rhs) {
|
||||||
|
bool ret = lhs < rhs;
|
||||||
|
if (ret) {
|
||||||
|
lhs = rhs;
|
||||||
|
}
|
||||||
|
return ret;
|
||||||
|
}
|
||||||
|
template <typename T, typename U>
|
||||||
|
bool chmin(T& lhs, const U& rhs) {
|
||||||
|
bool ret = lhs > rhs;
|
||||||
|
if (ret) {
|
||||||
|
lhs = rhs;
|
||||||
|
}
|
||||||
|
return ret;
|
||||||
|
}
|
||||||
|
|
||||||
|
#define functor(func) ([&](auto&&... val) \
|
||||||
|
noexcept(noexcept(func(std::forward<decltype(val)>(val)...))) -> decltype(auto) \
|
||||||
|
{return func(std::forward<decltype(val)>(val)...);})
|
||||||
|
#define expr(ret, ...) ([&] (__VA_ARGS__) { return (ret); })
|
||||||
|
template <typename Func, typename RandomIt> void sort_by_key(RandomIt first, RandomIt last, Func extractor) {
|
||||||
|
std::sort(first, last, [&] (auto&& a, auto&& b) { return std::less<>()(extractor(a), extractor(b)); });
|
||||||
|
}
|
||||||
|
template <typename Func, typename RandomIt, typename Compare> void sort_by_key(RandomIt first, RandomIt last, Func extractor, Compare comp) {
|
||||||
|
std::sort(first, last, [&] (auto&& a, auto&& b) { return comp(extractor(a), extractor(b)); });
|
||||||
|
}
|
||||||
|
template <typename T, typename U, typename Iterator_T, typename Iterator_U>
|
||||||
|
vector<pair<T, U>> zip(Iterator_T a_first, Iterator_T a_last, Iterator_U b_first, Iterator_U b_last) {
|
||||||
|
vector<pair<T, U>> res;
|
||||||
|
auto a_it = a_first;
|
||||||
|
auto b_it = b_first;
|
||||||
|
for (; not (a_it == a_last) and not (b_it == b_last); ++a_it, ++b_it) {
|
||||||
|
res.emplace_back(*a_it, *b_it);
|
||||||
|
}
|
||||||
|
return res;
|
||||||
|
}
|
||||||
|
template <typename T, typename U, typename Iterator_T, typename Iterator_U>
|
||||||
|
vector<pair<T, U>> zip_n(Iterator_T a_first, Iterator_U b_first, size_t n) {
|
||||||
|
vector<pair<T, U>> res;
|
||||||
|
if (n > 0) {
|
||||||
|
res.emplace_back(*a_first, *b_first);
|
||||||
|
for (size_t i = 1; i != n; ++i) {
|
||||||
|
res.emplace_back(*++a_first, *++b_first);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
return res;
|
||||||
|
}
|
||||||
|
template <typename T>
|
||||||
|
class ArithmeticIterator : bidirectional_iterator_tag {
|
||||||
|
public:
|
||||||
|
using difference_type = ptrdiff_t;
|
||||||
|
using value_type = T;
|
||||||
|
private:
|
||||||
|
value_type value;
|
||||||
|
public:
|
||||||
|
ArithmeticIterator(const T& value) : value(value) {}
|
||||||
|
value_type operator*() const { return value; }
|
||||||
|
ArithmeticIterator<T>& operator++() { ++value; return *this; }
|
||||||
|
ArithmeticIterator<T>& operator--() { --value; return *this; }
|
||||||
|
bool operator==(const ArithmeticIterator<T>& rhs) const { return value == rhs.value; }
|
||||||
|
};
|
||||||
|
template <typename T> vector<pair<int, T>> enumerate(const vector<T>& container) {
|
||||||
|
return zip<int, T>(ArithmeticIterator<int>(0), ArithmeticIterator<int>(INT_MAX), container.begin(), container.end());
|
||||||
|
}
|
||||||
|
#define initarray(init, N) (__initarray<decay<decltype(init)>::type, (N)>(init))
|
||||||
|
namespace detail {
|
||||||
|
template <typename T, std::size_t...Is>
|
||||||
|
constexpr std::array<T, sizeof...(Is)>
|
||||||
|
make_array(const T& value, std::index_sequence<Is...>) {
|
||||||
|
return {{(static_cast<void>(Is), value)...}};
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
template <typename T, std::size_t N>
|
||||||
|
constexpr std::array<T, N> __initarray(const T& value) {
|
||||||
|
return detail::make_array(value, std::make_index_sequence<N>());
|
||||||
|
}
|
||||||
|
/*******************************************************/
|
||||||
|
|
||||||
|
// #define SINGLE_TEST_CASE
|
||||||
|
// #define DUMP_TEST_CASE 7219
|
||||||
|
// #define TOT_TEST_CASE 10000
|
||||||
|
|
||||||
|
void dump() {}
|
||||||
|
|
||||||
|
void dump_ignore() {}
|
||||||
|
|
||||||
|
void prep() {
|
||||||
|
}
|
||||||
|
|
||||||
|
// __attribute__((target("popcnt")))
|
||||||
|
void solve() {
|
||||||
|
read(int, n);
|
||||||
|
read(string, a);
|
||||||
|
if (a[0] == '1' or a[n - 1] == '1') {
|
||||||
|
cout << "Alice\n";
|
||||||
|
} else {
|
||||||
|
cout << "Bob\n";
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
int main() {
|
||||||
|
#if __cplusplus < 201402L or defined(_MSC_VER) and not defined(__clang__)
|
||||||
|
static_assert(false, "incompatible compiler variant detected.");
|
||||||
|
#endif
|
||||||
|
untie;
|
||||||
|
prep();
|
||||||
|
#ifdef SINGLE_TEST_CASE
|
||||||
|
solve();
|
||||||
|
#else
|
||||||
|
read(int, t);
|
||||||
|
for (int i = 0; i < t; ++i) {
|
||||||
|
#ifdef DUMP_TEST_CASE
|
||||||
|
if (t != (TOT_TEST_CASE)) {
|
||||||
|
solve();
|
||||||
|
} else if (i + 1 == (DUMP_TEST_CASE)) {
|
||||||
|
dump();
|
||||||
|
} else {
|
||||||
|
dump_ignore();
|
||||||
|
}
|
||||||
|
#else
|
||||||
|
solve();
|
||||||
|
#endif
|
||||||
|
}
|
||||||
|
#endif
|
||||||
|
}
|
|
@ -0,0 +1,648 @@
|
||||||
|
// #pragma GCC target("popcnt,lzcnt,abm,bmi,bmi2")
|
||||||
|
#pragma GCC optimize("Ofast,unroll-loops")
|
||||||
|
/************* This code requires C++17. ***************/
|
||||||
|
|
||||||
|
#include<bits/stdc++.h>
|
||||||
|
using namespace std;
|
||||||
|
|
||||||
|
/* macro helpers */
|
||||||
|
#define __NARGS(...) std::tuple_size<decltype(std::make_tuple(__VA_ARGS__))>::value
|
||||||
|
#define __DECOMPOSE_S(a, x) auto x = a;
|
||||||
|
#define __DECOMPOSE_N(a, ...) auto [__VA_ARGS__] = a;
|
||||||
|
constexpr void __() {}
|
||||||
|
#define __AS_PROCEDURE(...) __(); __VA_ARGS__; __()
|
||||||
|
#define __as_typeof(container) remove_reference<decltype(container)>::type
|
||||||
|
template <typename T> struct argument_type;
|
||||||
|
template <typename T, typename U> struct argument_type<T(U)> { using type = U; };
|
||||||
|
|
||||||
|
/* type aliases */
|
||||||
|
#if LONG_LONG_MAX != INT64_MAX
|
||||||
|
using ll = int64_t;
|
||||||
|
using ull = uint64_t;
|
||||||
|
#else
|
||||||
|
using ll = long long;
|
||||||
|
using ull = unsigned long long;
|
||||||
|
#endif
|
||||||
|
using int128 = __int128_t;
|
||||||
|
using uint128 = __uint128_t;
|
||||||
|
using ld = __float128; // up to 1e-9 precision in binary search
|
||||||
|
using pii = pair<int, int>; using pil = pair<int, ll>; using pid = pair<int, ld>;
|
||||||
|
using pli = pair<ll, int>; using pll = pair<ll, ll>; using pld = pair<ll, ld>;
|
||||||
|
using pdi = pair<ld, int>; using pdl = pair<ld, ll>; using pdd = pair<ld, ld>;
|
||||||
|
using tiii = tuple<int, int, int>; using tiil = tuple<int, int, ll>; using tiid = tuple<int, int, ld>;
|
||||||
|
using tili = tuple<int, ll, int>; using till = tuple<int, ll, ll>; using tild = tuple<int, ll, ld>;
|
||||||
|
using tidi = tuple<int, ld, int>; using tidl = tuple<int, ld, ll>; using tidd = tuple<int, ld, ld>;
|
||||||
|
using tlii = tuple<ll, int, int>; using tlil = tuple<ll, int, ll>; using tlid = tuple<ll, int, ld>;
|
||||||
|
using tlli = tuple<ll, ll, int>; using tlll = tuple<ll, ll, ll>; using tlld = tuple<ll, ll, ld>;
|
||||||
|
using tldi = tuple<ll, ld, int>; using tldl = tuple<ll, ld, ll>; using tldd = tuple<ll, ld, ld>;
|
||||||
|
using tdii = tuple<ld, int, int>; using tdil = tuple<ld, int, ll>; using tdid = tuple<ld, int, ld>;
|
||||||
|
using tdli = tuple<ld, ll, int>; using tdll = tuple<ld, ll, ll>; using tdld = tuple<ld, ll, ld>;
|
||||||
|
using tddi = tuple<ld, ld, int>; using tddl = tuple<ld, ld, ll>; using tddd = tuple<ld, ld, ld>;
|
||||||
|
template <typename T> using max_heap = priority_queue<T>;
|
||||||
|
template <typename T> using min_heap = priority_queue<T, vector<T>, greater<>>;
|
||||||
|
template <typename T> using oi = ostream_iterator<T>;
|
||||||
|
template <typename T> using ii = istream_iterator<T>;
|
||||||
|
|
||||||
|
/* constants */
|
||||||
|
constexpr int INF = 0x3f3f3f3f;
|
||||||
|
constexpr ll INFLL = 0x3f3f3f3f3f3f3f3fLL;
|
||||||
|
constexpr ll MDL = 1e9 + 7;
|
||||||
|
constexpr ll PRIME = 998'244'353;
|
||||||
|
constexpr ll PRIMELL = 901017227882342239LL;
|
||||||
|
constexpr ll MDL1 = 8784491;
|
||||||
|
constexpr ll MDL2 = PRIME;
|
||||||
|
constexpr int128 INT128_MAX = numeric_limits<int128>::max();
|
||||||
|
constexpr uint128 UINT128_MAX = numeric_limits<uint128>::max();
|
||||||
|
constexpr int128 INT128_MIN = numeric_limits<int128>::min();
|
||||||
|
constexpr uint128 UINT128_MIN = numeric_limits<uint128>::min();
|
||||||
|
|
||||||
|
/* random */
|
||||||
|
|
||||||
|
mt19937_64 rd(chrono::duration_cast<chrono::milliseconds>(chrono::system_clock::now().time_since_epoch()).count());
|
||||||
|
|
||||||
|
/* bit-wise operations */
|
||||||
|
#define lowbit(x) ((x) & -(x))
|
||||||
|
#define popcount(x) (__builtin_popcountll(ll(x)))
|
||||||
|
#define parity(x) (__builtin_parityll(ll(x)))
|
||||||
|
#define msp(x) (63LL - __builtin_clzll(ll(x)))
|
||||||
|
#define lsp(x) (__builtin_ctzll(ll(x)))
|
||||||
|
|
||||||
|
/* arithmetic operations */
|
||||||
|
#define mod(x, y) ((((x) % (y)) + (y)) % (y))
|
||||||
|
|
||||||
|
/* fast pairs */
|
||||||
|
#define upair ull
|
||||||
|
#define umake(x, y) (ull(x) << 32 | (ull(y) & ((1ULL << 32) - 1)))
|
||||||
|
#define u1(p) ((p) >> 32)
|
||||||
|
#define u2(p) ((p) & ((1ULL << 32) - 1))
|
||||||
|
#define ult std::less<upair>
|
||||||
|
#define ugt std::greater<upair>
|
||||||
|
|
||||||
|
#define ipair ull
|
||||||
|
#define imake(x, y) (umake(x, y))
|
||||||
|
#define i1(p) (int(u1(ll(p))))
|
||||||
|
#define i2(p) (ll(u2(p) << 32) >> 32)
|
||||||
|
struct ilt {
|
||||||
|
bool operator()(const ipair& a, const ipair& b) const {
|
||||||
|
if (i1(a) == i1(b)) return i2(a) < i2(b);
|
||||||
|
else return i1(a) < i1(b);
|
||||||
|
}
|
||||||
|
};
|
||||||
|
struct igt {
|
||||||
|
bool operator()(const ipair& a, const ipair& b) const {
|
||||||
|
if (i1(a) == i1(b)) return i2(a) > i2(b);
|
||||||
|
else return i1(a) > i1(b);
|
||||||
|
}
|
||||||
|
};
|
||||||
|
|
||||||
|
/* conditions */
|
||||||
|
#define loop while (1)
|
||||||
|
#define if_or(var, val) if (!((var) == (val))) (var) = (val); else
|
||||||
|
#define continue_or(var, val) __AS_PROCEDURE(if ((var) == (val)) continue; (var) = (val);)
|
||||||
|
#define break_or(var, val) __AS_PROCEDURE(if ((var) == (val)) break; (var) = (val);)
|
||||||
|
|
||||||
|
/* hash */
|
||||||
|
struct safe_hash {
|
||||||
|
// https://codeforces.com/blog/entry/62393
|
||||||
|
static uint64_t splitmix64(uint64_t x) {
|
||||||
|
// http://xorshift.di.unimi.it/splitmix64.c
|
||||||
|
x += 0x9e3779b97f4a7c15;
|
||||||
|
x = (x ^ (x >> 30)) * 0xbf58476d1ce4e5b9;
|
||||||
|
x = (x ^ (x >> 27)) * 0x94d049bb133111eb;
|
||||||
|
return x ^ (x >> 31);
|
||||||
|
}
|
||||||
|
|
||||||
|
size_t operator()(uint64_t x) const {
|
||||||
|
static const uint64_t FIXED_RANDOM = chrono::steady_clock::now().time_since_epoch().count();
|
||||||
|
return splitmix64(x + FIXED_RANDOM);
|
||||||
|
}
|
||||||
|
};
|
||||||
|
|
||||||
|
struct pair_hash {
|
||||||
|
template <typename T, typename U>
|
||||||
|
size_t operator()(const pair<T, U>& a) const {
|
||||||
|
auto hash1 = safe_hash()(a.first);
|
||||||
|
auto hash2 = safe_hash()(a.second);
|
||||||
|
if (hash1 != hash2) {
|
||||||
|
return hash1 ^ hash2;
|
||||||
|
}
|
||||||
|
return hash1;
|
||||||
|
}
|
||||||
|
};
|
||||||
|
|
||||||
|
uniform_int_distribution<mt19937::result_type> dist(PRIME);
|
||||||
|
const size_t __array_hash_b = 31, __array_hash_mdl1 = dist(rd), __array_hash_mdl2 = dist(rd);
|
||||||
|
struct array_hash {
|
||||||
|
safe_hash hasher;
|
||||||
|
template <typename Sequence>
|
||||||
|
size_t operator()(const Sequence& arr) const {
|
||||||
|
size_t pw1 = 1, pw2 = 1;
|
||||||
|
size_t res1 = 0, res2 = 0;
|
||||||
|
for (auto&& x : arr) {
|
||||||
|
auto h = hasher(x);
|
||||||
|
res1 = (res1 + h * pw1) % __array_hash_mdl1;
|
||||||
|
res2 = (res2 + h * pw2) % __array_hash_mdl2;
|
||||||
|
pw1 = (pw1 * __array_hash_b) % __array_hash_mdl1;
|
||||||
|
pw2 = (pw2 * __array_hash_b) % __array_hash_mdl2;
|
||||||
|
}
|
||||||
|
return res1 + res2;
|
||||||
|
}
|
||||||
|
};
|
||||||
|
|
||||||
|
/* build data structures */
|
||||||
|
#define faster(um) __AS_PROCEDURE((um).reserve(1024); (um).max_load_factor(0.25);)
|
||||||
|
#define unordered_counter(from, to) __AS_PROCEDURE(unordered_map<__as_typeof(from), size_t, safe_hash> to; for (auto&& x : from) ++to[x];)
|
||||||
|
#define counter(from, to, cmp) __AS_PROCEDURE(map<__as_typeof(from), size_t, cmp> to; for (auto&& x : from) ++to[x];)
|
||||||
|
#define adj(ch, n) __AS_PROCEDURE(vector<vector<int>> ch((n) + 1);)
|
||||||
|
#define edge(ch, u, v) __AS_PROCEDURE(ch[u].push_back(v), ch[v].push_back(u);)
|
||||||
|
#define edgew(ch, u, v, ...) __AS_PROCEDURE(ch[u].emplace_back(v, __VA_ARGS__), ch[v].emplace_back(u, __VA_ARGS__);)
|
||||||
|
#define Edge(ch, u, v) __AS_PROCEDURE(ch[u].push_back(v);)
|
||||||
|
#define Edgew(ch, u, v, ...) __AS_PROCEDURE(ch[u].emplace_back(v, __VA_ARGS__);)
|
||||||
|
template <typename T, typename Iterator> pair<size_t, map<T, size_t>> discretize(Iterator __first, Iterator __last) {
|
||||||
|
set<T> st(__first, __last);
|
||||||
|
size_t N = 0;
|
||||||
|
map<T, size_t> mp;
|
||||||
|
for (auto&& x : st) mp[x] = ++N;
|
||||||
|
return {N, mp};
|
||||||
|
}
|
||||||
|
template <typename T, typename Iterator> pair<size_t, unordered_map<T, size_t, safe_hash>> unordered_discretize(Iterator __first, Iterator __last) {
|
||||||
|
set<T> st(__first, __last);
|
||||||
|
size_t N = 0;
|
||||||
|
unordered_map<T, size_t, safe_hash> mp;
|
||||||
|
for (auto&& x : st) mp[x] = ++N;
|
||||||
|
return {N, mp};
|
||||||
|
}
|
||||||
|
|
||||||
|
/* io */
|
||||||
|
#define untie __AS_PROCEDURE(ios_base::sync_with_stdio(0), cin.tie(NULL))
|
||||||
|
|
||||||
|
// add declarations to avoid circular dependency
|
||||||
|
template<typename T, typename U> istream& operator>>(istream&, pair<T, U>&);
|
||||||
|
template<typename T, typename U> ostream& operator<<(ostream&, const pair<T, U>&);
|
||||||
|
template<typename T, size_t N> istream& operator>>(istream&, array<T, N>&);
|
||||||
|
template <typename T, size_t N> ostream& operator<<(ostream&, const array<T, N>&);
|
||||||
|
template<typename Char, typename Traits, typename... Args>
|
||||||
|
decltype(auto) operator<<(std::basic_ostream<Char, Traits>&, const std::tuple<Args...>&);
|
||||||
|
template<typename T> ostream& operator<<(ostream&, const vector<T>&);
|
||||||
|
std::ostream& operator<<(std::ostream&, const int128&);
|
||||||
|
|
||||||
|
template<typename T, typename U> istream& operator>>(istream& in, pair<T, U>& p) {
|
||||||
|
return in >> p.first >> p.second;
|
||||||
|
}
|
||||||
|
template<typename T, typename U> ostream& operator<<(ostream& out, const pair<T, U>& p) {
|
||||||
|
out << "{" << p.first << ", " << p.second << "}";
|
||||||
|
return out;
|
||||||
|
}
|
||||||
|
template<typename T, size_t N> istream& operator>>(istream& in, array<T, N>& a) {
|
||||||
|
for (size_t i = 0; i < N; ++i) in >> a[i];
|
||||||
|
return in;
|
||||||
|
}
|
||||||
|
template <typename T, size_t N> ostream& operator<<(ostream& out, const array<T, N>& a) {
|
||||||
|
for (auto&& i : a) out << i << ' ';
|
||||||
|
return out;
|
||||||
|
}
|
||||||
|
template<typename Char, typename Traits, typename Tuple, std::size_t... Index>
|
||||||
|
void print_tuple_impl(std::basic_ostream<Char, Traits>& os, const Tuple& t, std::index_sequence<Index...>) {
|
||||||
|
using swallow = int[]; // guaranties left to right order
|
||||||
|
(void)swallow { 0, (void(os << (Index == 0 ? "" : ", ") << std::get<Index>(t)), 0)... };
|
||||||
|
}
|
||||||
|
template<typename Char, typename Traits, typename... Args>
|
||||||
|
decltype(auto) operator<<(std::basic_ostream<Char, Traits>& os, const std::tuple<Args...>& t) {
|
||||||
|
os << "{";
|
||||||
|
print_tuple_impl(os, t, std::index_sequence_for<Args...>{});
|
||||||
|
return os << "}";
|
||||||
|
}
|
||||||
|
template<typename T> ostream& operator<<(ostream& out, const vector<T>& vec) {
|
||||||
|
for (auto&& i : vec) out << i << ' ';
|
||||||
|
return out;
|
||||||
|
}
|
||||||
|
std::ostream& operator<<(std::ostream& dest, const int128& value) {
|
||||||
|
// https://stackoverflow.com/a/25115163/23881100
|
||||||
|
std::ostream::sentry s( dest );
|
||||||
|
if ( s ) {
|
||||||
|
uint128 tmp = value < 0 ? -value : value;
|
||||||
|
char buffer[ 128 ];
|
||||||
|
char* d = std::end( buffer );
|
||||||
|
do {
|
||||||
|
-- d;
|
||||||
|
*d = "0123456789"[ tmp % 10 ];
|
||||||
|
tmp /= 10;
|
||||||
|
} while ( tmp != 0 );
|
||||||
|
if ( value < 0 ) {
|
||||||
|
-- d;
|
||||||
|
*d = '-';
|
||||||
|
}
|
||||||
|
int len = std::end( buffer ) - d;
|
||||||
|
if ( dest.rdbuf()->sputn( d, len ) != len ) {
|
||||||
|
dest.setstate( std::ios_base::badbit );
|
||||||
|
}
|
||||||
|
}
|
||||||
|
return dest;
|
||||||
|
}
|
||||||
|
template<typename T> void __read(T& x) { cin >> x; }
|
||||||
|
template<typename T, typename... U> void __read(T& x, U&... args) { cin >> x; __read(args...); }
|
||||||
|
#define read(t, ...) __AS_PROCEDURE(argument_type<void(t)>::type __VA_ARGS__; __read(__VA_ARGS__);)
|
||||||
|
#define readvec(t, a, n) __AS_PROCEDURE(vector<argument_type<void(t)>::type> a(n); for (auto& x : (a)) cin >> x;)
|
||||||
|
#define readvec1(t, a, n) __AS_PROCEDURE(vector<argument_type<void(t)>::type> a((n) + 1); copy_n(ii<argument_type<void(t)>::type>(cin), (n), (a).begin() + 1);)
|
||||||
|
#define putvec(a) __AS_PROCEDURE(copy((a).begin(), (a).end(), oi<__as_typeof(a)::value_type>(cout, " ")); cout << endl;)
|
||||||
|
#define putvec1(a) __AS_PROCEDURE(copy((a).begin() + 1, (a).end(), oi<__as_typeof(a)::value_type>(cout, " ")); cout << endl;)
|
||||||
|
#define putvec_eol(a) __AS_PROCEDURE(copy((a).begin(), (a).end(), oi<__as_typeof(a)::value_type>(cout, "\n"));)
|
||||||
|
#define putvec1_eol(a) __AS_PROCEDURE(copy((a).begin() + 1, (a).end(), oi<__as_typeof(a)::value_type>(cout, "\n"));)
|
||||||
|
#define debug(x) __AS_PROCEDURE(cerr << #x" = " << (x) << endl;)
|
||||||
|
#define debugvec(a) __AS_PROCEDURE(cerr << #a" = "; for (auto&& x : (a)) cerr << x << ' '; cerr << endl;)
|
||||||
|
#define deb(...) debug(make_tuple(__VA_ARGS__))
|
||||||
|
|
||||||
|
/* pops */
|
||||||
|
template <typename Container>
|
||||||
|
inline auto poptop(Container& q) {
|
||||||
|
auto ret = q.top();
|
||||||
|
q.pop();
|
||||||
|
return ret;
|
||||||
|
}
|
||||||
|
template <typename Container>
|
||||||
|
inline auto popback(Container& q) {
|
||||||
|
auto ret = q.back();
|
||||||
|
q.pop_back();
|
||||||
|
return ret;
|
||||||
|
}
|
||||||
|
template <typename Container>
|
||||||
|
inline auto popfront(Container& q) {
|
||||||
|
auto ret = q.front();
|
||||||
|
q.pop_front();
|
||||||
|
return ret;
|
||||||
|
}
|
||||||
|
|
||||||
|
/* math */
|
||||||
|
template <typename return_t>
|
||||||
|
return_t qpow(ll b, ll p) {
|
||||||
|
if (b == 0 and p != 0) return 0;
|
||||||
|
if (p == 0) return 1;
|
||||||
|
return_t half = qpow<return_t>(b, p / 2);
|
||||||
|
if (p % 2 == 1) return half * half * b;
|
||||||
|
else return half * half;
|
||||||
|
}
|
||||||
|
|
||||||
|
// dynamic modulus
|
||||||
|
ll qpow(ll b, ll p, ll mod) {
|
||||||
|
if (b == 0 and p != 0) return 0;
|
||||||
|
if (p == 0) return 1;
|
||||||
|
ll half = qpow(b, p / 2, mod);
|
||||||
|
if (p % 2 == 1) return (int128(half) * half % mod) * b % mod;
|
||||||
|
else return half * half % mod;
|
||||||
|
}
|
||||||
|
|
||||||
|
|
||||||
|
#pragma GCC diagnostic push
|
||||||
|
#pragma GCC diagnostic ignored "-Wparentheses"
|
||||||
|
// Accurately find `i` 'th root of `n` (taking the floor)
|
||||||
|
inline ll root(ll n, ll i) {
|
||||||
|
ll l = 0, r = pow(LLONG_MAX, (long double)(1) / i);
|
||||||
|
while (l < r) {
|
||||||
|
ll mid = l + r + 1 >> 1;
|
||||||
|
if (qpow<int128>(mid, i) <= n) {
|
||||||
|
l = mid;
|
||||||
|
} else {
|
||||||
|
r = mid - 1;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
return l;
|
||||||
|
}
|
||||||
|
#pragma GCC diagnostic pop
|
||||||
|
|
||||||
|
|
||||||
|
#define comb(n, k) ((n) < 0 or (k) < 0 or (n) < (k) ? 0 : fact[n] / fact[k] / fact[(n) - (k)])
|
||||||
|
#define fastcomb(n, k) ((n) < 0 or (k) < 0 or (n) < (k) ? 0 : fact[n] * factrev[k] * factrev[(n) - (k)])
|
||||||
|
|
||||||
|
__attribute__((target("lzcnt")))
|
||||||
|
constexpr inline int lg2(ll x) { return x == 0 ? -1 : sizeof(ll) * 8 - 1 - __builtin_clzll(x); }
|
||||||
|
|
||||||
|
template <typename T>
|
||||||
|
T mygcd(T a, T b) { return b == 0 ? a : mygcd(b, a % b); }
|
||||||
|
|
||||||
|
void __exgcd(ll a, ll b, ll& x, ll& y) {
|
||||||
|
if (b == 0) {
|
||||||
|
x = 1, y = 0;
|
||||||
|
return;
|
||||||
|
}
|
||||||
|
__exgcd(b, a % b, y, x);
|
||||||
|
y -= a / b * x;
|
||||||
|
}
|
||||||
|
|
||||||
|
ll inverse(ll a, ll b) {
|
||||||
|
ll x, y;
|
||||||
|
__exgcd(a, b, x, y);
|
||||||
|
return mod(x, b);
|
||||||
|
}
|
||||||
|
|
||||||
|
vector<tuple<int, int, ll>> decompose(ll x) {
|
||||||
|
// return (factor, count, factor ** count)
|
||||||
|
vector<tuple<int, int, ll>> res;
|
||||||
|
for (int i = 2; i * i <= x; i++) {
|
||||||
|
if (x % i == 0) {
|
||||||
|
int cnt = 0;
|
||||||
|
ll pw = 1;
|
||||||
|
while (x % i == 0) ++cnt, x /= i, pw *= i;
|
||||||
|
res.emplace_back(i, cnt, pw);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
if (x != 1) {
|
||||||
|
res.emplace_back(x, 1, x);
|
||||||
|
}
|
||||||
|
return res;
|
||||||
|
}
|
||||||
|
|
||||||
|
vector<pii> decompose_prime(int N) {
|
||||||
|
// return (factor, count)
|
||||||
|
vector<pii> result;
|
||||||
|
for (int i = 2; i * i <= N; i++) {
|
||||||
|
if (N % i == 0) {
|
||||||
|
int cnt = 0;
|
||||||
|
while (N % i == 0) N /= i, ++cnt;
|
||||||
|
result.emplace_back(i, cnt);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
if (N != 1) {
|
||||||
|
result.emplace_back(N, 1);
|
||||||
|
}
|
||||||
|
return result;
|
||||||
|
}
|
||||||
|
|
||||||
|
/* string algorithms */
|
||||||
|
vector<int> calc_next(string t) { // pi function of t
|
||||||
|
int n = (int)t.length();
|
||||||
|
vector<int> pi(n);
|
||||||
|
for (int i = 1; i < n; i++) {
|
||||||
|
int j = pi[i - 1];
|
||||||
|
while (j > 0 && t[i] != t[j]) j = pi[j - 1];
|
||||||
|
if (t[i] == t[j]) j++;
|
||||||
|
pi[i] = j;
|
||||||
|
}
|
||||||
|
return pi;
|
||||||
|
}
|
||||||
|
vector<int> calc_z(string t) { // z function of t
|
||||||
|
int m = t.length();
|
||||||
|
vector<int> z;
|
||||||
|
z.push_back(m);
|
||||||
|
pair<int, int> prev = {1, -1};
|
||||||
|
for (int i = 1; i < m; ++i) {
|
||||||
|
if (z[i - prev.first] + i <= prev.second) {
|
||||||
|
z.push_back(z[i - prev.first]);
|
||||||
|
} else {
|
||||||
|
int j = max(i, prev.second + 1);
|
||||||
|
while (j < m && t[j] == t[j - i]) ++j;
|
||||||
|
z.push_back(j - i);
|
||||||
|
prev = {i, j - 1};
|
||||||
|
}
|
||||||
|
}
|
||||||
|
return z;
|
||||||
|
}
|
||||||
|
vector<int> kmp(const string& s, const string& t) { // find all t in s
|
||||||
|
string cur = t + '#' + s;
|
||||||
|
int sz1 = s.size(), sz2 = t.size();
|
||||||
|
vector<int> v;
|
||||||
|
vector<int> lps = calc_next(cur);
|
||||||
|
for (int i = sz2 + 1; i <= sz1 + sz2; i++) {
|
||||||
|
if (lps[i] == sz2) v.push_back(i - 2 * sz2);
|
||||||
|
}
|
||||||
|
return v;
|
||||||
|
}
|
||||||
|
int period(const string& s) { // find the length of shortest recurring period
|
||||||
|
int n = s.length();
|
||||||
|
auto z = calc_z(s);
|
||||||
|
for (int i = 1; i <= n / 2; ++i) {
|
||||||
|
if (n % i == 0 && z[i] == n - i) {
|
||||||
|
return i;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
return n;
|
||||||
|
}
|
||||||
|
|
||||||
|
/* modular arithmetic */
|
||||||
|
template <ll mdl> struct MLL {
|
||||||
|
ll val;
|
||||||
|
MLL(ll v = 0) : val(mod(v, mdl)) {}
|
||||||
|
MLL(const MLL<mdl>& other) : val(other.val) {}
|
||||||
|
friend MLL operator+(const MLL& lhs, const MLL& rhs) { return mod(lhs.val + rhs.val, mdl); }
|
||||||
|
friend MLL operator-(const MLL& lhs, const MLL& rhs) { return mod(lhs.val - rhs.val, mdl); }
|
||||||
|
friend MLL operator*(const MLL& lhs, const MLL& rhs) { return mod(int128(lhs.val) * rhs.val, mdl); }
|
||||||
|
friend MLL operator/(const MLL& lhs, const MLL& rhs) { return lhs * mod(inverse(rhs.val, mdl), mdl); }
|
||||||
|
friend MLL operator%(const MLL& lhs, const MLL& rhs) { return mod(lhs.val - (lhs / rhs).val, mdl); }
|
||||||
|
friend bool operator==(const MLL& lhs, const MLL& rhs) { return lhs.val == rhs.val; }
|
||||||
|
friend bool operator!=(const MLL& lhs, const MLL& rhs) { return lhs.val != rhs.val; }
|
||||||
|
MLL& operator+=(const MLL& rhs) { return *this = *this + rhs; }
|
||||||
|
MLL& operator-=(const MLL& rhs) { return *this = *this - rhs; }
|
||||||
|
MLL& operator*=(const MLL& rhs) { return *this = *this * rhs; }
|
||||||
|
MLL& operator/=(const MLL& rhs) { return *this = *this / rhs; }
|
||||||
|
MLL& operator%=(const MLL& rhs) { return *this = *this % rhs; }
|
||||||
|
};
|
||||||
|
|
||||||
|
template <ll mdl>
|
||||||
|
ostream& operator<<(ostream& out, const MLL<mdl>& num) {
|
||||||
|
return out << num.val;
|
||||||
|
}
|
||||||
|
|
||||||
|
template <ll mdl>
|
||||||
|
istream& operator>>(istream& in, MLL<mdl>& num) {
|
||||||
|
return in >> num.val;
|
||||||
|
}
|
||||||
|
|
||||||
|
// miscancellous
|
||||||
|
template <typename T, typename U>
|
||||||
|
bool chmax(T& lhs, const U& rhs) {
|
||||||
|
bool ret = lhs < rhs;
|
||||||
|
if (ret) {
|
||||||
|
lhs = rhs;
|
||||||
|
}
|
||||||
|
return ret;
|
||||||
|
}
|
||||||
|
template <typename T, typename U>
|
||||||
|
bool chmin(T& lhs, const U& rhs) {
|
||||||
|
bool ret = lhs > rhs;
|
||||||
|
if (ret) {
|
||||||
|
lhs = rhs;
|
||||||
|
}
|
||||||
|
return ret;
|
||||||
|
}
|
||||||
|
|
||||||
|
#define functor(func) ([&](auto&&... val) \
|
||||||
|
noexcept(noexcept(func(std::forward<decltype(val)>(val)...))) -> decltype(auto) \
|
||||||
|
{return func(std::forward<decltype(val)>(val)...);})
|
||||||
|
#define expr(ret, ...) ([&] (__VA_ARGS__) { return (ret); })
|
||||||
|
template <typename Func, typename RandomIt> void sort_by_key(RandomIt first, RandomIt last, Func extractor) {
|
||||||
|
std::sort(first, last, [&] (auto&& a, auto&& b) { return std::less<>()(extractor(a), extractor(b)); });
|
||||||
|
}
|
||||||
|
template <typename Func, typename RandomIt, typename Compare> void sort_by_key(RandomIt first, RandomIt last, Func extractor, Compare comp) {
|
||||||
|
std::sort(first, last, [&] (auto&& a, auto&& b) { return comp(extractor(a), extractor(b)); });
|
||||||
|
}
|
||||||
|
template <typename T, typename U, typename Iterator_T, typename Iterator_U>
|
||||||
|
vector<pair<T, U>> zip(Iterator_T a_first, Iterator_T a_last, Iterator_U b_first, Iterator_U b_last) {
|
||||||
|
vector<pair<T, U>> res;
|
||||||
|
auto a_it = a_first;
|
||||||
|
auto b_it = b_first;
|
||||||
|
for (; not (a_it == a_last) and not (b_it == b_last); ++a_it, ++b_it) {
|
||||||
|
res.emplace_back(*a_it, *b_it);
|
||||||
|
}
|
||||||
|
return res;
|
||||||
|
}
|
||||||
|
template <typename T, typename U, typename Iterator_T, typename Iterator_U>
|
||||||
|
vector<pair<T, U>> zip_n(Iterator_T a_first, Iterator_U b_first, size_t n) {
|
||||||
|
vector<pair<T, U>> res;
|
||||||
|
if (n > 0) {
|
||||||
|
res.emplace_back(*a_first, *b_first);
|
||||||
|
for (size_t i = 1; i != n; ++i) {
|
||||||
|
res.emplace_back(*++a_first, *++b_first);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
return res;
|
||||||
|
}
|
||||||
|
template <typename T>
|
||||||
|
class ArithmeticIterator : bidirectional_iterator_tag {
|
||||||
|
public:
|
||||||
|
using difference_type = ptrdiff_t;
|
||||||
|
using value_type = T;
|
||||||
|
private:
|
||||||
|
value_type value;
|
||||||
|
public:
|
||||||
|
ArithmeticIterator(const T& value) : value(value) {}
|
||||||
|
value_type operator*() const { return value; }
|
||||||
|
ArithmeticIterator<T>& operator++() { ++value; return *this; }
|
||||||
|
ArithmeticIterator<T>& operator--() { --value; return *this; }
|
||||||
|
bool operator==(const ArithmeticIterator<T>& rhs) const { return value == rhs.value; }
|
||||||
|
};
|
||||||
|
template <typename T> vector<pair<int, T>> enumerate(const vector<T>& container) {
|
||||||
|
return zip<int, T>(ArithmeticIterator<int>(0), ArithmeticIterator<int>(INT_MAX), container.begin(), container.end());
|
||||||
|
}
|
||||||
|
#define initarray(init, N) (__initarray<decay<decltype(init)>::type, (N)>(init))
|
||||||
|
namespace detail {
|
||||||
|
template <typename T, std::size_t...Is>
|
||||||
|
constexpr std::array<T, sizeof...(Is)>
|
||||||
|
make_array(const T& value, std::index_sequence<Is...>) {
|
||||||
|
return {{(static_cast<void>(Is), value)...}};
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
template <typename T, std::size_t N>
|
||||||
|
constexpr std::array<T, N> __initarray(const T& value) {
|
||||||
|
return detail::make_array(value, std::make_index_sequence<N>());
|
||||||
|
}
|
||||||
|
/*******************************************************/
|
||||||
|
|
||||||
|
#define SINGLE_TEST_CASE
|
||||||
|
// #define DUMP_TEST_CASE 7219
|
||||||
|
// #define TOT_TEST_CASE 10000
|
||||||
|
|
||||||
|
void dump() {}
|
||||||
|
|
||||||
|
void dump_ignore() {}
|
||||||
|
|
||||||
|
void prep() {
|
||||||
|
}
|
||||||
|
|
||||||
|
template<typename T>
|
||||||
|
struct BIT {
|
||||||
|
int n;
|
||||||
|
vector<T> c;
|
||||||
|
BIT(size_t n) : n(n), c(n + 1) {}
|
||||||
|
void add(size_t i, const T& k) {
|
||||||
|
while (i <= n) {
|
||||||
|
c[i] += k;
|
||||||
|
i += lowbit(i);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
T getsum(size_t i) {
|
||||||
|
T res = {};
|
||||||
|
while (i) {
|
||||||
|
res += c[i];
|
||||||
|
i -= lowbit(i);
|
||||||
|
}
|
||||||
|
return res;
|
||||||
|
}
|
||||||
|
};
|
||||||
|
|
||||||
|
|
||||||
|
// __attribute__((target("popcnt")))
|
||||||
|
void solve() {
|
||||||
|
read(int, n, m);
|
||||||
|
n += 1;
|
||||||
|
vector cntrj(n, vector<int>(26));
|
||||||
|
vector ac(n, vector<bool>(26));
|
||||||
|
vector<pil> status(n);
|
||||||
|
|
||||||
|
vector<tuple<string, int, ll, int>> events;
|
||||||
|
vector<ll> oc = { ll(26) << 32 };
|
||||||
|
for (int i = 0; i < m; ++i) {
|
||||||
|
ll time = 0;
|
||||||
|
read(string, raw_time);
|
||||||
|
time += stoi(raw_time.substr(0, 2)) * 60 + stoi(raw_time.substr(3, 2));
|
||||||
|
read(int, team);
|
||||||
|
read(char, raw_no);
|
||||||
|
int no = raw_no - 'A';
|
||||||
|
read(string, raw_stat);
|
||||||
|
int stat = raw_stat == "AC";
|
||||||
|
bool upd = team == 0 and stat and not ac[team][no];
|
||||||
|
if (stat) {
|
||||||
|
if (ac[team][no]) {
|
||||||
|
;;
|
||||||
|
} else {
|
||||||
|
ac[team][no] = 1;
|
||||||
|
status[team].first += 1;
|
||||||
|
status[team].second += time + ll(1) * 20 * cntrj[team][no];
|
||||||
|
}
|
||||||
|
} else {
|
||||||
|
cntrj[team][no] += 1;
|
||||||
|
}
|
||||||
|
// deb(team, status[team]);
|
||||||
|
ll currstatus = (26 - ll(1) * status[team].first) << 32 bitor status[team].second;
|
||||||
|
oc.emplace_back(currstatus);
|
||||||
|
events.emplace_back(raw_time, team, currstatus, upd ? no : -1);
|
||||||
|
}
|
||||||
|
|
||||||
|
sort(oc.begin(), oc.end());
|
||||||
|
int t = unique(oc.begin(), oc.end()) - oc.begin();
|
||||||
|
oc.resize(t);
|
||||||
|
auto get = [&] (ll x) { return lower_bound(oc.begin(), oc.end(), x) - oc.begin(); };
|
||||||
|
|
||||||
|
BIT<int> tr(t);
|
||||||
|
|
||||||
|
vector<ll> curr(n, (ll(1) * 26) << 32);
|
||||||
|
tr.add((ll(1) * 26) << 32, n);
|
||||||
|
|
||||||
|
for (auto&& [raw_time, team, penalty, no] : events) {
|
||||||
|
int old;
|
||||||
|
if (no != -1) {
|
||||||
|
old = tr.getsum(get(curr[0])) + 1;
|
||||||
|
}
|
||||||
|
tr.add(get(curr[team]) + 1, -1);
|
||||||
|
curr[team] = penalty;
|
||||||
|
tr.add(get(curr[team]) + 1, 1);
|
||||||
|
if (no != -1) {
|
||||||
|
cout << raw_time << ' ' << char(no + 'A') << " #" << old << " -> #" << tr.getsum(get(curr[0])) + 1 << '\n';
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
int main() {
|
||||||
|
#if __cplusplus < 201402L or defined(_MSC_VER) and not defined(__clang__)
|
||||||
|
static_assert(false, "incompatible compiler variant detected.");
|
||||||
|
#endif
|
||||||
|
untie;
|
||||||
|
prep();
|
||||||
|
#ifdef SINGLE_TEST_CASE
|
||||||
|
solve();
|
||||||
|
#else
|
||||||
|
read(int, t);
|
||||||
|
for (int i = 0; i < t; ++i) {
|
||||||
|
#ifdef DUMP_TEST_CASE
|
||||||
|
if (t != (TOT_TEST_CASE)) {
|
||||||
|
solve();
|
||||||
|
} else if (i + 1 == (DUMP_TEST_CASE)) {
|
||||||
|
dump();
|
||||||
|
} else {
|
||||||
|
dump_ignore();
|
||||||
|
}
|
||||||
|
#else
|
||||||
|
solve();
|
||||||
|
#endif
|
||||||
|
}
|
||||||
|
#endif
|
||||||
|
}
|
|
@ -0,0 +1,651 @@
|
||||||
|
// #pragma GCC target("popcnt,lzcnt,abm,bmi,bmi2")
|
||||||
|
#pragma GCC optimize("Ofast,unroll-loops")
|
||||||
|
/************* This code requires C++17. ***************/
|
||||||
|
|
||||||
|
#include<bits/stdc++.h>
|
||||||
|
using namespace std;
|
||||||
|
|
||||||
|
/* macro helpers */
|
||||||
|
#define __NARGS(...) std::tuple_size<decltype(std::make_tuple(__VA_ARGS__))>::value
|
||||||
|
#define __DECOMPOSE_S(a, x) auto x = a;
|
||||||
|
#define __DECOMPOSE_N(a, ...) auto [__VA_ARGS__] = a;
|
||||||
|
constexpr void __() {}
|
||||||
|
#define __AS_PROCEDURE(...) __(); __VA_ARGS__; __()
|
||||||
|
#define __as_typeof(container) remove_reference<decltype(container)>::type
|
||||||
|
template <typename T> struct argument_type;
|
||||||
|
template <typename T, typename U> struct argument_type<T(U)> { using type = U; };
|
||||||
|
|
||||||
|
/* type aliases */
|
||||||
|
#if LONG_LONG_MAX != INT64_MAX
|
||||||
|
using ll = int64_t;
|
||||||
|
using ull = uint64_t;
|
||||||
|
#else
|
||||||
|
using ll = long long;
|
||||||
|
using ull = unsigned long long;
|
||||||
|
#endif
|
||||||
|
using int128 = __int128_t;
|
||||||
|
using uint128 = __uint128_t;
|
||||||
|
using ld = __float128; // up to 1e-9 precision in binary search
|
||||||
|
using pii = pair<int, int>; using pil = pair<int, ll>; using pid = pair<int, ld>;
|
||||||
|
using pli = pair<ll, int>; using pll = pair<ll, ll>; using pld = pair<ll, ld>;
|
||||||
|
using pdi = pair<ld, int>; using pdl = pair<ld, ll>; using pdd = pair<ld, ld>;
|
||||||
|
using tiii = tuple<int, int, int>; using tiil = tuple<int, int, ll>; using tiid = tuple<int, int, ld>;
|
||||||
|
using tili = tuple<int, ll, int>; using till = tuple<int, ll, ll>; using tild = tuple<int, ll, ld>;
|
||||||
|
using tidi = tuple<int, ld, int>; using tidl = tuple<int, ld, ll>; using tidd = tuple<int, ld, ld>;
|
||||||
|
using tlii = tuple<ll, int, int>; using tlil = tuple<ll, int, ll>; using tlid = tuple<ll, int, ld>;
|
||||||
|
using tlli = tuple<ll, ll, int>; using tlll = tuple<ll, ll, ll>; using tlld = tuple<ll, ll, ld>;
|
||||||
|
using tldi = tuple<ll, ld, int>; using tldl = tuple<ll, ld, ll>; using tldd = tuple<ll, ld, ld>;
|
||||||
|
using tdii = tuple<ld, int, int>; using tdil = tuple<ld, int, ll>; using tdid = tuple<ld, int, ld>;
|
||||||
|
using tdli = tuple<ld, ll, int>; using tdll = tuple<ld, ll, ll>; using tdld = tuple<ld, ll, ld>;
|
||||||
|
using tddi = tuple<ld, ld, int>; using tddl = tuple<ld, ld, ll>; using tddd = tuple<ld, ld, ld>;
|
||||||
|
template <typename T> using max_heap = priority_queue<T>;
|
||||||
|
template <typename T> using min_heap = priority_queue<T, vector<T>, greater<>>;
|
||||||
|
template <typename T> using oi = ostream_iterator<T>;
|
||||||
|
template <typename T> using ii = istream_iterator<T>;
|
||||||
|
|
||||||
|
/* constants */
|
||||||
|
constexpr int INF = 0x3f3f3f3f;
|
||||||
|
constexpr ll INFLL = 0x3f3f3f3f3f3f3f3fLL;
|
||||||
|
constexpr ll MDL = 1e9 + 7;
|
||||||
|
constexpr ll PRIME = 998'244'353;
|
||||||
|
constexpr ll PRIMELL = 901017227882342239LL;
|
||||||
|
constexpr ll MDL1 = 8784491;
|
||||||
|
constexpr ll MDL2 = PRIME;
|
||||||
|
constexpr int128 INT128_MAX = numeric_limits<int128>::max();
|
||||||
|
constexpr uint128 UINT128_MAX = numeric_limits<uint128>::max();
|
||||||
|
constexpr int128 INT128_MIN = numeric_limits<int128>::min();
|
||||||
|
constexpr uint128 UINT128_MIN = numeric_limits<uint128>::min();
|
||||||
|
|
||||||
|
/* random */
|
||||||
|
|
||||||
|
mt19937_64 rd(chrono::duration_cast<chrono::milliseconds>(chrono::system_clock::now().time_since_epoch()).count());
|
||||||
|
|
||||||
|
/* bit-wise operations */
|
||||||
|
#define lowbit(x) ((x) & -(x))
|
||||||
|
#define popcount(x) (__builtin_popcountll(ll(x)))
|
||||||
|
#define parity(x) (__builtin_parityll(ll(x)))
|
||||||
|
#define msp(x) (63LL - __builtin_clzll(ll(x)))
|
||||||
|
#define lsp(x) (__builtin_ctzll(ll(x)))
|
||||||
|
|
||||||
|
/* arithmetic operations */
|
||||||
|
#define mod(x, y) ((((x) % (y)) + (y)) % (y))
|
||||||
|
|
||||||
|
/* fast pairs */
|
||||||
|
#define upair ull
|
||||||
|
#define umake(x, y) (ull(x) << 32 | (ull(y) & ((1ULL << 32) - 1)))
|
||||||
|
#define u1(p) ((p) >> 32)
|
||||||
|
#define u2(p) ((p) & ((1ULL << 32) - 1))
|
||||||
|
#define ult std::less<upair>
|
||||||
|
#define ugt std::greater<upair>
|
||||||
|
|
||||||
|
#define ipair ull
|
||||||
|
#define imake(x, y) (umake(x, y))
|
||||||
|
#define i1(p) (int(u1(ll(p))))
|
||||||
|
#define i2(p) (ll(u2(p) << 32) >> 32)
|
||||||
|
struct ilt {
|
||||||
|
bool operator()(const ipair& a, const ipair& b) const {
|
||||||
|
if (i1(a) == i1(b)) return i2(a) < i2(b);
|
||||||
|
else return i1(a) < i1(b);
|
||||||
|
}
|
||||||
|
};
|
||||||
|
struct igt {
|
||||||
|
bool operator()(const ipair& a, const ipair& b) const {
|
||||||
|
if (i1(a) == i1(b)) return i2(a) > i2(b);
|
||||||
|
else return i1(a) > i1(b);
|
||||||
|
}
|
||||||
|
};
|
||||||
|
|
||||||
|
/* conditions */
|
||||||
|
#define loop while (1)
|
||||||
|
#define if_or(var, val) if (!((var) == (val))) (var) = (val); else
|
||||||
|
#define continue_or(var, val) __AS_PROCEDURE(if ((var) == (val)) continue; (var) = (val);)
|
||||||
|
#define break_or(var, val) __AS_PROCEDURE(if ((var) == (val)) break; (var) = (val);)
|
||||||
|
|
||||||
|
/* hash */
|
||||||
|
struct safe_hash {
|
||||||
|
// https://codeforces.com/blog/entry/62393
|
||||||
|
static uint64_t splitmix64(uint64_t x) {
|
||||||
|
// http://xorshift.di.unimi.it/splitmix64.c
|
||||||
|
x += 0x9e3779b97f4a7c15;
|
||||||
|
x = (x ^ (x >> 30)) * 0xbf58476d1ce4e5b9;
|
||||||
|
x = (x ^ (x >> 27)) * 0x94d049bb133111eb;
|
||||||
|
return x ^ (x >> 31);
|
||||||
|
}
|
||||||
|
|
||||||
|
size_t operator()(uint64_t x) const {
|
||||||
|
static const uint64_t FIXED_RANDOM = chrono::steady_clock::now().time_since_epoch().count();
|
||||||
|
return splitmix64(x + FIXED_RANDOM);
|
||||||
|
}
|
||||||
|
};
|
||||||
|
|
||||||
|
struct pair_hash {
|
||||||
|
template <typename T, typename U>
|
||||||
|
size_t operator()(const pair<T, U>& a) const {
|
||||||
|
auto hash1 = safe_hash()(a.first);
|
||||||
|
auto hash2 = safe_hash()(a.second);
|
||||||
|
if (hash1 != hash2) {
|
||||||
|
return hash1 ^ hash2;
|
||||||
|
}
|
||||||
|
return hash1;
|
||||||
|
}
|
||||||
|
};
|
||||||
|
|
||||||
|
uniform_int_distribution<mt19937::result_type> dist(PRIME);
|
||||||
|
const size_t __array_hash_b = 31, __array_hash_mdl1 = dist(rd), __array_hash_mdl2 = dist(rd);
|
||||||
|
struct array_hash {
|
||||||
|
safe_hash hasher;
|
||||||
|
template <typename Sequence>
|
||||||
|
size_t operator()(const Sequence& arr) const {
|
||||||
|
size_t pw1 = 1, pw2 = 1;
|
||||||
|
size_t res1 = 0, res2 = 0;
|
||||||
|
for (auto&& x : arr) {
|
||||||
|
auto h = hasher(x);
|
||||||
|
res1 = (res1 + h * pw1) % __array_hash_mdl1;
|
||||||
|
res2 = (res2 + h * pw2) % __array_hash_mdl2;
|
||||||
|
pw1 = (pw1 * __array_hash_b) % __array_hash_mdl1;
|
||||||
|
pw2 = (pw2 * __array_hash_b) % __array_hash_mdl2;
|
||||||
|
}
|
||||||
|
return res1 + res2;
|
||||||
|
}
|
||||||
|
};
|
||||||
|
|
||||||
|
/* build data structures */
|
||||||
|
#define faster(um) __AS_PROCEDURE((um).reserve(1024); (um).max_load_factor(0.25);)
|
||||||
|
#define unordered_counter(from, to) __AS_PROCEDURE(unordered_map<__as_typeof(from), size_t, safe_hash> to; for (auto&& x : from) ++to[x];)
|
||||||
|
#define counter(from, to, cmp) __AS_PROCEDURE(map<__as_typeof(from), size_t, cmp> to; for (auto&& x : from) ++to[x];)
|
||||||
|
#define adj(ch, n) __AS_PROCEDURE(vector<vector<int>> ch((n) + 1);)
|
||||||
|
#define edge(ch, u, v) __AS_PROCEDURE(ch[u].push_back(v), ch[v].push_back(u);)
|
||||||
|
#define edgew(ch, u, v, ...) __AS_PROCEDURE(ch[u].emplace_back(v, __VA_ARGS__), ch[v].emplace_back(u, __VA_ARGS__);)
|
||||||
|
#define Edge(ch, u, v) __AS_PROCEDURE(ch[u].push_back(v);)
|
||||||
|
#define Edgew(ch, u, v, ...) __AS_PROCEDURE(ch[u].emplace_back(v, __VA_ARGS__);)
|
||||||
|
template <typename T, typename Iterator> pair<size_t, map<T, size_t>> discretize(Iterator __first, Iterator __last) {
|
||||||
|
set<T> st(__first, __last);
|
||||||
|
size_t N = 0;
|
||||||
|
map<T, size_t> mp;
|
||||||
|
for (auto&& x : st) mp[x] = ++N;
|
||||||
|
return {N, mp};
|
||||||
|
}
|
||||||
|
template <typename T, typename Iterator> pair<size_t, unordered_map<T, size_t, safe_hash>> unordered_discretize(Iterator __first, Iterator __last) {
|
||||||
|
set<T> st(__first, __last);
|
||||||
|
size_t N = 0;
|
||||||
|
unordered_map<T, size_t, safe_hash> mp;
|
||||||
|
for (auto&& x : st) mp[x] = ++N;
|
||||||
|
return {N, mp};
|
||||||
|
}
|
||||||
|
|
||||||
|
/* io */
|
||||||
|
#define untie __AS_PROCEDURE(ios_base::sync_with_stdio(0), cin.tie(NULL))
|
||||||
|
|
||||||
|
// add declarations to avoid circular dependency
|
||||||
|
template<typename T, typename U> istream& operator>>(istream&, pair<T, U>&);
|
||||||
|
template<typename T, typename U> ostream& operator<<(ostream&, const pair<T, U>&);
|
||||||
|
template<typename T, size_t N> istream& operator>>(istream&, array<T, N>&);
|
||||||
|
template <typename T, size_t N> ostream& operator<<(ostream&, const array<T, N>&);
|
||||||
|
template<typename Char, typename Traits, typename... Args>
|
||||||
|
decltype(auto) operator<<(std::basic_ostream<Char, Traits>&, const std::tuple<Args...>&);
|
||||||
|
template<typename T> ostream& operator<<(ostream&, const vector<T>&);
|
||||||
|
std::ostream& operator<<(std::ostream&, const int128&);
|
||||||
|
|
||||||
|
template<typename T, typename U> istream& operator>>(istream& in, pair<T, U>& p) {
|
||||||
|
return in >> p.first >> p.second;
|
||||||
|
}
|
||||||
|
template<typename T, typename U> ostream& operator<<(ostream& out, const pair<T, U>& p) {
|
||||||
|
out << "{" << p.first << ", " << p.second << "}";
|
||||||
|
return out;
|
||||||
|
}
|
||||||
|
template<typename T, size_t N> istream& operator>>(istream& in, array<T, N>& a) {
|
||||||
|
for (size_t i = 0; i < N; ++i) in >> a[i];
|
||||||
|
return in;
|
||||||
|
}
|
||||||
|
template <typename T, size_t N> ostream& operator<<(ostream& out, const array<T, N>& a) {
|
||||||
|
for (auto&& i : a) out << i << ' ';
|
||||||
|
return out;
|
||||||
|
}
|
||||||
|
template<typename Char, typename Traits, typename Tuple, std::size_t... Index>
|
||||||
|
void print_tuple_impl(std::basic_ostream<Char, Traits>& os, const Tuple& t, std::index_sequence<Index...>) {
|
||||||
|
using swallow = int[]; // guaranties left to right order
|
||||||
|
(void)swallow { 0, (void(os << (Index == 0 ? "" : ", ") << std::get<Index>(t)), 0)... };
|
||||||
|
}
|
||||||
|
template<typename Char, typename Traits, typename... Args>
|
||||||
|
decltype(auto) operator<<(std::basic_ostream<Char, Traits>& os, const std::tuple<Args...>& t) {
|
||||||
|
os << "{";
|
||||||
|
print_tuple_impl(os, t, std::index_sequence_for<Args...>{});
|
||||||
|
return os << "}";
|
||||||
|
}
|
||||||
|
template<typename T> ostream& operator<<(ostream& out, const vector<T>& vec) {
|
||||||
|
for (auto&& i : vec) out << i << ' ';
|
||||||
|
return out;
|
||||||
|
}
|
||||||
|
std::ostream& operator<<(std::ostream& dest, const int128& value) {
|
||||||
|
// https://stackoverflow.com/a/25115163/23881100
|
||||||
|
std::ostream::sentry s( dest );
|
||||||
|
if ( s ) {
|
||||||
|
uint128 tmp = value < 0 ? -value : value;
|
||||||
|
char buffer[ 128 ];
|
||||||
|
char* d = std::end( buffer );
|
||||||
|
do {
|
||||||
|
-- d;
|
||||||
|
*d = "0123456789"[ tmp % 10 ];
|
||||||
|
tmp /= 10;
|
||||||
|
} while ( tmp != 0 );
|
||||||
|
if ( value < 0 ) {
|
||||||
|
-- d;
|
||||||
|
*d = '-';
|
||||||
|
}
|
||||||
|
int len = std::end( buffer ) - d;
|
||||||
|
if ( dest.rdbuf()->sputn( d, len ) != len ) {
|
||||||
|
dest.setstate( std::ios_base::badbit );
|
||||||
|
}
|
||||||
|
}
|
||||||
|
return dest;
|
||||||
|
}
|
||||||
|
template<typename T> void __read(T& x) { cin >> x; }
|
||||||
|
template<typename T, typename... U> void __read(T& x, U&... args) { cin >> x; __read(args...); }
|
||||||
|
#define read(t, ...) __AS_PROCEDURE(argument_type<void(t)>::type __VA_ARGS__; __read(__VA_ARGS__);)
|
||||||
|
#define readvec(t, a, n) __AS_PROCEDURE(vector<argument_type<void(t)>::type> a(n); for (auto& x : (a)) cin >> x;)
|
||||||
|
#define readvec1(t, a, n) __AS_PROCEDURE(vector<argument_type<void(t)>::type> a((n) + 1); copy_n(ii<argument_type<void(t)>::type>(cin), (n), (a).begin() + 1);)
|
||||||
|
#define putvec(a) __AS_PROCEDURE(copy((a).begin(), (a).end(), oi<__as_typeof(a)::value_type>(cout, " ")); cout << endl;)
|
||||||
|
#define putvec1(a) __AS_PROCEDURE(copy((a).begin() + 1, (a).end(), oi<__as_typeof(a)::value_type>(cout, " ")); cout << endl;)
|
||||||
|
#define putvec_eol(a) __AS_PROCEDURE(copy((a).begin(), (a).end(), oi<__as_typeof(a)::value_type>(cout, "\n"));)
|
||||||
|
#define putvec1_eol(a) __AS_PROCEDURE(copy((a).begin() + 1, (a).end(), oi<__as_typeof(a)::value_type>(cout, "\n"));)
|
||||||
|
#define debug(x) __AS_PROCEDURE(cerr << #x" = " << (x) << endl;)
|
||||||
|
#define debugvec(a) __AS_PROCEDURE(cerr << #a" = "; for (auto&& x : (a)) cerr << x << ' '; cerr << endl;)
|
||||||
|
#define deb(...) debug(make_tuple(__VA_ARGS__))
|
||||||
|
|
||||||
|
/* pops */
|
||||||
|
template <typename Container>
|
||||||
|
inline auto poptop(Container& q) {
|
||||||
|
auto ret = q.top();
|
||||||
|
q.pop();
|
||||||
|
return ret;
|
||||||
|
}
|
||||||
|
template <typename Container>
|
||||||
|
inline auto popback(Container& q) {
|
||||||
|
auto ret = q.back();
|
||||||
|
q.pop_back();
|
||||||
|
return ret;
|
||||||
|
}
|
||||||
|
template <typename Container>
|
||||||
|
inline auto popfront(Container& q) {
|
||||||
|
auto ret = q.front();
|
||||||
|
q.pop_front();
|
||||||
|
return ret;
|
||||||
|
}
|
||||||
|
|
||||||
|
/* math */
|
||||||
|
template <typename return_t>
|
||||||
|
return_t qpow(ll b, ll p) {
|
||||||
|
if (b == 0 and p != 0) return 0;
|
||||||
|
if (p == 0) return 1;
|
||||||
|
return_t half = qpow<return_t>(b, p / 2);
|
||||||
|
if (p % 2 == 1) return half * half * b;
|
||||||
|
else return half * half;
|
||||||
|
}
|
||||||
|
|
||||||
|
// dynamic modulus
|
||||||
|
ll qpow(ll b, ll p, ll mod) {
|
||||||
|
if (b == 0 and p != 0) return 0;
|
||||||
|
if (p == 0) return 1;
|
||||||
|
ll half = qpow(b, p / 2, mod);
|
||||||
|
if (p % 2 == 1) return (int128(half) * half % mod) * b % mod;
|
||||||
|
else return half * half % mod;
|
||||||
|
}
|
||||||
|
|
||||||
|
|
||||||
|
#pragma GCC diagnostic push
|
||||||
|
#pragma GCC diagnostic ignored "-Wparentheses"
|
||||||
|
// Accurately find `i` 'th root of `n` (taking the floor)
|
||||||
|
inline ll root(ll n, ll i) {
|
||||||
|
ll l = 0, r = pow(LLONG_MAX, (long double)(1) / i);
|
||||||
|
while (l < r) {
|
||||||
|
ll mid = l + r + 1 >> 1;
|
||||||
|
if (qpow<int128>(mid, i) <= n) {
|
||||||
|
l = mid;
|
||||||
|
} else {
|
||||||
|
r = mid - 1;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
return l;
|
||||||
|
}
|
||||||
|
#pragma GCC diagnostic pop
|
||||||
|
|
||||||
|
|
||||||
|
#define comb(n, k) ((n) < 0 or (k) < 0 or (n) < (k) ? 0 : fact[n] / fact[k] / fact[(n) - (k)])
|
||||||
|
#define fastcomb(n, k) ((n) < 0 or (k) < 0 or (n) < (k) ? 0 : fact[n] * factrev[k] * factrev[(n) - (k)])
|
||||||
|
|
||||||
|
__attribute__((target("lzcnt")))
|
||||||
|
constexpr inline int lg2(ll x) { return x == 0 ? -1 : sizeof(ll) * 8 - 1 - __builtin_clzll(x); }
|
||||||
|
|
||||||
|
template <typename T>
|
||||||
|
T mygcd(T a, T b) { return b == 0 ? a : mygcd(b, a % b); }
|
||||||
|
|
||||||
|
void __exgcd(ll a, ll b, ll& x, ll& y) {
|
||||||
|
if (b == 0) {
|
||||||
|
x = 1, y = 0;
|
||||||
|
return;
|
||||||
|
}
|
||||||
|
__exgcd(b, a % b, y, x);
|
||||||
|
y -= a / b * x;
|
||||||
|
}
|
||||||
|
|
||||||
|
ll inverse(ll a, ll b) {
|
||||||
|
ll x, y;
|
||||||
|
__exgcd(a, b, x, y);
|
||||||
|
return mod(x, b);
|
||||||
|
}
|
||||||
|
|
||||||
|
vector<tuple<int, int, ll>> decompose(ll x) {
|
||||||
|
// return (factor, count, factor ** count)
|
||||||
|
vector<tuple<int, int, ll>> res;
|
||||||
|
for (int i = 2; i * i <= x; i++) {
|
||||||
|
if (x % i == 0) {
|
||||||
|
int cnt = 0;
|
||||||
|
ll pw = 1;
|
||||||
|
while (x % i == 0) ++cnt, x /= i, pw *= i;
|
||||||
|
res.emplace_back(i, cnt, pw);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
if (x != 1) {
|
||||||
|
res.emplace_back(x, 1, x);
|
||||||
|
}
|
||||||
|
return res;
|
||||||
|
}
|
||||||
|
|
||||||
|
vector<pii> decompose_prime(int N) {
|
||||||
|
// return (factor, count)
|
||||||
|
vector<pii> result;
|
||||||
|
for (int i = 2; i * i <= N; i++) {
|
||||||
|
if (N % i == 0) {
|
||||||
|
int cnt = 0;
|
||||||
|
while (N % i == 0) N /= i, ++cnt;
|
||||||
|
result.emplace_back(i, cnt);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
if (N != 1) {
|
||||||
|
result.emplace_back(N, 1);
|
||||||
|
}
|
||||||
|
return result;
|
||||||
|
}
|
||||||
|
|
||||||
|
/* string algorithms */
|
||||||
|
vector<int> calc_next(string t) { // pi function of t
|
||||||
|
int n = (int)t.length();
|
||||||
|
vector<int> pi(n);
|
||||||
|
for (int i = 1; i < n; i++) {
|
||||||
|
int j = pi[i - 1];
|
||||||
|
while (j > 0 && t[i] != t[j]) j = pi[j - 1];
|
||||||
|
if (t[i] == t[j]) j++;
|
||||||
|
pi[i] = j;
|
||||||
|
}
|
||||||
|
return pi;
|
||||||
|
}
|
||||||
|
vector<int> calc_z(string t) { // z function of t
|
||||||
|
int m = t.length();
|
||||||
|
vector<int> z;
|
||||||
|
z.push_back(m);
|
||||||
|
pair<int, int> prev = {1, -1};
|
||||||
|
for (int i = 1; i < m; ++i) {
|
||||||
|
if (z[i - prev.first] + i <= prev.second) {
|
||||||
|
z.push_back(z[i - prev.first]);
|
||||||
|
} else {
|
||||||
|
int j = max(i, prev.second + 1);
|
||||||
|
while (j < m && t[j] == t[j - i]) ++j;
|
||||||
|
z.push_back(j - i);
|
||||||
|
prev = {i, j - 1};
|
||||||
|
}
|
||||||
|
}
|
||||||
|
return z;
|
||||||
|
}
|
||||||
|
vector<int> kmp(const string& s, const string& t) { // find all t in s
|
||||||
|
string cur = t + '#' + s;
|
||||||
|
int sz1 = s.size(), sz2 = t.size();
|
||||||
|
vector<int> v;
|
||||||
|
vector<int> lps = calc_next(cur);
|
||||||
|
for (int i = sz2 + 1; i <= sz1 + sz2; i++) {
|
||||||
|
if (lps[i] == sz2) v.push_back(i - 2 * sz2);
|
||||||
|
}
|
||||||
|
return v;
|
||||||
|
}
|
||||||
|
int period(const string& s) { // find the length of shortest recurring period
|
||||||
|
int n = s.length();
|
||||||
|
auto z = calc_z(s);
|
||||||
|
for (int i = 1; i <= n / 2; ++i) {
|
||||||
|
if (n % i == 0 && z[i] == n - i) {
|
||||||
|
return i;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
return n;
|
||||||
|
}
|
||||||
|
|
||||||
|
/* modular arithmetic */
|
||||||
|
template <ll mdl> struct MLL {
|
||||||
|
ll val;
|
||||||
|
MLL(ll v = 0) : val(mod(v, mdl)) {}
|
||||||
|
MLL(const MLL<mdl>& other) : val(other.val) {}
|
||||||
|
friend MLL operator+(const MLL& lhs, const MLL& rhs) { return mod(lhs.val + rhs.val, mdl); }
|
||||||
|
friend MLL operator-(const MLL& lhs, const MLL& rhs) { return mod(lhs.val - rhs.val, mdl); }
|
||||||
|
friend MLL operator*(const MLL& lhs, const MLL& rhs) { return mod(int128(lhs.val) * rhs.val, mdl); }
|
||||||
|
friend MLL operator/(const MLL& lhs, const MLL& rhs) { return lhs * mod(inverse(rhs.val, mdl), mdl); }
|
||||||
|
friend MLL operator%(const MLL& lhs, const MLL& rhs) { return mod(lhs.val - (lhs / rhs).val, mdl); }
|
||||||
|
friend bool operator==(const MLL& lhs, const MLL& rhs) { return lhs.val == rhs.val; }
|
||||||
|
friend bool operator!=(const MLL& lhs, const MLL& rhs) { return lhs.val != rhs.val; }
|
||||||
|
MLL& operator+=(const MLL& rhs) { return *this = *this + rhs; }
|
||||||
|
MLL& operator-=(const MLL& rhs) { return *this = *this - rhs; }
|
||||||
|
MLL& operator*=(const MLL& rhs) { return *this = *this * rhs; }
|
||||||
|
MLL& operator/=(const MLL& rhs) { return *this = *this / rhs; }
|
||||||
|
MLL& operator%=(const MLL& rhs) { return *this = *this % rhs; }
|
||||||
|
};
|
||||||
|
|
||||||
|
template <ll mdl>
|
||||||
|
ostream& operator<<(ostream& out, const MLL<mdl>& num) {
|
||||||
|
return out << num.val;
|
||||||
|
}
|
||||||
|
|
||||||
|
template <ll mdl>
|
||||||
|
istream& operator>>(istream& in, MLL<mdl>& num) {
|
||||||
|
return in >> num.val;
|
||||||
|
}
|
||||||
|
|
||||||
|
// miscancellous
|
||||||
|
template <typename T, typename U>
|
||||||
|
bool chmax(T& lhs, const U& rhs) {
|
||||||
|
bool ret = lhs < rhs;
|
||||||
|
if (ret) {
|
||||||
|
lhs = rhs;
|
||||||
|
}
|
||||||
|
return ret;
|
||||||
|
}
|
||||||
|
template <typename T, typename U>
|
||||||
|
bool chmin(T& lhs, const U& rhs) {
|
||||||
|
bool ret = lhs > rhs;
|
||||||
|
if (ret) {
|
||||||
|
lhs = rhs;
|
||||||
|
}
|
||||||
|
return ret;
|
||||||
|
}
|
||||||
|
|
||||||
|
#define functor(func) ([&](auto&&... val) \
|
||||||
|
noexcept(noexcept(func(std::forward<decltype(val)>(val)...))) -> decltype(auto) \
|
||||||
|
{return func(std::forward<decltype(val)>(val)...);})
|
||||||
|
#define expr(ret, ...) ([&] (__VA_ARGS__) { return (ret); })
|
||||||
|
template <typename Func, typename RandomIt> void sort_by_key(RandomIt first, RandomIt last, Func extractor) {
|
||||||
|
std::sort(first, last, [&] (auto&& a, auto&& b) { return std::less<>()(extractor(a), extractor(b)); });
|
||||||
|
}
|
||||||
|
template <typename Func, typename RandomIt, typename Compare> void sort_by_key(RandomIt first, RandomIt last, Func extractor, Compare comp) {
|
||||||
|
std::sort(first, last, [&] (auto&& a, auto&& b) { return comp(extractor(a), extractor(b)); });
|
||||||
|
}
|
||||||
|
template <typename T, typename U, typename Iterator_T, typename Iterator_U>
|
||||||
|
vector<pair<T, U>> zip(Iterator_T a_first, Iterator_T a_last, Iterator_U b_first, Iterator_U b_last) {
|
||||||
|
vector<pair<T, U>> res;
|
||||||
|
auto a_it = a_first;
|
||||||
|
auto b_it = b_first;
|
||||||
|
for (; not (a_it == a_last) and not (b_it == b_last); ++a_it, ++b_it) {
|
||||||
|
res.emplace_back(*a_it, *b_it);
|
||||||
|
}
|
||||||
|
return res;
|
||||||
|
}
|
||||||
|
template <typename T, typename U, typename Iterator_T, typename Iterator_U>
|
||||||
|
vector<pair<T, U>> zip_n(Iterator_T a_first, Iterator_U b_first, size_t n) {
|
||||||
|
vector<pair<T, U>> res;
|
||||||
|
if (n > 0) {
|
||||||
|
res.emplace_back(*a_first, *b_first);
|
||||||
|
for (size_t i = 1; i != n; ++i) {
|
||||||
|
res.emplace_back(*++a_first, *++b_first);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
return res;
|
||||||
|
}
|
||||||
|
template <typename T>
|
||||||
|
class ArithmeticIterator : bidirectional_iterator_tag {
|
||||||
|
public:
|
||||||
|
using difference_type = ptrdiff_t;
|
||||||
|
using value_type = T;
|
||||||
|
private:
|
||||||
|
value_type value;
|
||||||
|
public:
|
||||||
|
ArithmeticIterator(const T& value) : value(value) {}
|
||||||
|
value_type operator*() const { return value; }
|
||||||
|
ArithmeticIterator<T>& operator++() { ++value; return *this; }
|
||||||
|
ArithmeticIterator<T>& operator--() { --value; return *this; }
|
||||||
|
bool operator==(const ArithmeticIterator<T>& rhs) const { return value == rhs.value; }
|
||||||
|
};
|
||||||
|
template <typename T> vector<pair<int, T>> enumerate(const vector<T>& container) {
|
||||||
|
return zip<int, T>(ArithmeticIterator<int>(0), ArithmeticIterator<int>(INT_MAX), container.begin(), container.end());
|
||||||
|
}
|
||||||
|
#define initarray(init, N) (__initarray<decay<decltype(init)>::type, (N)>(init))
|
||||||
|
namespace detail {
|
||||||
|
template <typename T, std::size_t...Is>
|
||||||
|
constexpr std::array<T, sizeof...(Is)>
|
||||||
|
make_array(const T& value, std::index_sequence<Is...>) {
|
||||||
|
return {{(static_cast<void>(Is), value)...}};
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
template <typename T, std::size_t N>
|
||||||
|
constexpr std::array<T, N> __initarray(const T& value) {
|
||||||
|
return detail::make_array(value, std::make_index_sequence<N>());
|
||||||
|
}
|
||||||
|
/*******************************************************/
|
||||||
|
|
||||||
|
#define SINGLE_TEST_CASE
|
||||||
|
// #define DUMP_TEST_CASE 7219
|
||||||
|
// #define TOT_TEST_CASE 10000
|
||||||
|
|
||||||
|
void dump() {}
|
||||||
|
|
||||||
|
void dump_ignore() {}
|
||||||
|
|
||||||
|
void prep() {
|
||||||
|
}
|
||||||
|
|
||||||
|
// __attribute__((target("popcnt")))
|
||||||
|
void solve() {
|
||||||
|
read(int, n);
|
||||||
|
adj(ch, n);
|
||||||
|
for (int i = 0; i < n - 1; ++i) {
|
||||||
|
read(int, u, v);
|
||||||
|
edge(ch, u, v);
|
||||||
|
}
|
||||||
|
|
||||||
|
vector<int> sz(n + 1);
|
||||||
|
{
|
||||||
|
auto dfs = [&] (auto dfs, int v, int pa) -> void {
|
||||||
|
sz[v] = 1;
|
||||||
|
for (auto&& u : ch[v]) {
|
||||||
|
if (u == pa) continue;
|
||||||
|
dfs(dfs, u, v);
|
||||||
|
sz[v] += sz[u];
|
||||||
|
}
|
||||||
|
};
|
||||||
|
dfs(dfs, 1, 0);
|
||||||
|
}
|
||||||
|
|
||||||
|
vector<pll> down(n + 1);
|
||||||
|
{
|
||||||
|
auto dfs = [&] (auto dfs, int v, int pa) -> void {
|
||||||
|
down[v].second = sz[v] - 1;
|
||||||
|
int tot_sz = 0;
|
||||||
|
for (auto&& u : ch[v]) {
|
||||||
|
if (u == pa) continue;
|
||||||
|
dfs(dfs, u, v);
|
||||||
|
down[v].first += down[u].first + down[u].second;
|
||||||
|
down[v].second += down[u].second;
|
||||||
|
down[v].second += ll(1) * tot_sz * sz[u];
|
||||||
|
tot_sz += sz[u];
|
||||||
|
}
|
||||||
|
};
|
||||||
|
dfs(dfs, 1, 0);
|
||||||
|
}
|
||||||
|
|
||||||
|
vector<pll> up(n + 1);
|
||||||
|
{
|
||||||
|
auto dfs = [&] (auto dfs, int v, int pa) -> void {
|
||||||
|
// up[v].second += n - sz[v];
|
||||||
|
for (auto&& u : ch[v]) {
|
||||||
|
if (u == pa) continue;
|
||||||
|
// up[v].first += down[u].first;
|
||||||
|
// up[v].second += down[u].second;
|
||||||
|
}
|
||||||
|
up[v].second += n - sz[v];
|
||||||
|
up[v].second += ll(1) * (n - sz[v]) * (sz[v] - 1);
|
||||||
|
// if (v == 1) {
|
||||||
|
// debug(up[v]);
|
||||||
|
// debug(down[v]);
|
||||||
|
// }
|
||||||
|
for (auto&& u : ch[v]) {
|
||||||
|
if (u == pa) continue;
|
||||||
|
up[v].second -= ll(1) * sz[u] * (n - sz[v]);
|
||||||
|
down[v].second -= ll(1) * sz[u] * (sz[v] - sz[u]);
|
||||||
|
down[v].first -= down[u].first + down[u].second;
|
||||||
|
down[v].second -= down[u].second;
|
||||||
|
// if (v == 1) {
|
||||||
|
// debug(u);
|
||||||
|
// debug(up[v]);
|
||||||
|
// debug(down[v]);
|
||||||
|
// }
|
||||||
|
|
||||||
|
up[u].first += up[v].first + up[v].second;
|
||||||
|
up[u].first += down[v].first + down[v].second;
|
||||||
|
up[u].second += up[v].second;
|
||||||
|
up[u].second += down[v].second;
|
||||||
|
dfs(dfs, u, v);
|
||||||
|
|
||||||
|
up[v].second += ll(1) * sz[u] * (n - sz[v]);
|
||||||
|
down[v].second += ll(1) * sz[u] * (sz[v] - sz[u]);
|
||||||
|
down[v].first += down[u].first + down[u].second;
|
||||||
|
down[v].second += down[u].second;
|
||||||
|
}
|
||||||
|
};
|
||||||
|
dfs(dfs, 1, 0);
|
||||||
|
}
|
||||||
|
|
||||||
|
for (int i = 1; i <= n; ++i) {
|
||||||
|
cout << up[i].first + down[i].first << '\n';
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
int main() {
|
||||||
|
#if __cplusplus < 201402L or defined(_MSC_VER) and not defined(__clang__)
|
||||||
|
static_assert(false, "incompatible compiler variant detected.");
|
||||||
|
#endif
|
||||||
|
untie;
|
||||||
|
prep();
|
||||||
|
#ifdef SINGLE_TEST_CASE
|
||||||
|
solve();
|
||||||
|
#else
|
||||||
|
read(int, t);
|
||||||
|
for (int i = 0; i < t; ++i) {
|
||||||
|
#ifdef DUMP_TEST_CASE
|
||||||
|
if (t != (TOT_TEST_CASE)) {
|
||||||
|
solve();
|
||||||
|
} else if (i + 1 == (DUMP_TEST_CASE)) {
|
||||||
|
dump();
|
||||||
|
} else {
|
||||||
|
dump_ignore();
|
||||||
|
}
|
||||||
|
#else
|
||||||
|
solve();
|
||||||
|
#endif
|
||||||
|
}
|
||||||
|
#endif
|
||||||
|
}
|
|
@ -0,0 +1,608 @@
|
||||||
|
// #pragma GCC target("popcnt,lzcnt,abm,bmi,bmi2")
|
||||||
|
#pragma GCC optimize("Ofast,unroll-loops")
|
||||||
|
/************* This code requires C++17. ***************/
|
||||||
|
|
||||||
|
#include<bits/stdc++.h>
|
||||||
|
using namespace std;
|
||||||
|
|
||||||
|
/* macro helpers */
|
||||||
|
#define __NARGS(...) std::tuple_size<decltype(std::make_tuple(__VA_ARGS__))>::value
|
||||||
|
#define __DECOMPOSE_S(a, x) auto x = a;
|
||||||
|
#define __DECOMPOSE_N(a, ...) auto [__VA_ARGS__] = a;
|
||||||
|
constexpr void __() {}
|
||||||
|
#define __AS_PROCEDURE(...) __(); __VA_ARGS__; __()
|
||||||
|
#define __as_typeof(container) remove_reference<decltype(container)>::type
|
||||||
|
template <typename T> struct argument_type;
|
||||||
|
template <typename T, typename U> struct argument_type<T(U)> { using type = U; };
|
||||||
|
|
||||||
|
/* type aliases */
|
||||||
|
#if LONG_LONG_MAX != INT64_MAX
|
||||||
|
using ll = int64_t;
|
||||||
|
using ull = uint64_t;
|
||||||
|
#else
|
||||||
|
using ll = long long;
|
||||||
|
using ull = unsigned long long;
|
||||||
|
#endif
|
||||||
|
using int128 = __int128_t;
|
||||||
|
using uint128 = __uint128_t;
|
||||||
|
using ld = __float128; // up to 1e-9 precision in binary search
|
||||||
|
using pii = pair<int, int>; using pil = pair<int, ll>; using pid = pair<int, ld>;
|
||||||
|
using pli = pair<ll, int>; using pll = pair<ll, ll>; using pld = pair<ll, ld>;
|
||||||
|
using pdi = pair<ld, int>; using pdl = pair<ld, ll>; using pdd = pair<ld, ld>;
|
||||||
|
using tiii = tuple<int, int, int>; using tiil = tuple<int, int, ll>; using tiid = tuple<int, int, ld>;
|
||||||
|
using tili = tuple<int, ll, int>; using till = tuple<int, ll, ll>; using tild = tuple<int, ll, ld>;
|
||||||
|
using tidi = tuple<int, ld, int>; using tidl = tuple<int, ld, ll>; using tidd = tuple<int, ld, ld>;
|
||||||
|
using tlii = tuple<ll, int, int>; using tlil = tuple<ll, int, ll>; using tlid = tuple<ll, int, ld>;
|
||||||
|
using tlli = tuple<ll, ll, int>; using tlll = tuple<ll, ll, ll>; using tlld = tuple<ll, ll, ld>;
|
||||||
|
using tldi = tuple<ll, ld, int>; using tldl = tuple<ll, ld, ll>; using tldd = tuple<ll, ld, ld>;
|
||||||
|
using tdii = tuple<ld, int, int>; using tdil = tuple<ld, int, ll>; using tdid = tuple<ld, int, ld>;
|
||||||
|
using tdli = tuple<ld, ll, int>; using tdll = tuple<ld, ll, ll>; using tdld = tuple<ld, ll, ld>;
|
||||||
|
using tddi = tuple<ld, ld, int>; using tddl = tuple<ld, ld, ll>; using tddd = tuple<ld, ld, ld>;
|
||||||
|
template <typename T> using max_heap = priority_queue<T>;
|
||||||
|
template <typename T> using min_heap = priority_queue<T, vector<T>, greater<>>;
|
||||||
|
template <typename T> using oi = ostream_iterator<T>;
|
||||||
|
template <typename T> using ii = istream_iterator<T>;
|
||||||
|
|
||||||
|
/* constants */
|
||||||
|
constexpr int INF = 0x3f3f3f3f;
|
||||||
|
constexpr ll INFLL = 0x3f3f3f3f3f3f3f3fLL;
|
||||||
|
constexpr ll MDL = 1e9 + 7;
|
||||||
|
constexpr ll PRIME = 998'244'353;
|
||||||
|
constexpr ll PRIMELL = 901017227882342239LL;
|
||||||
|
constexpr ll MDL1 = 8784491;
|
||||||
|
constexpr ll MDL2 = PRIME;
|
||||||
|
constexpr int128 INT128_MAX = numeric_limits<int128>::max();
|
||||||
|
constexpr uint128 UINT128_MAX = numeric_limits<uint128>::max();
|
||||||
|
constexpr int128 INT128_MIN = numeric_limits<int128>::min();
|
||||||
|
constexpr uint128 UINT128_MIN = numeric_limits<uint128>::min();
|
||||||
|
|
||||||
|
/* random */
|
||||||
|
|
||||||
|
mt19937_64 rd(chrono::duration_cast<chrono::milliseconds>(chrono::system_clock::now().time_since_epoch()).count());
|
||||||
|
|
||||||
|
/* bit-wise operations */
|
||||||
|
#define lowbit(x) ((x) & -(x))
|
||||||
|
#define popcount(x) (__builtin_popcountll(ll(x)))
|
||||||
|
#define parity(x) (__builtin_parityll(ll(x)))
|
||||||
|
#define msp(x) (63LL - __builtin_clzll(ll(x)))
|
||||||
|
#define lsp(x) (__builtin_ctzll(ll(x)))
|
||||||
|
|
||||||
|
/* arithmetic operations */
|
||||||
|
#define mod(x, y) ((((x) % (y)) + (y)) % (y))
|
||||||
|
|
||||||
|
/* fast pairs */
|
||||||
|
#define upair ull
|
||||||
|
#define umake(x, y) (ull(x) << 32 | (ull(y) & ((1ULL << 32) - 1)))
|
||||||
|
#define u1(p) ((p) >> 32)
|
||||||
|
#define u2(p) ((p) & ((1ULL << 32) - 1))
|
||||||
|
#define ult std::less<upair>
|
||||||
|
#define ugt std::greater<upair>
|
||||||
|
|
||||||
|
#define ipair ull
|
||||||
|
#define imake(x, y) (umake(x, y))
|
||||||
|
#define i1(p) (int(u1(ll(p))))
|
||||||
|
#define i2(p) (ll(u2(p) << 32) >> 32)
|
||||||
|
struct ilt {
|
||||||
|
bool operator()(const ipair& a, const ipair& b) const {
|
||||||
|
if (i1(a) == i1(b)) return i2(a) < i2(b);
|
||||||
|
else return i1(a) < i1(b);
|
||||||
|
}
|
||||||
|
};
|
||||||
|
struct igt {
|
||||||
|
bool operator()(const ipair& a, const ipair& b) const {
|
||||||
|
if (i1(a) == i1(b)) return i2(a) > i2(b);
|
||||||
|
else return i1(a) > i1(b);
|
||||||
|
}
|
||||||
|
};
|
||||||
|
|
||||||
|
/* conditions */
|
||||||
|
#define loop while (1)
|
||||||
|
#define if_or(var, val) if (!((var) == (val))) (var) = (val); else
|
||||||
|
#define continue_or(var, val) __AS_PROCEDURE(if ((var) == (val)) continue; (var) = (val);)
|
||||||
|
#define break_or(var, val) __AS_PROCEDURE(if ((var) == (val)) break; (var) = (val);)
|
||||||
|
|
||||||
|
/* hash */
|
||||||
|
struct safe_hash {
|
||||||
|
// https://codeforces.com/blog/entry/62393
|
||||||
|
static uint64_t splitmix64(uint64_t x) {
|
||||||
|
// http://xorshift.di.unimi.it/splitmix64.c
|
||||||
|
x += 0x9e3779b97f4a7c15;
|
||||||
|
x = (x ^ (x >> 30)) * 0xbf58476d1ce4e5b9;
|
||||||
|
x = (x ^ (x >> 27)) * 0x94d049bb133111eb;
|
||||||
|
return x ^ (x >> 31);
|
||||||
|
}
|
||||||
|
|
||||||
|
size_t operator()(uint64_t x) const {
|
||||||
|
static const uint64_t FIXED_RANDOM = chrono::steady_clock::now().time_since_epoch().count();
|
||||||
|
return splitmix64(x + FIXED_RANDOM);
|
||||||
|
}
|
||||||
|
};
|
||||||
|
|
||||||
|
struct pair_hash {
|
||||||
|
template <typename T, typename U>
|
||||||
|
size_t operator()(const pair<T, U>& a) const {
|
||||||
|
auto hash1 = safe_hash()(a.first);
|
||||||
|
auto hash2 = safe_hash()(a.second);
|
||||||
|
if (hash1 != hash2) {
|
||||||
|
return hash1 ^ hash2;
|
||||||
|
}
|
||||||
|
return hash1;
|
||||||
|
}
|
||||||
|
};
|
||||||
|
|
||||||
|
uniform_int_distribution<mt19937::result_type> dist(PRIME);
|
||||||
|
const size_t __array_hash_b = 31, __array_hash_mdl1 = dist(rd), __array_hash_mdl2 = dist(rd);
|
||||||
|
struct array_hash {
|
||||||
|
safe_hash hasher;
|
||||||
|
template <typename Sequence>
|
||||||
|
size_t operator()(const Sequence& arr) const {
|
||||||
|
size_t pw1 = 1, pw2 = 1;
|
||||||
|
size_t res1 = 0, res2 = 0;
|
||||||
|
for (auto&& x : arr) {
|
||||||
|
auto h = hasher(x);
|
||||||
|
res1 = (res1 + h * pw1) % __array_hash_mdl1;
|
||||||
|
res2 = (res2 + h * pw2) % __array_hash_mdl2;
|
||||||
|
pw1 = (pw1 * __array_hash_b) % __array_hash_mdl1;
|
||||||
|
pw2 = (pw2 * __array_hash_b) % __array_hash_mdl2;
|
||||||
|
}
|
||||||
|
return res1 + res2;
|
||||||
|
}
|
||||||
|
};
|
||||||
|
|
||||||
|
/* build data structures */
|
||||||
|
#define faster(um) __AS_PROCEDURE((um).reserve(1024); (um).max_load_factor(0.25);)
|
||||||
|
#define unordered_counter(from, to) __AS_PROCEDURE(unordered_map<__as_typeof(from), size_t, safe_hash> to; for (auto&& x : from) ++to[x];)
|
||||||
|
#define counter(from, to, cmp) __AS_PROCEDURE(map<__as_typeof(from), size_t, cmp> to; for (auto&& x : from) ++to[x];)
|
||||||
|
#define adj(ch, n) __AS_PROCEDURE(vector<vector<int>> ch((n) + 1);)
|
||||||
|
#define edge(ch, u, v) __AS_PROCEDURE(ch[u].push_back(v), ch[v].push_back(u);)
|
||||||
|
#define edgew(ch, u, v, ...) __AS_PROCEDURE(ch[u].emplace_back(v, __VA_ARGS__), ch[v].emplace_back(u, __VA_ARGS__);)
|
||||||
|
#define Edge(ch, u, v) __AS_PROCEDURE(ch[u].push_back(v);)
|
||||||
|
#define Edgew(ch, u, v, ...) __AS_PROCEDURE(ch[u].emplace_back(v, __VA_ARGS__);)
|
||||||
|
template <typename T, typename Iterator> pair<size_t, map<T, size_t>> discretize(Iterator __first, Iterator __last) {
|
||||||
|
set<T> st(__first, __last);
|
||||||
|
size_t N = 0;
|
||||||
|
map<T, size_t> mp;
|
||||||
|
for (auto&& x : st) mp[x] = ++N;
|
||||||
|
return {N, mp};
|
||||||
|
}
|
||||||
|
template <typename T, typename Iterator> pair<size_t, unordered_map<T, size_t, safe_hash>> unordered_discretize(Iterator __first, Iterator __last) {
|
||||||
|
set<T> st(__first, __last);
|
||||||
|
size_t N = 0;
|
||||||
|
unordered_map<T, size_t, safe_hash> mp;
|
||||||
|
for (auto&& x : st) mp[x] = ++N;
|
||||||
|
return {N, mp};
|
||||||
|
}
|
||||||
|
|
||||||
|
/* io */
|
||||||
|
#define untie __AS_PROCEDURE(ios_base::sync_with_stdio(0), cin.tie(NULL))
|
||||||
|
|
||||||
|
// add declarations to avoid circular dependency
|
||||||
|
template<typename T, typename U> istream& operator>>(istream&, pair<T, U>&);
|
||||||
|
template<typename T, typename U> ostream& operator<<(ostream&, const pair<T, U>&);
|
||||||
|
template<typename T, size_t N> istream& operator>>(istream&, array<T, N>&);
|
||||||
|
template <typename T, size_t N> ostream& operator<<(ostream&, const array<T, N>&);
|
||||||
|
template<typename Char, typename Traits, typename... Args>
|
||||||
|
decltype(auto) operator<<(std::basic_ostream<Char, Traits>&, const std::tuple<Args...>&);
|
||||||
|
template<typename T> ostream& operator<<(ostream&, const vector<T>&);
|
||||||
|
std::ostream& operator<<(std::ostream&, const int128&);
|
||||||
|
|
||||||
|
template<typename T, typename U> istream& operator>>(istream& in, pair<T, U>& p) {
|
||||||
|
return in >> p.first >> p.second;
|
||||||
|
}
|
||||||
|
template<typename T, typename U> ostream& operator<<(ostream& out, const pair<T, U>& p) {
|
||||||
|
out << "{" << p.first << ", " << p.second << "}";
|
||||||
|
return out;
|
||||||
|
}
|
||||||
|
template<typename T, size_t N> istream& operator>>(istream& in, array<T, N>& a) {
|
||||||
|
for (size_t i = 0; i < N; ++i) in >> a[i];
|
||||||
|
return in;
|
||||||
|
}
|
||||||
|
template <typename T, size_t N> ostream& operator<<(ostream& out, const array<T, N>& a) {
|
||||||
|
for (auto&& i : a) out << i << ' ';
|
||||||
|
return out;
|
||||||
|
}
|
||||||
|
template<typename Char, typename Traits, typename Tuple, std::size_t... Index>
|
||||||
|
void print_tuple_impl(std::basic_ostream<Char, Traits>& os, const Tuple& t, std::index_sequence<Index...>) {
|
||||||
|
using swallow = int[]; // guaranties left to right order
|
||||||
|
(void)swallow { 0, (void(os << (Index == 0 ? "" : ", ") << std::get<Index>(t)), 0)... };
|
||||||
|
}
|
||||||
|
template<typename Char, typename Traits, typename... Args>
|
||||||
|
decltype(auto) operator<<(std::basic_ostream<Char, Traits>& os, const std::tuple<Args...>& t) {
|
||||||
|
os << "{";
|
||||||
|
print_tuple_impl(os, t, std::index_sequence_for<Args...>{});
|
||||||
|
return os << "}";
|
||||||
|
}
|
||||||
|
template<typename T> ostream& operator<<(ostream& out, const vector<T>& vec) {
|
||||||
|
for (auto&& i : vec) out << i << ' ';
|
||||||
|
return out;
|
||||||
|
}
|
||||||
|
std::ostream& operator<<(std::ostream& dest, const int128& value) {
|
||||||
|
// https://stackoverflow.com/a/25115163/23881100
|
||||||
|
std::ostream::sentry s( dest );
|
||||||
|
if ( s ) {
|
||||||
|
uint128 tmp = value < 0 ? -value : value;
|
||||||
|
char buffer[ 128 ];
|
||||||
|
char* d = std::end( buffer );
|
||||||
|
do {
|
||||||
|
-- d;
|
||||||
|
*d = "0123456789"[ tmp % 10 ];
|
||||||
|
tmp /= 10;
|
||||||
|
} while ( tmp != 0 );
|
||||||
|
if ( value < 0 ) {
|
||||||
|
-- d;
|
||||||
|
*d = '-';
|
||||||
|
}
|
||||||
|
int len = std::end( buffer ) - d;
|
||||||
|
if ( dest.rdbuf()->sputn( d, len ) != len ) {
|
||||||
|
dest.setstate( std::ios_base::badbit );
|
||||||
|
}
|
||||||
|
}
|
||||||
|
return dest;
|
||||||
|
}
|
||||||
|
template<typename T> void __read(T& x) { cin >> x; }
|
||||||
|
template<typename T, typename... U> void __read(T& x, U&... args) { cin >> x; __read(args...); }
|
||||||
|
#define read(t, ...) __AS_PROCEDURE(argument_type<void(t)>::type __VA_ARGS__; __read(__VA_ARGS__);)
|
||||||
|
#define readvec(t, a, n) __AS_PROCEDURE(vector<argument_type<void(t)>::type> a(n); for (auto& x : (a)) cin >> x;)
|
||||||
|
#define readvec1(t, a, n) __AS_PROCEDURE(vector<argument_type<void(t)>::type> a((n) + 1); copy_n(ii<argument_type<void(t)>::type>(cin), (n), (a).begin() + 1);)
|
||||||
|
#define putvec(a) __AS_PROCEDURE(copy((a).begin(), (a).end(), oi<__as_typeof(a)::value_type>(cout, " ")); cout << endl;)
|
||||||
|
#define putvec1(a) __AS_PROCEDURE(copy((a).begin() + 1, (a).end(), oi<__as_typeof(a)::value_type>(cout, " ")); cout << endl;)
|
||||||
|
#define putvec_eol(a) __AS_PROCEDURE(copy((a).begin(), (a).end(), oi<__as_typeof(a)::value_type>(cout, "\n"));)
|
||||||
|
#define putvec1_eol(a) __AS_PROCEDURE(copy((a).begin() + 1, (a).end(), oi<__as_typeof(a)::value_type>(cout, "\n"));)
|
||||||
|
#define debug(x) __AS_PROCEDURE(cerr << #x" = " << (x) << endl;)
|
||||||
|
#define debugvec(a) __AS_PROCEDURE(cerr << #a" = "; for (auto&& x : (a)) cerr << x << ' '; cerr << endl;)
|
||||||
|
#define deb(...) debug(make_tuple(__VA_ARGS__))
|
||||||
|
|
||||||
|
/* pops */
|
||||||
|
template <typename Container>
|
||||||
|
inline auto poptop(Container& q) {
|
||||||
|
auto ret = q.top();
|
||||||
|
q.pop();
|
||||||
|
return ret;
|
||||||
|
}
|
||||||
|
template <typename Container>
|
||||||
|
inline auto popback(Container& q) {
|
||||||
|
auto ret = q.back();
|
||||||
|
q.pop_back();
|
||||||
|
return ret;
|
||||||
|
}
|
||||||
|
template <typename Container>
|
||||||
|
inline auto popfront(Container& q) {
|
||||||
|
auto ret = q.front();
|
||||||
|
q.pop_front();
|
||||||
|
return ret;
|
||||||
|
}
|
||||||
|
|
||||||
|
/* math */
|
||||||
|
template <typename return_t>
|
||||||
|
return_t qpow(ll b, ll p) {
|
||||||
|
if (b == 0 and p != 0) return 0;
|
||||||
|
if (p == 0) return 1;
|
||||||
|
return_t half = qpow<return_t>(b, p / 2);
|
||||||
|
if (p % 2 == 1) return half * half * b;
|
||||||
|
else return half * half;
|
||||||
|
}
|
||||||
|
|
||||||
|
// dynamic modulus
|
||||||
|
ll qpow(ll b, ll p, ll mod) {
|
||||||
|
if (b == 0 and p != 0) return 0;
|
||||||
|
if (p == 0) return 1;
|
||||||
|
ll half = qpow(b, p / 2, mod);
|
||||||
|
if (p % 2 == 1) return (int128(half) * half % mod) * b % mod;
|
||||||
|
else return half * half % mod;
|
||||||
|
}
|
||||||
|
|
||||||
|
|
||||||
|
#pragma GCC diagnostic push
|
||||||
|
#pragma GCC diagnostic ignored "-Wparentheses"
|
||||||
|
// Accurately find `i` 'th root of `n` (taking the floor)
|
||||||
|
inline ll root(ll n, ll i) {
|
||||||
|
ll l = 0, r = pow(LLONG_MAX, (long double)(1) / i);
|
||||||
|
while (l < r) {
|
||||||
|
ll mid = l + r + 1 >> 1;
|
||||||
|
if (qpow<int128>(mid, i) <= n) {
|
||||||
|
l = mid;
|
||||||
|
} else {
|
||||||
|
r = mid - 1;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
return l;
|
||||||
|
}
|
||||||
|
#pragma GCC diagnostic pop
|
||||||
|
|
||||||
|
|
||||||
|
#define comb(n, k) ((n) < 0 or (k) < 0 or (n) < (k) ? 0 : fact[n] / fact[k] / fact[(n) - (k)])
|
||||||
|
#define fastcomb(n, k) ((n) < 0 or (k) < 0 or (n) < (k) ? 0 : fact[n] * factrev[k] * factrev[(n) - (k)])
|
||||||
|
|
||||||
|
__attribute__((target("lzcnt")))
|
||||||
|
constexpr inline int lg2(ll x) { return x == 0 ? -1 : sizeof(ll) * 8 - 1 - __builtin_clzll(x); }
|
||||||
|
|
||||||
|
template <typename T>
|
||||||
|
T mygcd(T a, T b) { return b == 0 ? a : mygcd(b, a % b); }
|
||||||
|
|
||||||
|
void __exgcd(ll a, ll b, ll& x, ll& y) {
|
||||||
|
if (b == 0) {
|
||||||
|
x = 1, y = 0;
|
||||||
|
return;
|
||||||
|
}
|
||||||
|
__exgcd(b, a % b, y, x);
|
||||||
|
y -= a / b * x;
|
||||||
|
}
|
||||||
|
|
||||||
|
ll inverse(ll a, ll b) {
|
||||||
|
ll x, y;
|
||||||
|
__exgcd(a, b, x, y);
|
||||||
|
return mod(x, b);
|
||||||
|
}
|
||||||
|
|
||||||
|
vector<tuple<int, int, ll>> decompose(ll x) {
|
||||||
|
// return (factor, count, factor ** count)
|
||||||
|
vector<tuple<int, int, ll>> res;
|
||||||
|
for (int i = 2; i * i <= x; i++) {
|
||||||
|
if (x % i == 0) {
|
||||||
|
int cnt = 0;
|
||||||
|
ll pw = 1;
|
||||||
|
while (x % i == 0) ++cnt, x /= i, pw *= i;
|
||||||
|
res.emplace_back(i, cnt, pw);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
if (x != 1) {
|
||||||
|
res.emplace_back(x, 1, x);
|
||||||
|
}
|
||||||
|
return res;
|
||||||
|
}
|
||||||
|
|
||||||
|
vector<pii> decompose_prime(int N) {
|
||||||
|
// return (factor, count)
|
||||||
|
vector<pii> result;
|
||||||
|
for (int i = 2; i * i <= N; i++) {
|
||||||
|
if (N % i == 0) {
|
||||||
|
int cnt = 0;
|
||||||
|
while (N % i == 0) N /= i, ++cnt;
|
||||||
|
result.emplace_back(i, cnt);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
if (N != 1) {
|
||||||
|
result.emplace_back(N, 1);
|
||||||
|
}
|
||||||
|
return result;
|
||||||
|
}
|
||||||
|
|
||||||
|
/* string algorithms */
|
||||||
|
vector<int> calc_next(string t) { // pi function of t
|
||||||
|
int n = (int)t.length();
|
||||||
|
vector<int> pi(n);
|
||||||
|
for (int i = 1; i < n; i++) {
|
||||||
|
int j = pi[i - 1];
|
||||||
|
while (j > 0 && t[i] != t[j]) j = pi[j - 1];
|
||||||
|
if (t[i] == t[j]) j++;
|
||||||
|
pi[i] = j;
|
||||||
|
}
|
||||||
|
return pi;
|
||||||
|
}
|
||||||
|
vector<int> calc_z(string t) { // z function of t
|
||||||
|
int m = t.length();
|
||||||
|
vector<int> z;
|
||||||
|
z.push_back(m);
|
||||||
|
pair<int, int> prev = {1, -1};
|
||||||
|
for (int i = 1; i < m; ++i) {
|
||||||
|
if (z[i - prev.first] + i <= prev.second) {
|
||||||
|
z.push_back(z[i - prev.first]);
|
||||||
|
} else {
|
||||||
|
int j = max(i, prev.second + 1);
|
||||||
|
while (j < m && t[j] == t[j - i]) ++j;
|
||||||
|
z.push_back(j - i);
|
||||||
|
prev = {i, j - 1};
|
||||||
|
}
|
||||||
|
}
|
||||||
|
return z;
|
||||||
|
}
|
||||||
|
vector<int> kmp(const string& s, const string& t) { // find all t in s
|
||||||
|
string cur = t + '#' + s;
|
||||||
|
int sz1 = s.size(), sz2 = t.size();
|
||||||
|
vector<int> v;
|
||||||
|
vector<int> lps = calc_next(cur);
|
||||||
|
for (int i = sz2 + 1; i <= sz1 + sz2; i++) {
|
||||||
|
if (lps[i] == sz2) v.push_back(i - 2 * sz2);
|
||||||
|
}
|
||||||
|
return v;
|
||||||
|
}
|
||||||
|
int period(const string& s) { // find the length of shortest recurring period
|
||||||
|
int n = s.length();
|
||||||
|
auto z = calc_z(s);
|
||||||
|
for (int i = 1; i <= n / 2; ++i) {
|
||||||
|
if (n % i == 0 && z[i] == n - i) {
|
||||||
|
return i;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
return n;
|
||||||
|
}
|
||||||
|
|
||||||
|
/* modular arithmetic */
|
||||||
|
template <ll mdl> struct MLL {
|
||||||
|
ll val;
|
||||||
|
MLL(ll v = 0) : val(mod(v, mdl)) {}
|
||||||
|
MLL(const MLL<mdl>& other) : val(other.val) {}
|
||||||
|
friend MLL operator+(const MLL& lhs, const MLL& rhs) { return mod(lhs.val + rhs.val, mdl); }
|
||||||
|
friend MLL operator-(const MLL& lhs, const MLL& rhs) { return mod(lhs.val - rhs.val, mdl); }
|
||||||
|
friend MLL operator*(const MLL& lhs, const MLL& rhs) { return mod(int128(lhs.val) * rhs.val, mdl); }
|
||||||
|
friend MLL operator/(const MLL& lhs, const MLL& rhs) { return lhs * mod(inverse(rhs.val, mdl), mdl); }
|
||||||
|
friend MLL operator%(const MLL& lhs, const MLL& rhs) { return mod(lhs.val - (lhs / rhs).val, mdl); }
|
||||||
|
friend bool operator==(const MLL& lhs, const MLL& rhs) { return lhs.val == rhs.val; }
|
||||||
|
friend bool operator!=(const MLL& lhs, const MLL& rhs) { return lhs.val != rhs.val; }
|
||||||
|
MLL& operator+=(const MLL& rhs) { return *this = *this + rhs; }
|
||||||
|
MLL& operator-=(const MLL& rhs) { return *this = *this - rhs; }
|
||||||
|
MLL& operator*=(const MLL& rhs) { return *this = *this * rhs; }
|
||||||
|
MLL& operator/=(const MLL& rhs) { return *this = *this / rhs; }
|
||||||
|
MLL& operator%=(const MLL& rhs) { return *this = *this % rhs; }
|
||||||
|
};
|
||||||
|
|
||||||
|
template <ll mdl>
|
||||||
|
ostream& operator<<(ostream& out, const MLL<mdl>& num) {
|
||||||
|
return out << num.val;
|
||||||
|
}
|
||||||
|
|
||||||
|
template <ll mdl>
|
||||||
|
istream& operator>>(istream& in, MLL<mdl>& num) {
|
||||||
|
return in >> num.val;
|
||||||
|
}
|
||||||
|
|
||||||
|
// miscancellous
|
||||||
|
template <typename T, typename U>
|
||||||
|
bool chmax(T& lhs, const U& rhs) {
|
||||||
|
bool ret = lhs < rhs;
|
||||||
|
if (ret) {
|
||||||
|
lhs = rhs;
|
||||||
|
}
|
||||||
|
return ret;
|
||||||
|
}
|
||||||
|
template <typename T, typename U>
|
||||||
|
bool chmin(T& lhs, const U& rhs) {
|
||||||
|
bool ret = lhs > rhs;
|
||||||
|
if (ret) {
|
||||||
|
lhs = rhs;
|
||||||
|
}
|
||||||
|
return ret;
|
||||||
|
}
|
||||||
|
|
||||||
|
#define functor(func) ([&](auto&&... val) \
|
||||||
|
noexcept(noexcept(func(std::forward<decltype(val)>(val)...))) -> decltype(auto) \
|
||||||
|
{return func(std::forward<decltype(val)>(val)...);})
|
||||||
|
#define expr(ret, ...) ([&] (__VA_ARGS__) { return (ret); })
|
||||||
|
template <typename Func, typename RandomIt> void sort_by_key(RandomIt first, RandomIt last, Func extractor) {
|
||||||
|
std::sort(first, last, [&] (auto&& a, auto&& b) { return std::less<>()(extractor(a), extractor(b)); });
|
||||||
|
}
|
||||||
|
template <typename Func, typename RandomIt, typename Compare> void sort_by_key(RandomIt first, RandomIt last, Func extractor, Compare comp) {
|
||||||
|
std::sort(first, last, [&] (auto&& a, auto&& b) { return comp(extractor(a), extractor(b)); });
|
||||||
|
}
|
||||||
|
template <typename T, typename U, typename Iterator_T, typename Iterator_U>
|
||||||
|
vector<pair<T, U>> zip(Iterator_T a_first, Iterator_T a_last, Iterator_U b_first, Iterator_U b_last) {
|
||||||
|
vector<pair<T, U>> res;
|
||||||
|
auto a_it = a_first;
|
||||||
|
auto b_it = b_first;
|
||||||
|
for (; not (a_it == a_last) and not (b_it == b_last); ++a_it, ++b_it) {
|
||||||
|
res.emplace_back(*a_it, *b_it);
|
||||||
|
}
|
||||||
|
return res;
|
||||||
|
}
|
||||||
|
template <typename T, typename U, typename Iterator_T, typename Iterator_U>
|
||||||
|
vector<pair<T, U>> zip_n(Iterator_T a_first, Iterator_U b_first, size_t n) {
|
||||||
|
vector<pair<T, U>> res;
|
||||||
|
if (n > 0) {
|
||||||
|
res.emplace_back(*a_first, *b_first);
|
||||||
|
for (size_t i = 1; i != n; ++i) {
|
||||||
|
res.emplace_back(*++a_first, *++b_first);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
return res;
|
||||||
|
}
|
||||||
|
template <typename T>
|
||||||
|
class ArithmeticIterator : bidirectional_iterator_tag {
|
||||||
|
public:
|
||||||
|
using difference_type = ptrdiff_t;
|
||||||
|
using value_type = T;
|
||||||
|
private:
|
||||||
|
value_type value;
|
||||||
|
public:
|
||||||
|
ArithmeticIterator(const T& value) : value(value) {}
|
||||||
|
value_type operator*() const { return value; }
|
||||||
|
ArithmeticIterator<T>& operator++() { ++value; return *this; }
|
||||||
|
ArithmeticIterator<T>& operator--() { --value; return *this; }
|
||||||
|
bool operator==(const ArithmeticIterator<T>& rhs) const { return value == rhs.value; }
|
||||||
|
};
|
||||||
|
template <typename T> vector<pair<int, T>> enumerate(const vector<T>& container) {
|
||||||
|
return zip<int, T>(ArithmeticIterator<int>(0), ArithmeticIterator<int>(INT_MAX), container.begin(), container.end());
|
||||||
|
}
|
||||||
|
#define initarray(init, N) (__initarray<decay<decltype(init)>::type, (N)>(init))
|
||||||
|
namespace detail {
|
||||||
|
template <typename T, std::size_t...Is>
|
||||||
|
constexpr std::array<T, sizeof...(Is)>
|
||||||
|
make_array(const T& value, std::index_sequence<Is...>) {
|
||||||
|
return {{(static_cast<void>(Is), value)...}};
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
template <typename T, std::size_t N>
|
||||||
|
constexpr std::array<T, N> __initarray(const T& value) {
|
||||||
|
return detail::make_array(value, std::make_index_sequence<N>());
|
||||||
|
}
|
||||||
|
/*******************************************************/
|
||||||
|
|
||||||
|
#define SINGLE_TEST_CASE
|
||||||
|
// #define DUMP_TEST_CASE 7219
|
||||||
|
// #define TOT_TEST_CASE 10000
|
||||||
|
|
||||||
|
void dump() {}
|
||||||
|
|
||||||
|
void dump_ignore() {}
|
||||||
|
|
||||||
|
void prep() {
|
||||||
|
}
|
||||||
|
|
||||||
|
constexpr int M = 500;
|
||||||
|
constexpr int N = 1e5 + 1;
|
||||||
|
constexpr int S = 1 << 17;
|
||||||
|
int pre[(N + M) / M][S], a[N];
|
||||||
|
|
||||||
|
// __attribute__((target("popcnt")))
|
||||||
|
void solve() {
|
||||||
|
read(int, n, k);
|
||||||
|
for (int i = 0; i < n; ++i) {
|
||||||
|
cin >> a[i];
|
||||||
|
}
|
||||||
|
int t = (n + M - 1) / M;
|
||||||
|
for (int i = 0; i < n; ++i) {
|
||||||
|
int c = i / M;
|
||||||
|
for (int j = i; j < min(n, i + M); ++j) {
|
||||||
|
for (int k = 0; k < S; ++k) {
|
||||||
|
pre[c][k] xor_eq a[j] - k;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
i += M - 1;
|
||||||
|
}
|
||||||
|
|
||||||
|
while (k--) {
|
||||||
|
read(int, d, l, r);
|
||||||
|
--l, --r;
|
||||||
|
int left = l;
|
||||||
|
int res = 0;
|
||||||
|
while (left <= r and left % M != 0) {
|
||||||
|
res xor_eq a[left] - d;
|
||||||
|
left += 1;
|
||||||
|
}
|
||||||
|
while (r - left + 1 >= M) {
|
||||||
|
res xor_eq pre[left / M][d];
|
||||||
|
left += M;
|
||||||
|
}
|
||||||
|
for (int j = left; j <= r; ++j) {
|
||||||
|
res xor_eq a[j] - d;
|
||||||
|
}
|
||||||
|
cout << res << '\n';
|
||||||
|
}
|
||||||
|
|
||||||
|
}
|
||||||
|
|
||||||
|
int main() {
|
||||||
|
#if __cplusplus < 201402L or defined(_MSC_VER) and not defined(__clang__)
|
||||||
|
static_assert(false, "incompatible compiler variant detected.");
|
||||||
|
#endif
|
||||||
|
untie;
|
||||||
|
prep();
|
||||||
|
#ifdef SINGLE_TEST_CASE
|
||||||
|
solve();
|
||||||
|
#else
|
||||||
|
read(int, t);
|
||||||
|
for (int i = 0; i < t; ++i) {
|
||||||
|
#ifdef DUMP_TEST_CASE
|
||||||
|
if (t != (TOT_TEST_CASE)) {
|
||||||
|
solve();
|
||||||
|
} else if (i + 1 == (DUMP_TEST_CASE)) {
|
||||||
|
dump();
|
||||||
|
} else {
|
||||||
|
dump_ignore();
|
||||||
|
}
|
||||||
|
#else
|
||||||
|
solve();
|
||||||
|
#endif
|
||||||
|
}
|
||||||
|
#endif
|
||||||
|
}
|
|
@ -0,0 +1,590 @@
|
||||||
|
// #pragma GCC target("popcnt,lzcnt,abm,bmi,bmi2")
|
||||||
|
#pragma GCC optimize("Ofast,unroll-loops")
|
||||||
|
/************* This code requires C++17. ***************/
|
||||||
|
|
||||||
|
#include<bits/stdc++.h>
|
||||||
|
using namespace std;
|
||||||
|
|
||||||
|
/* macro helpers */
|
||||||
|
#define __NARGS(...) std::tuple_size<decltype(std::make_tuple(__VA_ARGS__))>::value
|
||||||
|
#define __DECOMPOSE_S(a, x) auto x = a;
|
||||||
|
#define __DECOMPOSE_N(a, ...) auto [__VA_ARGS__] = a;
|
||||||
|
constexpr void __() {}
|
||||||
|
#define __AS_PROCEDURE(...) __(); __VA_ARGS__; __()
|
||||||
|
#define __as_typeof(container) remove_reference<decltype(container)>::type
|
||||||
|
template <typename T> struct argument_type;
|
||||||
|
template <typename T, typename U> struct argument_type<T(U)> { using type = U; };
|
||||||
|
|
||||||
|
/* type aliases */
|
||||||
|
#if LONG_LONG_MAX != INT64_MAX
|
||||||
|
using ll = int64_t;
|
||||||
|
using ull = uint64_t;
|
||||||
|
#else
|
||||||
|
using ll = long long;
|
||||||
|
using ull = unsigned long long;
|
||||||
|
#endif
|
||||||
|
using int128 = __int128_t;
|
||||||
|
using uint128 = __uint128_t;
|
||||||
|
using ld = __float128; // up to 1e-9 precision in binary search
|
||||||
|
using pii = pair<int, int>; using pil = pair<int, ll>; using pid = pair<int, ld>;
|
||||||
|
using pli = pair<ll, int>; using pll = pair<ll, ll>; using pld = pair<ll, ld>;
|
||||||
|
using pdi = pair<ld, int>; using pdl = pair<ld, ll>; using pdd = pair<ld, ld>;
|
||||||
|
using tiii = tuple<int, int, int>; using tiil = tuple<int, int, ll>; using tiid = tuple<int, int, ld>;
|
||||||
|
using tili = tuple<int, ll, int>; using till = tuple<int, ll, ll>; using tild = tuple<int, ll, ld>;
|
||||||
|
using tidi = tuple<int, ld, int>; using tidl = tuple<int, ld, ll>; using tidd = tuple<int, ld, ld>;
|
||||||
|
using tlii = tuple<ll, int, int>; using tlil = tuple<ll, int, ll>; using tlid = tuple<ll, int, ld>;
|
||||||
|
using tlli = tuple<ll, ll, int>; using tlll = tuple<ll, ll, ll>; using tlld = tuple<ll, ll, ld>;
|
||||||
|
using tldi = tuple<ll, ld, int>; using tldl = tuple<ll, ld, ll>; using tldd = tuple<ll, ld, ld>;
|
||||||
|
using tdii = tuple<ld, int, int>; using tdil = tuple<ld, int, ll>; using tdid = tuple<ld, int, ld>;
|
||||||
|
using tdli = tuple<ld, ll, int>; using tdll = tuple<ld, ll, ll>; using tdld = tuple<ld, ll, ld>;
|
||||||
|
using tddi = tuple<ld, ld, int>; using tddl = tuple<ld, ld, ll>; using tddd = tuple<ld, ld, ld>;
|
||||||
|
template <typename T> using max_heap = priority_queue<T>;
|
||||||
|
template <typename T> using min_heap = priority_queue<T, vector<T>, greater<>>;
|
||||||
|
template <typename T> using oi = ostream_iterator<T>;
|
||||||
|
template <typename T> using ii = istream_iterator<T>;
|
||||||
|
|
||||||
|
/* constants */
|
||||||
|
constexpr int INF = 0x3f3f3f3f;
|
||||||
|
constexpr ll INFLL = 0x3f3f3f3f3f3f3f3fLL;
|
||||||
|
constexpr ll MDL = 1e9 + 7;
|
||||||
|
constexpr ll PRIME = 998'244'353;
|
||||||
|
constexpr ll PRIMELL = 901017227882342239LL;
|
||||||
|
constexpr ll MDL1 = 8784491;
|
||||||
|
constexpr ll MDL2 = PRIME;
|
||||||
|
constexpr int128 INT128_MAX = numeric_limits<int128>::max();
|
||||||
|
constexpr uint128 UINT128_MAX = numeric_limits<uint128>::max();
|
||||||
|
constexpr int128 INT128_MIN = numeric_limits<int128>::min();
|
||||||
|
constexpr uint128 UINT128_MIN = numeric_limits<uint128>::min();
|
||||||
|
|
||||||
|
/* random */
|
||||||
|
|
||||||
|
mt19937_64 rd(chrono::duration_cast<chrono::milliseconds>(chrono::system_clock::now().time_since_epoch()).count());
|
||||||
|
|
||||||
|
/* bit-wise operations */
|
||||||
|
#define lowbit(x) ((x) & -(x))
|
||||||
|
#define popcount(x) (__builtin_popcountll(ll(x)))
|
||||||
|
#define parity(x) (__builtin_parityll(ll(x)))
|
||||||
|
#define msp(x) (63LL - __builtin_clzll(ll(x)))
|
||||||
|
#define lsp(x) (__builtin_ctzll(ll(x)))
|
||||||
|
|
||||||
|
/* arithmetic operations */
|
||||||
|
#define mod(x, y) ((((x) % (y)) + (y)) % (y))
|
||||||
|
|
||||||
|
/* fast pairs */
|
||||||
|
#define upair ull
|
||||||
|
#define umake(x, y) (ull(x) << 32 | (ull(y) & ((1ULL << 32) - 1)))
|
||||||
|
#define u1(p) ((p) >> 32)
|
||||||
|
#define u2(p) ((p) & ((1ULL << 32) - 1))
|
||||||
|
#define ult std::less<upair>
|
||||||
|
#define ugt std::greater<upair>
|
||||||
|
|
||||||
|
#define ipair ull
|
||||||
|
#define imake(x, y) (umake(x, y))
|
||||||
|
#define i1(p) (int(u1(ll(p))))
|
||||||
|
#define i2(p) (ll(u2(p) << 32) >> 32)
|
||||||
|
struct ilt {
|
||||||
|
bool operator()(const ipair& a, const ipair& b) const {
|
||||||
|
if (i1(a) == i1(b)) return i2(a) < i2(b);
|
||||||
|
else return i1(a) < i1(b);
|
||||||
|
}
|
||||||
|
};
|
||||||
|
struct igt {
|
||||||
|
bool operator()(const ipair& a, const ipair& b) const {
|
||||||
|
if (i1(a) == i1(b)) return i2(a) > i2(b);
|
||||||
|
else return i1(a) > i1(b);
|
||||||
|
}
|
||||||
|
};
|
||||||
|
|
||||||
|
/* conditions */
|
||||||
|
#define loop while (1)
|
||||||
|
#define if_or(var, val) if (!((var) == (val))) (var) = (val); else
|
||||||
|
#define continue_or(var, val) __AS_PROCEDURE(if ((var) == (val)) continue; (var) = (val);)
|
||||||
|
#define break_or(var, val) __AS_PROCEDURE(if ((var) == (val)) break; (var) = (val);)
|
||||||
|
|
||||||
|
/* hash */
|
||||||
|
struct safe_hash {
|
||||||
|
// https://codeforces.com/blog/entry/62393
|
||||||
|
static uint64_t splitmix64(uint64_t x) {
|
||||||
|
// http://xorshift.di.unimi.it/splitmix64.c
|
||||||
|
x += 0x9e3779b97f4a7c15;
|
||||||
|
x = (x ^ (x >> 30)) * 0xbf58476d1ce4e5b9;
|
||||||
|
x = (x ^ (x >> 27)) * 0x94d049bb133111eb;
|
||||||
|
return x ^ (x >> 31);
|
||||||
|
}
|
||||||
|
|
||||||
|
size_t operator()(uint64_t x) const {
|
||||||
|
static const uint64_t FIXED_RANDOM = chrono::steady_clock::now().time_since_epoch().count();
|
||||||
|
return splitmix64(x + FIXED_RANDOM);
|
||||||
|
}
|
||||||
|
};
|
||||||
|
|
||||||
|
struct pair_hash {
|
||||||
|
template <typename T, typename U>
|
||||||
|
size_t operator()(const pair<T, U>& a) const {
|
||||||
|
auto hash1 = safe_hash()(a.first);
|
||||||
|
auto hash2 = safe_hash()(a.second);
|
||||||
|
if (hash1 != hash2) {
|
||||||
|
return hash1 ^ hash2;
|
||||||
|
}
|
||||||
|
return hash1;
|
||||||
|
}
|
||||||
|
};
|
||||||
|
|
||||||
|
uniform_int_distribution<mt19937::result_type> dist(PRIME);
|
||||||
|
const size_t __array_hash_b = 31, __array_hash_mdl1 = dist(rd), __array_hash_mdl2 = dist(rd);
|
||||||
|
struct array_hash {
|
||||||
|
safe_hash hasher;
|
||||||
|
template <typename Sequence>
|
||||||
|
size_t operator()(const Sequence& arr) const {
|
||||||
|
size_t pw1 = 1, pw2 = 1;
|
||||||
|
size_t res1 = 0, res2 = 0;
|
||||||
|
for (auto&& x : arr) {
|
||||||
|
auto h = hasher(x);
|
||||||
|
res1 = (res1 + h * pw1) % __array_hash_mdl1;
|
||||||
|
res2 = (res2 + h * pw2) % __array_hash_mdl2;
|
||||||
|
pw1 = (pw1 * __array_hash_b) % __array_hash_mdl1;
|
||||||
|
pw2 = (pw2 * __array_hash_b) % __array_hash_mdl2;
|
||||||
|
}
|
||||||
|
return res1 + res2;
|
||||||
|
}
|
||||||
|
};
|
||||||
|
|
||||||
|
/* build data structures */
|
||||||
|
#define faster(um) __AS_PROCEDURE((um).reserve(1024); (um).max_load_factor(0.25);)
|
||||||
|
#define unordered_counter(from, to) __AS_PROCEDURE(unordered_map<__as_typeof(from), size_t, safe_hash> to; for (auto&& x : from) ++to[x];)
|
||||||
|
#define counter(from, to, cmp) __AS_PROCEDURE(map<__as_typeof(from), size_t, cmp> to; for (auto&& x : from) ++to[x];)
|
||||||
|
#define adj(ch, n) __AS_PROCEDURE(vector<vector<int>> ch((n) + 1);)
|
||||||
|
#define edge(ch, u, v) __AS_PROCEDURE(ch[u].push_back(v), ch[v].push_back(u);)
|
||||||
|
#define edgew(ch, u, v, ...) __AS_PROCEDURE(ch[u].emplace_back(v, __VA_ARGS__), ch[v].emplace_back(u, __VA_ARGS__);)
|
||||||
|
#define Edge(ch, u, v) __AS_PROCEDURE(ch[u].push_back(v);)
|
||||||
|
#define Edgew(ch, u, v, ...) __AS_PROCEDURE(ch[u].emplace_back(v, __VA_ARGS__);)
|
||||||
|
template <typename T, typename Iterator> pair<size_t, map<T, size_t>> discretize(Iterator __first, Iterator __last) {
|
||||||
|
set<T> st(__first, __last);
|
||||||
|
size_t N = 0;
|
||||||
|
map<T, size_t> mp;
|
||||||
|
for (auto&& x : st) mp[x] = ++N;
|
||||||
|
return {N, mp};
|
||||||
|
}
|
||||||
|
template <typename T, typename Iterator> pair<size_t, unordered_map<T, size_t, safe_hash>> unordered_discretize(Iterator __first, Iterator __last) {
|
||||||
|
set<T> st(__first, __last);
|
||||||
|
size_t N = 0;
|
||||||
|
unordered_map<T, size_t, safe_hash> mp;
|
||||||
|
for (auto&& x : st) mp[x] = ++N;
|
||||||
|
return {N, mp};
|
||||||
|
}
|
||||||
|
|
||||||
|
/* io */
|
||||||
|
#define untie __AS_PROCEDURE(ios_base::sync_with_stdio(0), cin.tie(NULL))
|
||||||
|
|
||||||
|
// add declarations to avoid circular dependency
|
||||||
|
template<typename T, typename U> istream& operator>>(istream&, pair<T, U>&);
|
||||||
|
template<typename T, typename U> ostream& operator<<(ostream&, const pair<T, U>&);
|
||||||
|
template<typename T, size_t N> istream& operator>>(istream&, array<T, N>&);
|
||||||
|
template <typename T, size_t N> ostream& operator<<(ostream&, const array<T, N>&);
|
||||||
|
template<typename Char, typename Traits, typename... Args>
|
||||||
|
decltype(auto) operator<<(std::basic_ostream<Char, Traits>&, const std::tuple<Args...>&);
|
||||||
|
template<typename T> ostream& operator<<(ostream&, const vector<T>&);
|
||||||
|
std::ostream& operator<<(std::ostream&, const int128&);
|
||||||
|
|
||||||
|
template<typename T, typename U> istream& operator>>(istream& in, pair<T, U>& p) {
|
||||||
|
return in >> p.first >> p.second;
|
||||||
|
}
|
||||||
|
template<typename T, typename U> ostream& operator<<(ostream& out, const pair<T, U>& p) {
|
||||||
|
out << "{" << p.first << ", " << p.second << "}";
|
||||||
|
return out;
|
||||||
|
}
|
||||||
|
template<typename T, size_t N> istream& operator>>(istream& in, array<T, N>& a) {
|
||||||
|
for (size_t i = 0; i < N; ++i) in >> a[i];
|
||||||
|
return in;
|
||||||
|
}
|
||||||
|
template <typename T, size_t N> ostream& operator<<(ostream& out, const array<T, N>& a) {
|
||||||
|
for (auto&& i : a) out << i << ' ';
|
||||||
|
return out;
|
||||||
|
}
|
||||||
|
template<typename Char, typename Traits, typename Tuple, std::size_t... Index>
|
||||||
|
void print_tuple_impl(std::basic_ostream<Char, Traits>& os, const Tuple& t, std::index_sequence<Index...>) {
|
||||||
|
using swallow = int[]; // guaranties left to right order
|
||||||
|
(void)swallow { 0, (void(os << (Index == 0 ? "" : ", ") << std::get<Index>(t)), 0)... };
|
||||||
|
}
|
||||||
|
template<typename Char, typename Traits, typename... Args>
|
||||||
|
decltype(auto) operator<<(std::basic_ostream<Char, Traits>& os, const std::tuple<Args...>& t) {
|
||||||
|
os << "{";
|
||||||
|
print_tuple_impl(os, t, std::index_sequence_for<Args...>{});
|
||||||
|
return os << "}";
|
||||||
|
}
|
||||||
|
template<typename T> ostream& operator<<(ostream& out, const vector<T>& vec) {
|
||||||
|
for (auto&& i : vec) out << i << ' ';
|
||||||
|
return out;
|
||||||
|
}
|
||||||
|
std::ostream& operator<<(std::ostream& dest, const int128& value) {
|
||||||
|
// https://stackoverflow.com/a/25115163/23881100
|
||||||
|
std::ostream::sentry s( dest );
|
||||||
|
if ( s ) {
|
||||||
|
uint128 tmp = value < 0 ? -value : value;
|
||||||
|
char buffer[ 128 ];
|
||||||
|
char* d = std::end( buffer );
|
||||||
|
do {
|
||||||
|
-- d;
|
||||||
|
*d = "0123456789"[ tmp % 10 ];
|
||||||
|
tmp /= 10;
|
||||||
|
} while ( tmp != 0 );
|
||||||
|
if ( value < 0 ) {
|
||||||
|
-- d;
|
||||||
|
*d = '-';
|
||||||
|
}
|
||||||
|
int len = std::end( buffer ) - d;
|
||||||
|
if ( dest.rdbuf()->sputn( d, len ) != len ) {
|
||||||
|
dest.setstate( std::ios_base::badbit );
|
||||||
|
}
|
||||||
|
}
|
||||||
|
return dest;
|
||||||
|
}
|
||||||
|
template<typename T> void __read(T& x) { cin >> x; }
|
||||||
|
template<typename T, typename... U> void __read(T& x, U&... args) { cin >> x; __read(args...); }
|
||||||
|
#define read(t, ...) __AS_PROCEDURE(argument_type<void(t)>::type __VA_ARGS__; __read(__VA_ARGS__);)
|
||||||
|
#define readvec(t, a, n) __AS_PROCEDURE(vector<argument_type<void(t)>::type> a(n); for (auto& x : (a)) cin >> x;)
|
||||||
|
#define readvec1(t, a, n) __AS_PROCEDURE(vector<argument_type<void(t)>::type> a((n) + 1); copy_n(ii<argument_type<void(t)>::type>(cin), (n), (a).begin() + 1);)
|
||||||
|
#define putvec(a) __AS_PROCEDURE(copy((a).begin(), (a).end(), oi<__as_typeof(a)::value_type>(cout, " ")); cout << endl;)
|
||||||
|
#define putvec1(a) __AS_PROCEDURE(copy((a).begin() + 1, (a).end(), oi<__as_typeof(a)::value_type>(cout, " ")); cout << endl;)
|
||||||
|
#define putvec_eol(a) __AS_PROCEDURE(copy((a).begin(), (a).end(), oi<__as_typeof(a)::value_type>(cout, "\n"));)
|
||||||
|
#define putvec1_eol(a) __AS_PROCEDURE(copy((a).begin() + 1, (a).end(), oi<__as_typeof(a)::value_type>(cout, "\n"));)
|
||||||
|
#define debug(x) __AS_PROCEDURE(cerr << #x" = " << (x) << endl;)
|
||||||
|
#define debugvec(a) __AS_PROCEDURE(cerr << #a" = "; for (auto&& x : (a)) cerr << x << ' '; cerr << endl;)
|
||||||
|
#define deb(...) debug(make_tuple(__VA_ARGS__))
|
||||||
|
|
||||||
|
/* pops */
|
||||||
|
template <typename Container>
|
||||||
|
inline auto poptop(Container& q) {
|
||||||
|
auto ret = q.top();
|
||||||
|
q.pop();
|
||||||
|
return ret;
|
||||||
|
}
|
||||||
|
template <typename Container>
|
||||||
|
inline auto popback(Container& q) {
|
||||||
|
auto ret = q.back();
|
||||||
|
q.pop_back();
|
||||||
|
return ret;
|
||||||
|
}
|
||||||
|
template <typename Container>
|
||||||
|
inline auto popfront(Container& q) {
|
||||||
|
auto ret = q.front();
|
||||||
|
q.pop_front();
|
||||||
|
return ret;
|
||||||
|
}
|
||||||
|
|
||||||
|
/* math */
|
||||||
|
template <typename return_t>
|
||||||
|
return_t qpow(ll b, ll p) {
|
||||||
|
if (b == 0 and p != 0) return 0;
|
||||||
|
if (p == 0) return 1;
|
||||||
|
return_t half = qpow<return_t>(b, p / 2);
|
||||||
|
if (p % 2 == 1) return half * half * b;
|
||||||
|
else return half * half;
|
||||||
|
}
|
||||||
|
|
||||||
|
// dynamic modulus
|
||||||
|
ll qpow(ll b, ll p, ll mod) {
|
||||||
|
if (b == 0 and p != 0) return 0;
|
||||||
|
if (p == 0) return 1;
|
||||||
|
ll half = qpow(b, p / 2, mod);
|
||||||
|
if (p % 2 == 1) return (int128(half) * half % mod) * b % mod;
|
||||||
|
else return half * half % mod;
|
||||||
|
}
|
||||||
|
|
||||||
|
|
||||||
|
#pragma GCC diagnostic push
|
||||||
|
#pragma GCC diagnostic ignored "-Wparentheses"
|
||||||
|
// Accurately find `i` 'th root of `n` (taking the floor)
|
||||||
|
inline ll root(ll n, ll i) {
|
||||||
|
ll l = 0, r = pow(LLONG_MAX, (long double)(1) / i);
|
||||||
|
while (l < r) {
|
||||||
|
ll mid = l + r + 1 >> 1;
|
||||||
|
if (qpow<int128>(mid, i) <= n) {
|
||||||
|
l = mid;
|
||||||
|
} else {
|
||||||
|
r = mid - 1;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
return l;
|
||||||
|
}
|
||||||
|
#pragma GCC diagnostic pop
|
||||||
|
|
||||||
|
|
||||||
|
#define comb(n, k) ((n) < 0 or (k) < 0 or (n) < (k) ? 0 : fact[n] / fact[k] / fact[(n) - (k)])
|
||||||
|
#define fastcomb(n, k) ((n) < 0 or (k) < 0 or (n) < (k) ? 0 : fact[n] * factrev[k] * factrev[(n) - (k)])
|
||||||
|
|
||||||
|
__attribute__((target("lzcnt")))
|
||||||
|
constexpr inline int lg2(ll x) { return x == 0 ? -1 : sizeof(ll) * 8 - 1 - __builtin_clzll(x); }
|
||||||
|
|
||||||
|
template <typename T>
|
||||||
|
T mygcd(T a, T b) { return b == 0 ? a : mygcd(b, a % b); }
|
||||||
|
|
||||||
|
void __exgcd(ll a, ll b, ll& x, ll& y) {
|
||||||
|
if (b == 0) {
|
||||||
|
x = 1, y = 0;
|
||||||
|
return;
|
||||||
|
}
|
||||||
|
__exgcd(b, a % b, y, x);
|
||||||
|
y -= a / b * x;
|
||||||
|
}
|
||||||
|
|
||||||
|
ll inverse(ll a, ll b) {
|
||||||
|
ll x, y;
|
||||||
|
__exgcd(a, b, x, y);
|
||||||
|
return mod(x, b);
|
||||||
|
}
|
||||||
|
|
||||||
|
vector<tuple<int, int, ll>> decompose(ll x) {
|
||||||
|
// return (factor, count, factor ** count)
|
||||||
|
vector<tuple<int, int, ll>> res;
|
||||||
|
for (int i = 2; i * i <= x; i++) {
|
||||||
|
if (x % i == 0) {
|
||||||
|
int cnt = 0;
|
||||||
|
ll pw = 1;
|
||||||
|
while (x % i == 0) ++cnt, x /= i, pw *= i;
|
||||||
|
res.emplace_back(i, cnt, pw);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
if (x != 1) {
|
||||||
|
res.emplace_back(x, 1, x);
|
||||||
|
}
|
||||||
|
return res;
|
||||||
|
}
|
||||||
|
|
||||||
|
vector<pii> decompose_prime(int N) {
|
||||||
|
// return (factor, count)
|
||||||
|
vector<pii> result;
|
||||||
|
for (int i = 2; i * i <= N; i++) {
|
||||||
|
if (N % i == 0) {
|
||||||
|
int cnt = 0;
|
||||||
|
while (N % i == 0) N /= i, ++cnt;
|
||||||
|
result.emplace_back(i, cnt);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
if (N != 1) {
|
||||||
|
result.emplace_back(N, 1);
|
||||||
|
}
|
||||||
|
return result;
|
||||||
|
}
|
||||||
|
|
||||||
|
/* string algorithms */
|
||||||
|
vector<int> calc_next(string t) { // pi function of t
|
||||||
|
int n = (int)t.length();
|
||||||
|
vector<int> pi(n);
|
||||||
|
for (int i = 1; i < n; i++) {
|
||||||
|
int j = pi[i - 1];
|
||||||
|
while (j > 0 && t[i] != t[j]) j = pi[j - 1];
|
||||||
|
if (t[i] == t[j]) j++;
|
||||||
|
pi[i] = j;
|
||||||
|
}
|
||||||
|
return pi;
|
||||||
|
}
|
||||||
|
vector<int> calc_z(string t) { // z function of t
|
||||||
|
int m = t.length();
|
||||||
|
vector<int> z;
|
||||||
|
z.push_back(m);
|
||||||
|
pair<int, int> prev = {1, -1};
|
||||||
|
for (int i = 1; i < m; ++i) {
|
||||||
|
if (z[i - prev.first] + i <= prev.second) {
|
||||||
|
z.push_back(z[i - prev.first]);
|
||||||
|
} else {
|
||||||
|
int j = max(i, prev.second + 1);
|
||||||
|
while (j < m && t[j] == t[j - i]) ++j;
|
||||||
|
z.push_back(j - i);
|
||||||
|
prev = {i, j - 1};
|
||||||
|
}
|
||||||
|
}
|
||||||
|
return z;
|
||||||
|
}
|
||||||
|
vector<int> kmp(const string& s, const string& t) { // find all t in s
|
||||||
|
string cur = t + '#' + s;
|
||||||
|
int sz1 = s.size(), sz2 = t.size();
|
||||||
|
vector<int> v;
|
||||||
|
vector<int> lps = calc_next(cur);
|
||||||
|
for (int i = sz2 + 1; i <= sz1 + sz2; i++) {
|
||||||
|
if (lps[i] == sz2) v.push_back(i - 2 * sz2);
|
||||||
|
}
|
||||||
|
return v;
|
||||||
|
}
|
||||||
|
int period(const string& s) { // find the length of shortest recurring period
|
||||||
|
int n = s.length();
|
||||||
|
auto z = calc_z(s);
|
||||||
|
for (int i = 1; i <= n / 2; ++i) {
|
||||||
|
if (n % i == 0 && z[i] == n - i) {
|
||||||
|
return i;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
return n;
|
||||||
|
}
|
||||||
|
|
||||||
|
/* modular arithmetic */
|
||||||
|
template <ll mdl> struct MLL {
|
||||||
|
ll val;
|
||||||
|
MLL(ll v = 0) : val(mod(v, mdl)) {}
|
||||||
|
MLL(const MLL<mdl>& other) : val(other.val) {}
|
||||||
|
friend MLL operator+(const MLL& lhs, const MLL& rhs) { return mod(lhs.val + rhs.val, mdl); }
|
||||||
|
friend MLL operator-(const MLL& lhs, const MLL& rhs) { return mod(lhs.val - rhs.val, mdl); }
|
||||||
|
friend MLL operator*(const MLL& lhs, const MLL& rhs) { return mod(int128(lhs.val) * rhs.val, mdl); }
|
||||||
|
friend MLL operator/(const MLL& lhs, const MLL& rhs) { return lhs * mod(inverse(rhs.val, mdl), mdl); }
|
||||||
|
friend MLL operator%(const MLL& lhs, const MLL& rhs) { return mod(lhs.val - (lhs / rhs).val, mdl); }
|
||||||
|
friend bool operator==(const MLL& lhs, const MLL& rhs) { return lhs.val == rhs.val; }
|
||||||
|
friend bool operator!=(const MLL& lhs, const MLL& rhs) { return lhs.val != rhs.val; }
|
||||||
|
MLL& operator+=(const MLL& rhs) { return *this = *this + rhs; }
|
||||||
|
MLL& operator-=(const MLL& rhs) { return *this = *this - rhs; }
|
||||||
|
MLL& operator*=(const MLL& rhs) { return *this = *this * rhs; }
|
||||||
|
MLL& operator/=(const MLL& rhs) { return *this = *this / rhs; }
|
||||||
|
MLL& operator%=(const MLL& rhs) { return *this = *this % rhs; }
|
||||||
|
};
|
||||||
|
|
||||||
|
template <ll mdl>
|
||||||
|
ostream& operator<<(ostream& out, const MLL<mdl>& num) {
|
||||||
|
return out << num.val;
|
||||||
|
}
|
||||||
|
|
||||||
|
template <ll mdl>
|
||||||
|
istream& operator>>(istream& in, MLL<mdl>& num) {
|
||||||
|
return in >> num.val;
|
||||||
|
}
|
||||||
|
|
||||||
|
// miscancellous
|
||||||
|
template <typename T, typename U>
|
||||||
|
bool chmax(T& lhs, const U& rhs) {
|
||||||
|
bool ret = lhs < rhs;
|
||||||
|
if (ret) {
|
||||||
|
lhs = rhs;
|
||||||
|
}
|
||||||
|
return ret;
|
||||||
|
}
|
||||||
|
template <typename T, typename U>
|
||||||
|
bool chmin(T& lhs, const U& rhs) {
|
||||||
|
bool ret = lhs > rhs;
|
||||||
|
if (ret) {
|
||||||
|
lhs = rhs;
|
||||||
|
}
|
||||||
|
return ret;
|
||||||
|
}
|
||||||
|
|
||||||
|
#define functor(func) ([&](auto&&... val) \
|
||||||
|
noexcept(noexcept(func(std::forward<decltype(val)>(val)...))) -> decltype(auto) \
|
||||||
|
{return func(std::forward<decltype(val)>(val)...);})
|
||||||
|
#define expr(ret, ...) ([&] (__VA_ARGS__) { return (ret); })
|
||||||
|
template <typename Func, typename RandomIt> void sort_by_key(RandomIt first, RandomIt last, Func extractor) {
|
||||||
|
std::sort(first, last, [&] (auto&& a, auto&& b) { return std::less<>()(extractor(a), extractor(b)); });
|
||||||
|
}
|
||||||
|
template <typename Func, typename RandomIt, typename Compare> void sort_by_key(RandomIt first, RandomIt last, Func extractor, Compare comp) {
|
||||||
|
std::sort(first, last, [&] (auto&& a, auto&& b) { return comp(extractor(a), extractor(b)); });
|
||||||
|
}
|
||||||
|
template <typename T, typename U, typename Iterator_T, typename Iterator_U>
|
||||||
|
vector<pair<T, U>> zip(Iterator_T a_first, Iterator_T a_last, Iterator_U b_first, Iterator_U b_last) {
|
||||||
|
vector<pair<T, U>> res;
|
||||||
|
auto a_it = a_first;
|
||||||
|
auto b_it = b_first;
|
||||||
|
for (; not (a_it == a_last) and not (b_it == b_last); ++a_it, ++b_it) {
|
||||||
|
res.emplace_back(*a_it, *b_it);
|
||||||
|
}
|
||||||
|
return res;
|
||||||
|
}
|
||||||
|
template <typename T, typename U, typename Iterator_T, typename Iterator_U>
|
||||||
|
vector<pair<T, U>> zip_n(Iterator_T a_first, Iterator_U b_first, size_t n) {
|
||||||
|
vector<pair<T, U>> res;
|
||||||
|
if (n > 0) {
|
||||||
|
res.emplace_back(*a_first, *b_first);
|
||||||
|
for (size_t i = 1; i != n; ++i) {
|
||||||
|
res.emplace_back(*++a_first, *++b_first);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
return res;
|
||||||
|
}
|
||||||
|
template <typename T>
|
||||||
|
class ArithmeticIterator : bidirectional_iterator_tag {
|
||||||
|
public:
|
||||||
|
using difference_type = ptrdiff_t;
|
||||||
|
using value_type = T;
|
||||||
|
private:
|
||||||
|
value_type value;
|
||||||
|
public:
|
||||||
|
ArithmeticIterator(const T& value) : value(value) {}
|
||||||
|
value_type operator*() const { return value; }
|
||||||
|
ArithmeticIterator<T>& operator++() { ++value; return *this; }
|
||||||
|
ArithmeticIterator<T>& operator--() { --value; return *this; }
|
||||||
|
bool operator==(const ArithmeticIterator<T>& rhs) const { return value == rhs.value; }
|
||||||
|
};
|
||||||
|
template <typename T> vector<pair<int, T>> enumerate(const vector<T>& container) {
|
||||||
|
return zip<int, T>(ArithmeticIterator<int>(0), ArithmeticIterator<int>(INT_MAX), container.begin(), container.end());
|
||||||
|
}
|
||||||
|
#define initarray(init, N) (__initarray<decay<decltype(init)>::type, (N)>(init))
|
||||||
|
namespace detail {
|
||||||
|
template <typename T, std::size_t...Is>
|
||||||
|
constexpr std::array<T, sizeof...(Is)>
|
||||||
|
make_array(const T& value, std::index_sequence<Is...>) {
|
||||||
|
return {{(static_cast<void>(Is), value)...}};
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
template <typename T, std::size_t N>
|
||||||
|
constexpr std::array<T, N> __initarray(const T& value) {
|
||||||
|
return detail::make_array(value, std::make_index_sequence<N>());
|
||||||
|
}
|
||||||
|
/*******************************************************/
|
||||||
|
|
||||||
|
// #define SINGLE_TEST_CASE
|
||||||
|
// #define DUMP_TEST_CASE 7219
|
||||||
|
// #define TOT_TEST_CASE 10000
|
||||||
|
|
||||||
|
void dump() {}
|
||||||
|
|
||||||
|
void dump_ignore() {}
|
||||||
|
|
||||||
|
void prep() {
|
||||||
|
}
|
||||||
|
|
||||||
|
// __attribute__((target("popcnt")))
|
||||||
|
void solve() {
|
||||||
|
read(int, n);
|
||||||
|
read(ll, l);
|
||||||
|
readvec(ll, a, n);
|
||||||
|
ll raw = 0;
|
||||||
|
for (int i = 0; i < n; ++i) {
|
||||||
|
raw or_eq a[i];
|
||||||
|
}
|
||||||
|
for (int i = 60; ~i; --i) {
|
||||||
|
int cnt = 0;
|
||||||
|
for (int j = 0; j < n; ++j) {
|
||||||
|
cnt += a[j] >> i bitand 1;
|
||||||
|
}
|
||||||
|
if (cnt < 2) continue;
|
||||||
|
for (int j = 0; j < n; ++j) {
|
||||||
|
if ((a[j] >> i bitand 1) and ((a[j] bitor ((ll(1) << i) - 1)) xor ll(1) << i) >= l) {
|
||||||
|
cout << (raw bitor ((ll(1) << i) - 1)) << '\n';
|
||||||
|
return;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
cout << raw << '\n';
|
||||||
|
}
|
||||||
|
|
||||||
|
int main() {
|
||||||
|
#if __cplusplus < 201402L or defined(_MSC_VER) and not defined(__clang__)
|
||||||
|
static_assert(false, "incompatible compiler variant detected.");
|
||||||
|
#endif
|
||||||
|
untie;
|
||||||
|
prep();
|
||||||
|
#ifdef SINGLE_TEST_CASE
|
||||||
|
solve();
|
||||||
|
#else
|
||||||
|
read(int, t);
|
||||||
|
for (int i = 0; i < t; ++i) {
|
||||||
|
#ifdef DUMP_TEST_CASE
|
||||||
|
if (t != (TOT_TEST_CASE)) {
|
||||||
|
solve();
|
||||||
|
} else if (i + 1 == (DUMP_TEST_CASE)) {
|
||||||
|
dump();
|
||||||
|
} else {
|
||||||
|
dump_ignore();
|
||||||
|
}
|
||||||
|
#else
|
||||||
|
solve();
|
||||||
|
#endif
|
||||||
|
}
|
||||||
|
#endif
|
||||||
|
}
|
|
@ -0,0 +1,586 @@
|
||||||
|
// #pragma GCC target("popcnt,lzcnt,abm,bmi,bmi2")
|
||||||
|
#pragma GCC optimize("Ofast,unroll-loops")
|
||||||
|
/************* This code requires C++17. ***************/
|
||||||
|
|
||||||
|
#include<bits/stdc++.h>
|
||||||
|
using namespace std;
|
||||||
|
|
||||||
|
/* macro helpers */
|
||||||
|
#define __NARGS(...) std::tuple_size<decltype(std::make_tuple(__VA_ARGS__))>::value
|
||||||
|
#define __DECOMPOSE_S(a, x) auto x = a;
|
||||||
|
#define __DECOMPOSE_N(a, ...) auto [__VA_ARGS__] = a;
|
||||||
|
constexpr void __() {}
|
||||||
|
#define __AS_PROCEDURE(...) __(); __VA_ARGS__; __()
|
||||||
|
#define __as_typeof(container) remove_reference<decltype(container)>::type
|
||||||
|
template <typename T> struct argument_type;
|
||||||
|
template <typename T, typename U> struct argument_type<T(U)> { using type = U; };
|
||||||
|
|
||||||
|
/* type aliases */
|
||||||
|
#if LONG_LONG_MAX != INT64_MAX
|
||||||
|
using ll = int64_t;
|
||||||
|
using ull = uint64_t;
|
||||||
|
#else
|
||||||
|
using ll = long long;
|
||||||
|
using ull = unsigned long long;
|
||||||
|
#endif
|
||||||
|
using int128 = __int128_t;
|
||||||
|
using uint128 = __uint128_t;
|
||||||
|
using ld = __float128; // up to 1e-9 precision in binary search
|
||||||
|
using pii = pair<int, int>; using pil = pair<int, ll>; using pid = pair<int, ld>;
|
||||||
|
using pli = pair<ll, int>; using pll = pair<ll, ll>; using pld = pair<ll, ld>;
|
||||||
|
using pdi = pair<ld, int>; using pdl = pair<ld, ll>; using pdd = pair<ld, ld>;
|
||||||
|
using tiii = tuple<int, int, int>; using tiil = tuple<int, int, ll>; using tiid = tuple<int, int, ld>;
|
||||||
|
using tili = tuple<int, ll, int>; using till = tuple<int, ll, ll>; using tild = tuple<int, ll, ld>;
|
||||||
|
using tidi = tuple<int, ld, int>; using tidl = tuple<int, ld, ll>; using tidd = tuple<int, ld, ld>;
|
||||||
|
using tlii = tuple<ll, int, int>; using tlil = tuple<ll, int, ll>; using tlid = tuple<ll, int, ld>;
|
||||||
|
using tlli = tuple<ll, ll, int>; using tlll = tuple<ll, ll, ll>; using tlld = tuple<ll, ll, ld>;
|
||||||
|
using tldi = tuple<ll, ld, int>; using tldl = tuple<ll, ld, ll>; using tldd = tuple<ll, ld, ld>;
|
||||||
|
using tdii = tuple<ld, int, int>; using tdil = tuple<ld, int, ll>; using tdid = tuple<ld, int, ld>;
|
||||||
|
using tdli = tuple<ld, ll, int>; using tdll = tuple<ld, ll, ll>; using tdld = tuple<ld, ll, ld>;
|
||||||
|
using tddi = tuple<ld, ld, int>; using tddl = tuple<ld, ld, ll>; using tddd = tuple<ld, ld, ld>;
|
||||||
|
template <typename T> using max_heap = priority_queue<T>;
|
||||||
|
template <typename T> using min_heap = priority_queue<T, vector<T>, greater<>>;
|
||||||
|
template <typename T> using oi = ostream_iterator<T>;
|
||||||
|
template <typename T> using ii = istream_iterator<T>;
|
||||||
|
|
||||||
|
/* constants */
|
||||||
|
constexpr int INF = 0x3f3f3f3f;
|
||||||
|
constexpr ll INFLL = 0x3f3f3f3f3f3f3f3fLL;
|
||||||
|
constexpr ll MDL = 1e9 + 7;
|
||||||
|
constexpr ll PRIME = 998'244'353;
|
||||||
|
constexpr ll PRIMELL = 901017227882342239LL;
|
||||||
|
constexpr ll MDL1 = 8784491;
|
||||||
|
constexpr ll MDL2 = PRIME;
|
||||||
|
constexpr int128 INT128_MAX = numeric_limits<int128>::max();
|
||||||
|
constexpr uint128 UINT128_MAX = numeric_limits<uint128>::max();
|
||||||
|
constexpr int128 INT128_MIN = numeric_limits<int128>::min();
|
||||||
|
constexpr uint128 UINT128_MIN = numeric_limits<uint128>::min();
|
||||||
|
|
||||||
|
/* random */
|
||||||
|
|
||||||
|
mt19937_64 rd(chrono::duration_cast<chrono::milliseconds>(chrono::system_clock::now().time_since_epoch()).count());
|
||||||
|
|
||||||
|
/* bit-wise operations */
|
||||||
|
#define lowbit(x) ((x) & -(x))
|
||||||
|
#define popcount(x) (__builtin_popcountll(ll(x)))
|
||||||
|
#define parity(x) (__builtin_parityll(ll(x)))
|
||||||
|
#define msp(x) (63LL - __builtin_clzll(ll(x)))
|
||||||
|
#define lsp(x) (__builtin_ctzll(ll(x)))
|
||||||
|
|
||||||
|
/* arithmetic operations */
|
||||||
|
#define mod(x, y) ((((x) % (y)) + (y)) % (y))
|
||||||
|
|
||||||
|
/* fast pairs */
|
||||||
|
#define upair ull
|
||||||
|
#define umake(x, y) (ull(x) << 32 | (ull(y) & ((1ULL << 32) - 1)))
|
||||||
|
#define u1(p) ((p) >> 32)
|
||||||
|
#define u2(p) ((p) & ((1ULL << 32) - 1))
|
||||||
|
#define ult std::less<upair>
|
||||||
|
#define ugt std::greater<upair>
|
||||||
|
|
||||||
|
#define ipair ull
|
||||||
|
#define imake(x, y) (umake(x, y))
|
||||||
|
#define i1(p) (int(u1(ll(p))))
|
||||||
|
#define i2(p) (ll(u2(p) << 32) >> 32)
|
||||||
|
struct ilt {
|
||||||
|
bool operator()(const ipair& a, const ipair& b) const {
|
||||||
|
if (i1(a) == i1(b)) return i2(a) < i2(b);
|
||||||
|
else return i1(a) < i1(b);
|
||||||
|
}
|
||||||
|
};
|
||||||
|
struct igt {
|
||||||
|
bool operator()(const ipair& a, const ipair& b) const {
|
||||||
|
if (i1(a) == i1(b)) return i2(a) > i2(b);
|
||||||
|
else return i1(a) > i1(b);
|
||||||
|
}
|
||||||
|
};
|
||||||
|
|
||||||
|
/* conditions */
|
||||||
|
#define loop while (1)
|
||||||
|
#define if_or(var, val) if (!((var) == (val))) (var) = (val); else
|
||||||
|
#define continue_or(var, val) __AS_PROCEDURE(if ((var) == (val)) continue; (var) = (val);)
|
||||||
|
#define break_or(var, val) __AS_PROCEDURE(if ((var) == (val)) break; (var) = (val);)
|
||||||
|
|
||||||
|
/* hash */
|
||||||
|
struct safe_hash {
|
||||||
|
// https://codeforces.com/blog/entry/62393
|
||||||
|
static uint64_t splitmix64(uint64_t x) {
|
||||||
|
// http://xorshift.di.unimi.it/splitmix64.c
|
||||||
|
x += 0x9e3779b97f4a7c15;
|
||||||
|
x = (x ^ (x >> 30)) * 0xbf58476d1ce4e5b9;
|
||||||
|
x = (x ^ (x >> 27)) * 0x94d049bb133111eb;
|
||||||
|
return x ^ (x >> 31);
|
||||||
|
}
|
||||||
|
|
||||||
|
size_t operator()(uint64_t x) const {
|
||||||
|
static const uint64_t FIXED_RANDOM = chrono::steady_clock::now().time_since_epoch().count();
|
||||||
|
return splitmix64(x + FIXED_RANDOM);
|
||||||
|
}
|
||||||
|
};
|
||||||
|
|
||||||
|
struct pair_hash {
|
||||||
|
template <typename T, typename U>
|
||||||
|
size_t operator()(const pair<T, U>& a) const {
|
||||||
|
auto hash1 = safe_hash()(a.first);
|
||||||
|
auto hash2 = safe_hash()(a.second);
|
||||||
|
if (hash1 != hash2) {
|
||||||
|
return hash1 ^ hash2;
|
||||||
|
}
|
||||||
|
return hash1;
|
||||||
|
}
|
||||||
|
};
|
||||||
|
|
||||||
|
uniform_int_distribution<mt19937::result_type> dist(PRIME);
|
||||||
|
const size_t __array_hash_b = 31, __array_hash_mdl1 = dist(rd), __array_hash_mdl2 = dist(rd);
|
||||||
|
struct array_hash {
|
||||||
|
safe_hash hasher;
|
||||||
|
template <typename Sequence>
|
||||||
|
size_t operator()(const Sequence& arr) const {
|
||||||
|
size_t pw1 = 1, pw2 = 1;
|
||||||
|
size_t res1 = 0, res2 = 0;
|
||||||
|
for (auto&& x : arr) {
|
||||||
|
auto h = hasher(x);
|
||||||
|
res1 = (res1 + h * pw1) % __array_hash_mdl1;
|
||||||
|
res2 = (res2 + h * pw2) % __array_hash_mdl2;
|
||||||
|
pw1 = (pw1 * __array_hash_b) % __array_hash_mdl1;
|
||||||
|
pw2 = (pw2 * __array_hash_b) % __array_hash_mdl2;
|
||||||
|
}
|
||||||
|
return res1 + res2;
|
||||||
|
}
|
||||||
|
};
|
||||||
|
|
||||||
|
/* build data structures */
|
||||||
|
#define faster(um) __AS_PROCEDURE((um).reserve(1024); (um).max_load_factor(0.25);)
|
||||||
|
#define unordered_counter(from, to) __AS_PROCEDURE(unordered_map<__as_typeof(from), size_t, safe_hash> to; for (auto&& x : from) ++to[x];)
|
||||||
|
#define counter(from, to, cmp) __AS_PROCEDURE(map<__as_typeof(from), size_t, cmp> to; for (auto&& x : from) ++to[x];)
|
||||||
|
#define adj(ch, n) __AS_PROCEDURE(vector<vector<int>> ch((n) + 1);)
|
||||||
|
#define edge(ch, u, v) __AS_PROCEDURE(ch[u].push_back(v), ch[v].push_back(u);)
|
||||||
|
#define edgew(ch, u, v, ...) __AS_PROCEDURE(ch[u].emplace_back(v, __VA_ARGS__), ch[v].emplace_back(u, __VA_ARGS__);)
|
||||||
|
#define Edge(ch, u, v) __AS_PROCEDURE(ch[u].push_back(v);)
|
||||||
|
#define Edgew(ch, u, v, ...) __AS_PROCEDURE(ch[u].emplace_back(v, __VA_ARGS__);)
|
||||||
|
template <typename T, typename Iterator> pair<size_t, map<T, size_t>> discretize(Iterator __first, Iterator __last) {
|
||||||
|
set<T> st(__first, __last);
|
||||||
|
size_t N = 0;
|
||||||
|
map<T, size_t> mp;
|
||||||
|
for (auto&& x : st) mp[x] = ++N;
|
||||||
|
return {N, mp};
|
||||||
|
}
|
||||||
|
template <typename T, typename Iterator> pair<size_t, unordered_map<T, size_t, safe_hash>> unordered_discretize(Iterator __first, Iterator __last) {
|
||||||
|
set<T> st(__first, __last);
|
||||||
|
size_t N = 0;
|
||||||
|
unordered_map<T, size_t, safe_hash> mp;
|
||||||
|
for (auto&& x : st) mp[x] = ++N;
|
||||||
|
return {N, mp};
|
||||||
|
}
|
||||||
|
|
||||||
|
/* io */
|
||||||
|
#define untie __AS_PROCEDURE(ios_base::sync_with_stdio(0), cin.tie(NULL))
|
||||||
|
|
||||||
|
// add declarations to avoid circular dependency
|
||||||
|
template<typename T, typename U> istream& operator>>(istream&, pair<T, U>&);
|
||||||
|
template<typename T, typename U> ostream& operator<<(ostream&, const pair<T, U>&);
|
||||||
|
template<typename T, size_t N> istream& operator>>(istream&, array<T, N>&);
|
||||||
|
template <typename T, size_t N> ostream& operator<<(ostream&, const array<T, N>&);
|
||||||
|
template<typename Char, typename Traits, typename... Args>
|
||||||
|
decltype(auto) operator<<(std::basic_ostream<Char, Traits>&, const std::tuple<Args...>&);
|
||||||
|
template<typename T> ostream& operator<<(ostream&, const vector<T>&);
|
||||||
|
std::ostream& operator<<(std::ostream&, const int128&);
|
||||||
|
|
||||||
|
template<typename T, typename U> istream& operator>>(istream& in, pair<T, U>& p) {
|
||||||
|
return in >> p.first >> p.second;
|
||||||
|
}
|
||||||
|
template<typename T, typename U> ostream& operator<<(ostream& out, const pair<T, U>& p) {
|
||||||
|
out << "{" << p.first << ", " << p.second << "}";
|
||||||
|
return out;
|
||||||
|
}
|
||||||
|
template<typename T, size_t N> istream& operator>>(istream& in, array<T, N>& a) {
|
||||||
|
for (size_t i = 0; i < N; ++i) in >> a[i];
|
||||||
|
return in;
|
||||||
|
}
|
||||||
|
template <typename T, size_t N> ostream& operator<<(ostream& out, const array<T, N>& a) {
|
||||||
|
for (auto&& i : a) out << i << ' ';
|
||||||
|
return out;
|
||||||
|
}
|
||||||
|
template<typename Char, typename Traits, typename Tuple, std::size_t... Index>
|
||||||
|
void print_tuple_impl(std::basic_ostream<Char, Traits>& os, const Tuple& t, std::index_sequence<Index...>) {
|
||||||
|
using swallow = int[]; // guaranties left to right order
|
||||||
|
(void)swallow { 0, (void(os << (Index == 0 ? "" : ", ") << std::get<Index>(t)), 0)... };
|
||||||
|
}
|
||||||
|
template<typename Char, typename Traits, typename... Args>
|
||||||
|
decltype(auto) operator<<(std::basic_ostream<Char, Traits>& os, const std::tuple<Args...>& t) {
|
||||||
|
os << "{";
|
||||||
|
print_tuple_impl(os, t, std::index_sequence_for<Args...>{});
|
||||||
|
return os << "}";
|
||||||
|
}
|
||||||
|
template<typename T> ostream& operator<<(ostream& out, const vector<T>& vec) {
|
||||||
|
for (auto&& i : vec) out << i << ' ';
|
||||||
|
return out;
|
||||||
|
}
|
||||||
|
std::ostream& operator<<(std::ostream& dest, const int128& value) {
|
||||||
|
// https://stackoverflow.com/a/25115163/23881100
|
||||||
|
std::ostream::sentry s( dest );
|
||||||
|
if ( s ) {
|
||||||
|
uint128 tmp = value < 0 ? -value : value;
|
||||||
|
char buffer[ 128 ];
|
||||||
|
char* d = std::end( buffer );
|
||||||
|
do {
|
||||||
|
-- d;
|
||||||
|
*d = "0123456789"[ tmp % 10 ];
|
||||||
|
tmp /= 10;
|
||||||
|
} while ( tmp != 0 );
|
||||||
|
if ( value < 0 ) {
|
||||||
|
-- d;
|
||||||
|
*d = '-';
|
||||||
|
}
|
||||||
|
int len = std::end( buffer ) - d;
|
||||||
|
if ( dest.rdbuf()->sputn( d, len ) != len ) {
|
||||||
|
dest.setstate( std::ios_base::badbit );
|
||||||
|
}
|
||||||
|
}
|
||||||
|
return dest;
|
||||||
|
}
|
||||||
|
template<typename T> void __read(T& x) { cin >> x; }
|
||||||
|
template<typename T, typename... U> void __read(T& x, U&... args) { cin >> x; __read(args...); }
|
||||||
|
#define read(t, ...) __AS_PROCEDURE(argument_type<void(t)>::type __VA_ARGS__; __read(__VA_ARGS__);)
|
||||||
|
#define readvec(t, a, n) __AS_PROCEDURE(vector<argument_type<void(t)>::type> a(n); for (auto& x : (a)) cin >> x;)
|
||||||
|
#define readvec1(t, a, n) __AS_PROCEDURE(vector<argument_type<void(t)>::type> a((n) + 1); copy_n(ii<argument_type<void(t)>::type>(cin), (n), (a).begin() + 1);)
|
||||||
|
#define putvec(a) __AS_PROCEDURE(copy((a).begin(), (a).end(), oi<__as_typeof(a)::value_type>(cout, " ")); cout << endl;)
|
||||||
|
#define putvec1(a) __AS_PROCEDURE(copy((a).begin() + 1, (a).end(), oi<__as_typeof(a)::value_type>(cout, " ")); cout << endl;)
|
||||||
|
#define putvec_eol(a) __AS_PROCEDURE(copy((a).begin(), (a).end(), oi<__as_typeof(a)::value_type>(cout, "\n"));)
|
||||||
|
#define putvec1_eol(a) __AS_PROCEDURE(copy((a).begin() + 1, (a).end(), oi<__as_typeof(a)::value_type>(cout, "\n"));)
|
||||||
|
#define debug(x) __AS_PROCEDURE(cerr << #x" = " << (x) << endl;)
|
||||||
|
#define debugvec(a) __AS_PROCEDURE(cerr << #a" = "; for (auto&& x : (a)) cerr << x << ' '; cerr << endl;)
|
||||||
|
#define deb(...) debug(make_tuple(__VA_ARGS__))
|
||||||
|
|
||||||
|
/* pops */
|
||||||
|
template <typename Container>
|
||||||
|
inline auto poptop(Container& q) {
|
||||||
|
auto ret = q.top();
|
||||||
|
q.pop();
|
||||||
|
return ret;
|
||||||
|
}
|
||||||
|
template <typename Container>
|
||||||
|
inline auto popback(Container& q) {
|
||||||
|
auto ret = q.back();
|
||||||
|
q.pop_back();
|
||||||
|
return ret;
|
||||||
|
}
|
||||||
|
template <typename Container>
|
||||||
|
inline auto popfront(Container& q) {
|
||||||
|
auto ret = q.front();
|
||||||
|
q.pop_front();
|
||||||
|
return ret;
|
||||||
|
}
|
||||||
|
|
||||||
|
/* math */
|
||||||
|
template <typename return_t>
|
||||||
|
return_t qpow(ll b, ll p) {
|
||||||
|
if (b == 0 and p != 0) return 0;
|
||||||
|
if (p == 0) return 1;
|
||||||
|
return_t half = qpow<return_t>(b, p / 2);
|
||||||
|
if (p % 2 == 1) return half * half * b;
|
||||||
|
else return half * half;
|
||||||
|
}
|
||||||
|
|
||||||
|
// dynamic modulus
|
||||||
|
ll qpow(ll b, ll p, ll mod) {
|
||||||
|
if (b == 0 and p != 0) return 0;
|
||||||
|
if (p == 0) return 1;
|
||||||
|
ll half = qpow(b, p / 2, mod);
|
||||||
|
if (p % 2 == 1) return (int128(half) * half % mod) * b % mod;
|
||||||
|
else return half * half % mod;
|
||||||
|
}
|
||||||
|
|
||||||
|
|
||||||
|
#pragma GCC diagnostic push
|
||||||
|
#pragma GCC diagnostic ignored "-Wparentheses"
|
||||||
|
// Accurately find `i` 'th root of `n` (taking the floor)
|
||||||
|
inline ll root(ll n, ll i) {
|
||||||
|
ll l = 0, r = pow(LLONG_MAX, (long double)(1) / i);
|
||||||
|
while (l < r) {
|
||||||
|
ll mid = l + r + 1 >> 1;
|
||||||
|
if (qpow<int128>(mid, i) <= n) {
|
||||||
|
l = mid;
|
||||||
|
} else {
|
||||||
|
r = mid - 1;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
return l;
|
||||||
|
}
|
||||||
|
#pragma GCC diagnostic pop
|
||||||
|
|
||||||
|
|
||||||
|
#define comb(n, k) ((n) < 0 or (k) < 0 or (n) < (k) ? 0 : fact[n] / fact[k] / fact[(n) - (k)])
|
||||||
|
#define fastcomb(n, k) ((n) < 0 or (k) < 0 or (n) < (k) ? 0 : fact[n] * factrev[k] * factrev[(n) - (k)])
|
||||||
|
|
||||||
|
__attribute__((target("lzcnt")))
|
||||||
|
constexpr inline int lg2(ll x) { return x == 0 ? -1 : sizeof(ll) * 8 - 1 - __builtin_clzll(x); }
|
||||||
|
|
||||||
|
template <typename T>
|
||||||
|
T mygcd(T a, T b) { return b == 0 ? a : mygcd(b, a % b); }
|
||||||
|
|
||||||
|
void __exgcd(ll a, ll b, ll& x, ll& y) {
|
||||||
|
if (b == 0) {
|
||||||
|
x = 1, y = 0;
|
||||||
|
return;
|
||||||
|
}
|
||||||
|
__exgcd(b, a % b, y, x);
|
||||||
|
y -= a / b * x;
|
||||||
|
}
|
||||||
|
|
||||||
|
ll inverse(ll a, ll b) {
|
||||||
|
ll x, y;
|
||||||
|
__exgcd(a, b, x, y);
|
||||||
|
return mod(x, b);
|
||||||
|
}
|
||||||
|
|
||||||
|
vector<tuple<int, int, ll>> decompose(ll x) {
|
||||||
|
// return (factor, count, factor ** count)
|
||||||
|
vector<tuple<int, int, ll>> res;
|
||||||
|
for (int i = 2; i * i <= x; i++) {
|
||||||
|
if (x % i == 0) {
|
||||||
|
int cnt = 0;
|
||||||
|
ll pw = 1;
|
||||||
|
while (x % i == 0) ++cnt, x /= i, pw *= i;
|
||||||
|
res.emplace_back(i, cnt, pw);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
if (x != 1) {
|
||||||
|
res.emplace_back(x, 1, x);
|
||||||
|
}
|
||||||
|
return res;
|
||||||
|
}
|
||||||
|
|
||||||
|
vector<pii> decompose_prime(int N) {
|
||||||
|
// return (factor, count)
|
||||||
|
vector<pii> result;
|
||||||
|
for (int i = 2; i * i <= N; i++) {
|
||||||
|
if (N % i == 0) {
|
||||||
|
int cnt = 0;
|
||||||
|
while (N % i == 0) N /= i, ++cnt;
|
||||||
|
result.emplace_back(i, cnt);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
if (N != 1) {
|
||||||
|
result.emplace_back(N, 1);
|
||||||
|
}
|
||||||
|
return result;
|
||||||
|
}
|
||||||
|
|
||||||
|
/* string algorithms */
|
||||||
|
vector<int> calc_next(string t) { // pi function of t
|
||||||
|
int n = (int)t.length();
|
||||||
|
vector<int> pi(n);
|
||||||
|
for (int i = 1; i < n; i++) {
|
||||||
|
int j = pi[i - 1];
|
||||||
|
while (j > 0 && t[i] != t[j]) j = pi[j - 1];
|
||||||
|
if (t[i] == t[j]) j++;
|
||||||
|
pi[i] = j;
|
||||||
|
}
|
||||||
|
return pi;
|
||||||
|
}
|
||||||
|
vector<int> calc_z(string t) { // z function of t
|
||||||
|
int m = t.length();
|
||||||
|
vector<int> z;
|
||||||
|
z.push_back(m);
|
||||||
|
pair<int, int> prev = {1, -1};
|
||||||
|
for (int i = 1; i < m; ++i) {
|
||||||
|
if (z[i - prev.first] + i <= prev.second) {
|
||||||
|
z.push_back(z[i - prev.first]);
|
||||||
|
} else {
|
||||||
|
int j = max(i, prev.second + 1);
|
||||||
|
while (j < m && t[j] == t[j - i]) ++j;
|
||||||
|
z.push_back(j - i);
|
||||||
|
prev = {i, j - 1};
|
||||||
|
}
|
||||||
|
}
|
||||||
|
return z;
|
||||||
|
}
|
||||||
|
vector<int> kmp(const string& s, const string& t) { // find all t in s
|
||||||
|
string cur = t + '#' + s;
|
||||||
|
int sz1 = s.size(), sz2 = t.size();
|
||||||
|
vector<int> v;
|
||||||
|
vector<int> lps = calc_next(cur);
|
||||||
|
for (int i = sz2 + 1; i <= sz1 + sz2; i++) {
|
||||||
|
if (lps[i] == sz2) v.push_back(i - 2 * sz2);
|
||||||
|
}
|
||||||
|
return v;
|
||||||
|
}
|
||||||
|
int period(const string& s) { // find the length of shortest recurring period
|
||||||
|
int n = s.length();
|
||||||
|
auto z = calc_z(s);
|
||||||
|
for (int i = 1; i <= n / 2; ++i) {
|
||||||
|
if (n % i == 0 && z[i] == n - i) {
|
||||||
|
return i;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
return n;
|
||||||
|
}
|
||||||
|
|
||||||
|
/* modular arithmetic */
|
||||||
|
template <ll mdl> struct MLL {
|
||||||
|
ll val;
|
||||||
|
MLL(ll v = 0) : val(mod(v, mdl)) {}
|
||||||
|
MLL(const MLL<mdl>& other) : val(other.val) {}
|
||||||
|
friend MLL operator+(const MLL& lhs, const MLL& rhs) { return mod(lhs.val + rhs.val, mdl); }
|
||||||
|
friend MLL operator-(const MLL& lhs, const MLL& rhs) { return mod(lhs.val - rhs.val, mdl); }
|
||||||
|
friend MLL operator*(const MLL& lhs, const MLL& rhs) { return mod(int128(lhs.val) * rhs.val, mdl); }
|
||||||
|
friend MLL operator/(const MLL& lhs, const MLL& rhs) { return lhs * mod(inverse(rhs.val, mdl), mdl); }
|
||||||
|
friend MLL operator%(const MLL& lhs, const MLL& rhs) { return mod(lhs.val - (lhs / rhs).val, mdl); }
|
||||||
|
friend bool operator==(const MLL& lhs, const MLL& rhs) { return lhs.val == rhs.val; }
|
||||||
|
friend bool operator!=(const MLL& lhs, const MLL& rhs) { return lhs.val != rhs.val; }
|
||||||
|
MLL& operator+=(const MLL& rhs) { return *this = *this + rhs; }
|
||||||
|
MLL& operator-=(const MLL& rhs) { return *this = *this - rhs; }
|
||||||
|
MLL& operator*=(const MLL& rhs) { return *this = *this * rhs; }
|
||||||
|
MLL& operator/=(const MLL& rhs) { return *this = *this / rhs; }
|
||||||
|
MLL& operator%=(const MLL& rhs) { return *this = *this % rhs; }
|
||||||
|
};
|
||||||
|
|
||||||
|
template <ll mdl>
|
||||||
|
ostream& operator<<(ostream& out, const MLL<mdl>& num) {
|
||||||
|
return out << num.val;
|
||||||
|
}
|
||||||
|
|
||||||
|
template <ll mdl>
|
||||||
|
istream& operator>>(istream& in, MLL<mdl>& num) {
|
||||||
|
return in >> num.val;
|
||||||
|
}
|
||||||
|
|
||||||
|
// miscancellous
|
||||||
|
template <typename T, typename U>
|
||||||
|
bool chmax(T& lhs, const U& rhs) {
|
||||||
|
bool ret = lhs < rhs;
|
||||||
|
if (ret) {
|
||||||
|
lhs = rhs;
|
||||||
|
}
|
||||||
|
return ret;
|
||||||
|
}
|
||||||
|
template <typename T, typename U>
|
||||||
|
bool chmin(T& lhs, const U& rhs) {
|
||||||
|
bool ret = lhs > rhs;
|
||||||
|
if (ret) {
|
||||||
|
lhs = rhs;
|
||||||
|
}
|
||||||
|
return ret;
|
||||||
|
}
|
||||||
|
|
||||||
|
#define functor(func) ([&](auto&&... val) \
|
||||||
|
noexcept(noexcept(func(std::forward<decltype(val)>(val)...))) -> decltype(auto) \
|
||||||
|
{return func(std::forward<decltype(val)>(val)...);})
|
||||||
|
#define expr(ret, ...) ([&] (__VA_ARGS__) { return (ret); })
|
||||||
|
template <typename Func, typename RandomIt> void sort_by_key(RandomIt first, RandomIt last, Func extractor) {
|
||||||
|
std::sort(first, last, [&] (auto&& a, auto&& b) { return std::less<>()(extractor(a), extractor(b)); });
|
||||||
|
}
|
||||||
|
template <typename Func, typename RandomIt, typename Compare> void sort_by_key(RandomIt first, RandomIt last, Func extractor, Compare comp) {
|
||||||
|
std::sort(first, last, [&] (auto&& a, auto&& b) { return comp(extractor(a), extractor(b)); });
|
||||||
|
}
|
||||||
|
template <typename T, typename U, typename Iterator_T, typename Iterator_U>
|
||||||
|
vector<pair<T, U>> zip(Iterator_T a_first, Iterator_T a_last, Iterator_U b_first, Iterator_U b_last) {
|
||||||
|
vector<pair<T, U>> res;
|
||||||
|
auto a_it = a_first;
|
||||||
|
auto b_it = b_first;
|
||||||
|
for (; not (a_it == a_last) and not (b_it == b_last); ++a_it, ++b_it) {
|
||||||
|
res.emplace_back(*a_it, *b_it);
|
||||||
|
}
|
||||||
|
return res;
|
||||||
|
}
|
||||||
|
template <typename T, typename U, typename Iterator_T, typename Iterator_U>
|
||||||
|
vector<pair<T, U>> zip_n(Iterator_T a_first, Iterator_U b_first, size_t n) {
|
||||||
|
vector<pair<T, U>> res;
|
||||||
|
if (n > 0) {
|
||||||
|
res.emplace_back(*a_first, *b_first);
|
||||||
|
for (size_t i = 1; i != n; ++i) {
|
||||||
|
res.emplace_back(*++a_first, *++b_first);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
return res;
|
||||||
|
}
|
||||||
|
template <typename T>
|
||||||
|
class ArithmeticIterator : bidirectional_iterator_tag {
|
||||||
|
public:
|
||||||
|
using difference_type = ptrdiff_t;
|
||||||
|
using value_type = T;
|
||||||
|
private:
|
||||||
|
value_type value;
|
||||||
|
public:
|
||||||
|
ArithmeticIterator(const T& value) : value(value) {}
|
||||||
|
value_type operator*() const { return value; }
|
||||||
|
ArithmeticIterator<T>& operator++() { ++value; return *this; }
|
||||||
|
ArithmeticIterator<T>& operator--() { --value; return *this; }
|
||||||
|
bool operator==(const ArithmeticIterator<T>& rhs) const { return value == rhs.value; }
|
||||||
|
};
|
||||||
|
template <typename T> vector<pair<int, T>> enumerate(const vector<T>& container) {
|
||||||
|
return zip<int, T>(ArithmeticIterator<int>(0), ArithmeticIterator<int>(INT_MAX), container.begin(), container.end());
|
||||||
|
}
|
||||||
|
#define initarray(init, N) (__initarray<decay<decltype(init)>::type, (N)>(init))
|
||||||
|
namespace detail {
|
||||||
|
template <typename T, std::size_t...Is>
|
||||||
|
constexpr std::array<T, sizeof...(Is)>
|
||||||
|
make_array(const T& value, std::index_sequence<Is...>) {
|
||||||
|
return {{(static_cast<void>(Is), value)...}};
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
template <typename T, std::size_t N>
|
||||||
|
constexpr std::array<T, N> __initarray(const T& value) {
|
||||||
|
return detail::make_array(value, std::make_index_sequence<N>());
|
||||||
|
}
|
||||||
|
/*******************************************************/
|
||||||
|
|
||||||
|
#define SINGLE_TEST_CASE
|
||||||
|
// #define DUMP_TEST_CASE 7219
|
||||||
|
// #define TOT_TEST_CASE 10000
|
||||||
|
|
||||||
|
void dump() {}
|
||||||
|
|
||||||
|
void dump_ignore() {}
|
||||||
|
|
||||||
|
void prep() {}
|
||||||
|
|
||||||
|
// __attribute__((target("popcnt")))
|
||||||
|
void solve() {
|
||||||
|
read(int, n, m);
|
||||||
|
if (m == 1) {
|
||||||
|
cout << 0 << '\n';
|
||||||
|
return;
|
||||||
|
}
|
||||||
|
vector<ll> md(n + 1);
|
||||||
|
for (int i = 1; i <= n; ++i) {
|
||||||
|
md[i] = qpow(i, m, PRIME);
|
||||||
|
}
|
||||||
|
ll res = 0;
|
||||||
|
for (int i = 1; i < n; ++i) {
|
||||||
|
ll all = md[i + 1];
|
||||||
|
ll one = 2 * md[i] % PRIME;
|
||||||
|
ll none = i - 1 <= 0 ? 0 : md[i - 1];
|
||||||
|
res += ll(1) * ((n - i) * mod(all - one + none, PRIME) % PRIME) * (ll(1) * i * i % PRIME) % PRIME;
|
||||||
|
res %= PRIME;
|
||||||
|
}
|
||||||
|
cout << res << '\n';
|
||||||
|
}
|
||||||
|
|
||||||
|
int main() {
|
||||||
|
#if __cplusplus < 201402L or defined(_MSC_VER) and not defined(__clang__)
|
||||||
|
static_assert(false, "incompatible compiler variant detected.");
|
||||||
|
#endif
|
||||||
|
untie;
|
||||||
|
prep();
|
||||||
|
#ifdef SINGLE_TEST_CASE
|
||||||
|
solve();
|
||||||
|
#else
|
||||||
|
read(int, t);
|
||||||
|
for (int i = 0; i < t; ++i) {
|
||||||
|
#ifdef DUMP_TEST_CASE
|
||||||
|
if (t != (TOT_TEST_CASE)) {
|
||||||
|
solve();
|
||||||
|
} else if (i + 1 == (DUMP_TEST_CASE)) {
|
||||||
|
dump();
|
||||||
|
} else {
|
||||||
|
dump_ignore();
|
||||||
|
}
|
||||||
|
#else
|
||||||
|
solve();
|
||||||
|
#endif
|
||||||
|
}
|
||||||
|
#endif
|
||||||
|
}
|
|
@ -0,0 +1,627 @@
|
||||||
|
// #pragma GCC target("popcnt,lzcnt,abm,bmi,bmi2")
|
||||||
|
#pragma GCC optimize("Ofast,unroll-loops")
|
||||||
|
/************* This code requires C++17. ***************/
|
||||||
|
|
||||||
|
#include<bits/stdc++.h>
|
||||||
|
using namespace std;
|
||||||
|
|
||||||
|
/* macro helpers */
|
||||||
|
#define __NARGS(...) std::tuple_size<decltype(std::make_tuple(__VA_ARGS__))>::value
|
||||||
|
#define __DECOMPOSE_S(a, x) auto x = a;
|
||||||
|
#define __DECOMPOSE_N(a, ...) auto [__VA_ARGS__] = a;
|
||||||
|
constexpr void __() {}
|
||||||
|
#define __AS_PROCEDURE(...) __(); __VA_ARGS__; __()
|
||||||
|
#define __as_typeof(container) remove_reference<decltype(container)>::type
|
||||||
|
template <typename T> struct argument_type;
|
||||||
|
template <typename T, typename U> struct argument_type<T(U)> { using type = U; };
|
||||||
|
|
||||||
|
/* type aliases */
|
||||||
|
#if LONG_LONG_MAX != INT64_MAX
|
||||||
|
using ll = int64_t;
|
||||||
|
using ull = uint64_t;
|
||||||
|
#else
|
||||||
|
using ll = long long;
|
||||||
|
using ull = unsigned long long;
|
||||||
|
#endif
|
||||||
|
using int128 = __int128_t;
|
||||||
|
using uint128 = __uint128_t;
|
||||||
|
using ld = __float128; // up to 1e-9 precision in binary search
|
||||||
|
using pii = pair<int, int>; using pil = pair<int, ll>; using pid = pair<int, ld>;
|
||||||
|
using pli = pair<ll, int>; using pll = pair<ll, ll>; using pld = pair<ll, ld>;
|
||||||
|
using pdi = pair<ld, int>; using pdl = pair<ld, ll>; using pdd = pair<ld, ld>;
|
||||||
|
using tiii = tuple<int, int, int>; using tiil = tuple<int, int, ll>; using tiid = tuple<int, int, ld>;
|
||||||
|
using tili = tuple<int, ll, int>; using till = tuple<int, ll, ll>; using tild = tuple<int, ll, ld>;
|
||||||
|
using tidi = tuple<int, ld, int>; using tidl = tuple<int, ld, ll>; using tidd = tuple<int, ld, ld>;
|
||||||
|
using tlii = tuple<ll, int, int>; using tlil = tuple<ll, int, ll>; using tlid = tuple<ll, int, ld>;
|
||||||
|
using tlli = tuple<ll, ll, int>; using tlll = tuple<ll, ll, ll>; using tlld = tuple<ll, ll, ld>;
|
||||||
|
using tldi = tuple<ll, ld, int>; using tldl = tuple<ll, ld, ll>; using tldd = tuple<ll, ld, ld>;
|
||||||
|
using tdii = tuple<ld, int, int>; using tdil = tuple<ld, int, ll>; using tdid = tuple<ld, int, ld>;
|
||||||
|
using tdli = tuple<ld, ll, int>; using tdll = tuple<ld, ll, ll>; using tdld = tuple<ld, ll, ld>;
|
||||||
|
using tddi = tuple<ld, ld, int>; using tddl = tuple<ld, ld, ll>; using tddd = tuple<ld, ld, ld>;
|
||||||
|
template <typename T> using max_heap = priority_queue<T>;
|
||||||
|
template <typename T> using min_heap = priority_queue<T, vector<T>, greater<>>;
|
||||||
|
template <typename T> using oi = ostream_iterator<T>;
|
||||||
|
template <typename T> using ii = istream_iterator<T>;
|
||||||
|
|
||||||
|
/* constants */
|
||||||
|
constexpr int INF = 0x3f3f3f3f;
|
||||||
|
constexpr ll INFLL = 0x3f3f3f3f3f3f3f3fLL;
|
||||||
|
constexpr ll MDL = 1e9 + 7;
|
||||||
|
constexpr ll PRIME = 998'244'353;
|
||||||
|
constexpr ll PRIMELL = 901017227882342239LL;
|
||||||
|
constexpr ll MDL1 = 8784491;
|
||||||
|
constexpr ll MDL2 = PRIME;
|
||||||
|
constexpr int128 INT128_MAX = numeric_limits<int128>::max();
|
||||||
|
constexpr uint128 UINT128_MAX = numeric_limits<uint128>::max();
|
||||||
|
constexpr int128 INT128_MIN = numeric_limits<int128>::min();
|
||||||
|
constexpr uint128 UINT128_MIN = numeric_limits<uint128>::min();
|
||||||
|
|
||||||
|
/* random */
|
||||||
|
|
||||||
|
mt19937_64 rd(chrono::duration_cast<chrono::milliseconds>(chrono::system_clock::now().time_since_epoch()).count());
|
||||||
|
|
||||||
|
/* bit-wise operations */
|
||||||
|
#define lowbit(x) ((x) & -(x))
|
||||||
|
#define popcount(x) (__builtin_popcountll(ll(x)))
|
||||||
|
#define parity(x) (__builtin_parityll(ll(x)))
|
||||||
|
#define msp(x) (63LL - __builtin_clzll(ll(x)))
|
||||||
|
#define lsp(x) (__builtin_ctzll(ll(x)))
|
||||||
|
|
||||||
|
/* arithmetic operations */
|
||||||
|
#define mod(x, y) ((((x) % (y)) + (y)) % (y))
|
||||||
|
|
||||||
|
/* fast pairs */
|
||||||
|
#define upair ull
|
||||||
|
#define umake(x, y) (ull(x) << 32 | (ull(y) & ((1ULL << 32) - 1)))
|
||||||
|
#define u1(p) ((p) >> 32)
|
||||||
|
#define u2(p) ((p) & ((1ULL << 32) - 1))
|
||||||
|
#define ult std::less<upair>
|
||||||
|
#define ugt std::greater<upair>
|
||||||
|
|
||||||
|
#define ipair ull
|
||||||
|
#define imake(x, y) (umake(x, y))
|
||||||
|
#define i1(p) (int(u1(ll(p))))
|
||||||
|
#define i2(p) (ll(u2(p) << 32) >> 32)
|
||||||
|
struct ilt {
|
||||||
|
bool operator()(const ipair& a, const ipair& b) const {
|
||||||
|
if (i1(a) == i1(b)) return i2(a) < i2(b);
|
||||||
|
else return i1(a) < i1(b);
|
||||||
|
}
|
||||||
|
};
|
||||||
|
struct igt {
|
||||||
|
bool operator()(const ipair& a, const ipair& b) const {
|
||||||
|
if (i1(a) == i1(b)) return i2(a) > i2(b);
|
||||||
|
else return i1(a) > i1(b);
|
||||||
|
}
|
||||||
|
};
|
||||||
|
|
||||||
|
/* conditions */
|
||||||
|
#define loop while (1)
|
||||||
|
#define if_or(var, val) if (!((var) == (val))) (var) = (val); else
|
||||||
|
#define continue_or(var, val) __AS_PROCEDURE(if ((var) == (val)) continue; (var) = (val);)
|
||||||
|
#define break_or(var, val) __AS_PROCEDURE(if ((var) == (val)) break; (var) = (val);)
|
||||||
|
|
||||||
|
/* hash */
|
||||||
|
struct safe_hash {
|
||||||
|
// https://codeforces.com/blog/entry/62393
|
||||||
|
static uint64_t splitmix64(uint64_t x) {
|
||||||
|
// http://xorshift.di.unimi.it/splitmix64.c
|
||||||
|
x += 0x9e3779b97f4a7c15;
|
||||||
|
x = (x ^ (x >> 30)) * 0xbf58476d1ce4e5b9;
|
||||||
|
x = (x ^ (x >> 27)) * 0x94d049bb133111eb;
|
||||||
|
return x ^ (x >> 31);
|
||||||
|
}
|
||||||
|
|
||||||
|
size_t operator()(uint64_t x) const {
|
||||||
|
static const uint64_t FIXED_RANDOM = chrono::steady_clock::now().time_since_epoch().count();
|
||||||
|
return splitmix64(x + FIXED_RANDOM);
|
||||||
|
}
|
||||||
|
};
|
||||||
|
|
||||||
|
struct pair_hash {
|
||||||
|
template <typename T, typename U>
|
||||||
|
size_t operator()(const pair<T, U>& a) const {
|
||||||
|
auto hash1 = safe_hash()(a.first);
|
||||||
|
auto hash2 = safe_hash()(a.second);
|
||||||
|
if (hash1 != hash2) {
|
||||||
|
return hash1 ^ hash2;
|
||||||
|
}
|
||||||
|
return hash1;
|
||||||
|
}
|
||||||
|
};
|
||||||
|
|
||||||
|
uniform_int_distribution<mt19937::result_type> dist(PRIME);
|
||||||
|
const size_t __array_hash_b = 31, __array_hash_mdl1 = dist(rd), __array_hash_mdl2 = dist(rd);
|
||||||
|
struct array_hash {
|
||||||
|
safe_hash hasher;
|
||||||
|
template <typename Sequence>
|
||||||
|
size_t operator()(const Sequence& arr) const {
|
||||||
|
size_t pw1 = 1, pw2 = 1;
|
||||||
|
size_t res1 = 0, res2 = 0;
|
||||||
|
for (auto&& x : arr) {
|
||||||
|
auto h = hasher(x);
|
||||||
|
res1 = (res1 + h * pw1) % __array_hash_mdl1;
|
||||||
|
res2 = (res2 + h * pw2) % __array_hash_mdl2;
|
||||||
|
pw1 = (pw1 * __array_hash_b) % __array_hash_mdl1;
|
||||||
|
pw2 = (pw2 * __array_hash_b) % __array_hash_mdl2;
|
||||||
|
}
|
||||||
|
return res1 + res2;
|
||||||
|
}
|
||||||
|
};
|
||||||
|
|
||||||
|
/* build data structures */
|
||||||
|
#define faster(um) __AS_PROCEDURE((um).reserve(1024); (um).max_load_factor(0.25);)
|
||||||
|
#define unordered_counter(from, to) __AS_PROCEDURE(unordered_map<__as_typeof(from), size_t, safe_hash> to; for (auto&& x : from) ++to[x];)
|
||||||
|
#define counter(from, to, cmp) __AS_PROCEDURE(map<__as_typeof(from), size_t, cmp> to; for (auto&& x : from) ++to[x];)
|
||||||
|
#define adj(ch, n) __AS_PROCEDURE(vector<vector<int>> ch((n) + 1);)
|
||||||
|
#define edge(ch, u, v) __AS_PROCEDURE(ch[u].push_back(v), ch[v].push_back(u);)
|
||||||
|
#define edgew(ch, u, v, ...) __AS_PROCEDURE(ch[u].emplace_back(v, __VA_ARGS__), ch[v].emplace_back(u, __VA_ARGS__);)
|
||||||
|
#define Edge(ch, u, v) __AS_PROCEDURE(ch[u].push_back(v);)
|
||||||
|
#define Edgew(ch, u, v, ...) __AS_PROCEDURE(ch[u].emplace_back(v, __VA_ARGS__);)
|
||||||
|
template <typename T, typename Iterator> pair<size_t, map<T, size_t>> discretize(Iterator __first, Iterator __last) {
|
||||||
|
set<T> st(__first, __last);
|
||||||
|
size_t N = 0;
|
||||||
|
map<T, size_t> mp;
|
||||||
|
for (auto&& x : st) mp[x] = ++N;
|
||||||
|
return {N, mp};
|
||||||
|
}
|
||||||
|
template <typename T, typename Iterator> pair<size_t, unordered_map<T, size_t, safe_hash>> unordered_discretize(Iterator __first, Iterator __last) {
|
||||||
|
set<T> st(__first, __last);
|
||||||
|
size_t N = 0;
|
||||||
|
unordered_map<T, size_t, safe_hash> mp;
|
||||||
|
for (auto&& x : st) mp[x] = ++N;
|
||||||
|
return {N, mp};
|
||||||
|
}
|
||||||
|
|
||||||
|
/* io */
|
||||||
|
#define untie __AS_PROCEDURE(ios_base::sync_with_stdio(0), cin.tie(NULL))
|
||||||
|
|
||||||
|
// add declarations to avoid circular dependency
|
||||||
|
template<typename T, typename U> istream& operator>>(istream&, pair<T, U>&);
|
||||||
|
template<typename T, typename U> ostream& operator<<(ostream&, const pair<T, U>&);
|
||||||
|
template<typename T, size_t N> istream& operator>>(istream&, array<T, N>&);
|
||||||
|
template <typename T, size_t N> ostream& operator<<(ostream&, const array<T, N>&);
|
||||||
|
template<typename Char, typename Traits, typename... Args>
|
||||||
|
decltype(auto) operator<<(std::basic_ostream<Char, Traits>&, const std::tuple<Args...>&);
|
||||||
|
template<typename T> ostream& operator<<(ostream&, const vector<T>&);
|
||||||
|
std::ostream& operator<<(std::ostream&, const int128&);
|
||||||
|
|
||||||
|
template<typename T, typename U> istream& operator>>(istream& in, pair<T, U>& p) {
|
||||||
|
return in >> p.first >> p.second;
|
||||||
|
}
|
||||||
|
template<typename T, typename U> ostream& operator<<(ostream& out, const pair<T, U>& p) {
|
||||||
|
out << "{" << p.first << ", " << p.second << "}";
|
||||||
|
return out;
|
||||||
|
}
|
||||||
|
template<typename T, size_t N> istream& operator>>(istream& in, array<T, N>& a) {
|
||||||
|
for (size_t i = 0; i < N; ++i) in >> a[i];
|
||||||
|
return in;
|
||||||
|
}
|
||||||
|
template <typename T, size_t N> ostream& operator<<(ostream& out, const array<T, N>& a) {
|
||||||
|
for (auto&& i : a) out << i << ' ';
|
||||||
|
return out;
|
||||||
|
}
|
||||||
|
template<typename Char, typename Traits, typename Tuple, std::size_t... Index>
|
||||||
|
void print_tuple_impl(std::basic_ostream<Char, Traits>& os, const Tuple& t, std::index_sequence<Index...>) {
|
||||||
|
using swallow = int[]; // guaranties left to right order
|
||||||
|
(void)swallow { 0, (void(os << (Index == 0 ? "" : ", ") << std::get<Index>(t)), 0)... };
|
||||||
|
}
|
||||||
|
template<typename Char, typename Traits, typename... Args>
|
||||||
|
decltype(auto) operator<<(std::basic_ostream<Char, Traits>& os, const std::tuple<Args...>& t) {
|
||||||
|
os << "{";
|
||||||
|
print_tuple_impl(os, t, std::index_sequence_for<Args...>{});
|
||||||
|
return os << "}";
|
||||||
|
}
|
||||||
|
template<typename T> ostream& operator<<(ostream& out, const vector<T>& vec) {
|
||||||
|
for (auto&& i : vec) out << i << ' ';
|
||||||
|
return out;
|
||||||
|
}
|
||||||
|
std::ostream& operator<<(std::ostream& dest, const int128& value) {
|
||||||
|
// https://stackoverflow.com/a/25115163/23881100
|
||||||
|
std::ostream::sentry s( dest );
|
||||||
|
if ( s ) {
|
||||||
|
uint128 tmp = value < 0 ? -value : value;
|
||||||
|
char buffer[ 128 ];
|
||||||
|
char* d = std::end( buffer );
|
||||||
|
do {
|
||||||
|
-- d;
|
||||||
|
*d = "0123456789"[ tmp % 10 ];
|
||||||
|
tmp /= 10;
|
||||||
|
} while ( tmp != 0 );
|
||||||
|
if ( value < 0 ) {
|
||||||
|
-- d;
|
||||||
|
*d = '-';
|
||||||
|
}
|
||||||
|
int len = std::end( buffer ) - d;
|
||||||
|
if ( dest.rdbuf()->sputn( d, len ) != len ) {
|
||||||
|
dest.setstate( std::ios_base::badbit );
|
||||||
|
}
|
||||||
|
}
|
||||||
|
return dest;
|
||||||
|
}
|
||||||
|
template<typename T> void __read(T& x) { cin >> x; }
|
||||||
|
template<typename T, typename... U> void __read(T& x, U&... args) { cin >> x; __read(args...); }
|
||||||
|
#define read(t, ...) __AS_PROCEDURE(argument_type<void(t)>::type __VA_ARGS__; __read(__VA_ARGS__);)
|
||||||
|
#define readvec(t, a, n) __AS_PROCEDURE(vector<argument_type<void(t)>::type> a(n); for (auto& x : (a)) cin >> x;)
|
||||||
|
#define readvec1(t, a, n) __AS_PROCEDURE(vector<argument_type<void(t)>::type> a((n) + 1); copy_n(ii<argument_type<void(t)>::type>(cin), (n), (a).begin() + 1);)
|
||||||
|
#define putvec(a) __AS_PROCEDURE(copy((a).begin(), (a).end(), oi<__as_typeof(a)::value_type>(cout, " ")); cout << endl;)
|
||||||
|
#define putvec1(a) __AS_PROCEDURE(copy((a).begin() + 1, (a).end(), oi<__as_typeof(a)::value_type>(cout, " ")); cout << endl;)
|
||||||
|
#define putvec_eol(a) __AS_PROCEDURE(copy((a).begin(), (a).end(), oi<__as_typeof(a)::value_type>(cout, "\n"));)
|
||||||
|
#define putvec1_eol(a) __AS_PROCEDURE(copy((a).begin() + 1, (a).end(), oi<__as_typeof(a)::value_type>(cout, "\n"));)
|
||||||
|
#define debug(x) __AS_PROCEDURE(cerr << #x" = " << (x) << endl;)
|
||||||
|
#define debugvec(a) __AS_PROCEDURE(cerr << #a" = "; for (auto&& x : (a)) cerr << x << ' '; cerr << endl;)
|
||||||
|
#define deb(...) debug(make_tuple(__VA_ARGS__))
|
||||||
|
|
||||||
|
/* pops */
|
||||||
|
template <typename Container>
|
||||||
|
inline auto poptop(Container& q) {
|
||||||
|
auto ret = q.top();
|
||||||
|
q.pop();
|
||||||
|
return ret;
|
||||||
|
}
|
||||||
|
template <typename Container>
|
||||||
|
inline auto popback(Container& q) {
|
||||||
|
auto ret = q.back();
|
||||||
|
q.pop_back();
|
||||||
|
return ret;
|
||||||
|
}
|
||||||
|
template <typename Container>
|
||||||
|
inline auto popfront(Container& q) {
|
||||||
|
auto ret = q.front();
|
||||||
|
q.pop_front();
|
||||||
|
return ret;
|
||||||
|
}
|
||||||
|
|
||||||
|
/* math */
|
||||||
|
template <typename return_t>
|
||||||
|
return_t qpow(ll b, ll p) {
|
||||||
|
if (b == 0 and p != 0) return 0;
|
||||||
|
if (p == 0) return 1;
|
||||||
|
return_t half = qpow<return_t>(b, p / 2);
|
||||||
|
if (p % 2 == 1) return half * half * b;
|
||||||
|
else return half * half;
|
||||||
|
}
|
||||||
|
|
||||||
|
// dynamic modulus
|
||||||
|
ll qpow(ll b, ll p, ll mod) {
|
||||||
|
if (b == 0 and p != 0) return 0;
|
||||||
|
if (p == 0) return 1;
|
||||||
|
ll half = qpow(b, p / 2, mod);
|
||||||
|
if (p % 2 == 1) return (int128(half) * half % mod) * b % mod;
|
||||||
|
else return half * half % mod;
|
||||||
|
}
|
||||||
|
|
||||||
|
|
||||||
|
#pragma GCC diagnostic push
|
||||||
|
#pragma GCC diagnostic ignored "-Wparentheses"
|
||||||
|
// Accurately find `i` 'th root of `n` (taking the floor)
|
||||||
|
inline ll root(ll n, ll i) {
|
||||||
|
ll l = 0, r = pow(LLONG_MAX, (long double)(1) / i);
|
||||||
|
while (l < r) {
|
||||||
|
ll mid = l + r + 1 >> 1;
|
||||||
|
if (qpow<int128>(mid, i) <= n) {
|
||||||
|
l = mid;
|
||||||
|
} else {
|
||||||
|
r = mid - 1;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
return l;
|
||||||
|
}
|
||||||
|
#pragma GCC diagnostic pop
|
||||||
|
|
||||||
|
|
||||||
|
#define comb(n, k) ((n) < 0 or (k) < 0 or (n) < (k) ? 0 : fact[n] / fact[k] / fact[(n) - (k)])
|
||||||
|
#define fastcomb(n, k) ((n) < 0 or (k) < 0 or (n) < (k) ? 0 : fact[n] * factrev[k] * factrev[(n) - (k)])
|
||||||
|
|
||||||
|
__attribute__((target("lzcnt")))
|
||||||
|
constexpr inline int lg2(ll x) { return x == 0 ? -1 : sizeof(ll) * 8 - 1 - __builtin_clzll(x); }
|
||||||
|
|
||||||
|
template <typename T>
|
||||||
|
T mygcd(T a, T b) { return b == 0 ? a : mygcd(b, a % b); }
|
||||||
|
|
||||||
|
void __exgcd(ll a, ll b, ll& x, ll& y) {
|
||||||
|
if (b == 0) {
|
||||||
|
x = 1, y = 0;
|
||||||
|
return;
|
||||||
|
}
|
||||||
|
__exgcd(b, a % b, y, x);
|
||||||
|
y -= a / b * x;
|
||||||
|
}
|
||||||
|
|
||||||
|
ll inverse(ll a, ll b) {
|
||||||
|
ll x, y;
|
||||||
|
__exgcd(a, b, x, y);
|
||||||
|
return mod(x, b);
|
||||||
|
}
|
||||||
|
|
||||||
|
vector<tuple<int, int, ll>> decompose(ll x) {
|
||||||
|
// return (factor, count, factor ** count)
|
||||||
|
vector<tuple<int, int, ll>> res;
|
||||||
|
for (int i = 2; i * i <= x; i++) {
|
||||||
|
if (x % i == 0) {
|
||||||
|
int cnt = 0;
|
||||||
|
ll pw = 1;
|
||||||
|
while (x % i == 0) ++cnt, x /= i, pw *= i;
|
||||||
|
res.emplace_back(i, cnt, pw);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
if (x != 1) {
|
||||||
|
res.emplace_back(x, 1, x);
|
||||||
|
}
|
||||||
|
return res;
|
||||||
|
}
|
||||||
|
|
||||||
|
vector<pii> decompose_prime(int N) {
|
||||||
|
// return (factor, count)
|
||||||
|
vector<pii> result;
|
||||||
|
for (int i = 2; i * i <= N; i++) {
|
||||||
|
if (N % i == 0) {
|
||||||
|
int cnt = 0;
|
||||||
|
while (N % i == 0) N /= i, ++cnt;
|
||||||
|
result.emplace_back(i, cnt);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
if (N != 1) {
|
||||||
|
result.emplace_back(N, 1);
|
||||||
|
}
|
||||||
|
return result;
|
||||||
|
}
|
||||||
|
|
||||||
|
/* string algorithms */
|
||||||
|
vector<int> calc_next(string t) { // pi function of t
|
||||||
|
int n = (int)t.length();
|
||||||
|
vector<int> pi(n);
|
||||||
|
for (int i = 1; i < n; i++) {
|
||||||
|
int j = pi[i - 1];
|
||||||
|
while (j > 0 && t[i] != t[j]) j = pi[j - 1];
|
||||||
|
if (t[i] == t[j]) j++;
|
||||||
|
pi[i] = j;
|
||||||
|
}
|
||||||
|
return pi;
|
||||||
|
}
|
||||||
|
vector<int> calc_z(string t) { // z function of t
|
||||||
|
int m = t.length();
|
||||||
|
vector<int> z;
|
||||||
|
z.push_back(m);
|
||||||
|
pair<int, int> prev = {1, -1};
|
||||||
|
for (int i = 1; i < m; ++i) {
|
||||||
|
if (z[i - prev.first] + i <= prev.second) {
|
||||||
|
z.push_back(z[i - prev.first]);
|
||||||
|
} else {
|
||||||
|
int j = max(i, prev.second + 1);
|
||||||
|
while (j < m && t[j] == t[j - i]) ++j;
|
||||||
|
z.push_back(j - i);
|
||||||
|
prev = {i, j - 1};
|
||||||
|
}
|
||||||
|
}
|
||||||
|
return z;
|
||||||
|
}
|
||||||
|
vector<int> kmp(const string& s, const string& t) { // find all t in s
|
||||||
|
string cur = t + '#' + s;
|
||||||
|
int sz1 = s.size(), sz2 = t.size();
|
||||||
|
vector<int> v;
|
||||||
|
vector<int> lps = calc_next(cur);
|
||||||
|
for (int i = sz2 + 1; i <= sz1 + sz2; i++) {
|
||||||
|
if (lps[i] == sz2) v.push_back(i - 2 * sz2);
|
||||||
|
}
|
||||||
|
return v;
|
||||||
|
}
|
||||||
|
int period(const string& s) { // find the length of shortest recurring period
|
||||||
|
int n = s.length();
|
||||||
|
auto z = calc_z(s);
|
||||||
|
for (int i = 1; i <= n / 2; ++i) {
|
||||||
|
if (n % i == 0 && z[i] == n - i) {
|
||||||
|
return i;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
return n;
|
||||||
|
}
|
||||||
|
|
||||||
|
/* modular arithmetic */
|
||||||
|
template <ll mdl> struct MLL {
|
||||||
|
ll val;
|
||||||
|
MLL(ll v = 0) : val(mod(v, mdl)) {}
|
||||||
|
MLL(const MLL<mdl>& other) : val(other.val) {}
|
||||||
|
friend MLL operator+(const MLL& lhs, const MLL& rhs) { return mod(lhs.val + rhs.val, mdl); }
|
||||||
|
friend MLL operator-(const MLL& lhs, const MLL& rhs) { return mod(lhs.val - rhs.val, mdl); }
|
||||||
|
friend MLL operator*(const MLL& lhs, const MLL& rhs) { return mod(int128(lhs.val) * rhs.val, mdl); }
|
||||||
|
friend MLL operator/(const MLL& lhs, const MLL& rhs) { return lhs * mod(inverse(rhs.val, mdl), mdl); }
|
||||||
|
friend MLL operator%(const MLL& lhs, const MLL& rhs) { return mod(lhs.val - (lhs / rhs).val, mdl); }
|
||||||
|
friend bool operator==(const MLL& lhs, const MLL& rhs) { return lhs.val == rhs.val; }
|
||||||
|
friend bool operator!=(const MLL& lhs, const MLL& rhs) { return lhs.val != rhs.val; }
|
||||||
|
MLL& operator+=(const MLL& rhs) { return *this = *this + rhs; }
|
||||||
|
MLL& operator-=(const MLL& rhs) { return *this = *this - rhs; }
|
||||||
|
MLL& operator*=(const MLL& rhs) { return *this = *this * rhs; }
|
||||||
|
MLL& operator/=(const MLL& rhs) { return *this = *this / rhs; }
|
||||||
|
MLL& operator%=(const MLL& rhs) { return *this = *this % rhs; }
|
||||||
|
};
|
||||||
|
|
||||||
|
template <ll mdl>
|
||||||
|
ostream& operator<<(ostream& out, const MLL<mdl>& num) {
|
||||||
|
return out << num.val;
|
||||||
|
}
|
||||||
|
|
||||||
|
template <ll mdl>
|
||||||
|
istream& operator>>(istream& in, MLL<mdl>& num) {
|
||||||
|
return in >> num.val;
|
||||||
|
}
|
||||||
|
|
||||||
|
// miscancellous
|
||||||
|
template <typename T, typename U>
|
||||||
|
bool chmax(T& lhs, const U& rhs) {
|
||||||
|
bool ret = lhs < rhs;
|
||||||
|
if (ret) {
|
||||||
|
lhs = rhs;
|
||||||
|
}
|
||||||
|
return ret;
|
||||||
|
}
|
||||||
|
template <typename T, typename U>
|
||||||
|
bool chmin(T& lhs, const U& rhs) {
|
||||||
|
bool ret = lhs > rhs;
|
||||||
|
if (ret) {
|
||||||
|
lhs = rhs;
|
||||||
|
}
|
||||||
|
return ret;
|
||||||
|
}
|
||||||
|
|
||||||
|
#define functor(func) ([&](auto&&... val) \
|
||||||
|
noexcept(noexcept(func(std::forward<decltype(val)>(val)...))) -> decltype(auto) \
|
||||||
|
{return func(std::forward<decltype(val)>(val)...);})
|
||||||
|
#define expr(ret, ...) ([&] (__VA_ARGS__) { return (ret); })
|
||||||
|
template <typename Func, typename RandomIt> void sort_by_key(RandomIt first, RandomIt last, Func extractor) {
|
||||||
|
std::sort(first, last, [&] (auto&& a, auto&& b) { return std::less<>()(extractor(a), extractor(b)); });
|
||||||
|
}
|
||||||
|
template <typename Func, typename RandomIt, typename Compare> void sort_by_key(RandomIt first, RandomIt last, Func extractor, Compare comp) {
|
||||||
|
std::sort(first, last, [&] (auto&& a, auto&& b) { return comp(extractor(a), extractor(b)); });
|
||||||
|
}
|
||||||
|
template <typename T, typename U, typename Iterator_T, typename Iterator_U>
|
||||||
|
vector<pair<T, U>> zip(Iterator_T a_first, Iterator_T a_last, Iterator_U b_first, Iterator_U b_last) {
|
||||||
|
vector<pair<T, U>> res;
|
||||||
|
auto a_it = a_first;
|
||||||
|
auto b_it = b_first;
|
||||||
|
for (; not (a_it == a_last) and not (b_it == b_last); ++a_it, ++b_it) {
|
||||||
|
res.emplace_back(*a_it, *b_it);
|
||||||
|
}
|
||||||
|
return res;
|
||||||
|
}
|
||||||
|
template <typename T, typename U, typename Iterator_T, typename Iterator_U>
|
||||||
|
vector<pair<T, U>> zip_n(Iterator_T a_first, Iterator_U b_first, size_t n) {
|
||||||
|
vector<pair<T, U>> res;
|
||||||
|
if (n > 0) {
|
||||||
|
res.emplace_back(*a_first, *b_first);
|
||||||
|
for (size_t i = 1; i != n; ++i) {
|
||||||
|
res.emplace_back(*++a_first, *++b_first);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
return res;
|
||||||
|
}
|
||||||
|
template <typename T>
|
||||||
|
class ArithmeticIterator : bidirectional_iterator_tag {
|
||||||
|
public:
|
||||||
|
using difference_type = ptrdiff_t;
|
||||||
|
using value_type = T;
|
||||||
|
private:
|
||||||
|
value_type value;
|
||||||
|
public:
|
||||||
|
ArithmeticIterator(const T& value) : value(value) {}
|
||||||
|
value_type operator*() const { return value; }
|
||||||
|
ArithmeticIterator<T>& operator++() { ++value; return *this; }
|
||||||
|
ArithmeticIterator<T>& operator--() { --value; return *this; }
|
||||||
|
bool operator==(const ArithmeticIterator<T>& rhs) const { return value == rhs.value; }
|
||||||
|
};
|
||||||
|
template <typename T> vector<pair<int, T>> enumerate(const vector<T>& container) {
|
||||||
|
return zip<int, T>(ArithmeticIterator<int>(0), ArithmeticIterator<int>(INT_MAX), container.begin(), container.end());
|
||||||
|
}
|
||||||
|
#define initarray(init, N) (__initarray<decay<decltype(init)>::type, (N)>(init))
|
||||||
|
namespace detail {
|
||||||
|
template <typename T, std::size_t...Is>
|
||||||
|
constexpr std::array<T, sizeof...(Is)>
|
||||||
|
make_array(const T& value, std::index_sequence<Is...>) {
|
||||||
|
return {{(static_cast<void>(Is), value)...}};
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
template <typename T, std::size_t N>
|
||||||
|
constexpr std::array<T, N> __initarray(const T& value) {
|
||||||
|
return detail::make_array(value, std::make_index_sequence<N>());
|
||||||
|
}
|
||||||
|
/*******************************************************/
|
||||||
|
|
||||||
|
#define SINGLE_TEST_CASE
|
||||||
|
// #define DUMP_TEST_CASE 7219
|
||||||
|
// #define TOT_TEST_CASE 10000
|
||||||
|
|
||||||
|
void dump() {}
|
||||||
|
|
||||||
|
void dump_ignore() {}
|
||||||
|
|
||||||
|
void prep() {
|
||||||
|
}
|
||||||
|
|
||||||
|
// __attribute__((target("popcnt")))
|
||||||
|
void solve() {
|
||||||
|
read(int, n, m);
|
||||||
|
readvec(int, a, n);
|
||||||
|
readvec(int, b, m);
|
||||||
|
|
||||||
|
vector res(n, vector<int>(m));
|
||||||
|
for (int i = 0; i < n; ++i) {
|
||||||
|
for (int j = 0; j < m; ++j) {
|
||||||
|
res[i][j] = b[j];
|
||||||
|
}
|
||||||
|
}
|
||||||
|
int g = 0;
|
||||||
|
for (int i = 0; i < n; ++i) {
|
||||||
|
g = g == 0 ? a[i] : gcd(g, a[i]);
|
||||||
|
}
|
||||||
|
ll l = 1;
|
||||||
|
for (int j = 0; j < m; ++j) {
|
||||||
|
l = lcm(l, ll(1) * b[j]);
|
||||||
|
if (l > 1e9) {
|
||||||
|
cout << "No\n";
|
||||||
|
return;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
if (g % l != 0) {
|
||||||
|
cout << "No\n";
|
||||||
|
return;
|
||||||
|
}
|
||||||
|
int col = 0, dir = 1;
|
||||||
|
for (int i = 0; i < n; ++i) {
|
||||||
|
if (l == a[i]) continue;
|
||||||
|
res[i][col] = a[i];
|
||||||
|
col += dir;
|
||||||
|
if (col == m) {
|
||||||
|
col = max(0, m - 2);
|
||||||
|
dir = -dir;
|
||||||
|
} else if (col == -1) {
|
||||||
|
col = min(m - 1, 1);
|
||||||
|
dir = -dir;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
for (int j = 0; j < m; ++j) {
|
||||||
|
int g = 0;
|
||||||
|
for (int i = 0; i < n; ++i) {
|
||||||
|
g = g == 0 ? res[i][j] : gcd(g, res[i][j]);
|
||||||
|
}
|
||||||
|
if (g != b[j]) {
|
||||||
|
cout << "No\n";
|
||||||
|
return;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
cout << "Yes\n";
|
||||||
|
for (int i = 0; i < n; ++i) {
|
||||||
|
for (int j = 0; j < m; ++j) {
|
||||||
|
cout << res[i][j] << ' ';
|
||||||
|
}
|
||||||
|
cout << '\n';
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
int main() {
|
||||||
|
#if __cplusplus < 201402L or defined(_MSC_VER) and not defined(__clang__)
|
||||||
|
static_assert(false, "incompatible compiler variant detected.");
|
||||||
|
#endif
|
||||||
|
untie;
|
||||||
|
prep();
|
||||||
|
#ifdef SINGLE_TEST_CASE
|
||||||
|
solve();
|
||||||
|
#else
|
||||||
|
read(int, t);
|
||||||
|
for (int i = 0; i < t; ++i) {
|
||||||
|
#ifdef DUMP_TEST_CASE
|
||||||
|
if (t != (TOT_TEST_CASE)) {
|
||||||
|
solve();
|
||||||
|
} else if (i + 1 == (DUMP_TEST_CASE)) {
|
||||||
|
dump();
|
||||||
|
} else {
|
||||||
|
dump_ignore();
|
||||||
|
}
|
||||||
|
#else
|
||||||
|
solve();
|
||||||
|
#endif
|
||||||
|
}
|
||||||
|
#endif
|
||||||
|
}
|
158
src/bin/j.cc
158
src/bin/j.cc
|
@ -1,5 +1,5 @@
|
||||||
// #pragma GCC target("popcnt,lzcnt,abm,bmi,bmi2")
|
// #pragma GCC target("popcnt,lzcnt,abm,bmi,bmi2")
|
||||||
#pragma GCC optimize("Ofast,no-stack-protector,unroll-loops,fast-math")
|
#pragma GCC optimize("Ofast,unroll-loops")
|
||||||
/************* This code requires C++17. ***************/
|
/************* This code requires C++17. ***************/
|
||||||
|
|
||||||
#include<bits/stdc++.h>
|
#include<bits/stdc++.h>
|
||||||
|
@ -12,6 +12,8 @@ using namespace std;
|
||||||
constexpr void __() {}
|
constexpr void __() {}
|
||||||
#define __AS_PROCEDURE(...) __(); __VA_ARGS__; __()
|
#define __AS_PROCEDURE(...) __(); __VA_ARGS__; __()
|
||||||
#define __as_typeof(container) remove_reference<decltype(container)>::type
|
#define __as_typeof(container) remove_reference<decltype(container)>::type
|
||||||
|
template <typename T> struct argument_type;
|
||||||
|
template <typename T, typename U> struct argument_type<T(U)> { using type = U; };
|
||||||
|
|
||||||
/* type aliases */
|
/* type aliases */
|
||||||
#if LONG_LONG_MAX != INT64_MAX
|
#if LONG_LONG_MAX != INT64_MAX
|
||||||
|
@ -23,7 +25,7 @@ using ull = unsigned long long;
|
||||||
#endif
|
#endif
|
||||||
using int128 = __int128_t;
|
using int128 = __int128_t;
|
||||||
using uint128 = __uint128_t;
|
using uint128 = __uint128_t;
|
||||||
using ld = long double;
|
using ld = __float128; // up to 1e-9 precision in binary search
|
||||||
using pii = pair<int, int>; using pil = pair<int, ll>; using pid = pair<int, ld>;
|
using pii = pair<int, int>; using pil = pair<int, ll>; using pid = pair<int, ld>;
|
||||||
using pli = pair<ll, int>; using pll = pair<ll, ll>; using pld = pair<ll, ld>;
|
using pli = pair<ll, int>; using pll = pair<ll, ll>; using pld = pair<ll, ld>;
|
||||||
using pdi = pair<ld, int>; using pdl = pair<ld, ll>; using pdd = pair<ld, ld>;
|
using pdi = pair<ld, int>; using pdl = pair<ld, ll>; using pdd = pair<ld, ld>;
|
||||||
|
@ -46,6 +48,7 @@ constexpr int INF = 0x3f3f3f3f;
|
||||||
constexpr ll INFLL = 0x3f3f3f3f3f3f3f3fLL;
|
constexpr ll INFLL = 0x3f3f3f3f3f3f3f3fLL;
|
||||||
constexpr ll MDL = 1e9 + 7;
|
constexpr ll MDL = 1e9 + 7;
|
||||||
constexpr ll PRIME = 998'244'353;
|
constexpr ll PRIME = 998'244'353;
|
||||||
|
constexpr ll PRIMELL = 901017227882342239LL;
|
||||||
constexpr ll MDL1 = 8784491;
|
constexpr ll MDL1 = 8784491;
|
||||||
constexpr ll MDL2 = PRIME;
|
constexpr ll MDL2 = PRIME;
|
||||||
constexpr int128 INT128_MAX = numeric_limits<int128>::max();
|
constexpr int128 INT128_MAX = numeric_limits<int128>::max();
|
||||||
|
@ -94,9 +97,9 @@ struct igt {
|
||||||
|
|
||||||
/* conditions */
|
/* conditions */
|
||||||
#define loop while (1)
|
#define loop while (1)
|
||||||
#define if_or(var, val) if (!(var == val)) var = val; else
|
#define if_or(var, val) if (!((var) == (val))) (var) = (val); else
|
||||||
#define continue_or(var, val) __AS_PROCEDURE(if (var == val) continue; var = val;)
|
#define continue_or(var, val) __AS_PROCEDURE(if ((var) == (val)) continue; (var) = (val);)
|
||||||
#define break_or(var, val) __AS_PROCEDURE(if (var == val) break; var = val;)
|
#define break_or(var, val) __AS_PROCEDURE(if ((var) == (val)) break; (var) = (val);)
|
||||||
|
|
||||||
/* hash */
|
/* hash */
|
||||||
struct safe_hash {
|
struct safe_hash {
|
||||||
|
@ -130,13 +133,15 @@ struct pair_hash {
|
||||||
uniform_int_distribution<mt19937::result_type> dist(PRIME);
|
uniform_int_distribution<mt19937::result_type> dist(PRIME);
|
||||||
const size_t __array_hash_b = 31, __array_hash_mdl1 = dist(rd), __array_hash_mdl2 = dist(rd);
|
const size_t __array_hash_b = 31, __array_hash_mdl1 = dist(rd), __array_hash_mdl2 = dist(rd);
|
||||||
struct array_hash {
|
struct array_hash {
|
||||||
|
safe_hash hasher;
|
||||||
template <typename Sequence>
|
template <typename Sequence>
|
||||||
size_t operator()(const Sequence& arr) const {
|
size_t operator()(const Sequence& arr) const {
|
||||||
size_t pw1 = 1, pw2 = 1;
|
size_t pw1 = 1, pw2 = 1;
|
||||||
size_t res1 = 0, res2 = 0;
|
size_t res1 = 0, res2 = 0;
|
||||||
for (auto&& x : arr) {
|
for (auto&& x : arr) {
|
||||||
res1 = (res1 + x * pw1) % __array_hash_mdl1;
|
auto h = hasher(x);
|
||||||
res2 = (res2 + x * pw2) % __array_hash_mdl2;
|
res1 = (res1 + h * pw1) % __array_hash_mdl1;
|
||||||
|
res2 = (res2 + h * pw2) % __array_hash_mdl2;
|
||||||
pw1 = (pw1 * __array_hash_b) % __array_hash_mdl1;
|
pw1 = (pw1 * __array_hash_b) % __array_hash_mdl1;
|
||||||
pw2 = (pw2 * __array_hash_b) % __array_hash_mdl2;
|
pw2 = (pw2 * __array_hash_b) % __array_hash_mdl2;
|
||||||
}
|
}
|
||||||
|
@ -170,6 +175,17 @@ template <typename T, typename Iterator> pair<size_t, unordered_map<T, size_t, s
|
||||||
|
|
||||||
/* io */
|
/* io */
|
||||||
#define untie __AS_PROCEDURE(ios_base::sync_with_stdio(0), cin.tie(NULL))
|
#define untie __AS_PROCEDURE(ios_base::sync_with_stdio(0), cin.tie(NULL))
|
||||||
|
|
||||||
|
// add declarations to avoid circular dependency
|
||||||
|
template<typename T, typename U> istream& operator>>(istream&, pair<T, U>&);
|
||||||
|
template<typename T, typename U> ostream& operator<<(ostream&, const pair<T, U>&);
|
||||||
|
template<typename T, size_t N> istream& operator>>(istream&, array<T, N>&);
|
||||||
|
template <typename T, size_t N> ostream& operator<<(ostream&, const array<T, N>&);
|
||||||
|
template<typename Char, typename Traits, typename... Args>
|
||||||
|
decltype(auto) operator<<(std::basic_ostream<Char, Traits>&, const std::tuple<Args...>&);
|
||||||
|
template<typename T> ostream& operator<<(ostream&, const vector<T>&);
|
||||||
|
std::ostream& operator<<(std::ostream&, const int128&);
|
||||||
|
|
||||||
template<typename T, typename U> istream& operator>>(istream& in, pair<T, U>& p) {
|
template<typename T, typename U> istream& operator>>(istream& in, pair<T, U>& p) {
|
||||||
return in >> p.first >> p.second;
|
return in >> p.first >> p.second;
|
||||||
}
|
}
|
||||||
|
@ -177,6 +193,14 @@ template<typename T, typename U> ostream& operator<<(ostream& out, const pair<T,
|
||||||
out << "{" << p.first << ", " << p.second << "}";
|
out << "{" << p.first << ", " << p.second << "}";
|
||||||
return out;
|
return out;
|
||||||
}
|
}
|
||||||
|
template<typename T, size_t N> istream& operator>>(istream& in, array<T, N>& a) {
|
||||||
|
for (size_t i = 0; i < N; ++i) in >> a[i];
|
||||||
|
return in;
|
||||||
|
}
|
||||||
|
template <typename T, size_t N> ostream& operator<<(ostream& out, const array<T, N>& a) {
|
||||||
|
for (auto&& i : a) out << i << ' ';
|
||||||
|
return out;
|
||||||
|
}
|
||||||
template<typename Char, typename Traits, typename Tuple, std::size_t... Index>
|
template<typename Char, typename Traits, typename Tuple, std::size_t... Index>
|
||||||
void print_tuple_impl(std::basic_ostream<Char, Traits>& os, const Tuple& t, std::index_sequence<Index...>) {
|
void print_tuple_impl(std::basic_ostream<Char, Traits>& os, const Tuple& t, std::index_sequence<Index...>) {
|
||||||
using swallow = int[]; // guaranties left to right order
|
using swallow = int[]; // guaranties left to right order
|
||||||
|
@ -217,21 +241,36 @@ std::ostream& operator<<(std::ostream& dest, const int128& value) {
|
||||||
}
|
}
|
||||||
template<typename T> void __read(T& x) { cin >> x; }
|
template<typename T> void __read(T& x) { cin >> x; }
|
||||||
template<typename T, typename... U> void __read(T& x, U&... args) { cin >> x; __read(args...); }
|
template<typename T, typename... U> void __read(T& x, U&... args) { cin >> x; __read(args...); }
|
||||||
#define read(type, ...) __AS_PROCEDURE(type __VA_ARGS__; __read(__VA_ARGS__);)
|
#define read(t, ...) __AS_PROCEDURE(argument_type<void(t)>::type __VA_ARGS__; __read(__VA_ARGS__);)
|
||||||
#define readvec(type, a, n) __AS_PROCEDURE(vector<type> a(n); for (auto& x : a) cin >> x;)
|
#define readvec(t, a, n) __AS_PROCEDURE(vector<argument_type<void(t)>::type> a(n); for (auto& x : (a)) cin >> x;)
|
||||||
#define readvec1(type, a, n) __AS_PROCEDURE(vector<type> a((n) + 1); copy_n(ii<type>(cin), (n), a.begin() + 1);)
|
#define readvec1(t, a, n) __AS_PROCEDURE(vector<argument_type<void(t)>::type> a((n) + 1); copy_n(ii<argument_type<void(t)>::type>(cin), (n), (a).begin() + 1);)
|
||||||
#define putvec(a) __AS_PROCEDURE(copy(a.begin(), a.end(), oi<__as_typeof(a)::value_type>(cout, " ")); cout << endl;)
|
#define putvec(a) __AS_PROCEDURE(copy((a).begin(), (a).end(), oi<__as_typeof(a)::value_type>(cout, " ")); cout << endl;)
|
||||||
#define putvec1(a) __AS_PROCEDURE(copy(a.begin() + 1, a.end(), oi<__as_typeof(a)::value_type>(cout, " ")); cout << endl;)
|
#define putvec1(a) __AS_PROCEDURE(copy((a).begin() + 1, (a).end(), oi<__as_typeof(a)::value_type>(cout, " ")); cout << endl;)
|
||||||
#define putvec_eol(a) __AS_PROCEDURE(copy(a.begin(), a.end(), oi<__as_typeof(a)::value_type>(cout, "\n"));)
|
#define putvec_eol(a) __AS_PROCEDURE(copy((a).begin(), (a).end(), oi<__as_typeof(a)::value_type>(cout, "\n"));)
|
||||||
#define putvec1_eol(a) __AS_PROCEDURE(copy(a.begin() + 1, a.end(), oi<__as_typeof(a)::value_type>(cout, "\n"));)
|
#define putvec1_eol(a) __AS_PROCEDURE(copy((a).begin() + 1, (a).end(), oi<__as_typeof(a)::value_type>(cout, "\n"));)
|
||||||
#define debug(x) __AS_PROCEDURE(cerr << #x" = " << (x) << endl;)
|
#define debug(x) __AS_PROCEDURE(cerr << #x" = " << (x) << endl;)
|
||||||
#define debugvec(a) __AS_PROCEDURE(cerr << #a" = "; for (auto&& x : a) cerr << x << ' '; cerr << endl;)
|
#define debugvec(a) __AS_PROCEDURE(cerr << #a" = "; for (auto&& x : (a)) cerr << x << ' '; cerr << endl;)
|
||||||
#define deb(...) debug(make_tuple(__VA_ARGS__))
|
#define deb(...) debug(make_tuple(__VA_ARGS__))
|
||||||
|
|
||||||
/* pops */
|
/* pops */
|
||||||
#define poptop(q, ...) __AS_PROCEDURE(auto [__VA_ARGS__] = q.top(); q.pop();)
|
template <typename Container>
|
||||||
#define popback(q, ...) __AS_PROCEDURE(auto [__VA_ARGS__] = q.back(); q.pop_back();)
|
inline auto poptop(Container& q) {
|
||||||
#define popfront(q, ...) __AS_PROCEDURE(auto [__VA_ARGS__] = q.front();q.pop_front();)
|
auto ret = q.top();
|
||||||
|
q.pop();
|
||||||
|
return ret;
|
||||||
|
}
|
||||||
|
template <typename Container>
|
||||||
|
inline auto popback(Container& q) {
|
||||||
|
auto ret = q.back();
|
||||||
|
q.pop_back();
|
||||||
|
return ret;
|
||||||
|
}
|
||||||
|
template <typename Container>
|
||||||
|
inline auto popfront(Container& q) {
|
||||||
|
auto ret = q.front();
|
||||||
|
q.pop_front();
|
||||||
|
return ret;
|
||||||
|
}
|
||||||
|
|
||||||
/* math */
|
/* math */
|
||||||
template <typename return_t>
|
template <typename return_t>
|
||||||
|
@ -243,11 +282,43 @@ return_t qpow(ll b, ll p) {
|
||||||
else return half * half;
|
else return half * half;
|
||||||
}
|
}
|
||||||
|
|
||||||
|
// dynamic modulus
|
||||||
|
ll qpow(ll b, ll p, ll mod) {
|
||||||
|
if (b == 0 and p != 0) return 0;
|
||||||
|
if (p == 0) return 1;
|
||||||
|
ll half = qpow(b, p / 2, mod);
|
||||||
|
if (p % 2 == 1) return (int128(half) * half % mod) * b % mod;
|
||||||
|
else return half * half % mod;
|
||||||
|
}
|
||||||
|
|
||||||
|
|
||||||
|
#pragma GCC diagnostic push
|
||||||
|
#pragma GCC diagnostic ignored "-Wparentheses"
|
||||||
|
// Accurately find `i` 'th root of `n` (taking the floor)
|
||||||
|
inline ll root(ll n, ll i) {
|
||||||
|
ll l = 0, r = pow(LLONG_MAX, (long double)(1) / i);
|
||||||
|
while (l < r) {
|
||||||
|
ll mid = l + r + 1 >> 1;
|
||||||
|
if (qpow<int128>(mid, i) <= n) {
|
||||||
|
l = mid;
|
||||||
|
} else {
|
||||||
|
r = mid - 1;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
return l;
|
||||||
|
}
|
||||||
|
#pragma GCC diagnostic pop
|
||||||
|
|
||||||
|
|
||||||
#define comb(n, k) ((n) < 0 or (k) < 0 or (n) < (k) ? 0 : fact[n] / fact[k] / fact[(n) - (k)])
|
#define comb(n, k) ((n) < 0 or (k) < 0 or (n) < (k) ? 0 : fact[n] / fact[k] / fact[(n) - (k)])
|
||||||
#define fastcomb(n, k) ((n) < 0 or (k) < 0 or (n) < (k) ? 0 : fact[n] * factrev[k] * factrev[(n) - (k)])
|
#define fastcomb(n, k) ((n) < 0 or (k) < 0 or (n) < (k) ? 0 : fact[n] * factrev[k] * factrev[(n) - (k)])
|
||||||
|
|
||||||
|
__attribute__((target("lzcnt")))
|
||||||
constexpr inline int lg2(ll x) { return x == 0 ? -1 : sizeof(ll) * 8 - 1 - __builtin_clzll(x); }
|
constexpr inline int lg2(ll x) { return x == 0 ? -1 : sizeof(ll) * 8 - 1 - __builtin_clzll(x); }
|
||||||
|
|
||||||
|
template <typename T>
|
||||||
|
T mygcd(T a, T b) { return b == 0 ? a : mygcd(b, a % b); }
|
||||||
|
|
||||||
void __exgcd(ll a, ll b, ll& x, ll& y) {
|
void __exgcd(ll a, ll b, ll& x, ll& y) {
|
||||||
if (b == 0) {
|
if (b == 0) {
|
||||||
x = 1, y = 0;
|
x = 1, y = 0;
|
||||||
|
@ -325,7 +396,7 @@ vector<int> calc_z(string t) { // z function of t
|
||||||
}
|
}
|
||||||
return z;
|
return z;
|
||||||
}
|
}
|
||||||
vector<int> kmp(string s, string t) { // find all t in s
|
vector<int> kmp(const string& s, const string& t) { // find all t in s
|
||||||
string cur = t + '#' + s;
|
string cur = t + '#' + s;
|
||||||
int sz1 = s.size(), sz2 = t.size();
|
int sz1 = s.size(), sz2 = t.size();
|
||||||
vector<int> v;
|
vector<int> v;
|
||||||
|
@ -335,7 +406,7 @@ vector<int> kmp(string s, string t) { // find all t in s
|
||||||
}
|
}
|
||||||
return v;
|
return v;
|
||||||
}
|
}
|
||||||
int period(string s) { // find the length of shortest recurring period
|
int period(const string& s) { // find the length of shortest recurring period
|
||||||
int n = s.length();
|
int n = s.length();
|
||||||
auto z = calc_z(s);
|
auto z = calc_z(s);
|
||||||
for (int i = 1; i <= n / 2; ++i) {
|
for (int i = 1; i <= n / 2; ++i) {
|
||||||
|
@ -353,16 +424,16 @@ template <ll mdl> struct MLL {
|
||||||
MLL(const MLL<mdl>& other) : val(other.val) {}
|
MLL(const MLL<mdl>& other) : val(other.val) {}
|
||||||
friend MLL operator+(const MLL& lhs, const MLL& rhs) { return mod(lhs.val + rhs.val, mdl); }
|
friend MLL operator+(const MLL& lhs, const MLL& rhs) { return mod(lhs.val + rhs.val, mdl); }
|
||||||
friend MLL operator-(const MLL& lhs, const MLL& rhs) { return mod(lhs.val - rhs.val, mdl); }
|
friend MLL operator-(const MLL& lhs, const MLL& rhs) { return mod(lhs.val - rhs.val, mdl); }
|
||||||
friend MLL operator*(const MLL& lhs, const MLL& rhs) { return mod(lhs.val * rhs.val, mdl); }
|
friend MLL operator*(const MLL& lhs, const MLL& rhs) { return mod(int128(lhs.val) * rhs.val, mdl); }
|
||||||
friend MLL operator/(const MLL& lhs, const MLL& rhs) { return mod(lhs.val * mod(inverse(rhs.val, mdl), mdl), mdl); }
|
friend MLL operator/(const MLL& lhs, const MLL& rhs) { return lhs * mod(inverse(rhs.val, mdl), mdl); }
|
||||||
friend MLL operator%(const MLL& lhs, const MLL& rhs) { return mod(lhs.val - (lhs / rhs).val, mdl); }
|
friend MLL operator%(const MLL& lhs, const MLL& rhs) { return mod(lhs.val - (lhs / rhs).val, mdl); }
|
||||||
friend bool operator==(const MLL& lhs, const MLL& rhs) { return lhs.val == rhs.val; }
|
friend bool operator==(const MLL& lhs, const MLL& rhs) { return lhs.val == rhs.val; }
|
||||||
friend bool operator!=(const MLL& lhs, const MLL& rhs) { return lhs.val != rhs.val; }
|
friend bool operator!=(const MLL& lhs, const MLL& rhs) { return lhs.val != rhs.val; }
|
||||||
void operator+=(const MLL& rhs) { val = (*this + rhs).val; }
|
MLL& operator+=(const MLL& rhs) { return *this = *this + rhs; }
|
||||||
void operator-=(const MLL& rhs) { val = (*this - rhs).val; }
|
MLL& operator-=(const MLL& rhs) { return *this = *this - rhs; }
|
||||||
void operator*=(const MLL& rhs) { val = (*this * rhs).val; }
|
MLL& operator*=(const MLL& rhs) { return *this = *this * rhs; }
|
||||||
void operator/=(const MLL& rhs) { val = (*this / rhs).val; }
|
MLL& operator/=(const MLL& rhs) { return *this = *this / rhs; }
|
||||||
void operator%=(const MLL& rhs) { val = (*this % rhs).val; }
|
MLL& operator%=(const MLL& rhs) { return *this = *this % rhs; }
|
||||||
};
|
};
|
||||||
|
|
||||||
template <ll mdl>
|
template <ll mdl>
|
||||||
|
@ -456,7 +527,7 @@ constexpr std::array<T, N> __initarray(const T& value) {
|
||||||
}
|
}
|
||||||
/*******************************************************/
|
/*******************************************************/
|
||||||
|
|
||||||
#define SINGLE_TEST_CASE
|
// #define SINGLE_TEST_CASE
|
||||||
// #define DUMP_TEST_CASE 7219
|
// #define DUMP_TEST_CASE 7219
|
||||||
// #define TOT_TEST_CASE 10000
|
// #define TOT_TEST_CASE 10000
|
||||||
|
|
||||||
|
@ -470,28 +541,31 @@ void prep() {
|
||||||
// __attribute__((target("popcnt")))
|
// __attribute__((target("popcnt")))
|
||||||
void solve() {
|
void solve() {
|
||||||
read(int, n);
|
read(int, n);
|
||||||
ll tot = 0;
|
read(ll, l);
|
||||||
|
readvec(ll, a, n);
|
||||||
|
ll raw = 0;
|
||||||
for (int i = 0; i < n; ++i) {
|
for (int i = 0; i < n; ++i) {
|
||||||
read(char, c);
|
raw or_eq a[i];
|
||||||
if (c == 'B') {
|
|
||||||
read(int, x);
|
|
||||||
ll use = min<ll>(x, tot);
|
|
||||||
tot -= use;
|
|
||||||
if (x - use > 0) {
|
|
||||||
cout << "YES\n";
|
|
||||||
} else {
|
|
||||||
cout << "NO\n";
|
|
||||||
}
|
}
|
||||||
} else {
|
for (int i = 60; ~i; --i) {
|
||||||
read(int, x);
|
int cnt = 0;
|
||||||
tot += x;
|
for (int j = 0; j < n; ++j) {
|
||||||
|
cnt += a[j] >> i bitand 1;
|
||||||
|
}
|
||||||
|
if (cnt < 2) continue;
|
||||||
|
for (int j = 0; j < n; ++j) {
|
||||||
|
if ((a[j] >> i bitand 1) and ((a[j] bitor ((ll(1) << i) - 1)) xor ll(1) << i) >= l) {
|
||||||
|
cout << (raw bitor ((ll(1) << i) - 1)) << '\n';
|
||||||
|
return;
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
}
|
||||||
|
cout << raw << '\n';
|
||||||
}
|
}
|
||||||
|
|
||||||
int main() {
|
int main() {
|
||||||
#if __cplusplus < 201402L or defined(_MSC_VER) and not defined(__clang__)
|
#if __cplusplus < 201402L or defined(_MSC_VER) and not defined(__clang__)
|
||||||
assert(false && "incompatible compiler variant detected.");
|
static_assert(false, "incompatible compiler variant detected.");
|
||||||
#endif
|
#endif
|
||||||
untie;
|
untie;
|
||||||
prep();
|
prep();
|
||||||
|
|
|
@ -0,0 +1,586 @@
|
||||||
|
// #pragma GCC target("popcnt,lzcnt,abm,bmi,bmi2")
|
||||||
|
#pragma GCC optimize("Ofast,unroll-loops")
|
||||||
|
/************* This code requires C++17. ***************/
|
||||||
|
|
||||||
|
#include<bits/stdc++.h>
|
||||||
|
using namespace std;
|
||||||
|
|
||||||
|
/* macro helpers */
|
||||||
|
#define __NARGS(...) std::tuple_size<decltype(std::make_tuple(__VA_ARGS__))>::value
|
||||||
|
#define __DECOMPOSE_S(a, x) auto x = a;
|
||||||
|
#define __DECOMPOSE_N(a, ...) auto [__VA_ARGS__] = a;
|
||||||
|
constexpr void __() {}
|
||||||
|
#define __AS_PROCEDURE(...) __(); __VA_ARGS__; __()
|
||||||
|
#define __as_typeof(container) remove_reference<decltype(container)>::type
|
||||||
|
template <typename T> struct argument_type;
|
||||||
|
template <typename T, typename U> struct argument_type<T(U)> { using type = U; };
|
||||||
|
|
||||||
|
/* type aliases */
|
||||||
|
#if LONG_LONG_MAX != INT64_MAX
|
||||||
|
using ll = int64_t;
|
||||||
|
using ull = uint64_t;
|
||||||
|
#else
|
||||||
|
using ll = long long;
|
||||||
|
using ull = unsigned long long;
|
||||||
|
#endif
|
||||||
|
using int128 = __int128_t;
|
||||||
|
using uint128 = __uint128_t;
|
||||||
|
using ld = __float128; // up to 1e-9 precision in binary search
|
||||||
|
using pii = pair<int, int>; using pil = pair<int, ll>; using pid = pair<int, ld>;
|
||||||
|
using pli = pair<ll, int>; using pll = pair<ll, ll>; using pld = pair<ll, ld>;
|
||||||
|
using pdi = pair<ld, int>; using pdl = pair<ld, ll>; using pdd = pair<ld, ld>;
|
||||||
|
using tiii = tuple<int, int, int>; using tiil = tuple<int, int, ll>; using tiid = tuple<int, int, ld>;
|
||||||
|
using tili = tuple<int, ll, int>; using till = tuple<int, ll, ll>; using tild = tuple<int, ll, ld>;
|
||||||
|
using tidi = tuple<int, ld, int>; using tidl = tuple<int, ld, ll>; using tidd = tuple<int, ld, ld>;
|
||||||
|
using tlii = tuple<ll, int, int>; using tlil = tuple<ll, int, ll>; using tlid = tuple<ll, int, ld>;
|
||||||
|
using tlli = tuple<ll, ll, int>; using tlll = tuple<ll, ll, ll>; using tlld = tuple<ll, ll, ld>;
|
||||||
|
using tldi = tuple<ll, ld, int>; using tldl = tuple<ll, ld, ll>; using tldd = tuple<ll, ld, ld>;
|
||||||
|
using tdii = tuple<ld, int, int>; using tdil = tuple<ld, int, ll>; using tdid = tuple<ld, int, ld>;
|
||||||
|
using tdli = tuple<ld, ll, int>; using tdll = tuple<ld, ll, ll>; using tdld = tuple<ld, ll, ld>;
|
||||||
|
using tddi = tuple<ld, ld, int>; using tddl = tuple<ld, ld, ll>; using tddd = tuple<ld, ld, ld>;
|
||||||
|
template <typename T> using max_heap = priority_queue<T>;
|
||||||
|
template <typename T> using min_heap = priority_queue<T, vector<T>, greater<>>;
|
||||||
|
template <typename T> using oi = ostream_iterator<T>;
|
||||||
|
template <typename T> using ii = istream_iterator<T>;
|
||||||
|
|
||||||
|
/* constants */
|
||||||
|
constexpr int INF = 0x3f3f3f3f;
|
||||||
|
constexpr ll INFLL = 0x3f3f3f3f3f3f3f3fLL;
|
||||||
|
constexpr ll MDL = 1e9 + 7;
|
||||||
|
constexpr ll PRIME = 998'244'353;
|
||||||
|
constexpr ll PRIMELL = 901017227882342239LL;
|
||||||
|
constexpr ll MDL1 = 8784491;
|
||||||
|
constexpr ll MDL2 = PRIME;
|
||||||
|
constexpr int128 INT128_MAX = numeric_limits<int128>::max();
|
||||||
|
constexpr uint128 UINT128_MAX = numeric_limits<uint128>::max();
|
||||||
|
constexpr int128 INT128_MIN = numeric_limits<int128>::min();
|
||||||
|
constexpr uint128 UINT128_MIN = numeric_limits<uint128>::min();
|
||||||
|
|
||||||
|
/* random */
|
||||||
|
|
||||||
|
mt19937_64 rd(chrono::duration_cast<chrono::milliseconds>(chrono::system_clock::now().time_since_epoch()).count());
|
||||||
|
|
||||||
|
/* bit-wise operations */
|
||||||
|
#define lowbit(x) ((x) & -(x))
|
||||||
|
#define popcount(x) (__builtin_popcountll(ll(x)))
|
||||||
|
#define parity(x) (__builtin_parityll(ll(x)))
|
||||||
|
#define msp(x) (63LL - __builtin_clzll(ll(x)))
|
||||||
|
#define lsp(x) (__builtin_ctzll(ll(x)))
|
||||||
|
|
||||||
|
/* arithmetic operations */
|
||||||
|
#define mod(x, y) ((((x) % (y)) + (y)) % (y))
|
||||||
|
|
||||||
|
/* fast pairs */
|
||||||
|
#define upair ull
|
||||||
|
#define umake(x, y) (ull(x) << 32 | (ull(y) & ((1ULL << 32) - 1)))
|
||||||
|
#define u1(p) ((p) >> 32)
|
||||||
|
#define u2(p) ((p) & ((1ULL << 32) - 1))
|
||||||
|
#define ult std::less<upair>
|
||||||
|
#define ugt std::greater<upair>
|
||||||
|
|
||||||
|
#define ipair ull
|
||||||
|
#define imake(x, y) (umake(x, y))
|
||||||
|
#define i1(p) (int(u1(ll(p))))
|
||||||
|
#define i2(p) (ll(u2(p) << 32) >> 32)
|
||||||
|
struct ilt {
|
||||||
|
bool operator()(const ipair& a, const ipair& b) const {
|
||||||
|
if (i1(a) == i1(b)) return i2(a) < i2(b);
|
||||||
|
else return i1(a) < i1(b);
|
||||||
|
}
|
||||||
|
};
|
||||||
|
struct igt {
|
||||||
|
bool operator()(const ipair& a, const ipair& b) const {
|
||||||
|
if (i1(a) == i1(b)) return i2(a) > i2(b);
|
||||||
|
else return i1(a) > i1(b);
|
||||||
|
}
|
||||||
|
};
|
||||||
|
|
||||||
|
/* conditions */
|
||||||
|
#define loop while (1)
|
||||||
|
#define if_or(var, val) if (!((var) == (val))) (var) = (val); else
|
||||||
|
#define continue_or(var, val) __AS_PROCEDURE(if ((var) == (val)) continue; (var) = (val);)
|
||||||
|
#define break_or(var, val) __AS_PROCEDURE(if ((var) == (val)) break; (var) = (val);)
|
||||||
|
|
||||||
|
/* hash */
|
||||||
|
struct safe_hash {
|
||||||
|
// https://codeforces.com/blog/entry/62393
|
||||||
|
static uint64_t splitmix64(uint64_t x) {
|
||||||
|
// http://xorshift.di.unimi.it/splitmix64.c
|
||||||
|
x += 0x9e3779b97f4a7c15;
|
||||||
|
x = (x ^ (x >> 30)) * 0xbf58476d1ce4e5b9;
|
||||||
|
x = (x ^ (x >> 27)) * 0x94d049bb133111eb;
|
||||||
|
return x ^ (x >> 31);
|
||||||
|
}
|
||||||
|
|
||||||
|
size_t operator()(uint64_t x) const {
|
||||||
|
static const uint64_t FIXED_RANDOM = chrono::steady_clock::now().time_since_epoch().count();
|
||||||
|
return splitmix64(x + FIXED_RANDOM);
|
||||||
|
}
|
||||||
|
};
|
||||||
|
|
||||||
|
struct pair_hash {
|
||||||
|
template <typename T, typename U>
|
||||||
|
size_t operator()(const pair<T, U>& a) const {
|
||||||
|
auto hash1 = safe_hash()(a.first);
|
||||||
|
auto hash2 = safe_hash()(a.second);
|
||||||
|
if (hash1 != hash2) {
|
||||||
|
return hash1 ^ hash2;
|
||||||
|
}
|
||||||
|
return hash1;
|
||||||
|
}
|
||||||
|
};
|
||||||
|
|
||||||
|
uniform_int_distribution<mt19937::result_type> dist(PRIME);
|
||||||
|
const size_t __array_hash_b = 31, __array_hash_mdl1 = dist(rd), __array_hash_mdl2 = dist(rd);
|
||||||
|
struct array_hash {
|
||||||
|
safe_hash hasher;
|
||||||
|
template <typename Sequence>
|
||||||
|
size_t operator()(const Sequence& arr) const {
|
||||||
|
size_t pw1 = 1, pw2 = 1;
|
||||||
|
size_t res1 = 0, res2 = 0;
|
||||||
|
for (auto&& x : arr) {
|
||||||
|
auto h = hasher(x);
|
||||||
|
res1 = (res1 + h * pw1) % __array_hash_mdl1;
|
||||||
|
res2 = (res2 + h * pw2) % __array_hash_mdl2;
|
||||||
|
pw1 = (pw1 * __array_hash_b) % __array_hash_mdl1;
|
||||||
|
pw2 = (pw2 * __array_hash_b) % __array_hash_mdl2;
|
||||||
|
}
|
||||||
|
return res1 + res2;
|
||||||
|
}
|
||||||
|
};
|
||||||
|
|
||||||
|
/* build data structures */
|
||||||
|
#define faster(um) __AS_PROCEDURE((um).reserve(1024); (um).max_load_factor(0.25);)
|
||||||
|
#define unordered_counter(from, to) __AS_PROCEDURE(unordered_map<__as_typeof(from), size_t, safe_hash> to; for (auto&& x : from) ++to[x];)
|
||||||
|
#define counter(from, to, cmp) __AS_PROCEDURE(map<__as_typeof(from), size_t, cmp> to; for (auto&& x : from) ++to[x];)
|
||||||
|
#define adj(ch, n) __AS_PROCEDURE(vector<vector<int>> ch((n) + 1);)
|
||||||
|
#define edge(ch, u, v) __AS_PROCEDURE(ch[u].push_back(v), ch[v].push_back(u);)
|
||||||
|
#define edgew(ch, u, v, ...) __AS_PROCEDURE(ch[u].emplace_back(v, __VA_ARGS__), ch[v].emplace_back(u, __VA_ARGS__);)
|
||||||
|
#define Edge(ch, u, v) __AS_PROCEDURE(ch[u].push_back(v);)
|
||||||
|
#define Edgew(ch, u, v, ...) __AS_PROCEDURE(ch[u].emplace_back(v, __VA_ARGS__);)
|
||||||
|
template <typename T, typename Iterator> pair<size_t, map<T, size_t>> discretize(Iterator __first, Iterator __last) {
|
||||||
|
set<T> st(__first, __last);
|
||||||
|
size_t N = 0;
|
||||||
|
map<T, size_t> mp;
|
||||||
|
for (auto&& x : st) mp[x] = ++N;
|
||||||
|
return {N, mp};
|
||||||
|
}
|
||||||
|
template <typename T, typename Iterator> pair<size_t, unordered_map<T, size_t, safe_hash>> unordered_discretize(Iterator __first, Iterator __last) {
|
||||||
|
set<T> st(__first, __last);
|
||||||
|
size_t N = 0;
|
||||||
|
unordered_map<T, size_t, safe_hash> mp;
|
||||||
|
for (auto&& x : st) mp[x] = ++N;
|
||||||
|
return {N, mp};
|
||||||
|
}
|
||||||
|
|
||||||
|
/* io */
|
||||||
|
#define untie __AS_PROCEDURE(ios_base::sync_with_stdio(0), cin.tie(NULL))
|
||||||
|
|
||||||
|
// add declarations to avoid circular dependency
|
||||||
|
template<typename T, typename U> istream& operator>>(istream&, pair<T, U>&);
|
||||||
|
template<typename T, typename U> ostream& operator<<(ostream&, const pair<T, U>&);
|
||||||
|
template<typename T, size_t N> istream& operator>>(istream&, array<T, N>&);
|
||||||
|
template <typename T, size_t N> ostream& operator<<(ostream&, const array<T, N>&);
|
||||||
|
template<typename Char, typename Traits, typename... Args>
|
||||||
|
decltype(auto) operator<<(std::basic_ostream<Char, Traits>&, const std::tuple<Args...>&);
|
||||||
|
template<typename T> ostream& operator<<(ostream&, const vector<T>&);
|
||||||
|
std::ostream& operator<<(std::ostream&, const int128&);
|
||||||
|
|
||||||
|
template<typename T, typename U> istream& operator>>(istream& in, pair<T, U>& p) {
|
||||||
|
return in >> p.first >> p.second;
|
||||||
|
}
|
||||||
|
template<typename T, typename U> ostream& operator<<(ostream& out, const pair<T, U>& p) {
|
||||||
|
out << "{" << p.first << ", " << p.second << "}";
|
||||||
|
return out;
|
||||||
|
}
|
||||||
|
template<typename T, size_t N> istream& operator>>(istream& in, array<T, N>& a) {
|
||||||
|
for (size_t i = 0; i < N; ++i) in >> a[i];
|
||||||
|
return in;
|
||||||
|
}
|
||||||
|
template <typename T, size_t N> ostream& operator<<(ostream& out, const array<T, N>& a) {
|
||||||
|
for (auto&& i : a) out << i << ' ';
|
||||||
|
return out;
|
||||||
|
}
|
||||||
|
template<typename Char, typename Traits, typename Tuple, std::size_t... Index>
|
||||||
|
void print_tuple_impl(std::basic_ostream<Char, Traits>& os, const Tuple& t, std::index_sequence<Index...>) {
|
||||||
|
using swallow = int[]; // guaranties left to right order
|
||||||
|
(void)swallow { 0, (void(os << (Index == 0 ? "" : ", ") << std::get<Index>(t)), 0)... };
|
||||||
|
}
|
||||||
|
template<typename Char, typename Traits, typename... Args>
|
||||||
|
decltype(auto) operator<<(std::basic_ostream<Char, Traits>& os, const std::tuple<Args...>& t) {
|
||||||
|
os << "{";
|
||||||
|
print_tuple_impl(os, t, std::index_sequence_for<Args...>{});
|
||||||
|
return os << "}";
|
||||||
|
}
|
||||||
|
template<typename T> ostream& operator<<(ostream& out, const vector<T>& vec) {
|
||||||
|
for (auto&& i : vec) out << i << ' ';
|
||||||
|
return out;
|
||||||
|
}
|
||||||
|
std::ostream& operator<<(std::ostream& dest, const int128& value) {
|
||||||
|
// https://stackoverflow.com/a/25115163/23881100
|
||||||
|
std::ostream::sentry s( dest );
|
||||||
|
if ( s ) {
|
||||||
|
uint128 tmp = value < 0 ? -value : value;
|
||||||
|
char buffer[ 128 ];
|
||||||
|
char* d = std::end( buffer );
|
||||||
|
do {
|
||||||
|
-- d;
|
||||||
|
*d = "0123456789"[ tmp % 10 ];
|
||||||
|
tmp /= 10;
|
||||||
|
} while ( tmp != 0 );
|
||||||
|
if ( value < 0 ) {
|
||||||
|
-- d;
|
||||||
|
*d = '-';
|
||||||
|
}
|
||||||
|
int len = std::end( buffer ) - d;
|
||||||
|
if ( dest.rdbuf()->sputn( d, len ) != len ) {
|
||||||
|
dest.setstate( std::ios_base::badbit );
|
||||||
|
}
|
||||||
|
}
|
||||||
|
return dest;
|
||||||
|
}
|
||||||
|
template<typename T> void __read(T& x) { cin >> x; }
|
||||||
|
template<typename T, typename... U> void __read(T& x, U&... args) { cin >> x; __read(args...); }
|
||||||
|
#define read(t, ...) __AS_PROCEDURE(argument_type<void(t)>::type __VA_ARGS__; __read(__VA_ARGS__);)
|
||||||
|
#define readvec(t, a, n) __AS_PROCEDURE(vector<argument_type<void(t)>::type> a(n); for (auto& x : (a)) cin >> x;)
|
||||||
|
#define readvec1(t, a, n) __AS_PROCEDURE(vector<argument_type<void(t)>::type> a((n) + 1); copy_n(ii<argument_type<void(t)>::type>(cin), (n), (a).begin() + 1);)
|
||||||
|
#define putvec(a) __AS_PROCEDURE(copy((a).begin(), (a).end(), oi<__as_typeof(a)::value_type>(cout, " ")); cout << endl;)
|
||||||
|
#define putvec1(a) __AS_PROCEDURE(copy((a).begin() + 1, (a).end(), oi<__as_typeof(a)::value_type>(cout, " ")); cout << endl;)
|
||||||
|
#define putvec_eol(a) __AS_PROCEDURE(copy((a).begin(), (a).end(), oi<__as_typeof(a)::value_type>(cout, "\n"));)
|
||||||
|
#define putvec1_eol(a) __AS_PROCEDURE(copy((a).begin() + 1, (a).end(), oi<__as_typeof(a)::value_type>(cout, "\n"));)
|
||||||
|
#define debug(x) __AS_PROCEDURE(cerr << #x" = " << (x) << endl;)
|
||||||
|
#define debugvec(a) __AS_PROCEDURE(cerr << #a" = "; for (auto&& x : (a)) cerr << x << ' '; cerr << endl;)
|
||||||
|
#define deb(...) debug(make_tuple(__VA_ARGS__))
|
||||||
|
|
||||||
|
/* pops */
|
||||||
|
template <typename Container>
|
||||||
|
inline auto poptop(Container& q) {
|
||||||
|
auto ret = q.top();
|
||||||
|
q.pop();
|
||||||
|
return ret;
|
||||||
|
}
|
||||||
|
template <typename Container>
|
||||||
|
inline auto popback(Container& q) {
|
||||||
|
auto ret = q.back();
|
||||||
|
q.pop_back();
|
||||||
|
return ret;
|
||||||
|
}
|
||||||
|
template <typename Container>
|
||||||
|
inline auto popfront(Container& q) {
|
||||||
|
auto ret = q.front();
|
||||||
|
q.pop_front();
|
||||||
|
return ret;
|
||||||
|
}
|
||||||
|
|
||||||
|
/* math */
|
||||||
|
template <typename return_t>
|
||||||
|
return_t qpow(ll b, ll p) {
|
||||||
|
if (b == 0 and p != 0) return 0;
|
||||||
|
if (p == 0) return 1;
|
||||||
|
return_t half = qpow<return_t>(b, p / 2);
|
||||||
|
if (p % 2 == 1) return half * half * b;
|
||||||
|
else return half * half;
|
||||||
|
}
|
||||||
|
|
||||||
|
// dynamic modulus
|
||||||
|
ll qpow(ll b, ll p, ll mod) {
|
||||||
|
if (b == 0 and p != 0) return 0;
|
||||||
|
if (p == 0) return 1;
|
||||||
|
ll half = qpow(b, p / 2, mod);
|
||||||
|
if (p % 2 == 1) return (int128(half) * half % mod) * b % mod;
|
||||||
|
else return half * half % mod;
|
||||||
|
}
|
||||||
|
|
||||||
|
|
||||||
|
#pragma GCC diagnostic push
|
||||||
|
#pragma GCC diagnostic ignored "-Wparentheses"
|
||||||
|
// Accurately find `i` 'th root of `n` (taking the floor)
|
||||||
|
inline ll root(ll n, ll i) {
|
||||||
|
ll l = 0, r = pow(LLONG_MAX, (long double)(1) / i);
|
||||||
|
while (l < r) {
|
||||||
|
ll mid = l + r + 1 >> 1;
|
||||||
|
if (qpow<int128>(mid, i) <= n) {
|
||||||
|
l = mid;
|
||||||
|
} else {
|
||||||
|
r = mid - 1;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
return l;
|
||||||
|
}
|
||||||
|
#pragma GCC diagnostic pop
|
||||||
|
|
||||||
|
|
||||||
|
#define comb(n, k) ((n) < 0 or (k) < 0 or (n) < (k) ? 0 : fact[n] / fact[k] / fact[(n) - (k)])
|
||||||
|
#define fastcomb(n, k) ((n) < 0 or (k) < 0 or (n) < (k) ? 0 : fact[n] * factrev[k] * factrev[(n) - (k)])
|
||||||
|
|
||||||
|
__attribute__((target("lzcnt")))
|
||||||
|
constexpr inline int lg2(ll x) { return x == 0 ? -1 : sizeof(ll) * 8 - 1 - __builtin_clzll(x); }
|
||||||
|
|
||||||
|
template <typename T>
|
||||||
|
T mygcd(T a, T b) { return b == 0 ? a : mygcd(b, a % b); }
|
||||||
|
|
||||||
|
void __exgcd(ll a, ll b, ll& x, ll& y) {
|
||||||
|
if (b == 0) {
|
||||||
|
x = 1, y = 0;
|
||||||
|
return;
|
||||||
|
}
|
||||||
|
__exgcd(b, a % b, y, x);
|
||||||
|
y -= a / b * x;
|
||||||
|
}
|
||||||
|
|
||||||
|
ll inverse(ll a, ll b) {
|
||||||
|
ll x, y;
|
||||||
|
__exgcd(a, b, x, y);
|
||||||
|
return mod(x, b);
|
||||||
|
}
|
||||||
|
|
||||||
|
vector<tuple<int, int, ll>> decompose(ll x) {
|
||||||
|
// return (factor, count, factor ** count)
|
||||||
|
vector<tuple<int, int, ll>> res;
|
||||||
|
for (int i = 2; i * i <= x; i++) {
|
||||||
|
if (x % i == 0) {
|
||||||
|
int cnt = 0;
|
||||||
|
ll pw = 1;
|
||||||
|
while (x % i == 0) ++cnt, x /= i, pw *= i;
|
||||||
|
res.emplace_back(i, cnt, pw);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
if (x != 1) {
|
||||||
|
res.emplace_back(x, 1, x);
|
||||||
|
}
|
||||||
|
return res;
|
||||||
|
}
|
||||||
|
|
||||||
|
vector<pii> decompose_prime(int N) {
|
||||||
|
// return (factor, count)
|
||||||
|
vector<pii> result;
|
||||||
|
for (int i = 2; i * i <= N; i++) {
|
||||||
|
if (N % i == 0) {
|
||||||
|
int cnt = 0;
|
||||||
|
while (N % i == 0) N /= i, ++cnt;
|
||||||
|
result.emplace_back(i, cnt);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
if (N != 1) {
|
||||||
|
result.emplace_back(N, 1);
|
||||||
|
}
|
||||||
|
return result;
|
||||||
|
}
|
||||||
|
|
||||||
|
/* string algorithms */
|
||||||
|
vector<int> calc_next(string t) { // pi function of t
|
||||||
|
int n = (int)t.length();
|
||||||
|
vector<int> pi(n);
|
||||||
|
for (int i = 1; i < n; i++) {
|
||||||
|
int j = pi[i - 1];
|
||||||
|
while (j > 0 && t[i] != t[j]) j = pi[j - 1];
|
||||||
|
if (t[i] == t[j]) j++;
|
||||||
|
pi[i] = j;
|
||||||
|
}
|
||||||
|
return pi;
|
||||||
|
}
|
||||||
|
vector<int> calc_z(string t) { // z function of t
|
||||||
|
int m = t.length();
|
||||||
|
vector<int> z;
|
||||||
|
z.push_back(m);
|
||||||
|
pair<int, int> prev = {1, -1};
|
||||||
|
for (int i = 1; i < m; ++i) {
|
||||||
|
if (z[i - prev.first] + i <= prev.second) {
|
||||||
|
z.push_back(z[i - prev.first]);
|
||||||
|
} else {
|
||||||
|
int j = max(i, prev.second + 1);
|
||||||
|
while (j < m && t[j] == t[j - i]) ++j;
|
||||||
|
z.push_back(j - i);
|
||||||
|
prev = {i, j - 1};
|
||||||
|
}
|
||||||
|
}
|
||||||
|
return z;
|
||||||
|
}
|
||||||
|
vector<int> kmp(const string& s, const string& t) { // find all t in s
|
||||||
|
string cur = t + '#' + s;
|
||||||
|
int sz1 = s.size(), sz2 = t.size();
|
||||||
|
vector<int> v;
|
||||||
|
vector<int> lps = calc_next(cur);
|
||||||
|
for (int i = sz2 + 1; i <= sz1 + sz2; i++) {
|
||||||
|
if (lps[i] == sz2) v.push_back(i - 2 * sz2);
|
||||||
|
}
|
||||||
|
return v;
|
||||||
|
}
|
||||||
|
int period(const string& s) { // find the length of shortest recurring period
|
||||||
|
int n = s.length();
|
||||||
|
auto z = calc_z(s);
|
||||||
|
for (int i = 1; i <= n / 2; ++i) {
|
||||||
|
if (n % i == 0 && z[i] == n - i) {
|
||||||
|
return i;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
return n;
|
||||||
|
}
|
||||||
|
|
||||||
|
/* modular arithmetic */
|
||||||
|
template <ll mdl> struct MLL {
|
||||||
|
ll val;
|
||||||
|
MLL(ll v = 0) : val(mod(v, mdl)) {}
|
||||||
|
MLL(const MLL<mdl>& other) : val(other.val) {}
|
||||||
|
friend MLL operator+(const MLL& lhs, const MLL& rhs) { return mod(lhs.val + rhs.val, mdl); }
|
||||||
|
friend MLL operator-(const MLL& lhs, const MLL& rhs) { return mod(lhs.val - rhs.val, mdl); }
|
||||||
|
friend MLL operator*(const MLL& lhs, const MLL& rhs) { return mod(int128(lhs.val) * rhs.val, mdl); }
|
||||||
|
friend MLL operator/(const MLL& lhs, const MLL& rhs) { return lhs * mod(inverse(rhs.val, mdl), mdl); }
|
||||||
|
friend MLL operator%(const MLL& lhs, const MLL& rhs) { return mod(lhs.val - (lhs / rhs).val, mdl); }
|
||||||
|
friend bool operator==(const MLL& lhs, const MLL& rhs) { return lhs.val == rhs.val; }
|
||||||
|
friend bool operator!=(const MLL& lhs, const MLL& rhs) { return lhs.val != rhs.val; }
|
||||||
|
MLL& operator+=(const MLL& rhs) { return *this = *this + rhs; }
|
||||||
|
MLL& operator-=(const MLL& rhs) { return *this = *this - rhs; }
|
||||||
|
MLL& operator*=(const MLL& rhs) { return *this = *this * rhs; }
|
||||||
|
MLL& operator/=(const MLL& rhs) { return *this = *this / rhs; }
|
||||||
|
MLL& operator%=(const MLL& rhs) { return *this = *this % rhs; }
|
||||||
|
};
|
||||||
|
|
||||||
|
template <ll mdl>
|
||||||
|
ostream& operator<<(ostream& out, const MLL<mdl>& num) {
|
||||||
|
return out << num.val;
|
||||||
|
}
|
||||||
|
|
||||||
|
template <ll mdl>
|
||||||
|
istream& operator>>(istream& in, MLL<mdl>& num) {
|
||||||
|
return in >> num.val;
|
||||||
|
}
|
||||||
|
|
||||||
|
// miscancellous
|
||||||
|
template <typename T, typename U>
|
||||||
|
bool chmax(T& lhs, const U& rhs) {
|
||||||
|
bool ret = lhs < rhs;
|
||||||
|
if (ret) {
|
||||||
|
lhs = rhs;
|
||||||
|
}
|
||||||
|
return ret;
|
||||||
|
}
|
||||||
|
template <typename T, typename U>
|
||||||
|
bool chmin(T& lhs, const U& rhs) {
|
||||||
|
bool ret = lhs > rhs;
|
||||||
|
if (ret) {
|
||||||
|
lhs = rhs;
|
||||||
|
}
|
||||||
|
return ret;
|
||||||
|
}
|
||||||
|
|
||||||
|
#define functor(func) ([&](auto&&... val) \
|
||||||
|
noexcept(noexcept(func(std::forward<decltype(val)>(val)...))) -> decltype(auto) \
|
||||||
|
{return func(std::forward<decltype(val)>(val)...);})
|
||||||
|
#define expr(ret, ...) ([&] (__VA_ARGS__) { return (ret); })
|
||||||
|
template <typename Func, typename RandomIt> void sort_by_key(RandomIt first, RandomIt last, Func extractor) {
|
||||||
|
std::sort(first, last, [&] (auto&& a, auto&& b) { return std::less<>()(extractor(a), extractor(b)); });
|
||||||
|
}
|
||||||
|
template <typename Func, typename RandomIt, typename Compare> void sort_by_key(RandomIt first, RandomIt last, Func extractor, Compare comp) {
|
||||||
|
std::sort(first, last, [&] (auto&& a, auto&& b) { return comp(extractor(a), extractor(b)); });
|
||||||
|
}
|
||||||
|
template <typename T, typename U, typename Iterator_T, typename Iterator_U>
|
||||||
|
vector<pair<T, U>> zip(Iterator_T a_first, Iterator_T a_last, Iterator_U b_first, Iterator_U b_last) {
|
||||||
|
vector<pair<T, U>> res;
|
||||||
|
auto a_it = a_first;
|
||||||
|
auto b_it = b_first;
|
||||||
|
for (; not (a_it == a_last) and not (b_it == b_last); ++a_it, ++b_it) {
|
||||||
|
res.emplace_back(*a_it, *b_it);
|
||||||
|
}
|
||||||
|
return res;
|
||||||
|
}
|
||||||
|
template <typename T, typename U, typename Iterator_T, typename Iterator_U>
|
||||||
|
vector<pair<T, U>> zip_n(Iterator_T a_first, Iterator_U b_first, size_t n) {
|
||||||
|
vector<pair<T, U>> res;
|
||||||
|
if (n > 0) {
|
||||||
|
res.emplace_back(*a_first, *b_first);
|
||||||
|
for (size_t i = 1; i != n; ++i) {
|
||||||
|
res.emplace_back(*++a_first, *++b_first);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
return res;
|
||||||
|
}
|
||||||
|
template <typename T>
|
||||||
|
class ArithmeticIterator : bidirectional_iterator_tag {
|
||||||
|
public:
|
||||||
|
using difference_type = ptrdiff_t;
|
||||||
|
using value_type = T;
|
||||||
|
private:
|
||||||
|
value_type value;
|
||||||
|
public:
|
||||||
|
ArithmeticIterator(const T& value) : value(value) {}
|
||||||
|
value_type operator*() const { return value; }
|
||||||
|
ArithmeticIterator<T>& operator++() { ++value; return *this; }
|
||||||
|
ArithmeticIterator<T>& operator--() { --value; return *this; }
|
||||||
|
bool operator==(const ArithmeticIterator<T>& rhs) const { return value == rhs.value; }
|
||||||
|
};
|
||||||
|
template <typename T> vector<pair<int, T>> enumerate(const vector<T>& container) {
|
||||||
|
return zip<int, T>(ArithmeticIterator<int>(0), ArithmeticIterator<int>(INT_MAX), container.begin(), container.end());
|
||||||
|
}
|
||||||
|
#define initarray(init, N) (__initarray<decay<decltype(init)>::type, (N)>(init))
|
||||||
|
namespace detail {
|
||||||
|
template <typename T, std::size_t...Is>
|
||||||
|
constexpr std::array<T, sizeof...(Is)>
|
||||||
|
make_array(const T& value, std::index_sequence<Is...>) {
|
||||||
|
return {{(static_cast<void>(Is), value)...}};
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
template <typename T, std::size_t N>
|
||||||
|
constexpr std::array<T, N> __initarray(const T& value) {
|
||||||
|
return detail::make_array(value, std::make_index_sequence<N>());
|
||||||
|
}
|
||||||
|
/*******************************************************/
|
||||||
|
|
||||||
|
#define SINGLE_TEST_CASE
|
||||||
|
// #define DUMP_TEST_CASE 7219
|
||||||
|
// #define TOT_TEST_CASE 10000
|
||||||
|
|
||||||
|
void dump() {}
|
||||||
|
|
||||||
|
void dump_ignore() {}
|
||||||
|
|
||||||
|
void prep() {}
|
||||||
|
|
||||||
|
// __attribute__((target("popcnt")))
|
||||||
|
void solve() {
|
||||||
|
read(int, n, m);
|
||||||
|
if (m == 1) {
|
||||||
|
cout << 0 << '\n';
|
||||||
|
return;
|
||||||
|
}
|
||||||
|
vector<ll> md(n + 1);
|
||||||
|
for (int i = 1; i <= n; ++i) {
|
||||||
|
md[i] = qpow(i, m, PRIME);
|
||||||
|
}
|
||||||
|
ll res = 0;
|
||||||
|
for (int i = 1; i < n; ++i) {
|
||||||
|
ll all = md[i + 1];
|
||||||
|
ll one = 2 * md[i] % PRIME;
|
||||||
|
ll none = i - 1 <= 0 ? 0 : md[i - 1];
|
||||||
|
res += ll(1) * ((n - i) * mod(all - one + none, PRIME) % PRIME) * (ll(1) * i * i % PRIME) % PRIME;
|
||||||
|
res %= PRIME;
|
||||||
|
}
|
||||||
|
cout << res << '\n';
|
||||||
|
}
|
||||||
|
|
||||||
|
int main() {
|
||||||
|
#if __cplusplus < 201402L or defined(_MSC_VER) and not defined(__clang__)
|
||||||
|
static_assert(false, "incompatible compiler variant detected.");
|
||||||
|
#endif
|
||||||
|
untie;
|
||||||
|
prep();
|
||||||
|
#ifdef SINGLE_TEST_CASE
|
||||||
|
solve();
|
||||||
|
#else
|
||||||
|
read(int, t);
|
||||||
|
for (int i = 0; i < t; ++i) {
|
||||||
|
#ifdef DUMP_TEST_CASE
|
||||||
|
if (t != (TOT_TEST_CASE)) {
|
||||||
|
solve();
|
||||||
|
} else if (i + 1 == (DUMP_TEST_CASE)) {
|
||||||
|
dump();
|
||||||
|
} else {
|
||||||
|
dump_ignore();
|
||||||
|
}
|
||||||
|
#else
|
||||||
|
solve();
|
||||||
|
#endif
|
||||||
|
}
|
||||||
|
#endif
|
||||||
|
}
|
|
@ -0,0 +1,627 @@
|
||||||
|
// #pragma GCC target("popcnt,lzcnt,abm,bmi,bmi2")
|
||||||
|
#pragma GCC optimize("Ofast,unroll-loops")
|
||||||
|
/************* This code requires C++17. ***************/
|
||||||
|
|
||||||
|
#include<bits/stdc++.h>
|
||||||
|
using namespace std;
|
||||||
|
|
||||||
|
/* macro helpers */
|
||||||
|
#define __NARGS(...) std::tuple_size<decltype(std::make_tuple(__VA_ARGS__))>::value
|
||||||
|
#define __DECOMPOSE_S(a, x) auto x = a;
|
||||||
|
#define __DECOMPOSE_N(a, ...) auto [__VA_ARGS__] = a;
|
||||||
|
constexpr void __() {}
|
||||||
|
#define __AS_PROCEDURE(...) __(); __VA_ARGS__; __()
|
||||||
|
#define __as_typeof(container) remove_reference<decltype(container)>::type
|
||||||
|
template <typename T> struct argument_type;
|
||||||
|
template <typename T, typename U> struct argument_type<T(U)> { using type = U; };
|
||||||
|
|
||||||
|
/* type aliases */
|
||||||
|
#if LONG_LONG_MAX != INT64_MAX
|
||||||
|
using ll = int64_t;
|
||||||
|
using ull = uint64_t;
|
||||||
|
#else
|
||||||
|
using ll = long long;
|
||||||
|
using ull = unsigned long long;
|
||||||
|
#endif
|
||||||
|
using int128 = __int128_t;
|
||||||
|
using uint128 = __uint128_t;
|
||||||
|
using ld = __float128; // up to 1e-9 precision in binary search
|
||||||
|
using pii = pair<int, int>; using pil = pair<int, ll>; using pid = pair<int, ld>;
|
||||||
|
using pli = pair<ll, int>; using pll = pair<ll, ll>; using pld = pair<ll, ld>;
|
||||||
|
using pdi = pair<ld, int>; using pdl = pair<ld, ll>; using pdd = pair<ld, ld>;
|
||||||
|
using tiii = tuple<int, int, int>; using tiil = tuple<int, int, ll>; using tiid = tuple<int, int, ld>;
|
||||||
|
using tili = tuple<int, ll, int>; using till = tuple<int, ll, ll>; using tild = tuple<int, ll, ld>;
|
||||||
|
using tidi = tuple<int, ld, int>; using tidl = tuple<int, ld, ll>; using tidd = tuple<int, ld, ld>;
|
||||||
|
using tlii = tuple<ll, int, int>; using tlil = tuple<ll, int, ll>; using tlid = tuple<ll, int, ld>;
|
||||||
|
using tlli = tuple<ll, ll, int>; using tlll = tuple<ll, ll, ll>; using tlld = tuple<ll, ll, ld>;
|
||||||
|
using tldi = tuple<ll, ld, int>; using tldl = tuple<ll, ld, ll>; using tldd = tuple<ll, ld, ld>;
|
||||||
|
using tdii = tuple<ld, int, int>; using tdil = tuple<ld, int, ll>; using tdid = tuple<ld, int, ld>;
|
||||||
|
using tdli = tuple<ld, ll, int>; using tdll = tuple<ld, ll, ll>; using tdld = tuple<ld, ll, ld>;
|
||||||
|
using tddi = tuple<ld, ld, int>; using tddl = tuple<ld, ld, ll>; using tddd = tuple<ld, ld, ld>;
|
||||||
|
template <typename T> using max_heap = priority_queue<T>;
|
||||||
|
template <typename T> using min_heap = priority_queue<T, vector<T>, greater<>>;
|
||||||
|
template <typename T> using oi = ostream_iterator<T>;
|
||||||
|
template <typename T> using ii = istream_iterator<T>;
|
||||||
|
|
||||||
|
/* constants */
|
||||||
|
constexpr int INF = 0x3f3f3f3f;
|
||||||
|
constexpr ll INFLL = 0x3f3f3f3f3f3f3f3fLL;
|
||||||
|
constexpr ll MDL = 1e9 + 7;
|
||||||
|
constexpr ll PRIME = 998'244'353;
|
||||||
|
constexpr ll PRIMELL = 901017227882342239LL;
|
||||||
|
constexpr ll MDL1 = 8784491;
|
||||||
|
constexpr ll MDL2 = PRIME;
|
||||||
|
constexpr int128 INT128_MAX = numeric_limits<int128>::max();
|
||||||
|
constexpr uint128 UINT128_MAX = numeric_limits<uint128>::max();
|
||||||
|
constexpr int128 INT128_MIN = numeric_limits<int128>::min();
|
||||||
|
constexpr uint128 UINT128_MIN = numeric_limits<uint128>::min();
|
||||||
|
|
||||||
|
/* random */
|
||||||
|
|
||||||
|
mt19937_64 rd(chrono::duration_cast<chrono::milliseconds>(chrono::system_clock::now().time_since_epoch()).count());
|
||||||
|
|
||||||
|
/* bit-wise operations */
|
||||||
|
#define lowbit(x) ((x) & -(x))
|
||||||
|
#define popcount(x) (__builtin_popcountll(ll(x)))
|
||||||
|
#define parity(x) (__builtin_parityll(ll(x)))
|
||||||
|
#define msp(x) (63LL - __builtin_clzll(ll(x)))
|
||||||
|
#define lsp(x) (__builtin_ctzll(ll(x)))
|
||||||
|
|
||||||
|
/* arithmetic operations */
|
||||||
|
#define mod(x, y) ((((x) % (y)) + (y)) % (y))
|
||||||
|
|
||||||
|
/* fast pairs */
|
||||||
|
#define upair ull
|
||||||
|
#define umake(x, y) (ull(x) << 32 | (ull(y) & ((1ULL << 32) - 1)))
|
||||||
|
#define u1(p) ((p) >> 32)
|
||||||
|
#define u2(p) ((p) & ((1ULL << 32) - 1))
|
||||||
|
#define ult std::less<upair>
|
||||||
|
#define ugt std::greater<upair>
|
||||||
|
|
||||||
|
#define ipair ull
|
||||||
|
#define imake(x, y) (umake(x, y))
|
||||||
|
#define i1(p) (int(u1(ll(p))))
|
||||||
|
#define i2(p) (ll(u2(p) << 32) >> 32)
|
||||||
|
struct ilt {
|
||||||
|
bool operator()(const ipair& a, const ipair& b) const {
|
||||||
|
if (i1(a) == i1(b)) return i2(a) < i2(b);
|
||||||
|
else return i1(a) < i1(b);
|
||||||
|
}
|
||||||
|
};
|
||||||
|
struct igt {
|
||||||
|
bool operator()(const ipair& a, const ipair& b) const {
|
||||||
|
if (i1(a) == i1(b)) return i2(a) > i2(b);
|
||||||
|
else return i1(a) > i1(b);
|
||||||
|
}
|
||||||
|
};
|
||||||
|
|
||||||
|
/* conditions */
|
||||||
|
#define loop while (1)
|
||||||
|
#define if_or(var, val) if (!((var) == (val))) (var) = (val); else
|
||||||
|
#define continue_or(var, val) __AS_PROCEDURE(if ((var) == (val)) continue; (var) = (val);)
|
||||||
|
#define break_or(var, val) __AS_PROCEDURE(if ((var) == (val)) break; (var) = (val);)
|
||||||
|
|
||||||
|
/* hash */
|
||||||
|
struct safe_hash {
|
||||||
|
// https://codeforces.com/blog/entry/62393
|
||||||
|
static uint64_t splitmix64(uint64_t x) {
|
||||||
|
// http://xorshift.di.unimi.it/splitmix64.c
|
||||||
|
x += 0x9e3779b97f4a7c15;
|
||||||
|
x = (x ^ (x >> 30)) * 0xbf58476d1ce4e5b9;
|
||||||
|
x = (x ^ (x >> 27)) * 0x94d049bb133111eb;
|
||||||
|
return x ^ (x >> 31);
|
||||||
|
}
|
||||||
|
|
||||||
|
size_t operator()(uint64_t x) const {
|
||||||
|
static const uint64_t FIXED_RANDOM = chrono::steady_clock::now().time_since_epoch().count();
|
||||||
|
return splitmix64(x + FIXED_RANDOM);
|
||||||
|
}
|
||||||
|
};
|
||||||
|
|
||||||
|
struct pair_hash {
|
||||||
|
template <typename T, typename U>
|
||||||
|
size_t operator()(const pair<T, U>& a) const {
|
||||||
|
auto hash1 = safe_hash()(a.first);
|
||||||
|
auto hash2 = safe_hash()(a.second);
|
||||||
|
if (hash1 != hash2) {
|
||||||
|
return hash1 ^ hash2;
|
||||||
|
}
|
||||||
|
return hash1;
|
||||||
|
}
|
||||||
|
};
|
||||||
|
|
||||||
|
uniform_int_distribution<mt19937::result_type> dist(PRIME);
|
||||||
|
const size_t __array_hash_b = 31, __array_hash_mdl1 = dist(rd), __array_hash_mdl2 = dist(rd);
|
||||||
|
struct array_hash {
|
||||||
|
safe_hash hasher;
|
||||||
|
template <typename Sequence>
|
||||||
|
size_t operator()(const Sequence& arr) const {
|
||||||
|
size_t pw1 = 1, pw2 = 1;
|
||||||
|
size_t res1 = 0, res2 = 0;
|
||||||
|
for (auto&& x : arr) {
|
||||||
|
auto h = hasher(x);
|
||||||
|
res1 = (res1 + h * pw1) % __array_hash_mdl1;
|
||||||
|
res2 = (res2 + h * pw2) % __array_hash_mdl2;
|
||||||
|
pw1 = (pw1 * __array_hash_b) % __array_hash_mdl1;
|
||||||
|
pw2 = (pw2 * __array_hash_b) % __array_hash_mdl2;
|
||||||
|
}
|
||||||
|
return res1 + res2;
|
||||||
|
}
|
||||||
|
};
|
||||||
|
|
||||||
|
/* build data structures */
|
||||||
|
#define faster(um) __AS_PROCEDURE((um).reserve(1024); (um).max_load_factor(0.25);)
|
||||||
|
#define unordered_counter(from, to) __AS_PROCEDURE(unordered_map<__as_typeof(from), size_t, safe_hash> to; for (auto&& x : from) ++to[x];)
|
||||||
|
#define counter(from, to, cmp) __AS_PROCEDURE(map<__as_typeof(from), size_t, cmp> to; for (auto&& x : from) ++to[x];)
|
||||||
|
#define adj(ch, n) __AS_PROCEDURE(vector<vector<int>> ch((n) + 1);)
|
||||||
|
#define edge(ch, u, v) __AS_PROCEDURE(ch[u].push_back(v), ch[v].push_back(u);)
|
||||||
|
#define edgew(ch, u, v, ...) __AS_PROCEDURE(ch[u].emplace_back(v, __VA_ARGS__), ch[v].emplace_back(u, __VA_ARGS__);)
|
||||||
|
#define Edge(ch, u, v) __AS_PROCEDURE(ch[u].push_back(v);)
|
||||||
|
#define Edgew(ch, u, v, ...) __AS_PROCEDURE(ch[u].emplace_back(v, __VA_ARGS__);)
|
||||||
|
template <typename T, typename Iterator> pair<size_t, map<T, size_t>> discretize(Iterator __first, Iterator __last) {
|
||||||
|
set<T> st(__first, __last);
|
||||||
|
size_t N = 0;
|
||||||
|
map<T, size_t> mp;
|
||||||
|
for (auto&& x : st) mp[x] = ++N;
|
||||||
|
return {N, mp};
|
||||||
|
}
|
||||||
|
template <typename T, typename Iterator> pair<size_t, unordered_map<T, size_t, safe_hash>> unordered_discretize(Iterator __first, Iterator __last) {
|
||||||
|
set<T> st(__first, __last);
|
||||||
|
size_t N = 0;
|
||||||
|
unordered_map<T, size_t, safe_hash> mp;
|
||||||
|
for (auto&& x : st) mp[x] = ++N;
|
||||||
|
return {N, mp};
|
||||||
|
}
|
||||||
|
|
||||||
|
/* io */
|
||||||
|
#define untie __AS_PROCEDURE(ios_base::sync_with_stdio(0), cin.tie(NULL))
|
||||||
|
|
||||||
|
// add declarations to avoid circular dependency
|
||||||
|
template<typename T, typename U> istream& operator>>(istream&, pair<T, U>&);
|
||||||
|
template<typename T, typename U> ostream& operator<<(ostream&, const pair<T, U>&);
|
||||||
|
template<typename T, size_t N> istream& operator>>(istream&, array<T, N>&);
|
||||||
|
template <typename T, size_t N> ostream& operator<<(ostream&, const array<T, N>&);
|
||||||
|
template<typename Char, typename Traits, typename... Args>
|
||||||
|
decltype(auto) operator<<(std::basic_ostream<Char, Traits>&, const std::tuple<Args...>&);
|
||||||
|
template<typename T> ostream& operator<<(ostream&, const vector<T>&);
|
||||||
|
std::ostream& operator<<(std::ostream&, const int128&);
|
||||||
|
|
||||||
|
template<typename T, typename U> istream& operator>>(istream& in, pair<T, U>& p) {
|
||||||
|
return in >> p.first >> p.second;
|
||||||
|
}
|
||||||
|
template<typename T, typename U> ostream& operator<<(ostream& out, const pair<T, U>& p) {
|
||||||
|
out << "{" << p.first << ", " << p.second << "}";
|
||||||
|
return out;
|
||||||
|
}
|
||||||
|
template<typename T, size_t N> istream& operator>>(istream& in, array<T, N>& a) {
|
||||||
|
for (size_t i = 0; i < N; ++i) in >> a[i];
|
||||||
|
return in;
|
||||||
|
}
|
||||||
|
template <typename T, size_t N> ostream& operator<<(ostream& out, const array<T, N>& a) {
|
||||||
|
for (auto&& i : a) out << i << ' ';
|
||||||
|
return out;
|
||||||
|
}
|
||||||
|
template<typename Char, typename Traits, typename Tuple, std::size_t... Index>
|
||||||
|
void print_tuple_impl(std::basic_ostream<Char, Traits>& os, const Tuple& t, std::index_sequence<Index...>) {
|
||||||
|
using swallow = int[]; // guaranties left to right order
|
||||||
|
(void)swallow { 0, (void(os << (Index == 0 ? "" : ", ") << std::get<Index>(t)), 0)... };
|
||||||
|
}
|
||||||
|
template<typename Char, typename Traits, typename... Args>
|
||||||
|
decltype(auto) operator<<(std::basic_ostream<Char, Traits>& os, const std::tuple<Args...>& t) {
|
||||||
|
os << "{";
|
||||||
|
print_tuple_impl(os, t, std::index_sequence_for<Args...>{});
|
||||||
|
return os << "}";
|
||||||
|
}
|
||||||
|
template<typename T> ostream& operator<<(ostream& out, const vector<T>& vec) {
|
||||||
|
for (auto&& i : vec) out << i << ' ';
|
||||||
|
return out;
|
||||||
|
}
|
||||||
|
std::ostream& operator<<(std::ostream& dest, const int128& value) {
|
||||||
|
// https://stackoverflow.com/a/25115163/23881100
|
||||||
|
std::ostream::sentry s( dest );
|
||||||
|
if ( s ) {
|
||||||
|
uint128 tmp = value < 0 ? -value : value;
|
||||||
|
char buffer[ 128 ];
|
||||||
|
char* d = std::end( buffer );
|
||||||
|
do {
|
||||||
|
-- d;
|
||||||
|
*d = "0123456789"[ tmp % 10 ];
|
||||||
|
tmp /= 10;
|
||||||
|
} while ( tmp != 0 );
|
||||||
|
if ( value < 0 ) {
|
||||||
|
-- d;
|
||||||
|
*d = '-';
|
||||||
|
}
|
||||||
|
int len = std::end( buffer ) - d;
|
||||||
|
if ( dest.rdbuf()->sputn( d, len ) != len ) {
|
||||||
|
dest.setstate( std::ios_base::badbit );
|
||||||
|
}
|
||||||
|
}
|
||||||
|
return dest;
|
||||||
|
}
|
||||||
|
template<typename T> void __read(T& x) { cin >> x; }
|
||||||
|
template<typename T, typename... U> void __read(T& x, U&... args) { cin >> x; __read(args...); }
|
||||||
|
#define read(t, ...) __AS_PROCEDURE(argument_type<void(t)>::type __VA_ARGS__; __read(__VA_ARGS__);)
|
||||||
|
#define readvec(t, a, n) __AS_PROCEDURE(vector<argument_type<void(t)>::type> a(n); for (auto& x : (a)) cin >> x;)
|
||||||
|
#define readvec1(t, a, n) __AS_PROCEDURE(vector<argument_type<void(t)>::type> a((n) + 1); copy_n(ii<argument_type<void(t)>::type>(cin), (n), (a).begin() + 1);)
|
||||||
|
#define putvec(a) __AS_PROCEDURE(copy((a).begin(), (a).end(), oi<__as_typeof(a)::value_type>(cout, " ")); cout << endl;)
|
||||||
|
#define putvec1(a) __AS_PROCEDURE(copy((a).begin() + 1, (a).end(), oi<__as_typeof(a)::value_type>(cout, " ")); cout << endl;)
|
||||||
|
#define putvec_eol(a) __AS_PROCEDURE(copy((a).begin(), (a).end(), oi<__as_typeof(a)::value_type>(cout, "\n"));)
|
||||||
|
#define putvec1_eol(a) __AS_PROCEDURE(copy((a).begin() + 1, (a).end(), oi<__as_typeof(a)::value_type>(cout, "\n"));)
|
||||||
|
#define debug(x) __AS_PROCEDURE(cerr << #x" = " << (x) << endl;)
|
||||||
|
#define debugvec(a) __AS_PROCEDURE(cerr << #a" = "; for (auto&& x : (a)) cerr << x << ' '; cerr << endl;)
|
||||||
|
#define deb(...) debug(make_tuple(__VA_ARGS__))
|
||||||
|
|
||||||
|
/* pops */
|
||||||
|
template <typename Container>
|
||||||
|
inline auto poptop(Container& q) {
|
||||||
|
auto ret = q.top();
|
||||||
|
q.pop();
|
||||||
|
return ret;
|
||||||
|
}
|
||||||
|
template <typename Container>
|
||||||
|
inline auto popback(Container& q) {
|
||||||
|
auto ret = q.back();
|
||||||
|
q.pop_back();
|
||||||
|
return ret;
|
||||||
|
}
|
||||||
|
template <typename Container>
|
||||||
|
inline auto popfront(Container& q) {
|
||||||
|
auto ret = q.front();
|
||||||
|
q.pop_front();
|
||||||
|
return ret;
|
||||||
|
}
|
||||||
|
|
||||||
|
/* math */
|
||||||
|
template <typename return_t>
|
||||||
|
return_t qpow(ll b, ll p) {
|
||||||
|
if (b == 0 and p != 0) return 0;
|
||||||
|
if (p == 0) return 1;
|
||||||
|
return_t half = qpow<return_t>(b, p / 2);
|
||||||
|
if (p % 2 == 1) return half * half * b;
|
||||||
|
else return half * half;
|
||||||
|
}
|
||||||
|
|
||||||
|
// dynamic modulus
|
||||||
|
ll qpow(ll b, ll p, ll mod) {
|
||||||
|
if (b == 0 and p != 0) return 0;
|
||||||
|
if (p == 0) return 1;
|
||||||
|
ll half = qpow(b, p / 2, mod);
|
||||||
|
if (p % 2 == 1) return (int128(half) * half % mod) * b % mod;
|
||||||
|
else return half * half % mod;
|
||||||
|
}
|
||||||
|
|
||||||
|
|
||||||
|
#pragma GCC diagnostic push
|
||||||
|
#pragma GCC diagnostic ignored "-Wparentheses"
|
||||||
|
// Accurately find `i` 'th root of `n` (taking the floor)
|
||||||
|
inline ll root(ll n, ll i) {
|
||||||
|
ll l = 0, r = pow(LLONG_MAX, (long double)(1) / i);
|
||||||
|
while (l < r) {
|
||||||
|
ll mid = l + r + 1 >> 1;
|
||||||
|
if (qpow<int128>(mid, i) <= n) {
|
||||||
|
l = mid;
|
||||||
|
} else {
|
||||||
|
r = mid - 1;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
return l;
|
||||||
|
}
|
||||||
|
#pragma GCC diagnostic pop
|
||||||
|
|
||||||
|
|
||||||
|
#define comb(n, k) ((n) < 0 or (k) < 0 or (n) < (k) ? 0 : fact[n] / fact[k] / fact[(n) - (k)])
|
||||||
|
#define fastcomb(n, k) ((n) < 0 or (k) < 0 or (n) < (k) ? 0 : fact[n] * factrev[k] * factrev[(n) - (k)])
|
||||||
|
|
||||||
|
__attribute__((target("lzcnt")))
|
||||||
|
constexpr inline int lg2(ll x) { return x == 0 ? -1 : sizeof(ll) * 8 - 1 - __builtin_clzll(x); }
|
||||||
|
|
||||||
|
template <typename T>
|
||||||
|
T mygcd(T a, T b) { return b == 0 ? a : mygcd(b, a % b); }
|
||||||
|
|
||||||
|
void __exgcd(ll a, ll b, ll& x, ll& y) {
|
||||||
|
if (b == 0) {
|
||||||
|
x = 1, y = 0;
|
||||||
|
return;
|
||||||
|
}
|
||||||
|
__exgcd(b, a % b, y, x);
|
||||||
|
y -= a / b * x;
|
||||||
|
}
|
||||||
|
|
||||||
|
ll inverse(ll a, ll b) {
|
||||||
|
ll x, y;
|
||||||
|
__exgcd(a, b, x, y);
|
||||||
|
return mod(x, b);
|
||||||
|
}
|
||||||
|
|
||||||
|
vector<tuple<int, int, ll>> decompose(ll x) {
|
||||||
|
// return (factor, count, factor ** count)
|
||||||
|
vector<tuple<int, int, ll>> res;
|
||||||
|
for (int i = 2; i * i <= x; i++) {
|
||||||
|
if (x % i == 0) {
|
||||||
|
int cnt = 0;
|
||||||
|
ll pw = 1;
|
||||||
|
while (x % i == 0) ++cnt, x /= i, pw *= i;
|
||||||
|
res.emplace_back(i, cnt, pw);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
if (x != 1) {
|
||||||
|
res.emplace_back(x, 1, x);
|
||||||
|
}
|
||||||
|
return res;
|
||||||
|
}
|
||||||
|
|
||||||
|
vector<pii> decompose_prime(int N) {
|
||||||
|
// return (factor, count)
|
||||||
|
vector<pii> result;
|
||||||
|
for (int i = 2; i * i <= N; i++) {
|
||||||
|
if (N % i == 0) {
|
||||||
|
int cnt = 0;
|
||||||
|
while (N % i == 0) N /= i, ++cnt;
|
||||||
|
result.emplace_back(i, cnt);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
if (N != 1) {
|
||||||
|
result.emplace_back(N, 1);
|
||||||
|
}
|
||||||
|
return result;
|
||||||
|
}
|
||||||
|
|
||||||
|
/* string algorithms */
|
||||||
|
vector<int> calc_next(string t) { // pi function of t
|
||||||
|
int n = (int)t.length();
|
||||||
|
vector<int> pi(n);
|
||||||
|
for (int i = 1; i < n; i++) {
|
||||||
|
int j = pi[i - 1];
|
||||||
|
while (j > 0 && t[i] != t[j]) j = pi[j - 1];
|
||||||
|
if (t[i] == t[j]) j++;
|
||||||
|
pi[i] = j;
|
||||||
|
}
|
||||||
|
return pi;
|
||||||
|
}
|
||||||
|
vector<int> calc_z(string t) { // z function of t
|
||||||
|
int m = t.length();
|
||||||
|
vector<int> z;
|
||||||
|
z.push_back(m);
|
||||||
|
pair<int, int> prev = {1, -1};
|
||||||
|
for (int i = 1; i < m; ++i) {
|
||||||
|
if (z[i - prev.first] + i <= prev.second) {
|
||||||
|
z.push_back(z[i - prev.first]);
|
||||||
|
} else {
|
||||||
|
int j = max(i, prev.second + 1);
|
||||||
|
while (j < m && t[j] == t[j - i]) ++j;
|
||||||
|
z.push_back(j - i);
|
||||||
|
prev = {i, j - 1};
|
||||||
|
}
|
||||||
|
}
|
||||||
|
return z;
|
||||||
|
}
|
||||||
|
vector<int> kmp(const string& s, const string& t) { // find all t in s
|
||||||
|
string cur = t + '#' + s;
|
||||||
|
int sz1 = s.size(), sz2 = t.size();
|
||||||
|
vector<int> v;
|
||||||
|
vector<int> lps = calc_next(cur);
|
||||||
|
for (int i = sz2 + 1; i <= sz1 + sz2; i++) {
|
||||||
|
if (lps[i] == sz2) v.push_back(i - 2 * sz2);
|
||||||
|
}
|
||||||
|
return v;
|
||||||
|
}
|
||||||
|
int period(const string& s) { // find the length of shortest recurring period
|
||||||
|
int n = s.length();
|
||||||
|
auto z = calc_z(s);
|
||||||
|
for (int i = 1; i <= n / 2; ++i) {
|
||||||
|
if (n % i == 0 && z[i] == n - i) {
|
||||||
|
return i;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
return n;
|
||||||
|
}
|
||||||
|
|
||||||
|
/* modular arithmetic */
|
||||||
|
template <ll mdl> struct MLL {
|
||||||
|
ll val;
|
||||||
|
MLL(ll v = 0) : val(mod(v, mdl)) {}
|
||||||
|
MLL(const MLL<mdl>& other) : val(other.val) {}
|
||||||
|
friend MLL operator+(const MLL& lhs, const MLL& rhs) { return mod(lhs.val + rhs.val, mdl); }
|
||||||
|
friend MLL operator-(const MLL& lhs, const MLL& rhs) { return mod(lhs.val - rhs.val, mdl); }
|
||||||
|
friend MLL operator*(const MLL& lhs, const MLL& rhs) { return mod(int128(lhs.val) * rhs.val, mdl); }
|
||||||
|
friend MLL operator/(const MLL& lhs, const MLL& rhs) { return lhs * mod(inverse(rhs.val, mdl), mdl); }
|
||||||
|
friend MLL operator%(const MLL& lhs, const MLL& rhs) { return mod(lhs.val - (lhs / rhs).val, mdl); }
|
||||||
|
friend bool operator==(const MLL& lhs, const MLL& rhs) { return lhs.val == rhs.val; }
|
||||||
|
friend bool operator!=(const MLL& lhs, const MLL& rhs) { return lhs.val != rhs.val; }
|
||||||
|
MLL& operator+=(const MLL& rhs) { return *this = *this + rhs; }
|
||||||
|
MLL& operator-=(const MLL& rhs) { return *this = *this - rhs; }
|
||||||
|
MLL& operator*=(const MLL& rhs) { return *this = *this * rhs; }
|
||||||
|
MLL& operator/=(const MLL& rhs) { return *this = *this / rhs; }
|
||||||
|
MLL& operator%=(const MLL& rhs) { return *this = *this % rhs; }
|
||||||
|
};
|
||||||
|
|
||||||
|
template <ll mdl>
|
||||||
|
ostream& operator<<(ostream& out, const MLL<mdl>& num) {
|
||||||
|
return out << num.val;
|
||||||
|
}
|
||||||
|
|
||||||
|
template <ll mdl>
|
||||||
|
istream& operator>>(istream& in, MLL<mdl>& num) {
|
||||||
|
return in >> num.val;
|
||||||
|
}
|
||||||
|
|
||||||
|
// miscancellous
|
||||||
|
template <typename T, typename U>
|
||||||
|
bool chmax(T& lhs, const U& rhs) {
|
||||||
|
bool ret = lhs < rhs;
|
||||||
|
if (ret) {
|
||||||
|
lhs = rhs;
|
||||||
|
}
|
||||||
|
return ret;
|
||||||
|
}
|
||||||
|
template <typename T, typename U>
|
||||||
|
bool chmin(T& lhs, const U& rhs) {
|
||||||
|
bool ret = lhs > rhs;
|
||||||
|
if (ret) {
|
||||||
|
lhs = rhs;
|
||||||
|
}
|
||||||
|
return ret;
|
||||||
|
}
|
||||||
|
|
||||||
|
#define functor(func) ([&](auto&&... val) \
|
||||||
|
noexcept(noexcept(func(std::forward<decltype(val)>(val)...))) -> decltype(auto) \
|
||||||
|
{return func(std::forward<decltype(val)>(val)...);})
|
||||||
|
#define expr(ret, ...) ([&] (__VA_ARGS__) { return (ret); })
|
||||||
|
template <typename Func, typename RandomIt> void sort_by_key(RandomIt first, RandomIt last, Func extractor) {
|
||||||
|
std::sort(first, last, [&] (auto&& a, auto&& b) { return std::less<>()(extractor(a), extractor(b)); });
|
||||||
|
}
|
||||||
|
template <typename Func, typename RandomIt, typename Compare> void sort_by_key(RandomIt first, RandomIt last, Func extractor, Compare comp) {
|
||||||
|
std::sort(first, last, [&] (auto&& a, auto&& b) { return comp(extractor(a), extractor(b)); });
|
||||||
|
}
|
||||||
|
template <typename T, typename U, typename Iterator_T, typename Iterator_U>
|
||||||
|
vector<pair<T, U>> zip(Iterator_T a_first, Iterator_T a_last, Iterator_U b_first, Iterator_U b_last) {
|
||||||
|
vector<pair<T, U>> res;
|
||||||
|
auto a_it = a_first;
|
||||||
|
auto b_it = b_first;
|
||||||
|
for (; not (a_it == a_last) and not (b_it == b_last); ++a_it, ++b_it) {
|
||||||
|
res.emplace_back(*a_it, *b_it);
|
||||||
|
}
|
||||||
|
return res;
|
||||||
|
}
|
||||||
|
template <typename T, typename U, typename Iterator_T, typename Iterator_U>
|
||||||
|
vector<pair<T, U>> zip_n(Iterator_T a_first, Iterator_U b_first, size_t n) {
|
||||||
|
vector<pair<T, U>> res;
|
||||||
|
if (n > 0) {
|
||||||
|
res.emplace_back(*a_first, *b_first);
|
||||||
|
for (size_t i = 1; i != n; ++i) {
|
||||||
|
res.emplace_back(*++a_first, *++b_first);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
return res;
|
||||||
|
}
|
||||||
|
template <typename T>
|
||||||
|
class ArithmeticIterator : bidirectional_iterator_tag {
|
||||||
|
public:
|
||||||
|
using difference_type = ptrdiff_t;
|
||||||
|
using value_type = T;
|
||||||
|
private:
|
||||||
|
value_type value;
|
||||||
|
public:
|
||||||
|
ArithmeticIterator(const T& value) : value(value) {}
|
||||||
|
value_type operator*() const { return value; }
|
||||||
|
ArithmeticIterator<T>& operator++() { ++value; return *this; }
|
||||||
|
ArithmeticIterator<T>& operator--() { --value; return *this; }
|
||||||
|
bool operator==(const ArithmeticIterator<T>& rhs) const { return value == rhs.value; }
|
||||||
|
};
|
||||||
|
template <typename T> vector<pair<int, T>> enumerate(const vector<T>& container) {
|
||||||
|
return zip<int, T>(ArithmeticIterator<int>(0), ArithmeticIterator<int>(INT_MAX), container.begin(), container.end());
|
||||||
|
}
|
||||||
|
#define initarray(init, N) (__initarray<decay<decltype(init)>::type, (N)>(init))
|
||||||
|
namespace detail {
|
||||||
|
template <typename T, std::size_t...Is>
|
||||||
|
constexpr std::array<T, sizeof...(Is)>
|
||||||
|
make_array(const T& value, std::index_sequence<Is...>) {
|
||||||
|
return {{(static_cast<void>(Is), value)...}};
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
template <typename T, std::size_t N>
|
||||||
|
constexpr std::array<T, N> __initarray(const T& value) {
|
||||||
|
return detail::make_array(value, std::make_index_sequence<N>());
|
||||||
|
}
|
||||||
|
/*******************************************************/
|
||||||
|
|
||||||
|
#define SINGLE_TEST_CASE
|
||||||
|
// #define DUMP_TEST_CASE 7219
|
||||||
|
// #define TOT_TEST_CASE 10000
|
||||||
|
|
||||||
|
void dump() {}
|
||||||
|
|
||||||
|
void dump_ignore() {}
|
||||||
|
|
||||||
|
void prep() {
|
||||||
|
}
|
||||||
|
|
||||||
|
// __attribute__((target("popcnt")))
|
||||||
|
void solve() {
|
||||||
|
read(int, n, m);
|
||||||
|
readvec(int, a, n);
|
||||||
|
readvec(int, b, m);
|
||||||
|
|
||||||
|
vector res(n, vector<int>(m));
|
||||||
|
for (int i = 0; i < n; ++i) {
|
||||||
|
for (int j = 0; j < m; ++j) {
|
||||||
|
res[i][j] = b[j];
|
||||||
|
}
|
||||||
|
}
|
||||||
|
int g = 0;
|
||||||
|
for (int i = 0; i < n; ++i) {
|
||||||
|
g = g == 0 ? a[i] : gcd(g, a[i]);
|
||||||
|
}
|
||||||
|
ll l = 1;
|
||||||
|
for (int j = 0; j < m; ++j) {
|
||||||
|
l = lcm(l, ll(1) * b[j]);
|
||||||
|
if (l > 1e9) {
|
||||||
|
cout << "No\n";
|
||||||
|
return;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
if (g % l != 0) {
|
||||||
|
cout << "No\n";
|
||||||
|
return;
|
||||||
|
}
|
||||||
|
int col = 0, dir = 1;
|
||||||
|
for (int i = 0; i < n; ++i) {
|
||||||
|
if (l == a[i]) continue;
|
||||||
|
res[i][col] = a[i];
|
||||||
|
col += dir;
|
||||||
|
if (col == m) {
|
||||||
|
col = max(0, m - 2);
|
||||||
|
dir = -dir;
|
||||||
|
} else if (col == -1) {
|
||||||
|
col = min(m - 1, 1);
|
||||||
|
dir = -dir;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
for (int j = 0; j < m; ++j) {
|
||||||
|
int g = 0;
|
||||||
|
for (int i = 0; i < n; ++i) {
|
||||||
|
g = g == 0 ? res[i][j] : gcd(g, res[i][j]);
|
||||||
|
}
|
||||||
|
if (g != b[j]) {
|
||||||
|
cout << "No\n";
|
||||||
|
return;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
cout << "Yes\n";
|
||||||
|
for (int i = 0; i < n; ++i) {
|
||||||
|
for (int j = 0; j < m; ++j) {
|
||||||
|
cout << res[i][j] << ' ';
|
||||||
|
}
|
||||||
|
cout << '\n';
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
int main() {
|
||||||
|
#if __cplusplus < 201402L or defined(_MSC_VER) and not defined(__clang__)
|
||||||
|
static_assert(false, "incompatible compiler variant detected.");
|
||||||
|
#endif
|
||||||
|
untie;
|
||||||
|
prep();
|
||||||
|
#ifdef SINGLE_TEST_CASE
|
||||||
|
solve();
|
||||||
|
#else
|
||||||
|
read(int, t);
|
||||||
|
for (int i = 0; i < t; ++i) {
|
||||||
|
#ifdef DUMP_TEST_CASE
|
||||||
|
if (t != (TOT_TEST_CASE)) {
|
||||||
|
solve();
|
||||||
|
} else if (i + 1 == (DUMP_TEST_CASE)) {
|
||||||
|
dump();
|
||||||
|
} else {
|
||||||
|
dump_ignore();
|
||||||
|
}
|
||||||
|
#else
|
||||||
|
solve();
|
||||||
|
#endif
|
||||||
|
}
|
||||||
|
#endif
|
||||||
|
}
|
|
@ -1 +1,7 @@
|
||||||
aaaaaaaaaa
|
6 16
|
||||||
|
10 9
|
||||||
|
10 5 1
|
||||||
|
12 2 1
|
||||||
|
20 18 3
|
||||||
|
10 2 3
|
||||||
|
2 1 5
|
||||||
|
|
|
@ -8,8 +8,10 @@ import io
|
||||||
PRIME = 998_244_353
|
PRIME = 998_244_353
|
||||||
|
|
||||||
if __name__ == '__main__':
|
if __name__ == '__main__':
|
||||||
N = 50
|
N = 5000
|
||||||
print(N)
|
M = 10 ** 9
|
||||||
|
print(N, M)
|
||||||
|
print(10, 9)
|
||||||
for i in range(2, N + 1):
|
for i in range(2, N + 1):
|
||||||
print(f'{randint(1, i - 1)} {i} {randint(100000000, 999999999)}')
|
print(10, 9, 1)
|
||||||
print(f'1 50 {randint(100000000, 999999999)}')
|
|
||||||
|
|
Loading…
Reference in New Issue