backup

src/bin/cf-1583e.cc

@@ -0,0 +1,333 @@
+#pragma GCC optimize("Ofast")
+/////////////////////////////////////////////////////////
+/**
+ * Useful Macros
+ *   by subcrip
+ * (requires C++17)
+ */
+
+#include<bits/stdc++.h>
+using namespace std;
+
+/* macro helpers */
+#define __NARGS(...) std::tuple_size<decltype(std::make_tuple(__VA_ARGS__))>::value
+#define __DECOMPOSE_S(a, x) auto x = a;
+#define __DECOMPOSE_N(a, ...) auto [__VA_ARGS__] = a;
+constexpr void __() {}
+#define __AS_PROCEDURE(...) __(); __VA_ARGS__; __()
+#define __as_typeof(container) decltype(container)::value_type
+
+/* type aliases */
+using ll = int64_t;
+using ull = uint64_t;
+using pii = pair<int, int>;
+using pil = pair<int, ll>;
+using pli = pair<ll, int>;
+using pll = pair<ll, ll>;
+
+/* constants */
+constexpr int INF = 0x3f3f3f3f;
+constexpr ll INFLL = 0x3f3f3f3f3f3f3f3fLL;
+constexpr ll MDL = 1e9 + 7;
+constexpr ll PRIME = 998'244'353;
+constexpr ll MDL1 = 8784491;
+constexpr ll MDL2 = PRIME;
+
+/* random */
+
+mt19937 rd(chrono::duration_cast<chrono::milliseconds>(chrono::system_clock::now().time_since_epoch()).count());
+
+/* bit-wise operations */
+#define lowbit(x) ((x) & -(x))
+#define popcount(x) (__builtin_popcountll(ll(x)))
+#define parity(x) (__builtin_parityll(ll(x)))
+#define msp(x) (63LL - __builtin_clzll(ll(x)))
+#define lsp(x) (__builtin_ctzll(ll(x)))
+
+/* arithmetic operations */
+#define mod(x, y) ((((x) % (y)) + (y)) % (y))
+
+/* fast pairs */
+#define upair ull
+#define umake(x, y) (ull(x) << 32 | (ull(y) & ((1ULL << 32) - 1)))
+#define u1(p) ((p) >> 32)
+#define u2(p) ((p) & ((1ULL << 32) - 1))
+#define ult std::less<upair>
+#define ugt std::greater<upair>
+
+#define ipair ull
+#define imake(x, y) (umake(x, y))
+#define i1(p) (int(u1(ll(p))))
+#define i2(p) (ll(u2(p) << 32) >> 32)
+struct ilt {
+    bool operator()(const ipair& a, const ipair& b) const {
+        if (i1(a) == i1(b)) return i2(a) < i2(b);
+        else return i1(a) < i1(b);
+    }
+};
+struct igt {
+    bool operator()(const ipair& a, const ipair& b) const {
+        if (i1(a) == i1(b)) return i2(a) > i2(b);
+        else return i1(a) > i1(b);
+    }
+};
+
+/* conditions */
+#define loop while (1)
+#define if_or(var, val) if (!(var == val)) var = val; else
+#define continue_or(var, val) __AS_PROCEDURE(if (var == val) continue; var = val;)
+#define break_or(var, val) __AS_PROCEDURE(if (var == val) break; var = val;)
+
+/* hash */
+struct safe_hash {
+    // https://codeforces.com/blog/entry/62393
+    static uint64_t splitmix64(uint64_t x) {
+        // http://xorshift.di.unimi.it/splitmix64.c
+        x += 0x9e3779b97f4a7c15;
+        x = (x ^ (x >> 30)) * 0xbf58476d1ce4e5b9;
+        x = (x ^ (x >> 27)) * 0x94d049bb133111eb;
+        return x ^ (x >> 31);
+    }
+
+    size_t operator()(uint64_t x) const {
+        static const uint64_t FIXED_RANDOM = chrono::steady_clock::now().time_since_epoch().count();
+        return splitmix64(x + FIXED_RANDOM);
+    }
+};
+
+struct pair_hash {
+    template <typename T, typename U>
+    size_t operator()(const pair<T, U>& a) const {
+        auto hash1 = safe_hash()(a.first);
+        auto hash2 = safe_hash()(a.second);
+        if (hash1 != hash2) {
+            return hash1 ^ hash2;
+        }
+        return hash1;
+    }
+};
+
+/* build data structures */
+#define unordered_counter(from, to) __AS_PROCEDURE(unordered_map<__as_typeof(from), size_t, safe_hash> to; for (auto&& x : from) ++to[x];)
+#define counter(from, to, cmp) __AS_PROCEDURE(map<__as_typeof(from), size_t, cmp> to; for (auto&& x : from) ++to[x];)
+#define pa(a) __AS_PROCEDURE(__typeof(a) pa; pa.push_back({}); for (auto&&x : a) pa.push_back(pa.back() + x);)
+#define sa(a) __AS_PROCEDURE(__typeof(a) sa(a.size() + 1); {int n = a.size(); for (int i = n - 1; i >= 0; --i) sa[i] = sa[i + 1] + a[i];};)
+#define adj(ch, n) __AS_PROCEDURE(vector<vector<int>> 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);)
+template <typename T, typename Iterator> pair<size_t, map<T, size_t>> discretize(Iterator __first, Iterator __last) {
+    set<T> st(__first, __last);
+    size_t N = 0;
+    map<T, size_t> mp;
+    for (auto&& x : st) mp[x] = ++N;
+    return {N, mp};
+}
+template <typename T, typename Iterator> pair<size_t, unordered_map<T, size_t, safe_hash>> unordered_discretize(Iterator __first, Iterator __last) {
+    set<T> st(__first, __last);
+    size_t N = 0;
+    unordered_map<T, size_t, safe_hash> mp;
+    for (auto&& x : st) mp[x] = ++N;
+    return {N, mp};
+}
+
+/* io */
+#define untie __AS_PROCEDURE(ios_base::sync_with_stdio(0), cin.tie(NULL))
+template<typename T> void __read(T& x) { cin >> x; }
+template<typename T, typename... U> void __read(T& x, U&... args) { cin >> x; __read(args...); }
+#define read(type, ...) __AS_PROCEDURE(type __VA_ARGS__; __read(__VA_ARGS__);)
+#define readvec(type, a, n) __AS_PROCEDURE(vector<type> a(n); for (int i = 0; i < (n); ++i) cin >> a[i];)
+#define putvec(a) __AS_PROCEDURE(for (auto&& x : a) cout << x << ' '; cout << endl;)
+#define debug(x) __AS_PROCEDURE(cerr << #x" = " << (x) << endl;)
+#define debugvec(a) __AS_PROCEDURE(cerr << #a" = "; for (auto&& x : a) cerr << x << ' '; cerr << endl;)
+template<typename T, typename U> ostream& operator<<(ostream& out, const pair<T, U>& p) {
+    out << "{" << p.first << ", " << p.second << "}";
+    return out;
+}
+template<typename Char, typename Traits, typename Tuple, std::size_t... Index>
+void print_tuple_impl(std::basic_ostream<Char, Traits>& os, const Tuple& t, std::index_sequence<Index...>) {
+    using swallow = int[]; // guaranties left to right order
+    (void)swallow { 0, (void(os << (Index == 0 ? "" : ", ") << std::get<Index>(t)), 0)... };
+}
+template<typename Char, typename Traits, typename... Args>
+decltype(auto) operator<<(std::basic_ostream<Char, Traits>& os, const std::tuple<Args...>& t) {
+    os << "{";
+    print_tuple_impl(os, t, std::index_sequence_for<Args...>{});
+    return os << "}";
+}
+template<typename T> ostream& operator<<(ostream& out, const vector<T>& vec) {
+    for (auto&& i : vec) out << i << ' ';
+    return out;
+}
+
+/* pops */
+#define poptop(q, ...) __AS_PROCEDURE(auto [__VA_ARGS__] = q.top(); q.pop();)
+#define popback(q, ...) __AS_PROCEDURE(auto [__VA_ARGS__] = q.back(); q.pop_back();)
+#define popfront(q, ...) __AS_PROCEDURE(auto [__VA_ARGS__] = q.front();q.pop_front();)
+
+/* math */
+constexpr inline int lg2(ll x) { return x == 0 ? -1 : sizeof(ll) * 8 - 1 - __builtin_clzll(x); }
+
+void __exgcd(ll a, ll b, ll& x, ll& y) {
+  if (b == 0) {
+    x = 1, y = 0;
+    return;
+  }
+  __exgcd(b, a % b, y, x);
+  y -= a / b * x;
+}
+
+ll inverse(ll a, ll b) {
+    ll x, y;
+    __exgcd(a, b, x, y);
+    return mod(x, b);
+}
+
+vector<tuple<int, int, ll>> decompose(ll x) {
+    vector<tuple<int, int, ll>> res;
+    for (int i = 2; i * i <= x; i++) {
+        if (x % i == 0) {
+            int cnt = 0;
+            ll pw = 1;
+            while (x % i == 0) ++cnt, x /= i, pw *= i;
+            res.emplace_back(i, cnt, pw);
+        }
+    }
+    if (x != 1) {
+        res.emplace_back(x, 1, x);
+    }
+    return res;
+}
+
+/* string algorithms */
+vector<int> calc_next(string t) {  // pi function of t
+  int n = (int)t.length();
+  vector<int> pi(n);
+  for (int i = 1; i < n; i++) {
+    int j = pi[i - 1];
+    while (j > 0 && t[i] != t[j]) j = pi[j - 1];
+    if (t[i] == t[j]) j++;
+    pi[i] = j;
+  }
+  return pi;
+}
+vector<int> calc_z(string t) {  // z function of t
+    int m = t.length();
+    vector<int> z;
+    z.push_back(m);
+    pair<int, int> prev = {1, -1};
+    for (int i = 1; i < m; ++i) {
+        if (z[i - prev.first] + i <= prev.second) {
+            z.push_back(z[i - prev.first]);
+        } else {
+            int j = max(i, prev.second + 1);
+            while (j < m && t[j] == t[j - i]) ++j;
+            z.push_back(j - i);
+            prev = {i, j - 1};
+        }
+    }
+    return z;
+}
+vector<int> kmp(string s, string t) {  // find all t in s
+  string cur = t + '#' + s;
+  int sz1 = s.size(), sz2 = t.size();
+  vector<int> v;
+  vector<int> lps = calc_next(cur);
+  for (int i = sz2 + 1; i <= sz1 + sz2; i++) {
+    if (lps[i] == sz2) v.push_back(i - 2 * sz2);
+  }
+  return v;
+}
+int period(string s) {  // find the length of shortest recurring period
+    int n = s.length();
+    auto z = calc_z(s);
+    for (int i = 1; i <= n / 2; ++i) {
+        if (n % i == 0 && z[i] == n - i) {
+            return i;
+        }
+    }
+    return n;
+}
+/////////////////////////////////////////////////////////
+
+#define SINGLE_TEST_CASE
+// #define DUMP_TEST_CASE 512
+
+void dump() {}
+
+void prep() {}
+
+void solve() {
+    read(int, n, m);
+    adj(ch, n);
+    while (m--) {
+        read(int, u, v);
+        edge(ch, u, v);
+    }
+    read(int, q);
+    vector<bool> vis(n + 1);
+    vector<vector<int>> res;
+    vector<int> curr;
+    int search_to;
+    auto dfs = [&] (auto dfs, int v) -> bool {
+        vis[v] = 1;
+        if (v == search_to) {
+            curr.push_back(v);
+            return true;
+        }
+        for (auto&& u : ch[v]) {
+            if (vis[u]) continue;
+            if (dfs(dfs, u)) {
+                curr.push_back(v);
+                return true;
+            }
+        }
+        return false;
+    };
+    vector<int> oc(n + 1);
+    while (q--) {
+        read(int, u, v);
+        oc[u] += 1, oc[v] += 1;
+        vis.assign(n + 1, 0);
+        curr.clear();
+        search_to = v;
+        assert(dfs(dfs, u));
+        res.push_back(curr);
+    }
+    int odd_cnt = 0;
+    for (int i = 1; i <= n; ++i) if (oc[i] & 1) odd_cnt += 1;
+    assert(odd_cnt % 2 == 0);
+    if (odd_cnt) {
+        cout << "NO\n";
+        cout << odd_cnt / 2 << '\n';
+    } else {
+        cout << "YES\n";
+        for (auto&& v : res) {
+            cout << v.size() << '\n';
+            putvec(v);
+        }
+    }
+}
+
+int main() {
+#if __cplusplus < 201703L || defined(_MSC_VER) && !defined(__clang__)
+    assert(false && "incompatible compiler variant detected.");
+#endif
+    untie, cout.tie(NULL);
+    prep();
+#ifdef SINGLE_TEST_CASE
+    solve();
+#else
+    read(int, t);
+    for (int i = 0; i < t; ++i) {
+#ifdef DUMP_TEST_CASE
+        if (i + 1 == (DUMP_TEST_CASE)) {
+            dump();
+        } else {
+            solve();
+        }
+#else
+        solve();
+#endif
+    }
+#endif
+}

src/bin/cf-1605d.cc

@@ -0,0 +1,322 @@
+#pragma GCC optimize("Ofast")
+/////////////////////////////////////////////////////////
+/**
+ * Useful Macros
+ *   by subcrip
+ * (requires C++17)
+ */
+
+#include<bits/stdc++.h>
+using namespace std;
+
+/* macro helpers */
+#define __NARGS(...) std::tuple_size<decltype(std::make_tuple(__VA_ARGS__))>::value
+#define __DECOMPOSE_S(a, x) auto x = a;
+#define __DECOMPOSE_N(a, ...) auto [__VA_ARGS__] = a;
+constexpr void __() {}
+#define __AS_PROCEDURE(...) __(); __VA_ARGS__; __()
+#define __as_typeof(container) decltype(container)::value_type
+
+/* type aliases */
+using ll = int64_t;
+using ull = uint64_t;
+using pii = pair<int, int>;
+using pil = pair<int, ll>;
+using pli = pair<ll, int>;
+using pll = pair<ll, ll>;
+
+/* constants */
+constexpr int INF = 0x3f3f3f3f;
+constexpr ll INFLL = 0x3f3f3f3f3f3f3f3fLL;
+constexpr ll MDL = 1e9 + 7;
+constexpr ll PRIME = 998'244'353;
+constexpr ll MDL1 = 8784491;
+constexpr ll MDL2 = PRIME;
+
+/* random */
+
+mt19937 rd(chrono::duration_cast<chrono::milliseconds>(chrono::system_clock::now().time_since_epoch()).count());
+
+/* bit-wise operations */
+#define lowbit(x) ((x) & -(x))
+#define popcount(x) (__builtin_popcountll(ll(x)))
+#define parity(x) (__builtin_parityll(ll(x)))
+#define msp(x) (63LL - __builtin_clzll(ll(x)))
+#define lsp(x) (__builtin_ctzll(ll(x)))
+
+/* arithmetic operations */
+#define mod(x, y) ((((x) % (y)) + (y)) % (y))
+
+/* fast pairs */
+#define upair ull
+#define umake(x, y) (ull(x) << 32 | (ull(y) & ((1ULL << 32) - 1)))
+#define u1(p) ((p) >> 32)
+#define u2(p) ((p) & ((1ULL << 32) - 1))
+#define ult std::less<upair>
+#define ugt std::greater<upair>
+
+#define ipair ull
+#define imake(x, y) (umake(x, y))
+#define i1(p) (int(u1(ll(p))))
+#define i2(p) (ll(u2(p) << 32) >> 32)
+struct ilt {
+    bool operator()(const ipair& a, const ipair& b) const {
+        if (i1(a) == i1(b)) return i2(a) < i2(b);
+        else return i1(a) < i1(b);
+    }
+};
+struct igt {
+    bool operator()(const ipair& a, const ipair& b) const {
+        if (i1(a) == i1(b)) return i2(a) > i2(b);
+        else return i1(a) > i1(b);
+    }
+};
+
+/* conditions */
+#define loop while (1)
+#define if_or(var, val) if (!(var == val)) var = val; else
+#define continue_or(var, val) __AS_PROCEDURE(if (var == val) continue; var = val;)
+#define break_or(var, val) __AS_PROCEDURE(if (var == val) break; var = val;)
+
+/* hash */
+struct safe_hash {
+    // https://codeforces.com/blog/entry/62393
+    static uint64_t splitmix64(uint64_t x) {
+        // http://xorshift.di.unimi.it/splitmix64.c
+        x += 0x9e3779b97f4a7c15;
+        x = (x ^ (x >> 30)) * 0xbf58476d1ce4e5b9;
+        x = (x ^ (x >> 27)) * 0x94d049bb133111eb;
+        return x ^ (x >> 31);
+    }
+
+    size_t operator()(uint64_t x) const {
+        static const uint64_t FIXED_RANDOM = chrono::steady_clock::now().time_since_epoch().count();
+        return splitmix64(x + FIXED_RANDOM);
+    }
+};
+
+struct pair_hash {
+    template <typename T, typename U>
+    size_t operator()(const pair<T, U>& a) const {
+        auto hash1 = safe_hash()(a.first);
+        auto hash2 = safe_hash()(a.second);
+        if (hash1 != hash2) {
+            return hash1 ^ hash2;
+        }
+        return hash1;
+    }
+};
+
+/* build data structures */
+#define unordered_counter(from, to) __AS_PROCEDURE(unordered_map<__as_typeof(from), size_t, safe_hash> to; for (auto&& x : from) ++to[x];)
+#define counter(from, to, cmp) __AS_PROCEDURE(map<__as_typeof(from), size_t, cmp> to; for (auto&& x : from) ++to[x];)
+#define pa(a) __AS_PROCEDURE(__typeof(a) pa; pa.push_back({}); for (auto&&x : a) pa.push_back(pa.back() + x);)
+#define sa(a) __AS_PROCEDURE(__typeof(a) sa(a.size() + 1); {int n = a.size(); for (int i = n - 1; i >= 0; --i) sa[i] = sa[i + 1] + a[i];};)
+#define adj(ch, n) __AS_PROCEDURE(vector<vector<int>> 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);)
+template <typename T, typename Iterator> pair<size_t, map<T, size_t>> discretize(Iterator __first, Iterator __last) {
+    set<T> st(__first, __last);
+    size_t N = 0;
+    map<T, size_t> mp;
+    for (auto&& x : st) mp[x] = ++N;
+    return {N, mp};
+}
+template <typename T, typename Iterator> pair<size_t, unordered_map<T, size_t, safe_hash>> unordered_discretize(Iterator __first, Iterator __last) {
+    set<T> st(__first, __last);
+    size_t N = 0;
+    unordered_map<T, size_t, safe_hash> mp;
+    for (auto&& x : st) mp[x] = ++N;
+    return {N, mp};
+}
+
+/* io */
+#define untie __AS_PROCEDURE(ios_base::sync_with_stdio(0), cin.tie(NULL))
+template<typename T> void __read(T& x) { cin >> x; }
+template<typename T, typename... U> void __read(T& x, U&... args) { cin >> x; __read(args...); }
+#define read(type, ...) __AS_PROCEDURE(type __VA_ARGS__; __read(__VA_ARGS__);)
+#define readvec(type, a, n) __AS_PROCEDURE(vector<type> a(n); for (int i = 0; i < (n); ++i) cin >> a[i];)
+#define putvec(a) __AS_PROCEDURE(for (auto&& x : a) cout << x << ' '; cout << endl;)
+#define debug(x) __AS_PROCEDURE(cerr << #x" = " << (x) << endl;)
+#define debugvec(a) __AS_PROCEDURE(cerr << #a" = "; for (auto&& x : a) cerr << x << ' '; cerr << endl;)
+template<typename T, typename U> ostream& operator<<(ostream& out, const pair<T, U>& p) {
+    out << "{" << p.first << ", " << p.second << "}";
+    return out;
+}
+template<typename Char, typename Traits, typename Tuple, std::size_t... Index>
+void print_tuple_impl(std::basic_ostream<Char, Traits>& os, const Tuple& t, std::index_sequence<Index...>) {
+    using swallow = int[]; // guaranties left to right order
+    (void)swallow { 0, (void(os << (Index == 0 ? "" : ", ") << std::get<Index>(t)), 0)... };
+}
+template<typename Char, typename Traits, typename... Args>
+decltype(auto) operator<<(std::basic_ostream<Char, Traits>& os, const std::tuple<Args...>& t) {
+    os << "{";
+    print_tuple_impl(os, t, std::index_sequence_for<Args...>{});
+    return os << "}";
+}
+template<typename T> ostream& operator<<(ostream& out, const vector<T>& vec) {
+    for (auto&& i : vec) out << i << ' ';
+    return out;
+}
+
+/* pops */
+#define poptop(q, ...) __AS_PROCEDURE(auto [__VA_ARGS__] = q.top(); q.pop();)
+#define popback(q, ...) __AS_PROCEDURE(auto [__VA_ARGS__] = q.back(); q.pop_back();)
+#define popfront(q, ...) __AS_PROCEDURE(auto [__VA_ARGS__] = q.front();q.pop_front();)
+
+/* math */
+constexpr inline int lg2(ll x) { return x == 0 ? -1 : sizeof(ll) * 8 - 1 - __builtin_clzll(x); }
+
+void __exgcd(ll a, ll b, ll& x, ll& y) {
+  if (b == 0) {
+    x = 1, y = 0;
+    return;
+  }
+  __exgcd(b, a % b, y, x);
+  y -= a / b * x;
+}
+
+ll inverse(ll a, ll b) {
+    ll x, y;
+    __exgcd(a, b, x, y);
+    return mod(x, b);
+}
+
+vector<tuple<int, int, ll>> decompose(ll x) {
+    vector<tuple<int, int, ll>> res;
+    for (int i = 2; i * i <= x; i++) {
+        if (x % i == 0) {
+            int cnt = 0;
+            ll pw = 1;
+            while (x % i == 0) ++cnt, x /= i, pw *= i;
+            res.emplace_back(i, cnt, pw);
+        }
+    }
+    if (x != 1) {
+        res.emplace_back(x, 1, x);
+    }
+    return res;
+}
+
+/* string algorithms */
+vector<int> calc_next(string t) {  // pi function of t
+  int n = (int)t.length();
+  vector<int> pi(n);
+  for (int i = 1; i < n; i++) {
+    int j = pi[i - 1];
+    while (j > 0 && t[i] != t[j]) j = pi[j - 1];
+    if (t[i] == t[j]) j++;
+    pi[i] = j;
+  }
+  return pi;
+}
+vector<int> calc_z(string t) {  // z function of t
+    int m = t.length();
+    vector<int> z;
+    z.push_back(m);
+    pair<int, int> prev = {1, -1};
+    for (int i = 1; i < m; ++i) {
+        if (z[i - prev.first] + i <= prev.second) {
+            z.push_back(z[i - prev.first]);
+        } else {
+            int j = max(i, prev.second + 1);
+            while (j < m && t[j] == t[j - i]) ++j;
+            z.push_back(j - i);
+            prev = {i, j - 1};
+        }
+    }
+    return z;
+}
+vector<int> kmp(string s, string t) {  // find all t in s
+  string cur = t + '#' + s;
+  int sz1 = s.size(), sz2 = t.size();
+  vector<int> v;
+  vector<int> lps = calc_next(cur);
+  for (int i = sz2 + 1; i <= sz1 + sz2; i++) {
+    if (lps[i] == sz2) v.push_back(i - 2 * sz2);
+  }
+  return v;
+}
+int period(string s) {  // find the length of shortest recurring period
+    int n = s.length();
+    auto z = calc_z(s);
+    for (int i = 1; i <= n / 2; ++i) {
+        if (n % i == 0 && z[i] == n - i) {
+            return i;
+        }
+    }
+    return n;
+}
+/////////////////////////////////////////////////////////
+
+// #define SINGLE_TEST_CASE
+// #define DUMP_TEST_CASE 512
+
+void dump() {}
+
+void prep() {}
+
+void solve() {
+    read(int, n);
+    adj(ch, n);
+    for (int i = 0; i < n - 1; ++i) {
+        read(int, u, v);
+        if ((u ^ v) <= min(u, v)) edge(ch, u, v);
+    }
+    vector<bool> vis(n + 1);
+    vector<bool> dp(n + 1);  // 0 for the first player winning, 1 for the second player winning
+    vector<bool> res(n + 1);
+    auto dfs1 = [&] (auto dfs1, int v, int pa) -> void {
+        // calculate downwards
+        vis[v] = 1;
+        int has_1 = 0;
+        for (auto&& u : ch[v]) {
+            if (u == pa) continue;
+            dfs1(dfs1, u, v);
+            if (dp[u] == 1) has_1 = 1;
+        }
+        if (has_1) dp[v] = 0;
+        else dp[v] = 1;
+    };
+    auto dfs2 = [&] (auto dfs2, int v, int pa, bool up) -> void {
+        // switch root
+        int has_1 = up;
+        for (auto&& u : ch[v]) {
+            if (u == pa) continue;
+            if (dp[u] == 1) has_1 = 1;
+        }
+        if (has_1) res[v] = 0;
+        else res[v] = 1;
+    };
+    int 
+    for (int i = 1; i <= n; ++i) {
+        if (vis[i]) continue;
+        dfs1(dfs1, i, 0);
+        dfs2(dfs2, i, 0, 0);
+        
+    }
+}
+
+int main() {
+#if __cplusplus < 201703L || defined(_MSC_VER) && !defined(__clang__)
+    assert(false && "incompatible compiler variant detected.");
+#endif
+    untie, cout.tie(NULL);
+    prep();
+#ifdef SINGLE_TEST_CASE
+    solve();
+#else
+    read(int, t);
+    for (int i = 0; i < t; ++i) {
+#ifdef DUMP_TEST_CASE
+        if (i + 1 == (DUMP_TEST_CASE)) {
+            dump();
+        } else {
+            solve();
+        }
+#else
+        solve();
+#endif
+    }
+#endif
+}

src/bin/cf-1619f.cc

@@ -0,0 +1,322 @@
+#pragma GCC optimize("Ofast")
+/////////////////////////////////////////////////////////
+/**
+ * Useful Macros
+ *   by subcrip
+ * (requires C++17)
+ */
+
+#include<bits/stdc++.h>
+using namespace std;
+
+/* macro helpers */
+#define __NARGS(...) std::tuple_size<decltype(std::make_tuple(__VA_ARGS__))>::value
+#define __DECOMPOSE_S(a, x) auto x = a;
+#define __DECOMPOSE_N(a, ...) auto [__VA_ARGS__] = a;
+constexpr void __() {}
+#define __AS_PROCEDURE(...) __(); __VA_ARGS__; __()
+#define __as_typeof(container) decltype(container)::value_type
+
+/* type aliases */
+using ll = int64_t;
+using ull = uint64_t;
+using pii = pair<int, int>;
+using pil = pair<int, ll>;
+using pli = pair<ll, int>;
+using pll = pair<ll, ll>;
+
+/* constants */
+constexpr int INF = 0x3f3f3f3f;
+constexpr ll INFLL = 0x3f3f3f3f3f3f3f3fLL;
+constexpr ll MDL = 1e9 + 7;
+constexpr ll PRIME = 998'244'353;
+constexpr ll MDL1 = 8784491;
+constexpr ll MDL2 = PRIME;
+
+/* random */
+
+mt19937 rd(chrono::duration_cast<chrono::milliseconds>(chrono::system_clock::now().time_since_epoch()).count());
+
+/* bit-wise operations */
+#define lowbit(x) ((x) & -(x))
+#define popcount(x) (__builtin_popcountll(ll(x)))
+#define parity(x) (__builtin_parityll(ll(x)))
+#define msp(x) (63LL - __builtin_clzll(ll(x)))
+#define lsp(x) (__builtin_ctzll(ll(x)))
+
+/* arithmetic operations */
+#define mod(x, y) ((((x) % (y)) + (y)) % (y))
+
+/* fast pairs */
+#define upair ull
+#define umake(x, y) (ull(x) << 32 | (ull(y) & ((1ULL << 32) - 1)))
+#define u1(p) ((p) >> 32)
+#define u2(p) ((p) & ((1ULL << 32) - 1))
+#define ult std::less<upair>
+#define ugt std::greater<upair>
+
+#define ipair ull
+#define imake(x, y) (umake(x, y))
+#define i1(p) (int(u1(ll(p))))
+#define i2(p) (ll(u2(p) << 32) >> 32)
+struct ilt {
+    bool operator()(const ipair& a, const ipair& b) const {
+        if (i1(a) == i1(b)) return i2(a) < i2(b);
+        else return i1(a) < i1(b);
+    }
+};
+struct igt {
+    bool operator()(const ipair& a, const ipair& b) const {
+        if (i1(a) == i1(b)) return i2(a) > i2(b);
+        else return i1(a) > i1(b);
+    }
+};
+
+/* conditions */
+#define loop while (1)
+#define if_or(var, val) if (!(var == val)) var = val; else
+#define continue_or(var, val) __AS_PROCEDURE(if (var == val) continue; var = val;)
+#define break_or(var, val) __AS_PROCEDURE(if (var == val) break; var = val;)
+
+/* hash */
+struct safe_hash {
+    // https://codeforces.com/blog/entry/62393
+    static uint64_t splitmix64(uint64_t x) {
+        // http://xorshift.di.unimi.it/splitmix64.c
+        x += 0x9e3779b97f4a7c15;
+        x = (x ^ (x >> 30)) * 0xbf58476d1ce4e5b9;
+        x = (x ^ (x >> 27)) * 0x94d049bb133111eb;
+        return x ^ (x >> 31);
+    }
+
+    size_t operator()(uint64_t x) const {
+        static const uint64_t FIXED_RANDOM = chrono::steady_clock::now().time_since_epoch().count();
+        return splitmix64(x + FIXED_RANDOM);
+    }
+};
+
+struct pair_hash {
+    template <typename T, typename U>
+    size_t operator()(const pair<T, U>& a) const {
+        auto hash1 = safe_hash()(a.first);
+        auto hash2 = safe_hash()(a.second);
+        if (hash1 != hash2) {
+            return hash1 ^ hash2;
+        }
+        return hash1;
+    }
+};
+
+/* build data structures */
+#define unordered_counter(from, to) __AS_PROCEDURE(unordered_map<__as_typeof(from), size_t, safe_hash> to; for (auto&& x : from) ++to[x];)
+#define counter(from, to, cmp) __AS_PROCEDURE(map<__as_typeof(from), size_t, cmp> to; for (auto&& x : from) ++to[x];)
+#define pa(a) __AS_PROCEDURE(__typeof(a) pa; pa.push_back({}); for (auto&&x : a) pa.push_back(pa.back() + x);)
+#define sa(a) __AS_PROCEDURE(__typeof(a) sa(a.size() + 1); {int n = a.size(); for (int i = n - 1; i >= 0; --i) sa[i] = sa[i + 1] + a[i];};)
+#define adj(ch, n) __AS_PROCEDURE(vector<vector<int>> 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);)
+template <typename T, typename Iterator> pair<size_t, map<T, size_t>> discretize(Iterator __first, Iterator __last) {
+    set<T> st(__first, __last);
+    size_t N = 0;
+    map<T, size_t> mp;
+    for (auto&& x : st) mp[x] = ++N;
+    return {N, mp};
+}
+template <typename T, typename Iterator> pair<size_t, unordered_map<T, size_t, safe_hash>> unordered_discretize(Iterator __first, Iterator __last) {
+    set<T> st(__first, __last);
+    size_t N = 0;
+    unordered_map<T, size_t, safe_hash> mp;
+    for (auto&& x : st) mp[x] = ++N;
+    return {N, mp};
+}
+
+/* io */
+#define untie __AS_PROCEDURE(ios_base::sync_with_stdio(0), cin.tie(NULL))
+template<typename T> void __read(T& x) { cin >> x; }
+template<typename T, typename... U> void __read(T& x, U&... args) { cin >> x; __read(args...); }
+#define read(type, ...) __AS_PROCEDURE(type __VA_ARGS__; __read(__VA_ARGS__);)
+#define readvec(type, a, n) __AS_PROCEDURE(vector<type> a(n); for (int i = 0; i < (n); ++i) cin >> a[i];)
+#define putvec(a) __AS_PROCEDURE(for (auto&& x : a) cout << x << ' '; cout << endl;)
+#define debug(x) __AS_PROCEDURE(cerr << #x" = " << (x) << endl;)
+#define debugvec(a) __AS_PROCEDURE(cerr << #a" = "; for (auto&& x : a) cerr << x << ' '; cerr << endl;)
+template<typename T, typename U> ostream& operator<<(ostream& out, const pair<T, U>& p) {
+    out << "{" << p.first << ", " << p.second << "}";
+    return out;
+}
+template<typename Char, typename Traits, typename Tuple, std::size_t... Index>
+void print_tuple_impl(std::basic_ostream<Char, Traits>& os, const Tuple& t, std::index_sequence<Index...>) {
+    using swallow = int[]; // guaranties left to right order
+    (void)swallow { 0, (void(os << (Index == 0 ? "" : ", ") << std::get<Index>(t)), 0)... };
+}
+template<typename Char, typename Traits, typename... Args>
+decltype(auto) operator<<(std::basic_ostream<Char, Traits>& os, const std::tuple<Args...>& t) {
+    os << "{";
+    print_tuple_impl(os, t, std::index_sequence_for<Args...>{});
+    return os << "}";
+}
+template<typename T> ostream& operator<<(ostream& out, const vector<T>& vec) {
+    for (auto&& i : vec) out << i << ' ';
+    return out;
+}
+
+/* pops */
+#define poptop(q, ...) __AS_PROCEDURE(auto [__VA_ARGS__] = q.top(); q.pop();)
+#define popback(q, ...) __AS_PROCEDURE(auto [__VA_ARGS__] = q.back(); q.pop_back();)
+#define popfront(q, ...) __AS_PROCEDURE(auto [__VA_ARGS__] = q.front();q.pop_front();)
+
+/* math */
+constexpr inline int lg2(ll x) { return x == 0 ? -1 : sizeof(ll) * 8 - 1 - __builtin_clzll(x); }
+
+void __exgcd(ll a, ll b, ll& x, ll& y) {
+  if (b == 0) {
+    x = 1, y = 0;
+    return;
+  }
+  __exgcd(b, a % b, y, x);
+  y -= a / b * x;
+}
+
+ll inverse(ll a, ll b) {
+    ll x, y;
+    __exgcd(a, b, x, y);
+    return mod(x, b);
+}
+
+vector<tuple<int, int, ll>> decompose(ll x) {
+    vector<tuple<int, int, ll>> res;
+    for (int i = 2; i * i <= x; i++) {
+        if (x % i == 0) {
+            int cnt = 0;
+            ll pw = 1;
+            while (x % i == 0) ++cnt, x /= i, pw *= i;
+            res.emplace_back(i, cnt, pw);
+        }
+    }
+    if (x != 1) {
+        res.emplace_back(x, 1, x);
+    }
+    return res;
+}
+
+/* string algorithms */
+vector<int> calc_next(string t) {  // pi function of t
+  int n = (int)t.length();
+  vector<int> pi(n);
+  for (int i = 1; i < n; i++) {
+    int j = pi[i - 1];
+    while (j > 0 && t[i] != t[j]) j = pi[j - 1];
+    if (t[i] == t[j]) j++;
+    pi[i] = j;
+  }
+  return pi;
+}
+vector<int> calc_z(string t) {  // z function of t
+    int m = t.length();
+    vector<int> z;
+    z.push_back(m);
+    pair<int, int> prev = {1, -1};
+    for (int i = 1; i < m; ++i) {
+        if (z[i - prev.first] + i <= prev.second) {
+            z.push_back(z[i - prev.first]);
+        } else {
+            int j = max(i, prev.second + 1);
+            while (j < m && t[j] == t[j - i]) ++j;
+            z.push_back(j - i);
+            prev = {i, j - 1};
+        }
+    }
+    return z;
+}
+vector<int> kmp(string s, string t) {  // find all t in s
+  string cur = t + '#' + s;
+  int sz1 = s.size(), sz2 = t.size();
+  vector<int> v;
+  vector<int> lps = calc_next(cur);
+  for (int i = sz2 + 1; i <= sz1 + sz2; i++) {
+    if (lps[i] == sz2) v.push_back(i - 2 * sz2);
+  }
+  return v;
+}
+int period(string s) {  // find the length of shortest recurring period
+    int n = s.length();
+    auto z = calc_z(s);
+    for (int i = 1; i <= n / 2; ++i) {
+        if (n % i == 0 && z[i] == n - i) {
+            return i;
+        }
+    }
+    return n;
+}
+/////////////////////////////////////////////////////////
+
+// #define SINGLE_TEST_CASE
+// #define DUMP_TEST_CASE 512
+
+void dump() {}
+
+void prep() {}
+
+void solve() {
+    read(int, n, m, k);
+    int p = n / m, q = (n + m - 1) / m;
+    int q_cnt = n - p * m;
+    int p_cnt = m - q_cnt;
+    int p_tot = p * p_cnt, q_tot = q * q_cnt;
+    set<pii> cnt;
+    for (int i = 1; i <= n; ++i) {
+        cnt.emplace(0, i);
+    }
+    while (k--) {
+        vector<bool> is_vip(n + 1);
+        unordered_set<pii, pair_hash> open;
+        for (int i = 0; i < q_tot; ++i) {
+            auto [c, u] = *cnt.begin(); cnt.erase(cnt.begin());
+            is_vip[u] = 1;
+            open.emplace(c + 1, u);
+        }
+        for (auto&& [x, y] : open) cnt.emplace(x, y);
+        int ptr = 1;
+        for (int i = 0; i < p_cnt; ++i) {
+            cout << p << ' ';
+            for (int j = 0; j < p; ++j) {
+                while (is_vip[ptr]) ++ptr;
+                cout << (ptr++) << ' ';
+            }
+            cout << '\n';
+        }
+        ptr = 1;
+        for (int i = 0; i < q_cnt; ++i) {
+            cout << q << ' ';
+            for (int j = 0; j < q; ++j) {
+                while (!is_vip[ptr]) ++ptr;
+                cout << (ptr++) << ' ';
+            }
+            cout << '\n';
+        }
+    }
+    cout << '\n';
+}
+
+int main() {
+#if __cplusplus < 201703L || defined(_MSC_VER) && !defined(__clang__)
+    assert(false && "incompatible compiler variant detected.");
+#endif
+    untie, cout.tie(NULL);
+    prep();
+#ifdef SINGLE_TEST_CASE
+    solve();
+#else
+    read(int, t);
+    for (int i = 0; i < t; ++i) {
+#ifdef DUMP_TEST_CASE
+        if (i + 1 == (DUMP_TEST_CASE)) {
+            dump();
+        } else {
+            solve();
+        }
+#else
+        solve();
+#endif
+    }
+#endif
+}

src/bin/cf-1624f.cc

@@ -0,0 +1,319 @@
+#pragma GCC optimize("Ofast")
+/////////////////////////////////////////////////////////
+/**
+ * Useful Macros
+ *   by subcrip
+ * (requires C++17)
+ */
+
+#include<bits/stdc++.h>
+using namespace std;
+
+/* macro helpers */
+#define __NARGS(...) std::tuple_size<decltype(std::make_tuple(__VA_ARGS__))>::value
+#define __DECOMPOSE_S(a, x) auto x = a;
+#define __DECOMPOSE_N(a, ...) auto [__VA_ARGS__] = a;
+constexpr void __() {}
+#define __AS_PROCEDURE(...) __(); __VA_ARGS__; __()
+#define __as_typeof(container) decltype(container)::value_type
+
+/* type aliases */
+using ll = int64_t;
+using ull = uint64_t;
+using pii = pair<int, int>;
+using pil = pair<int, ll>;
+using pli = pair<ll, int>;
+using pll = pair<ll, ll>;
+
+/* constants */
+constexpr int INF = 0x3f3f3f3f;
+constexpr ll INFLL = 0x3f3f3f3f3f3f3f3fLL;
+constexpr ll MDL = 1e9 + 7;
+constexpr ll PRIME = 998'244'353;
+constexpr ll MDL1 = 8784491;
+constexpr ll MDL2 = PRIME;
+
+/* random */
+
+mt19937 rd(chrono::duration_cast<chrono::milliseconds>(chrono::system_clock::now().time_since_epoch()).count());
+
+/* bit-wise operations */
+#define lowbit(x) ((x) & -(x))
+#define popcount(x) (__builtin_popcountll(ll(x)))
+#define parity(x) (__builtin_parityll(ll(x)))
+#define msp(x) (63LL - __builtin_clzll(ll(x)))
+#define lsp(x) (__builtin_ctzll(ll(x)))
+
+/* arithmetic operations */
+#define mod(x, y) ((((x) % (y)) + (y)) % (y))
+
+/* fast pairs */
+#define upair ull
+#define umake(x, y) (ull(x) << 32 | (ull(y) & ((1ULL << 32) - 1)))
+#define u1(p) ((p) >> 32)
+#define u2(p) ((p) & ((1ULL << 32) - 1))
+#define ult std::less<upair>
+#define ugt std::greater<upair>
+
+#define ipair ull
+#define imake(x, y) (umake(x, y))
+#define i1(p) (int(u1(ll(p))))
+#define i2(p) (ll(u2(p) << 32) >> 32)
+struct ilt {
+    bool operator()(const ipair& a, const ipair& b) const {
+        if (i1(a) == i1(b)) return i2(a) < i2(b);
+        else return i1(a) < i1(b);
+    }
+};
+struct igt {
+    bool operator()(const ipair& a, const ipair& b) const {
+        if (i1(a) == i1(b)) return i2(a) > i2(b);
+        else return i1(a) > i1(b);
+    }
+};
+
+/* conditions */
+#define loop while (1)
+#define if_or(var, val) if (!(var == val)) var = val; else
+#define continue_or(var, val) __AS_PROCEDURE(if (var == val) continue; var = val;)
+#define break_or(var, val) __AS_PROCEDURE(if (var == val) break; var = val;)
+
+/* hash */
+struct safe_hash {
+    // https://codeforces.com/blog/entry/62393
+    static uint64_t splitmix64(uint64_t x) {
+        // http://xorshift.di.unimi.it/splitmix64.c
+        x += 0x9e3779b97f4a7c15;
+        x = (x ^ (x >> 30)) * 0xbf58476d1ce4e5b9;
+        x = (x ^ (x >> 27)) * 0x94d049bb133111eb;
+        return x ^ (x >> 31);
+    }
+
+    size_t operator()(uint64_t x) const {
+        static const uint64_t FIXED_RANDOM = chrono::steady_clock::now().time_since_epoch().count();
+        return splitmix64(x + FIXED_RANDOM);
+    }
+};
+
+struct pair_hash {
+    template <typename T, typename U>
+    size_t operator()(const pair<T, U>& a) const {
+        auto hash1 = safe_hash()(a.first);
+        auto hash2 = safe_hash()(a.second);
+        if (hash1 != hash2) {
+            return hash1 ^ hash2;
+        }
+        return hash1;
+    }
+};
+
+/* build data structures */
+#define unordered_counter(from, to) __AS_PROCEDURE(unordered_map<__as_typeof(from), size_t, safe_hash> to; for (auto&& x : from) ++to[x];)
+#define counter(from, to, cmp) __AS_PROCEDURE(map<__as_typeof(from), size_t, cmp> to; for (auto&& x : from) ++to[x];)
+#define pa(a) __AS_PROCEDURE(__typeof(a) pa; pa.push_back({}); for (auto&&x : a) pa.push_back(pa.back() + x);)
+#define sa(a) __AS_PROCEDURE(__typeof(a) sa(a.size() + 1); {int n = a.size(); for (int i = n - 1; i >= 0; --i) sa[i] = sa[i + 1] + a[i];};)
+#define adj(ch, n) __AS_PROCEDURE(vector<vector<int>> 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);)
+template <typename T, typename Iterator> pair<size_t, map<T, size_t>> discretize(Iterator __first, Iterator __last) {
+    set<T> st(__first, __last);
+    size_t N = 0;
+    map<T, size_t> mp;
+    for (auto&& x : st) mp[x] = ++N;
+    return {N, mp};
+}
+template <typename T, typename Iterator> pair<size_t, unordered_map<T, size_t, safe_hash>> unordered_discretize(Iterator __first, Iterator __last) {
+    set<T> st(__first, __last);
+    size_t N = 0;
+    unordered_map<T, size_t, safe_hash> mp;
+    for (auto&& x : st) mp[x] = ++N;
+    return {N, mp};
+}
+
+/* io */
+#define untie __AS_PROCEDURE(ios_base::sync_with_stdio(0), cin.tie(NULL))
+template<typename T> void __read(T& x) { cin >> x; }
+template<typename T, typename... U> void __read(T& x, U&... args) { cin >> x; __read(args...); }
+#define read(type, ...) __AS_PROCEDURE(type __VA_ARGS__; __read(__VA_ARGS__);)
+#define readvec(type, a, n) __AS_PROCEDURE(vector<type> a(n); for (int i = 0; i < (n); ++i) cin >> a[i];)
+#define putvec(a) __AS_PROCEDURE(for (auto&& x : a) cout << x << ' '; cout << endl;)
+#define debug(x) __AS_PROCEDURE(cerr << #x" = " << (x) << endl;)
+#define debugvec(a) __AS_PROCEDURE(cerr << #a" = "; for (auto&& x : a) cerr << x << ' '; cerr << endl;)
+template<typename T, typename U> ostream& operator<<(ostream& out, const pair<T, U>& p) {
+    out << "{" << p.first << ", " << p.second << "}";
+    return out;
+}
+template<typename Char, typename Traits, typename Tuple, std::size_t... Index>
+void print_tuple_impl(std::basic_ostream<Char, Traits>& os, const Tuple& t, std::index_sequence<Index...>) {
+    using swallow = int[]; // guaranties left to right order
+    (void)swallow { 0, (void(os << (Index == 0 ? "" : ", ") << std::get<Index>(t)), 0)... };
+}
+template<typename Char, typename Traits, typename... Args>
+decltype(auto) operator<<(std::basic_ostream<Char, Traits>& os, const std::tuple<Args...>& t) {
+    os << "{";
+    print_tuple_impl(os, t, std::index_sequence_for<Args...>{});
+    return os << "}";
+}
+template<typename T> ostream& operator<<(ostream& out, const vector<T>& vec) {
+    for (auto&& i : vec) out << i << ' ';
+    return out;
+}
+
+/* pops */
+#define poptop(q, ...) __AS_PROCEDURE(auto [__VA_ARGS__] = q.top(); q.pop();)
+#define popback(q, ...) __AS_PROCEDURE(auto [__VA_ARGS__] = q.back(); q.pop_back();)
+#define popfront(q, ...) __AS_PROCEDURE(auto [__VA_ARGS__] = q.front();q.pop_front();)
+
+/* math */
+constexpr inline int lg2(ll x) { return x == 0 ? -1 : sizeof(ll) * 8 - 1 - __builtin_clzll(x); }
+
+void __exgcd(ll a, ll b, ll& x, ll& y) {
+  if (b == 0) {
+    x = 1, y = 0;
+    return;
+  }
+  __exgcd(b, a % b, y, x);
+  y -= a / b * x;
+}
+
+ll inverse(ll a, ll b) {
+    ll x, y;
+    __exgcd(a, b, x, y);
+    return mod(x, b);
+}
+
+vector<tuple<int, int, ll>> decompose(ll x) {
+    vector<tuple<int, int, ll>> res;
+    for (int i = 2; i * i <= x; i++) {
+        if (x % i == 0) {
+            int cnt = 0;
+            ll pw = 1;
+            while (x % i == 0) ++cnt, x /= i, pw *= i;
+            res.emplace_back(i, cnt, pw);
+        }
+    }
+    if (x != 1) {
+        res.emplace_back(x, 1, x);
+    }
+    return res;
+}
+
+/* string algorithms */
+vector<int> calc_next(string t) {  // pi function of t
+  int n = (int)t.length();
+  vector<int> pi(n);
+  for (int i = 1; i < n; i++) {
+    int j = pi[i - 1];
+    while (j > 0 && t[i] != t[j]) j = pi[j - 1];
+    if (t[i] == t[j]) j++;
+    pi[i] = j;
+  }
+  return pi;
+}
+vector<int> calc_z(string t) {  // z function of t
+    int m = t.length();
+    vector<int> z;
+    z.push_back(m);
+    pair<int, int> prev = {1, -1};
+    for (int i = 1; i < m; ++i) {
+        if (z[i - prev.first] + i <= prev.second) {
+            z.push_back(z[i - prev.first]);
+        } else {
+            int j = max(i, prev.second + 1);
+            while (j < m && t[j] == t[j - i]) ++j;
+            z.push_back(j - i);
+            prev = {i, j - 1};
+        }
+    }
+    return z;
+}
+vector<int> kmp(string s, string t) {  // find all t in s
+  string cur = t + '#' + s;
+  int sz1 = s.size(), sz2 = t.size();
+  vector<int> v;
+  vector<int> lps = calc_next(cur);
+  for (int i = sz2 + 1; i <= sz1 + sz2; i++) {
+    if (lps[i] == sz2) v.push_back(i - 2 * sz2);
+  }
+  return v;
+}
+int period(string s) {  // find the length of shortest recurring period
+    int n = s.length();
+    auto z = calc_z(s);
+    for (int i = 1; i <= n / 2; ++i) {
+        if (n % i == 0 && z[i] == n - i) {
+            return i;
+        }
+    }
+    return n;
+}
+/////////////////////////////////////////////////////////
+
+#define SINGLE_TEST_CASE
+// #define DUMP_TEST_CASE 512
+
+void dump() {}
+
+void prep() {}
+
+void solve() {
+    int diff = 0;
+    int prev = 0;
+    int prev_res = 0;
+    int acc = 0;
+    read(int, n);
+    auto query = [&] (int x) -> int {
+        int curr;
+        if (prev > x) {
+            curr = n - prev + x;
+            diff += 1;
+        } else if (prev < x) {
+            curr = x - prev;
+        } else {
+            return prev_res;
+        }
+        prev = x;
+        acc += curr;
+        cout << "+ " << curr << endl;
+        read(int, res);
+        prev_res = res - diff;
+        return prev_res;
+    };
+    auto claim = [] (int x) -> void {
+        cout << "! " << x << endl;
+    };
+    int l = 1, r = n - 1;
+    while (l < r) {
+        int mid = l + r >> 1;
+        if (query(mid) == 1) {
+            r = mid;
+        } else {
+            l = mid + 1;
+        }
+    }
+    claim(n - l + acc);
+}
+
+int main() {
+#if __cplusplus < 201703L || defined(_MSC_VER) && !defined(__clang__)
+    assert(false && "incompatible compiler variant detected.");
+#endif
+    untie, cout.tie(NULL);
+    prep();
+#ifdef SINGLE_TEST_CASE
+    solve();
+#else
+    read(int, t);
+    for (int i = 0; i < t; ++i) {
+#ifdef DUMP_TEST_CASE
+        if (i + 1 == (DUMP_TEST_CASE)) {
+            dump();
+        } else {
+            solve();
+        }
+#else
+        solve();
+#endif
+    }
+#endif
+}

src/bin/codefun-1783.cc

@@ -0,0 +1,304 @@
+#pragma GCC optimize("Ofast")
+/////////////////////////////////////////////////////////
+/**
+ * Useful Macros
+ *   by subcrip
+ * (requires C++17)
+ */
+
+#include<bits/stdc++.h>
+using namespace std;
+
+/* macro helpers */
+#define __NARGS(...) std::tuple_size<decltype(std::make_tuple(__VA_ARGS__))>::value
+#define __DECOMPOSE_S(a, x) auto x = a;
+#define __DECOMPOSE_N(a, ...) auto [__VA_ARGS__] = a;
+constexpr void __() {}
+#define __AS_PROCEDURE(...) __(); __VA_ARGS__; __()
+#define __as_typeof(container) decltype(container)::value_type
+
+/* type aliases */
+using ll = int64_t;
+using ull = uint64_t;
+using pii = pair<int, int>;
+using pil = pair<int, ll>;
+using pli = pair<ll, int>;
+using pll = pair<ll, ll>;
+
+/* constants */
+constexpr int INF = 0x3f3f3f3f;
+constexpr ll INFLL = 0x3f3f3f3f3f3f3f3fLL;
+constexpr ll MDL = 1e9 + 7;
+constexpr ll PRIME = 998'244'353;
+constexpr ll MDL1 = 8784491;
+constexpr ll MDL2 = PRIME;
+
+/* random */
+
+mt19937 rd(chrono::duration_cast<chrono::milliseconds>(chrono::system_clock::now().time_since_epoch()).count());
+
+/* bit-wise operations */
+#define lowbit(x) ((x) & -(x))
+#define popcount(x) (__builtin_popcountll(ll(x)))
+#define parity(x) (__builtin_parityll(ll(x)))
+#define msp(x) (63LL - __builtin_clzll(ll(x)))
+#define lsp(x) (__builtin_ctzll(ll(x)))
+
+/* arithmetic operations */
+#define mod(x, y) ((((x) % (y)) + (y)) % (y))
+
+/* fast pairs */
+#define upair ull
+#define umake(x, y) (ull(x) << 32 | (ull(y) & ((1ULL << 32) - 1)))
+#define u1(p) ((p) >> 32)
+#define u2(p) ((p) & ((1ULL << 32) - 1))
+#define ult std::less<upair>
+#define ugt std::greater<upair>
+
+#define ipair ull
+#define imake(x, y) (umake(x, y))
+#define i1(p) (int(u1(ll(p))))
+#define i2(p) (ll(u2(p) << 32) >> 32)
+struct ilt {
+    bool operator()(const ipair& a, const ipair& b) const {
+        if (i1(a) == i1(b)) return i2(a) < i2(b);
+        else return i1(a) < i1(b);
+    }
+};
+struct igt {
+    bool operator()(const ipair& a, const ipair& b) const {
+        if (i1(a) == i1(b)) return i2(a) > i2(b);
+        else return i1(a) > i1(b);
+    }
+};
+
+/* conditions */
+#define loop while (1)
+#define if_or(var, val) if (!(var == val)) var = val; else
+#define continue_or(var, val) __AS_PROCEDURE(if (var == val) continue; var = val;)
+#define break_or(var, val) __AS_PROCEDURE(if (var == val) break; var = val;)
+
+/* hash */
+struct safe_hash {
+    // https://codeforces.com/blog/entry/62393
+    static uint64_t splitmix64(uint64_t x) {
+        // http://xorshift.di.unimi.it/splitmix64.c
+        x += 0x9e3779b97f4a7c15;
+        x = (x ^ (x >> 30)) * 0xbf58476d1ce4e5b9;
+        x = (x ^ (x >> 27)) * 0x94d049bb133111eb;
+        return x ^ (x >> 31);
+    }
+
+    size_t operator()(uint64_t x) const {
+        static const uint64_t FIXED_RANDOM = chrono::steady_clock::now().time_since_epoch().count();
+        return splitmix64(x + FIXED_RANDOM);
+    }
+};
+
+struct pair_hash {
+    template <typename T, typename U>
+    size_t operator()(const pair<T, U>& a) const {
+        auto hash1 = safe_hash()(a.first);
+        auto hash2 = safe_hash()(a.second);
+        if (hash1 != hash2) {
+            return hash1 ^ hash2;
+        }
+        return hash1;
+    }
+};
+
+/* build data structures */
+#define unordered_counter(from, to) __AS_PROCEDURE(unordered_map<__as_typeof(from), size_t, safe_hash> to; for (auto&& x : from) ++to[x];)
+#define counter(from, to, cmp) __AS_PROCEDURE(map<__as_typeof(from), size_t, cmp> to; for (auto&& x : from) ++to[x];)
+#define pa(a) __AS_PROCEDURE(__typeof(a) pa; pa.push_back({}); for (auto&&x : a) pa.push_back(pa.back() + x);)
+#define sa(a) __AS_PROCEDURE(__typeof(a) sa(a.size() + 1); {int n = a.size(); for (int i = n - 1; i >= 0; --i) sa[i] = sa[i + 1] + a[i];};)
+#define adj(ch, n) __AS_PROCEDURE(vector<vector<int>> 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);)
+template <typename T, typename Iterator> pair<size_t, map<T, size_t>> discretize(Iterator __first, Iterator __last) {
+    set<T> st(__first, __last);
+    size_t N = 0;
+    map<T, size_t> mp;
+    for (auto&& x : st) mp[x] = ++N;
+    return {N, mp};
+}
+template <typename T, typename Iterator> pair<size_t, unordered_map<T, size_t, safe_hash>> unordered_discretize(Iterator __first, Iterator __last) {
+    set<T> st(__first, __last);
+    size_t N = 0;
+    unordered_map<T, size_t, safe_hash> mp;
+    for (auto&& x : st) mp[x] = ++N;
+    return {N, mp};
+}
+
+/* io */
+#define untie __AS_PROCEDURE(ios_base::sync_with_stdio(0), cin.tie(NULL))
+template<typename T> void __read(T& x) { cin >> x; }
+template<typename T, typename... U> void __read(T& x, U&... args) { cin >> x; __read(args...); }
+#define read(type, ...) __AS_PROCEDURE(type __VA_ARGS__; __read(__VA_ARGS__);)
+#define readvec(type, a, n) __AS_PROCEDURE(vector<type> a(n); for (int i = 0; i < (n); ++i) cin >> a[i];)
+#define putvec(a) __AS_PROCEDURE(for (auto&& x : a) cout << x << ' '; cout << endl;)
+#define debug(x) __AS_PROCEDURE(cerr << #x" = " << (x) << endl;)
+#define debugvec(a) __AS_PROCEDURE(cerr << #a" = "; for (auto&& x : a) cerr << x << ' '; cerr << endl;)
+template<typename T, typename U> ostream& operator<<(ostream& out, const pair<T, U>& p) {
+    out << "{" << p.first << ", " << p.second << "}";
+    return out;
+}
+template<typename Char, typename Traits, typename Tuple, std::size_t... Index>
+void print_tuple_impl(std::basic_ostream<Char, Traits>& os, const Tuple& t, std::index_sequence<Index...>) {
+    using swallow = int[]; // guaranties left to right order
+    (void)swallow { 0, (void(os << (Index == 0 ? "" : ", ") << std::get<Index>(t)), 0)... };
+}
+template<typename Char, typename Traits, typename... Args>
+decltype(auto) operator<<(std::basic_ostream<Char, Traits>& os, const std::tuple<Args...>& t) {
+    os << "{";
+    print_tuple_impl(os, t, std::index_sequence_for<Args...>{});
+    return os << "}";
+}
+template<typename T> ostream& operator<<(ostream& out, const vector<T>& vec) {
+    for (auto&& i : vec) out << i << ' ';
+    return out;
+}
+
+/* pops */
+#define poptop(q, ...) __AS_PROCEDURE(auto [__VA_ARGS__] = q.top(); q.pop();)
+#define popback(q, ...) __AS_PROCEDURE(auto [__VA_ARGS__] = q.back(); q.pop_back();)
+#define popfront(q, ...) __AS_PROCEDURE(auto [__VA_ARGS__] = q.front();q.pop_front();)
+
+/* math */
+constexpr inline int lg2(ll x) { return x == 0 ? -1 : sizeof(ll) * 8 - 1 - __builtin_clzll(x); }
+
+void __exgcd(ll a, ll b, ll& x, ll& y) {
+  if (b == 0) {
+    x = 1, y = 0;
+    return;
+  }
+  __exgcd(b, a % b, y, x);
+  y -= a / b * x;
+}
+
+ll inverse(ll a, ll b) {
+    ll x, y;
+    __exgcd(a, b, x, y);
+    return mod(x, b);
+}
+
+vector<tuple<int, int, ll>> decompose(ll x) {
+    vector<tuple<int, int, ll>> res;
+    for (int i = 2; i * i <= x; i++) {
+        if (x % i == 0) {
+            int cnt = 0;
+            ll pw = 1;
+            while (x % i == 0) ++cnt, x /= i, pw *= i;
+            res.emplace_back(i, cnt, pw);
+        }
+    }
+    if (x != 1) {
+        res.emplace_back(x, 1, x);
+    }
+    return res;
+}
+
+/* string algorithms */
+vector<int> calc_next(string t) {  // pi function of t
+  int n = (int)t.length();
+  vector<int> pi(n);
+  for (int i = 1; i < n; i++) {
+    int j = pi[i - 1];
+    while (j > 0 && t[i] != t[j]) j = pi[j - 1];
+    if (t[i] == t[j]) j++;
+    pi[i] = j;
+  }
+  return pi;
+}
+vector<int> calc_z(string t) {  // z function of t
+    int m = t.length();
+    vector<int> z;
+    z.push_back(m);
+    pair<int, int> prev = {1, -1};
+    for (int i = 1; i < m; ++i) {
+        if (z[i - prev.first] + i <= prev.second) {
+            z.push_back(z[i - prev.first]);
+        } else {
+            int j = max(i, prev.second + 1);
+            while (j < m && t[j] == t[j - i]) ++j;
+            z.push_back(j - i);
+            prev = {i, j - 1};
+        }
+    }
+    return z;
+}
+vector<int> kmp(string s, string t) {  // find all t in s
+  string cur = t + '#' + s;
+  int sz1 = s.size(), sz2 = t.size();
+  vector<int> v;
+  vector<int> lps = calc_next(cur);
+  for (int i = sz2 + 1; i <= sz1 + sz2; i++) {
+    if (lps[i] == sz2) v.push_back(i - 2 * sz2);
+  }
+  return v;
+}
+int period(string s) {  // find the length of shortest recurring period
+    int n = s.length();
+    auto z = calc_z(s);
+    for (int i = 1; i <= n / 2; ++i) {
+        if (n % i == 0 && z[i] == n - i) {
+            return i;
+        }
+    }
+    return n;
+}
+/////////////////////////////////////////////////////////
+
+#define SINGLE_TEST_CASE
+// #define DUMP_TEST_CASE 512
+
+void dump() {}
+
+void prep() {}
+
+void solve() {
+    read(int, n);
+    readvec(int, x, n);
+    readvec(int, a, n);
+    vector<array<double, 2>> dp(n + 1);
+    for (int i = 1; i <= n; ++i) {
+        // this is the second tower
+        for (int j = 2; j < i; ++j) {
+            dp[i][0] = max(dp[i][0], (double)(a[0] + a[j - 1]) / (x[j - 1] - x[0]) * (a[j - 1] + a[i - 1]) / (x[i - 1] - x[j - 1]));
+        }
+        // this is the third tower
+        for (int j = 2; j < i; ++j) {
+            dp[i][1] = max(dp[i][1], dp[j][0] * (a[j - 1] + a[i - 1]) / (x[i - 1] - x[j - 1]));
+        }
+    }
+    double res = 0;
+    for (int i = 2; i < n; ++i) {
+        res = max(res, dp[i][1] * (a[n - 1] + a[i - 1]) / (x[n - 1] - x[i - 1]));
+    }
+    printf("%.9lf\n", res);
+    // cout << fixed << setprecision(10) << res << '\n';
+}
+
+int main() {
+#if __cplusplus < 201703L || defined(_MSC_VER) && !defined(__clang__)
+    assert(false && "incompatible compiler variant detected.");
+#endif
+    // untie, cout.tie(NULL);
+    prep();
+#ifdef SINGLE_TEST_CASE
+    solve();
+#else
+    read(int, t);
+    for (int i = 0; i < t; ++i) {
+#ifdef DUMP_TEST_CASE
+        if (i + 1 == (DUMP_TEST_CASE)) {
+            dump();
+        } else {
+            solve();
+        }
+#else
+        solve();
+#endif
+    }
+#endif
+}

src/bin/std.in

@@ -1,10 +1,13 @@
-9
+6 7
-3 4
-7 6
 2 1
-8 3
+2 3
+3 5
+1 4
+6 1
 5 6
-1 8
+4 5
-8 6
+3
-9 6
+1 4
+5 1
+4 5