From 083819b0dd80ecf2c68df04620c645341ea34172 Mon Sep 17 00:00:00 2001 From: subcrip Date: Wed, 5 Jun 2024 23:48:41 +0800 Subject: [PATCH] backup --- src/bin/.nvim.lua | 14 +- src/bin/a.cc | 55 ++-- src/bin/a.out | Bin 2375832 -> 2405192 bytes src/bin/b.cc | 70 +++-- src/bin/c.cc | 106 +++---- src/bin/cf-1615d.cc | 727 +++++++++++++++++++++++++++++++++++++++++++ src/bin/cf-1617d2.cc | 609 ++++++++++++++++++++++++++++++++++++ src/bin/cf-1619g.cc | 660 +++++++++++++++++++++++++++++++++++++++ src/bin/cf-1689d.cc | 688 ++++++++++++++++++++++++++++++++++++++++ src/bin/cf-1692h.cc | 542 ++++++++++++++++++++++++++++++++ src/bin/cf-1693b.cc | 553 ++++++++++++++++++++++++++++++++ src/bin/cf-1702f.cc | 550 ++++++++++++++++++++++++++++++++ src/bin/cf-1703g.cc | 546 ++++++++++++++++++++++++++++++++ src/bin/cf-1707b.cc | 580 ++++++++++++++++++++++++++++++++++ src/bin/cf-1709c.cc | 579 ++++++++++++++++++++++++++++++++++ src/bin/cf-1980d.cc | 556 +++++++++++++++++++++++++++++++++ src/bin/cf-1980e.cc | 663 +++++++++++++++++++++++++++++++++++++++ src/bin/cf-1980f1.cc | 611 ++++++++++++++++++++++++++++++++++++ src/bin/cf-1980f2.cc | 610 ++++++++++++++++++++++++++++++++++++ src/bin/cf-1980g.cc | 653 ++++++++++++++++++++++++++++++++++++++ src/bin/ctext_out.cc | 115 +++---- src/bin/d.cc | 163 +++------- src/bin/e.cc | 284 ++++++++++++++--- src/bin/f.cc | 210 +++++++++++-- src/bin/f1.cc | 611 ++++++++++++++++++++++++++++++++++++ src/bin/f2.cc | 603 +++++++++++++++++++++++++++++++++++ src/bin/std.in | 40 ++- src/bin/test.cc | 702 +---------------------------------------- src/bin/test.py | 10 +- 29 files changed, 11062 insertions(+), 1048 deletions(-) create mode 100644 src/bin/cf-1615d.cc create mode 100644 src/bin/cf-1617d2.cc create mode 100644 src/bin/cf-1619g.cc create mode 100644 src/bin/cf-1689d.cc create mode 100644 src/bin/cf-1692h.cc create mode 100644 src/bin/cf-1693b.cc create mode 100644 src/bin/cf-1702f.cc create mode 100644 src/bin/cf-1703g.cc create mode 100644 src/bin/cf-1707b.cc create mode 100644 src/bin/cf-1709c.cc create mode 100644 src/bin/cf-1980d.cc create mode 100644 src/bin/cf-1980e.cc create mode 100644 src/bin/cf-1980f1.cc create mode 100644 src/bin/cf-1980f2.cc create mode 100644 src/bin/cf-1980g.cc create mode 100644 src/bin/f1.cc create mode 100644 src/bin/f2.cc diff --git a/src/bin/.nvim.lua b/src/bin/.nvim.lua index 3783e19..a297068 100644 --- a/src/bin/.nvim.lua +++ b/src/bin/.nvim.lua @@ -75,10 +75,10 @@ local function add_timestamp() vim.api.nvim_buf_set_lines(bufnr, 0, -1, false, lines) end -vim.api.nvim_create_autocmd( - "BufWritePre", - { - pattern = "*.cc", - callback = add_timestamp, - } -) +-- vim.api.nvim_create_autocmd( +-- "BufWritePre", +-- { +-- pattern = "*.cc", +-- callback = add_timestamp, +-- } +-- ) diff --git a/src/bin/a.cc b/src/bin/a.cc index 7834781..a89e47a 100644 --- a/src/bin/a.cc +++ b/src/bin/a.cc @@ -1,16 +1,15 @@ /** * Author: subcrip - * Created: 2024-05-27 20:22:28 - * Modified: 2024-05-27 20:23:19 - * Elapsed: 0 minutes + * Created: 2024-06-03 22:38:12 + * Modified: 2024-06-03 22:39:28 + * Elapsed: 1 minutes */ #pragma GCC optimize("Ofast") ///////////////////////////////////////////////////////// /** - * Useful Macros - * by subcrip - * (requires C++17) + * This code should require C++14. + * However, it's only been tested with C++17. */ #include @@ -181,6 +180,7 @@ struct array_hash { }; /* 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 pa(a) __AS_PROCEDURE(__typeof(a) pa; pa.push_back({}); for (auto&&x : a) pa.push_back(pa.back() + x);) @@ -270,6 +270,17 @@ std::ostream& operator<<(std::ostream& dest, const int128& value) { #define popfront(q, ...) __AS_PROCEDURE(auto [__VA_ARGS__] = q.front();q.pop_front();) /* math */ +template +return_t qpow(ll b, ll p) { + if (b == 0 and p != 0) return 0; + if (p == 0) return 1; + return_t half = qpow(b, p / 2); + if (p % 2 == 1) return half * half * b; + else return half * half; +} + +#define comb(n, k) ((n) < 0 or (k) < 0 or (n) < (k) ? 0 : fact[n] / fact[k] / fact[(n) - (k)]) + constexpr inline int lg2(ll x) { return x == 0 ? -1 : sizeof(ll) * 8 - 1 - __builtin_clzll(x); } void __exgcd(ll a, ll b, ll& x, ll& y) { @@ -391,12 +402,12 @@ template struct MLL { struct MLLd { ll val, mdl; MLLd(ll mdl, ll v = 0) : mdl(mdl), val(mod(v, mdl)) {} - MLLd(const MLLd& other) : val(other.val) {} - friend MLLd operator+(const MLLd& lhs, const MLLd& rhs) { return mod(lhs.val + rhs.val, lhs.mdl); } - friend MLLd operator-(const MLLd& lhs, const MLLd& rhs) { return mod(lhs.val - rhs.val, lhs.mdl); } - friend MLLd operator*(const MLLd& lhs, const MLLd& rhs) { return mod(lhs.val * rhs.val, lhs.mdl); } - friend MLLd operator/(const MLLd& lhs, const MLLd& rhs) { return mod(lhs.val * mod(inverse(rhs.val, lhs.mdl), lhs.mdl), lhs.mdl); } - friend MLLd operator%(const MLLd& lhs, const MLLd& rhs) { return mod(lhs.val - (lhs / rhs).val, lhs.mdl); } + MLLd(const MLLd& other) : mdl(other.mdl), val(other.val) {} + friend MLLd operator+(const MLLd& lhs, const MLLd& rhs) { return MLLd(lhs.mdl, mod(lhs.val + rhs.val, lhs.mdl)); } + friend MLLd operator-(const MLLd& lhs, const MLLd& rhs) { return MLLd(lhs.mdl, mod(lhs.val - rhs.val, lhs.mdl)); } + friend MLLd operator*(const MLLd& lhs, const MLLd& rhs) { return MLLd(lhs.mdl, mod(lhs.val * rhs.val, lhs.mdl)); } + friend MLLd operator/(const MLLd& lhs, const MLLd& rhs) { return MLLd(lhs.mdl, mod(lhs.val * mod(inverse(rhs.val, lhs.mdl), lhs.mdl), lhs.mdl)); } + friend MLLd operator%(const MLLd& lhs, const MLLd& rhs) { return MLLd(lhs.mdl, mod(lhs.val - (lhs / rhs).val, lhs.mdl)); } friend bool operator==(const MLLd& lhs, const MLLd& rhs) { return lhs.val == rhs.val; } friend bool operator!=(const MLLd& lhs, const MLLd& rhs) { return lhs.val != rhs.val; } void operator+=(const MLLd& rhs) { val = (*this + rhs).val; } @@ -425,6 +436,9 @@ istream& operator>>(istream& in, MLLd& num) { } // miscancellous +#define functor(func) [&](auto&&... val) \ +noexcept(noexcept(func(std::forward(val)...))) -> decltype(auto) \ +{return func(std::forward(val)...);} template 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)); }); } @@ -484,18 +498,23 @@ void prep() { void solve() { read(int, n, m); - if ((n + m) % 2 == 0 and n >= m) { - cout << "Yes\n"; - } else { - cout << "No\n"; + read(string, s); + array cnt = {}; + for (auto&& x : s) { + cnt[x - 'A'] += 1; } + int res = 0; + for (int i = 0; i < 7; ++i) { + res += max(0, m - cnt[i]); + } + cout << res << '\n'; } int main() { -#if __cplusplus < 201703L 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."); #endif - untie, cout.tie(NULL); + untie; prep(); #ifdef SINGLE_TEST_CASE solve(); diff --git a/src/bin/a.out b/src/bin/a.out index 8114a4ef3d4d25d56a2be7a67f54199a23da7890..f36b593be7a0aadec8684d4f9d01aee42931e053 100755 GIT binary patch delta 730918 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�T>AqI%FL#SH{I0jKK2mB3H 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 delta 704382 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 @@ -181,6 +180,7 @@ struct array_hash { }; /* 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 pa(a) __AS_PROCEDURE(__typeof(a) pa; pa.push_back({}); for (auto&&x : a) pa.push_back(pa.back() + x);) @@ -270,6 +270,17 @@ std::ostream& operator<<(std::ostream& dest, const int128& value) { #define popfront(q, ...) __AS_PROCEDURE(auto [__VA_ARGS__] = q.front();q.pop_front();) /* math */ +template +return_t qpow(ll b, ll p) { + if (b == 0 and p != 0) return 0; + if (p == 0) return 1; + return_t half = qpow(b, p / 2); + if (p % 2 == 1) return half * half * b; + else return half * half; +} + +#define comb(n, k) ((n) < 0 or (k) < 0 or (n) < (k) ? 0 : fact[n] / fact[k] / fact[(n) - (k)]) + constexpr inline int lg2(ll x) { return x == 0 ? -1 : sizeof(ll) * 8 - 1 - __builtin_clzll(x); } void __exgcd(ll a, ll b, ll& x, ll& y) { @@ -391,12 +402,12 @@ template struct MLL { struct MLLd { ll val, mdl; MLLd(ll mdl, ll v = 0) : mdl(mdl), val(mod(v, mdl)) {} - MLLd(const MLLd& other) : val(other.val) {} - friend MLLd operator+(const MLLd& lhs, const MLLd& rhs) { return mod(lhs.val + rhs.val, lhs.mdl); } - friend MLLd operator-(const MLLd& lhs, const MLLd& rhs) { return mod(lhs.val - rhs.val, lhs.mdl); } - friend MLLd operator*(const MLLd& lhs, const MLLd& rhs) { return mod(lhs.val * rhs.val, lhs.mdl); } - friend MLLd operator/(const MLLd& lhs, const MLLd& rhs) { return mod(lhs.val * mod(inverse(rhs.val, lhs.mdl), lhs.mdl), lhs.mdl); } - friend MLLd operator%(const MLLd& lhs, const MLLd& rhs) { return mod(lhs.val - (lhs / rhs).val, lhs.mdl); } + MLLd(const MLLd& other) : mdl(other.mdl), val(other.val) {} + friend MLLd operator+(const MLLd& lhs, const MLLd& rhs) { return MLLd(lhs.mdl, mod(lhs.val + rhs.val, lhs.mdl)); } + friend MLLd operator-(const MLLd& lhs, const MLLd& rhs) { return MLLd(lhs.mdl, mod(lhs.val - rhs.val, lhs.mdl)); } + friend MLLd operator*(const MLLd& lhs, const MLLd& rhs) { return MLLd(lhs.mdl, mod(lhs.val * rhs.val, lhs.mdl)); } + friend MLLd operator/(const MLLd& lhs, const MLLd& rhs) { return MLLd(lhs.mdl, mod(lhs.val * mod(inverse(rhs.val, lhs.mdl), lhs.mdl), lhs.mdl)); } + friend MLLd operator%(const MLLd& lhs, const MLLd& rhs) { return MLLd(lhs.mdl, mod(lhs.val - (lhs / rhs).val, lhs.mdl)); } friend bool operator==(const MLLd& lhs, const MLLd& rhs) { return lhs.val == rhs.val; } friend bool operator!=(const MLLd& lhs, const MLLd& rhs) { return lhs.val != rhs.val; } void operator+=(const MLLd& rhs) { val = (*this + rhs).val; } @@ -425,6 +436,9 @@ istream& operator>>(istream& in, MLLd& num) { } // miscancellous +#define functor(func) [&](auto&&... val) \ +noexcept(noexcept(func(std::forward(val)...))) -> decltype(auto) \ +{return func(std::forward(val)...);} template 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)); }); } @@ -483,31 +497,27 @@ void prep() { } void solve() { - read(int, x); - vector res; - int prev = 0; - for (int i = 0; i <= 31; ++i) { - int curr = x >> i & 1; - int carry = 0; - if (curr + prev == 1 and res.size() and res.back() == 1) { - carry = 1; - res.back() = -1; - res.emplace_back(0); - } else { - carry = (curr + prev) / 2; - res.emplace_back((curr + prev) % 2); - } - prev = carry; + read(int, n, f, k); + readvec(int,a ,n); + f = a[f - 1]; + sort(a.begin(), a.end(), greater()); + int yes = 0, no = 0; + if (a[k - 1] > f) { + cout << "NO\n"; + } else if (a[k - 1] < f) { + cout << "YES\n"; + } else if (k <= n - 1 and a[k] == f) { + cout << "MAYBE\n"; + } else { + cout << "YES\n"; } - cout << res.size() << '\n'; - putvec(res); } int main() { -#if __cplusplus < 201703L 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."); #endif - untie, cout.tie(NULL); + untie; prep(); #ifdef SINGLE_TEST_CASE solve(); diff --git a/src/bin/c.cc b/src/bin/c.cc index 278b7db..8bdcc68 100644 --- a/src/bin/c.cc +++ b/src/bin/c.cc @@ -1,16 +1,15 @@ /** * Author: subcrip - * Created: 2024-05-27 20:38:48 - * Modified: 2024-05-27 20:46:39 - * Elapsed: 7 minutes + * Created: 2024-06-03 22:48:29 + * Modified: 2024-06-03 23:01:57 + * Elapsed: 13 minutes */ #pragma GCC optimize("Ofast") ///////////////////////////////////////////////////////// /** - * Useful Macros - * by subcrip - * (requires C++17) + * This code should require C++14. + * However, it's only been tested with C++17. */ #include @@ -181,6 +180,7 @@ struct array_hash { }; /* 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 pa(a) __AS_PROCEDURE(__typeof(a) pa; pa.push_back({}); for (auto&&x : a) pa.push_back(pa.back() + x);) @@ -270,6 +270,17 @@ std::ostream& operator<<(std::ostream& dest, const int128& value) { #define popfront(q, ...) __AS_PROCEDURE(auto [__VA_ARGS__] = q.front();q.pop_front();) /* math */ +template +return_t qpow(ll b, ll p) { + if (b == 0 and p != 0) return 0; + if (p == 0) return 1; + return_t half = qpow(b, p / 2); + if (p % 2 == 1) return half * half * b; + else return half * half; +} + +#define comb(n, k) ((n) < 0 or (k) < 0 or (n) < (k) ? 0 : fact[n] / fact[k] / fact[(n) - (k)]) + constexpr inline int lg2(ll x) { return x == 0 ? -1 : sizeof(ll) * 8 - 1 - __builtin_clzll(x); } void __exgcd(ll a, ll b, ll& x, ll& y) { @@ -391,12 +402,12 @@ template struct MLL { struct MLLd { ll val, mdl; MLLd(ll mdl, ll v = 0) : mdl(mdl), val(mod(v, mdl)) {} - MLLd(const MLLd& other) : val(other.val) {} - friend MLLd operator+(const MLLd& lhs, const MLLd& rhs) { return mod(lhs.val + rhs.val, lhs.mdl); } - friend MLLd operator-(const MLLd& lhs, const MLLd& rhs) { return mod(lhs.val - rhs.val, lhs.mdl); } - friend MLLd operator*(const MLLd& lhs, const MLLd& rhs) { return mod(lhs.val * rhs.val, lhs.mdl); } - friend MLLd operator/(const MLLd& lhs, const MLLd& rhs) { return mod(lhs.val * mod(inverse(rhs.val, lhs.mdl), lhs.mdl), lhs.mdl); } - friend MLLd operator%(const MLLd& lhs, const MLLd& rhs) { return mod(lhs.val - (lhs / rhs).val, lhs.mdl); } + MLLd(const MLLd& other) : mdl(other.mdl), val(other.val) {} + friend MLLd operator+(const MLLd& lhs, const MLLd& rhs) { return MLLd(lhs.mdl, mod(lhs.val + rhs.val, lhs.mdl)); } + friend MLLd operator-(const MLLd& lhs, const MLLd& rhs) { return MLLd(lhs.mdl, mod(lhs.val - rhs.val, lhs.mdl)); } + friend MLLd operator*(const MLLd& lhs, const MLLd& rhs) { return MLLd(lhs.mdl, mod(lhs.val * rhs.val, lhs.mdl)); } + friend MLLd operator/(const MLLd& lhs, const MLLd& rhs) { return MLLd(lhs.mdl, mod(lhs.val * mod(inverse(rhs.val, lhs.mdl), lhs.mdl), lhs.mdl)); } + friend MLLd operator%(const MLLd& lhs, const MLLd& rhs) { return MLLd(lhs.mdl, mod(lhs.val - (lhs / rhs).val, lhs.mdl)); } friend bool operator==(const MLLd& lhs, const MLLd& rhs) { return lhs.val == rhs.val; } friend bool operator!=(const MLLd& lhs, const MLLd& rhs) { return lhs.val != rhs.val; } void operator+=(const MLLd& rhs) { val = (*this + rhs).val; } @@ -425,6 +436,9 @@ istream& operator>>(istream& in, MLLd& num) { } // miscancellous +#define functor(func) [&](auto&&... val) \ +noexcept(noexcept(func(std::forward(val)...))) -> decltype(auto) \ +{return func(std::forward(val)...);} template 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)); }); } @@ -485,55 +499,43 @@ void prep() { void solve() { read(int, n); readvec(int, a, n); - sort(a.begin(), a.end()); - int f = 1; - for (int i = 0; i < n - 1; ++i) { - if (a[n - 1] % a[i] != 0) { - f = 0; - break; + readvec(int, b, n); + read(int, m); + unordered_map, safe_hash> cnt; + vector c(m); + unordered_set oc(b.begin(), b.end()); + for (int i = 0; i < m; ++i) { + read(int, x); + c[i] = x; + cnt[x].emplace_back(i); + } + vector res(m); + for (int i = 0; i < n; ++i) { + if (a[i] != b[i]) { + if (cnt[b[i]].empty()) { + cout << "NO\n"; + return; + } + cnt[b[i]].pop_back(); } } - if (not f) { - cout << n << '\n'; - } else { - int sq = sqrt(a[n - 1]); - set st; - for (int i = 1; i <= sq; ++i) { - if (a[n - 1] % i == 0) { - st.emplace(i); - st.emplace(a[n - 1] / i); - } + int f = 0; + for (int i = m - 1; ~i; --i) { + if (oc.count(c[i])) { + f = 1; + } else if (f == 0) { + cout << "NO\n"; + return; } - int N = 0; - unordered_map mp, rev; - for (auto&& x : st) mp[x] = ++N, rev[N] = x; - vector> dp(n + 1, vector(N + 1)); - for (int i = 1; i <= n; ++i) { - for (int j = 1; j <= N; ++j) { - dp[i][j] = dp[i - 1][j]; - } - for (int j = 1; j <= N; ++j) { - if (dp[i - 1][j] != 0) - dp[i][mp[lcm(a[i - 1], rev[j])]] = max(dp[i][mp[lcm(a[i - 1], rev[j])]], dp[i - 1][j] + 1); - } - dp[i][mp[a[i - 1]]] = max(dp[i][mp[a[i - 1]]], 1); - } - unordered_set nums(a.begin(), a.end()); - int res = 0; - for (int j = 1; j <= N; ++j) { - if (not nums.count(rev[j])) { - res = max(res, dp[n][j]); - } - } - cout << res << '\n'; } + cout << "YES\n"; } int main() { -#if __cplusplus < 201703L 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."); #endif - untie, cout.tie(NULL); + untie; prep(); #ifdef SINGLE_TEST_CASE solve(); diff --git a/src/bin/cf-1615d.cc b/src/bin/cf-1615d.cc new file mode 100644 index 0000000..db0cfcd --- /dev/null +++ b/src/bin/cf-1615d.cc @@ -0,0 +1,727 @@ +/** + * Author: subcrip + * Created: 2024-06-05 12:44:48 + * Modified: 2024-06-05 13:39:50 + * Elapsed: 55 minutes + */ + +#pragma GCC optimize("Ofast") +///////////////////////////////////////////////////////// +/** + * This code should require C++14. + * However, it's only been tested with C++17. + */ + +#include +using namespace std; + +/* macro helpers */ +#define __NARGS(...) std::tuple_size::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::type + +/* 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; +using ld = long double; +#endif +using int128 = __int128_t; +using uint128 = __uint128_t; +using ld = long double; +using pii = pair; +using pil = pair; +using pli = pair; +using pll = pair; +using pid = pair; +using pdi = pair; +using pld = pair; +using pdl = pair; +using pdd = pair; +using tlll = tuple; +using tlld = tuple; +using tlli = tuple; +using tldl = tuple; +using tldd = tuple; +using tldi = tuple; +using tlil = tuple; +using tlid = tuple; +using tlii = tuple; +using tdll = tuple; +using tdld = tuple; +using tdli = tuple; +using tddl = tuple; +using tddd = tuple; +using tddi = tuple; +using tdil = tuple; +using tdid = tuple; +using tdii = tuple; +using till = tuple; +using tild = tuple; +using tili = tuple; +using tidl = tuple; +using tidd = tuple; +using tidi = tuple; +using tiil = tuple; +using tiid = tuple; +using tiii = tuple; +template using max_heap = priority_queue; +template using min_heap = priority_queue, greater<>>; +template using oi = ostream_iterator; +template using ii = istream_iterator; + +/* constants */ +constexpr int INF = 0x3f3f3f3f; +constexpr ll INFLL = 0x3f3f3f3f3f3f3f3fLL; +constexpr ll MDL = 1e9 + 7; +constexpr ll PRIME = 998'244'353; +constexpr ll MDL1 = 8784491; +constexpr ll MDL2 = PRIME; +constexpr int128 INT128_MAX = numeric_limits::max(); +constexpr uint128 UINT128_MAX = numeric_limits::max(); +constexpr int128 INT128_MIN = numeric_limits::min(); +constexpr uint128 UINT128_MIN = numeric_limits::min(); + +/* random */ + +mt19937 rd(chrono::duration_cast(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 +#define ugt std::greater + +#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 + size_t operator()(const pair& 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 dist(PRIME); +const size_t __array_hash_b = 31, __array_hash_mdl1 = dist(rd), __array_hash_mdl2 = dist(rd); +struct array_hash { + template + size_t operator()(const Sequence& arr) const { + size_t pw1 = 1, pw2 = 1; + size_t res1 = 0, res2 = 0; + for (auto&& x : arr) { + res1 = (res1 + x * pw1) % __array_hash_mdl1; + res2 = (res2 + x * 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 pa(a) __AS_PROCEDURE(__typeof(a) pa; pa.push_back({}); for (auto&&x : a) pa.push_back(pa.back() + x);) +#define sa(a) __AS_PROCEDURE(__typeof(a) sa(a.size() + 1); {int n = a.size(); for (int i = n - 1; i >= 0; --i) sa[i] = sa[i + 1] + a[i];};) +#define adj(ch, n) __AS_PROCEDURE(vector> 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, w) __AS_PROCEDURE(ch[u].emplace_back(v, w), ch[v].emplace_back(u, w);) +#define Edge(ch, u, v) __AS_PROCEDURE(ch[u].push_back(v);) +#define Edgew(ch, u, v, w) __AS_PROCEDURE(ch[u].emplace_back(v, w);) +template pair> discretize(Iterator __first, Iterator __last) { + set st(__first, __last); + size_t N = 0; + map mp; + for (auto&& x : st) mp[x] = ++N; + return {N, mp}; +} +template pair> unordered_discretize(Iterator __first, Iterator __last) { + set st(__first, __last); + size_t N = 0; + unordered_map 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)) +template void __read(T& x) { cin >> x; } +template void __read(T& x, U&... args) { cin >> x; __read(args...); } +#define read(type, ...) __AS_PROCEDURE(type __VA_ARGS__; __read(__VA_ARGS__);) +#define readvec(type, a, n) __AS_PROCEDURE(vector a(n); for (auto& x : a) cin >> x;) +#define readvec1(type, a, n) __AS_PROCEDURE(vector a((n) + 1); copy_n(ii(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;) +template istream& operator>>(istream& in, pair& p) { + return in >> p.first >> p.second; +} +template ostream& operator<<(ostream& out, const pair& p) { + out << "{" << p.first << ", " << p.second << "}"; + return out; +} +template +void print_tuple_impl(std::basic_ostream& os, const Tuple& t, std::index_sequence) { + using swallow = int[]; // guaranties left to right order + (void)swallow { 0, (void(os << (Index == 0 ? "" : ", ") << std::get(t)), 0)... }; +} +template +decltype(auto) operator<<(std::basic_ostream& os, const std::tuple& t) { + os << "{"; + print_tuple_impl(os, t, std::index_sequence_for{}); + return os << "}"; +} +template ostream& operator<<(ostream& out, const vector& 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; +} + +/* pops */ +#define poptop(q, ...) __AS_PROCEDURE(auto [__VA_ARGS__] = q.top(); q.pop();) +#define popback(q, ...) __AS_PROCEDURE(auto [__VA_ARGS__] = q.back(); q.pop_back();) +#define popfront(q, ...) __AS_PROCEDURE(auto [__VA_ARGS__] = q.front();q.pop_front();) + +/* math */ +template +return_t qpow(ll b, ll p) { + if (b == 0 and p != 0) return 0; + if (p == 0) return 1; + return_t half = qpow(b, p / 2); + if (p % 2 == 1) return half * half * b; + else return half * half; +} + +#define comb(n, k) ((n) < 0 or (k) < 0 or (n) < (k) ? 0 : fact[n] / fact[k] / fact[(n) - (k)]) + +constexpr inline int lg2(ll x) { return x == 0 ? -1 : sizeof(ll) * 8 - 1 - __builtin_clzll(x); } + +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> decompose(ll x) { + // return (factor, count, factor ** count) + vector> 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 decompose_prime(int N) { + // return (factor, count) + vector 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 calc_next(string t) { // pi function of t + int n = (int)t.length(); + vector 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 calc_z(string t) { // z function of t + int m = t.length(); + vector z; + z.push_back(m); + pair 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 kmp(string s, string t) { // find all t in s + string cur = t + '#' + s; + int sz1 = s.size(), sz2 = t.size(); + vector v; + vector 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(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 struct MLL { + ll val; + MLL(ll v = 0) : val(mod(v, mdl)) {} + MLL(const MLL& 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 * mod(inverse(rhs.val, mdl), 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; } + void operator+=(const MLL& rhs) { val = (*this + rhs).val; } + void operator-=(const MLL& rhs) { val = (*this - rhs).val; } + void operator*=(const MLL& rhs) { val = (*this * rhs).val; } + void operator/=(const MLL& rhs) { val = (*this / rhs).val; } + void operator%=(const MLL& rhs) { val = (*this % rhs).val; } +}; +struct MLLd { + ll val, mdl; + MLLd(ll mdl, ll v = 0) : mdl(mdl), val(mod(v, mdl)) {} + MLLd(const MLLd& other) : mdl(other.mdl), val(other.val) {} + friend MLLd operator+(const MLLd& lhs, const MLLd& rhs) { return MLLd(lhs.mdl, mod(lhs.val + rhs.val, lhs.mdl)); } + friend MLLd operator-(const MLLd& lhs, const MLLd& rhs) { return MLLd(lhs.mdl, mod(lhs.val - rhs.val, lhs.mdl)); } + friend MLLd operator*(const MLLd& lhs, const MLLd& rhs) { return MLLd(lhs.mdl, mod(lhs.val * rhs.val, lhs.mdl)); } + friend MLLd operator/(const MLLd& lhs, const MLLd& rhs) { return MLLd(lhs.mdl, mod(lhs.val * mod(inverse(rhs.val, lhs.mdl), lhs.mdl), lhs.mdl)); } + friend MLLd operator%(const MLLd& lhs, const MLLd& rhs) { return MLLd(lhs.mdl, mod(lhs.val - (lhs / rhs).val, lhs.mdl)); } + friend bool operator==(const MLLd& lhs, const MLLd& rhs) { return lhs.val == rhs.val; } + friend bool operator!=(const MLLd& lhs, const MLLd& rhs) { return lhs.val != rhs.val; } + void operator+=(const MLLd& rhs) { val = (*this + rhs).val; } + void operator-=(const MLLd& rhs) { val = (*this - rhs).val; } + void operator*=(const MLLd& rhs) { val = (*this * rhs).val; } + void operator/=(const MLLd& rhs) { val = (*this / rhs).val; } + void operator%=(const MLLd& rhs) { val = (*this % rhs).val; } +}; + +template +ostream& operator<<(ostream& out, const MLL& num) { + return out << num.val; +} + +ostream& operator<<(ostream& out, const MLLd& num) { + return out << num.val; +} + +template +istream& operator>>(istream& in, MLL& num) { + return in >> num.val; +} + +istream& operator>>(istream& in, MLLd& num) { + return in >> num.val; +} + +// miscancellous +#define functor(func) [&](auto&&... val) \ +noexcept(noexcept(func(std::forward(val)...))) -> decltype(auto) \ +{return func(std::forward(val)...);} +template 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 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 +vector> zip(Iterator_T a_first, Iterator_T a_last, Iterator_U b_first, Iterator_U b_last) { + vector> 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 +vector> zip_n(Iterator_T a_first, Iterator_U b_first, size_t n) { + vector> 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 +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& operator++() { ++value; return *this; } + ArithmeticIterator& operator--() { --value; return *this; } + bool operator==(const ArithmeticIterator& rhs) const { return value == rhs.value; } +}; +template vector> enumerate(const vector& container) { + return zip(ArithmeticIterator(0), ArithmeticIterator(INT_MAX), container.begin(), container.end()); +} +///////////////////////////////////////////////////////// + +// #define SINGLE_TEST_CASE +// #define DUMP_TEST_CASE 7219 +// #define TOT_TEST_CASE 10000 + +void dump() {} + +void dump_ignore() {} + +void prep() { +} + +namespace tarjan { + struct mutex_cond { + int v1; bool cond1; + int v2; bool cond2; + mutex_cond(int v1, bool cond1, int v2, bool cond2) : v1(v1), cond1(cond1), v2(v2), cond2(cond2) {} + }; + struct inclusive_cond { + int v1; bool cond1; + int v2; bool cond2; + inclusive_cond(int v1, bool cond1, int v2, bool cond2) : v1(v1), cond1(cond1), v2(v2), cond2(cond2) {} + }; + // Returns the mapping between vertices and their affiliated sccs. + vector scc(const vector>& ch) { + int n = ch.size(); + int cnt = 0, scn = 0; + vector dfn(n), low(n), vis(n), st; + vector br(n); + auto tarjan = [&] (auto tarjan, int v) -> void { + dfn[v]=low[v]=++cnt; + st.push_back(v); + vis[v]=1; + for(const auto&u:ch[v]) + if(!dfn[u]) tarjan(tarjan, u),low[v]=min(low[v],low[u]); + else if(vis[u])low[v]=min(low[v],dfn[u]); + if(dfn[v]==low[v]){ + ++scn; + int u; + do u=st.back(), st.pop_back(),vis[u]=0,br[u]=scn; while(u!=v); + } + }; + for (int i = 0; i < n; ++i) { + if (!dfn[i]) { + tarjan(tarjan, i); + } + } + return br; + } + // This method can eliminate redundant edges or self-loops + vector> build_scc(const vector>& ch) { + int n = ch.size(); + auto br = scc(ch); + int cnt = *max_element(br.begin(), br.end()); + vector> rb(cnt + 1); + for (int i = 0; i < n; ++i) { + for (auto&& u : ch[i]) { + if (br[i] != br[u]) rb[br[i]].emplace(br[u]); + } + } + vector> res(cnt + 1); + for (int i = 1; i <= cnt; ++i) { + res[i] = vector(rb[i].begin(), rb[i].end()); + } + return res; + } + + // This method can eliminate redundant edges or self-loops + // return form: (scc size, children of scc) + vector>> build_scc_with_size(const vector>& ch) { + int n = ch.size(); + auto br = scc(ch); + int cnt = *max_element(br.begin(), br.end()); + vector> rb(cnt + 1); + for (int i = 0; i < n; ++i) { + for (auto&& u : ch[i]) { + if (br[i] != br[u]) rb[br[i]].emplace(br[u]); + } + } + vector>> res(cnt + 1); + for (int i = 1; i <= cnt; ++i) { + res[i].second = vector(rb[i].begin(), rb[i].end()); + } + for (int i = 1; i <= n; ++i) { + res[br[i]].first += 1; + } + return res; + } + // indices start from 1, result has `n` items + optional> solve_twosat(int n, const vector& conditions) { + vector> ch(2 * n + 1); + for (auto&& [v1, cond1, v2, cond2] : conditions) { + ch[(1 ^ cond1) * n + v1].emplace_back(cond2 * n + v2); + ch[(1 ^ cond2) * n + v2].emplace_back(cond1 * n + v1); + } + auto sccno = scc(ch); + for (int i = 1; i <= n; ++i) { + if (sccno[i] == sccno[i + n]) { + return nullopt; + } + } + vector res; + for (int i = 1; i <= n; ++i) { + if (sccno[i] < sccno[i + n]) { + res.emplace_back(false); + } else { + res.emplace_back(true); + } + } + return res; + }; + // indices start from 1, result has `n` items + optional> solve_twosat(int n, const vector& conditions) { + vector trans_conds; + for (auto&& [v1, cond1, v2, cond2] : conditions) { + trans_conds.emplace_back(v1, cond1, v2, not cond2); + } + return solve_twosat(n, trans_conds); + } + // Returns if each vertex is a cut vertex + // All indices start from 1 + vector cut_v(const vector>& ch) { + int n = ch.size() - 1; + vector vis(n + 1); + vector low(n + 1), dfn(n + 1), flag(n + 1); + int cnt = 0; + auto dfs = [&] (auto dfs, int v, int pa) -> void { + vis[v] = 1; + low[v] = dfn[v] = ++cnt; + int child = 0; + for (auto&& u : ch[v]) { + if (not vis[u]) { + ++child; + dfs(dfs, u, v); + low[v] = min(low[v], low[u]); + if (pa != v and low[u] >= dfn[v] and not flag[v]) { + flag[v] = 1; + } + } else if (u != pa) { + low[v] = min(low[v], dfn[u]); + } + } + if (pa == v and child >= 2 and not flag[v]) { + flag[v] = 1; + } + }; + for (int i = 1; i <= n; ++i) { + if (not dfn[i]) { + dfs(dfs, i, 0); + } + } + return flag; + } +} + +void solve() { + read(int, n, m); + vector> e(n + 1); + vector conditions; + auto insert = [&] (int u, int v, bool w) -> void { + if (w == 1) { + conditions.push_back({ + u, 1, + v, 1, + }); + conditions.push_back({ + u, 0, + v, 0, + }); + } else { + conditions.push_back({ + u, 1, + v, 0, + }); + conditions.push_back({ + u, 0, + v, 1, + }); + } + }; + vector res(n - 1, -1); + vector edges(n - 1); + for (int i = 0; i < n - 1; ++i) { + read(int, u, v, w); + edgew(e, u, v, i); + edges[i] = {u, v}; + if (w != -1) { + insert(u, v, parity(w)); + res[i] = w; + } + } + while (m--) { + read(int, u, v, w); + insert(u, v, w); + } + auto sol = tarjan::solve_twosat(n, conditions); + if (sol == nullopt) { + cout << "NO\n"; + } else { + cout << "YES\n"; + auto dfs = [&] (auto dfs, int v, int pa) -> void { + for (auto&& [u, id] : e[v]) { + if (u == pa) continue; + if (res[id] == -1) { + res[id] = (*sol)[u - 1] ^ (*sol)[v - 1]; + } + dfs(dfs, u, v); + } + }; + dfs(dfs, 1, 0); + for (int i = 0; i < n - 1; ++i) { + cout << edges[i].first << ' ' << edges[i].second << ' ' << res[i] << '\n'; + } + } +} + +int main() { +#if __cplusplus < 201402L or defined(_MSC_VER) and not defined(__clang__) + 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 +} diff --git a/src/bin/cf-1617d2.cc b/src/bin/cf-1617d2.cc new file mode 100644 index 0000000..91b320f --- /dev/null +++ b/src/bin/cf-1617d2.cc @@ -0,0 +1,609 @@ +#pragma GCC optimize("Ofast") +///////////////////////////////////////////////////////// +/** + * This code should require C++14. + * However, it's only been tested with C++17. + */ + +#include +using namespace std; + +/* macro helpers */ +#define __NARGS(...) std::tuple_size::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::type + +/* 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; +using ld = long double; +#endif +using int128 = __int128_t; +using uint128 = __uint128_t; +using ld = long double; +using pii = pair; +using pil = pair; +using pli = pair; +using pll = pair; +using pid = pair; +using pdi = pair; +using pld = pair; +using pdl = pair; +using pdd = pair; +using tlll = tuple; +using tlld = tuple; +using tlli = tuple; +using tldl = tuple; +using tldd = tuple; +using tldi = tuple; +using tlil = tuple; +using tlid = tuple; +using tlii = tuple; +using tdll = tuple; +using tdld = tuple; +using tdli = tuple; +using tddl = tuple; +using tddd = tuple; +using tddi = tuple; +using tdil = tuple; +using tdid = tuple; +using tdii = tuple; +using till = tuple; +using tild = tuple; +using tili = tuple; +using tidl = tuple; +using tidd = tuple; +using tidi = tuple; +using tiil = tuple; +using tiid = tuple; +using tiii = tuple; +template using max_heap = priority_queue; +template using min_heap = priority_queue, greater<>>; +template using oi = ostream_iterator; +template using ii = istream_iterator; + +/* constants */ +constexpr int INF = 0x3f3f3f3f; +constexpr ll INFLL = 0x3f3f3f3f3f3f3f3fLL; +constexpr ll MDL = 1e9 + 7; +constexpr ll PRIME = 998'244'353; +constexpr ll MDL1 = 8784491; +constexpr ll MDL2 = PRIME; +constexpr int128 INT128_MAX = numeric_limits::max(); +constexpr uint128 UINT128_MAX = numeric_limits::max(); +constexpr int128 INT128_MIN = numeric_limits::min(); +constexpr uint128 UINT128_MIN = numeric_limits::min(); + +/* random */ + +mt19937 rd(chrono::duration_cast(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 +#define ugt std::greater + +#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 + size_t operator()(const pair& 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 dist(PRIME); +const size_t __array_hash_b = 31, __array_hash_mdl1 = dist(rd), __array_hash_mdl2 = dist(rd); +struct array_hash { + template + size_t operator()(const Sequence& arr) const { + size_t pw1 = 1, pw2 = 1; + size_t res1 = 0, res2 = 0; + for (auto&& x : arr) { + res1 = (res1 + x * pw1) % __array_hash_mdl1; + res2 = (res2 + x * 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 pa(a) __AS_PROCEDURE(__typeof(a) pa; pa.push_back({}); for (auto&&x : a) pa.push_back(pa.back() + x);) +#define sa(a) __AS_PROCEDURE(__typeof(a) sa(a.size() + 1); {int n = a.size(); for (int i = n - 1; i >= 0; --i) sa[i] = sa[i + 1] + a[i];};) +#define adj(ch, n) __AS_PROCEDURE(vector> 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, w) __AS_PROCEDURE(ch[u].emplace_back(v, w), ch[v].emplace_back(u, w);) +#define Edge(ch, u, v) __AS_PROCEDURE(ch[u].push_back(v);) +#define Edgew(ch, u, v, w) __AS_PROCEDURE(ch[u].emplace_back(v, w);) +template pair> discretize(Iterator __first, Iterator __last) { + set st(__first, __last); + size_t N = 0; + map mp; + for (auto&& x : st) mp[x] = ++N; + return {N, mp}; +} +template pair> unordered_discretize(Iterator __first, Iterator __last) { + set st(__first, __last); + size_t N = 0; + unordered_map 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)) +template void __read(T& x) { cin >> x; } +template void __read(T& x, U&... args) { cin >> x; __read(args...); } +#define read(type, ...) __AS_PROCEDURE(type __VA_ARGS__; __read(__VA_ARGS__);) +#define readvec(type, a, n) __AS_PROCEDURE(vector a(n); for (auto& x : a) cin >> x;) +#define readvec1(type, a, n) __AS_PROCEDURE(vector a((n) + 1); copy_n(ii(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;) +template istream& operator>>(istream& in, pair& p) { + return in >> p.first >> p.second; +} +template ostream& operator<<(ostream& out, const pair& p) { + out << "{" << p.first << ", " << p.second << "}"; + return out; +} +template +void print_tuple_impl(std::basic_ostream& os, const Tuple& t, std::index_sequence) { + using swallow = int[]; // guaranties left to right order + (void)swallow { 0, (void(os << (Index == 0 ? "" : ", ") << std::get(t)), 0)... }; +} +template +decltype(auto) operator<<(std::basic_ostream& os, const std::tuple& t) { + os << "{"; + print_tuple_impl(os, t, std::index_sequence_for{}); + return os << "}"; +} +template ostream& operator<<(ostream& out, const vector& 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; +} + +/* pops */ +#define poptop(q, ...) __AS_PROCEDURE(auto [__VA_ARGS__] = q.top(); q.pop();) +#define popback(q, ...) __AS_PROCEDURE(auto [__VA_ARGS__] = q.back(); q.pop_back();) +#define popfront(q, ...) __AS_PROCEDURE(auto [__VA_ARGS__] = q.front();q.pop_front();) + +/* math */ +template +return_t qpow(ll b, ll p) { + if (b == 0 and p != 0) return 0; + if (p == 0) return 1; + return_t half = qpow(b, p / 2); + if (p % 2 == 1) return half * half * b; + else return half * half; +} + +#define comb(n, k) ((n) < 0 or (k) < 0 or (n) < (k) ? 0 : fact[n] / fact[k] / fact[(n) - (k)]) + +constexpr inline int lg2(ll x) { return x == 0 ? -1 : sizeof(ll) * 8 - 1 - __builtin_clzll(x); } + +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> decompose(ll x) { + // return (factor, count, factor ** count) + vector> 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 decompose_prime(int N) { + // return (factor, count) + vector 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 calc_next(string t) { // pi function of t + int n = (int)t.length(); + vector 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 calc_z(string t) { // z function of t + int m = t.length(); + vector z; + z.push_back(m); + pair 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 kmp(string s, string t) { // find all t in s + string cur = t + '#' + s; + int sz1 = s.size(), sz2 = t.size(); + vector v; + vector 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(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 struct MLL { + ll val; + MLL(ll v = 0) : val(mod(v, mdl)) {} + MLL(const MLL& 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 * mod(inverse(rhs.val, mdl), 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; } + void operator+=(const MLL& rhs) { val = (*this + rhs).val; } + void operator-=(const MLL& rhs) { val = (*this - rhs).val; } + void operator*=(const MLL& rhs) { val = (*this * rhs).val; } + void operator/=(const MLL& rhs) { val = (*this / rhs).val; } + void operator%=(const MLL& rhs) { val = (*this % rhs).val; } +}; +struct MLLd { + ll val, mdl; + MLLd(ll mdl, ll v = 0) : mdl(mdl), val(mod(v, mdl)) {} + MLLd(const MLLd& other) : mdl(other.mdl), val(other.val) {} + friend MLLd operator+(const MLLd& lhs, const MLLd& rhs) { return MLLd(lhs.mdl, mod(lhs.val + rhs.val, lhs.mdl)); } + friend MLLd operator-(const MLLd& lhs, const MLLd& rhs) { return MLLd(lhs.mdl, mod(lhs.val - rhs.val, lhs.mdl)); } + friend MLLd operator*(const MLLd& lhs, const MLLd& rhs) { return MLLd(lhs.mdl, mod(lhs.val * rhs.val, lhs.mdl)); } + friend MLLd operator/(const MLLd& lhs, const MLLd& rhs) { return MLLd(lhs.mdl, mod(lhs.val * mod(inverse(rhs.val, lhs.mdl), lhs.mdl), lhs.mdl)); } + friend MLLd operator%(const MLLd& lhs, const MLLd& rhs) { return MLLd(lhs.mdl, mod(lhs.val - (lhs / rhs).val, lhs.mdl)); } + friend bool operator==(const MLLd& lhs, const MLLd& rhs) { return lhs.val == rhs.val; } + friend bool operator!=(const MLLd& lhs, const MLLd& rhs) { return lhs.val != rhs.val; } + void operator+=(const MLLd& rhs) { val = (*this + rhs).val; } + void operator-=(const MLLd& rhs) { val = (*this - rhs).val; } + void operator*=(const MLLd& rhs) { val = (*this * rhs).val; } + void operator/=(const MLLd& rhs) { val = (*this / rhs).val; } + void operator%=(const MLLd& rhs) { val = (*this % rhs).val; } +}; + +template +ostream& operator<<(ostream& out, const MLL& num) { + return out << num.val; +} + +ostream& operator<<(ostream& out, const MLLd& num) { + return out << num.val; +} + +template +istream& operator>>(istream& in, MLL& num) { + return in >> num.val; +} + +istream& operator>>(istream& in, MLLd& num) { + return in >> num.val; +} + +// miscancellous +#define functor(func) [&](auto&&... val) \ +noexcept(noexcept(func(std::forward(val)...))) -> decltype(auto) \ +{return func(std::forward(val)...);} +template 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 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 +vector> zip(Iterator_T a_first, Iterator_T a_last, Iterator_U b_first, Iterator_U b_last) { + vector> 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 +vector> zip_n(Iterator_T a_first, Iterator_U b_first, size_t n) { + vector> 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 +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& operator++() { ++value; return *this; } + ArithmeticIterator& operator--() { --value; return *this; } + bool operator==(const ArithmeticIterator& rhs) const { return value == rhs.value; } +}; +template vector> enumerate(const vector& container) { + return zip(ArithmeticIterator(0), ArithmeticIterator(INT_MAX), container.begin(), container.end()); +} +///////////////////////////////////////////////////////// + +// #define SINGLE_TEST_CASE +// #define DUMP_TEST_CASE 7219 +// #define TOT_TEST_CASE 10000 + +void dump() {} + +void dump_ignore() {} + +void prep() { +} + +bool query(int i, int j, int k) { + cout << "? " << i + 1 << ' ' << j + 1 << ' ' << k + 1 << endl; + read(int, x); + if (x == -1) exit(0); + return x ^ 1; +} + +void claim(const vector& idx) { + cout << "! " << idx.size(); + for (auto&& x : idx) cout << ' ' << x + 1; + cout << endl; +} + +void solve() { + read(int, n); + int m = n / 3; + vector dense(m); + vector is_impostor(n); + int p = -1, q = -1; + for (int i = 0; i < m; ++i) { + dense[i] = query(i * 3, i * 3 + 1, i * 3 + 2); + if (dense[i]) p = i; + else q = i; + } + assert(p != -1 and q != -1); + int zero = -1, one = -1; + if (query(3 * p, 3 * p + 1, 3 * q) == 0 or + query(3 * p, 3 * p + 1, 3 * q + 1) == 0 or + query(3 * p, 3 * p + 1, 3 * q + 2) == 0) { + // one of them is 0, the remaining one must be 1. + one = 3 * p + 2; + } else { + // both of them is 1, set to an arbitrary one. + one = 3 * p; + } + if (query(3 * q, 3 * q + 1, one) == 0) { + zero = 3 * q; + } else if (query(3 * q, 3 * q + 2, one) == 0) { + zero = 3 * q; + } else { + zero = 3 * q + 1; + } + for (int i = 0; i < m; ++i) { + int curr = 0; + if (dense[i]) { + int left = query(3 * i, 3 * i + 1, zero); + int right = query(3 * i, 3 * i + 2, zero); + if (left == 0 and right == 0) { + is_impostor[3 * i] = 0; + is_impostor[3 * i + 1] = 1; + is_impostor[3 * i + 2] = 1; + } else if (left == 0 and right == 1) { + is_impostor[3 * i] = 1; + is_impostor[3 * i + 1] = 0; + is_impostor[3 * i + 2] = 1; + } else if (left == 1 and right == 0) { + is_impostor[3 * i] = 1; + is_impostor[3 * i + 1] = 1; + is_impostor[3 * i + 2] = 0; + } else { + is_impostor[3 * i] = 1; + is_impostor[3 * i + 1] = 1; + is_impostor[3 * i + 2] = 1; + } + } else { + int left = query(3 * i, 3 * i + 1, one); + int right = query(3 * i, 3 * i + 2, one); + if (left == 0 and right == 0) { + is_impostor[3 * i] = 0; + is_impostor[3 * i + 1] = 0; + is_impostor[3 * i + 2] = 0; + } else if (left == 0 and right == 1) { + is_impostor[3 * i] = 0; + is_impostor[3 * i + 1] = 0; + is_impostor[3 * i + 2] = 1; + } else if (left == 1 and right == 0) { + is_impostor[3 * i] = 0; + is_impostor[3 * i + 1] = 1; + is_impostor[3 * i + 2] = 0; + } else { + is_impostor[3 * i] = 1; + is_impostor[3 * i + 1] = 0; + is_impostor[3 * i + 2] = 0; + } + } + } + vector res; + for (int i = 0; i < n; ++i) { + if (is_impostor[i]) res.emplace_back(i); + } + claim(res); +} + +int main() { +#if __cplusplus < 201402L or defined(_MSC_VER) and not defined(__clang__) + 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 +} diff --git a/src/bin/cf-1619g.cc b/src/bin/cf-1619g.cc new file mode 100644 index 0000000..e22b24b --- /dev/null +++ b/src/bin/cf-1619g.cc @@ -0,0 +1,660 @@ +/** + * Author: subcrip + * Created: 2024-06-05 13:40:00 + * Modified: 2024-06-05 13:51:37 + * Elapsed: 11 minutes + */ + +#pragma GCC optimize("Ofast") +///////////////////////////////////////////////////////// +/** + * This code should require C++14. + * However, it's only been tested with C++17. + */ + +#include +using namespace std; + +/* macro helpers */ +#define __NARGS(...) std::tuple_size::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::type + +/* 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; +using ld = long double; +#endif +using int128 = __int128_t; +using uint128 = __uint128_t; +using ld = long double; +using pii = pair; +using pil = pair; +using pli = pair; +using pll = pair; +using pid = pair; +using pdi = pair; +using pld = pair; +using pdl = pair; +using pdd = pair; +using tlll = tuple; +using tlld = tuple; +using tlli = tuple; +using tldl = tuple; +using tldd = tuple; +using tldi = tuple; +using tlil = tuple; +using tlid = tuple; +using tlii = tuple; +using tdll = tuple; +using tdld = tuple; +using tdli = tuple; +using tddl = tuple; +using tddd = tuple; +using tddi = tuple; +using tdil = tuple; +using tdid = tuple; +using tdii = tuple; +using till = tuple; +using tild = tuple; +using tili = tuple; +using tidl = tuple; +using tidd = tuple; +using tidi = tuple; +using tiil = tuple; +using tiid = tuple; +using tiii = tuple; +template using max_heap = priority_queue; +template using min_heap = priority_queue, greater<>>; +template using oi = ostream_iterator; +template using ii = istream_iterator; + +/* constants */ +constexpr int INF = 0x3f3f3f3f; +constexpr ll INFLL = 0x3f3f3f3f3f3f3f3fLL; +constexpr ll MDL = 1e9 + 7; +constexpr ll PRIME = 998'244'353; +constexpr ll MDL1 = 8784491; +constexpr ll MDL2 = PRIME; +constexpr int128 INT128_MAX = numeric_limits::max(); +constexpr uint128 UINT128_MAX = numeric_limits::max(); +constexpr int128 INT128_MIN = numeric_limits::min(); +constexpr uint128 UINT128_MIN = numeric_limits::min(); + +/* random */ + +mt19937 rd(chrono::duration_cast(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 +#define ugt std::greater + +#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 + size_t operator()(const pair& 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 dist(PRIME); +const size_t __array_hash_b = 31, __array_hash_mdl1 = dist(rd), __array_hash_mdl2 = dist(rd); +struct array_hash { + template + size_t operator()(const Sequence& arr) const { + size_t pw1 = 1, pw2 = 1; + size_t res1 = 0, res2 = 0; + for (auto&& x : arr) { + res1 = (res1 + x * pw1) % __array_hash_mdl1; + res2 = (res2 + x * 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 pa(a) __AS_PROCEDURE(__typeof(a) pa; pa.push_back({}); for (auto&&x : a) pa.push_back(pa.back() + x);) +#define sa(a) __AS_PROCEDURE(__typeof(a) sa(a.size() + 1); {int n = a.size(); for (int i = n - 1; i >= 0; --i) sa[i] = sa[i + 1] + a[i];};) +#define adj(ch, n) __AS_PROCEDURE(vector> 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, w) __AS_PROCEDURE(ch[u].emplace_back(v, w), ch[v].emplace_back(u, w);) +#define Edge(ch, u, v) __AS_PROCEDURE(ch[u].push_back(v);) +#define Edgew(ch, u, v, w) __AS_PROCEDURE(ch[u].emplace_back(v, w);) +template pair> discretize(Iterator __first, Iterator __last) { + set st(__first, __last); + size_t N = 0; + map mp; + for (auto&& x : st) mp[x] = ++N; + return {N, mp}; +} +template pair> unordered_discretize(Iterator __first, Iterator __last) { + set st(__first, __last); + size_t N = 0; + unordered_map 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)) +template void __read(T& x) { cin >> x; } +template void __read(T& x, U&... args) { cin >> x; __read(args...); } +#define read(type, ...) __AS_PROCEDURE(type __VA_ARGS__; __read(__VA_ARGS__);) +#define readvec(type, a, n) __AS_PROCEDURE(vector a(n); for (auto& x : a) cin >> x;) +#define readvec1(type, a, n) __AS_PROCEDURE(vector a((n) + 1); copy_n(ii(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;) +template istream& operator>>(istream& in, pair& p) { + return in >> p.first >> p.second; +} +template ostream& operator<<(ostream& out, const pair& p) { + out << "{" << p.first << ", " << p.second << "}"; + return out; +} +template +void print_tuple_impl(std::basic_ostream& os, const Tuple& t, std::index_sequence) { + using swallow = int[]; // guaranties left to right order + (void)swallow { 0, (void(os << (Index == 0 ? "" : ", ") << std::get(t)), 0)... }; +} +template +decltype(auto) operator<<(std::basic_ostream& os, const std::tuple& t) { + os << "{"; + print_tuple_impl(os, t, std::index_sequence_for{}); + return os << "}"; +} +template ostream& operator<<(ostream& out, const vector& 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; +} + +/* pops */ +#define poptop(q, ...) __AS_PROCEDURE(auto [__VA_ARGS__] = q.top(); q.pop();) +#define popback(q, ...) __AS_PROCEDURE(auto [__VA_ARGS__] = q.back(); q.pop_back();) +#define popfront(q, ...) __AS_PROCEDURE(auto [__VA_ARGS__] = q.front();q.pop_front();) + +/* math */ +template +return_t qpow(ll b, ll p) { + if (b == 0 and p != 0) return 0; + if (p == 0) return 1; + return_t half = qpow(b, p / 2); + if (p % 2 == 1) return half * half * b; + else return half * half; +} + +#define comb(n, k) ((n) < 0 or (k) < 0 or (n) < (k) ? 0 : fact[n] / fact[k] / fact[(n) - (k)]) + +constexpr inline int lg2(ll x) { return x == 0 ? -1 : sizeof(ll) * 8 - 1 - __builtin_clzll(x); } + +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> decompose(ll x) { + // return (factor, count, factor ** count) + vector> 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 decompose_prime(int N) { + // return (factor, count) + vector 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 calc_next(string t) { // pi function of t + int n = (int)t.length(); + vector 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 calc_z(string t) { // z function of t + int m = t.length(); + vector z; + z.push_back(m); + pair 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 kmp(string s, string t) { // find all t in s + string cur = t + '#' + s; + int sz1 = s.size(), sz2 = t.size(); + vector v; + vector 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(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 struct MLL { + ll val; + MLL(ll v = 0) : val(mod(v, mdl)) {} + MLL(const MLL& 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 * mod(inverse(rhs.val, mdl), 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; } + void operator+=(const MLL& rhs) { val = (*this + rhs).val; } + void operator-=(const MLL& rhs) { val = (*this - rhs).val; } + void operator*=(const MLL& rhs) { val = (*this * rhs).val; } + void operator/=(const MLL& rhs) { val = (*this / rhs).val; } + void operator%=(const MLL& rhs) { val = (*this % rhs).val; } +}; +struct MLLd { + ll val, mdl; + MLLd(ll mdl, ll v = 0) : mdl(mdl), val(mod(v, mdl)) {} + MLLd(const MLLd& other) : mdl(other.mdl), val(other.val) {} + friend MLLd operator+(const MLLd& lhs, const MLLd& rhs) { return MLLd(lhs.mdl, mod(lhs.val + rhs.val, lhs.mdl)); } + friend MLLd operator-(const MLLd& lhs, const MLLd& rhs) { return MLLd(lhs.mdl, mod(lhs.val - rhs.val, lhs.mdl)); } + friend MLLd operator*(const MLLd& lhs, const MLLd& rhs) { return MLLd(lhs.mdl, mod(lhs.val * rhs.val, lhs.mdl)); } + friend MLLd operator/(const MLLd& lhs, const MLLd& rhs) { return MLLd(lhs.mdl, mod(lhs.val * mod(inverse(rhs.val, lhs.mdl), lhs.mdl), lhs.mdl)); } + friend MLLd operator%(const MLLd& lhs, const MLLd& rhs) { return MLLd(lhs.mdl, mod(lhs.val - (lhs / rhs).val, lhs.mdl)); } + friend bool operator==(const MLLd& lhs, const MLLd& rhs) { return lhs.val == rhs.val; } + friend bool operator!=(const MLLd& lhs, const MLLd& rhs) { return lhs.val != rhs.val; } + void operator+=(const MLLd& rhs) { val = (*this + rhs).val; } + void operator-=(const MLLd& rhs) { val = (*this - rhs).val; } + void operator*=(const MLLd& rhs) { val = (*this * rhs).val; } + void operator/=(const MLLd& rhs) { val = (*this / rhs).val; } + void operator%=(const MLLd& rhs) { val = (*this % rhs).val; } +}; + +template +ostream& operator<<(ostream& out, const MLL& num) { + return out << num.val; +} + +ostream& operator<<(ostream& out, const MLLd& num) { + return out << num.val; +} + +template +istream& operator>>(istream& in, MLL& num) { + return in >> num.val; +} + +istream& operator>>(istream& in, MLLd& num) { + return in >> num.val; +} + +// miscancellous +#define functor(func) [&](auto&&... val) \ +noexcept(noexcept(func(std::forward(val)...))) -> decltype(auto) \ +{return func(std::forward(val)...);} +template 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 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 +vector> zip(Iterator_T a_first, Iterator_T a_last, Iterator_U b_first, Iterator_U b_last) { + vector> 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 +vector> zip_n(Iterator_T a_first, Iterator_U b_first, size_t n) { + vector> 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 +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& operator++() { ++value; return *this; } + ArithmeticIterator& operator--() { --value; return *this; } + bool operator==(const ArithmeticIterator& rhs) const { return value == rhs.value; } +}; +template vector> enumerate(const vector& container) { + return zip(ArithmeticIterator(0), ArithmeticIterator(INT_MAX), container.begin(), container.end()); +} +///////////////////////////////////////////////////////// + +// #define SINGLE_TEST_CASE +// #define DUMP_TEST_CASE 23 +// #define TOT_TEST_CASE 10000 + +void dump() { + read(int, n, k); + cout << n << ' ' << k << '\n'; + for (int i = 0; i < n; ++i) { + read(int, x, y, t); + cout << x << ' ' << y << ' ' << t << '\n'; + } +} + +void dump_ignore() { + read(int, n, k); + for (int i = 0; i < n; ++i) { + read(int, x, y, t); + } +} + +void prep() { +} + +class quick_union { +public: + vector c, sz; +public: + quick_union(size_t n) : c(n), sz(n) { + iota(c.begin(), c.end(), 0); + sz.assign(n, 1); + } + + size_t query(size_t i) { + if (c[i] != i) c[i] = query(c[i]); + return c[i]; + } + + void merge(size_t i, size_t j) { + if (connected(i, j)) return; + sz[query(j)] += sz[query(i)]; + c[query(i)] = query(j); + } + bool connected(size_t i, size_t j) { + return query(i) == query(j); + } + size_t query_size(size_t i) { + return sz[query(i)]; + } +}; + +void solve() { + read(int, n, k); + unordered_map, safe_hash> row, col; + vector co(n); + map> rev; + for (int i = 0; i < n; ++i) { + read(int, x, y, t); + rev[t].emplace_back(i); + row[x].emplace_back(y, i); + col[y].emplace_back(x, i); + co[i] = { x, y }; + } + unordered_map, safe_hash> row_link, col_link; + vector::iterator, list::iterator>> pt(n); + vector stale(n); + for (auto&& [x, v] : row) { + sort(v.begin(), v.end()); + row_link[x].insert(row_link[x].end(), v.begin(), v.end()); + for (auto it = row_link[x].begin(); it != row_link[x].end(); ++it) { + pt[it->second].first = it; + } + } + for (auto&& [y, v] : col) { + sort(v.begin(), v.end()); + col_link[y].insert(col_link[y].end(), v.begin(), v.end()); + for (auto it = col_link[y].begin(); it != col_link[y].end(); ++it) { + pt[it->second].second = it; + } + } + quick_union qu(n); + auto dfs = [&] (auto dfs, int v) -> void { + auto [x, y] = co[v]; + auto [row_it, col_it] = pt[v]; + stale[v] = 1; + // down + if (row_it != row_link[x].begin()) { + auto prev_it = prev(row_it); + if (not stale[prev_it->second] and y - prev_it->first <= k) { + qu.merge(v, prev_it->second); + dfs(dfs, prev_it->second); + } + } + // up + if (row_it != row_link[x].end()) { + auto next_it = next(row_it); + if (next_it != row_link[x].end()) { + if (not stale[next_it->second] and next_it->first - y <= k) { + qu.merge(v, next_it->second); + dfs(dfs, next_it->second); + } + } + } + // left + if (col_it != col_link[y].begin()) { + auto prev_it = prev(col_it); + if (not stale[prev_it->second] and x - prev_it->first <= k) { + qu.merge(v, prev_it->second); + dfs(dfs, prev_it->second); + } + } + // right + if (col_it != col_link[x].end()) { + auto next_it = next(col_it); + if (next_it != col_link[y].end()) { + if (not stale[next_it->second] and next_it->first - x <= k) { + qu.merge(v, next_it->second); + dfs(dfs, next_it->second); + } + } + } + + row_link[x].erase(row_it); + col_link[y].erase(col_it); + }; + for (int i = 0; i < n; ++i) { + if (not stale[i]) { + dfs(dfs, i); + } + } + int blk = 0; + for (int i = 0; i < n; ++i) { + if (qu.query(i) == i) { + blk += 1; + } + } + vector use(n); + int res = blk - 1; + for (auto&& [t, v] : rev) { + for (auto&& i : v) { + if (use[qu.query(i)]) continue; + use[qu.query(i)] = 1; + blk -= 1; + } + res = min(res, t + max(0, blk - t - 1)); + } + cout << res << '\n'; +} + +int main() { +#if __cplusplus < 201402L or defined(_MSC_VER) and not defined(__clang__) + 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 +} diff --git a/src/bin/cf-1689d.cc b/src/bin/cf-1689d.cc new file mode 100644 index 0000000..3a1dbf6 --- /dev/null +++ b/src/bin/cf-1689d.cc @@ -0,0 +1,688 @@ +#pragma GCC optimize("Ofast") +///////////////////////////////////////////////////////// +/** + * This code should require C++14. + * However, it's only been tested with C++17. + */ + +#include +using namespace std; + +/* macro helpers */ +#define __NARGS(...) std::tuple_size::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::type + +/* 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; +using ld = long double; +#endif +using int128 = __int128_t; +using uint128 = __uint128_t; +using ld = long double; +using pii = pair; +using pil = pair; +using pli = pair; +using pll = pair; +using pid = pair; +using pdi = pair; +using pld = pair; +using pdl = pair; +using pdd = pair; +using tlll = tuple; +using tlld = tuple; +using tlli = tuple; +using tldl = tuple; +using tldd = tuple; +using tldi = tuple; +using tlil = tuple; +using tlid = tuple; +using tlii = tuple; +using tdll = tuple; +using tdld = tuple; +using tdli = tuple; +using tddl = tuple; +using tddd = tuple; +using tddi = tuple; +using tdil = tuple; +using tdid = tuple; +using tdii = tuple; +using till = tuple; +using tild = tuple; +using tili = tuple; +using tidl = tuple; +using tidd = tuple; +using tidi = tuple; +using tiil = tuple; +using tiid = tuple; +using tiii = tuple; +template using max_heap = priority_queue; +template using min_heap = priority_queue, greater<>>; +template using oi = ostream_iterator; +template using ii = istream_iterator; + +/* constants */ +constexpr int INF = 0x3f3f3f3f; +constexpr ll INFLL = 0x3f3f3f3f3f3f3f3fLL; +constexpr ll MDL = 1e9 + 7; +constexpr ll PRIME = 998'244'353; +constexpr ll MDL1 = 8784491; +constexpr ll MDL2 = PRIME; +constexpr int128 INT128_MAX = numeric_limits::max(); +constexpr uint128 UINT128_MAX = numeric_limits::max(); +constexpr int128 INT128_MIN = numeric_limits::min(); +constexpr uint128 UINT128_MIN = numeric_limits::min(); + +/* random */ + +mt19937 rd(chrono::duration_cast(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 +#define ugt std::greater + +#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 + size_t operator()(const pair& 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 dist(PRIME); +const size_t __array_hash_b = 31, __array_hash_mdl1 = dist(rd), __array_hash_mdl2 = dist(rd); +struct array_hash { + template + size_t operator()(const Sequence& arr) const { + size_t pw1 = 1, pw2 = 1; + size_t res1 = 0, res2 = 0; + for (auto&& x : arr) { + res1 = (res1 + x * pw1) % __array_hash_mdl1; + res2 = (res2 + x * 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 pa(a) __AS_PROCEDURE(__typeof(a) pa; pa.push_back({}); for (auto&&x : a) pa.push_back(pa.back() + x);) +#define sa(a) __AS_PROCEDURE(__typeof(a) sa(a.size() + 1); {int n = a.size(); for (int i = n - 1; i >= 0; --i) sa[i] = sa[i + 1] + a[i];};) +#define adj(ch, n) __AS_PROCEDURE(vector> 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, w) __AS_PROCEDURE(ch[u].emplace_back(v, w), ch[v].emplace_back(u, w);) +#define Edge(ch, u, v) __AS_PROCEDURE(ch[u].push_back(v);) +#define Edgew(ch, u, v, w) __AS_PROCEDURE(ch[u].emplace_back(v, w);) +template pair> discretize(Iterator __first, Iterator __last) { + set st(__first, __last); + size_t N = 0; + map mp; + for (auto&& x : st) mp[x] = ++N; + return {N, mp}; +} +template pair> unordered_discretize(Iterator __first, Iterator __last) { + set st(__first, __last); + size_t N = 0; + unordered_map 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)) +template void __read(T& x) { cin >> x; } +template void __read(T& x, U&... args) { cin >> x; __read(args...); } +#define read(type, ...) __AS_PROCEDURE(type __VA_ARGS__; __read(__VA_ARGS__);) +#define readvec(type, a, n) __AS_PROCEDURE(vector a(n); for (auto& x : a) cin >> x;) +#define readvec1(type, a, n) __AS_PROCEDURE(vector a((n) + 1); copy_n(ii(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;) +template istream& operator>>(istream& in, pair& p) { + return in >> p.first >> p.second; +} +template ostream& operator<<(ostream& out, const pair& p) { + out << "{" << p.first << ", " << p.second << "}"; + return out; +} +template +void print_tuple_impl(std::basic_ostream& os, const Tuple& t, std::index_sequence) { + using swallow = int[]; // guaranties left to right order + (void)swallow { 0, (void(os << (Index == 0 ? "" : ", ") << std::get(t)), 0)... }; +} +template +decltype(auto) operator<<(std::basic_ostream& os, const std::tuple& t) { + os << "{"; + print_tuple_impl(os, t, std::index_sequence_for{}); + return os << "}"; +} +template ostream& operator<<(ostream& out, const vector& 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; +} + +/* pops */ +#define poptop(q, ...) __AS_PROCEDURE(auto [__VA_ARGS__] = q.top(); q.pop();) +#define popback(q, ...) __AS_PROCEDURE(auto [__VA_ARGS__] = q.back(); q.pop_back();) +#define popfront(q, ...) __AS_PROCEDURE(auto [__VA_ARGS__] = q.front();q.pop_front();) + +/* math */ +template +return_t qpow(ll b, ll p) { + if (b == 0 and p != 0) return 0; + if (p == 0) return 1; + return_t half = qpow(b, p / 2); + if (p % 2 == 1) return half * half * b; + else return half * half; +} + +#define comb(n, k) ((n) < 0 or (k) < 0 or (n) < (k) ? 0 : fact[n] / fact[k] / fact[(n) - (k)]) + +constexpr inline int lg2(ll x) { return x == 0 ? -1 : sizeof(ll) * 8 - 1 - __builtin_clzll(x); } + +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> decompose(ll x) { + // return (factor, count, factor ** count) + vector> 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 decompose_prime(int N) { + // return (factor, count) + vector 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 calc_next(string t) { // pi function of t + int n = (int)t.length(); + vector 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 calc_z(string t) { // z function of t + int m = t.length(); + vector z; + z.push_back(m); + pair 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 kmp(string s, string t) { // find all t in s + string cur = t + '#' + s; + int sz1 = s.size(), sz2 = t.size(); + vector v; + vector 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(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 struct MLL { + ll val; + MLL(ll v = 0) : val(mod(v, mdl)) {} + MLL(const MLL& 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 * mod(inverse(rhs.val, mdl), 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; } + void operator+=(const MLL& rhs) { val = (*this + rhs).val; } + void operator-=(const MLL& rhs) { val = (*this - rhs).val; } + void operator*=(const MLL& rhs) { val = (*this * rhs).val; } + void operator/=(const MLL& rhs) { val = (*this / rhs).val; } + void operator%=(const MLL& rhs) { val = (*this % rhs).val; } +}; +struct MLLd { + ll val, mdl; + MLLd(ll mdl, ll v = 0) : mdl(mdl), val(mod(v, mdl)) {} + MLLd(const MLLd& other) : mdl(other.mdl), val(other.val) {} + friend MLLd operator+(const MLLd& lhs, const MLLd& rhs) { return MLLd(lhs.mdl, mod(lhs.val + rhs.val, lhs.mdl)); } + friend MLLd operator-(const MLLd& lhs, const MLLd& rhs) { return MLLd(lhs.mdl, mod(lhs.val - rhs.val, lhs.mdl)); } + friend MLLd operator*(const MLLd& lhs, const MLLd& rhs) { return MLLd(lhs.mdl, mod(lhs.val * rhs.val, lhs.mdl)); } + friend MLLd operator/(const MLLd& lhs, const MLLd& rhs) { return MLLd(lhs.mdl, mod(lhs.val * mod(inverse(rhs.val, lhs.mdl), lhs.mdl), lhs.mdl)); } + friend MLLd operator%(const MLLd& lhs, const MLLd& rhs) { return MLLd(lhs.mdl, mod(lhs.val - (lhs / rhs).val, lhs.mdl)); } + friend bool operator==(const MLLd& lhs, const MLLd& rhs) { return lhs.val == rhs.val; } + friend bool operator!=(const MLLd& lhs, const MLLd& rhs) { return lhs.val != rhs.val; } + void operator+=(const MLLd& rhs) { val = (*this + rhs).val; } + void operator-=(const MLLd& rhs) { val = (*this - rhs).val; } + void operator*=(const MLLd& rhs) { val = (*this * rhs).val; } + void operator/=(const MLLd& rhs) { val = (*this / rhs).val; } + void operator%=(const MLLd& rhs) { val = (*this % rhs).val; } +}; + +template +ostream& operator<<(ostream& out, const MLL& num) { + return out << num.val; +} + +ostream& operator<<(ostream& out, const MLLd& num) { + return out << num.val; +} + +template +istream& operator>>(istream& in, MLL& num) { + return in >> num.val; +} + +istream& operator>>(istream& in, MLLd& num) { + return in >> num.val; +} + +// miscancellous +#define functor(func) [&](auto&&... val) \ +noexcept(noexcept(func(std::forward(val)...))) -> decltype(auto) \ +{return func(std::forward(val)...);} +template 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 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 +vector> zip(Iterator_T a_first, Iterator_T a_last, Iterator_U b_first, Iterator_U b_last) { + vector> 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 +vector> zip_n(Iterator_T a_first, Iterator_U b_first, size_t n) { + vector> 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 +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& operator++() { ++value; return *this; } + ArithmeticIterator& operator--() { --value; return *this; } + bool operator==(const ArithmeticIterator& rhs) const { return value == rhs.value; } +}; +template vector> enumerate(const vector& container) { + return zip(ArithmeticIterator(0), ArithmeticIterator(INT_MAX), container.begin(), container.end()); +} +///////////////////////////////////////////////////////// + +// #define SINGLE_TEST_CASE +// #define DUMP_TEST_CASE 7219 +// #define TOT_TEST_CASE 10000 + +void dump() {} + +void dump_ignore() {} + +void prep() { +} + +template> class segtree { +private: + using size_type = uint64_t; + using info_type = Addable_Info_t; + using tag_type = Tag_t; + size_type _max; + vector d; + vector b; + void pull(size_type p) { + d[p] = d[p * 2] + d[p * 2 + 1]; + } + void push(size_type p, size_type left_len, size_type right_len) { + d[p * 2].apply(b[p], left_len), d[p * 2 + 1].apply(b[p], right_len); + b[p * 2].apply(b[p]), b[p * 2 + 1].apply(b[p]); + b[p] = tag_type(); + } + void set(size_type s, size_type t, size_type p, size_type x, const info_type& c) { + if (s == t) { + d[p] = c; + return; + } + size_type m = s + (t - s >> 1); + if (s != t) push(p, m - s + 1, t - m); + if (x <= m) set(s, m, p * 2, x, c); + else set(m + 1, t, p * 2 + 1, x, c); + pull(p); + } + + void range_apply(size_type s, size_type t, size_type p, size_type l, size_type r, const tag_type& c) { + if (l <= s && t <= r) { + d[p].apply(c, t - s + 1); + b[p].apply(c); + return; + } + size_type m = s + (t - s >> 1); + push(p, m - s + 1, t - m); + if (l <= m) range_apply(s, m, p * 2, l, r, c); + if (r > m) range_apply(m + 1, t, p * 2 + 1, l, r, c); + pull(p); + } + info_type range_query(size_type s, size_type t, size_type p, size_type l, size_type r) { + if (l <= s && t <= r) { + return d[p]; + } + size_type m = s + (t - s >> 1); + info_type res = {}; + push(p, m - s + 1, t - m); + if (l <= m) res = res + range_query(s, m, p * 2, l, r); + if (r > m) res = res + range_query(m + 1, t, p * 2 + 1, l, r); + return res; + } + void build(const Sequence& a, size_type s, size_type t, size_type p) { + if (s == t) { + d[p] = a[s]; + return; + } + int m = s + (t - s >> 1); + build(a, s, m, p * 2); + build(a, m + 1, t, p * 2 + 1); + pull(p); + } +public: + segtree(size_type __max) : d(4 * __max), b(4 * __max), _max(__max - 1) {} + segtree(const Sequence& a) : segtree(a.size()) { + build(a, {}, _max, 1); + } + void set(size_type i, const info_type& c) { + set({}, _max, 1, i, c); + } + + void range_apply(size_type l, size_type r, const tag_type& c) { + range_apply({}, _max, 1, l, r, c); + } + void apply(size_type i, const tag_type& c) { + range_apply(i, i, c); + } + info_type range_query(size_type l, size_type r) { + return range_query({}, _max, 1, l, r); + } + info_type query(size_type i) { + return range_query(i, i); + } + Sequence serialize() { + Sequence res = {}; + for (size_type i = 0; i <= _max; ++i) { + res.push_back(query(i)); + } + return res; + } + const vector& get_d() { + return d; + } +}; +struct Tag { + ll val = -INFLL; + void apply(const Tag& rhs) { + val = max(val, rhs.val); + } +}; +struct Info { + ll val = -INFLL; + void apply(const Tag& rhs, size_t len) { + val = max(val, rhs.val); + } +}; +Info operator+(const Info &a, const Info &b) { + return {max(a.val, b.val)}; +} + +void solve() { + read(int, n, m); + vector> row(n); + segtree big(m), small(m); + for (int i = 0; i < n; ++i) { + for (int j = 0; j < m; ++j) { + read(char, c); + if (c == 'B') { + row[i].emplace_back(j); + } + } + } + vector> res(n, vector(m)); + for (int i = 0; i < n; ++i) { + for (auto&& j : row[i]) { + big.apply(j, {-i+j}); + small.apply(j, {-i-j}); + } + for (int j = 0; j < m; ++j) { + ll big_query = big.range_query(j, m).val; + ll small_query = small.range_query(0, j).val; + if (big_query != -INFLL) { + res[i][j] = max(res[i][j], i - j + int(big_query)); + } + if (small_query != -INFLL) { + res[i][j] = max(res[i][j], i + j + int(small_query)); + } + } + } + for (int j = 0; j < m; ++j) { + big.set(j, {}); + small.set(j, {}); + } + for (int i = n - 1; ~i; --i) { + for (auto&& j : row[i]) { + big.apply(j, {i+j}); + small.apply(j, {i-j}); + } + for (int j = 0; j < m; ++j) { + ll big_query = big.range_query(j, m).val; + ll small_query = small.range_query(0, j).val; + if (big_query != -INFLL) { + res[i][j] = max(res[i][j], - i - j + int(big_query)); + } + if (small_query != -INFLL) { + res[i][j] = max(res[i][j], - i + j + int(small_query)); + } + } + } + int ans = INF; + int x = 0, y = 0; + for (int i = 0; i < n; ++i) { + for (int j = 0; j < m; ++j) { + if (res[i][j] < ans) { + ans = res[i][j]; + x = i + 1; + y = j + 1; + } + } + } + cout << x << ' ' << y << '\n'; +} + +int main() { +#if __cplusplus < 201402L or defined(_MSC_VER) and not defined(__clang__) + 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 +} diff --git a/src/bin/cf-1692h.cc b/src/bin/cf-1692h.cc new file mode 100644 index 0000000..0f14b76 --- /dev/null +++ b/src/bin/cf-1692h.cc @@ -0,0 +1,542 @@ +#pragma GCC optimize("Ofast") +///////////////////////////////////////////////////////// +/** + * This code should require C++14. + * However, it's only been tested with C++17. + */ + +#include +using namespace std; + +/* macro helpers */ +#define __NARGS(...) std::tuple_size::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::type + +/* 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; +using ld = long double; +#endif +using int128 = __int128_t; +using uint128 = __uint128_t; +using ld = long double; +using pii = pair; +using pil = pair; +using pli = pair; +using pll = pair; +using pid = pair; +using pdi = pair; +using pld = pair; +using pdl = pair; +using pdd = pair; +using tlll = tuple; +using tlld = tuple; +using tlli = tuple; +using tldl = tuple; +using tldd = tuple; +using tldi = tuple; +using tlil = tuple; +using tlid = tuple; +using tlii = tuple; +using tdll = tuple; +using tdld = tuple; +using tdli = tuple; +using tddl = tuple; +using tddd = tuple; +using tddi = tuple; +using tdil = tuple; +using tdid = tuple; +using tdii = tuple; +using till = tuple; +using tild = tuple; +using tili = tuple; +using tidl = tuple; +using tidd = tuple; +using tidi = tuple; +using tiil = tuple; +using tiid = tuple; +using tiii = tuple; +template using max_heap = priority_queue; +template using min_heap = priority_queue, greater<>>; +template using oi = ostream_iterator; +template using ii = istream_iterator; + +/* constants */ +constexpr int INF = 0x3f3f3f3f; +constexpr ll INFLL = 0x3f3f3f3f3f3f3f3fLL; +constexpr ll MDL = 1e9 + 7; +constexpr ll PRIME = 998'244'353; +constexpr ll MDL1 = 8784491; +constexpr ll MDL2 = PRIME; +constexpr int128 INT128_MAX = numeric_limits::max(); +constexpr uint128 UINT128_MAX = numeric_limits::max(); +constexpr int128 INT128_MIN = numeric_limits::min(); +constexpr uint128 UINT128_MIN = numeric_limits::min(); + +/* random */ + +mt19937 rd(chrono::duration_cast(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 +#define ugt std::greater + +#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 + size_t operator()(const pair& 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 dist(PRIME); +const size_t __array_hash_b = 31, __array_hash_mdl1 = dist(rd), __array_hash_mdl2 = dist(rd); +struct array_hash { + template + size_t operator()(const Sequence& arr) const { + size_t pw1 = 1, pw2 = 1; + size_t res1 = 0, res2 = 0; + for (auto&& x : arr) { + res1 = (res1 + x * pw1) % __array_hash_mdl1; + res2 = (res2 + x * 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 pa(a) __AS_PROCEDURE(__typeof(a) pa; pa.push_back({}); for (auto&&x : a) pa.push_back(pa.back() + x);) +#define sa(a) __AS_PROCEDURE(__typeof(a) sa(a.size() + 1); {int n = a.size(); for (int i = n - 1; i >= 0; --i) sa[i] = sa[i + 1] + a[i];};) +#define adj(ch, n) __AS_PROCEDURE(vector> 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, w) __AS_PROCEDURE(ch[u].emplace_back(v, w), ch[v].emplace_back(u, w);) +#define Edge(ch, u, v) __AS_PROCEDURE(ch[u].push_back(v);) +#define Edgew(ch, u, v, w) __AS_PROCEDURE(ch[u].emplace_back(v, w);) +template pair> discretize(Iterator __first, Iterator __last) { + set st(__first, __last); + size_t N = 0; + map mp; + for (auto&& x : st) mp[x] = ++N; + return {N, mp}; +} +template pair> unordered_discretize(Iterator __first, Iterator __last) { + set st(__first, __last); + size_t N = 0; + unordered_map 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)) +template void __read(T& x) { cin >> x; } +template void __read(T& x, U&... args) { cin >> x; __read(args...); } +#define read(type, ...) __AS_PROCEDURE(type __VA_ARGS__; __read(__VA_ARGS__);) +#define readvec(type, a, n) __AS_PROCEDURE(vector a(n); for (auto& x : a) cin >> x;) +#define readvec1(type, a, n) __AS_PROCEDURE(vector a((n) + 1); copy_n(ii(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;) +template istream& operator>>(istream& in, pair& p) { + return in >> p.first >> p.second; +} +template ostream& operator<<(ostream& out, const pair& p) { + out << "{" << p.first << ", " << p.second << "}"; + return out; +} +template +void print_tuple_impl(std::basic_ostream& os, const Tuple& t, std::index_sequence) { + using swallow = int[]; // guaranties left to right order + (void)swallow { 0, (void(os << (Index == 0 ? "" : ", ") << std::get(t)), 0)... }; +} +template +decltype(auto) operator<<(std::basic_ostream& os, const std::tuple& t) { + os << "{"; + print_tuple_impl(os, t, std::index_sequence_for{}); + return os << "}"; +} +template ostream& operator<<(ostream& out, const vector& 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; +} + +/* pops */ +#define poptop(q, ...) __AS_PROCEDURE(auto [__VA_ARGS__] = q.top(); q.pop();) +#define popback(q, ...) __AS_PROCEDURE(auto [__VA_ARGS__] = q.back(); q.pop_back();) +#define popfront(q, ...) __AS_PROCEDURE(auto [__VA_ARGS__] = q.front();q.pop_front();) + +/* math */ +template +return_t qpow(ll b, ll p) { + if (b == 0 and p != 0) return 0; + if (p == 0) return 1; + return_t half = qpow(b, p / 2); + if (p % 2 == 1) return half * half * b; + else return half * half; +} + +#define comb(n, k) ((n) < 0 or (k) < 0 or (n) < (k) ? 0 : fact[n] / fact[k] / fact[(n) - (k)]) + +constexpr inline int lg2(ll x) { return x == 0 ? -1 : sizeof(ll) * 8 - 1 - __builtin_clzll(x); } + +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> decompose(ll x) { + // return (factor, count, factor ** count) + vector> 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 decompose_prime(int N) { + // return (factor, count) + vector 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 calc_next(string t) { // pi function of t + int n = (int)t.length(); + vector 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 calc_z(string t) { // z function of t + int m = t.length(); + vector z; + z.push_back(m); + pair 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 kmp(string s, string t) { // find all t in s + string cur = t + '#' + s; + int sz1 = s.size(), sz2 = t.size(); + vector v; + vector 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(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 struct MLL { + ll val; + MLL(ll v = 0) : val(mod(v, mdl)) {} + MLL(const MLL& 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 * mod(inverse(rhs.val, mdl), 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; } + void operator+=(const MLL& rhs) { val = (*this + rhs).val; } + void operator-=(const MLL& rhs) { val = (*this - rhs).val; } + void operator*=(const MLL& rhs) { val = (*this * rhs).val; } + void operator/=(const MLL& rhs) { val = (*this / rhs).val; } + void operator%=(const MLL& rhs) { val = (*this % rhs).val; } +}; +struct MLLd { + ll val, mdl; + MLLd(ll mdl, ll v = 0) : mdl(mdl), val(mod(v, mdl)) {} + MLLd(const MLLd& other) : mdl(other.mdl), val(other.val) {} + friend MLLd operator+(const MLLd& lhs, const MLLd& rhs) { return MLLd(lhs.mdl, mod(lhs.val + rhs.val, lhs.mdl)); } + friend MLLd operator-(const MLLd& lhs, const MLLd& rhs) { return MLLd(lhs.mdl, mod(lhs.val - rhs.val, lhs.mdl)); } + friend MLLd operator*(const MLLd& lhs, const MLLd& rhs) { return MLLd(lhs.mdl, mod(lhs.val * rhs.val, lhs.mdl)); } + friend MLLd operator/(const MLLd& lhs, const MLLd& rhs) { return MLLd(lhs.mdl, mod(lhs.val * mod(inverse(rhs.val, lhs.mdl), lhs.mdl), lhs.mdl)); } + friend MLLd operator%(const MLLd& lhs, const MLLd& rhs) { return MLLd(lhs.mdl, mod(lhs.val - (lhs / rhs).val, lhs.mdl)); } + friend bool operator==(const MLLd& lhs, const MLLd& rhs) { return lhs.val == rhs.val; } + friend bool operator!=(const MLLd& lhs, const MLLd& rhs) { return lhs.val != rhs.val; } + void operator+=(const MLLd& rhs) { val = (*this + rhs).val; } + void operator-=(const MLLd& rhs) { val = (*this - rhs).val; } + void operator*=(const MLLd& rhs) { val = (*this * rhs).val; } + void operator/=(const MLLd& rhs) { val = (*this / rhs).val; } + void operator%=(const MLLd& rhs) { val = (*this % rhs).val; } +}; + +template +ostream& operator<<(ostream& out, const MLL& num) { + return out << num.val; +} + +ostream& operator<<(ostream& out, const MLLd& num) { + return out << num.val; +} + +template +istream& operator>>(istream& in, MLL& num) { + return in >> num.val; +} + +istream& operator>>(istream& in, MLLd& num) { + return in >> num.val; +} + +// miscancellous +#define functor(func) [&](auto&&... val) \ +noexcept(noexcept(func(std::forward(val)...))) -> decltype(auto) \ +{return func(std::forward(val)...);} +template 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 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 +vector> zip(Iterator_T a_first, Iterator_T a_last, Iterator_U b_first, Iterator_U b_last) { + vector> 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 +vector> zip_n(Iterator_T a_first, Iterator_U b_first, size_t n) { + vector> 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 +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& operator++() { ++value; return *this; } + ArithmeticIterator& operator--() { --value; return *this; } + bool operator==(const ArithmeticIterator& rhs) const { return value == rhs.value; } +}; +template vector> enumerate(const vector& container) { + return zip(ArithmeticIterator(0), ArithmeticIterator(INT_MAX), container.begin(), container.end()); +} +///////////////////////////////////////////////////////// + +// #define SINGLE_TEST_CASE +// #define DUMP_TEST_CASE 7219 +// #define TOT_TEST_CASE 10000 + +void dump() {} + +void dump_ignore() {} + +void prep() { +} + +void solve() { + read(int, n); + readvec(int, a, n); + vector ps(n); + unordered_map, safe_hash> bk; + int choice = a[0], l = 0, r = 0; + int res = 1; + for (int i = 0; i < n; ++i) { + int curr = 2 * bk[a[i]].first - i; + if (bk[a[i]].first > 0) { + if (curr + 1 - ps[bk[a[i]].second] > res) { + res = curr + 1 - ps[bk[a[i]].second]; + choice = a[i]; + l = bk[a[i]].second; + r = i; + } + } + ps[i] = curr; + if (bk[a[i]].first == 0 or ps[i] < ps[bk[a[i]].second]) { + bk[a[i]].second = i; + } + bk[a[i]].first += 1; + } + cout << choice << ' ' << l + 1 << ' ' << r + 1 << '\n'; +} + +int main() { +#if __cplusplus < 201402L or defined(_MSC_VER) and not defined(__clang__) + 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 +} diff --git a/src/bin/cf-1693b.cc b/src/bin/cf-1693b.cc new file mode 100644 index 0000000..60294a5 --- /dev/null +++ b/src/bin/cf-1693b.cc @@ -0,0 +1,553 @@ +/** + * Author: subcrip + * Created: 2024-06-03 21:57:30 + * Modified: 2024-06-03 22:01:36 + * Elapsed: 4 minutes + */ + +#pragma GCC optimize("Ofast") +///////////////////////////////////////////////////////// +/** + * This code should require C++14. + * However, it's only been tested with C++17. + */ + +#include +using namespace std; + +/* macro helpers */ +#define __NARGS(...) std::tuple_size::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::type + +/* 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; +using ld = long double; +#endif +using int128 = __int128_t; +using uint128 = __uint128_t; +using ld = long double; +using pii = pair; +using pil = pair; +using pli = pair; +using pll = pair; +using pid = pair; +using pdi = pair; +using pld = pair; +using pdl = pair; +using pdd = pair; +using tlll = tuple; +using tlld = tuple; +using tlli = tuple; +using tldl = tuple; +using tldd = tuple; +using tldi = tuple; +using tlil = tuple; +using tlid = tuple; +using tlii = tuple; +using tdll = tuple; +using tdld = tuple; +using tdli = tuple; +using tddl = tuple; +using tddd = tuple; +using tddi = tuple; +using tdil = tuple; +using tdid = tuple; +using tdii = tuple; +using till = tuple; +using tild = tuple; +using tili = tuple; +using tidl = tuple; +using tidd = tuple; +using tidi = tuple; +using tiil = tuple; +using tiid = tuple; +using tiii = tuple; +template using max_heap = priority_queue; +template using min_heap = priority_queue, greater<>>; +template using oi = ostream_iterator; +template using ii = istream_iterator; + +/* constants */ +constexpr int INF = 0x3f3f3f3f; +constexpr ll INFLL = 0x3f3f3f3f3f3f3f3fLL; +constexpr ll MDL = 1e9 + 7; +constexpr ll PRIME = 998'244'353; +constexpr ll MDL1 = 8784491; +constexpr ll MDL2 = PRIME; +constexpr int128 INT128_MAX = numeric_limits::max(); +constexpr uint128 UINT128_MAX = numeric_limits::max(); +constexpr int128 INT128_MIN = numeric_limits::min(); +constexpr uint128 UINT128_MIN = numeric_limits::min(); + +/* random */ + +mt19937 rd(chrono::duration_cast(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 +#define ugt std::greater + +#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 + size_t operator()(const pair& 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 dist(PRIME); +const size_t __array_hash_b = 31, __array_hash_mdl1 = dist(rd), __array_hash_mdl2 = dist(rd); +struct array_hash { + template + size_t operator()(const Sequence& arr) const { + size_t pw1 = 1, pw2 = 1; + size_t res1 = 0, res2 = 0; + for (auto&& x : arr) { + res1 = (res1 + x * pw1) % __array_hash_mdl1; + res2 = (res2 + x * 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 pa(a) __AS_PROCEDURE(__typeof(a) pa; pa.push_back({}); for (auto&&x : a) pa.push_back(pa.back() + x);) +#define sa(a) __AS_PROCEDURE(__typeof(a) sa(a.size() + 1); {int n = a.size(); for (int i = n - 1; i >= 0; --i) sa[i] = sa[i + 1] + a[i];};) +#define adj(ch, n) __AS_PROCEDURE(vector> 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, w) __AS_PROCEDURE(ch[u].emplace_back(v, w), ch[v].emplace_back(u, w);) +#define Edge(ch, u, v) __AS_PROCEDURE(ch[u].push_back(v);) +#define Edgew(ch, u, v, w) __AS_PROCEDURE(ch[u].emplace_back(v, w);) +template pair> discretize(Iterator __first, Iterator __last) { + set st(__first, __last); + size_t N = 0; + map mp; + for (auto&& x : st) mp[x] = ++N; + return {N, mp}; +} +template pair> unordered_discretize(Iterator __first, Iterator __last) { + set st(__first, __last); + size_t N = 0; + unordered_map 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)) +template void __read(T& x) { cin >> x; } +template void __read(T& x, U&... args) { cin >> x; __read(args...); } +#define read(type, ...) __AS_PROCEDURE(type __VA_ARGS__; __read(__VA_ARGS__);) +#define readvec(type, a, n) __AS_PROCEDURE(vector a(n); for (auto& x : a) cin >> x;) +#define readvec1(type, a, n) __AS_PROCEDURE(vector a((n) + 1); copy_n(ii(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;) +template istream& operator>>(istream& in, pair& p) { + return in >> p.first >> p.second; +} +template ostream& operator<<(ostream& out, const pair& p) { + out << "{" << p.first << ", " << p.second << "}"; + return out; +} +template +void print_tuple_impl(std::basic_ostream& os, const Tuple& t, std::index_sequence) { + using swallow = int[]; // guaranties left to right order + (void)swallow { 0, (void(os << (Index == 0 ? "" : ", ") << std::get(t)), 0)... }; +} +template +decltype(auto) operator<<(std::basic_ostream& os, const std::tuple& t) { + os << "{"; + print_tuple_impl(os, t, std::index_sequence_for{}); + return os << "}"; +} +template ostream& operator<<(ostream& out, const vector& 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; +} + +/* pops */ +#define poptop(q, ...) __AS_PROCEDURE(auto [__VA_ARGS__] = q.top(); q.pop();) +#define popback(q, ...) __AS_PROCEDURE(auto [__VA_ARGS__] = q.back(); q.pop_back();) +#define popfront(q, ...) __AS_PROCEDURE(auto [__VA_ARGS__] = q.front();q.pop_front();) + +/* math */ +template +return_t qpow(ll b, ll p) { + if (b == 0 and p != 0) return 0; + if (p == 0) return 1; + return_t half = qpow(b, p / 2); + if (p % 2 == 1) return half * half * b; + else return half * half; +} + +#define comb(n, k) ((n) < 0 or (k) < 0 or (n) < (k) ? 0 : fact[n] / fact[k] / fact[(n) - (k)]) + +constexpr inline int lg2(ll x) { return x == 0 ? -1 : sizeof(ll) * 8 - 1 - __builtin_clzll(x); } + +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> decompose(ll x) { + // return (factor, count, factor ** count) + vector> 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 decompose_prime(int N) { + // return (factor, count) + vector 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 calc_next(string t) { // pi function of t + int n = (int)t.length(); + vector 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 calc_z(string t) { // z function of t + int m = t.length(); + vector z; + z.push_back(m); + pair 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 kmp(string s, string t) { // find all t in s + string cur = t + '#' + s; + int sz1 = s.size(), sz2 = t.size(); + vector v; + vector 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(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 struct MLL { + ll val; + MLL(ll v = 0) : val(mod(v, mdl)) {} + MLL(const MLL& 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 * mod(inverse(rhs.val, mdl), 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; } + void operator+=(const MLL& rhs) { val = (*this + rhs).val; } + void operator-=(const MLL& rhs) { val = (*this - rhs).val; } + void operator*=(const MLL& rhs) { val = (*this * rhs).val; } + void operator/=(const MLL& rhs) { val = (*this / rhs).val; } + void operator%=(const MLL& rhs) { val = (*this % rhs).val; } +}; +struct MLLd { + ll val, mdl; + MLLd(ll mdl, ll v = 0) : mdl(mdl), val(mod(v, mdl)) {} + MLLd(const MLLd& other) : mdl(other.mdl), val(other.val) {} + friend MLLd operator+(const MLLd& lhs, const MLLd& rhs) { return MLLd(lhs.mdl, mod(lhs.val + rhs.val, lhs.mdl)); } + friend MLLd operator-(const MLLd& lhs, const MLLd& rhs) { return MLLd(lhs.mdl, mod(lhs.val - rhs.val, lhs.mdl)); } + friend MLLd operator*(const MLLd& lhs, const MLLd& rhs) { return MLLd(lhs.mdl, mod(lhs.val * rhs.val, lhs.mdl)); } + friend MLLd operator/(const MLLd& lhs, const MLLd& rhs) { return MLLd(lhs.mdl, mod(lhs.val * mod(inverse(rhs.val, lhs.mdl), lhs.mdl), lhs.mdl)); } + friend MLLd operator%(const MLLd& lhs, const MLLd& rhs) { return MLLd(lhs.mdl, mod(lhs.val - (lhs / rhs).val, lhs.mdl)); } + friend bool operator==(const MLLd& lhs, const MLLd& rhs) { return lhs.val == rhs.val; } + friend bool operator!=(const MLLd& lhs, const MLLd& rhs) { return lhs.val != rhs.val; } + void operator+=(const MLLd& rhs) { val = (*this + rhs).val; } + void operator-=(const MLLd& rhs) { val = (*this - rhs).val; } + void operator*=(const MLLd& rhs) { val = (*this * rhs).val; } + void operator/=(const MLLd& rhs) { val = (*this / rhs).val; } + void operator%=(const MLLd& rhs) { val = (*this % rhs).val; } +}; + +template +ostream& operator<<(ostream& out, const MLL& num) { + return out << num.val; +} + +ostream& operator<<(ostream& out, const MLLd& num) { + return out << num.val; +} + +template +istream& operator>>(istream& in, MLL& num) { + return in >> num.val; +} + +istream& operator>>(istream& in, MLLd& num) { + return in >> num.val; +} + +// miscancellous +#define functor(func) [&](auto&&... val) \ +noexcept(noexcept(func(std::forward(val)...))) -> decltype(auto) \ +{return func(std::forward(val)...);} +template 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 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 +vector> zip(Iterator_T a_first, Iterator_T a_last, Iterator_U b_first, Iterator_U b_last) { + vector> 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 +vector> zip_n(Iterator_T a_first, Iterator_U b_first, size_t n) { + vector> 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 +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& operator++() { ++value; return *this; } + ArithmeticIterator& operator--() { --value; return *this; } + bool operator==(const ArithmeticIterator& rhs) const { return value == rhs.value; } +}; +template vector> enumerate(const vector& container) { + return zip(ArithmeticIterator(0), ArithmeticIterator(INT_MAX), container.begin(), container.end()); +} +///////////////////////////////////////////////////////// + +// #define SINGLE_TEST_CASE +// #define DUMP_TEST_CASE 7219 +// #define TOT_TEST_CASE 10000 + +void dump() {} + +void dump_ignore() {} + +void prep() { +} + +void solve() { + read(int, n); + adj(ch, n); + for (int i = 2; i <= n; ++i) { + read(int, p); + edge(ch, i, p); + } + vector target(n + 1); + for (int i = 1; i <= n; ++i) { + cin >> target[i]; + } + int res = 0; + auto dfs = [&] (auto dfs, int v, int pa) -> ll { + ll sum = 0; + for (auto&& u : ch[v]) { + if (u == pa) continue; + sum += dfs(dfs, u, v); + } + if (sum >= target[v].second) { + sum = target[v].second; + } else if (sum < target[v].first) { + sum = target[v].second; + res += 1; + } + return sum; + }; + dfs(dfs, 1, 0); + cout << res << '\n'; +} + +int main() { +#if __cplusplus < 201402L or defined(_MSC_VER) and not defined(__clang__) + 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 +} diff --git a/src/bin/cf-1702f.cc b/src/bin/cf-1702f.cc new file mode 100644 index 0000000..0d8e741 --- /dev/null +++ b/src/bin/cf-1702f.cc @@ -0,0 +1,550 @@ +/** + * Author: subcrip + * Created: 2024-06-03 15:39:47 + * Modified: 2024-06-03 16:27:08 + * Elapsed: 47 minutes + */ + +#pragma GCC optimize("Ofast") +///////////////////////////////////////////////////////// +/** + * This code should require C++14. + * However, it's only been tested with C++17. + */ + +#include +using namespace std; + +/* macro helpers */ +#define __NARGS(...) std::tuple_size::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::type + +/* 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; +using ld = long double; +#endif +using int128 = __int128_t; +using uint128 = __uint128_t; +using ld = long double; +using pii = pair; +using pil = pair; +using pli = pair; +using pll = pair; +using pid = pair; +using pdi = pair; +using pld = pair; +using pdl = pair; +using pdd = pair; +using tlll = tuple; +using tlld = tuple; +using tlli = tuple; +using tldl = tuple; +using tldd = tuple; +using tldi = tuple; +using tlil = tuple; +using tlid = tuple; +using tlii = tuple; +using tdll = tuple; +using tdld = tuple; +using tdli = tuple; +using tddl = tuple; +using tddd = tuple; +using tddi = tuple; +using tdil = tuple; +using tdid = tuple; +using tdii = tuple; +using till = tuple; +using tild = tuple; +using tili = tuple; +using tidl = tuple; +using tidd = tuple; +using tidi = tuple; +using tiil = tuple; +using tiid = tuple; +using tiii = tuple; +template using max_heap = priority_queue; +template using min_heap = priority_queue, greater<>>; +template using oi = ostream_iterator; +template using ii = istream_iterator; + +/* constants */ +constexpr int INF = 0x3f3f3f3f; +constexpr ll INFLL = 0x3f3f3f3f3f3f3f3fLL; +constexpr ll MDL = 1e9 + 7; +constexpr ll PRIME = 998'244'353; +constexpr ll MDL1 = 8784491; +constexpr ll MDL2 = PRIME; +constexpr int128 INT128_MAX = numeric_limits::max(); +constexpr uint128 UINT128_MAX = numeric_limits::max(); +constexpr int128 INT128_MIN = numeric_limits::min(); +constexpr uint128 UINT128_MIN = numeric_limits::min(); + +/* random */ + +mt19937 rd(chrono::duration_cast(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 +#define ugt std::greater + +#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 + size_t operator()(const pair& 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 dist(PRIME); +const size_t __array_hash_b = 31, __array_hash_mdl1 = dist(rd), __array_hash_mdl2 = dist(rd); +struct array_hash { + template + size_t operator()(const Sequence& arr) const { + size_t pw1 = 1, pw2 = 1; + size_t res1 = 0, res2 = 0; + for (auto&& x : arr) { + res1 = (res1 + x * pw1) % __array_hash_mdl1; + res2 = (res2 + x * 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 pa(a) __AS_PROCEDURE(__typeof(a) pa; pa.push_back({}); for (auto&&x : a) pa.push_back(pa.back() + x);) +#define sa(a) __AS_PROCEDURE(__typeof(a) sa(a.size() + 1); {int n = a.size(); for (int i = n - 1; i >= 0; --i) sa[i] = sa[i + 1] + a[i];};) +#define adj(ch, n) __AS_PROCEDURE(vector> 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, w) __AS_PROCEDURE(ch[u].emplace_back(v, w), ch[v].emplace_back(u, w);) +#define Edge(ch, u, v) __AS_PROCEDURE(ch[u].push_back(v);) +#define Edgew(ch, u, v, w) __AS_PROCEDURE(ch[u].emplace_back(v, w);) +template pair> discretize(Iterator __first, Iterator __last) { + set st(__first, __last); + size_t N = 0; + map mp; + for (auto&& x : st) mp[x] = ++N; + return {N, mp}; +} +template pair> unordered_discretize(Iterator __first, Iterator __last) { + set st(__first, __last); + size_t N = 0; + unordered_map 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)) +template void __read(T& x) { cin >> x; } +template void __read(T& x, U&... args) { cin >> x; __read(args...); } +#define read(type, ...) __AS_PROCEDURE(type __VA_ARGS__; __read(__VA_ARGS__);) +#define readvec(type, a, n) __AS_PROCEDURE(vector a(n); for (auto& x : a) cin >> x;) +#define readvec1(type, a, n) __AS_PROCEDURE(vector a((n) + 1); copy_n(ii(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;) +template istream& operator>>(istream& in, pair& p) { + return in >> p.first >> p.second; +} +template ostream& operator<<(ostream& out, const pair& p) { + out << "{" << p.first << ", " << p.second << "}"; + return out; +} +template +void print_tuple_impl(std::basic_ostream& os, const Tuple& t, std::index_sequence) { + using swallow = int[]; // guaranties left to right order + (void)swallow { 0, (void(os << (Index == 0 ? "" : ", ") << std::get(t)), 0)... }; +} +template +decltype(auto) operator<<(std::basic_ostream& os, const std::tuple& t) { + os << "{"; + print_tuple_impl(os, t, std::index_sequence_for{}); + return os << "}"; +} +template ostream& operator<<(ostream& out, const vector& 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; +} + +/* pops */ +#define poptop(q, ...) __AS_PROCEDURE(auto [__VA_ARGS__] = q.top(); q.pop();) +#define popback(q, ...) __AS_PROCEDURE(auto [__VA_ARGS__] = q.back(); q.pop_back();) +#define popfront(q, ...) __AS_PROCEDURE(auto [__VA_ARGS__] = q.front();q.pop_front();) + +/* math */ +template +return_t qpow(ll b, ll p) { + if (b == 0 and p != 0) return 0; + if (p == 0) return 1; + return_t half = qpow(b, p / 2); + if (p % 2 == 1) return half * half * b; + else return half * half; +} + +#define comb(n, k) ((n) < 0 or (k) < 0 or (n) < (k) ? 0 : fact[n] / fact[k] / fact[(n) - (k)]) + +constexpr inline int lg2(ll x) { return x == 0 ? -1 : sizeof(ll) * 8 - 1 - __builtin_clzll(x); } + +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> decompose(ll x) { + // return (factor, count, factor ** count) + vector> 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 decompose_prime(int N) { + // return (factor, count) + vector 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 calc_next(string t) { // pi function of t + int n = (int)t.length(); + vector 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 calc_z(string t) { // z function of t + int m = t.length(); + vector z; + z.push_back(m); + pair 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 kmp(string s, string t) { // find all t in s + string cur = t + '#' + s; + int sz1 = s.size(), sz2 = t.size(); + vector v; + vector 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(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 struct MLL { + ll val; + MLL(ll v = 0) : val(mod(v, mdl)) {} + MLL(const MLL& 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 * mod(inverse(rhs.val, mdl), 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; } + void operator+=(const MLL& rhs) { val = (*this + rhs).val; } + void operator-=(const MLL& rhs) { val = (*this - rhs).val; } + void operator*=(const MLL& rhs) { val = (*this * rhs).val; } + void operator/=(const MLL& rhs) { val = (*this / rhs).val; } + void operator%=(const MLL& rhs) { val = (*this % rhs).val; } +}; +struct MLLd { + ll val, mdl; + MLLd(ll mdl, ll v = 0) : mdl(mdl), val(mod(v, mdl)) {} + MLLd(const MLLd& other) : mdl(other.mdl), val(other.val) {} + friend MLLd operator+(const MLLd& lhs, const MLLd& rhs) { return MLLd(lhs.mdl, mod(lhs.val + rhs.val, lhs.mdl)); } + friend MLLd operator-(const MLLd& lhs, const MLLd& rhs) { return MLLd(lhs.mdl, mod(lhs.val - rhs.val, lhs.mdl)); } + friend MLLd operator*(const MLLd& lhs, const MLLd& rhs) { return MLLd(lhs.mdl, mod(lhs.val * rhs.val, lhs.mdl)); } + friend MLLd operator/(const MLLd& lhs, const MLLd& rhs) { return MLLd(lhs.mdl, mod(lhs.val * mod(inverse(rhs.val, lhs.mdl), lhs.mdl), lhs.mdl)); } + friend MLLd operator%(const MLLd& lhs, const MLLd& rhs) { return MLLd(lhs.mdl, mod(lhs.val - (lhs / rhs).val, lhs.mdl)); } + friend bool operator==(const MLLd& lhs, const MLLd& rhs) { return lhs.val == rhs.val; } + friend bool operator!=(const MLLd& lhs, const MLLd& rhs) { return lhs.val != rhs.val; } + void operator+=(const MLLd& rhs) { val = (*this + rhs).val; } + void operator-=(const MLLd& rhs) { val = (*this - rhs).val; } + void operator*=(const MLLd& rhs) { val = (*this * rhs).val; } + void operator/=(const MLLd& rhs) { val = (*this / rhs).val; } + void operator%=(const MLLd& rhs) { val = (*this % rhs).val; } +}; + +template +ostream& operator<<(ostream& out, const MLL& num) { + return out << num.val; +} + +ostream& operator<<(ostream& out, const MLLd& num) { + return out << num.val; +} + +template +istream& operator>>(istream& in, MLL& num) { + return in >> num.val; +} + +istream& operator>>(istream& in, MLLd& num) { + return in >> num.val; +} + +// miscancellous +#define functor(func) [&](auto&&... val) \ +noexcept(noexcept(func(std::forward(val)...))) -> decltype(auto) \ +{return func(std::forward(val)...);} +template 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 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 +vector> zip(Iterator_T a_first, Iterator_T a_last, Iterator_U b_first, Iterator_U b_last) { + vector> 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 +vector> zip_n(Iterator_T a_first, Iterator_U b_first, size_t n) { + vector> 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 +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& operator++() { ++value; return *this; } + ArithmeticIterator& operator--() { --value; return *this; } + bool operator==(const ArithmeticIterator& rhs) const { return value == rhs.value; } +}; +template vector> enumerate(const vector& container) { + return zip(ArithmeticIterator(0), ArithmeticIterator(INT_MAX), container.begin(), container.end()); +} +///////////////////////////////////////////////////////// + +// #define SINGLE_TEST_CASE +// #define DUMP_TEST_CASE 7219 +// #define TOT_TEST_CASE 10000 + +void dump() {} + +void dump_ignore() {} + +void prep() { +} + +void solve() { + read(int, n); + readvec(int, a, n); + readvec(int, b, n); + unordered_map bk; + for (int i = 0; i < n; ++i) { + bk[a[i] >> __builtin_ctz(a[i])] += 1; + } + for (int i = 0; i < n; ++i) { + while (b[i] != 0) { + b[i] >>= __builtin_ctz(b[i]); + if (bk.count(b[i])) { + if (--bk[b[i]] == 0) { + bk.erase(b[i]); + } + break; + } + b[i] >>= 1; + } + } + if (bk.size() == 0) { + cout << "YES\n"; + } else { + cout << "NO\n"; + } +} + +int main() { +#if __cplusplus < 201402L or defined(_MSC_VER) and not defined(__clang__) + 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 +} diff --git a/src/bin/cf-1703g.cc b/src/bin/cf-1703g.cc new file mode 100644 index 0000000..6b9a172 --- /dev/null +++ b/src/bin/cf-1703g.cc @@ -0,0 +1,546 @@ +/** + * Author: subcrip + * Created: 2024-06-03 14:55:45 + * Modified: 2024-06-03 15:26:11 + * Elapsed: 30 minutes + */ + +#pragma GCC optimize("Ofast") +///////////////////////////////////////////////////////// +/** + * This code should require C++14. + * However, it's only been tested with C++17. + */ + +#include +using namespace std; + +/* macro helpers */ +#define __NARGS(...) std::tuple_size::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::type + +/* 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; +using ld = long double; +#endif +using int128 = __int128_t; +using uint128 = __uint128_t; +using ld = long double; +using pii = pair; +using pil = pair; +using pli = pair; +using pll = pair; +using pid = pair; +using pdi = pair; +using pld = pair; +using pdl = pair; +using pdd = pair; +using tlll = tuple; +using tlld = tuple; +using tlli = tuple; +using tldl = tuple; +using tldd = tuple; +using tldi = tuple; +using tlil = tuple; +using tlid = tuple; +using tlii = tuple; +using tdll = tuple; +using tdld = tuple; +using tdli = tuple; +using tddl = tuple; +using tddd = tuple; +using tddi = tuple; +using tdil = tuple; +using tdid = tuple; +using tdii = tuple; +using till = tuple; +using tild = tuple; +using tili = tuple; +using tidl = tuple; +using tidd = tuple; +using tidi = tuple; +using tiil = tuple; +using tiid = tuple; +using tiii = tuple; +template using max_heap = priority_queue; +template using min_heap = priority_queue, greater<>>; +template using oi = ostream_iterator; +template using ii = istream_iterator; + +/* constants */ +constexpr int INF = 0x3f3f3f3f; +constexpr ll INFLL = 0x3f3f3f3f3f3f3f3fLL; +constexpr ll MDL = 1e9 + 7; +constexpr ll PRIME = 998'244'353; +constexpr ll MDL1 = 8784491; +constexpr ll MDL2 = PRIME; +constexpr int128 INT128_MAX = numeric_limits::max(); +constexpr uint128 UINT128_MAX = numeric_limits::max(); +constexpr int128 INT128_MIN = numeric_limits::min(); +constexpr uint128 UINT128_MIN = numeric_limits::min(); + +/* random */ + +mt19937 rd(chrono::duration_cast(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 +#define ugt std::greater + +#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 + size_t operator()(const pair& 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 dist(PRIME); +const size_t __array_hash_b = 31, __array_hash_mdl1 = dist(rd), __array_hash_mdl2 = dist(rd); +struct array_hash { + template + size_t operator()(const Sequence& arr) const { + size_t pw1 = 1, pw2 = 1; + size_t res1 = 0, res2 = 0; + for (auto&& x : arr) { + res1 = (res1 + x * pw1) % __array_hash_mdl1; + res2 = (res2 + x * 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 pa(a) __AS_PROCEDURE(__typeof(a) pa; pa.push_back({}); for (auto&&x : a) pa.push_back(pa.back() + x);) +#define sa(a) __AS_PROCEDURE(__typeof(a) sa(a.size() + 1); {int n = a.size(); for (int i = n - 1; i >= 0; --i) sa[i] = sa[i + 1] + a[i];};) +#define adj(ch, n) __AS_PROCEDURE(vector> 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, w) __AS_PROCEDURE(ch[u].emplace_back(v, w), ch[v].emplace_back(u, w);) +#define Edge(ch, u, v) __AS_PROCEDURE(ch[u].push_back(v);) +#define Edgew(ch, u, v, w) __AS_PROCEDURE(ch[u].emplace_back(v, w);) +template pair> discretize(Iterator __first, Iterator __last) { + set st(__first, __last); + size_t N = 0; + map mp; + for (auto&& x : st) mp[x] = ++N; + return {N, mp}; +} +template pair> unordered_discretize(Iterator __first, Iterator __last) { + set st(__first, __last); + size_t N = 0; + unordered_map 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)) +template void __read(T& x) { cin >> x; } +template void __read(T& x, U&... args) { cin >> x; __read(args...); } +#define read(type, ...) __AS_PROCEDURE(type __VA_ARGS__; __read(__VA_ARGS__);) +#define readvec(type, a, n) __AS_PROCEDURE(vector a(n); for (auto& x : a) cin >> x;) +#define readvec1(type, a, n) __AS_PROCEDURE(vector a((n) + 1); copy_n(ii(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;) +template istream& operator>>(istream& in, pair& p) { + return in >> p.first >> p.second; +} +template ostream& operator<<(ostream& out, const pair& p) { + out << "{" << p.first << ", " << p.second << "}"; + return out; +} +template +void print_tuple_impl(std::basic_ostream& os, const Tuple& t, std::index_sequence) { + using swallow = int[]; // guaranties left to right order + (void)swallow { 0, (void(os << (Index == 0 ? "" : ", ") << std::get(t)), 0)... }; +} +template +decltype(auto) operator<<(std::basic_ostream& os, const std::tuple& t) { + os << "{"; + print_tuple_impl(os, t, std::index_sequence_for{}); + return os << "}"; +} +template ostream& operator<<(ostream& out, const vector& 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; +} + +/* pops */ +#define poptop(q, ...) __AS_PROCEDURE(auto [__VA_ARGS__] = q.top(); q.pop();) +#define popback(q, ...) __AS_PROCEDURE(auto [__VA_ARGS__] = q.back(); q.pop_back();) +#define popfront(q, ...) __AS_PROCEDURE(auto [__VA_ARGS__] = q.front();q.pop_front();) + +/* math */ +template +return_t qpow(ll b, ll p) { + if (b == 0 and p != 0) return 0; + if (p == 0) return 1; + return_t half = qpow(b, p / 2); + if (p % 2 == 1) return half * half * b; + else return half * half; +} + +#define comb(n, k) ((n) < 0 or (k) < 0 or (n) < (k) ? 0 : fact[n] / fact[k] / fact[(n) - (k)]) + +constexpr inline int lg2(ll x) { return x == 0 ? -1 : sizeof(ll) * 8 - 1 - __builtin_clzll(x); } + +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> decompose(ll x) { + // return (factor, count, factor ** count) + vector> 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 decompose_prime(int N) { + // return (factor, count) + vector 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 calc_next(string t) { // pi function of t + int n = (int)t.length(); + vector 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 calc_z(string t) { // z function of t + int m = t.length(); + vector z; + z.push_back(m); + pair 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 kmp(string s, string t) { // find all t in s + string cur = t + '#' + s; + int sz1 = s.size(), sz2 = t.size(); + vector v; + vector 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(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 struct MLL { + ll val; + MLL(ll v = 0) : val(mod(v, mdl)) {} + MLL(const MLL& 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 * mod(inverse(rhs.val, mdl), 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; } + void operator+=(const MLL& rhs) { val = (*this + rhs).val; } + void operator-=(const MLL& rhs) { val = (*this - rhs).val; } + void operator*=(const MLL& rhs) { val = (*this * rhs).val; } + void operator/=(const MLL& rhs) { val = (*this / rhs).val; } + void operator%=(const MLL& rhs) { val = (*this % rhs).val; } +}; +struct MLLd { + ll val, mdl; + MLLd(ll mdl, ll v = 0) : mdl(mdl), val(mod(v, mdl)) {} + MLLd(const MLLd& other) : mdl(other.mdl), val(other.val) {} + friend MLLd operator+(const MLLd& lhs, const MLLd& rhs) { return MLLd(lhs.mdl, mod(lhs.val + rhs.val, lhs.mdl)); } + friend MLLd operator-(const MLLd& lhs, const MLLd& rhs) { return MLLd(lhs.mdl, mod(lhs.val - rhs.val, lhs.mdl)); } + friend MLLd operator*(const MLLd& lhs, const MLLd& rhs) { return MLLd(lhs.mdl, mod(lhs.val * rhs.val, lhs.mdl)); } + friend MLLd operator/(const MLLd& lhs, const MLLd& rhs) { return MLLd(lhs.mdl, mod(lhs.val * mod(inverse(rhs.val, lhs.mdl), lhs.mdl), lhs.mdl)); } + friend MLLd operator%(const MLLd& lhs, const MLLd& rhs) { return MLLd(lhs.mdl, mod(lhs.val - (lhs / rhs).val, lhs.mdl)); } + friend bool operator==(const MLLd& lhs, const MLLd& rhs) { return lhs.val == rhs.val; } + friend bool operator!=(const MLLd& lhs, const MLLd& rhs) { return lhs.val != rhs.val; } + void operator+=(const MLLd& rhs) { val = (*this + rhs).val; } + void operator-=(const MLLd& rhs) { val = (*this - rhs).val; } + void operator*=(const MLLd& rhs) { val = (*this * rhs).val; } + void operator/=(const MLLd& rhs) { val = (*this / rhs).val; } + void operator%=(const MLLd& rhs) { val = (*this % rhs).val; } +}; + +template +ostream& operator<<(ostream& out, const MLL& num) { + return out << num.val; +} + +ostream& operator<<(ostream& out, const MLLd& num) { + return out << num.val; +} + +template +istream& operator>>(istream& in, MLL& num) { + return in >> num.val; +} + +istream& operator>>(istream& in, MLLd& num) { + return in >> num.val; +} + +// miscancellous +#define functor(func) [&](auto&&... val) \ +noexcept(noexcept(func(std::forward(val)...))) -> decltype(auto) \ +{return func(std::forward(val)...);} +template 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 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 +vector> zip(Iterator_T a_first, Iterator_T a_last, Iterator_U b_first, Iterator_U b_last) { + vector> 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 +vector> zip_n(Iterator_T a_first, Iterator_U b_first, size_t n) { + vector> 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 +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& operator++() { ++value; return *this; } + ArithmeticIterator& operator--() { --value; return *this; } + bool operator==(const ArithmeticIterator& rhs) const { return value == rhs.value; } +}; +template vector> enumerate(const vector& container) { + return zip(ArithmeticIterator(0), ArithmeticIterator(INT_MAX), container.begin(), container.end()); +} +///////////////////////////////////////////////////////// + +// #define SINGLE_TEST_CASE +// #define DUMP_TEST_CASE 7219 +// #define TOT_TEST_CASE 10000 + +void dump() {} + +void dump_ignore() {} + +void prep() { +} + +void solve() { + constexpr ll m = lg2(MDL) + 2; + read(ll, n, k); + readvec(ll, a, n); + ll sum = accumulate(a.begin(), a.end(), ll(0)); + vector> ss(n + 1, vector(m)); + for (ll j = 1; j < m; ++j) { + for (ll i = n - 1; ~i; --i) { + ss[i][j] = ss[i + 1][j] + a[i] - a[i] / 2; + a[i] /= 2; + } + } + vector> dp(n + 1, vector(m, INFLL)); + dp[0][0] = 0; + for (ll i = 1; i <= n; ++i) { + dp[i][0] = dp[i - 1][0] + k; + for (ll j = 1; j < m; ++j) { + dp[i][j] = min(dp[i - 1][j] + k, dp[i - 1][j - 1] + ss[i - 1][j]); + } + } + cout << sum - *min_element(dp[n].begin(), dp[n].end()) << '\n'; +} + +int main() { +#if __cplusplus < 201402L or defined(_MSC_VER) and not defined(__clang__) + 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 +} diff --git a/src/bin/cf-1707b.cc b/src/bin/cf-1707b.cc new file mode 100644 index 0000000..9e82f16 --- /dev/null +++ b/src/bin/cf-1707b.cc @@ -0,0 +1,580 @@ +/** + * Author: subcrip + * Created: 2024-06-03 12:01:51 + * Modified: 2024-06-03 14:07:12 + * Elapsed: 125 minutes + */ + +#pragma GCC optimize("Ofast") +///////////////////////////////////////////////////////// +/** + * This code should require C++14. + * However, it's only been tested with C++17. + */ + +#include +using namespace std; + +/* macro helpers */ +#define __NARGS(...) std::tuple_size::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::type + +/* 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; +using ld = long double; +#endif +using int128 = __int128_t; +using uint128 = __uint128_t; +using ld = long double; +using pii = pair; +using pil = pair; +using pli = pair; +using pll = pair; +using pid = pair; +using pdi = pair; +using pld = pair; +using pdl = pair; +using pdd = pair; +using tlll = tuple; +using tlld = tuple; +using tlli = tuple; +using tldl = tuple; +using tldd = tuple; +using tldi = tuple; +using tlil = tuple; +using tlid = tuple; +using tlii = tuple; +using tdll = tuple; +using tdld = tuple; +using tdli = tuple; +using tddl = tuple; +using tddd = tuple; +using tddi = tuple; +using tdil = tuple; +using tdid = tuple; +using tdii = tuple; +using till = tuple; +using tild = tuple; +using tili = tuple; +using tidl = tuple; +using tidd = tuple; +using tidi = tuple; +using tiil = tuple; +using tiid = tuple; +using tiii = tuple; +template using max_heap = priority_queue; +template using min_heap = priority_queue, greater<>>; +template using oi = ostream_iterator; +template using ii = istream_iterator; + +/* constants */ +constexpr int INF = 0x3f3f3f3f; +constexpr ll INFLL = 0x3f3f3f3f3f3f3f3fLL; +constexpr ll MDL = 1e9 + 7; +constexpr ll PRIME = 998'244'353; +constexpr ll MDL1 = 8784491; +constexpr ll MDL2 = PRIME; +constexpr int128 INT128_MAX = numeric_limits::max(); +constexpr uint128 UINT128_MAX = numeric_limits::max(); +constexpr int128 INT128_MIN = numeric_limits::min(); +constexpr uint128 UINT128_MIN = numeric_limits::min(); + +/* random */ + +mt19937 rd(chrono::duration_cast(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 +#define ugt std::greater + +#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 + size_t operator()(const pair& 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 dist(PRIME); +const size_t __array_hash_b = 31, __array_hash_mdl1 = dist(rd), __array_hash_mdl2 = dist(rd); +struct array_hash { + template + size_t operator()(const Sequence& arr) const { + size_t pw1 = 1, pw2 = 1; + size_t res1 = 0, res2 = 0; + for (auto&& x : arr) { + res1 = (res1 + x * pw1) % __array_hash_mdl1; + res2 = (res2 + x * 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 pa(a) __AS_PROCEDURE(__typeof(a) pa; pa.push_back({}); for (auto&&x : a) pa.push_back(pa.back() + x);) +#define sa(a) __AS_PROCEDURE(__typeof(a) sa(a.size() + 1); {int n = a.size(); for (int i = n - 1; i >= 0; --i) sa[i] = sa[i + 1] + a[i];};) +#define adj(ch, n) __AS_PROCEDURE(vector> 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, w) __AS_PROCEDURE(ch[u].emplace_back(v, w), ch[v].emplace_back(u, w);) +#define Edge(ch, u, v) __AS_PROCEDURE(ch[u].push_back(v);) +#define Edgew(ch, u, v, w) __AS_PROCEDURE(ch[u].emplace_back(v, w);) +template pair> discretize(Iterator __first, Iterator __last) { + set st(__first, __last); + size_t N = 0; + map mp; + for (auto&& x : st) mp[x] = ++N; + return {N, mp}; +} +template pair> unordered_discretize(Iterator __first, Iterator __last) { + set st(__first, __last); + size_t N = 0; + unordered_map 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)) +template void __read(T& x) { cin >> x; } +template void __read(T& x, U&... args) { cin >> x; __read(args...); } +#define read(type, ...) __AS_PROCEDURE(type __VA_ARGS__; __read(__VA_ARGS__);) +#define readvec(type, a, n) __AS_PROCEDURE(vector a(n); for (auto& x : a) cin >> x;) +#define readvec1(type, a, n) __AS_PROCEDURE(vector a((n) + 1); copy_n(ii(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;) +template istream& operator>>(istream& in, pair& p) { + return in >> p.first >> p.second; +} +template ostream& operator<<(ostream& out, const pair& p) { + out << "{" << p.first << ", " << p.second << "}"; + return out; +} +template +void print_tuple_impl(std::basic_ostream& os, const Tuple& t, std::index_sequence) { + using swallow = int[]; // guaranties left to right order + (void)swallow { 0, (void(os << (Index == 0 ? "" : ", ") << std::get(t)), 0)... }; +} +template +decltype(auto) operator<<(std::basic_ostream& os, const std::tuple& t) { + os << "{"; + print_tuple_impl(os, t, std::index_sequence_for{}); + return os << "}"; +} +template ostream& operator<<(ostream& out, const vector& 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; +} + +/* pops */ +#define poptop(q, ...) __AS_PROCEDURE(auto [__VA_ARGS__] = q.top(); q.pop();) +#define popback(q, ...) __AS_PROCEDURE(auto [__VA_ARGS__] = q.back(); q.pop_back();) +#define popfront(q, ...) __AS_PROCEDURE(auto [__VA_ARGS__] = q.front();q.pop_front();) + +/* math */ +template +return_t qpow(ll b, ll p) { + if (b == 0 and p != 0) return 0; + if (p == 0) return 1; + return_t half = qpow(b, p / 2); + if (p % 2 == 1) return half * half * b; + else return half * half; +} + +#define comb(n, k) ((n) < 0 or (k) < 0 or (n) < (k) ? 0 : fact[n] / fact[k] / fact[(n) - (k)]) + +constexpr inline int lg2(ll x) { return x == 0 ? -1 : sizeof(ll) * 8 - 1 - __builtin_clzll(x); } + +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> decompose(ll x) { + // return (factor, count, factor ** count) + vector> 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 decompose_prime(int N) { + // return (factor, count) + vector 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 calc_next(string t) { // pi function of t + int n = (int)t.length(); + vector 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 calc_z(string t) { // z function of t + int m = t.length(); + vector z; + z.push_back(m); + pair 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 kmp(string s, string t) { // find all t in s + string cur = t + '#' + s; + int sz1 = s.size(), sz2 = t.size(); + vector v; + vector 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(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 struct MLL { + ll val; + MLL(ll v = 0) : val(mod(v, mdl)) {} + MLL(const MLL& 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 * mod(inverse(rhs.val, mdl), 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; } + void operator+=(const MLL& rhs) { val = (*this + rhs).val; } + void operator-=(const MLL& rhs) { val = (*this - rhs).val; } + void operator*=(const MLL& rhs) { val = (*this * rhs).val; } + void operator/=(const MLL& rhs) { val = (*this / rhs).val; } + void operator%=(const MLL& rhs) { val = (*this % rhs).val; } +}; +struct MLLd { + ll val, mdl; + MLLd(ll mdl, ll v = 0) : mdl(mdl), val(mod(v, mdl)) {} + MLLd(const MLLd& other) : mdl(other.mdl), val(other.val) {} + friend MLLd operator+(const MLLd& lhs, const MLLd& rhs) { return MLLd(lhs.mdl, mod(lhs.val + rhs.val, lhs.mdl)); } + friend MLLd operator-(const MLLd& lhs, const MLLd& rhs) { return MLLd(lhs.mdl, mod(lhs.val - rhs.val, lhs.mdl)); } + friend MLLd operator*(const MLLd& lhs, const MLLd& rhs) { return MLLd(lhs.mdl, mod(lhs.val * rhs.val, lhs.mdl)); } + friend MLLd operator/(const MLLd& lhs, const MLLd& rhs) { return MLLd(lhs.mdl, mod(lhs.val * mod(inverse(rhs.val, lhs.mdl), lhs.mdl), lhs.mdl)); } + friend MLLd operator%(const MLLd& lhs, const MLLd& rhs) { return MLLd(lhs.mdl, mod(lhs.val - (lhs / rhs).val, lhs.mdl)); } + friend bool operator==(const MLLd& lhs, const MLLd& rhs) { return lhs.val == rhs.val; } + friend bool operator!=(const MLLd& lhs, const MLLd& rhs) { return lhs.val != rhs.val; } + void operator+=(const MLLd& rhs) { val = (*this + rhs).val; } + void operator-=(const MLLd& rhs) { val = (*this - rhs).val; } + void operator*=(const MLLd& rhs) { val = (*this * rhs).val; } + void operator/=(const MLLd& rhs) { val = (*this / rhs).val; } + void operator%=(const MLLd& rhs) { val = (*this % rhs).val; } +}; + +template +ostream& operator<<(ostream& out, const MLL& num) { + return out << num.val; +} + +ostream& operator<<(ostream& out, const MLLd& num) { + return out << num.val; +} + +template +istream& operator>>(istream& in, MLL& num) { + return in >> num.val; +} + +istream& operator>>(istream& in, MLLd& num) { + return in >> num.val; +} + +// miscancellous +#define functor(func) [&](auto&&... val) \ +noexcept(noexcept(func(std::forward(val)...))) -> decltype(auto) \ +{return func(std::forward(val)...);} +template 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 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 +vector> zip(Iterator_T a_first, Iterator_T a_last, Iterator_U b_first, Iterator_U b_last) { + vector> 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 +vector> zip_n(Iterator_T a_first, Iterator_U b_first, size_t n) { + vector> 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 +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& operator++() { ++value; return *this; } + ArithmeticIterator& operator--() { --value; return *this; } + bool operator==(const ArithmeticIterator& rhs) const { return value == rhs.value; } +}; +template vector> enumerate(const vector& container) { + return zip(ArithmeticIterator(0), ArithmeticIterator(INT_MAX), container.begin(), container.end()); +} +///////////////////////////////////////////////////////// + +// #define SINGLE_TEST_CASE +// #define DUMP_TEST_CASE 7219 +// #define TOT_TEST_CASE 10000 + +void dump() {} + +void dump_ignore() {} + +void prep() { +} + +void solve() { + read(int, n); + vector a, b; + int m = 0; + int prev = -1; + int zeros = 0; + int first = 0; + for (int i = 0; i < n; ++i) { + read(int, x); + if (x == 0) { + first = 1; + } + if (x != prev) { + if (prev == 0) first = 1; + a.emplace_back(x); + m += 1; + prev = x; + } else { + zeros += 1; + } + } + for (int i = 0; i < n - 1; ++i) { + int m = a.size(); + if (m <= 1) { + break; + } + // debug(a); + // debug(zeros); + set oc; + if (first) { + oc.emplace(a[0]); + } + if (zeros) { + first = 1; + zeros -= 1; + } else { + first = 0; + } + for (int i = 1; i < m; ++i) { + if (oc.count(a[i] - a[i - 1])) { + zeros += 1; + } else { + oc.emplace(a[i] - a[i - 1]); + } + } + a.clear(); + for (auto&& x : oc) { + a.emplace_back(x); + } + } + if (m == 0) { + cout << 0 << '\n'; + } else { + cout << a[0] << '\n'; + } +} + +int main() { +#if __cplusplus < 201402L or defined(_MSC_VER) and not defined(__clang__) + 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 +} diff --git a/src/bin/cf-1709c.cc b/src/bin/cf-1709c.cc new file mode 100644 index 0000000..0d7a6ec --- /dev/null +++ b/src/bin/cf-1709c.cc @@ -0,0 +1,579 @@ +/** + * Author: subcrip + * Created: 2024-06-02 23:15:35 + * Modified: 2024-06-03 00:11:27 + * Elapsed: 55 minutes + */ + +#pragma GCC optimize("Ofast") +///////////////////////////////////////////////////////// +/** + * This code should require C++14. + * However, it's only been tested with C++17. + */ + +#include +using namespace std; + +/* macro helpers */ +#define __NARGS(...) std::tuple_size::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::type + +/* 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; +using ld = long double; +#endif +using int128 = __int128_t; +using uint128 = __uint128_t; +using ld = long double; +using pii = pair; +using pil = pair; +using pli = pair; +using pll = pair; +using pid = pair; +using pdi = pair; +using pld = pair; +using pdl = pair; +using pdd = pair; +using tlll = tuple; +using tlld = tuple; +using tlli = tuple; +using tldl = tuple; +using tldd = tuple; +using tldi = tuple; +using tlil = tuple; +using tlid = tuple; +using tlii = tuple; +using tdll = tuple; +using tdld = tuple; +using tdli = tuple; +using tddl = tuple; +using tddd = tuple; +using tddi = tuple; +using tdil = tuple; +using tdid = tuple; +using tdii = tuple; +using till = tuple; +using tild = tuple; +using tili = tuple; +using tidl = tuple; +using tidd = tuple; +using tidi = tuple; +using tiil = tuple; +using tiid = tuple; +using tiii = tuple; +template using max_heap = priority_queue; +template using min_heap = priority_queue, greater<>>; +template using oi = ostream_iterator; +template using ii = istream_iterator; + +/* constants */ +constexpr int INF = 0x3f3f3f3f; +constexpr ll INFLL = 0x3f3f3f3f3f3f3f3fLL; +constexpr ll MDL = 1e9 + 7; +constexpr ll PRIME = 998'244'353; +constexpr ll MDL1 = 8784491; +constexpr ll MDL2 = PRIME; +constexpr int128 INT128_MAX = numeric_limits::max(); +constexpr uint128 UINT128_MAX = numeric_limits::max(); +constexpr int128 INT128_MIN = numeric_limits::min(); +constexpr uint128 UINT128_MIN = numeric_limits::min(); + +/* random */ + +mt19937 rd(chrono::duration_cast(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 +#define ugt std::greater + +#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 + size_t operator()(const pair& 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 dist(PRIME); +const size_t __array_hash_b = 31, __array_hash_mdl1 = dist(rd), __array_hash_mdl2 = dist(rd); +struct array_hash { + template + size_t operator()(const Sequence& arr) const { + size_t pw1 = 1, pw2 = 1; + size_t res1 = 0, res2 = 0; + for (auto&& x : arr) { + res1 = (res1 + x * pw1) % __array_hash_mdl1; + res2 = (res2 + x * 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 pa(a) __AS_PROCEDURE(__typeof(a) pa; pa.push_back({}); for (auto&&x : a) pa.push_back(pa.back() + x);) +#define sa(a) __AS_PROCEDURE(__typeof(a) sa(a.size() + 1); {int n = a.size(); for (int i = n - 1; i >= 0; --i) sa[i] = sa[i + 1] + a[i];};) +#define adj(ch, n) __AS_PROCEDURE(vector> 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, w) __AS_PROCEDURE(ch[u].emplace_back(v, w), ch[v].emplace_back(u, w);) +#define Edge(ch, u, v) __AS_PROCEDURE(ch[u].push_back(v);) +#define Edgew(ch, u, v, w) __AS_PROCEDURE(ch[u].emplace_back(v, w);) +template pair> discretize(Iterator __first, Iterator __last) { + set st(__first, __last); + size_t N = 0; + map mp; + for (auto&& x : st) mp[x] = ++N; + return {N, mp}; +} +template pair> unordered_discretize(Iterator __first, Iterator __last) { + set st(__first, __last); + size_t N = 0; + unordered_map 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)) +template void __read(T& x) { cin >> x; } +template void __read(T& x, U&... args) { cin >> x; __read(args...); } +#define read(type, ...) __AS_PROCEDURE(type __VA_ARGS__; __read(__VA_ARGS__);) +#define readvec(type, a, n) __AS_PROCEDURE(vector a(n); for (auto& x : a) cin >> x;) +#define readvec1(type, a, n) __AS_PROCEDURE(vector a((n) + 1); copy_n(ii(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;) +template istream& operator>>(istream& in, pair& p) { + return in >> p.first >> p.second; +} +template ostream& operator<<(ostream& out, const pair& p) { + out << "{" << p.first << ", " << p.second << "}"; + return out; +} +template +void print_tuple_impl(std::basic_ostream& os, const Tuple& t, std::index_sequence) { + using swallow = int[]; // guaranties left to right order + (void)swallow { 0, (void(os << (Index == 0 ? "" : ", ") << std::get(t)), 0)... }; +} +template +decltype(auto) operator<<(std::basic_ostream& os, const std::tuple& t) { + os << "{"; + print_tuple_impl(os, t, std::index_sequence_for{}); + return os << "}"; +} +template ostream& operator<<(ostream& out, const vector& 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; +} + +/* pops */ +#define poptop(q, ...) __AS_PROCEDURE(auto [__VA_ARGS__] = q.top(); q.pop();) +#define popback(q, ...) __AS_PROCEDURE(auto [__VA_ARGS__] = q.back(); q.pop_back();) +#define popfront(q, ...) __AS_PROCEDURE(auto [__VA_ARGS__] = q.front();q.pop_front();) + +/* math */ +template +return_t qpow(ll b, ll p) { + if (b == 0 and p != 0) return 0; + if (p == 0) return 1; + return_t half = qpow(b, p / 2); + if (p % 2 == 1) return half * half * b; + else return half * half; +} + +#define comb(n, k) ((n) < 0 or (k) < 0 or (n) < (k) ? 0 : fact[n] / fact[k] / fact[(n) - (k)]) + +constexpr inline int lg2(ll x) { return x == 0 ? -1 : sizeof(ll) * 8 - 1 - __builtin_clzll(x); } + +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> decompose(ll x) { + // return (factor, count, factor ** count) + vector> 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 decompose_prime(int N) { + // return (factor, count) + vector 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 calc_next(string t) { // pi function of t + int n = (int)t.length(); + vector 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 calc_z(string t) { // z function of t + int m = t.length(); + vector z; + z.push_back(m); + pair 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 kmp(string s, string t) { // find all t in s + string cur = t + '#' + s; + int sz1 = s.size(), sz2 = t.size(); + vector v; + vector 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(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 struct MLL { + ll val; + MLL(ll v = 0) : val(mod(v, mdl)) {} + MLL(const MLL& 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 * mod(inverse(rhs.val, mdl), 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; } + void operator+=(const MLL& rhs) { val = (*this + rhs).val; } + void operator-=(const MLL& rhs) { val = (*this - rhs).val; } + void operator*=(const MLL& rhs) { val = (*this * rhs).val; } + void operator/=(const MLL& rhs) { val = (*this / rhs).val; } + void operator%=(const MLL& rhs) { val = (*this % rhs).val; } +}; +struct MLLd { + ll val, mdl; + MLLd(ll mdl, ll v = 0) : mdl(mdl), val(mod(v, mdl)) {} + MLLd(const MLLd& other) : mdl(other.mdl), val(other.val) {} + friend MLLd operator+(const MLLd& lhs, const MLLd& rhs) { return MLLd(lhs.mdl, mod(lhs.val + rhs.val, lhs.mdl)); } + friend MLLd operator-(const MLLd& lhs, const MLLd& rhs) { return MLLd(lhs.mdl, mod(lhs.val - rhs.val, lhs.mdl)); } + friend MLLd operator*(const MLLd& lhs, const MLLd& rhs) { return MLLd(lhs.mdl, mod(lhs.val * rhs.val, lhs.mdl)); } + friend MLLd operator/(const MLLd& lhs, const MLLd& rhs) { return MLLd(lhs.mdl, mod(lhs.val * mod(inverse(rhs.val, lhs.mdl), lhs.mdl), lhs.mdl)); } + friend MLLd operator%(const MLLd& lhs, const MLLd& rhs) { return MLLd(lhs.mdl, mod(lhs.val - (lhs / rhs).val, lhs.mdl)); } + friend bool operator==(const MLLd& lhs, const MLLd& rhs) { return lhs.val == rhs.val; } + friend bool operator!=(const MLLd& lhs, const MLLd& rhs) { return lhs.val != rhs.val; } + void operator+=(const MLLd& rhs) { val = (*this + rhs).val; } + void operator-=(const MLLd& rhs) { val = (*this - rhs).val; } + void operator*=(const MLLd& rhs) { val = (*this * rhs).val; } + void operator/=(const MLLd& rhs) { val = (*this / rhs).val; } + void operator%=(const MLLd& rhs) { val = (*this % rhs).val; } +}; + +template +ostream& operator<<(ostream& out, const MLL& num) { + return out << num.val; +} + +ostream& operator<<(ostream& out, const MLLd& num) { + return out << num.val; +} + +template +istream& operator>>(istream& in, MLL& num) { + return in >> num.val; +} + +istream& operator>>(istream& in, MLLd& num) { + return in >> num.val; +} + +// miscancellous +#define functor(func) [&](auto&&... val) \ +noexcept(noexcept(func(std::forward(val)...))) -> decltype(auto) \ +{return func(std::forward(val)...);} +template 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 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 +vector> zip(Iterator_T a_first, Iterator_T a_last, Iterator_U b_first, Iterator_U b_last) { + vector> 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 +vector> zip_n(Iterator_T a_first, Iterator_U b_first, size_t n) { + vector> 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 +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& operator++() { ++value; return *this; } + ArithmeticIterator& operator--() { --value; return *this; } + bool operator==(const ArithmeticIterator& rhs) const { return value == rhs.value; } +}; +template vector> enumerate(const vector& container) { + return zip(ArithmeticIterator(0), ArithmeticIterator(INT_MAX), container.begin(), container.end()); +} +///////////////////////////////////////////////////////// + +// #define SINGLE_TEST_CASE +// #define DUMP_TEST_CASE 7219 +// #define TOT_TEST_CASE 10000 + +void dump() {} + +void dump_ignore() {} + +void prep() { +} + +void solve() { + read(string, a); + int n = a.size(); + int s = 0, cnt = 0; + for (int i = 0; i < n; ++i) { + if (a[i] == '(') { + s += 1; + } else if (a[i] == ')') { + s -= 1; + } else { + cnt += 1; + } + } + s = -s; + int x = cnt + s >> 1, y = cnt - s >> 1; + int curr = 0, cx = x, cy = y; + string p, q; + for (int i = 0; i < n; ++i) { + if (a[i] == '(') { + curr += 1; + } else if (a[i] == ')') { + curr -= 1; + } else { + if (cx) { + p += '('; + curr += 1; + cx -= 1; + } else { + p += ')'; + curr -= 1; + } + } + } + for (int i = 0; i < n; ++i) { + if (a[i] == '(') { + curr += 1; + } else if (a[i] == ')') { + curr -= 1; + } else { + if (curr > 0 and cy) { + q += ')'; + curr -= 1; + cy -= 1; + } else { + q += '('; + curr += 1; + } + } + } + if (p == q) { + cout << "YES\n"; + } else { + cout << "NO\n"; + } +} + +int main() { +#if __cplusplus < 201402L or defined(_MSC_VER) and not defined(__clang__) + 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 +} diff --git a/src/bin/cf-1980d.cc b/src/bin/cf-1980d.cc new file mode 100644 index 0000000..be0a94f --- /dev/null +++ b/src/bin/cf-1980d.cc @@ -0,0 +1,556 @@ +/** + * Author: subcrip + * Created: 2024-06-03 23:04:55 + * Modified: 2024-06-04 20:27:56 + * Elapsed: 1283 minutes + */ + +#pragma GCC optimize("Ofast") +///////////////////////////////////////////////////////// +/** + * This code should require C++14. + * However, it's only been tested with C++17. + */ + +#include +using namespace std; + +/* macro helpers */ +#define __NARGS(...) std::tuple_size::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::type + +/* 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; +using ld = long double; +#endif +using int128 = __int128_t; +using uint128 = __uint128_t; +using ld = long double; +using pii = pair; +using pil = pair; +using pli = pair; +using pll = pair; +using pid = pair; +using pdi = pair; +using pld = pair; +using pdl = pair; +using pdd = pair; +using tlll = tuple; +using tlld = tuple; +using tlli = tuple; +using tldl = tuple; +using tldd = tuple; +using tldi = tuple; +using tlil = tuple; +using tlid = tuple; +using tlii = tuple; +using tdll = tuple; +using tdld = tuple; +using tdli = tuple; +using tddl = tuple; +using tddd = tuple; +using tddi = tuple; +using tdil = tuple; +using tdid = tuple; +using tdii = tuple; +using till = tuple; +using tild = tuple; +using tili = tuple; +using tidl = tuple; +using tidd = tuple; +using tidi = tuple; +using tiil = tuple; +using tiid = tuple; +using tiii = tuple; +template using max_heap = priority_queue; +template using min_heap = priority_queue, greater<>>; +template using oi = ostream_iterator; +template using ii = istream_iterator; + +/* constants */ +constexpr int INF = 0x3f3f3f3f; +constexpr ll INFLL = 0x3f3f3f3f3f3f3f3fLL; +constexpr ll MDL = 1e9 + 7; +constexpr ll PRIME = 998'244'353; +constexpr ll MDL1 = 8784491; +constexpr ll MDL2 = PRIME; +constexpr int128 INT128_MAX = numeric_limits::max(); +constexpr uint128 UINT128_MAX = numeric_limits::max(); +constexpr int128 INT128_MIN = numeric_limits::min(); +constexpr uint128 UINT128_MIN = numeric_limits::min(); + +/* random */ + +mt19937 rd(chrono::duration_cast(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 +#define ugt std::greater + +#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 + size_t operator()(const pair& 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 dist(PRIME); +const size_t __array_hash_b = 31, __array_hash_mdl1 = dist(rd), __array_hash_mdl2 = dist(rd); +struct array_hash { + template + size_t operator()(const Sequence& arr) const { + size_t pw1 = 1, pw2 = 1; + size_t res1 = 0, res2 = 0; + for (auto&& x : arr) { + res1 = (res1 + x * pw1) % __array_hash_mdl1; + res2 = (res2 + x * 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 pa(a) __AS_PROCEDURE(__typeof(a) pa; pa.push_back({}); for (auto&&x : a) pa.push_back(pa.back() + x);) +#define sa(a) __AS_PROCEDURE(__typeof(a) sa(a.size() + 1); {int n = a.size(); for (int i = n - 1; i >= 0; --i) sa[i] = sa[i + 1] + a[i];};) +#define adj(ch, n) __AS_PROCEDURE(vector> 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, w) __AS_PROCEDURE(ch[u].emplace_back(v, w), ch[v].emplace_back(u, w);) +#define Edge(ch, u, v) __AS_PROCEDURE(ch[u].push_back(v);) +#define Edgew(ch, u, v, w) __AS_PROCEDURE(ch[u].emplace_back(v, w);) +template pair> discretize(Iterator __first, Iterator __last) { + set st(__first, __last); + size_t N = 0; + map mp; + for (auto&& x : st) mp[x] = ++N; + return {N, mp}; +} +template pair> unordered_discretize(Iterator __first, Iterator __last) { + set st(__first, __last); + size_t N = 0; + unordered_map 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)) +template void __read(T& x) { cin >> x; } +template void __read(T& x, U&... args) { cin >> x; __read(args...); } +#define read(type, ...) __AS_PROCEDURE(type __VA_ARGS__; __read(__VA_ARGS__);) +#define readvec(type, a, n) __AS_PROCEDURE(vector a(n); for (auto& x : a) cin >> x;) +#define readvec1(type, a, n) __AS_PROCEDURE(vector a((n) + 1); copy_n(ii(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;) +template istream& operator>>(istream& in, pair& p) { + return in >> p.first >> p.second; +} +template ostream& operator<<(ostream& out, const pair& p) { + out << "{" << p.first << ", " << p.second << "}"; + return out; +} +template +void print_tuple_impl(std::basic_ostream& os, const Tuple& t, std::index_sequence) { + using swallow = int[]; // guaranties left to right order + (void)swallow { 0, (void(os << (Index == 0 ? "" : ", ") << std::get(t)), 0)... }; +} +template +decltype(auto) operator<<(std::basic_ostream& os, const std::tuple& t) { + os << "{"; + print_tuple_impl(os, t, std::index_sequence_for{}); + return os << "}"; +} +template ostream& operator<<(ostream& out, const vector& 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; +} + +/* pops */ +#define poptop(q, ...) __AS_PROCEDURE(auto [__VA_ARGS__] = q.top(); q.pop();) +#define popback(q, ...) __AS_PROCEDURE(auto [__VA_ARGS__] = q.back(); q.pop_back();) +#define popfront(q, ...) __AS_PROCEDURE(auto [__VA_ARGS__] = q.front();q.pop_front();) + +/* math */ +template +return_t qpow(ll b, ll p) { + if (b == 0 and p != 0) return 0; + if (p == 0) return 1; + return_t half = qpow(b, p / 2); + if (p % 2 == 1) return half * half * b; + else return half * half; +} + +#define comb(n, k) ((n) < 0 or (k) < 0 or (n) < (k) ? 0 : fact[n] / fact[k] / fact[(n) - (k)]) + +constexpr inline int lg2(ll x) { return x == 0 ? -1 : sizeof(ll) * 8 - 1 - __builtin_clzll(x); } + +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> decompose(ll x) { + // return (factor, count, factor ** count) + vector> 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 decompose_prime(int N) { + // return (factor, count) + vector 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 calc_next(string t) { // pi function of t + int n = (int)t.length(); + vector 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 calc_z(string t) { // z function of t + int m = t.length(); + vector z; + z.push_back(m); + pair 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 kmp(string s, string t) { // find all t in s + string cur = t + '#' + s; + int sz1 = s.size(), sz2 = t.size(); + vector v; + vector 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(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 struct MLL { + ll val; + MLL(ll v = 0) : val(mod(v, mdl)) {} + MLL(const MLL& 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 * mod(inverse(rhs.val, mdl), 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; } + void operator+=(const MLL& rhs) { val = (*this + rhs).val; } + void operator-=(const MLL& rhs) { val = (*this - rhs).val; } + void operator*=(const MLL& rhs) { val = (*this * rhs).val; } + void operator/=(const MLL& rhs) { val = (*this / rhs).val; } + void operator%=(const MLL& rhs) { val = (*this % rhs).val; } +}; +struct MLLd { + ll val, mdl; + MLLd(ll mdl, ll v = 0) : mdl(mdl), val(mod(v, mdl)) {} + MLLd(const MLLd& other) : mdl(other.mdl), val(other.val) {} + friend MLLd operator+(const MLLd& lhs, const MLLd& rhs) { return MLLd(lhs.mdl, mod(lhs.val + rhs.val, lhs.mdl)); } + friend MLLd operator-(const MLLd& lhs, const MLLd& rhs) { return MLLd(lhs.mdl, mod(lhs.val - rhs.val, lhs.mdl)); } + friend MLLd operator*(const MLLd& lhs, const MLLd& rhs) { return MLLd(lhs.mdl, mod(lhs.val * rhs.val, lhs.mdl)); } + friend MLLd operator/(const MLLd& lhs, const MLLd& rhs) { return MLLd(lhs.mdl, mod(lhs.val * mod(inverse(rhs.val, lhs.mdl), lhs.mdl), lhs.mdl)); } + friend MLLd operator%(const MLLd& lhs, const MLLd& rhs) { return MLLd(lhs.mdl, mod(lhs.val - (lhs / rhs).val, lhs.mdl)); } + friend bool operator==(const MLLd& lhs, const MLLd& rhs) { return lhs.val == rhs.val; } + friend bool operator!=(const MLLd& lhs, const MLLd& rhs) { return lhs.val != rhs.val; } + void operator+=(const MLLd& rhs) { val = (*this + rhs).val; } + void operator-=(const MLLd& rhs) { val = (*this - rhs).val; } + void operator*=(const MLLd& rhs) { val = (*this * rhs).val; } + void operator/=(const MLLd& rhs) { val = (*this / rhs).val; } + void operator%=(const MLLd& rhs) { val = (*this % rhs).val; } +}; + +template +ostream& operator<<(ostream& out, const MLL& num) { + return out << num.val; +} + +ostream& operator<<(ostream& out, const MLLd& num) { + return out << num.val; +} + +template +istream& operator>>(istream& in, MLL& num) { + return in >> num.val; +} + +istream& operator>>(istream& in, MLLd& num) { + return in >> num.val; +} + +// miscancellous +#define functor(func) [&](auto&&... val) \ +noexcept(noexcept(func(std::forward(val)...))) -> decltype(auto) \ +{return func(std::forward(val)...);} +template 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 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 +vector> zip(Iterator_T a_first, Iterator_T a_last, Iterator_U b_first, Iterator_U b_last) { + vector> 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 +vector> zip_n(Iterator_T a_first, Iterator_U b_first, size_t n) { + vector> 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 +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& operator++() { ++value; return *this; } + ArithmeticIterator& operator--() { --value; return *this; } + bool operator==(const ArithmeticIterator& rhs) const { return value == rhs.value; } +}; +template vector> enumerate(const vector& container) { + return zip(ArithmeticIterator(0), ArithmeticIterator(INT_MAX), container.begin(), container.end()); +} +///////////////////////////////////////////////////////// + +// #define SINGLE_TEST_CASE +// #define DUMP_TEST_CASE 7219 +// #define TOT_TEST_CASE 10000 + +void dump() {} + +void dump_ignore() {} + +void prep() { +} + +void solve() { + read(int, n); + readvec(int, a, n); + auto check = [&] (int idx) -> bool { + int prev_num = idx == 0 ? a[1] : a[0]; + int prev_gcd = -INF; + for (int i = idx == 0 ? 2 : 1; i < n; ++i) { + if (i == idx) continue; + int curr_gcd = gcd(a[i], prev_num); + if (curr_gcd < prev_gcd) { + return false; + } + prev_gcd = curr_gcd; + prev_num = a[i]; + } + return true; + }; + int prev_gcd = -INF; + for (int i = 1; i < n; ++i) { + int curr_gcd = gcd(a[i], a[i - 1]); + if (curr_gcd < prev_gcd) { + if ((i - 2 >= 0 and check(i - 2)) or check(i - 1) or check(i)) { + cout << "YES\n"; + } else { + cout << "NO\n"; + } + return; + } + prev_gcd = curr_gcd; + } + cout << "YES\n"; +} + +int main() { +#if __cplusplus < 201402L or defined(_MSC_VER) and not defined(__clang__) + 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 +} diff --git a/src/bin/cf-1980e.cc b/src/bin/cf-1980e.cc new file mode 100644 index 0000000..b7c2880 --- /dev/null +++ b/src/bin/cf-1980e.cc @@ -0,0 +1,663 @@ +/** + * Author: subcrip + * Created: 2024-06-03 23:18:29 + * Modified: 2024-06-04 20:28:04 + * Elapsed: 1269 minutes + */ + +#pragma GCC optimize("Ofast") +///////////////////////////////////////////////////////// +/** + * This code should require C++14. + * However, it's only been tested with C++17. + */ + +#include +using namespace std; + +/* macro helpers */ +#define __NARGS(...) std::tuple_size::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::type + +/* 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; +using ld = long double; +#endif +using int128 = __int128_t; +using uint128 = __uint128_t; +using ld = long double; +using pii = pair; +using pil = pair; +using pli = pair; +using pll = pair; +using pid = pair; +using pdi = pair; +using pld = pair; +using pdl = pair; +using pdd = pair; +using tlll = tuple; +using tlld = tuple; +using tlli = tuple; +using tldl = tuple; +using tldd = tuple; +using tldi = tuple; +using tlil = tuple; +using tlid = tuple; +using tlii = tuple; +using tdll = tuple; +using tdld = tuple; +using tdli = tuple; +using tddl = tuple; +using tddd = tuple; +using tddi = tuple; +using tdil = tuple; +using tdid = tuple; +using tdii = tuple; +using till = tuple; +using tild = tuple; +using tili = tuple; +using tidl = tuple; +using tidd = tuple; +using tidi = tuple; +using tiil = tuple; +using tiid = tuple; +using tiii = tuple; +template using max_heap = priority_queue; +template using min_heap = priority_queue, greater<>>; +template using oi = ostream_iterator; +template using ii = istream_iterator; + +/* constants */ +constexpr int INF = 0x3f3f3f3f; +constexpr ll INFLL = 0x3f3f3f3f3f3f3f3fLL; +constexpr ll MDL = 1e9 + 7; +constexpr ll PRIME = 998'244'353; +constexpr ll MDL1 = 8784491; +constexpr ll MDL2 = PRIME; +constexpr int128 INT128_MAX = numeric_limits::max(); +constexpr uint128 UINT128_MAX = numeric_limits::max(); +constexpr int128 INT128_MIN = numeric_limits::min(); +constexpr uint128 UINT128_MIN = numeric_limits::min(); + +/* random */ + +mt19937 rd(chrono::duration_cast(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 +#define ugt std::greater + +#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 + size_t operator()(const pair& 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 dist(PRIME); +const size_t __array_hash_b = 31, __array_hash_mdl1 = dist(rd), __array_hash_mdl2 = dist(rd); +struct array_hash { + template + size_t operator()(const Sequence& arr) const { + size_t pw1 = 1, pw2 = 1; + size_t res1 = 0, res2 = 0; + for (auto&& x : arr) { + res1 = (res1 + x * pw1) % __array_hash_mdl1; + res2 = (res2 + x * 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 pa(a) __AS_PROCEDURE(__typeof(a) pa; pa.push_back({}); for (auto&&x : a) pa.push_back(pa.back() + x);) +#define sa(a) __AS_PROCEDURE(__typeof(a) sa(a.size() + 1); {int n = a.size(); for (int i = n - 1; i >= 0; --i) sa[i] = sa[i + 1] + a[i];};) +#define adj(ch, n) __AS_PROCEDURE(vector> 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, w) __AS_PROCEDURE(ch[u].emplace_back(v, w), ch[v].emplace_back(u, w);) +#define Edge(ch, u, v) __AS_PROCEDURE(ch[u].push_back(v);) +#define Edgew(ch, u, v, w) __AS_PROCEDURE(ch[u].emplace_back(v, w);) +template pair> discretize(Iterator __first, Iterator __last) { + set st(__first, __last); + size_t N = 0; + map mp; + for (auto&& x : st) mp[x] = ++N; + return {N, mp}; +} +template pair> unordered_discretize(Iterator __first, Iterator __last) { + set st(__first, __last); + size_t N = 0; + unordered_map 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)) +template void __read(T& x) { cin >> x; } +template void __read(T& x, U&... args) { cin >> x; __read(args...); } +#define read(type, ...) __AS_PROCEDURE(type __VA_ARGS__; __read(__VA_ARGS__);) +#define readvec(type, a, n) __AS_PROCEDURE(vector a(n); for (auto& x : a) cin >> x;) +#define readvec1(type, a, n) __AS_PROCEDURE(vector a((n) + 1); copy_n(ii(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;) +template istream& operator>>(istream& in, pair& p) { + return in >> p.first >> p.second; +} +template ostream& operator<<(ostream& out, const pair& p) { + out << "{" << p.first << ", " << p.second << "}"; + return out; +} +template +void print_tuple_impl(std::basic_ostream& os, const Tuple& t, std::index_sequence) { + using swallow = int[]; // guaranties left to right order + (void)swallow { 0, (void(os << (Index == 0 ? "" : ", ") << std::get(t)), 0)... }; +} +template +decltype(auto) operator<<(std::basic_ostream& os, const std::tuple& t) { + os << "{"; + print_tuple_impl(os, t, std::index_sequence_for{}); + return os << "}"; +} +template ostream& operator<<(ostream& out, const vector& 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; +} + +/* pops */ +#define poptop(q, ...) __AS_PROCEDURE(auto [__VA_ARGS__] = q.top(); q.pop();) +#define popback(q, ...) __AS_PROCEDURE(auto [__VA_ARGS__] = q.back(); q.pop_back();) +#define popfront(q, ...) __AS_PROCEDURE(auto [__VA_ARGS__] = q.front();q.pop_front();) + +/* math */ +template +return_t qpow(ll b, ll p) { + if (b == 0 and p != 0) return 0; + if (p == 0) return 1; + return_t half = qpow(b, p / 2); + if (p % 2 == 1) return half * half * b; + else return half * half; +} + +#define comb(n, k) ((n) < 0 or (k) < 0 or (n) < (k) ? 0 : fact[n] / fact[k] / fact[(n) - (k)]) + +constexpr inline int lg2(ll x) { return x == 0 ? -1 : sizeof(ll) * 8 - 1 - __builtin_clzll(x); } + +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> decompose(ll x) { + // return (factor, count, factor ** count) + vector> 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 decompose_prime(int N) { + // return (factor, count) + vector 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 calc_next(string t) { // pi function of t + int n = (int)t.length(); + vector 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 calc_z(string t) { // z function of t + int m = t.length(); + vector z; + z.push_back(m); + pair 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 kmp(string s, string t) { // find all t in s + string cur = t + '#' + s; + int sz1 = s.size(), sz2 = t.size(); + vector v; + vector 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(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 struct MLL { + ll val; + MLL(ll v = 0) : val(mod(v, mdl)) {} + MLL(const MLL& 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 * mod(inverse(rhs.val, mdl), 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; } + void operator+=(const MLL& rhs) { val = (*this + rhs).val; } + void operator-=(const MLL& rhs) { val = (*this - rhs).val; } + void operator*=(const MLL& rhs) { val = (*this * rhs).val; } + void operator/=(const MLL& rhs) { val = (*this / rhs).val; } + void operator%=(const MLL& rhs) { val = (*this % rhs).val; } +}; +struct MLLd { + ll val, mdl; + MLLd(ll mdl, ll v = 0) : mdl(mdl), val(mod(v, mdl)) {} + MLLd(const MLLd& other) : mdl(other.mdl), val(other.val) {} + friend MLLd operator+(const MLLd& lhs, const MLLd& rhs) { return MLLd(lhs.mdl, mod(lhs.val + rhs.val, lhs.mdl)); } + friend MLLd operator-(const MLLd& lhs, const MLLd& rhs) { return MLLd(lhs.mdl, mod(lhs.val - rhs.val, lhs.mdl)); } + friend MLLd operator*(const MLLd& lhs, const MLLd& rhs) { return MLLd(lhs.mdl, mod(lhs.val * rhs.val, lhs.mdl)); } + friend MLLd operator/(const MLLd& lhs, const MLLd& rhs) { return MLLd(lhs.mdl, mod(lhs.val * mod(inverse(rhs.val, lhs.mdl), lhs.mdl), lhs.mdl)); } + friend MLLd operator%(const MLLd& lhs, const MLLd& rhs) { return MLLd(lhs.mdl, mod(lhs.val - (lhs / rhs).val, lhs.mdl)); } + friend bool operator==(const MLLd& lhs, const MLLd& rhs) { return lhs.val == rhs.val; } + friend bool operator!=(const MLLd& lhs, const MLLd& rhs) { return lhs.val != rhs.val; } + void operator+=(const MLLd& rhs) { val = (*this + rhs).val; } + void operator-=(const MLLd& rhs) { val = (*this - rhs).val; } + void operator*=(const MLLd& rhs) { val = (*this * rhs).val; } + void operator/=(const MLLd& rhs) { val = (*this / rhs).val; } + void operator%=(const MLLd& rhs) { val = (*this % rhs).val; } +}; + +template +ostream& operator<<(ostream& out, const MLL& num) { + return out << num.val; +} + +ostream& operator<<(ostream& out, const MLLd& num) { + return out << num.val; +} + +template +istream& operator>>(istream& in, MLL& num) { + return in >> num.val; +} + +istream& operator>>(istream& in, MLLd& num) { + return in >> num.val; +} + +// miscancellous +#define functor(func) [&](auto&&... val) \ +noexcept(noexcept(func(std::forward(val)...))) -> decltype(auto) \ +{return func(std::forward(val)...);} +template 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 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 +vector> zip(Iterator_T a_first, Iterator_T a_last, Iterator_U b_first, Iterator_U b_last) { + vector> 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 +vector> zip_n(Iterator_T a_first, Iterator_U b_first, size_t n) { + vector> 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 +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& operator++() { ++value; return *this; } + ArithmeticIterator& operator--() { --value; return *this; } + bool operator==(const ArithmeticIterator& rhs) const { return value == rhs.value; } +}; +template vector> enumerate(const vector& container) { + return zip(ArithmeticIterator(0), ArithmeticIterator(INT_MAX), container.begin(), container.end()); +} +///////////////////////////////////////////////////////// + +// #define SINGLE_TEST_CASE +// #define DUMP_TEST_CASE 7219 +// #define TOT_TEST_CASE 10000 + +void dump() {} + +void dump_ignore() {} + +void prep() { +} + +static vector> power1; +static vector> power2; +static const ll b = rd(); +template +struct hash_vec { + using hash_type = pll; + MLL hash1; + MLL hash2; + vector<_Tp> seq; + size_t size() { + return seq.size(); + } + void push_back(const _Tp& x) { + hash1 = hash1 * b + x; + hash2 = hash2 * b + x; + seq.push_back(x); + } + void push_front(const _Tp& x) { + size_t length = size(); + hash1 += x * power1[length]; + hash2 += x * power2[length]; + seq.push_front(x); + } + void pop_back() { + _Tp e = seq.back(); seq.pop_back(); + hash1 = (hash1 - e) / b; + hash2 = (hash2 - e) / b; + } + void pop_front() { + _Tp e = seq.front(); seq.pop_front(); + int length = seq.size(); + hash1 -= e * power1[length]; + hash2 -= e * power2[length]; + } + void set(size_t pos, const _Tp& value) { + int length = seq.size(); + int old_value = seq[pos]; + hash1 += (value - old_value) * power1[length - 1 - pos]; + hash2 += (value - old_value) * power2[length - 1 - pos]; + seq[pos] = value; + } + const _Tp& operator[](size_t pos) { + return seq[pos]; + } + hash_type hash() { + return {hash1.val, hash2.val}; + } + void clear() { + hash1 = 0; + hash2 = 0; + seq.clear(); + } + hash_vec(size_t maxn) { + clear(); + MLL c1 = power1.size() ? power1.back() * b : 1; + MLL c2 = power2.size() ? power2.back() * b : 1; + for (int i = power1.size(); i < maxn; ++i) { + power1.push_back(c1); + power2.push_back(c2); + c1 *= b; + c2 *= b; + } + } + hash_vec(size_t maxn, const _Tp& init_value) : hash_vec(maxn) { + for (size_t i = 0; i != maxn; ++i) { + push_back(init_value); + } + } +}; + +void solve() { + read(int, n, m); + vector> a(n, vector(m)), b(n, vector(m)); + for (int i = 0; i < n; ++i) { + for (int j = 0; j < m; ++j) { + cin >> a[i][j]; + } + } + for (int i = 0; i < n; ++i) { + for (int j = 0; j < m; ++j) { + cin >> b[i][j]; + } + } + unordered_map::hash_type, vector, pair_hash> b_row; + hash_vec hs(max(n, m) + 1); + for (int i = 0; i < n; ++i) { + vector r = b[i]; + sort(r.begin(), r.end()); + hs.clear(); + for (int j = 0; j < m; ++j) { + hs.push_back(r[j]); + } + b_row[hs.hash()].emplace_back(i); + } + vector row_mapping(n); + for (int i = 0; i < n; ++i) { + hs.clear(); + vector r = a[i]; + sort(r.begin(), r.end()); + for (int j = 0; j < m; ++j) { + hs.push_back(r[j]); + } + if (not b_row.count(hs.hash())) { + cout << "NO\n"; + return; + } + row_mapping[i] = b_row[hs.hash()].back(); + b_row[hs.hash()].pop_back(); + if (b_row[hs.hash()].size() == 0) { + b_row.erase(hs.hash()); + } + } + vector> new_a(n, vector(m)); + for (int i = 0; i < n; ++i) { + for (int j = 0; j < m; ++j) { + new_a[row_mapping[i]][j] = a[i][j]; + } + } + unordered_map::hash_type, int, pair_hash> b_col; + for (int j = 0; j < m; ++j) { + hs.clear(); + for (int i = 0; i < n; ++i) { + hs.push_back(b[i][j]); + } + b_col[hs.hash()] += 1; + } + for (int j = 0; j < m; ++j) { + hs.clear(); + for (int i = 0; i < n; ++i) { + hs.push_back(new_a[i][j]); + } + if (b_col[hs.hash()] == 0) { + cout << "NO\n"; + return; + } + b_col[hs.hash()] -= 1; + } + cout << "YES\n"; +} + +int main() { +#if __cplusplus < 201402L or defined(_MSC_VER) and not defined(__clang__) + 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 +} diff --git a/src/bin/cf-1980f1.cc b/src/bin/cf-1980f1.cc new file mode 100644 index 0000000..0fea485 --- /dev/null +++ b/src/bin/cf-1980f1.cc @@ -0,0 +1,611 @@ +/** + * Author: subcrip + * Created: 2024-06-03 23:49:19 + * Modified: 2024-06-04 20:28:10 + * Elapsed: 1238 minutes + */ + +#pragma GCC optimize("Ofast") +///////////////////////////////////////////////////////// +/** + * This code should require C++14. + * However, it's only been tested with C++17. + */ + +#include +using namespace std; + +/* macro helpers */ +#define __NARGS(...) std::tuple_size::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::type + +/* 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; +using ld = long double; +#endif +using int128 = __int128_t; +using uint128 = __uint128_t; +using ld = long double; +using pii = pair; +using pil = pair; +using pli = pair; +using pll = pair; +using pid = pair; +using pdi = pair; +using pld = pair; +using pdl = pair; +using pdd = pair; +using tlll = tuple; +using tlld = tuple; +using tlli = tuple; +using tldl = tuple; +using tldd = tuple; +using tldi = tuple; +using tlil = tuple; +using tlid = tuple; +using tlii = tuple; +using tdll = tuple; +using tdld = tuple; +using tdli = tuple; +using tddl = tuple; +using tddd = tuple; +using tddi = tuple; +using tdil = tuple; +using tdid = tuple; +using tdii = tuple; +using till = tuple; +using tild = tuple; +using tili = tuple; +using tidl = tuple; +using tidd = tuple; +using tidi = tuple; +using tiil = tuple; +using tiid = tuple; +using tiii = tuple; +template using max_heap = priority_queue; +template using min_heap = priority_queue, greater<>>; +template using oi = ostream_iterator; +template using ii = istream_iterator; + +/* constants */ +constexpr int INF = 0x3f3f3f3f; +constexpr ll INFLL = 0x3f3f3f3f3f3f3f3fLL; +constexpr ll MDL = 1e9 + 7; +constexpr ll PRIME = 998'244'353; +constexpr ll MDL1 = 8784491; +constexpr ll MDL2 = PRIME; +constexpr int128 INT128_MAX = numeric_limits::max(); +constexpr uint128 UINT128_MAX = numeric_limits::max(); +constexpr int128 INT128_MIN = numeric_limits::min(); +constexpr uint128 UINT128_MIN = numeric_limits::min(); + +/* random */ + +mt19937 rd(chrono::duration_cast(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 +#define ugt std::greater + +#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 + size_t operator()(const pair& 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 dist(PRIME); +const size_t __array_hash_b = 31, __array_hash_mdl1 = dist(rd), __array_hash_mdl2 = dist(rd); +struct array_hash { + template + size_t operator()(const Sequence& arr) const { + size_t pw1 = 1, pw2 = 1; + size_t res1 = 0, res2 = 0; + for (auto&& x : arr) { + res1 = (res1 + x * pw1) % __array_hash_mdl1; + res2 = (res2 + x * 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 pa(a) __AS_PROCEDURE(__typeof(a) pa; pa.push_back({}); for (auto&&x : a) pa.push_back(pa.back() + x);) +#define sa(a) __AS_PROCEDURE(__typeof(a) sa(a.size() + 1); {int n = a.size(); for (int i = n - 1; i >= 0; --i) sa[i] = sa[i + 1] + a[i];};) +#define adj(ch, n) __AS_PROCEDURE(vector> 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, w) __AS_PROCEDURE(ch[u].emplace_back(v, w), ch[v].emplace_back(u, w);) +#define Edge(ch, u, v) __AS_PROCEDURE(ch[u].push_back(v);) +#define Edgew(ch, u, v, w) __AS_PROCEDURE(ch[u].emplace_back(v, w);) +template pair> discretize(Iterator __first, Iterator __last) { + set st(__first, __last); + size_t N = 0; + map mp; + for (auto&& x : st) mp[x] = ++N; + return {N, mp}; +} +template pair> unordered_discretize(Iterator __first, Iterator __last) { + set st(__first, __last); + size_t N = 0; + unordered_map 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)) +template void __read(T& x) { cin >> x; } +template void __read(T& x, U&... args) { cin >> x; __read(args...); } +#define read(type, ...) __AS_PROCEDURE(type __VA_ARGS__; __read(__VA_ARGS__);) +#define readvec(type, a, n) __AS_PROCEDURE(vector a(n); for (auto& x : a) cin >> x;) +#define readvec1(type, a, n) __AS_PROCEDURE(vector a((n) + 1); copy_n(ii(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;) +template istream& operator>>(istream& in, pair& p) { + return in >> p.first >> p.second; +} +template ostream& operator<<(ostream& out, const pair& p) { + out << "{" << p.first << ", " << p.second << "}"; + return out; +} +template +void print_tuple_impl(std::basic_ostream& os, const Tuple& t, std::index_sequence) { + using swallow = int[]; // guaranties left to right order + (void)swallow { 0, (void(os << (Index == 0 ? "" : ", ") << std::get(t)), 0)... }; +} +template +decltype(auto) operator<<(std::basic_ostream& os, const std::tuple& t) { + os << "{"; + print_tuple_impl(os, t, std::index_sequence_for{}); + return os << "}"; +} +template ostream& operator<<(ostream& out, const vector& 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; +} + +/* pops */ +#define poptop(q, ...) __AS_PROCEDURE(auto [__VA_ARGS__] = q.top(); q.pop();) +#define popback(q, ...) __AS_PROCEDURE(auto [__VA_ARGS__] = q.back(); q.pop_back();) +#define popfront(q, ...) __AS_PROCEDURE(auto [__VA_ARGS__] = q.front();q.pop_front();) + +/* math */ +template +return_t qpow(ll b, ll p) { + if (b == 0 and p != 0) return 0; + if (p == 0) return 1; + return_t half = qpow(b, p / 2); + if (p % 2 == 1) return half * half * b; + else return half * half; +} + +#define comb(n, k) ((n) < 0 or (k) < 0 or (n) < (k) ? 0 : fact[n] / fact[k] / fact[(n) - (k)]) + +constexpr inline int lg2(ll x) { return x == 0 ? -1 : sizeof(ll) * 8 - 1 - __builtin_clzll(x); } + +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> decompose(ll x) { + // return (factor, count, factor ** count) + vector> 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 decompose_prime(int N) { + // return (factor, count) + vector 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 calc_next(string t) { // pi function of t + int n = (int)t.length(); + vector 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 calc_z(string t) { // z function of t + int m = t.length(); + vector z; + z.push_back(m); + pair 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 kmp(string s, string t) { // find all t in s + string cur = t + '#' + s; + int sz1 = s.size(), sz2 = t.size(); + vector v; + vector 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(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 struct MLL { + ll val; + MLL(ll v = 0) : val(mod(v, mdl)) {} + MLL(const MLL& 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 * mod(inverse(rhs.val, mdl), 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; } + void operator+=(const MLL& rhs) { val = (*this + rhs).val; } + void operator-=(const MLL& rhs) { val = (*this - rhs).val; } + void operator*=(const MLL& rhs) { val = (*this * rhs).val; } + void operator/=(const MLL& rhs) { val = (*this / rhs).val; } + void operator%=(const MLL& rhs) { val = (*this % rhs).val; } +}; +struct MLLd { + ll val, mdl; + MLLd(ll mdl, ll v = 0) : mdl(mdl), val(mod(v, mdl)) {} + MLLd(const MLLd& other) : mdl(other.mdl), val(other.val) {} + friend MLLd operator+(const MLLd& lhs, const MLLd& rhs) { return MLLd(lhs.mdl, mod(lhs.val + rhs.val, lhs.mdl)); } + friend MLLd operator-(const MLLd& lhs, const MLLd& rhs) { return MLLd(lhs.mdl, mod(lhs.val - rhs.val, lhs.mdl)); } + friend MLLd operator*(const MLLd& lhs, const MLLd& rhs) { return MLLd(lhs.mdl, mod(lhs.val * rhs.val, lhs.mdl)); } + friend MLLd operator/(const MLLd& lhs, const MLLd& rhs) { return MLLd(lhs.mdl, mod(lhs.val * mod(inverse(rhs.val, lhs.mdl), lhs.mdl), lhs.mdl)); } + friend MLLd operator%(const MLLd& lhs, const MLLd& rhs) { return MLLd(lhs.mdl, mod(lhs.val - (lhs / rhs).val, lhs.mdl)); } + friend bool operator==(const MLLd& lhs, const MLLd& rhs) { return lhs.val == rhs.val; } + friend bool operator!=(const MLLd& lhs, const MLLd& rhs) { return lhs.val != rhs.val; } + void operator+=(const MLLd& rhs) { val = (*this + rhs).val; } + void operator-=(const MLLd& rhs) { val = (*this - rhs).val; } + void operator*=(const MLLd& rhs) { val = (*this * rhs).val; } + void operator/=(const MLLd& rhs) { val = (*this / rhs).val; } + void operator%=(const MLLd& rhs) { val = (*this % rhs).val; } +}; + +template +ostream& operator<<(ostream& out, const MLL& num) { + return out << num.val; +} + +ostream& operator<<(ostream& out, const MLLd& num) { + return out << num.val; +} + +template +istream& operator>>(istream& in, MLL& num) { + return in >> num.val; +} + +istream& operator>>(istream& in, MLLd& num) { + return in >> num.val; +} + +// miscancellous +#define functor(func) [&](auto&&... val) \ +noexcept(noexcept(func(std::forward(val)...))) -> decltype(auto) \ +{return func(std::forward(val)...);} +template 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 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 +vector> zip(Iterator_T a_first, Iterator_T a_last, Iterator_U b_first, Iterator_U b_last) { + vector> 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 +vector> zip_n(Iterator_T a_first, Iterator_U b_first, size_t n) { + vector> 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 +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& operator++() { ++value; return *this; } + ArithmeticIterator& operator--() { --value; return *this; } + bool operator==(const ArithmeticIterator& rhs) const { return value == rhs.value; } +}; +template vector> enumerate(const vector& container) { + return zip(ArithmeticIterator(0), ArithmeticIterator(INT_MAX), container.begin(), container.end()); +} +///////////////////////////////////////////////////////// + +// #define SINGLE_TEST_CASE +// #define DUMP_TEST_CASE 7219 +// #define TOT_TEST_CASE 10000 + +void dump() {} + +void dump_ignore() {} + +void prep() { +} + +template> struct sparse_table { + _Op op; + vector> st; + template + sparse_table(ReverseIterator __first, ReverseIterator __last, _Op&& __operation) { + op = __operation; + int n = distance(__first, __last); + st = vector>(n, vector<_Tp>(int(log2(n) + 1))); + int i = n - 1; + for (auto it = __first; it != __last; ++it) { + st[i][0] = *it; + for (int j = 1; i + (1 << j) <= n; ++j) { + st[i][j] = op(st[i][j - 1], st[i + (1 << (j - 1))][j - 1]); + } + i -= 1; + } + } + _Tp query(size_t __start, size_t __end) { + int s = lg2(__end - __start + 1); + return op(st[__start][s], st[__end - (1 << s) + 1][s]); + } +}; + + +void solve() { + read(ll, n, m); + read(int, k); + readvec(pll, a, k); + vector rev(k); + iota(rev.begin(), rev.end(), 0); + sort_by_key(rev.begin(), rev.end(), [&] (int i) -> pll { return {a[i].first, -a[i].second}; }); + sort_by_key(a.begin(), a.end(), [&] (pll x) -> pll { return {x.first, -x.second}; }); + ll res = 0; + vector ss(k + 1, {m + 1, n + 1}); + vector stale(k); + for (int i = 0; i < k - 1; ++i) { + if (a[i + 1].first == a[i].first) { + stale[i] = 1; + } + } + a.emplace_back(n + 1, m + 1); + vector> st; + st.emplace_back(0, 0, -1); + vector> c(k); + vector val(k + 1); + vector fa(k + 1); + ll curr = 0; + vector tag; + for (int i = 0; i < k; ++i) { + tag.emplace_back(a[i].second, i); + } + sparse_table rmq(tag.rbegin(), tag.rend(), functor(min)); + for (int i = 0; i <= k; ++i) { + while (st.size() and get<1>(st.back()) > a[i].second) { + st.pop_back(); + } + int prev = get<2>(st.back()); + curr = (prev == -1 ? 0 : val[prev]) + (a[i].second - 1) * (a[i].first - get<0>(st.back())); + val[i] = curr; + st.emplace_back(a[i].first, a[i].second, i); + fa[i] = prev; + int l = -1, r = prev - 1; + if (l > r) continue; + while (l < r) { + int mid = l + r + 1 >> 1; + if ((mid == -1 ? 0 : rmq.query(mid, prev - 1).first) <= a[i].second) { + l = mid; + } else { + r = mid - 1; + } + } + if ((l == -1 ? 0 : a[l].second) <= a[i].second) { + ll asdf = (l == -1 ? 0 : val[l]) + (a[i].second - 1) * (a[i].first - (l == -1 ? 0 : a[l].first)); + c[prev][i] = asdf - curr; + // debug(make_tuple(l, prev, rev[prev])); + } + } + curr -= m; + cout << curr << '\n'; + vector d(k); + int ptr = k; + while (fa[ptr] != -1) { + d[rev[fa[ptr]]] = !!c[fa[ptr]][ptr]; + ptr = fa[ptr]; + } + putvec(d); +} + +int main() { +#if __cplusplus < 201402L or defined(_MSC_VER) and not defined(__clang__) + 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 +} diff --git a/src/bin/cf-1980f2.cc b/src/bin/cf-1980f2.cc new file mode 100644 index 0000000..02e9008 --- /dev/null +++ b/src/bin/cf-1980f2.cc @@ -0,0 +1,610 @@ +/** + * Author: subcrip + * Created: 2024-06-03 23:49:19 + * Modified: 2024-06-04 20:28:22 + * Elapsed: 1239 minutes + */ + +#pragma GCC optimize("Ofast") +///////////////////////////////////////////////////////// +/** + * This code should require C++14. + * However, it's only been tested with C++17. + */ + +#include +using namespace std; + +/* macro helpers */ +#define __NARGS(...) std::tuple_size::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::type + +/* 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; +using ld = long double; +#endif +using int128 = __int128_t; +using uint128 = __uint128_t; +using ld = long double; +using pii = pair; +using pil = pair; +using pli = pair; +using pll = pair; +using pid = pair; +using pdi = pair; +using pld = pair; +using pdl = pair; +using pdd = pair; +using tlll = tuple; +using tlld = tuple; +using tlli = tuple; +using tldl = tuple; +using tldd = tuple; +using tldi = tuple; +using tlil = tuple; +using tlid = tuple; +using tlii = tuple; +using tdll = tuple; +using tdld = tuple; +using tdli = tuple; +using tddl = tuple; +using tddd = tuple; +using tddi = tuple; +using tdil = tuple; +using tdid = tuple; +using tdii = tuple; +using till = tuple; +using tild = tuple; +using tili = tuple; +using tidl = tuple; +using tidd = tuple; +using tidi = tuple; +using tiil = tuple; +using tiid = tuple; +using tiii = tuple; +template using max_heap = priority_queue; +template using min_heap = priority_queue, greater<>>; +template using oi = ostream_iterator; +template using ii = istream_iterator; + +/* constants */ +constexpr int INF = 0x3f3f3f3f; +constexpr ll INFLL = 0x3f3f3f3f3f3f3f3fLL; +constexpr ll MDL = 1e9 + 7; +constexpr ll PRIME = 998'244'353; +constexpr ll MDL1 = 8784491; +constexpr ll MDL2 = PRIME; +constexpr int128 INT128_MAX = numeric_limits::max(); +constexpr uint128 UINT128_MAX = numeric_limits::max(); +constexpr int128 INT128_MIN = numeric_limits::min(); +constexpr uint128 UINT128_MIN = numeric_limits::min(); + +/* random */ + +mt19937 rd(chrono::duration_cast(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 +#define ugt std::greater + +#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 + size_t operator()(const pair& 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 dist(PRIME); +const size_t __array_hash_b = 31, __array_hash_mdl1 = dist(rd), __array_hash_mdl2 = dist(rd); +struct array_hash { + template + size_t operator()(const Sequence& arr) const { + size_t pw1 = 1, pw2 = 1; + size_t res1 = 0, res2 = 0; + for (auto&& x : arr) { + res1 = (res1 + x * pw1) % __array_hash_mdl1; + res2 = (res2 + x * 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 pa(a) __AS_PROCEDURE(__typeof(a) pa; pa.push_back({}); for (auto&&x : a) pa.push_back(pa.back() + x);) +#define sa(a) __AS_PROCEDURE(__typeof(a) sa(a.size() + 1); {int n = a.size(); for (int i = n - 1; i >= 0; --i) sa[i] = sa[i + 1] + a[i];};) +#define adj(ch, n) __AS_PROCEDURE(vector> 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, w) __AS_PROCEDURE(ch[u].emplace_back(v, w), ch[v].emplace_back(u, w);) +#define Edge(ch, u, v) __AS_PROCEDURE(ch[u].push_back(v);) +#define Edgew(ch, u, v, w) __AS_PROCEDURE(ch[u].emplace_back(v, w);) +template pair> discretize(Iterator __first, Iterator __last) { + set st(__first, __last); + size_t N = 0; + map mp; + for (auto&& x : st) mp[x] = ++N; + return {N, mp}; +} +template pair> unordered_discretize(Iterator __first, Iterator __last) { + set st(__first, __last); + size_t N = 0; + unordered_map 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)) +template void __read(T& x) { cin >> x; } +template void __read(T& x, U&... args) { cin >> x; __read(args...); } +#define read(type, ...) __AS_PROCEDURE(type __VA_ARGS__; __read(__VA_ARGS__);) +#define readvec(type, a, n) __AS_PROCEDURE(vector a(n); for (auto& x : a) cin >> x;) +#define readvec1(type, a, n) __AS_PROCEDURE(vector a((n) + 1); copy_n(ii(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;) +template istream& operator>>(istream& in, pair& p) { + return in >> p.first >> p.second; +} +template ostream& operator<<(ostream& out, const pair& p) { + out << "{" << p.first << ", " << p.second << "}"; + return out; +} +template +void print_tuple_impl(std::basic_ostream& os, const Tuple& t, std::index_sequence) { + using swallow = int[]; // guaranties left to right order + (void)swallow { 0, (void(os << (Index == 0 ? "" : ", ") << std::get(t)), 0)... }; +} +template +decltype(auto) operator<<(std::basic_ostream& os, const std::tuple& t) { + os << "{"; + print_tuple_impl(os, t, std::index_sequence_for{}); + return os << "}"; +} +template ostream& operator<<(ostream& out, const vector& 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; +} + +/* pops */ +#define poptop(q, ...) __AS_PROCEDURE(auto [__VA_ARGS__] = q.top(); q.pop();) +#define popback(q, ...) __AS_PROCEDURE(auto [__VA_ARGS__] = q.back(); q.pop_back();) +#define popfront(q, ...) __AS_PROCEDURE(auto [__VA_ARGS__] = q.front();q.pop_front();) + +/* math */ +template +return_t qpow(ll b, ll p) { + if (b == 0 and p != 0) return 0; + if (p == 0) return 1; + return_t half = qpow(b, p / 2); + if (p % 2 == 1) return half * half * b; + else return half * half; +} + +#define comb(n, k) ((n) < 0 or (k) < 0 or (n) < (k) ? 0 : fact[n] / fact[k] / fact[(n) - (k)]) + +constexpr inline int lg2(ll x) { return x == 0 ? -1 : sizeof(ll) * 8 - 1 - __builtin_clzll(x); } + +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> decompose(ll x) { + // return (factor, count, factor ** count) + vector> 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 decompose_prime(int N) { + // return (factor, count) + vector 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 calc_next(string t) { // pi function of t + int n = (int)t.length(); + vector 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 calc_z(string t) { // z function of t + int m = t.length(); + vector z; + z.push_back(m); + pair 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 kmp(string s, string t) { // find all t in s + string cur = t + '#' + s; + int sz1 = s.size(), sz2 = t.size(); + vector v; + vector 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(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 struct MLL { + ll val; + MLL(ll v = 0) : val(mod(v, mdl)) {} + MLL(const MLL& 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 * mod(inverse(rhs.val, mdl), 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; } + void operator+=(const MLL& rhs) { val = (*this + rhs).val; } + void operator-=(const MLL& rhs) { val = (*this - rhs).val; } + void operator*=(const MLL& rhs) { val = (*this * rhs).val; } + void operator/=(const MLL& rhs) { val = (*this / rhs).val; } + void operator%=(const MLL& rhs) { val = (*this % rhs).val; } +}; +struct MLLd { + ll val, mdl; + MLLd(ll mdl, ll v = 0) : mdl(mdl), val(mod(v, mdl)) {} + MLLd(const MLLd& other) : mdl(other.mdl), val(other.val) {} + friend MLLd operator+(const MLLd& lhs, const MLLd& rhs) { return MLLd(lhs.mdl, mod(lhs.val + rhs.val, lhs.mdl)); } + friend MLLd operator-(const MLLd& lhs, const MLLd& rhs) { return MLLd(lhs.mdl, mod(lhs.val - rhs.val, lhs.mdl)); } + friend MLLd operator*(const MLLd& lhs, const MLLd& rhs) { return MLLd(lhs.mdl, mod(lhs.val * rhs.val, lhs.mdl)); } + friend MLLd operator/(const MLLd& lhs, const MLLd& rhs) { return MLLd(lhs.mdl, mod(lhs.val * mod(inverse(rhs.val, lhs.mdl), lhs.mdl), lhs.mdl)); } + friend MLLd operator%(const MLLd& lhs, const MLLd& rhs) { return MLLd(lhs.mdl, mod(lhs.val - (lhs / rhs).val, lhs.mdl)); } + friend bool operator==(const MLLd& lhs, const MLLd& rhs) { return lhs.val == rhs.val; } + friend bool operator!=(const MLLd& lhs, const MLLd& rhs) { return lhs.val != rhs.val; } + void operator+=(const MLLd& rhs) { val = (*this + rhs).val; } + void operator-=(const MLLd& rhs) { val = (*this - rhs).val; } + void operator*=(const MLLd& rhs) { val = (*this * rhs).val; } + void operator/=(const MLLd& rhs) { val = (*this / rhs).val; } + void operator%=(const MLLd& rhs) { val = (*this % rhs).val; } +}; + +template +ostream& operator<<(ostream& out, const MLL& num) { + return out << num.val; +} + +ostream& operator<<(ostream& out, const MLLd& num) { + return out << num.val; +} + +template +istream& operator>>(istream& in, MLL& num) { + return in >> num.val; +} + +istream& operator>>(istream& in, MLLd& num) { + return in >> num.val; +} + +// miscancellous +#define functor(func) [&](auto&&... val) \ +noexcept(noexcept(func(std::forward(val)...))) -> decltype(auto) \ +{return func(std::forward(val)...);} +template 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 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 +vector> zip(Iterator_T a_first, Iterator_T a_last, Iterator_U b_first, Iterator_U b_last) { + vector> 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 +vector> zip_n(Iterator_T a_first, Iterator_U b_first, size_t n) { + vector> 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 +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& operator++() { ++value; return *this; } + ArithmeticIterator& operator--() { --value; return *this; } + bool operator==(const ArithmeticIterator& rhs) const { return value == rhs.value; } +}; +template vector> enumerate(const vector& container) { + return zip(ArithmeticIterator(0), ArithmeticIterator(INT_MAX), container.begin(), container.end()); +} +///////////////////////////////////////////////////////// + +// #define SINGLE_TEST_CASE +// #define DUMP_TEST_CASE 7219 +// #define TOT_TEST_CASE 10000 + +void dump() {} + +void dump_ignore() {} + +void prep() { +} + +template> struct sparse_table { + _Op op; + vector> st; + template + sparse_table(ReverseIterator __first, ReverseIterator __last, _Op&& __operation) { + op = __operation; + int n = distance(__first, __last); + st = vector>(n, vector<_Tp>(int(log2(n) + 1))); + int i = n - 1; + for (auto it = __first; it != __last; ++it) { + st[i][0] = *it; + for (int j = 1; i + (1 << j) <= n; ++j) { + st[i][j] = op(st[i][j - 1], st[i + (1 << (j - 1))][j - 1]); + } + i -= 1; + } + } + _Tp query(size_t __start, size_t __end) { + int s = lg2(__end - __start + 1); + return op(st[__start][s], st[__end - (1 << s) + 1][s]); + } +}; + +void solve() { + read(ll, n, m); + read(int, k); + readvec(pll, a, k); + vector rev(k); + iota(rev.begin(), rev.end(), 0); + sort_by_key(rev.begin(), rev.end(), [&] (int i) -> pll { return {a[i].first, -a[i].second}; }); + sort_by_key(a.begin(), a.end(), [&] (pll x) -> pll { return {x.first, -x.second}; }); + ll res = 0; + vector ss(k + 1, {m + 1, n + 1}); + vector stale(k); + for (int i = 0; i < k - 1; ++i) { + if (a[i + 1].first == a[i].first) { + stale[i] = 1; + } + } + a.emplace_back(n + 1, m + 1); + vector> st; + st.emplace_back(0, 0, -1); + vector> c(k); + vector val(k + 1); + vector fa(k + 1); + ll curr = 0; + vector tag; + for (int i = 0; i < k; ++i) { + tag.emplace_back(a[i].second, i); + } + sparse_table rmq(tag.rbegin(), tag.rend(), functor(min)); + for (int i = 0; i <= k; ++i) { + while (st.size() and get<1>(st.back()) > a[i].second) { + st.pop_back(); + } + int prev = get<2>(st.back()); + curr = (prev == -1 ? 0 : val[prev]) + (a[i].second - 1) * (a[i].first - get<0>(st.back())); + val[i] = curr; + st.emplace_back(a[i].first, a[i].second, i); + fa[i] = prev; + int l = -1, r = prev - 1; + if (l > r) continue; + while (l < r) { + int mid = l + r + 1 >> 1; + if ((mid == -1 ? 0 : rmq.query(mid, prev - 1).first) <= a[i].second) { + l = mid; + } else { + r = mid - 1; + } + } + if ((l == -1 ? 0 : a[l].second) <= a[i].second) { + ll asdf = (l == -1 ? 0 : val[l]) + (a[i].second - 1) * (a[i].first - (l == -1 ? 0 : a[l].first)); + c[prev][i] = asdf - curr; + // debug(make_tuple(l, prev, rev[prev])); + } + } + curr -= m; + cout << curr << '\n'; + vector d(k); + int ptr = k; + while (fa[ptr] != -1) { + d[rev[fa[ptr]]] = c[fa[ptr]][ptr]; + ptr = fa[ptr]; + } + putvec(d); +} + +int main() { +#if __cplusplus < 201402L or defined(_MSC_VER) and not defined(__clang__) + 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 +} diff --git a/src/bin/cf-1980g.cc b/src/bin/cf-1980g.cc new file mode 100644 index 0000000..839a2af --- /dev/null +++ b/src/bin/cf-1980g.cc @@ -0,0 +1,653 @@ +/** + * Author: subcrip + * Created: 2024-06-04 21:12:25 + * Modified: 2024-06-04 23:19:38 + * Elapsed: 127 minutes + */ + +#pragma GCC optimize("Ofast") +///////////////////////////////////////////////////////// +/** + * This code should require C++14. + * However, it's only been tested with C++17. + */ + +#include +using namespace std; + +/* macro helpers */ +#define __NARGS(...) std::tuple_size::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::type + +/* 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; +using ld = long double; +#endif +using int128 = __int128_t; +using uint128 = __uint128_t; +using ld = long double; +using pii = pair; +using pil = pair; +using pli = pair; +using pll = pair; +using pid = pair; +using pdi = pair; +using pld = pair; +using pdl = pair; +using pdd = pair; +using tlll = tuple; +using tlld = tuple; +using tlli = tuple; +using tldl = tuple; +using tldd = tuple; +using tldi = tuple; +using tlil = tuple; +using tlid = tuple; +using tlii = tuple; +using tdll = tuple; +using tdld = tuple; +using tdli = tuple; +using tddl = tuple; +using tddd = tuple; +using tddi = tuple; +using tdil = tuple; +using tdid = tuple; +using tdii = tuple; +using till = tuple; +using tild = tuple; +using tili = tuple; +using tidl = tuple; +using tidd = tuple; +using tidi = tuple; +using tiil = tuple; +using tiid = tuple; +using tiii = tuple; +template using max_heap = priority_queue; +template using min_heap = priority_queue, greater<>>; +template using oi = ostream_iterator; +template using ii = istream_iterator; + +/* constants */ +constexpr int INF = 0x3f3f3f3f; +constexpr ll INFLL = 0x3f3f3f3f3f3f3f3fLL; +constexpr ll MDL = 1e9 + 7; +constexpr ll PRIME = 998'244'353; +constexpr ll MDL1 = 8784491; +constexpr ll MDL2 = PRIME; +constexpr int128 INT128_MAX = numeric_limits::max(); +constexpr uint128 UINT128_MAX = numeric_limits::max(); +constexpr int128 INT128_MIN = numeric_limits::min(); +constexpr uint128 UINT128_MIN = numeric_limits::min(); + +/* random */ + +mt19937 rd(chrono::duration_cast(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 +#define ugt std::greater + +#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 + size_t operator()(const pair& 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 dist(PRIME); +const size_t __array_hash_b = 31, __array_hash_mdl1 = dist(rd), __array_hash_mdl2 = dist(rd); +struct array_hash { + template + size_t operator()(const Sequence& arr) const { + size_t pw1 = 1, pw2 = 1; + size_t res1 = 0, res2 = 0; + for (auto&& x : arr) { + res1 = (res1 + x * pw1) % __array_hash_mdl1; + res2 = (res2 + x * 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 pa(a) __AS_PROCEDURE(__typeof(a) pa; pa.push_back({}); for (auto&&x : a) pa.push_back(pa.back() + x);) +#define sa(a) __AS_PROCEDURE(__typeof(a) sa(a.size() + 1); {int n = a.size(); for (int i = n - 1; i >= 0; --i) sa[i] = sa[i + 1] + a[i];};) +#define adj(ch, n) __AS_PROCEDURE(vector> 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, w) __AS_PROCEDURE(ch[u].emplace_back(v, w), ch[v].emplace_back(u, w);) +#define Edge(ch, u, v) __AS_PROCEDURE(ch[u].push_back(v);) +#define Edgew(ch, u, v, w) __AS_PROCEDURE(ch[u].emplace_back(v, w);) +template pair> discretize(Iterator __first, Iterator __last) { + set st(__first, __last); + size_t N = 0; + map mp; + for (auto&& x : st) mp[x] = ++N; + return {N, mp}; +} +template pair> unordered_discretize(Iterator __first, Iterator __last) { + set st(__first, __last); + size_t N = 0; + unordered_map 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)) +template void __read(T& x) { cin >> x; } +template void __read(T& x, U&... args) { cin >> x; __read(args...); } +#define read(type, ...) __AS_PROCEDURE(type __VA_ARGS__; __read(__VA_ARGS__);) +#define readvec(type, a, n) __AS_PROCEDURE(vector a(n); for (auto& x : a) cin >> x;) +#define readvec1(type, a, n) __AS_PROCEDURE(vector a((n) + 1); copy_n(ii(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;) +template istream& operator>>(istream& in, pair& p) { + return in >> p.first >> p.second; +} +template ostream& operator<<(ostream& out, const pair& p) { + out << "{" << p.first << ", " << p.second << "}"; + return out; +} +template +void print_tuple_impl(std::basic_ostream& os, const Tuple& t, std::index_sequence) { + using swallow = int[]; // guaranties left to right order + (void)swallow { 0, (void(os << (Index == 0 ? "" : ", ") << std::get(t)), 0)... }; +} +template +decltype(auto) operator<<(std::basic_ostream& os, const std::tuple& t) { + os << "{"; + print_tuple_impl(os, t, std::index_sequence_for{}); + return os << "}"; +} +template ostream& operator<<(ostream& out, const vector& 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; +} + +/* pops */ +#define poptop(q, ...) __AS_PROCEDURE(auto [__VA_ARGS__] = q.top(); q.pop();) +#define popback(q, ...) __AS_PROCEDURE(auto [__VA_ARGS__] = q.back(); q.pop_back();) +#define popfront(q, ...) __AS_PROCEDURE(auto [__VA_ARGS__] = q.front();q.pop_front();) + +/* math */ +template +return_t qpow(ll b, ll p) { + if (b == 0 and p != 0) return 0; + if (p == 0) return 1; + return_t half = qpow(b, p / 2); + if (p % 2 == 1) return half * half * b; + else return half * half; +} + +#define comb(n, k) ((n) < 0 or (k) < 0 or (n) < (k) ? 0 : fact[n] / fact[k] / fact[(n) - (k)]) + +constexpr inline int lg2(ll x) { return x == 0 ? -1 : sizeof(ll) * 8 - 1 - __builtin_clzll(x); } + +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> decompose(ll x) { + // return (factor, count, factor ** count) + vector> 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 decompose_prime(int N) { + // return (factor, count) + vector 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 calc_next(string t) { // pi function of t + int n = (int)t.length(); + vector 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 calc_z(string t) { // z function of t + int m = t.length(); + vector z; + z.push_back(m); + pair 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 kmp(string s, string t) { // find all t in s + string cur = t + '#' + s; + int sz1 = s.size(), sz2 = t.size(); + vector v; + vector 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(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 struct MLL { + ll val; + MLL(ll v = 0) : val(mod(v, mdl)) {} + MLL(const MLL& 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 * mod(inverse(rhs.val, mdl), 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; } + void operator+=(const MLL& rhs) { val = (*this + rhs).val; } + void operator-=(const MLL& rhs) { val = (*this - rhs).val; } + void operator*=(const MLL& rhs) { val = (*this * rhs).val; } + void operator/=(const MLL& rhs) { val = (*this / rhs).val; } + void operator%=(const MLL& rhs) { val = (*this % rhs).val; } +}; +struct MLLd { + ll val, mdl; + MLLd(ll mdl, ll v = 0) : mdl(mdl), val(mod(v, mdl)) {} + MLLd(const MLLd& other) : mdl(other.mdl), val(other.val) {} + friend MLLd operator+(const MLLd& lhs, const MLLd& rhs) { return MLLd(lhs.mdl, mod(lhs.val + rhs.val, lhs.mdl)); } + friend MLLd operator-(const MLLd& lhs, const MLLd& rhs) { return MLLd(lhs.mdl, mod(lhs.val - rhs.val, lhs.mdl)); } + friend MLLd operator*(const MLLd& lhs, const MLLd& rhs) { return MLLd(lhs.mdl, mod(lhs.val * rhs.val, lhs.mdl)); } + friend MLLd operator/(const MLLd& lhs, const MLLd& rhs) { return MLLd(lhs.mdl, mod(lhs.val * mod(inverse(rhs.val, lhs.mdl), lhs.mdl), lhs.mdl)); } + friend MLLd operator%(const MLLd& lhs, const MLLd& rhs) { return MLLd(lhs.mdl, mod(lhs.val - (lhs / rhs).val, lhs.mdl)); } + friend bool operator==(const MLLd& lhs, const MLLd& rhs) { return lhs.val == rhs.val; } + friend bool operator!=(const MLLd& lhs, const MLLd& rhs) { return lhs.val != rhs.val; } + void operator+=(const MLLd& rhs) { val = (*this + rhs).val; } + void operator-=(const MLLd& rhs) { val = (*this - rhs).val; } + void operator*=(const MLLd& rhs) { val = (*this * rhs).val; } + void operator/=(const MLLd& rhs) { val = (*this / rhs).val; } + void operator%=(const MLLd& rhs) { val = (*this % rhs).val; } +}; + +template +ostream& operator<<(ostream& out, const MLL& num) { + return out << num.val; +} + +ostream& operator<<(ostream& out, const MLLd& num) { + return out << num.val; +} + +template +istream& operator>>(istream& in, MLL& num) { + return in >> num.val; +} + +istream& operator>>(istream& in, MLLd& num) { + return in >> num.val; +} + +// miscancellous +#define functor(func) [&](auto&&... val) \ +noexcept(noexcept(func(std::forward(val)...))) -> decltype(auto) \ +{return func(std::forward(val)...);} +template 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 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 +vector> zip(Iterator_T a_first, Iterator_T a_last, Iterator_U b_first, Iterator_U b_last) { + vector> 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 +vector> zip_n(Iterator_T a_first, Iterator_U b_first, size_t n) { + vector> 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 +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& operator++() { ++value; return *this; } + ArithmeticIterator& operator--() { --value; return *this; } + bool operator==(const ArithmeticIterator& rhs) const { return value == rhs.value; } +}; +template vector> enumerate(const vector& container) { + return zip(ArithmeticIterator(0), ArithmeticIterator(INT_MAX), container.begin(), container.end()); +} +///////////////////////////////////////////////////////// + +// #define SINGLE_TEST_CASE +// #define DUMP_TEST_CASE 7219 +// #define TOT_TEST_CASE 10000 + +void dump() {} + +void dump_ignore() {} + +void prep() { +} + +template +struct binary_trie { + vector, DataT, array>> tr; + binary_trie() : tr(1) {} + void emplace(ll x, const DataT& data = {}) { + int ptr = 0; + for (int i = N - 1; ~i; --i) { + int bit = x >> i & 1; + if (not std::get<0>(tr[ptr])[bit]) { + std::get<0>(tr[ptr])[bit] = tr.size(); + tr.emplace_back(); + } + std::get<2>(tr[ptr])[bit] += 1; + ptr = std::get<0>(tr[ptr])[bit]; + } + std::get<1>(tr[ptr]) = data; + } + + /// WARN: Don't try to erase a non-existent element! + void erase(ll x) { + int ptr = 0; + vector st; + for (int i = N - 1; ~i; --i) { + int bit = x >> i & 1; + st.emplace_back(ptr, bit); + ptr = std::get<0>(tr[ptr])[bit]; + } + while (st.size() and std::get<2>(tr[st.back().first])[st.back().second] == 1) { + std::get<0>(tr[st.back().first])[st.back().second] = 0; + std::get<2>(tr[st.back().first])[st.back().second] = 0; + st.pop_back(); + } + tr[ptr] = {}; + } + + optional get(ll x) { + int ptr = 0; + for (int i = N - 1; ~i; --i) { + int bit = x >> i & 1; + if (not std::get<0>(tr[ptr])[bit]) return {}; + ptr = std::get<0>(tr[ptr])[bit]; + } + return { std::get<1>(tr[ptr]) }; + } + + int count_prefix(ll x, int bits = N) { + int ptr = 0; + int res = 0; + for (int i = N - 1; i > max(-1, N - 1 - bits); --i) { + int bit = x >> 1 & 1; + if (not std::get<0>(tr[ptr])[bit]) return 0; + ptr = std::get<0>(tr[ptr])[bit]; + res = std::get<2>(tr[ptr])[bit]; + } + return res; + } + + optional> get_max_xor(ll x) { + int ptr = 0; + ll res = 0; + for (int i = N - 1; ~i; --i) { + int bit = x >> i & 1; + if (std::get<0>(tr[ptr])[1 ^ bit]) { + ptr = std::get<0>(tr[ptr])[1 ^ bit]; + res |= (1 ^ bit) << i; + } else if (std::get<0>(tr[ptr])[bit]) { + ptr = std::get<0>(tr[ptr])[bit]; + res |= bit << i; + } else { + return {}; + } + } + return {{ res, std::get<1>(tr[ptr]) }}; + } +}; + +void solve() { + read(int, n, m); + vector> e(n + 1); + for (int i = 0; i < n - 1; ++i) { + read(int, u, v, w); + edgew(e, u, v, w); + } + array, 2> trie; + vector l(n + 1); + vector pre(n + 1); + auto dfs = [&] (auto dfs, int v, int pa, int layer, int pf) -> void { + l[v] = layer; + pre[v] = pf; + if (trie[layer].count_prefix(pf)) { + trie[layer].emplace(pf, trie[layer].get(pf).value() + 1); + } else { + trie[layer].emplace(pf, 1); + } + for (auto&& [u, w] : e[v]) { + if (u == pa) continue; + dfs(dfs, u, v, 1 ^ layer, pf ^ w); + } + }; + dfs(dfs, 1, 0, 0, 0); + int acc = 0; + while (m--) { + read(char, op); + if (op == '^') { + read(int, y); + acc ^= y; + } else { + read(int, v, x); + int prev_val = pre[v]; + int q = trie[l[v]].get(prev_val).value(); + if (q == 1) { + trie[l[v]].erase(prev_val); + } else { + trie[l[v]].emplace(prev_val, q - 1); + } + int v_pf = l[v] == 1 ? pre[v] ^ acc : pre[v]; + ll res = 0; + // process the odd part + auto u_odd_pf = trie[1].get_max_xor(v_pf ^ acc ^ x); + if (u_odd_pf != nullopt) res = max(res, u_odd_pf->first ^ v_pf ^ acc ^ x); + // process the even part + auto u_even_pf = trie[0].get_max_xor(v_pf ^ x); + if (u_even_pf != nullopt) res = max(res, u_even_pf->first ^ v_pf ^ x); + cout << res << ' '; + trie[l[v]].emplace(prev_val, q); + } + } + cout << '\n'; +} + +int main() { +#if __cplusplus < 201402L or defined(_MSC_VER) and not defined(__clang__) + 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 +} diff --git a/src/bin/ctext_out.cc b/src/bin/ctext_out.cc index a390bc2..3a1dbf6 100644 --- a/src/bin/ctext_out.cc +++ b/src/bin/ctext_out.cc @@ -1,10 +1,3 @@ -/** - * Author: subcrip - * Created: 2024-06-02 19:04:46 - * Modified: 2024-06-02 19:52:13 - * Elapsed: 47 minutes - */ - #pragma GCC optimize("Ofast") ///////////////////////////////////////////////////////// /** @@ -523,7 +516,7 @@ private: else set(m + 1, t, p * 2 + 1, x, c); pull(p); } - + void range_apply(size_type s, size_type t, size_type p, size_type l, size_type r, const tag_type& c) { if (l <= s && t <= r) { d[p].apply(c, t - s + 1); @@ -565,7 +558,7 @@ public: void set(size_type i, const info_type& c) { set({}, _max, 1, i, c); } - + void range_apply(size_type l, size_type r, const tag_type& c) { range_apply({}, _max, 1, l, r, c); } @@ -590,66 +583,82 @@ public: } }; struct Tag { - int val = 0; + ll val = -INFLL; void apply(const Tag& rhs) { - val = rhs.val; + val = max(val, rhs.val); } }; struct Info { - int val = 0; + ll val = -INFLL; void apply(const Tag& rhs, size_t len) { - val += rhs.val * len; + val = max(val, rhs.val); } }; Info operator+(const Info &a, const Info &b) { - return {a.val + b.val}; + return {max(a.val, b.val)}; } void solve() { - read(int, n); - read(string, s, t); - array, 26> bk; - for (int i = n - 1; ~i; --i) { - bk[s[i] - 'a'].emplace_back(i); - } - ll res = INFLL; - ll cnt = 0; - vector mark(n); - segtree tr(n); - auto get = [&] (int i) -> int { - return i + (i + 1 > n - 1 ? 0 : tr.range_query(i + 1, n - 1).val); - }; - int ptr = 0; + read(int, n, m); + vector> row(n); + segtree big(m), small(m); for (int i = 0; i < n; ++i) { - while (mark[ptr]) ++ptr; - assert(ptr < n); - int x = s[ptr] - 'a', y = t[i] - 'a'; - if (x < y) { - res = min(res, cnt); - } - int f = 0; - for (int j = 0; j < 26; ++j) { - while (bk[j].size() and (mark[bk[j].back()] or get(bk[j].back()) < i)) { - bk[j].pop_back(); - } - if (bk[j].size()) { - if (j < y) { - res = min(res, cnt + get(bk[j].back()) - i); - } else if (j == y) { - f = 1; - mark[bk[j].back()] = 1; - tr.set(bk[j].back(), {1}); - cnt += get(bk[j].back()) - i; - } + for (int j = 0; j < m; ++j) { + read(char, c); + if (c == 'B') { + row[i].emplace_back(j); } } - if (f == 0) break; } - if (res == INFLL) { - cout << -1 << '\n'; - } else { - cout << res << '\n'; + vector> res(n, vector(m)); + for (int i = 0; i < n; ++i) { + for (auto&& j : row[i]) { + big.apply(j, {-i+j}); + small.apply(j, {-i-j}); + } + for (int j = 0; j < m; ++j) { + ll big_query = big.range_query(j, m).val; + ll small_query = small.range_query(0, j).val; + if (big_query != -INFLL) { + res[i][j] = max(res[i][j], i - j + int(big_query)); + } + if (small_query != -INFLL) { + res[i][j] = max(res[i][j], i + j + int(small_query)); + } + } } + for (int j = 0; j < m; ++j) { + big.set(j, {}); + small.set(j, {}); + } + for (int i = n - 1; ~i; --i) { + for (auto&& j : row[i]) { + big.apply(j, {i+j}); + small.apply(j, {i-j}); + } + for (int j = 0; j < m; ++j) { + ll big_query = big.range_query(j, m).val; + ll small_query = small.range_query(0, j).val; + if (big_query != -INFLL) { + res[i][j] = max(res[i][j], - i - j + int(big_query)); + } + if (small_query != -INFLL) { + res[i][j] = max(res[i][j], - i + j + int(small_query)); + } + } + } + int ans = INF; + int x = 0, y = 0; + for (int i = 0; i < n; ++i) { + for (int j = 0; j < m; ++j) { + if (res[i][j] < ans) { + ans = res[i][j]; + x = i + 1; + y = j + 1; + } + } + } + cout << x << ' ' << y << '\n'; } int main() { diff --git a/src/bin/d.cc b/src/bin/d.cc index dd14c1c..160e655 100644 --- a/src/bin/d.cc +++ b/src/bin/d.cc @@ -1,16 +1,15 @@ /** * Author: subcrip - * Created: 2024-05-27 21:39:24 - * Modified: 2024-05-27 22:45:19 - * Elapsed: 65 minutes + * Created: 2024-06-03 23:04:55 + * Modified: 2024-06-03 23:17:23 + * Elapsed: 12 minutes */ #pragma GCC optimize("Ofast") ///////////////////////////////////////////////////////// /** - * Useful Macros - * by subcrip - * (requires C++17) + * This code should require C++14. + * However, it's only been tested with C++17. */ #include @@ -181,6 +180,7 @@ struct array_hash { }; /* 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 pa(a) __AS_PROCEDURE(__typeof(a) pa; pa.push_back({}); for (auto&&x : a) pa.push_back(pa.back() + x);) @@ -270,6 +270,17 @@ std::ostream& operator<<(std::ostream& dest, const int128& value) { #define popfront(q, ...) __AS_PROCEDURE(auto [__VA_ARGS__] = q.front();q.pop_front();) /* math */ +template +return_t qpow(ll b, ll p) { + if (b == 0 and p != 0) return 0; + if (p == 0) return 1; + return_t half = qpow(b, p / 2); + if (p % 2 == 1) return half * half * b; + else return half * half; +} + +#define comb(n, k) ((n) < 0 or (k) < 0 or (n) < (k) ? 0 : fact[n] / fact[k] / fact[(n) - (k)]) + constexpr inline int lg2(ll x) { return x == 0 ? -1 : sizeof(ll) * 8 - 1 - __builtin_clzll(x); } void __exgcd(ll a, ll b, ll& x, ll& y) { @@ -425,6 +436,9 @@ istream& operator>>(istream& in, MLLd& num) { } // miscancellous +#define functor(func) [&](auto&&... val) \ +noexcept(noexcept(func(std::forward(val)...))) -> decltype(auto) \ +{return func(std::forward(val)...);} template 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)); }); } @@ -482,123 +496,44 @@ void dump_ignore() {} void prep() { } -static vector> power1; -static vector> power2; -static const ll b = rd(); -template -struct hash_vec { - using hash_type = pll; - MLL hash1; - MLL hash2; - vector<_Tp> seq; - size_t size() { - return seq.size(); - } - void push_back(const _Tp& x) { - hash1 = hash1 * b + x; - hash2 = hash2 * b + x; - seq.push_back(x); - } - void push_front(const _Tp& x) { - size_t length = size(); - hash1 += x * power1[length]; - hash2 += x * power2[length]; - seq.push_front(x); - } - void pop_back() { - _Tp e = seq.back(); seq.pop_back(); - hash1 = (hash1 - e) / b; - hash2 = (hash2 - e) / b; - } - void pop_front() { - _Tp e = seq.front(); seq.pop_front(); - int length = seq.size(); - hash1 -= e * power1[length]; - hash2 -= e * power2[length]; - } - void set(size_t pos, const _Tp& value) { - int length = seq.size(); - int old_value = seq[pos]; - hash1 += (value - old_value) * power1[length - 1 - pos]; - hash2 += (value - old_value) * power2[length - 1 - pos]; - seq[pos] = value; - } - const _Tp& operator[](size_t pos) { - return seq[pos]; - } - hash_type hash() { - return {hash1.val, hash2.val}; - } - void clear() { - hash1 = 0; - hash2 = 0; - seq.clear(); - } - hash_vec(size_t maxn) { - clear(); - MLL c1 = power1.size() ? power1.back() * b : 1; - MLL c2 = power2.size() ? power2.back() * b : 1; - for (int i = power1.size(); i < maxn; ++i) { - power1.push_back(c1); - power2.push_back(c2); - c1 *= b; - c2 *= b; - } - } - hash_vec(size_t maxn, const _Tp& init_value) : hash_vec(maxn) { - for (size_t i = 0; i != maxn; ++i) { - push_back(init_value); - } - } -}; - void solve() { - read(int, n, m); - vector> a(n, vector(m)); - for (int i = 0; i < n; ++i) { - for (int j = 0; j < m; ++j) { - read(char, c); - a[i][j] = c == '1'; + read(int, n); + readvec(int, a, n); + auto check = [&] (int idx) -> bool { + int prev_num = idx == 0 ? a[1] : a[0]; + int prev_gcd = -INF; + for (int i = idx == 0 ? 2 : 1; i < n; ++i) { + if (i == idx) continue; + int curr_gcd = gcd(a[i], prev_num); + if (curr_gcd < prev_gcd) { + return false; + } + prev_gcd = curr_gcd; + prev_num = a[i]; } - } - unordered_map>, pair_hash> dp; - for (int j = 0; j < m; ++j) { - hash_vec v(n); - for (int i = 0; i < n; ++i) { - v.push_back(a[i][j]); - } - for (int i =0; i < n; ++i) { - v.set(i, a[i][j] ^ 1); - dp[v.hash()] = {dp[v.hash()].first + 1, {j, i}}; - v.set(i, a[i][j]); + return true; + }; + int prev_gcd = -INF; + for (int i = 1; i < n; ++i) { + int curr_gcd = gcd(a[i], a[i - 1]); + if (curr_gcd < prev_gcd) { + if ((i - 2 >= 0 and check(i - 2)) or check(i - 1) or check(i)) { + cout << "YES\n"; + } else { + cout << "NO\n"; + } + return; } + prev_gcd = curr_gcd; } - int k = 0; - pair v; - for (auto&& [k1, v1] : dp) { - if (v1.first > k) { - k = v1.first; - v = v1.second; - } - } - vector res(n); - auto [q, p] = v; - for (int i = 0; i < n; ++i) { - res[i] = a[i][q]; - } - res[p] = a[p][q] ^ 1; - cout << k << '\n'; - for (int i = 0; i < n; ++i) { - cout << res[i]; - } - cout << '\n';; + cout << "YES\n"; } int main() { -#if __cplusplus < 201703L 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."); #endif - untie, cout.tie(NULL); + untie; prep(); #ifdef SINGLE_TEST_CASE solve(); diff --git a/src/bin/e.cc b/src/bin/e.cc index b428862..ac94213 100644 --- a/src/bin/e.cc +++ b/src/bin/e.cc @@ -1,9 +1,15 @@ +/** + * Author: subcrip + * Created: 2024-06-03 23:18:29 + * Modified: 2024-06-03 23:35:27 + * Elapsed: 16 minutes + */ + #pragma GCC optimize("Ofast") ///////////////////////////////////////////////////////// /** - * Useful Macros - * by subcrip - * (requires C++17) + * This code should require C++14. + * However, it's only been tested with C++17. */ #include @@ -15,7 +21,7 @@ using namespace std; #define __DECOMPOSE_N(a, ...) auto [__VA_ARGS__] = a; constexpr void __() {} #define __AS_PROCEDURE(...) __(); __VA_ARGS__; __() -#define __as_typeof(container) decltype(container)::value_type +#define __as_typeof(container) remove_reference::type /* type aliases */ #if LONG_LONG_MAX != INT64_MAX @@ -67,6 +73,8 @@ using tiid = tuple; using tiii = tuple; template using max_heap = priority_queue; template using min_heap = priority_queue, greater<>>; +template using oi = ostream_iterator; +template using ii = istream_iterator; /* constants */ constexpr int INF = 0x3f3f3f3f; @@ -172,6 +180,7 @@ struct array_hash { }; /* 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 pa(a) __AS_PROCEDURE(__typeof(a) pa; pa.push_back({}); for (auto&&x : a) pa.push_back(pa.back() + x);) @@ -201,10 +210,17 @@ template pair void __read(T& x) { cin >> x; } template void __read(T& x, U&... args) { cin >> x; __read(args...); } #define read(type, ...) __AS_PROCEDURE(type __VA_ARGS__; __read(__VA_ARGS__);) -#define readvec(type, a, n) __AS_PROCEDURE(vector a(n); for (int i = 0; i < (n); ++i) cin >> a[i];) -#define putvec(a) __AS_PROCEDURE(for (auto&& x : a) cout << x << ' '; cout << endl;) +#define readvec(type, a, n) __AS_PROCEDURE(vector a(n); for (auto& x : a) cin >> x;) +#define readvec1(type, a, n) __AS_PROCEDURE(vector a((n) + 1); copy_n(ii(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;) +template istream& operator>>(istream& in, pair& p) { + return in >> p.first >> p.second; +} template ostream& operator<<(ostream& out, const pair& p) { out << "{" << p.first << ", " << p.second << "}"; return out; @@ -254,6 +270,17 @@ std::ostream& operator<<(std::ostream& dest, const int128& value) { #define popfront(q, ...) __AS_PROCEDURE(auto [__VA_ARGS__] = q.front();q.pop_front();) /* math */ +template +return_t qpow(ll b, ll p) { + if (b == 0 and p != 0) return 0; + if (p == 0) return 1; + return_t half = qpow(b, p / 2); + if (p % 2 == 1) return half * half * b; + else return half * half; +} + +#define comb(n, k) ((n) < 0 or (k) < 0 or (n) < (k) ? 0 : fact[n] / fact[k] / fact[(n) - (k)]) + constexpr inline int lg2(ll x) { return x == 0 ? -1 : sizeof(ll) * 8 - 1 - __builtin_clzll(x); } void __exgcd(ll a, ll b, ll& x, ll& y) { @@ -372,77 +399,248 @@ template struct MLL { void operator/=(const MLL& rhs) { val = (*this / rhs).val; } void operator%=(const MLL& rhs) { val = (*this % rhs).val; } }; +struct MLLd { + ll val, mdl; + MLLd(ll mdl, ll v = 0) : mdl(mdl), val(mod(v, mdl)) {} + MLLd(const MLLd& other) : mdl(other.mdl), val(other.val) {} + friend MLLd operator+(const MLLd& lhs, const MLLd& rhs) { return MLLd(lhs.mdl, mod(lhs.val + rhs.val, lhs.mdl)); } + friend MLLd operator-(const MLLd& lhs, const MLLd& rhs) { return MLLd(lhs.mdl, mod(lhs.val - rhs.val, lhs.mdl)); } + friend MLLd operator*(const MLLd& lhs, const MLLd& rhs) { return MLLd(lhs.mdl, mod(lhs.val * rhs.val, lhs.mdl)); } + friend MLLd operator/(const MLLd& lhs, const MLLd& rhs) { return MLLd(lhs.mdl, mod(lhs.val * mod(inverse(rhs.val, lhs.mdl), lhs.mdl), lhs.mdl)); } + friend MLLd operator%(const MLLd& lhs, const MLLd& rhs) { return MLLd(lhs.mdl, mod(lhs.val - (lhs / rhs).val, lhs.mdl)); } + friend bool operator==(const MLLd& lhs, const MLLd& rhs) { return lhs.val == rhs.val; } + friend bool operator!=(const MLLd& lhs, const MLLd& rhs) { return lhs.val != rhs.val; } + void operator+=(const MLLd& rhs) { val = (*this + rhs).val; } + void operator-=(const MLLd& rhs) { val = (*this - rhs).val; } + void operator*=(const MLLd& rhs) { val = (*this * rhs).val; } + void operator/=(const MLLd& rhs) { val = (*this / rhs).val; } + void operator%=(const MLLd& rhs) { val = (*this % rhs).val; } +}; template ostream& operator<<(ostream& out, const MLL& num) { return out << num.val; } +ostream& operator<<(ostream& out, const MLLd& num) { + return out << num.val; +} + template istream& operator>>(istream& in, MLL& num) { return in >> num.val; } +istream& operator>>(istream& in, MLLd& num) { + return in >> num.val; +} + // miscancellous +#define functor(func) [&](auto&&... val) \ +noexcept(noexcept(func(std::forward(val)...))) -> decltype(auto) \ +{return func(std::forward(val)...);} template 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 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 +vector> zip(Iterator_T a_first, Iterator_T a_last, Iterator_U b_first, Iterator_U b_last) { + vector> 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 +vector> zip_n(Iterator_T a_first, Iterator_U b_first, size_t n) { + vector> 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 +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& operator++() { ++value; return *this; } + ArithmeticIterator& operator--() { --value; return *this; } + bool operator==(const ArithmeticIterator& rhs) const { return value == rhs.value; } +}; +template vector> enumerate(const vector& container) { + return zip(ArithmeticIterator(0), ArithmeticIterator(INT_MAX), container.begin(), container.end()); +} ///////////////////////////////////////////////////////// -#define SINGLE_TEST_CASE +// #define SINGLE_TEST_CASE // #define DUMP_TEST_CASE 7219 +// #define TOT_TEST_CASE 10000 void dump() {} void dump_ignore() {} -void prep() {} +void prep() { +} + +static vector> power1; +static vector> power2; +static const ll b = rd(); +template +struct hash_vec { + using hash_type = pll; + MLL hash1; + MLL hash2; + vector<_Tp> seq; + size_t size() { + return seq.size(); + } + void push_back(const _Tp& x) { + hash1 = hash1 * b + x; + hash2 = hash2 * b + x; + seq.push_back(x); + } + void push_front(const _Tp& x) { + size_t length = size(); + hash1 += x * power1[length]; + hash2 += x * power2[length]; + seq.push_front(x); + } + void pop_back() { + _Tp e = seq.back(); seq.pop_back(); + hash1 = (hash1 - e) / b; + hash2 = (hash2 - e) / b; + } + void pop_front() { + _Tp e = seq.front(); seq.pop_front(); + int length = seq.size(); + hash1 -= e * power1[length]; + hash2 -= e * power2[length]; + } + void set(size_t pos, const _Tp& value) { + int length = seq.size(); + int old_value = seq[pos]; + hash1 += (value - old_value) * power1[length - 1 - pos]; + hash2 += (value - old_value) * power2[length - 1 - pos]; + seq[pos] = value; + } + const _Tp& operator[](size_t pos) { + return seq[pos]; + } + hash_type hash() { + return {hash1.val, hash2.val}; + } + void clear() { + hash1 = 0; + hash2 = 0; + seq.clear(); + } + hash_vec(size_t maxn) { + clear(); + MLL c1 = power1.size() ? power1.back() * b : 1; + MLL c2 = power2.size() ? power2.back() * b : 1; + for (int i = power1.size(); i < maxn; ++i) { + power1.push_back(c1); + power2.push_back(c2); + c1 *= b; + c2 *= b; + } + } + hash_vec(size_t maxn, const _Tp& init_value) : hash_vec(maxn) { + for (size_t i = 0; i != maxn; ++i) { + push_back(init_value); + } + } +}; void solve() { - read(int, n); - readvec(string, a, n); - vector, int>> trie(1); - auto insert = [&] (const string& s) -> void { - int curr = 0; - vector trace; - for (auto&& x : s) { - if (not trie[curr].first[x - 97]) { - trie[curr].first[x - 97] = trie.size(); - trie.push_back({}); - } - curr = trie[curr].first[x - 97]; - trace.emplace_back(curr); + read(int, n, m); + vector> a(n, vector(m)), b(n, vector(m)); + for (int i = 0; i < n; ++i) { + for (int j = 0; j < m; ++j) { + cin >> a[i][j]; } - for (auto&& i : trace) { - trie[i].second += 1; - } - }; - auto query = [&] (const string& s) -> ll { - ll res = 0; - int curr = 0; - for (auto&& x : s) { - curr = trie[curr].first[x - 97]; - if (not curr) break; - res += trie[curr].second; - } - return res; - }; - ll res = 0; - for (int i = n - 1; ~i; --i) { - res += query(a[i]); - insert(a[i]); } - cout << res << '\n'; + for (int i = 0; i < n; ++i) { + for (int j = 0; j < m; ++j) { + cin >> b[i][j]; + } + } + unordered_map::hash_type, vector, pair_hash> b_row; + hash_vec hs(max(n, m) + 1); + for (int i = 0; i < n; ++i) { + vector r = b[i]; + sort(r.begin(), r.end()); + hs.clear(); + for (int j = 0; j < m; ++j) { + hs.push_back(r[j]); + } + b_row[hs.hash()].emplace_back(i); + } + vector row_mapping(n); + for (int i = 0; i < n; ++i) { + hs.clear(); + vector r = a[i]; + sort(r.begin(), r.end()); + for (int j = 0; j < m; ++j) { + hs.push_back(r[j]); + } + if (not b_row.count(hs.hash())) { + cout << "NO\n"; + return; + } + row_mapping[i] = b_row[hs.hash()].back(); + b_row[hs.hash()].pop_back(); + if (b_row[hs.hash()].size() == 0) { + b_row.erase(hs.hash()); + } + } + vector> new_a(n, vector(m)); + for (int i = 0; i < n; ++i) { + for (int j = 0; j < m; ++j) { + new_a[row_mapping[i]][j] = a[i][j]; + } + } + unordered_map::hash_type, int, pair_hash> b_col; + for (int j = 0; j < m; ++j) { + hs.clear(); + for (int i = 0; i < n; ++i) { + hs.push_back(b[i][j]); + } + b_col[hs.hash()] += 1; + } + for (int j = 0; j < m; ++j) { + hs.clear(); + for (int i = 0; i < n; ++i) { + hs.push_back(new_a[i][j]); + } + if (b_col[hs.hash()] == 0) { + cout << "NO\n"; + return; + } + b_col[hs.hash()] -= 1; + } + cout << "YES\n"; } int main() { -#if __cplusplus < 201703L || defined(_MSC_VER) && !defined(__clang__) +#if __cplusplus < 201402L or defined(_MSC_VER) and not defined(__clang__) assert(false && "incompatible compiler variant detected."); #endif - untie, cout.tie(NULL); + untie; prep(); #ifdef SINGLE_TEST_CASE solve(); @@ -450,7 +648,7 @@ int main() { read(int, t); for (int i = 0; i < t; ++i) { #ifdef DUMP_TEST_CASE - if (t < (DUMP_TEST_CASE)) { + if (t != (TOT_TEST_CASE)) { solve(); } else if (i + 1 == (DUMP_TEST_CASE)) { dump(); diff --git a/src/bin/f.cc b/src/bin/f.cc index 35f7b1f..780e2f7 100644 --- a/src/bin/f.cc +++ b/src/bin/f.cc @@ -1,9 +1,15 @@ +/** + * Author: subcrip + * Created: 2024-06-03 23:49:19 + * Modified: 2024-06-04 01:17:16 + * Elapsed: 87 minutes + */ + #pragma GCC optimize("Ofast") ///////////////////////////////////////////////////////// /** - * Useful Macros - * by subcrip - * (requires C++17) + * This code should require C++14. + * However, it's only been tested with C++17. */ #include @@ -15,7 +21,7 @@ using namespace std; #define __DECOMPOSE_N(a, ...) auto [__VA_ARGS__] = a; constexpr void __() {} #define __AS_PROCEDURE(...) __(); __VA_ARGS__; __() -#define __as_typeof(container) decltype(container)::value_type +#define __as_typeof(container) remove_reference::type /* type aliases */ #if LONG_LONG_MAX != INT64_MAX @@ -67,6 +73,8 @@ using tiid = tuple; using tiii = tuple; template using max_heap = priority_queue; template using min_heap = priority_queue, greater<>>; +template using oi = ostream_iterator; +template using ii = istream_iterator; /* constants */ constexpr int INF = 0x3f3f3f3f; @@ -172,6 +180,7 @@ struct array_hash { }; /* 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 pa(a) __AS_PROCEDURE(__typeof(a) pa; pa.push_back({}); for (auto&&x : a) pa.push_back(pa.back() + x);) @@ -201,10 +210,17 @@ template pair void __read(T& x) { cin >> x; } template void __read(T& x, U&... args) { cin >> x; __read(args...); } #define read(type, ...) __AS_PROCEDURE(type __VA_ARGS__; __read(__VA_ARGS__);) -#define readvec(type, a, n) __AS_PROCEDURE(vector a(n); for (int i = 0; i < (n); ++i) cin >> a[i];) -#define putvec(a) __AS_PROCEDURE(for (auto&& x : a) cout << x << ' '; cout << endl;) +#define readvec(type, a, n) __AS_PROCEDURE(vector a(n); for (auto& x : a) cin >> x;) +#define readvec1(type, a, n) __AS_PROCEDURE(vector a((n) + 1); copy_n(ii(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;) +template istream& operator>>(istream& in, pair& p) { + return in >> p.first >> p.second; +} template ostream& operator<<(ostream& out, const pair& p) { out << "{" << p.first << ", " << p.second << "}"; return out; @@ -254,6 +270,17 @@ std::ostream& operator<<(std::ostream& dest, const int128& value) { #define popfront(q, ...) __AS_PROCEDURE(auto [__VA_ARGS__] = q.front();q.pop_front();) /* math */ +template +return_t qpow(ll b, ll p) { + if (b == 0 and p != 0) return 0; + if (p == 0) return 1; + return_t half = qpow(b, p / 2); + if (p % 2 == 1) return half * half * b; + else return half * half; +} + +#define comb(n, k) ((n) < 0 or (k) < 0 or (n) < (k) ? 0 : fact[n] / fact[k] / fact[(n) - (k)]) + constexpr inline int lg2(ll x) { return x == 0 ? -1 : sizeof(ll) * 8 - 1 - __builtin_clzll(x); } void __exgcd(ll a, ll b, ll& x, ll& y) { @@ -372,55 +399,196 @@ template struct MLL { void operator/=(const MLL& rhs) { val = (*this / rhs).val; } void operator%=(const MLL& rhs) { val = (*this % rhs).val; } }; +struct MLLd { + ll val, mdl; + MLLd(ll mdl, ll v = 0) : mdl(mdl), val(mod(v, mdl)) {} + MLLd(const MLLd& other) : mdl(other.mdl), val(other.val) {} + friend MLLd operator+(const MLLd& lhs, const MLLd& rhs) { return MLLd(lhs.mdl, mod(lhs.val + rhs.val, lhs.mdl)); } + friend MLLd operator-(const MLLd& lhs, const MLLd& rhs) { return MLLd(lhs.mdl, mod(lhs.val - rhs.val, lhs.mdl)); } + friend MLLd operator*(const MLLd& lhs, const MLLd& rhs) { return MLLd(lhs.mdl, mod(lhs.val * rhs.val, lhs.mdl)); } + friend MLLd operator/(const MLLd& lhs, const MLLd& rhs) { return MLLd(lhs.mdl, mod(lhs.val * mod(inverse(rhs.val, lhs.mdl), lhs.mdl), lhs.mdl)); } + friend MLLd operator%(const MLLd& lhs, const MLLd& rhs) { return MLLd(lhs.mdl, mod(lhs.val - (lhs / rhs).val, lhs.mdl)); } + friend bool operator==(const MLLd& lhs, const MLLd& rhs) { return lhs.val == rhs.val; } + friend bool operator!=(const MLLd& lhs, const MLLd& rhs) { return lhs.val != rhs.val; } + void operator+=(const MLLd& rhs) { val = (*this + rhs).val; } + void operator-=(const MLLd& rhs) { val = (*this - rhs).val; } + void operator*=(const MLLd& rhs) { val = (*this * rhs).val; } + void operator/=(const MLLd& rhs) { val = (*this / rhs).val; } + void operator%=(const MLLd& rhs) { val = (*this % rhs).val; } +}; template ostream& operator<<(ostream& out, const MLL& num) { return out << num.val; } +ostream& operator<<(ostream& out, const MLLd& num) { + return out << num.val; +} + template istream& operator>>(istream& in, MLL& num) { return in >> num.val; } +istream& operator>>(istream& in, MLLd& num) { + return in >> num.val; +} + // miscancellous +#define functor(func) [&](auto&&... val) \ +noexcept(noexcept(func(std::forward(val)...))) -> decltype(auto) \ +{return func(std::forward(val)...);} template 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 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 +vector> zip(Iterator_T a_first, Iterator_T a_last, Iterator_U b_first, Iterator_U b_last) { + vector> 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 +vector> zip_n(Iterator_T a_first, Iterator_U b_first, size_t n) { + vector> 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 +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& operator++() { ++value; return *this; } + ArithmeticIterator& operator--() { --value; return *this; } + bool operator==(const ArithmeticIterator& rhs) const { return value == rhs.value; } +}; +template vector> enumerate(const vector& container) { + return zip(ArithmeticIterator(0), ArithmeticIterator(INT_MAX), container.begin(), container.end()); +} ///////////////////////////////////////////////////////// // #define SINGLE_TEST_CASE // #define DUMP_TEST_CASE 7219 +// #define TOT_TEST_CASE 10000 void dump() {} void dump_ignore() {} -void prep() {} - -ll calc(ll r) { - ll res = 0; - for (ll x = -r; x <= r; ++x) { - ll rg = (ll(ceil(sqrt((long double)(r * r) - x * x))) - 1); - if (rg < 0) continue; - else res += 2 * rg + 1; - } - return res; +void prep() { } +template> struct sparse_table { + _Op op; + vector> st; + template + sparse_table(ReverseIterator __first, ReverseIterator __last, _Op&& __operation) { + op = __operation; + int n = distance(__first, __last); + st = vector>(n, vector<_Tp>(int(log2(n) + 1))); + int i = n - 1; + for (auto it = __first; it != __last; ++it) { + st[i][0] = *it; + for (int j = 1; i + (1 << j) <= n; ++j) { + st[i][j] = op(st[i][j - 1], st[i + (1 << (j - 1))][j - 1]); + } + i -= 1; + } + } + _Tp query(size_t __start, size_t __end) { + int s = lg2(__end - __start + 1); + return op(st[__start][s], st[__end - (1 << s) + 1][s]); + } +}; + + void solve() { - read(ll, r); - cout << calc(r + 1) - calc(r) << '\n'; + read(ll, n, m); + read(int, k); + readvec(pll, a, k); + vector rev(k); + iota(rev.begin(), rev.end(), 0); + sort_by_key(rev.begin(), rev.end(), [&] (int i) -> pll { return {a[i].first, -a[i].second}; }); + sort_by_key(a.begin(), a.end(), [&] (pll x) -> pll { return {x.first, -x.second}; }); + ll res = 0; + vector ss(k + 1, {m + 1, n + 1}); + vector stale(k); + for (int i = 0; i < k - 1; ++i) { + if (a[i + 1].first == a[i].first) { + stale[i] = 1; + } + } + a.emplace_back(n + 1, m + 1); + vector> st; + st.emplace_back(0, 0, -1); + vector> c(k); + vector val(k + 1); + vector fa(k + 1); + ll curr = 0; + vector tag; + for (int i = 0; i < k; ++i) { + tag.emplace_back(a[i].second, i); + } + sparse_table rmq(tag.rbegin(), tag.rend(), functor(min)); + for (int i = 0; i <= k; ++i) { + while (st.size() and get<1>(st.back()) > a[i].second) { + st.pop_back(); + } + int prev = get<2>(st.back()); + curr = (prev == -1 ? 0 : val[prev]) + (a[i].second - 1) * (a[i].first - get<0>(st.back())); + val[i] = curr; + st.emplace_back(a[i].first, a[i].second, i); + fa[i] = prev; + int l = -1, r = prev - 1; + if (l > r) continue; + while (l < r) { + int mid = l + r + 1 >> 1; + if ((mid == -1 ? 0 : rmq.query(mid, prev - 1).first) <= a[i].second) { + l = mid; + } else { + r = mid - 1; + } + } + if ((l == -1 ? 0 : a[l].second) <= a[i].second) { + ll asdf = (l == -1 ? 0 : val[l]) + (a[i].second - 1) * (a[i].first - (l == -1 ? 0 : a[l].first)); + c[prev][i] = asdf - curr; + // debug(make_tuple(l, prev, rev[prev])); + } + } + curr -= m; + cout << curr << '\n'; + vector d(k); + int ptr = k; + while (fa[ptr] != -1) { + d[rev[fa[ptr]]] = c[fa[ptr]][ptr]; + ptr = fa[ptr]; + } + putvec(d); } int main() { -#if __cplusplus < 201703L || defined(_MSC_VER) && !defined(__clang__) +#if __cplusplus < 201402L or defined(_MSC_VER) and not defined(__clang__) assert(false && "incompatible compiler variant detected."); #endif - untie, cout.tie(NULL); + untie; prep(); #ifdef SINGLE_TEST_CASE solve(); @@ -428,7 +596,7 @@ int main() { read(int, t); for (int i = 0; i < t; ++i) { #ifdef DUMP_TEST_CASE - if (t < (DUMP_TEST_CASE)) { + if (t != (TOT_TEST_CASE)) { solve(); } else if (i + 1 == (DUMP_TEST_CASE)) { dump(); diff --git a/src/bin/f1.cc b/src/bin/f1.cc new file mode 100644 index 0000000..cafa5f4 --- /dev/null +++ b/src/bin/f1.cc @@ -0,0 +1,611 @@ +/** + * Author: subcrip + * Created: 2024-06-03 23:49:19 + * Modified: 2024-06-04 01:18:51 + * Elapsed: 89 minutes + */ + +#pragma GCC optimize("Ofast") +///////////////////////////////////////////////////////// +/** + * This code should require C++14. + * However, it's only been tested with C++17. + */ + +#include +using namespace std; + +/* macro helpers */ +#define __NARGS(...) std::tuple_size::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::type + +/* 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; +using ld = long double; +#endif +using int128 = __int128_t; +using uint128 = __uint128_t; +using ld = long double; +using pii = pair; +using pil = pair; +using pli = pair; +using pll = pair; +using pid = pair; +using pdi = pair; +using pld = pair; +using pdl = pair; +using pdd = pair; +using tlll = tuple; +using tlld = tuple; +using tlli = tuple; +using tldl = tuple; +using tldd = tuple; +using tldi = tuple; +using tlil = tuple; +using tlid = tuple; +using tlii = tuple; +using tdll = tuple; +using tdld = tuple; +using tdli = tuple; +using tddl = tuple; +using tddd = tuple; +using tddi = tuple; +using tdil = tuple; +using tdid = tuple; +using tdii = tuple; +using till = tuple; +using tild = tuple; +using tili = tuple; +using tidl = tuple; +using tidd = tuple; +using tidi = tuple; +using tiil = tuple; +using tiid = tuple; +using tiii = tuple; +template using max_heap = priority_queue; +template using min_heap = priority_queue, greater<>>; +template using oi = ostream_iterator; +template using ii = istream_iterator; + +/* constants */ +constexpr int INF = 0x3f3f3f3f; +constexpr ll INFLL = 0x3f3f3f3f3f3f3f3fLL; +constexpr ll MDL = 1e9 + 7; +constexpr ll PRIME = 998'244'353; +constexpr ll MDL1 = 8784491; +constexpr ll MDL2 = PRIME; +constexpr int128 INT128_MAX = numeric_limits::max(); +constexpr uint128 UINT128_MAX = numeric_limits::max(); +constexpr int128 INT128_MIN = numeric_limits::min(); +constexpr uint128 UINT128_MIN = numeric_limits::min(); + +/* random */ + +mt19937 rd(chrono::duration_cast(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 +#define ugt std::greater + +#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 + size_t operator()(const pair& 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 dist(PRIME); +const size_t __array_hash_b = 31, __array_hash_mdl1 = dist(rd), __array_hash_mdl2 = dist(rd); +struct array_hash { + template + size_t operator()(const Sequence& arr) const { + size_t pw1 = 1, pw2 = 1; + size_t res1 = 0, res2 = 0; + for (auto&& x : arr) { + res1 = (res1 + x * pw1) % __array_hash_mdl1; + res2 = (res2 + x * 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 pa(a) __AS_PROCEDURE(__typeof(a) pa; pa.push_back({}); for (auto&&x : a) pa.push_back(pa.back() + x);) +#define sa(a) __AS_PROCEDURE(__typeof(a) sa(a.size() + 1); {int n = a.size(); for (int i = n - 1; i >= 0; --i) sa[i] = sa[i + 1] + a[i];};) +#define adj(ch, n) __AS_PROCEDURE(vector> 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, w) __AS_PROCEDURE(ch[u].emplace_back(v, w), ch[v].emplace_back(u, w);) +#define Edge(ch, u, v) __AS_PROCEDURE(ch[u].push_back(v);) +#define Edgew(ch, u, v, w) __AS_PROCEDURE(ch[u].emplace_back(v, w);) +template pair> discretize(Iterator __first, Iterator __last) { + set st(__first, __last); + size_t N = 0; + map mp; + for (auto&& x : st) mp[x] = ++N; + return {N, mp}; +} +template pair> unordered_discretize(Iterator __first, Iterator __last) { + set st(__first, __last); + size_t N = 0; + unordered_map 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)) +template void __read(T& x) { cin >> x; } +template void __read(T& x, U&... args) { cin >> x; __read(args...); } +#define read(type, ...) __AS_PROCEDURE(type __VA_ARGS__; __read(__VA_ARGS__);) +#define readvec(type, a, n) __AS_PROCEDURE(vector a(n); for (auto& x : a) cin >> x;) +#define readvec1(type, a, n) __AS_PROCEDURE(vector a((n) + 1); copy_n(ii(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;) +template istream& operator>>(istream& in, pair& p) { + return in >> p.first >> p.second; +} +template ostream& operator<<(ostream& out, const pair& p) { + out << "{" << p.first << ", " << p.second << "}"; + return out; +} +template +void print_tuple_impl(std::basic_ostream& os, const Tuple& t, std::index_sequence) { + using swallow = int[]; // guaranties left to right order + (void)swallow { 0, (void(os << (Index == 0 ? "" : ", ") << std::get(t)), 0)... }; +} +template +decltype(auto) operator<<(std::basic_ostream& os, const std::tuple& t) { + os << "{"; + print_tuple_impl(os, t, std::index_sequence_for{}); + return os << "}"; +} +template ostream& operator<<(ostream& out, const vector& 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; +} + +/* pops */ +#define poptop(q, ...) __AS_PROCEDURE(auto [__VA_ARGS__] = q.top(); q.pop();) +#define popback(q, ...) __AS_PROCEDURE(auto [__VA_ARGS__] = q.back(); q.pop_back();) +#define popfront(q, ...) __AS_PROCEDURE(auto [__VA_ARGS__] = q.front();q.pop_front();) + +/* math */ +template +return_t qpow(ll b, ll p) { + if (b == 0 and p != 0) return 0; + if (p == 0) return 1; + return_t half = qpow(b, p / 2); + if (p % 2 == 1) return half * half * b; + else return half * half; +} + +#define comb(n, k) ((n) < 0 or (k) < 0 or (n) < (k) ? 0 : fact[n] / fact[k] / fact[(n) - (k)]) + +constexpr inline int lg2(ll x) { return x == 0 ? -1 : sizeof(ll) * 8 - 1 - __builtin_clzll(x); } + +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> decompose(ll x) { + // return (factor, count, factor ** count) + vector> 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 decompose_prime(int N) { + // return (factor, count) + vector 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 calc_next(string t) { // pi function of t + int n = (int)t.length(); + vector 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 calc_z(string t) { // z function of t + int m = t.length(); + vector z; + z.push_back(m); + pair 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 kmp(string s, string t) { // find all t in s + string cur = t + '#' + s; + int sz1 = s.size(), sz2 = t.size(); + vector v; + vector 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(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 struct MLL { + ll val; + MLL(ll v = 0) : val(mod(v, mdl)) {} + MLL(const MLL& 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 * mod(inverse(rhs.val, mdl), 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; } + void operator+=(const MLL& rhs) { val = (*this + rhs).val; } + void operator-=(const MLL& rhs) { val = (*this - rhs).val; } + void operator*=(const MLL& rhs) { val = (*this * rhs).val; } + void operator/=(const MLL& rhs) { val = (*this / rhs).val; } + void operator%=(const MLL& rhs) { val = (*this % rhs).val; } +}; +struct MLLd { + ll val, mdl; + MLLd(ll mdl, ll v = 0) : mdl(mdl), val(mod(v, mdl)) {} + MLLd(const MLLd& other) : mdl(other.mdl), val(other.val) {} + friend MLLd operator+(const MLLd& lhs, const MLLd& rhs) { return MLLd(lhs.mdl, mod(lhs.val + rhs.val, lhs.mdl)); } + friend MLLd operator-(const MLLd& lhs, const MLLd& rhs) { return MLLd(lhs.mdl, mod(lhs.val - rhs.val, lhs.mdl)); } + friend MLLd operator*(const MLLd& lhs, const MLLd& rhs) { return MLLd(lhs.mdl, mod(lhs.val * rhs.val, lhs.mdl)); } + friend MLLd operator/(const MLLd& lhs, const MLLd& rhs) { return MLLd(lhs.mdl, mod(lhs.val * mod(inverse(rhs.val, lhs.mdl), lhs.mdl), lhs.mdl)); } + friend MLLd operator%(const MLLd& lhs, const MLLd& rhs) { return MLLd(lhs.mdl, mod(lhs.val - (lhs / rhs).val, lhs.mdl)); } + friend bool operator==(const MLLd& lhs, const MLLd& rhs) { return lhs.val == rhs.val; } + friend bool operator!=(const MLLd& lhs, const MLLd& rhs) { return lhs.val != rhs.val; } + void operator+=(const MLLd& rhs) { val = (*this + rhs).val; } + void operator-=(const MLLd& rhs) { val = (*this - rhs).val; } + void operator*=(const MLLd& rhs) { val = (*this * rhs).val; } + void operator/=(const MLLd& rhs) { val = (*this / rhs).val; } + void operator%=(const MLLd& rhs) { val = (*this % rhs).val; } +}; + +template +ostream& operator<<(ostream& out, const MLL& num) { + return out << num.val; +} + +ostream& operator<<(ostream& out, const MLLd& num) { + return out << num.val; +} + +template +istream& operator>>(istream& in, MLL& num) { + return in >> num.val; +} + +istream& operator>>(istream& in, MLLd& num) { + return in >> num.val; +} + +// miscancellous +#define functor(func) [&](auto&&... val) \ +noexcept(noexcept(func(std::forward(val)...))) -> decltype(auto) \ +{return func(std::forward(val)...);} +template 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 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 +vector> zip(Iterator_T a_first, Iterator_T a_last, Iterator_U b_first, Iterator_U b_last) { + vector> 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 +vector> zip_n(Iterator_T a_first, Iterator_U b_first, size_t n) { + vector> 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 +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& operator++() { ++value; return *this; } + ArithmeticIterator& operator--() { --value; return *this; } + bool operator==(const ArithmeticIterator& rhs) const { return value == rhs.value; } +}; +template vector> enumerate(const vector& container) { + return zip(ArithmeticIterator(0), ArithmeticIterator(INT_MAX), container.begin(), container.end()); +} +///////////////////////////////////////////////////////// + +// #define SINGLE_TEST_CASE +// #define DUMP_TEST_CASE 7219 +// #define TOT_TEST_CASE 10000 + +void dump() {} + +void dump_ignore() {} + +void prep() { +} + +template> struct sparse_table { + _Op op; + vector> st; + template + sparse_table(ReverseIterator __first, ReverseIterator __last, _Op&& __operation) { + op = __operation; + int n = distance(__first, __last); + st = vector>(n, vector<_Tp>(int(log2(n) + 1))); + int i = n - 1; + for (auto it = __first; it != __last; ++it) { + st[i][0] = *it; + for (int j = 1; i + (1 << j) <= n; ++j) { + st[i][j] = op(st[i][j - 1], st[i + (1 << (j - 1))][j - 1]); + } + i -= 1; + } + } + _Tp query(size_t __start, size_t __end) { + int s = lg2(__end - __start + 1); + return op(st[__start][s], st[__end - (1 << s) + 1][s]); + } +}; + + +void solve() { + read(ll, n, m); + read(int, k); + readvec(pll, a, k); + vector rev(k); + iota(rev.begin(), rev.end(), 0); + sort_by_key(rev.begin(), rev.end(), [&] (int i) -> pll { return {a[i].first, -a[i].second}; }); + sort_by_key(a.begin(), a.end(), [&] (pll x) -> pll { return {x.first, -x.second}; }); + ll res = 0; + vector ss(k + 1, {m + 1, n + 1}); + vector stale(k); + for (int i = 0; i < k - 1; ++i) { + if (a[i + 1].first == a[i].first) { + stale[i] = 1; + } + } + a.emplace_back(n + 1, m + 1); + vector> st; + st.emplace_back(0, 0, -1); + vector> c(k); + vector val(k + 1); + vector fa(k + 1); + ll curr = 0; + vector tag; + for (int i = 0; i < k; ++i) { + tag.emplace_back(a[i].second, i); + } + sparse_table rmq(tag.rbegin(), tag.rend(), functor(min)); + for (int i = 0; i <= k; ++i) { + while (st.size() and get<1>(st.back()) > a[i].second) { + st.pop_back(); + } + int prev = get<2>(st.back()); + curr = (prev == -1 ? 0 : val[prev]) + (a[i].second - 1) * (a[i].first - get<0>(st.back())); + val[i] = curr; + st.emplace_back(a[i].first, a[i].second, i); + fa[i] = prev; + int l = -1, r = prev - 1; + if (l > r) continue; + while (l < r) { + int mid = l + r + 1 >> 1; + if ((mid == -1 ? 0 : rmq.query(mid, prev - 1).first) <= a[i].second) { + l = mid; + } else { + r = mid - 1; + } + } + if ((l == -1 ? 0 : a[l].second) <= a[i].second) { + ll asdf = (l == -1 ? 0 : val[l]) + (a[i].second - 1) * (a[i].first - (l == -1 ? 0 : a[l].first)); + c[prev][i] = asdf - curr; + // debug(make_tuple(l, prev, rev[prev])); + } + } + curr -= m; + cout << curr << '\n'; + vector d(k); + int ptr = k; + while (fa[ptr] != -1) { + d[rev[fa[ptr]]] = !!c[fa[ptr]][ptr]; + ptr = fa[ptr]; + } + putvec(d); +} + +int main() { +#if __cplusplus < 201402L or defined(_MSC_VER) and not defined(__clang__) + 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 +} diff --git a/src/bin/f2.cc b/src/bin/f2.cc new file mode 100644 index 0000000..b4f3f3e --- /dev/null +++ b/src/bin/f2.cc @@ -0,0 +1,603 @@ +/** + * Author: subcrip + * Created: 2024-06-03 23:49:19 + * Modified: 2024-06-04 08:16:51 + * Elapsed: 507 minutes + */ + +#pragma GCC optimize("Ofast") +///////////////////////////////////////////////////////// +/** + * This code should require C++14. + * However, it's only been tested with C++17. + */ + +#include +using namespace std; + +/* macro helpers */ +#define __NARGS(...) std::tuple_size::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::type + +/* 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; +using ld = long double; +#endif +using int128 = __int128_t; +using uint128 = __uint128_t; +using ld = long double; +using pii = pair; +using pil = pair; +using pli = pair; +using pll = pair; +using pid = pair; +using pdi = pair; +using pld = pair; +using pdl = pair; +using pdd = pair; +using tlll = tuple; +using tlld = tuple; +using tlli = tuple; +using tldl = tuple; +using tldd = tuple; +using tldi = tuple; +using tlil = tuple; +using tlid = tuple; +using tlii = tuple; +using tdll = tuple; +using tdld = tuple; +using tdli = tuple; +using tddl = tuple; +using tddd = tuple; +using tddi = tuple; +using tdil = tuple; +using tdid = tuple; +using tdii = tuple; +using till = tuple; +using tild = tuple; +using tili = tuple; +using tidl = tuple; +using tidd = tuple; +using tidi = tuple; +using tiil = tuple; +using tiid = tuple; +using tiii = tuple; +template using max_heap = priority_queue; +template using min_heap = priority_queue, greater<>>; +template using oi = ostream_iterator; +template using ii = istream_iterator; + +/* constants */ +constexpr int INF = 0x3f3f3f3f; +constexpr ll INFLL = 0x3f3f3f3f3f3f3f3fLL; +constexpr ll MDL = 1e9 + 7; +constexpr ll PRIME = 998'244'353; +constexpr ll MDL1 = 8784491; +constexpr ll MDL2 = PRIME; +constexpr int128 INT128_MAX = numeric_limits::max(); +constexpr uint128 UINT128_MAX = numeric_limits::max(); +constexpr int128 INT128_MIN = numeric_limits::min(); +constexpr uint128 UINT128_MIN = numeric_limits::min(); + +/* random */ + +mt19937 rd(chrono::duration_cast(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 +#define ugt std::greater + +#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 + size_t operator()(const pair& 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 dist(PRIME); +const size_t __array_hash_b = 31, __array_hash_mdl1 = dist(rd), __array_hash_mdl2 = dist(rd); +struct array_hash { + template + size_t operator()(const Sequence& arr) const { + size_t pw1 = 1, pw2 = 1; + size_t res1 = 0, res2 = 0; + for (auto&& x : arr) { + res1 = (res1 + x * pw1) % __array_hash_mdl1; + res2 = (res2 + x * 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 pa(a) __AS_PROCEDURE(__typeof(a) pa; pa.push_back({}); for (auto&&x : a) pa.push_back(pa.back() + x);) +#define sa(a) __AS_PROCEDURE(__typeof(a) sa(a.size() + 1); {int n = a.size(); for (int i = n - 1; i >= 0; --i) sa[i] = sa[i + 1] + a[i];};) +#define adj(ch, n) __AS_PROCEDURE(vector> 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, w) __AS_PROCEDURE(ch[u].emplace_back(v, w), ch[v].emplace_back(u, w);) +#define Edge(ch, u, v) __AS_PROCEDURE(ch[u].push_back(v);) +#define Edgew(ch, u, v, w) __AS_PROCEDURE(ch[u].emplace_back(v, w);) +template pair> discretize(Iterator __first, Iterator __last) { + set st(__first, __last); + size_t N = 0; + map mp; + for (auto&& x : st) mp[x] = ++N; + return {N, mp}; +} +template pair> unordered_discretize(Iterator __first, Iterator __last) { + set st(__first, __last); + size_t N = 0; + unordered_map 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)) +template void __read(T& x) { cin >> x; } +template void __read(T& x, U&... args) { cin >> x; __read(args...); } +#define read(type, ...) __AS_PROCEDURE(type __VA_ARGS__; __read(__VA_ARGS__);) +#define readvec(type, a, n) __AS_PROCEDURE(vector a(n); for (auto& x : a) cin >> x;) +#define readvec1(type, a, n) __AS_PROCEDURE(vector a((n) + 1); copy_n(ii(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;) +template istream& operator>>(istream& in, pair& p) { + return in >> p.first >> p.second; +} +template ostream& operator<<(ostream& out, const pair& p) { + out << "{" << p.first << ", " << p.second << "}"; + return out; +} +template +void print_tuple_impl(std::basic_ostream& os, const Tuple& t, std::index_sequence) { + using swallow = int[]; // guaranties left to right order + (void)swallow { 0, (void(os << (Index == 0 ? "" : ", ") << std::get(t)), 0)... }; +} +template +decltype(auto) operator<<(std::basic_ostream& os, const std::tuple& t) { + os << "{"; + print_tuple_impl(os, t, std::index_sequence_for{}); + return os << "}"; +} +template ostream& operator<<(ostream& out, const vector& 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; +} + +/* pops */ +#define poptop(q, ...) __AS_PROCEDURE(auto [__VA_ARGS__] = q.top(); q.pop();) +#define popback(q, ...) __AS_PROCEDURE(auto [__VA_ARGS__] = q.back(); q.pop_back();) +#define popfront(q, ...) __AS_PROCEDURE(auto [__VA_ARGS__] = q.front();q.pop_front();) + +/* math */ +template +return_t qpow(ll b, ll p) { + if (b == 0 and p != 0) return 0; + if (p == 0) return 1; + return_t half = qpow(b, p / 2); + if (p % 2 == 1) return half * half * b; + else return half * half; +} + +#define comb(n, k) ((n) < 0 or (k) < 0 or (n) < (k) ? 0 : fact[n] / fact[k] / fact[(n) - (k)]) + +constexpr inline int lg2(ll x) { return x == 0 ? -1 : sizeof(ll) * 8 - 1 - __builtin_clzll(x); } + +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> decompose(ll x) { + // return (factor, count, factor ** count) + vector> 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 decompose_prime(int N) { + // return (factor, count) + vector 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 calc_next(string t) { // pi function of t + int n = (int)t.length(); + vector 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 calc_z(string t) { // z function of t + int m = t.length(); + vector z; + z.push_back(m); + pair 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 kmp(string s, string t) { // find all t in s + string cur = t + '#' + s; + int sz1 = s.size(), sz2 = t.size(); + vector v; + vector 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(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 struct MLL { + ll val; + MLL(ll v = 0) : val(mod(v, mdl)) {} + MLL(const MLL& 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 * mod(inverse(rhs.val, mdl), 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; } + void operator+=(const MLL& rhs) { val = (*this + rhs).val; } + void operator-=(const MLL& rhs) { val = (*this - rhs).val; } + void operator*=(const MLL& rhs) { val = (*this * rhs).val; } + void operator/=(const MLL& rhs) { val = (*this / rhs).val; } + void operator%=(const MLL& rhs) { val = (*this % rhs).val; } +}; +struct MLLd { + ll val, mdl; + MLLd(ll mdl, ll v = 0) : mdl(mdl), val(mod(v, mdl)) {} + MLLd(const MLLd& other) : mdl(other.mdl), val(other.val) {} + friend MLLd operator+(const MLLd& lhs, const MLLd& rhs) { return MLLd(lhs.mdl, mod(lhs.val + rhs.val, lhs.mdl)); } + friend MLLd operator-(const MLLd& lhs, const MLLd& rhs) { return MLLd(lhs.mdl, mod(lhs.val - rhs.val, lhs.mdl)); } + friend MLLd operator*(const MLLd& lhs, const MLLd& rhs) { return MLLd(lhs.mdl, mod(lhs.val * rhs.val, lhs.mdl)); } + friend MLLd operator/(const MLLd& lhs, const MLLd& rhs) { return MLLd(lhs.mdl, mod(lhs.val * mod(inverse(rhs.val, lhs.mdl), lhs.mdl), lhs.mdl)); } + friend MLLd operator%(const MLLd& lhs, const MLLd& rhs) { return MLLd(lhs.mdl, mod(lhs.val - (lhs / rhs).val, lhs.mdl)); } + friend bool operator==(const MLLd& lhs, const MLLd& rhs) { return lhs.val == rhs.val; } + friend bool operator!=(const MLLd& lhs, const MLLd& rhs) { return lhs.val != rhs.val; } + void operator+=(const MLLd& rhs) { val = (*this + rhs).val; } + void operator-=(const MLLd& rhs) { val = (*this - rhs).val; } + void operator*=(const MLLd& rhs) { val = (*this * rhs).val; } + void operator/=(const MLLd& rhs) { val = (*this / rhs).val; } + void operator%=(const MLLd& rhs) { val = (*this % rhs).val; } +}; + +template +ostream& operator<<(ostream& out, const MLL& num) { + return out << num.val; +} + +ostream& operator<<(ostream& out, const MLLd& num) { + return out << num.val; +} + +template +istream& operator>>(istream& in, MLL& num) { + return in >> num.val; +} + +istream& operator>>(istream& in, MLLd& num) { + return in >> num.val; +} + +// miscancellous +#define functor(func) [&](auto&&... val) \ +noexcept(noexcept(func(std::forward(val)...))) -> decltype(auto) \ +{return func(std::forward(val)...);} +template 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 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 +vector> zip(Iterator_T a_first, Iterator_T a_last, Iterator_U b_first, Iterator_U b_last) { + vector> 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 +vector> zip_n(Iterator_T a_first, Iterator_U b_first, size_t n) { + vector> 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 +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& operator++() { ++value; return *this; } + ArithmeticIterator& operator--() { --value; return *this; } + bool operator==(const ArithmeticIterator& rhs) const { return value == rhs.value; } +}; +template vector> enumerate(const vector& container) { + return zip(ArithmeticIterator(0), ArithmeticIterator(INT_MAX), container.begin(), container.end()); +} +///////////////////////////////////////////////////////// + +// #define SINGLE_TEST_CASE +// #define DUMP_TEST_CASE 7219 +// #define TOT_TEST_CASE 10000 + +void dump() {} + +void dump_ignore() {} + +void prep() { +} + +template> struct sparse_table { + _Op op; + vector> st; + template + sparse_table(ReverseIterator __first, ReverseIterator __last, _Op&& __operation) { + op = __operation; + int n = distance(__first, __last); + st = vector>(n, vector<_Tp>(int(log2(n) + 1))); + int i = n - 1; + for (auto it = __first; it != __last; ++it) { + st[i][0] = *it; + for (int j = 1; i + (1 << j) <= n; ++j) { + st[i][j] = op(st[i][j - 1], st[i + (1 << (j - 1))][j - 1]); + } + i -= 1; + } + } + _Tp query(size_t __start, size_t __end) { + int s = lg2(__end - __start + 1); + return op(st[__start][s], st[__end - (1 << s) + 1][s]); + } +}; + +void solve() { + read(ll, n, m); + read(int, k); + readvec(pll, a, k); + vector rev(k); + iota(rev.begin(), rev.end(), 0); + sort_by_key(rev.begin(), rev.end(), [&] (int i) -> pll { return {a[i].first, -a[i].second}; }); + sort_by_key(a.begin(), a.end(), [&] (pll x) -> pll { return {x.first, -x.second}; }); + ll res = 0; + a.emplace_back(n + 1, m + 1); + vector> st; + st.emplace_back(0, 0, -1); + vector> c(k); + vector val(k + 1); + vector fa(k + 1); + ll curr = 0; + vector tag; + for (int i = 0; i < k; ++i) { + tag.emplace_back(a[i].second, i); + } + sparse_table rmq(tag.rbegin(), tag.rend(), functor(min)); + for (int i = 0; i <= k; ++i) { + while (st.size() and get<1>(st.back()) > a[i].second) { + st.pop_back(); + } + int prev = get<2>(st.back()); + curr = (prev == -1 ? 0 : val[prev]) + (a[i].second - 1) * (a[i].first - get<0>(st.back())); + val[i] = curr; + st.emplace_back(a[i].first, a[i].second, i); + fa[i] = prev; + int l = -1, r = prev - 1; + if (l > r) continue; + while (l < r) { + int mid = l + r + 1 >> 1; + if ((mid == -1 ? 0 : rmq.query(mid, prev - 1).first) <= a[i].second) { + l = mid; + } else { + r = mid - 1; + } + } + if ((l == -1 ? 0 : a[l].second) <= a[i].second) { + ll asdf = (l == -1 ? 0 : val[l]) + (a[i].second - 1) * (a[i].first - (l == -1 ? 0 : a[l].first)); + c[prev][i] = asdf - curr; + // debug(make_tuple(l, prev, rev[prev])); + } + } + curr -= m; + cout << curr << '\n'; + vector d(k); + int ptr = k; + while (fa[ptr] != -1) { + d[rev[fa[ptr]]] = c[fa[ptr]][ptr]; + ptr = fa[ptr]; + } + putvec(d); +} + +int main() { +#if __cplusplus < 201402L or defined(_MSC_VER) and not defined(__clang__) + 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 +} diff --git a/src/bin/std.in b/src/bin/std.in index b640086..12ec86f 100644 --- a/src/bin/std.in +++ b/src/bin/std.in @@ -1,13 +1,29 @@ -4 -1 -a -a -3 -rll -rrr -3 -caa -aca 5 -ababa -aabba +3 2 +BW +WW +WB +3 3 +WWB +WBW +BWW +2 3 +BBB +BBB +5 5 +BWBWB +WBWBW +BWBWB +WBWBW +BWBWB +9 9 +WWWWWWWWW +WWWWWWWWW +BWWWWWWWW +WWWWWWWWW +WWWWBWWWW +WWWWWWWWW +WWWWWWWWW +WWWWWWWWW +WWWWWWWWB + diff --git a/src/bin/test.cc b/src/bin/test.cc index de679bc..a3359cf 100644 --- a/src/bin/test.cc +++ b/src/bin/test.cc @@ -1,704 +1,20 @@ /** * Author: subcrip - * Created: 2024-06-01 13:45:49 - * Modified: 2024-06-02 12:33:56 - * Elapsed: 1368 minutes + * Created: 2024-06-03 15:16:33 + * Modified: 2024-06-05 00:29:02 + * Elapsed: 1992 minutes */ -#pragma GCC optimize("Ofast") -///////////////////////////////////////////////////////// -/** - * This code should require C++14. - * However, it's only been tested with C++17. - */ - -#include +#include +#include using namespace std; -/* macro helpers */ -#define __NARGS(...) std::tuple_size::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::type - -/* 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; -using ld = long double; -#endif -using int128 = __int128_t; -using uint128 = __uint128_t; -using ld = long double; -using pii = pair; -using pil = pair; -using pli = pair; -using pll = pair; -using pid = pair; -using pdi = pair; -using pld = pair; -using pdl = pair; -using pdd = pair; -using tlll = tuple; -using tlld = tuple; -using tlli = tuple; -using tldl = tuple; -using tldd = tuple; -using tldi = tuple; -using tlil = tuple; -using tlid = tuple; -using tlii = tuple; -using tdll = tuple; -using tdld = tuple; -using tdli = tuple; -using tddl = tuple; -using tddd = tuple; -using tddi = tuple; -using tdil = tuple; -using tdid = tuple; -using tdii = tuple; -using till = tuple; -using tild = tuple; -using tili = tuple; -using tidl = tuple; -using tidd = tuple; -using tidi = tuple; -using tiil = tuple; -using tiid = tuple; -using tiii = tuple; -template using max_heap = priority_queue; -template using min_heap = priority_queue, greater<>>; -template using oi = ostream_iterator; -template using ii = istream_iterator; - -/* constants */ -constexpr int INF = 0x3f3f3f3f; -constexpr ll INFLL = 0x3f3f3f3f3f3f3f3fLL; -constexpr ll MDL = 1e9 + 7; -constexpr ll PRIME = 998'244'353; -constexpr ll MDL1 = 8784491; -constexpr ll MDL2 = PRIME; -constexpr int128 INT128_MAX = numeric_limits::max(); -constexpr uint128 UINT128_MAX = numeric_limits::max(); -constexpr int128 INT128_MIN = numeric_limits::min(); -constexpr uint128 UINT128_MIN = numeric_limits::min(); - -/* random */ - -mt19937 rd(chrono::duration_cast(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 -#define ugt std::greater - -#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); - } +struct test { + int val; }; -/* 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 - size_t operator()(const pair& 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 dist(PRIME); -const size_t __array_hash_b = 31, __array_hash_mdl1 = dist(rd), __array_hash_mdl2 = dist(rd); -struct array_hash { - template - size_t operator()(const Sequence& arr) const { - size_t pw1 = 1, pw2 = 1; - size_t res1 = 0, res2 = 0; - for (auto&& x : arr) { - res1 = (res1 + x * pw1) % __array_hash_mdl1; - res2 = (res2 + x * 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 pa(a) __AS_PROCEDURE(__typeof(a) pa; pa.push_back({}); for (auto&&x : a) pa.push_back(pa.back() + x);) -#define sa(a) __AS_PROCEDURE(__typeof(a) sa(a.size() + 1); {int n = a.size(); for (int i = n - 1; i >= 0; --i) sa[i] = sa[i + 1] + a[i];};) -#define adj(ch, n) __AS_PROCEDURE(vector> 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, w) __AS_PROCEDURE(ch[u].emplace_back(v, w), ch[v].emplace_back(u, w);) -#define Edge(ch, u, v) __AS_PROCEDURE(ch[u].push_back(v);) -#define Edgew(ch, u, v, w) __AS_PROCEDURE(ch[u].emplace_back(v, w);) -template pair> discretize(Iterator __first, Iterator __last) { - set st(__first, __last); - size_t N = 0; - map mp; - for (auto&& x : st) mp[x] = ++N; - return {N, mp}; -} -template pair> unordered_discretize(Iterator __first, Iterator __last) { - set st(__first, __last); - size_t N = 0; - unordered_map 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)) -template void __read(T& x) { cin >> x; } -template void __read(T& x, U&... args) { cin >> x; __read(args...); } -#define read(type, ...) __AS_PROCEDURE(type __VA_ARGS__; __read(__VA_ARGS__);) -#define readvec(type, a, n) __AS_PROCEDURE(vector a(n); for (auto& x : a) cin >> x;) -#define readvec1(type, a, n) __AS_PROCEDURE(vector a((n) + 1); copy_n(ii(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;) -template istream& operator>>(istream& in, pair& p) { - return in >> p.first >> p.second; -} -template ostream& operator<<(ostream& out, const pair& p) { - out << "{" << p.first << ", " << p.second << "}"; - return out; -} -template -void print_tuple_impl(std::basic_ostream& os, const Tuple& t, std::index_sequence) { - using swallow = int[]; // guaranties left to right order - (void)swallow { 0, (void(os << (Index == 0 ? "" : ", ") << std::get(t)), 0)... }; -} -template -decltype(auto) operator<<(std::basic_ostream& os, const std::tuple& t) { - os << "{"; - print_tuple_impl(os, t, std::index_sequence_for{}); - return os << "}"; -} -template ostream& operator<<(ostream& out, const vector& 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; -} - -/* pops */ -#define poptop(q, ...) __AS_PROCEDURE(auto [__VA_ARGS__] = q.top(); q.pop();) -#define popback(q, ...) __AS_PROCEDURE(auto [__VA_ARGS__] = q.back(); q.pop_back();) -#define popfront(q, ...) __AS_PROCEDURE(auto [__VA_ARGS__] = q.front();q.pop_front();) - -/* math */ -template -return_t qpow(ll b, ll p) { - if (b == 0 and p != 0) return 0; - if (p == 0) return 1; - return_t half = qpow(b, p / 2); - if (p % 2 == 1) return half * half * b; - else return half * half; -} - -#define comb(n, k) ((n) < 0 or (k) < 0 or (n) < (k) ? 0 : fact[n] / fact[k] / fact[(n) - (k)]) - -constexpr inline int lg2(ll x) { return x == 0 ? -1 : sizeof(ll) * 8 - 1 - __builtin_clzll(x); } - -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> decompose(ll x) { - // return (factor, count, factor ** count) - vector> 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 decompose_prime(int N) { - // return (factor, count) - vector 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 calc_next(string t) { // pi function of t - int n = (int)t.length(); - vector 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 calc_z(string t) { // z function of t - int m = t.length(); - vector z; - z.push_back(m); - pair 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 kmp(string s, string t) { // find all t in s - string cur = t + '#' + s; - int sz1 = s.size(), sz2 = t.size(); - vector v; - vector 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(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 struct MLL { - ll val; - MLL(ll v = 0) : val(mod(v, mdl)) {} - MLL(const MLL& 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 * mod(inverse(rhs.val, mdl), 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; } - void operator+=(const MLL& rhs) { val = (*this + rhs).val; } - void operator-=(const MLL& rhs) { val = (*this - rhs).val; } - void operator*=(const MLL& rhs) { val = (*this * rhs).val; } - void operator/=(const MLL& rhs) { val = (*this / rhs).val; } - void operator%=(const MLL& rhs) { val = (*this % rhs).val; } -}; -struct MLLd { - ll val, mdl; - MLLd(ll mdl, ll v = 0) : mdl(mdl), val(mod(v, mdl)) {} - MLLd(const MLLd& other) : mdl(other.mdl), val(other.val) {} - friend MLLd operator+(const MLLd& lhs, const MLLd& rhs) { return MLLd(lhs.mdl, mod(lhs.val + rhs.val, lhs.mdl)); } - friend MLLd operator-(const MLLd& lhs, const MLLd& rhs) { return MLLd(lhs.mdl, mod(lhs.val - rhs.val, lhs.mdl)); } - friend MLLd operator*(const MLLd& lhs, const MLLd& rhs) { return MLLd(lhs.mdl, mod(lhs.val * rhs.val, lhs.mdl)); } - friend MLLd operator/(const MLLd& lhs, const MLLd& rhs) { return MLLd(lhs.mdl, mod(lhs.val * mod(inverse(rhs.val, lhs.mdl), lhs.mdl), lhs.mdl)); } - friend MLLd operator%(const MLLd& lhs, const MLLd& rhs) { return MLLd(lhs.mdl, mod(lhs.val - (lhs / rhs).val, lhs.mdl)); } - friend bool operator==(const MLLd& lhs, const MLLd& rhs) { return lhs.val == rhs.val; } - friend bool operator!=(const MLLd& lhs, const MLLd& rhs) { return lhs.val != rhs.val; } - void operator+=(const MLLd& rhs) { val = (*this + rhs).val; } - void operator-=(const MLLd& rhs) { val = (*this - rhs).val; } - void operator*=(const MLLd& rhs) { val = (*this * rhs).val; } - void operator/=(const MLLd& rhs) { val = (*this / rhs).val; } - void operator%=(const MLLd& rhs) { val = (*this % rhs).val; } -}; - -template -ostream& operator<<(ostream& out, const MLL& num) { - return out << num.val; -} - -ostream& operator<<(ostream& out, const MLLd& num) { - return out << num.val; -} - -template -istream& operator>>(istream& in, MLL& num) { - return in >> num.val; -} - -istream& operator>>(istream& in, MLLd& num) { - return in >> num.val; -} - -// miscancellous -#define functor(func) [&](auto&&... val) \ -noexcept(noexcept(func(std::forward(val)...))) -> decltype(auto) \ -{return func(std::forward(val)...);} -template 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 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 -vector> zip(Iterator_T a_first, Iterator_T a_last, Iterator_U b_first, Iterator_U b_last) { - vector> 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 -vector> zip_n(Iterator_T a_first, Iterator_U b_first, size_t n) { - vector> 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 -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& operator++() { ++value; return *this; } - ArithmeticIterator& operator--() { --value; return *this; } - bool operator==(const ArithmeticIterator& rhs) const { return value == rhs.value; } -}; -template vector> enumerate(const vector& container) { - return zip(ArithmeticIterator(0), ArithmeticIterator(INT_MAX), container.begin(), container.end()); -} -///////////////////////////////////////////////////////// - -#define SINGLE_TEST_CASE -// #define DUMP_TEST_CASE 7219 -// #define TOT_TEST_CASE 10000 - -void dump() {} - -void dump_ignore() {} - -void prep() { -} - -constexpr int MAXN = 5010; -int low[MAXN], dfn[MAXN], dfs_clock; -bool isbridge[MAXN]; -vector ch[MAXN]; -int cnt_bridge; -int father[MAXN]; - -void tarjan(int u, int fa) { - father[u] = fa; - low[u] = dfn[u] = ++dfs_clock; - for (int i = 0; i < ch[u].size(); i++) { - int v = ch[u][i]; - if (!dfn[v]) { - tarjan(v, u); - low[u] = min(low[u], low[v]); - if (low[v] > dfn[u]) { - isbridge[v] = true; - ++cnt_bridge; - } - } else if (dfn[v] < dfn[u] && v != fa) { - low[u] = min(low[u], dfn[v]); - } - } -} - -struct LCA { - vector depth; - vector> pa; - LCA(const vector>& g, int root = 1) { - int n = g.size() - 1; - int m = 32 - __builtin_clz(n); - depth.resize(n + 1); - pa.resize(n + 1, vector(m, -1)); - function dfs = [&](int x, int fa) { - pa[x][0] = fa; - for (auto&& [y, _, ___] : g[x]) { - if (y != fa) { - depth[y] = depth[x] + 1; - dfs(y, x); - } - } - }; - dfs(root, 0); - - for (int i = 0; i < m - 1; i++) - for (int x = 1; x <= n; x++) - if (int p = pa[x][i]; p != -1) - pa[x][i + 1] = pa[p][i]; - } - - int get_kth_ancestor(int node, int k) { - for (; k; k &= k - 1) - node = pa[node][__builtin_ctz(k)]; - return node; - } - - int query(int x, int y) { - if (depth[x] > depth[y]) - swap(x, y); - y = get_kth_ancestor(y, depth[y] - depth[x]); - if (y == x) - return x; - for (int i = pa[x].size() - 1; i >= 0; i--) { - int px = pa[x][i], py = pa[y][i]; - if (px != py) { - x = px; - y = py; - } - } - return pa[x][0]; - } -}; - - -void solve() { - read(int, n, m); - vector edges; - unordered_set oc; - while (m--){ - read(int, x, y); - if (x == y or oc.count(minmax(x, y))) continue; - oc.insert(minmax(x, y)); - edges.emplace_back(x, y); - edge(ch, x, y); - } - tarjan(1, 0); - // for (int i = 1; i <= n; ++i) { - // debug(isbridge[i]); - // } - adj(sp, n); - for (auto&& [u, v] : edges) { - if (isbridge[u] and minmax(u, v) == minmax(father[u], u)) continue; - if (isbridge[v] and minmax(u, v) == minmax(father[v], v)) continue; - // debug(make_tuple(u, v)); - edge(sp, u, v); - } - // debugvec(sp); - vector vis(n + 1); - int N = 0; - vector col(n + 1); - vector sz(1); - vector no(n + 1); - auto dfs = [&] (auto dfs, int v) -> void { - if (vis[v]) return; - vis[v] = 1; - col[v] = N; - no[v] = sz[N]; - sz[N] += 1; - for (auto&& u : sp[v]) { - if (vis[u]) continue; - dfs(dfs, u); - break; - } - }; - for (int i = 1; i <= n; ++i) { - if (vis[i]) continue; - ++N; - sz.emplace_back(0); - dfs(dfs, i); - } - // debug(col); - vector> nch(N + 1); - for (auto&& [u, v] : edges) { - if (col[u] == col[v]) continue; - nch[col[u]].emplace_back(col[v], u, v); - nch[col[v]].emplace_back(col[u], v, u); - } - vector> branch(N + 1, vector(N + 1)); - vector branch_up(N + 1); - auto dfs2 = [&] (auto dfs2, int v, int pa) -> vector { - vector chs = {v}; - for (auto&& [u, from, to] : nch[v]) { - if (u == pa) continue; - branch_up[u] = to; - // debug(make_tuple(u, to)); - vector curr = dfs2(dfs2, u, v); - chs.insert(chs.end(), curr.begin(), curr.end()); - for (auto&& x : curr) { - branch[v][x] = from; - } - } - return chs; - }; - dfs2(dfs2, 1, 0); - LCA lca(nch); - auto query_dist = [&] (int v, int u) -> int { - // debug(make_tuple(u, v)); - assert(col[v] == col[u]); - if (no[v] > no[u]) swap(u, v); - // debug(min(no[u] - no[v], no[v] - no[u] + sz[col[v]])); - return min(no[u] - no[v], no[v] - no[u] + sz[col[v]]); - }; - auto query = [&] (int v, int u) -> int { - if (col[v] == col[u]) { - return query_dist(u, v); - } - int p = lca.query(col[u], col[v]); - // debug(make_tuple(v, u)); - if (p == col[u]) { - // debug(1); - // return lca.depth[col[v]] - lca.depth[col[u]] + query_dist(u, branch[col[u]][col[v]]) + query_dist(v, branch_up[col[v]]); - return lca.depth[col[v]] - lca.depth[col[u]] + query_dist(v, branch_up[col[v]]); - } else if (p == col[v]) { - // return lca.depth[col[u]] - lca.depth[col[v]] + query_dist(v, branch[col[v]][col[u]]) + query_dist(u, branch_up[col[u]]); - return lca.depth[col[u]] - lca.depth[col[v]] + query_dist(v, branch[col[v]][col[u]]); - }else { - // debug(make_tuple(p, col[v], col[u])); - // debug(lca.depth[col[u]] - lca.depth[p]); - return lca.depth[col[v]] - lca.depth[p] + lca.depth[col[u]] - lca.depth[p] - + query_dist(v, branch_up[col[v]]);// + query_dist(u, branch_up[col[u]]); - } - }; - read(int, t); - int prev = 1; - while (t--) { - read(int, v); - cout << query(prev, v) << " \n"[t == 0]; - prev = v; - } -} +#define empty (test{}) int main() { -#if __cplusplus < 201402L or defined(_MSC_VER) and not defined(__clang__) - assert(false && "incompatible compiler variant detected."); -#endif - untie, cout.tie(NULL); - 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 + empty.val; } diff --git a/src/bin/test.py b/src/bin/test.py index 4fdc6ef..f282f80 100644 --- a/src/bin/test.py +++ b/src/bin/test.py @@ -4,8 +4,8 @@ from os import system import io if __name__ == '__main__': - n = 5000 - m = 10000 - t = 200000 - print(n, m) - for _ in range(m): + n = 100000 + print(2) + print(n) + for _ in range(n): + print(0)