From 8137ce15f12b1ac39083c812e7ecf5051a8138c8 Mon Sep 17 00:00:00 2001 From: arielherself Date: Tue, 27 Feb 2024 11:42:51 +0800 Subject: [PATCH] backup --- ...2.rs_7dc1464bbe4be0252836cbae4f6e0902.prob | 1 + src/bin/a.cc | 252 ++++++++++++++ src/bin/a.out | Bin 0 -> 398584 bytes src/bin/at-abc337g.cc | 145 ++++++++ src/bin/b.cc | 266 +++++++++++++++ src/bin/c.cc | 251 ++++++++++++++ src/bin/cf-1245c.cc | 43 +++ src/bin/cf-1656c.cc | 175 ++++++++++ src/bin/cf-1700d.cc | 259 +++++++++++++++ src/bin/cf-1715d.cc | 278 ++++++++++++++++ src/bin/cf-1739d.cc | 269 +++++++++++++++ src/bin/cf-1742g.cc | 259 +++++++++++++++ src/bin/cf-1760f.cc | 270 +++++++++++++++ src/bin/cf-1791g2.cc | 298 +++++++++++++++++ src/bin/cf-1799d1.cc | 279 ++++++++++++++++ src/bin/cf-1800e2.cc | 265 +++++++++++++++ src/bin/cf-1811e.cc | 309 +++++++++++++++++ src/bin/cf-1846g.cc | 281 ++++++++++++++++ src/bin/cf-1849d.cc | 185 +++++++++++ src/bin/cf-1850h.cc | 196 +++++++++++ src/bin/cf-1851f.cc | 224 +++++++++++++ src/bin/cf-1852b.cc | 184 ++++++++++ src/bin/cf-1856e1.cc | 193 +++++++++++ src/bin/cf-1857f.cc | 204 ++++++++++++ src/bin/cf-1859d.cc | 274 +++++++++++++++ src/bin/cf-1867d.cc | 214 ++++++++++++ src/bin/cf-1870d.cc | 187 +++++++++++ src/bin/cf-1872e.cc | 188 +++++++++++ src/bin/cf-1872f.cc | 206 ++++++++++++ src/bin/cf-1882c.cc | 179 ++++++++++ src/bin/cf-1905c.cc | 208 ++++++++++-- src/bin/cf-1905c.gen | Bin 0 -> 46888 bytes src/bin/cf-1909b.cc | 177 ++++++++++ src/bin/cf-309c.cc | 191 +++++++++++ src/bin/cf1759e.cc | 265 +++++++++++++++ src/bin/cf1760f.cc | 242 ++++++++++++++ src/bin/cf1923d.cc | 314 ++++++++++++++++++ src/bin/d.cc | 314 ++++++++++++++++++ src/bin/lc-2846.cc | 268 +++++++++++++++ src/bin/lg-1352.cc | 178 ++++++++++ src/bin/lg-2015.cc | 207 ++++++++++++ src/bin/lg-u41492.cc | 222 +++++++++++++ src/bin/lq-170a.cc | 242 ++++++++++++++ src/bin/lq-170b.cc | 253 ++++++++++++++ src/bin/lq-170c.cc | 251 ++++++++++++++ src/bin/lq-170d.cc | 287 ++++++++++++++++ src/bin/lq-170e.cc | 299 +++++++++++++++++ src/bin/lq-170f.cc | 274 +++++++++++++++ src/bin/nc-75766b.cc | 247 ++++++++++++++ src/bin/nc-75766c.cc | 253 ++++++++++++++ src/bin/nc-75766d.cc | 290 ++++++++++++++++ src/bin/nc-75766e.cc | 276 +++++++++++++++ src/bin/nc-75766f.cc | 287 ++++++++++++++++ src/bin/std.in | 18 + src/bin/std.out | 4 + src/bin/test.cc | 212 ++++++------ src/bin/test.js | 32 ++ src/bin/test.py | 52 ++- src/bin/test.rs | 43 +-- src/bin/test.s | 116 +++++++ src/bin/test.ts | 17 + src/bin/test1.cc | 278 ++++++++++++++-- src/bin/testgen.cc | 63 ++++ src/bin/testget.cc | 9 +- 64 files changed, 12482 insertions(+), 241 deletions(-) create mode 100644 src/bin/.cph/.lc-1552.rs_7dc1464bbe4be0252836cbae4f6e0902.prob create mode 100644 src/bin/a.cc create mode 100755 src/bin/a.out create mode 100644 src/bin/at-abc337g.cc create mode 100644 src/bin/b.cc create mode 100644 src/bin/c.cc create mode 100644 src/bin/cf-1245c.cc create mode 100644 src/bin/cf-1656c.cc create mode 100644 src/bin/cf-1700d.cc create mode 100644 src/bin/cf-1715d.cc create mode 100644 src/bin/cf-1739d.cc create mode 100644 src/bin/cf-1742g.cc create mode 100644 src/bin/cf-1760f.cc create mode 100644 src/bin/cf-1791g2.cc create mode 100644 src/bin/cf-1799d1.cc create mode 100644 src/bin/cf-1800e2.cc create mode 100644 src/bin/cf-1811e.cc create mode 100644 src/bin/cf-1846g.cc create mode 100644 src/bin/cf-1849d.cc create mode 100644 src/bin/cf-1850h.cc create mode 100644 src/bin/cf-1851f.cc create mode 100644 src/bin/cf-1852b.cc create mode 100644 src/bin/cf-1856e1.cc create mode 100644 src/bin/cf-1857f.cc create mode 100644 src/bin/cf-1859d.cc create mode 100644 src/bin/cf-1867d.cc create mode 100644 src/bin/cf-1870d.cc create mode 100644 src/bin/cf-1872e.cc create mode 100644 src/bin/cf-1872f.cc create mode 100644 src/bin/cf-1882c.cc create mode 100755 src/bin/cf-1905c.gen create mode 100644 src/bin/cf-1909b.cc create mode 100644 src/bin/cf-309c.cc create mode 100644 src/bin/cf1759e.cc create mode 100644 src/bin/cf1760f.cc create mode 100644 src/bin/cf1923d.cc create mode 100644 src/bin/d.cc create mode 100644 src/bin/lc-2846.cc create mode 100644 src/bin/lg-1352.cc create mode 100644 src/bin/lg-2015.cc create mode 100644 src/bin/lg-u41492.cc create mode 100644 src/bin/lq-170a.cc create mode 100644 src/bin/lq-170b.cc create mode 100644 src/bin/lq-170c.cc create mode 100644 src/bin/lq-170d.cc create mode 100644 src/bin/lq-170e.cc create mode 100644 src/bin/lq-170f.cc create mode 100644 src/bin/nc-75766b.cc create mode 100644 src/bin/nc-75766c.cc create mode 100644 src/bin/nc-75766d.cc create mode 100644 src/bin/nc-75766e.cc create mode 100644 src/bin/nc-75766f.cc create mode 100644 src/bin/std.in create mode 100644 src/bin/std.out create mode 100644 src/bin/test.js create mode 100644 src/bin/test.s create mode 100644 src/bin/test.ts create mode 100644 src/bin/testgen.cc diff --git a/src/bin/.cph/.lc-1552.rs_7dc1464bbe4be0252836cbae4f6e0902.prob b/src/bin/.cph/.lc-1552.rs_7dc1464bbe4be0252836cbae4f6e0902.prob new file mode 100644 index 0000000..feb3db0 --- /dev/null +++ b/src/bin/.cph/.lc-1552.rs_7dc1464bbe4be0252836cbae4f6e0902.prob @@ -0,0 +1 @@ +{"name":"Local: lc-1552","url":"/home/user/RustIsBestLang/src/bin/lc-1552.rs","tests":[{"id":1703835090875,"input":"1 2 3 4 7\n3","output":"3"}],"interactive":false,"memoryLimit":1024,"timeLimit":3000,"srcPath":"/home/user/RustIsBestLang/src/bin/lc-1552.rs","group":"local","local":true} \ No newline at end of file diff --git a/src/bin/a.cc b/src/bin/a.cc new file mode 100644 index 0000000..f4c1b7f --- /dev/null +++ b/src/bin/a.cc @@ -0,0 +1,252 @@ +#pragma GCC optimize("Ofast") +///////////////////////////////////////////////////////// +/** + * Useful Macros + * by subcrip + * (requires C++17) + */ + +#include +#include +using namespace std; +using namespace __gnu_cxx; +using namespace __gnu_pbds; + +/* 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) decltype(container)::value_type + +/* type aliases */ +using ll = int64_t; +using ull = uint64_t; +using pii = pair; +using pil = pair; +using pli = pair; +using pll = pair; + +/* constants */ +constexpr int INF = 0x3f3f3f3f; +constexpr ull MDL = 1e9 + 7; +constexpr ull PRIME = 998'244'353; +constexpr ll MDL1 = 825; +constexpr ll MDL2 = PRIME; + +/* random */ + +mt19937 rd(chrono::duration_cast(chrono::system_clock::now().time_since_epoch()).count()); + +/* bit-wise operations */ +#define lowbit(x) ((x) & -(x)) +#define popcount(x) (__builtin_popcountll(ll(x))) +#define parity(x) (__builtin_parityll(ll(x))) +#define msp(x) (63LL - __builtin_clzll(ll(x))) +#define lsp(x) (__builtin_ctzll(ll(x))) + +/* arithmetic operations */ +#define mod(x, y) ((((x) % (y)) + (y)) % (y)) + +/* fast pairs */ +#define upair ull +#define umake(x, y) (ull(x) << 32 | (ull(y) & ((1ULL << 32) - 1))) +#define u1(p) ((p) >> 32) +#define u2(p) ((p) & ((1ULL << 32) - 1)) +#define ult std::less +#define ugt std::greater + +#define ipair ull +#define imake(x, y) (umake(x, y)) +#define i1(p) (int(u1(ll(p)))) +#define i2(p) (ll(u2(p) << 32) >> 32) +struct ilt { + bool operator()(const ipair& a, const ipair& b) const { + if (i1(a) == i1(b)) return i2(a) < i2(b); + else return i1(a) < i1(b); + } +}; +struct igt { + bool operator()(const ipair& a, const ipair& b) const { + if (i1(a) == i1(b)) return i2(a) > i2(b); + else return i1(a) > i1(b); + } +}; + +/* conditions */ +#define loop while (1) +#define if_or(var, val) if (!(var == val)) var = val; else +#define continue_or(var, val) __AS_PROCEDURE(if (var == val) continue; var = val;) +#define break_or(var, val) __AS_PROCEDURE(if (var == val) break; var = val;) + +/* hash */ +struct safe_hash { + // https://codeforces.com/blog/entry/62393 + static uint64_t splitmix64(uint64_t x) { + // http://xorshift.di.unimi.it/splitmix64.c + x += 0x9e3779b97f4a7c15; + x = (x ^ (x >> 30)) * 0xbf58476d1ce4e5b9; + x = (x ^ (x >> 27)) * 0x94d049bb133111eb; + return x ^ (x >> 31); + } + + size_t operator()(uint64_t x) const { + static const uint64_t FIXED_RANDOM = chrono::steady_clock::now().time_since_epoch().count(); + return splitmix64(x + FIXED_RANDOM); + } +}; + +struct pair_hash { + template + size_t operator()(const pair& a) const { + auto hash1 = safe_hash()(a.first); + auto hash2 = safe_hash()(a.second); + if (hash1 != hash2) { + return hash1 ^ hash2; + } + return hash1; + } +}; + +/* build data structures */ +#define unordered_counter(from, to) __AS_PROCEDURE(unordered_map<__as_typeof(from), size_t, safe_hash> to; for (auto&& x : from) ++to[x];) +#define counter(from, to, cmp) __AS_PROCEDURE(map<__as_typeof(from), size_t, cmp> to; for (auto&& x : from) ++to[x];) +#define pa(a) __AS_PROCEDURE(__typeof(a) pa; pa.push_back({}); for (auto&&x : a) pa.push_back(pa.back() + x);) +#define sa(a) __AS_PROCEDURE(__typeof(a) sa(a.size() + 1); {int n = a.size(); for (int i = n - 1; i >= 0; --i) sa[i] = sa[i + 1] + a[i];};) +#define adj(ch, n) __AS_PROCEDURE(vector> ch((n) + 1);) +#define edge(ch, u, v) __AS_PROCEDURE(ch[u].push_back(v), ch[v].push_back(u);) +#define Edge(ch, u, v) __AS_PROCEDURE(ch[u].push_back(v);) + +/* io */ +#define untie __AS_PROCEDURE(ios_base::sync_with_stdio(0), cin.tie(NULL)) +template void __read(T& x) { cin >> x; } +template void __read(T& x, U&... args) { cin >> x; __read(args...); } +#define read(type, ...) __AS_PROCEDURE(type __VA_ARGS__; __read(__VA_ARGS__);) +#define readvec(type, a, n) __AS_PROCEDURE(vector a(n); for (int i = 0; i < (n); ++i) cin >> a[i];) +#define putvec(a) __AS_PROCEDURE(for (auto&& x : a) cout << x << ' '; cout << endl;) +#define debug(x) __AS_PROCEDURE(cerr << #x" = " << (x) << endl;) +#define debugvec(a) __AS_PROCEDURE(cerr << #a" = "; for (auto&& x : a) cerr << x << ' '; cerr << endl;) +template ostream& operator<<(ostream& out, vector vec) { + for (auto&& i : vec) out << i << ' '; + return out; +} + +/* pops */ +#define poptop(q, ...) __AS_PROCEDURE(auto [__VA_ARGS__] = q.top(); q.pop();) +#define popback(q, ...) __AS_PROCEDURE(auto [__VA_ARGS__] = q.back(); q.pop_back();) +#define popfront(q, ...) __AS_PROCEDURE(auto [__VA_ARGS__] = q.front();q.pop_front();) + +/* math */ +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); +} + +/* string algorithms */ +vector calc_next(string t) { // pi function of t + int n = (int)t.length(); + vector pi(n); + for (int i = 1; i < n; i++) { + int j = pi[i - 1]; + while (j > 0 && t[i] != t[j]) j = pi[j - 1]; + if (t[i] == t[j]) j++; + pi[i] = j; + } + return pi; +} +vector calc_z(string t) { // z function of t + int m = t.length(); + vector z; + z.push_back(m); + pair prev = {1, -1}; + for (int i = 1; i < m; ++i) { + if (z[i - prev.first] + i <= prev.second) { + z.push_back(z[i - prev.first]); + } else { + int j = max(i, prev.second + 1); + while (j < m && t[j] == t[j - i]) ++j; + z.push_back(j - i); + prev = {i, j - 1}; + } + } + return z; +} +vector kmp(string s, string t) { // find all t in s + string cur = t + '#' + s; + int sz1 = s.size(), sz2 = t.size(); + vector v; + vector lps = calc_next(cur); + for (int i = sz2 + 1; i <= sz1 + sz2; i++) { + if (lps[i] == sz2) v.push_back(i - 2 * sz2); + } + return v; +} +int period(string s) { // find the length of shortest recurring period + int n = s.length(); + auto z = calc_z(s); + for (int i = 1; i <= n / 2; ++i) { + if (n % i == 0 && z[i] == n - i) { + return i; + } + } + return n; +} +///////////////////////////////////////////////////////// + +// #define SINGLE_TEST_CASE +// #define DUMP_TEST_CASE 512 + +void dump() {} + +void solve() { + read(int, n); + readvec(int, a, n); + int zer = 0; + for (int i = 0; i < n; ++i) { + if (a[i] == 1) { + int res = 0, zer = 0; + for (int j = i + 1; j < n; ++j) { + if (a[j] == 1) { + res += zer; + zer = 0; + } else { + zer += 1; + } + } + cout << res << endl; + return; + } + } + cout << 0 << endl; +} + +int main() { + untie, cout.tie(NULL); +#ifdef SINGLE_TEST_CASE + solve(); +#else + read(int, t); + for (int i = 0; i < t; ++i) { +#ifdef DUMP_TEST_CASE + if (i + 1 == (DUMP_TEST_CASE)) { + dump(); + } else { + solve(); + } +#else + solve(); +#endif + } +#endif +} diff --git a/src/bin/a.out b/src/bin/a.out new file mode 100755 index 0000000000000000000000000000000000000000..20c6d89f4abb765c58730f4f785d207e28e691bd GIT binary patch literal 398584 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ΰ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%0AiCelKSa9`tKo^gM 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 +using namespace std; +template +struct fenwick : std::vector<__Tp> { + size_t n; + fenwick(const size_t &_n) : std::vector<__Tp>(_n + 1), n(_n) {} + fenwick() {} + void update(const int &x, const __Tp &val) { + assert(x > 0); + for (int i = x; i <= n; i += i & -i) { + (*this)[i] += val; + } + } + __Tp query(const int &x, __Tp res = 0) { + assert(x >= 0); + for (int i = x; i; i -= i & -i) { + res += (*this)[i]; + } + return res; + } +}; +int main() { + cin.tie(nullptr)->sync_with_stdio(false); + + int n; + cin >> n; + + vector> g(n + 1); + for (int i = 1, u, v; i < n; i++) { + cin >> u >> v; + g[u].push_back(v); + g[v].push_back(u); + } + + vector F(n + 1), G(n + 1); + fenwick tr(n); + vector dep(n + 1), ls(n + 1, -1), l(n + 1), r(n + 1), id(n + 1), sz(n + 1); + int t = 0; + function dfs = [&](int x, int fa) { + l[x] = ++t; + id[t] = x; + dep[x] = dep[fa] + 1; + for (auto y : g[x]) { + if (y == fa) continue; + dfs(y, x); + sz[x] += sz[y]; + if (ls[x] == -1 || sz[y] > sz[ls[x]]) ls[x] = y; + } + sz[x]++; + r[x] = t; + }; + dfs(1, 0); + function solveF = [&](int x, int fa, int keep) { + cerr << "Calling solveF, x = " << x << ", fa = " << fa << ", keep = " << keep << endl; + for (auto y : g[x]) { + if (y != fa && y != ls[x]) { + solveF(y, x, 0); + } + } + if (ls[x] != -1) { + solveF(ls[x], x, 1); + } + for (auto y : g[x]) { + if (y == fa || y == ls[x]) continue; + for (int j = l[y]; j <= r[y]; j++) tr.update(id[j], 1); + } + tr.update(x, 1); + F[x] = tr.query(fa); + cerr << "Writing F[x] = " << F[x] << endl; + if (!keep) { + for (int j = l[x]; j <= r[x]; j++) { + tr.update(id[j], -1); + } + } + }; + function solveG = [&](int x, int fa, int keep) { + cerr << "Calling solveG, x = " << x << ", fa = " << fa << ", keep = " << keep << endl; + for (auto y : g[x]) { + if (y != fa && y != ls[x]) { + solveG(y, x, 0); + } + } + if (ls[x] != -1) { + solveG(ls[x], x, 1); + } + for (auto y : g[x]) { + if (y == fa || y == ls[x]) continue; + for (int j = l[y]; j <= r[y]; j++) tr.update(id[j], -1); + } + tr.update(x, -1); + G[x] = tr.query(x); + cerr << "Writing G[x] = " << G[x] << endl; + if (!keep) { + for (int j = l[x]; j <= r[x]; j++) { + tr.update(id[j], 1); + } + } + }; + + solveF(1, 0, 1); + solveG(1, 0, 1); + + fill(tr.begin(), tr.end(), 0); + vector f(n + 1); + function get = [&](int x, int fa) { + tr.update(x, 1); + for (auto y : g[x]) { + if (y == fa) { + continue; + } + get(y, x); + } + f[1] += dep[x] - tr.query(x); + tr.update(x, -1); + }; + function ans = [&](int x, int fa) { + f[x] += f[fa] - F[x] + G[x]; + // 父亲答案 - 当前子树比父亲小的元素个数 + 非当前子树比当前元素小的元素个数 + // 考虑当前元素的ans3，一定也是父亲的ans + // 考虑当前元素的ans2，要么是父亲的ans3，要么是其他子树中比当前元素小的元素 + // 考虑父亲的ans3，一定可以是当前元素的ans + // 考虑父亲的ans2，可能是当前子树比父亲小的元素，需要排除。 + for (auto y : g[x]) { + if (y == fa) { + continue; + } + ans(y, x); + } + }; + + get(1, 0); + ans(1, 0); + for (int i = 1; i <= n; i++) { + cout << F[i] << ' '; + } + cout << endl; + for (int i = 1; i <= n; i++) { + cout << G[i] << ' '; + } + cout << endl; + for (int i = 1; i <= n; i++) { + cout << f[i] << ' '; + } + return 0; +} \ No newline at end of file diff --git a/src/bin/b.cc b/src/bin/b.cc new file mode 100644 index 0000000..b1fb862 --- /dev/null +++ b/src/bin/b.cc @@ -0,0 +1,266 @@ +#pragma GCC optimize("Ofast") +///////////////////////////////////////////////////////// +/** + * Useful Macros + * by subcrip + * (requires C++17) + */ + +#include +#include +using namespace std; +using namespace __gnu_cxx; +using namespace __gnu_pbds; + +/* 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) decltype(container)::value_type + +/* type aliases */ +using ll = int64_t; +using ull = uint64_t; +using pii = pair; +using pil = pair; +using pli = pair; +using pll = pair; + +/* constants */ +constexpr int INF = 0x3f3f3f3f; +constexpr ull MDL = 1e9 + 7; +constexpr ull PRIME = 998'244'353; +constexpr ll MDL1 = 825; +constexpr ll MDL2 = PRIME; + +/* random */ + +mt19937 rd(chrono::duration_cast(chrono::system_clock::now().time_since_epoch()).count()); + +/* bit-wise operations */ +#define lowbit(x) ((x) & -(x)) +#define popcount(x) (__builtin_popcountll(ll(x))) +#define parity(x) (__builtin_parityll(ll(x))) +#define msp(x) (63LL - __builtin_clzll(ll(x))) +#define lsp(x) (__builtin_ctzll(ll(x))) + +/* arithmetic operations */ +#define mod(x, y) ((((x) % (y)) + (y)) % (y)) + +/* fast pairs */ +#define upair ull +#define umake(x, y) (ull(x) << 32 | (ull(y) & ((1ULL << 32) - 1))) +#define u1(p) ((p) >> 32) +#define u2(p) ((p) & ((1ULL << 32) - 1)) +#define ult std::less +#define ugt std::greater + +#define ipair ull +#define imake(x, y) (umake(x, y)) +#define i1(p) (int(u1(ll(p)))) +#define i2(p) (ll(u2(p) << 32) >> 32) +struct ilt { + bool operator()(const ipair& a, const ipair& b) const { + if (i1(a) == i1(b)) return i2(a) < i2(b); + else return i1(a) < i1(b); + } +}; +struct igt { + bool operator()(const ipair& a, const ipair& b) const { + if (i1(a) == i1(b)) return i2(a) > i2(b); + else return i1(a) > i1(b); + } +}; + +/* conditions */ +#define loop while (1) +#define if_or(var, val) if (!(var == val)) var = val; else +#define continue_or(var, val) __AS_PROCEDURE(if (var == val) continue; var = val;) +#define break_or(var, val) __AS_PROCEDURE(if (var == val) break; var = val;) + +/* hash */ +struct safe_hash { + // https://codeforces.com/blog/entry/62393 + static uint64_t splitmix64(uint64_t x) { + // http://xorshift.di.unimi.it/splitmix64.c + x += 0x9e3779b97f4a7c15; + x = (x ^ (x >> 30)) * 0xbf58476d1ce4e5b9; + x = (x ^ (x >> 27)) * 0x94d049bb133111eb; + return x ^ (x >> 31); + } + + size_t operator()(uint64_t x) const { + static const uint64_t FIXED_RANDOM = chrono::steady_clock::now().time_since_epoch().count(); + return splitmix64(x + FIXED_RANDOM); + } +}; + +struct pair_hash { + template + size_t operator()(const pair& a) const { + auto hash1 = safe_hash()(a.first); + auto hash2 = safe_hash()(a.second); + if (hash1 != hash2) { + return hash1 ^ hash2; + } + return hash1; + } +}; + +/* build data structures */ +#define unordered_counter(from, to) __AS_PROCEDURE(unordered_map<__as_typeof(from), size_t, safe_hash> to; for (auto&& x : from) ++to[x];) +#define counter(from, to, cmp) __AS_PROCEDURE(map<__as_typeof(from), size_t, cmp> to; for (auto&& x : from) ++to[x];) +#define pa(a) __AS_PROCEDURE(__typeof(a) pa; pa.push_back({}); for (auto&&x : a) pa.push_back(pa.back() + x);) +#define sa(a) __AS_PROCEDURE(__typeof(a) sa(a.size() + 1); {int n = a.size(); for (int i = n - 1; i >= 0; --i) sa[i] = sa[i + 1] + a[i];};) +#define adj(ch, n) __AS_PROCEDURE(vector> ch((n) + 1);) +#define edge(ch, u, v) __AS_PROCEDURE(ch[u].push_back(v), ch[v].push_back(u);) +#define Edge(ch, u, v) __AS_PROCEDURE(ch[u].push_back(v);) + +/* io */ +#define untie __AS_PROCEDURE(ios_base::sync_with_stdio(0), cin.tie(NULL)) +template void __read(T& x) { cin >> x; } +template void __read(T& x, U&... args) { cin >> x; __read(args...); } +#define read(type, ...) __AS_PROCEDURE(type __VA_ARGS__; __read(__VA_ARGS__);) +#define readvec(type, a, n) __AS_PROCEDURE(vector a(n); for (int i = 0; i < (n); ++i) cin >> a[i];) +#define putvec(a) __AS_PROCEDURE(for (auto&& x : a) cout << x << ' '; cout << endl;) +#define debug(x) __AS_PROCEDURE(cerr << #x" = " << (x) << endl;) +#define debugvec(a) __AS_PROCEDURE(cerr << #a" = "; for (auto&& x : a) cerr << x << ' '; cerr << endl;) +template ostream& operator<<(ostream& out, vector vec) { + for (auto&& i : vec) out << i << ' '; + return out; +} + +/* pops */ +#define poptop(q, ...) __AS_PROCEDURE(auto [__VA_ARGS__] = q.top(); q.pop();) +#define popback(q, ...) __AS_PROCEDURE(auto [__VA_ARGS__] = q.back(); q.pop_back();) +#define popfront(q, ...) __AS_PROCEDURE(auto [__VA_ARGS__] = q.front();q.pop_front();) + +/* math */ +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); +} + +/* string algorithms */ +vector calc_next(string t) { // pi function of t + int n = (int)t.length(); + vector pi(n); + for (int i = 1; i < n; i++) { + int j = pi[i - 1]; + while (j > 0 && t[i] != t[j]) j = pi[j - 1]; + if (t[i] == t[j]) j++; + pi[i] = j; + } + return pi; +} +vector calc_z(string t) { // z function of t + int m = t.length(); + vector z; + z.push_back(m); + pair prev = {1, -1}; + for (int i = 1; i < m; ++i) { + if (z[i - prev.first] + i <= prev.second) { + z.push_back(z[i - prev.first]); + } else { + int j = max(i, prev.second + 1); + while (j < m && t[j] == t[j - i]) ++j; + z.push_back(j - i); + prev = {i, j - 1}; + } + } + return z; +} +vector kmp(string s, string t) { // find all t in s + string cur = t + '#' + s; + int sz1 = s.size(), sz2 = t.size(); + vector v; + vector lps = calc_next(cur); + for (int i = sz2 + 1; i <= sz1 + sz2; i++) { + if (lps[i] == sz2) v.push_back(i - 2 * sz2); + } + return v; +} +int period(string s) { // find the length of shortest recurring period + int n = s.length(); + auto z = calc_z(s); + for (int i = 1; i <= n / 2; ++i) { + if (n % i == 0 && z[i] == n - i) { + return i; + } + } + return n; +} +///////////////////////////////////////////////////////// + +// #define SINGLE_TEST_CASE +// #define DUMP_TEST_CASE 512 + +void dump() {} + +void solve() { + read(int, n); + read(ll, k); + vector raw(n); + for (int i = 0; i < n; ++i) { + cin >> raw[i].first; + } + for (int i = 0; i < n; ++i) { + cin >> raw[i].second; + } + vector bucket(n + 1); + for (int i = 0; i < n; ++i) { + bucket[abs(raw[i].second)] += raw[i].first; + } + int r = 1; + for (int i = 0; i <= n; ++i) { + // debug(bucket[i]); + if (bucket[i] != 0) { + cout << "NO\n"; + return; + } + ll curr = k; + while (r <= n) { + if (bucket[r] > curr) { + bucket[r] -= curr; + break; + } else { + curr -= bucket[r]; + bucket[r] = 0; + r += 1; + } + } + } + cout << "YES\n"; +} + +int main() { + untie, cout.tie(NULL); +#ifdef SINGLE_TEST_CASE + solve(); +#else + read(int, t); + for (int i = 0; i < t; ++i) { +#ifdef DUMP_TEST_CASE + if (i + 1 == (DUMP_TEST_CASE)) { + dump(); + } else { + solve(); + } +#else + solve(); +#endif + } +#endif +} diff --git a/src/bin/c.cc b/src/bin/c.cc new file mode 100644 index 0000000..24c44f0 --- /dev/null +++ b/src/bin/c.cc @@ -0,0 +1,251 @@ +#pragma GCC optimize("Ofast") +///////////////////////////////////////////////////////// +/** + * Useful Macros + * by subcrip + * (requires C++17) + */ + +#include +#include +using namespace std; +using namespace __gnu_cxx; +using namespace __gnu_pbds; + +/* 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) decltype(container)::value_type + +/* type aliases */ +using ll = int64_t; +using ull = uint64_t; +using pii = pair; +using pil = pair; +using pli = pair; +using pll = pair; + +/* constants */ +constexpr int INF = 0x3f3f3f3f; +constexpr ull MDL = 1e9 + 7; +constexpr ull PRIME = 998'244'353; +constexpr ll MDL1 = 8784491; +constexpr ll MDL2 = PRIME; + +/* random */ + +mt19937 rd(chrono::duration_cast(chrono::system_clock::now().time_since_epoch()).count()); + +/* bit-wise operations */ +#define lowbit(x) ((x) & -(x)) +#define popcount(x) (__builtin_popcountll(ll(x))) +#define parity(x) (__builtin_parityll(ll(x))) +#define msp(x) (63LL - __builtin_clzll(ll(x))) +#define lsp(x) (__builtin_ctzll(ll(x))) + +/* arithmetic operations */ +#define mod(x, y) ((((x) % (y)) + (y)) % (y)) + +/* fast pairs */ +#define upair ull +#define umake(x, y) (ull(x) << 32 | (ull(y) & ((1ULL << 32) - 1))) +#define u1(p) ((p) >> 32) +#define u2(p) ((p) & ((1ULL << 32) - 1)) +#define ult std::less +#define ugt std::greater + +#define ipair ull +#define imake(x, y) (umake(x, y)) +#define i1(p) (int(u1(ll(p)))) +#define i2(p) (ll(u2(p) << 32) >> 32) +struct ilt { + bool operator()(const ipair& a, const ipair& b) const { + if (i1(a) == i1(b)) return i2(a) < i2(b); + else return i1(a) < i1(b); + } +}; +struct igt { + bool operator()(const ipair& a, const ipair& b) const { + if (i1(a) == i1(b)) return i2(a) > i2(b); + else return i1(a) > i1(b); + } +}; + +/* conditions */ +#define loop while (1) +#define if_or(var, val) if (!(var == val)) var = val; else +#define continue_or(var, val) __AS_PROCEDURE(if (var == val) continue; var = val;) +#define break_or(var, val) __AS_PROCEDURE(if (var == val) break; var = val;) + +/* hash */ +struct safe_hash { + // https://codeforces.com/blog/entry/62393 + static uint64_t splitmix64(uint64_t x) { + // http://xorshift.di.unimi.it/splitmix64.c + x += 0x9e3779b97f4a7c15; + x = (x ^ (x >> 30)) * 0xbf58476d1ce4e5b9; + x = (x ^ (x >> 27)) * 0x94d049bb133111eb; + return x ^ (x >> 31); + } + + size_t operator()(uint64_t x) const { + static const uint64_t FIXED_RANDOM = chrono::steady_clock::now().time_since_epoch().count(); + return splitmix64(x + FIXED_RANDOM); + } +}; + +struct pair_hash { + template + size_t operator()(const pair& a) const { + auto hash1 = safe_hash()(a.first); + auto hash2 = safe_hash()(a.second); + if (hash1 != hash2) { + return hash1 ^ hash2; + } + return hash1; + } +}; + +/* build data structures */ +#define unordered_counter(from, to) __AS_PROCEDURE(unordered_map<__as_typeof(from), size_t, safe_hash> to; for (auto&& x : from) ++to[x];) +#define counter(from, to, cmp) __AS_PROCEDURE(map<__as_typeof(from), size_t, cmp> to; for (auto&& x : from) ++to[x];) +#define pa(a) __AS_PROCEDURE(__typeof(a) pa; pa.push_back({}); for (auto&&x : a) pa.push_back(pa.back() + x);) +#define sa(a) __AS_PROCEDURE(__typeof(a) sa(a.size() + 1); {int n = a.size(); for (int i = n - 1; i >= 0; --i) sa[i] = sa[i + 1] + a[i];};) +#define adj(ch, n) __AS_PROCEDURE(vector> ch((n) + 1);) +#define edge(ch, u, v) __AS_PROCEDURE(ch[u].push_back(v), ch[v].push_back(u);) +#define Edge(ch, u, v) __AS_PROCEDURE(ch[u].push_back(v);) + +/* io */ +#define untie __AS_PROCEDURE(ios_base::sync_with_stdio(0), cin.tie(NULL)) +template void __read(T& x) { cin >> x; } +template void __read(T& x, U&... args) { cin >> x; __read(args...); } +#define read(type, ...) __AS_PROCEDURE(type __VA_ARGS__; __read(__VA_ARGS__);) +#define readvec(type, a, n) __AS_PROCEDURE(vector a(n); for (int i = 0; i < (n); ++i) cin >> a[i];) +#define putvec(a) __AS_PROCEDURE(for (auto&& x : a) cout << x << ' '; cout << endl;) +#define debug(x) __AS_PROCEDURE(cerr << #x" = " << (x) << endl;) +#define debugvec(a) __AS_PROCEDURE(cerr << #a" = "; for (auto&& x : a) cerr << x << ' '; cerr << endl;) +template ostream& operator<<(ostream& out, vector vec) { + for (auto&& i : vec) out << i << ' '; + return out; +} + +/* pops */ +#define poptop(q, ...) __AS_PROCEDURE(auto [__VA_ARGS__] = q.top(); q.pop();) +#define popback(q, ...) __AS_PROCEDURE(auto [__VA_ARGS__] = q.back(); q.pop_back();) +#define popfront(q, ...) __AS_PROCEDURE(auto [__VA_ARGS__] = q.front();q.pop_front();) + +/* math */ +constexpr inline int lg2(ll x) { return x == 0 ? -1 : sizeof(ll) * 8 - 1 - __builtin_clzll(x); } + +void __exgcd(ll a, ll b, ll& x, ll& y) { + if (b == 0) { + x = 1, y = 0; + return; + } + __exgcd(b, a % b, y, x); + y -= a / b * x; +} + +ll inverse(ll a, ll b) { + ll x, y; + __exgcd(a, b, x, y); + return mod(x, b); +} + +/* string algorithms */ +vector calc_next(string t) { // pi function of t + int n = (int)t.length(); + vector pi(n); + for (int i = 1; i < n; i++) { + int j = pi[i - 1]; + while (j > 0 && t[i] != t[j]) j = pi[j - 1]; + if (t[i] == t[j]) j++; + pi[i] = j; + } + return pi; +} +vector calc_z(string t) { // z function of t + int m = t.length(); + vector z; + z.push_back(m); + pair prev = {1, -1}; + for (int i = 1; i < m; ++i) { + if (z[i - prev.first] + i <= prev.second) { + z.push_back(z[i - prev.first]); + } else { + int j = max(i, prev.second + 1); + while (j < m && t[j] == t[j - i]) ++j; + z.push_back(j - i); + prev = {i, j - 1}; + } + } + return z; +} +vector kmp(string s, string t) { // find all t in s + string cur = t + '#' + s; + int sz1 = s.size(), sz2 = t.size(); + vector v; + vector lps = calc_next(cur); + for (int i = sz2 + 1; i <= sz1 + sz2; i++) { + if (lps[i] == sz2) v.push_back(i - 2 * sz2); + } + return v; +} +int period(string s) { // find the length of shortest recurring period + int n = s.length(); + auto z = calc_z(s); + for (int i = 1; i <= n / 2; ++i) { + if (n % i == 0 && z[i] == n - i) { + return i; + } + } + return n; +} +///////////////////////////////////////////////////////// + + +// #define SINGLE_TEST_CASE +// #define DUMP_TEST_CASE 512 + +void dump() {} + +void solve() { + read(int, n, q); + readvec(int, a, n); + vector cnt1(n + 1), ps(n + 1); + for (int i = 1; i <= n; ++i) { + cnt1[i] = cnt1[i - 1] + (a[i - 1] == 1); + ps[i] = ps[i - 1] + a[i - 1]; + } + while (q--) { + read(int, l, r); + if (l != r && ps[r] - ps[l - 1] - cnt1[r] + cnt1[l - 1] >= r - l + 1) { + cout << "YES\n"; + } else { + cout << "NO\n"; + } + } +} + +int main() { + untie, cout.tie(NULL); +#ifdef SINGLE_TEST_CASE + solve(); +#else + read(int, t); + for (int i = 0; i < t; ++i) { +#ifdef DUMP_TEST_CASE + if (i + 1 == (DUMP_TEST_CASE)) { + dump(); + } else { + solve(); + } +#else + solve(); +#endif + } +#endif +} diff --git a/src/bin/cf-1245c.cc b/src/bin/cf-1245c.cc new file mode 100644 index 0000000..50983f5 --- /dev/null +++ b/src/bin/cf-1245c.cc @@ -0,0 +1,43 @@ +#include +using namespace std; +using ull = uint64_t; + +constexpr int MAXN = 1e5 + 10; +constexpr ull mdl = 1e9 + 7; + +ull table[MAXN + 1]; + +void prep() { + ull l1 = 1, l2 = 0; + for (int i = 0; i < MAXN + 1; ++i) { + table[i] = (l1 + l2) % mdl; + l1 = l2; + l2 = table[i]; + } +} + +int main() { + prep(); + string s; cin >> s; + s.push_back(0); + ull res = 1; + int acc = 0; + char prev = 0; + for (auto&& c : s) { + if (c == 'w' || c == 'm') { + goto zero; + } + if (c != prev) { + if (prev == 'u' || prev == 'n') { + res = (res * (table[acc] % mdl)) % mdl; + } + acc = 1; + prev = c; + } else { + ++acc; + } + } + cout << res; + return 0; + zero: cout << '0'; +} \ No newline at end of file diff --git a/src/bin/cf-1656c.cc b/src/bin/cf-1656c.cc new file mode 100644 index 0000000..bd2b1fd --- /dev/null +++ b/src/bin/cf-1656c.cc @@ -0,0 +1,175 @@ +///////////////////////////////////////////////////////// +/** + * Useful Macros + * by subcrip + * (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) decltype(container)::value_type + +/* type aliases */ +using ll = int64_t; +using ull = uint64_t; +using pii = pair; +using pil = pair; +using pli = pair; +using pll = pair; + +/* constants */ +constexpr int INF = 0x3f3f3f3f; +constexpr ull MDL = 1e9 + 7; +constexpr ull PRIME = 998'244'353; +constexpr ull MDL1 = 825; +constexpr ull MDL2 = 87825; + +/* 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)) + +/* fast pairs */ +#define upair ull +#define umake(x, y) (ull(x) << 32 | ull(y)) +#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(p))) +#define i2(p) (int(u2(p))) +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;) + +/* build data structures */ +#define unordered_counter(from, to) __AS_PROCEDURE(unordered_map<__as_typeof(from), size_t> to; for (auto&& x : from) ++to[x];) +#define counter(from, to, cmp) __AS_PROCEDURE(map<__as_typeof(from), size_t, cmp> to; for (auto&& x : from) ++to[x];) +#define pa(a) __AS_PROCEDURE(__typeof(a) pa; pa.push_back({}); for (auto&&x : a) pa.push_back(pa.back() + x);) +#define sa(a) __AS_PROCEDURE(__typeof(a) sa(a.size() + 1); {int n = a.size(); for (int i = n - 1; i >= 0; --i) sa[i] = sa[i + 1] + a[i];};) +#define adj(ch, n) __AS_PROCEDURE(vector> ch((n) + 1);) +#define edge(ch, u, v) __AS_PROCEDURE(ch[u].push_back(v), ch[v].push_back(u);) +#define Edge(ch, u, v) __AS_PROCEDURE(ch[u].push_back(v);) + +/* io */ +#define untie __AS_PROCEDURE(ios_base::sync_with_stdio(0), cin.tie(NULL)) +template void __read(T& x) { cin >> x; } +template void __read(T& x, U&... args) { cin >> x; __read(args...); } +#define read(type, ...) __AS_PROCEDURE(type __VA_ARGS__; __read(__VA_ARGS__);) +#define readvec(type, a, n) __AS_PROCEDURE(vector a(n); for (int i = 0; i < (n); ++i) cin >> a[i];) +#define putvec(a) __AS_PROCEDURE(for (auto&& x : a) cout << x << ' '; cout << endl;) +#define debug(x) __AS_PROCEDURE(cerr << #x" = " << (x) << endl;) +#define debugvec(a) __AS_PROCEDURE(cerr << #a" = "; for (auto&& x : a) cerr << x << ' '; cerr << endl;) +template ostream& operator<<(ostream& out, vector vec) { + for (auto&& i : vec) out << i << ' '; + return out; +} + +/* pops */ +#define poptop(q, ...) __AS_PROCEDURE(auto [__VA_ARGS__] = q.top(); q.pop();) +#define popback(q, ...) __AS_PROCEDURE(auto [__VA_ARGS__] = q.back(); q.pop_back();) +#define popfront(q, ...) __AS_PROCEDURE(auto [__VA_ARGS__] = q.front();q.pop_front();) + +/* algorithms */ + +vector calc_next(string t) { // pi function of t + int n = (int)t.length(); + vector pi(n); + for (int i = 1; i < n; i++) { + int j = pi[i - 1]; + while (j > 0 && t[i] != t[j]) j = pi[j - 1]; + if (t[i] == t[j]) j++; + pi[i] = j; + } + return pi; +} +vector calc_z(string t) { // z function of t + int m = t.length(); + vector z; + z.push_back(m); + pair prev = {1, -1}; + for (int i = 1; i < m; ++i) { + if (z[i - prev.first] + i <= prev.second) { + z.push_back(z[i - prev.first]); + } else { + int j = max(i, prev.second + 1); + while (j < m && t[j] == t[j - i]) ++j; + z.push_back(j - i); + prev = {i, j - 1}; + } + } + return z; +} +vector kmp(string s, string t) { // find all t in s + string cur = t + '#' + s; + int sz1 = s.size(), sz2 = t.size(); + vector v; + vector lps = calc_next(cur); + for (int i = sz2 + 1; i <= sz1 + sz2; i++) { + if (lps[i] == sz2) v.push_back(i - 2 * sz2); + } + return v; +} +int period(string s) { // find the length of shortest recurring period + int n = s.length(); + auto z = calc_z(s); + for (int i = 1; i <= n / 2; ++i) { + if (n % i == 0 && z[i] == n - i) { + return i; + } + } + return n; +} +///////////////////////////////////////////////////////// + + +void solve() { + read(int, n); + readvec(int, a, n); + sort(a.begin(), a.end()); + if (count(a.begin(), a.end(), 1)) { + for (int i = 1; i < n; ++i) { + if (a[i] - a[i-1] == 1) { + cout << "NO\n"; + return; + } + } + cout << "YES\n"; + } else { + cout << "YES\n"; + } +} +int main() { + read(int, t); + while (t--) solve(); +} \ No newline at end of file diff --git a/src/bin/cf-1700d.cc b/src/bin/cf-1700d.cc new file mode 100644 index 0000000..3496479 --- /dev/null +++ b/src/bin/cf-1700d.cc @@ -0,0 +1,259 @@ +#pragma GCC optimize("Ofast") +///////////////////////////////////////////////////////// +/** + * Useful Macros + * by subcrip + * (requires C++17) + */ + +#include +#include +using namespace std; +using namespace __gnu_cxx; +using namespace __gnu_pbds; + +/* 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) decltype(container)::value_type + +/* type aliases */ +using ll = int64_t; +using ull = uint64_t; +using pii = pair; +using pil = pair; +using pli = pair; +using pll = pair; + +/* constants */ +constexpr int INF = 0x3f3f3f3f; +constexpr ll INFLL = 0x3f3f3f3f3f3f3f3fLL; +constexpr ull MDL = 1e9 + 7; +constexpr ull PRIME = 998'244'353; +constexpr ll MDL1 = 8784491; +constexpr ll MDL2 = PRIME; + +/* random */ + +mt19937 rd(chrono::duration_cast(chrono::system_clock::now().time_since_epoch()).count()); + +/* bit-wise operations */ +#define lowbit(x) ((x) & -(x)) +#define popcount(x) (__builtin_popcountll(ll(x))) +#define parity(x) (__builtin_parityll(ll(x))) +#define msp(x) (63LL - __builtin_clzll(ll(x))) +#define lsp(x) (__builtin_ctzll(ll(x))) + +/* arithmetic operations */ +#define mod(x, y) ((((x) % (y)) + (y)) % (y)) + +/* fast pairs */ +#define upair ull +#define umake(x, y) (ull(x) << 32 | (ull(y) & ((1ULL << 32) - 1))) +#define u1(p) ((p) >> 32) +#define u2(p) ((p) & ((1ULL << 32) - 1)) +#define ult std::less +#define ugt std::greater + +#define ipair ull +#define imake(x, y) (umake(x, y)) +#define i1(p) (int(u1(ll(p)))) +#define i2(p) (ll(u2(p) << 32) >> 32) +struct ilt { + bool operator()(const ipair& a, const ipair& b) const { + if (i1(a) == i1(b)) return i2(a) < i2(b); + else return i1(a) < i1(b); + } +}; +struct igt { + bool operator()(const ipair& a, const ipair& b) const { + if (i1(a) == i1(b)) return i2(a) > i2(b); + else return i1(a) > i1(b); + } +}; + +/* conditions */ +#define loop while (1) +#define if_or(var, val) if (!(var == val)) var = val; else +#define continue_or(var, val) __AS_PROCEDURE(if (var == val) continue; var = val;) +#define break_or(var, val) __AS_PROCEDURE(if (var == val) break; var = val;) + +/* hash */ +struct safe_hash { + // https://codeforces.com/blog/entry/62393 + static uint64_t splitmix64(uint64_t x) { + // http://xorshift.di.unimi.it/splitmix64.c + x += 0x9e3779b97f4a7c15; + x = (x ^ (x >> 30)) * 0xbf58476d1ce4e5b9; + x = (x ^ (x >> 27)) * 0x94d049bb133111eb; + return x ^ (x >> 31); + } + + size_t operator()(uint64_t x) const { + static const uint64_t FIXED_RANDOM = chrono::steady_clock::now().time_since_epoch().count(); + return splitmix64(x + FIXED_RANDOM); + } +}; + +struct pair_hash { + template + size_t operator()(const pair& a) const { + auto hash1 = safe_hash()(a.first); + auto hash2 = safe_hash()(a.second); + if (hash1 != hash2) { + return hash1 ^ hash2; + } + return hash1; + } +}; + +/* build data structures */ +#define unordered_counter(from, to) __AS_PROCEDURE(unordered_map<__as_typeof(from), size_t, safe_hash> to; for (auto&& x : from) ++to[x];) +#define counter(from, to, cmp) __AS_PROCEDURE(map<__as_typeof(from), size_t, cmp> to; for (auto&& x : from) ++to[x];) +#define pa(a) __AS_PROCEDURE(__typeof(a) pa; pa.push_back({}); for (auto&&x : a) pa.push_back(pa.back() + x);) +#define sa(a) __AS_PROCEDURE(__typeof(a) sa(a.size() + 1); {int n = a.size(); for (int i = n - 1; i >= 0; --i) sa[i] = sa[i + 1] + a[i];};) +#define adj(ch, n) __AS_PROCEDURE(vector> ch((n) + 1);) +#define edge(ch, u, v) __AS_PROCEDURE(ch[u].push_back(v), ch[v].push_back(u);) +#define Edge(ch, u, v) __AS_PROCEDURE(ch[u].push_back(v);) + +/* io */ +#define untie __AS_PROCEDURE(ios_base::sync_with_stdio(0), cin.tie(NULL)) +template void __read(T& x) { cin >> x; } +template void __read(T& x, U&... args) { cin >> x; __read(args...); } +#define read(type, ...) __AS_PROCEDURE(type __VA_ARGS__; __read(__VA_ARGS__);) +#define readvec(type, a, n) __AS_PROCEDURE(vector a(n); for (int i = 0; i < (n); ++i) cin >> a[i];) +#define putvec(a) __AS_PROCEDURE(for (auto&& x : a) cout << x << ' '; cout << endl;) +#define debug(x) __AS_PROCEDURE(cerr << #x" = " << (x) << endl;) +#define debugvec(a) __AS_PROCEDURE(cerr << #a" = "; for (auto&& x : a) cerr << x << ' '; cerr << endl;) +template ostream& operator<<(ostream& out, vector vec) { + for (auto&& i : vec) out << i << ' '; + return out; +} + +/* pops */ +#define poptop(q, ...) __AS_PROCEDURE(auto [__VA_ARGS__] = q.top(); q.pop();) +#define popback(q, ...) __AS_PROCEDURE(auto [__VA_ARGS__] = q.back(); q.pop_back();) +#define popfront(q, ...) __AS_PROCEDURE(auto [__VA_ARGS__] = q.front();q.pop_front();) + +/* math */ +constexpr inline int lg2(ll x) { return x == 0 ? -1 : sizeof(ll) * 8 - 1 - __builtin_clzll(x); } + +void __exgcd(ll a, ll b, ll& x, ll& y) { + if (b == 0) { + x = 1, y = 0; + return; + } + __exgcd(b, a % b, y, x); + y -= a / b * x; +} + +ll inverse(ll a, ll b) { + ll x, y; + __exgcd(a, b, x, y); + return mod(x, b); +} + +/* string algorithms */ +vector calc_next(string t) { // pi function of t + int n = (int)t.length(); + vector pi(n); + for (int i = 1; i < n; i++) { + int j = pi[i - 1]; + while (j > 0 && t[i] != t[j]) j = pi[j - 1]; + if (t[i] == t[j]) j++; + pi[i] = j; + } + return pi; +} +vector calc_z(string t) { // z function of t + int m = t.length(); + vector z; + z.push_back(m); + pair prev = {1, -1}; + for (int i = 1; i < m; ++i) { + if (z[i - prev.first] + i <= prev.second) { + z.push_back(z[i - prev.first]); + } else { + int j = max(i, prev.second + 1); + while (j < m && t[j] == t[j - i]) ++j; + z.push_back(j - i); + prev = {i, j - 1}; + } + } + return z; +} +vector kmp(string s, string t) { // find all t in s + string cur = t + '#' + s; + int sz1 = s.size(), sz2 = t.size(); + vector v; + vector lps = calc_next(cur); + for (int i = sz2 + 1; i <= sz1 + sz2; i++) { + if (lps[i] == sz2) v.push_back(i - 2 * sz2); + } + return v; +} +int period(string s) { // find the length of shortest recurring period + int n = s.length(); + auto z = calc_z(s); + for (int i = 1; i <= n / 2; ++i) { + if (n % i == 0 && z[i] == n - i) { + return i; + } + } + return n; +} +///////////////////////////////////////////////////////// + + +#define SINGLE_TEST_CASE +// #define DUMP_TEST_CASE 512 + +void dump() {} + +void solve() { + read(int, n); + readvec(int, a, n); + vector p(n); + ll sum = 0; + for (int i = 0; i < n; ++i ) { + sum += a[i]; + p[i] = (sum + i) / (i + 1); + } + vector pre_max(n + 1); + for (int i = 1; i <= n; ++i) { + pre_max[i] = max(pre_max[i - 1], p[i - 1]); + } + read(int, q); + while (q--) { + read(ll, t); + ll x = (sum + t - 1) / t; + if (x > n || pre_max[x] > t) { + cout << -1 << endl; + } else { + cout << x << endl; + } + } +} + +int main() { + untie, cout.tie(NULL); +#ifdef SINGLE_TEST_CASE + solve(); +#else + read(int, t); + for (int i = 0; i < t; ++i) { +#ifdef DUMP_TEST_CASE + if (i + 1 == (DUMP_TEST_CASE)) { + dump(); + } else { + solve(); + } +#else + solve(); +#endif + } +#endif +} diff --git a/src/bin/cf-1715d.cc b/src/bin/cf-1715d.cc new file mode 100644 index 0000000..3509904 --- /dev/null +++ b/src/bin/cf-1715d.cc @@ -0,0 +1,278 @@ +#pragma GCC optimize("Ofast") +///////////////////////////////////////////////////////// +/** + * Useful Macros + * by subcrip + * (requires C++17) + */ + +#include +#include +using namespace std; +using namespace __gnu_cxx; +using namespace __gnu_pbds; + +/* 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) decltype(container)::value_type + +/* type aliases */ +using ll = int64_t; +using ull = uint64_t; +using pii = pair; +using pil = pair; +using pli = pair; +using pll = pair; + +/* constants */ +constexpr int INF = 0x3f3f3f3f; +constexpr ull MDL = 1e9 + 7; +constexpr ull PRIME = 998'244'353; +constexpr ll MDL1 = 825; +constexpr ll MDL2 = PRIME; + +/* random */ + +mt19937 rd(chrono::duration_cast(chrono::system_clock::now().time_since_epoch()).count()); + +/* bit-wise operations */ +#define lowbit(x) ((x) & -(x)) +#define popcount(x) (__builtin_popcountll(ll(x))) +#define parity(x) (__builtin_parityll(ll(x))) +#define msp(x) (63LL - __builtin_clzll(ll(x))) +#define lsp(x) (__builtin_ctzll(ll(x))) + +/* arithmetic operations */ +#define mod(x, y) ((((x) % (y)) + (y)) % (y)) + +/* fast pairs */ +#define upair ull +#define umake(x, y) (ull(x) << 32 | (ull(y) & ((1ULL << 32) - 1))) +#define u1(p) ((p) >> 32) +#define u2(p) ((p) & ((1ULL << 32) - 1)) +#define ult std::less +#define ugt std::greater + +#define ipair ull +#define imake(x, y) (umake(x, y)) +#define i1(p) (int(u1(ll(p)))) +#define i2(p) (ll(u2(p) << 32) >> 32) +struct ilt { + bool operator()(const ipair& a, const ipair& b) const { + if (i1(a) == i1(b)) return i2(a) < i2(b); + else return i1(a) < i1(b); + } +}; +struct igt { + bool operator()(const ipair& a, const ipair& b) const { + if (i1(a) == i1(b)) return i2(a) > i2(b); + else return i1(a) > i1(b); + } +}; + +/* conditions */ +#define loop while (1) +#define if_or(var, val) if (!(var == val)) var = val; else +#define continue_or(var, val) __AS_PROCEDURE(if (var == val) continue; var = val;) +#define break_or(var, val) __AS_PROCEDURE(if (var == val) break; var = val;) + +/* hash */ +struct safe_hash { + // https://codeforces.com/blog/entry/62393 + static uint64_t splitmix64(uint64_t x) { + // http://xorshift.di.unimi.it/splitmix64.c + x += 0x9e3779b97f4a7c15; + x = (x ^ (x >> 30)) * 0xbf58476d1ce4e5b9; + x = (x ^ (x >> 27)) * 0x94d049bb133111eb; + return x ^ (x >> 31); + } + + size_t operator()(uint64_t x) const { + static const uint64_t FIXED_RANDOM = chrono::steady_clock::now().time_since_epoch().count(); + return splitmix64(x + FIXED_RANDOM); + } +}; + +struct pair_hash { + template + size_t operator()(const pair& a) const { + auto hash1 = safe_hash()(a.first); + auto hash2 = safe_hash()(a.second); + if (hash1 != hash2) { + return hash1 ^ hash2; + } + return hash1; + } +}; + +/* build data structures */ +#define unordered_counter(from, to) __AS_PROCEDURE(unordered_map<__as_typeof(from), size_t, safe_hash> to; for (auto&& x : from) ++to[x];) +#define counter(from, to, cmp) __AS_PROCEDURE(map<__as_typeof(from), size_t, cmp> to; for (auto&& x : from) ++to[x];) +#define pa(a) __AS_PROCEDURE(__typeof(a) pa; pa.push_back({}); for (auto&&x : a) pa.push_back(pa.back() + x);) +#define sa(a) __AS_PROCEDURE(__typeof(a) sa(a.size() + 1); {int n = a.size(); for (int i = n - 1; i >= 0; --i) sa[i] = sa[i + 1] + a[i];};) +#define adj(ch, n) __AS_PROCEDURE(vector> ch((n) + 1);) +#define edge(ch, u, v) __AS_PROCEDURE(ch[u].push_back(v), ch[v].push_back(u);) +#define Edge(ch, u, v) __AS_PROCEDURE(ch[u].push_back(v);) + +/* io */ +#define untie __AS_PROCEDURE(ios_base::sync_with_stdio(0), cin.tie(NULL)) +template void __read(T& x) { cin >> x; } +template void __read(T& x, U&... args) { cin >> x; __read(args...); } +#define read(type, ...) __AS_PROCEDURE(type __VA_ARGS__; __read(__VA_ARGS__);) +#define readvec(type, a, n) __AS_PROCEDURE(vector a(n); for (int i = 0; i < (n); ++i) cin >> a[i];) +#define putvec(a) __AS_PROCEDURE(for (auto&& x : a) cout << x << ' '; cout << endl;) +#define debug(x) __AS_PROCEDURE(cerr << #x" = " << (x) << endl;) +#define debugvec(a) __AS_PROCEDURE(cerr << #a" = "; for (auto&& x : a) cerr << x << ' '; cerr << endl;) +template ostream& operator<<(ostream& out, vector vec) { + for (auto&& i : vec) out << i << ' '; + return out; +} + +/* pops */ +#define poptop(q, ...) __AS_PROCEDURE(auto [__VA_ARGS__] = q.top(); q.pop();) +#define popback(q, ...) __AS_PROCEDURE(auto [__VA_ARGS__] = q.back(); q.pop_back();) +#define popfront(q, ...) __AS_PROCEDURE(auto [__VA_ARGS__] = q.front();q.pop_front();) + +/* math */ +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); +} + +/* string algorithms */ +vector calc_next(string t) { // pi function of t + int n = (int)t.length(); + vector pi(n); + for (int i = 1; i < n; i++) { + int j = pi[i - 1]; + while (j > 0 && t[i] != t[j]) j = pi[j - 1]; + if (t[i] == t[j]) j++; + pi[i] = j; + } + return pi; +} +vector calc_z(string t) { // z function of t + int m = t.length(); + vector z; + z.push_back(m); + pair prev = {1, -1}; + for (int i = 1; i < m; ++i) { + if (z[i - prev.first] + i <= prev.second) { + z.push_back(z[i - prev.first]); + } else { + int j = max(i, prev.second + 1); + while (j < m && t[j] == t[j - i]) ++j; + z.push_back(j - i); + prev = {i, j - 1}; + } + } + return z; +} +vector kmp(string s, string t) { // find all t in s + string cur = t + '#' + s; + int sz1 = s.size(), sz2 = t.size(); + vector v; + vector lps = calc_next(cur); + for (int i = sz2 + 1; i <= sz1 + sz2; i++) { + if (lps[i] == sz2) v.push_back(i - 2 * sz2); + } + return v; +} +int period(string s) { // find the length of shortest recurring period + int n = s.length(); + auto z = calc_z(s); + for (int i = 1; i <= n / 2; ++i) { + if (n % i == 0 && z[i] == n - i) { + return i; + } + } + return n; +} +///////////////////////////////////////////////////////// + +#define SINGLE_TEST_CASE +// #define DUMP_TEST_CASE 512 + +void dump() {} + +void solve() { + read(int, n, q); + vector> r(q); + vector> tb(n); + for (int i = 0; i < n; ++i) { + fill(tb[i].begin(), tb[i].end(), -1); + } + for (int i = 0; i < q; ++i) { + read(int, x, y, z); + r[i] = {minmax(x - 1, y - 1), z}; + } + auto get = [] (int x, int b) -> int { + return (x >> b) & 1; + }; + for (int b = 0; b <= 30; ++b) { + vector> ch(n); + // process all-zeros + for (int i = 0; i < q; ++i) { + auto [j, k] = r[i].first; + if (get(r[i].second, b) == 0) { + tb[j][b] = tb[k][b] = 0; + } else { + ch[j].push_back(k); + ch[k].push_back(j); + } + } + for (int i = 0; i < n; ++i) { + int must = 0; + for (auto&& u : ch[i]) { + if (u == i || tb[u][b] == 0) { + must = 1; + break; + } + } + tb[i][b] = must; + } + } + vector res(n); + for (int i = 0; i < n; ++i) { + for (int b = 0; b <= 30; ++b) { + if (tb[i][b] == 1) { + res[i] |= 1 << b; + } + } + } + putvec(res); +} + +int main() { + untie, cout.tie(NULL); +#ifdef SINGLE_TEST_CASE + solve(); +#else + read(int, t); + for (int i = 0; i < t; ++i) { +#ifdef DUMP_TEST_CASE + if (i + 1 == (DUMP_TEST_CASE)) { + dump(); + } else { + solve(); + } +#else + solve(); +#endif + } +#endif +} diff --git a/src/bin/cf-1739d.cc b/src/bin/cf-1739d.cc new file mode 100644 index 0000000..e202468 --- /dev/null +++ b/src/bin/cf-1739d.cc @@ -0,0 +1,269 @@ +#pragma GCC optimize("Ofast") +///////////////////////////////////////////////////////// +/** + * Useful Macros + * by subcrip + * (requires C++17) + */ + +#include +#include +using namespace std; +using namespace __gnu_cxx; +using namespace __gnu_pbds; + +/* 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) decltype(container)::value_type + +/* type aliases */ +using ll = int64_t; +using ull = uint64_t; +using pii = pair; +using pil = pair; +using pli = pair; +using pll = pair; + +/* constants */ +constexpr int INF = 0x3f3f3f3f; +constexpr ll INFLL = 0x3f3f3f3f3f3f3f3fLL; +constexpr ull MDL = 1e9 + 7; +constexpr ull PRIME = 998'244'353; +constexpr ll MDL1 = 8784491; +constexpr ll MDL2 = PRIME; + +/* random */ + +mt19937 rd(chrono::duration_cast(chrono::system_clock::now().time_since_epoch()).count()); + +/* bit-wise operations */ +#define lowbit(x) ((x) & -(x)) +#define popcount(x) (__builtin_popcountll(ll(x))) +#define parity(x) (__builtin_parityll(ll(x))) +#define msp(x) (63LL - __builtin_clzll(ll(x))) +#define lsp(x) (__builtin_ctzll(ll(x))) + +/* arithmetic operations */ +#define mod(x, y) ((((x) % (y)) + (y)) % (y)) + +/* fast pairs */ +#define upair ull +#define umake(x, y) (ull(x) << 32 | (ull(y) & ((1ULL << 32) - 1))) +#define u1(p) ((p) >> 32) +#define u2(p) ((p) & ((1ULL << 32) - 1)) +#define ult std::less +#define ugt std::greater + +#define ipair ull +#define imake(x, y) (umake(x, y)) +#define i1(p) (int(u1(ll(p)))) +#define i2(p) (ll(u2(p) << 32) >> 32) +struct ilt { + bool operator()(const ipair& a, const ipair& b) const { + if (i1(a) == i1(b)) return i2(a) < i2(b); + else return i1(a) < i1(b); + } +}; +struct igt { + bool operator()(const ipair& a, const ipair& b) const { + if (i1(a) == i1(b)) return i2(a) > i2(b); + else return i1(a) > i1(b); + } +}; + +/* conditions */ +#define loop while (1) +#define if_or(var, val) if (!(var == val)) var = val; else +#define continue_or(var, val) __AS_PROCEDURE(if (var == val) continue; var = val;) +#define break_or(var, val) __AS_PROCEDURE(if (var == val) break; var = val;) + +/* hash */ +struct safe_hash { + // https://codeforces.com/blog/entry/62393 + static uint64_t splitmix64(uint64_t x) { + // http://xorshift.di.unimi.it/splitmix64.c + x += 0x9e3779b97f4a7c15; + x = (x ^ (x >> 30)) * 0xbf58476d1ce4e5b9; + x = (x ^ (x >> 27)) * 0x94d049bb133111eb; + return x ^ (x >> 31); + } + + size_t operator()(uint64_t x) const { + static const uint64_t FIXED_RANDOM = chrono::steady_clock::now().time_since_epoch().count(); + return splitmix64(x + FIXED_RANDOM); + } +}; + +struct pair_hash { + template + size_t operator()(const pair& a) const { + auto hash1 = safe_hash()(a.first); + auto hash2 = safe_hash()(a.second); + if (hash1 != hash2) { + return hash1 ^ hash2; + } + return hash1; + } +}; + +/* build data structures */ +#define unordered_counter(from, to) __AS_PROCEDURE(unordered_map<__as_typeof(from), size_t, safe_hash> to; for (auto&& x : from) ++to[x];) +#define counter(from, to, cmp) __AS_PROCEDURE(map<__as_typeof(from), size_t, cmp> to; for (auto&& x : from) ++to[x];) +#define pa(a) __AS_PROCEDURE(__typeof(a) pa; pa.push_back({}); for (auto&&x : a) pa.push_back(pa.back() + x);) +#define sa(a) __AS_PROCEDURE(__typeof(a) sa(a.size() + 1); {int n = a.size(); for (int i = n - 1; i >= 0; --i) sa[i] = sa[i + 1] + a[i];};) +#define adj(ch, n) __AS_PROCEDURE(vector> ch((n) + 1);) +#define edge(ch, u, v) __AS_PROCEDURE(ch[u].push_back(v), ch[v].push_back(u);) +#define Edge(ch, u, v) __AS_PROCEDURE(ch[u].push_back(v);) + +/* io */ +#define untie __AS_PROCEDURE(ios_base::sync_with_stdio(0), cin.tie(NULL)) +template void __read(T& x) { cin >> x; } +template void __read(T& x, U&... args) { cin >> x; __read(args...); } +#define read(type, ...) __AS_PROCEDURE(type __VA_ARGS__; __read(__VA_ARGS__);) +#define readvec(type, a, n) __AS_PROCEDURE(vector a(n); for (int i = 0; i < (n); ++i) cin >> a[i];) +#define putvec(a) __AS_PROCEDURE(for (auto&& x : a) cout << x << ' '; cout << endl;) +#define debug(x) __AS_PROCEDURE(cerr << #x" = " << (x) << endl;) +#define debugvec(a) __AS_PROCEDURE(cerr << #a" = "; for (auto&& x : a) cerr << x << ' '; cerr << endl;) +template ostream& operator<<(ostream& out, vector vec) { + for (auto&& i : vec) out << i << ' '; + return out; +} + +/* pops */ +#define poptop(q, ...) __AS_PROCEDURE(auto [__VA_ARGS__] = q.top(); q.pop();) +#define popback(q, ...) __AS_PROCEDURE(auto [__VA_ARGS__] = q.back(); q.pop_back();) +#define popfront(q, ...) __AS_PROCEDURE(auto [__VA_ARGS__] = q.front();q.pop_front();) + +/* math */ +constexpr inline int lg2(ll x) { return x == 0 ? -1 : sizeof(ll) * 8 - 1 - __builtin_clzll(x); } + +void __exgcd(ll a, ll b, ll& x, ll& y) { + if (b == 0) { + x = 1, y = 0; + return; + } + __exgcd(b, a % b, y, x); + y -= a / b * x; +} + +ll inverse(ll a, ll b) { + ll x, y; + __exgcd(a, b, x, y); + return mod(x, b); +} + +/* string algorithms */ +vector calc_next(string t) { // pi function of t + int n = (int)t.length(); + vector pi(n); + for (int i = 1; i < n; i++) { + int j = pi[i - 1]; + while (j > 0 && t[i] != t[j]) j = pi[j - 1]; + if (t[i] == t[j]) j++; + pi[i] = j; + } + return pi; +} +vector calc_z(string t) { // z function of t + int m = t.length(); + vector z; + z.push_back(m); + pair prev = {1, -1}; + for (int i = 1; i < m; ++i) { + if (z[i - prev.first] + i <= prev.second) { + z.push_back(z[i - prev.first]); + } else { + int j = max(i, prev.second + 1); + while (j < m && t[j] == t[j - i]) ++j; + z.push_back(j - i); + prev = {i, j - 1}; + } + } + return z; +} +vector kmp(string s, string t) { // find all t in s + string cur = t + '#' + s; + int sz1 = s.size(), sz2 = t.size(); + vector v; + vector lps = calc_next(cur); + for (int i = sz2 + 1; i <= sz1 + sz2; i++) { + if (lps[i] == sz2) v.push_back(i - 2 * sz2); + } + return v; +} +int period(string s) { // find the length of shortest recurring period + int n = s.length(); + auto z = calc_z(s); + for (int i = 1; i <= n / 2; ++i) { + if (n % i == 0 && z[i] == n - i) { + return i; + } + } + return n; +} +///////////////////////////////////////////////////////// + + +// #define SINGLE_TEST_CASE +// #define DUMP_TEST_CASE 512 + +void dump() {} + +void solve() { + read(int, n, k); + adj(ch, n); + for (int i = 2; i <= n; ++i) { + read(int, p); + edge(ch, p, i); + } + auto check = [&] (int mx) -> bool { + int res = 0; + auto dfs = [&] (auto dfs, int v, int pa, int h) -> void { + if (h > mx) { + res += 1; + h = 1; + } + for (auto&& u : ch[v]) { + if (u != pa) { + dfs(dfs, u, v, h + 1); + } + } + }; + dfs(dfs, 1, 0, 0); + return res <= k; + }; + int l = 1, r = 2e5 + 10; + while (l < r) { + int mid = l + r >> 1; + if (check(mid)) { + r = mid; + } else { + l = mid + 1; + } + } + cout << l << endl; +} + +int main() { + untie, cout.tie(NULL); +#ifdef SINGLE_TEST_CASE + solve(); +#else + read(int, t); + for (int i = 0; i < t; ++i) { +#ifdef DUMP_TEST_CASE + if (i + 1 == (DUMP_TEST_CASE)) { + dump(); + } else { + solve(); + } +#else + solve(); +#endif + } +#endif +} diff --git a/src/bin/cf-1742g.cc b/src/bin/cf-1742g.cc new file mode 100644 index 0000000..10c3b61 --- /dev/null +++ b/src/bin/cf-1742g.cc @@ -0,0 +1,259 @@ +#pragma GCC optimize("Ofast") +///////////////////////////////////////////////////////// +/** + * Useful Macros + * by subcrip + * (requires C++17) + */ + +#include +#include +using namespace std; +using namespace __gnu_cxx; +using namespace __gnu_pbds; + +/* 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) decltype(container)::value_type + +/* type aliases */ +using ll = int64_t; +using ull = uint64_t; +using pii = pair; +using pil = pair; +using pli = pair; +using pll = pair; + +/* constants */ +constexpr int INF = 0x3f3f3f3f; +constexpr ll INFLL = 0x3f3f3f3f3f3f3f3fLL; +constexpr ull MDL = 1e9 + 7; +constexpr ull PRIME = 998'244'353; +constexpr ll MDL1 = 8784491; +constexpr ll MDL2 = PRIME; + +/* random */ + +mt19937 rd(chrono::duration_cast(chrono::system_clock::now().time_since_epoch()).count()); + +/* bit-wise operations */ +#define lowbit(x) ((x) & -(x)) +#define popcount(x) (__builtin_popcountll(ll(x))) +#define parity(x) (__builtin_parityll(ll(x))) +#define msp(x) (63LL - __builtin_clzll(ll(x))) +#define lsp(x) (__builtin_ctzll(ll(x))) + +/* arithmetic operations */ +#define mod(x, y) ((((x) % (y)) + (y)) % (y)) + +/* fast pairs */ +#define upair ull +#define umake(x, y) (ull(x) << 32 | (ull(y) & ((1ULL << 32) - 1))) +#define u1(p) ((p) >> 32) +#define u2(p) ((p) & ((1ULL << 32) - 1)) +#define ult std::less +#define ugt std::greater + +#define ipair ull +#define imake(x, y) (umake(x, y)) +#define i1(p) (int(u1(ll(p)))) +#define i2(p) (ll(u2(p) << 32) >> 32) +struct ilt { + bool operator()(const ipair& a, const ipair& b) const { + if (i1(a) == i1(b)) return i2(a) < i2(b); + else return i1(a) < i1(b); + } +}; +struct igt { + bool operator()(const ipair& a, const ipair& b) const { + if (i1(a) == i1(b)) return i2(a) > i2(b); + else return i1(a) > i1(b); + } +}; + +/* conditions */ +#define loop while (1) +#define if_or(var, val) if (!(var == val)) var = val; else +#define continue_or(var, val) __AS_PROCEDURE(if (var == val) continue; var = val;) +#define break_or(var, val) __AS_PROCEDURE(if (var == val) break; var = val;) + +/* hash */ +struct safe_hash { + // https://codeforces.com/blog/entry/62393 + static uint64_t splitmix64(uint64_t x) { + // http://xorshift.di.unimi.it/splitmix64.c + x += 0x9e3779b97f4a7c15; + x = (x ^ (x >> 30)) * 0xbf58476d1ce4e5b9; + x = (x ^ (x >> 27)) * 0x94d049bb133111eb; + return x ^ (x >> 31); + } + + size_t operator()(uint64_t x) const { + static const uint64_t FIXED_RANDOM = chrono::steady_clock::now().time_since_epoch().count(); + return splitmix64(x + FIXED_RANDOM); + } +}; + +struct pair_hash { + template + size_t operator()(const pair& a) const { + auto hash1 = safe_hash()(a.first); + auto hash2 = safe_hash()(a.second); + if (hash1 != hash2) { + return hash1 ^ hash2; + } + return hash1; + } +}; + +/* build data structures */ +#define unordered_counter(from, to) __AS_PROCEDURE(unordered_map<__as_typeof(from), size_t, safe_hash> to; for (auto&& x : from) ++to[x];) +#define counter(from, to, cmp) __AS_PROCEDURE(map<__as_typeof(from), size_t, cmp> to; for (auto&& x : from) ++to[x];) +#define pa(a) __AS_PROCEDURE(__typeof(a) pa; pa.push_back({}); for (auto&&x : a) pa.push_back(pa.back() + x);) +#define sa(a) __AS_PROCEDURE(__typeof(a) sa(a.size() + 1); {int n = a.size(); for (int i = n - 1; i >= 0; --i) sa[i] = sa[i + 1] + a[i];};) +#define adj(ch, n) __AS_PROCEDURE(vector> ch((n) + 1);) +#define edge(ch, u, v) __AS_PROCEDURE(ch[u].push_back(v), ch[v].push_back(u);) +#define Edge(ch, u, v) __AS_PROCEDURE(ch[u].push_back(v);) + +/* io */ +#define untie __AS_PROCEDURE(ios_base::sync_with_stdio(0), cin.tie(NULL)) +template void __read(T& x) { cin >> x; } +template void __read(T& x, U&... args) { cin >> x; __read(args...); } +#define read(type, ...) __AS_PROCEDURE(type __VA_ARGS__; __read(__VA_ARGS__);) +#define readvec(type, a, n) __AS_PROCEDURE(vector a(n); for (int i = 0; i < (n); ++i) cin >> a[i];) +#define putvec(a) __AS_PROCEDURE(for (auto&& x : a) cout << x << ' '; cout << endl;) +#define debug(x) __AS_PROCEDURE(cerr << #x" = " << (x) << endl;) +#define debugvec(a) __AS_PROCEDURE(cerr << #a" = "; for (auto&& x : a) cerr << x << ' '; cerr << endl;) +template ostream& operator<<(ostream& out, vector vec) { + for (auto&& i : vec) out << i << ' '; + return out; +} + +/* pops */ +#define poptop(q, ...) __AS_PROCEDURE(auto [__VA_ARGS__] = q.top(); q.pop();) +#define popback(q, ...) __AS_PROCEDURE(auto [__VA_ARGS__] = q.back(); q.pop_back();) +#define popfront(q, ...) __AS_PROCEDURE(auto [__VA_ARGS__] = q.front();q.pop_front();) + +/* math */ +constexpr inline int lg2(ll x) { return x == 0 ? -1 : sizeof(ll) * 8 - 1 - __builtin_clzll(x); } + +void __exgcd(ll a, ll b, ll& x, ll& y) { + if (b == 0) { + x = 1, y = 0; + return; + } + __exgcd(b, a % b, y, x); + y -= a / b * x; +} + +ll inverse(ll a, ll b) { + ll x, y; + __exgcd(a, b, x, y); + return mod(x, b); +} + +/* string algorithms */ +vector calc_next(string t) { // pi function of t + int n = (int)t.length(); + vector pi(n); + for (int i = 1; i < n; i++) { + int j = pi[i - 1]; + while (j > 0 && t[i] != t[j]) j = pi[j - 1]; + if (t[i] == t[j]) j++; + pi[i] = j; + } + return pi; +} +vector calc_z(string t) { // z function of t + int m = t.length(); + vector z; + z.push_back(m); + pair prev = {1, -1}; + for (int i = 1; i < m; ++i) { + if (z[i - prev.first] + i <= prev.second) { + z.push_back(z[i - prev.first]); + } else { + int j = max(i, prev.second + 1); + while (j < m && t[j] == t[j - i]) ++j; + z.push_back(j - i); + prev = {i, j - 1}; + } + } + return z; +} +vector kmp(string s, string t) { // find all t in s + string cur = t + '#' + s; + int sz1 = s.size(), sz2 = t.size(); + vector v; + vector lps = calc_next(cur); + for (int i = sz2 + 1; i <= sz1 + sz2; i++) { + if (lps[i] == sz2) v.push_back(i - 2 * sz2); + } + return v; +} +int period(string s) { // find the length of shortest recurring period + int n = s.length(); + auto z = calc_z(s); + for (int i = 1; i <= n / 2; ++i) { + if (n % i == 0 && z[i] == n - i) { + return i; + } + } + return n; +} +///////////////////////////////////////////////////////// + + +// #define SINGLE_TEST_CASE +// #define DUMP_TEST_CASE 512 + +void dump() {} + +void solve() { + read(int, n); + readvec(int, a, n); + sort(a.begin(), a.end(), greater<>()); + vector mark(n); + vector res; + for (int b = 30; ~b; --b) { + for (int i = 0; i < n; ++i) { + if (((a[i] >> b) & 1) == 1) { + if (mark[i]) { + ;; + } else { + mark[i] = 1; + res.push_back(a[i]); + } + break; + } + } + } + for (int i = 0; i < n; ++i) { + if (!mark[i]) res.push_back(a[i]); + } + putvec(res); +} + +int main() { + untie, cout.tie(NULL); +#ifdef SINGLE_TEST_CASE + solve(); +#else + read(int, t); + for (int i = 0; i < t; ++i) { +#ifdef DUMP_TEST_CASE + if (i + 1 == (DUMP_TEST_CASE)) { + dump(); + } else { + solve(); + } +#else + solve(); +#endif + } +#endif +} diff --git a/src/bin/cf-1760f.cc b/src/bin/cf-1760f.cc new file mode 100644 index 0000000..30faea5 --- /dev/null +++ b/src/bin/cf-1760f.cc @@ -0,0 +1,270 @@ +#pragma GCC optimize("Ofast") +///////////////////////////////////////////////////////// +/** + * Useful Macros + * by subcrip + * (requires C++17) + */ + +#include +#include +using namespace std; +using namespace __gnu_cxx; +using namespace __gnu_pbds; + +/* 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) decltype(container)::value_type + +/* type aliases */ +using ll = int64_t; +using ull = uint64_t; +using pii = pair; +using pil = pair; +using pli = pair; +using pll = pair; + +/* constants */ +constexpr int INF = 0x3f3f3f3f; +constexpr ll INFLL = 0x3f3f3f3f3f3f3f3fLL; +constexpr ull MDL = 1e9 + 7; +constexpr ull PRIME = 998'244'353; +constexpr ll MDL1 = 8784491; +constexpr ll MDL2 = PRIME; + +/* random */ + +mt19937 rd(chrono::duration_cast(chrono::system_clock::now().time_since_epoch()).count()); + +/* bit-wise operations */ +#define lowbit(x) ((x) & -(x)) +#define popcount(x) (__builtin_popcountll(ll(x))) +#define parity(x) (__builtin_parityll(ll(x))) +#define msp(x) (63LL - __builtin_clzll(ll(x))) +#define lsp(x) (__builtin_ctzll(ll(x))) + +/* arithmetic operations */ +#define mod(x, y) ((((x) % (y)) + (y)) % (y)) + +/* fast pairs */ +#define upair ull +#define umake(x, y) (ull(x) << 32 | (ull(y) & ((1ULL << 32) - 1))) +#define u1(p) ((p) >> 32) +#define u2(p) ((p) & ((1ULL << 32) - 1)) +#define ult std::less +#define ugt std::greater + +#define ipair ull +#define imake(x, y) (umake(x, y)) +#define i1(p) (int(u1(ll(p)))) +#define i2(p) (ll(u2(p) << 32) >> 32) +struct ilt { + bool operator()(const ipair& a, const ipair& b) const { + if (i1(a) == i1(b)) return i2(a) < i2(b); + else return i1(a) < i1(b); + } +}; +struct igt { + bool operator()(const ipair& a, const ipair& b) const { + if (i1(a) == i1(b)) return i2(a) > i2(b); + else return i1(a) > i1(b); + } +}; + +/* conditions */ +#define loop while (1) +#define if_or(var, val) if (!(var == val)) var = val; else +#define continue_or(var, val) __AS_PROCEDURE(if (var == val) continue; var = val;) +#define break_or(var, val) __AS_PROCEDURE(if (var == val) break; var = val;) + +/* hash */ +struct safe_hash { + // https://codeforces.com/blog/entry/62393 + static uint64_t splitmix64(uint64_t x) { + // http://xorshift.di.unimi.it/splitmix64.c + x += 0x9e3779b97f4a7c15; + x = (x ^ (x >> 30)) * 0xbf58476d1ce4e5b9; + x = (x ^ (x >> 27)) * 0x94d049bb133111eb; + return x ^ (x >> 31); + } + + size_t operator()(uint64_t x) const { + static const uint64_t FIXED_RANDOM = chrono::steady_clock::now().time_since_epoch().count(); + return splitmix64(x + FIXED_RANDOM); + } +}; + +struct pair_hash { + template + size_t operator()(const pair& a) const { + auto hash1 = safe_hash()(a.first); + auto hash2 = safe_hash()(a.second); + if (hash1 != hash2) { + return hash1 ^ hash2; + } + return hash1; + } +}; + +/* build data structures */ +#define unordered_counter(from, to) __AS_PROCEDURE(unordered_map<__as_typeof(from), size_t, safe_hash> to; for (auto&& x : from) ++to[x];) +#define counter(from, to, cmp) __AS_PROCEDURE(map<__as_typeof(from), size_t, cmp> to; for (auto&& x : from) ++to[x];) +#define pa(a) __AS_PROCEDURE(__typeof(a) pa; pa.push_back({}); for (auto&&x : a) pa.push_back(pa.back() + x);) +#define sa(a) __AS_PROCEDURE(__typeof(a) sa(a.size() + 1); {int n = a.size(); for (int i = n - 1; i >= 0; --i) sa[i] = sa[i + 1] + a[i];};) +#define adj(ch, n) __AS_PROCEDURE(vector> ch((n) + 1);) +#define edge(ch, u, v) __AS_PROCEDURE(ch[u].push_back(v), ch[v].push_back(u);) +#define Edge(ch, u, v) __AS_PROCEDURE(ch[u].push_back(v);) + +/* io */ +#define untie __AS_PROCEDURE(ios_base::sync_with_stdio(0), cin.tie(NULL)) +template void __read(T& x) { cin >> x; } +template void __read(T& x, U&... args) { cin >> x; __read(args...); } +#define read(type, ...) __AS_PROCEDURE(type __VA_ARGS__; __read(__VA_ARGS__);) +#define readvec(type, a, n) __AS_PROCEDURE(vector a(n); for (int i = 0; i < (n); ++i) cin >> a[i];) +#define putvec(a) __AS_PROCEDURE(for (auto&& x : a) cout << x << ' '; cout << endl;) +#define debug(x) __AS_PROCEDURE(cerr << #x" = " << (x) << endl;) +#define debugvec(a) __AS_PROCEDURE(cerr << #a" = "; for (auto&& x : a) cerr << x << ' '; cerr << endl;) +template ostream& operator<<(ostream& out, vector vec) { + for (auto&& i : vec) out << i << ' '; + return out; +} + +/* pops */ +#define poptop(q, ...) __AS_PROCEDURE(auto [__VA_ARGS__] = q.top(); q.pop();) +#define popback(q, ...) __AS_PROCEDURE(auto [__VA_ARGS__] = q.back(); q.pop_back();) +#define popfront(q, ...) __AS_PROCEDURE(auto [__VA_ARGS__] = q.front();q.pop_front();) + +/* math */ +constexpr inline int lg2(ll x) { return x == 0 ? -1 : sizeof(ll) * 8 - 1 - __builtin_clzll(x); } + +void __exgcd(ll a, ll b, ll& x, ll& y) { + if (b == 0) { + x = 1, y = 0; + return; + } + __exgcd(b, a % b, y, x); + y -= a / b * x; +} + +ll inverse(ll a, ll b) { + ll x, y; + __exgcd(a, b, x, y); + return mod(x, b); +} + +/* string algorithms */ +vector calc_next(string t) { // pi function of t + int n = (int)t.length(); + vector pi(n); + for (int i = 1; i < n; i++) { + int j = pi[i - 1]; + while (j > 0 && t[i] != t[j]) j = pi[j - 1]; + if (t[i] == t[j]) j++; + pi[i] = j; + } + return pi; +} +vector calc_z(string t) { // z function of t + int m = t.length(); + vector z; + z.push_back(m); + pair prev = {1, -1}; + for (int i = 1; i < m; ++i) { + if (z[i - prev.first] + i <= prev.second) { + z.push_back(z[i - prev.first]); + } else { + int j = max(i, prev.second + 1); + while (j < m && t[j] == t[j - i]) ++j; + z.push_back(j - i); + prev = {i, j - 1}; + } + } + return z; +} +vector kmp(string s, string t) { // find all t in s + string cur = t + '#' + s; + int sz1 = s.size(), sz2 = t.size(); + vector v; + vector lps = calc_next(cur); + for (int i = sz2 + 1; i <= sz1 + sz2; i++) { + if (lps[i] == sz2) v.push_back(i - 2 * sz2); + } + return v; +} +int period(string s) { // find the length of shortest recurring period + int n = s.length(); + auto z = calc_z(s); + for (int i = 1; i <= n / 2; ++i) { + if (n % i == 0 && z[i] == n - i) { + return i; + } + } + return n; +} +///////////////////////////////////////////////////////// + + +// #define SINGLE_TEST_CASE +// #define DUMP_TEST_CASE 512 + +void dump() {} + +void solve() { + read(int, n); + read(ll, c); + read(int, d); + readvec(int, a, n); + sort(a.begin(), a.end(), greater<>()); + auto check = [&] (ll p) -> bool { + ll full = d / (p + 1); + ll sum = 0; + for (int i = 0; i < min(ll(n), p + 1); ++i) { + sum += a[i]; + } + sum *= full; + for (int i = 0; i < min(ll(n), d % (p + 1)); ++i) { + sum += a[i]; + } + return sum >= c; + }; + ll l = 0, r = INFLL; + while (l < r) { + ll mid = l + r + 1 >> 1; + if (check(mid)) { + l = mid; + } else { + r = mid - 1; + } + } + if (accumulate(a.begin(), a.begin() + min(d, n), 0LL) >= c) { + cout << "Infinity\n"; + } else if (r == 0 && !check(0)) { + cout << "Impossible\n"; + } else { + cout << r << endl; + } +} + +int main() { + untie, cout.tie(NULL); +#ifdef SINGLE_TEST_CASE + solve(); +#else + read(int, t); + for (int i = 0; i < t; ++i) { +#ifdef DUMP_TEST_CASE + if (i + 1 == (DUMP_TEST_CASE)) { + dump(); + } else { + solve(); + } +#else + solve(); +#endif + } +#endif +} diff --git a/src/bin/cf-1791g2.cc b/src/bin/cf-1791g2.cc new file mode 100644 index 0000000..ce58ee4 --- /dev/null +++ b/src/bin/cf-1791g2.cc @@ -0,0 +1,298 @@ +#pragma GCC optimize("Ofast") +///////////////////////////////////////////////////////// +/** + * Useful Macros + * by subcrip + * (requires C++17) + */ + +#include +#include +using namespace std; +using namespace __gnu_cxx; +using namespace __gnu_pbds; + +/* 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) decltype(container)::value_type + +/* type aliases */ +using ll = int64_t; +using ull = uint64_t; +using pii = pair; +using pil = pair; +using pli = pair; +using pll = pair; + +/* constants */ +constexpr int INF = 0x3f3f3f3f; +constexpr ll INFLL = 0x3f3f3f3f3f3f3f3fLL; +constexpr ull MDL = 1e9 + 7; +constexpr ull PRIME = 998'244'353; +constexpr ll MDL1 = 8784491; +constexpr ll MDL2 = PRIME; + +/* random */ + +mt19937 rd(chrono::duration_cast(chrono::system_clock::now().time_since_epoch()).count()); + +/* bit-wise operations */ +#define lowbit(x) ((x) & -(x)) +#define popcount(x) (__builtin_popcountll(ll(x))) +#define parity(x) (__builtin_parityll(ll(x))) +#define msp(x) (63LL - __builtin_clzll(ll(x))) +#define lsp(x) (__builtin_ctzll(ll(x))) + +/* arithmetic operations */ +#define mod(x, y) ((((x) % (y)) + (y)) % (y)) + +/* fast pairs */ +#define upair ull +#define umake(x, y) (ull(x) << 32 | (ull(y) & ((1ULL << 32) - 1))) +#define u1(p) ((p) >> 32) +#define u2(p) ((p) & ((1ULL << 32) - 1)) +#define ult std::less +#define ugt std::greater + +#define ipair ull +#define imake(x, y) (umake(x, y)) +#define i1(p) (int(u1(ll(p)))) +#define i2(p) (ll(u2(p) << 32) >> 32) +struct ilt { + bool operator()(const ipair& a, const ipair& b) const { + if (i1(a) == i1(b)) return i2(a) < i2(b); + else return i1(a) < i1(b); + } +}; +struct igt { + bool operator()(const ipair& a, const ipair& b) const { + if (i1(a) == i1(b)) return i2(a) > i2(b); + else return i1(a) > i1(b); + } +}; + +/* conditions */ +#define loop while (1) +#define if_or(var, val) if (!(var == val)) var = val; else +#define continue_or(var, val) __AS_PROCEDURE(if (var == val) continue; var = val;) +#define break_or(var, val) __AS_PROCEDURE(if (var == val) break; var = val;) + +/* hash */ +struct safe_hash { + // https://codeforces.com/blog/entry/62393 + static uint64_t splitmix64(uint64_t x) { + // http://xorshift.di.unimi.it/splitmix64.c + x += 0x9e3779b97f4a7c15; + x = (x ^ (x >> 30)) * 0xbf58476d1ce4e5b9; + x = (x ^ (x >> 27)) * 0x94d049bb133111eb; + return x ^ (x >> 31); + } + + size_t operator()(uint64_t x) const { + static const uint64_t FIXED_RANDOM = chrono::steady_clock::now().time_since_epoch().count(); + return splitmix64(x + FIXED_RANDOM); + } +}; + +struct pair_hash { + template + size_t operator()(const pair& a) const { + auto hash1 = safe_hash()(a.first); + auto hash2 = safe_hash()(a.second); + if (hash1 != hash2) { + return hash1 ^ hash2; + } + return hash1; + } +}; + +/* build data structures */ +#define unordered_counter(from, to) __AS_PROCEDURE(unordered_map<__as_typeof(from), size_t, safe_hash> to; for (auto&& x : from) ++to[x];) +#define counter(from, to, cmp) __AS_PROCEDURE(map<__as_typeof(from), size_t, cmp> to; for (auto&& x : from) ++to[x];) +#define pa(a) __AS_PROCEDURE(__typeof(a) pa; pa.push_back({}); for (auto&&x : a) pa.push_back(pa.back() + x);) +#define sa(a) __AS_PROCEDURE(__typeof(a) sa(a.size() + 1); {int n = a.size(); for (int i = n - 1; i >= 0; --i) sa[i] = sa[i + 1] + a[i];};) +#define adj(ch, n) __AS_PROCEDURE(vector> ch((n) + 1);) +#define edge(ch, u, v) __AS_PROCEDURE(ch[u].push_back(v), ch[v].push_back(u);) +#define Edge(ch, u, v) __AS_PROCEDURE(ch[u].push_back(v);) + +/* io */ +#define untie __AS_PROCEDURE(ios_base::sync_with_stdio(0), cin.tie(NULL)) +template void __read(T& x) { cin >> x; } +template void __read(T& x, U&... args) { cin >> x; __read(args...); } +#define read(type, ...) __AS_PROCEDURE(type __VA_ARGS__; __read(__VA_ARGS__);) +#define readvec(type, a, n) __AS_PROCEDURE(vector a(n); for (int i = 0; i < (n); ++i) cin >> a[i];) +#define putvec(a) __AS_PROCEDURE(for (auto&& x : a) cout << x << ' '; cout << endl;) +#define debug(x) __AS_PROCEDURE(cerr << #x" = " << (x) << endl;) +#define debugvec(a) __AS_PROCEDURE(cerr << #a" = "; for (auto&& x : a) cerr << x << ' '; cerr << endl;) +template ostream& operator<<(ostream& out, vector vec) { + for (auto&& i : vec) out << i << ' '; + return out; +} + +/* pops */ +#define poptop(q, ...) __AS_PROCEDURE(auto [__VA_ARGS__] = q.top(); q.pop();) +#define popback(q, ...) __AS_PROCEDURE(auto [__VA_ARGS__] = q.back(); q.pop_back();) +#define popfront(q, ...) __AS_PROCEDURE(auto [__VA_ARGS__] = q.front();q.pop_front();) + +/* math */ +constexpr inline int lg2(ll x) { return x == 0 ? -1 : sizeof(ll) * 8 - 1 - __builtin_clzll(x); } + +void __exgcd(ll a, ll b, ll& x, ll& y) { + if (b == 0) { + x = 1, y = 0; + return; + } + __exgcd(b, a % b, y, x); + y -= a / b * x; +} + +ll inverse(ll a, ll b) { + ll x, y; + __exgcd(a, b, x, y); + return mod(x, b); +} + +/* string algorithms */ +vector calc_next(string t) { // pi function of t + int n = (int)t.length(); + vector pi(n); + for (int i = 1; i < n; i++) { + int j = pi[i - 1]; + while (j > 0 && t[i] != t[j]) j = pi[j - 1]; + if (t[i] == t[j]) j++; + pi[i] = j; + } + return pi; +} +vector calc_z(string t) { // z function of t + int m = t.length(); + vector z; + z.push_back(m); + pair prev = {1, -1}; + for (int i = 1; i < m; ++i) { + if (z[i - prev.first] + i <= prev.second) { + z.push_back(z[i - prev.first]); + } else { + int j = max(i, prev.second + 1); + while (j < m && t[j] == t[j - i]) ++j; + z.push_back(j - i); + prev = {i, j - 1}; + } + } + return z; +} +vector kmp(string s, string t) { // find all t in s + string cur = t + '#' + s; + int sz1 = s.size(), sz2 = t.size(); + vector v; + vector lps = calc_next(cur); + for (int i = sz2 + 1; i <= sz1 + sz2; i++) { + if (lps[i] == sz2) v.push_back(i - 2 * sz2); + } + return v; +} +int period(string s) { // find the length of shortest recurring period + int n = s.length(); + auto z = calc_z(s); + for (int i = 1; i <= n / 2; ++i) { + if (n % i == 0 && z[i] == n - i) { + return i; + } + } + return n; +} +///////////////////////////////////////////////////////// + + +// #define SINGLE_TEST_CASE +// #define DUMP_TEST_CASE 512 + +void dump() {} + +void solve() { + read(int, n, c); + readvec(int, a, n); + vector> event; + for (int i = 0; i < n; ++i) { + event.emplace_back(i + 1 + a[i], i, 0); + event.emplace_back(n - i + a[i], i, 1); + } + sort(event.begin(), event.end()); + for (auto [x, y, z] : event) { + cerr << "{" << x << ", " << y << ", " << z << "}\n"; + } + map> open; + int dc = -1, tar = -1; + ll sum = 0, cnt = 0; + int m = event.size(); + for (int i = 0; i < m; ++i) { + auto [x, y, z] = event[i]; + if (z == 0) { + if (open.count(y)) { + dc = open[y]; + sum -= get<0>(event[open[y]]); + cnt -= 1; + } + tar = i; + cnt += 1; + sum += x; + break; + } else { + open[y] = i; + cnt += 1; + sum += x; + } + } + if (tar == -1) { + cout << 0 << endl; + return; + } + if (sum <= c) { + for (int i = tar + 1; i < m; ++i) { + auto [x, y, z] = event[i]; + if (sum + x > c) break; + if (!open.count(y)) { + cnt += 1; + sum += x; + } + } + cout << cnt << endl; + } else { + for (int i = tar - 1; ~i; --i) { + if (i == dc) continue; + auto [x, y, z] = event[i]; + sum -= x; + cnt -= 1; + if (sum <= c) break; + } + if (sum > c) { + cout << 0 << endl; + } else { + cout << cnt << endl; + } + } +} + +int main() { + untie, cout.tie(NULL); +#ifdef SINGLE_TEST_CASE + solve(); +#else + read(int, t); + for (int i = 0; i < t; ++i) { +#ifdef DUMP_TEST_CASE + if (i + 1 == (DUMP_TEST_CASE)) { + dump(); + } else { + solve(); + } +#else + solve(); +#endif + } +#endif +} diff --git a/src/bin/cf-1799d1.cc b/src/bin/cf-1799d1.cc new file mode 100644 index 0000000..45b17c5 --- /dev/null +++ b/src/bin/cf-1799d1.cc @@ -0,0 +1,279 @@ +#pragma GCC optimize("Ofast") +///////////////////////////////////////////////////////// +/** + * Useful Macros + * by subcrip + * (requires C++17) + */ + +#include +#include +using namespace std; +using namespace __gnu_cxx; +using namespace __gnu_pbds; + +/* 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) decltype(container)::value_type + +/* type aliases */ +using ll = int64_t; +using ull = uint64_t; +using pii = pair; +using pil = pair; +using pli = pair; +using pll = pair; + +/* constants */ +constexpr int INF = 0x3f3f3f3f; +constexpr ll INFLL = 0x3f3f3f3f3f3f3f3fLL; +constexpr ull MDL = 1e9 + 7; +constexpr ull PRIME = 998'244'353; +constexpr ll MDL1 = 8784491; +constexpr ll MDL2 = PRIME; + +/* random */ + +mt19937 rd(chrono::duration_cast(chrono::system_clock::now().time_since_epoch()).count()); + +/* bit-wise operations */ +#define lowbit(x) ((x) & -(x)) +#define popcount(x) (__builtin_popcountll(ll(x))) +#define parity(x) (__builtin_parityll(ll(x))) +#define msp(x) (63LL - __builtin_clzll(ll(x))) +#define lsp(x) (__builtin_ctzll(ll(x))) + +/* arithmetic operations */ +#define mod(x, y) ((((x) % (y)) + (y)) % (y)) + +/* fast pairs */ +#define upair ull +#define umake(x, y) (ull(x) << 32 | (ull(y) & ((1ULL << 32) - 1))) +#define u1(p) ((p) >> 32) +#define u2(p) ((p) & ((1ULL << 32) - 1)) +#define ult std::less +#define ugt std::greater + +#define ipair ull +#define imake(x, y) (umake(x, y)) +#define i1(p) (int(u1(ll(p)))) +#define i2(p) (ll(u2(p) << 32) >> 32) +struct ilt { + bool operator()(const ipair& a, const ipair& b) const { + if (i1(a) == i1(b)) return i2(a) < i2(b); + else return i1(a) < i1(b); + } +}; +struct igt { + bool operator()(const ipair& a, const ipair& b) const { + if (i1(a) == i1(b)) return i2(a) > i2(b); + else return i1(a) > i1(b); + } +}; + +/* conditions */ +#define loop while (1) +#define if_or(var, val) if (!(var == val)) var = val; else +#define continue_or(var, val) __AS_PROCEDURE(if (var == val) continue; var = val;) +#define break_or(var, val) __AS_PROCEDURE(if (var == val) break; var = val;) + +/* hash */ +struct safe_hash { + // https://codeforces.com/blog/entry/62393 + static uint64_t splitmix64(uint64_t x) { + // http://xorshift.di.unimi.it/splitmix64.c + x += 0x9e3779b97f4a7c15; + x = (x ^ (x >> 30)) * 0xbf58476d1ce4e5b9; + x = (x ^ (x >> 27)) * 0x94d049bb133111eb; + return x ^ (x >> 31); + } + + size_t operator()(uint64_t x) const { + static const uint64_t FIXED_RANDOM = chrono::steady_clock::now().time_since_epoch().count(); + return splitmix64(x + FIXED_RANDOM); + } +}; + +struct pair_hash { + template + size_t operator()(const pair& a) const { + auto hash1 = safe_hash()(a.first); + auto hash2 = safe_hash()(a.second); + if (hash1 != hash2) { + return hash1 ^ hash2; + } + return hash1; + } +}; + +/* build data structures */ +#define unordered_counter(from, to) __AS_PROCEDURE(unordered_map<__as_typeof(from), size_t, safe_hash> to; for (auto&& x : from) ++to[x];) +#define counter(from, to, cmp) __AS_PROCEDURE(map<__as_typeof(from), size_t, cmp> to; for (auto&& x : from) ++to[x];) +#define pa(a) __AS_PROCEDURE(__typeof(a) pa; pa.push_back({}); for (auto&&x : a) pa.push_back(pa.back() + x);) +#define sa(a) __AS_PROCEDURE(__typeof(a) sa(a.size() + 1); {int n = a.size(); for (int i = n - 1; i >= 0; --i) sa[i] = sa[i + 1] + a[i];};) +#define adj(ch, n) __AS_PROCEDURE(vector> ch((n) + 1);) +#define edge(ch, u, v) __AS_PROCEDURE(ch[u].push_back(v), ch[v].push_back(u);) +#define Edge(ch, u, v) __AS_PROCEDURE(ch[u].push_back(v);) + +/* io */ +#define untie __AS_PROCEDURE(ios_base::sync_with_stdio(0), cin.tie(NULL)) +template void __read(T& x) { cin >> x; } +template void __read(T& x, U&... args) { cin >> x; __read(args...); } +#define read(type, ...) __AS_PROCEDURE(type __VA_ARGS__; __read(__VA_ARGS__);) +#define readvec(type, a, n) __AS_PROCEDURE(vector a(n); for (int i = 0; i < (n); ++i) cin >> a[i];) +#define putvec(a) __AS_PROCEDURE(for (auto&& x : a) cout << x << ' '; cout << endl;) +#define debug(x) __AS_PROCEDURE(cerr << #x" = " << (x) << endl;) +#define debugvec(a) __AS_PROCEDURE(cerr << #a" = "; for (auto&& x : a) cerr << x << ' '; cerr << endl;) +template ostream& operator<<(ostream& out, vector vec) { + for (auto&& i : vec) out << i << ' '; + return out; +} + +/* pops */ +#define poptop(q, ...) __AS_PROCEDURE(auto [__VA_ARGS__] = q.top(); q.pop();) +#define popback(q, ...) __AS_PROCEDURE(auto [__VA_ARGS__] = q.back(); q.pop_back();) +#define popfront(q, ...) __AS_PROCEDURE(auto [__VA_ARGS__] = q.front();q.pop_front();) + +/* math */ +constexpr inline int lg2(ll x) { return x == 0 ? -1 : sizeof(ll) * 8 - 1 - __builtin_clzll(x); } + +void __exgcd(ll a, ll b, ll& x, ll& y) { + if (b == 0) { + x = 1, y = 0; + return; + } + __exgcd(b, a % b, y, x); + y -= a / b * x; +} + +ll inverse(ll a, ll b) { + ll x, y; + __exgcd(a, b, x, y); + return mod(x, b); +} + +/* string algorithms */ +vector calc_next(string t) { // pi function of t + int n = (int)t.length(); + vector pi(n); + for (int i = 1; i < n; i++) { + int j = pi[i - 1]; + while (j > 0 && t[i] != t[j]) j = pi[j - 1]; + if (t[i] == t[j]) j++; + pi[i] = j; + } + return pi; +} +vector calc_z(string t) { // z function of t + int m = t.length(); + vector z; + z.push_back(m); + pair prev = {1, -1}; + for (int i = 1; i < m; ++i) { + if (z[i - prev.first] + i <= prev.second) { + z.push_back(z[i - prev.first]); + } else { + int j = max(i, prev.second + 1); + while (j < m && t[j] == t[j - i]) ++j; + z.push_back(j - i); + prev = {i, j - 1}; + } + } + return z; +} +vector kmp(string s, string t) { // find all t in s + string cur = t + '#' + s; + int sz1 = s.size(), sz2 = t.size(); + vector v; + vector lps = calc_next(cur); + for (int i = sz2 + 1; i <= sz1 + sz2; i++) { + if (lps[i] == sz2) v.push_back(i - 2 * sz2); + } + return v; +} +int period(string s) { // find the length of shortest recurring period + int n = s.length(); + auto z = calc_z(s); + for (int i = 1; i <= n / 2; ++i) { + if (n % i == 0 && z[i] == n - i) { + return i; + } + } + return n; +} +///////////////////////////////////////////////////////// + + +// #define SINGLE_TEST_CASE +// #define DUMP_TEST_CASE 512 + +void dump() {} + +constexpr int MAXK = 5010; +ll col_exclude[MAXK], row_exclude[MAXK], col[MAXK], row[MAXK]; + +void solve() { + read(int, n, k); + readvec(int, a, n); + readvec(int, cold, k); + readvec(int, hot, k); + vector> dp; + vector> ndp; + dp.reserve(2 * k), ndp.reserve(2 * k); + dp.emplace_back(imake(0, 0), 0); + for (int i = 0; i < n; ++i) { + int curr = a[i]; + memset(col_exclude, 0x3f, sizeof(col_exclude)); + memset(col, 0x3f, sizeof(col)); + memset(row_exclude, 0x3f, sizeof(row_exclude)); + memset(row, 0x3f, sizeof(row)); + for (auto&& [p, v] : dp) { + if (i1(p) == curr) row[i2(p)] = v; + else { + row_exclude[i2(p)] = min(row_exclude[i2(p)], v); + } + if (i2(p) == curr) col[i1(p)] = v; + else { + col_exclude[i1(p)] = min(col_exclude[i1(p)], v); + } + } + for (int y = 0; y <= k; ++y) { + // dp[curr][y] + if (y == curr) continue; + ndp.emplace_back(imake(curr, y), min(row_exclude[y] + cold[curr - 1], row[y] + hot[curr - 1])); + ndp.emplace_back(imake(y, curr), min(col_exclude[y] + cold[curr - 1], col[y] + hot[curr - 1])); + } + ndp.emplace_back(imake(curr, curr), min(cold[curr - 1] + min(row_exclude[curr], col_exclude[curr]), hot[curr - 1] + min(row[curr], col[curr]))); + swap(dp, ndp); + ndp.clear(); + } + ll res = INFLL; + for (auto&& [_, v] : dp) { + res = min(res, v); + } + cout << res << endl; +} + +int main() { + untie, cout.tie(NULL); +#ifdef SINGLE_TEST_CASE + solve(); +#else + read(int, t); + for (int i = 0; i < t; ++i) { +#ifdef DUMP_TEST_CASE + if (i + 1 == (DUMP_TEST_CASE)) { + dump(); + } else { + solve(); + } +#else + solve(); +#endif + } +#endif +} diff --git a/src/bin/cf-1800e2.cc b/src/bin/cf-1800e2.cc new file mode 100644 index 0000000..cf9f54f --- /dev/null +++ b/src/bin/cf-1800e2.cc @@ -0,0 +1,265 @@ +#pragma GCC optimize("Ofast") +///////////////////////////////////////////////////////// +/** + * Useful Macros + * by subcrip + * (requires C++17) + */ + +#include +#include +using namespace std; +using namespace __gnu_cxx; +using namespace __gnu_pbds; + +/* 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) decltype(container)::value_type + +/* type aliases */ +using ll = int64_t; +using ull = uint64_t; +using pii = pair; +using pil = pair; +using pli = pair; +using pll = pair; + +/* constants */ +constexpr int INF = 0x3f3f3f3f; +constexpr ll INFLL = 0x3f3f3f3f3f3f3f3fLL; +constexpr ull MDL = 1e9 + 7; +constexpr ull PRIME = 998'244'353; +constexpr ll MDL1 = 8784491; +constexpr ll MDL2 = PRIME; + +/* random */ + +mt19937 rd(chrono::duration_cast(chrono::system_clock::now().time_since_epoch()).count()); + +/* bit-wise operations */ +#define lowbit(x) ((x) & -(x)) +#define popcount(x) (__builtin_popcountll(ll(x))) +#define parity(x) (__builtin_parityll(ll(x))) +#define msp(x) (63LL - __builtin_clzll(ll(x))) +#define lsp(x) (__builtin_ctzll(ll(x))) + +/* arithmetic operations */ +#define mod(x, y) ((((x) % (y)) + (y)) % (y)) + +/* fast pairs */ +#define upair ull +#define umake(x, y) (ull(x) << 32 | (ull(y) & ((1ULL << 32) - 1))) +#define u1(p) ((p) >> 32) +#define u2(p) ((p) & ((1ULL << 32) - 1)) +#define ult std::less +#define ugt std::greater + +#define ipair ull +#define imake(x, y) (umake(x, y)) +#define i1(p) (int(u1(ll(p)))) +#define i2(p) (ll(u2(p) << 32) >> 32) +struct ilt { + bool operator()(const ipair& a, const ipair& b) const { + if (i1(a) == i1(b)) return i2(a) < i2(b); + else return i1(a) < i1(b); + } +}; +struct igt { + bool operator()(const ipair& a, const ipair& b) const { + if (i1(a) == i1(b)) return i2(a) > i2(b); + else return i1(a) > i1(b); + } +}; + +/* conditions */ +#define loop while (1) +#define if_or(var, val) if (!(var == val)) var = val; else +#define continue_or(var, val) __AS_PROCEDURE(if (var == val) continue; var = val;) +#define break_or(var, val) __AS_PROCEDURE(if (var == val) break; var = val;) + +/* hash */ +struct safe_hash { + // https://codeforces.com/blog/entry/62393 + static uint64_t splitmix64(uint64_t x) { + // http://xorshift.di.unimi.it/splitmix64.c + x += 0x9e3779b97f4a7c15; + x = (x ^ (x >> 30)) * 0xbf58476d1ce4e5b9; + x = (x ^ (x >> 27)) * 0x94d049bb133111eb; + return x ^ (x >> 31); + } + + size_t operator()(uint64_t x) const { + static const uint64_t FIXED_RANDOM = chrono::steady_clock::now().time_since_epoch().count(); + return splitmix64(x + FIXED_RANDOM); + } +}; + +struct pair_hash { + template + size_t operator()(const pair& a) const { + auto hash1 = safe_hash()(a.first); + auto hash2 = safe_hash()(a.second); + if (hash1 != hash2) { + return hash1 ^ hash2; + } + return hash1; + } +}; + +/* build data structures */ +#define unordered_counter(from, to) __AS_PROCEDURE(unordered_map<__as_typeof(from), size_t, safe_hash> to; for (auto&& x : from) ++to[x];) +#define counter(from, to, cmp) __AS_PROCEDURE(map<__as_typeof(from), size_t, cmp> to; for (auto&& x : from) ++to[x];) +#define pa(a) __AS_PROCEDURE(__typeof(a) pa; pa.push_back({}); for (auto&&x : a) pa.push_back(pa.back() + x);) +#define sa(a) __AS_PROCEDURE(__typeof(a) sa(a.size() + 1); {int n = a.size(); for (int i = n - 1; i >= 0; --i) sa[i] = sa[i + 1] + a[i];};) +#define adj(ch, n) __AS_PROCEDURE(vector> ch((n) + 1);) +#define edge(ch, u, v) __AS_PROCEDURE(ch[u].push_back(v), ch[v].push_back(u);) +#define Edge(ch, u, v) __AS_PROCEDURE(ch[u].push_back(v);) + +/* io */ +#define untie __AS_PROCEDURE(ios_base::sync_with_stdio(0), cin.tie(NULL)) +template void __read(T& x) { cin >> x; } +template void __read(T& x, U&... args) { cin >> x; __read(args...); } +#define read(type, ...) __AS_PROCEDURE(type __VA_ARGS__; __read(__VA_ARGS__);) +#define readvec(type, a, n) __AS_PROCEDURE(vector a(n); for (int i = 0; i < (n); ++i) cin >> a[i];) +#define putvec(a) __AS_PROCEDURE(for (auto&& x : a) cout << x << ' '; cout << endl;) +#define debug(x) __AS_PROCEDURE(cerr << #x" = " << (x) << endl;) +#define debugvec(a) __AS_PROCEDURE(cerr << #a" = "; for (auto&& x : a) cerr << x << ' '; cerr << endl;) +template ostream& operator<<(ostream& out, vector vec) { + for (auto&& i : vec) out << i << ' '; + return out; +} + +/* pops */ +#define poptop(q, ...) __AS_PROCEDURE(auto [__VA_ARGS__] = q.top(); q.pop();) +#define popback(q, ...) __AS_PROCEDURE(auto [__VA_ARGS__] = q.back(); q.pop_back();) +#define popfront(q, ...) __AS_PROCEDURE(auto [__VA_ARGS__] = q.front();q.pop_front();) + +/* math */ +constexpr inline int lg2(ll x) { return x == 0 ? -1 : sizeof(ll) * 8 - 1 - __builtin_clzll(x); } + +void __exgcd(ll a, ll b, ll& x, ll& y) { + if (b == 0) { + x = 1, y = 0; + return; + } + __exgcd(b, a % b, y, x); + y -= a / b * x; +} + +ll inverse(ll a, ll b) { + ll x, y; + __exgcd(a, b, x, y); + return mod(x, b); +} + +/* string algorithms */ +vector calc_next(string t) { // pi function of t + int n = (int)t.length(); + vector pi(n); + for (int i = 1; i < n; i++) { + int j = pi[i - 1]; + while (j > 0 && t[i] != t[j]) j = pi[j - 1]; + if (t[i] == t[j]) j++; + pi[i] = j; + } + return pi; +} +vector calc_z(string t) { // z function of t + int m = t.length(); + vector z; + z.push_back(m); + pair prev = {1, -1}; + for (int i = 1; i < m; ++i) { + if (z[i - prev.first] + i <= prev.second) { + z.push_back(z[i - prev.first]); + } else { + int j = max(i, prev.second + 1); + while (j < m && t[j] == t[j - i]) ++j; + z.push_back(j - i); + prev = {i, j - 1}; + } + } + return z; +} +vector kmp(string s, string t) { // find all t in s + string cur = t + '#' + s; + int sz1 = s.size(), sz2 = t.size(); + vector v; + vector lps = calc_next(cur); + for (int i = sz2 + 1; i <= sz1 + sz2; i++) { + if (lps[i] == sz2) v.push_back(i - 2 * sz2); + } + return v; +} +int period(string s) { // find the length of shortest recurring period + int n = s.length(); + auto z = calc_z(s); + for (int i = 1; i <= n / 2; ++i) { + if (n % i == 0 && z[i] == n - i) { + return i; + } + } + return n; +} +///////////////////////////////////////////////////////// + + +// #define SINGLE_TEST_CASE +// #define DUMP_TEST_CASE 512 + +void dump() {} + +void solve() { + read(int, n, k); + read(string, a); + read(string, b); + if (k >= n) { + if (a == b) { + cout << "YES\n"; + } else { + cout << "NO\n"; + } + return;; + } + string sa = a, sb = b; + sort(sa.begin(), sa.end()); + sort(sb.begin(), sb.end()); + if (sa != sb) { + cout << "NO\n"; + return; + } + if (n - k >= k) { + cout << "YES\n"; + return; + } + string p1(a.begin() + n - k, a.begin() + k), p2(b.begin() + n - k, b.begin() + k); + if (p1 == p2) { + cout << "YES\n"; + } else { + cout << "NO\n"; + } +} + +int main() { + untie, cout.tie(NULL); +#ifdef SINGLE_TEST_CASE + solve(); +#else + read(int, t); + for (int i = 0; i < t; ++i) { +#ifdef DUMP_TEST_CASE + if (i + 1 == (DUMP_TEST_CASE)) { + dump(); + } else { + solve(); + } +#else + solve(); +#endif + } +#endif +} diff --git a/src/bin/cf-1811e.cc b/src/bin/cf-1811e.cc new file mode 100644 index 0000000..dd763a9 --- /dev/null +++ b/src/bin/cf-1811e.cc @@ -0,0 +1,309 @@ +#pragma GCC optimize("Ofast") +///////////////////////////////////////////////////////// +/** + * Useful Macros + * by subcrip + * (requires C++17) + */ + +#include +#include +using namespace std; +using namespace __gnu_cxx; +using namespace __gnu_pbds; + +/* 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) decltype(container)::value_type + +/* type aliases */ +using ll = int64_t; +using ull = uint64_t; +using pii = pair; +using pil = pair; +using pli = pair; +using pll = pair; + +/* constants */ +constexpr int INF = 0x3f3f3f3f; +constexpr ll INFLL = 0x3f3f3f3f3f3f3f3fLL; +constexpr ull MDL = 1e9 + 7; +constexpr ull PRIME = 998'244'353; +constexpr ll MDL1 = 8784491; +constexpr ll MDL2 = PRIME; + +/* random */ + +mt19937 rd(chrono::duration_cast(chrono::system_clock::now().time_since_epoch()).count()); + +/* bit-wise operations */ +#define lowbit(x) ((x) & -(x)) +#define popcount(x) (__builtin_popcountll(ll(x))) +#define parity(x) (__builtin_parityll(ll(x))) +#define msp(x) (63LL - __builtin_clzll(ll(x))) +#define lsp(x) (__builtin_ctzll(ll(x))) + +/* arithmetic operations */ +#define mod(x, y) ((((x) % (y)) + (y)) % (y)) + +/* fast pairs */ +#define upair ull +#define umake(x, y) (ull(x) << 32 | (ull(y) & ((1ULL << 32) - 1))) +#define u1(p) ((p) >> 32) +#define u2(p) ((p) & ((1ULL << 32) - 1)) +#define ult std::less +#define ugt std::greater + +#define ipair ull +#define imake(x, y) (umake(x, y)) +#define i1(p) (int(u1(ll(p)))) +#define i2(p) (ll(u2(p) << 32) >> 32) +struct ilt { + bool operator()(const ipair& a, const ipair& b) const { + if (i1(a) == i1(b)) return i2(a) < i2(b); + else return i1(a) < i1(b); + } +}; +struct igt { + bool operator()(const ipair& a, const ipair& b) const { + if (i1(a) == i1(b)) return i2(a) > i2(b); + else return i1(a) > i1(b); + } +}; + +/* conditions */ +#define loop while (1) +#define if_or(var, val) if (!(var == val)) var = val; else +#define continue_or(var, val) __AS_PROCEDURE(if (var == val) continue; var = val;) +#define break_or(var, val) __AS_PROCEDURE(if (var == val) break; var = val;) + +/* hash */ +struct safe_hash { + // https://codeforces.com/blog/entry/62393 + static uint64_t splitmix64(uint64_t x) { + // http://xorshift.di.unimi.it/splitmix64.c + x += 0x9e3779b97f4a7c15; + x = (x ^ (x >> 30)) * 0xbf58476d1ce4e5b9; + x = (x ^ (x >> 27)) * 0x94d049bb133111eb; + return x ^ (x >> 31); + } + + size_t operator()(uint64_t x) const { + static const uint64_t FIXED_RANDOM = chrono::steady_clock::now().time_since_epoch().count(); + return splitmix64(x + FIXED_RANDOM); + } +}; + +struct pair_hash { + template + size_t operator()(const pair& a) const { + auto hash1 = safe_hash()(a.first); + auto hash2 = safe_hash()(a.second); + if (hash1 != hash2) { + return hash1 ^ hash2; + } + return hash1; + } +}; + +/* build data structures */ +#define unordered_counter(from, to) __AS_PROCEDURE(unordered_map<__as_typeof(from), size_t, safe_hash> to; for (auto&& x : from) ++to[x];) +#define counter(from, to, cmp) __AS_PROCEDURE(map<__as_typeof(from), size_t, cmp> to; for (auto&& x : from) ++to[x];) +#define pa(a) __AS_PROCEDURE(__typeof(a) pa; pa.push_back({}); for (auto&&x : a) pa.push_back(pa.back() + x);) +#define sa(a) __AS_PROCEDURE(__typeof(a) sa(a.size() + 1); {int n = a.size(); for (int i = n - 1; i >= 0; --i) sa[i] = sa[i + 1] + a[i];};) +#define adj(ch, n) __AS_PROCEDURE(vector> ch((n) + 1);) +#define edge(ch, u, v) __AS_PROCEDURE(ch[u].push_back(v), ch[v].push_back(u);) +#define Edge(ch, u, v) __AS_PROCEDURE(ch[u].push_back(v);) + +/* io */ +#define untie __AS_PROCEDURE(ios_base::sync_with_stdio(0), cin.tie(NULL)) +template void __read(T& x) { cin >> x; } +template void __read(T& x, U&... args) { cin >> x; __read(args...); } +#define read(type, ...) __AS_PROCEDURE(type __VA_ARGS__; __read(__VA_ARGS__);) +#define readvec(type, a, n) __AS_PROCEDURE(vector a(n); for (int i = 0; i < (n); ++i) cin >> a[i];) +#define putvec(a) __AS_PROCEDURE(for (auto&& x : a) cout << x << ' '; cout << endl;) +#define debug(x) __AS_PROCEDURE(cerr << #x" = " << (x) << endl;) +#define debugvec(a) __AS_PROCEDURE(cerr << #a" = "; for (auto&& x : a) cerr << x << ' '; cerr << endl;) +template ostream& operator<<(ostream& out, vector vec) { + for (auto&& i : vec) out << i << ' '; + return out; +} + +/* pops */ +#define poptop(q, ...) __AS_PROCEDURE(auto [__VA_ARGS__] = q.top(); q.pop();) +#define popback(q, ...) __AS_PROCEDURE(auto [__VA_ARGS__] = q.back(); q.pop_back();) +#define popfront(q, ...) __AS_PROCEDURE(auto [__VA_ARGS__] = q.front();q.pop_front();) + +/* math */ +constexpr inline int lg2(ll x) { return x == 0 ? -1 : sizeof(ll) * 8 - 1 - __builtin_clzll(x); } + +void __exgcd(ll a, ll b, ll& x, ll& y) { + if (b == 0) { + x = 1, y = 0; + return; + } + __exgcd(b, a % b, y, x); + y -= a / b * x; +} + +ll inverse(ll a, ll b) { + ll x, y; + __exgcd(a, b, x, y); + return mod(x, b); +} + +/* string algorithms */ +vector calc_next(string t) { // pi function of t + int n = (int)t.length(); + vector pi(n); + for (int i = 1; i < n; i++) { + int j = pi[i - 1]; + while (j > 0 && t[i] != t[j]) j = pi[j - 1]; + if (t[i] == t[j]) j++; + pi[i] = j; + } + return pi; +} +vector calc_z(string t) { // z function of t + int m = t.length(); + vector z; + z.push_back(m); + pair prev = {1, -1}; + for (int i = 1; i < m; ++i) { + if (z[i - prev.first] + i <= prev.second) { + z.push_back(z[i - prev.first]); + } else { + int j = max(i, prev.second + 1); + while (j < m && t[j] == t[j - i]) ++j; + z.push_back(j - i); + prev = {i, j - 1}; + } + } + return z; +} +vector kmp(string s, string t) { // find all t in s + string cur = t + '#' + s; + int sz1 = s.size(), sz2 = t.size(); + vector v; + vector lps = calc_next(cur); + for (int i = sz2 + 1; i <= sz1 + sz2; i++) { + if (lps[i] == sz2) v.push_back(i - 2 * sz2); + } + return v; +} +int period(string s) { // find the length of shortest recurring period + int n = s.length(); + auto z = calc_z(s); + for (int i = 1; i <= n / 2; ++i) { + if (n % i == 0 && z[i] == n - i) { + return i; + } + } + return n; +} +///////////////////////////////////////////////////////// + + +// #define SINGLE_TEST_CASE +// #define DUMP_TEST_CASE 512 + +void dump() {} + +ll full[19]; +ll pw[19]; + +void prep() { + full[1] = 1; + pw[1] = 10; + pw[0] = 1; + for (int i = 2; i <= 18; ++i) { + full[i] = full[i-1] * 9 + pw[i-1]; + pw[i] = pw[i-1] * 10; + } +} + +void solve() { + read(ll, k); + auto gettot = [] (ll x) -> int{ + int res = 0; + while (x) { + res += 1; + x /= 10; + } + return res; + }; + auto get = [] (ll x, int b) -> int { + for (int i = 0; i < b; ++i) { + x /= 10; + } + return x % 10; + }; + auto so = [&] (ll x) -> ll { + ll cnt = 0; + int tot = gettot(x); + int mark = 0; + for (int b = tot - 1; b > 0; --b) { + // b - 1 + for (int j = 1; j < 10; ++j) { + if (j == 4) { + cnt += pw[b-1]; + } else { + cnt += full[b-1]; + } + } + } + for (int b = tot - 1; ~b; --b) { + int digit = get(x, b); + for (int j = 0; j < digit; ++j) { + if (b == tot - 1 && j == 0) continue; + if (mark) { + cnt += pw[b]; + } else { + if (j == 4) { + cnt += pw[b]; + } else { + cnt += full[b]; + } + } + } + if (digit == 4) mark = 1; + } + if (mark) cnt += 1; + return cnt; + }; + ll l = 1, r = INFLL; + while (l < r) { + ll mid = l + r >> 1; + if (mid - so(mid) < k) { + l = mid + 1; + } else { + r = mid; + } + } + cout << l << endl; +} + +int main() { + prep(); + untie, cout.tie(NULL); +#ifdef SINGLE_TEST_CASE + solve(); +#else + read(int, t); + for (int i = 0; i < t; ++i) { +#ifdef DUMP_TEST_CASE + if (i + 1 == (DUMP_TEST_CASE)) { + dump(); + } else { + solve(); + } +#else + solve(); +#endif + } +#endif +} diff --git a/src/bin/cf-1846g.cc b/src/bin/cf-1846g.cc new file mode 100644 index 0000000..7cd1100 --- /dev/null +++ b/src/bin/cf-1846g.cc @@ -0,0 +1,281 @@ +#pragma GCC optimize("Ofast") +///////////////////////////////////////////////////////// +/** + * Useful Macros + * by subcrip + * (requires C++17) + */ + +#include +#include +using namespace std; +using namespace __gnu_cxx; +using namespace __gnu_pbds; + +/* 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) decltype(container)::value_type + +/* type aliases */ +using ll = int64_t; +using ull = uint64_t; +using pii = pair; +using pil = pair; +using pli = pair; +using pll = pair; + +/* constants */ +constexpr int INF = 0x3f3f3f3f; +constexpr ll INFLL = 0x3f3f3f3f3f3f3f3fLL; +constexpr ull MDL = 1e9 + 7; +constexpr ull PRIME = 998'244'353; +constexpr ll MDL1 = 8784491; +constexpr ll MDL2 = PRIME; + +/* random */ + +mt19937 rd(chrono::duration_cast(chrono::system_clock::now().time_since_epoch()).count()); + +/* bit-wise operations */ +#define lowbit(x) ((x) & -(x)) +#define popcount(x) (__builtin_popcountll(ll(x))) +#define parity(x) (__builtin_parityll(ll(x))) +#define msp(x) (63LL - __builtin_clzll(ll(x))) +#define lsp(x) (__builtin_ctzll(ll(x))) + +/* arithmetic operations */ +#define mod(x, y) ((((x) % (y)) + (y)) % (y)) + +/* fast pairs */ +#define upair ull +#define umake(x, y) (ull(x) << 32 | (ull(y) & ((1ULL << 32) - 1))) +#define u1(p) ((p) >> 32) +#define u2(p) ((p) & ((1ULL << 32) - 1)) +#define ult std::less +#define ugt std::greater + +#define ipair ull +#define imake(x, y) (umake(x, y)) +#define i1(p) (int(u1(ll(p)))) +#define i2(p) (ll(u2(p) << 32) >> 32) +struct ilt { + bool operator()(const ipair& a, const ipair& b) const { + if (i1(a) == i1(b)) return i2(a) < i2(b); + else return i1(a) < i1(b); + } +}; +struct igt { + bool operator()(const ipair& a, const ipair& b) const { + if (i1(a) == i1(b)) return i2(a) > i2(b); + else return i1(a) > i1(b); + } +}; + +/* conditions */ +#define loop while (1) +#define if_or(var, val) if (!(var == val)) var = val; else +#define continue_or(var, val) __AS_PROCEDURE(if (var == val) continue; var = val;) +#define break_or(var, val) __AS_PROCEDURE(if (var == val) break; var = val;) + +/* hash */ +struct safe_hash { + // https://codeforces.com/blog/entry/62393 + static uint64_t splitmix64(uint64_t x) { + // http://xorshift.di.unimi.it/splitmix64.c + x += 0x9e3779b97f4a7c15; + x = (x ^ (x >> 30)) * 0xbf58476d1ce4e5b9; + x = (x ^ (x >> 27)) * 0x94d049bb133111eb; + return x ^ (x >> 31); + } + + size_t operator()(uint64_t x) const { + static const uint64_t FIXED_RANDOM = chrono::steady_clock::now().time_since_epoch().count(); + return splitmix64(x + FIXED_RANDOM); + } +}; + +struct pair_hash { + template + size_t operator()(const pair& a) const { + auto hash1 = safe_hash()(a.first); + auto hash2 = safe_hash()(a.second); + if (hash1 != hash2) { + return hash1 ^ hash2; + } + return hash1; + } +}; + +/* build data structures */ +#define unordered_counter(from, to) __AS_PROCEDURE(unordered_map<__as_typeof(from), size_t, safe_hash> to; for (auto&& x : from) ++to[x];) +#define counter(from, to, cmp) __AS_PROCEDURE(map<__as_typeof(from), size_t, cmp> to; for (auto&& x : from) ++to[x];) +#define pa(a) __AS_PROCEDURE(__typeof(a) pa; pa.push_back({}); for (auto&&x : a) pa.push_back(pa.back() + x);) +#define sa(a) __AS_PROCEDURE(__typeof(a) sa(a.size() + 1); {int n = a.size(); for (int i = n - 1; i >= 0; --i) sa[i] = sa[i + 1] + a[i];};) +#define adj(ch, n) __AS_PROCEDURE(vector> ch((n) + 1);) +#define edge(ch, u, v) __AS_PROCEDURE(ch[u].push_back(v), ch[v].push_back(u);) +#define Edge(ch, u, v) __AS_PROCEDURE(ch[u].push_back(v);) + +/* io */ +#define untie __AS_PROCEDURE(ios_base::sync_with_stdio(0), cin.tie(NULL)) +template void __read(T& x) { cin >> x; } +template void __read(T& x, U&... args) { cin >> x; __read(args...); } +#define read(type, ...) __AS_PROCEDURE(type __VA_ARGS__; __read(__VA_ARGS__);) +#define readvec(type, a, n) __AS_PROCEDURE(vector a(n); for (int i = 0; i < (n); ++i) cin >> a[i];) +#define putvec(a) __AS_PROCEDURE(for (auto&& x : a) cout << x << ' '; cout << endl;) +#define debug(x) __AS_PROCEDURE(cerr << #x" = " << (x) << endl;) +#define debugvec(a) __AS_PROCEDURE(cerr << #a" = "; for (auto&& x : a) cerr << x << ' '; cerr << endl;) +template ostream& operator<<(ostream& out, vector vec) { + for (auto&& i : vec) out << i << ' '; + return out; +} + +/* pops */ +#define poptop(q, ...) __AS_PROCEDURE(auto [__VA_ARGS__] = q.top(); q.pop();) +#define popback(q, ...) __AS_PROCEDURE(auto [__VA_ARGS__] = q.back(); q.pop_back();) +#define popfront(q, ...) __AS_PROCEDURE(auto [__VA_ARGS__] = q.front();q.pop_front();) + +/* math */ +constexpr inline int lg2(ll x) { return x == 0 ? -1 : sizeof(ll) * 8 - 1 - __builtin_clzll(x); } + +void __exgcd(ll a, ll b, ll& x, ll& y) { + if (b == 0) { + x = 1, y = 0; + return; + } + __exgcd(b, a % b, y, x); + y -= a / b * x; +} + +ll inverse(ll a, ll b) { + ll x, y; + __exgcd(a, b, x, y); + return mod(x, b); +} + +/* string algorithms */ +vector calc_next(string t) { // pi function of t + int n = (int)t.length(); + vector pi(n); + for (int i = 1; i < n; i++) { + int j = pi[i - 1]; + while (j > 0 && t[i] != t[j]) j = pi[j - 1]; + if (t[i] == t[j]) j++; + pi[i] = j; + } + return pi; +} +vector calc_z(string t) { // z function of t + int m = t.length(); + vector z; + z.push_back(m); + pair prev = {1, -1}; + for (int i = 1; i < m; ++i) { + if (z[i - prev.first] + i <= prev.second) { + z.push_back(z[i - prev.first]); + } else { + int j = max(i, prev.second + 1); + while (j < m && t[j] == t[j - i]) ++j; + z.push_back(j - i); + prev = {i, j - 1}; + } + } + return z; +} +vector kmp(string s, string t) { // find all t in s + string cur = t + '#' + s; + int sz1 = s.size(), sz2 = t.size(); + vector v; + vector lps = calc_next(cur); + for (int i = sz2 + 1; i <= sz1 + sz2; i++) { + if (lps[i] == sz2) v.push_back(i - 2 * sz2); + } + return v; +} +int period(string s) { // find the length of shortest recurring period + int n = s.length(); + auto z = calc_z(s); + for (int i = 1; i <= n / 2; ++i) { + if (n % i == 0 && z[i] == n - i) { + return i; + } + } + return n; +} +///////////////////////////////////////////////////////// + + +// #define SINGLE_TEST_CASE +// #define DUMP_TEST_CASE 512 + +void dump() {} + +int read_binary(int length) { + int res = 0; + for (int i = length - 1; ~i; --i) { + read(char, c); + res |= int(c - 48) << i; + } + return res; +} + +void solve() { + read(int, n, m); + vector> ch(1 << n); + vector> masks; + int start = read_binary(n); + while (m--) { + read(int, d); + int x = read_binary(n), y = read_binary(n); + masks.emplace_back(x, y, d); + } + for (int i = 0; i < (1 << n); ++i) { + for (auto&& [rem, add, w] : masks) { + ch[i].emplace_back((i & ~rem) | add, w); + } + } + std::priority_queue, greater<>> pq; + pq.emplace(0, start); + vector vis(1 << n); + vector dis(1 << n, INFLL); + dis[start] = 0; + while (pq.size()) { + auto [_, v] = pq.top(); pq.pop(); + continue_or(vis[v], 1); + for (auto&& [u, w] : ch[v]) { + if (!vis[u] && dis[v] + w < dis[u]) { + dis[u] = dis[v] + w; + pq.emplace(dis[u], u); + } + } + } + if (dis[0] == INFLL) { + cout << -1 << endl; + } else { + cout << dis[0] << endl; + } + +} + +int main() { + untie, cout.tie(NULL); +#ifdef SINGLE_TEST_CASE + solve(); +#else + read(int, t); + for (int i = 0; i < t; ++i) { +#ifdef DUMP_TEST_CASE + if (i + 1 == (DUMP_TEST_CASE)) { + dump(); + } else { + solve(); + } +#else + solve(); +#endif + } +#endif +} diff --git a/src/bin/cf-1849d.cc b/src/bin/cf-1849d.cc new file mode 100644 index 0000000..3e0142e --- /dev/null +++ b/src/bin/cf-1849d.cc @@ -0,0 +1,185 @@ +///////////////////////////////////////////////////////// +/** + * Useful Macros + * by subcrip + * (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) decltype(container)::value_type + +/* type aliases */ +using ll = int64_t; +using ull = uint64_t; +using pii = pair; +using pil = pair; +using pli = pair; +using pll = pair; + +/* constants */ +constexpr int INF = 0x3f3f3f3f; +constexpr ull MDL = 1e9 + 7; +constexpr ull PRIME = 998'244'353; +constexpr ull MDL1 = 825; +constexpr ull MDL2 = 87825; + +/* 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)) + +/* fast pairs */ +#define upair ull +#define umake(x, y) (ull(x) << 32 | ull(y)) +#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(p))) +#define i2(p) (int(u2(p))) +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;) + +/* build data structures */ +#define unordered_counter(from, to) __AS_PROCEDURE(unordered_map<__as_typeof(from), size_t> to; for (auto&& x : from) ++to[x];) +#define counter(from, to, cmp) __AS_PROCEDURE(map<__as_typeof(from), size_t, cmp> to; for (auto&& x : from) ++to[x];) +#define pa(a) __AS_PROCEDURE(__typeof(a) pa; pa.push_back({}); for (auto&&x : a) pa.push_back(pa.back() + x);) +#define sa(a) __AS_PROCEDURE(__typeof(a) sa(a.size() + 1); {int n = a.size(); for (int i = n - 1; i >= 0; --i) sa[i] = sa[i + 1] + a[i];};) +#define adj(ch, n) __AS_PROCEDURE(vector> ch((n) + 1);) +#define edge(ch, u, v) __AS_PROCEDURE(ch[u].push_back(v), ch[v].push_back(u);) +#define Edge(ch, u, v) __AS_PROCEDURE(ch[u].push_back(v);) + +/* io */ +#define untie __AS_PROCEDURE(ios_base::sync_with_stdio(0), cin.tie(NULL)) +template void __read(T& x) { cin >> x; } +template void __read(T& x, U&... args) { cin >> x; __read(args...); } +#define read(type, ...) __AS_PROCEDURE(type __VA_ARGS__; __read(__VA_ARGS__);) +#define readvec(type, a, n) __AS_PROCEDURE(vector a(n); for (int i = 0; i < (n); ++i) cin >> a[i];) +#define putvec(a) __AS_PROCEDURE(for (auto&& x : a) cout << x << ' '; cout << endl;) +#define debug(x) __AS_PROCEDURE(cerr << #x" = " << (x) << endl;) +#define debugvec(a) __AS_PROCEDURE(cerr << #a" = "; for (auto&& x : a) cerr << x << ' '; cerr << endl;) +template ostream& operator<<(ostream& out, vector vec) { + for (auto&& i : vec) out << i << ' '; + return out; +} + +/* pops */ +#define poptop(q, ...) __AS_PROCEDURE(auto [__VA_ARGS__] = q.top(); q.pop();) +#define popback(q, ...) __AS_PROCEDURE(auto [__VA_ARGS__] = q.back(); q.pop_back();) +#define popfront(q, ...) __AS_PROCEDURE(auto [__VA_ARGS__] = q.front();q.pop_front();) + +/* algorithms */ + +vector calc_next(string t) { // pi function of t + int n = (int)t.length(); + vector pi(n); + for (int i = 1; i < n; i++) { + int j = pi[i - 1]; + while (j > 0 && t[i] != t[j]) j = pi[j - 1]; + if (t[i] == t[j]) j++; + pi[i] = j; + } + return pi; +} +vector calc_z(string t) { // z function of t + int m = t.length(); + vector z; + z.push_back(m); + pair prev = {1, -1}; + for (int i = 1; i < m; ++i) { + if (z[i - prev.first] + i <= prev.second) { + z.push_back(z[i - prev.first]); + } else { + int j = max(i, prev.second + 1); + while (j < m && t[j] == t[j - i]) ++j; + z.push_back(j - i); + prev = {i, j - 1}; + } + } + return z; +} +vector kmp(string s, string t) { // find all t in s + string cur = t + '#' + s; + int sz1 = s.size(), sz2 = t.size(); + vector v; + vector lps = calc_next(cur); + for (int i = sz2 + 1; i <= sz1 + sz2; i++) { + if (lps[i] == sz2) v.push_back(i - 2 * sz2); + } + return v; +} +int period(string s) { // find the length of shortest recurring period + int n = s.length(); + auto z = calc_z(s); + for (int i = 1; i <= n / 2; ++i) { + if (n % i == 0 && z[i] == n - i) { + return i; + } + } + return n; +} +///////////////////////////////////////////////////////// + +int main() { + read(int, n); + readvec(int, a, n); + a.push_back(0); + int left_full = 1; + int res = 0; + int has_2 = 0, has_1 = 0; + for (int i = 0; i <= n; ++i) { + if (a[i] == 0) { + if (has_2) { + res += 1; + left_full = 1; + } else if (has_1) { + res += 1; + left_full = left_full; + } else { + if (!left_full) { + res += 1; + } + left_full = 0; + } + has_2 = 0; + has_1 = 0; + } else if (a[i] == 1) { + has_1 = 1; + } else { + has_2 = 1; + } + } + cout << res; +} \ No newline at end of file diff --git a/src/bin/cf-1850h.cc b/src/bin/cf-1850h.cc new file mode 100644 index 0000000..45110b2 --- /dev/null +++ b/src/bin/cf-1850h.cc @@ -0,0 +1,196 @@ +///////////////////////////////////////////////////////// +/** + * Useful Macros + * by subcrip + * (requires C++17) + */ + +#include +#include +using namespace std; + +/* macro helpers */ +#define __NARGS(...) std::tuple_size::value +#define __DECOMPOSE_S(a, x) auto x = a; +#define __DECOMPOSE_N(a, ...) auto [__VA_ARGS__] = a; +constexpr void __() {} +#define __AS_PROCEDURE(...) __(); __VA_ARGS__; __() +#define __as_typeof(container) decltype(container)::value_type + +/* type aliases */ +using ll = int64_t; +using ull = uint64_t; +using pii = pair; +using pil = pair; +using pli = pair; +using pll = pair; + +/* constants */ +constexpr int INF = 0x3f3f3f3f; +constexpr ull MDL = 1e9 + 7; +constexpr ull PRIME = 998'244'353; +constexpr ull MDL1 = 825; +constexpr ull MDL2 = 87825; + +/* 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)) + +/* fast pairs */ +#define upair ull +#define umake(x, y) (ull(x) << 32 | ull(y)) +#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(p))) +#define i2(p) (int(u2(p))) +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;) + +/* build data structures */ +#define unordered_counter(from, to) __AS_PROCEDURE(unordered_map<__as_typeof(from), size_t> to; for (auto&& x : from) ++to[x];) +#define counter(from, to, cmp) __AS_PROCEDURE(map<__as_typeof(from), size_t, cmp> to; for (auto&& x : from) ++to[x];) +#define pa(a) __AS_PROCEDURE(__typeof(a) pa; pa.push_back({}); for (auto&&x : a) pa.push_back(pa.back() + x);) +#define sa(a) __AS_PROCEDURE(__typeof(a) sa(a.size() + 1); {int n = a.size(); for (int i = n - 1; i >= 0; --i) sa[i] = sa[i + 1] + a[i];};) +#define adj(ch, n) __AS_PROCEDURE(vector> ch((n) + 1);) +#define edge(ch, u, v) __AS_PROCEDURE(ch[u].push_back(v), ch[v].push_back(u);) +#define Edge(ch, u, v) __AS_PROCEDURE(ch[u].push_back(v);) + +/* io */ +#define untie __AS_PROCEDURE(ios_base::sync_with_stdio(0), cin.tie(NULL)) +template void __read(T& x) { cin >> x; } +template void __read(T& x, U&... args) { cin >> x; __read(args...); } +#define read(type, ...) __AS_PROCEDURE(type __VA_ARGS__; __read(__VA_ARGS__);) +#define readvec(type, a, n) __AS_PROCEDURE(vector a(n); for (int i = 0; i < (n); ++i) cin >> a[i];) +#define putvec(a) __AS_PROCEDURE(for (auto&& x : a) cout << x << ' '; cout << endl;) +#define debug(x) __AS_PROCEDURE(cerr << #x" = " << (x) << endl;) +#define debugvec(a) __AS_PROCEDURE(cerr << #a" = "; for (auto&& x : a) cerr << x << ' '; cerr << endl;) +template ostream& operator<<(ostream& out, vector vec) { + for (auto&& i : vec) out << i << ' '; + return out; +} + +/* pops */ +#define poptop(q, ...) __AS_PROCEDURE(auto [__VA_ARGS__] = q.top(); q.pop();) +#define popback(q, ...) __AS_PROCEDURE(auto [__VA_ARGS__] = q.back(); q.pop_back();) +#define popfront(q, ...) __AS_PROCEDURE(auto [__VA_ARGS__] = q.front();q.pop_front();) + +/* algorithms */ + +vector calc_next(string t) { // pi function of t + int n = (int)t.length(); + vector pi(n); + for (int i = 1; i < n; i++) { + int j = pi[i - 1]; + while (j > 0 && t[i] != t[j]) j = pi[j - 1]; + if (t[i] == t[j]) j++; + pi[i] = j; + } + return pi; +} +vector calc_z(string t) { // z function of t + int m = t.length(); + vector z; + z.push_back(m); + pair prev = {1, -1}; + for (int i = 1; i < m; ++i) { + if (z[i - prev.first] + i <= prev.second) { + z.push_back(z[i - prev.first]); + } else { + int j = max(i, prev.second + 1); + while (j < m && t[j] == t[j - i]) ++j; + z.push_back(j - i); + prev = {i, j - 1}; + } + } + return z; +} +vector kmp(string s, string t) { // find all t in s + string cur = t + '#' + s; + int sz1 = s.size(), sz2 = t.size(); + vector v; + vector lps = calc_next(cur); + for (int i = sz2 + 1; i <= sz1 + sz2; i++) { + if (lps[i] == sz2) v.push_back(i - 2 * sz2); + } + return v; +} +int period(string s) { // find the length of shortest recurring period + int n = s.length(); + auto z = calc_z(s); + for (int i = 1; i <= n / 2; ++i) { + if (n % i == 0 && z[i] == n - i) { + return i; + } + } + return n; +} +///////////////////////////////////////////////////////// + +int cnt = 0; + +void solve() { + // debug(++cnt); + read(int, n, m); + // vector> e(n + 1); + vector> e(n + 1); + vector ind(n + 1); + int f = 1; + while (m--) { + read(int, u, v, w); + e[v].emplace_back(u, w); + e[u].emplace_back(v, -w); + } + if (!f) { + cout << "NO\n"; + return; + } + unordered_map dis; + int rt = 0; + auto dfs = [&] (auto dfs, int v, ll d) -> int { + // cerr << "dfs(" << v << ", " << d << ")\n"; + if (dis.count(v)) return dis[v] == d; + dis[v] = d; + int res = 1; + for (auto&& [u, w] : e[v]) { + res &= dfs(dfs, u, d + w); + } + return res; + }; + for (rt = 1; rt <= n; ++rt) if (!dis.count(rt) && !dfs(dfs, rt, 0)) { + cout << "NO\n"; + return; + } + cout << "YES\n"; +} + +int main() { + read(int, t); + while (t--) solve(); +} \ No newline at end of file diff --git a/src/bin/cf-1851f.cc b/src/bin/cf-1851f.cc new file mode 100644 index 0000000..74a859d --- /dev/null +++ b/src/bin/cf-1851f.cc @@ -0,0 +1,224 @@ +///////////////////////////////////////////////////////// +/** + * Useful Macros + * by subcrip + * (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) decltype(container)::value_type + +/* type aliases */ +using ll = int64_t; +using ull = uint64_t; +using pii = pair; +using pil = pair; +using pli = pair; +using pll = pair; + +/* constants */ +constexpr int INF = 0x3f3f3f3f; +constexpr ull MDL = 1e9 + 7; +constexpr ull PRIME = 998'244'353; +constexpr ull MDL1 = 825; +constexpr ull MDL2 = 87825; + +/* 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)) + +/* fast pairs */ +#define upair ull +#define umake(x, y) (ull(x) << 32 | ull(y)) +#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(p))) +#define i2(p) (int(u2(p))) +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;) + +/* build data structures */ +#define unordered_counter(from, to) __AS_PROCEDURE(unordered_map<__as_typeof(from), size_t> to; for (auto&& x : from) ++to[x];) +#define counter(from, to, cmp) __AS_PROCEDURE(map<__as_typeof(from), size_t, cmp> to; for (auto&& x : from) ++to[x];) +#define pa(a) __AS_PROCEDURE(__typeof(a) pa; pa.push_back({}); for (auto&&x : a) pa.push_back(pa.back() + x);) +#define sa(a) __AS_PROCEDURE(__typeof(a) sa(a.size() + 1); {int n = a.size(); for (int i = n - 1; i >= 0; --i) sa[i] = sa[i + 1] + a[i];};) +#define adj(ch, n) __AS_PROCEDURE(vector> ch((n) + 1);) +#define edge(ch, u, v) __AS_PROCEDURE(ch[u].push_back(v), ch[v].push_back(u);) +#define Edge(ch, u, v) __AS_PROCEDURE(ch[u].push_back(v);) + +/* io */ +#define untie __AS_PROCEDURE(ios_base::sync_with_stdio(0), cin.tie(NULL)) +template void __read(T& x) { cin >> x; } +template void __read(T& x, U&... args) { cin >> x; __read(args...); } +#define read(type, ...) __AS_PROCEDURE(type __VA_ARGS__; __read(__VA_ARGS__);) +#define readvec(type, a, n) __AS_PROCEDURE(vector a(n); for (int i = 0; i < (n); ++i) cin >> a[i];) +#define putvec(a) __AS_PROCEDURE(for (auto&& x : a) cout << x << ' '; cout << endl;) +#define debug(x) __AS_PROCEDURE(cerr << #x" = " << (x) << endl;) +#define debugvec(a) __AS_PROCEDURE(cerr << #a" = "; for (auto&& x : a) cerr << x << ' '; cerr << endl;) +template ostream& operator<<(ostream& out, vector vec) { + for (auto&& i : vec) out << i << ' '; + return out; +} + +/* pops */ +#define poptop(q, ...) __AS_PROCEDURE(auto [__VA_ARGS__] = q.top(); q.pop();) +#define popback(q, ...) __AS_PROCEDURE(auto [__VA_ARGS__] = q.back(); q.pop_back();) +#define popfront(q, ...) __AS_PROCEDURE(auto [__VA_ARGS__] = q.front();q.pop_front();) + +/* algorithms */ + +vector calc_next(string t) { // pi function of t + int n = (int)t.length(); + vector pi(n); + for (int i = 1; i < n; i++) { + int j = pi[i - 1]; + while (j > 0 && t[i] != t[j]) j = pi[j - 1]; + if (t[i] == t[j]) j++; + pi[i] = j; + } + return pi; +} +vector calc_z(string t) { // z function of t + int m = t.length(); + vector z; + z.push_back(m); + pair prev = {1, -1}; + for (int i = 1; i < m; ++i) { + if (z[i - prev.first] + i <= prev.second) { + z.push_back(z[i - prev.first]); + } else { + int j = max(i, prev.second + 1); + while (j < m && t[j] == t[j - i]) ++j; + z.push_back(j - i); + prev = {i, j - 1}; + } + } + return z; +} +vector kmp(string s, string t) { // find all t in s + string cur = t + '#' + s; + int sz1 = s.size(), sz2 = t.size(); + vector v; + vector lps = calc_next(cur); + for (int i = sz2 + 1; i <= sz1 + sz2; i++) { + if (lps[i] == sz2) v.push_back(i - 2 * sz2); + } + return v; +} +int period(string s) { // find the length of shortest recurring period + int n = s.length(); + auto z = calc_z(s); + for (int i = 1; i <= n / 2; ++i) { + if (n % i == 0 && z[i] == n - i) { + return i; + } + } + return n; +} +///////////////////////////////////////////////////////// + +void solve() { + read(int, n, k); + vector a; + for (int i = 0; i < n; ++i) { + read(int, t); + a.emplace_back(t, msp(t)); + } + vector cnt(30); + vector>> trie(30, vector>(1)); + auto insert = [&] (int trie_idx, int num, int i) { + int curr = 0; + for (int bi = trie_idx; ~bi; --bi) { + int bit = (num >> bi) & 1; + if (!trie[trie_idx][curr][bit]) { + trie[trie_idx][curr][bit] = ++cnt[trie_idx]; + trie[trie_idx].push_back({}); + } + curr = trie[trie_idx][curr][bit]; + } + trie[trie_idx][curr][2] = i; + }; + + vector slot(n); + iota(slot.begin(), slot.end(), 0); + sort(slot.begin(), slot.end(), [&](int i, int j){return a[i].second < a[j].second;}); + sort(a.begin(), a.end(), [](auto&& x, auto&& y){return x.second < y.second;}); + int f_fact = 0, f_res = -1, f_this = 0, f_other = 0; + for (int j = 0; j < 30; ++j) { + insert(j, a[0].first, 0); + } + for (int i = 1; i < n; ++i) { + auto [x, msd] = a[i]; + int curr = 0; + int fact = 0; + int res = 0; + int other = 0; + for (int d = msd; ~d; --d) { + int bit = (x >> d) & 1; + if (trie[msd][curr][bit]) { + curr = trie[msd][curr][bit]; + fact |= (1 ^ bit) << d; + res |= 1 << d; + other |= bit << d; + } else { + curr = trie[msd][curr][1^bit]; + other |= (1 ^ bit) << d; + } + } + int addition = ((1 << (k - 1 - msd)) - 1) << (msd + 1); + res |= addition; + fact |= addition; + if (res > f_res) { + f_res = res; + f_fact = fact; + f_this = i; + f_other = trie[msd][curr][2]; + } + // insert + for (int j = 0; j < 30; ++j) { + insert(j, x, i); + } + } + cout << slot[f_this] + 1 << ' '<< slot[f_other] + 1 << ' '<< f_fact << endl; +} + +int main() { + // debug(msp(0)); + read(int, t); + while (t--) solve(); +} \ No newline at end of file diff --git a/src/bin/cf-1852b.cc b/src/bin/cf-1852b.cc new file mode 100644 index 0000000..ddfa1e5 --- /dev/null +++ b/src/bin/cf-1852b.cc @@ -0,0 +1,184 @@ +///////////////////////////////////////////////////////// +/** + * Useful Macros + * by subcrip + * (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) decltype(container)::value_type + +/* type aliases */ +using ll = int64_t; +using ull = uint64_t; +using pii = pair; +using pil = pair; +using pli = pair; +using pll = pair; + +/* constants */ +constexpr int INF = 0x3f3f3f3f; +constexpr ull MDL = 1e9 + 7; +constexpr ull PRIME = 998'244'353; +constexpr ull MDL1 = 825; +constexpr ull MDL2 = 87825; + +/* 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)) + +/* fast pairs */ +#define upair ull +#define umake(x, y) (ull(x) << 32 | ull(y)) +#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(p))) +#define i2(p) (int(u2(p))) +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;) + +/* build data structures */ +#define unordered_counter(from, to) __AS_PROCEDURE(unordered_map<__as_typeof(from), size_t> to; for (auto&& x : from) ++to[x];) +#define counter(from, to, cmp) __AS_PROCEDURE(map<__as_typeof(from), size_t, cmp> to; for (auto&& x : from) ++to[x];) +#define pa(a) __AS_PROCEDURE(__typeof(a) pa; pa.push_back({}); for (auto&&x : a) pa.push_back(pa.back() + x);) +#define sa(a) __AS_PROCEDURE(__typeof(a) sa(a.size() + 1); {int n = a.size(); for (int i = n - 1; i >= 0; --i) sa[i] = sa[i + 1] + a[i];};) +#define adj(ch, n) __AS_PROCEDURE(vector> ch((n) + 1);) +#define edge(ch, u, v) __AS_PROCEDURE(ch[u].push_back(v), ch[v].push_back(u);) +#define Edge(ch, u, v) __AS_PROCEDURE(ch[u].push_back(v);) + +/* io */ +#define untie __AS_PROCEDURE(ios_base::sync_with_stdio(0), cin.tie(NULL)) +template void __read(T& x) { cin >> x; } +template void __read(T& x, U&... args) { cin >> x; __read(args...); } +#define read(type, ...) __AS_PROCEDURE(type __VA_ARGS__; __read(__VA_ARGS__);) +#define readvec(type, a, n) __AS_PROCEDURE(vector a(n); for (int i = 0; i < (n); ++i) cin >> a[i];) +#define putvec(a) __AS_PROCEDURE(for (auto&& x : a) cout << x << ' '; cout << endl;) +#define debug(x) __AS_PROCEDURE(cerr << #x" = " << (x) << endl;) +#define debugvec(a) __AS_PROCEDURE(cerr << #a" = "; for (auto&& x : a) cerr << x << ' '; cerr << endl;) +template ostream& operator<<(ostream& out, vector vec) { + for (auto&& i : vec) out << i << ' '; + return out; +} + +/* pops */ +#define poptop(q, ...) __AS_PROCEDURE(auto [__VA_ARGS__] = q.top(); q.pop();) +#define popback(q, ...) __AS_PROCEDURE(auto [__VA_ARGS__] = q.back(); q.pop_back();) +#define popfront(q, ...) __AS_PROCEDURE(auto [__VA_ARGS__] = q.front();q.pop_front();) + +/* algorithms */ + +vector calc_next(string t) { // pi function of t + int n = (int)t.length(); + vector pi(n); + for (int i = 1; i < n; i++) { + int j = pi[i - 1]; + while (j > 0 && t[i] != t[j]) j = pi[j - 1]; + if (t[i] == t[j]) j++; + pi[i] = j; + } + return pi; +} +vector calc_z(string t) { // z function of t + int m = t.length(); + vector z; + z.push_back(m); + pair prev = {1, -1}; + for (int i = 1; i < m; ++i) { + if (z[i - prev.first] + i <= prev.second) { + z.push_back(z[i - prev.first]); + } else { + int j = max(i, prev.second + 1); + while (j < m && t[j] == t[j - i]) ++j; + z.push_back(j - i); + prev = {i, j - 1}; + } + } + return z; +} +vector kmp(string s, string t) { // find all t in s + string cur = t + '#' + s; + int sz1 = s.size(), sz2 = t.size(); + vector v; + vector lps = calc_next(cur); + for (int i = sz2 + 1; i <= sz1 + sz2; i++) { + if (lps[i] == sz2) v.push_back(i - 2 * sz2); + } + return v; +} +int period(string s) { // find the length of shortest recurring period + int n = s.length(); + auto z = calc_z(s); + for (int i = 1; i <= n / 2; ++i) { + if (n % i == 0 && z[i] == n - i) { + return i; + } + } + return n; +} +///////////////////////////////////////////////////////// + +void solve() { + read(int, n); + vector> slot(n + 1); + for (int i = 0; i < n; ++i) { + read(int, t); + slot[t].push_back(i); + } + int pos = 0; + vector res(n); + for (int i = n; i > 0; --i) { + if (slot[pos + i].size()) { + res[slot[pos + i].back()] = +i; + slot[pos + i].pop_back(); + pos += 1; + } else if (slot[pos].size()) { + res[slot[pos].back()] = -i; + slot[pos].pop_back(); + } else { + cout << "NO\n"; + return; + } + } + cout << "YES\n"; + putvec(res); +} + +int main() { + read(int, t); + while (t--) solve(); +} \ No newline at end of file diff --git a/src/bin/cf-1856e1.cc b/src/bin/cf-1856e1.cc new file mode 100644 index 0000000..cf5c885 --- /dev/null +++ b/src/bin/cf-1856e1.cc @@ -0,0 +1,193 @@ +#pragma GCC optimize("Ofast") + +///////////////////////////////////////////////////////// +/** + * Useful Macros + * by subcrip + * (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) decltype(container)::value_type + +/* type aliases */ +using ll = int64_t; +using ull = uint64_t; +using pii = pair; +using pil = pair; +using pli = pair; +using pll = pair; + +/* constants */ +constexpr int INF = 0x3f3f3f3f; +constexpr ull MDL = 1e9 + 7; +constexpr ull PRIME = 998'244'353; +constexpr ull MDL1 = 825; +constexpr ull MDL2 = 87825; + +/* 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)) + +/* fast pairs */ +#define upair ull +#define umake(x, y) (ull(x) << 32 | ull(y)) +#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(p))) +#define i2(p) (int(u2(p))) +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;) + +/* build data structures */ +#define unordered_counter(from, to) __AS_PROCEDURE(unordered_map<__as_typeof(from), size_t> to; for (auto&& x : from) ++to[x];) +#define counter(from, to, cmp) __AS_PROCEDURE(map<__as_typeof(from), size_t, cmp> to; for (auto&& x : from) ++to[x];) +#define pa(a) __AS_PROCEDURE(__typeof(a) pa; pa.push_back({}); for (auto&&x : a) pa.push_back(pa.back() + x);) +#define sa(a) __AS_PROCEDURE(__typeof(a) sa(a.size() + 1); {int n = a.size(); for (int i = n - 1; i >= 0; --i) sa[i] = sa[i + 1] + a[i];};) +#define adj(ch, n) __AS_PROCEDURE(vector> ch((n) + 1);) +#define edge(ch, u, v) __AS_PROCEDURE(ch[u].push_back(v), ch[v].push_back(u);) +#define Edge(ch, u, v) __AS_PROCEDURE(ch[u].push_back(v);) + +/* io */ +#define untie __AS_PROCEDURE(ios_base::sync_with_stdio(0), cin.tie(NULL)) +template void __read(T& x) { cin >> x; } +template void __read(T& x, U&... args) { cin >> x; __read(args...); } +#define read(type, ...) __AS_PROCEDURE(type __VA_ARGS__; __read(__VA_ARGS__);) +#define readvec(type, a, n) __AS_PROCEDURE(vector a(n); for (int i = 0; i < (n); ++i) cin >> a[i];) +#define putvec(a) __AS_PROCEDURE(for (auto&& x : a) cout << x << ' '; cout << endl;) +#define debug(x) __AS_PROCEDURE(cerr << #x" = " << (x) << endl;) +#define debugvec(a) __AS_PROCEDURE(cerr << #a" = "; for (auto&& x : a) cerr << x << ' '; cerr << endl;) +template ostream& operator<<(ostream& out, vector vec) { + for (auto&& i : vec) out << i << ' '; + return out; +} + +/* pops */ +#define poptop(q, ...) __AS_PROCEDURE(auto [__VA_ARGS__] = q.top(); q.pop();) +#define popback(q, ...) __AS_PROCEDURE(auto [__VA_ARGS__] = q.back(); q.pop_back();) +#define popfront(q, ...) __AS_PROCEDURE(auto [__VA_ARGS__] = q.front();q.pop_front();) + +/* algorithms */ + +vector calc_next(string t) { // pi function of t + int n = (int)t.length(); + vector pi(n); + for (int i = 1; i < n; i++) { + int j = pi[i - 1]; + while (j > 0 && t[i] != t[j]) j = pi[j - 1]; + if (t[i] == t[j]) j++; + pi[i] = j; + } + return pi; +} +vector calc_z(string t) { // z function of t + int m = t.length(); + vector z; + z.push_back(m); + pair prev = {1, -1}; + for (int i = 1; i < m; ++i) { + if (z[i - prev.first] + i <= prev.second) { + z.push_back(z[i - prev.first]); + } else { + int j = max(i, prev.second + 1); + while (j < m && t[j] == t[j - i]) ++j; + z.push_back(j - i); + prev = {i, j - 1}; + } + } + return z; +} +vector kmp(string s, string t) { // find all t in s + string cur = t + '#' + s; + int sz1 = s.size(), sz2 = t.size(); + vector v; + vector lps = calc_next(cur); + for (int i = sz2 + 1; i <= sz1 + sz2; i++) { + if (lps[i] == sz2) v.push_back(i - 2 * sz2); + } + return v; +} +int period(string s) { // find the length of shortest recurring period + int n = s.length(); + auto z = calc_z(s); + for (int i = 1; i <= n / 2; ++i) { + if (n % i == 0 && z[i] == n - i) { + return i; + } + } + return n; +} +///////////////////////////////////////////////////////// + +int main() { + untie; + read(int, n); + adj(ch, n); + for (int i = 2; i <= n; ++i) { + read(int, t); + edge(ch, i, t); + } + ll res = 0; + bitset dp; + auto dfs = [&] (auto dfs, int v, int pa) -> ll { + ll cnt = 0; + vector s; + for (auto&& u : ch[v]) { + if (u == pa) continue; + ll curr = dfs(dfs, u, v); + s.push_back(curr); + cnt += curr; + } + ll pack_size = cnt >> 1; + dp.reset(); + dp[0] = 1; + ll sum = 0; + for (auto&& c : s) { + for (ll i = pack_size; i >= c; --i) { + if (dp[i-c]) { + dp[i] = 1; + sum = max(sum, i); + } + } + } + res += sum * (cnt - sum); + return cnt + 1; + }; + dfs(dfs, 1, 0); + cout << res << endl; +} \ No newline at end of file diff --git a/src/bin/cf-1857f.cc b/src/bin/cf-1857f.cc new file mode 100644 index 0000000..0c71da4 --- /dev/null +++ b/src/bin/cf-1857f.cc @@ -0,0 +1,204 @@ +#pragma GCC optimize("Ofast") +///////////////////////////////////////////////////////// +/** + * Useful Macros + * by subcrip + * (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) decltype(container)::value_type + +/* type aliases */ +using ll = int64_t; +using ull = uint64_t; +using pii = pair; +using pil = pair; +using pli = pair; +using pll = pair; + +/* constants */ +constexpr int INF = 0x3f3f3f3f; +constexpr ull MDL = 1e9 + 7; +constexpr ull PRIME = 998'244'353; +constexpr ull MDL1 = 825; +constexpr ull MDL2 = 87825; + +/* 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)) + +/* fast pairs */ +#define upair ull +#define umake(x, y) (ull(x) << 32 | ull(y)) +#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(p))) +#define i2(p) (int(u2(p))) +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;) + +/* build data structures */ +#define unordered_counter(from, to) __AS_PROCEDURE(unordered_map<__as_typeof(from), size_t> to; for (auto&& x : from) ++to[x];) +#define counter(from, to, cmp) __AS_PROCEDURE(map<__as_typeof(from), size_t, cmp> to; for (auto&& x : from) ++to[x];) +#define pa(a) __AS_PROCEDURE(__typeof(a) pa; pa.push_back({}); for (auto&&x : a) pa.push_back(pa.back() + x);) +#define sa(a) __AS_PROCEDURE(__typeof(a) sa(a.size() + 1); {int n = a.size(); for (int i = n - 1; i >= 0; --i) sa[i] = sa[i + 1] + a[i];};) +#define adj(ch, n) __AS_PROCEDURE(vector> ch((n) + 1);) +#define edge(ch, u, v) __AS_PROCEDURE(ch[u].push_back(v), ch[v].push_back(u);) +#define Edge(ch, u, v) __AS_PROCEDURE(ch[u].push_back(v);) + +/* io */ +#define untie __AS_PROCEDURE(ios_base::sync_with_stdio(0), cin.tie(NULL)) +template void __read(T& x) { cin >> x; } +template void __read(T& x, U&... args) { cin >> x; __read(args...); } +#define read(type, ...) __AS_PROCEDURE(type __VA_ARGS__; __read(__VA_ARGS__);) +#define readvec(type, a, n) __AS_PROCEDURE(vector a(n); for (int i = 0; i < (n); ++i) cin >> a[i];) +#define putvec(a) __AS_PROCEDURE(for (auto&& x : a) cout << x << ' '; cout << endl;) +#define debug(x) __AS_PROCEDURE(cerr << #x" = " << (x) << endl;) +#define debugvec(a) __AS_PROCEDURE(cerr << #a" = "; for (auto&& x : a) cerr << x << ' '; cerr << endl;) +template ostream& operator<<(ostream& out, vector vec) { + for (auto&& i : vec) out << i << ' '; + return out; +} + +/* pops */ +#define poptop(q, ...) __AS_PROCEDURE(auto [__VA_ARGS__] = q.top(); q.pop();) +#define popback(q, ...) __AS_PROCEDURE(auto [__VA_ARGS__] = q.back(); q.pop_back();) +#define popfront(q, ...) __AS_PROCEDURE(auto [__VA_ARGS__] = q.front();q.pop_front();) + +/* algorithms */ + +vector calc_next(string t) { // pi function of t + int n = (int)t.length(); + vector pi(n); + for (int i = 1; i < n; i++) { + int j = pi[i - 1]; + while (j > 0 && t[i] != t[j]) j = pi[j - 1]; + if (t[i] == t[j]) j++; + pi[i] = j; + } + return pi; +} +vector calc_z(string t) { // z function of t + int m = t.length(); + vector z; + z.push_back(m); + pair prev = {1, -1}; + for (int i = 1; i < m; ++i) { + if (z[i - prev.first] + i <= prev.second) { + z.push_back(z[i - prev.first]); + } else { + int j = max(i, prev.second + 1); + while (j < m && t[j] == t[j - i]) ++j; + z.push_back(j - i); + prev = {i, j - 1}; + } + } + return z; +} +vector kmp(string s, string t) { // find all t in s + string cur = t + '#' + s; + int sz1 = s.size(), sz2 = t.size(); + vector v; + vector lps = calc_next(cur); + for (int i = sz2 + 1; i <= sz1 + sz2; i++) { + if (lps[i] == sz2) v.push_back(i - 2 * sz2); + } + return v; +} +int period(string s) { // find the length of shortest recurring period + int n = s.length(); + auto z = calc_z(s); + for (int i = 1; i <= n / 2; ++i) { + if (n % i == 0 && z[i] == n - i) { + return i; + } + } + return n; +} +///////////////////////////////////////////////////////// + +constexpr int MAXN = 2e5 + 10; + +unordered_map ct; + +void solve() { + read(int, n); + ct.clear(); + for (int i = 0; i < n; ++i) { + read(ll, t); + ct[t] += 1; + } + read(int, q); + while (q--) { + read(ll, x, y); + ll delta = x * x - 4 * y; + if (delta < 0) { + cout << "0 "; + } else { + ll rt = ll(sqrt(delta)); + if (rt * rt != delta) { + cout << "0 "; + } else { + if (delta == 0) { + if (x & 1) { + cout << "0 "; + } else { + cout << ct[x >> 1] * (ct[x >> 1] - 1) / 2 << ' '; + } + } else { + if ((x + rt) & 1) { + cout << "0 "; + } else { + ll p1 = x + rt >> 1; + ll q1 = y / p1; + cout << ct[p1] * ct[q1] << ' '; + } + } + } + } + } + cout << endl; +} + +int main() { + untie; + ct.reserve(MAXN); + read(int, t); + while (t--) solve(); +} \ No newline at end of file diff --git a/src/bin/cf-1859d.cc b/src/bin/cf-1859d.cc new file mode 100644 index 0000000..e3928a7 --- /dev/null +++ b/src/bin/cf-1859d.cc @@ -0,0 +1,274 @@ +#pragma GCC optimize("Ofast") +///////////////////////////////////////////////////////// +/** + * Useful Macros + * by subcrip + * (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) decltype(container)::value_type + +/* type aliases */ +using ll = int64_t; +using ull = uint64_t; +using pii = pair; +using pil = pair; +using pli = pair; +using pll = pair; + +/* constants */ +constexpr int INF = 0x3f3f3f3f; +constexpr ull MDL = 1e9 + 7; +constexpr ull PRIME = 998'244'353; +constexpr ull MDL1 = 825; +constexpr ull MDL2 = 87825; + +/* 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)) + +/* fast pairs */ +#define upair ull +#define umake(x, y) (ull(x) << 32 | ull(y)) +#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(p))) +#define i2(p) (int(u2(p))) +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;) + +/* build data structures */ +#define unordered_counter(from, to) __AS_PROCEDURE(unordered_map<__as_typeof(from), size_t> to; for (auto&& x : from) ++to[x];) +#define counter(from, to, cmp) __AS_PROCEDURE(map<__as_typeof(from), size_t, cmp> to; for (auto&& x : from) ++to[x];) +#define pa(a) __AS_PROCEDURE(__typeof(a) pa; pa.push_back({}); for (auto&&x : a) pa.push_back(pa.back() + x);) +#define sa(a) __AS_PROCEDURE(__typeof(a) sa(a.size() + 1); {int n = a.size(); for (int i = n - 1; i >= 0; --i) sa[i] = sa[i + 1] + a[i];};) +#define adj(ch, n) __AS_PROCEDURE(vector> ch((n) + 1);) +#define edge(ch, u, v) __AS_PROCEDURE(ch[u].push_back(v), ch[v].push_back(u);) +#define Edge(ch, u, v) __AS_PROCEDURE(ch[u].push_back(v);) + +/* io */ +#define untie __AS_PROCEDURE(ios_base::sync_with_stdio(0), cin.tie(NULL)) +template void __read(T& x) { cin >> x; } +template void __read(T& x, U&... args) { cin >> x; __read(args...); } +#define read(type, ...) __AS_PROCEDURE(type __VA_ARGS__; __read(__VA_ARGS__);) +#define readvec(type, a, n) __AS_PROCEDURE(vector a(n); for (int i = 0; i < (n); ++i) cin >> a[i];) +#define putvec(a) __AS_PROCEDURE(for (auto&& x : a) cout << x << ' '; cout << endl;) +#define debug(x) __AS_PROCEDURE(cerr << #x" = " << (x) << endl;) +#define debugvec(a) __AS_PROCEDURE(cerr << #a" = "; for (auto&& x : a) cerr << x << ' '; cerr << endl;) +template ostream& operator<<(ostream& out, vector vec) { + for (auto&& i : vec) out << i << ' '; + return out; +} + +/* pops */ +#define poptop(q, ...) __AS_PROCEDURE(auto [__VA_ARGS__] = q.top(); q.pop();) +#define popback(q, ...) __AS_PROCEDURE(auto [__VA_ARGS__] = q.back(); q.pop_back();) +#define popfront(q, ...) __AS_PROCEDURE(auto [__VA_ARGS__] = q.front();q.pop_front();) + +/* algorithms */ + +vector calc_next(string t) { // pi function of t + int n = (int)t.length(); + vector pi(n); + for (int i = 1; i < n; i++) { + int j = pi[i - 1]; + while (j > 0 && t[i] != t[j]) j = pi[j - 1]; + if (t[i] == t[j]) j++; + pi[i] = j; + } + return pi; +} +vector calc_z(string t) { // z function of t + int m = t.length(); + vector z; + z.push_back(m); + pair prev = {1, -1}; + for (int i = 1; i < m; ++i) { + if (z[i - prev.first] + i <= prev.second) { + z.push_back(z[i - prev.first]); + } else { + int j = max(i, prev.second + 1); + while (j < m && t[j] == t[j - i]) ++j; + z.push_back(j - i); + prev = {i, j - 1}; + } + } + return z; +} +vector kmp(string s, string t) { // find all t in s + string cur = t + '#' + s; + int sz1 = s.size(), sz2 = t.size(); + vector v; + vector lps = calc_next(cur); + for (int i = sz2 + 1; i <= sz1 + sz2; i++) { + if (lps[i] == sz2) v.push_back(i - 2 * sz2); + } + return v; +} +int period(string s) { // find the length of shortest recurring period + int n = s.length(); + auto z = calc_z(s); + for (int i = 1; i <= n / 2; ++i) { + if (n % i == 0 && z[i] == n - i) { + return i; + } + } + return n; +} +///////////////////////////////////////////////////////// + +constexpr int MAXN=2e5+10; +int b[4*MAXN]; // tree d, tags b + +int getsum(int s,int t,int p,int l,int r){ + if(l<=s&&t<=r)return b[p]; + int m=s+(t-s>>1),sum=0; + if(b[p]){ + b[p*2]=b[p],b[p*2+1]=b[p]; + b[p]=0; + } + if(l<=m)sum+=getsum(s,m,p*2,l,r); + if(r>m) sum+=getsum(m+1,t,p*2+1,l,r); + return sum; +} + +void update(int s,int t,int p,int l,int r,int c) { // difference c + if(l<=s&&t<=r){ + b[p]=c; + return; + } + int m=s+(t-s>>1); + if(b[p]&&s!=t){ + b[p*2]=b[p],b[p*2+1]=b[p]; + b[p]=0; + } + if(l<=m)update(s,m,p*2,l,r,c); + if(r>m) update(m+1,t,p*2+1,l,r,c); +} + +struct segment { + ll l, r, a, b, f; +}; + +void clear(int n) { + int limit = n + 1; + memset(b, 0, 4 * limit * sizeof(int)); +} + +void solve() { + read(int, n); + vector a(n); + for (int i = 0; i < n; ++i) cin >> a[i].l >> a[i].r >> a[i].a >> a[i].b; + auto cmp_b_greater = [&] (const segment& a, const segment& b) { + return a.b > b.b; + }; + auto cmp_l_less = [&] (const segment& a, const segment& b) { + return a.l < b.l; + }; + auto cmp_f_less = [&] (const segment& a, const segment& b) { + return a.f < b.f; + }; + sort(a.begin(), a.end(), cmp_b_greater); + priority_queue, decltype(cmp_f_less)> pq(cmp_f_less); + for (int i = 0; i < n; ++i) { + while (pq.size() && pq.top().l > a[i].b) pq.pop(); + a[i].f = a[i].b; + if (pq.size()) a[i].f = max(a[i].f, pq.top().f); + pq.push(a[i]); + } + // for (int i = 0; i < n; ++i) { + // printf("a[%d]: l = %ld, r = %ld, a = %ld, b = %ld, f = %ld\n", i, a[i].l, a[i].r, a[i].a, a[i].b, a[i].f); + // } + sort(a.begin(), a.end(), cmp_l_less); + read(int, q); + clear(q); + readvec(ll, query, q); + vector mp(q); + iota(mp.begin(), mp.end(), 0); + sort(mp.begin(), mp.end(), [&] (int i, int j) {return query[i] < query[j];}); + auto find_left = [&] (int bound) { + int l = 0, r = q - 1; + while (l < r) { + int mid = l + r >> 1; + if (query[mp[mid]] < bound) { + l = mid + 1; + } else { + r = mid; + } + } + if (query[mp[l]] < bound) { + return -1; + } + return l; + }; + auto find_right = [&] (int bound) { + int l = 0, r = q - 1; + while (l < r) { + int mid = l + r + 1 >> 1; + if (query[mp[mid]] > bound) { + r = mid - 1; + } else { + l = mid; + } + } + if (query[mp[l]] > bound) { + return -1; + } + return l; + }; + for (int i = 0; i < n; ++i) { + int left = find_left(a[i].l); + int right = find_right(a[i].r); + if (left == -1 || right == -1) continue; + // debug(left), debug(right); + update(1, q, 1, left + 1, right + 1, a[i].f); + } + // for (int i = 0; i < q; ++i) {debug(getsum(1, q, 1, i + 1, i + 1));} + vector res(q); + for (int i = 0; i < q; ++i) { + res[mp[i]] = max(query[mp[i]], ll(getsum(1, q, 1, i + 1, i + 1))); + } + putvec(res); +} + +int main() { + untie; + read(int, t); + while (t--) solve(); +} \ No newline at end of file diff --git a/src/bin/cf-1867d.cc b/src/bin/cf-1867d.cc new file mode 100644 index 0000000..608d816 --- /dev/null +++ b/src/bin/cf-1867d.cc @@ -0,0 +1,214 @@ +///////////////////////////////////////////////////////// +/** + * Useful Macros + * by subcrip + * (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) decltype(container)::value_type + +/* type aliases */ +using ll = int64_t; +using ull = uint64_t; +using pii = pair; +using pil = pair; +using pli = pair; +using pll = pair; + +/* constants */ +constexpr int INF = 0x3f3f3f3f; +constexpr ull MDL = 1e9 + 7; +constexpr ull PRIME = 998'244'353; +constexpr ull MDL1 = 825; +constexpr ull MDL2 = 87825; + +/* 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)) + +/* fast pairs */ +#define upair ull +#define umake(x, y) (ull(x) << 32 | ull(y)) +#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(p))) +#define i2(p) (int(u2(p))) +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;) + +/* build data structures */ +#define unordered_counter(from, to) __AS_PROCEDURE(unordered_map<__as_typeof(from), size_t> to; for (auto&& x : from) ++to[x];) +#define counter(from, to, cmp) __AS_PROCEDURE(map<__as_typeof(from), size_t, cmp> to; for (auto&& x : from) ++to[x];) +#define pa(a) __AS_PROCEDURE(__typeof(a) pa; pa.push_back({}); for (auto&&x : a) pa.push_back(pa.back() + x);) +#define sa(a) __AS_PROCEDURE(__typeof(a) sa(a.size() + 1); {int n = a.size(); for (int i = n - 1; i >= 0; --i) sa[i] = sa[i + 1] + a[i];};) +#define adj(ch, n) __AS_PROCEDURE(vector> ch((n) + 1);) +#define edge(ch, u, v) __AS_PROCEDURE(ch[u].push_back(v), ch[v].push_back(u);) +#define Edge(ch, u, v) __AS_PROCEDURE(ch[u].push_back(v);) + +/* io */ +#define untie __AS_PROCEDURE(ios_base::sync_with_stdio(0), cin.tie(NULL)) +template void __read(T& x) { cin >> x; } +template void __read(T& x, U&... args) { cin >> x; __read(args...); } +#define read(type, ...) __AS_PROCEDURE(type __VA_ARGS__; __read(__VA_ARGS__);) +#define readvec(type, a, n) __AS_PROCEDURE(vector a(n); for (int i = 0; i < (n); ++i) cin >> a[i];) +#define putvec(a) __AS_PROCEDURE(for (auto&& x : a) cout << x << ' '; cout << endl;) +#define debug(x) __AS_PROCEDURE(cerr << #x" = " << (x) << endl;) +#define debugvec(a) __AS_PROCEDURE(cerr << #a" = "; for (auto&& x : a) cerr << x << ' '; cerr << endl;) +template ostream& operator<<(ostream& out, vector vec) { + for (auto&& i : vec) out << i << ' '; + return out; +} + +/* pops */ +#define poptop(q, ...) __AS_PROCEDURE(auto [__VA_ARGS__] = q.top(); q.pop();) +#define popback(q, ...) __AS_PROCEDURE(auto [__VA_ARGS__] = q.back(); q.pop_back();) +#define popfront(q, ...) __AS_PROCEDURE(auto [__VA_ARGS__] = q.front();q.pop_front();) + +/* algorithms */ + +vector calc_next(string t) { // pi function of t + int n = (int)t.length(); + vector pi(n); + for (int i = 1; i < n; i++) { + int j = pi[i - 1]; + while (j > 0 && t[i] != t[j]) j = pi[j - 1]; + if (t[i] == t[j]) j++; + pi[i] = j; + } + return pi; +} +vector calc_z(string t) { // z function of t + int m = t.length(); + vector z; + z.push_back(m); + pair prev = {1, -1}; + for (int i = 1; i < m; ++i) { + if (z[i - prev.first] + i <= prev.second) { + z.push_back(z[i - prev.first]); + } else { + int j = max(i, prev.second + 1); + while (j < m && t[j] == t[j - i]) ++j; + z.push_back(j - i); + prev = {i, j - 1}; + } + } + return z; +} +vector kmp(string s, string t) { // find all t in s + string cur = t + '#' + s; + int sz1 = s.size(), sz2 = t.size(); + vector v; + vector lps = calc_next(cur); + for (int i = sz2 + 1; i <= sz1 + sz2; i++) { + if (lps[i] == sz2) v.push_back(i - 2 * sz2); + } + return v; +} +int period(string s) { // find the length of shortest recurring period + int n = s.length(); + auto z = calc_z(s); + for (int i = 1; i <= n / 2; ++i) { + if (n % i == 0 && z[i] == n - i) { + return i; + } + } + return n; +} +///////////////////////////////////////////////////////// + +void solve() { + read(int, n, k); + vector ch(n + 1); + for (int i = 1; i <= n; ++i) { + read(int, j); + ch[i] = j; + } + int ok = 1; + vector vis(n + 1); + vector dfn(n + 1); + vector mark(n + 1); + auto dfs = [&] (auto dfs, int v, int tm) -> void { + // if (mark[v]) return; + if (dfn[v]) { + if (tm - dfn[v] != k) { + ok = 0; + return; + } + int curr = v; + mark[curr] = 1; + while (ch[curr] != v) { + curr = ch[curr]; + mark[curr] = 1; + } + return; + } else if (vis[v]) return; + vis[v] = 1; + dfn[v] = tm; + dfs(dfs, ch[v], tm + 1); + dfn[v] = 0; + }; + vector dis(n + 1); + auto dfs2 = [&] (auto dfs2, int v) -> int { + if (mark[v]) return 0; + if (dis[v]) return dis[v]; + dis[v] = dfs2(dfs2, ch[v]) + 1; + return dis[v]; + }; + for (int i = 1; i <= n; ++i) { + if (!vis[i]) dfs(dfs, i, 1); + } + if (!ok) { + cout << "NO\n"; + return; + } + for (int i = 1; i <= n; ++i) { + dfs2(dfs2, i); + if (k == 1 && dis[i]) { + ok = 0; + break; + } + } + if (!ok) cout << "NO\n"; + else cout << "YES\n"; +} + +int main() { + read(int, t); + while (t--) solve(); +} \ No newline at end of file diff --git a/src/bin/cf-1870d.cc b/src/bin/cf-1870d.cc new file mode 100644 index 0000000..ed7c157 --- /dev/null +++ b/src/bin/cf-1870d.cc @@ -0,0 +1,187 @@ +///////////////////////////////////////////////////////// +/** + * Useful Macros + * by subcrip + * (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) decltype(container)::value_type + +/* type aliases */ +using ll = int64_t; +using ull = uint64_t; +using pii = pair; +using pil = pair; +using pli = pair; +using pll = pair; + +/* constants */ +constexpr int INF = 0x3f3f3f3f; +constexpr ull MDL = 1e9 + 7; +constexpr ull PRIME = 998'244'353; +constexpr ull MDL1 = 825; +constexpr ull MDL2 = 87825; + +/* 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)) + +/* fast pairs */ +#define upair ull +#define umake(x, y) (ull(x) << 32 | ull(y)) +#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(p))) +#define i2(p) (int(u2(p))) +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;) + +/* build data structures */ +#define unordered_counter(from, to) __AS_PROCEDURE(unordered_map<__as_typeof(from), size_t> to; for (auto&& x : from) ++to[x];) +#define counter(from, to, cmp) __AS_PROCEDURE(map<__as_typeof(from), size_t, cmp> to; for (auto&& x : from) ++to[x];) +#define pa(a) __AS_PROCEDURE(__typeof(a) pa; pa.push_back({}); for (auto&&x : a) pa.push_back(pa.back() + x);) +#define sa(a) __AS_PROCEDURE(__typeof(a) sa(a.size() + 1); {int n = a.size(); for (int i = n - 1; i >= 0; --i) sa[i] = sa[i + 1] + a[i];};) +#define adj(ch, n) __AS_PROCEDURE(vector> ch((n) + 1);) +#define edge(ch, u, v) __AS_PROCEDURE(ch[u].push_back(v), ch[v].push_back(u);) +#define Edge(ch, u, v) __AS_PROCEDURE(ch[u].push_back(v);) + +/* io */ +#define untie __AS_PROCEDURE(ios_base::sync_with_stdio(0), cin.tie(NULL)) +template void __read(T& x) { cin >> x; } +template void __read(T& x, U&... args) { cin >> x; __read(args...); } +#define read(type, ...) __AS_PROCEDURE(type __VA_ARGS__; __read(__VA_ARGS__);) +#define readvec(type, a, n) __AS_PROCEDURE(vector a(n); for (int i = 0; i < (n); ++i) cin >> a[i];) +#define putvec(a) __AS_PROCEDURE(for (auto&& x : a) cout << x << ' '; cout << endl;) +#define debug(x) __AS_PROCEDURE(cerr << #x" = " << (x) << endl;) +#define debugvec(a) __AS_PROCEDURE(cerr << #a" = "; for (auto&& x : a) cerr << x << ' '; cerr << endl;) +template ostream& operator<<(ostream& out, vector vec) { + for (auto&& i : vec) out << i << ' '; + return out; +} + +/* pops */ +#define poptop(q, ...) __AS_PROCEDURE(auto [__VA_ARGS__] = q.top(); q.pop();) +#define popback(q, ...) __AS_PROCEDURE(auto [__VA_ARGS__] = q.back(); q.pop_back();) +#define popfront(q, ...) __AS_PROCEDURE(auto [__VA_ARGS__] = q.front();q.pop_front();) + +/* algorithms */ + +vector calc_next(string t) { // pi function of t + int n = (int)t.length(); + vector pi(n); + for (int i = 1; i < n; i++) { + int j = pi[i - 1]; + while (j > 0 && t[i] != t[j]) j = pi[j - 1]; + if (t[i] == t[j]) j++; + pi[i] = j; + } + return pi; +} +vector calc_z(string t) { // z function of t + int m = t.length(); + vector z; + z.push_back(m); + pair prev = {1, -1}; + for (int i = 1; i < m; ++i) { + if (z[i - prev.first] + i <= prev.second) { + z.push_back(z[i - prev.first]); + } else { + int j = max(i, prev.second + 1); + while (j < m && t[j] == t[j - i]) ++j; + z.push_back(j - i); + prev = {i, j - 1}; + } + } + return z; +} +vector kmp(string s, string t) { // find all t in s + string cur = t + '#' + s; + int sz1 = s.size(), sz2 = t.size(); + vector v; + vector lps = calc_next(cur); + for (int i = sz2 + 1; i <= sz1 + sz2; i++) { + if (lps[i] == sz2) v.push_back(i - 2 * sz2); + } + return v; +} +int period(string s) { // find the length of shortest recurring period + int n = s.length(); + auto z = calc_z(s); + for (int i = 1; i <= n / 2; ++i) { + if (n % i == 0 && z[i] == n - i) { + return i; + } + } + return n; +} +///////////////////////////////////////////////////////// + +void solve() { + read(ll, n); + readvec(ll, a, n); + read(ll, k); + vector idx(n); + iota(idx.begin(), idx.end(), 0); + sort(idx.begin(), idx.end(), [&](int i, int j) { + if (a[i] == a[j]) return i > j; + return a[i] < a[j]; + }); + vector diff(n + 1); + ll remains = k, prev = -1, max_swap = LLONG_MAX; + for (int t = 0; t < n; ++t) { + ll i = idx[t]; + if (i < prev) continue; + ll sw = prev == -1 ? (remains / a[i]) : min(max_swap, remains / (a[i] - a[prev])); + diff[prev + 1] += sw; + diff[i + 1] -= sw; + remains -= prev == -1 ? (sw * a[i]) : sw * (a[i] - a[prev]); + max_swap = sw; + prev = i; + } + ll curr = diff[0]; + for (int i = 1; i <= n; ++i) { + cout << curr << " \n"[i == n]; + curr += diff[i]; + } +} + +int main() { + read(int, t); + while (t--) solve(); +} \ No newline at end of file diff --git a/src/bin/cf-1872e.cc b/src/bin/cf-1872e.cc new file mode 100644 index 0000000..7a8f206 --- /dev/null +++ b/src/bin/cf-1872e.cc @@ -0,0 +1,188 @@ +///////////////////////////////////////////////////////// +/** + * Useful Macros + * by subcrip + * (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) decltype(container)::value_type + +/* type aliases */ +using ll = int64_t; +using ull = uint64_t; +using pii = pair; +using pil = pair; +using pli = pair; +using pll = pair; + +/* constants */ +constexpr int INF = 0x3f3f3f3f; +constexpr ull MDL = 1e9 + 7; +constexpr ull PRIME = 998'244'353; +constexpr ull MDL1 = 825; +constexpr ull MDL2 = 87825; + +/* 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)) + +/* fast pairs */ +#define upair ull +#define umake(x, y) (ull(x) << 32 | ull(y)) +#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(p))) +#define i2(p) (int(u2(p))) +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;) + +/* build data structures */ +#define unordered_counter(from, to) __AS_PROCEDURE(unordered_map<__as_typeof(from), size_t> to; for (auto&& x : from) ++to[x];) +#define counter(from, to, cmp) __AS_PROCEDURE(map<__as_typeof(from), size_t, cmp> to; for (auto&& x : from) ++to[x];) +#define pa(a) __AS_PROCEDURE(__typeof(a) pa; pa.push_back({}); for (auto&&x : a) pa.push_back(pa.back() + x);) +#define sa(a) __AS_PROCEDURE(__typeof(a) sa(a.size() + 1); {int n = a.size(); for (int i = n - 1; i >= 0; --i) sa[i] = sa[i + 1] + a[i];};) +#define adj(ch, n) __AS_PROCEDURE(vector> ch((n) + 1);) +#define edge(ch, u, v) __AS_PROCEDURE(ch[u].push_back(v), ch[v].push_back(u);) +#define Edge(ch, u, v) __AS_PROCEDURE(ch[u].push_back(v);) + +/* io */ +#define untie __AS_PROCEDURE(ios_base::sync_with_stdio(0), cin.tie(NULL)) +template void __read(T& x) { cin >> x; } +template void __read(T& x, U&... args) { cin >> x; __read(args...); } +#define read(type, ...) __AS_PROCEDURE(type __VA_ARGS__; __read(__VA_ARGS__);) +#define readvec(type, a, n) __AS_PROCEDURE(vector a(n); for (int i = 0; i < (n); ++i) cin >> a[i];) +#define putvec(a) __AS_PROCEDURE(for (auto&& x : a) cout << x << ' '; cout << endl;) +#define debug(x) __AS_PROCEDURE(cerr << #x" = " << (x) << endl;) +#define debugvec(a) __AS_PROCEDURE(cerr << #a" = "; for (auto&& x : a) cerr << x << ' '; cerr << endl;) +template ostream& operator<<(ostream& out, vector vec) { + for (auto&& i : vec) out << i << ' '; + return out; +} + +/* pops */ +#define poptop(q, ...) __AS_PROCEDURE(auto [__VA_ARGS__] = q.top(); q.pop();) +#define popback(q, ...) __AS_PROCEDURE(auto [__VA_ARGS__] = q.back(); q.pop_back();) +#define popfront(q, ...) __AS_PROCEDURE(auto [__VA_ARGS__] = q.front();q.pop_front();) + +/* algorithms */ + +vector calc_next(string t) { // pi function of t + int n = (int)t.length(); + vector pi(n); + for (int i = 1; i < n; i++) { + int j = pi[i - 1]; + while (j > 0 && t[i] != t[j]) j = pi[j - 1]; + if (t[i] == t[j]) j++; + pi[i] = j; + } + return pi; +} +vector calc_z(string t) { // z function of t + int m = t.length(); + vector z; + z.push_back(m); + pair prev = {1, -1}; + for (int i = 1; i < m; ++i) { + if (z[i - prev.first] + i <= prev.second) { + z.push_back(z[i - prev.first]); + } else { + int j = max(i, prev.second + 1); + while (j < m && t[j] == t[j - i]) ++j; + z.push_back(j - i); + prev = {i, j - 1}; + } + } + return z; +} +vector kmp(string s, string t) { // find all t in s + string cur = t + '#' + s; + int sz1 = s.size(), sz2 = t.size(); + vector v; + vector lps = calc_next(cur); + for (int i = sz2 + 1; i <= sz1 + sz2; i++) { + if (lps[i] == sz2) v.push_back(i - 2 * sz2); + } + return v; +} +int period(string s) { // find the length of shortest recurring period + int n = s.length(); + auto z = calc_z(s); + for (int i = 1; i <= n / 2; ++i) { + if (n % i == 0 && z[i] == n - i) { + return i; + } + } + return n; +} +///////////////////////////////////////////////////////// + +void solve() { + read(int, n); + readvec(ll, a, n); + read(string, s); + vector ps(n + 1); + ll res = 0; + for (int i = 1; i <= n; ++i) { + ps[i] = ps[i-1] ^ a[i-1]; + if (s[i-1] == '1') { + res ^= a[i-1]; + } + } + read(int, q); + while (q--) { + read(int, p); + if (p == 1) { + read(int, l, r); + res ^= ps[r] ^ ps[l - 1]; + } else { + read(int, g); + if (g == 1) { + cout << res << ' '; + } else { + cout << (ps[n] ^ res) << ' '; + } + } + } + cout << endl; +} + +int main() { + read(int, t); + while (t--) solve(); +} \ No newline at end of file diff --git a/src/bin/cf-1872f.cc b/src/bin/cf-1872f.cc new file mode 100644 index 0000000..a467998 --- /dev/null +++ b/src/bin/cf-1872f.cc @@ -0,0 +1,206 @@ +///////////////////////////////////////////////////////// +/** + * Useful Macros + * by subcrip + * (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) decltype(container)::value_type + +/* type aliases */ +using ll = int64_t; +using ull = uint64_t; +using pii = pair; +using pil = pair; +using pli = pair; +using pll = pair; + +/* constants */ +constexpr int INF = 0x3f3f3f3f; +constexpr ull MDL = 1e9 + 7; +constexpr ull PRIME = 998'244'353; +constexpr ull MDL1 = 825; +constexpr ull MDL2 = 87825; + +/* 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)) + +/* fast pairs */ +#define upair ull +#define umake(x, y) (ull(x) << 32 | ull(y)) +#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(p))) +#define i2(p) (int(u2(p))) +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;) + +/* build data structures */ +#define unordered_counter(from, to) __AS_PROCEDURE(unordered_map<__as_typeof(from), size_t> to; for (auto&& x : from) ++to[x];) +#define counter(from, to, cmp) __AS_PROCEDURE(map<__as_typeof(from), size_t, cmp> to; for (auto&& x : from) ++to[x];) +#define pa(a) __AS_PROCEDURE(__typeof(a) pa; pa.push_back({}); for (auto&&x : a) pa.push_back(pa.back() + x);) +#define sa(a) __AS_PROCEDURE(__typeof(a) sa(a.size() + 1); {int n = a.size(); for (int i = n - 1; i >= 0; --i) sa[i] = sa[i + 1] + a[i];};) +#define adj(ch, n) __AS_PROCEDURE(vector> ch((n) + 1);) +#define edge(ch, u, v) __AS_PROCEDURE(ch[u].push_back(v), ch[v].push_back(u);) +#define Edge(ch, u, v) __AS_PROCEDURE(ch[u].push_back(v);) + +/* io */ +#define untie __AS_PROCEDURE(ios_base::sync_with_stdio(0), cin.tie(NULL)) +template void __read(T& x) { cin >> x; } +template void __read(T& x, U&... args) { cin >> x; __read(args...); } +#define read(type, ...) __AS_PROCEDURE(type __VA_ARGS__; __read(__VA_ARGS__);) +#define readvec(type, a, n) __AS_PROCEDURE(vector a(n); for (int i = 0; i < (n); ++i) cin >> a[i];) +#define putvec(a) __AS_PROCEDURE(for (auto&& x : a) cout << x << ' '; cout << endl;) +#define debug(x) __AS_PROCEDURE(cerr << #x" = " << (x) << endl;) +#define debugvec(a) __AS_PROCEDURE(cerr << #a" = "; for (auto&& x : a) cerr << x << ' '; cerr << endl;) +template ostream& operator<<(ostream& out, vector vec) { + for (auto&& i : vec) out << i << ' '; + return out; +} + +/* pops */ +#define poptop(q, ...) __AS_PROCEDURE(auto [__VA_ARGS__] = q.top(); q.pop();) +#define popback(q, ...) __AS_PROCEDURE(auto [__VA_ARGS__] = q.back(); q.pop_back();) +#define popfront(q, ...) __AS_PROCEDURE(auto [__VA_ARGS__] = q.front();q.pop_front();) + +/* algorithms */ + +vector calc_next(string t) { // pi function of t + int n = (int)t.length(); + vector pi(n); + for (int i = 1; i < n; i++) { + int j = pi[i - 1]; + while (j > 0 && t[i] != t[j]) j = pi[j - 1]; + if (t[i] == t[j]) j++; + pi[i] = j; + } + return pi; +} +vector calc_z(string t) { // z function of t + int m = t.length(); + vector z; + z.push_back(m); + pair prev = {1, -1}; + for (int i = 1; i < m; ++i) { + if (z[i - prev.first] + i <= prev.second) { + z.push_back(z[i - prev.first]); + } else { + int j = max(i, prev.second + 1); + while (j < m && t[j] == t[j - i]) ++j; + z.push_back(j - i); + prev = {i, j - 1}; + } + } + return z; +} +vector kmp(string s, string t) { // find all t in s + string cur = t + '#' + s; + int sz1 = s.size(), sz2 = t.size(); + vector v; + vector lps = calc_next(cur); + for (int i = sz2 + 1; i <= sz1 + sz2; i++) { + if (lps[i] == sz2) v.push_back(i - 2 * sz2); + } + return v; +} +int period(string s) { // find the length of shortest recurring period + int n = s.length(); + auto z = calc_z(s); + for (int i = 1; i <= n / 2; ++i) { + if (n % i == 0 && z[i] == n - i) { + return i; + } + } + return n; +} +///////////////////////////////////////////////////////// + +void solve() { + read(int, n); + vector ch(n + 1); + vector ind(n + 1); + for (int i = 1; i <= n; ++i) { + read(int, t); + ch[i] = t; + ind[t] += 1; + } + vector cost(n + 1); + for (int i = 1; i <= n; ++i) cin >> cost[i]; + deque dq; + for (int i = 1; i <= n; ++i) { + if (!ind[i]) dq.push_back(i);; + } + vector vis(n + 1); + while (dq.size()) { + int i = dq.front(); dq.pop_front(); + continue_or(vis[i], 1); + cout << i << ' '; + auto&& j = ch[i]; + ind[j] -= 1; + if (!ind[j]) dq.push_back(j); + } + vector trace; + for (int i = 1; i <= n; ++i) { + if (!vis[i]) { + trace.clear(); + int curr = i; + int mn = 0; + while (!vis[curr]) { + trace.push_back(curr); + vis[curr] = 1; + if (cost[curr] < cost[trace[mn]]) mn = trace.size() - 1; + curr = ch[curr]; + } + int m = trace.size(); + for (int j = mn + 1; j < m; ++j) { + cout << trace[j] << ' '; + } + for (int j = 0; j <= mn; ++j) { + cout << trace[j] << ' '; + } + } + } + cout << endl; +} + +int main() { + read(int, t); + while (t--) solve(); +} \ No newline at end of file diff --git a/src/bin/cf-1882c.cc b/src/bin/cf-1882c.cc new file mode 100644 index 0000000..3b44573 --- /dev/null +++ b/src/bin/cf-1882c.cc @@ -0,0 +1,179 @@ +///////////////////////////////////////////////////////// +/** + * Useful Macros + * by subcrip + * (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) decltype(container)::value_type + +/* type aliases */ +using ll = int64_t; +using ull = uint64_t; +using pii = pair; +using pil = pair; +using pli = pair; +using pll = pair; + +/* constants */ +constexpr int INF = 0x3f3f3f3f; +constexpr ull MDL = 1e9 + 7; +constexpr ull PRIME = 998'244'353; +constexpr ull MDL1 = 825; +constexpr ull MDL2 = 87825; + +/* 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)) + +/* fast pairs */ +#define upair ull +#define umake(x, y) (ull(x) << 32 | ull(y)) +#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(p))) +#define i2(p) (int(u2(p))) +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;) + +/* build data structures */ +#define unordered_counter(from, to) __AS_PROCEDURE(unordered_map<__as_typeof(from), size_t> to; for (auto&& x : from) ++to[x];) +#define counter(from, to, cmp) __AS_PROCEDURE(map<__as_typeof(from), size_t, cmp> to; for (auto&& x : from) ++to[x];) +#define pa(a) __AS_PROCEDURE(__typeof(a) pa; pa.push_back({}); for (auto&&x : a) pa.push_back(pa.back() + x);) +#define sa(a) __AS_PROCEDURE(__typeof(a) sa(a.size() + 1); {int n = a.size(); for (int i = n - 1; i >= 0; --i) sa[i] = sa[i + 1] + a[i];};) +#define adj(ch, n) __AS_PROCEDURE(vector> ch((n) + 1);) +#define edge(ch, u, v) __AS_PROCEDURE(ch[u].push_back(v), ch[v].push_back(u);) +#define Edge(ch, u, v) __AS_PROCEDURE(ch[u].push_back(v);) + +/* io */ +#define untie __AS_PROCEDURE(ios_base::sync_with_stdio(0), cin.tie(NULL)) +template void __read(T& x) { cin >> x; } +template void __read(T& x, U&... args) { cin >> x; __read(args...); } +#define read(type, ...) __AS_PROCEDURE(type __VA_ARGS__; __read(__VA_ARGS__);) +#define readvec(type, a, n) __AS_PROCEDURE(vector a(n); for (int i = 0; i < (n); ++i) cin >> a[i];) +#define putvec(a) __AS_PROCEDURE(for (auto&& x : a) cout << x << ' '; cout << endl;) +#define debug(x) __AS_PROCEDURE(cerr << #x" = " << (x) << endl;) +#define debugvec(a) __AS_PROCEDURE(cerr << #a" = "; for (auto&& x : a) cerr << x << ' '; cerr << endl;) +template ostream& operator<<(ostream& out, vector vec) { + for (auto&& i : vec) out << i << ' '; + return out; +} + +/* pops */ +#define poptop(q, ...) __AS_PROCEDURE(auto [__VA_ARGS__] = q.top(); q.pop();) +#define popback(q, ...) __AS_PROCEDURE(auto [__VA_ARGS__] = q.back(); q.pop_back();) +#define popfront(q, ...) __AS_PROCEDURE(auto [__VA_ARGS__] = q.front();q.pop_front();) + +/* algorithms */ + +vector calc_next(string t) { // pi function of t + int n = (int)t.length(); + vector pi(n); + for (int i = 1; i < n; i++) { + int j = pi[i - 1]; + while (j > 0 && t[i] != t[j]) j = pi[j - 1]; + if (t[i] == t[j]) j++; + pi[i] = j; + } + return pi; +} +vector calc_z(string t) { // z function of t + int m = t.length(); + vector z; + z.push_back(m); + pair prev = {1, -1}; + for (int i = 1; i < m; ++i) { + if (z[i - prev.first] + i <= prev.second) { + z.push_back(z[i - prev.first]); + } else { + int j = max(i, prev.second + 1); + while (j < m && t[j] == t[j - i]) ++j; + z.push_back(j - i); + prev = {i, j - 1}; + } + } + return z; +} +vector kmp(string s, string t) { // find all t in s + string cur = t + '#' + s; + int sz1 = s.size(), sz2 = t.size(); + vector v; + vector lps = calc_next(cur); + for (int i = sz2 + 1; i <= sz1 + sz2; i++) { + if (lps[i] == sz2) v.push_back(i - 2 * sz2); + } + return v; +} +int period(string s) { // find the length of shortest recurring period + int n = s.length(); + auto z = calc_z(s); + for (int i = 1; i <= n / 2; ++i) { + if (n % i == 0 && z[i] == n - i) { + return i; + } + } + return n; +} +///////////////////////////////////////////////////////// + +void solve() { + read(int, n); + read(int, first); + ll even = 0, odd = first; + for(int i = 2; i <= n; ++i) { + read(int, a); + if (a > 0) { + // i:even + del:odd = (curr:odd, new_del:even) ==> can del + // i:even + del:even ==> cannot del + if (i % 2 == 0) { + even = max(even, odd + a); + } else { + odd = max(odd, even + a); + } + } else { + even = odd = max(even, odd); + } + } + cout << max(odd, even) << endl; +} + +int main() { + read(int, t); + while (t--) solve(); +} \ No newline at end of file diff --git a/src/bin/cf-1905c.cc b/src/bin/cf-1905c.cc index 50983f5..7659b77 100644 --- a/src/bin/cf-1905c.cc +++ b/src/bin/cf-1905c.cc @@ -1,43 +1,187 @@ +///////////////////////////////////////////////////////// +/** + * Useful Macros + * by subcrip + * (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) decltype(container)::value_type + +/* type aliases */ +using ll = int64_t; using ull = uint64_t; +using pii = pair; +using pil = pair; +using pli = pair; +using pll = pair; -constexpr int MAXN = 1e5 + 10; -constexpr ull mdl = 1e9 + 7; +/* constants */ +constexpr int INF = 0x3f3f3f3f; +constexpr ull MDL = 1e9 + 7; +constexpr ull PRIME = 998'244'353; +constexpr ull MDL1 = 825; +constexpr ull MDL2 = 87825; -ull table[MAXN + 1]; +/* 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))) -void prep() { - ull l1 = 1, l2 = 0; - for (int i = 0; i < MAXN + 1; ++i) { - table[i] = (l1 + l2) % mdl; - l1 = l2; - l2 = table[i]; +/* arithmetic operations */ +#define mod(x, y) (((x) + (y)) % (y)) + +/* fast pairs */ +#define upair ull +#define umake(x, y) (ull(x) << 32 | ull(y)) +#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(p))) +#define i2(p) (int(u2(p))) +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;) + +/* build data structures */ +#define unordered_counter(from, to) __AS_PROCEDURE(unordered_map<__as_typeof(from), size_t> to; for (auto&& x : from) ++to[x];) +#define counter(from, to, cmp) __AS_PROCEDURE(map<__as_typeof(from), size_t, cmp> to; for (auto&& x : from) ++to[x];) +#define pa(a) __AS_PROCEDURE(__typeof(a) pa; pa.push_back({}); for (auto&&x : a) pa.push_back(pa.back() + x);) +#define sa(a) __AS_PROCEDURE(__typeof(a) sa(a.size() + 1); {int n = a.size(); for (int i = n - 1; i >= 0; --i) sa[i] = sa[i + 1] + a[i];};) +#define adj(ch, n) __AS_PROCEDURE(vector> ch((n) + 1);) +#define edge(ch, u, v) __AS_PROCEDURE(ch[u].push_back(v), ch[v].push_back(u);) +#define Edge(ch, u, v) __AS_PROCEDURE(ch[u].push_back(v);) + +/* io */ +#define untie __AS_PROCEDURE(ios_base::sync_with_stdio(0), cin.tie(NULL)) +template void __read(T& x) { cin >> x; } +template void __read(T& x, U&... args) { cin >> x; __read(args...); } +#define read(type, ...) __AS_PROCEDURE(type __VA_ARGS__; __read(__VA_ARGS__);) +#define readvec(type, a, n) __AS_PROCEDURE(vector a(n); for (int i = 0; i < (n); ++i) cin >> a[i];) +#define putvec(a) __AS_PROCEDURE(for (auto&& x : a) cout << x << ' '; cout << endl;) +#define debug(x) __AS_PROCEDURE(cerr << #x" = " << (x) << endl;) +#define debugvec(a) __AS_PROCEDURE(cerr << #a" = "; for (auto&& x : a) cerr << x << ' '; cerr << endl;) +template ostream& operator<<(ostream& out, vector vec) { + for (auto&& i : vec) out << i << ' '; + return out; +} + +/* pops */ +#define poptop(q, ...) __AS_PROCEDURE(auto [__VA_ARGS__] = q.top(); q.pop();) +#define popback(q, ...) __AS_PROCEDURE(auto [__VA_ARGS__] = q.back(); q.pop_back();) +#define popfront(q, ...) __AS_PROCEDURE(auto [__VA_ARGS__] = q.front();q.pop_front();) + +/* algorithms */ + +vector calc_next(string t) { // pi function of t + int n = (int)t.length(); + vector pi(n); + for (int i = 1; i < n; i++) { + int j = pi[i - 1]; + while (j > 0 && t[i] != t[j]) j = pi[j - 1]; + if (t[i] == t[j]) j++; + pi[i] = j; + } + return pi; +} +vector calc_z(string t) { // z function of t + int m = t.length(); + vector z; + z.push_back(m); + pair prev = {1, -1}; + for (int i = 1; i < m; ++i) { + if (z[i - prev.first] + i <= prev.second) { + z.push_back(z[i - prev.first]); + } else { + int j = max(i, prev.second + 1); + while (j < m && t[j] == t[j - i]) ++j; + z.push_back(j - i); + prev = {i, j - 1}; + } + } + return z; +} +vector kmp(string s, string t) { // find all t in s + string cur = t + '#' + s; + int sz1 = s.size(), sz2 = t.size(); + vector v; + vector lps = calc_next(cur); + for (int i = sz2 + 1; i <= sz1 + sz2; i++) { + if (lps[i] == sz2) v.push_back(i - 2 * sz2); + } + return v; +} +int period(string s) { // find the length of shortest recurring period + int n = s.length(); + auto z = calc_z(s); + for (int i = 1; i <= n / 2; ++i) { + if (n % i == 0 && z[i] == n - i) { + return i; + } + } + return n; +} +///////////////////////////////////////////////////////// + +void solve() { + read(int, n); + read(string, a); + vector st; + for (int i = 0; i < n; ++i) { + while (st.size() && a[st.back()] < a[i]) st.pop_back(); + st.push_back(i); + } + int m = st.size(); + int mh = st.size() >> 1; + int res = 0; + for (int i = 1; i < m; ++i) { + if (a[st[i]] != a[st[0]]) { + res = m - i; + break; + } + } + for (int i = 0; i < mh; ++i) { + swap(a[st[i]], a[st[m - 1 - i]]); + } + for (int i = 1; i < n; ++i) { + if (a[i] < a[i-1]) { + cout << -1 << endl; + return; + } + } + cout << res << endl; } int main() { - prep(); - string s; cin >> s; - s.push_back(0); - ull res = 1; - int acc = 0; - char prev = 0; - for (auto&& c : s) { - if (c == 'w' || c == 'm') { - goto zero; - } - if (c != prev) { - if (prev == 'u' || prev == 'n') { - res = (res * (table[acc] % mdl)) % mdl; - } - acc = 1; - prev = c; - } else { - ++acc; - } - } - cout << res; - return 0; - zero: cout << '0'; + read(int, t); + while (t--) solve(); } \ No newline at end of file diff --git a/src/bin/cf-1905c.gen b/src/bin/cf-1905c.gen new file mode 100755 index 0000000000000000000000000000000000000000..bda96e3b5e5e880b58a7bb69c98b7a5474dbaec8 GIT binary patch literal 46888 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 literal 0 HcmV?d00001 diff --git a/src/bin/cf-1909b.cc b/src/bin/cf-1909b.cc new file mode 100644 index 0000000..d0e92bc --- /dev/null +++ b/src/bin/cf-1909b.cc @@ -0,0 +1,177 @@ +///////////////////////////////////////////////////////// +/** + * Useful Macros + * by subcrip + * (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) decltype(container)::value_type + +/* type aliases */ +using ll = int64_t; +using ull = uint64_t; +using pii = pair; +using pil = pair; +using pli = pair; +using pll = pair; + +/* constants */ +constexpr int INF = 0x3f3f3f3f; +constexpr ull MDL = 1e9 + 7; +constexpr ull PRIME = 998'244'353; +constexpr ull MDL1 = 825; +constexpr ull MDL2 = 87825; + +/* 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)) + +/* fast pairs */ +#define upair ull +#define umake(x, y) (ull(x) << 32 | ull(y)) +#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(p))) +#define i2(p) (int(u2(p))) +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;) + +/* build data structures */ +#define unordered_counter(from, to) __AS_PROCEDURE(unordered_map<__as_typeof(from), size_t> to; for (auto&& x : from) ++to[x];) +#define counter(from, to, cmp) __AS_PROCEDURE(map<__as_typeof(from), size_t, cmp> to; for (auto&& x : from) ++to[x];) +#define pa(a) __AS_PROCEDURE(__typeof(a) pa; pa.push_back({}); for (auto&&x : a) pa.push_back(pa.back() + x);) +#define sa(a) __AS_PROCEDURE(__typeof(a) sa(a.size() + 1); {int n = a.size(); for (int i = n - 1; i >= 0; --i) sa[i] = sa[i + 1] + a[i];};) +#define adj(ch, n) __AS_PROCEDURE(vector> ch((n) + 1);) +#define edge(ch, u, v) __AS_PROCEDURE(ch[u].push_back(v), ch[v].push_back(u);) +#define Edge(ch, u, v) __AS_PROCEDURE(ch[u].push_back(v);) + +/* io */ +#define untie __AS_PROCEDURE(ios_base::sync_with_stdio(0), cin.tie(NULL)) +template void __read(T& x) { cin >> x; } +template void __read(T& x, U&... args) { cin >> x; __read(args...); } +#define read(type, ...) __AS_PROCEDURE(type __VA_ARGS__; __read(__VA_ARGS__);) +#define readvec(type, a, n) __AS_PROCEDURE(vector a(n); for (int i = 0; i < (n); ++i) cin >> a[i];) +#define putvec(a) __AS_PROCEDURE(for (auto&& x : a) cout << x << ' '; cout << endl;) +#define debug(x) __AS_PROCEDURE(cerr << #x" = " << (x) << endl;) +#define debugvec(a) __AS_PROCEDURE(cerr << #a" = "; for (auto&& x : a) cerr << x << ' '; cerr << endl;) +template ostream& operator<<(ostream& out, vector vec) { + for (auto&& i : vec) out << i << ' '; + return out; +} + +/* pops */ +#define poptop(q, ...) __AS_PROCEDURE(auto [__VA_ARGS__] = q.top(); q.pop();) +#define popback(q, ...) __AS_PROCEDURE(auto [__VA_ARGS__] = q.back(); q.pop_back();) +#define popfront(q, ...) __AS_PROCEDURE(auto [__VA_ARGS__] = q.front();q.pop_front();) + +/* algorithms */ + +vector calc_next(string t) { // pi function of t + int n = (int)t.length(); + vector pi(n); + for (int i = 1; i < n; i++) { + int j = pi[i - 1]; + while (j > 0 && t[i] != t[j]) j = pi[j - 1]; + if (t[i] == t[j]) j++; + pi[i] = j; + } + return pi; +} +vector calc_z(string t) { // z function of t + int m = t.length(); + vector z; + z.push_back(m); + pair prev = {1, -1}; + for (int i = 1; i < m; ++i) { + if (z[i - prev.first] + i <= prev.second) { + z.push_back(z[i - prev.first]); + } else { + int j = max(i, prev.second + 1); + while (j < m && t[j] == t[j - i]) ++j; + z.push_back(j - i); + prev = {i, j - 1}; + } + } + return z; +} +vector kmp(string s, string t) { // find all t in s + string cur = t + '#' + s; + int sz1 = s.size(), sz2 = t.size(); + vector v; + vector lps = calc_next(cur); + for (int i = sz2 + 1; i <= sz1 + sz2; i++) { + if (lps[i] == sz2) v.push_back(i - 2 * sz2); + } + return v; +} +int period(string s) { // find the length of shortest recurring period + int n = s.length(); + auto z = calc_z(s); + for (int i = 1; i <= n / 2; ++i) { + if (n % i == 0 && z[i] == n - i) { + return i; + } + } + return n; +} +///////////////////////////////////////////////////////// + +void solve() { + read(int, n); + readvec(ll, a, n); + array, 60> cnt = {}; + for (auto&& i : a) { + for(int j = 0; j < 60; ++j) { + cnt[j][(i>>j)&1] = 1; + } + } + for (int i = 0; i < 60; ++i) { + if (cnt[i][0] && cnt[i][1]) { + cout << (1LL << i + 1) << endl; + // for (auto&& j : a) cerr << (j % (1LL << i + 1)) << ' '; + // cerr << endl; + return; + } + } +} + +int main() { + read(int, t); + while (t--) solve(); +} \ No newline at end of file diff --git a/src/bin/cf-309c.cc b/src/bin/cf-309c.cc new file mode 100644 index 0000000..48b7052 --- /dev/null +++ b/src/bin/cf-309c.cc @@ -0,0 +1,191 @@ +///////////////////////////////////////////////////////// +/** + * Useful Macros + * by subcrip + * (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) decltype(container)::value_type + +/* type aliases */ +using ll = int64_t; +using ull = uint64_t; +using pii = pair; +using pil = pair; +using pli = pair; +using pll = pair; + +/* constants */ +constexpr int INF = 0x3f3f3f3f; +constexpr ull MDL = 1e9 + 7; +constexpr ull PRIME = 998'244'353; +constexpr ull MDL1 = 825; +constexpr ull MDL2 = 87825; + +/* 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)) + +/* fast pairs */ +#define upair ull +#define umake(x, y) (ull(x) << 32 | ull(y)) +#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(p))) +#define i2(p) (int(u2(p))) +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;) + +/* build data structures */ +#define unordered_counter(from, to) __AS_PROCEDURE(unordered_map<__as_typeof(from), size_t> to; for (auto&& x : from) ++to[x];) +#define counter(from, to, cmp) __AS_PROCEDURE(map<__as_typeof(from), size_t, cmp> to; for (auto&& x : from) ++to[x];) +#define pa(a) __AS_PROCEDURE(__typeof(a) pa; pa.push_back({}); for (auto&&x : a) pa.push_back(pa.back() + x);) +#define sa(a) __AS_PROCEDURE(__typeof(a) sa(a.size() + 1); {int n = a.size(); for (int i = n - 1; i >= 0; --i) sa[i] = sa[i + 1] + a[i];};) +#define adj(ch, n) __AS_PROCEDURE(vector> ch((n) + 1);) +#define edge(ch, u, v) __AS_PROCEDURE(ch[u].push_back(v), ch[v].push_back(u);) +#define Edge(ch, u, v) __AS_PROCEDURE(ch[u].push_back(v);) + +/* io */ +#define untie __AS_PROCEDURE(ios_base::sync_with_stdio(0), cin.tie(NULL)) +template void __read(T& x) { cin >> x; } +template void __read(T& x, U&... args) { cin >> x; __read(args...); } +#define read(type, ...) __AS_PROCEDURE(type __VA_ARGS__; __read(__VA_ARGS__);) +#define readvec(type, a, n) __AS_PROCEDURE(vector a(n); for (int i = 0; i < (n); ++i) cin >> a[i];) +#define putvec(a) __AS_PROCEDURE(for (auto&& x : a) cout << x << ' '; cout << endl;) +#define debug(x) __AS_PROCEDURE(cerr << #x" = " << (x) << endl;) +#define debugvec(a) __AS_PROCEDURE(cerr << #a" = "; for (auto&& x : a) cerr << x << ' '; cerr << endl;) +template ostream& operator<<(ostream& out, vector vec) { + for (auto&& i : vec) out << i << ' '; + return out; +} + +/* pops */ +#define poptop(q, ...) __AS_PROCEDURE(auto [__VA_ARGS__] = q.top(); q.pop();) +#define popback(q, ...) __AS_PROCEDURE(auto [__VA_ARGS__] = q.back(); q.pop_back();) +#define popfront(q, ...) __AS_PROCEDURE(auto [__VA_ARGS__] = q.front();q.pop_front();) + +/* algorithms */ + +vector calc_next(string t) { // pi function of t + int n = (int)t.length(); + vector pi(n); + for (int i = 1; i < n; i++) { + int j = pi[i - 1]; + while (j > 0 && t[i] != t[j]) j = pi[j - 1]; + if (t[i] == t[j]) j++; + pi[i] = j; + } + return pi; +} +vector calc_z(string t) { // z function of t + int m = t.length(); + vector z; + z.push_back(m); + pair prev = {1, -1}; + for (int i = 1; i < m; ++i) { + if (z[i - prev.first] + i <= prev.second) { + z.push_back(z[i - prev.first]); + } else { + int j = max(i, prev.second + 1); + while (j < m && t[j] == t[j - i]) ++j; + z.push_back(j - i); + prev = {i, j - 1}; + } + } + return z; +} +vector kmp(string s, string t) { // find all t in s + string cur = t + '#' + s; + int sz1 = s.size(), sz2 = t.size(); + vector v; + vector lps = calc_next(cur); + for (int i = sz2 + 1; i <= sz1 + sz2; i++) { + if (lps[i] == sz2) v.push_back(i - 2 * sz2); + } + return v; +} +int period(string s) { // find the length of shortest recurring period + int n = s.length(); + auto z = calc_z(s); + for (int i = 1; i <= n / 2; ++i) { + if (n % i == 0 && z[i] == n - i) { + return i; + } + } + return n; +} +///////////////////////////////////////////////////////// + +int main() { + untie; + read(int, n, m); + ll res = 0; + vector a_p(32); + for (int i = 0; i < n; ++i) { + read(ll, a); + int j = 0; + while (a) { + a_p[j] += a & 1; + a >>= 1; + j += 1; + } + } + vector b_p(32); + for (int i = 0; i < m; ++i) { + read(int, b); + b_p[b] += 1; + } + for (int i = 0; i < 32; ++i) { + for (int t = 0; t < a_p[i]; ++t) { + ll remains = 1 << i; + for (int j = 0; j < 32; ++j) { + if ((b_p[j] << j) > remains) { + ll add = remains / (1 << j); + res += add; + b_p[j] -= add; + break; + } + res += b_p[j]; + remains -= b_p[j] << j; + b_p[j] = 0; + } + } + } + cout << res << endl; +} \ No newline at end of file diff --git a/src/bin/cf1759e.cc b/src/bin/cf1759e.cc new file mode 100644 index 0000000..19c94ce --- /dev/null +++ b/src/bin/cf1759e.cc @@ -0,0 +1,265 @@ +#pragma GCC optimize("Ofast") +///////////////////////////////////////////////////////// +/** + * Useful Macros + * by subcrip + * (requires C++17) + */ + +#include +#include +using namespace std; +using namespace __gnu_cxx; +using namespace __gnu_pbds; + +/* 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) decltype(container)::value_type + +/* type aliases */ +using ll = int64_t; +using ull = uint64_t; +using pii = pair; +using pil = pair; +using pli = pair; +using pll = pair; + +/* constants */ +constexpr int INF = 0x3f3f3f3f; +constexpr ll INFLL = 0x3f3f3f3f3f3f3f3fLL; +constexpr ull MDL = 1e9 + 7; +constexpr ull PRIME = 998'244'353; +constexpr ll MDL1 = 8784491; +constexpr ll MDL2 = PRIME; + +/* random */ + +mt19937 rd(chrono::duration_cast(chrono::system_clock::now().time_since_epoch()).count()); + +/* bit-wise operations */ +#define lowbit(x) ((x) & -(x)) +#define popcount(x) (__builtin_popcountll(ll(x))) +#define parity(x) (__builtin_parityll(ll(x))) +#define msp(x) (63LL - __builtin_clzll(ll(x))) +#define lsp(x) (__builtin_ctzll(ll(x))) + +/* arithmetic operations */ +#define mod(x, y) ((((x) % (y)) + (y)) % (y)) + +/* fast pairs */ +#define upair ull +#define umake(x, y) (ull(x) << 32 | (ull(y) & ((1ULL << 32) - 1))) +#define u1(p) ((p) >> 32) +#define u2(p) ((p) & ((1ULL << 32) - 1)) +#define ult std::less +#define ugt std::greater + +#define ipair ull +#define imake(x, y) (umake(x, y)) +#define i1(p) (int(u1(ll(p)))) +#define i2(p) (ll(u2(p) << 32) >> 32) +struct ilt { + bool operator()(const ipair& a, const ipair& b) const { + if (i1(a) == i1(b)) return i2(a) < i2(b); + else return i1(a) < i1(b); + } +}; +struct igt { + bool operator()(const ipair& a, const ipair& b) const { + if (i1(a) == i1(b)) return i2(a) > i2(b); + else return i1(a) > i1(b); + } +}; + +/* conditions */ +#define loop while (1) +#define if_or(var, val) if (!(var == val)) var = val; else +#define continue_or(var, val) __AS_PROCEDURE(if (var == val) continue; var = val;) +#define break_or(var, val) __AS_PROCEDURE(if (var == val) break; var = val;) + +/* hash */ +struct safe_hash { + // https://codeforces.com/blog/entry/62393 + static uint64_t splitmix64(uint64_t x) { + // http://xorshift.di.unimi.it/splitmix64.c + x += 0x9e3779b97f4a7c15; + x = (x ^ (x >> 30)) * 0xbf58476d1ce4e5b9; + x = (x ^ (x >> 27)) * 0x94d049bb133111eb; + return x ^ (x >> 31); + } + + size_t operator()(uint64_t x) const { + static const uint64_t FIXED_RANDOM = chrono::steady_clock::now().time_since_epoch().count(); + return splitmix64(x + FIXED_RANDOM); + } +}; + +struct pair_hash { + template + size_t operator()(const pair& a) const { + auto hash1 = safe_hash()(a.first); + auto hash2 = safe_hash()(a.second); + if (hash1 != hash2) { + return hash1 ^ hash2; + } + return hash1; + } +}; + +/* build data structures */ +#define unordered_counter(from, to) __AS_PROCEDURE(unordered_map<__as_typeof(from), size_t, safe_hash> to; for (auto&& x : from) ++to[x];) +#define counter(from, to, cmp) __AS_PROCEDURE(map<__as_typeof(from), size_t, cmp> to; for (auto&& x : from) ++to[x];) +#define pa(a) __AS_PROCEDURE(__typeof(a) pa; pa.push_back({}); for (auto&&x : a) pa.push_back(pa.back() + x);) +#define sa(a) __AS_PROCEDURE(__typeof(a) sa(a.size() + 1); {int n = a.size(); for (int i = n - 1; i >= 0; --i) sa[i] = sa[i + 1] + a[i];};) +#define adj(ch, n) __AS_PROCEDURE(vector> ch((n) + 1);) +#define edge(ch, u, v) __AS_PROCEDURE(ch[u].push_back(v), ch[v].push_back(u);) +#define Edge(ch, u, v) __AS_PROCEDURE(ch[u].push_back(v);) + +/* io */ +#define untie __AS_PROCEDURE(ios_base::sync_with_stdio(0), cin.tie(NULL)) +template void __read(T& x) { cin >> x; } +template void __read(T& x, U&... args) { cin >> x; __read(args...); } +#define read(type, ...) __AS_PROCEDURE(type __VA_ARGS__; __read(__VA_ARGS__);) +#define readvec(type, a, n) __AS_PROCEDURE(vector a(n); for (int i = 0; i < (n); ++i) cin >> a[i];) +#define putvec(a) __AS_PROCEDURE(for (auto&& x : a) cout << x << ' '; cout << endl;) +#define debug(x) __AS_PROCEDURE(cerr << #x" = " << (x) << endl;) +#define debugvec(a) __AS_PROCEDURE(cerr << #a" = "; for (auto&& x : a) cerr << x << ' '; cerr << endl;) +template ostream& operator<<(ostream& out, vector vec) { + for (auto&& i : vec) out << i << ' '; + return out; +} + +/* pops */ +#define poptop(q, ...) __AS_PROCEDURE(auto [__VA_ARGS__] = q.top(); q.pop();) +#define popback(q, ...) __AS_PROCEDURE(auto [__VA_ARGS__] = q.back(); q.pop_back();) +#define popfront(q, ...) __AS_PROCEDURE(auto [__VA_ARGS__] = q.front();q.pop_front();) + +/* math */ +constexpr inline int lg2(ll x) { return x == 0 ? -1 : sizeof(ll) * 8 - 1 - __builtin_clzll(x); } + +void __exgcd(ll a, ll b, ll& x, ll& y) { + if (b == 0) { + x = 1, y = 0; + return; + } + __exgcd(b, a % b, y, x); + y -= a / b * x; +} + +ll inverse(ll a, ll b) { + ll x, y; + __exgcd(a, b, x, y); + return mod(x, b); +} + +/* string algorithms */ +vector calc_next(string t) { // pi function of t + int n = (int)t.length(); + vector pi(n); + for (int i = 1; i < n; i++) { + int j = pi[i - 1]; + while (j > 0 && t[i] != t[j]) j = pi[j - 1]; + if (t[i] == t[j]) j++; + pi[i] = j; + } + return pi; +} +vector calc_z(string t) { // z function of t + int m = t.length(); + vector z; + z.push_back(m); + pair prev = {1, -1}; + for (int i = 1; i < m; ++i) { + if (z[i - prev.first] + i <= prev.second) { + z.push_back(z[i - prev.first]); + } else { + int j = max(i, prev.second + 1); + while (j < m && t[j] == t[j - i]) ++j; + z.push_back(j - i); + prev = {i, j - 1}; + } + } + return z; +} +vector kmp(string s, string t) { // find all t in s + string cur = t + '#' + s; + int sz1 = s.size(), sz2 = t.size(); + vector v; + vector lps = calc_next(cur); + for (int i = sz2 + 1; i <= sz1 + sz2; i++) { + if (lps[i] == sz2) v.push_back(i - 2 * sz2); + } + return v; +} +int period(string s) { // find the length of shortest recurring period + int n = s.length(); + auto z = calc_z(s); + for (int i = 1; i <= n / 2; ++i) { + if (n % i == 0 && z[i] == n - i) { + return i; + } + } + return n; +} +///////////////////////////////////////////////////////// + + +// #define SINGLE_TEST_CASE +// #define DUMP_TEST_CASE 512 + +void dump() {} + +void prep() {} + +void solve() { + read(int, n, h); + readvec(ll, a, n); + sort(a.begin(), a.end()); + auto work = [&] (vector pattern) -> int { + int ptr = 0; + int i = 0; + ll curr = h; + while (i < n) { + if (curr > a[i]) { + curr += a[i] / 2; + i += 1; + } else { + if (ptr >= 3) break; + curr *= pattern[ptr]; + ptr += 1; + } + } + return i; + }; + int res = 0; + vector> patterns = {{2, 2, 3}, {2, 3, 2}, {3, 2, 2}}; + for (auto&& p : patterns) { + res = max(res, work(p)); + } + cout << res << endl; +} + +int main() { + untie, cout.tie(NULL); + prep(); +#ifdef SINGLE_TEST_CASE + solve(); +#else + read(int, t); + for (int i = 0; i < t; ++i) { +#ifdef DUMP_TEST_CASE + if (i + 1 == (DUMP_TEST_CASE)) { + dump(); + } else { + solve(); + } +#else + solve(); +#endif + } +#endif +} diff --git a/src/bin/cf1760f.cc b/src/bin/cf1760f.cc new file mode 100644 index 0000000..24de1a4 --- /dev/null +++ b/src/bin/cf1760f.cc @@ -0,0 +1,242 @@ +#pragma GCC optimize("Ofast") +///////////////////////////////////////////////////////// +/** + * Useful Macros + * by subcrip + * (requires C++17) + */ + +#include +#include +using namespace std; +using namespace __gnu_cxx; +using namespace __gnu_pbds; + +/* 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) decltype(container)::value_type + +/* type aliases */ +using ll = int64_t; +using ull = uint64_t; +using pii = pair; +using pil = pair; +using pli = pair; +using pll = pair; + +/* constants */ +constexpr int INF = 0x3f3f3f3f; +constexpr ull MDL = 1e9 + 7; +constexpr ull PRIME = 998'244'353; +constexpr ll MDL1 = 8784491; +constexpr ll MDL2 = PRIME; + +/* random */ + +mt19937 rd(chrono::duration_cast(chrono::system_clock::now().time_since_epoch()).count()); + +/* bit-wise operations */ +#define lowbit(x) ((x) & -(x)) +#define popcount(x) (__builtin_popcountll(ll(x))) +#define parity(x) (__builtin_parityll(ll(x))) +#define msp(x) (63LL - __builtin_clzll(ll(x))) +#define lsp(x) (__builtin_ctzll(ll(x))) + +/* arithmetic operations */ +#define mod(x, y) ((((x) % (y)) + (y)) % (y)) + +/* fast pairs */ +#define upair ull +#define umake(x, y) (ull(x) << 32 | (ull(y) & ((1ULL << 32) - 1))) +#define u1(p) ((p) >> 32) +#define u2(p) ((p) & ((1ULL << 32) - 1)) +#define ult std::less +#define ugt std::greater + +#define ipair ull +#define imake(x, y) (umake(x, y)) +#define i1(p) (int(u1(ll(p)))) +#define i2(p) (ll(u2(p) << 32) >> 32) +struct ilt { + bool operator()(const ipair& a, const ipair& b) const { + if (i1(a) == i1(b)) return i2(a) < i2(b); + else return i1(a) < i1(b); + } +}; +struct igt { + bool operator()(const ipair& a, const ipair& b) const { + if (i1(a) == i1(b)) return i2(a) > i2(b); + else return i1(a) > i1(b); + } +}; + +/* conditions */ +#define loop while (1) +#define if_or(var, val) if (!(var == val)) var = val; else +#define continue_or(var, val) __AS_PROCEDURE(if (var == val) continue; var = val;) +#define break_or(var, val) __AS_PROCEDURE(if (var == val) break; var = val;) + +/* hash */ +struct safe_hash { + // https://codeforces.com/blog/entry/62393 + static uint64_t splitmix64(uint64_t x) { + // http://xorshift.di.unimi.it/splitmix64.c + x += 0x9e3779b97f4a7c15; + x = (x ^ (x >> 30)) * 0xbf58476d1ce4e5b9; + x = (x ^ (x >> 27)) * 0x94d049bb133111eb; + return x ^ (x >> 31); + } + + size_t operator()(uint64_t x) const { + static const uint64_t FIXED_RANDOM = chrono::steady_clock::now().time_since_epoch().count(); + return splitmix64(x + FIXED_RANDOM); + } +}; + +struct pair_hash { + template + size_t operator()(const pair& a) const { + auto hash1 = safe_hash()(a.first); + auto hash2 = safe_hash()(a.second); + if (hash1 != hash2) { + return hash1 ^ hash2; + } + return hash1; + } +}; + +/* build data structures */ +#define unordered_counter(from, to) __AS_PROCEDURE(unordered_map<__as_typeof(from), size_t, safe_hash> to; for (auto&& x : from) ++to[x];) +#define counter(from, to, cmp) __AS_PROCEDURE(map<__as_typeof(from), size_t, cmp> to; for (auto&& x : from) ++to[x];) +#define pa(a) __AS_PROCEDURE(__typeof(a) pa; pa.push_back({}); for (auto&&x : a) pa.push_back(pa.back() + x);) +#define sa(a) __AS_PROCEDURE(__typeof(a) sa(a.size() + 1); {int n = a.size(); for (int i = n - 1; i >= 0; --i) sa[i] = sa[i + 1] + a[i];};) +#define adj(ch, n) __AS_PROCEDURE(vector> ch((n) + 1);) +#define edge(ch, u, v) __AS_PROCEDURE(ch[u].push_back(v), ch[v].push_back(u);) +#define Edge(ch, u, v) __AS_PROCEDURE(ch[u].push_back(v);) + +/* io */ +#define untie __AS_PROCEDURE(ios_base::sync_with_stdio(0), cin.tie(NULL)) +template void __read(T& x) { cin >> x; } +template void __read(T& x, U&... args) { cin >> x; __read(args...); } +#define read(type, ...) __AS_PROCEDURE(type __VA_ARGS__; __read(__VA_ARGS__);) +#define readvec(type, a, n) __AS_PROCEDURE(vector a(n); for (int i = 0; i < (n); ++i) cin >> a[i];) +#define putvec(a) __AS_PROCEDURE(for (auto&& x : a) cout << x << ' '; cout << endl;) +#define debug(x) __AS_PROCEDURE(cerr << #x" = " << (x) << endl;) +#define debugvec(a) __AS_PROCEDURE(cerr << #a" = "; for (auto&& x : a) cerr << x << ' '; cerr << endl;) +template ostream& operator<<(ostream& out, vector vec) { + for (auto&& i : vec) out << i << ' '; + return out; +} + +/* pops */ +#define poptop(q, ...) __AS_PROCEDURE(auto [__VA_ARGS__] = q.top(); q.pop();) +#define popback(q, ...) __AS_PROCEDURE(auto [__VA_ARGS__] = q.back(); q.pop_back();) +#define popfront(q, ...) __AS_PROCEDURE(auto [__VA_ARGS__] = q.front();q.pop_front();) + +/* math */ +constexpr inline int lg2(ll x) { return x == 0 ? -1 : sizeof(ll) * 8 - 1 - __builtin_clzll(x); } + +void __exgcd(ll a, ll b, ll& x, ll& y) { + if (b == 0) { + x = 1, y = 0; + return; + } + __exgcd(b, a % b, y, x); + y -= a / b * x; +} + +ll inverse(ll a, ll b) { + ll x, y; + __exgcd(a, b, x, y); + return mod(x, b); +} + +/* string algorithms */ +vector calc_next(string t) { // pi function of t + int n = (int)t.length(); + vector pi(n); + for (int i = 1; i < n; i++) { + int j = pi[i - 1]; + while (j > 0 && t[i] != t[j]) j = pi[j - 1]; + if (t[i] == t[j]) j++; + pi[i] = j; + } + return pi; +} +vector calc_z(string t) { // z function of t + int m = t.length(); + vector z; + z.push_back(m); + pair prev = {1, -1}; + for (int i = 1; i < m; ++i) { + if (z[i - prev.first] + i <= prev.second) { + z.push_back(z[i - prev.first]); + } else { + int j = max(i, prev.second + 1); + while (j < m && t[j] == t[j - i]) ++j; + z.push_back(j - i); + prev = {i, j - 1}; + } + } + return z; +} +vector kmp(string s, string t) { // find all t in s + string cur = t + '#' + s; + int sz1 = s.size(), sz2 = t.size(); + vector v; + vector lps = calc_next(cur); + for (int i = sz2 + 1; i <= sz1 + sz2; i++) { + if (lps[i] == sz2) v.push_back(i - 2 * sz2); + } + return v; +} +int period(string s) { // find the length of shortest recurring period + int n = s.length(); + auto z = calc_z(s); + for (int i = 1; i <= n / 2; ++i) { + if (n % i == 0 && z[i] == n - i) { + return i; + } + } + return n; +} +///////////////////////////////////////////////////////// + + +// #define SINGLE_TEST_CASE +// #define DUMP_TEST_CASE 512 + +void dump() {} + +void solve() { + read(int, n); + read(ll, c); + read(int, d); + readvec(int, a, n); + sort(a.begin(), a.end(), greater()); + +} + +int main() { + untie, cout.tie(NULL); +#ifdef SINGLE_TEST_CASE + solve(); +#else + read(int, t); + for (int i = 0; i < t; ++i) { +#ifdef DUMP_TEST_CASE + if (i + 1 == (DUMP_TEST_CASE)) { + dump(); + } else { + solve(); + } +#else + solve(); +#endif + } +#endif +} diff --git a/src/bin/cf1923d.cc b/src/bin/cf1923d.cc new file mode 100644 index 0000000..97db525 --- /dev/null +++ b/src/bin/cf1923d.cc @@ -0,0 +1,314 @@ +#pragma GCC optimize("Ofast") +///////////////////////////////////////////////////////// +/** + * Useful Macros + * by subcrip + * (requires C++17) + */ + +#include +#include +using namespace std; +using namespace __gnu_cxx; +using namespace __gnu_pbds; + +/* 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) decltype(container)::value_type + +/* type aliases */ +using ll = int64_t; +using ull = uint64_t; +using pii = pair; +using pil = pair; +using pli = pair; +using pll = pair; + +/* constants */ +constexpr int INF = 0x3f3f3f3f; +constexpr ull MDL = 1e9 + 7; +constexpr ull PRIME = 998'244'353; +constexpr ll MDL1 = 825; +constexpr ll MDL2 = PRIME; + +/* random */ + +mt19937 rd(chrono::duration_cast(chrono::system_clock::now().time_since_epoch()).count()); + +/* bit-wise operations */ +#define lowbit(x) ((x) & -(x)) +#define popcount(x) (__builtin_popcountll(ll(x))) +#define parity(x) (__builtin_parityll(ll(x))) +#define msp(x) (63LL - __builtin_clzll(ll(x))) +#define lsp(x) (__builtin_ctzll(ll(x))) + +/* arithmetic operations */ +#define mod(x, y) ((((x) % (y)) + (y)) % (y)) + +/* fast pairs */ +#define upair ull +#define umake(x, y) (ull(x) << 32 | (ull(y) & ((1ULL << 32) - 1))) +#define u1(p) ((p) >> 32) +#define u2(p) ((p) & ((1ULL << 32) - 1)) +#define ult std::less +#define ugt std::greater + +#define ipair ull +#define imake(x, y) (umake(x, y)) +#define i1(p) (int(u1(ll(p)))) +#define i2(p) (ll(u2(p) << 32) >> 32) +struct ilt { + bool operator()(const ipair& a, const ipair& b) const { + if (i1(a) == i1(b)) return i2(a) < i2(b); + else return i1(a) < i1(b); + } +}; +struct igt { + bool operator()(const ipair& a, const ipair& b) const { + if (i1(a) == i1(b)) return i2(a) > i2(b); + else return i1(a) > i1(b); + } +}; + +/* conditions */ +#define loop while (1) +#define if_or(var, val) if (!(var == val)) var = val; else +#define continue_or(var, val) __AS_PROCEDURE(if (var == val) continue; var = val;) +#define break_or(var, val) __AS_PROCEDURE(if (var == val) break; var = val;) + +/* hash */ +struct safe_hash { + // https://codeforces.com/blog/entry/62393 + static uint64_t splitmix64(uint64_t x) { + // http://xorshift.di.unimi.it/splitmix64.c + x += 0x9e3779b97f4a7c15; + x = (x ^ (x >> 30)) * 0xbf58476d1ce4e5b9; + x = (x ^ (x >> 27)) * 0x94d049bb133111eb; + return x ^ (x >> 31); + } + + size_t operator()(uint64_t x) const { + static const uint64_t FIXED_RANDOM = chrono::steady_clock::now().time_since_epoch().count(); + return splitmix64(x + FIXED_RANDOM); + } +}; + +struct pair_hash { + template + size_t operator()(const pair& a) const { + auto hash1 = safe_hash()(a.first); + auto hash2 = safe_hash()(a.second); + if (hash1 != hash2) { + return hash1 ^ hash2; + } + return hash1; + } +}; + +/* build data structures */ +#define unordered_counter(from, to) __AS_PROCEDURE(unordered_map<__as_typeof(from), size_t, safe_hash> to; for (auto&& x : from) ++to[x];) +#define counter(from, to, cmp) __AS_PROCEDURE(map<__as_typeof(from), size_t, cmp> to; for (auto&& x : from) ++to[x];) +#define pa(a) __AS_PROCEDURE(__typeof(a) pa; pa.push_back({}); for (auto&&x : a) pa.push_back(pa.back() + x);) +#define sa(a) __AS_PROCEDURE(__typeof(a) sa(a.size() + 1); {int n = a.size(); for (int i = n - 1; i >= 0; --i) sa[i] = sa[i + 1] + a[i];};) +#define adj(ch, n) __AS_PROCEDURE(vector> ch((n) + 1);) +#define edge(ch, u, v) __AS_PROCEDURE(ch[u].push_back(v), ch[v].push_back(u);) +#define Edge(ch, u, v) __AS_PROCEDURE(ch[u].push_back(v);) + +/* io */ +#define untie __AS_PROCEDURE(ios_base::sync_with_stdio(0), cin.tie(NULL)) +template void __read(T& x) { cin >> x; } +template void __read(T& x, U&... args) { cin >> x; __read(args...); } +#define read(type, ...) __AS_PROCEDURE(type __VA_ARGS__; __read(__VA_ARGS__);) +#define readvec(type, a, n) __AS_PROCEDURE(vector a(n); for (int i = 0; i < (n); ++i) cin >> a[i];) +#define putvec(a) __AS_PROCEDURE(for (auto&& x : a) cout << x << ' '; cout << endl;) +#define debug(x) __AS_PROCEDURE(cerr << #x" = " << (x) << endl;) +#define debugvec(a) __AS_PROCEDURE(cerr << #a" = "; for (auto&& x : a) cerr << x << ' '; cerr << endl;) +template ostream& operator<<(ostream& out, vector vec) { + for (auto&& i : vec) out << i << ' '; + return out; +} + +/* pops */ +#define poptop(q, ...) __AS_PROCEDURE(auto [__VA_ARGS__] = q.top(); q.pop();) +#define popback(q, ...) __AS_PROCEDURE(auto [__VA_ARGS__] = q.back(); q.pop_back();) +#define popfront(q, ...) __AS_PROCEDURE(auto [__VA_ARGS__] = q.front();q.pop_front();) + +/* math */ +constexpr inline int lg2(ll x) { return x == 0 ? -1 : sizeof(ll) * 8 - 1 - __builtin_clzll(x); } + +void __exgcd(ll a, ll b, ll& x, ll& y) { + if (b == 0) { + x = 1, y = 0; + return; + } + __exgcd(b, a % b, y, x); + y -= a / b * x; +} + +ll inverse(ll a, ll b) { + ll x, y; + __exgcd(a, b, x, y); + return mod(x, b); +} + +/* string algorithms */ +vector calc_next(string t) { // pi function of t + int n = (int)t.length(); + vector pi(n); + for (int i = 1; i < n; i++) { + int j = pi[i - 1]; + while (j > 0 && t[i] != t[j]) j = pi[j - 1]; + if (t[i] == t[j]) j++; + pi[i] = j; + } + return pi; +} +vector calc_z(string t) { // z function of t + int m = t.length(); + vector z; + z.push_back(m); + pair prev = {1, -1}; + for (int i = 1; i < m; ++i) { + if (z[i - prev.first] + i <= prev.second) { + z.push_back(z[i - prev.first]); + } else { + int j = max(i, prev.second + 1); + while (j < m && t[j] == t[j - i]) ++j; + z.push_back(j - i); + prev = {i, j - 1}; + } + } + return z; +} +vector kmp(string s, string t) { // find all t in s + string cur = t + '#' + s; + int sz1 = s.size(), sz2 = t.size(); + vector v; + vector lps = calc_next(cur); + for (int i = sz2 + 1; i <= sz1 + sz2; i++) { + if (lps[i] == sz2) v.push_back(i - 2 * sz2); + } + return v; +} +int period(string s) { // find the length of shortest recurring period + int n = s.length(); + auto z = calc_z(s); + for (int i = 1; i <= n / 2; ++i) { + if (n % i == 0 && z[i] == n - i) { + return i; + } + } + return n; +} +///////////////////////////////////////////////////////// + +// #define SINGLE_TEST_CASE +// #define DUMP_TEST_CASE 512 + +void dump() {} + +template> struct sparse_table { + _Op op; + vector> st; + template + sparse_table(ReverseIterator __first, ReverseIterator __last, _Op&& __operation) { + op = __operation; + int n = distance(__first, __last); + st = vector>(n, vector<_Tp>(int(log2(n) + 1))); + int i = n - 1; + for (auto it = __first; it != __last; ++it) { + st[i][0] = *it; + for (int j = 1; i + (1 << j) <= n; ++j) { + st[i][j] = op(st[i][j - 1], st[i + (1 << (j - 1))][j - 1]); + } + i -= 1; + } + } + _Tp query(size_t __start, size_t __end) { + int s = lg2(__end - __start + 1); + return op(st[__start][s], st[__end - (1 << s) + 1][s]); + } +}; + +auto u_max = [] (const int& a, const int& b) { return max(a, b); }; +auto u_min = [] (const int& a, const int& b) { return min(a, b); }; + +void solve() { + read(int, n); + readvec(int, a, n); + vector ps(n + 1); + for (int i = 1; i <= n; ++i) { + ps[i] = ps[i - 1] + a[i - 1]; + } + vector res(n); + // sparse_table mxt(a.rbegin(), a.rend(), u_max); + // sparse_table mnt(a.rbegin(), a.rend(), u_min); + sparse_table mxt(a.rbegin(), a.rend(), u_max); + sparse_table mnt(a.rbegin(), a.rend(), u_min); + auto find_left = [&] (int i) -> int { + // find the first ps > a[i - 1] + if (i == 1) return INT_MAX; + int l = 0, r = i - 1; + while (l < r) { + int mid = l + r + 1 >> 1; + if (ps[i - 1] - ps[mid] <= a[i - 1] || mid + 1 != i - 1 && mxt.query(mid, i - 2) == mnt.query(mid, i - 2)) { + r = mid - 1; + } else { + l = mid; + } + } + if (ps[i - 1] - ps[l] <= a[i - 1] || l + 1 != i - 1 && mxt.query(l, i - 2) == mnt.query(l, i - 2)) { + return INT_MAX; + } else { + return i - l - 1; + } + }; + auto find_right = [&] (int i) -> int { + if (i == n) return INT_MAX; + int l = i, r = n; + while (l < r) { + int mid = l + r >> 1; + if (ps[mid] - ps[i] <= a[i - 1] || i + 1 != mid && mxt.query(i, mid - 1) == mnt.query(i, mid - 1)) { + l = mid + 1; + } else { + r = mid; + } + } + if (ps[r] - ps[i] <= a[i - 1] || i + 1 != r && mxt.query(i, r - 1) == mnt.query(i, r - 1)) { + return INT_MAX; + } else { + return r - i; + } + }; + for (int i = 1; i <= n; ++i) { + if (i > 1 && a[i-2] > a[i-1]) res[i-1] = 1; + else if (i < n && a[i] > a[i-1]) res[i-1] = 1; + else res[i - 1] = min(find_left(i), find_right(i)); + if (res[i - 1] == INT_MAX) res[i - 1] = -1; + } + putvec(res); +} + +int main() { + untie, cout.tie(NULL); +#ifdef SINGLE_TEST_CASE + solve(); +#else + read(int, t); + for (int i = 0; i < t; ++i) { +#ifdef DUMP_TEST_CASE + if (i + 1 == (DUMP_TEST_CASE)) { + dump(); + } else { + solve(); + } +#else + solve(); +#endif + } +#endif +} diff --git a/src/bin/d.cc b/src/bin/d.cc new file mode 100644 index 0000000..97db525 --- /dev/null +++ b/src/bin/d.cc @@ -0,0 +1,314 @@ +#pragma GCC optimize("Ofast") +///////////////////////////////////////////////////////// +/** + * Useful Macros + * by subcrip + * (requires C++17) + */ + +#include +#include +using namespace std; +using namespace __gnu_cxx; +using namespace __gnu_pbds; + +/* 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) decltype(container)::value_type + +/* type aliases */ +using ll = int64_t; +using ull = uint64_t; +using pii = pair; +using pil = pair; +using pli = pair; +using pll = pair; + +/* constants */ +constexpr int INF = 0x3f3f3f3f; +constexpr ull MDL = 1e9 + 7; +constexpr ull PRIME = 998'244'353; +constexpr ll MDL1 = 825; +constexpr ll MDL2 = PRIME; + +/* random */ + +mt19937 rd(chrono::duration_cast(chrono::system_clock::now().time_since_epoch()).count()); + +/* bit-wise operations */ +#define lowbit(x) ((x) & -(x)) +#define popcount(x) (__builtin_popcountll(ll(x))) +#define parity(x) (__builtin_parityll(ll(x))) +#define msp(x) (63LL - __builtin_clzll(ll(x))) +#define lsp(x) (__builtin_ctzll(ll(x))) + +/* arithmetic operations */ +#define mod(x, y) ((((x) % (y)) + (y)) % (y)) + +/* fast pairs */ +#define upair ull +#define umake(x, y) (ull(x) << 32 | (ull(y) & ((1ULL << 32) - 1))) +#define u1(p) ((p) >> 32) +#define u2(p) ((p) & ((1ULL << 32) - 1)) +#define ult std::less +#define ugt std::greater + +#define ipair ull +#define imake(x, y) (umake(x, y)) +#define i1(p) (int(u1(ll(p)))) +#define i2(p) (ll(u2(p) << 32) >> 32) +struct ilt { + bool operator()(const ipair& a, const ipair& b) const { + if (i1(a) == i1(b)) return i2(a) < i2(b); + else return i1(a) < i1(b); + } +}; +struct igt { + bool operator()(const ipair& a, const ipair& b) const { + if (i1(a) == i1(b)) return i2(a) > i2(b); + else return i1(a) > i1(b); + } +}; + +/* conditions */ +#define loop while (1) +#define if_or(var, val) if (!(var == val)) var = val; else +#define continue_or(var, val) __AS_PROCEDURE(if (var == val) continue; var = val;) +#define break_or(var, val) __AS_PROCEDURE(if (var == val) break; var = val;) + +/* hash */ +struct safe_hash { + // https://codeforces.com/blog/entry/62393 + static uint64_t splitmix64(uint64_t x) { + // http://xorshift.di.unimi.it/splitmix64.c + x += 0x9e3779b97f4a7c15; + x = (x ^ (x >> 30)) * 0xbf58476d1ce4e5b9; + x = (x ^ (x >> 27)) * 0x94d049bb133111eb; + return x ^ (x >> 31); + } + + size_t operator()(uint64_t x) const { + static const uint64_t FIXED_RANDOM = chrono::steady_clock::now().time_since_epoch().count(); + return splitmix64(x + FIXED_RANDOM); + } +}; + +struct pair_hash { + template + size_t operator()(const pair& a) const { + auto hash1 = safe_hash()(a.first); + auto hash2 = safe_hash()(a.second); + if (hash1 != hash2) { + return hash1 ^ hash2; + } + return hash1; + } +}; + +/* build data structures */ +#define unordered_counter(from, to) __AS_PROCEDURE(unordered_map<__as_typeof(from), size_t, safe_hash> to; for (auto&& x : from) ++to[x];) +#define counter(from, to, cmp) __AS_PROCEDURE(map<__as_typeof(from), size_t, cmp> to; for (auto&& x : from) ++to[x];) +#define pa(a) __AS_PROCEDURE(__typeof(a) pa; pa.push_back({}); for (auto&&x : a) pa.push_back(pa.back() + x);) +#define sa(a) __AS_PROCEDURE(__typeof(a) sa(a.size() + 1); {int n = a.size(); for (int i = n - 1; i >= 0; --i) sa[i] = sa[i + 1] + a[i];};) +#define adj(ch, n) __AS_PROCEDURE(vector> ch((n) + 1);) +#define edge(ch, u, v) __AS_PROCEDURE(ch[u].push_back(v), ch[v].push_back(u);) +#define Edge(ch, u, v) __AS_PROCEDURE(ch[u].push_back(v);) + +/* io */ +#define untie __AS_PROCEDURE(ios_base::sync_with_stdio(0), cin.tie(NULL)) +template void __read(T& x) { cin >> x; } +template void __read(T& x, U&... args) { cin >> x; __read(args...); } +#define read(type, ...) __AS_PROCEDURE(type __VA_ARGS__; __read(__VA_ARGS__);) +#define readvec(type, a, n) __AS_PROCEDURE(vector a(n); for (int i = 0; i < (n); ++i) cin >> a[i];) +#define putvec(a) __AS_PROCEDURE(for (auto&& x : a) cout << x << ' '; cout << endl;) +#define debug(x) __AS_PROCEDURE(cerr << #x" = " << (x) << endl;) +#define debugvec(a) __AS_PROCEDURE(cerr << #a" = "; for (auto&& x : a) cerr << x << ' '; cerr << endl;) +template ostream& operator<<(ostream& out, vector vec) { + for (auto&& i : vec) out << i << ' '; + return out; +} + +/* pops */ +#define poptop(q, ...) __AS_PROCEDURE(auto [__VA_ARGS__] = q.top(); q.pop();) +#define popback(q, ...) __AS_PROCEDURE(auto [__VA_ARGS__] = q.back(); q.pop_back();) +#define popfront(q, ...) __AS_PROCEDURE(auto [__VA_ARGS__] = q.front();q.pop_front();) + +/* math */ +constexpr inline int lg2(ll x) { return x == 0 ? -1 : sizeof(ll) * 8 - 1 - __builtin_clzll(x); } + +void __exgcd(ll a, ll b, ll& x, ll& y) { + if (b == 0) { + x = 1, y = 0; + return; + } + __exgcd(b, a % b, y, x); + y -= a / b * x; +} + +ll inverse(ll a, ll b) { + ll x, y; + __exgcd(a, b, x, y); + return mod(x, b); +} + +/* string algorithms */ +vector calc_next(string t) { // pi function of t + int n = (int)t.length(); + vector pi(n); + for (int i = 1; i < n; i++) { + int j = pi[i - 1]; + while (j > 0 && t[i] != t[j]) j = pi[j - 1]; + if (t[i] == t[j]) j++; + pi[i] = j; + } + return pi; +} +vector calc_z(string t) { // z function of t + int m = t.length(); + vector z; + z.push_back(m); + pair prev = {1, -1}; + for (int i = 1; i < m; ++i) { + if (z[i - prev.first] + i <= prev.second) { + z.push_back(z[i - prev.first]); + } else { + int j = max(i, prev.second + 1); + while (j < m && t[j] == t[j - i]) ++j; + z.push_back(j - i); + prev = {i, j - 1}; + } + } + return z; +} +vector kmp(string s, string t) { // find all t in s + string cur = t + '#' + s; + int sz1 = s.size(), sz2 = t.size(); + vector v; + vector lps = calc_next(cur); + for (int i = sz2 + 1; i <= sz1 + sz2; i++) { + if (lps[i] == sz2) v.push_back(i - 2 * sz2); + } + return v; +} +int period(string s) { // find the length of shortest recurring period + int n = s.length(); + auto z = calc_z(s); + for (int i = 1; i <= n / 2; ++i) { + if (n % i == 0 && z[i] == n - i) { + return i; + } + } + return n; +} +///////////////////////////////////////////////////////// + +// #define SINGLE_TEST_CASE +// #define DUMP_TEST_CASE 512 + +void dump() {} + +template> struct sparse_table { + _Op op; + vector> st; + template + sparse_table(ReverseIterator __first, ReverseIterator __last, _Op&& __operation) { + op = __operation; + int n = distance(__first, __last); + st = vector>(n, vector<_Tp>(int(log2(n) + 1))); + int i = n - 1; + for (auto it = __first; it != __last; ++it) { + st[i][0] = *it; + for (int j = 1; i + (1 << j) <= n; ++j) { + st[i][j] = op(st[i][j - 1], st[i + (1 << (j - 1))][j - 1]); + } + i -= 1; + } + } + _Tp query(size_t __start, size_t __end) { + int s = lg2(__end - __start + 1); + return op(st[__start][s], st[__end - (1 << s) + 1][s]); + } +}; + +auto u_max = [] (const int& a, const int& b) { return max(a, b); }; +auto u_min = [] (const int& a, const int& b) { return min(a, b); }; + +void solve() { + read(int, n); + readvec(int, a, n); + vector ps(n + 1); + for (int i = 1; i <= n; ++i) { + ps[i] = ps[i - 1] + a[i - 1]; + } + vector res(n); + // sparse_table mxt(a.rbegin(), a.rend(), u_max); + // sparse_table mnt(a.rbegin(), a.rend(), u_min); + sparse_table mxt(a.rbegin(), a.rend(), u_max); + sparse_table mnt(a.rbegin(), a.rend(), u_min); + auto find_left = [&] (int i) -> int { + // find the first ps > a[i - 1] + if (i == 1) return INT_MAX; + int l = 0, r = i - 1; + while (l < r) { + int mid = l + r + 1 >> 1; + if (ps[i - 1] - ps[mid] <= a[i - 1] || mid + 1 != i - 1 && mxt.query(mid, i - 2) == mnt.query(mid, i - 2)) { + r = mid - 1; + } else { + l = mid; + } + } + if (ps[i - 1] - ps[l] <= a[i - 1] || l + 1 != i - 1 && mxt.query(l, i - 2) == mnt.query(l, i - 2)) { + return INT_MAX; + } else { + return i - l - 1; + } + }; + auto find_right = [&] (int i) -> int { + if (i == n) return INT_MAX; + int l = i, r = n; + while (l < r) { + int mid = l + r >> 1; + if (ps[mid] - ps[i] <= a[i - 1] || i + 1 != mid && mxt.query(i, mid - 1) == mnt.query(i, mid - 1)) { + l = mid + 1; + } else { + r = mid; + } + } + if (ps[r] - ps[i] <= a[i - 1] || i + 1 != r && mxt.query(i, r - 1) == mnt.query(i, r - 1)) { + return INT_MAX; + } else { + return r - i; + } + }; + for (int i = 1; i <= n; ++i) { + if (i > 1 && a[i-2] > a[i-1]) res[i-1] = 1; + else if (i < n && a[i] > a[i-1]) res[i-1] = 1; + else res[i - 1] = min(find_left(i), find_right(i)); + if (res[i - 1] == INT_MAX) res[i - 1] = -1; + } + putvec(res); +} + +int main() { + untie, cout.tie(NULL); +#ifdef SINGLE_TEST_CASE + solve(); +#else + read(int, t); + for (int i = 0; i < t; ++i) { +#ifdef DUMP_TEST_CASE + if (i + 1 == (DUMP_TEST_CASE)) { + dump(); + } else { + solve(); + } +#else + solve(); +#endif + } +#endif +} diff --git a/src/bin/lc-2846.cc b/src/bin/lc-2846.cc new file mode 100644 index 0000000..39437d2 --- /dev/null +++ b/src/bin/lc-2846.cc @@ -0,0 +1,268 @@ +///////////////////////////////////////////////////////// +/** + * Useful Macros + * by subcrip + * (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) decltype(container)::value_type + +/* type aliases */ +using ll = int64_t; +using ull = uint64_t; +using pii = pair; +using pil = pair; +using pli = pair; +using pll = pair; + +/* constants */ +constexpr int INF = 0x3f3f3f3f; +constexpr ull MDL = 1e9 + 7; +constexpr ull PRIME = 998'244'353; +constexpr ull MDL1 = 825; +constexpr ull MDL2 = 87825; + +/* 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)) + +/* fast pairs */ +#define upair ull +#define umake(x, y) (ull(x) << 32 | ull(y)) +#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(p))) +#define i2(p) (int(u2(p))) +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;) + +/* build data structures */ +#define unordered_counter(from, to) __AS_PROCEDURE(unordered_map<__as_typeof(from), size_t> to; for (auto&& x : from) ++to[x];) +#define counter(from, to, cmp) __AS_PROCEDURE(map<__as_typeof(from), size_t, cmp> to; for (auto&& x : from) ++to[x];) +#define pa(a) __AS_PROCEDURE(__typeof(a) pa; pa.push_back({}); for (auto&&x : a) pa.push_back(pa.back() + x);) +#define sa(a) __AS_PROCEDURE(__typeof(a) sa(a.size() + 1); {int n = a.size(); for (int i = n - 1; i >= 0; --i) sa[i] = sa[i + 1] + a[i];};) +#define adj(ch, n) __AS_PROCEDURE(vector> ch((n) + 1);) +#define edge(ch, u, v) __AS_PROCEDURE(ch[u].push_back(v), ch[v].push_back(u);) +#define Edge(ch, u, v) __AS_PROCEDURE(ch[u].push_back(v);) + +/* io */ +#define untie __AS_PROCEDURE(ios_base::sync_with_stdio(0), cin.tie(NULL)) +template void __read(T& x) { cin >> x; } +template void __read(T& x, U&... args) { cin >> x; __read(args...); } +#define read(type, ...) __AS_PROCEDURE(type __VA_ARGS__; __read(__VA_ARGS__);) +#define readvec(type, a, n) __AS_PROCEDURE(vector a(n); for (int i = 0; i < (n); ++i) cin >> a[i];) +#define putvec(a) __AS_PROCEDURE(for (auto&& x : a) cout << x << ' '; cout << endl;) +#define debug(x) __AS_PROCEDURE(cerr << #x" = " << (x) << endl;) +#define debugvec(a) __AS_PROCEDURE(cerr << #a" = "; for (auto&& x : a) cerr << x << ' '; cerr << endl;) +template ostream& operator<<(ostream& out, vector vec) { + for (auto&& i : vec) out << i << ' '; + return out; +} + +/* pops */ +#define poptop(q, ...) __AS_PROCEDURE(auto [__VA_ARGS__] = q.top(); q.pop();) +#define popback(q, ...) __AS_PROCEDURE(auto [__VA_ARGS__] = q.back(); q.pop_back();) +#define popfront(q, ...) __AS_PROCEDURE(auto [__VA_ARGS__] = q.front();q.pop_front();) + +/* algorithms */ + +vector calc_next(string t) { // pi function of t + int n = (int)t.length(); + vector pi(n); + for (int i = 1; i < n; i++) { + int j = pi[i - 1]; + while (j > 0 && t[i] != t[j]) j = pi[j - 1]; + if (t[i] == t[j]) j++; + pi[i] = j; + } + return pi; +} +vector calc_z(string t) { // z function of t + int m = t.length(); + vector z; + z.push_back(m); + pair prev = {1, -1}; + for (int i = 1; i < m; ++i) { + if (z[i - prev.first] + i <= prev.second) { + z.push_back(z[i - prev.first]); + } else { + int j = max(i, prev.second + 1); + while (j < m && t[j] == t[j - i]) ++j; + z.push_back(j - i); + prev = {i, j - 1}; + } + } + return z; +} +vector kmp(string s, string t) { // find all t in s + string cur = t + '#' + s; + int sz1 = s.size(), sz2 = t.size(); + vector v; + vector lps = calc_next(cur); + for (int i = sz2 + 1; i <= sz1 + sz2; i++) { + if (lps[i] == sz2) v.push_back(i - 2 * sz2); + } + return v; +} +int period(string s) { // find the length of shortest recurring period + int n = s.length(); + auto z = calc_z(s); + for (int i = 1; i <= n / 2; ++i) { + if (n % i == 0 && z[i] == n - i) { + return i; + } + } + return n; +} +///////////////////////////////////////////////////////// +using pii = pair; +constexpr int MAXN = 1e4 + 10; +constexpr int MAXM = 2e4 + 10; + +int curr[27], lca[MAXM], cnt[MAXN][27], sz[MAXN]; +pii heavy[MAXN]; +vector ch[MAXN]; +vector tag[MAXN]; +unordered_map tags; + +int prep(int v, int pa) { + int curr = 1; + heavy[v].first = -1; + for (auto&& [u, w] : ch[v]) { + if (u != pa) { + int t = prep(u, v); + curr += t; + if (heavy[v].first == -1 || t > sz[heavy[v].first]) { + heavy[v] = {u, w}; + } + } + } + sz[v] = curr; + return curr; +} + +void dfs(int v, int pa, int save) { + cerr << "dfs(" << v << ", " << pa << ", " << save << ")\n"; + if (save) { + for (int i = 0; i < 27; ++i) { + cnt[v][i] = curr[i]; + } + for (auto&& [u, w] : ch[v]) { + if (u != pa && u != heavy[v].first) { + curr[w] += 1; + dfs(u, v, 1); + curr[w] -= 1; + tags.clear(); + } + } + } + if (heavy[v].first != -1) { + curr[heavy[v].second] += 1; + dfs(heavy[v].first, v, save); + curr[heavy[v].second] -= 1; + } + for (auto&& i : tag[v]) { + tags[i] += 1; + if (tags[i] > 1 && save) { + if (lca[i] == -1) lca[i] = v; + tags[i] = 0; + } + } + for (auto&& [u, w] : ch[v]) { + if (u != pa && u != heavy[v].first) { + dfs(u, v, 0); + for (auto&& [i, o] : tags) { + if (o > 1 && save) { + if (lca[i] == -1) lca[i] = v; + tags[i] = 0; + } + } + } + } +} + +class Solution { +public: + vector minOperationsQueries(int n, vector>& edges, vector>& queries) { + int q = queries.size(); + + memset(sz, 0, sizeof(sz)); + memset(curr, 0, sizeof(curr)); + memset(lca, 0xff, q * sizeof(int)); + memset(cnt, 0, sizeof(cnt)); + for (int i = 0; i < n; ++i) { + ch[i].clear(), tag[i].clear(); + } + tags.clear(); + + for (auto&& e : edges) { + ch[e[0]].emplace_back(e[1], e[2]); + ch[e[1]].emplace_back(e[0], e[2]); + } + for (int i = 0; i < q; ++i) { + tag[queries[i][0]].push_back(i); + tag[queries[i][1]].push_back(i); + } + prep(0, 0); + dfs(0, 0, 1); + vector res(q); + for (int i = 0; i < q; ++i) { + int u = queries[i][0], v = queries[i][1]; + if (u == v) { + res[i] = 0; + continue; + } + int l = lca[i]; + int mx = 0, tot = 0; + for (int i = 1; i < 27; ++i) { + int curr = cnt[u][i] + cnt[v][i] - 2 * cnt[l][i]; + tot += curr; + mx = max(mx, curr); + } + res[i] = tot - mx; + } + return res; + } +}; + +int main() { + vector> edges = {{9,7,1},{5,9,2},{0,9,4},{3,9,5},{1,9,5},{4,0,4},{2,0,2},{8,7,4},{6,3,2}}; + vector> queries = {{4,3},{8,1},{9,6},{7,0},{1,1},{5,0},{4,8},{3,6},{8,2},{9,7}}; + cout << Solution().minOperationsQueries(6, edges, queries); +} \ No newline at end of file diff --git a/src/bin/lg-1352.cc b/src/bin/lg-1352.cc new file mode 100644 index 0000000..410d6f4 --- /dev/null +++ b/src/bin/lg-1352.cc @@ -0,0 +1,178 @@ +///////////////////////////////////////////////////////// +/** + * Useful Macros + * by subcrip + * (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) decltype(container)::value_type + +/* type aliases */ +using ll = int64_t; +using ull = uint64_t; +using pii = pair; +using pil = pair; +using pli = pair; +using pll = pair; + +/* constants */ +constexpr int INF = 0x3f3f3f3f; +constexpr ull MDL = 1e9 + 7; +constexpr ull PRIME = 998'244'353; +constexpr ull MDL1 = 825; +constexpr ull MDL2 = 87825; + +/* 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)) + +/* fast pairs */ +#define upair ull +#define umake(x, y) (ull(x) << 32 | ull(y)) +#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(p))) +#define i2(p) (int(u2(p))) +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;) + +/* build data structures */ +#define unordered_counter(from, to) __AS_PROCEDURE(unordered_map<__as_typeof(from), size_t> to; for (auto&& x : from) ++to[x];) +#define counter(from, to, cmp) __AS_PROCEDURE(map<__as_typeof(from), size_t, cmp> to; for (auto&& x : from) ++to[x];) +#define pa(a) __AS_PROCEDURE(__typeof(a) pa; pa.push_back({}); for (auto&&x : a) pa.push_back(pa.back() + x);) +#define sa(a) __AS_PROCEDURE(__typeof(a) sa(a.size() + 1); {int n = a.size(); for (int i = n - 1; i >= 0; --i) sa[i] = sa[i + 1] + a[i];};) +#define adj(ch, n) __AS_PROCEDURE(vector> ch((n) + 1);) +#define edge(ch, u, v) __AS_PROCEDURE(ch[u].push_back(v), ch[v].push_back(u);) +#define Edge(ch, u, v) __AS_PROCEDURE(ch[u].push_back(v);) + +/* io */ +#define untie __AS_PROCEDURE(ios_base::sync_with_stdio(0), cin.tie(NULL)) +template void __read(T& x) { cin >> x; } +template void __read(T& x, U&... args) { cin >> x; __read(args...); } +#define read(type, ...) __AS_PROCEDURE(type __VA_ARGS__; __read(__VA_ARGS__);) +#define readvec(type, a, n) __AS_PROCEDURE(vector a(n); for (int i = 0; i < (n); ++i) cin >> a[i];) +#define putvec(a) __AS_PROCEDURE(for (auto&& x : a) cout << x << ' '; cout << endl;) +#define debug(x) __AS_PROCEDURE(cerr << #x" = " << (x) << endl;) +#define debugvec(a) __AS_PROCEDURE(cerr << #a" = "; for (auto&& x : a) cerr << x << ' '; cerr << endl;) +template ostream& operator<<(ostream& out, vector vec) { + for (auto&& i : vec) out << i << ' '; + return out; +} + +/* pops */ +#define poptop(q, ...) __AS_PROCEDURE(auto [__VA_ARGS__] = q.top(); q.pop();) +#define popback(q, ...) __AS_PROCEDURE(auto [__VA_ARGS__] = q.back(); q.pop_back();) +#define popfront(q, ...) __AS_PROCEDURE(auto [__VA_ARGS__] = q.front();q.pop_front();) + +/* algorithms */ + +vector calc_next(string t) { // pi function of t + int n = (int)t.length(); + vector pi(n); + for (int i = 1; i < n; i++) { + int j = pi[i - 1]; + while (j > 0 && t[i] != t[j]) j = pi[j - 1]; + if (t[i] == t[j]) j++; + pi[i] = j; + } + return pi; +} +vector calc_z(string t) { // z function of t + int m = t.length(); + vector z; + z.push_back(m); + pair prev = {1, -1}; + for (int i = 1; i < m; ++i) { + if (z[i - prev.first] + i <= prev.second) { + z.push_back(z[i - prev.first]); + } else { + int j = max(i, prev.second + 1); + while (j < m && t[j] == t[j - i]) ++j; + z.push_back(j - i); + prev = {i, j - 1}; + } + } + return z; +} +vector kmp(string s, string t) { // find all t in s + string cur = t + '#' + s; + int sz1 = s.size(), sz2 = t.size(); + vector v; + vector lps = calc_next(cur); + for (int i = sz2 + 1; i <= sz1 + sz2; i++) { + if (lps[i] == sz2) v.push_back(i - 2 * sz2); + } + return v; +} +int period(string s) { // find the length of shortest recurring period + int n = s.length(); + auto z = calc_z(s); + for (int i = 1; i <= n / 2; ++i) { + if (n % i == 0 && z[i] == n - i) { + return i; + } + } + return n; +} +///////////////////////////////////////////////////////// + +int main() { + read(int, n); + readvec(ll, r, n); + adj(ch, n); + for (int i = 0; i < n - 1; ++i) { + read(int, u, v); + edge(ch, u, v); + } + ll res = 0; + auto dfs = [&] (auto dfs, int v, int pa) -> upair { + // return (permissive, restricted) + ll inclusive = r[v - 1], exclusive = 0; + for (auto&& u : ch[v]) { + if (u != pa) { + auto curr = dfs(dfs, u, v); + ll cp = u1(curr), cr = u2(curr); + inclusive += cr; + exclusive += cp; + } + } + return umake(max(inclusive, exclusive), exclusive); + }; + cout << u1(dfs(dfs, 1, 0)) << endl; +} \ No newline at end of file diff --git a/src/bin/lg-2015.cc b/src/bin/lg-2015.cc new file mode 100644 index 0000000..5676b4d --- /dev/null +++ b/src/bin/lg-2015.cc @@ -0,0 +1,207 @@ +///////////////////////////////////////////////////////// +/** + * Useful Macros + * by subcrip + * (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) decltype(container)::value_type + +/* type aliases */ +using ll = int64_t; +using ull = uint64_t; +using pii = pair; +using pil = pair; +using pli = pair; +using pll = pair; + +/* constants */ +constexpr int INF = 0x3f3f3f3f; +constexpr ull MDL = 1e9 + 7; +constexpr ull PRIME = 998'244'353; +constexpr ull MDL1 = 825; +constexpr ull MDL2 = 87825; + +/* 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)) + +/* fast pairs */ +#define upair ull +#define umake(x, y) (ull(x) << 32 | ull(y)) +#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(p))) +#define i2(p) (int(u2(p))) +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;) + +/* build data structures */ +#define unordered_counter(from, to) __AS_PROCEDURE(unordered_map<__as_typeof(from), size_t> to; for (auto&& x : from) ++to[x];) +#define counter(from, to, cmp) __AS_PROCEDURE(map<__as_typeof(from), size_t, cmp> to; for (auto&& x : from) ++to[x];) +#define pa(a) __AS_PROCEDURE(__typeof(a) pa; pa.push_back({}); for (auto&&x : a) pa.push_back(pa.back() + x);) +#define sa(a) __AS_PROCEDURE(__typeof(a) sa(a.size() + 1); {int n = a.size(); for (int i = n - 1; i >= 0; --i) sa[i] = sa[i + 1] + a[i];};) +#define adj(ch, n) __AS_PROCEDURE(vector> ch((n) + 1);) +#define edge(ch, u, v) __AS_PROCEDURE(ch[u].push_back(v), ch[v].push_back(u);) +#define Edge(ch, u, v) __AS_PROCEDURE(ch[u].push_back(v);) + +/* io */ +#define untie __AS_PROCEDURE(ios_base::sync_with_stdio(0), cin.tie(NULL)) +template void __read(T& x) { cin >> x; } +template void __read(T& x, U&... args) { cin >> x; __read(args...); } +#define read(type, ...) __AS_PROCEDURE(type __VA_ARGS__; __read(__VA_ARGS__);) +#define readvec(type, a, n) __AS_PROCEDURE(vector a(n); for (int i = 0; i < (n); ++i) cin >> a[i];) +#define putvec(a) __AS_PROCEDURE(for (auto&& x : a) cout << x << ' '; cout << endl;) +#define debug(x) __AS_PROCEDURE(cerr << #x" = " << (x) << endl;) +#define debugvec(a) __AS_PROCEDURE(cerr << #a" = "; for (auto&& x : a) cerr << x << ' '; cerr << endl;) +template ostream& operator<<(ostream& out, vector vec) { + for (auto&& i : vec) out << i << ' '; + return out; +} + +/* pops */ +#define poptop(q, ...) __AS_PROCEDURE(auto [__VA_ARGS__] = q.top(); q.pop();) +#define popback(q, ...) __AS_PROCEDURE(auto [__VA_ARGS__] = q.back(); q.pop_back();) +#define popfront(q, ...) __AS_PROCEDURE(auto [__VA_ARGS__] = q.front();q.pop_front();) + +/* algorithms */ + +vector calc_next(string t) { // pi function of t + int n = (int)t.length(); + vector pi(n); + for (int i = 1; i < n; i++) { + int j = pi[i - 1]; + while (j > 0 && t[i] != t[j]) j = pi[j - 1]; + if (t[i] == t[j]) j++; + pi[i] = j; + } + return pi; +} +vector calc_z(string t) { // z function of t + int m = t.length(); + vector z; + z.push_back(m); + pair prev = {1, -1}; + for (int i = 1; i < m; ++i) { + if (z[i - prev.first] + i <= prev.second) { + z.push_back(z[i - prev.first]); + } else { + int j = max(i, prev.second + 1); + while (j < m && t[j] == t[j - i]) ++j; + z.push_back(j - i); + prev = {i, j - 1}; + } + } + return z; +} +vector kmp(string s, string t) { // find all t in s + string cur = t + '#' + s; + int sz1 = s.size(), sz2 = t.size(); + vector v; + vector lps = calc_next(cur); + for (int i = sz2 + 1; i <= sz1 + sz2; i++) { + if (lps[i] == sz2) v.push_back(i - 2 * sz2); + } + return v; +} +int period(string s) { // find the length of shortest recurring period + int n = s.length(); + auto z = calc_z(s); + for (int i = 1; i <= n / 2; ++i) { + if (n % i == 0 && z[i] == n - i) { + return i; + } + } + return n; +} +///////////////////////////////////////////////////////// + + +int main() { + read(int, n, q); + vector> e(n + 1); + int need_to_delete = n - 1 - q; + vector> res(n + 1, vector(need_to_delete + 1)); + for (int i = 0; i < n - 1; ++i) { + read(int, u, v, w); + e[u].emplace_back(v, w); + e[v].emplace_back(u, w); + } + vector cnt(n + 1); + auto count = [&] (auto count, int v, int pa) -> void { + for (auto&& [u, _] : e[v]) { + if (u == pa) continue; + count(count, u, v); + cnt[v] += cnt[u] + 1; + } + }; + count(count, 1, 0); + auto dfs = [&] (auto dfs, int v, int pa) -> void { + if (e[v].size() == 1) return; + vector chs, ws; + for (auto&& [u, w] : e[v]) { + if (u == pa) continue; + dfs(dfs, u, v); + chs.push_back(u), ws.push_back(w); + } + // don't delete + for (int i = 0; i <= need_to_delete; ++i) { + for (int j = 0; j <= i; ++j) { + if (j > cnt[chs[0]] || i - j > cnt[chs[1]]) continue; + res[v][i] = max(res[v][i], res[chs[0]][j] + res[chs[1]][i-j] + ws[0] + ws[1]); + } + } + // delete lson + for (int i = 1; i <= need_to_delete - cnt[chs[0]]; ++i) { + if (i - 1 > cnt[chs[1]]) break; + res[v][cnt[chs[0]] + i] = max(res[v][cnt[chs[0]] + i], res[chs[1]][i-1] + ws[1]); + } + // delete rson + for (int i = 1; i <= need_to_delete - cnt[chs[1]]; ++i) { + if (i - 1 > cnt[chs[0]]) break; + res[v][cnt[chs[1]] + i] = max(res[v][cnt[chs[1]] + i], res[chs[0]][i-1] + ws[0]); + } + // delete everything is not 0 + }; + dfs(dfs, 1, 0); + // debug(res[72]); + // debug(res[39]); + // debug(res[1]); + cout << res[1][need_to_delete] << endl; +} \ No newline at end of file diff --git a/src/bin/lg-u41492.cc b/src/bin/lg-u41492.cc new file mode 100644 index 0000000..e6a3792 --- /dev/null +++ b/src/bin/lg-u41492.cc @@ -0,0 +1,222 @@ +///////////////////////////////////////////////////////// +/** + * Useful Macros + * by subcrip + * (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) decltype(container)::value_type + +/* type aliases */ +using ll = int64_t; +using ull = uint64_t; +using pii = pair; +using pil = pair; +using pli = pair; +using pll = pair; + +/* constants */ +constexpr int INF = 0x3f3f3f3f; +constexpr ull MDL = 1e9 + 7; +constexpr ull PRIME = 998'244'353; +constexpr ull MDL1 = 825; +constexpr ull MDL2 = 87825; + +/* 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)) + +/* fast pairs */ +#define upair ull +#define umake(x, y) (ull(x) << 32 | ull(y)) +#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(p))) +#define i2(p) (int(u2(p))) +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;) + +/* build data structures */ +#define unordered_counter(from, to) __AS_PROCEDURE(unordered_map<__as_typeof(from), size_t> to; for (auto&& x : from) ++to[x];) +#define counter(from, to, cmp) __AS_PROCEDURE(map<__as_typeof(from), size_t, cmp> to; for (auto&& x : from) ++to[x];) +#define pa(a) __AS_PROCEDURE(__typeof(a) pa; pa.push_back({}); for (auto&&x : a) pa.push_back(pa.back() + x);) +#define sa(a) __AS_PROCEDURE(__typeof(a) sa(a.size() + 1); {int n = a.size(); for (int i = n - 1; i >= 0; --i) sa[i] = sa[i + 1] + a[i];};) +#define adj(ch, n) __AS_PROCEDURE(vector> ch((n) + 1);) +#define edge(ch, u, v) __AS_PROCEDURE(ch[u].push_back(v), ch[v].push_back(u);) +#define Edge(ch, u, v) __AS_PROCEDURE(ch[u].push_back(v);) + +/* io */ +#define untie __AS_PROCEDURE(ios_base::sync_with_stdio(0), cin.tie(NULL)) +template void __read(T& x) { cin >> x; } +template void __read(T& x, U&... args) { cin >> x; __read(args...); } +#define read(type, ...) __AS_PROCEDURE(type __VA_ARGS__; __read(__VA_ARGS__);) +#define readvec(type, a, n) __AS_PROCEDURE(vector a(n); for (int i = 0; i < (n); ++i) cin >> a[i];) +#define putvec(a) __AS_PROCEDURE(for (auto&& x : a) cout << x << ' '; cout << endl;) +#define debug(x) __AS_PROCEDURE(cerr << #x" = " << (x) << endl;) +#define debugvec(a) __AS_PROCEDURE(cerr << #a" = "; for (auto&& x : a) cerr << x << ' '; cerr << endl;) +template ostream& operator<<(ostream& out, vector vec) { + for (auto&& i : vec) out << i << ' '; + return out; +} + +/* pops */ +#define poptop(q, ...) __AS_PROCEDURE(auto [__VA_ARGS__] = q.top(); q.pop();) +#define popback(q, ...) __AS_PROCEDURE(auto [__VA_ARGS__] = q.back(); q.pop_back();) +#define popfront(q, ...) __AS_PROCEDURE(auto [__VA_ARGS__] = q.front();q.pop_front();) + +/* algorithms */ + +vector calc_next(string t) { // pi function of t + int n = (int)t.length(); + vector pi(n); + for (int i = 1; i < n; i++) { + int j = pi[i - 1]; + while (j > 0 && t[i] != t[j]) j = pi[j - 1]; + if (t[i] == t[j]) j++; + pi[i] = j; + } + return pi; +} +vector calc_z(string t) { // z function of t + int m = t.length(); + vector z; + z.push_back(m); + pair prev = {1, -1}; + for (int i = 1; i < m; ++i) { + if (z[i - prev.first] + i <= prev.second) { + z.push_back(z[i - prev.first]); + } else { + int j = max(i, prev.second + 1); + while (j < m && t[j] == t[j - i]) ++j; + z.push_back(j - i); + prev = {i, j - 1}; + } + } + return z; +} +vector kmp(string s, string t) { // find all t in s + string cur = t + '#' + s; + int sz1 = s.size(), sz2 = t.size(); + vector v; + vector lps = calc_next(cur); + for (int i = sz2 + 1; i <= sz1 + sz2; i++) { + if (lps[i] == sz2) v.push_back(i - 2 * sz2); + } + return v; +} +int period(string s) { // find the length of shortest recurring period + int n = s.length(); + auto z = calc_z(s); + for (int i = 1; i <= n / 2; ++i) { + if (n % i == 0 && z[i] == n - i) { + return i; + } + } + return n; +} +///////////////////////////////////////////////////////// + +int main() { + untie; + read(int, n); + adj(ch, n); + for (int i = 0; i < n - 1; ++i) { + read(int, u, v); + edge(ch, u, v); + } + readvec(int, c, n); // WARNING + + + vector size(n + 1); + vector heavy(n + 1); + auto dfs = [&] (auto dfs, int v, int pa) -> int { + size[v] = 1; + for (auto&& u : ch[v]) { + if (u != pa) { + int curr = dfs(dfs, u, v); + size[v] += curr; + if (curr > size[heavy[v]]) heavy[v] = u; + } + } + return size[v]; + }; + dfs(dfs, 1, 0); + + + vector cnt(n + 1); + vector res(n + 1); + auto remove = [&] (auto remove, int v, int pa) -> void { + cnt[c[v-1]] -= 1; + for (auto&& u : ch[v]) if (u != pa) remove(remove, u, v); + }; + auto dfs2 = [&] (auto dfs2, int v, int pa, int update_ans, int write_cnt) -> int { + if (!v) return 0; + if (update_ans) { + for (auto&& u : ch[v]) { + if (u != pa && u != heavy[v]) dfs2(dfs2, u, v, 1, 0); + } + } + int ans = dfs2(dfs2, heavy[v], v, update_ans, 1); + for (auto&& u : ch[v]) { + if (u != pa && u != heavy[v]) ans += dfs2(dfs2, u, v, 0, 1); + } + if (!cnt[c[v-1]]) { + cnt[c[v-1]] = 1; + ++ans; + } else { + cnt[c[v-1]] += 1; + } + // debugvec(cnt); + if (!write_cnt) { + remove(remove, v, pa); + } + if (update_ans) { + res[v] = ans; + } + return ans; + }; + dfs2(dfs2, 1, 0, 1, 1); + + + read(int, m); + while(m--) { + read(int, q); + cout << res[q] << endl; + } +} \ No newline at end of file diff --git a/src/bin/lq-170a.cc b/src/bin/lq-170a.cc new file mode 100644 index 0000000..ee1a527 --- /dev/null +++ b/src/bin/lq-170a.cc @@ -0,0 +1,242 @@ +#pragma GCC optimize("Ofast") +///////////////////////////////////////////////////////// +/** + * Useful Macros + * by subcrip + * (requires C++17) + */ + +#include +#include +using namespace std; +using namespace __gnu_cxx; +using namespace __gnu_pbds; + +/* 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) decltype(container)::value_type + +/* type aliases */ +using ll = int64_t; +using ull = uint64_t; +using pii = pair; +using pil = pair; +using pli = pair; +using pll = pair; + +/* constants */ +constexpr int INF = 0x3f3f3f3f; +constexpr ull MDL = 1e9 + 7; +constexpr ull PRIME = 998'244'353; +constexpr ll MDL1 = 8784491; +constexpr ll MDL2 = PRIME; + +/* random */ + +mt19937 rd(chrono::duration_cast(chrono::system_clock::now().time_since_epoch()).count()); + +/* bit-wise operations */ +#define lowbit(x) ((x) & -(x)) +#define popcount(x) (__builtin_popcountll(ll(x))) +#define parity(x) (__builtin_parityll(ll(x))) +#define msp(x) (63LL - __builtin_clzll(ll(x))) +#define lsp(x) (__builtin_ctzll(ll(x))) + +/* arithmetic operations */ +#define mod(x, y) ((((x) % (y)) + (y)) % (y)) + +/* fast pairs */ +#define upair ull +#define umake(x, y) (ull(x) << 32 | (ull(y) & ((1ULL << 32) - 1))) +#define u1(p) ((p) >> 32) +#define u2(p) ((p) & ((1ULL << 32) - 1)) +#define ult std::less +#define ugt std::greater + +#define ipair ull +#define imake(x, y) (umake(x, y)) +#define i1(p) (int(u1(ll(p)))) +#define i2(p) (ll(u2(p) << 32) >> 32) +struct ilt { + bool operator()(const ipair& a, const ipair& b) const { + if (i1(a) == i1(b)) return i2(a) < i2(b); + else return i1(a) < i1(b); + } +}; +struct igt { + bool operator()(const ipair& a, const ipair& b) const { + if (i1(a) == i1(b)) return i2(a) > i2(b); + else return i1(a) > i1(b); + } +}; + +/* conditions */ +#define loop while (1) +#define if_or(var, val) if (!(var == val)) var = val; else +#define continue_or(var, val) __AS_PROCEDURE(if (var == val) continue; var = val;) +#define break_or(var, val) __AS_PROCEDURE(if (var == val) break; var = val;) + +/* hash */ +struct safe_hash { + // https://codeforces.com/blog/entry/62393 + static uint64_t splitmix64(uint64_t x) { + // http://xorshift.di.unimi.it/splitmix64.c + x += 0x9e3779b97f4a7c15; + x = (x ^ (x >> 30)) * 0xbf58476d1ce4e5b9; + x = (x ^ (x >> 27)) * 0x94d049bb133111eb; + return x ^ (x >> 31); + } + + size_t operator()(uint64_t x) const { + static const uint64_t FIXED_RANDOM = chrono::steady_clock::now().time_since_epoch().count(); + return splitmix64(x + FIXED_RANDOM); + } +}; + +struct pair_hash { + template + size_t operator()(const pair& a) const { + auto hash1 = safe_hash()(a.first); + auto hash2 = safe_hash()(a.second); + if (hash1 != hash2) { + return hash1 ^ hash2; + } + return hash1; + } +}; + +/* build data structures */ +#define unordered_counter(from, to) __AS_PROCEDURE(unordered_map<__as_typeof(from), size_t, safe_hash> to; for (auto&& x : from) ++to[x];) +#define counter(from, to, cmp) __AS_PROCEDURE(map<__as_typeof(from), size_t, cmp> to; for (auto&& x : from) ++to[x];) +#define pa(a) __AS_PROCEDURE(__typeof(a) pa; pa.push_back({}); for (auto&&x : a) pa.push_back(pa.back() + x);) +#define sa(a) __AS_PROCEDURE(__typeof(a) sa(a.size() + 1); {int n = a.size(); for (int i = n - 1; i >= 0; --i) sa[i] = sa[i + 1] + a[i];};) +#define adj(ch, n) __AS_PROCEDURE(vector> ch((n) + 1);) +#define edge(ch, u, v) __AS_PROCEDURE(ch[u].push_back(v), ch[v].push_back(u);) +#define Edge(ch, u, v) __AS_PROCEDURE(ch[u].push_back(v);) + +/* io */ +#define untie __AS_PROCEDURE(ios_base::sync_with_stdio(0), cin.tie(NULL)) +template void __read(T& x) { cin >> x; } +template void __read(T& x, U&... args) { cin >> x; __read(args...); } +#define read(type, ...) __AS_PROCEDURE(type __VA_ARGS__; __read(__VA_ARGS__);) +#define readvec(type, a, n) __AS_PROCEDURE(vector a(n); for (int i = 0; i < (n); ++i) cin >> a[i];) +#define putvec(a) __AS_PROCEDURE(for (auto&& x : a) cout << x << ' '; cout << endl;) +#define debug(x) __AS_PROCEDURE(cerr << #x" = " << (x) << endl;) +#define debugvec(a) __AS_PROCEDURE(cerr << #a" = "; for (auto&& x : a) cerr << x << ' '; cerr << endl;) +template ostream& operator<<(ostream& out, vector vec) { + for (auto&& i : vec) out << i << ' '; + return out; +} + +/* pops */ +#define poptop(q, ...) __AS_PROCEDURE(auto [__VA_ARGS__] = q.top(); q.pop();) +#define popback(q, ...) __AS_PROCEDURE(auto [__VA_ARGS__] = q.back(); q.pop_back();) +#define popfront(q, ...) __AS_PROCEDURE(auto [__VA_ARGS__] = q.front();q.pop_front();) + +/* math */ +constexpr inline int lg2(ll x) { return x == 0 ? -1 : sizeof(ll) * 8 - 1 - __builtin_clzll(x); } + +void __exgcd(ll a, ll b, ll& x, ll& y) { + if (b == 0) { + x = 1, y = 0; + return; + } + __exgcd(b, a % b, y, x); + y -= a / b * x; +} + +ll inverse(ll a, ll b) { + ll x, y; + __exgcd(a, b, x, y); + return mod(x, b); +} + +/* string algorithms */ +vector calc_next(string t) { // pi function of t + int n = (int)t.length(); + vector pi(n); + for (int i = 1; i < n; i++) { + int j = pi[i - 1]; + while (j > 0 && t[i] != t[j]) j = pi[j - 1]; + if (t[i] == t[j]) j++; + pi[i] = j; + } + return pi; +} +vector calc_z(string t) { // z function of t + int m = t.length(); + vector z; + z.push_back(m); + pair prev = {1, -1}; + for (int i = 1; i < m; ++i) { + if (z[i - prev.first] + i <= prev.second) { + z.push_back(z[i - prev.first]); + } else { + int j = max(i, prev.second + 1); + while (j < m && t[j] == t[j - i]) ++j; + z.push_back(j - i); + prev = {i, j - 1}; + } + } + return z; +} +vector kmp(string s, string t) { // find all t in s + string cur = t + '#' + s; + int sz1 = s.size(), sz2 = t.size(); + vector v; + vector lps = calc_next(cur); + for (int i = sz2 + 1; i <= sz1 + sz2; i++) { + if (lps[i] == sz2) v.push_back(i - 2 * sz2); + } + return v; +} +int period(string s) { // find the length of shortest recurring period + int n = s.length(); + auto z = calc_z(s); + for (int i = 1; i <= n / 2; ++i) { + if (n % i == 0 && z[i] == n - i) { + return i; + } + } + return n; +} +///////////////////////////////////////////////////////// + + +// #define SINGLE_TEST_CASE +// #define DUMP_TEST_CASE 512 + +void dump() {} + +void solve() { + read(ll, x); + if (x % 4 == 0 && (x / 4) % 2 == 0 && (x / 4 - 1) > 0) { + cout << "Yes\n" << (x / 4 - 1) << ' ' << (x / 4 + 1) << endl; + } else { + cout << "No\n"; + } +} + +int main() { + untie, cout.tie(NULL); +#ifdef SINGLE_TEST_CASE + solve(); +#else + read(int, t); + for (int i = 0; i < t; ++i) { +#ifdef DUMP_TEST_CASE + if (i + 1 == (DUMP_TEST_CASE)) { + dump(); + } else { + solve(); + } +#else + solve(); +#endif + } +#endif +} diff --git a/src/bin/lq-170b.cc b/src/bin/lq-170b.cc new file mode 100644 index 0000000..8937cd2 --- /dev/null +++ b/src/bin/lq-170b.cc @@ -0,0 +1,253 @@ +#pragma GCC optimize("Ofast") +///////////////////////////////////////////////////////// +/** + * Useful Macros + * by subcrip + * (requires C++17) + */ + +#include +#include +using namespace std; +using namespace __gnu_cxx; +using namespace __gnu_pbds; + +/* 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) decltype(container)::value_type + +/* type aliases */ +using ll = int64_t; +using ull = uint64_t; +using pii = pair; +using pil = pair; +using pli = pair; +using pll = pair; + +/* constants */ +constexpr int INF = 0x3f3f3f3f; +constexpr ull MDL = 1e9 + 7; +constexpr ull PRIME = 998'244'353; +constexpr ll MDL1 = 8784491; +constexpr ll MDL2 = PRIME; + +/* random */ + +mt19937 rd(chrono::duration_cast(chrono::system_clock::now().time_since_epoch()).count()); + +/* bit-wise operations */ +#define lowbit(x) ((x) & -(x)) +#define popcount(x) (__builtin_popcountll(ll(x))) +#define parity(x) (__builtin_parityll(ll(x))) +#define msp(x) (63LL - __builtin_clzll(ll(x))) +#define lsp(x) (__builtin_ctzll(ll(x))) + +/* arithmetic operations */ +#define mod(x, y) ((((x) % (y)) + (y)) % (y)) + +/* fast pairs */ +#define upair ull +#define umake(x, y) (ull(x) << 32 | (ull(y) & ((1ULL << 32) - 1))) +#define u1(p) ((p) >> 32) +#define u2(p) ((p) & ((1ULL << 32) - 1)) +#define ult std::less +#define ugt std::greater + +#define ipair ull +#define imake(x, y) (umake(x, y)) +#define i1(p) (int(u1(ll(p)))) +#define i2(p) (ll(u2(p) << 32) >> 32) +struct ilt { + bool operator()(const ipair& a, const ipair& b) const { + if (i1(a) == i1(b)) return i2(a) < i2(b); + else return i1(a) < i1(b); + } +}; +struct igt { + bool operator()(const ipair& a, const ipair& b) const { + if (i1(a) == i1(b)) return i2(a) > i2(b); + else return i1(a) > i1(b); + } +}; + +/* conditions */ +#define loop while (1) +#define if_or(var, val) if (!(var == val)) var = val; else +#define continue_or(var, val) __AS_PROCEDURE(if (var == val) continue; var = val;) +#define break_or(var, val) __AS_PROCEDURE(if (var == val) break; var = val;) + +/* hash */ +struct safe_hash { + // https://codeforces.com/blog/entry/62393 + static uint64_t splitmix64(uint64_t x) { + // http://xorshift.di.unimi.it/splitmix64.c + x += 0x9e3779b97f4a7c15; + x = (x ^ (x >> 30)) * 0xbf58476d1ce4e5b9; + x = (x ^ (x >> 27)) * 0x94d049bb133111eb; + return x ^ (x >> 31); + } + + size_t operator()(uint64_t x) const { + static const uint64_t FIXED_RANDOM = chrono::steady_clock::now().time_since_epoch().count(); + return splitmix64(x + FIXED_RANDOM); + } +}; + +struct pair_hash { + template + size_t operator()(const pair& a) const { + auto hash1 = safe_hash()(a.first); + auto hash2 = safe_hash()(a.second); + if (hash1 != hash2) { + return hash1 ^ hash2; + } + return hash1; + } +}; + +/* build data structures */ +#define unordered_counter(from, to) __AS_PROCEDURE(unordered_map<__as_typeof(from), size_t, safe_hash> to; for (auto&& x : from) ++to[x];) +#define counter(from, to, cmp) __AS_PROCEDURE(map<__as_typeof(from), size_t, cmp> to; for (auto&& x : from) ++to[x];) +#define pa(a) __AS_PROCEDURE(__typeof(a) pa; pa.push_back({}); for (auto&&x : a) pa.push_back(pa.back() + x);) +#define sa(a) __AS_PROCEDURE(__typeof(a) sa(a.size() + 1); {int n = a.size(); for (int i = n - 1; i >= 0; --i) sa[i] = sa[i + 1] + a[i];};) +#define adj(ch, n) __AS_PROCEDURE(vector> ch((n) + 1);) +#define edge(ch, u, v) __AS_PROCEDURE(ch[u].push_back(v), ch[v].push_back(u);) +#define Edge(ch, u, v) __AS_PROCEDURE(ch[u].push_back(v);) + +/* io */ +#define untie __AS_PROCEDURE(ios_base::sync_with_stdio(0), cin.tie(NULL)) +template void __read(T& x) { cin >> x; } +template void __read(T& x, U&... args) { cin >> x; __read(args...); } +#define read(type, ...) __AS_PROCEDURE(type __VA_ARGS__; __read(__VA_ARGS__);) +#define readvec(type, a, n) __AS_PROCEDURE(vector a(n); for (int i = 0; i < (n); ++i) cin >> a[i];) +#define putvec(a) __AS_PROCEDURE(for (auto&& x : a) cout << x << ' '; cout << endl;) +#define debug(x) __AS_PROCEDURE(cerr << #x" = " << (x) << endl;) +#define debugvec(a) __AS_PROCEDURE(cerr << #a" = "; for (auto&& x : a) cerr << x << ' '; cerr << endl;) +template ostream& operator<<(ostream& out, vector vec) { + for (auto&& i : vec) out << i << ' '; + return out; +} + +/* pops */ +#define poptop(q, ...) __AS_PROCEDURE(auto [__VA_ARGS__] = q.top(); q.pop();) +#define popback(q, ...) __AS_PROCEDURE(auto [__VA_ARGS__] = q.back(); q.pop_back();) +#define popfront(q, ...) __AS_PROCEDURE(auto [__VA_ARGS__] = q.front();q.pop_front();) + +/* math */ +constexpr inline int lg2(ll x) { return x == 0 ? -1 : sizeof(ll) * 8 - 1 - __builtin_clzll(x); } + +void __exgcd(ll a, ll b, ll& x, ll& y) { + if (b == 0) { + x = 1, y = 0; + return; + } + __exgcd(b, a % b, y, x); + y -= a / b * x; +} + +ll inverse(ll a, ll b) { + ll x, y; + __exgcd(a, b, x, y); + return mod(x, b); +} + +/* string algorithms */ +vector calc_next(string t) { // pi function of t + int n = (int)t.length(); + vector pi(n); + for (int i = 1; i < n; i++) { + int j = pi[i - 1]; + while (j > 0 && t[i] != t[j]) j = pi[j - 1]; + if (t[i] == t[j]) j++; + pi[i] = j; + } + return pi; +} +vector calc_z(string t) { // z function of t + int m = t.length(); + vector z; + z.push_back(m); + pair prev = {1, -1}; + for (int i = 1; i < m; ++i) { + if (z[i - prev.first] + i <= prev.second) { + z.push_back(z[i - prev.first]); + } else { + int j = max(i, prev.second + 1); + while (j < m && t[j] == t[j - i]) ++j; + z.push_back(j - i); + prev = {i, j - 1}; + } + } + return z; +} +vector kmp(string s, string t) { // find all t in s + string cur = t + '#' + s; + int sz1 = s.size(), sz2 = t.size(); + vector v; + vector lps = calc_next(cur); + for (int i = sz2 + 1; i <= sz1 + sz2; i++) { + if (lps[i] == sz2) v.push_back(i - 2 * sz2); + } + return v; +} +int period(string s) { // find the length of shortest recurring period + int n = s.length(); + auto z = calc_z(s); + for (int i = 1; i <= n / 2; ++i) { + if (n % i == 0 && z[i] == n - i) { + return i; + } + } + return n; +} +///////////////////////////////////////////////////////// + + +#define SINGLE_TEST_CASE +// #define DUMP_TEST_CASE 512 + +void dump() {} + +void solve() { + read(int, n); + readvec(ll, a, n); + readvec(ll, b, n); + sort(a.begin(), a.end(), greater()); + sort(b.begin(), b.end(), greater()); + int d = 0; + int res = 0; + for (int i = 0; i < n; ++i) { + while (d < n && a[i] * 2 <= b[d]) ++d; + if (d >= n) { + break; + } else { + res += 1; + d += 1; + } + } + cout << res << endl; +} + +int main() { + untie, cout.tie(NULL); +#ifdef SINGLE_TEST_CASE + solve(); +#else + read(int, t); + for (int i = 0; i < t; ++i) { +#ifdef DUMP_TEST_CASE + if (i + 1 == (DUMP_TEST_CASE)) { + dump(); + } else { + solve(); + } +#else + solve(); +#endif + } +#endif +} diff --git a/src/bin/lq-170c.cc b/src/bin/lq-170c.cc new file mode 100644 index 0000000..ec35e3a --- /dev/null +++ b/src/bin/lq-170c.cc @@ -0,0 +1,251 @@ +#pragma GCC optimize("Ofast") +///////////////////////////////////////////////////////// +/** + * Useful Macros + * by subcrip + * (requires C++17) + */ + +#include +#include +using namespace std; +using namespace __gnu_cxx; +using namespace __gnu_pbds; + +/* 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) decltype(container)::value_type + +/* type aliases */ +using ll = int64_t; +using ull = uint64_t; +using pii = pair; +using pil = pair; +using pli = pair; +using pll = pair; + +/* constants */ +constexpr int INF = 0x3f3f3f3f; +constexpr ull MDL = 1e9 + 7; +constexpr ull PRIME = 998'244'353; +constexpr ll MDL1 = 8784491; +constexpr ll MDL2 = PRIME; + +/* random */ + +mt19937 rd(chrono::duration_cast(chrono::system_clock::now().time_since_epoch()).count()); + +/* bit-wise operations */ +#define lowbit(x) ((x) & -(x)) +#define popcount(x) (__builtin_popcountll(ll(x))) +#define parity(x) (__builtin_parityll(ll(x))) +#define msp(x) (63LL - __builtin_clzll(ll(x))) +#define lsp(x) (__builtin_ctzll(ll(x))) + +/* arithmetic operations */ +#define mod(x, y) ((((x) % (y)) + (y)) % (y)) + +/* fast pairs */ +#define upair ull +#define umake(x, y) (ull(x) << 32 | (ull(y) & ((1ULL << 32) - 1))) +#define u1(p) ((p) >> 32) +#define u2(p) ((p) & ((1ULL << 32) - 1)) +#define ult std::less +#define ugt std::greater + +#define ipair ull +#define imake(x, y) (umake(x, y)) +#define i1(p) (int(u1(ll(p)))) +#define i2(p) (ll(u2(p) << 32) >> 32) +struct ilt { + bool operator()(const ipair& a, const ipair& b) const { + if (i1(a) == i1(b)) return i2(a) < i2(b); + else return i1(a) < i1(b); + } +}; +struct igt { + bool operator()(const ipair& a, const ipair& b) const { + if (i1(a) == i1(b)) return i2(a) > i2(b); + else return i1(a) > i1(b); + } +}; + +/* conditions */ +#define loop while (1) +#define if_or(var, val) if (!(var == val)) var = val; else +#define continue_or(var, val) __AS_PROCEDURE(if (var == val) continue; var = val;) +#define break_or(var, val) __AS_PROCEDURE(if (var == val) break; var = val;) + +/* hash */ +struct safe_hash { + // https://codeforces.com/blog/entry/62393 + static uint64_t splitmix64(uint64_t x) { + // http://xorshift.di.unimi.it/splitmix64.c + x += 0x9e3779b97f4a7c15; + x = (x ^ (x >> 30)) * 0xbf58476d1ce4e5b9; + x = (x ^ (x >> 27)) * 0x94d049bb133111eb; + return x ^ (x >> 31); + } + + size_t operator()(uint64_t x) const { + static const uint64_t FIXED_RANDOM = chrono::steady_clock::now().time_since_epoch().count(); + return splitmix64(x + FIXED_RANDOM); + } +}; + +struct pair_hash { + template + size_t operator()(const pair& a) const { + auto hash1 = safe_hash()(a.first); + auto hash2 = safe_hash()(a.second); + if (hash1 != hash2) { + return hash1 ^ hash2; + } + return hash1; + } +}; + +/* build data structures */ +#define unordered_counter(from, to) __AS_PROCEDURE(unordered_map<__as_typeof(from), size_t, safe_hash> to; for (auto&& x : from) ++to[x];) +#define counter(from, to, cmp) __AS_PROCEDURE(map<__as_typeof(from), size_t, cmp> to; for (auto&& x : from) ++to[x];) +#define pa(a) __AS_PROCEDURE(__typeof(a) pa; pa.push_back({}); for (auto&&x : a) pa.push_back(pa.back() + x);) +#define sa(a) __AS_PROCEDURE(__typeof(a) sa(a.size() + 1); {int n = a.size(); for (int i = n - 1; i >= 0; --i) sa[i] = sa[i + 1] + a[i];};) +#define adj(ch, n) __AS_PROCEDURE(vector> ch((n) + 1);) +#define edge(ch, u, v) __AS_PROCEDURE(ch[u].push_back(v), ch[v].push_back(u);) +#define Edge(ch, u, v) __AS_PROCEDURE(ch[u].push_back(v);) + +/* io */ +#define untie __AS_PROCEDURE(ios_base::sync_with_stdio(0), cin.tie(NULL)) +template void __read(T& x) { cin >> x; } +template void __read(T& x, U&... args) { cin >> x; __read(args...); } +#define read(type, ...) __AS_PROCEDURE(type __VA_ARGS__; __read(__VA_ARGS__);) +#define readvec(type, a, n) __AS_PROCEDURE(vector a(n); for (int i = 0; i < (n); ++i) cin >> a[i];) +#define putvec(a) __AS_PROCEDURE(for (auto&& x : a) cout << x << ' '; cout << endl;) +#define debug(x) __AS_PROCEDURE(cerr << #x" = " << (x) << endl;) +#define debugvec(a) __AS_PROCEDURE(cerr << #a" = "; for (auto&& x : a) cerr << x << ' '; cerr << endl;) +template ostream& operator<<(ostream& out, vector vec) { + for (auto&& i : vec) out << i << ' '; + return out; +} + +/* pops */ +#define poptop(q, ...) __AS_PROCEDURE(auto [__VA_ARGS__] = q.top(); q.pop();) +#define popback(q, ...) __AS_PROCEDURE(auto [__VA_ARGS__] = q.back(); q.pop_back();) +#define popfront(q, ...) __AS_PROCEDURE(auto [__VA_ARGS__] = q.front();q.pop_front();) + +/* math */ +constexpr inline int lg2(ll x) { return x == 0 ? -1 : sizeof(ll) * 8 - 1 - __builtin_clzll(x); } + +void __exgcd(ll a, ll b, ll& x, ll& y) { + if (b == 0) { + x = 1, y = 0; + return; + } + __exgcd(b, a % b, y, x); + y -= a / b * x; +} + +ll inverse(ll a, ll b) { + ll x, y; + __exgcd(a, b, x, y); + return mod(x, b); +} + +/* string algorithms */ +vector calc_next(string t) { // pi function of t + int n = (int)t.length(); + vector pi(n); + for (int i = 1; i < n; i++) { + int j = pi[i - 1]; + while (j > 0 && t[i] != t[j]) j = pi[j - 1]; + if (t[i] == t[j]) j++; + pi[i] = j; + } + return pi; +} +vector calc_z(string t) { // z function of t + int m = t.length(); + vector z; + z.push_back(m); + pair prev = {1, -1}; + for (int i = 1; i < m; ++i) { + if (z[i - prev.first] + i <= prev.second) { + z.push_back(z[i - prev.first]); + } else { + int j = max(i, prev.second + 1); + while (j < m && t[j] == t[j - i]) ++j; + z.push_back(j - i); + prev = {i, j - 1}; + } + } + return z; +} +vector kmp(string s, string t) { // find all t in s + string cur = t + '#' + s; + int sz1 = s.size(), sz2 = t.size(); + vector v; + vector lps = calc_next(cur); + for (int i = sz2 + 1; i <= sz1 + sz2; i++) { + if (lps[i] == sz2) v.push_back(i - 2 * sz2); + } + return v; +} +int period(string s) { // find the length of shortest recurring period + int n = s.length(); + auto z = calc_z(s); + for (int i = 1; i <= n / 2; ++i) { + if (n % i == 0 && z[i] == n - i) { + return i; + } + } + return n; +} +///////////////////////////////////////////////////////// + + +// #define SINGLE_TEST_CASE +// #define DUMP_TEST_CASE 512 + +void dump() {} + +void solve() { + read(int, k, m); + int l = 1, r = m * m + 1; + auto calc = [&] (int x) -> double { + return sqrt(x) + int(log(x) / log(k)) - m; + }; + debug(log(2) / log(1)); + while (l < r) { + int mid = l + r >> 1; + if (calc(mid) > 0) { + r = mid; + } else { + l = mid + 1; + } + } + cout << l << endl; +} + +int main() { + untie, cout.tie(NULL); +#ifdef SINGLE_TEST_CASE + solve(); +#else + read(int, t); + for (int i = 0; i < t; ++i) { +#ifdef DUMP_TEST_CASE + if (i + 1 == (DUMP_TEST_CASE)) { + dump(); + } else { + solve(); + } +#else + solve(); +#endif + } +#endif +} diff --git a/src/bin/lq-170d.cc b/src/bin/lq-170d.cc new file mode 100644 index 0000000..4c37ea0 --- /dev/null +++ b/src/bin/lq-170d.cc @@ -0,0 +1,287 @@ +#pragma GCC optimize("Ofast") +///////////////////////////////////////////////////////// +/** + * Useful Macros + * by subcrip + * (requires C++17) + */ + +#include +#include +using namespace std; +using namespace __gnu_cxx; +using namespace __gnu_pbds; + +/* 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) decltype(container)::value_type + +/* type aliases */ +using ll = int64_t; +using ull = uint64_t; +using pii = pair; +using pil = pair; +using pli = pair; +using pll = pair; + +/* constants */ +constexpr int INF = 0x3f3f3f3f; +constexpr ull MDL = 1e9 + 7; +constexpr ull PRIME = 998'244'353; +constexpr ll MDL1 = 8784491; +constexpr ll MDL2 = PRIME; + +/* random */ + +mt19937 rd(chrono::duration_cast(chrono::system_clock::now().time_since_epoch()).count()); + +/* bit-wise operations */ +#define lowbit(x) ((x) & -(x)) +#define popcount(x) (__builtin_popcountll(ll(x))) +#define parity(x) (__builtin_parityll(ll(x))) +#define msp(x) (63LL - __builtin_clzll(ll(x))) +#define lsp(x) (__builtin_ctzll(ll(x))) + +/* arithmetic operations */ +#define mod(x, y) ((((x) % (y)) + (y)) % (y)) + +/* fast pairs */ +#define upair ull +#define umake(x, y) (ull(x) << 32 | (ull(y) & ((1ULL << 32) - 1))) +#define u1(p) ((p) >> 32) +#define u2(p) ((p) & ((1ULL << 32) - 1)) +#define ult std::less +#define ugt std::greater + +#define ipair ull +#define imake(x, y) (umake(x, y)) +#define i1(p) (int(u1(ll(p)))) +#define i2(p) (ll(u2(p) << 32) >> 32) +struct ilt { + bool operator()(const ipair& a, const ipair& b) const { + if (i1(a) == i1(b)) return i2(a) < i2(b); + else return i1(a) < i1(b); + } +}; +struct igt { + bool operator()(const ipair& a, const ipair& b) const { + if (i1(a) == i1(b)) return i2(a) > i2(b); + else return i1(a) > i1(b); + } +}; + +/* conditions */ +#define loop while (1) +#define if_or(var, val) if (!(var == val)) var = val; else +#define continue_or(var, val) __AS_PROCEDURE(if (var == val) continue; var = val;) +#define break_or(var, val) __AS_PROCEDURE(if (var == val) break; var = val;) + +/* hash */ +struct safe_hash { + // https://codeforces.com/blog/entry/62393 + static uint64_t splitmix64(uint64_t x) { + // http://xorshift.di.unimi.it/splitmix64.c + x += 0x9e3779b97f4a7c15; + x = (x ^ (x >> 30)) * 0xbf58476d1ce4e5b9; + x = (x ^ (x >> 27)) * 0x94d049bb133111eb; + return x ^ (x >> 31); + } + + size_t operator()(uint64_t x) const { + static const uint64_t FIXED_RANDOM = chrono::steady_clock::now().time_since_epoch().count(); + return splitmix64(x + FIXED_RANDOM); + } +}; + +struct pair_hash { + template + size_t operator()(const pair& a) const { + auto hash1 = safe_hash()(a.first); + auto hash2 = safe_hash()(a.second); + if (hash1 != hash2) { + return hash1 ^ hash2; + } + return hash1; + } +}; + +/* build data structures */ +#define unordered_counter(from, to) __AS_PROCEDURE(unordered_map<__as_typeof(from), size_t, safe_hash> to; for (auto&& x : from) ++to[x];) +#define counter(from, to, cmp) __AS_PROCEDURE(map<__as_typeof(from), size_t, cmp> to; for (auto&& x : from) ++to[x];) +#define pa(a) __AS_PROCEDURE(__typeof(a) pa; pa.push_back({}); for (auto&&x : a) pa.push_back(pa.back() + x);) +#define sa(a) __AS_PROCEDURE(__typeof(a) sa(a.size() + 1); {int n = a.size(); for (int i = n - 1; i >= 0; --i) sa[i] = sa[i + 1] + a[i];};) +#define adj(ch, n) __AS_PROCEDURE(vector> ch((n) + 1);) +#define edge(ch, u, v) __AS_PROCEDURE(ch[u].push_back(v), ch[v].push_back(u);) +#define Edge(ch, u, v) __AS_PROCEDURE(ch[u].push_back(v);) + +/* io */ +#define untie __AS_PROCEDURE(ios_base::sync_with_stdio(0), cin.tie(NULL)) +template void __read(T& x) { cin >> x; } +template void __read(T& x, U&... args) { cin >> x; __read(args...); } +#define read(type, ...) __AS_PROCEDURE(type __VA_ARGS__; __read(__VA_ARGS__);) +#define readvec(type, a, n) __AS_PROCEDURE(vector a(n); for (int i = 0; i < (n); ++i) cin >> a[i];) +#define putvec(a) __AS_PROCEDURE(for (auto&& x : a) cout << x << ' '; cout << endl;) +#define debug(x) __AS_PROCEDURE(cerr << #x" = " << (x) << endl;) +#define debugvec(a) __AS_PROCEDURE(cerr << #a" = "; for (auto&& x : a) cerr << x << ' '; cerr << endl;) +template ostream& operator<<(ostream& out, vector vec) { + for (auto&& i : vec) out << i << ' '; + return out; +} + +/* pops */ +#define poptop(q, ...) __AS_PROCEDURE(auto [__VA_ARGS__] = q.top(); q.pop();) +#define popback(q, ...) __AS_PROCEDURE(auto [__VA_ARGS__] = q.back(); q.pop_back();) +#define popfront(q, ...) __AS_PROCEDURE(auto [__VA_ARGS__] = q.front();q.pop_front();) + +/* math */ +constexpr inline int lg2(ll x) { return x == 0 ? -1 : sizeof(ll) * 8 - 1 - __builtin_clzll(x); } + +void __exgcd(ll a, ll b, ll& x, ll& y) { + if (b == 0) { + x = 1, y = 0; + return; + } + __exgcd(b, a % b, y, x); + y -= a / b * x; +} + +ll inverse(ll a, ll b) { + ll x, y; + __exgcd(a, b, x, y); + return mod(x, b); +} + +/* string algorithms */ +vector calc_next(string t) { // pi function of t + int n = (int)t.length(); + vector pi(n); + for (int i = 1; i < n; i++) { + int j = pi[i - 1]; + while (j > 0 && t[i] != t[j]) j = pi[j - 1]; + if (t[i] == t[j]) j++; + pi[i] = j; + } + return pi; +} +vector calc_z(string t) { // z function of t + int m = t.length(); + vector z; + z.push_back(m); + pair prev = {1, -1}; + for (int i = 1; i < m; ++i) { + if (z[i - prev.first] + i <= prev.second) { + z.push_back(z[i - prev.first]); + } else { + int j = max(i, prev.second + 1); + while (j < m && t[j] == t[j - i]) ++j; + z.push_back(j - i); + prev = {i, j - 1}; + } + } + return z; +} +vector kmp(string s, string t) { // find all t in s + string cur = t + '#' + s; + int sz1 = s.size(), sz2 = t.size(); + vector v; + vector lps = calc_next(cur); + for (int i = sz2 + 1; i <= sz1 + sz2; i++) { + if (lps[i] == sz2) v.push_back(i - 2 * sz2); + } + return v; +} +int period(string s) { // find the length of shortest recurring period + int n = s.length(); + auto z = calc_z(s); + for (int i = 1; i <= n / 2; ++i) { + if (n % i == 0 && z[i] == n - i) { + return i; + } + } + return n; +} +///////////////////////////////////////////////////////// + + +#define SINGLE_TEST_CASE +// #define DUMP_TEST_CASE 512 + +void dump() {} + +void solve() { + array, 13> full{}; + full[0][0] = 1; + for (int i = 1; i <= 12; ++i) { + for (int j = 0; j <= 24; ++j) { + full[i][j] = full[i-1][j] * 5 + (j > 0 ? full[i-1][j-1] * 4 : 0) + (j > 1 ? full[i-1][j-2] : 0); + } + } + auto cnt = [] (ll x) -> int { + int res = 0; + while (x) { + res += 1; + x /= 10; + } + return res; + }; + auto get = [] (ll x, int d) -> int { + for (int i = 0; i < d; ++i) { + x /= 10; + } + return x % 10; + }; + read(ll, l, r); + read(int, k); + array tab {1, 0, 0, 0, 1, 0, 1, 0, 2, 1}; + auto work = [&] (ll x) -> ll { + if (x == 0) return k == 1; + int tot = cnt(x), acc = 0; + ll res = k == 1; + for (int i = 0; i < tot - 1; ++i) { + for (int j = 1; j < 10; ++j) { + if (k - acc - tab[j] >= 0) + res += full[i][k - acc - tab[j]]; + } + } + for (int i = tot - 1; ~i; --i) { + int digit = get(x, i); + for (int j = 0; j < digit; ++j) { + if (i == tot - 1 && j == 0) continue; + int curr = tab[j];; + if (k - acc - curr >= 0) { + res += full[i][k - acc - curr]; + } + } + acc += tab[digit]; + } + if (acc == k) res += 1; + return res; + }; + ll rl = work(l - 1); + ll rr = work(r); + cout << rr - rl << endl; +} + +int main() { + untie, cout.tie(NULL); +#ifdef SINGLE_TEST_CASE + solve(); +#else + read(int, t); + for (int i = 0; i < t; ++i) { +#ifdef DUMP_TEST_CASE + if (i + 1 == (DUMP_TEST_CASE)) { + dump(); + } else { + solve(); + } +#else + solve(); +#endif + } +#endif +} diff --git a/src/bin/lq-170e.cc b/src/bin/lq-170e.cc new file mode 100644 index 0000000..eafb9c5 --- /dev/null +++ b/src/bin/lq-170e.cc @@ -0,0 +1,299 @@ +#pragma GCC optimize("Ofast") +///////////////////////////////////////////////////////// +/** + * Useful Macros + * by subcrip + * (requires C++17) + */ + +#include +#include +using namespace std; +using namespace __gnu_cxx; +using namespace __gnu_pbds; + +/* 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) decltype(container)::value_type + +/* type aliases */ +using ll = int64_t; +using ull = uint64_t; +using pii = pair; +using pil = pair; +using pli = pair; +using pll = pair; + +/* constants */ +constexpr int INF = 0x3f3f3f3f; +constexpr ull MDL = 1e9 + 7; +constexpr ull PRIME = 998'244'353; +constexpr ll MDL1 = 8784491; +constexpr ll MDL2 = PRIME; + +/* random */ + +mt19937 rd(chrono::duration_cast(chrono::system_clock::now().time_since_epoch()).count()); + +/* bit-wise operations */ +#define lowbit(x) ((x) & -(x)) +#define popcount(x) (__builtin_popcountll(ll(x))) +#define parity(x) (__builtin_parityll(ll(x))) +#define msp(x) (63LL - __builtin_clzll(ll(x))) +#define lsp(x) (__builtin_ctzll(ll(x))) + +/* arithmetic operations */ +#define mod(x, y) ((((x) % (y)) + (y)) % (y)) + +/* fast pairs */ +#define upair ull +#define umake(x, y) (ull(x) << 32 | (ull(y) & ((1ULL << 32) - 1))) +#define u1(p) ((p) >> 32) +#define u2(p) ((p) & ((1ULL << 32) - 1)) +#define ult std::less +#define ugt std::greater + +#define ipair ull +#define imake(x, y) (umake(x, y)) +#define i1(p) (int(u1(ll(p)))) +#define i2(p) (ll(u2(p) << 32) >> 32) +struct ilt { + bool operator()(const ipair& a, const ipair& b) const { + if (i1(a) == i1(b)) return i2(a) < i2(b); + else return i1(a) < i1(b); + } +}; +struct igt { + bool operator()(const ipair& a, const ipair& b) const { + if (i1(a) == i1(b)) return i2(a) > i2(b); + else return i1(a) > i1(b); + } +}; + +/* conditions */ +#define loop while (1) +#define if_or(var, val) if (!(var == val)) var = val; else +#define continue_or(var, val) __AS_PROCEDURE(if (var == val) continue; var = val;) +#define break_or(var, val) __AS_PROCEDURE(if (var == val) break; var = val;) + +/* hash */ +struct safe_hash { + // https://codeforces.com/blog/entry/62393 + static uint64_t splitmix64(uint64_t x) { + // http://xorshift.di.unimi.it/splitmix64.c + x += 0x9e3779b97f4a7c15; + x = (x ^ (x >> 30)) * 0xbf58476d1ce4e5b9; + x = (x ^ (x >> 27)) * 0x94d049bb133111eb; + return x ^ (x >> 31); + } + + size_t operator()(uint64_t x) const { + static const uint64_t FIXED_RANDOM = chrono::steady_clock::now().time_since_epoch().count(); + return splitmix64(x + FIXED_RANDOM); + } +}; + +struct pair_hash { + template + size_t operator()(const pair& a) const { + auto hash1 = safe_hash()(a.first); + auto hash2 = safe_hash()(a.second); + if (hash1 != hash2) { + return hash1 ^ hash2; + } + return hash1; + } +}; + +/* build data structures */ +#define unordered_counter(from, to) __AS_PROCEDURE(unordered_map<__as_typeof(from), size_t, safe_hash> to; for (auto&& x : from) ++to[x];) +#define counter(from, to, cmp) __AS_PROCEDURE(map<__as_typeof(from), size_t, cmp> to; for (auto&& x : from) ++to[x];) +#define pa(a) __AS_PROCEDURE(__typeof(a) pa; pa.push_back({}); for (auto&&x : a) pa.push_back(pa.back() + x);) +#define sa(a) __AS_PROCEDURE(__typeof(a) sa(a.size() + 1); {int n = a.size(); for (int i = n - 1; i >= 0; --i) sa[i] = sa[i + 1] + a[i];};) +#define adj(ch, n) __AS_PROCEDURE(vector> ch((n) + 1);) +#define edge(ch, u, v) __AS_PROCEDURE(ch[u].push_back(v), ch[v].push_back(u);) +#define Edge(ch, u, v) __AS_PROCEDURE(ch[u].push_back(v);) + +/* io */ +#define untie __AS_PROCEDURE(ios_base::sync_with_stdio(0), cin.tie(NULL)) +template void __read(T& x) { cin >> x; } +template void __read(T& x, U&... args) { cin >> x; __read(args...); } +#define read(type, ...) __AS_PROCEDURE(type __VA_ARGS__; __read(__VA_ARGS__);) +#define readvec(type, a, n) __AS_PROCEDURE(vector a(n); for (int i = 0; i < (n); ++i) cin >> a[i];) +#define putvec(a) __AS_PROCEDURE(for (auto&& x : a) cout << x << ' '; cout << endl;) +#define debug(x) __AS_PROCEDURE(cerr << #x" = " << (x) << endl;) +#define debugvec(a) __AS_PROCEDURE(cerr << #a" = "; for (auto&& x : a) cerr << x << ' '; cerr << endl;) +template ostream& operator<<(ostream& out, vector vec) { + for (auto&& i : vec) out << i << ' '; + return out; +} + +/* pops */ +#define poptop(q, ...) __AS_PROCEDURE(auto [__VA_ARGS__] = q.top(); q.pop();) +#define popback(q, ...) __AS_PROCEDURE(auto [__VA_ARGS__] = q.back(); q.pop_back();) +#define popfront(q, ...) __AS_PROCEDURE(auto [__VA_ARGS__] = q.front();q.pop_front();) + +/* math */ +constexpr inline int lg2(ll x) { return x == 0 ? -1 : sizeof(ll) * 8 - 1 - __builtin_clzll(x); } + +void __exgcd(ll a, ll b, ll& x, ll& y) { + if (b == 0) { + x = 1, y = 0; + return; + } + __exgcd(b, a % b, y, x); + y -= a / b * x; +} + +ll inverse(ll a, ll b) { + ll x, y; + __exgcd(a, b, x, y); + return mod(x, b); +} + +/* string algorithms */ +vector calc_next(string t) { // pi function of t + int n = (int)t.length(); + vector pi(n); + for (int i = 1; i < n; i++) { + int j = pi[i - 1]; + while (j > 0 && t[i] != t[j]) j = pi[j - 1]; + if (t[i] == t[j]) j++; + pi[i] = j; + } + return pi; +} +vector calc_z(string t) { // z function of t + int m = t.length(); + vector z; + z.push_back(m); + pair prev = {1, -1}; + for (int i = 1; i < m; ++i) { + if (z[i - prev.first] + i <= prev.second) { + z.push_back(z[i - prev.first]); + } else { + int j = max(i, prev.second + 1); + while (j < m && t[j] == t[j - i]) ++j; + z.push_back(j - i); + prev = {i, j - 1}; + } + } + return z; +} +vector kmp(string s, string t) { // find all t in s + string cur = t + '#' + s; + int sz1 = s.size(), sz2 = t.size(); + vector v; + vector lps = calc_next(cur); + for (int i = sz2 + 1; i <= sz1 + sz2; i++) { + if (lps[i] == sz2) v.push_back(i - 2 * sz2); + } + return v; +} +int period(string s) { // find the length of shortest recurring period + int n = s.length(); + auto z = calc_z(s); + for (int i = 1; i <= n / 2; ++i) { + if (n % i == 0 && z[i] == n - i) { + return i; + } + } + return n; +} +///////////////////////////////////////////////////////// + + +#define SINGLE_TEST_CASE +// #define DUMP_TEST_CASE 512 + +void dump() {} + +auto umx = [] (const pii& a, const pii& b) -> pii { + array t {a.first, a.second, b.first, b.second}; + sort(t.begin(), t.end(), greater<>()); + return {t[0], t[1]}; +}; + +template class segtree { +private: + using size_type = uint64_t; + T _max; + vector d; + + void _update(size_type s, size_type t, size_type p, size_type l, size_type r, T c) { + if (l <= s && t <= r) { + d[p] = {c, 0}; + return; + } + size_type m = s + (t - s >> 1); + if (l <= m) _update(s, m, p * 2, l, r, c); + if (r > m) _update(m + 1, t, p * 2 + 1, l, r, c); + d[p] = umx(d[p * 2], d[p * 2 + 1]); + } + + pii _query(size_type s, size_type t, size_type p, size_type l, size_type r) { + if (l <= s && t <= r) return d[p]; + size_type m = s + (t - s >> 1); + pii res = {}; + if (l <= m) res = umx(res, _query(s, m, p * 2, l, r)); + if (r > m) res = umx(res, _query(m + 1, t, p * 2 + 1, l, r)); + return res; + } +public: + segtree(T _max) : d(4 * _max), _max(_max) {} + + void update(size_type l, size_type r, T c) { + _update({}, _max, 1, l, r, c); + } + + pii query(size_type l, size_type r) { + return _query({}, _max, 1, l, r); + } +}; + +void solve() { + read(int, n, q); + vector raw(n); + segtree tr(n); + for (int i = 0; i < n; ++i) { + read(int, x); + tr.update(i + 1, i + 1, x); + } + ll res = 0; + while (q--) { + read(int, l, r); + auto [x, y] = tr.query(l, r); + res += x + y; + } + cout << res << endl; + read(int, m); + if (res % (m + 1) == 0) { + cout << "blue\n"; + } else { + cout << "red\n"; + } +} + +int main() { + untie, cout.tie(NULL); +#ifdef SINGLE_TEST_CASE + solve(); +#else + read(int, t); + for (int i = 0; i < t; ++i) { +#ifdef DUMP_TEST_CASE + if (i + 1 == (DUMP_TEST_CASE)) { + dump(); + } else { + solve(); + } +#else + solve(); +#endif + } +#endif +} diff --git a/src/bin/lq-170f.cc b/src/bin/lq-170f.cc new file mode 100644 index 0000000..17fb324 --- /dev/null +++ b/src/bin/lq-170f.cc @@ -0,0 +1,274 @@ +#pragma GCC optimize("Ofast") +///////////////////////////////////////////////////////// +/** + * Useful Macros + * by subcrip + * (requires C++17) + */ + +#include +#include +using namespace std; +using namespace __gnu_cxx; +using namespace __gnu_pbds; + +/* 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) decltype(container)::value_type + +/* type aliases */ +using ll = int64_t; +using ull = uint64_t; +using pii = pair; +using pil = pair; +using pli = pair; +using pll = pair; + +/* constants */ +constexpr int INF = 0x3f3f3f3f; +constexpr ull MDL = 1e9 + 7; +constexpr ull PRIME = 998'244'353; +constexpr ll MDL1 = 8784491; +constexpr ll MDL2 = PRIME; + +/* random */ + +mt19937 rd(chrono::duration_cast(chrono::system_clock::now().time_since_epoch()).count()); + +/* bit-wise operations */ +#define lowbit(x) ((x) & -(x)) +#define popcount(x) (__builtin_popcountll(ll(x))) +#define parity(x) (__builtin_parityll(ll(x))) +#define msp(x) (63LL - __builtin_clzll(ll(x))) +#define lsp(x) (__builtin_ctzll(ll(x))) + +/* arithmetic operations */ +#define mod(x, y) ((((x) % (y)) + (y)) % (y)) + +/* fast pairs */ +#define upair ull +#define umake(x, y) (ull(x) << 32 | (ull(y) & ((1ULL << 32) - 1))) +#define u1(p) ((p) >> 32) +#define u2(p) ((p) & ((1ULL << 32) - 1)) +#define ult std::less +#define ugt std::greater + +#define ipair ull +#define imake(x, y) (umake(x, y)) +#define i1(p) (int(u1(ll(p)))) +#define i2(p) (ll(u2(p) << 32) >> 32) +struct ilt { + bool operator()(const ipair& a, const ipair& b) const { + if (i1(a) == i1(b)) return i2(a) < i2(b); + else return i1(a) < i1(b); + } +}; +struct igt { + bool operator()(const ipair& a, const ipair& b) const { + if (i1(a) == i1(b)) return i2(a) > i2(b); + else return i1(a) > i1(b); + } +}; + +/* conditions */ +#define loop while (1) +#define if_or(var, val) if (!(var == val)) var = val; else +#define continue_or(var, val) __AS_PROCEDURE(if (var == val) continue; var = val;) +#define break_or(var, val) __AS_PROCEDURE(if (var == val) break; var = val;) + +/* hash */ +struct safe_hash { + // https://codeforces.com/blog/entry/62393 + static uint64_t splitmix64(uint64_t x) { + // http://xorshift.di.unimi.it/splitmix64.c + x += 0x9e3779b97f4a7c15; + x = (x ^ (x >> 30)) * 0xbf58476d1ce4e5b9; + x = (x ^ (x >> 27)) * 0x94d049bb133111eb; + return x ^ (x >> 31); + } + + size_t operator()(uint64_t x) const { + static const uint64_t FIXED_RANDOM = chrono::steady_clock::now().time_since_epoch().count(); + return splitmix64(x + FIXED_RANDOM); + } +}; + +struct pair_hash { + template + size_t operator()(const pair& a) const { + auto hash1 = safe_hash()(a.first); + auto hash2 = safe_hash()(a.second); + if (hash1 != hash2) { + return hash1 ^ hash2; + } + return hash1; + } +}; + +/* build data structures */ +#define unordered_counter(from, to) __AS_PROCEDURE(unordered_map<__as_typeof(from), size_t, safe_hash> to; for (auto&& x : from) ++to[x];) +#define counter(from, to, cmp) __AS_PROCEDURE(map<__as_typeof(from), size_t, cmp> to; for (auto&& x : from) ++to[x];) +#define pa(a) __AS_PROCEDURE(__typeof(a) pa; pa.push_back({}); for (auto&&x : a) pa.push_back(pa.back() + x);) +#define sa(a) __AS_PROCEDURE(__typeof(a) sa(a.size() + 1); {int n = a.size(); for (int i = n - 1; i >= 0; --i) sa[i] = sa[i + 1] + a[i];};) +#define adj(ch, n) __AS_PROCEDURE(vector> ch((n) + 1);) +#define edge(ch, u, v) __AS_PROCEDURE(ch[u].push_back(v), ch[v].push_back(u);) +#define Edge(ch, u, v) __AS_PROCEDURE(ch[u].push_back(v);) + +/* io */ +#define untie __AS_PROCEDURE(ios_base::sync_with_stdio(0), cin.tie(NULL)) +template void __read(T& x) { cin >> x; } +template void __read(T& x, U&... args) { cin >> x; __read(args...); } +#define read(type, ...) __AS_PROCEDURE(type __VA_ARGS__; __read(__VA_ARGS__);) +#define readvec(type, a, n) __AS_PROCEDURE(vector a(n); for (int i = 0; i < (n); ++i) cin >> a[i];) +#define putvec(a) __AS_PROCEDURE(for (auto&& x : a) cout << x << ' '; cout << endl;) +#define debug(x) __AS_PROCEDURE(cerr << #x" = " << (x) << endl;) +#define debugvec(a) __AS_PROCEDURE(cerr << #a" = "; for (auto&& x : a) cerr << x << ' '; cerr << endl;) +template ostream& operator<<(ostream& out, vector vec) { + for (auto&& i : vec) out << i << ' '; + return out; +} + +/* pops */ +#define poptop(q, ...) __AS_PROCEDURE(auto [__VA_ARGS__] = q.top(); q.pop();) +#define popback(q, ...) __AS_PROCEDURE(auto [__VA_ARGS__] = q.back(); q.pop_back();) +#define popfront(q, ...) __AS_PROCEDURE(auto [__VA_ARGS__] = q.front();q.pop_front();) + +/* math */ +constexpr inline int lg2(ll x) { return x == 0 ? -1 : sizeof(ll) * 8 - 1 - __builtin_clzll(x); } + +void __exgcd(ll a, ll b, ll& x, ll& y) { + if (b == 0) { + x = 1, y = 0; + return; + } + __exgcd(b, a % b, y, x); + y -= a / b * x; +} + +ll inverse(ll a, ll b) { + ll x, y; + __exgcd(a, b, x, y); + return mod(x, b); +} + +/* string algorithms */ +vector calc_next(string t) { // pi function of t + int n = (int)t.length(); + vector pi(n); + for (int i = 1; i < n; i++) { + int j = pi[i - 1]; + while (j > 0 && t[i] != t[j]) j = pi[j - 1]; + if (t[i] == t[j]) j++; + pi[i] = j; + } + return pi; +} +vector calc_z(string t) { // z function of t + int m = t.length(); + vector z; + z.push_back(m); + pair prev = {1, -1}; + for (int i = 1; i < m; ++i) { + if (z[i - prev.first] + i <= prev.second) { + z.push_back(z[i - prev.first]); + } else { + int j = max(i, prev.second + 1); + while (j < m && t[j] == t[j - i]) ++j; + z.push_back(j - i); + prev = {i, j - 1}; + } + } + return z; +} +vector kmp(string s, string t) { // find all t in s + string cur = t + '#' + s; + int sz1 = s.size(), sz2 = t.size(); + vector v; + vector lps = calc_next(cur); + for (int i = sz2 + 1; i <= sz1 + sz2; i++) { + if (lps[i] == sz2) v.push_back(i - 2 * sz2); + } + return v; +} +int period(string s) { // find the length of shortest recurring period + int n = s.length(); + auto z = calc_z(s); + for (int i = 1; i <= n / 2; ++i) { + if (n % i == 0 && z[i] == n - i) { + return i; + } + } + return n; +} +///////////////////////////////////////////////////////// + + +#define SINGLE_TEST_CASE +// #define DUMP_TEST_CASE 512 + +void dump() {} + +void solve() { + read(int, n); + readvec(int, a, n); + array bucket {}; + for (int mask = 1; mask < (1 << 15); ++mask) { + int f = 1, cnt = 0; + int pattern = a[0] & mask; + for (int i = 0; i < n; ++i) { + if ((a[i] & mask) == pattern) { + cnt += 1; + } else if (((~a[i]) & mask) != pattern) { + f = 0; + break; + } + } + if (f) { + if (pattern == 0) { + if (n - cnt) { + bucket[popcount(mask)] += 1 << cnt + 1; + } + } else if (pattern == mask) { + if (cnt) { + bucket[popcount(mask)] += 1 << n - cnt + 1; + } + } else { + bucket[popcount(mask)] += 2; + } + } + } + int res = 0; + for (int i = 1; i < 16; ++i) { + if (i % 2) { + res += bucket[i]; + } else { + res -= bucket[i]; + } + } + debugvec(bucket);; + cout << (1 << n) - res << endl; +} + +int main() { + untie, cout.tie(NULL); +#ifdef SINGLE_TEST_CASE + solve(); +#else + read(int, t); + for (int i = 0; i < t; ++i) { +#ifdef DUMP_TEST_CASE + if (i + 1 == (DUMP_TEST_CASE)) { + dump(); + } else { + solve(); + } +#else + solve(); +#endif + } +#endif +} diff --git a/src/bin/nc-75766b.cc b/src/bin/nc-75766b.cc new file mode 100644 index 0000000..45a157a --- /dev/null +++ b/src/bin/nc-75766b.cc @@ -0,0 +1,247 @@ +#pragma GCC optimize("Ofast") +///////////////////////////////////////////////////////// +/** + * Useful Macros + * by subcrip + * (requires C++17) + */ + +#include +#include +using namespace std; +using namespace __gnu_cxx; +using namespace __gnu_pbds; + +/* 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) decltype(container)::value_type + +/* type aliases */ +using ll = int64_t; +using ull = uint64_t; +using pii = pair; +using pil = pair; +using pli = pair; +using pll = pair; + +/* constants */ +constexpr int INF = 0x3f3f3f3f; +constexpr ull MDL = 1e9 + 7; +constexpr ull PRIME = 998'244'353; +constexpr ll MDL1 = 8784491; +constexpr ll MDL2 = PRIME; + +/* random */ + +mt19937 rd(chrono::duration_cast(chrono::system_clock::now().time_since_epoch()).count()); + +/* bit-wise operations */ +#define lowbit(x) ((x) & -(x)) +#define popcount(x) (__builtin_popcountll(ll(x))) +#define parity(x) (__builtin_parityll(ll(x))) +#define msp(x) (63LL - __builtin_clzll(ll(x))) +#define lsp(x) (__builtin_ctzll(ll(x))) + +/* arithmetic operations */ +#define mod(x, y) ((((x) % (y)) + (y)) % (y)) + +/* fast pairs */ +#define upair ull +#define umake(x, y) (ull(x) << 32 | (ull(y) & ((1ULL << 32) - 1))) +#define u1(p) ((p) >> 32) +#define u2(p) ((p) & ((1ULL << 32) - 1)) +#define ult std::less +#define ugt std::greater + +#define ipair ull +#define imake(x, y) (umake(x, y)) +#define i1(p) (int(u1(ll(p)))) +#define i2(p) (ll(u2(p) << 32) >> 32) +struct ilt { + bool operator()(const ipair& a, const ipair& b) const { + if (i1(a) == i1(b)) return i2(a) < i2(b); + else return i1(a) < i1(b); + } +}; +struct igt { + bool operator()(const ipair& a, const ipair& b) const { + if (i1(a) == i1(b)) return i2(a) > i2(b); + else return i1(a) > i1(b); + } +}; + +/* conditions */ +#define loop while (1) +#define if_or(var, val) if (!(var == val)) var = val; else +#define continue_or(var, val) __AS_PROCEDURE(if (var == val) continue; var = val;) +#define break_or(var, val) __AS_PROCEDURE(if (var == val) break; var = val;) + +/* hash */ +struct safe_hash { + // https://codeforces.com/blog/entry/62393 + static uint64_t splitmix64(uint64_t x) { + // http://xorshift.di.unimi.it/splitmix64.c + x += 0x9e3779b97f4a7c15; + x = (x ^ (x >> 30)) * 0xbf58476d1ce4e5b9; + x = (x ^ (x >> 27)) * 0x94d049bb133111eb; + return x ^ (x >> 31); + } + + size_t operator()(uint64_t x) const { + static const uint64_t FIXED_RANDOM = chrono::steady_clock::now().time_since_epoch().count(); + return splitmix64(x + FIXED_RANDOM); + } +}; + +struct pair_hash { + template + size_t operator()(const pair& a) const { + auto hash1 = safe_hash()(a.first); + auto hash2 = safe_hash()(a.second); + if (hash1 != hash2) { + return hash1 ^ hash2; + } + return hash1; + } +}; + +/* build data structures */ +#define unordered_counter(from, to) __AS_PROCEDURE(unordered_map<__as_typeof(from), size_t, safe_hash> to; for (auto&& x : from) ++to[x];) +#define counter(from, to, cmp) __AS_PROCEDURE(map<__as_typeof(from), size_t, cmp> to; for (auto&& x : from) ++to[x];) +#define pa(a) __AS_PROCEDURE(__typeof(a) pa; pa.push_back({}); for (auto&&x : a) pa.push_back(pa.back() + x);) +#define sa(a) __AS_PROCEDURE(__typeof(a) sa(a.size() + 1); {int n = a.size(); for (int i = n - 1; i >= 0; --i) sa[i] = sa[i + 1] + a[i];};) +#define adj(ch, n) __AS_PROCEDURE(vector> ch((n) + 1);) +#define edge(ch, u, v) __AS_PROCEDURE(ch[u].push_back(v), ch[v].push_back(u);) +#define Edge(ch, u, v) __AS_PROCEDURE(ch[u].push_back(v);) + +/* io */ +#define untie __AS_PROCEDURE(ios_base::sync_with_stdio(0), cin.tie(NULL)) +template void __read(T& x) { cin >> x; } +template void __read(T& x, U&... args) { cin >> x; __read(args...); } +#define read(type, ...) __AS_PROCEDURE(type __VA_ARGS__; __read(__VA_ARGS__);) +#define readvec(type, a, n) __AS_PROCEDURE(vector a(n); for (int i = 0; i < (n); ++i) cin >> a[i];) +#define putvec(a) __AS_PROCEDURE(for (auto&& x : a) cout << x << ' '; cout << endl;) +#define debug(x) __AS_PROCEDURE(cerr << #x" = " << (x) << endl;) +#define debugvec(a) __AS_PROCEDURE(cerr << #a" = "; for (auto&& x : a) cerr << x << ' '; cerr << endl;) +template ostream& operator<<(ostream& out, vector vec) { + for (auto&& i : vec) out << i << ' '; + return out; +} + +/* pops */ +#define poptop(q, ...) __AS_PROCEDURE(auto [__VA_ARGS__] = q.top(); q.pop();) +#define popback(q, ...) __AS_PROCEDURE(auto [__VA_ARGS__] = q.back(); q.pop_back();) +#define popfront(q, ...) __AS_PROCEDURE(auto [__VA_ARGS__] = q.front();q.pop_front();) + +/* math */ +constexpr inline int lg2(ll x) { return x == 0 ? -1 : sizeof(ll) * 8 - 1 - __builtin_clzll(x); } + +void __exgcd(ll a, ll b, ll& x, ll& y) { + if (b == 0) { + x = 1, y = 0; + return; + } + __exgcd(b, a % b, y, x); + y -= a / b * x; +} + +ll inverse(ll a, ll b) { + ll x, y; + __exgcd(a, b, x, y); + return mod(x, b); +} + +/* string algorithms */ +vector calc_next(string t) { // pi function of t + int n = (int)t.length(); + vector pi(n); + for (int i = 1; i < n; i++) { + int j = pi[i - 1]; + while (j > 0 && t[i] != t[j]) j = pi[j - 1]; + if (t[i] == t[j]) j++; + pi[i] = j; + } + return pi; +} +vector calc_z(string t) { // z function of t + int m = t.length(); + vector z; + z.push_back(m); + pair prev = {1, -1}; + for (int i = 1; i < m; ++i) { + if (z[i - prev.first] + i <= prev.second) { + z.push_back(z[i - prev.first]); + } else { + int j = max(i, prev.second + 1); + while (j < m && t[j] == t[j - i]) ++j; + z.push_back(j - i); + prev = {i, j - 1}; + } + } + return z; +} +vector kmp(string s, string t) { // find all t in s + string cur = t + '#' + s; + int sz1 = s.size(), sz2 = t.size(); + vector v; + vector lps = calc_next(cur); + for (int i = sz2 + 1; i <= sz1 + sz2; i++) { + if (lps[i] == sz2) v.push_back(i - 2 * sz2); + } + return v; +} +int period(string s) { // find the length of shortest recurring period + int n = s.length(); + auto z = calc_z(s); + for (int i = 1; i <= n / 2; ++i) { + if (n % i == 0 && z[i] == n - i) { + return i; + } + } + return n; +} +///////////////////////////////////////////////////////// + + +#define SINGLE_TEST_CASE +// #define DUMP_TEST_CASE 512 + +void dump() {} + +void solve() { + read(int, n); + readvec(int, a, n); + vector oc(n + 1); + for (int i = 0; i < n; ++i) { + oc[a[i]] = 1; + } + if (count(oc.begin(), oc.end(), 1) == n) { + cout << "1\n1 1000000000\n"; + } else { + cout << 0 << endl; + } +} + +int main() { + untie, cout.tie(NULL); +#ifdef SINGLE_TEST_CASE + solve(); +#else + read(int, t); + for (int i = 0; i < t; ++i) { +#ifdef DUMP_TEST_CASE + if (i + 1 == (DUMP_TEST_CASE)) { + dump(); + } else { + solve(); + } +#else + solve(); +#endif + } +#endif +} diff --git a/src/bin/nc-75766c.cc b/src/bin/nc-75766c.cc new file mode 100644 index 0000000..e83fe67 --- /dev/null +++ b/src/bin/nc-75766c.cc @@ -0,0 +1,253 @@ +#pragma GCC optimize("Ofast") +///////////////////////////////////////////////////////// +/** + * Useful Macros + * by subcrip + * (requires C++17) + */ + +#include +#include +using namespace std; +using namespace __gnu_cxx; +using namespace __gnu_pbds; + +/* 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) decltype(container)::value_type + +/* type aliases */ +using ll = int64_t; +using ull = uint64_t; +using pii = pair; +using pil = pair; +using pli = pair; +using pll = pair; + +/* constants */ +constexpr int INF = 0x3f3f3f3f; +constexpr ull MDL = 1e9 + 7; +constexpr ull PRIME = 998'244'353; +constexpr ll MDL1 = 8784491; +constexpr ll MDL2 = PRIME; + +/* random */ + +mt19937 rd(chrono::duration_cast(chrono::system_clock::now().time_since_epoch()).count()); + +/* bit-wise operations */ +#define lowbit(x) ((x) & -(x)) +#define popcount(x) (__builtin_popcountll(ll(x))) +#define parity(x) (__builtin_parityll(ll(x))) +#define msp(x) (63LL - __builtin_clzll(ll(x))) +#define lsp(x) (__builtin_ctzll(ll(x))) + +/* arithmetic operations */ +#define mod(x, y) ((((x) % (y)) + (y)) % (y)) + +/* fast pairs */ +#define upair ull +#define umake(x, y) (ull(x) << 32 | (ull(y) & ((1ULL << 32) - 1))) +#define u1(p) ((p) >> 32) +#define u2(p) ((p) & ((1ULL << 32) - 1)) +#define ult std::less +#define ugt std::greater + +#define ipair ull +#define imake(x, y) (umake(x, y)) +#define i1(p) (int(u1(ll(p)))) +#define i2(p) (ll(u2(p) << 32) >> 32) +struct ilt { + bool operator()(const ipair& a, const ipair& b) const { + if (i1(a) == i1(b)) return i2(a) < i2(b); + else return i1(a) < i1(b); + } +}; +struct igt { + bool operator()(const ipair& a, const ipair& b) const { + if (i1(a) == i1(b)) return i2(a) > i2(b); + else return i1(a) > i1(b); + } +}; + +/* conditions */ +#define loop while (1) +#define if_or(var, val) if (!(var == val)) var = val; else +#define continue_or(var, val) __AS_PROCEDURE(if (var == val) continue; var = val;) +#define break_or(var, val) __AS_PROCEDURE(if (var == val) break; var = val;) + +/* hash */ +struct safe_hash { + // https://codeforces.com/blog/entry/62393 + static uint64_t splitmix64(uint64_t x) { + // http://xorshift.di.unimi.it/splitmix64.c + x += 0x9e3779b97f4a7c15; + x = (x ^ (x >> 30)) * 0xbf58476d1ce4e5b9; + x = (x ^ (x >> 27)) * 0x94d049bb133111eb; + return x ^ (x >> 31); + } + + size_t operator()(uint64_t x) const { + static const uint64_t FIXED_RANDOM = chrono::steady_clock::now().time_since_epoch().count(); + return splitmix64(x + FIXED_RANDOM); + } +}; + +struct pair_hash { + template + size_t operator()(const pair& a) const { + auto hash1 = safe_hash()(a.first); + auto hash2 = safe_hash()(a.second); + if (hash1 != hash2) { + return hash1 ^ hash2; + } + return hash1; + } +}; + +/* build data structures */ +#define unordered_counter(from, to) __AS_PROCEDURE(unordered_map<__as_typeof(from), size_t, safe_hash> to; for (auto&& x : from) ++to[x];) +#define counter(from, to, cmp) __AS_PROCEDURE(map<__as_typeof(from), size_t, cmp> to; for (auto&& x : from) ++to[x];) +#define pa(a) __AS_PROCEDURE(__typeof(a) pa; pa.push_back({}); for (auto&&x : a) pa.push_back(pa.back() + x);) +#define sa(a) __AS_PROCEDURE(__typeof(a) sa(a.size() + 1); {int n = a.size(); for (int i = n - 1; i >= 0; --i) sa[i] = sa[i + 1] + a[i];};) +#define adj(ch, n) __AS_PROCEDURE(vector> ch((n) + 1);) +#define edge(ch, u, v) __AS_PROCEDURE(ch[u].push_back(v), ch[v].push_back(u);) +#define Edge(ch, u, v) __AS_PROCEDURE(ch[u].push_back(v);) + +/* io */ +#define untie __AS_PROCEDURE(ios_base::sync_with_stdio(0), cin.tie(NULL)) +template void __read(T& x) { cin >> x; } +template void __read(T& x, U&... args) { cin >> x; __read(args...); } +#define read(type, ...) __AS_PROCEDURE(type __VA_ARGS__; __read(__VA_ARGS__);) +#define readvec(type, a, n) __AS_PROCEDURE(vector a(n); for (int i = 0; i < (n); ++i) cin >> a[i];) +#define putvec(a) __AS_PROCEDURE(for (auto&& x : a) cout << x << ' '; cout << endl;) +#define debug(x) __AS_PROCEDURE(cerr << #x" = " << (x) << endl;) +#define debugvec(a) __AS_PROCEDURE(cerr << #a" = "; for (auto&& x : a) cerr << x << ' '; cerr << endl;) +template ostream& operator<<(ostream& out, vector vec) { + for (auto&& i : vec) out << i << ' '; + return out; +} + +/* pops */ +#define poptop(q, ...) __AS_PROCEDURE(auto [__VA_ARGS__] = q.top(); q.pop();) +#define popback(q, ...) __AS_PROCEDURE(auto [__VA_ARGS__] = q.back(); q.pop_back();) +#define popfront(q, ...) __AS_PROCEDURE(auto [__VA_ARGS__] = q.front();q.pop_front();) + +/* math */ +constexpr inline int lg2(ll x) { return x == 0 ? -1 : sizeof(ll) * 8 - 1 - __builtin_clzll(x); } + +void __exgcd(ll a, ll b, ll& x, ll& y) { + if (b == 0) { + x = 1, y = 0; + return; + } + __exgcd(b, a % b, y, x); + y -= a / b * x; +} + +ll inverse(ll a, ll b) { + ll x, y; + __exgcd(a, b, x, y); + return mod(x, b); +} + +/* string algorithms */ +vector calc_next(string t) { // pi function of t + int n = (int)t.length(); + vector pi(n); + for (int i = 1; i < n; i++) { + int j = pi[i - 1]; + while (j > 0 && t[i] != t[j]) j = pi[j - 1]; + if (t[i] == t[j]) j++; + pi[i] = j; + } + return pi; +} +vector calc_z(string t) { // z function of t + int m = t.length(); + vector z; + z.push_back(m); + pair prev = {1, -1}; + for (int i = 1; i < m; ++i) { + if (z[i - prev.first] + i <= prev.second) { + z.push_back(z[i - prev.first]); + } else { + int j = max(i, prev.second + 1); + while (j < m && t[j] == t[j - i]) ++j; + z.push_back(j - i); + prev = {i, j - 1}; + } + } + return z; +} +vector kmp(string s, string t) { // find all t in s + string cur = t + '#' + s; + int sz1 = s.size(), sz2 = t.size(); + vector v; + vector lps = calc_next(cur); + for (int i = sz2 + 1; i <= sz1 + sz2; i++) { + if (lps[i] == sz2) v.push_back(i - 2 * sz2); + } + return v; +} +int period(string s) { // find the length of shortest recurring period + int n = s.length(); + auto z = calc_z(s); + for (int i = 1; i <= n / 2; ++i) { + if (n % i == 0 && z[i] == n - i) { + return i; + } + } + return n; +} +///////////////////////////////////////////////////////// + + +#define SINGLE_TEST_CASE +// #define DUMP_TEST_CASE 512 + +void dump() {} + +void solve() { + read(string, s); + int prev = 0; + int n = s.size(); + vector res; + for (int i = 0; i < n; ++i) { + if ((s[i] - 48) % 2 == 0) { + res.push_back(s.substr(prev, i - prev + 1)); + prev = i + 1; + } + } + sort(res.begin(), res.end(), [] (const string& a, const string& b) { + if (a.size() == b.size()) return a < b; + else return a.size() < b.size(); + }); + for (auto&& s : res) { + cout << s << endl; + } +} + +int main() { + untie, cout.tie(NULL); +#ifdef SINGLE_TEST_CASE + solve(); +#else + read(int, t); + for (int i = 0; i < t; ++i) { +#ifdef DUMP_TEST_CASE + if (i + 1 == (DUMP_TEST_CASE)) { + dump(); + } else { + solve(); + } +#else + solve(); +#endif + } +#endif +} diff --git a/src/bin/nc-75766d.cc b/src/bin/nc-75766d.cc new file mode 100644 index 0000000..5f5f703 --- /dev/null +++ b/src/bin/nc-75766d.cc @@ -0,0 +1,290 @@ +#pragma GCC optimize("Ofast") +///////////////////////////////////////////////////////// +/** + * Useful Macros + * by subcrip + * (requires C++17) + */ + +#include +#include +using namespace std; +using namespace __gnu_cxx; +using namespace __gnu_pbds; + +/* 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) decltype(container)::value_type + +/* type aliases */ +using ll = int64_t; +using ull = uint64_t; +using pii = pair; +using pil = pair; +using pli = pair; +using pll = pair; + +/* constants */ +constexpr int INF = 0x3f3f3f3f; +constexpr ull MDL = 1e9 + 7; +constexpr ull PRIME = 998'244'353; +constexpr ll MDL1 = 8784491; +constexpr ll MDL2 = PRIME; + +/* random */ + +mt19937 rd(chrono::duration_cast(chrono::system_clock::now().time_since_epoch()).count()); + +/* bit-wise operations */ +#define lowbit(x) ((x) & -(x)) +#define popcount(x) (__builtin_popcountll(ll(x))) +#define parity(x) (__builtin_parityll(ll(x))) +#define msp(x) (63LL - __builtin_clzll(ll(x))) +#define lsp(x) (__builtin_ctzll(ll(x))) + +/* arithmetic operations */ +#define mod(x, y) ((((x) % (y)) + (y)) % (y)) + +/* fast pairs */ +#define upair ull +#define umake(x, y) (ull(x) << 32 | (ull(y) & ((1ULL << 32) - 1))) +#define u1(p) ((p) >> 32) +#define u2(p) ((p) & ((1ULL << 32) - 1)) +#define ult std::less +#define ugt std::greater + +#define ipair ull +#define imake(x, y) (umake(x, y)) +#define i1(p) (int(u1(ll(p)))) +#define i2(p) (ll(u2(p) << 32) >> 32) +struct ilt { + bool operator()(const ipair& a, const ipair& b) const { + if (i1(a) == i1(b)) return i2(a) < i2(b); + else return i1(a) < i1(b); + } +}; +struct igt { + bool operator()(const ipair& a, const ipair& b) const { + if (i1(a) == i1(b)) return i2(a) > i2(b); + else return i1(a) > i1(b); + } +}; + +/* conditions */ +#define loop while (1) +#define if_or(var, val) if (!(var == val)) var = val; else +#define continue_or(var, val) __AS_PROCEDURE(if (var == val) continue; var = val;) +#define break_or(var, val) __AS_PROCEDURE(if (var == val) break; var = val;) + +/* hash */ +struct safe_hash { + // https://codeforces.com/blog/entry/62393 + static uint64_t splitmix64(uint64_t x) { + // http://xorshift.di.unimi.it/splitmix64.c + x += 0x9e3779b97f4a7c15; + x = (x ^ (x >> 30)) * 0xbf58476d1ce4e5b9; + x = (x ^ (x >> 27)) * 0x94d049bb133111eb; + return x ^ (x >> 31); + } + + size_t operator()(uint64_t x) const { + static const uint64_t FIXED_RANDOM = chrono::steady_clock::now().time_since_epoch().count(); + return splitmix64(x + FIXED_RANDOM); + } +}; + +struct pair_hash { + template + size_t operator()(const pair& a) const { + auto hash1 = safe_hash()(a.first); + auto hash2 = safe_hash()(a.second); + if (hash1 != hash2) { + return hash1 ^ hash2; + } + return hash1; + } +}; + +/* build data structures */ +#define unordered_counter(from, to) __AS_PROCEDURE(unordered_map<__as_typeof(from), size_t, safe_hash> to; for (auto&& x : from) ++to[x];) +#define counter(from, to, cmp) __AS_PROCEDURE(map<__as_typeof(from), size_t, cmp> to; for (auto&& x : from) ++to[x];) +#define pa(a) __AS_PROCEDURE(__typeof(a) pa; pa.push_back({}); for (auto&&x : a) pa.push_back(pa.back() + x);) +#define sa(a) __AS_PROCEDURE(__typeof(a) sa(a.size() + 1); {int n = a.size(); for (int i = n - 1; i >= 0; --i) sa[i] = sa[i + 1] + a[i];};) +#define adj(ch, n) __AS_PROCEDURE(vector> ch((n) + 1);) +#define edge(ch, u, v) __AS_PROCEDURE(ch[u].push_back(v), ch[v].push_back(u);) +#define Edge(ch, u, v) __AS_PROCEDURE(ch[u].push_back(v);) + +/* io */ +#define untie __AS_PROCEDURE(ios_base::sync_with_stdio(0), cin.tie(NULL)) +template void __read(T& x) { cin >> x; } +template void __read(T& x, U&... args) { cin >> x; __read(args...); } +#define read(type, ...) __AS_PROCEDURE(type __VA_ARGS__; __read(__VA_ARGS__);) +#define readvec(type, a, n) __AS_PROCEDURE(vector a(n); for (int i = 0; i < (n); ++i) cin >> a[i];) +#define putvec(a) __AS_PROCEDURE(for (auto&& x : a) cout << x << ' '; cout << endl;) +#define debug(x) __AS_PROCEDURE(cerr << #x" = " << (x) << endl;) +#define debugvec(a) __AS_PROCEDURE(cerr << #a" = "; for (auto&& x : a) cerr << x << ' '; cerr << endl;) +template ostream& operator<<(ostream& out, vector vec) { + for (auto&& i : vec) out << i << ' '; + return out; +} + +/* pops */ +#define poptop(q, ...) __AS_PROCEDURE(auto [__VA_ARGS__] = q.top(); q.pop();) +#define popback(q, ...) __AS_PROCEDURE(auto [__VA_ARGS__] = q.back(); q.pop_back();) +#define popfront(q, ...) __AS_PROCEDURE(auto [__VA_ARGS__] = q.front();q.pop_front();) + +/* math */ +constexpr inline int lg2(ll x) { return x == 0 ? -1 : sizeof(ll) * 8 - 1 - __builtin_clzll(x); } + +void __exgcd(ll a, ll b, ll& x, ll& y) { + if (b == 0) { + x = 1, y = 0; + return; + } + __exgcd(b, a % b, y, x); + y -= a / b * x; +} + +ll inverse(ll a, ll b) { + ll x, y; + __exgcd(a, b, x, y); + return mod(x, b); +} + +/* string algorithms */ +vector calc_next(string t) { // pi function of t + int n = (int)t.length(); + vector pi(n); + for (int i = 1; i < n; i++) { + int j = pi[i - 1]; + while (j > 0 && t[i] != t[j]) j = pi[j - 1]; + if (t[i] == t[j]) j++; + pi[i] = j; + } + return pi; +} +vector calc_z(string t) { // z function of t + int m = t.length(); + vector z; + z.push_back(m); + pair prev = {1, -1}; + for (int i = 1; i < m; ++i) { + if (z[i - prev.first] + i <= prev.second) { + z.push_back(z[i - prev.first]); + } else { + int j = max(i, prev.second + 1); + while (j < m && t[j] == t[j - i]) ++j; + z.push_back(j - i); + prev = {i, j - 1}; + } + } + return z; +} +vector kmp(string s, string t) { // find all t in s + string cur = t + '#' + s; + int sz1 = s.size(), sz2 = t.size(); + vector v; + vector lps = calc_next(cur); + for (int i = sz2 + 1; i <= sz1 + sz2; i++) { + if (lps[i] == sz2) v.push_back(i - 2 * sz2); + } + return v; +} +int period(string s) { // find the length of shortest recurring period + int n = s.length(); + auto z = calc_z(s); + for (int i = 1; i <= n / 2; ++i) { + if (n % i == 0 && z[i] == n - i) { + return i; + } + } + return n; +} +///////////////////////////////////////////////////////// + + +#define SINGLE_TEST_CASE +// #define DUMP_TEST_CASE 512 + +void dump() {} + +void solve() { + read(int, n); + readvec(int, a, n); + int prev = 0, tp = -1; + for (int i = 0; i < n; ++i) { + if (a[i] && a[i] != prev) { + if (prev == 0) { + prev = a[i]; + } else { + tp = i; + break; + } + } + } + if (tp != -1) { + for (int i = 0; i < tp; ++i) { + a[i] = prev; + } + for (int i = tp; i < n; ++i) { + if (a[i] && a[i] != a[tp]) { + cout << -1 << endl; + return; + } + a[i] = a[tp]; + } + putvec(a); + } else { + if (prev == 0) { + if (n == 1) cout << -1 << endl; + else { + fill(a.begin(), a.end(), 2); + a[0] = 1; + putvec(a); + } + } else { + if (n == 1) cout << -1 << endl; + else { + if (a[0] == 0) { + a[0] = prev + 1; + for (int i = 1; i < n; ++i) { + a[i] = prev; + } + } else if (a[n - 1] == 0) { + a[n - 1] = prev + 1; + for (int i = 0; i < n - 1; ++i) { + a[i] = prev; + } + } else { + cout << -1 << endl; + return; + } + putvec(a); + } + } + } +} + +int main() { + untie, cout.tie(NULL); +#ifdef SINGLE_TEST_CASE + solve(); +#else + read(int, t); + for (int i = 0; i < t; ++i) { +#ifdef DUMP_TEST_CASE + if (i + 1 == (DUMP_TEST_CASE)) { + dump(); + } else { + solve(); + } +#else + solve(); +#endif + } +#endif +} diff --git a/src/bin/nc-75766e.cc b/src/bin/nc-75766e.cc new file mode 100644 index 0000000..f4f0a79 --- /dev/null +++ b/src/bin/nc-75766e.cc @@ -0,0 +1,276 @@ +#pragma GCC optimize("Ofast") +///////////////////////////////////////////////////////// +/** + * Useful Macros + * by subcrip + * (requires C++17) + */ + +#include +#include +using namespace std; +using namespace __gnu_cxx; +using namespace __gnu_pbds; + +/* 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) decltype(container)::value_type + +/* type aliases */ +using ll = int64_t; +using ull = uint64_t; +using pii = pair; +using pil = pair; +using pli = pair; +using pll = pair; + +/* constants */ +constexpr int INF = 0x3f3f3f3f; +constexpr ull MDL = 1e9 + 7; +constexpr ull PRIME = 998'244'353; +constexpr ll MDL1 = 8784491; +constexpr ll MDL2 = PRIME; + +/* random */ + +mt19937 rd(chrono::duration_cast(chrono::system_clock::now().time_since_epoch()).count()); + +/* bit-wise operations */ +#define lowbit(x) ((x) & -(x)) +#define popcount(x) (__builtin_popcountll(ll(x))) +#define parity(x) (__builtin_parityll(ll(x))) +#define msp(x) (63LL - __builtin_clzll(ll(x))) +#define lsp(x) (__builtin_ctzll(ll(x))) + +/* arithmetic operations */ +#define mod(x, y) ((((x) % (y)) + (y)) % (y)) + +/* fast pairs */ +#define upair ull +#define umake(x, y) (ull(x) << 32 | (ull(y) & ((1ULL << 32) - 1))) +#define u1(p) ((p) >> 32) +#define u2(p) ((p) & ((1ULL << 32) - 1)) +#define ult std::less +#define ugt std::greater + +#define ipair ull +#define imake(x, y) (umake(x, y)) +#define i1(p) (int(u1(ll(p)))) +#define i2(p) (ll(u2(p) << 32) >> 32) +struct ilt { + bool operator()(const ipair& a, const ipair& b) const { + if (i1(a) == i1(b)) return i2(a) < i2(b); + else return i1(a) < i1(b); + } +}; +struct igt { + bool operator()(const ipair& a, const ipair& b) const { + if (i1(a) == i1(b)) return i2(a) > i2(b); + else return i1(a) > i1(b); + } +}; + +/* conditions */ +#define loop while (1) +#define if_or(var, val) if (!(var == val)) var = val; else +#define continue_or(var, val) __AS_PROCEDURE(if (var == val) continue; var = val;) +#define break_or(var, val) __AS_PROCEDURE(if (var == val) break; var = val;) + +/* hash */ +struct safe_hash { + // https://codeforces.com/blog/entry/62393 + static uint64_t splitmix64(uint64_t x) { + // http://xorshift.di.unimi.it/splitmix64.c + x += 0x9e3779b97f4a7c15; + x = (x ^ (x >> 30)) * 0xbf58476d1ce4e5b9; + x = (x ^ (x >> 27)) * 0x94d049bb133111eb; + return x ^ (x >> 31); + } + + size_t operator()(uint64_t x) const { + static const uint64_t FIXED_RANDOM = chrono::steady_clock::now().time_since_epoch().count(); + return splitmix64(x + FIXED_RANDOM); + } +}; + +struct pair_hash { + template + size_t operator()(const pair& a) const { + auto hash1 = safe_hash()(a.first); + auto hash2 = safe_hash()(a.second); + if (hash1 != hash2) { + return hash1 ^ hash2; + } + return hash1; + } +}; + +/* build data structures */ +#define unordered_counter(from, to) __AS_PROCEDURE(unordered_map<__as_typeof(from), size_t, safe_hash> to; for (auto&& x : from) ++to[x];) +#define counter(from, to, cmp) __AS_PROCEDURE(map<__as_typeof(from), size_t, cmp> to; for (auto&& x : from) ++to[x];) +#define pa(a) __AS_PROCEDURE(__typeof(a) pa; pa.push_back({}); for (auto&&x : a) pa.push_back(pa.back() + x);) +#define sa(a) __AS_PROCEDURE(__typeof(a) sa(a.size() + 1); {int n = a.size(); for (int i = n - 1; i >= 0; --i) sa[i] = sa[i + 1] + a[i];};) +#define adj(ch, n) __AS_PROCEDURE(vector> ch((n) + 1);) +#define edge(ch, u, v) __AS_PROCEDURE(ch[u].push_back(v), ch[v].push_back(u);) +#define Edge(ch, u, v) __AS_PROCEDURE(ch[u].push_back(v);) + +/* io */ +#define untie __AS_PROCEDURE(ios_base::sync_with_stdio(0), cin.tie(NULL)) +template void __read(T& x) { cin >> x; } +template void __read(T& x, U&... args) { cin >> x; __read(args...); } +#define read(type, ...) __AS_PROCEDURE(type __VA_ARGS__; __read(__VA_ARGS__);) +#define readvec(type, a, n) __AS_PROCEDURE(vector a(n); for (int i = 0; i < (n); ++i) cin >> a[i];) +#define putvec(a) __AS_PROCEDURE(for (auto&& x : a) cout << x << ' '; cout << endl;) +#define debug(x) __AS_PROCEDURE(cerr << #x" = " << (x) << endl;) +#define debugvec(a) __AS_PROCEDURE(cerr << #a" = "; for (auto&& x : a) cerr << x << ' '; cerr << endl;) +template ostream& operator<<(ostream& out, vector vec) { + for (auto&& i : vec) out << i << ' '; + return out; +} + +/* pops */ +#define poptop(q, ...) __AS_PROCEDURE(auto [__VA_ARGS__] = q.top(); q.pop();) +#define popback(q, ...) __AS_PROCEDURE(auto [__VA_ARGS__] = q.back(); q.pop_back();) +#define popfront(q, ...) __AS_PROCEDURE(auto [__VA_ARGS__] = q.front();q.pop_front();) + +/* math */ +constexpr inline int lg2(ll x) { return x == 0 ? -1 : sizeof(ll) * 8 - 1 - __builtin_clzll(x); } + +void __exgcd(ll a, ll b, ll& x, ll& y) { + if (b == 0) { + x = 1, y = 0; + return; + } + __exgcd(b, a % b, y, x); + y -= a / b * x; +} + +ll inverse(ll a, ll b) { + ll x, y; + __exgcd(a, b, x, y); + return mod(x, b); +} + +/* string algorithms */ +vector calc_next(string t) { // pi function of t + int n = (int)t.length(); + vector pi(n); + for (int i = 1; i < n; i++) { + int j = pi[i - 1]; + while (j > 0 && t[i] != t[j]) j = pi[j - 1]; + if (t[i] == t[j]) j++; + pi[i] = j; + } + return pi; +} +vector calc_z(string t) { // z function of t + int m = t.length(); + vector z; + z.push_back(m); + pair prev = {1, -1}; + for (int i = 1; i < m; ++i) { + if (z[i - prev.first] + i <= prev.second) { + z.push_back(z[i - prev.first]); + } else { + int j = max(i, prev.second + 1); + while (j < m && t[j] == t[j - i]) ++j; + z.push_back(j - i); + prev = {i, j - 1}; + } + } + return z; +} +vector kmp(string s, string t) { // find all t in s + string cur = t + '#' + s; + int sz1 = s.size(), sz2 = t.size(); + vector v; + vector lps = calc_next(cur); + for (int i = sz2 + 1; i <= sz1 + sz2; i++) { + if (lps[i] == sz2) v.push_back(i - 2 * sz2); + } + return v; +} +int period(string s) { // find the length of shortest recurring period + int n = s.length(); + auto z = calc_z(s); + for (int i = 1; i <= n / 2; ++i) { + if (n % i == 0 && z[i] == n - i) { + return i; + } + } + return n; +} +///////////////////////////////////////////////////////// + + +#define SINGLE_TEST_CASE +// #define DUMP_TEST_CASE 512 + +void dump() {} + +void solve() { + read(int, n); + readvec(char, a, n); + vector> ch(n); + for (int i = 0; i + 1 < n; ++i) { + read(int, x, y); + ch[x - 1].push_back(y - 1); + ch[y - 1].push_back(x - 1); + } + vector color(n); + auto dfs = [&] (auto dfs, int v, int pa, int col) -> void { + color[v] = col; + for (auto&& u : ch[v]) { + if (u == pa) continue; + dfs(dfs, u, v, 1 ^ col); + } + }; + dfs(dfs, 0, -1, 0); + array mp {0, 0}; + for (int i = 0; i < n; ++i) { + if (mp[color[i]] && a[i] != '?' && mp[color[i]] != a[i]) { + cout << -1 << endl; + return; + } + if (a[i] != '?') mp[color[i]] = a[i]; + } + if (mp[0] == 0 && mp[1] == 0) { + mp[0] = 'p'; + mp[1] = 'd'; + } else if (mp[0] == 0) { + mp[0] = mp[1] == 'p' ? 'd' : 'p'; + } else if (mp[1] == 0) { + mp[1] = mp[0] == 'p' ? 'd' : 'p'; + } else if (mp[0] == mp[1]) { + cout << -1 << endl; + return; + } + for (int i = 0; i < n; ++i) { + cout << mp[color[i]]; + } + cout << endl; +} + +int main() { + untie, cout.tie(NULL); +#ifdef SINGLE_TEST_CASE + solve(); +#else + read(int, t); + for (int i = 0; i < t; ++i) { +#ifdef DUMP_TEST_CASE + if (i + 1 == (DUMP_TEST_CASE)) { + dump(); + } else { + solve(); + } +#else + solve(); +#endif + } +#endif +} diff --git a/src/bin/nc-75766f.cc b/src/bin/nc-75766f.cc new file mode 100644 index 0000000..ead26a0 --- /dev/null +++ b/src/bin/nc-75766f.cc @@ -0,0 +1,287 @@ +#pragma GCC optimize("Ofast") +///////////////////////////////////////////////////////// +/** + * Useful Macros + * by subcrip + * (requires C++17) + */ + +#include +#include +using namespace std; +using namespace __gnu_cxx; +using namespace __gnu_pbds; + +/* 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) decltype(container)::value_type + +/* type aliases */ +using ll = int64_t; +using ull = uint64_t; +using pii = pair; +using pil = pair; +using pli = pair; +using pll = pair; + +/* constants */ +constexpr int INF = 0x3f3f3f3f; +constexpr ull MDL = 1e9 + 7; +constexpr ull PRIME = 998'244'353; +constexpr ll MDL1 = 8784491; +constexpr ll MDL2 = PRIME; + +/* random */ + +mt19937 rd(chrono::duration_cast(chrono::system_clock::now().time_since_epoch()).count()); + +/* bit-wise operations */ +#define lowbit(x) ((x) & -(x)) +#define popcount(x) (__builtin_popcountll(ll(x))) +#define parity(x) (__builtin_parityll(ll(x))) +#define msp(x) (63LL - __builtin_clzll(ll(x))) +#define lsp(x) (__builtin_ctzll(ll(x))) + +/* arithmetic operations */ +#define mod(x, y) ((((x) % (y)) + (y)) % (y)) + +/* fast pairs */ +#define upair ull +#define umake(x, y) (ull(x) << 32 | (ull(y) & ((1ULL << 32) - 1))) +#define u1(p) ((p) >> 32) +#define u2(p) ((p) & ((1ULL << 32) - 1)) +#define ult std::less +#define ugt std::greater + +#define ipair ull +#define imake(x, y) (umake(x, y)) +#define i1(p) (int(u1(ll(p)))) +#define i2(p) (ll(u2(p) << 32) >> 32) +struct ilt { + bool operator()(const ipair& a, const ipair& b) const { + if (i1(a) == i1(b)) return i2(a) < i2(b); + else return i1(a) < i1(b); + } +}; +struct igt { + bool operator()(const ipair& a, const ipair& b) const { + if (i1(a) == i1(b)) return i2(a) > i2(b); + else return i1(a) > i1(b); + } +}; + +/* conditions */ +#define loop while (1) +#define if_or(var, val) if (!(var == val)) var = val; else +#define continue_or(var, val) __AS_PROCEDURE(if (var == val) continue; var = val;) +#define break_or(var, val) __AS_PROCEDURE(if (var == val) break; var = val;) + +/* hash */ +struct safe_hash { + // https://codeforces.com/blog/entry/62393 + static uint64_t splitmix64(uint64_t x) { + // http://xorshift.di.unimi.it/splitmix64.c + x += 0x9e3779b97f4a7c15; + x = (x ^ (x >> 30)) * 0xbf58476d1ce4e5b9; + x = (x ^ (x >> 27)) * 0x94d049bb133111eb; + return x ^ (x >> 31); + } + + size_t operator()(uint64_t x) const { + static const uint64_t FIXED_RANDOM = chrono::steady_clock::now().time_since_epoch().count(); + return splitmix64(x + FIXED_RANDOM); + } +}; + +struct pair_hash { + template + size_t operator()(const pair& a) const { + auto hash1 = safe_hash()(a.first); + auto hash2 = safe_hash()(a.second); + if (hash1 != hash2) { + return hash1 ^ hash2; + } + return hash1; + } +}; + +/* build data structures */ +#define unordered_counter(from, to) __AS_PROCEDURE(unordered_map<__as_typeof(from), size_t, safe_hash> to; for (auto&& x : from) ++to[x];) +#define counter(from, to, cmp) __AS_PROCEDURE(map<__as_typeof(from), size_t, cmp> to; for (auto&& x : from) ++to[x];) +#define pa(a) __AS_PROCEDURE(__typeof(a) pa; pa.push_back({}); for (auto&&x : a) pa.push_back(pa.back() + x);) +#define sa(a) __AS_PROCEDURE(__typeof(a) sa(a.size() + 1); {int n = a.size(); for (int i = n - 1; i >= 0; --i) sa[i] = sa[i + 1] + a[i];};) +#define adj(ch, n) __AS_PROCEDURE(vector> ch((n) + 1);) +#define edge(ch, u, v) __AS_PROCEDURE(ch[u].push_back(v), ch[v].push_back(u);) +#define Edge(ch, u, v) __AS_PROCEDURE(ch[u].push_back(v);) + +/* io */ +#define untie __AS_PROCEDURE(ios_base::sync_with_stdio(0), cin.tie(NULL)) +template void __read(T& x) { cin >> x; } +template void __read(T& x, U&... args) { cin >> x; __read(args...); } +#define read(type, ...) __AS_PROCEDURE(type __VA_ARGS__; __read(__VA_ARGS__);) +#define readvec(type, a, n) __AS_PROCEDURE(vector a(n); for (int i = 0; i < (n); ++i) cin >> a[i];) +#define putvec(a) __AS_PROCEDURE(for (auto&& x : a) cout << x << ' '; cout << endl;) +#define debug(x) __AS_PROCEDURE(cerr << #x" = " << (x) << endl;) +#define debugvec(a) __AS_PROCEDURE(cerr << #a" = "; for (auto&& x : a) cerr << x << ' '; cerr << endl;) +template ostream& operator<<(ostream& out, vector vec) { + for (auto&& i : vec) out << i << ' '; + return out; +} + +/* pops */ +#define poptop(q, ...) __AS_PROCEDURE(auto [__VA_ARGS__] = q.top(); q.pop();) +#define popback(q, ...) __AS_PROCEDURE(auto [__VA_ARGS__] = q.back(); q.pop_back();) +#define popfront(q, ...) __AS_PROCEDURE(auto [__VA_ARGS__] = q.front();q.pop_front();) + +/* math */ +constexpr inline int lg2(ll x) { return x == 0 ? -1 : sizeof(ll) * 8 - 1 - __builtin_clzll(x); } + +void __exgcd(ll a, ll b, ll& x, ll& y) { + if (b == 0) { + x = 1, y = 0; + return; + } + __exgcd(b, a % b, y, x); + y -= a / b * x; +} + +ll inverse(ll a, ll b) { + ll x, y; + __exgcd(a, b, x, y); + return mod(x, b); +} + +/* string algorithms */ +vector calc_next(string t) { // pi function of t + int n = (int)t.length(); + vector pi(n); + for (int i = 1; i < n; i++) { + int j = pi[i - 1]; + while (j > 0 && t[i] != t[j]) j = pi[j - 1]; + if (t[i] == t[j]) j++; + pi[i] = j; + } + return pi; +} +vector calc_z(string t) { // z function of t + int m = t.length(); + vector z; + z.push_back(m); + pair prev = {1, -1}; + for (int i = 1; i < m; ++i) { + if (z[i - prev.first] + i <= prev.second) { + z.push_back(z[i - prev.first]); + } else { + int j = max(i, prev.second + 1); + while (j < m && t[j] == t[j - i]) ++j; + z.push_back(j - i); + prev = {i, j - 1}; + } + } + return z; +} +vector kmp(string s, string t) { // find all t in s + string cur = t + '#' + s; + int sz1 = s.size(), sz2 = t.size(); + vector v; + vector lps = calc_next(cur); + for (int i = sz2 + 1; i <= sz1 + sz2; i++) { + if (lps[i] == sz2) v.push_back(i - 2 * sz2); + } + return v; +} +int period(string s) { // find the length of shortest recurring period + int n = s.length(); + auto z = calc_z(s); + for (int i = 1; i <= n / 2; ++i) { + if (n % i == 0 && z[i] == n - i) { + return i; + } + } + return n; +} +///////////////////////////////////////////////////////// + + +#define SINGLE_TEST_CASE +// #define DUMP_TEST_CASE 512 + +void dump() {} + +void solve() { + read(int, n, m, x); + int mx = min(n, m); + vector> res(n, vector(m)); + for (int i = 2; i <= mx; i += 2) { + if (x % (i * i) == 0) { + int per = x / (i * i); + for (int j = 0; j < i; ++j) { + for (int k = 0; k < i; ++k) { + res[j][k] = per; + } + } + for (int x = 0; x < n; ++x) { + for (int y = 0; y < m; ++y) { + cout << res[x][y] << " \n"[y + 1 == m]; + } + } + return; + } + } + if (n == m) { + if (x % n == 0) { + int per = x / n; + for (int j = 0; j < n; ++j) { + res[j][j] = per; + } + for (int x = 0; x < n; ++x) { + for (int y = 0; y < m; ++y) { + cout << res[x][y] << " \n"[y + 1 == m]; + } + } + return; + } + } + if (n % 2 == m % 2) { + if (x % (m * n) == 0) { + int per = x / (m * n); + for (int j = 0; j < n; ++j) { + for (int k = 0; k < m; ++k) { + res[j][k] = per; + } + } + for (int x = 0; x < n; ++x) { + for (int y = 0; y < m; ++y) { + cout << res[x][y] << " \n"[y + 1 == m]; + } + } + return; + } + } + cout << -1 << endl; + return; +} + +int main() { + untie, cout.tie(NULL); +#ifdef SINGLE_TEST_CASE + solve(); +#else + read(int, t); + for (int i = 0; i < t; ++i) { +#ifdef DUMP_TEST_CASE + if (i + 1 == (DUMP_TEST_CASE)) { + dump(); + } else { + solve(); + } +#else + solve(); +#endif + } +#endif +} diff --git a/src/bin/std.in b/src/bin/std.in new file mode 100644 index 0000000..42f0b53 --- /dev/null +++ b/src/bin/std.in @@ -0,0 +1,18 @@ + +8 +4 1 +2 1 8 9 +3 3 +6 2 60 +4 5 +5 1 100 5 +3 2 +38 6 3 +1 1 +12 +4 6 +12 12 36 100 +4 1 +2 1 1 15 +3 5 +15 1 13 diff --git a/src/bin/std.out b/src/bin/std.out new file mode 100644 index 0000000..b6c7c83 --- /dev/null +++ b/src/bin/std.out @@ -0,0 +1,4 @@ +-1 3 -5 +-1 -1 +-1 3 +1 1 1 -7 diff --git a/src/bin/test.cc b/src/bin/test.cc index e755a5c..19c94ce 100644 --- a/src/bin/test.cc +++ b/src/bin/test.cc @@ -1,3 +1,4 @@ +#pragma GCC optimize("Ofast") ///////////////////////////////////////////////////////// /** * Useful Macros @@ -6,7 +7,10 @@ */ #include +#include using namespace std; +using namespace __gnu_cxx; +using namespace __gnu_pbds; /* macro helpers */ #define __NARGS(...) std::tuple_size::value @@ -26,10 +30,15 @@ using pll = pair; /* constants */ constexpr int INF = 0x3f3f3f3f; +constexpr ll INFLL = 0x3f3f3f3f3f3f3f3fLL; constexpr ull MDL = 1e9 + 7; constexpr ull PRIME = 998'244'353; -constexpr ull MDL1 = 825; -constexpr ull MDL2 = 87825; +constexpr ll MDL1 = 8784491; +constexpr ll MDL2 = PRIME; + +/* random */ + +mt19937 rd(chrono::duration_cast(chrono::system_clock::now().time_since_epoch()).count()); /* bit-wise operations */ #define lowbit(x) ((x) & -(x)) @@ -39,11 +48,11 @@ constexpr ull MDL2 = 87825; #define lsp(x) (__builtin_ctzll(ll(x))) /* arithmetic operations */ -#define mod(x, y) (((x) + (y)) % (y)) +#define mod(x, y) ((((x) % (y)) + (y)) % (y)) /* fast pairs */ #define upair ull -#define umake(x, y) (ull(x) << 32 | ull(y)) +#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 @@ -51,8 +60,8 @@ constexpr ull MDL2 = 87825; #define ipair ull #define imake(x, y) (umake(x, y)) -#define i1(p) (int(u1(p))) -#define i2(p) (int(u2(p))) +#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); @@ -72,8 +81,37 @@ struct igt { #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; + } +}; + /* build data structures */ -#define unordered_counter(from, to) __AS_PROCEDURE(unordered_map<__as_typeof(from), size_t> to; for (auto&& x : from) ++to[x];) +#define unordered_counter(from, to) __AS_PROCEDURE(unordered_map<__as_typeof(from), size_t, safe_hash> to; for (auto&& x : from) ++to[x];) #define counter(from, to, cmp) __AS_PROCEDURE(map<__as_typeof(from), size_t, cmp> to; for (auto&& x : from) ++to[x];) #define pa(a) __AS_PROCEDURE(__typeof(a) pa; pa.push_back({}); for (auto&&x : a) pa.push_back(pa.back() + x);) #define sa(a) __AS_PROCEDURE(__typeof(a) sa(a.size() + 1); {int n = a.size(); for (int i = n - 1; i >= 0; --i) sa[i] = sa[i + 1] + a[i];};) @@ -100,8 +138,25 @@ template ostream& operator<<(ostream& out, vector vec) { #define popback(q, ...) __AS_PROCEDURE(auto [__VA_ARGS__] = q.back(); q.pop_back();) #define popfront(q, ...) __AS_PROCEDURE(auto [__VA_ARGS__] = q.front();q.pop_front();) -/* algorithms */ +/* math */ +constexpr inline int lg2(ll x) { return x == 0 ? -1 : sizeof(ll) * 8 - 1 - __builtin_clzll(x); } +void __exgcd(ll a, ll b, ll& x, ll& y) { + if (b == 0) { + x = 1, y = 0; + return; + } + __exgcd(b, a % b, y, x); + y -= a / b * x; +} + +ll inverse(ll a, ll b) { + ll x, y; + __exgcd(a, b, x, y); + return mod(x, b); +} + +/* string algorithms */ vector calc_next(string t) { // pi function of t int n = (int)t.length(); vector pi(n); @@ -152,112 +207,59 @@ int period(string s) { // find the length of shortest recurring period } ///////////////////////////////////////////////////////// -constexpr int N = 1e6 + 10; -ll s[N]; -ll n, sa[N], rk[N], oldrk[N << 1], id[N], key1[N], cnt[N], height[N]; +// #define SINGLE_TEST_CASE +// #define DUMP_TEST_CASE 512 -bool cmp(ll x, ll y, ll w) { - return oldrk[x] == oldrk[y] && oldrk[x + w] == oldrk[y + w]; -} +void dump() {} -void calc_sa() { - ll i, m = N - 1, p, w; - for (i = 1; i <= n; ++i) ++cnt[rk[i] = s[i]]; - for (i = 1; i <= m; ++i) cnt[i] += cnt[i - 1]; - for (i = n; i >= 1; --i) sa[cnt[rk[i]]--] = i; +void prep() {} - for (w = 1;; w <<= 1, m = p) { - for (p = 0, i = n; i > n - w; --i) id[++p] = i; - for (i = 1; i <= n; ++i) - if (sa[i] > w) id[++p] = sa[i] - w; - - memset(cnt, 0, sizeof(cnt)); - for (i = 1; i <= n; ++i) ++cnt[key1[i] = rk[id[i]]]; - - for (i = 1; i <= m; ++i) cnt[i] += cnt[i - 1]; - for (i = n; i >= 1; --i) sa[cnt[key1[i]]--] = id[i]; - memcpy(oldrk + 1, rk + 1, n * sizeof(ll)); - for (p = 0, i = 1; i <= n; ++i) - rk[sa[i]] = cmp(sa[i], sa[i - 1], w) ? p : ++p; - if (p == n) { - break; +void solve() { + read(int, n, h); + readvec(ll, a, n); + sort(a.begin(), a.end()); + auto work = [&] (vector pattern) -> int { + int ptr = 0; + int i = 0; + ll curr = h; + while (i < n) { + if (curr > a[i]) { + curr += a[i] / 2; + i += 1; + } else { + if (ptr >= 3) break; + curr *= pattern[ptr]; + ptr += 1; + } } - } -} - -void calc_height() { - int i, k; - for (i = 1, k = 0; i <= n; ++i) { - if (rk[i] == 0) continue; - if (k) --k; - while (s[i + k] == s[sa[rk[i] - 1] + k]) ++k; - height[rk[i]] = k; - } -} - -ll d[4*N]; - -void build(int s,int t,int p){ // root p, range [s,t] - // debug(s), debug(t), debug(p); - if(s==t){ - d[p]=height[s]; - return; + return i; + }; + int res = 0; + vector> patterns = {{2, 2, 3}, {2, 3, 2}, {3, 2, 2}}; + for (auto&& p : patterns) { + res = max(res, work(p)); } - int m=s+(t-s>>1); - build(s,m,p*2),build(m+1,t,p*2+1); - d[p]=min(d[p*2], d[p*2+1]); -} - -ll getmin(int s,int t,int p,int l,int r){ - if (l > r) return LLONG_MAX; - if(l<=s&&t<=r)return d[p]; - int m=s+(t-s>>1); - ll sum=LLONG_MAX; - if(l<=m)sum=min(sum, getmin(s,m,p*2,l,r)); - if(r>m) sum=min(sum, getmin(m+1,t,p*2+1,l,r)); - return sum; + cout << res << endl; } int main() { - untie; - cin >> n; - read(int, k); - for (int i = 1; i <= n; ++i) cin >> s[i]; - calc_sa(), calc_height(); - build(1, n, 1); - int l = 0, r = n; - auto binary_search = [&] (int start, int length) { - int l = start, r = n; - while (l < r) { - int mid = l + r + 1 >> 1; - if (getmin(1, n, 1, start + 1, mid) < length) { - r = mid - 1; - } else { - l = mid; - } - } - return l; - }; - // l = 2, r = 4; - // for (int i = 1; i <= n; ++i) cerr << height[i] << " \n"[i == n]; - // debug(rk[2]), debug(rk[4]); - // for (int start = 1; start <= n; ++start) - // for (int i = start; i <= n; ++i) cerr << getmin(1, n, 1, start, i) << " \n"[i == n]; - while (l < r) { - int curr_len = l + r + 1 >> 1; - ll match = 0; - for (int i = 1; i <= n; ++i) { - ll idx = binary_search(i, curr_len); - match = max(match, idx - i + 1); - } - // debug(curr_len), debug(match); - if (match < k) { - // cerr << curr_len << " not ok\n"; - r = curr_len - 1; + untie, cout.tie(NULL); + prep(); +#ifdef SINGLE_TEST_CASE + solve(); +#else + read(int, t); + for (int i = 0; i < t; ++i) { +#ifdef DUMP_TEST_CASE + if (i + 1 == (DUMP_TEST_CASE)) { + dump(); } else { - l = curr_len; + solve(); } +#else + solve(); +#endif } - cout << l << endl; -} \ No newline at end of file +#endif +} diff --git a/src/bin/test.js b/src/bin/test.js new file mode 100644 index 0000000..4db3a06 --- /dev/null +++ b/src/bin/test.js @@ -0,0 +1,32 @@ +// ==UserScript== +// @name New Userscript +// @namespace http://tampermonkey.net/ +// @version 2024-02-17 +// @description try to take over the world! +// @author You +// @match https://codeforces.com/problemset/problem/* +// @match https://codeforces.com/contest/*/problem/* +// @icon https://www.google.com/s2/favicons?sz=64&domain=codeforces.com +// @grant none +// ==/UserScript== + +(function() { + 'use strict'; + const url = window.location.pathname.split('/'); + let contest, problem; + if (url.includes('contest')) { + contest = url[2]; + problem = url[4]; + } else { + contest = url[3]; + problem = url[4]; + } + let button = document.createElement('li'); + let inner = document.createElement('a'); + inner.target = '_blank'; + inner.href = `https://www.luogu.com.cn/problem/solution/CF${contest}${problem}`; + inner.innerText = 'SOLUTIONS'; + button.appendChild(inner); + let menu = document.getElementsByClassName('second-level-menu-list')[0]; + menu.insertBefore(button, menu.children[2]) +})(); \ No newline at end of file diff --git a/src/bin/test.py b/src/bin/test.py index 73e9b8a..7f7a9ca 100644 --- a/src/bin/test.py +++ b/src/bin/test.py @@ -1,29 +1,25 @@ -def kmp(s, t): # find all occurrences of t in s - n = len(s) - m = len(t) - next = [-1] - j = -1 - i = 0 - while i < m: - if j == -1 or t[i] == t[j]: - i += 1 - j += 1 - if i != m and t[j] == t[i]: - next.append(next[j]) - else: - next.append(j) +import hashlib + +def generateLicense(email): + array = [] + + hashObject = hashlib.md5(email.encode('utf-8')) + hexDigest = hashObject.hexdigest() + + for i in range(0, len(hexDigest),5): + if i < 21: + flag = hexDigest[i:i + 5] + array.append(flag) else: - j = next[j] - res = [] - i = 0 - j = 0 - while i < n and j < m: - if j == -1 or s[i] == t[j]: - i += 1 - j += 1 - if j == m: - res.append(i - j) - j = next[j] - else: - j = next[j] - return res \ No newline at end of file + pass + licenseKey = '-'.join(array) + + return licenseKey + +if __name__ == '__main__': + emailInput = input('请输入Email:') + + licenseKey = generateLicense(emailInput) + listen = '{\n "email" : "' +str(emailInput) + '",\n "license_key" : "' + format(licenseKey) + '"\n}' + + print(listen) diff --git a/src/bin/test.rs b/src/bin/test.rs index 34a7c8b..d2ebf91 100644 --- a/src/bin/test.rs +++ b/src/bin/test.rs @@ -1,37 +1,10 @@ +// Returns a function that adds `y` to its input +fn make_adder_function(y: i32) -> impl Fn(i32) -> i32 { + let closure = move |x: i32| { x + y }; + closure +} + fn main() { - let mut buf = String::new(); - std::io::stdin().read_line(&mut buf).ok(); - let t: usize = buf.trim().parse::().unwrap(); - let mut curr = vec![0;1000]; - let mut tmp = vec![0;1000]; - for _ in 0..t { - buf.clear(); - std::io::stdin().read_line(&mut buf).ok(); - let nxz: Vec = buf.trim().split(' ').map(|x|x.parse::().unwrap()).collect::>(); - let (n, x, z) = (nxz[0], nxz[1], nxz[2]); - buf.clear(); - std::io::stdin().read_line(&mut buf).ok(); - let a: Vec = buf.trim().split(' ').map(|x|x.parse::().unwrap()).collect::>(); - curr.fill(usize::MAX); - curr[z%x] = z; - let mut res = usize::MAX; - for &i in &a { - for j in 0..x { - tmp[j] = curr[j]; - } - for j in 0..x { - if tmp[j] != usize::MAX { - curr[(j + i) % x] = curr[(j + i) % x].min(tmp[j] + i); - if (tmp[j] + i) % x == 0 { - res = res.min(curr[0] / x); - } - } - } - } - if res != usize::MAX { - println!("{res}"); - } else { - println!("-1"); - } - } + let plus_one = make_adder_function(1); + assert_eq!(plus_one(2), 3); } \ No newline at end of file diff --git a/src/bin/test.s b/src/bin/test.s new file mode 100644 index 0000000..6132893 --- /dev/null +++ b/src/bin/test.s @@ -0,0 +1,116 @@ + .file "test.cc" + .text + .p2align 4 + .globl _Z5solvePiiS_i + .type _Z5solvePiiS_i, @function +_Z5solvePiiS_i: +.LFB0: + .cfi_startproc + endbr64 + pushq %r14 + .cfi_def_cfa_offset 16 + .cfi_offset 14, -16 + pushq %rbx + .cfi_def_cfa_offset 24 + .cfi_offset 3, -24 + cmpl %esi, %ecx + jge .L10 + movl %esi, %r10d + movq %rdx, %r11 + movl %ecx, %r8d + xorl %r9d, %r9d + subl %ecx, %r10d + xorl %ebx, %ebx + .p2align 4,,10 + .p2align 3 +.L3: + movq %r11, %rdx + movl %r9d, %eax + testl %ecx, %ecx + jg .L8 + jmp .L14 + .p2align 4,,10 + .p2align 3 +.L4: + testl %esi, %esi + jne .L7 + movslq %eax, %rsi + movl (%rdi,%rsi,4), %r14d + cmpl %r14d, 4(%rdi,%rsi,4) + jne .L5 +.L6: + addl $1, %eax + addq $4, %rdx + cmpl %eax, %r8d + je .L14 +.L8: + movl (%rdx), %esi + cmpl $1, %esi + jne .L4 + movslq %eax, %rsi + movl (%rdi,%rsi,4), %r14d + cmpl %r14d, 4(%rdi,%rsi,4) + jg .L6 +.L5: + addl $1, %r9d + addl $1, %r8d + cmpl %r9d, %r10d + jne .L3 +.L1: + movl %ebx, %eax + popq %rbx + .cfi_remember_state + .cfi_def_cfa_offset 16 + popq %r14 + .cfi_def_cfa_offset 8 + ret + .p2align 4,,10 + .p2align 3 +.L7: + .cfi_restore_state + cmpl $-1, %esi + jne .L6 + movslq %eax, %rsi + movl (%rdi,%rsi,4), %r14d + cmpl %r14d, 4(%rdi,%rsi,4) + jge .L5 + addl $1, %eax + addq $4, %rdx + cmpl %eax, %r8d + jne .L8 +.L14: + addl $1, %r9d + addl $1, %ebx + addl $1, %r8d + cmpl %r9d, %r10d + jne .L3 + jmp .L1 +.L10: + xorl %ebx, %ebx + movl %ebx, %eax + popq %rbx + .cfi_def_cfa_offset 16 + popq %r14 + .cfi_def_cfa_offset 8 + ret + .cfi_endproc +.LFE0: + .size _Z5solvePiiS_i, .-_Z5solvePiiS_i + .ident "GCC: (Ubuntu 13.2.0-4ubuntu3) 13.2.0" + .section .note.GNU-stack,"",@progbits + .section .note.gnu.property,"a" + .align 8 + .long 1f - 0f + .long 4f - 1f + .long 5 +0: + .string "GNU" +1: + .align 8 + .long 0xc0000002 + .long 3f - 2f +2: + .long 0x3 +3: + .align 8 +4: diff --git a/src/bin/test.ts b/src/bin/test.ts new file mode 100644 index 0000000..8871698 --- /dev/null +++ b/src/bin/test.ts @@ -0,0 +1,17 @@ +interface T { + name: string, + age: number; + gender: boolean +} + +const a : T = {name: 'Ariel', age: 19, gender: false}; +const arr: Readonly> = [1, 2, 3]; +console.log(typeof(a)); + +type optional = {a, b?}; +function test(t: optional) { + const {a, b} = t; + console.log(b); +} + +test({a: 'c'}); \ No newline at end of file diff --git a/src/bin/test1.cc b/src/bin/test1.cc index 9439c51..b920014 100644 --- a/src/bin/test1.cc +++ b/src/bin/test1.cc @@ -1,40 +1,246 @@ -#include +#pragma GCC optimize("Ofast") +///////////////////////////////////////////////////////// +/** + * Useful Macros + * by subcrip + * (requires C++17) + */ -int main() { - int n; - scanf("%d", &n); - printf("%d\n", n - 1); - fflush(stdout); - for (int i = 0; i < n - 1; ++i) { - printf("%d ", n - 1 - i); - for (int j = i + 1; j <= n - 1; ++j) { - printf("%d", j); - if (j == n - 1) printf("\n"), fflush(stdout); - else printf(" "); - } +#include +#include +using namespace std; +using namespace __gnu_cxx; +using namespace __gnu_pbds; +/* 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) decltype(container)::value_type + +/* type aliases */ +using ll = int64_t; +using ull = uint64_t; +using pii = pair; +using pil = pair; +using pli = pair; +using pll = pair; + +/* constants */ +constexpr int INF = 0x3f3f3f3f; +constexpr ull MDL = 1e9 + 7; +constexpr ull PRIME = 998'244'353; +constexpr ll MDL1 = 825; +constexpr ll MDL2 = PRIME; + +/* 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; } - char* s = new char[n - 1]; - scanf("%s", s); - for (int i = 0; i < n - 1; ++i) { - if (i == n - 2) { - if (s[i] == '1') { - delete[] s; - printf("%d\n", i + 1); - fflush(stdout); - return 0; - } - } else { - if (s[i] == '1' && s[i+1] == '0') { - delete[] s; - printf("%d\n", i + 1); - fflush(stdout); - return 0; - } - } + return hash1; + } +}; + +/* build data structures */ +#define unordered_counter(from, to) \ + __AS_PROCEDURE(unordered_map<__as_typeof(from), size_t, safe_hash> to; \ + for (auto &&x \ + : from)++ to[x];) +#define counter(from, to, cmp) \ + __AS_PROCEDURE(map<__as_typeof(from), size_t, cmp> to; \ + for (auto &&x \ + : from)++ to[x];) +#define pa(a) \ + __AS_PROCEDURE(__typeof(a) pa; pa.push_back({}); \ + for (auto &&x \ + : a) pa.push_back(pa.back() + x);) +#define sa(a) \ + __AS_PROCEDURE(__typeof(a) sa(a.size() + 1); { \ + int n = a.size(); \ + for (int i = n - 1; i >= 0; --i) \ + sa[i] = sa[i + 1] + a[i]; \ + };) +#define adj(ch, n) __AS_PROCEDURE(vector> ch((n) + 1);) +#define edge(ch, u, v) __AS_PROCEDURE(ch[u].push_back(v), ch[v].push_back(u);) +#define Edge(ch, u, v) __AS_PROCEDURE(ch[u].push_back(v);) + +/* io */ +#define untie __AS_PROCEDURE(ios_base::sync_with_stdio(0), cin.tie(NULL)) +template void __read(T &x) { cin >> x; } +template void __read(T &x, U &...args) { + cin >> x; + __read(args...); +} +#define read(type, ...) __AS_PROCEDURE(type __VA_ARGS__; __read(__VA_ARGS__);) +#define readvec(type, a, n) \ + __AS_PROCEDURE(vector a(n); for (int i = 0; i < (n); ++i) cin >> a[i];) +#define putvec(a) \ + __AS_PROCEDURE(for (auto &&x : a) cout << x << ' '; cout << endl;) +#define debug(x) __AS_PROCEDURE(cerr << #x " = " << (x) << endl;) +#define debugvec(a) \ + __AS_PROCEDURE(cerr << #a " = "; for (auto &&x \ + : a) cerr \ + << x << ' '; \ + cerr << endl;) +template ostream &operator<<(ostream &out, vector vec) { + for (auto &&i : vec) + out << i << ' '; + return out; +} + +/* pops */ +#define poptop(q, ...) __AS_PROCEDURE(auto [__VA_ARGS__] = q.top(); q.pop();) +#define popback(q, ...) \ + __AS_PROCEDURE(auto [__VA_ARGS__] = q.back(); q.pop_back();) +#define popfront(q, ...) \ + __AS_PROCEDURE(auto [__VA_ARGS__] = q.front(); q.pop_front();) + +/* math */ +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); +} + +/* 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}; } - delete[] s; - printf("%d\n", n); - fflush(stdout); - return 0; -} \ No newline at end of file + } + return z; +} +vector kmp(string s, string t) { // find all t in s + string cur = t + '#' + s; + int sz1 = s.size(), sz2 = t.size(); + vector v; + vector lps = calc_next(cur); + for (int i = sz2 + 1; i <= sz1 + sz2; i++) { + if (lps[i] == sz2) + v.push_back(i - 2 * sz2); + } + return v; +} +int period(string s) { // find the length of shortest recurring period + int n = s.length(); + auto z = calc_z(s); + for (int i = 1; i <= n / 2; ++i) { + if (n % i == 0 && z[i] == n - i) { + return i; + } + } + return n; +} +///////////////////////////////////////////////////////// + +int main() { cout << inverse(31, 998244353); } diff --git a/src/bin/testgen.cc b/src/bin/testgen.cc new file mode 100644 index 0000000..d7bad66 --- /dev/null +++ b/src/bin/testgen.cc @@ -0,0 +1,63 @@ +#include +using namespace std; + +bool isprime(int x) { + int sq = sqrt(x); + for (int i = 2; i <= sq; ++i) { + if (x % i == 0) { + return 0; + } + } + return 1; +} + +class Solution { +public: + long long countPaths(int n, vector>& edges) { + using ll = int64_t; + using pii = pair; + ll res = 0; + vector dp(n + 1); + unordered_set prime_table; + for (int i = 2; i <= n; ++i) { + if (isprime(i)) prime_table.insert(i); + } + auto dfs = [&] (auto dfs, int v, int pa) -> void { + ll cs = 0, cn = 0; + cerr << "v=" << v << endl;; + for (auto&& u : edges[v-1]) { + if (u == pa) continue; + dfs(dfs, u, v); + cs += dp[u].first; + cn += dp[u].second; + } + if (prime_table.count(v)) { + ll curr = 0; + for (auto&& u : edges[v-1]) { + if (u == pa) continue; + curr += dp[u].second * (cn - dp[u].second + 1); + } + curr /= 2; + res += curr; + dp[v] = {cn, 0}; + } else { + ll curr = 0; + for (auto&& u : edges[v-1]) { + if (u == pa) continue; + curr += dp[u].first * (cn - dp[u].second + 1); + } + curr /= 2; + res += curr; + dp[v] = {cs, cn}; + } + }; + dfs(dfs, 1, 0); + return res; + } +}; + +int main() { + int n = 5; + vector> edges = {{1, 2}, {1, 3}, {2, 4}, {2, 5}}; + cout << Solution().countPaths(n, edges) << endl; +} diff --git a/src/bin/testget.cc b/src/bin/testget.cc index a5b04f5..e7dec9d 100644 --- a/src/bin/testget.cc +++ b/src/bin/testget.cc @@ -139,7 +139,7 @@ vector kmp(string s, string t) { // find all t in s int period(string s) { // find the length of shortest recurring period int n = s.length(); auto z = calc_z(s); - for (int i = 1; i <= n / 2; ++i) { + for (int i = 1; i <= n / 2; ++i) if (n % i == 0 && z[i] == n - i) { return i; } @@ -149,9 +149,8 @@ int period(string s) { // find the length of shortest recurring period ///////////////////////////////////////////////////////// int main() { - constexpr int n = 3e5; - cout << 1 << ' ' << n << endl; - for (int i = 0; i < n; ++i) { - cout << 1 << ' '; + cout << 1000 << endl;; + for (int i = 0; i < 1000; ++i) { + } } \ No newline at end of file