From 97477a73dbf6139399ffa98ebdd8e7731554959f Mon Sep 17 00:00:00 2001 From: arielherself Date: Thu, 18 Jan 2024 12:40:12 +0800 Subject: [PATCH] backup --- src/bin/at-abc335a.cc | 0 src/bin/at-abs335a.py | 2 + src/bin/at-abs335b.py | 5 ++ src/bin/cf-1873g.cc | 160 ++++++++++++++++++++++++++++++++++ src/bin/cf-1873h.cc | 173 +++++++++++++++++++++++++++++++++++++ src/bin/cf-1875d.cc | 123 ++++++++++++++++++++++++++ src/bin/cf-1878d.cc | 143 ++++++++++++++++++++++++++++++ src/bin/cf-1879d.cc | 110 +++++++++++++++++++++++ src/bin/cf-1881f.cc | 99 +++++++++++++++++++++ src/bin/cf-1883e.cc | 40 +++++++++ src/bin/cf-1884c.cc | 43 +++++++++ src/bin/cf-1889b.cc | 29 +++++++ src/bin/cf-1901d.rs | 22 +++++ src/bin/cf-1903c.rs | 26 ++++++ src/bin/cf-1903d1.rs | 45 ++++++++++ src/bin/cf-1905a.cc | 12 +++ src/bin/cf-1905b.cc | 43 +++++++++ src/bin/cf-1905c.cc | 43 +++++++++ src/bin/cf-1905c.gen.cc | 13 +++ src/bin/cf-1907e.rs | 17 ++++ src/bin/cf-1909a.rs | 38 ++++++++ src/bin/cf-1909b.rs | 30 +++++++ src/bin/cf-1909c.rs | 33 +++++++ src/bin/cf-1913c.rs | 37 ++++++++ src/bin/cf-1914a.rs | 24 +++++ src/bin/cf-1914b.rs | 18 ++++ src/bin/cf-1914c.rs | 26 ++++++ src/bin/cf-1914d.rs | 30 +++++++ src/bin/cf-1915e.rs | 40 +++++++++ src/bin/cf-1915f.rs | 62 +++++++++++++ src/bin/cf-1916c.rs | 41 +++++++++ src/bin/cf-1917a.rs | 35 ++++++++ src/bin/cf-1917b.rs | 28 ++++++ src/bin/cf-1917c.rs | 85 ++++++++++++++++++ src/bin/cf-1917d.py | 12 +++ src/bin/cf-1917d.rs | 0 src/bin/cf-1919c.rs | 33 +++++++ src/bin/dancing-links.rs | 120 +++++++++++++++++++++++++ src/bin/lc-100163.rs | 63 ++++++++++++++ src/bin/lc-1691.rs | 38 ++++++++ src/bin/lc-1703.rs | 59 +++++++++++++ src/bin/lc-1723.rs | 64 ++++++++++++++ src/bin/lc-20.rs | 20 +++++ src/bin/lc-2305.rs | 47 ++++++++++ src/bin/lc-238.rs | 27 ++++++ src/bin/lc-2680.rs | 27 ++++++ src/bin/lc-2696.rs | 29 +++++++ src/bin/lc-2707.rs | 71 +++++++++++++++ src/bin/lc-2807.rs | 42 +++++++++ src/bin/lc-32.rs | 20 +++++ src/bin/lc-5.cc | 55 ++++++++++++ src/bin/lc-83.rs | 35 ++++++++ src/bin/lg-1048.rs | 65 ++++++++++++++ src/bin/lg-uva437.cc | 60 +++++++++++++ src/bin/lg-uva437.rs | 65 ++++++++++++++ src/bin/loj-101-1.rs | 80 +++++++++++++++++ src/bin/loj-101.rs | 74 ++++++++++++++++ src/bin/lzf-t2.rs | 0 src/bin/lzf-t3-tianping.cc | 86 ++++++++++++++++++ src/bin/lzf-t3-tianping.rs | 0 src/bin/number-dp.rs | 52 +++++++++++ src/bin/test.cc | 160 ++++++++++++++++++++++++++++++++++ src/bin/test.py | 29 +++++++ src/bin/test.rs | 37 ++++++++ src/bin/test_b.cc | 35 ++++++++ src/bin/uoj-78.cc | 56 ++++++++++++ 66 files changed, 3236 insertions(+) create mode 100644 src/bin/at-abc335a.cc create mode 100644 src/bin/at-abs335a.py create mode 100644 src/bin/at-abs335b.py create mode 100644 src/bin/cf-1873g.cc create mode 100644 src/bin/cf-1873h.cc create mode 100644 src/bin/cf-1875d.cc create mode 100644 src/bin/cf-1878d.cc create mode 100644 src/bin/cf-1879d.cc create mode 100644 src/bin/cf-1881f.cc create mode 100644 src/bin/cf-1883e.cc create mode 100644 src/bin/cf-1884c.cc create mode 100644 src/bin/cf-1889b.cc create mode 100644 src/bin/cf-1901d.rs create mode 100644 src/bin/cf-1903c.rs create mode 100644 src/bin/cf-1903d1.rs create mode 100644 src/bin/cf-1905a.cc create mode 100644 src/bin/cf-1905b.cc create mode 100644 src/bin/cf-1905c.cc create mode 100644 src/bin/cf-1905c.gen.cc create mode 100644 src/bin/cf-1907e.rs create mode 100644 src/bin/cf-1909a.rs create mode 100644 src/bin/cf-1909b.rs create mode 100644 src/bin/cf-1909c.rs create mode 100644 src/bin/cf-1913c.rs create mode 100644 src/bin/cf-1914a.rs create mode 100644 src/bin/cf-1914b.rs create mode 100644 src/bin/cf-1914c.rs create mode 100644 src/bin/cf-1914d.rs create mode 100644 src/bin/cf-1915e.rs create mode 100644 src/bin/cf-1915f.rs create mode 100644 src/bin/cf-1916c.rs create mode 100644 src/bin/cf-1917a.rs create mode 100644 src/bin/cf-1917b.rs create mode 100644 src/bin/cf-1917c.rs create mode 100644 src/bin/cf-1917d.py create mode 100644 src/bin/cf-1917d.rs create mode 100644 src/bin/cf-1919c.rs create mode 100644 src/bin/dancing-links.rs create mode 100644 src/bin/lc-100163.rs create mode 100644 src/bin/lc-1691.rs create mode 100644 src/bin/lc-1703.rs create mode 100644 src/bin/lc-1723.rs create mode 100644 src/bin/lc-20.rs create mode 100644 src/bin/lc-2305.rs create mode 100644 src/bin/lc-238.rs create mode 100644 src/bin/lc-2680.rs create mode 100644 src/bin/lc-2696.rs create mode 100644 src/bin/lc-2707.rs create mode 100644 src/bin/lc-2807.rs create mode 100644 src/bin/lc-32.rs create mode 100644 src/bin/lc-5.cc create mode 100644 src/bin/lc-83.rs create mode 100644 src/bin/lg-1048.rs create mode 100644 src/bin/lg-uva437.cc create mode 100644 src/bin/lg-uva437.rs create mode 100644 src/bin/loj-101-1.rs create mode 100644 src/bin/loj-101.rs create mode 100644 src/bin/lzf-t2.rs create mode 100644 src/bin/lzf-t3-tianping.cc create mode 100644 src/bin/lzf-t3-tianping.rs create mode 100644 src/bin/number-dp.rs create mode 100644 src/bin/test.cc create mode 100644 src/bin/test.py create mode 100644 src/bin/test.rs create mode 100644 src/bin/test_b.cc create mode 100644 src/bin/uoj-78.cc diff --git a/src/bin/at-abc335a.cc b/src/bin/at-abc335a.cc new file mode 100644 index 0000000..e69de29 diff --git a/src/bin/at-abs335a.py b/src/bin/at-abs335a.py new file mode 100644 index 0000000..ca24fe3 --- /dev/null +++ b/src/bin/at-abs335a.py @@ -0,0 +1,2 @@ +s = input() +print(s[:-1] + '4') \ No newline at end of file diff --git a/src/bin/at-abs335b.py b/src/bin/at-abs335b.py new file mode 100644 index 0000000..2de0223 --- /dev/null +++ b/src/bin/at-abs335b.py @@ -0,0 +1,5 @@ +n = int(input()) +for i in range(n + 1): + for j in range(n - i + 1): + for k in range(n - i - j + 1): + print(i, j, k) \ No newline at end of file diff --git a/src/bin/cf-1873g.cc b/src/bin/cf-1873g.cc new file mode 100644 index 0000000..9fc5945 --- /dev/null +++ b/src/bin/cf-1873g.cc @@ -0,0 +1,160 @@ +///////////////////////////////////////////////////////// +/** + * 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;) + +/* 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 kmp(string s, string t) { // find all t in s + int n = s.length(), m = t.length(); + vector next; next.push_back(-1); + int j = -1, i = 0; + while (i < m) + if (j == -1 || t[i] == t[j]) { + ++i, ++j; + if (i != m && t[i] == t[j]) next.push_back(next[j]); + else next.push_back(j); + } else j = next[j]; + vector res; + i = 0, j = 0; + while (i < n && j < m) + if (j == -1 || s[i] == t[j]) { + ++i, ++j; + if (j == m) res.push_back(i - j), j = next[j]; + } else j = next[j]; + return res; +} +///////////////////////////////////////////////////////// + +void solve() { + read(string, s); + s.push_back('B'); + int n = s.length(); + int curr = 0; + int sum = 0; + int mn = INT_MAX; + int no_b = 1; + int res = 0; + for (int i = 0; i < n; ++i) { + if (s[i] == 'A') { + ++curr; + } else { + if (s[i - 1] == 'B') { + res += sum; + sum = 0; + mn = INT_MAX; + no_b = 0; + } else { + sum += curr; + mn = min(mn, curr); + } + curr = 0; + } + } + if (sum) { + if (no_b) { + res += sum - mn; + } else { + res += sum; + } + } + cout << res << endl; +} + +int main() { + read(int, t); + while (t--) solve(); +} \ No newline at end of file diff --git a/src/bin/cf-1873h.cc b/src/bin/cf-1873h.cc new file mode 100644 index 0000000..f9c19a3 --- /dev/null +++ b/src/bin/cf-1873h.cc @@ -0,0 +1,173 @@ +///////////////////////////////////////////////////////// +/** + * 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))) + +/* 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;) + +/* 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 kmp(string s, string t) { // find all t in s + int n = s.length(), m = t.length(); + vector next; next.push_back(-1); + int j = -1, i = 0; + while (i < m) + if (j == -1 || t[i] == t[j]) { + ++i, ++j; + if (i != m && t[i] == t[j]) next.push_back(next[j]); + else next.push_back(j); + } else j = next[j]; + vector res; + i = 0, j = 0; + while (i < n && j < m) + if (j == -1 || s[i] == t[j]) { + ++i, ++j; + if (j == m) res.push_back(i - j), j = next[j]; + } else j = next[j]; + return res; +} +///////////////////////////////////////////////////////// + +void solve() { + read(int, n, a, b); + adj(ch, n); + for (int i = 0; i < n; ++i) { + read(int, u, v); + edge(ch, u, v); + } + vector vis(n + 1); + // bfs => distance from M to each vertex + deque> dq; + vector dis_m(n + 1, INF); + dq.emplace_back(a, 0); + while (dq.size()) { + popfront(dq, v, d); + continue_or(vis[v], 1); + dis_m[v] = d; + for (auto&& u : ch[v]) { + dq.emplace_back(u, d + 1); + } + } + fill(vis.begin(), vis.end(), 0); + // bfs => distance from V to each vertex + vector dis_v(n + 1, INF); + dq.emplace_back(b, 0); + while (dq.size()) { + popfront(dq, v, d); + continue_or(vis[v], 1); + dis_v[v] = d; + for (auto&& u : ch[v]) { + dq.emplace_back(u, d + 1); + } + } + // dfs => find qualified cycle + fill(vis.begin(), vis.end(), 0); + function dfs = [&] (int v, int pa) -> bool { + if_or(vis[v], 1) { + if (dis_m[v] > dis_v[v]) { + } + return dis_m[v] > dis_v[v]; + } + for (auto&& u : ch[v]) { + if (u != pa && dfs(u, v)) return 1; + } + return 0; + }; + if (dfs(b, 0)) { + cout << "YES\n"; + } else { + cout << "NO\n"; + } +} + +int main() { + read(int, t); + while(t--) solve(); +} \ No newline at end of file diff --git a/src/bin/cf-1875d.cc b/src/bin/cf-1875d.cc new file mode 100644 index 0000000..7be3a4c --- /dev/null +++ b/src/bin/cf-1875d.cc @@ -0,0 +1,123 @@ +#include +using namespace std; + +#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 + +using ll = int64_t; +using ull = uint64_t; +using pii = pair; +using pil = pair; +using pli = pair; +using pll = pair; + +constexpr ull MDL = 1e9 + 7; +constexpr ull PRIME = 998244353; +constexpr ull MDL1 = 825; +constexpr ull MDL2 = 87825; + +#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))) + +#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); + } +}; + +#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 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;) + +#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 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();) + +#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);) + +vector kmp(string s, string t) { // find all t in s + int n = s.length(), m = t.length(); + vector next; next.push_back(-1); + int j = -1, i = 0; + while (i < m) + if (j == -1 || t[i] == t[j]) { + ++i, ++j; + if (i != m && t[i] == t[j]) next.push_back(next[j]); + else next.push_back(j); + } else j = next[j]; + vector res; + i = 0, j = 0; + while (i < n && j < m) + if (j == -1 || s[i] == t[j]) { + ++i, ++j; + if (j == m) res.push_back(i - j), j = next[j]; + } else j = next[j]; + return res; +} + +void solve() { + read(int, n); + readvec(int, a, n); + counter(a, ct, greater<>); + unordered_map res; + int init = ct.begin()->first + 1; + int prev = init; + for (auto&& [i, _] : ct) { + if (i < prev - 1) { + init = i + 1; + } + prev = i; + } + for (auto&& [i, t] : ct) { + if (i > init) continue; + int mn = init * int(t - 1) + i; + for (auto&& [j, prev] : res) { + mn = min(mn, prev + j * int(t - 1) + i); + } + res[i] = mn; + // debug(i), debug(res[i]); + } + cout << res[0] << endl; +} + +int main() { + read(int, t); + while (t--) solve(); +} \ No newline at end of file diff --git a/src/bin/cf-1878d.cc b/src/bin/cf-1878d.cc new file mode 100644 index 0000000..0141070 --- /dev/null +++ b/src/bin/cf-1878d.cc @@ -0,0 +1,143 @@ +#include +using namespace std; + +#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__; __() + +using ll = int64_t; +using ull = uint64_t; +using pii = pair; +using pil = pair; +using pli = pair; +using pll = pair; + +constexpr ull MDL = 1e9 + 7; +constexpr ull PRIME = 998244353; +constexpr ull MDL1 = 825; +constexpr ull MDL2 = 87825; + +#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))) + +#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); + } +}; + +#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;) + +#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 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();) + +#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);) + +vector kmp(string s, string t) { // find all t in s + int n = s.length(), m = t.length(); + vector next; next.push_back(-1); + int j = -1, i = 0; + while (i < m) + if (j == -1 || t[i] == t[j]) { + ++i, ++j; + if (i != m && t[i] == t[j]) next.push_back(next[j]); + else next.push_back(j); + } else j = next[j]; + vector res; + i = 0, j = 0; + while (i < n && j < m) + if (j == -1 || s[i] == t[j]) { + ++i, ++j; + if (j == m) res.push_back(i - j), j = next[j]; + } else j = next[j]; + return res; +} + +void solve() { + read(int, n, k); + read(string, s); + readvec(int, l, k); + readvec(int, r, k); + read(int, q); + readvec(int, x, q); + for (int i = 0; i < k; ++i) { + --l[i], --r[i]; + } + for (int i = 0; i < q; ++i) { + --x[i]; + } + vector pos(n); + { + int curr = 0; + for (int i = 0; i < n; ++i) { + if (i > r[curr]) ++curr; + pos[i] = curr; + } + } + vector> mark(k, vector(n)); + for (auto&& i : x) { + int ipos = pos[i]; + int offset = min(i, l[ipos] + r[ipos] - i) - l[ipos]; + mark[ipos][offset] ^= 1; + } + for (int i = 0; i < k; ++i) { + int left = l[i], right = r[i]; + vector c(right - left + 1); + int mid = right - left + 2 >> 1; + int rev = 0; + for (int j = 0; j < mid; ++j) { + rev ^= mark[i][j]; + if (rev) { + debug(j), debug(right - j), debug(c.size()); + c[j] = s[right - j]; + c[right - left - j] = s[left + j]; + } else { + c[j] = s[left + j]; + c[right - left - j] = s[right - j]; + } + } + for (auto&& x : c) cout << x; + } + cout << endl; +} + +int main() { + read(int, t); + while (t--) solve(); +} \ No newline at end of file diff --git a/src/bin/cf-1879d.cc b/src/bin/cf-1879d.cc new file mode 100644 index 0000000..3858cd8 --- /dev/null +++ b/src/bin/cf-1879d.cc @@ -0,0 +1,110 @@ +#include +#include +using namespace std; + +#define __NARGS(...) std::tuple_size::value +#define __decompose_s(a, x) auto x = a; +#define __decompose_n(a, ...) auto [__VA_ARGS__] = a; + +using ll = int64_t; +using ull = uint64_t; +using pii = pair; +using pil = pair; +using pli = pair; +using pll = pair; + +constexpr ull MDL = 1e9 + 7; +constexpr ull PRIME = 998244353; +constexpr ull MDL1 = 825; +constexpr ull MDL2 = 87825; + +#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))) + +#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); + } +}; + +#define untie 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, ...) type __VA_ARGS__; __read(__VA_ARGS__); +#define readvec(type, a, n) vector a(n); for (int i = 0; i < (n); ++i) cin >> a[i]; +#define putvec(a) for (auto&& x : a) cout << x << ' '; cout << endl; +#define debug(x) cerr << #x" = " << x << endl; +#define debugvec(a) cerr << #a" = "; for (auto&& x : a) cerr << x << ' '; cerr << endl; + +#define pa(a) __typeof(a) pa; pa.push_back({}); for (auto&&x : a) pa.push_back(pa.back() + x); +#define sa(a) __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 poptop(q, ...) auto [__VA_ARGS__] = q.top(); q.pop(); +#define popback(q, ...) auto [__VA_ARGS__] = q.back(); q.pop_back(); +#define popfront(q, ...) auto [__VA_ARGS__] = q.front();q.pop_front(); + +#define adj(ch, n) vector> ch((n) + 1); +#define edge(ch, u, v) ch[u].push_back(v), ch[v].push_back(u); +#define Edge(ch, u, v) ch[u].push_back(v); + +vector kmp(string s, string t) { // find all t in s + int n = s.length(), m = t.length(); + vector next; next.push_back(-1); + int j = -1, i = 0; + while (i < m) + if (j == -1 || t[i] == t[j]) { + ++i, ++j; + if (i != m && t[i] == t[j]) next.push_back(next[j]); + else next.push_back(j); + } else j = next[j]; + vector res; + i = 0, j = 0; + while (i < n && j < m) + if (j == -1 || s[i] == t[j]) { + ++i, ++j; + if (j == m) res.push_back(i - j), j = next[j]; + } else j = next[j]; + return res; +} + +int main() { + read(int, n); + readvec(ull, a, n); + ull s1, s2, s3, s4, pa; + + s1 = s2 = 0, pa = 0; + for (int i = 0; i < n; ++i) { + pa ^= a[i]; + s1 = (s1 + (i + 1) * pa) % PRIME; + s2 = (s2 + pa) % PRIME; + } + s3 = s4 = 0, pa = 0; + for (int i = 0; i < n; ++i) { + s3 = (s3 + i * pa) % PRIME; + s4 = (s4 + pa) % PRIME; + pa ^= a[i]; + } + ull res = n * s1 - n * (n - 1) / 2 * s2 + n * s3 - n * (n + 1) / 2 * s4; + cout << (res % PRIME); +} \ No newline at end of file diff --git a/src/bin/cf-1881f.cc b/src/bin/cf-1881f.cc new file mode 100644 index 0000000..314b538 --- /dev/null +++ b/src/bin/cf-1881f.cc @@ -0,0 +1,99 @@ +#include +using namespace std; + +#define __NARGS(...) std::tuple_size::value +#define __decompose_s(a, x) auto x = a; +#define __decompose_n(a, ...) auto [__VA_ARGS__] = a; + +using ll = int64_t; +using ull = uint64_t; +using pii = pair; +using pil = pair; +using pli = pair; +using pll = pair; + +#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))) + +#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); + } +}; + +#define untie 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, ...) type __VA_ARGS__; __read(__VA_ARGS__); +#define readvec(type, a, n) vector a(n); for (int i = 0; i < (n); ++i) cin >> a[i]; +#define putvec(a) for (auto&& x : a) cout << x << ' '; cout << endl; +#define debug(x) cerr << #x" = " << x << endl; +#define debugvec(a) cerr << #a" = "; for (auto&& x : a) cerr << x << ' '; cerr << endl; + +#define pa(a) __typeof(a) pa; pa.push_back({}); for (auto&&x : a) pa.push_back(pa.back() + x); +#define sa(a) __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 poptop(q, ...) auto [__VA_ARGS__] = q.top(); q.pop(); +#define popback(q, ...) auto [__VA_ARGS__] = q.back(); q.pop_back(); +#define popfront(q, ...) auto [__VA_ARGS__] = q.front();q.pop_front(); + +#define adj(ch, n) vector> ch((n) + 1); +#define edge(ch, u, v) ch[u].push_back(v), ch[v].push_back(u); +#define Edge(ch, u, v) ch[u].push_back(v); + + +void solve() { + read(int, n, k); + vector marks(n + 1); + for (int i = 0; i < k; ++i) { + read(int, v); + marks[v] = 1; + } + adj(ch, n); + for (int i = 0; i < n - 1; ++i) { + read(int, u, v); + edge(ch, u, v); + } + function(int, int)> dfs = [&] (int v, int pa) { + int res = 0; + int max_w = marks[v] == 0 ? 0 : -1; + int max_r = marks[v] == 1 ? 0 : -1; + for (auto&& u : ch[v]) { + if (u == pa) continue; + auto [sub_ans, w, r] = dfs(u, v); + if (w != -1 && max_r != -1) res = min(res, w + 1 + max_r); + if (r != -1 && max_w != -1) res = min(res, r + 1 + max_w); + if (w != -1) max_w = max(max_w, w + 1); + if (r != -1) max_r = max(max_r, r + 1); + res = min(res, sub_ans); + } + return make_tuple(res, max_w, max_r); + }; + cout << get<0>(dfs(1, 0)) << endl; +} + +int main() { + read(int, t); + while (t--) solve(); +} \ No newline at end of file diff --git a/src/bin/cf-1883e.cc b/src/bin/cf-1883e.cc new file mode 100644 index 0000000..c7cdbfd --- /dev/null +++ b/src/bin/cf-1883e.cc @@ -0,0 +1,40 @@ +#include +using namespace std; +using ll = int64_t; +#define msd_power(x) (63LL - __builtin_clz(x)) +void solve() { + int n; cin >> n; + vector a(n); + for (int i = 0; i < n; ++i) cin >> a[i]; + ll res = 0; + ll last_power = 0; + for (int i = 1; i < n; ++i) { + if (msd_power(a[i]) >= msd_power(a[i-1]) + last_power) { + ll prev = a[i-1] << last_power; + if (prev > a[i]) { + last_power = 1; + } else { + last_power = 0; + } + } else { + ll diff = 0; + if (msd_power(a[i]) <= msd_power(a[i-1])) { + ll curr = a[i] << (msd_power(a[i-1]) - msd_power(a[i])); + if (curr < a[i-1]) diff = 1; + } else { + ll prev = a[i-1] << (msd_power(a[i]) - msd_power(a[i-1])); + if (prev > a[i]) diff = 1; + } + last_power = msd_power(a[i-1]) + last_power - msd_power(a[i]) + diff; + } +// cerr << last_power << ' '; + res += last_power; + } +// cerr << endl; + cout << res << endl; +} + +int main() { + int t; cin >> t; + while (t--) solve(); +} \ No newline at end of file diff --git a/src/bin/cf-1884c.cc b/src/bin/cf-1884c.cc new file mode 100644 index 0000000..a81f3f5 --- /dev/null +++ b/src/bin/cf-1884c.cc @@ -0,0 +1,43 @@ +#include +using namespace std; + +void solve() { + int n, m; cin >> n >> m; + vector> seg(n); + for (int i = 0; i < n; ++i) { + int l, r; cin >> l >> r; + seg[i] = {l, r}; + } + sort(seg.begin(), seg.end(), [](const pair& x, const pair& y) { + if (x.first == y.first) { + return x.second > y.second; + } + return x.first < y.first; + }); + int res = 0; + set> lefts; + set> rights; + int prev = 0; + for (int i = 0; i < n; ++i) { + auto&& [l, r] = seg[i]; + if (l == 1 || l == prev) continue; + prev = l; + auto rp = rights.begin(); + while (rights.size() && rp->first < l) { + lefts.erase({seg[rp->second].first, rp->second}); + rp = rights.erase(rp); + } + lefts.insert({l, i}); + rights.insert({r, i}); + res = max(res, int(lefts.size())); + cerr << lefts.size() << ' ' << res << endl; + } + lefts.clear(), rights.clear(), prev = 0; + + cout << res << endl; +} + +int main() { + int t; cin >> t; + while (t--) solve(); +} \ No newline at end of file diff --git a/src/bin/cf-1889b.cc b/src/bin/cf-1889b.cc new file mode 100644 index 0000000..441b6c1 --- /dev/null +++ b/src/bin/cf-1889b.cc @@ -0,0 +1,29 @@ +#include +using namespace std; +using ll = int64_t; + +void solve() { + int n, c; cin >> n >> c; + vector a(n); + for (int i = 0; i < n; ++i) cin >> a[i]; + vector idx(n - 1); + iota(idx.begin(), idx.end(), 1); + sort(idx.begin(), idx.end(), [&](int i, int j) { + if (a[i] == a[j]) return i < j; + return a[i] > a[j]; + }); + ll sum = a[0]; + for (auto&& i : idx) { + sum += a[i]; + if (sum < (i + 1) * c) { + cout << "No\n"; + return; + } + } + cout << "Yes\n"; +} + +int main() { + int t; cin >> t; + while (t--) solve(); +} \ No newline at end of file diff --git a/src/bin/cf-1901d.rs b/src/bin/cf-1901d.rs new file mode 100644 index 0000000..4937e79 --- /dev/null +++ b/src/bin/cf-1901d.rs @@ -0,0 +1,22 @@ +fn main() { + let mut buf = String::new(); + std::io::stdin().read_line(&mut buf).ok(); + let n: usize = buf.trim().parse::().unwrap(); + buf.clear(); + std::io::stdin().read_line(&mut buf).ok(); + let a: Vec = buf.trim().split(' ').map(|x|x.parse::().unwrap()).collect::>(); + let mut pa = vec![0;n+1]; + let mut sa = vec![0;n+1]; + pa[0] = 0 - n as i64 - 1; + for i in 1..=n { + pa[i] = pa[i-1].max(a[i-1] - i as i64 - 1); + } + for i in (0..n).rev() { + sa[i] = sa[i+1].max(a[i] + i as i64); + } + let mut res = i64::MAX; + for i in 0..n { + res = res.min(a[i].max((pa[i] + n as i64 + 1).max(sa[i+1]))); + } + println!("{res}"); +} \ No newline at end of file diff --git a/src/bin/cf-1903c.rs b/src/bin/cf-1903c.rs new file mode 100644 index 0000000..474aad8 --- /dev/null +++ b/src/bin/cf-1903c.rs @@ -0,0 +1,26 @@ +fn main() { + let mut buf = String::new(); + std::io::stdin().read_line(&mut buf).ok(); + let t: usize = buf.trim().parse::().unwrap(); + for _ in 0..t { + buf.clear(); + std::io::stdin().read_line(&mut buf).ok(); + buf.clear(); + std::io::stdin().read_line(&mut buf).ok(); + let a: Vec = buf.trim().split(' ').map(|x|x.parse::().unwrap()).collect::>(); + let mut s: i64 = a.iter().sum(); + let mut curr_seg = 0; + let mut curr_sum = 0; + let mut res = 0; + for x in a { + curr_sum += x; + s -= x; + if s >= 0 { + curr_seg += 1; + res += curr_seg * curr_sum; + curr_sum = 0; + } + } + println!("{res}"); + } +} \ No newline at end of file diff --git a/src/bin/cf-1903d1.rs b/src/bin/cf-1903d1.rs new file mode 100644 index 0000000..e443f27 --- /dev/null +++ b/src/bin/cf-1903d1.rs @@ -0,0 +1,45 @@ +fn main() { + let mut buf = String::new(); + std::io::stdin().read_line(&mut buf).ok(); + let nq: Vec = buf.trim().split(' ').map(|x|x.parse::().unwrap()).collect::>(); + let (n, q) = (nq[0], nq[1]); + buf.clear(); + std::io::stdin().read_line(&mut buf).ok(); + let a: Vec = buf.trim().split(' ').map(|x|x.parse::().unwrap()).collect::>(); + for _ in 0..q { + buf.clear(); + std::io::stdin().read_line(&mut buf).ok(); + let mut k: i64 = buf.trim().parse::().unwrap(); + let mut a = a.to_owned(); + let mut pow = 59; + let mut res = 0; + while pow >= 0 { + let target = 1 << pow; + let mut need = 0; + let mut f = true; + for i in 0..n { + let curr = 0.max(target - a[i]); + if curr > k - need { + f = false; + break; + } + need += 0.max(target - a[i]); + } + if f { + for i in 0..n { + a[i] = a[i].max(target) - target; + } + k -= need; + res += target; + } else { + for i in 0..n { + if a[i] >= target { + a[i] -= target; + } + } + } + pow -= 1; + } + println!("{res}"); + } +} \ No newline at end of file diff --git a/src/bin/cf-1905a.cc b/src/bin/cf-1905a.cc new file mode 100644 index 0000000..6992151 --- /dev/null +++ b/src/bin/cf-1905a.cc @@ -0,0 +1,12 @@ +#include +using namespace std; + +void solve() { + int n, m; cin >> n >> m; + cout << max(n, m) << endl; +} + +int main() { + int t; cin >> t; + while(t--) solve(); +} \ No newline at end of file diff --git a/src/bin/cf-1905b.cc b/src/bin/cf-1905b.cc new file mode 100644 index 0000000..4d1f144 --- /dev/null +++ b/src/bin/cf-1905b.cc @@ -0,0 +1,43 @@ +#include +using namespace std; + +constexpr int MAXN = 1e5 + 10; + +vector ch[MAXN]; + +void solve() { + int n; cin >> n; + fill(ch, ch + n + 1, vector()); + for (int i = 0; i < n - 1; ++i) { + int u, v; cin >> u >> v; + ch[u].push_back(v); + ch[v].push_back(u); + } + int cnt = 0; + function dfs = [&](int v, int pa) { + int f = 1; + for (auto&&u : ch[v]) { + if (u != pa) { + f = 0; + dfs(u, v); + } + } + if (f) ++cnt; + }; + if (n == 2) { + cout << 1 << endl; + } else { + for (int i = 1; i <= n; ++i) { + if (ch[i].size() > 1) { + dfs(i, 0); + break; + } + } + cout << (cnt + 1 >> 1) << endl; + } +} + +int main() { + int t; cin >> t; + while(t--) solve(); +} \ No newline at end of file diff --git a/src/bin/cf-1905c.cc b/src/bin/cf-1905c.cc new file mode 100644 index 0000000..50983f5 --- /dev/null +++ b/src/bin/cf-1905c.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-1905c.gen.cc b/src/bin/cf-1905c.gen.cc new file mode 100644 index 0000000..653830c --- /dev/null +++ b/src/bin/cf-1905c.gen.cc @@ -0,0 +1,13 @@ +#include +using namespace std; +using ull = uint64_t; +int main() { + ull l1 = 1, l2 = 1; + cout << "1, 1"; + for (int i = 2; i <= 1e5 + 1; ++i) { + ull t = l1 + l2; + cout << ", " << t; + l1 = l2; + l2 = t; + } +} \ No newline at end of file diff --git a/src/bin/cf-1907e.rs b/src/bin/cf-1907e.rs new file mode 100644 index 0000000..3052912 --- /dev/null +++ b/src/bin/cf-1907e.rs @@ -0,0 +1,17 @@ +fn main() { + let mut buf = String::new(); + std::io::stdin().read_line(&mut buf).ok(); + let t: usize = buf.trim().parse::().unwrap(); + for _ in 0..t { + buf.clear(); + std::io::stdin().read_line(&mut buf).ok(); + let mut n: i64 = buf.trim().parse::().unwrap(); + let mut res = 1; + while n != 0 { + let digit = n % 10; + n /= 10; + res *= (digit + 2) * (digit + 1) >> 1; + } + println!("{res}"); + } +} \ No newline at end of file diff --git a/src/bin/cf-1909a.rs b/src/bin/cf-1909a.rs new file mode 100644 index 0000000..80c03cc --- /dev/null +++ b/src/bin/cf-1909a.rs @@ -0,0 +1,38 @@ +fn judge(x: Vec>) -> bool { + let a = x.iter().fold(true, |b, p|{ + b && p[0] <= 0 + }); + let b = x.iter().fold(true, |b, p|{ + b && p[1] <= 0 + }); + let c = x.iter().fold(true, |b, p|{ + b && p[0] >= 0 + }); + let d = x.iter().fold(true, |b, p|{ + b && p[1] >= 0 + }); + a || b || c || d +} + +fn main() { + let mut buf = String::new(); + std::io::stdin().read_line(&mut buf).ok(); + let t: usize = buf.trim().parse::().unwrap(); + for _ in 0..t { + buf.clear(); + std::io::stdin().read_line(&mut buf).ok(); + let n: usize = buf.trim().parse::().unwrap(); + let mut co = Vec::with_capacity(n); + for _ in 0..n { + buf.clear(); + std::io::stdin().read_line(&mut buf).ok(); + let tmp: Vec = buf.trim().split(' ').map(|x|x.parse::().unwrap()).collect::>(); + co.push(tmp); + } + if judge(co) { + println!("YES"); + } else { + println!("NO"); + } + } +} \ No newline at end of file diff --git a/src/bin/cf-1909b.rs b/src/bin/cf-1909b.rs new file mode 100644 index 0000000..66ac621 --- /dev/null +++ b/src/bin/cf-1909b.rs @@ -0,0 +1,30 @@ +fn main() { + let mut buf = String::new(); + std::io::stdin().read_line(&mut buf).ok(); + let t: usize = buf.trim().parse::().unwrap(); + for _ in 0..t { + buf.clear(); + std::io::stdin().read_line(&mut buf).ok(); + buf.clear(); + std::io::stdin().read_line(&mut buf).ok(); + let mut a: Vec = buf.trim().split(' ').map(|x|x.parse::().unwrap()).collect::>(); + let mut mdl = 2u64; + loop { + let mut one = false; + let mut zero = false; + for x in &mut a { + if *x & 1 == 0 { + zero = true; + } else { + one = true; + } + *x >>= 1; + } + if zero && one { + println!("{mdl}"); + break; + } + mdl <<= 1; + } + } +} \ No newline at end of file diff --git a/src/bin/cf-1909c.rs b/src/bin/cf-1909c.rs new file mode 100644 index 0000000..ca54666 --- /dev/null +++ b/src/bin/cf-1909c.rs @@ -0,0 +1,33 @@ +use std::collections::BTreeSet; +use std::ops::Bound::*; +fn main() { + let mut buf = String::new(); + std::io::stdin().read_line(&mut buf).ok(); + let t: usize = buf.trim().parse::().unwrap(); + for _ in 0..t { + buf.clear(); + std::io::stdin().read_line(&mut buf).ok(); + buf.clear(); + std::io::stdin().read_line(&mut buf).ok(); + let mut l: Vec = buf.trim().split(' ').map(|x|x.parse::().unwrap()).collect::>(); + buf.clear(); + std::io::stdin().read_line(&mut buf).ok(); + let r: Vec = buf.trim().split(' ').map(|x|x.parse::().unwrap()).collect::>(); + buf.clear(); + std::io::stdin().read_line(&mut buf).ok(); + let mut rst = BTreeSet::new(); + r.into_iter().for_each(|x|{ rst.insert(x); }); + let mut c: Vec = buf.trim().split(' ').map(|x|x.parse::().unwrap()).collect::>(); + l.sort_unstable(); + let mut ranges = vec![]; + for &x in l.iter().rev() { + let cr = *rst.range((Excluded(x), Unbounded)).next().unwrap(); + rst.remove(&cr); + ranges.push(cr - x); + } + ranges.sort_unstable_by_key(|x|-x); + c.sort_unstable(); + let res = ranges.into_iter().zip(c.into_iter()).fold(0i64, |s, p|s + p.0 * p.1); + println!("{res}"); + } +} \ No newline at end of file diff --git a/src/bin/cf-1913c.rs b/src/bin/cf-1913c.rs new file mode 100644 index 0000000..4b22373 --- /dev/null +++ b/src/bin/cf-1913c.rs @@ -0,0 +1,37 @@ +fn main() { + let mut buf = String::new(); + std::io::stdin().read_line(&mut buf).ok(); + let m: usize = buf.trim().parse::().unwrap(); + let mut cnt = vec![0;30]; + for _ in 0..m { + buf.clear(); + std::io::stdin().read_line(&mut buf).ok(); + let query: Vec = buf.trim().split(' ').map(|x|x.parse::().unwrap()).collect::>(); + let (t, mut v) = (query[0], query[1]); + if t == 1 { + cnt[query[1] as usize] += 1; + } else { + let mut f = true; + let mut ccnt = 0; + let mut i = 0; + while v != 0 { + ccnt = (ccnt >> 1) + cnt[i]; + let curr_bit = v & 1; + v >>= 1; + if curr_bit == 1 { + if ccnt == 0 { + f = false; + break; + } + ccnt -= 1; + } + i += 1; + } + if f { + println!("YES"); + } else { + println!("NO"); + } + } + } +} \ No newline at end of file diff --git a/src/bin/cf-1914a.rs b/src/bin/cf-1914a.rs new file mode 100644 index 0000000..793f4f0 --- /dev/null +++ b/src/bin/cf-1914a.rs @@ -0,0 +1,24 @@ +use std::collections::HashMap; + +fn main() { + let mut buf = String::new(); + std::io::stdin().read_line(&mut buf).ok(); + let t: usize = buf.trim().parse::().unwrap(); + for _ in 0..t { + buf.clear(); + std::io::stdin().read_line(&mut buf).ok(); + buf.clear(); + std::io::stdin().read_line(&mut buf).ok(); + let t: String = buf.trim().parse::().unwrap(); + let a = t.into_bytes(); + let mut mp = HashMap::::new(); + let mut cnt = 0; + for x in a { + *mp.entry(x).or_default() += 1; + if matches!(mp.get(&x), Some(&t) if t + 64 == x as usize) { + cnt += 1; + } + } + println!("{cnt}"); + } +} \ No newline at end of file diff --git a/src/bin/cf-1914b.rs b/src/bin/cf-1914b.rs new file mode 100644 index 0000000..9677348 --- /dev/null +++ b/src/bin/cf-1914b.rs @@ -0,0 +1,18 @@ +fn main() { + let mut buf = String::new(); + std::io::stdin().read_line(&mut buf).ok(); + let t: usize = buf.trim().parse::().unwrap(); + for _ in 0..t { + buf.clear(); + std::io::stdin().read_line(&mut buf).ok(); + let t: Vec = buf.trim().split(' ').map(|x|x.parse::().unwrap()).collect::>(); + let (n, k) = (t[0], t[1]); + for i in 1..=k { + print!("{i} "); + } + for i in (k+1..=n).rev() { + print!("{i} "); + } + println!(); + } +} \ No newline at end of file diff --git a/src/bin/cf-1914c.rs b/src/bin/cf-1914c.rs new file mode 100644 index 0000000..b92ebd5 --- /dev/null +++ b/src/bin/cf-1914c.rs @@ -0,0 +1,26 @@ +fn main() { + let mut buf = String::new(); + std::io::stdin().read_line(&mut buf).ok(); + let t: usize = buf.trim().parse::().unwrap(); + for _ in 0..t { + buf.clear(); + std::io::stdin().read_line(&mut buf).ok(); + let nk: Vec = buf.trim().split(' ').map(|x|x.parse::().unwrap()).collect::>(); + let (n, k) = (nk[0], nk[1]); + buf.clear(); + std::io::stdin().read_line(&mut buf).ok(); + let a: Vec = buf.trim().split(' ').map(|x|x.parse::().unwrap()).collect::>(); + buf.clear(); + std::io::stdin().read_line(&mut buf).ok(); + let b: Vec = buf.trim().split(' ').map(|x|x.parse::().unwrap()).collect::>(); + let mut res = 0; + let mut a_sum = 0; + let mut b_max = 0; + for i in 0..n.min(k) { + a_sum += a[i]; + b_max = b_max.max(b[i]); + res = res.max(a_sum + b_max * (k - i - 1) as i64); + } + println!("{res}"); + } +} \ No newline at end of file diff --git a/src/bin/cf-1914d.rs b/src/bin/cf-1914d.rs new file mode 100644 index 0000000..c6d3178 --- /dev/null +++ b/src/bin/cf-1914d.rs @@ -0,0 +1,30 @@ +fn main() { + let mut buf = String::new(); + std::io::stdin().read_line(&mut buf).ok(); + let t: usize = buf.trim().parse::().unwrap(); + for _ in 0..t { + buf.clear(); + std::io::stdin().read_line(&mut buf).ok(); + let n: usize = buf.trim().parse::().unwrap(); + buf.clear(); + std::io::stdin().read_line(&mut buf).ok(); + let a: Vec = buf.trim().split(' ').map(|x|x.parse::().unwrap()).collect::>(); + buf.clear(); + std::io::stdin().read_line(&mut buf).ok(); + let b: Vec = buf.trim().split(' ').map(|x|x.parse::().unwrap()).collect::>(); + buf.clear(); + std::io::stdin().read_line(&mut buf).ok(); + let c: Vec = buf.trim().split(' ').map(|x|x.parse::().unwrap()).collect::>(); + let mut dp = vec![vec![i64::MIN;8];n+1]; + for i in 1..=n { + dp[i][0b001] = dp[i-1][0b001].max(c[i-1]); + dp[i][0b010] = dp[i-1][0b010].max(b[i-1]); + dp[i][0b100] = dp[i-1][0b100].max(a[i-1]); + dp[i][0b011] = dp[i-1][0b011].max(dp[i-1][0b001] + b[i-1]).max(dp[i-1][0b010] + c[i-1]); + dp[i][0b101] = dp[i-1][0b101].max(dp[i-1][0b001] + a[i-1]).max(dp[i-1][0b100] + c[i-1]); + dp[i][0b110] = dp[i-1][0b110].max(dp[i-1][0b010] + a[i-1]).max(dp[i-1][0b100] + b[i-1]); + dp[i][0b111] = dp[i-1][0b111].max(dp[i-1][0b110] + c[i-1]).max(dp[i-1][0b101] + b[i-1]).max(dp[i-1][0b011] + a[i-1]); + } + println!("{}", dp[n][0b111]); + } +} \ No newline at end of file diff --git a/src/bin/cf-1915e.rs b/src/bin/cf-1915e.rs new file mode 100644 index 0000000..6d2c227 --- /dev/null +++ b/src/bin/cf-1915e.rs @@ -0,0 +1,40 @@ +use std::collections::HashSet; + +fn main() { + let mut buf = String::new(); + std::io::stdin().read_line(&mut buf).ok(); + let t: usize = buf.trim().parse::().unwrap(); + for _ in 0..t { + buf.clear(); + std::io::stdin().read_line(&mut buf).ok(); + let n: usize = buf.trim().parse::().unwrap(); + buf.clear(); + std::io::stdin().read_line(&mut buf).ok(); + let a: Vec = buf.trim().split(' ').map(|x|x.parse::().unwrap()).collect::>(); + let mut x = vec![0;n+1]; + let mut y = vec![0;n+1]; + for i in 1..=n { + x[i] = x[i-1]; + y[i] = y[i-1]; + if i & 1 == 0 { + x[i] += a[i-1]; + } else { + y[i] += a[i-1]; + } + } + let mut oc = HashSet::new(); + let mut f = true; + for i in 0..=n { + if oc.contains(&(x[i] - y[i])) { + println!("YES"); + f = false; + break; + } else { + oc.insert(x[i] - y[i]); + } + } + if f { + println!("NO"); + } + } +} \ No newline at end of file diff --git a/src/bin/cf-1915f.rs b/src/bin/cf-1915f.rs new file mode 100644 index 0000000..6b3a18a --- /dev/null +++ b/src/bin/cf-1915f.rs @@ -0,0 +1,62 @@ +use std::collections::{BTreeSet, HashMap}; + +struct BIT(usize, Vec); + +impl BIT { + fn new(n: usize) -> Self { + Self(n, vec![0;n+1]) + } + fn query(&self, mut i: usize) -> i64 { + let lowbit = |x: i64|x&-x; + let mut res = 0; + while i > 0 { + res += self.1[i]; + i -= lowbit(i as i64) as usize; + } + res + } + fn insert(&mut self, mut i: usize) { + let lowbit = |x: i64| x & -x; + while i <= self.0 { + self.1[i] += 1; + i += lowbit(i as i64) as usize; + } + } +} + +fn main() { + let mut buf = String::new(); + std::io::stdin().read_line(&mut buf).ok(); + let t: usize = buf.trim().parse::().unwrap(); + for _ in 0..t { + buf.clear(); + std::io::stdin().read_line(&mut buf).ok(); + let n : usize = buf.trim().parse::().unwrap(); + let mut a = vec![]; + let mut numbers = BTreeSet::new(); + for _ in 0..n { + buf.clear(); + std::io::stdin().read_line(&mut buf).ok(); + let tmp: Vec = buf.trim().split(' ').map(|x|x.parse::().unwrap()).collect::>(); + a.push((tmp[0], tmp[1])); + numbers.insert(tmp[0]); + numbers.insert(tmp[1]); + } + let mut mp = HashMap::new(); + let mut tot = 0; + for p in numbers { + tot += 1; + mp.insert(p, tot); + } + a.sort_unstable(); + let mut st = BIT::new(tot); + let mut res = 0; + for x in a.iter().rev() { + let td = *mp.get(&x.1).unwrap(); + let cnt = st.query(td); + res += cnt; + st.insert(td); + } + println!("{res}"); + } +} \ No newline at end of file diff --git a/src/bin/cf-1916c.rs b/src/bin/cf-1916c.rs new file mode 100644 index 0000000..e44ad8a --- /dev/null +++ b/src/bin/cf-1916c.rs @@ -0,0 +1,41 @@ +fn main() { + let mut buf = String::new(); + std::io::stdin().read_line(&mut buf).ok(); + let t: usize = buf.trim().parse::().unwrap(); + for _ in 0..t { + buf.clear(); + std::io::stdin().read_line(&mut buf).ok(); + buf.clear(); + std::io::stdin().read_line(&mut buf).ok(); + let a: Vec = buf.trim().split(' ').map(|x|x.parse::().unwrap()).collect(); + let mut odd = 0; + let mut even = 0; + let mut sum = 0; + for x in a { + sum += x; + if x & 1 == 1 { + odd += 1; + } else { + even += 1; + } + if odd + even == 1 { + print!("{x} "); + } else if odd + even == 2 { + if odd == 1 && even == 1 { + print!("{} ", sum - 1); + } else { + print!("{} ", sum); + } + } else { + let mut res = sum; + res -= odd / 3; + if odd % 3 == 1 { + print!("{} ", res - 1); + } else { + print!("{} ", res); + } + } + } + println!(); + } +} \ No newline at end of file diff --git a/src/bin/cf-1917a.rs b/src/bin/cf-1917a.rs new file mode 100644 index 0000000..519bc77 --- /dev/null +++ b/src/bin/cf-1917a.rs @@ -0,0 +1,35 @@ +/** + * 如果有负数，那么就不需要变，因为现在已经是最小的了 + * 如果没负数，至多需要把随便一个数变成0即可。 + */ + + +fn main() { + let mut buf = String::new(); + std::io::stdin().read_line(&mut buf).ok(); + let t: usize = buf.trim().parse::().unwrap(); + for _ in 0..t { + buf.clear(); + std::io::stdin().read_line(&mut buf).ok(); + buf.clear(); + std::io::stdin().read_line(&mut buf).ok(); + let a: Vec = buf.trim().split(' ').map(|x|x.parse::().unwrap()).collect::>(); + let mut f = true; + let mut sgn = 1; + for x in a { + sgn *= x.signum(); + if x == 0 { + println!("0"); + f = false; + break; + } + } + if f { + if sgn == 1 { + println!("1\n1 0"); + } else { + println!("0"); + } + } + } +} \ No newline at end of file diff --git a/src/bin/cf-1917b.rs b/src/bin/cf-1917b.rs new file mode 100644 index 0000000..1ba2bdb --- /dev/null +++ b/src/bin/cf-1917b.rs @@ -0,0 +1,28 @@ +use std::collections::HashMap; + +/** + * dp[i] 表示进行i次删除首字母操作后得到的结果 + */ + +fn main() { + let mut buf = String::new(); + std::io::stdin().read_line(&mut buf).ok(); + let t: usize = buf.trim().parse::().unwrap(); + for _ in 0..t { + buf.clear(); + std::io::stdin().read_line(&mut buf).ok(); + let n: usize = buf.trim().parse::().unwrap(); + buf.clear(); + std::io::stdin().read_line(&mut buf).ok(); + let a = buf.trim().parse::().unwrap().into_bytes(); + let mut res = 0; + let mut mp = HashMap::new(); + let mut dp = vec![0;n+1]; + for i in (0..n).rev() { + dp[i] = mp.get(&a[i]).unwrap_or(&n) - i; + res += dp[i]; + mp.insert(a[i], i); + } + println!("{}", res); + } +} \ No newline at end of file diff --git a/src/bin/cf-1917c.rs b/src/bin/cf-1917c.rs new file mode 100644 index 0000000..f4c80d4 --- /dev/null +++ b/src/bin/cf-1917c.rs @@ -0,0 +1,85 @@ +fn solve(a: Vec, v: Vec, start_date: usize, limit: i64) -> (usize, i64) { + let n = a.len(); + let k = v.len(); + let mut delta_delta = vec![0i64;n+1]; + for i in 0..k { + delta_delta[0] += 1; + delta_delta[v[i]] -= 1; + } + let mut delta = vec![0;n]; + let mut t = 0; + for i in 0..n { + t += delta_delta[i]; + delta[i] = t; + } + let mut idx = n + 1; + let mut raw = 0; + for i in 0..n { + if a[i] <= i as i64 + 1 && idx == n + 1 { + idx = i; + } + if a[i] == i as i64 + 1 { + raw += 1; + } + } + if idx == n + 1 || delta[idx] == 0 { + return (1, raw); + } + let full = (idx as i64 + 1 - a[idx]) / delta[idx]; + let mut res = full * k as i64; + let mut rs = idx as i64 + 1 - (a[idx] + full * delta[idx]); + eprintln!("idx={idx}, full={full}, res={res}, rs={rs}"); + let mut cf = vec![0;n+1]; + for t in 0..k { + if rs == 0 { + if res + 1 > limit { + return if raw != 0 { + (1, raw) + } else { + (usize::MAX, 0) + }; + } + let mut cnt = 0; + let mut acc = 0; + for i in 0..n { + acc += cf[i]; + if a[i] + delta[i] * full + acc == i as i64 + 1 { + cnt += 1; + } + } + return (res as usize + 1, cnt); + } + res += 1; + cf[0] += 1; + cf[v[(start_date+t)%k]] -= 1; + if v[(start_date+t)%k] > idx { + rs -= 1; + } + } + panic!() +} + +fn main() { + let mut buf = String::new(); + std::io::stdin().read_line(&mut buf).ok(); + let t: usize = buf.trim().parse::().unwrap(); + for _ in 0..t { + buf.clear(); + std::io::stdin().read_line(&mut buf).ok(); + let tmp: Vec = buf.trim().split(' ').map(|x|x.parse::().unwrap()).collect::>(); + let d = tmp[2]; + buf.clear(); + std::io::stdin().read_line(&mut buf).ok(); + let a: Vec = buf.trim().split(' ').map(|x|x.parse::().unwrap()).collect::>(); + buf.clear(); + std::io::stdin().read_line(&mut buf).ok(); + let v: Vec = buf.trim().split(' ').map(|x|x.parse::().unwrap()).collect::>(); + let (next_date, init_score) = solve(a, v, 0, d as i64); + eprintln!("{next_date} {init_score}"); + if init_score == 0 || next_date > d { + println!("{}", (d - 1) / 2); + } else { + println!("{}", init_score + (d - next_date) as i64 / 2); + } + } +} \ No newline at end of file diff --git a/src/bin/cf-1917d.py b/src/bin/cf-1917d.py new file mode 100644 index 0000000..7a67540 --- /dev/null +++ b/src/bin/cf-1917d.py @@ -0,0 +1,12 @@ +from sortedcontainers import SortedList + +def solve(): + n, k = [int(x) for x in input().strip().split(' ')] + p = [int(x) for x in input().strip().split(' ')] + q = [int(x) for x in input().strip().split(' ')] + assert n == len(p) and k == len(q) + st = SortedList() + res = 0 + for i in range(n - 1, -1, -1): + res += st.bisect_left(p[i]) + res += \ No newline at end of file diff --git a/src/bin/cf-1917d.rs b/src/bin/cf-1917d.rs new file mode 100644 index 0000000..e69de29 diff --git a/src/bin/cf-1919c.rs b/src/bin/cf-1919c.rs new file mode 100644 index 0000000..13e151c --- /dev/null +++ b/src/bin/cf-1919c.rs @@ -0,0 +1,33 @@ +fn main() { + let mut buf = String::new(); + std::io::stdin().read_line(&mut buf).ok(); + let t: usize = buf.trim().parse::().unwrap(); + let f = t == 10000; + for k in 0..t { + buf.clear(); + std::io::stdin().read_line(&mut buf).ok(); + buf.clear(); + std::io::stdin().read_line(&mut buf).ok(); + let a: Vec = buf.trim().split(' ').map(|x|x.parse::().unwrap()).collect::>(); + let mut others = vec![]; + let mut last = i32::MAX; + for &x in &a { + if x > last { + others.push(x); + } else { + last = x; + } + } + let mut res = 0; + if !others.is_empty() { + for i in 0..others.len()-1 { + res += if others[i] < others[i+1] {1} else {0}; + } + } + if !f { + println!("{res}"); + } else if k == 470 { + println!("{:?}", &a); + } + } +} \ No newline at end of file diff --git a/src/bin/dancing-links.rs b/src/bin/dancing-links.rs new file mode 100644 index 0000000..9c6cba2 --- /dev/null +++ b/src/bin/dancing-links.rs @@ -0,0 +1,120 @@ +struct DancingLinks { + cnt: usize, + left: Vec, + right: Vec, + up: Vec, + down: Vec, + row_head: Vec, + col_head: Vec, + val: Vec, + row_info: Vec, + col_info: Vec, +} + +impl DancingLinks { + fn new(max_n: usize) -> Self { + let mut ins = Self { + cnt: 0, + left: vec![], + right: vec![], + up: vec![], + down: vec![], + row_head: vec![0;max_n], + col_head: vec![0;max_n], + val: vec![], + row_info: vec![], + col_info: vec![], + }; + ins.left.push(0); + ins.right.push(0); + ins.up.push(0); + ins.down.push(0); + ins.row_info.push(0); + ins.col_info.push(0); + ins + } + fn get_item(&self, idx: usize) -> T { + self.val[idx-1] + } + fn get(&self, i: usize, j: usize) -> Option { + let mut curr = self.row_head[i]; + while curr != 0 { + if self.col_info[curr] == j { + return Some(self.get_item(curr)); + } + curr = self.right[curr]; + } + curr = self.row_head[i]; + while curr != 0 { + if self.col_info[curr] == j { + return Some(self.get_item(curr)); + } + curr = self.left[curr]; + } + None + } + fn insert(&mut self, i: usize, j: usize, val: T) { + self.cnt += 1; + self.val.push(val); + self.left.push(0); + self.right.push(self.row_head[i]); + self.left[self.row_head[i]] = self.cnt; + self.row_head[i] = self.cnt; + self.up.push(0); + self.down.push(self.col_head[j]); + self.up[self.col_head[j]] = self.cnt; + self.col_head[j] = self.cnt; + self.row_info.push(i); + self.col_info.push(j); + } + fn remove_row(&mut self, i: usize) { + let mut curr = self.row_head[i]; + while curr != 0 { + self.down[self.up[curr]] = self.down[curr]; + self.up[self.down[curr]] = self.up[curr]; + curr = self.right[curr]; + } + self.row_head[i] = 0; + } + fn remove_col(&mut self, j: usize) { + let mut curr = self.col_head[j]; + while curr != 0 { + self.right[self.left[curr]] = self.right[curr]; + self.left[self.right[curr]] = self.left[curr]; + curr = self.right[curr]; + } + self.col_head[j] = 0; + } + fn dance_remove(&mut self, i: usize, plain: T) { + let mut curr = self.row_head[i]; + while curr != 0 { + if self.val[curr] != plain { + let mut curr = self.col_head[self.col_info[curr]]; + while curr != 0 { + if self.row_info[curr] != i && self.val[curr] != plain { + self.remove_row(self.row_info[curr]); + } + curr = self.down[curr]; + } + } + self.remove_col(self.col_info[curr]); + curr = self.right[curr]; + } + self.remove_row(i); + } +} + +fn main() { + let mut mat = DancingLinks::new(100); + mat.insert(0,0,10086); + mat.insert(0,1,234); + mat.insert(1,1,10010); + mat.insert(12,25,12345); + assert_eq!(mat.get(0,0), Some(10086)); + assert_eq!(mat.get(1,0), None); + assert_eq!(mat.get(12, 25), Some(12345)); + mat.dance_remove(0,0); + assert_eq!(mat.get(0,0), None); + assert_eq!(mat.get(1,0), None); + assert_eq!(mat.get(1,1), None); +} \ No newline at end of file diff --git a/src/bin/lc-100163.rs b/src/bin/lc-100163.rs new file mode 100644 index 0000000..2f208d5 --- /dev/null +++ b/src/bin/lc-100163.rs @@ -0,0 +1,63 @@ +struct Solution; + +struct Sol; + +impl Sol { + fn solve(mut x: i64, limit: i64, mut s: i64) -> i64 { + let mut pow = vec![1i64;17]; + for i in 1..17 { + pow[i] = pow[i-1] * 10; + } + let mut cnt = vec![0;17]; + let m = s; + let mut s_len = 0; + while s != 0 { + s_len += 1; + s /= 10; + } + let pass = m <= x % pow[s_len]; + let mut x_len = 0; + let mut x_digit = vec![]; + x_digit.push(0); + while x != 0 { + x_len += 1; + x_digit.push(x % 10); + x /= 10; + } + if s_len > x_len { + return 0; + } + for i in 1..=x_len { + if i <= s_len { + cnt[i] = 1; + } else { + cnt[i] = cnt[i-1] * (limit + 1); + } + } + let mut res = 0; + let mut f = true; + for i in (s_len+1..=x_len).rev() { + res += cnt[i-1] * (limit.min(x_digit[i] - 1) + 1); + if limit < x_digit[i] { + f = false; + break; + } + } + if f && pass { + res += 1; + } + res + } +} + +impl Solution { + pub fn number_of_powerful_int(start: i64, finish: i64, limit: i32, s: String) -> i64 { + let upper = Sol::solve(finish , limit as i64, s.parse().unwrap()); + let lower = Sol::solve(start - 1, limit as i64, s.parse().unwrap()); + upper - lower + } +} + +fn main() { + println!("{}", Solution::number_of_powerful_int(1, 1000000000000000, 4, "1".to_string())); +} \ No newline at end of file diff --git a/src/bin/lc-1691.rs b/src/bin/lc-1691.rs new file mode 100644 index 0000000..ba82fc0 --- /dev/null +++ b/src/bin/lc-1691.rs @@ -0,0 +1,38 @@ +struct Solution; + +impl Solution { + pub fn max_height(mut cuboids: Vec>) -> i32 { + for x in cuboids.iter_mut() { + x.sort_unstable_by_key(|x|-x); + } + cuboids.sort_unstable_by(|x, y| { + if x[0] == y[0] { + if x[1] == y[1] { + return y[2].cmp(&x[2]); + } + return y[1].cmp(&x[1]); + } + return y[0].cmp(&x[0]); + }); + let n = cuboids.len(); + let if_fit = |x: &Vec, y: &Vec| { + x[1] <= y[1] && x[2] <= y[2] + }; + let mut dp = vec![0;n]; + let mut res = 0; + for i in 0..n { + for j in 0..i { + if if_fit(&cuboids[i], &cuboids[j]) { + dp[i] = dp[i].max(dp[j]); + } + } + dp[i] += cuboids[i][0]; + res = res.max(dp[i]); + } + res + } +} + +fn main() { + +} \ No newline at end of file diff --git a/src/bin/lc-1703.rs b/src/bin/lc-1703.rs new file mode 100644 index 0000000..30d18bc --- /dev/null +++ b/src/bin/lc-1703.rs @@ -0,0 +1,59 @@ +// 中位数贪心，枚举结果中的中间那个1的位置。 +// 预处理一下前缀和和后缀和，这样在枚举的过程中就可以用二分查找，实现O(n\log n)复杂度。 +// nums = [1 0 0 1 0 1] +// pa = [1 1 1 2 2 3] +// pasum= [0 0 0 3 3 8] + + +struct Solution; + +#[inline] +fn sum(start: i32, length: i32) -> i64 { + (2 * start as i64 + length as i64 - 1) * length as i64 >> 1 +} + +impl Solution { + pub fn min_moves(nums: Vec, k: i32) -> i32 { + if k == 1 { + return 0; + } + let n = nums.len(); + let mut pa = vec![0;n+1]; + let mut pa_sum = vec![0;n+1]; + for i in 1..=n { + pa[i] = pa[i-1] + nums[i-1]; + if nums[i-1] == 1 { + pa_sum[i] = pa_sum[i-1] + i as i64 - 1; + } else { + pa_sum[i] = pa_sum[i-1]; + } + } + let part = k >> 1; + let mut res = i64::MAX; + for (i,&x) in nums.iter().enumerate() { + let i = i as i32; + if x == 0 { continue; } + let lsr = if k & 1 == 0 {i} else {i-1}; + let rsl = i + 1; + if lsr < 0 || rsl >= n as i32 {continue;} + if let Ok(li) = pa[0..=lsr as usize+1].binary_search_by_key(&-part, |t|t-pa[lsr as usize+1]) { + if let Ok(ri) = pa[rsl as usize+1..=n].binary_search_by_key(&part, |t|t-pa[rsl as usize]) { + let right_sum = pa_sum[ri+rsl as usize + 1] - pa_sum[rsl as usize] - sum(rsl, part); + let left_sum = sum(lsr - part + 1, part) - pa_sum[lsr as usize + 1] + pa_sum[li]; + res = res.min(left_sum + right_sum); + } + } + } + res as i32 + } +} + +fn main() { + let mut buf = String::new(); + std::io::stdin().read_line(&mut buf).ok(); + let nums: Vec = buf.trim().split(' ').map(|x|x.parse::().unwrap()).collect::>(); + buf.clear(); + std::io::stdin().read_line(&mut buf).ok(); + let k: i32 = buf.trim().parse::().unwrap(); + println!("{}", Solution::min_moves(nums, k)); +} \ No newline at end of file diff --git a/src/bin/lc-1723.rs b/src/bin/lc-1723.rs new file mode 100644 index 0000000..ff3194a --- /dev/null +++ b/src/bin/lc-1723.rs @@ -0,0 +1,64 @@ +struct Solution; + +struct Sol { + jobs: Vec, + k: i32, + n: usize, + tm: Vec, +} + +impl Sol { + fn init(&mut self, i: usize, curr_st: usize, curr_tm: i32) { + if i == self.n { + self.tm[curr_st] = curr_tm; + return; + } + self.init(i + 1, curr_st, curr_tm); + self.init(i + 1, curr_st | 1 << i, curr_tm + self.jobs[i]); + } + fn dfs(&mut self, i: usize, cnt: i32, curr_st: usize, curr_tm: i32, tm_res: i32) -> bool { + // eprintln!("{} {} {:#b} {}", i, cnt, curr_st, curr_tm); + if cnt == self.k { + return curr_st + 1 == 1 << self.n; + } + if i == self.tm.len() { + return false; + } + self.dfs(i + 1, cnt, curr_st, curr_tm, tm_res) || + if curr_st & i == 0 && self.tm[i] <= tm_res { + self.dfs(i + 1, cnt + 1, curr_st | i, curr_tm.max(self.tm[i]), tm_res) + } else {false} + } + fn solve(&mut self) -> i32 { + self.init(0, 0, 0); + let mut l = *self.jobs.iter().min().unwrap();; + let mut r = self.jobs.iter().sum::(); + while l < r { + let mid = l + r >> 1; + if self.dfs(0, 0, 0, 0, mid) { + r = mid; + } else { + l = mid + 1; + } + } + l + } +} + +impl Solution { + pub fn minimum_time_required(jobs: Vec, k: i32) -> i32 { + let n = jobs.len(); + let mut sol = Sol {jobs, k, n, tm: vec![0;1< = buf.trim().split(' ').map(|x|x.parse::().unwrap()).collect::>(); + buf.clear(); + std::io::stdin().read_line(&mut buf).ok(); + let k: i32 = buf.trim().parse::().unwrap(); + println!("{}", Solution::minimum_time_required(jobs, k)); +} \ No newline at end of file diff --git a/src/bin/lc-20.rs b/src/bin/lc-20.rs new file mode 100644 index 0000000..8e48734 --- /dev/null +++ b/src/bin/lc-20.rs @@ -0,0 +1,20 @@ +struct Solution; + +impl Solution { + pub fn is_valid(s: String) -> bool { + let s = s.into_bytes(); + let mut st = vec![]; + for x in s { + if matches!(st.last(), Some(y) if x - y == 2 || x - y == 1) { + st.pop(); + } else { + st.push(x); + } + } + st.is_empty() + } +} + +fn main() { + +} \ No newline at end of file diff --git a/src/bin/lc-2305.rs b/src/bin/lc-2305.rs new file mode 100644 index 0000000..369ad5d --- /dev/null +++ b/src/bin/lc-2305.rs @@ -0,0 +1,47 @@ +/// 状压dp +/// 状态c表示c的每一位1对应的饼干包都已经被分发 +/// dp[i][j] 表示分给前 i 个人，状态为 j 时每个人获得的最大饼干数量。 +/// 新的状态中，考虑是否有新的人出现。如果有新的人出现，那么枚举他分到了哪些饼干 +/// dp[i][j] = min(max(dp[i-1][j^t],cookies_sum[t]))，其中t|j==j +struct Solution; + +impl Solution { + pub fn distribute_cookies(cookies: Vec, k: i32) -> i32 { + let k = k as usize; + let n = cookies.len(); + let mut cookies_sum = vec![0;1<> i) & 1 == 1 { + cookies_sum[j] += cookies[i]; + } + } + } + dp[0][0] = 0; + for i in 1..=k { + dp[i][0] = 0; + for j in 1..1< = buf.trim().split(' ').map(|x|x.parse::().unwrap()).collect::>(); + buf.clear(); + std::io::stdin().read_line(&mut buf).ok(); + let k: i32 = buf.trim().parse::().unwrap(); + println!("{}", Solution::distribute_cookies(cookies, k)); +} \ No newline at end of file diff --git a/src/bin/lc-238.rs b/src/bin/lc-238.rs new file mode 100644 index 0000000..e6b9655 --- /dev/null +++ b/src/bin/lc-238.rs @@ -0,0 +1,27 @@ +struct Solution; + +impl Solution { + pub fn product_except_self(a: Vec) -> Vec { + let n = a.len(); + let mut pa = vec![1;n+1]; + for i in 1..=n { + pa[i] = pa[i-1] * a[i-1]; + } + let mut sa = vec![1;n+1]; + for i in (0..n).rev() { + sa[i] = sa[i+1] * a[i]; + } + let mut res = vec![]; + for i in 0..n { + res.push(sa[i+1]*pa[i]); + } + res + } +} + +fn main() { + let mut buf = String::new(); + std::io::stdin().read_line(&mut buf).ok(); + let a: Vec = buf.trim().split(' ').map(|x|x.parse::().unwrap()).collect::>(); + println!("{:?}", Solution::product_except_self(a)); +} \ No newline at end of file diff --git a/src/bin/lc-2680.rs b/src/bin/lc-2680.rs new file mode 100644 index 0000000..d936bcb --- /dev/null +++ b/src/bin/lc-2680.rs @@ -0,0 +1,27 @@ +struct Solution; + +impl Solution { + pub fn maximum_or(nums: Vec, k: i32) -> i64 { + let n = nums.len(); + let k = k as i64; + let mut pa = vec![0;n+1]; + for i in 1..=n { + pa[i] = pa[i-1] | nums[i-1] as i64; + } + let mut sa = vec![0;n+1]; + for i in (0..n).rev() { + sa[i] = sa[i+1] | nums[i] as i64; + } + (0..n).fold(0, |res, i|res.max((nums[i] as i64) < = buf.trim().split(' ').map(|x|x.parse::().unwrap()).collect::>(); + buf.clear(); + std::io::stdin().read_line(&mut buf).ok(); + let k: i32 = buf.trim().parse::().unwrap(); + println!("{}", Solution::maximum_or(nums, k)); +} \ No newline at end of file diff --git a/src/bin/lc-2696.rs b/src/bin/lc-2696.rs new file mode 100644 index 0000000..bbc888d --- /dev/null +++ b/src/bin/lc-2696.rs @@ -0,0 +1,29 @@ +struct Solution; + +impl Solution { + pub fn min_length(s: String) -> i32 { + let mut s = s.into_bytes(); + let mut n = s.len(); + let mut f = true; + while f && n != 0 { + f = false; + for i in 0..n-1 { + if s[i] == 65 && s[i+1] == 66 || s[i] == 67 && s[i+1] == 68 { + s.remove(i); + s.remove(i); + n -= 2; + f = true; + break; + } + } + } + n as i32 + } +} + +fn main() { + let mut buf = String::new(); + std::io::stdin().read_line(&mut buf).ok(); + let s: String = buf.trim().parse::().unwrap(); + println!("{}", Solution::min_length(s)); +} \ No newline at end of file diff --git a/src/bin/lc-2707.rs b/src/bin/lc-2707.rs new file mode 100644 index 0000000..57544b6 --- /dev/null +++ b/src/bin/lc-2707.rs @@ -0,0 +1,71 @@ +struct Solution; + +use std::collections::HashMap; + +struct Trie { + mark: bool, + nxt: HashMap>, +} + +impl Trie { + fn new() -> Self { + Self {mark: false, nxt: HashMap::new()} + } + fn insert(&mut self, s: Vec) { + let mut ptr = self; + for x in s.into_iter().rev() { + ptr = ptr.nxt.entry(x).or_insert(Box::new(Trie{mark: false, nxt: HashMap::new()})); + } + ptr.mark = true; + } + fn query(&self, s: &Vec) -> Vec { + let mut ptr = self; + let mut res = vec![]; + for (i, &x) in s.iter().rev().enumerate() { + if ptr.mark { + res.push(i); + } + if let Some(p) = ptr.nxt.get(&x) { + ptr = p.as_ref(); + } else { + return res; + } + } + if ptr.mark { + res.push(s.len()); + } + res + } +} + +impl Solution { + pub fn min_extra_char(s: String, dictionary: Vec) -> i32 { + let s = s.into_bytes(); + let n = s.len(); + let mut trie = Trie::new(); + for word in dictionary { + trie.insert(word.into_bytes()); + } + // eprintln!("{:?}", trie.query(&("leetcode".to_string().into_bytes()))); + // eprintln!("{:?}", trie.query(&("code".to_string().into_bytes()))); + let mut dp = vec![0;n+1]; + let mut query_string = vec![]; + for i in 1..=n { + query_string.push(s[i-1]); + let matchings = trie.query(&query_string); + dp[i] = (0..i).fold(usize::MAX, |c, j|c.min(i - j + dp[j])); + dp[i] = dp[i].min(matchings.into_iter().fold(usize::MAX, |c,j|c.min(dp[i-j]))); + } + dp[n] as i32 + } +} + +fn main() { + let mut buf = String::new(); + std::io::stdin().read_line(&mut buf).ok(); + let s: String = buf.trim().parse::().unwrap(); + buf.clear(); + std::io::stdin().read_line(&mut buf).ok(); + let dictionary: Vec = buf.trim().split(' ').map(|x|x.parse::().unwrap()).collect::>(); + println!("{}", Solution::min_extra_char(s, dictionary)); +} \ No newline at end of file diff --git a/src/bin/lc-2807.rs b/src/bin/lc-2807.rs new file mode 100644 index 0000000..5a88b6f --- /dev/null +++ b/src/bin/lc-2807.rs @@ -0,0 +1,42 @@ +// Definition for singly-linked list. +#[derive(PartialEq, Eq, Clone, Debug)] +pub struct ListNode { + pub val: i32, + pub next: Option> +} + +impl ListNode { + #[inline] + fn new(val: i32) -> Self { + ListNode { + next: None, + val + } + } +} +struct Solution; + + +impl Solution { + pub fn insert_greatest_common_divisors(mut head: Option>) -> Option> { + let gcd = |mut x: i32, mut y: i32| { + while y != 0 { + (x, y) = (y, x % y); + } + x + }; + let mut t = head.as_mut().unwrap(); + while t.next != None { + let next = t.next.take().unwrap(); + let mut mid = Box::new(ListNode::new(gcd(t.val, next.val))); + mid.next = Some(next); + t.next = Some(mid); + t = t.next.as_mut().unwrap().next.as_mut().unwrap(); + } + head + } +} + +fn main() { + +} \ No newline at end of file diff --git a/src/bin/lc-32.rs b/src/bin/lc-32.rs new file mode 100644 index 0000000..65df2db --- /dev/null +++ b/src/bin/lc-32.rs @@ -0,0 +1,20 @@ +struct Solution; + +impl Solution { + pub fn longest_valid_parentheses(s: String) -> i32 { + let mut st = vec![]; + let s = s.into_bytes(); + let mut res = 0; + for (i, &x) in s.iter().enumerate() { + if x == 41 && matches!(st.last(), Some(j) if s[j - 1] == 40) { + st.pop(); + res = res.max(i + 1 - st.last().unwrap_or(&0)); + } else { + st.push(i + 1); + } + } + res as i32 + } +} + +fn main() {} \ No newline at end of file diff --git a/src/bin/lc-5.cc b/src/bin/lc-5.cc new file mode 100644 index 0000000..0361d54 --- /dev/null +++ b/src/bin/lc-5.cc @@ -0,0 +1,55 @@ +#include +using namespace std; + +#define mod(x, y) (((x) % (y) + (y)) % (y)) +using ll = int64_t; +constexpr ll prime = 1e9 + 7; +constexpr ll b1 = 825; +constexpr ll b2 = 87825; + +class Solution { +public: + string longestPalindrome(string s) { + int n = s.length(); + vector pa1(n + 1), pa2(n + 1); + ll hash1 = 0, hash2 = 0; + for (int i = 1; i <= n; ++i) { + hash1 = (hash1 * b1 + s[i - 1]) % prime; + hash2 = (hash2 * b2 + s[i - 1]) % prime; + pa1[i] = hash1; + pa2[i] = hash2; + } + vector sa1(n + 1), sa2(n + 1); + hash1 = 0, hash2 = 0; + for (int i = n - 1; i >= 0; --i) { + hash1 = (hash1 * b1 + s[i]) % prime; + hash2 = (hash2 * b2 + s[i]) % prime; + sa1[i] = hash1; + sa2[i] = hash2; + } + vector p1(n + 1), p2(n + 1); + p1[0] = 1, p2[0] = 1; + for (int i = 1; i < n; ++i) { + p1[i] = (p1[i - 1] * b1) % prime; + p2[i] = (p2[i - 1] * b2) % prime; + } + function check_palindrome = [&] (int l, int r) { + int p = l + r >> 1, q = l + r + 1 >> 1; + return mod((pa1[p + 1] - pa1[l] * p1[p + 1 - l]), prime) == mod((sa1[q] - sa1[r + 1] * p1[r + 1 - q]), prime) && + mod((pa2[p + 1] - pa2[l] * p2[p + 1 - l]), prime) == mod((sa2[q] - sa2[r + 1] * p2[r + 1 - q]), prime); + }; + int l = 0; + pair res; + for (int i = 0; i < n; ++i) { + l = max(0, l - 1); + while (!check_palindrome(l, i)) ++l; + res = max(res, {i - l + 1, l}); + } + return s.substr(res.second, res.first); + } +}; + +int main() { + string s; cin >> s; + cout << Solution().longestPalindrome(s); +} \ No newline at end of file diff --git a/src/bin/lc-83.rs b/src/bin/lc-83.rs new file mode 100644 index 0000000..93aea9b --- /dev/null +++ b/src/bin/lc-83.rs @@ -0,0 +1,35 @@ +// Definition for singly-linked list. +#[derive(PartialEq, Eq, Clone, Debug)] +pub struct ListNode { + pub val: i32, + pub next: Option> +} + +impl ListNode { + #[inline] + fn new(val: i32) -> Self { + ListNode { + next: None, + val + } + } +} + +struct Solution; + +impl Solution { + pub fn delete_duplicates(mut head: Option>) -> Option> { + let mut c = head.as_mut(); + while let Some(curr) = c { + while let Some(next) = curr.next.as_mut() { + if next.val == curr.val { + curr.next = next.next.take(); + } else { + break; + } + } + c = curr.next.as_mut(); + } + head + } +} \ No newline at end of file diff --git a/src/bin/lg-1048.rs b/src/bin/lg-1048.rs new file mode 100644 index 0000000..cce71b5 --- /dev/null +++ b/src/bin/lg-1048.rs @@ -0,0 +1,65 @@ +struct Item { + time: i64, + value: i64, + cost: f64 +} + +impl Item { + fn new(time: i64, value: i64) -> Self { + Item { time, value, cost : value as f64 / time as f64 } + } +} + +struct Sol { + a: Vec, + tt: i64, + m: usize, + res: i64 +} + +impl Sol { + fn estimate(&self, mut curr_t: i64, next_idx: usize) -> f64 { + let mut res = 0.; + for i in next_idx..self.m { + if self.a[i].time + curr_t > self.tt { + return res + (self.tt - curr_t) as f64 * self.a[i].cost; + } + curr_t += self.a[i].time; + res += self.a[i].value as f64; + } + res + } + fn dfs(&mut self, curr_t: i64, idx: usize, curr_v: i64) { + self.res = self.res.max(curr_v); + if idx == self.m { + return; + } + if curr_t + self.a[idx].time <= self.tt { + self.dfs(curr_t + self.a[idx].time, idx + 1, curr_v + self.a[idx].value); + } + if curr_v + self.estimate(curr_t, idx + 1).ceil() as i64 > self.res { + self.dfs(curr_t, idx + 1, curr_v); + } + } + fn solve(&mut self) -> i64 { + self.dfs(0, 0, 0); + self.res + } +} + +fn main() { + let mut buf = String::new(); + std::io::stdin().read_line(&mut buf).ok(); + let tm: Vec = buf.trim().split(' ').map(|x|x.parse::().unwrap()).collect::>(); + let (tt, m) = (tm[0], tm[1]); + let mut a = Vec::::with_capacity(m as usize); + for _ in 0..m { + buf.clear(); + std::io::stdin().read_line(&mut buf).ok(); + let mut iter = buf.trim().split(' ').map(|x|x.parse::().unwrap()); + a.push(Item::new(iter.next().unwrap(), iter.next().unwrap())); + } + a.sort_unstable_by(|x,y|y.cost.total_cmp(&x.cost)); + let mut sol = Sol { a, tt, m: m as usize, res: 0 }; + println!("{}", sol.solve()); +} \ No newline at end of file diff --git a/src/bin/lg-uva437.cc b/src/bin/lg-uva437.cc new file mode 100644 index 0000000..190e8ad --- /dev/null +++ b/src/bin/lg-uva437.cc @@ -0,0 +1,60 @@ +#include +using namespace std; +using ll = int64_t; + +ll solve(vector> boxes) { + int m = boxes.size(); + int n = m * 3; + for (int i = 0; i < m; ++i) { + boxes.push_back({boxes[i][0], boxes[i][2], boxes[i][1]}); + boxes.push_back({boxes[i][1], boxes[i][2], boxes[i][0]}); + } + vector> ch(n); + vector ind(n, 0); + function&, const vector&)> is_fit = [](const vector& x, const vector& y) { + return x[0] < y[0] && x[1] < y[1] || x[0] < y[1] && x[1] < y[0]; + }; + for (int i = 0; i < n; ++i) { + for (int j = 0; j < n ;++j) { + if (is_fit(boxes[j], boxes[i])) { + ch[i].push_back(j); + ++ind[j]; + } + } + } + ll res = 0; + deque dq; + vector dp(n, 0); + for (int i = 0; i < n; ++i) { + if (!ind[i]) dq.push_back(i); + } + while (!dq.empty()) { + int i = dq.front(); + dq.pop_front(); + dp[i] += boxes[i][2]; + res = max(res, dp[i]); + for (auto&& j : ch[i]) { + dp[j] = max(dp[j], dp[i]); + --ind[j]; + if (!ind[j]) dq.push_back(j); + } + } + return res; +} + +int main() { + int i = 0; + while (1) { + ++i; + int n; + cin >> n; + if (!n) break; + vector> boxes(n); + for (int i = 0;i < n; ++i) { + for (int j = 0; j < 3; ++j) { + int t; cin >> t; boxes[i].push_back(t); + } + } + cout << "Case " << i << ": maximum height = " << solve(move(boxes)) << endl; + } +} \ No newline at end of file diff --git a/src/bin/lg-uva437.rs b/src/bin/lg-uva437.rs new file mode 100644 index 0000000..94160b8 --- /dev/null +++ b/src/bin/lg-uva437.rs @@ -0,0 +1,65 @@ +use std::collections::VecDeque; + +fn solve(mut boxes: Vec>) -> i64 { + let m = boxes.len(); + let n = m * 3; + for i in 0..m { + let curr = boxes[i].to_owned(); + boxes.push(vec![curr[0], curr[2], curr[1]]); + boxes.push(vec![curr[1], curr[2], curr[0]]); + } + let mut ch = vec![vec![];n]; + let mut ind = vec![0;n]; + let is_fit = |x: &Vec, y: &Vec| { + x[0] < y[0] && x[1] < y[1] || x[0] < y[1] && x[1] < y[0] + }; + for i in 0..n { + for j in 0..n { + if is_fit(&boxes[j], &boxes[i]) { + ch[i].push(j); + ind[j] += 1; + } + } + } + let mut res = 0; + let mut dq = VecDeque::new(); + let mut dp = vec![0;n]; + for i in 0..n { + if ind[i] == 0 { + dq.push_back(i); + } + } + while let Some(i) = dq.pop_front() { + dp[i] += boxes[i][2]; + res = res.max(dp[i]); + for &j in &ch[i] { + dp[j] = dp[j].max(dp[i]); + ind[j] -= 1; + if ind[j] == 0 { + dq.push_back(j); + } + } + } + res +} + +fn main() { + let mut i = 0; + loop { + i += 1; + let mut buf = String::new(); + std::io::stdin().read_line(&mut buf).ok(); + let n: usize = buf.trim().parse::().unwrap(); + if n == 0 { + break; + } + let mut boxes = Vec::with_capacity(n); + for _ in 0..n { + buf.clear(); + std::io::stdin().read_line(&mut buf).ok(); + let v: Vec = buf.trim().split(' ').map(|x|x.parse::().unwrap()).collect::>(); + boxes.push(v); + } + println!("Case {i}: maximum height = {}", solve(boxes)); + } +} \ No newline at end of file diff --git a/src/bin/loj-101-1.rs b/src/bin/loj-101-1.rs new file mode 100644 index 0000000..5bfa0bd --- /dev/null +++ b/src/bin/loj-101-1.rs @@ -0,0 +1,80 @@ +use std::collections::VecDeque; + +#[derive(Clone, Copy, Debug)] +struct Edge { + to: usize, + flow: i64, + cap: i64, + rev: usize, +} + +struct Net(Vec>, Vec, Vec); + +impl Net { + fn new(n: usize) -> Self { + Self(vec![vec![]; n+1], vec![0; n+1], vec![false; n+1]) + } + fn add_edge(&mut self, from: usize, to: usize, cap: i64) { + let to_edge = Edge {to, cap, flow: 0, rev: self.0[to].len()}; + self.0[from].push(to_edge); + let from_edge = Edge {to: from, flow: 0, cap: 0, rev: self.0[from].len() - 1}; + self.0[to].push(from_edge); + } + fn bfs(&mut self, s: usize, t: usize) -> bool { + self.1.fill(0); + let mut dq = VecDeque::new(); + self.1[s] = 1; + dq.push_back((s, 1)); + while let Some((v, l)) = dq.pop_front() { + for e in &self.0[v] { + if self.1[e.to] == 0 && e.cap > e.flow { + self.1[e.to] = l + 1; + dq.push_back((e.to, l + 1)); + } + } + } + self.1[t] != 0 + } + fn dfs(&mut self, s: usize, t: usize, cap: i64) -> i64 { + if self.2[s] { return 0; } + self.2[s] = true; + if s == t { return cap; } + let mut res = 0; + let n = self.0[s].len(); + for i in 0..n { + let e = self.0[s][i]; + if e.cap > e.flow && self.1[e.to] == self.1[s] + 1 { + let new = self.dfs(e.to, t, (cap - res).min(e.cap - e.flow)); + self.0[s][i].flow += new; + self.0[e.to][e.rev].flow -= new; + res += new; + if res == cap { return res; } + } + } + res + } + fn max_flow(&mut self, s: usize, t: usize) -> i64 { + let mut res = 0; + while self.bfs(s, t) { + self.2.fill(false); + res += self.dfs(s, t, i64::MAX); + } + res + } +} + +fn main() { + let mut buf = String::new(); + std::io::stdin().read_line(&mut buf).ok(); + let nmst: Vec = buf.trim().split(' ').map(|x|x.parse::().unwrap()).collect::>(); + let (n, m, s, t) = (nmst[0], nmst[1], nmst[2], nmst[3]); + let mut net = Net::new(n); + for _ in 0..m { + buf.clear(); + std::io::stdin().read_line(&mut buf).ok(); + let uvc: Vec = buf.trim().split(' ').map(|x|x.parse::().unwrap()).collect::>(); + let (u, v, c) = (uvc[0] as usize, uvc[1] as usize, uvc[2]); + net.add_edge(u, v, c); + } + println!("{}", net.max_flow(s, t)); +} \ No newline at end of file diff --git a/src/bin/loj-101.rs b/src/bin/loj-101.rs new file mode 100644 index 0000000..37734ac --- /dev/null +++ b/src/bin/loj-101.rs @@ -0,0 +1,74 @@ +use std::collections::VecDeque; + +#[derive(Clone, Debug)] +struct Edge { + to: usize, + cap: i64, + flow: i64, + rev: (usize, usize) +} + +struct Net(Vec>); + +impl Net { + fn new(n: usize) -> Self { + Self(vec![vec![];n+1]) + } + fn add_edge(&mut self, from: usize, to: usize, cap: i64) { + let to_edge = Edge {to, cap, flow: 0, rev: (to, self.0[to].len())}; + self.0[from].push(to_edge); + let from_edge = Edge {to: from, cap: 0, flow: 0, rev: (from, self.0[from].len() - 1)}; + self.0[to].push(from_edge); + } + fn max_flow(&mut self, s: usize, t: usize) -> i64 { + let n = self.0.len(); + let mut pa = vec![(0, 0);n+1]; + let mut res = 0; + loop { + let mut pf = vec![0;n+1]; + let mut dq = VecDeque::new(); + dq.push_back(s); + pf[s] = i64::MAX; + while let Some(v) = dq.pop_front() { + for (i, ne) in self.0[v].iter().enumerate() { + if pf[ne.to] == 0 && ne.cap > ne.flow { + pf[ne.to] = pf[v].min(ne.cap - ne.flow); + pa[ne.to] = (v, i); + dq.push_back(ne.to); + } + } + if pf[t] != 0 { + break; + } + } + if pf[t] == 0 { + break; + } + let mut p = t; + while pa[p].0 != 0 { + let (x, y) = pa[p]; + self.0[x][y].flow += pf[t]; + let (z, w) = self.0[x][y].rev; + self.0[z][w].flow -= pf[t]; + p = x; + } + res += pf[t]; + } + res + } +} + +fn main() { + let mut buf = String::new(); + std::io::stdin().read_line(&mut buf).ok(); + let tmp: Vec = buf.trim().split(' ').map(|x|x.parse::().unwrap()).collect::>(); + let (n, m, s, t) = (tmp[0], tmp[1], tmp[2], tmp[3]); + let mut net = Net::new(n); + for _ in 0..m { + buf.clear(); + std::io::stdin().read_line(&mut buf).ok(); + let tmp: Vec = buf.trim().split(' ').map(|x|x.parse::().unwrap()).collect::>(); + net.add_edge(tmp[0] as usize, tmp[1] as usize, tmp[2]); + } + println!("{}", net.max_flow(s, t)); +} \ No newline at end of file diff --git a/src/bin/lzf-t2.rs b/src/bin/lzf-t2.rs new file mode 100644 index 0000000..e69de29 diff --git a/src/bin/lzf-t3-tianping.cc b/src/bin/lzf-t3-tianping.cc new file mode 100644 index 0000000..83fbbb1 --- /dev/null +++ b/src/bin/lzf-t3-tianping.cc @@ -0,0 +1,86 @@ +#include +using namespace std; +using ll = int64_t; +constexpr int MAXN = 42; + +int n, m; +ll a[MAXN][MAXN]; +ll x[MAXN][MAXN]; + +int main() { + cin >> n >> m; + ll cnt1 = 0, sum1 = 0, cnt2 = 0, sum2 = 0; + for(int i = 0; i < n; ++i) { + for(int j = 0; j < m; ++j) { + cin >> a[i][j]; + if ((i + j) & 1) { + ++cnt1; + sum1 += a[i][j]; + } else { + ++cnt2; + sum2 += a[i][j]; + } + } + } + ll l = 0, r = LLONG_MAX / (MAXN * MAXN); + if ((n * m) & 1) { + l = (sum1 - sum2) / (cnt1 - cnt2); + r = l + 1; + } + ll res = LLONG_MAX; + int o = 0; + while(l < r) { + memset(x, 0, sizeof(x)); + ll mid = l + r >> 1; + cerr << mid << endl; + int f = 1; + ll cnt = 0; + for(int i = 0; i < n; ++i) { + for (int j = 0; j < m; ++j) { + ll available = mid - a[i][j] - x[i][j]; + if (available < 0) { + f = 0; + goto finish; + } + if (i + 1 == n) { + if (j + 1 == m) { + continue; + } + ll lo = min(available, mid - a[i][j+1] - x[i][j+1]); + x[i][j+1] += lo; + if (available != lo) { + f = 0; + goto finish; + } + } else { + if (j + 1 == m) { + ll lo = min(available, mid - a[i+1][j] - x[i+1][j]); + x[i+1][j] += lo; + if (available != lo) { + f = 0; + goto finish; + } + } else { + ll lo = min(available, mid - a[i][j+1] - x[i][j+1]); + x[i][j+1] += lo; + x[i+1][j] += available - lo; + } + } + cnt += 2 * available; + } + } + finish: + if(f) { + r = mid; + o = 1; + res = min(res, cnt); + } else { + l = mid + 1; + } + } + if (o) { + cout << res; + } else { + cout << -1; + } +} \ No newline at end of file diff --git a/src/bin/lzf-t3-tianping.rs b/src/bin/lzf-t3-tianping.rs new file mode 100644 index 0000000..e69de29 diff --git a/src/bin/number-dp.rs b/src/bin/number-dp.rs new file mode 100644 index 0000000..102342c --- /dev/null +++ b/src/bin/number-dp.rs @@ -0,0 +1,52 @@ +struct Sol { + dp: Vec, + pow: Vec, +} + +impl Sol { + fn solve(&self, mut x: usize) -> Vec { + let mut cnt = x; + let mut digit = vec![]; + let mut res = vec![0;10]; + let mut len = 0; + digit.push(0); + while x != 0 { + len += 1; + digit.push(x as usize % 10); + x /= 10; + } + for i in (1..=len).rev() { + cnt -= digit[i] * self.pow[i-1]; + res[digit[i]] += cnt + 1; + for b in 0..10 { + res[b] += self.dp[i-1] * digit[i]; + } + for j in 0..digit[i] { + res[j] += self.pow[i-1]; + } + res[0] -= self.pow[i-1]; + } + res + } +} + + +fn main() { + let mut buf = String::new(); + std::io::stdin().read_line(&mut buf).ok(); + let ab: Vec = buf.trim().split(' ').map(|x|x.parse::().unwrap()).collect::>(); + let a = ab[0]; + let b = ab[1]; + let mut dp = vec![0;13]; + let mut pow = vec![1;13]; + for i in 1..13 { + pow[i] = pow[i-1] * 10; + dp[i] = dp[i-1] * 10 + pow[i-1]; + } + let sol = Sol { dp, pow }; + let res_a_1 = sol.solve(a - 1); + let res_b = sol.solve(b); + for i in 0..10 { + print!("{} ", res_b[i] - res_a_1[i]); + } +} \ No newline at end of file diff --git a/src/bin/test.cc b/src/bin/test.cc new file mode 100644 index 0000000..55828d7 --- /dev/null +++ b/src/bin/test.cc @@ -0,0 +1,160 @@ +///////////////////////////////////////////////////////// +/** + * 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;) + +/* 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 main() { + read(string, s); + int n = s.length(); + string rev(s.rbegin(), s.rend()); + auto translate = [&] (int i) {return n - i - 1;}; + auto z = calc_z(s); + auto pi = calc_next(rev); + int res = 0; + for (int i = 1; i < n - 1; ++i) { + int suf = pi[translate(i)]; + if (suf > 0 && suf <= z[i]) { + res = max(res, suf); + } + } + if (res) { + cout << s.substr(0, res); + } else { + cout << "Just a legend"; + } +} \ No newline at end of file diff --git a/src/bin/test.py b/src/bin/test.py new file mode 100644 index 0000000..73e9b8a --- /dev/null +++ b/src/bin/test.py @@ -0,0 +1,29 @@ +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) + 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 diff --git a/src/bin/test.rs b/src/bin/test.rs new file mode 100644 index 0000000..34a7c8b --- /dev/null +++ b/src/bin/test.rs @@ -0,0 +1,37 @@ +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"); + } + } +} \ No newline at end of file diff --git a/src/bin/test_b.cc b/src/bin/test_b.cc new file mode 100644 index 0000000..a79424c --- /dev/null +++ b/src/bin/test_b.cc @@ -0,0 +1,35 @@ +#include +using namespace std; + +void solve() { + int n, k, x; cin >> n >> k >> x; + vector a(n); + for (int i = 0; i < n; ++i) cin >> a[i]; + sort(a.begin(), a.end(), greater<>()); + vector pa(n + 1); + int sum = 0; + for (int i = 1; i <= n; ++i) { + pa[i] = pa[i - 1] + a[i - 1]; + sum += a[i - 1]; + } + function get = [&](int idx) { + if (idx + x > n) { + return pa[n] - pa[idx]; + } else { + return pa[idx + x] - pa[idx]; + } + }; + int res = sum - 2 * get(0); + // cerr << "*" << sum << "*" << get(0) << "*" << res << endl; + for (int i = 1; i <= k; ++i) { + sum -= a[i-1]; + res = max(res, sum - 2 * get(i)); + // cerr << "*" << sum << "*" << get(i) << "*" << res << endl; + } + cout << res << endl; +} + +int main() { + int t; cin >> t; + while(t--) solve(); +} \ No newline at end of file diff --git a/src/bin/uoj-78.cc b/src/bin/uoj-78.cc new file mode 100644 index 0000000..0cf5f3c --- /dev/null +++ b/src/bin/uoj-78.cc @@ -0,0 +1,56 @@ +#include +using namespace std; + +int main() { + ios_base::sync_with_stdio(0), cin.tie(NULL); + int nl, nr, m; + cin >> nl >> nr >> m; + vector> left(nl+1); + vector> right(nr+1); + vector choice_left(nl+1); + vector choice_right(nr+1); + vector vis(nl+1); + while(m--) { + int v, u; + cin >> v >> u; + left[v].push_back(u); + right[u].push_back(v); + } + function dfs = [&](int v) -> bool { + if (vis[v]) return false; + vis[v] = true; + for (auto&& u : left[v]) { + if (choice_right[u]) { + int t = choice_right[u]; + if (dfs(t)) { + choice_left[v] = u; + choice_right[u] = v; + vis[v] = false; + return true; + } + } else { + choice_left[v] = u; + choice_right[u] = v; + vis[v] = false; + return true; + } + } + return false; + }; + for (int i = 1; i <= nl; ++i) { + if (!choice_left[i]) { + dfs(i); + } + } + vector res; + int cnt = 0; + for (int i = 1; i <= nl; ++i) { + if (choice_left[i]) { + ++cnt; + } + res.push_back(choice_left[i]); + } + cout << cnt << endl; + for (auto&& j : res) + cout << j << ' '; +} \ No newline at end of file