diff --git a/src/bin/.exrc b/src/bin/.exrc index 8c9ae93..4b7a302 100644 --- a/src/bin/.exrc +++ b/src/bin/.exrc @@ -1,2 +1,7 @@ nnoremap l 40vs std.in -nnoremap b term bash ./build.sh % + +if has('nvim') + nnoremap b wasplitterm bash ./build.sh %i +else + nnoremap b wasplitterm ++curwin bash ./build.sh % +endif diff --git a/src/bin/.nvim.lua b/src/bin/.nvim.lua deleted file mode 100644 index 5106d98..0000000 --- a/src/bin/.nvim.lua +++ /dev/null @@ -1,84 +0,0 @@ -vim.api.nvim_create_autocmd("FileType", { - pattern = "cpp", - callback = function() - vim.api.nvim_buf_set_keymap(0, 'n', "b", 'wa10spte ulimit -s unlimited && diff % .lastsrc >/dev/null 2>&1 && (echo -e "\\e[0;32mUsing cached binary for file % ...\\e[0m\\n" && time ./a.out < std.in) || (g++ -std=c++17 -DONLINE_JUDGE -Wl,-z,stack-size=268435456 -Wall -Wno-parentheses -Ofast -g -fsanitize=address,undefined -xc++ % && time ./a.out < std.in && cp % .lastsrc)i', { - silent = true, - noremap = true - }) - end, -}) - -vim.api.nvim_create_autocmd("FileType", { - pattern = "python", - callback = function() - vim.api.nvim_buf_set_keymap(0, 'n', "b", "wa10spte python3 %i", { - silent = true, - noremap = true - }) - end, -}) - --- vim.keymap.set('n', 'y', '!ctext -i $(gcc -xc++ /dev/null -E -Wp,-v 2>&1 | sed -n "s,^ ,,p" | tr "\\n" ",") < % > ctext_out.ccsplit ctext_out.cc:%%y+q') -vim.keymap.set('n', '1', 'CphReceive'); -vim.keymap.set('n', '2', 'CphTest'); -vim.keymap.set('n', '3', 'r ~/RustIsBestLang/src/bin/template.ccG'); -vim.keymap.set('n', 'l', '40vs std.in') - -local function add_timestamp() - local bufnr = vim.api.nvim_get_current_buf() - if vim.fs.basename(vim.api.nvim_buf_get_name(bufnr)) == "template.cc" then - return - end - local lines = vim.api.nvim_buf_get_lines(bufnr, 0, -1, false) - - local current_time = os.time() - local current_time_str = os.date("%Y-%m-%d %H:%M:%S", current_time) - - local create_time_str = "" - local elapsed_minutes = 0 - if #lines > 0 and lines[1]:match("/**") then - create_time_str = lines[3]:match(" * Created: (.*)") - local create_time = os.time({ - year = tonumber(create_time_str:sub(1, 4)), - month = tonumber(create_time_str:sub(6, 7)), - day = tonumber(create_time_str:sub(9, 10)), - hour = tonumber(create_time_str:sub(12, 13)), - min = tonumber(create_time_str:sub(15, 16)), - sec = tonumber(create_time_str:sub(18, 19)), - }) - elapsed_minutes = math.floor((current_time - create_time) / 60) - else - create_time_str = current_time_str - end - - local comment_string = { - "/**", - " * Author: subcrip", - " * Created: " .. create_time_str, - " * Modified: " .. current_time_str, - " * Elapsed: " .. elapsed_minutes .. " minutes", - " */", - "", - } - - if #lines > 0 and lines[1]:match("/**") then - for i = 1, #comment_string do - lines[i] = comment_string[i] - end - else - for i = #comment_string, 1, -1 do - table.insert(lines, 1, comment_string[i]) - end - end - - vim.cmd("undojoin") - vim.api.nvim_buf_set_lines(bufnr, 0, -1, false, lines) -end - --- vim.api.nvim_create_autocmd( --- "BufWritePre", --- { --- pattern = "*.cc", --- callback = add_timestamp, --- } --- ) diff --git a/src/bin/cf-2051g.cc b/src/bin/cf-2051g.cc new file mode 100644 index 0000000..6fc9c85 --- /dev/null +++ b/src/bin/cf-2051g.cc @@ -0,0 +1,612 @@ +// #pragma GCC target("popcnt,lzcnt,abm,bmi,bmi2") +// #pragma GCC optimize("Ofast,unroll-loops") +/************* This code requires 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 +template struct argument_type; +template struct argument_type { using type = U; }; + +/* type aliases */ +#if LONG_LONG_MAX != INT64_MAX +using ll = int64_t; +using ull = uint64_t; +#else +using ll = long long; +using ull = unsigned long long; +#endif +using int128 = __int128_t; +using uint128 = __uint128_t; +using ld = __float128; // up to 1e-9 precision in binary search +using pii = pair; using pil = pair; using pid = pair; +using pli = pair; using pll = pair; using pld = pair; +using pdi = pair; using pdl = pair; using pdd = pair; +using tiii = tuple; using tiil = tuple; using tiid = tuple; +using tili = tuple; using till = tuple; using tild = tuple; +using tidi = tuple; using tidl = tuple; using tidd = tuple; +using tlii = tuple; using tlil = tuple; using tlid = tuple; +using tlli = tuple; using tlll = tuple; using tlld = tuple; +using tldi = tuple; using tldl = tuple; using tldd = tuple; +using tdii = tuple; using tdil = tuple; using tdid = tuple; +using tdli = tuple; using tdll = tuple; using tdld = tuple; +using tddi = tuple; using tddl = tuple; using tddd = 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 PRIMELL = 901017227882342239LL; +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_64 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 { + safe_hash hasher; + template + size_t operator()(const Sequence& arr) const { + size_t pw1 = 1, pw2 = 1; + size_t res1 = 0, res2 = 0; + for (auto&& x : arr) { + auto h = hasher(x); + res1 = (res1 + h * pw1) % __array_hash_mdl1; + res2 = (res2 + h * pw2) % __array_hash_mdl2; + pw1 = (pw1 * __array_hash_b) % __array_hash_mdl1; + pw2 = (pw2 * __array_hash_b) % __array_hash_mdl2; + } + return res1 + res2; + } +}; + +/* build data structures */ +#define faster(um) __AS_PROCEDURE((um).reserve(1024); (um).max_load_factor(0.25);) +#define unordered_counter(from, to) __AS_PROCEDURE(unordered_map<__as_typeof(from), size_t, safe_hash> to; for (auto&& x : from) ++to[x];) +#define counter(from, to, cmp) __AS_PROCEDURE(map<__as_typeof(from), size_t, cmp> to; for (auto&& x : from) ++to[x];) +#define adj(ch, n) __AS_PROCEDURE(vector> ch((n) + 1);) +#define edge(ch, u, v) __AS_PROCEDURE(ch[u].push_back(v), ch[v].push_back(u);) +#define edgew(ch, u, v, ...) __AS_PROCEDURE(ch[u].emplace_back(v, __VA_ARGS__), ch[v].emplace_back(u, __VA_ARGS__);) +#define Edge(ch, u, v) __AS_PROCEDURE(ch[u].push_back(v);) +#define Edgew(ch, u, v, ...) __AS_PROCEDURE(ch[u].emplace_back(v, __VA_ARGS__);) +template 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)) + +// add declarations to avoid circular dependency +template istream& operator>>(istream&, pair&); +template ostream& operator<<(ostream&, const pair&); +template istream& operator>>(istream&, array&); +template ostream& operator<<(ostream&, const array&); +template +decltype(auto) operator<<(std::basic_ostream&, const std::tuple&); +template ostream& operator<<(ostream&, const vector&); +std::ostream& operator<<(std::ostream&, const int128&); + +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 istream& operator>>(istream& in, array& a) { + for (size_t i = 0; i < N; ++i) in >> a[i]; + return in; +} +template ostream& operator<<(ostream& out, const array& a) { + for (auto&& i : a) out << i << ' '; + 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; +} +template void __read(T& x) { cin >> x; } +template void __read(T& x, U&... args) { cin >> x; __read(args...); } +#define read(t, ...) __AS_PROCEDURE(argument_type::type __VA_ARGS__; __read(__VA_ARGS__);) +#define readvec(t, a, n) __AS_PROCEDURE(vector::type> a(n); for (auto& x : (a)) cin >> x;) +#define readvec1(t, a, n) __AS_PROCEDURE(vector::type> a((n) + 1); copy_n(ii::type>(cin), (n), (a).begin() + 1);) +#define putvec(a) __AS_PROCEDURE(copy((a).begin(), (a).end(), oi<__as_typeof(a)::value_type>(cout, " ")); cout << endl;) +#define putvec1(a) __AS_PROCEDURE(copy((a).begin() + 1, (a).end(), oi<__as_typeof(a)::value_type>(cout, " ")); cout << endl;) +#define putvec_eol(a) __AS_PROCEDURE(copy((a).begin(), (a).end(), oi<__as_typeof(a)::value_type>(cout, "\n"));) +#define putvec1_eol(a) __AS_PROCEDURE(copy((a).begin() + 1, (a).end(), oi<__as_typeof(a)::value_type>(cout, "\n"));) +#define debug(x) __AS_PROCEDURE(cerr << #x" = " << (x) << endl;) +#define debugvec(a) __AS_PROCEDURE(cerr << #a" = "; for (auto&& x : (a)) cerr << x << ' '; cerr << endl;) +#define deb(...) debug(make_tuple(__VA_ARGS__)) + +/* pops */ +template +inline auto poptop(Container& q) { + auto ret = q.top(); + q.pop(); + return ret; +} +template +inline auto popback(Container& q) { + auto ret = q.back(); + q.pop_back(); + return ret; +} +template +inline auto popfront(Container& q) { + auto ret = q.front(); + q.pop_front(); + return ret; +} + +/* 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; +} + +// dynamic modulus +ll qpow(ll b, ll p, ll mod) { + if (b == 0 and p != 0) return 0; + if (p == 0) return 1; + ll half = qpow(b, p / 2, mod); + if (p % 2 == 1) return (int128(half) * half % mod) * b % mod; + else return half * half % mod; +} + + +#pragma GCC diagnostic push +#pragma GCC diagnostic ignored "-Wparentheses" +// Accurately find `i` 'th root of `n` (taking the floor) +inline ll root(ll n, ll i) { + ll l = 0, r = pow(LLONG_MAX, (long double)(1) / i); + while (l < r) { + ll mid = l + r + 1 >> 1; + if (qpow(mid, i) <= n) { + l = mid; + } else { + r = mid - 1; + } + } + return l; +} +#pragma GCC diagnostic pop + + +#define comb(n, k) ((n) < 0 or (k) < 0 or (n) < (k) ? 0 : fact[n] / fact[k] / fact[(n) - (k)]) +#define fastcomb(n, k) ((n) < 0 or (k) < 0 or (n) < (k) ? 0 : fact[n] * factrev[k] * factrev[(n) - (k)]) + +__attribute__((target("lzcnt"))) +constexpr inline int lg2(ll x) { return x == 0 ? -1 : sizeof(ll) * 8 - 1 - __builtin_clzll(x); } + +template +T mygcd(T a, T b) { return b == 0 ? a : mygcd(b, a % b); } + +void __exgcd(ll a, ll b, ll& x, ll& y) { + if (b == 0) { + x = 1, y = 0; + return; + } + __exgcd(b, a % b, y, x); + y -= a / b * x; +} + +ll inverse(ll a, ll b) { + ll x, y; + __exgcd(a, b, x, y); + return mod(x, b); +} + +vector> 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(const string& s, const 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(const string& s) { // find the length of shortest recurring period + int n = s.length(); + auto z = calc_z(s); + for (int i = 1; i <= n / 2; ++i) { + if (n % i == 0 && z[i] == n - i) { + return i; + } + } + return n; +} + +/* modular arithmetic */ +template 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(int128(lhs.val) * rhs.val, mdl); } + friend MLL operator/(const MLL& lhs, const MLL& rhs) { return lhs * mod(inverse(rhs.val, mdl), mdl); } + friend MLL operator%(const MLL& lhs, const MLL& rhs) { return mod(lhs.val - (lhs / rhs).val, mdl); } + friend bool operator==(const MLL& lhs, const MLL& rhs) { return lhs.val == rhs.val; } + friend bool operator!=(const MLL& lhs, const MLL& rhs) { return lhs.val != rhs.val; } + MLL& operator+=(const MLL& rhs) { return *this = *this + rhs; } + MLL& operator-=(const MLL& rhs) { return *this = *this - rhs; } + MLL& operator*=(const MLL& rhs) { return *this = *this * rhs; } + MLL& operator/=(const MLL& rhs) { return *this = *this / rhs; } + MLL& operator%=(const MLL& rhs) { return *this = *this % rhs; } +}; + +template +ostream& operator<<(ostream& out, const MLL& num) { + return out << num.val; +} + +template +istream& operator>>(istream& in, MLL& num) { + return in >> num.val; +} + +// miscancellous +template +bool chmax(T& lhs, const U& rhs) { + bool ret = lhs < rhs; + if (ret) { + lhs = rhs; + } + return ret; +} +template +bool chmin(T& lhs, const U& rhs) { + bool ret = lhs > rhs; + if (ret) { + lhs = rhs; + } + return ret; +} + +#define functor(func) ([&](auto&&... val) \ +noexcept(noexcept(func(std::forward(val)...))) -> decltype(auto) \ +{return func(std::forward(val)...);}) +#define expr(ret, ...) ([&] (__VA_ARGS__) { return (ret); }) +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 initarray(init, N) (__initarray::type, (N)>(init)) +namespace detail { + template + constexpr std::array + make_array(const T& value, std::index_sequence) { + return {{(static_cast(Is), value)...}}; + } +} + +template +constexpr std::array __initarray(const T& value) { + return detail::make_array(value, std::make_index_sequence()); +} +/*******************************************************/ + +#define SINGLE_TEST_CASE +// #define DUMP_TEST_CASE 7219 +// #define TOT_TEST_CASE 10000 + +void dump() {} + +void dump_ignore() {} + +void prep() { +} + +__attribute__((target("popcnt,lzcnt"))) +void solve() { + read(int, n, q); + vector ops; + for (int i = 0; i < q; ++i) { + read(int, idx); + read(char, op); + ops.emplace_back(idx - 1, op == '+'); + } + vector cost(n + 1, vector(n + 1, 1)); + for (int i = 0; i <= n; ++i) { + for (int j = 0; j <= n; ++j) { + // calculate the cost if placing i before j + if (i == j) continue; + int l = 0, r = 0; + for (auto&& [idx, op] : ops) { + if (idx == i and op == 1) { + r += 1; + } else if (idx == j and op == 0) { + l += 1; + } + chmax(cost[i][j], r - l + 1); + } + } + } + // tsp + vector dp(1 << n + 1, vector(n + 1, INFLL)); + for (int i = 1; i < (1 << n + 1); ++i) { + if (popcount(i) == 1) { + // start from the current item + dp[i][lsp(i)] = 0; + } else { + for (int j = 0; j <= n; ++j) { + if (i >> j bitand 1) { + int rem = i xor 1 << j; + for (int k = 0; k <= n; ++k) { + if (rem >> k bitand 1) { + chmin(dp[i][j], dp[rem][k] + cost[k][j]); + } + } + } + } + } + } + cout << dp[(1 << n + 1) - 1][n] << '\n'; +} + +int main() { +#if __cplusplus < 201402L or defined(_MSC_VER) and not defined(__clang__) + static_assert(false, "incompatible compiler variant detected."); +#endif + untie; + prep(); +#ifdef SINGLE_TEST_CASE + solve(); +#else + read(int, t); + for (int i = 0; i < t; ++i) { +#ifdef DUMP_TEST_CASE + if (t != (TOT_TEST_CASE)) { + solve(); + } else if (i + 1 == (DUMP_TEST_CASE)) { + dump(); + } else { + dump_ignore(); + } +#else + solve(); +#endif + } +#endif +} diff --git a/src/bin/cf-825e.cc b/src/bin/cf-825e.cc new file mode 100644 index 0000000..b150b5d --- /dev/null +++ b/src/bin/cf-825e.cc @@ -0,0 +1,595 @@ +// #pragma GCC target("popcnt,lzcnt,abm,bmi,bmi2") +#pragma GCC optimize("Ofast,unroll-loops") +/************* This code requires 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 +template struct argument_type; +template struct argument_type { using type = U; }; + +/* type aliases */ +#if LONG_LONG_MAX != INT64_MAX +using ll = int64_t; +using ull = uint64_t; +#else +using ll = long long; +using ull = unsigned long long; +#endif +using int128 = __int128_t; +using uint128 = __uint128_t; +using ld = __float128; // up to 1e-9 precision in binary search +using pii = pair; using pil = pair; using pid = pair; +using pli = pair; using pll = pair; using pld = pair; +using pdi = pair; using pdl = pair; using pdd = pair; +using tiii = tuple; using tiil = tuple; using tiid = tuple; +using tili = tuple; using till = tuple; using tild = tuple; +using tidi = tuple; using tidl = tuple; using tidd = tuple; +using tlii = tuple; using tlil = tuple; using tlid = tuple; +using tlli = tuple; using tlll = tuple; using tlld = tuple; +using tldi = tuple; using tldl = tuple; using tldd = tuple; +using tdii = tuple; using tdil = tuple; using tdid = tuple; +using tdli = tuple; using tdll = tuple; using tdld = tuple; +using tddi = tuple; using tddl = tuple; using tddd = 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 PRIMELL = 901017227882342239LL; +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_64 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 { + safe_hash hasher; + template + size_t operator()(const Sequence& arr) const { + size_t pw1 = 1, pw2 = 1; + size_t res1 = 0, res2 = 0; + for (auto&& x : arr) { + auto h = hasher(x); + res1 = (res1 + h * pw1) % __array_hash_mdl1; + res2 = (res2 + h * pw2) % __array_hash_mdl2; + pw1 = (pw1 * __array_hash_b) % __array_hash_mdl1; + pw2 = (pw2 * __array_hash_b) % __array_hash_mdl2; + } + return res1 + res2; + } +}; + +/* build data structures */ +#define faster(um) __AS_PROCEDURE((um).reserve(1024); (um).max_load_factor(0.25);) +#define unordered_counter(from, to) __AS_PROCEDURE(unordered_map<__as_typeof(from), size_t, safe_hash> to; for (auto&& x : from) ++to[x];) +#define counter(from, to, cmp) __AS_PROCEDURE(map<__as_typeof(from), size_t, cmp> to; for (auto&& x : from) ++to[x];) +#define adj(ch, n) __AS_PROCEDURE(vector> ch((n) + 1);) +#define edge(ch, u, v) __AS_PROCEDURE(ch[u].push_back(v), ch[v].push_back(u);) +#define edgew(ch, u, v, ...) __AS_PROCEDURE(ch[u].emplace_back(v, __VA_ARGS__), ch[v].emplace_back(u, __VA_ARGS__);) +#define Edge(ch, u, v) __AS_PROCEDURE(ch[u].push_back(v);) +#define Edgew(ch, u, v, ...) __AS_PROCEDURE(ch[u].emplace_back(v, __VA_ARGS__);) +template 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)) + +// add declarations to avoid circular dependency +template istream& operator>>(istream&, pair&); +template ostream& operator<<(ostream&, const pair&); +template istream& operator>>(istream&, array&); +template ostream& operator<<(ostream&, const array&); +template +decltype(auto) operator<<(std::basic_ostream&, const std::tuple&); +template ostream& operator<<(ostream&, const vector&); +std::ostream& operator<<(std::ostream&, const int128&); + +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 istream& operator>>(istream& in, array& a) { + for (size_t i = 0; i < N; ++i) in >> a[i]; + return in; +} +template ostream& operator<<(ostream& out, const array& a) { + for (auto&& i : a) out << i << ' '; + 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; +} +template void __read(T& x) { cin >> x; } +template void __read(T& x, U&... args) { cin >> x; __read(args...); } +#define read(t, ...) __AS_PROCEDURE(argument_type::type __VA_ARGS__; __read(__VA_ARGS__);) +#define readvec(t, a, n) __AS_PROCEDURE(vector::type> a(n); for (auto& x : (a)) cin >> x;) +#define readvec1(t, a, n) __AS_PROCEDURE(vector::type> a((n) + 1); copy_n(ii::type>(cin), (n), (a).begin() + 1);) +#define putvec(a) __AS_PROCEDURE(copy((a).begin(), (a).end(), oi<__as_typeof(a)::value_type>(cout, " ")); cout << endl;) +#define putvec1(a) __AS_PROCEDURE(copy((a).begin() + 1, (a).end(), oi<__as_typeof(a)::value_type>(cout, " ")); cout << endl;) +#define putvec_eol(a) __AS_PROCEDURE(copy((a).begin(), (a).end(), oi<__as_typeof(a)::value_type>(cout, "\n"));) +#define putvec1_eol(a) __AS_PROCEDURE(copy((a).begin() + 1, (a).end(), oi<__as_typeof(a)::value_type>(cout, "\n"));) +#define debug(x) __AS_PROCEDURE(cerr << #x" = " << (x) << endl;) +#define debugvec(a) __AS_PROCEDURE(cerr << #a" = "; for (auto&& x : (a)) cerr << x << ' '; cerr << endl;) +#define deb(...) debug(make_tuple(__VA_ARGS__)) + +/* pops */ +template +inline auto poptop(Container& q) { + auto ret = q.top(); + q.pop(); + return ret; +} +template +inline auto popback(Container& q) { + auto ret = q.back(); + q.pop_back(); + return ret; +} +template +inline auto popfront(Container& q) { + auto ret = q.front(); + q.pop_front(); + return ret; +} + +/* 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; +} + +// dynamic modulus +ll qpow(ll b, ll p, ll mod) { + if (b == 0 and p != 0) return 0; + if (p == 0) return 1; + ll half = qpow(b, p / 2, mod); + if (p % 2 == 1) return (int128(half) * half % mod) * b % mod; + else return half * half % mod; +} + + +#pragma GCC diagnostic push +#pragma GCC diagnostic ignored "-Wparentheses" +// Accurately find `i` 'th root of `n` (taking the floor) +inline ll root(ll n, ll i) { + ll l = 0, r = pow(LLONG_MAX, (long double)(1) / i); + while (l < r) { + ll mid = l + r + 1 >> 1; + if (qpow(mid, i) <= n) { + l = mid; + } else { + r = mid - 1; + } + } + return l; +} +#pragma GCC diagnostic pop + + +#define comb(n, k) ((n) < 0 or (k) < 0 or (n) < (k) ? 0 : fact[n] / fact[k] / fact[(n) - (k)]) +#define fastcomb(n, k) ((n) < 0 or (k) < 0 or (n) < (k) ? 0 : fact[n] * factrev[k] * factrev[(n) - (k)]) + +__attribute__((target("lzcnt"))) +constexpr inline int lg2(ll x) { return x == 0 ? -1 : sizeof(ll) * 8 - 1 - __builtin_clzll(x); } + +template +T mygcd(T a, T b) { return b == 0 ? a : mygcd(b, a % b); } + +void __exgcd(ll a, ll b, ll& x, ll& y) { + if (b == 0) { + x = 1, y = 0; + return; + } + __exgcd(b, a % b, y, x); + y -= a / b * x; +} + +ll inverse(ll a, ll b) { + ll x, y; + __exgcd(a, b, x, y); + return mod(x, b); +} + +vector> 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(const string& s, const 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(const string& s) { // find the length of shortest recurring period + int n = s.length(); + auto z = calc_z(s); + for (int i = 1; i <= n / 2; ++i) { + if (n % i == 0 && z[i] == n - i) { + return i; + } + } + return n; +} + +/* modular arithmetic */ +template 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(int128(lhs.val) * rhs.val, mdl); } + friend MLL operator/(const MLL& lhs, const MLL& rhs) { return lhs * mod(inverse(rhs.val, mdl), mdl); } + friend MLL operator%(const MLL& lhs, const MLL& rhs) { return mod(lhs.val - (lhs / rhs).val, mdl); } + friend bool operator==(const MLL& lhs, const MLL& rhs) { return lhs.val == rhs.val; } + friend bool operator!=(const MLL& lhs, const MLL& rhs) { return lhs.val != rhs.val; } + MLL& operator+=(const MLL& rhs) { return *this = *this + rhs; } + MLL& operator-=(const MLL& rhs) { return *this = *this - rhs; } + MLL& operator*=(const MLL& rhs) { return *this = *this * rhs; } + MLL& operator/=(const MLL& rhs) { return *this = *this / rhs; } + MLL& operator%=(const MLL& rhs) { return *this = *this % rhs; } +}; + +template +ostream& operator<<(ostream& out, const MLL& num) { + return out << num.val; +} + +template +istream& operator>>(istream& in, MLL& num) { + return in >> num.val; +} + +// miscancellous +template +bool chmax(T& lhs, const U& rhs) { + bool ret = lhs < rhs; + if (ret) { + lhs = rhs; + } + return ret; +} +template +bool chmin(T& lhs, const U& rhs) { + bool ret = lhs > rhs; + if (ret) { + lhs = rhs; + } + return ret; +} + +#define functor(func) ([&](auto&&... val) \ +noexcept(noexcept(func(std::forward(val)...))) -> decltype(auto) \ +{return func(std::forward(val)...);}) +#define expr(ret, ...) ([&] (__VA_ARGS__) { return (ret); }) +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 initarray(init, N) (__initarray::type, (N)>(init)) +namespace detail { + template + constexpr std::array + make_array(const T& value, std::index_sequence) { + return {{(static_cast(Is), value)...}}; + } +} + +template +constexpr std::array __initarray(const T& value) { + return detail::make_array(value, std::make_index_sequence()); +} +/*******************************************************/ + +#define SINGLE_TEST_CASE +// #define DUMP_TEST_CASE 7219 +// #define TOT_TEST_CASE 10000 + +void dump() {} + +void dump_ignore() {} + +void prep() { +} + +// __attribute__((target("popcnt"))) +void solve() { + read(int, n, m); + adj(ch, n); + vector ind(n + 1); + for (int i = 0; i < m; ++i) { + read(int, u, v); + Edge(ch, u, v); + ind[v] += 1; + } + min_heap q; + for (int i = 1; i <= n; ++i) { + if (ind[i] == 0) { + q.emplace(i); + } + } + vector res(n + 1); + int tm = 0; + while (q.size()) { + int v = poptop(q); + res[v] = ++tm; + for (auto&& u : ch[v]) { + if (--ind[u] == 0) { + q.emplace(u); + } + } + } + putvec1(res); +} + +int main() { +#if __cplusplus < 201402L or defined(_MSC_VER) and not defined(__clang__) + static_assert(false, "incompatible compiler variant detected."); +#endif + untie; + prep(); +#ifdef SINGLE_TEST_CASE + solve(); +#else + read(int, t); + for (int i = 0; i < t; ++i) { +#ifdef DUMP_TEST_CASE + if (t != (TOT_TEST_CASE)) { + solve(); + } else if (i + 1 == (DUMP_TEST_CASE)) { + dump(); + } else { + dump_ignore(); + } +#else + solve(); +#endif + } +#endif +} diff --git a/src/bin/cf-825f.cc b/src/bin/cf-825f.cc new file mode 100644 index 0000000..9332401 --- /dev/null +++ b/src/bin/cf-825f.cc @@ -0,0 +1,699 @@ +// #pragma GCC target("popcnt,lzcnt,abm,bmi,bmi2") +#pragma GCC optimize("Ofast,unroll-loops") +/************* This code requires 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 +template struct argument_type; +template struct argument_type { using type = U; }; + +/* type aliases */ +#if LONG_LONG_MAX != INT64_MAX +using ll = int64_t; +using ull = uint64_t; +#else +using ll = long long; +using ull = unsigned long long; +#endif +using int128 = __int128_t; +using uint128 = __uint128_t; +using ld = __float128; // up to 1e-9 precision in binary search +using pii = pair; using pil = pair; using pid = pair; +using pli = pair; using pll = pair; using pld = pair; +using pdi = pair; using pdl = pair; using pdd = pair; +using tiii = tuple; using tiil = tuple; using tiid = tuple; +using tili = tuple; using till = tuple; using tild = tuple; +using tidi = tuple; using tidl = tuple; using tidd = tuple; +using tlii = tuple; using tlil = tuple; using tlid = tuple; +using tlli = tuple; using tlll = tuple; using tlld = tuple; +using tldi = tuple; using tldl = tuple; using tldd = tuple; +using tdii = tuple; using tdil = tuple; using tdid = tuple; +using tdli = tuple; using tdll = tuple; using tdld = tuple; +using tddi = tuple; using tddl = tuple; using tddd = 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 PRIMELL = 901017227882342239LL; +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_64 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 { + safe_hash hasher; + template + size_t operator()(const Sequence& arr) const { + size_t pw1 = 1, pw2 = 1; + size_t res1 = 0, res2 = 0; + for (auto&& x : arr) { + auto h = hasher(x); + res1 = (res1 + h * pw1) % __array_hash_mdl1; + res2 = (res2 + h * pw2) % __array_hash_mdl2; + pw1 = (pw1 * __array_hash_b) % __array_hash_mdl1; + pw2 = (pw2 * __array_hash_b) % __array_hash_mdl2; + } + return res1 + res2; + } +}; + +/* build data structures */ +#define faster(um) __AS_PROCEDURE((um).reserve(1024); (um).max_load_factor(0.25);) +#define unordered_counter(from, to) __AS_PROCEDURE(unordered_map<__as_typeof(from), size_t, safe_hash> to; for (auto&& x : from) ++to[x];) +#define counter(from, to, cmp) __AS_PROCEDURE(map<__as_typeof(from), size_t, cmp> to; for (auto&& x : from) ++to[x];) +#define adj(ch, n) __AS_PROCEDURE(vector> ch((n) + 1);) +#define edge(ch, u, v) __AS_PROCEDURE(ch[u].push_back(v), ch[v].push_back(u);) +#define edgew(ch, u, v, ...) __AS_PROCEDURE(ch[u].emplace_back(v, __VA_ARGS__), ch[v].emplace_back(u, __VA_ARGS__);) +#define Edge(ch, u, v) __AS_PROCEDURE(ch[u].push_back(v);) +#define Edgew(ch, u, v, ...) __AS_PROCEDURE(ch[u].emplace_back(v, __VA_ARGS__);) +template 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)) + +// add declarations to avoid circular dependency +template istream& operator>>(istream&, pair&); +template ostream& operator<<(ostream&, const pair&); +template istream& operator>>(istream&, array&); +template ostream& operator<<(ostream&, const array&); +template +decltype(auto) operator<<(std::basic_ostream&, const std::tuple&); +template ostream& operator<<(ostream&, const vector&); +std::ostream& operator<<(std::ostream&, const int128&); + +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 istream& operator>>(istream& in, array& a) { + for (size_t i = 0; i < N; ++i) in >> a[i]; + return in; +} +template ostream& operator<<(ostream& out, const array& a) { + for (auto&& i : a) out << i << ' '; + 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; +} +template void __read(T& x) { cin >> x; } +template void __read(T& x, U&... args) { cin >> x; __read(args...); } +#define read(t, ...) __AS_PROCEDURE(argument_type::type __VA_ARGS__; __read(__VA_ARGS__);) +#define readvec(t, a, n) __AS_PROCEDURE(vector::type> a(n); for (auto& x : (a)) cin >> x;) +#define readvec1(t, a, n) __AS_PROCEDURE(vector::type> a((n) + 1); copy_n(ii::type>(cin), (n), (a).begin() + 1);) +#define putvec(a) __AS_PROCEDURE(copy((a).begin(), (a).end(), oi<__as_typeof(a)::value_type>(cout, " ")); cout << endl;) +#define putvec1(a) __AS_PROCEDURE(copy((a).begin() + 1, (a).end(), oi<__as_typeof(a)::value_type>(cout, " ")); cout << endl;) +#define putvec_eol(a) __AS_PROCEDURE(copy((a).begin(), (a).end(), oi<__as_typeof(a)::value_type>(cout, "\n"));) +#define putvec1_eol(a) __AS_PROCEDURE(copy((a).begin() + 1, (a).end(), oi<__as_typeof(a)::value_type>(cout, "\n"));) +#define debug(x) __AS_PROCEDURE(cerr << #x" = " << (x) << endl;) +#define debugvec(a) __AS_PROCEDURE(cerr << #a" = "; for (auto&& x : (a)) cerr << x << ' '; cerr << endl;) +#define deb(...) debug(make_tuple(__VA_ARGS__)) + +/* pops */ +template +inline auto poptop(Container& q) { + auto ret = q.top(); + q.pop(); + return ret; +} +template +inline auto popback(Container& q) { + auto ret = q.back(); + q.pop_back(); + return ret; +} +template +inline auto popfront(Container& q) { + auto ret = q.front(); + q.pop_front(); + return ret; +} + +/* 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; +} + +// dynamic modulus +ll qpow(ll b, ll p, ll mod) { + if (b == 0 and p != 0) return 0; + if (p == 0) return 1; + ll half = qpow(b, p / 2, mod); + if (p % 2 == 1) return (int128(half) * half % mod) * b % mod; + else return half * half % mod; +} + + +#pragma GCC diagnostic push +#pragma GCC diagnostic ignored "-Wparentheses" +// Accurately find `i` 'th root of `n` (taking the floor) +inline ll root(ll n, ll i) { + ll l = 0, r = pow(LLONG_MAX, (long double)(1) / i); + while (l < r) { + ll mid = l + r + 1 >> 1; + if (qpow(mid, i) <= n) { + l = mid; + } else { + r = mid - 1; + } + } + return l; +} +#pragma GCC diagnostic pop + + +#define comb(n, k) ((n) < 0 or (k) < 0 or (n) < (k) ? 0 : fact[n] / fact[k] / fact[(n) - (k)]) +#define fastcomb(n, k) ((n) < 0 or (k) < 0 or (n) < (k) ? 0 : fact[n] * factrev[k] * factrev[(n) - (k)]) + +__attribute__((target("lzcnt"))) +constexpr inline int lg2(ll x) { return x == 0 ? -1 : sizeof(ll) * 8 - 1 - __builtin_clzll(x); } + +template +T mygcd(T a, T b) { return b == 0 ? a : mygcd(b, a % b); } + +void __exgcd(ll a, ll b, ll& x, ll& y) { + if (b == 0) { + x = 1, y = 0; + return; + } + __exgcd(b, a % b, y, x); + y -= a / b * x; +} + +ll inverse(ll a, ll b) { + ll x, y; + __exgcd(a, b, x, y); + return mod(x, b); +} + +vector> 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(const string& s, const 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(const string& s) { // find the length of shortest recurring period + int n = s.length(); + auto z = calc_z(s); + for (int i = 1; i <= n / 2; ++i) { + if (n % i == 0 && z[i] == n - i) { + return i; + } + } + return n; +} + +/* modular arithmetic */ +template 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(int128(lhs.val) * rhs.val, mdl); } + friend MLL operator/(const MLL& lhs, const MLL& rhs) { return lhs * mod(inverse(rhs.val, mdl), mdl); } + friend MLL operator%(const MLL& lhs, const MLL& rhs) { return mod(lhs.val - (lhs / rhs).val, mdl); } + friend bool operator==(const MLL& lhs, const MLL& rhs) { return lhs.val == rhs.val; } + friend bool operator!=(const MLL& lhs, const MLL& rhs) { return lhs.val != rhs.val; } + MLL& operator+=(const MLL& rhs) { return *this = *this + rhs; } + MLL& operator-=(const MLL& rhs) { return *this = *this - rhs; } + MLL& operator*=(const MLL& rhs) { return *this = *this * rhs; } + MLL& operator/=(const MLL& rhs) { return *this = *this / rhs; } + MLL& operator%=(const MLL& rhs) { return *this = *this % rhs; } +}; + +template +ostream& operator<<(ostream& out, const MLL& num) { + return out << num.val; +} + +template +istream& operator>>(istream& in, MLL& num) { + return in >> num.val; +} + +// miscancellous +template +bool chmax(T& lhs, const U& rhs) { + bool ret = lhs < rhs; + if (ret) { + lhs = rhs; + } + return ret; +} +template +bool chmin(T& lhs, const U& rhs) { + bool ret = lhs > rhs; + if (ret) { + lhs = rhs; + } + return ret; +} + +#define functor(func) ([&](auto&&... val) \ +noexcept(noexcept(func(std::forward(val)...))) -> decltype(auto) \ +{return func(std::forward(val)...);}) +#define expr(ret, ...) ([&] (__VA_ARGS__) { return (ret); }) +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 initarray(init, N) (__initarray::type, (N)>(init)) +namespace detail { + template + constexpr std::array + make_array(const T& value, std::index_sequence) { + return {{(static_cast(Is), value)...}}; + } +} + +template +constexpr std::array __initarray(const T& value) { + return detail::make_array(value, std::make_index_sequence()); +} +/*******************************************************/ + +#define SINGLE_TEST_CASE +// #define DUMP_TEST_CASE 7219 +// #define TOT_TEST_CASE 10000 + +void dump() {} + +void dump_ignore() {} + +void prep() { +} + +struct SA { + int n; + std::vector sa, rk, lc; + vector> st; + + SA(std::string s) { + n = s.size(); + sa.resize(n); + lc.resize(n - 1); + rk.resize(n); + std::iota(sa.begin(), sa.end(), 0); + sort_by_key(sa.begin(), sa.end(), expr(s[i], int i)); + rk[sa[0]] = 0; + for (int i = 1; i < n; i++) { + rk[sa[i]] = rk[sa[i - 1]] + (s[sa[i]] != s[sa[i - 1]]); + } + int k = 1; + std::vector tmp, cnt(n); + tmp.reserve(n); + while (rk[sa[n - 1]] < n - 1) { + tmp.clear(); + for (int i = 0; i < k; i++) { + tmp.push_back(n - k + i); + } + for (auto i : sa) { + if (i >= k) { + tmp.push_back(i - k); + } + } + std::fill(cnt.begin(), cnt.end(), 0); + for (int i = 0; i < n; i++) { + cnt[rk[i]]++; + } + for (int i = 1; i < n; i++) { + cnt[i] += cnt[i - 1]; + } + for (int i = n - 1; i >= 0; i--) { + sa[--cnt[rk[tmp[i]]]] = tmp[i]; + } + std::swap(rk, tmp); + rk[sa[0]] = 0; + for (int i = 1; i < n; i++) { + rk[sa[i]] = rk[sa[i - 1]] + (tmp[sa[i - 1]] < tmp[sa[i]] || sa[i - 1] + k == n || tmp[sa[i - 1] + k] < tmp[sa[i] + k]); + } + k *= 2; + } + for (int i = 0, j = 0; i < n; i++) { + if (rk[i] == 0) { + j = 0; + } else { + for (j -= j > 0; i + j < n && sa[rk[i] - 1] + j < n && s[i + j] == s[sa[rk[i] - 1] + j]; ) { + j++; + } + lc[rk[i] - 1] = j; + } + } + int m = lc.size(); + int lgm = lg2(m); + st = vector(lgm + 1, vector(m)); + st[0] = lc; + for (int j = 0; j < lgm; j++) { + for (int i = 0; i + (2 << j) <= m; i++) { + st[j + 1][i] = std::min(st[j][i], st[j][i + (1 << j)]); + } + } + } + + int rmq(int l, int r) { + int k = lg2(r - l); + return std::min(st[k][l], st[k][r - (1 << k)]); + } + + __attribute__((target("lzcnt"))) + int lcp(int i, int j) { + if (i == j || i == n || j == n) { + return std::min(n - i, n - j); + } + int a = rk[i]; + int b = rk[j]; + if (a > b) { + std::swap(a, b); + } + return std::min({n - i, n - j, rmq(a, b)}); + } + + int lcs(int i, int j) { + if (i == j || i == 0 || j == 0) { + return std::min(i, j); + } + int a = rk[n + n - i]; + int b = rk[n + n - j]; + if (a > b) { + std::swap(a, b); + } + return std::min({i, j, rmq(a, b)}); + } +}; + +int calc_len(int x) { + int res = 0; + while (x) { + x /= 10; + res += 1; + } + return res; +} + +// __attribute__((target("popcnt"))) +void solve() { + read(string, s); + SA sa(s); + int n = s.size(); + vector dp(n + 1, vector(n + 1, { INF, 0 })); + vector common(n + 1, INF); + dp[0][0] = { 0, 0 }; + common[0] = 0; + for (int i = 1; i <= n; ++i) { + for (int j = 1; j <= i; ++j) { + // concatenate + if (i - j >= j and sa.lcp(i - j, i - 2 * j) >= j) { + chmin(dp[i][j], pii { dp[i - j][j].first - calc_len(dp[i - j][j].second) + calc_len(dp[i - j][j].second + 1), dp[i - j][j].second + 1 }); + } + // start a new segment + chmin(dp[i][j], pii { common[i - j] + j + calc_len(1), 1 }); + chmin(common[i], dp[i][j].first); + } + } + int res = INF; + for (int j = 1; j <= n; ++j) { + chmin(res, dp[n][j].first); + } + cout << res << '\n'; +} + +int main() { +#if __cplusplus < 201402L or defined(_MSC_VER) and not defined(__clang__) + static_assert(false, "incompatible compiler variant detected."); +#endif + untie; + prep(); +#ifdef SINGLE_TEST_CASE + solve(); +#else + read(int, t); + for (int i = 0; i < t; ++i) { +#ifdef DUMP_TEST_CASE + if (t != (TOT_TEST_CASE)) { + solve(); + } else if (i + 1 == (DUMP_TEST_CASE)) { + dump(); + } else { + dump_ignore(); + } +#else + solve(); +#endif + } +#endif +} diff --git a/src/bin/cf-835e.cc b/src/bin/cf-835e.cc new file mode 100644 index 0000000..68f9ad6 --- /dev/null +++ b/src/bin/cf-835e.cc @@ -0,0 +1,674 @@ +// #pragma GCC target("popcnt,lzcnt,abm,bmi,bmi2") +#pragma GCC optimize("Ofast,unroll-loops") +/************* This code requires 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 +template struct argument_type; +template struct argument_type { using type = U; }; + +/* type aliases */ +#if LONG_LONG_MAX != INT64_MAX +using ll = int64_t; +using ull = uint64_t; +#else +using ll = long long; +using ull = unsigned long long; +#endif +using int128 = __int128_t; +using uint128 = __uint128_t; +using ld = __float128; // up to 1e-9 precision in binary search +using pii = pair; using pil = pair; using pid = pair; +using pli = pair; using pll = pair; using pld = pair; +using pdi = pair; using pdl = pair; using pdd = pair; +using tiii = tuple; using tiil = tuple; using tiid = tuple; +using tili = tuple; using till = tuple; using tild = tuple; +using tidi = tuple; using tidl = tuple; using tidd = tuple; +using tlii = tuple; using tlil = tuple; using tlid = tuple; +using tlli = tuple; using tlll = tuple; using tlld = tuple; +using tldi = tuple; using tldl = tuple; using tldd = tuple; +using tdii = tuple; using tdil = tuple; using tdid = tuple; +using tdli = tuple; using tdll = tuple; using tdld = tuple; +using tddi = tuple; using tddl = tuple; using tddd = 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 PRIMELL = 901017227882342239LL; +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_64 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 { + safe_hash hasher; + template + size_t operator()(const Sequence& arr) const { + size_t pw1 = 1, pw2 = 1; + size_t res1 = 0, res2 = 0; + for (auto&& x : arr) { + auto h = hasher(x); + res1 = (res1 + h * pw1) % __array_hash_mdl1; + res2 = (res2 + h * pw2) % __array_hash_mdl2; + pw1 = (pw1 * __array_hash_b) % __array_hash_mdl1; + pw2 = (pw2 * __array_hash_b) % __array_hash_mdl2; + } + return res1 + res2; + } +}; + +/* build data structures */ +#define faster(um) __AS_PROCEDURE((um).reserve(1024); (um).max_load_factor(0.25);) +#define unordered_counter(from, to) __AS_PROCEDURE(unordered_map<__as_typeof(from), size_t, safe_hash> to; for (auto&& x : from) ++to[x];) +#define counter(from, to, cmp) __AS_PROCEDURE(map<__as_typeof(from), size_t, cmp> to; for (auto&& x : from) ++to[x];) +#define adj(ch, n) __AS_PROCEDURE(vector> ch((n) + 1);) +#define edge(ch, u, v) __AS_PROCEDURE(ch[u].push_back(v), ch[v].push_back(u);) +#define edgew(ch, u, v, ...) __AS_PROCEDURE(ch[u].emplace_back(v, __VA_ARGS__), ch[v].emplace_back(u, __VA_ARGS__);) +#define Edge(ch, u, v) __AS_PROCEDURE(ch[u].push_back(v);) +#define Edgew(ch, u, v, ...) __AS_PROCEDURE(ch[u].emplace_back(v, __VA_ARGS__);) +template 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)) + +// add declarations to avoid circular dependency +template istream& operator>>(istream&, pair&); +template ostream& operator<<(ostream&, const pair&); +template istream& operator>>(istream&, array&); +template ostream& operator<<(ostream&, const array&); +template +decltype(auto) operator<<(std::basic_ostream&, const std::tuple&); +template ostream& operator<<(ostream&, const vector&); +std::ostream& operator<<(std::ostream&, const int128&); + +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 istream& operator>>(istream& in, array& a) { + for (size_t i = 0; i < N; ++i) in >> a[i]; + return in; +} +template ostream& operator<<(ostream& out, const array& a) { + for (auto&& i : a) out << i << ' '; + 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; +} +template void __read(T& x) { cin >> x; } +template void __read(T& x, U&... args) { cin >> x; __read(args...); } +#define read(t, ...) __AS_PROCEDURE(argument_type::type __VA_ARGS__; __read(__VA_ARGS__);) +#define readvec(t, a, n) __AS_PROCEDURE(vector::type> a(n); for (auto& x : (a)) cin >> x;) +#define readvec1(t, a, n) __AS_PROCEDURE(vector::type> a((n) + 1); copy_n(ii::type>(cin), (n), (a).begin() + 1);) +#define putvec(a) __AS_PROCEDURE(copy((a).begin(), (a).end(), oi<__as_typeof(a)::value_type>(cout, " ")); cout << endl;) +#define putvec1(a) __AS_PROCEDURE(copy((a).begin() + 1, (a).end(), oi<__as_typeof(a)::value_type>(cout, " ")); cout << endl;) +#define putvec_eol(a) __AS_PROCEDURE(copy((a).begin(), (a).end(), oi<__as_typeof(a)::value_type>(cout, "\n"));) +#define putvec1_eol(a) __AS_PROCEDURE(copy((a).begin() + 1, (a).end(), oi<__as_typeof(a)::value_type>(cout, "\n"));) +#define debug(x) __AS_PROCEDURE(cerr << #x" = " << (x) << endl;) +#define debugvec(a) __AS_PROCEDURE(cerr << #a" = "; for (auto&& x : (a)) cerr << x << ' '; cerr << endl;) +#define deb(...) debug(make_tuple(__VA_ARGS__)) + +/* pops */ +template +inline auto poptop(Container& q) { + auto ret = q.top(); + q.pop(); + return ret; +} +template +inline auto popback(Container& q) { + auto ret = q.back(); + q.pop_back(); + return ret; +} +template +inline auto popfront(Container& q) { + auto ret = q.front(); + q.pop_front(); + return ret; +} + +/* 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; +} + +// dynamic modulus +ll qpow(ll b, ll p, ll mod) { + if (b == 0 and p != 0) return 0; + if (p == 0) return 1; + ll half = qpow(b, p / 2, mod); + if (p % 2 == 1) return (int128(half) * half % mod) * b % mod; + else return half * half % mod; +} + + +#pragma GCC diagnostic push +#pragma GCC diagnostic ignored "-Wparentheses" +// Accurately find `i` 'th root of `n` (taking the floor) +inline ll root(ll n, ll i) { + ll l = 0, r = pow(LLONG_MAX, (long double)(1) / i); + while (l < r) { + ll mid = l + r + 1 >> 1; + if (qpow(mid, i) <= n) { + l = mid; + } else { + r = mid - 1; + } + } + return l; +} +#pragma GCC diagnostic pop + + +#define comb(n, k) ((n) < 0 or (k) < 0 or (n) < (k) ? 0 : fact[n] / fact[k] / fact[(n) - (k)]) +#define fastcomb(n, k) ((n) < 0 or (k) < 0 or (n) < (k) ? 0 : fact[n] * factrev[k] * factrev[(n) - (k)]) + +__attribute__((target("lzcnt"))) +constexpr inline int lg2(ll x) { return x == 0 ? -1 : sizeof(ll) * 8 - 1 - __builtin_clzll(x); } + +template +T mygcd(T a, T b) { return b == 0 ? a : mygcd(b, a % b); } + +void __exgcd(ll a, ll b, ll& x, ll& y) { + if (b == 0) { + x = 1, y = 0; + return; + } + __exgcd(b, a % b, y, x); + y -= a / b * x; +} + +ll inverse(ll a, ll b) { + ll x, y; + __exgcd(a, b, x, y); + return mod(x, b); +} + +vector> 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(const string& s, const 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(const string& s) { // find the length of shortest recurring period + int n = s.length(); + auto z = calc_z(s); + for (int i = 1; i <= n / 2; ++i) { + if (n % i == 0 && z[i] == n - i) { + return i; + } + } + return n; +} + +/* modular arithmetic */ +template 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(int128(lhs.val) * rhs.val, mdl); } + friend MLL operator/(const MLL& lhs, const MLL& rhs) { return lhs * mod(inverse(rhs.val, mdl), mdl); } + friend MLL operator%(const MLL& lhs, const MLL& rhs) { return mod(lhs.val - (lhs / rhs).val, mdl); } + friend bool operator==(const MLL& lhs, const MLL& rhs) { return lhs.val == rhs.val; } + friend bool operator!=(const MLL& lhs, const MLL& rhs) { return lhs.val != rhs.val; } + MLL& operator+=(const MLL& rhs) { return *this = *this + rhs; } + MLL& operator-=(const MLL& rhs) { return *this = *this - rhs; } + MLL& operator*=(const MLL& rhs) { return *this = *this * rhs; } + MLL& operator/=(const MLL& rhs) { return *this = *this / rhs; } + MLL& operator%=(const MLL& rhs) { return *this = *this % rhs; } +}; + +template +ostream& operator<<(ostream& out, const MLL& num) { + return out << num.val; +} + +template +istream& operator>>(istream& in, MLL& num) { + return in >> num.val; +} + +// miscancellous +template +bool chmax(T& lhs, const U& rhs) { + bool ret = lhs < rhs; + if (ret) { + lhs = rhs; + } + return ret; +} +template +bool chmin(T& lhs, const U& rhs) { + bool ret = lhs > rhs; + if (ret) { + lhs = rhs; + } + return ret; +} + +#define functor(func) ([&](auto&&... val) \ +noexcept(noexcept(func(std::forward(val)...))) -> decltype(auto) \ +{return func(std::forward(val)...);}) +#define expr(ret, ...) ([&] (__VA_ARGS__) { return (ret); }) +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 initarray(init, N) (__initarray::type, (N)>(init)) +namespace detail { + template + constexpr std::array + make_array(const T& value, std::index_sequence) { + return {{(static_cast(Is), value)...}}; + } +} + +template +constexpr std::array __initarray(const T& value) { + return detail::make_array(value, std::make_index_sequence()); +} +/*******************************************************/ + +#define SINGLE_TEST_CASE +// #define DUMP_TEST_CASE 7219 +// #define TOT_TEST_CASE 10000 + +void dump() {} + +void dump_ignore() {} + +void prep() { +} + +// __attribute__((target("popcnt"))) +void solve() { + constexpr int N = 1024; + read(int, n, x, y); + + auto ask = [&] (const vector& v) { + vector q; + int red = 0; + for (auto&& val : v) { + if (val < n) { + q.emplace_back(val); + } else { + red xor_eq x; + } + } + if (q.empty()) { + return red; + } + cout << "? " << q.size() << ' '; + for (auto&& val : q) { + cout << val + 1 << ' '; + } + cout << endl; + read(int, res); + if (res == -1) exit(825); + return res xor red; + }; + + auto par = [&] (int val, int len) { + if (len % 2 == 1) { + if (val == x) { + return 0; + } else { + return 1; + } + } else { + if (val == (x xor y)) { + return 1; + } else { + return 0; + } + } + }; + + int layer = 0; + for (int i = 9; i; --i) { + vector q; + for (int j = 0; j < N; ++j) { + if (j >> i & 1) { + q.emplace_back(j); + } + } + assert(q.size() * 2 == N); + if (par(ask(q), N / 2)) { + layer = i; + break; + } + } + + vector left; + for (int i = 0; i < N; ++i) { + if (i >> layer & 1) { + left.emplace_back(i); + } + } + + int y1, y2; + + { + int l = 0, r = N / 2 - 1; + while (l < r) { + int mid = l + r >> 1; + vector q; + for (int i = 0; i <= mid; ++i) { + q.emplace_back(left[i]); + } + if (par(ask(q), mid + 1)) { + r = mid; + } else { + l = mid + 1; + } + } + y1 = left[l]; + } + + { + int z = (y1 >> layer xor 1) << layer; + int l = z; + int r = z xor ((1 << layer) - 1); + while (l < r) { + int mid = l + r >> 1; + vector q; + for (int i = z; i <= mid; ++i) { + q.emplace_back(i); + } + if (par(ask(q), mid - z + 1)) { + r = mid; + } else { + l = mid + 1; + } + } + y2 = l; + } + + if (y1 > y2) swap(y1, y2); + cout << "! " << y1 + 1 << ' ' << y2 + 1 << endl; + +} + +int main() { +#if __cplusplus < 201402L or defined(_MSC_VER) and not defined(__clang__) + static_assert(false, "incompatible compiler variant detected."); +#endif + untie; + prep(); +#ifdef SINGLE_TEST_CASE + solve(); +#else + read(int, t); + for (int i = 0; i < t; ++i) { +#ifdef DUMP_TEST_CASE + if (t != (TOT_TEST_CASE)) { + solve(); + } else if (i + 1 == (DUMP_TEST_CASE)) { + dump(); + } else { + dump_ignore(); + } +#else + solve(); +#endif + } +#endif +} diff --git a/src/bin/cf-835f.cc b/src/bin/cf-835f.cc new file mode 100644 index 0000000..6eecb8e --- /dev/null +++ b/src/bin/cf-835f.cc @@ -0,0 +1,720 @@ +// #pragma GCC target("popcnt,lzcnt,abm,bmi,bmi2") +#pragma GCC optimize("Ofast,unroll-loops") +/************* This code requires 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 +template struct argument_type; +template struct argument_type { using type = U; }; + +/* type aliases */ +#if LONG_LONG_MAX != INT64_MAX +using ll = int64_t; +using ull = uint64_t; +#else +using ll = long long; +using ull = unsigned long long; +#endif +using int128 = __int128_t; +using uint128 = __uint128_t; +using ld = __float128; // up to 1e-9 precision in binary search +using pii = pair; using pil = pair; using pid = pair; +using pli = pair; using pll = pair; using pld = pair; +using pdi = pair; using pdl = pair; using pdd = pair; +using tiii = tuple; using tiil = tuple; using tiid = tuple; +using tili = tuple; using till = tuple; using tild = tuple; +using tidi = tuple; using tidl = tuple; using tidd = tuple; +using tlii = tuple; using tlil = tuple; using tlid = tuple; +using tlli = tuple; using tlll = tuple; using tlld = tuple; +using tldi = tuple; using tldl = tuple; using tldd = tuple; +using tdii = tuple; using tdil = tuple; using tdid = tuple; +using tdli = tuple; using tdll = tuple; using tdld = tuple; +using tddi = tuple; using tddl = tuple; using tddd = 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 PRIMELL = 901017227882342239LL; +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_64 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 { + safe_hash hasher; + template + size_t operator()(const Sequence& arr) const { + size_t pw1 = 1, pw2 = 1; + size_t res1 = 0, res2 = 0; + for (auto&& x : arr) { + auto h = hasher(x); + res1 = (res1 + h * pw1) % __array_hash_mdl1; + res2 = (res2 + h * pw2) % __array_hash_mdl2; + pw1 = (pw1 * __array_hash_b) % __array_hash_mdl1; + pw2 = (pw2 * __array_hash_b) % __array_hash_mdl2; + } + return res1 + res2; + } +}; + +/* build data structures */ +#define faster(um) __AS_PROCEDURE((um).reserve(1024); (um).max_load_factor(0.25);) +#define unordered_counter(from, to) __AS_PROCEDURE(unordered_map<__as_typeof(from), size_t, safe_hash> to; for (auto&& x : from) ++to[x];) +#define counter(from, to, cmp) __AS_PROCEDURE(map<__as_typeof(from), size_t, cmp> to; for (auto&& x : from) ++to[x];) +#define adj(ch, n) __AS_PROCEDURE(vector> ch((n) + 1);) +#define edge(ch, u, v) __AS_PROCEDURE(ch[u].push_back(v), ch[v].push_back(u);) +#define edgew(ch, u, v, ...) __AS_PROCEDURE(ch[u].emplace_back(v, __VA_ARGS__), ch[v].emplace_back(u, __VA_ARGS__);) +#define Edge(ch, u, v) __AS_PROCEDURE(ch[u].push_back(v);) +#define Edgew(ch, u, v, ...) __AS_PROCEDURE(ch[u].emplace_back(v, __VA_ARGS__);) +template 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)) + +// add declarations to avoid circular dependency +template istream& operator>>(istream&, pair&); +template ostream& operator<<(ostream&, const pair&); +template istream& operator>>(istream&, array&); +template ostream& operator<<(ostream&, const array&); +template +decltype(auto) operator<<(std::basic_ostream&, const std::tuple&); +template ostream& operator<<(ostream&, const vector&); +std::ostream& operator<<(std::ostream&, const int128&); + +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 istream& operator>>(istream& in, array& a) { + for (size_t i = 0; i < N; ++i) in >> a[i]; + return in; +} +template ostream& operator<<(ostream& out, const array& a) { + for (auto&& i : a) out << i << ' '; + 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; +} +template void __read(T& x) { cin >> x; } +template void __read(T& x, U&... args) { cin >> x; __read(args...); } +#define read(t, ...) __AS_PROCEDURE(argument_type::type __VA_ARGS__; __read(__VA_ARGS__);) +#define readvec(t, a, n) __AS_PROCEDURE(vector::type> a(n); for (auto& x : (a)) cin >> x;) +#define readvec1(t, a, n) __AS_PROCEDURE(vector::type> a((n) + 1); copy_n(ii::type>(cin), (n), (a).begin() + 1);) +#define putvec(a) __AS_PROCEDURE(copy((a).begin(), (a).end(), oi<__as_typeof(a)::value_type>(cout, " ")); cout << endl;) +#define putvec1(a) __AS_PROCEDURE(copy((a).begin() + 1, (a).end(), oi<__as_typeof(a)::value_type>(cout, " ")); cout << endl;) +#define putvec_eol(a) __AS_PROCEDURE(copy((a).begin(), (a).end(), oi<__as_typeof(a)::value_type>(cout, "\n"));) +#define putvec1_eol(a) __AS_PROCEDURE(copy((a).begin() + 1, (a).end(), oi<__as_typeof(a)::value_type>(cout, "\n"));) +#define debug(x) __AS_PROCEDURE(cerr << #x" = " << (x) << endl;) +#define debugvec(a) __AS_PROCEDURE(cerr << #a" = "; for (auto&& x : (a)) cerr << x << ' '; cerr << endl;) +#define deb(...) debug(make_tuple(__VA_ARGS__)) + +/* pops */ +template +inline auto poptop(Container& q) { + auto ret = q.top(); + q.pop(); + return ret; +} +template +inline auto popback(Container& q) { + auto ret = q.back(); + q.pop_back(); + return ret; +} +template +inline auto popfront(Container& q) { + auto ret = q.front(); + q.pop_front(); + return ret; +} + +/* 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; +} + +// dynamic modulus +ll qpow(ll b, ll p, ll mod) { + if (b == 0 and p != 0) return 0; + if (p == 0) return 1; + ll half = qpow(b, p / 2, mod); + if (p % 2 == 1) return (int128(half) * half % mod) * b % mod; + else return half * half % mod; +} + + +#pragma GCC diagnostic push +#pragma GCC diagnostic ignored "-Wparentheses" +// Accurately find `i` 'th root of `n` (taking the floor) +inline ll root(ll n, ll i) { + ll l = 0, r = pow(LLONG_MAX, (long double)(1) / i); + while (l < r) { + ll mid = l + r + 1 >> 1; + if (qpow(mid, i) <= n) { + l = mid; + } else { + r = mid - 1; + } + } + return l; +} +#pragma GCC diagnostic pop + + +#define comb(n, k) ((n) < 0 or (k) < 0 or (n) < (k) ? 0 : fact[n] / fact[k] / fact[(n) - (k)]) +#define fastcomb(n, k) ((n) < 0 or (k) < 0 or (n) < (k) ? 0 : fact[n] * factrev[k] * factrev[(n) - (k)]) + +__attribute__((target("lzcnt"))) +constexpr inline int lg2(ll x) { return x == 0 ? -1 : sizeof(ll) * 8 - 1 - __builtin_clzll(x); } + +template +T mygcd(T a, T b) { return b == 0 ? a : mygcd(b, a % b); } + +void __exgcd(ll a, ll b, ll& x, ll& y) { + if (b == 0) { + x = 1, y = 0; + return; + } + __exgcd(b, a % b, y, x); + y -= a / b * x; +} + +ll inverse(ll a, ll b) { + ll x, y; + __exgcd(a, b, x, y); + return mod(x, b); +} + +vector> 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(const string& s, const 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(const string& s) { // find the length of shortest recurring period + int n = s.length(); + auto z = calc_z(s); + for (int i = 1; i <= n / 2; ++i) { + if (n % i == 0 && z[i] == n - i) { + return i; + } + } + return n; +} + +/* modular arithmetic */ +template 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(int128(lhs.val) * rhs.val, mdl); } + friend MLL operator/(const MLL& lhs, const MLL& rhs) { return lhs * mod(inverse(rhs.val, mdl), mdl); } + friend MLL operator%(const MLL& lhs, const MLL& rhs) { return mod(lhs.val - (lhs / rhs).val, mdl); } + friend bool operator==(const MLL& lhs, const MLL& rhs) { return lhs.val == rhs.val; } + friend bool operator!=(const MLL& lhs, const MLL& rhs) { return lhs.val != rhs.val; } + MLL& operator+=(const MLL& rhs) { return *this = *this + rhs; } + MLL& operator-=(const MLL& rhs) { return *this = *this - rhs; } + MLL& operator*=(const MLL& rhs) { return *this = *this * rhs; } + MLL& operator/=(const MLL& rhs) { return *this = *this / rhs; } + MLL& operator%=(const MLL& rhs) { return *this = *this % rhs; } +}; + +template +ostream& operator<<(ostream& out, const MLL& num) { + return out << num.val; +} + +template +istream& operator>>(istream& in, MLL& num) { + return in >> num.val; +} + +// miscancellous +template +bool chmax(T& lhs, const U& rhs) { + bool ret = lhs < rhs; + if (ret) { + lhs = rhs; + } + return ret; +} +template +bool chmin(T& lhs, const U& rhs) { + bool ret = lhs > rhs; + if (ret) { + lhs = rhs; + } + return ret; +} + +#define functor(func) ([&](auto&&... val) \ +noexcept(noexcept(func(std::forward(val)...))) -> decltype(auto) \ +{return func(std::forward(val)...);}) +#define expr(ret, ...) ([&] (__VA_ARGS__) { return (ret); }) +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 initarray(init, N) (__initarray::type, (N)>(init)) +namespace detail { + template + constexpr std::array + make_array(const T& value, std::index_sequence) { + return {{(static_cast(Is), value)...}}; + } +} + +template +constexpr std::array __initarray(const T& value) { + return detail::make_array(value, std::make_index_sequence()); +} +/*******************************************************/ + +#define SINGLE_TEST_CASE +// #define DUMP_TEST_CASE 7219 +// #define TOT_TEST_CASE 10000 + +void dump() {} + +void dump_ignore() {} + +void prep() { +} + +// __attribute__((target("popcnt"))) +void solve() { + read(int, n); + + readvec((array), edges, n); + vector fa(n + 1); + vector depth(n + 1); + vector maxdepth(n + 1); + { + vector> e(n + 1); + for (auto&& [u, v, w] : edges) { + edgew(e, u, v, w); + } + vector vis(n + 1); + auto dfs = [&] (auto dfs, int v, int pa) -> void { + fa[v] = pa; + maxdepth[v] = depth[v]; + vis[v] = 1; + for (auto&& [u, w] : e[v]) { + if (u == pa or vis[u]) continue; + depth[u] = depth[v] + w; + dfs(dfs, u, v); + chmax(maxdepth[v], maxdepth[u]); + } + }; + dfs(dfs, 1, 0); + } + + vector> e(n + 1); + int u1 = -1, v1 = -1, w1 = -1; + for (auto&& [u, v, w] : edges) { + if (fa[u] not_eq v and fa[v] not_eq u) { + u1 = u, v1 = v, w1 = w; + } else { + edgew(e, u, v, w); + } + } + assert(u1 != -1); + if (depth[u1] > depth[v1]) swap(u1, v1); + + ll res = INFLL; + + // remove one edge on the cycle + vector du(n + 1), dv(n + 1); + { + auto dfs = [&] (auto dfs, int v, int pa, ll d) -> void { + du[v] = d; + for (auto&& [u, w] : e[v]) { + if (u == pa) continue; + dfs(dfs, u, v, d + w); + } + }; + dfs(dfs, u1, 0, 0); + } + { + auto dfs = [&] (auto dfs, int v, int pa, ll d) -> void { + dv[v] = d; + for (auto&& [u, w] : e[v]) { + if (u == pa) continue; + dfs(dfs, u, v, d + w); + } + }; + dfs(dfs, v1, 0, 0); + } + // subtree max of du and dv + vector mxdu(n + 1), mxdv(n + 1); + { + auto dfs = [&] (auto dfs, int v, int pa) -> void { + mxdu[v] = du[v]; + for (auto&& [u, w] : e[v]) { + if (u == pa) continue; + dfs(dfs, u, v); + chmax(mxdu[v], mxdu[u]); + } + }; + dfs(dfs, 1, 0); + } + { + auto dfs = [&] (auto dfs, int v, int pa) -> void { + mxdv[v] = dv[v]; + for (auto&& [u, w] : e[v]) { + if (u == pa) continue; + dfs(dfs, u, v); + chmax(mxdv[v], mxdv[u]); + } + }; + dfs(dfs, 1, 0); + } + + vector downinner(n + 1); + { + auto dfs = [&] (auto dfs, int v, int pa) -> void { + multiset d = { 0 }; + for (auto&& [u, w] : e[v]) { + if (u == pa) continue; + dfs(dfs, u, v); + chmax(downinner[v], downinner[u]); + d.emplace(maxdepth[u] - depth[v]); + } + if (d.size() >= 2) { + chmax(downinner[v], *d.rbegin() + *next(d.rbegin())); + } + }; + dfs(dfs, 1, 0); + } + // tree diameter + chmin(res, downinner[1]); + + vector updu(n + 1); + vector upinner(n + 1); + { + auto dfs = [&] (auto dfs, int v, int pa, ll uu, ll ud) -> void { + multiset dus = { uu, du[v] }, depths = { ud, 0 }; + multiset downs; + for (auto&& [u, w] : e[v]) { + if (u == pa) continue; + dus.emplace(mxdu[u]); + depths.emplace(maxdepth[u] - depth[v]); + downs.emplace(downinner[u]); + } + for (auto&& [u, w] : e[v]) { + if (u == pa) continue; + dus.erase(dus.find(mxdu[u])); + depths.erase(depths.find(maxdepth[u] - depth[v])); + downs.erase(downs.find(downinner[u])); + if (dus.size()) { + updu[u] = *dus.rbegin(); + } + chmax(upinner[u], upinner[v]); + if (downs.size()) { + chmax(upinner[u], *downs.rbegin()); + } + if (depths.size() >= 2) { + chmax(upinner[u], *depths.rbegin() + *next(depths.rbegin())); + } + dfs(dfs, u, v, dus.size() ? *dus.rbegin() : -INFLL, depths.size() ? *depths.rbegin() + w : -INFLL); + dus.emplace(mxdu[u]); + depths.emplace(maxdepth[u] - depth[v]); + downs.emplace(downinner[u]); + } + }; + dfs(dfs, 1, 0, -INFLL, -INFLL); + } + // deb(u1, v1); + + int v = v1; + while (v != u1) { + // deb(v, mxdv[v], updu[fa[v]], max({ downinner[v], upinner[v], w1 + mxdv[v] + updu[fa[v]] })); + chmin(res, max({ downinner[v], upinner[v], w1 + mxdv[v] + updu[v] })); + v = fa[v]; + } + + cout << res << '\n'; +} + +int main() { +#if __cplusplus < 201402L or defined(_MSC_VER) and not defined(__clang__) + static_assert(false, "incompatible compiler variant detected."); +#endif + untie; + prep(); +#ifdef SINGLE_TEST_CASE + solve(); +#else + read(int, t); + for (int i = 0; i < t; ++i) { +#ifdef DUMP_TEST_CASE + if (t != (TOT_TEST_CASE)) { + solve(); + } else if (i + 1 == (DUMP_TEST_CASE)) { + dump(); + } else { + dump_ignore(); + } +#else + solve(); +#endif + } +#endif +} diff --git a/src/bin/cf-845e.cc b/src/bin/cf-845e.cc new file mode 100644 index 0000000..0941aae --- /dev/null +++ b/src/bin/cf-845e.cc @@ -0,0 +1,644 @@ +// #pragma GCC target("popcnt,lzcnt,abm,bmi,bmi2") +#pragma GCC optimize("Ofast,unroll-loops") +/************* This code requires 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 +template struct argument_type; +template struct argument_type { using type = U; }; + +/* type aliases */ +#if LONG_LONG_MAX != INT64_MAX +using ll = int64_t; +using ull = uint64_t; +#else +using ll = long long; +using ull = unsigned long long; +#endif +using int128 = __int128_t; +using uint128 = __uint128_t; +using ld = __float128; // up to 1e-9 precision in binary search +using pii = pair; using pil = pair; using pid = pair; +using pli = pair; using pll = pair; using pld = pair; +using pdi = pair; using pdl = pair; using pdd = pair; +using tiii = tuple; using tiil = tuple; using tiid = tuple; +using tili = tuple; using till = tuple; using tild = tuple; +using tidi = tuple; using tidl = tuple; using tidd = tuple; +using tlii = tuple; using tlil = tuple; using tlid = tuple; +using tlli = tuple; using tlll = tuple; using tlld = tuple; +using tldi = tuple; using tldl = tuple; using tldd = tuple; +using tdii = tuple; using tdil = tuple; using tdid = tuple; +using tdli = tuple; using tdll = tuple; using tdld = tuple; +using tddi = tuple; using tddl = tuple; using tddd = 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 PRIMELL = 901017227882342239LL; +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_64 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 { + safe_hash hasher; + template + size_t operator()(const Sequence& arr) const { + size_t pw1 = 1, pw2 = 1; + size_t res1 = 0, res2 = 0; + for (auto&& x : arr) { + auto h = hasher(x); + res1 = (res1 + h * pw1) % __array_hash_mdl1; + res2 = (res2 + h * pw2) % __array_hash_mdl2; + pw1 = (pw1 * __array_hash_b) % __array_hash_mdl1; + pw2 = (pw2 * __array_hash_b) % __array_hash_mdl2; + } + return res1 + res2; + } +}; + +/* build data structures */ +#define faster(um) __AS_PROCEDURE((um).reserve(1024); (um).max_load_factor(0.25);) +#define unordered_counter(from, to) __AS_PROCEDURE(unordered_map<__as_typeof(from), size_t, safe_hash> to; for (auto&& x : from) ++to[x];) +#define counter(from, to, cmp) __AS_PROCEDURE(map<__as_typeof(from), size_t, cmp> to; for (auto&& x : from) ++to[x];) +#define adj(ch, n) __AS_PROCEDURE(vector> ch((n) + 1);) +#define edge(ch, u, v) __AS_PROCEDURE(ch[u].push_back(v), ch[v].push_back(u);) +#define edgew(ch, u, v, ...) __AS_PROCEDURE(ch[u].emplace_back(v, __VA_ARGS__), ch[v].emplace_back(u, __VA_ARGS__);) +#define Edge(ch, u, v) __AS_PROCEDURE(ch[u].push_back(v);) +#define Edgew(ch, u, v, ...) __AS_PROCEDURE(ch[u].emplace_back(v, __VA_ARGS__);) +template 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)) + +// add declarations to avoid circular dependency +template istream& operator>>(istream&, pair&); +template ostream& operator<<(ostream&, const pair&); +template istream& operator>>(istream&, array&); +template ostream& operator<<(ostream&, const array&); +template +decltype(auto) operator<<(std::basic_ostream&, const std::tuple&); +template ostream& operator<<(ostream&, const vector&); +std::ostream& operator<<(std::ostream&, const int128&); + +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 istream& operator>>(istream& in, array& a) { + for (size_t i = 0; i < N; ++i) in >> a[i]; + return in; +} +template ostream& operator<<(ostream& out, const array& a) { + for (auto&& i : a) out << i << ' '; + 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; +} +template void __read(T& x) { cin >> x; } +template void __read(T& x, U&... args) { cin >> x; __read(args...); } +#define read(t, ...) __AS_PROCEDURE(argument_type::type __VA_ARGS__; __read(__VA_ARGS__);) +#define readvec(t, a, n) __AS_PROCEDURE(vector::type> a(n); for (auto& x : (a)) cin >> x;) +#define readvec1(t, a, n) __AS_PROCEDURE(vector::type> a((n) + 1); copy_n(ii::type>(cin), (n), (a).begin() + 1);) +#define putvec(a) __AS_PROCEDURE(copy((a).begin(), (a).end(), oi<__as_typeof(a)::value_type>(cout, " ")); cout << endl;) +#define putvec1(a) __AS_PROCEDURE(copy((a).begin() + 1, (a).end(), oi<__as_typeof(a)::value_type>(cout, " ")); cout << endl;) +#define putvec_eol(a) __AS_PROCEDURE(copy((a).begin(), (a).end(), oi<__as_typeof(a)::value_type>(cout, "\n"));) +#define putvec1_eol(a) __AS_PROCEDURE(copy((a).begin() + 1, (a).end(), oi<__as_typeof(a)::value_type>(cout, "\n"));) +#define debug(x) __AS_PROCEDURE(cerr << #x" = " << (x) << endl;) +#define debugvec(a) __AS_PROCEDURE(cerr << #a" = "; for (auto&& x : (a)) cerr << x << ' '; cerr << endl;) +#define deb(...) debug(make_tuple(__VA_ARGS__)) + +/* pops */ +template +inline auto poptop(Container& q) { + auto ret = q.top(); + q.pop(); + return ret; +} +template +inline auto popback(Container& q) { + auto ret = q.back(); + q.pop_back(); + return ret; +} +template +inline auto popfront(Container& q) { + auto ret = q.front(); + q.pop_front(); + return ret; +} + +/* 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; +} + +// dynamic modulus +ll qpow(ll b, ll p, ll mod) { + if (b == 0 and p != 0) return 0; + if (p == 0) return 1; + ll half = qpow(b, p / 2, mod); + if (p % 2 == 1) return (int128(half) * half % mod) * b % mod; + else return half * half % mod; +} + + +#pragma GCC diagnostic push +#pragma GCC diagnostic ignored "-Wparentheses" +// Accurately find `i` 'th root of `n` (taking the floor) +inline ll root(ll n, ll i) { + ll l = 0, r = pow(LLONG_MAX, (long double)(1) / i); + while (l < r) { + ll mid = l + r + 1 >> 1; + if (qpow(mid, i) <= n) { + l = mid; + } else { + r = mid - 1; + } + } + return l; +} +#pragma GCC diagnostic pop + + +#define comb(n, k) ((n) < 0 or (k) < 0 or (n) < (k) ? 0 : fact[n] / fact[k] / fact[(n) - (k)]) +#define fastcomb(n, k) ((n) < 0 or (k) < 0 or (n) < (k) ? 0 : fact[n] * factrev[k] * factrev[(n) - (k)]) + +__attribute__((target("lzcnt"))) +constexpr inline int lg2(ll x) { return x == 0 ? -1 : sizeof(ll) * 8 - 1 - __builtin_clzll(x); } + +template +T mygcd(T a, T b) { return b == 0 ? a : mygcd(b, a % b); } + +void __exgcd(ll a, ll b, ll& x, ll& y) { + if (b == 0) { + x = 1, y = 0; + return; + } + __exgcd(b, a % b, y, x); + y -= a / b * x; +} + +ll inverse(ll a, ll b) { + ll x, y; + __exgcd(a, b, x, y); + return mod(x, b); +} + +vector> 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(const string& s, const 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(const string& s) { // find the length of shortest recurring period + int n = s.length(); + auto z = calc_z(s); + for (int i = 1; i <= n / 2; ++i) { + if (n % i == 0 && z[i] == n - i) { + return i; + } + } + return n; +} + +/* modular arithmetic */ +template 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(int128(lhs.val) * rhs.val, mdl); } + friend MLL operator/(const MLL& lhs, const MLL& rhs) { return lhs * mod(inverse(rhs.val, mdl), mdl); } + friend MLL operator%(const MLL& lhs, const MLL& rhs) { return mod(lhs.val - (lhs / rhs).val, mdl); } + friend bool operator==(const MLL& lhs, const MLL& rhs) { return lhs.val == rhs.val; } + friend bool operator!=(const MLL& lhs, const MLL& rhs) { return lhs.val != rhs.val; } + MLL& operator+=(const MLL& rhs) { return *this = *this + rhs; } + MLL& operator-=(const MLL& rhs) { return *this = *this - rhs; } + MLL& operator*=(const MLL& rhs) { return *this = *this * rhs; } + MLL& operator/=(const MLL& rhs) { return *this = *this / rhs; } + MLL& operator%=(const MLL& rhs) { return *this = *this % rhs; } +}; + +template +ostream& operator<<(ostream& out, const MLL& num) { + return out << num.val; +} + +template +istream& operator>>(istream& in, MLL& num) { + return in >> num.val; +} + +// miscancellous +template +bool chmax(T& lhs, const U& rhs) { + bool ret = lhs < rhs; + if (ret) { + lhs = rhs; + } + return ret; +} +template +bool chmin(T& lhs, const U& rhs) { + bool ret = lhs > rhs; + if (ret) { + lhs = rhs; + } + return ret; +} + +#define functor(func) ([&](auto&&... val) \ +noexcept(noexcept(func(std::forward(val)...))) -> decltype(auto) \ +{return func(std::forward(val)...);}) +#define expr(ret, ...) ([&] (__VA_ARGS__) { return (ret); }) +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 initarray(init, N) (__initarray::type, (N)>(init)) +namespace detail { + template + constexpr std::array + make_array(const T& value, std::index_sequence) { + return {{(static_cast(Is), value)...}}; + } +} + +template +constexpr std::array __initarray(const T& value) { + return detail::make_array(value, std::make_index_sequence()); +} +/*******************************************************/ + +#define SINGLE_TEST_CASE +// #define DUMP_TEST_CASE 7219 +// #define TOT_TEST_CASE 10000 + +void dump() {} + +void dump_ignore() {} + +void prep() { +} + +// __attribute__((target("popcnt"))) +void solve() { + read(int, n, m, k); + readvec(pii, a, k); + transform(a.begin(), a.end(), a.begin(), expr(pair(p.first - 1, p.second - 1), auto&& p)); + + auto check = [&] (int tm) -> bool { + vector row = { 0, n - 1, n }, col = { 0, m - 1, m }; + for (auto&& [x, y] : a) { + row.emplace_back(max(0, x - tm)); + row.emplace_back(max(0, x - tm - 1)); + row.emplace_back(min(n, x + tm)); + row.emplace_back(min(n, x + tm + 1)); + col.emplace_back(max(0, y - tm)); + col.emplace_back(max(0, y - tm - 1)); + col.emplace_back(min(m, y + tm)); + col.emplace_back(min(m, y + tm + 1)); + } + sort(row.begin(), row.end()); + int p = unique(row.begin(), row.end()) - row.begin(); + row.resize(p); + auto gr = [&] (int x) { return lower_bound(row.begin(), row.end(), x) - row.begin(); }; + sort(col.begin(), col.end()); + int q = unique(col.begin(), col.end()) - col.begin(); + col.resize(q); + auto gc = [&] (int x) { return lower_bound(col.begin(), col.end(), x) - col.begin(); }; + vector cnt(p + 1, vector(q + 1)); + for (auto&& [x, y] : a) { + cnt[gr(max(0, x - tm))][gc(max(0, y - tm))] += 1; + cnt[gr(max(0, x - tm))][gc(min(m, y + tm + 1))] -= 1; + cnt[gr(min(n, x + tm + 1))][gc(max(0, y - tm))] -= 1; + cnt[gr(min(n, x + tm + 1))][gc(min(m, y + tm + 1))] += 1; + } + for (int j = 1; j <= q; ++j) { + cnt[0][j] += cnt[0][j - 1]; + } + // debug(tm); + // debug(cnt[0]); + for (int i = 1; i <= p; ++i) { + cnt[i][0] += cnt[i - 1][0]; + for (int j = 1; j <= q; ++j) { + cnt[i][j] += cnt[i - 1][j] + cnt[i][j - 1] - cnt[i - 1][j - 1]; + } + // debug(cnt[i]); + } + int mapped_n = gr(n), mapped_m = gc(m); + int minx = INF, maxx = -INF, miny = INF, maxy = -INF; + for (int i = 0; i < mapped_n; ++i) { + for (int j = 0; j < mapped_m; ++j) { + if (cnt[i][j] == 0) { + int x = row[i], y = col[j]; + chmin(minx, x); + chmax(maxx, x); + chmin(miny, y); + chmax(maxy, y); + } + } + } + // deb(minx, maxx); + // deb(miny, maxy); + if (maxx - minx + 1 <= 1 + tm * 2 and maxy - miny + 1 <= 1 + tm * 2) { + return true; + } else { + return false; + } + }; + + int l = 0, r = INF; + while (l < r) { + int mid = l + r >> 1; + if (check(mid)) { + r = mid; + } else { + l = mid + 1; + } + } + cout << l << '\n'; +} + +int main() { +#if __cplusplus < 201402L or defined(_MSC_VER) and not defined(__clang__) + static_assert(false, "incompatible compiler variant detected."); +#endif + untie; + prep(); +#ifdef SINGLE_TEST_CASE + solve(); +#else + read(int, t); + for (int i = 0; i < t; ++i) { +#ifdef DUMP_TEST_CASE + if (t != (TOT_TEST_CASE)) { + solve(); + } else if (i + 1 == (DUMP_TEST_CASE)) { + dump(); + } else { + dump_ignore(); + } +#else + solve(); +#endif + } +#endif +} diff --git a/src/bin/cp-templates b/src/bin/cp-templates index a831bd6..d4d2d86 160000 --- a/src/bin/cp-templates +++ b/src/bin/cp-templates @@ -1 +1 @@ -Subproject commit a831bd62780d6d58963c16d34f1f283f560307c8 +Subproject commit d4d2d86f434f7eba5cbf0fe3ba3fb8e693a30712 diff --git a/src/bin/std.in b/src/bin/std.in index 8b13789..5693fed 100644 --- a/src/bin/std.in +++ b/src/bin/std.in @@ -1 +1 @@ - +aaaaaaaaaa diff --git a/src/bin/test.cc b/src/bin/test.cc index 35104d0..8e73167 100644 --- a/src/bin/test.cc +++ b/src/bin/test.cc @@ -25,7 +25,7 @@ using ull = unsigned long long; #endif using int128 = __int128_t; using uint128 = __uint128_t; -using ld = __float128; +using ld = __float128; // up to 1e-9 precision in binary search using pii = pair; using pil = pair; using pid = pair; using pli = pair; using pll = pair; using pld = pair; using pdi = pair; using pdl = pair; using pdd = pair; @@ -48,6 +48,7 @@ constexpr int INF = 0x3f3f3f3f; constexpr ll INFLL = 0x3f3f3f3f3f3f3f3fLL; constexpr ll MDL = 1e9 + 7; constexpr ll PRIME = 998'244'353; +constexpr ll PRIMELL = 901017227882342239LL; constexpr ll MDL1 = 8784491; constexpr ll MDL2 = PRIME; constexpr int128 INT128_MAX = numeric_limits::max(); @@ -96,9 +97,9 @@ struct igt { /* 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;) +#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 { @@ -241,14 +242,14 @@ std::ostream& operator<<(std::ostream& dest, const int128& value) { template void __read(T& x) { cin >> x; } template void __read(T& x, U&... args) { cin >> x; __read(args...); } #define read(t, ...) __AS_PROCEDURE(argument_type::type __VA_ARGS__; __read(__VA_ARGS__);) -#define readvec(t, a, n) __AS_PROCEDURE(vector::type> a(n); for (auto& x : a) cin >> x;) -#define readvec1(t, a, n) __AS_PROCEDURE(vector::type> a((n) + 1); copy_n(ii::type>(cin), (n), a.begin() + 1);) -#define putvec(a) __AS_PROCEDURE(copy(a.begin(), a.end(), oi<__as_typeof(a)::value_type>(cout, " ")); cout << endl;) -#define putvec1(a) __AS_PROCEDURE(copy(a.begin() + 1, a.end(), oi<__as_typeof(a)::value_type>(cout, " ")); cout << endl;) -#define putvec_eol(a) __AS_PROCEDURE(copy(a.begin(), a.end(), oi<__as_typeof(a)::value_type>(cout, "\n"));) -#define putvec1_eol(a) __AS_PROCEDURE(copy(a.begin() + 1, a.end(), oi<__as_typeof(a)::value_type>(cout, "\n"));) +#define readvec(t, a, n) __AS_PROCEDURE(vector::type> a(n); for (auto& x : (a)) cin >> x;) +#define readvec1(t, a, n) __AS_PROCEDURE(vector::type> a((n) + 1); copy_n(ii::type>(cin), (n), (a).begin() + 1);) +#define putvec(a) __AS_PROCEDURE(copy((a).begin(), (a).end(), oi<__as_typeof(a)::value_type>(cout, " ")); cout << endl;) +#define putvec1(a) __AS_PROCEDURE(copy((a).begin() + 1, (a).end(), oi<__as_typeof(a)::value_type>(cout, " ")); cout << endl;) +#define putvec_eol(a) __AS_PROCEDURE(copy((a).begin(), (a).end(), oi<__as_typeof(a)::value_type>(cout, "\n"));) +#define putvec1_eol(a) __AS_PROCEDURE(copy((a).begin() + 1, (a).end(), oi<__as_typeof(a)::value_type>(cout, "\n"));) #define debug(x) __AS_PROCEDURE(cerr << #x" = " << (x) << endl;) -#define debugvec(a) __AS_PROCEDURE(cerr << #a" = "; for (auto&& x : a) cerr << x << ' '; cerr << endl;) +#define debugvec(a) __AS_PROCEDURE(cerr << #a" = "; for (auto&& x : (a)) cerr << x << ' '; cerr << endl;) #define deb(...) debug(make_tuple(__VA_ARGS__)) /* pops */ @@ -395,7 +396,7 @@ vector calc_z(string t) { // z function of t } return z; } -vector kmp(string s, string t) { // find all t in s +vector kmp(const string& s, const string& t) { // find all t in s string cur = t + '#' + s; int sz1 = s.size(), sz2 = t.size(); vector v; @@ -405,7 +406,7 @@ vector kmp(string s, string t) { // find all t in s } return v; } -int period(string s) { // find the length of shortest recurring period +int period(const string& s) { // find the length of shortest recurring period int n = s.length(); auto z = calc_z(s); for (int i = 1; i <= n / 2; ++i) { @@ -423,8 +424,8 @@ template struct MLL { 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(int128(lhs.val) * rhs.val, mdl); } + friend MLL operator/(const MLL& lhs, const MLL& rhs) { return lhs * mod(inverse(rhs.val, mdl), mdl); } friend MLL operator%(const MLL& lhs, const MLL& rhs) { return mod(lhs.val - (lhs / rhs).val, mdl); } friend bool operator==(const MLL& lhs, const MLL& rhs) { return lhs.val == rhs.val; } friend bool operator!=(const MLL& lhs, const MLL& rhs) { return lhs.val != rhs.val; } @@ -526,7 +527,7 @@ constexpr std::array __initarray(const T& value) { } /*******************************************************/ -#define SINGLE_TEST_CASE +// #define SINGLE_TEST_CASE // #define DUMP_TEST_CASE 7219 // #define TOT_TEST_CASE 10000 @@ -539,14 +540,9 @@ void prep() { // __attribute__((target("popcnt"))) void solve() { - for (int i = 9; ; i += 9) { - if (parity(i)) { - debug(i); - auto test = [&] { - }; - return; - } - } + string a = "9"; + cout << a + char(48) << '\n'; + sort(a.begin(), a.end()); } int main() { diff --git a/src/bin/test.py b/src/bin/test.py index 6301e3f..ac433d4 100644 --- a/src/bin/test.py +++ b/src/bin/test.py @@ -8,7 +8,8 @@ import io PRIME = 998_244_353 if __name__ == '__main__': - N = 500000 - print(N, N // 2) - for _ in range(2): - print(*(randint(1, 10 ** 9) for _ in range(N))) + N = 50 + print(N) + for i in range(2, N + 1): + print(f'{randint(1, i - 1)} {i} {randint(100000000, 999999999)}') + print(f'1 50 {randint(100000000, 999999999)}')