More problems

.gitignore

@@ -3,3 +3,4 @@
 !*.cpp
 !TODO.md
 !problemlist.md
+*sync-conflict*

2018 ACM-ICPC, Universidad Nacional de Colombia Programming Contest/D. Divorce.cpp

@@ -0,0 +1,174 @@
+/* Problem URL: https://codeforces.com/gym/101845/problem/D */
+
+#include <bits/stdc++.h>
+#include <ext/pb_ds/assoc_container.hpp>
+#include <ext/pb_ds/tree_policy.hpp>
+
+using namespace std;
+using namespace __gnu_pbds;
+
+template <class T, class comp = less<>>
+using ordered_set = tree<T, null_type , comp , rb_tree_tag , tree_order_statistics_node_update>;
+
+#define V vector
+
+#define rmin(a, b) a = min(a, b)
+#define rmax(a, b) a = max(a, b)
+
+#define rep(i, lim) for (int i = 0; i < (lim); i++)
+#define nrep(i, s, lim) for (int i = s; i < (lim); i++)
+
+#define repv(i, v) for (auto &i : (v))
+#define fillv(v) for (auto &itr_ : (v)) { cin >> itr_; }
+#define sortv(v) sort(v.begin(), v.end())
+#define all(v) (v).begin(), (v).end()
+
+using vi = vector<int>;
+using vvi = vector<vi>;
+using vvvi = vector<vvi>;
+using vvvvi = vector<vvvi>;
+
+using ll = long long;
+
+using vl = vector<ll>;
+using vvl = vector<vl>;
+using vvvl = vector<vvl>;
+using vvvvl = vector<vvvl>;
+
+template<class v>
+auto operator<<(ostream &os, const vector<v> &vec)->ostream& {
+    os << vec[0];
+    for (size_t i = 1; i < vec.size(); i++) {
+        os << ' ' << vec[i];
+    }
+    os << '\n';
+    return os;
+}
+
+template<class v>
+auto operator>>(istream &is, vector<v> &vec)->istream& {
+    for (auto &i : vec) {
+        is >> i;
+    }
+    return is;
+}
+
+template<class v>
+auto operator<<(ostream &os, const vector<vector<v>> &vec)->ostream& {
+    for (auto &i : vec) {
+        os << i[0];
+        for (size_t j = 1; j < i.size(); j++) {
+            os << ' ' << i[j];
+        }
+        os << '\n';
+    }
+    return os;
+}
+
+template<class v>
+auto operator>>(istream  &is, vector<vector<v>> &vec)->istream& {
+    for (auto &i : vec) {
+        for (auto &j : i) {
+            is >> j;
+        }
+    }
+    return is;
+}
+
+const int oo = INT32_MAX >> 1;
+const ll OO = INT64_MAX >> 1;
+
+struct pt {
+    ll x, y;
+
+    pt() = default;
+    pt(ll x, ll y): x(x), y(y) {}
+
+    friend istream &operator >> (istream &is, pt &a) {
+        is >> a.x >> a.y;
+        return is;
+    }
+
+    ll operator * (pt b) {
+        return x * b.x + y * b.y;
+    }
+
+    ll operator ^ (pt b) {
+        return x * b.y - y * b.x;
+    }
+
+    pt operator - (pt b) {
+        return pt(x - b.x, y - b.y);
+    }
+};
+
+ll sarea2(pt a, pt b, pt c)
+{
+    return (b - a) ^ (c - a);
+}
+
+int ccw(pt a, pt b, pt c)
+{
+    ll r = sarea2(a, b, c);
+    return (r > 0) - (r < 0);
+}
+
+void pre()
+{
+
+}
+
+#define TEST 0
+
+void solve()
+{
+    int n, m;
+    cin >> n >> m;
+
+    V<pt> pol(n);
+    cin >> pol;
+
+    vl pref(n * 3);
+    nrep(i, 1, n * 3) {
+        pref[i] = pref[i - 1] + sarea2(pt(0, 0), pol[(i - 1) % n], pol[i % n]);
+    }
+
+    ll ans = 0;
+    while (m--) {
+        int l, r;
+        cin >> l >> r;
+        l--, r--;
+
+        if (l > r) {
+            swap(l, r);
+        }
+
+        if ((l + 1) % n == r) {
+            continue;
+        }
+
+        int l2 = r;
+        int r2 = l + n;
+
+        ll ar1 = abs(sarea2(pt(0, 0), pol[r], pol[l]) + pref[r] - pref[l]);
+        ll ar2 = abs(pref[r2] - pref[l2] + sarea2(pt(0, 0), pol[r2 % n], pol[l2 % n]));
+
+        rmax(ans, min(ar1, ar2));
+    }
+
+    cout << ans / 2.0 << '\n';
+}
+
+int main()
+{
+    ios::sync_with_stdio(false);
+    cin.tie(nullptr);
+
+    pre();
+
+    int t;
+    (TEST && cin >> t) || (t = 1);
+    while (t--) {
+        solve();
+    }
+}

2018 ACM-ICPC, Universidad Nacional de Colombia Programming Contest/F. UN Finals.cpp

@@ -0,0 +1,229 @@
+/* Problem URL: https://codeforces.com/gym/101845/problem/F */
+
+#include <bits/stdc++.h>
+#include <ext/pb_ds/assoc_container.hpp>
+#include <ext/pb_ds/tree_policy.hpp>
+
+using namespace std;
+using namespace __gnu_pbds;
+
+template <class T, class comp = less<>>
+using ordered_set = tree<T, null_type , comp , rb_tree_tag , tree_order_statistics_node_update>;
+
+#define V vector
+
+#define rmin(a, b) a = min(a, b)
+#define rmax(a, b) a = max(a, b)
+
+#define rep(i, lim) for (int i = 0; i < (lim); i++)
+#define nrep(i, s, lim) for (int i = s; i < (lim); i++)
+
+#define repv(i, v) for (auto &i : (v))
+#define fillv(v) for (auto &itr_ : (v)) { cin >> itr_; }
+#define sortv(v) sort(v.begin(), v.end())
+#define all(v) (v).begin(), (v).end()
+
+using vi = vector<int>;
+using vvi = vector<vi>;
+using vvvi = vector<vvi>;
+using vvvvi = vector<vvvi>;
+
+using ll = long long;
+
+using vl = vector<ll>;
+using vvl = vector<vl>;
+using vvvl = vector<vvl>;
+using vvvvl = vector<vvvl>;
+
+template<class v>
+auto operator<<(ostream &os, const vector<v> &vec)->ostream& {
+    os << vec[0];
+    for (size_t i = 1; i < vec.size(); i++) {
+        os << ' ' << vec[i];
+    }
+    os << '\n';
+    return os;
+}
+
+template<class v>
+auto operator>>(istream &is, vector<v> &vec)->istream& {
+    for (auto &i : vec) {
+        is >> i;
+    }
+    return is;
+}
+
+template<class v>
+auto operator<<(ostream &os, const vector<vector<v>> &vec)->ostream& {
+    for (auto &i : vec) {
+        os << i[0];
+        for (size_t j = 1; j < i.size(); j++) {
+            os << ' ' << i[j];
+        }
+        os << '\n';
+    }
+    return os;
+}
+
+template<class v>
+auto operator>>(istream  &is, vector<vector<v>> &vec)->istream& {
+    for (auto &i : vec) {
+        for (auto &j : i) {
+            is >> j;
+        }
+    }
+    return is;
+}
+
+const int oo = INT32_MAX >> 1;
+const ll OO = INT64_MAX >> 1;
+
+
+void pre()
+{
+
+}
+
+#define TEST 0
+
+void solve()
+{
+    int n;
+    cin >> n;
+
+    auto count = [&](string &a, int c[26]) {
+        repv(i, a) {
+            c[i - 'A']++;
+        }
+    };
+
+    V<tuple<int, ll, ll>> edges;
+    vvi graph(n + 28);
+    int sz = graph.size();
+
+    int s = 0;
+    int t = n + 27;
+
+    auto add_edge = [&](int u, int v, ll c) {
+        graph[u].push_back(edges.size());
+        edges.emplace_back(v, c, 0);
+        graph[v].push_back(edges.size());
+        edges.emplace_back(u, 0, 0);
+    };
+
+    vl pos(n);
+    rep(i, n) {
+        string a, b, c;
+        cin >> a >> b >> c;
+
+        add_edge(s, i + 1, 1);
+
+        int cc[26] = {0};
+
+        count(a, cc);
+        count(b, cc);
+        count(c, cc);
+
+        int ma = *max_element(cc, cc + 26);
+
+        rep(j, 26) {
+            if (cc[j] == ma) {
+                add_edge(i + 1, j + n + 1, 1);
+            }
+        }
+    }
+
+    int k;
+    cin >> k;
+
+    rep(i, 26) {
+        add_edge(i + n + 1, t, k);
+    }
+
+    vi lvl(sz, oo);
+    vi p(sz);
+
+    auto bfs = [&]() {
+        lvl[s] = 0;
+        queue<int> q;
+        q.push(s);
+
+        while (!q.empty()) {
+            auto i = q.front();
+            q.pop();
+
+            repv(id, graph[i]) {
+                auto [j, l, c] = edges[id];
+                if (l != c && lvl[j] > lvl[i] + 1) {
+                    lvl[j] = lvl[i] + 1;
+                    q.push(j);
+                }
+            }
+        }
+
+        return lvl[t] != oo;
+    };
+
+    function<ll(int, ll)> dfs = [&](int i, ll f) {
+        if (f == 0) {
+            return 0LL;
+        }
+
+        if (i == t) {
+            return f;
+        }
+
+        for (int &d = p[i]; d < graph[i].size(); d++) {
+            int id = graph[i][d];
+            auto &[j, l, c] = edges[id];
+
+            if (l == c || lvl[j] <= lvl[i]) {
+                continue;
+            }
+
+            ll fr = dfs(j, min(f, l - c));
+            if (fr == 0) {
+                continue;
+            }
+
+            c += fr;
+            auto &[_, __, c2] = edges[id^1];
+            c2 -= fr;
+
+            return fr;
+        }
+
+        return 0LL;
+    };
+
+    ll ans = 0;
+
+    while (1) {
+        fill(all(lvl), oo);
+        if (!bfs()) {
+            break;
+        }
+
+        fill(all(p), 0);
+        ll add = 0;
+        while ((add = dfs(s, OO)) != 0) {
+            ans += add;
+        }
+    };
+
+    cout << ans << '\n';
+}
+
+int main()
+{
+    ios::sync_with_stdio(false);
+    cin.tie(nullptr);
+
+    pre();
+
+    int t;
+    (TEST && cin >> t) || (t = 1);
+    while (t--) {
+        solve();
+    }
+}

2018 ACM-ICPC, Universidad Nacional de Colombia Programming Contest/I. Intense Bit Wheel.cpp

@@ -0,0 +1,128 @@
+/* Problem URL: https://codeforces.com/gym/101845/problem/I */
+
+#include <bits/stdc++.h>
+#include <ext/pb_ds/assoc_container.hpp>
+#include <ext/pb_ds/tree_policy.hpp>
+
+using namespace std;
+using namespace __gnu_pbds;
+
+template <class T, class comp = less<>>
+using ordered_set = tree<T, null_type , comp , rb_tree_tag , tree_order_statistics_node_update>;
+
+#define V vector
+
+#define rmin(a, b) a = min(a, b)
+#define rmax(a, b) a = max(a, b)
+
+#define rep(i, lim) for (int i = 0; i < (lim); i++)
+#define nrep(i, s, lim) for (int i = s; i < (lim); i++)
+
+#define repv(i, v) for (auto &i : (v))
+#define fillv(v) for (auto &itr_ : (v)) { cin >> itr_; }
+#define sortv(v) sort(v.begin(), v.end())
+#define all(v) (v).begin(), (v).end()
+
+using vi = vector<int>;
+using vvi = vector<vi>;
+using vvvi = vector<vvi>;
+using vvvvi = vector<vvvi>;
+
+using ll = long long;
+
+using vl = vector<ll>;
+using vvl = vector<vl>;
+using vvvl = vector<vvl>;
+using vvvvl = vector<vvvl>;
+
+template<class v>
+auto operator<<(ostream &os, const vector<v> &vec)->ostream& {
+    os << vec[0];
+    for (size_t i = 1; i < vec.size(); i++) {
+        os << ' ' << vec[i];
+    }
+    os << '\n';
+    return os;
+}
+
+template<class v>
+auto operator>>(istream &is, vector<v> &vec)->istream& {
+    for (auto &i : vec) {
+        is >> i;
+    }
+    return is;
+}
+
+template<class v>
+auto operator<<(ostream &os, const vector<vector<v>> &vec)->ostream& {
+    for (auto &i : vec) {
+        os << i[0];
+        for (size_t j = 1; j < i.size(); j++) {
+            os << ' ' << i[j];
+        }
+        os << '\n';
+    }
+    return os;
+}
+
+template<class v>
+auto operator>>(istream  &is, vector<vector<v>> &vec)->istream& {
+    for (auto &i : vec) {
+        for (auto &j : i) {
+            is >> j;
+        }
+    }
+    return is;
+}
+
+const int oo = INT32_MAX >> 1;
+const ll OO = INT64_MAX >> 1;
+
+
+void pre()
+{
+
+}
+
+#define TEST 0
+
+void solve()
+{
+    int n, m;
+    cin >> n >> m;
+
+    while (m--) {
+        ll num, k;
+        cin >> num >> k;
+
+        k %= n;
+
+        ll ans = 0;
+        int cur = 0;
+        int lim = n - k;
+        nrep(i, lim, n) {
+            ans |= ((num >> i) & 1) << cur;
+            cur++;
+        }
+        rep(i, lim) {
+            ans |= ((num >> i) & 1) << cur;
+            cur++;
+        }
+
+        cout << ans << '\n';
+    }
+}
+
+int main()
+{
+    ios::sync_with_stdio(false);
+    cin.tie(nullptr);
+
+    pre();
+
+    int t;
+    (TEST && cin >> t) || (t = 1);
+    while (t--) {
+        solve();
+    }
+}

2019 China Collegiate Programming Contest Qinhuangdao Onsite/A. Angle Beats.cpp

@@ -0,0 +1,302 @@
+/* Problem URL: https://codeforces.com/gym/102361/problem/A */
+
+#include <bits/stdc++.h>
+#include <ext/pb_ds/assoc_container.hpp>
+#include <ext/pb_ds/tree_policy.hpp>
+
+using namespace std;
+using namespace __gnu_pbds;
+
+template <class T, class comp = less<>>
+using ordered_set = tree<T, null_type , comp , rb_tree_tag , tree_order_statistics_node_update>;
+
+#define V vector
+
+#define rmin(a, b) a = min(a, b)
+#define rmax(a, b) a = max(a, b)
+
+#define rep(i, lim) for (int i = 0; i < (lim); i++)
+#define nrep(i, s, lim) for (int i = s; i < (lim); i++)
+
+#define repv(i, v) for (auto &i : (v))
+#define fillv(v) for (auto &itr_ : (v)) { cin >> itr_; }
+#define sortv(v) sort(v.begin(), v.end())
+#define all(v) (v).begin(), (v).end()
+
+using vi = vector<int>;
+using vvi = vector<vi>;
+using vvvi = vector<vvi>;
+using vvvvi = vector<vvvi>;
+
+using ll = long long;
+
+using vl = vector<ll>;
+using vvl = vector<vl>;
+using vvvl = vector<vvl>;
+using vvvvl = vector<vvvl>;
+
+template<class v>
+auto operator<<(ostream &os, const vector<v> &vec)->ostream& {
+    os << vec[0];
+    for (size_t i = 1; i < vec.size(); i++) {
+        os << ' ' << vec[i];
+    }
+    os << '\n';
+    return os;
+}
+
+template<class v>
+auto operator>>(istream &is, vector<v> &vec)->istream& {
+    for (auto &i : vec) {
+        is >> i;
+    }
+    return is;
+}
+
+template<class v>
+auto operator<<(ostream &os, const vector<vector<v>> &vec)->ostream& {
+    for (auto &i : vec) {
+        os << i[0];
+        for (size_t j = 1; j < i.size(); j++) {
+            os << ' ' << i[j];
+        }
+        os << '\n';
+    }
+    return os;
+}
+
+template<class v>
+auto operator>>(istream  &is, vector<vector<v>> &vec)->istream& {
+    for (auto &i : vec) {
+        for (auto &j : i) {
+            is >> j;
+        }
+    }
+    return is;
+}
+
+const int oo = INT32_MAX >> 1;
+const ll OO = INT64_MAX >> 1;
+
+struct pt {
+    ll x, y;
+
+    pt() = default;
+    pt(ll x, ll y): x(x), y(y) {}
+
+    friend istream &operator >> (istream &is, pt &a) {
+        is >> a.x >> a.y;
+        return is;
+    }
+
+    ll operator ^ (pt b) {
+        return x * b.y - y * b.x;
+    }
+
+    ll operator * (pt b) {
+        return x * b.x + y * b.y;
+    }
+
+    pt operator - (pt b) {
+        return pt(x - b.x, y - b.y);
+    }
+};
+
+int ccw(pt a, pt b, pt c)
+{
+    ll r = (b - a) ^ (c - a);
+    return (r > 0) - (r < 0);
+}
+
+ll cdot(pt a, pt b, pt c)
+{
+    return (b - a) * (c - a);
+}
+
+int quad(pt a)
+{
+    if (a.x == 0 && a.y > 0) {
+        return 0;
+    }
+    if (a.x > 0 && a.y == 0) {
+        return 1;
+    }
+    if (a.x == 0 && a.y < 0) {
+        return 2;
+    }
+    if (a.x < 0 && a.y == 0) {
+        return 3;
+    }
+    static const int q[][2] = {{0, 1}, {3, 2}};
+    return q[a.x < 0][a.y < 0];
+}
+
+bool polar_cmp(pt a, pt b)
+{
+    if (quad(a) != quad(b)) {
+        return quad(a) != quad(b);
+    }
+    return ccw(pt(0, 0), a, b) < 0;
+}
+
+void pre()
+{
+
+}
+
+#define TEST 0
+
+void solve()
+{
+    int n, q;
+    cin >> n >> q;
+    V<pt> pts(n + q);
+    cin >> pts;
+
+    vi p(n + q);
+    iota(all(p), 0);
+    
+    auto cmpr = [&](vi &p, int i) {
+        if (p.empty()) {
+            return vector<pair<int, ll>>();
+        }
+        sort(all(p), [&](int j, int k){return polar_cmp(pts[j] - pts[i], pts[k] - pts[i]);});
+        V<pair<int, ll>> v;
+        int c = 1;
+        nrep(j, 1, p.size()) {
+            if (ccw(pts[i], pts[p[j]], pts[p[j - 1]]) == 0) {
+                c++;
+                continue;
+            }
+            v.emplace_back(p[j - 1], c);
+            c = 1;
+        }
+        v.emplace_back(p.back(), c);
+        return v;
+    };
+
+    vl ans(q);
+
+    rep(i, n) {
+        vvi qp(4);
+        nrep(j, n, n + q) {
+            qp[quad(pts[j] - pts[i])].push_back(j);
+        }
+
+        vvi np(4);
+        rep(j, n) {
+            if (i == j) {
+                continue;
+            }
+            np[quad(pts[j] - pts[i])].push_back(j);
+        }
+
+        V<V<pair<int, ll>>> cp = {cmpr(np[0], i), cmpr(np[1], i), cmpr(np[2], i), cmpr(np[3], i)};
+        auto cmp = [&](int j, int k) {
+            return polar_cmp(pts[j] - pts[i], pts[k] - pts[i]);
+        };
+        sort(all(qp[0]), cmp);
+        sort(all(qp[1]), cmp);
+        sort(all(qp[2]), cmp);
+        sort(all(qp[3]), cmp);
+
+        auto getcw = [&](vi &p, V<pair<int, ll>> &c) {
+            int j = 0;
+            int k = 0;
+            while (j < p.size() && k < c.size()) {
+                ll dot = cdot(pts[i], pts[p[j]], pts[c[k].first]);
+                if (dot == 0) {
+                    ans[p[j] - n] += c[k].second;
+                    j++;
+                    continue;
+                }
+
+                if (dot > 0) {
+                    k++;
+                    continue;
+                }
+
+                j++;
+            }
+        };
+
+        auto getccw = [&](vi &p, V<pair<int, ll>> &c) {
+            int j = (int)p.size() - 1;
+            int k = (int)c.size() - 1;
+            while (j >= 0 && k >= 0) {
+                ll dot = cdot(pts[i], pts[p[j]], pts[c[k].first]);
+                if (dot == 0) {
+                    ans[p[j] - n] += c[k].second;
+                    j--;
+                    continue;
+                }
+
+                if (dot > 0) {
+                    k--;
+                    continue;
+                }
+
+                j--;
+            }
+        };
+
+        rep(j, 4) {
+            getcw(qp[j], cp[(j + 1) % 4]);
+            getccw(qp[j], cp[((j - 1) % 4 + 4) % 4]);
+        }
+    }
+
+    nrep(i, n, n + q) {
+        vvi np(4);
+        rep(j, n) {
+            np[quad(pts[j] - pts[i])].push_back(j);
+        }
+
+        V<V<pair<int, ll>>> cp = {cmpr(np[0], i), cmpr(np[1], i), cmpr(np[2], i), cmpr(np[3], i)};
+
+        auto getcw = [&](V<pair<int, ll>> &p1, V<pair<int, ll>> &p2) {
+            int j = 0;
+            int k = 0;
+
+            while (j < p1.size() && k < p2.size()) {
+                ll dot = cdot(pts[i], pts[p1[j].first], pts[p2[k].first]);
+
+                if (dot == 0) {
+                    ans[i - n] += p1[j].second * p2[k].second;
+                    j++;
+                    k++;
+                    continue;
+                }
+
+                if (dot < 0) {
+                    j++;
+                    continue;
+                }
+
+                k++;
+            }
+        };
+
+        rep(j, 4) {
+            getcw(cp[j], cp[(j + 1) % 4]);
+        }
+    }
+
+    repv(i, ans) {
+        cout << i << '\n';
+    }
+}
+
+int main()
+{
+    ios::sync_with_stdio(false);
+    cin.tie(nullptr);
+
+    pre();
+
+    int t;
+    (TEST && cin >> t) || (t = 1);
+    while (t--) {
+        solve();
+    }
+}

2019 China Collegiate Programming Contest Qinhuangdao Onsite/A. Angle Beats.sync-conflict-20260309-204720-OCZTPMA.cpp

@@ -0,0 +1,223 @@
+/* Problem URL: https://codeforces.com/gym/102361/problem/A */
+
+#include <bits/stdc++.h>
+#include <ext/pb_ds/assoc_container.hpp>
+#include <ext/pb_ds/tree_policy.hpp>
+
+using namespace std;
+using namespace __gnu_pbds;
+
+template <class T, class comp = less<>>
+using ordered_set = tree<T, null_type , comp , rb_tree_tag , tree_order_statistics_node_update>;
+
+#define V vector
+
+#define rmin(a, b) a = min(a, b)
+#define rmax(a, b) a = max(a, b)
+
+#define rep(i, lim) for (int i = 0; i < (lim); i++)
+#define nrep(i, s, lim) for (int i = s; i < (lim); i++)
+
+#define repv(i, v) for (auto &i : (v))
+#define fillv(v) for (auto &itr_ : (v)) { cin >> itr_; }
+#define sortv(v) sort(v.begin(), v.end())
+#define all(v) (v).begin(), (v).end()
+
+using vi = vector<int>;
+using vvi = vector<vi>;
+using vvvi = vector<vvi>;
+using vvvvi = vector<vvvi>;
+
+using ll = long long;
+
+using vl = vector<ll>;
+using vvl = vector<vl>;
+using vvvl = vector<vvl>;
+using vvvvl = vector<vvvl>;
+
+template<class v>
+auto operator<<(ostream &os, const vector<v> &vec)->ostream& {
+    os << vec[0];
+    for (size_t i = 1; i < vec.size(); i++) {
+        os << ' ' << vec[i];
+    }
+    os << '\n';
+    return os;
+}
+
+template<class v>
+auto operator>>(istream &is, vector<v> &vec)->istream& {
+    for (auto &i : vec) {
+        is >> i;
+    }
+    return is;
+}
+
+template<class v>
+auto operator<<(ostream &os, const vector<vector<v>> &vec)->ostream& {
+    for (auto &i : vec) {
+        os << i[0];
+        for (size_t j = 1; j < i.size(); j++) {
+            os << ' ' << i[j];
+        }
+        os << '\n';
+    }
+    return os;
+}
+
+template<class v>
+auto operator>>(istream  &is, vector<vector<v>> &vec)->istream& {
+    for (auto &i : vec) {
+        for (auto &j : i) {
+            is >> j;
+        }
+    }
+    return is;
+}
+
+const int oo = INT32_MAX >> 1;
+const ll OO = INT64_MAX >> 1;
+
+struct pt {
+    ll x, y;
+
+    pt() = default;
+    pt(ll x, ll y): x(x), y(y) {}
+
+    friend istream &operator >> (istream &is, pt &a) {
+        is >> a.x >> a.y;
+        return is;
+    }
+
+    pt operator - (pt b) {
+        return pt(x - b.x, y - b.y);
+    }
+
+    ll operator ^ (pt b) {
+        return x * b.y - y * b.x;
+    }
+
+    ll operator * (pt b) {
+        return x * b.x + y * b.y;
+    }
+    
+    bool operator < (pt b) const {
+        if (x == b.x) {
+            return y < b.y;
+        }
+        return x < b.x;
+    }
+};
+
+int quad(pt a)
+{
+    static const int q[][2] = {{0, 1}, {3, 2}};
+    return q[a.x < 0][a.y < 0];
+}
+
+int ccw(pt a, pt b, pt c)
+{
+    ll r = (b - a) ^ (c - b);
+    return (r > 0) - (r < 0);
+}
+
+bool polar_cmp(pt a, pt b)
+{
+    if (quad(a) != quad(b)) {
+        return quad(a) < quad(b);
+    }
+    return ccw(pt(0, 0), a, b) < 0;
+}
+
+ll dot(pt a, pt b, pt c)
+{
+    return (b - a) * (c - a);
+}
+
+void pre()
+{
+
+}
+
+#define TEST 0
+
+void solve()
+{
+    int n, q;
+    cin >> n >> q;
+
+    V<pt> a(n + q);
+    cin >> a;
+
+    vl ans(q);
+    vi p(n + q);
+    iota(all(p), 0);
+
+    rep(i, n + q) {
+        sort(all(p), [&](int j, int k){
+             return polar_cmp(a[j] - a[i], a[k] - a[i]);
+             });
+
+        int j = 0;
+        int now = 1;
+        while (j < n + q) {
+            int p1 = p[j];
+            int p2 = p[now];
+
+            if (p1 == i) {
+                j++;
+                continue;
+            }
+
+            if (now == j || p2 == i) {
+                now = (now + 1) % (q + n);
+                continue;
+            }
+
+            if (ccw(a[i], a[p1], a[p2]) >= 0) {
+                j++;
+                continue;
+            }
+
+            ll d = dot(a[i], a[p1], a[p2]);
+
+            if (d < 0) {
+                j++;
+                continue;
+            }
+
+            if (d > 0) {
+                now = (now + 1) % (q + n);
+                continue;
+            }
+
+            if (i >= n && p1 < n && p2 < n) {
+                ans[i - n]++;
+            } else if (i < n && p1 >= n && p2 < n) {
+                ans[p1 - n]++;
+            } else if (i < n && p1 < n && p2 >= n) {
+                ans[p2 - n]++;
+            }
+
+            j++;
+        }
+    }
+
+    repv(i, ans) {
+        cout << i << '\n';
+    }
+}
+
+int main()
+{
+    ios::sync_with_stdio(false);
+    cin.tie(nullptr);
+
+    pre();
+
+    int t;
+    (TEST && cin >> t) || (t = 1);
+    while (t--) {
+        solve();
+    }
+}

2024 ICPC Asia Taichung Regional Contest (Unrated, Online Mirror, ICPC Rules, Preferably Teams)/D. Drunken Maze.cpp

@@ -0,0 +1,174 @@
+/* Problem URL: https://codeforces.com/problemset/problem/2041/D */
+
+#include <bits/stdc++.h>
+#include <ext/pb_ds/assoc_container.hpp>
+#include <ext/pb_ds/tree_policy.hpp>
+
+using namespace std;
+using namespace __gnu_pbds;
+
+template <class T, class comp = less<>>
+using ordered_set = tree<T, null_type , comp , rb_tree_tag , tree_order_statistics_node_update>;
+
+#define V vector
+
+#define rmin(a, b) a = min(a, b)
+#define rmax(a, b) a = max(a, b)
+
+#define rep(i, lim) for (int i = 0; i < (lim); i++)
+#define nrep(i, s, lim) for (int i = s; i < (lim); i++)
+
+#define repv(i, v) for (auto &i : (v))
+#define fillv(v) for (auto &itr_ : (v)) { cin >> itr_; }
+#define sortv(v) sort(v.begin(), v.end())
+#define all(v) (v).begin(), (v).end()
+
+using vi = vector<int>;
+using vvi = vector<vi>;
+using vvvi = vector<vvi>;
+using vvvvi = vector<vvvi>;
+
+using ll = long long;
+
+using vl = vector<ll>;
+using vvl = vector<vl>;
+using vvvl = vector<vvl>;
+using vvvvl = vector<vvvl>;
+
+template<class v>
+auto operator<<(ostream &os, const vector<v> &vec)->ostream& {
+    os << vec[0];
+    for (size_t i = 1; i < vec.size(); i++) {
+        os << ' ' << vec[i];
+    }
+    os << '\n';
+    return os;
+}
+
+template<class v>
+auto operator>>(istream &is, vector<v> &vec)->istream& {
+    for (auto &i : vec) {
+        is >> i;
+    }
+    return is;
+}
+
+template<class v>
+auto operator<<(ostream &os, const vector<vector<v>> &vec)->ostream& {
+    for (auto &i : vec) {
+        os << i[0];
+        for (size_t j = 1; j < i.size(); j++) {
+            os << ' ' << i[j];
+        }
+        os << '\n';
+    }
+    return os;
+}
+
+template<class v>
+auto operator>>(istream  &is, vector<vector<v>> &vec)->istream& {
+    for (auto &i : vec) {
+        for (auto &j : i) {
+            is >> j;
+        }
+    }
+    return is;
+}
+
+const int oo = INT32_MAX >> 1;
+const ll OO = INT64_MAX >> 1;
+
+
+void pre()
+{
+
+}
+
+#define TEST 0
+
+void solve()
+{
+    int n, m;
+    cin >> n >> m;
+
+    V<string> a(n);
+    cin >> a;
+
+    vvvvi dis(n, vvvi(m, vvi(4, vi(4, oo))));
+    auto find_s = [&]() -> pair<pair<int, int>, pair<int, int>> {
+        int si;
+        int sj;
+        int ei;
+        int ej;
+        rep(i, n) {
+            rep(j, m) {
+                if (a[i][j] == 'S') {
+                    si = i;
+                    sj = j;
+                    continue;
+                }
+
+                if (a[i][j] == 'T') {
+                    ei = i;
+                    ej = j;
+                }
+            }
+        }
+
+        return {{si, sj}, {ei, ej}};
+    };
+
+    auto [s, t] = find_s();
+    auto [si, sj] = s;
+    auto [ei, ej] = t;
+
+    queue<tuple<int, int, int, int>> q;
+    dis[si][sj][0][0] = 0;
+    dis[si][sj][1][0] = 0;
+    dis[si][sj][2][0] = 0;
+    dis[si][sj][3][0] = 0;
+    q.emplace(si, sj, 0, 0);
+    q.emplace(si, sj, 1, 0);
+    q.emplace(si, sj, 2, 0);
+    q.emplace(si, sj, 3, 0);
+    int ans = oo;
+    while (!q.empty()) {
+        auto [i, j, d, t] = q.front();
+        q.pop();
+
+        if (i == ei && j == ej) {
+            rmin(ans, dis[i][j][d][t]);
+        }
+
+        int add[][2] = {{0, 1}, {0, -1}, {1, 0}, {-1, 0}};
+        rep(k, 4) {
+            int id = i + add[k][0];
+            int jd = j + add[k][1];
+
+            int td = k == d ? t + 1 : 1;
+
+            if (a[id][jd] == '#' || td > 3 || dis[id][jd][k][td] <= dis[i][j][d][t] + 1) {
+                continue;
+            }
+
+            dis[id][jd][k][td] = dis[i][j][d][t] + 1;
+            q.emplace(id, jd, k, td);
+        }
+    }
+
+    cout << (ans == oo ? -1 : ans) << '\n';
+}
+
+int main()
+{
+    ios::sync_with_stdio(false);
+    cin.tie(nullptr);
+
+    pre();
+
+    int t;
+    (TEST && cin >> t) || (t = 1);
+    while (t--) {
+        solve();
+    }
+}

2024-2025 ICPC Asia Jakarta Regional Contest (Unrated, Online Mirror, ICPC Rules, Teams Preferred)/C. Saraga.cpp

@@ -0,0 +1,146 @@
+/* Problem URL: https://codeforces.com/problemset/problem/2045/C */
+
+#include <bits/stdc++.h>
+#include <ext/pb_ds/assoc_container.hpp>
+#include <ext/pb_ds/tree_policy.hpp>
+
+using namespace std;
+using namespace __gnu_pbds;
+
+template <class T, class comp = less<>>
+using ordered_set = tree<T, null_type , comp , rb_tree_tag , tree_order_statistics_node_update>;
+
+#define V vector
+
+#define rmin(a, b) a = min(a, b)
+#define rmax(a, b) a = max(a, b)
+
+#define rep(i, lim) for (int i = 0; i < (lim); i++)
+#define nrep(i, s, lim) for (int i = s; i < (lim); i++)
+
+#define repv(i, v) for (auto &i : (v))
+#define fillv(v) for (auto &itr_ : (v)) { cin >> itr_; }
+#define sortv(v) sort(v.begin(), v.end())
+#define all(v) (v).begin(), (v).end()
+
+using vi = vector<int>;
+using vvi = vector<vi>;
+using vvvi = vector<vvi>;
+using vvvvi = vector<vvvi>;
+
+using ll = long long;
+
+using vl = vector<ll>;
+using vvl = vector<vl>;
+using vvvl = vector<vvl>;
+using vvvvl = vector<vvvl>;
+
+template<class v>
+auto operator<<(ostream &os, const vector<v> &vec)->ostream& {
+    os << vec[0];
+    for (size_t i = 1; i < vec.size(); i++) {
+        os << ' ' << vec[i];
+    }
+    os << '\n';
+    return os;
+}
+
+template<class v>
+auto operator>>(istream &is, vector<v> &vec)->istream& {
+    for (auto &i : vec) {
+        is >> i;
+    }
+    return is;
+}
+
+template<class v>
+auto operator<<(ostream &os, const vector<vector<v>> &vec)->ostream& {
+    for (auto &i : vec) {
+        os << i[0];
+        for (size_t j = 1; j < i.size(); j++) {
+            os << ' ' << i[j];
+        }
+        os << '\n';
+    }
+    return os;
+}
+
+template<class v>
+auto operator>>(istream  &is, vector<vector<v>> &vec)->istream& {
+    for (auto &i : vec) {
+        for (auto &j : i) {
+            is >> j;
+        }
+    }
+    return is;
+}
+
+const int oo = INT32_MAX >> 1;
+const ll OO = INT64_MAX >> 1;
+
+
+void pre()
+{
+
+}
+
+#define TEST 0
+
+void solve()
+{
+    string s, t;
+    cin >> s >> t;
+
+    int in = -1;
+    int jn = -1;
+    int ans = oo;
+
+    vi pos(26, -1);
+    rep(i, t.size() - 1) {
+        pos[t[i] - 'a'] = i;
+    }
+
+    nrep(i, 1, s.size()) {
+        int cur = s[i] - 'a';
+
+        if (pos[cur] == -1) {
+            continue;
+        }
+
+        int c = i + t.size() - pos[cur] + 1;
+        if (c < ans) {
+            ans = c;
+            in = i;
+            jn = pos[cur];
+        }
+    }
+
+    if (ans == oo) {
+        cout << "-1\n";
+        return;
+    }
+
+    rep(i, in) {
+        cout << s[i];
+    }
+    
+    nrep(j, jn, t.size()) {
+        cout << t[j];
+    }
+
+    cout << '\n';
+}
+
+int main()
+{
+    ios::sync_with_stdio(false);
+    cin.tie(nullptr);
+
+    pre();
+
+    int t;
+    (TEST && cin >> t) || (t = 1);
+    while (t--) {
+        solve();
+    }
+}

2024-2025 ICPC Asia Jakarta Regional Contest (Unrated, Online Mirror, ICPC Rules, Teams Preferred)/M. Mirror Maze.cpp

@@ -0,0 +1,248 @@
+/* Problem URL: https://codeforces.com/problemset/problem/2045/M */
+
+#include <bits/stdc++.h>
+#include <ext/pb_ds/assoc_container.hpp>
+#include <ext/pb_ds/tree_policy.hpp>
+
+using namespace std;
+using namespace __gnu_pbds;
+
+template <class T, class comp = less<>>
+using ordered_set = tree<T, null_type , comp , rb_tree_tag , tree_order_statistics_node_update>;
+
+#define V vector
+
+#define rmin(a, b) a = min(a, b)
+#define rmax(a, b) a = max(a, b)
+
+#define rep(i, lim) for (int i = 0; i < (lim); i++)
+#define nrep(i, s, lim) for (int i = s; i < (lim); i++)
+
+#define repv(i, v) for (auto &i : (v))
+#define fillv(v) for (auto &itr_ : (v)) { cin >> itr_; }
+#define sortv(v) sort(v.begin(), v.end())
+#define all(v) (v).begin(), (v).end()
+
+using vi = vector<int>;
+using vvi = vector<vi>;
+using vvvi = vector<vvi>;
+using vvvvi = vector<vvvi>;
+
+using ll = long long;
+
+using vl = vector<ll>;
+using vvl = vector<vl>;
+using vvvl = vector<vvl>;
+using vvvvl = vector<vvvl>;
+
+template<class v>
+auto operator<<(ostream &os, const vector<v> &vec)->ostream& {
+    os << vec[0];
+    for (size_t i = 1; i < vec.size(); i++) {
+        os << ' ' << vec[i];
+    }
+    os << '\n';
+    return os;
+}
+
+template<class v>
+auto operator>>(istream &is, vector<v> &vec)->istream& {
+    for (auto &i : vec) {
+        is >> i;
+    }
+    return is;
+}
+
+template<class v>
+auto operator<<(ostream &os, const vector<vector<v>> &vec)->ostream& {
+    for (auto &i : vec) {
+        os << i[0];
+        for (size_t j = 1; j < i.size(); j++) {
+            os << ' ' << i[j];
+        }
+        os << '\n';
+    }
+    return os;
+}
+
+template<class v>
+auto operator>>(istream  &is, vector<vector<v>> &vec)->istream& {
+    for (auto &i : vec) {
+        for (auto &j : i) {
+            is >> j;
+        }
+    }
+    return is;
+}
+
+const int oo = INT32_MAX >> 1;
+const ll OO = INT64_MAX >> 1;
+
+
+void pre()
+{
+
+}
+
+#define TEST 0
+
+void solve()
+{
+    int r, c;
+    cin >> r >> c;
+
+    V<string> a(r);
+    cin >> a;
+
+    auto getpos = [&](int i, int j, int k) {
+        return i * c * 4 + j * 4 + k;
+    };
+
+    int tot = 0;
+
+    vvi graph(r * c * 4);
+    vi ty(r * c * 4, -1);
+    rep(i, r) {
+        rep(j, c) {
+            int n = getpos(i, j, 0);
+            int e = getpos(i, j, 1);
+            int s = getpos(i, j, 2);
+            int w = getpos(i, j, 3);
+
+            if (i > 0) {
+                int ot = getpos(i - 1, j, 2);
+                graph[n].push_back(ot);
+            }
+
+            if (j > 0) {
+                int ot = getpos(i, j - 1, 1);
+                graph[w].push_back(ot);
+            }
+
+            if (i < r - 1) {
+                int ot = getpos(i + 1, j, 0);
+                graph[s].push_back(ot);
+            }
+
+            if (j < c - 1) {
+                int ot = getpos(i, j + 1, 3);
+                graph[e].push_back(ot);
+            }
+
+            if (a[i][j] == '.') {
+                graph[e].push_back(w);
+                graph[w].push_back(e);
+                graph[s].push_back(n);
+                graph[n].push_back(s);
+                continue;
+            }
+            tot++;
+            ty[n] = i * c + j;
+            ty[e] = i * c + j;
+            ty[s] = i * c + j;
+            ty[w] = i * c + j;
+
+            if (a[i][j] == '/') {
+                graph[n].push_back(w);
+                graph[w].push_back(n);
+                graph[s].push_back(e);
+                graph[e].push_back(s);
+                continue;
+            }
+
+            graph[n].push_back(e);
+            graph[e].push_back(n);
+            graph[w].push_back(s);
+            graph[s].push_back(w);
+        }
+    }
+
+    V<bool> vis(r * c * 4);
+    vi sz(r * c * 4, -1);
+
+    set<int> s;
+    function<void(int)> dfs = [&](int i) {
+        vis[i] = true;
+        if (ty[i] != -1) {
+            s.insert(ty[i]);
+        }
+
+        repv(j, graph[i]) {
+            if (vis[j]) {
+                continue;
+            }
+
+            dfs(j);
+        }
+    };
+
+    function<void(int)> dfs2 = [&](int i) {
+        sz[i] = s.size();
+
+        repv(j, graph[i]) {
+            if (sz[j] != -1) {
+                continue;
+            }
+
+            dfs2(j);
+        }
+    };
+
+    rep(i, r) {
+        rep(j, c) {
+            rep(k, 4) {
+                int ac = getpos(i, j, k);
+                if (vis[ac]) {
+                    continue;
+                }
+
+                dfs(ac);
+                dfs2(ac);
+                s.clear();
+            }
+        }
+    }
+
+    V<string> ans;
+    rep(i, r) {
+        int w = getpos(i, 0, 3);
+        if (sz[w] == tot) {
+            ans.emplace_back("W" + to_string(i + 1));
+        }
+        int e = getpos(i, c - 1, 1);
+        if (sz[e] == tot) {
+            ans.emplace_back("E" + to_string(i + 1));
+        }
+    }
+
+    rep(i, c) {
+        int n = getpos(0, i, 0);
+        if (sz[n] == tot) {
+            ans.emplace_back("N" + to_string(i + 1));
+        }
+        int s = getpos(r - 1, i, 2);
+        if (sz[s] == tot) {
+            ans.emplace_back("S" + to_string(i + 1));
+        }
+    }
+
+    cout << ans.size() << '\n';
+    repv(i, ans) {
+        cout << i << ' ';
+    }
+    cout << '\n';
+}
+
+int main()
+{
+    ios::sync_with_stdio(false);
+    cin.tie(nullptr);
+
+    pre();
+
+    int t;
+    (TEST && cin >> t) || (t = 1);
+    while (t--) {
+        solve();
+    }
+}

2024-2025 ICPC, NERC, Northern Eurasia Finals (Unrated, Online Mirror, ICPC Rules, Teams Preferred)/A. Adrenaline Rush.cpp

@@ -0,0 +1,157 @@
+/* Problem URL: https://codeforces.com/problemset/problem/2052/A */
+
+#include <bits/stdc++.h>
+#include <ext/pb_ds/assoc_container.hpp>
+#include <ext/pb_ds/tree_policy.hpp>
+
+using namespace std;
+using namespace __gnu_pbds;
+
+template <class T, class comp = less<>>
+using ordered_set = tree<T, null_type , comp , rb_tree_tag , tree_order_statistics_node_update>;
+
+#define V vector
+
+#define rmin(a, b) a = min(a, b)
+#define rmax(a, b) a = max(a, b)
+
+#define rep(i, lim) for (int i = 0; i < (lim); i++)
+#define nrep(i, s, lim) for (int i = s; i < (lim); i++)
+
+#define repv(i, v) for (auto &i : (v))
+#define fillv(v) for (auto &itr_ : (v)) { cin >> itr_; }
+#define sortv(v) sort(v.begin(), v.end())
+#define all(v) (v).begin(), (v).end()
+
+using vi = vector<int>;
+using vvi = vector<vi>;
+using vvvi = vector<vvi>;
+using vvvvi = vector<vvvi>;
+
+using ll = long long;
+
+using vl = vector<ll>;
+using vvl = vector<vl>;
+using vvvl = vector<vvl>;
+using vvvvl = vector<vvvl>;
+
+template<class v>
+auto operator<<(ostream &os, const vector<v> &vec)->ostream& {
+    os << vec[0];
+    for (size_t i = 1; i < vec.size(); i++) {
+        os << ' ' << vec[i];
+    }
+    os << '\n';
+    return os;
+}
+
+template<class v>
+auto operator>>(istream &is, vector<v> &vec)->istream& {
+    for (auto &i : vec) {
+        is >> i;
+    }
+    return is;
+}
+
+template<class v>
+auto operator<<(ostream &os, const vector<vector<v>> &vec)->ostream& {
+    for (auto &i : vec) {
+        os << i[0];
+        for (size_t j = 1; j < i.size(); j++) {
+            os << ' ' << i[j];
+        }
+        os << '\n';
+    }
+    return os;
+}
+
+template<class v>
+auto operator>>(istream  &is, vector<vector<v>> &vec)->istream& {
+    for (auto &i : vec) {
+        for (auto &j : i) {
+            is >> j;
+        }
+    }
+    return is;
+}
+
+const int oo = INT32_MAX >> 1;
+const ll OO = INT64_MAX >> 1;
+
+
+void pre()
+{
+
+}
+
+#define TEST 0
+
+void solve()
+{
+    int n;
+    cin >> n;
+    vi p(n);
+    cin >> p;
+    reverse(all(p));
+
+    V<pair<int, int>> ans;
+    V<bool> us(n + 1);
+
+    // rep(i, n) {
+    //     int c = p[i];
+    //     for (int j = c - 1; j > 0; j--) {
+    //         if (us[j - 1]) {
+    //             continue;
+    //         }
+    //
+    //         ans.emplace_back(c, j);
+    //     }
+    //
+    //     for (int j = c + 1; j <= n; j++) {
+    //         if (us[j - 1]) {
+    //             continue;
+    //         }
+    //
+    //         ans.emplace_back(j, c);
+    //         ans.emplace_back(c, j);
+    //     }
+    // }
+
+    rep(i, n) {
+        int c = p[i];
+        us[c] = true;
+
+        for (int j = c - 1; j > 0; j--) {
+            if (us[j]) {
+                continue;
+            }
+            ans.emplace_back(c, j);
+        }
+
+        for (int j = 1; j <= n; j++) {
+            if (us[j]) {
+                continue;
+            }
+            ans.emplace_back(j, c);
+        }
+    }
+
+    cout << ans.size() << '\n';
+    repv(i, ans) {
+        cout << i.first << ' ' << i.second << '\n';
+    }
+}
+
+int main()
+{
+    ios::sync_with_stdio(false);
+    cin.tie(nullptr);
+
+    pre();
+
+    int t;
+    (TEST && cin >> t) || (t = 1);
+    while (t--) {
+        solve();
+    }
+}

2024-2025 ICPC, NERC, Southern and Volga Russian Regional Contest (Unrated, Online Mirror, ICPC Rules, Preferably Teams)/A. Bonus Project.cpp

@@ -0,0 +1,140 @@
+/* Problem URL: https://codeforces.com/problemset/problem/2038/A */
+
+#include <bits/stdc++.h>
+#include <ext/pb_ds/assoc_container.hpp>
+#include <ext/pb_ds/tree_policy.hpp>
+
+using namespace std;
+using namespace __gnu_pbds;
+
+template <class T, class comp = less<>>
+using ordered_set = tree<T, null_type , comp , rb_tree_tag , tree_order_statistics_node_update>;
+
+#define V vector
+
+#define rmin(a, b) a = min(a, b)
+#define rmax(a, b) a = max(a, b)
+
+#define rep(i, lim) for (int i = 0; i < (lim); i++)
+#define nrep(i, s, lim) for (int i = s; i < (lim); i++)
+
+#define repv(i, v) for (auto &i : (v))
+#define fillv(v) for (auto &itr_ : (v)) { cin >> itr_; }
+#define sortv(v) sort(v.begin(), v.end())
+#define all(v) (v).begin(), (v).end()
+
+using vi = vector<int>;
+using vvi = vector<vi>;
+using vvvi = vector<vvi>;
+using vvvvi = vector<vvvi>;
+
+using ll = long long;
+
+using vl = vector<ll>;
+using vvl = vector<vl>;
+using vvvl = vector<vvl>;
+using vvvvl = vector<vvvl>;
+
+template<class v>
+auto operator<<(ostream &os, const vector<v> &vec)->ostream& {
+    os << vec[0];
+    for (size_t i = 1; i < vec.size(); i++) {
+        os << ' ' << vec[i];
+    }
+    os << '\n';
+    return os;
+}
+
+template<class v>
+auto operator>>(istream &is, vector<v> &vec)->istream& {
+    for (auto &i : vec) {
+        is >> i;
+    }
+    return is;
+}
+
+template<class v>
+auto operator<<(ostream &os, const vector<vector<v>> &vec)->ostream& {
+    for (auto &i : vec) {
+        os << i[0];
+        for (size_t j = 1; j < i.size(); j++) {
+            os << ' ' << i[j];
+        }
+        os << '\n';
+    }
+    return os;
+}
+
+template<class v>
+auto operator>>(istream  &is, vector<vector<v>> &vec)->istream& {
+    for (auto &i : vec) {
+        for (auto &j : i) {
+            is >> j;
+        }
+    }
+    return is;
+}
+
+const int oo = INT32_MAX >> 1;
+const ll OO = INT64_MAX >> 1;
+
+
+void pre()
+{
+
+}
+
+#define TEST 0
+
+void solve()
+{
+    int n, k;
+    cin >> n >> k;
+
+    vl a(n);
+    vl b(n);
+    cin >> a >> b;
+
+    ll total = 0;
+    vl ans(n);
+    rep(i, n) {
+        ans[i] = a[i] / b[i];
+        total += ans[i];
+    }
+
+    if (total < k) {
+        rep(i, n) {
+            cout << "0" << " \n"[i == n - 1];
+        }
+        return;
+    }
+
+    int inc = total - k;
+
+    rep(i, n) {
+        if (ans[i] < inc) {
+            inc -= ans[i];
+            ans[i] = 0;
+            continue;
+        }
+
+        ans[i] -= inc;
+        break;
+    }
+
+    cout << ans;
+}
+
+int main()
+{
+    ios::sync_with_stdio(false);
+    cin.tie(nullptr);
+
+    pre();
+
+    int t;
+    (TEST && cin >> t) || (t = 1);
+    while (t--) {
+        solve();
+    }
+}

2025-2026 ICPC, NERC, Northern Eurasia Finals (Unrated, Online Mirror, ICPC Rules, Teams Preferred)/F. Fragmented Nim.cpp

@@ -0,0 +1,118 @@
+/* Problem URL: https://codeforces.com/problemset/problem/2181/F */
+
+#include <bits/stdc++.h>
+#include <ext/pb_ds/assoc_container.hpp>
+#include <ext/pb_ds/tree_policy.hpp>
+
+using namespace std;
+using namespace __gnu_pbds;
+
+template <class T, class comp = less<>>
+using ordered_set = tree<T, null_type , comp , rb_tree_tag , tree_order_statistics_node_update>;
+
+#define V vector
+
+#define rmin(a, b) a = min(a, b)
+#define rmax(a, b) a = max(a, b)
+
+#define rep(i, lim) for (int i = 0; i < (lim); i++)
+#define nrep(i, s, lim) for (int i = s; i < (lim); i++)
+
+#define repv(i, v) for (auto &i : (v))
+#define fillv(v) for (auto &itr_ : (v)) { cin >> itr_; }
+#define sortv(v) sort(v.begin(), v.end())
+#define all(v) (v).begin(), (v).end()
+
+using vi = vector<int>;
+using vvi = vector<vi>;
+using vvvi = vector<vvi>;
+using vvvvi = vector<vvvi>;
+
+using ll = long long;
+
+using vl = vector<ll>;
+using vvl = vector<vl>;
+using vvvl = vector<vvl>;
+using vvvvl = vector<vvvl>;
+
+template<class v>
+auto operator<<(ostream &os, const vector<v> &vec)->ostream& {
+    os << vec[0];
+    for (size_t i = 1; i < vec.size(); i++) {
+        os << ' ' << vec[i];
+    }
+    os << '\n';
+    return os;
+}
+
+template<class v>
+auto operator>>(istream &is, vector<v> &vec)->istream& {
+    for (auto &i : vec) {
+        is >> i;
+    }
+    return is;
+}
+
+template<class v>
+auto operator<<(ostream &os, const vector<vector<v>> &vec)->ostream& {
+    for (auto &i : vec) {
+        os << i[0];
+        for (size_t j = 1; j < i.size(); j++) {
+            os << ' ' << i[j];
+        }
+        os << '\n';
+    }
+    return os;
+}
+
+template<class v>
+auto operator>>(istream  &is, vector<vector<v>> &vec)->istream& {
+    for (auto &i : vec) {
+        for (auto &j : i) {
+            is >> j;
+        }
+    }
+    return is;
+}
+
+const int oo = INT32_MAX >> 1;
+const ll OO = INT64_MAX >> 1;
+
+
+void pre()
+{
+
+}
+
+#define TEST 1
+
+void solve()
+{
+    int n;
+    cin >> n;
+    vl a(n);
+    cin >> a;
+
+    int c = 0;
+    bool t = false;
+    rep(i, n) {
+        c += a[i] == 1;
+        t = t || a[i] != 1;
+    }
+
+    cout << (((c & 1) && !t) || ((~c & 1) && t) ? "Alice\n" : "Bob\n");
+}
+
+int main()
+{
+    ios::sync_with_stdio(false);
+    cin.tie(nullptr);
+
+    pre();
+
+    int t;
+    (TEST && cin >> t) || (t = 1);
+    while (t--) {
+        solve();
+    }
+}

2025-2026 ICPC, NERC, Northern Eurasia Finals (Unrated, Online Mirror, ICPC Rules, Teams Preferred)/M. Medical Parity.cpp

@@ -0,0 +1,119 @@
+/* Problem URL: https://codeforces.com/problemset/problem/2181/M */
+
+#include <bits/stdc++.h>
+#include <ext/pb_ds/assoc_container.hpp>
+#include <ext/pb_ds/tree_policy.hpp>
+
+using namespace std;
+using namespace __gnu_pbds;
+
+template <class T, class comp = less<>>
+using ordered_set = tree<T, null_type , comp , rb_tree_tag , tree_order_statistics_node_update>;
+
+#define V vector
+
+#define rmin(a, b) a = min(a, b)
+#define rmax(a, b) a = max(a, b)
+
+#define rep(i, lim) for (int i = 0; i < (lim); i++)
+#define nrep(i, s, lim) for (int i = s; i < (lim); i++)
+
+#define repv(i, v) for (auto &i : (v))
+#define fillv(v) for (auto &itr_ : (v)) { cin >> itr_; }
+#define sortv(v) sort(v.begin(), v.end())
+#define all(v) (v).begin(), (v).end()
+
+using vi = vector<int>;
+using vvi = vector<vi>;
+using vvvi = vector<vvi>;
+using vvvvi = vector<vvvi>;
+
+using ll = long long;
+
+using vl = vector<ll>;
+using vvl = vector<vl>;
+using vvvl = vector<vvl>;
+using vvvvl = vector<vvvl>;
+
+template<class v>
+auto operator<<(ostream &os, const vector<v> &vec)->ostream& {
+    os << vec[0];
+    for (size_t i = 1; i < vec.size(); i++) {
+        os << ' ' << vec[i];
+    }
+    os << '\n';
+    return os;
+}
+
+template<class v>
+auto operator>>(istream &is, vector<v> &vec)->istream& {
+    for (auto &i : vec) {
+        is >> i;
+    }
+    return is;
+}
+
+template<class v>
+auto operator<<(ostream &os, const vector<vector<v>> &vec)->ostream& {
+    for (auto &i : vec) {
+        os << i[0];
+        for (size_t j = 1; j < i.size(); j++) {
+            os << ' ' << i[j];
+        }
+        os << '\n';
+    }
+    return os;
+}
+
+template<class v>
+auto operator>>(istream  &is, vector<vector<v>> &vec)->istream& {
+    for (auto &i : vec) {
+        for (auto &j : i) {
+            is >> j;
+        }
+    }
+    return is;
+}
+
+const int oo = INT32_MAX >> 1;
+const ll OO = INT64_MAX >> 1;
+
+
+void pre()
+{
+
+}
+
+#define TEST 1
+
+void solve()
+{
+    string a, b;
+    cin >> a >> b;
+    int n = a.size();
+
+    vvi dp(n, vi(2));
+    dp[n - 1][0] = b[n - 1] != '0';
+    dp[n - 1][1] = b[n - 1] != '1';
+
+    for (int i = n - 2; i >= 0; i--) {
+        dp[i][0] = (b[i] != '0') + min(dp[i + 1][1] + (a[i + 1] != '1'), dp[i + 1][0] + (a[i + 1] != '0'));
+        dp[i][1] = (b[i] != '1') + min(dp[i + 1][0] + (a[i + 1] != '1'), dp[i + 1][1] + (a[i + 1] != '0'));
+    }
+
+    cout << min(dp[0][0] + (a[0] != '0'), dp[0][1] + (a[0] != '1')) << '\n';
+}
+
+int main()
+{
+    ios::sync_with_stdio(false);
+    cin.tie(nullptr);
+
+    pre();
+
+    int t;
+    (TEST && cin >> t) || (t = 1);
+    while (t--) {
+        solve();
+    }
+}

Codeforces Global Round 26/C2. Magnitude (Hard Version).cpp

@@ -0,0 +1,144 @@
+/* Problem URL: https://codeforces.com/problemset/problem/1984/C2 */
+
+#include <bits/stdc++.h>
+#include <ext/pb_ds/assoc_container.hpp>
+#include <ext/pb_ds/tree_policy.hpp>
+
+using namespace std;
+using namespace __gnu_pbds;
+
+template <class T, class comp = less<>>
+using ordered_set = tree<T, null_type , comp , rb_tree_tag , tree_order_statistics_node_update>;
+
+#define V vector
+
+#define rmin(a, b) a = min(a, b)
+#define rmax(a, b) a = max(a, b)
+
+#define rep(i, lim) for (int i = 0; i < (lim); i++)
+#define nrep(i, s, lim) for (int i = s; i < (lim); i++)
+
+#define repv(i, v) for (auto &i : (v))
+#define fillv(v) for (auto &itr_ : (v)) { cin >> itr_; }
+#define sortv(v) sort(v.begin(), v.end())
+#define all(v) (v).begin(), (v).end()
+
+using vi = vector<int>;
+using vvi = vector<vi>;
+using vvvi = vector<vvi>;
+using vvvvi = vector<vvvi>;
+
+using ll = long long;
+
+using vl = vector<ll>;
+using vvl = vector<vl>;
+using vvvl = vector<vvl>;
+using vvvvl = vector<vvvl>;
+
+template<class v>
+auto operator<<(ostream &os, const vector<v> &vec)->ostream& {
+    os << vec[0];
+    for (size_t i = 1; i < vec.size(); i++) {
+        os << ' ' << vec[i];
+    }
+    os << '\n';
+    return os;
+}
+
+template<class v>
+auto operator>>(istream &is, vector<v> &vec)->istream& {
+    for (auto &i : vec) {
+        is >> i;
+    }
+    return is;
+}
+
+template<class v>
+auto operator<<(ostream &os, const vector<vector<v>> &vec)->ostream& {
+    for (auto &i : vec) {
+        os << i[0];
+        for (size_t j = 1; j < i.size(); j++) {
+            os << ' ' << i[j];
+        }
+        os << '\n';
+    }
+    return os;
+}
+
+template<class v>
+auto operator>>(istream  &is, vector<vector<v>> &vec)->istream& {
+    for (auto &i : vec) {
+        for (auto &j : i) {
+            is >> j;
+        }
+    }
+    return is;
+}
+
+const int oo = INT32_MAX >> 1;
+const ll OO = INT64_MAX >> 1;
+
+
+void pre()
+{
+
+}
+
+#define TEST 1
+
+void solve()
+{
+    int n;
+    cin >> n;
+    vl a(n);
+    cin >> a;
+
+    const ll mod = 998244353;
+
+    map<ll, ll> c1;
+    map<ll, ll> c2;
+
+    c1[0] = 1;
+    rep(i, n) {
+        if (c1.size() == 1) {
+            auto itr = c1.begin();
+            c2[itr->first + a[i]] += itr->second;
+            c2[itr->first + a[i]] %= mod;
+            c2[abs(itr->first + a[i])] += itr->second;
+            c2[abs(itr->first + a[i])] %= mod;
+            swap(c1, c2);
+            c2.clear();
+            continue;
+        }
+
+        auto itr1 = c1.begin();
+        auto itr2 = prev(c1.end());
+
+        c2[itr1->first + a[i]] += itr1->second;
+        c2[itr1->first + a[i]] %= mod;
+        c2[abs(itr1->first + a[i])] += itr1->second;
+        c2[abs(itr1->first + a[i])] %= mod;
+        c2[itr2->first + a[i]] += itr2->second;
+        c2[itr2->first + a[i]] %= mod;
+        c2[abs(itr2->first + a[i])] += itr2->second;
+        c2[abs(itr2->first + a[i])] %= mod;
+        swap(c1, c2);
+        c2.clear();
+    }
+
+    cout << prev(c1.end())->second << '\n';
+}
+
+int main()
+{
+    ios::sync_with_stdio(false);
+    cin.tie(nullptr);
+
+    pre();
+
+    int t;
+    (TEST && cin >> t) || (t = 1);
+    while (t--) {
+        solve();
+    }
+}

Codeforces Round 1007 (Div. 2)/C. Trapmigiano Reggiano.cpp

@@ -0,0 +1,172 @@
+/* Problem URL: https://codeforces.com/problemset/problem/2071/C */
+
+#include <bits/stdc++.h>
+#include <ext/pb_ds/assoc_container.hpp>
+#include <ext/pb_ds/tree_policy.hpp>
+
+using namespace std;
+using namespace __gnu_pbds;
+
+template <class T, class comp = less<>>
+using ordered_set = tree<T, null_type , comp , rb_tree_tag , tree_order_statistics_node_update>;
+
+#define V vector
+
+#define rmin(a, b) a = min(a, b)
+#define rmax(a, b) a = max(a, b)
+
+#define rep(i, lim) for (int i = 0; i < (lim); i++)
+#define nrep(i, s, lim) for (int i = s; i < (lim); i++)
+
+#define repv(i, v) for (auto &i : (v))
+#define fillv(v) for (auto &itr_ : (v)) { cin >> itr_; }
+#define sortv(v) sort(v.begin(), v.end())
+#define all(v) (v).begin(), (v).end()
+
+using vi = vector<int>;
+using vvi = vector<vi>;
+using vvvi = vector<vvi>;
+using vvvvi = vector<vvvi>;
+
+using ll = long long;
+
+using vl = vector<ll>;
+using vvl = vector<vl>;
+using vvvl = vector<vvl>;
+using vvvvl = vector<vvvl>;
+
+template<class v>
+auto operator<<(ostream &os, const vector<v> &vec)->ostream& {
+    os << vec[0];
+    for (size_t i = 1; i < vec.size(); i++) {
+        os << ' ' << vec[i];
+    }
+    os << '\n';
+    return os;
+}
+
+template<class v>
+auto operator>>(istream &is, vector<v> &vec)->istream& {
+    for (auto &i : vec) {
+        is >> i;
+    }
+    return is;
+}
+
+template<class v>
+auto operator<<(ostream &os, const vector<vector<v>> &vec)->ostream& {
+    for (auto &i : vec) {
+        os << i[0];
+        for (size_t j = 1; j < i.size(); j++) {
+            os << ' ' << i[j];
+        }
+        os << '\n';
+    }
+    return os;
+}
+
+template<class v>
+auto operator>>(istream  &is, vector<vector<v>> &vec)->istream& {
+    for (auto &i : vec) {
+        for (auto &j : i) {
+            is >> j;
+        }
+    }
+    return is;
+}
+
+const int oo = INT32_MAX >> 1;
+const ll OO = INT64_MAX >> 1;
+
+
+void pre()
+{
+
+}
+
+#define TEST 1
+
+void solve()
+{
+    int n, st, en;
+    cin >> n >> st >> en;
+    st--, en--;
+
+    vvi graph(n);
+    rep(i, n - 1) {
+        int a, b;
+        cin >> a >> b;
+        a--, b--;
+        graph[a].push_back(b);
+        graph[b].push_back(a);
+    }
+
+    vi ne(n, -1);
+    function<bool(int, int)> find_p = [&](int i, int p) {
+        if (i == en) {
+            return true;
+        }
+
+        repv(j, graph[i]) {
+            if (j == p) {
+                continue;
+            }
+
+            if (find_p(j, i)) {
+                ne[i] = j;
+                return true;
+            }
+        }
+
+        return false;
+    };
+
+    find_p(st, -1);
+
+    vi ans;
+
+    function<void(int, int)> rem = [&](int i, int p) {
+        repv(j, graph[i]) {
+            if (j == p) {
+                continue;
+            }
+
+            rem(j, i);
+        }
+
+        ans.push_back(i + 1);
+    };
+
+    function<void(int, int)> getans = [&](int i, int p) {
+        repv(j, graph[i]) {
+            if (j == p || j == ne[i]) {
+                continue;
+            }
+
+            rem(j, i);
+        }
+
+        ans.push_back(i + 1);
+        if (i != en) {
+            getans(ne[i], i);
+        }
+    };
+
+    getans(st, -1);
+
+    cout << ans;
+}
+
+int main()
+{
+    ios::sync_with_stdio(false);
+    cin.tie(nullptr);
+
+    pre();
+
+    int t;
+    (TEST && cin >> t) || (t = 1);
+    while (t--) {
+        solve();
+    }
+}

Codeforces Round 1024 (Div. 1)/B. Quartet Swapping.cpp

@@ -0,0 +1,141 @@
+/* Problem URL: https://codeforces.com/problemset/problem/2101/B */
+
+#include <bits/stdc++.h>
+#include <ext/pb_ds/assoc_container.hpp>
+#include <ext/pb_ds/tree_policy.hpp>
+
+using namespace std;
+using namespace __gnu_pbds;
+
+template <class T, class comp = less<>>
+using ordered_set = tree<T, null_type , comp , rb_tree_tag , tree_order_statistics_node_update>;
+
+#define V vector
+
+#define rmin(a, b) a = min(a, b)
+#define rmax(a, b) a = max(a, b)
+
+#define rep(i, lim) for (int i = 0; i < (lim); i++)
+#define nrep(i, s, lim) for (int i = s; i < (lim); i++)
+
+#define repv(i, v) for (auto &i : (v))
+#define fillv(v) for (auto &itr_ : (v)) { cin >> itr_; }
+#define sortv(v) sort(v.begin(), v.end())
+#define all(v) (v).begin(), (v).end()
+
+using vi = vector<int>;
+using vvi = vector<vi>;
+using vvvi = vector<vvi>;
+using vvvvi = vector<vvvi>;
+
+using ll = long long;
+
+using vl = vector<ll>;
+using vvl = vector<vl>;
+using vvvl = vector<vvl>;
+using vvvvl = vector<vvvl>;
+
+template<class v>
+auto operator<<(ostream &os, const vector<v> &vec)->ostream& {
+    os << vec[0];
+    for (size_t i = 1; i < vec.size(); i++) {
+        os << ' ' << vec[i];
+    }
+    os << '\n';
+    return os;
+}
+
+template<class v>
+auto operator>>(istream &is, vector<v> &vec)->istream& {
+    for (auto &i : vec) {
+        is >> i;
+    }
+    return is;
+}
+
+template<class v>
+auto operator<<(ostream &os, const vector<vector<v>> &vec)->ostream& {
+    for (auto &i : vec) {
+        os << i[0];
+        for (size_t j = 1; j < i.size(); j++) {
+            os << ' ' << i[j];
+        }
+        os << '\n';
+    }
+    return os;
+}
+
+template<class v>
+auto operator>>(istream  &is, vector<vector<v>> &vec)->istream& {
+    for (auto &i : vec) {
+        for (auto &j : i) {
+            is >> j;
+        }
+    }
+    return is;
+}
+
+const int oo = INT32_MAX >> 1;
+const ll OO = INT64_MAX >> 1;
+
+
+void pre()
+{
+
+}
+
+#define TEST 1
+
+void solve()
+{
+    int n;
+    cin >> n;
+    vi p(n);
+    cin >> p;
+
+    vvi od(2);
+
+    auto cnt = [&](vi &p) {
+        int ans = 0;
+        ordered_set<int> ord;
+        rep(i, p.size()) {
+            ans += ord.size() - ord.order_of_key(p[i]);
+            ord.insert(p[i]);
+        }
+        return ans & 1;
+    };
+
+    rep(i, n) {
+        od[i & 1].push_back(p[i]);
+    }
+
+    bool pos = cnt(od[0]) != cnt(od[1]);
+
+    sort(all(od[0]), greater<>());
+    sort(all(od[1]), greater<>());
+
+    rep(i, n) {
+        p[i] = od[i & 1].back();
+        od[i & 1].pop_back();
+    }
+
+    if (pos) {
+        swap(p[n - 1], p[n - 3]);
+    }
+
+    cout << p;
+}
+
+int main()
+{
+    ios::sync_with_stdio(false);
+    cin.tie(nullptr);
+
+    pre();
+
+    int t;
+    (TEST && cin >> t) || (t = 1);
+    while (t--) {
+        solve();
+    }
+}

Codeforces Round 1026 (Div. 2)/C. Racing.cpp

@@ -0,0 +1,151 @@
+/* Problem URL: https://codeforces.com/problemset/problem/2110/C */
+
+#include <bits/stdc++.h>
+#include <ext/pb_ds/assoc_container.hpp>
+#include <ext/pb_ds/tree_policy.hpp>
+
+using namespace std;
+using namespace __gnu_pbds;
+
+template <class T, class comp = less<>>
+using ordered_set = tree<T, null_type , comp , rb_tree_tag , tree_order_statistics_node_update>;
+
+#define V vector
+
+#define rmin(a, b) a = min(a, b)
+#define rmax(a, b) a = max(a, b)
+
+#define rep(i, lim) for (int i = 0; i < (lim); i++)
+#define nrep(i, s, lim) for (int i = s; i < (lim); i++)
+
+#define repv(i, v) for (auto &i : (v))
+#define fillv(v) for (auto &itr_ : (v)) { cin >> itr_; }
+#define sortv(v) sort(v.begin(), v.end())
+#define all(v) (v).begin(), (v).end()
+
+using vi = vector<int>;
+using vvi = vector<vi>;
+using vvvi = vector<vvi>;
+using vvvvi = vector<vvvi>;
+
+using ll = long long;
+
+using vl = vector<ll>;
+using vvl = vector<vl>;
+using vvvl = vector<vvl>;
+using vvvvl = vector<vvvl>;
+
+template<class v>
+auto operator<<(ostream &os, const vector<v> &vec)->ostream& {
+    os << vec[0];
+    for (size_t i = 1; i < vec.size(); i++) {
+        os << ' ' << vec[i];
+    }
+    os << '\n';
+    return os;
+}
+
+template<class v>
+auto operator>>(istream &is, vector<v> &vec)->istream& {
+    for (auto &i : vec) {
+        is >> i;
+    }
+    return is;
+}
+
+template<class v>
+auto operator<<(ostream &os, const vector<vector<v>> &vec)->ostream& {
+    for (auto &i : vec) {
+        os << i[0];
+        for (size_t j = 1; j < i.size(); j++) {
+            os << ' ' << i[j];
+        }
+        os << '\n';
+    }
+    return os;
+}
+
+template<class v>
+auto operator>>(istream  &is, vector<vector<v>> &vec)->istream& {
+    for (auto &i : vec) { 
+        for (auto &j : i) {
+            is >> j;
+        }
+    }
+    return is;
+}
+
+const int oo = INT32_MAX >> 1;
+const ll OO = INT64_MAX >> 1;
+
+
+void pre()
+{
+
+}
+
+#define TEST 1
+
+void solve()
+{
+    int n;
+    cin >> n;
+
+    vi d(n);
+    cin >> d;
+
+    V<pair<int, int>> v(n);
+    repv(i, v) {
+        cin >> i.first >> i.second;
+    }
+
+    V<pair<int, int>> p(n + 1);
+    nrep(i, 1, n + 1) {
+        int a = d[i - 1];
+        if (a == -1) {
+            p[i] = {p[i - 1].first, p[i - 1].second + 1};
+            rmin(p[i].second, v[i - 1].second);
+            rmax(p[i].first, v[i - 1].first);
+            if (p[i].second < p[i].first) {
+                cout << "-1\n";
+                return;
+            }
+            continue;
+        }
+
+        p[i] = {p[i - 1].first + a, p[i - 1].second + a};
+        rmin(p[i].second, v[i - 1].second);
+        rmax(p[i].first, v[i - 1].first);
+        if (p[i].second < p[i].first) {
+            cout << "-1\n";
+            return;
+        }
+    }
+
+    int cur = p.back().first;
+    for (int i = n - 1; i >= 0; i--) {
+        if (d[i] == -1) {
+            d[i] = cur > p[i].first;
+            cur -= cur > p[i].first;
+            continue;
+        }
+
+        cur -= d[i];
+    }
+
+    cout << d;
+}
+
+int main()
+{
+    ios::sync_with_stdio(false);
+    cin.tie(nullptr);
+
+    pre();
+
+    int t;
+    (TEST && cin >> t) || (t = 1);
+    while (t--) {
+        solve();
+    }
+}

Codeforces Round 1064 (Div. 1)/B. Marble Council.cpp

@@ -0,0 +1,138 @@
+/* Problem URL: https://codeforces.com/problemset/problem/2165/B */
+
+#include <bits/stdc++.h>
+#include <ext/pb_ds/assoc_container.hpp>
+#include <ext/pb_ds/tree_policy.hpp>
+
+using namespace std;
+using namespace __gnu_pbds;
+
+template <class T, class comp = less<>>
+using ordered_set = tree<T, null_type , comp , rb_tree_tag , tree_order_statistics_node_update>;
+
+#define V vector
+
+#define rmin(a, b) a = min(a, b)
+#define rmax(a, b) a = max(a, b)
+
+#define rep(i, lim) for (int i = 0; i < (lim); i++)
+#define nrep(i, s, lim) for (int i = s; i < (lim); i++)
+
+#define repv(i, v) for (auto &i : (v))
+#define fillv(v) for (auto &itr_ : (v)) { cin >> itr_; }
+#define sortv(v) sort(v.begin(), v.end())
+#define all(v) (v).begin(), (v).end()
+
+using vi = vector<int>;
+using vvi = vector<vi>;
+using vvvi = vector<vvi>;
+using vvvvi = vector<vvvi>;
+
+using ll = long long;
+
+using vl = vector<ll>;
+using vvl = vector<vl>;
+using vvvl = vector<vvl>;
+using vvvvl = vector<vvvl>;
+
+template<class v>
+auto operator<<(ostream &os, const vector<v> &vec)->ostream& {
+    os << vec[0];
+    for (size_t i = 1; i < vec.size(); i++) {
+        os << ' ' << vec[i];
+    }
+    os << '\n';
+    return os;
+}
+
+template<class v>
+auto operator>>(istream &is, vector<v> &vec)->istream& {
+    for (auto &i : vec) {
+        is >> i;
+    }
+    return is;
+}
+
+template<class v>
+auto operator<<(ostream &os, const vector<vector<v>> &vec)->ostream& {
+    for (auto &i : vec) {
+        os << i[0];
+        for (size_t j = 1; j < i.size(); j++) {
+            os << ' ' << i[j];
+        }
+        os << '\n';
+    }
+    return os;
+}
+
+template<class v>
+auto operator>>(istream  &is, vector<vector<v>> &vec)->istream& {
+    for (auto &i : vec) {
+        for (auto &j : i) {
+            is >> j;
+        }
+    }
+    return is;
+}
+
+const int oo = INT32_MAX >> 1;
+const ll OO = INT64_MAX >> 1;
+
+
+void pre()
+{
+
+}
+
+#define TEST 1
+
+void solve()
+{
+    int n;
+    cin >> n;
+
+    ll mod = 998244353;
+
+    vl c(n);
+    ll ma = 0;
+    rep(i, n) {
+        int a;
+        cin >> a;
+        c[a - 1]++;
+        rmax(ma, c[a - 1]);
+    }
+
+    vl dp(n + 1);
+    dp[0] = 1;
+
+    rep(i,  n) {
+        if (c[i] == 0) {
+            continue;
+        }
+
+        for (int j = n; j >= c[i]; j--) {
+            (dp[j] += dp[j - c[i]] * c[i]) %= mod;
+        }
+    }
+
+    ll ans = 0;
+    nrep(i, ma, n + 1) {
+        (ans += dp[i]) %= mod;
+    }
+
+    cout << ans << '\n';
+}
+
+int main()
+{
+    ios::sync_with_stdio(false);
+    cin.tie(nullptr);
+
+    pre();
+
+    int t;
+    (TEST && cin >> t) || (t = 1);
+    while (t--) {
+        solve();
+    }
+}

Codeforces Round 1065 (Div. 3)/D. Rae Taylor and Trees (easy version).cpp

@@ -0,0 +1,143 @@
+/* Problem URL: https://codeforces.com/problemset/problem/2171/D */
+
+#include <bits/stdc++.h>
+#include <ext/pb_ds/assoc_container.hpp>
+#include <ext/pb_ds/tree_policy.hpp>
+
+using namespace std;
+using namespace __gnu_pbds;
+
+template <class T, class comp = less<>>
+using ordered_set = tree<T, null_type , comp , rb_tree_tag , tree_order_statistics_node_update>;
+
+#define V vector
+
+#define rmin(a, b) a = min(a, b)
+#define rmax(a, b) a = max(a, b)
+
+#define rep(i, lim) for (int i = 0; i < (lim); i++)
+#define nrep(i, s, lim) for (int i = s; i < (lim); i++)
+
+#define repv(i, v) for (auto &i : (v))
+#define fillv(v) for (auto &itr_ : (v)) { cin >> itr_; }
+#define sortv(v) sort(v.begin(), v.end())
+#define all(v) (v).begin(), (v).end()
+
+using vi = vector<int>;
+using vvi = vector<vi>;
+using vvvi = vector<vvi>;
+using vvvvi = vector<vvvi>;
+
+using ll = long long;
+
+using vl = vector<ll>;
+using vvl = vector<vl>;
+using vvvl = vector<vvl>;
+using vvvvl = vector<vvvl>;
+
+template<class v>
+auto operator<<(ostream &os, const vector<v> &vec)->ostream& {
+    os << vec[0];
+    for (size_t i = 1; i < vec.size(); i++) {
+        os << ' ' << vec[i];
+    }
+    os << '\n';
+    return os;
+}
+
+template<class v>
+auto operator>>(istream &is, vector<v> &vec)->istream& {
+    for (auto &i : vec) {
+        is >> i;
+    }
+    return is;
+}
+
+template<class v>
+auto operator<<(ostream &os, const vector<vector<v>> &vec)->ostream& {
+    for (auto &i : vec) {
+        os << i[0];
+        for (size_t j = 1; j < i.size(); j++) {
+            os << ' ' << i[j];
+        }
+        os << '\n';
+    }
+    return os;
+}
+
+template<class v>
+auto operator>>(istream  &is, vector<vector<v>> &vec)->istream& {
+    for (auto &i : vec) {
+        for (auto &j : i) {
+            is >> j;
+        }
+    }
+    return is;
+}
+
+const int oo = INT32_MAX >> 1;
+const ll OO = INT64_MAX >> 1;
+
+
+void pre()
+{
+
+}
+
+#define TEST 1
+
+void solve()
+{
+    int n;
+    cin >> n;
+    vi p(n);
+    cin >> p;
+
+    vi suf(n + 1);
+    vi pos(n);
+    for (int i = n - 1; i >= 0; i--) {
+        suf[i] = max(suf[i + 1], p[i]);
+        pos[p[i] - 1] = i;
+    }
+
+    int now = 1;
+    int ma = 1;
+    int lim = n;
+    while (now <= n) {
+        int po = pos[now - 1];
+        if (po >= lim) {
+            now++;
+            continue;
+        }
+
+        if (now > ma) {
+            cout << "No\n";
+            return;
+        }
+
+        rmax(ma, suf[po]);
+        rmin(lim, po);
+        now++;
+    }
+
+    if (lim != 0) {
+        cout << "No\n";
+        return;
+    }
+
+    cout << "Yes\n";
+}
+
+int main()
+{
+    ios::sync_with_stdio(false);
+    cin.tie(nullptr);
+
+    pre();
+
+    int t;
+    (TEST && cin >> t) || (t = 1);
+    while (t--) {
+        solve();
+    }
+}

Codeforces Round 1065 (Div. 3)/F. Rae Taylor and Trees (hard version).cpp

@@ -93,42 +93,52 @@ void solve()
     vi p(n);
     cin >> p;
 
+    vi suf(n + 1);
     vi pos(n);
-    rep(i, n) {
+    for (int i = n - 1; i >= 0; i--) {
+        suf[i] = max(suf[i + 1], p[i]);
         pos[p[i] - 1] = i;
     }
 
-    stack<pair<int, int>> s;
+    V<pair<int, int>> ans;
 
-    pair<int, int> big = {0, 0};
-
-    V<pair<int, int>> edges;
-
-    for (int i = n - 1; i >= 0; i--) {
-        while (!s.empty() && s.top().first > pos[i]) {
-            edges.emplace_back(s.top().second + 1, i + 1);
-            s.pop();
+    int now = 1;
+    int lim = n;
+    int ma = 1;
+    while (now < n) {
+        int ps = pos[now - 1];
+        if (now > ma) {
+            cout << "No\n";
+            return;
         }
 
-        if (big.first > pos[i]) {
-            edges.emplace_back(big.second + 1, i + 1);
+        if (ps >= lim) {
+            now++;
             continue;
         }
 
-        big = {pos[i], i};
-        s.emplace(pos[i], i);
+        nrep(i, ps + 1, n) {
+            if (p[i] < now) {
+                break;
             }
 
-    sortv(edges);
-    edges.erase(unique(all(edges)), edges.end());
+            ans.emplace_back(p[i], now);
+        }
+        if (now != ma) {
+            ans.emplace_back(ma, now);
+        }
 
-    if (edges.size() != n - 1) {
+        lim = ps;
+        rmax(ma, suf[ps]);
+    }
+
+    if (ans.size() < n - 1) {
         cout << "No\n";
         return;
     }
 
     cout << "Yes\n";
-    repv(i, edges) {
+    repv(i, ans) {
         cout << i.first << ' ' << i.second << '\n';
     }
 }

Codeforces Round 1073 (Div. 1)/B1. Sub-RBS (Easy Version).cpp

@@ -0,0 +1,126 @@
+/* Problem URL: https://codeforces.com/problemset/problem/2190/B1 */
+
+#include <bits/stdc++.h>
+#include <ext/pb_ds/assoc_container.hpp>
+#include <ext/pb_ds/tree_policy.hpp>
+
+using namespace std;
+using namespace __gnu_pbds;
+
+template <class T, class comp = less<>>
+using ordered_set = tree<T, null_type , comp , rb_tree_tag , tree_order_statistics_node_update>;
+
+#define V vector
+
+#define rmin(a, b) a = min(a, b)
+#define rmax(a, b) a = max(a, b)
+
+#define rep(i, lim) for (int i = 0; i < (lim); i++)
+#define nrep(i, s, lim) for (int i = s; i < (lim); i++)
+
+#define repv(i, v) for (auto &i : (v))
+#define fillv(v) for (auto &itr_ : (v)) { cin >> itr_; }
+#define sortv(v) sort(v.begin(), v.end())
+#define all(v) (v).begin(), (v).end()
+
+using vi = vector<int>;
+using vvi = vector<vi>;
+using vvvi = vector<vvi>;
+using vvvvi = vector<vvvi>;
+
+using ll = long long;
+
+using vl = vector<ll>;
+using vvl = vector<vl>;
+using vvvl = vector<vvl>;
+using vvvvl = vector<vvvl>;
+
+template<class v>
+auto operator<<(ostream &os, const vector<v> &vec)->ostream& {
+    os << vec[0];
+    for (size_t i = 1; i < vec.size(); i++) {
+        os << ' ' << vec[i];
+    }
+    os << '\n';
+    return os;
+}
+
+template<class v>
+auto operator>>(istream &is, vector<v> &vec)->istream& {
+    for (auto &i : vec) {
+        is >> i;
+    }
+    return is;
+}
+
+template<class v>
+auto operator<<(ostream &os, const vector<vector<v>> &vec)->ostream& {
+    for (auto &i : vec) {
+        os << i[0];
+        for (size_t j = 1; j < i.size(); j++) {
+            os << ' ' << i[j];
+        }
+        os << '\n';
+    }
+    return os;
+}
+
+template<class v>
+auto operator>>(istream  &is, vector<vector<v>> &vec)->istream& {
+    for (auto &i : vec) {
+        for (auto &j : i) {
+            is >> j;
+        }
+    }
+    return is;
+}
+
+const int oo = INT32_MAX >> 1;
+const ll OO = INT64_MAX >> 1;
+
+
+void pre()
+{
+
+}
+
+#define TEST 1
+
+void solve()
+{
+    int n;
+    cin >> n;
+    string s;
+    cin >> s;
+
+    int ind = 0;
+    while (ind < s.size() - 1 && (s[ind] == '(' || s[ind + 1] == ')')) {
+        ind++;
+    }
+
+    int ne = ind + 2;
+    while (ne < s.size() && s[ne] != '(') {
+        ne++;
+    }
+
+    if (ne >= s.size()) {
+        cout << "-1\n";
+        return;
+    }
+
+    cout << n - 2 << '\n';
+}
+
+int main()
+{
+    ios::sync_with_stdio(false);
+    cin.tie(nullptr);
+
+    pre();
+
+    int t;
+    (TEST && cin >> t) || (t = 1);
+    while (t--) {
+        solve();
+    }
+}

Codeforces Round 1074 (Div. 4)/F. BattleCows.cpp

@@ -0,0 +1,155 @@
+/* Problem URL: https://codeforces.com/problemset/problem/2185/F */
+
+#include <bits/stdc++.h>
+#include <ext/pb_ds/assoc_container.hpp>
+#include <ext/pb_ds/tree_policy.hpp>
+
+using namespace std;
+using namespace __gnu_pbds;
+
+template <class T, class comp = less<>>
+using ordered_set = tree<T, null_type , comp , rb_tree_tag , tree_order_statistics_node_update>;
+
+#define V vector
+
+#define rmin(a, b) a = min(a, b)
+#define rmax(a, b) a = max(a, b)
+
+#define rep(i, lim) for (int i = 0; i < (lim); i++)
+#define nrep(i, s, lim) for (int i = s; i < (lim); i++)
+
+#define repv(i, v) for (auto &i : (v))
+#define fillv(v) for (auto &itr_ : (v)) { cin >> itr_; }
+#define sortv(v) sort(v.begin(), v.end())
+#define all(v) (v).begin(), (v).end()
+
+using vi = vector<int>;
+using vvi = vector<vi>;
+using vvvi = vector<vvi>;
+using vvvvi = vector<vvvi>;
+
+using ll = long long;
+
+using vl = vector<ll>;
+using vvl = vector<vl>;
+using vvvl = vector<vvl>;
+using vvvvl = vector<vvvl>;
+
+template<class v>
+auto operator<<(ostream &os, const vector<v> &vec)->ostream& {
+    os << vec[0];
+    for (size_t i = 1; i < vec.size(); i++) {
+        os << ' ' << vec[i];
+    }
+    os << '\n';
+    return os;
+}
+
+template<class v>
+auto operator>>(istream &is, vector<v> &vec)->istream& {
+    for (auto &i : vec) {
+        is >> i;
+    }
+    return is;
+}
+
+template<class v>
+auto operator<<(ostream &os, const vector<vector<v>> &vec)->ostream& {
+    for (auto &i : vec) {
+        os << i[0];
+        for (size_t j = 1; j < i.size(); j++) {
+            os << ' ' << i[j];
+        }
+        os << '\n';
+    }
+    return os;
+}
+
+template<class v>
+auto operator>>(istream  &is, vector<vector<v>> &vec)->istream& {
+    for (auto &i : vec) {
+        for (auto &j : i) {
+            is >> j;
+        }
+    }
+    return is;
+}
+
+const int oo = INT32_MAX >> 1;
+const ll OO = INT64_MAX >> 1;
+
+
+void pre()
+{
+
+}
+
+#define TEST 1
+
+void solve()
+{
+    int n, q;
+    cin >> n >> q;
+    int sz = 1 << n;
+
+    vl a(sz);
+    cin >> a;
+
+    vl an(sz * 2);
+
+    function<ll(int)> calc = [&](int i) {
+        if (i >= sz) {
+            an[i] = a[i - sz];
+            return an[i];
+        }
+
+        ll a1 = calc(i * 2);
+        ll a2 = calc(i * 2 + 1);
+
+        an[i] = a1 ^ a2;
+        return an[i];
+    };
+
+    calc(1);
+
+    while (q--) {
+        int b, c;
+        cin >> b >> c;
+
+        ll ans = 0;
+        ll cur = a[b - 1];
+        bool add = false;
+        int st = 0;
+        b += sz;
+        b--;
+
+        while (b > 1) {
+            int now = b & 1;
+            b >>= 1;
+
+            ll cur = an[(b << 1) + (now ^ 1)];
+            if (cur > c || (cur == c && now)) {
+                ans += 1 << st;
+            }
+
+            st++;
+            c ^= cur;
+        }
+        
+        cout << ans << '\n';
+    }
+}
+
+int main()
+{
+    ios::sync_with_stdio(false);
+    cin.tie(nullptr);
+
+    pre();
+
+    int t;
+    (TEST && cin >> t) || (t = 1);
+    while (t--) {
+        solve();
+    }
+}

Codeforces Round 1079 (Div. 1)/B. Another Problem about Beautiful Pairs.cpp

@@ -0,0 +1,139 @@
+/* Problem URL: https://codeforces.com/problemset/problem/2196/B */
+
+#include <bits/stdc++.h>
+#include <ext/pb_ds/assoc_container.hpp>
+#include <ext/pb_ds/tree_policy.hpp>
+
+using namespace std;
+using namespace __gnu_pbds;
+
+template <class T, class comp = less<>>
+using ordered_set = tree<T, null_type , comp , rb_tree_tag , tree_order_statistics_node_update>;
+
+#define V vector
+
+#define rmin(a, b) a = min(a, b)
+#define rmax(a, b) a = max(a, b)
+
+#define rep(i, lim) for (int i = 0; i < (lim); i++)
+#define nrep(i, s, lim) for (int i = s; i < (lim); i++)
+
+#define repv(i, v) for (auto &i : (v))
+#define fillv(v) for (auto &itr_ : (v)) { cin >> itr_; }
+#define sortv(v) sort(v.begin(), v.end())
+#define all(v) (v).begin(), (v).end()
+
+using vi = vector<int>;
+using vvi = vector<vi>;
+using vvvi = vector<vvi>;
+using vvvvi = vector<vvvi>;
+
+using ll = long long;
+
+using vl = vector<ll>;
+using vvl = vector<vl>;
+using vvvl = vector<vvl>;
+using vvvvl = vector<vvvl>;
+
+template<class v>
+auto operator<<(ostream &os, const vector<v> &vec)->ostream& {
+    os << vec[0];
+    for (size_t i = 1; i < vec.size(); i++) {
+        os << ' ' << vec[i];
+    }
+    os << '\n';
+    return os;
+}
+
+template<class v>
+auto operator>>(istream &is, vector<v> &vec)->istream& {
+    for (auto &i : vec) {
+        is >> i;
+    }
+    return is;
+}
+
+template<class v>
+auto operator<<(ostream &os, const vector<vector<v>> &vec)->ostream& {
+    for (auto &i : vec) {
+        os << i[0];
+        for (size_t j = 1; j < i.size(); j++) {
+            os << ' ' << i[j];
+        }
+        os << '\n';
+    }
+    return os;
+}
+
+template<class v>
+auto operator>>(istream  &is, vector<vector<v>> &vec)->istream& {
+    for (auto &i : vec) {
+        for (auto &j : i) {
+            is >> j;
+        }
+    }
+    return is;
+}
+
+const int oo = INT32_MAX >> 1;
+const ll OO = INT64_MAX >> 1;
+
+
+void pre()
+{
+
+}
+
+#define TEST 1
+
+void solve()
+{
+    int n;
+    cin >> n;
+
+    vl a(n);
+    cin >> a;
+
+    int b = sqrt(n) + 1;
+
+    ll ans = 0;
+    rep(i, n) {
+        if (a[i] >= b) {
+            for (int k = 1; i + k * a[i] < n; k++) {
+                if (k == a[i + k * a[i]]) {
+                    ans++;
+                }
+            }
+
+            for (int k = -1; i + k * a[i] >= 0; k--) {
+                if (-k == a[i + k * a[i]]) {
+                    ans++;
+                }
+            }
+
+            continue;
+        }
+
+        for (int k = 1; k < b && i + k * a[i] < n; k++) {
+            if (k == a[i + k * a[i]]) {
+                ans++;
+            }
+        }
+    }
+
+    cout << ans << '\n';
+}
+
+int main()
+{
+    ios::sync_with_stdio(false);
+    cin.tie(nullptr);
+
+    pre();
+
+    int t;
+    (TEST && cin >> t) || (t = 1);
+    while (t--) {
+        solve();
+    }
+}

Codeforces Round 1079 (Div. 2)/A. Friendly Numbers.cpp

@@ -0,0 +1,127 @@
+/* Problem URL: https://codeforces.com/contest/2197/problem/A */
+
+#include <bits/stdc++.h>
+#include <ext/pb_ds/assoc_container.hpp>
+#include <ext/pb_ds/tree_policy.hpp>
+
+using namespace std;
+using namespace __gnu_pbds;
+
+template <class T, class comp = less<>>
+using ordered_set = tree<T, null_type , comp , rb_tree_tag , tree_order_statistics_node_update>;
+
+#define V vector
+
+#define rmin(a, b) a = min(a, b)
+#define rmax(a, b) a = max(a, b)
+
+#define rep(i, lim) for (int i = 0; i < (lim); i++)
+#define nrep(i, s, lim) for (int i = s; i < (lim); i++)
+
+#define repv(i, v) for (auto &i : (v))
+#define fillv(v) for (auto &itr_ : (v)) { cin >> itr_; }
+#define sortv(v) sort(v.begin(), v.end())
+#define all(v) (v).begin(), (v).end()
+
+using vi = vector<int>;
+using vvi = vector<vi>;
+using vvvi = vector<vvi>;
+using vvvvi = vector<vvvi>;
+
+using ll = long long;
+
+using vl = vector<ll>;
+using vvl = vector<vl>;
+using vvvl = vector<vvl>;
+using vvvvl = vector<vvvl>;
+
+template<class v>
+auto operator<<(ostream &os, const vector<v> &vec)->ostream& {
+    os << vec[0];
+    for (size_t i = 1; i < vec.size(); i++) {
+        os << ' ' << vec[i];
+    }
+    os << '\n';
+    return os;
+}
+
+template<class v>
+auto operator>>(istream &is, vector<v> &vec)->istream& {
+    for (auto &i : vec) {
+        is >> i;
+    }
+    return is;
+}
+
+template<class v>
+auto operator<<(ostream &os, const vector<vector<v>> &vec)->ostream& {
+    for (auto &i : vec) {
+        os << i[0];
+        for (size_t j = 1; j < i.size(); j++) {
+            os << ' ' << i[j];
+        }
+        os << '\n';
+    }
+    return os;
+}
+
+template<class v>
+auto operator>>(istream  &is, vector<vector<v>> &vec)->istream& {
+    for (auto &i : vec) {
+        for (auto &j : i) {
+            is >> j;
+        }
+    }
+    return is;
+}
+
+const int oo = INT32_MAX >> 1;
+const ll OO = INT64_MAX >> 1;
+
+
+void pre()
+{
+
+}
+
+#define TEST 1
+
+void solve()
+{
+    ll x;
+    cin >> x;
+
+    auto calc = [&](ll a) {
+        ll sum = 0;
+        ll tmp = a;
+        while (tmp > 0) {
+            sum += tmp % 10;
+            tmp /= 10;
+        }
+
+        return a - sum;
+    };
+
+    int ans = 0;
+    rep(i, 1000) {
+        if (calc(x + i) == x) {
+            ans++;
+        }
+    }
+
+    cout << ans << '\n';
+}
+
+int main()
+{
+    ios::sync_with_stdio(false);
+    cin.tie(nullptr);
+
+    pre();
+
+    int t;
+    (TEST && cin >> t) || (t = 1);
+    while (t--) {
+        solve();
+    }
+}

Codeforces Round 1079 (Div. 2)/B. Array and Permutation.cpp

@@ -0,0 +1,132 @@
+/* Problem URL: https://codeforces.com/contest/2197/problem/B */
+
+#include <bits/stdc++.h>
+#include <ext/pb_ds/assoc_container.hpp>
+#include <ext/pb_ds/tree_policy.hpp>
+
+using namespace std;
+using namespace __gnu_pbds;
+
+template <class T, class comp = less<>>
+using ordered_set = tree<T, null_type , comp , rb_tree_tag , tree_order_statistics_node_update>;
+
+#define V vector
+
+#define rmin(a, b) a = min(a, b)
+#define rmax(a, b) a = max(a, b)
+
+#define rep(i, lim) for (int i = 0; i < (lim); i++)
+#define nrep(i, s, lim) for (int i = s; i < (lim); i++)
+
+#define repv(i, v) for (auto &i : (v))
+#define fillv(v) for (auto &itr_ : (v)) { cin >> itr_; }
+#define sortv(v) sort(v.begin(), v.end())
+#define all(v) (v).begin(), (v).end()
+
+using vi = vector<int>;
+using vvi = vector<vi>;
+using vvvi = vector<vvi>;
+using vvvvi = vector<vvvi>;
+
+using ll = long long;
+
+using vl = vector<ll>;
+using vvl = vector<vl>;
+using vvvl = vector<vvl>;
+using vvvvl = vector<vvvl>;
+
+template<class v>
+auto operator<<(ostream &os, const vector<v> &vec)->ostream& {
+    os << vec[0];
+    for (size_t i = 1; i < vec.size(); i++) {
+        os << ' ' << vec[i];
+    }
+    os << '\n';
+    return os;
+}
+
+template<class v>
+auto operator>>(istream &is, vector<v> &vec)->istream& {
+    for (auto &i : vec) {
+        is >> i;
+    }
+    return is;
+}
+
+template<class v>
+auto operator<<(ostream &os, const vector<vector<v>> &vec)->ostream& {
+    for (auto &i : vec) {
+        os << i[0];
+        for (size_t j = 1; j < i.size(); j++) {
+            os << ' ' << i[j];
+        }
+        os << '\n';
+    }
+    return os;
+}
+
+template<class v>
+auto operator>>(istream  &is, vector<vector<v>> &vec)->istream& {
+    for (auto &i : vec) {
+        for (auto &j : i) {
+            is >> j;
+        }
+    }
+    return is;
+}
+
+const int oo = INT32_MAX >> 1;
+const ll OO = INT64_MAX >> 1;
+
+
+void pre()
+{
+
+}
+
+#define TEST 1
+
+void solve()
+{
+    int n;
+    cin >> n;
+    vi a(n);
+    vi b(n);
+    cin >> a >> b;
+
+    vi pos(n);
+    rep(i, n) {
+        pos[a[i] - 1] = i;
+    }
+
+    vi need(n);
+    rep(i, n) {
+        need[i] = pos[b[i] - 1];
+    }
+
+    int mi = oo;
+    for (int i = n - 1; i >= 0; i--) {
+        if (need[i] > mi) {
+            cout << "NO\n";
+            return;
+        }
+
+        rmin(mi, need[i]);
+    }
+
+    cout << "YES\n";
+}
+
+int main()
+{
+    ios::sync_with_stdio(false);
+    cin.tie(nullptr);
+
+    pre();
+
+    int t;
+    (TEST && cin >> t) || (t = 1);
+    while (t--) {
+        solve();
+    }
+}

Codeforces Round 1079 (Div. 2)/C. Game with a Fraction.cpp

@@ -0,0 +1,120 @@
+/* Problem URL: https://codeforces.com/contest/2197/problem/C */
+
+#include <bits/stdc++.h>
+#include <ext/pb_ds/assoc_container.hpp>
+#include <ext/pb_ds/tree_policy.hpp>
+
+using namespace std;
+using namespace __gnu_pbds;
+
+template <class T, class comp = less<>>
+using ordered_set = tree<T, null_type , comp , rb_tree_tag , tree_order_statistics_node_update>;
+
+#define V vector
+
+#define rmin(a, b) a = min(a, b)
+#define rmax(a, b) a = max(a, b)
+
+#define rep(i, lim) for (int i = 0; i < (lim); i++)
+#define nrep(i, s, lim) for (int i = s; i < (lim); i++)
+
+#define repv(i, v) for (auto &i : (v))
+#define fillv(v) for (auto &itr_ : (v)) { cin >> itr_; }
+#define sortv(v) sort(v.begin(), v.end())
+#define all(v) (v).begin(), (v).end()
+
+using vi = vector<int>;
+using vvi = vector<vi>;
+using vvvi = vector<vvi>;
+using vvvvi = vector<vvvi>;
+
+using ll = long long;
+
+using vl = vector<ll>;
+using vvl = vector<vl>;
+using vvvl = vector<vvl>;
+using vvvvl = vector<vvvl>;
+
+template<class v>
+auto operator<<(ostream &os, const vector<v> &vec)->ostream& {
+    os << vec[0];
+    for (size_t i = 1; i < vec.size(); i++) {
+        os << ' ' << vec[i];
+    }
+    os << '\n';
+    return os;
+}
+
+template<class v>
+auto operator>>(istream &is, vector<v> &vec)->istream& {
+    for (auto &i : vec) {
+        is >> i;
+    }
+    return is;
+}
+
+template<class v>
+auto operator<<(ostream &os, const vector<vector<v>> &vec)->ostream& {
+    for (auto &i : vec) {
+        os << i[0];
+        for (size_t j = 1; j < i.size(); j++) {
+            os << ' ' << i[j];
+        }
+        os << '\n';
+    }
+    return os;
+}
+
+template<class v>
+auto operator>>(istream  &is, vector<vector<v>> &vec)->istream& {
+    for (auto &i : vec) {
+        for (auto &j : i) {
+            is >> j;
+        }
+    }
+    return is;
+}
+
+const int oo = INT32_MAX >> 1;
+const ll OO = INT64_MAX >> 1;
+
+
+void pre()
+{
+
+}
+
+#define TEST 1
+
+void solve()
+{
+    ll p, q;
+    cin >> p >> q;
+
+    if (p >= q) {
+        cout << "Alice\n";
+        return;
+    }
+
+    ll diff = q - p;
+    if (p >= 2 * diff && q >= 3 * diff) {
+        cout << "Bob\n";
+        return;
+    }
+
+    cout << "Alice\n";
+}
+
+int main()
+{
+    ios::sync_with_stdio(false);
+    cin.tie(nullptr);
+
+    pre();
+
+    int t;
+    (TEST && cin >> t) || (t = 1);
+    while (t--) {
+        solve();
+    }
+}

Codeforces Round 1081 (Div. 2)/A. String Rotation Game.cpp

@@ -0,0 +1,118 @@
+/* Problem URL: https://codeforces.com/contest/2192/problem/A */
+
+#include <bits/stdc++.h>
+#include <ext/pb_ds/assoc_container.hpp>
+#include <ext/pb_ds/tree_policy.hpp>
+
+using namespace std;
+using namespace __gnu_pbds;
+
+template <class T, class comp = less<>>
+using ordered_set = tree<T, null_type , comp , rb_tree_tag , tree_order_statistics_node_update>;
+
+#define V vector
+
+#define rmin(a, b) a = min(a, b)
+#define rmax(a, b) a = max(a, b)
+
+#define rep(i, lim) for (int i = 0; i < (lim); i++)
+#define nrep(i, s, lim) for (int i = s; i < (lim); i++)
+
+#define repv(i, v) for (auto &i : (v))
+#define fillv(v) for (auto &itr_ : (v)) { cin >> itr_; }
+#define sortv(v) sort(v.begin(), v.end())
+#define all(v) (v).begin(), (v).end()
+
+using vi = vector<int>;
+using vvi = vector<vi>;
+using vvvi = vector<vvi>;
+using vvvvi = vector<vvvi>;
+
+using ll = long long;
+
+using vl = vector<ll>;
+using vvl = vector<vl>;
+using vvvl = vector<vvl>;
+using vvvvl = vector<vvvl>;
+
+template<class v>
+auto operator<<(ostream &os, const vector<v> &vec)->ostream& {
+    os << vec[0];
+    for (size_t i = 1; i < vec.size(); i++) {
+        os << ' ' << vec[i];
+    }
+    os << '\n';
+    return os;
+}
+
+template<class v>
+auto operator>>(istream &is, vector<v> &vec)->istream& {
+    for (auto &i : vec) {
+        is >> i;
+    }
+    return is;
+}
+
+template<class v>
+auto operator<<(ostream &os, const vector<vector<v>> &vec)->ostream& {
+    for (auto &i : vec) {
+        os << i[0];
+        for (size_t j = 1; j < i.size(); j++) {
+            os << ' ' << i[j];
+        }
+        os << '\n';
+    }
+    return os;
+}
+
+template<class v>
+auto operator>>(istream  &is, vector<vector<v>> &vec)->istream& {
+    for (auto &i : vec) {
+        for (auto &j : i) {
+            is >> j;
+        }
+    }
+    return is;
+}
+
+const int oo = INT32_MAX >> 1;
+const ll OO = INT64_MAX >> 1;
+
+
+void pre()
+{
+
+}
+
+#define TEST 1
+
+void solve()
+{
+    int n;
+    cin >> n;
+    string a;
+    cin >> a;
+
+    int ans = 1;
+    int rep = 0;
+    nrep(i, 1, n) {
+        ans += a[i] != a[i - 1];
+        rep |= a[i] == a[i - 1];
+    }
+
+    cout << ans + rep - (rep && n > 1 && a.back() == a.front()) << '\n';
+}
+
+int main()
+{
+    ios::sync_with_stdio(false);
+    cin.tie(nullptr);
+
+    pre();
+
+    int t;
+    (TEST && cin >> t) || (t = 1);
+    while (t--) {
+        solve();
+    }
+}

Codeforces Round 1081 (Div. 2)/B. Flipping Binary String.cpp

@@ -0,0 +1,129 @@
+/* Problem URL: https://codeforces.com/contest/2192/problem/B */
+
+#include <bits/stdc++.h>
+#include <ext/pb_ds/assoc_container.hpp>
+#include <ext/pb_ds/tree_policy.hpp>
+
+using namespace std;
+using namespace __gnu_pbds;
+
+template <class T, class comp = less<>>
+using ordered_set = tree<T, null_type , comp , rb_tree_tag , tree_order_statistics_node_update>;
+
+#define V vector
+
+#define rmin(a, b) a = min(a, b)
+#define rmax(a, b) a = max(a, b)
+
+#define rep(i, lim) for (int i = 0; i < (lim); i++)
+#define nrep(i, s, lim) for (int i = s; i < (lim); i++)
+
+#define repv(i, v) for (auto &i : (v))
+#define fillv(v) for (auto &itr_ : (v)) { cin >> itr_; }
+#define sortv(v) sort(v.begin(), v.end())
+#define all(v) (v).begin(), (v).end()
+
+using vi = vector<int>;
+using vvi = vector<vi>;
+using vvvi = vector<vvi>;
+using vvvvi = vector<vvvi>;
+
+using ll = long long;
+
+using vl = vector<ll>;
+using vvl = vector<vl>;
+using vvvl = vector<vvl>;
+using vvvvl = vector<vvvl>;
+
+template<class v>
+auto operator<<(ostream &os, const vector<v> &vec)->ostream& {
+    os << vec[0];
+    for (size_t i = 1; i < vec.size(); i++) {
+        os << ' ' << vec[i];
+    }
+    os << '\n';
+    return os;
+}
+
+template<class v>
+auto operator>>(istream &is, vector<v> &vec)->istream& {
+    for (auto &i : vec) {
+        is >> i;
+    }
+    return is;
+}
+
+template<class v>
+auto operator<<(ostream &os, const vector<vector<v>> &vec)->ostream& {
+    for (auto &i : vec) {
+        os << i[0];
+        for (size_t j = 1; j < i.size(); j++) {
+            os << ' ' << i[j];
+        }
+        os << '\n';
+    }
+    return os;
+}
+
+template<class v>
+auto operator>>(istream  &is, vector<vector<v>> &vec)->istream& {
+    for (auto &i : vec) {
+        for (auto &j : i) {
+            is >> j;
+        }
+    }
+    return is;
+}
+
+const int oo = INT32_MAX >> 1;
+const ll OO = INT64_MAX >> 1;
+
+
+void pre()
+{
+
+}
+
+#define TEST 1
+
+void solve()
+{
+    int n;
+    cin >> n;
+
+    vvi pos(2);
+    rep(i, n) {
+        char b;
+        cin >> b;
+        pos[b == '1'].push_back(i + 1);
+    }
+
+    int now = 0;
+    if (~pos[0].size() & 1) {
+        if (pos[1].size() & 1) {
+            cout << "-1\n";
+            return;
+        }
+        now = 1;
+    }
+
+    cout << pos[now].size() << '\n';
+    repv(i, pos[now]) {
+        cout << i << ' ';
+    }
+    cout << '\n';
+}
+
+int main()
+{
+    ios::sync_with_stdio(false);
+    cin.tie(nullptr);
+
+    pre();
+
+    int t;
+    (TEST && cin >> t) || (t = 1);
+    while (t--) {
+        solve();
+    }
+}

Codeforces Round 1081 (Div. 2)/C. All-in-one Gun.cpp

@@ -0,0 +1,160 @@
+/* Problem URL: https://codeforces.com/contest/2192/problem/C */
+
+#include <bits/stdc++.h>
+#include <ext/pb_ds/assoc_container.hpp>
+#include <ext/pb_ds/tree_policy.hpp>
+
+using namespace std;
+using namespace __gnu_pbds;
+
+template <class T, class comp = less<>>
+using ordered_set = tree<T, null_type , comp , rb_tree_tag , tree_order_statistics_node_update>;
+
+#define V vector
+
+#define rmin(a, b) a = min(a, b)
+#define rmax(a, b) a = max(a, b)
+
+#define rep(i, lim) for (int i = 0; i < (lim); i++)
+#define nrep(i, s, lim) for (int i = s; i < (lim); i++)
+
+#define repv(i, v) for (auto &i : (v))
+#define fillv(v) for (auto &itr_ : (v)) { cin >> itr_; }
+#define sortv(v) sort(v.begin(), v.end())
+#define all(v) (v).begin(), (v).end()
+
+using vi = vector<int>;
+using vvi = vector<vi>;
+using vvvi = vector<vvi>;
+using vvvvi = vector<vvvi>;
+
+using ll = long long;
+
+using vl = vector<ll>;
+using vvl = vector<vl>;
+using vvvl = vector<vvl>;
+using vvvvl = vector<vvvl>;
+
+template<class v>
+auto operator<<(ostream &os, const vector<v> &vec)->ostream& {
+    os << vec[0];
+    for (size_t i = 1; i < vec.size(); i++) {
+        os << ' ' << vec[i];
+    }
+    os << '\n';
+    return os;
+}
+
+template<class v>
+auto operator>>(istream &is, vector<v> &vec)->istream& {
+    for (auto &i : vec) {
+        is >> i;
+    }
+    return is;
+}
+
+template<class v>
+auto operator<<(ostream &os, const vector<vector<v>> &vec)->ostream& {
+    for (auto &i : vec) {
+        os << i[0];
+        for (size_t j = 1; j < i.size(); j++) {
+            os << ' ' << i[j];
+        }
+        os << '\n';
+    }
+    return os;
+}
+
+template<class v>
+auto operator>>(istream  &is, vector<vector<v>> &vec)->istream& {
+    for (auto &i : vec) {
+        for (auto &j : i) {
+            is >> j;
+        }
+    }
+    return is;
+}
+
+const int oo = INT32_MAX >> 1;
+const ll OO = INT64_MAX >> 1;
+
+
+void pre()
+{
+
+}
+
+#define TEST 1
+
+void solve()
+{
+    int n;
+    ll h, k;
+    cin >> n >> h >> k;
+
+    vl a(n);
+    ll sum = 0;
+    repv(i, a) {
+        cin >> i;
+        sum += i;
+    }
+
+    ll ans = h / sum * (k + n);
+    h %= sum;
+
+    if (h == 0) {
+        cout << ans - k << '\n';
+        return;
+    }
+
+    int lim = 0;
+    vl pref(n + 1);
+    rep(i, n) {
+        pref[i + 1] = pref[i] + a[i];
+    }
+
+    while (h - pref[lim] > 0) {
+        lim++;
+    }
+
+    ll ma = 0;
+    nrep(j, lim - 1, n) {
+        rmax(ma, a[j]);
+    }
+
+    int cur = oo;
+    rep(i, lim) {
+        int low = i;
+        int high = lim - 1;
+        int ans = lim;
+        while (low <= high) {
+            int mid = (low + high) >> 1;
+
+            if (pref[mid + 1] - a[i] + ma >= h) {
+                ans = mid + 1;
+                high = mid - 1;
+                continue;
+            }
+
+            low = mid + 1;
+        }
+
+        rmin(cur, ans);
+    }
+
+    cout << ans + cur << '\n';
+}
+
+int main()
+{
+    ios::sync_with_stdio(false);
+    cin.tie(nullptr);
+
+    pre();
+
+    int t;
+    (TEST && cin >> t) || (t = 1);
+    while (t--) {
+        solve();
+    }
+}

Codeforces Round 1082 (Div. 2)/A. Parkour Design.cpp

@@ -0,0 +1,123 @@
+/* Problem URL: https://codeforces.com/contest/2202/problem/A */
+
+#include <bits/stdc++.h>
+#include <ext/pb_ds/assoc_container.hpp>
+#include <ext/pb_ds/tree_policy.hpp>
+
+using namespace std;
+using namespace __gnu_pbds;
+
+template <class T, class comp = less<>>
+using ordered_set = tree<T, null_type , comp , rb_tree_tag , tree_order_statistics_node_update>;
+
+#define V vector
+
+#define rmin(a, b) a = min(a, b)
+#define rmax(a, b) a = max(a, b)
+
+#define rep(i, lim) for (int i = 0; i < (lim); i++)
+#define nrep(i, s, lim) for (int i = s; i < (lim); i++)
+
+#define repv(i, v) for (auto &i : (v))
+#define fillv(v) for (auto &itr_ : (v)) { cin >> itr_; }
+#define sortv(v) sort(v.begin(), v.end())
+#define all(v) (v).begin(), (v).end()
+
+using vi = vector<int>;
+using vvi = vector<vi>;
+using vvvi = vector<vvi>;
+using vvvvi = vector<vvvi>;
+
+using ll = long long;
+
+using vl = vector<ll>;
+using vvl = vector<vl>;
+using vvvl = vector<vvl>;
+using vvvvl = vector<vvvl>;
+
+template<class v>
+auto operator<<(ostream &os, const vector<v> &vec)->ostream& {
+    os << vec[0];
+    for (size_t i = 1; i < vec.size(); i++) {
+        os << ' ' << vec[i];
+    }
+    os << '\n';
+    return os;
+}
+
+template<class v>
+auto operator>>(istream &is, vector<v> &vec)->istream& {
+    for (auto &i : vec) {
+        is >> i;
+    }
+    return is;
+}
+
+template<class v>
+auto operator<<(ostream &os, const vector<vector<v>> &vec)->ostream& {
+    for (auto &i : vec) {
+        os << i[0];
+        for (size_t j = 1; j < i.size(); j++) {
+            os << ' ' << i[j];
+        }
+        os << '\n';
+    }
+    return os;
+}
+
+template<class v>
+auto operator>>(istream  &is, vector<vector<v>> &vec)->istream& {
+    for (auto &i : vec) {
+        for (auto &j : i) {
+            is >> j;
+        }
+    }
+    return is;
+}
+
+const int oo = INT32_MAX >> 1;
+const ll OO = INT64_MAX >> 1;
+
+
+void pre()
+{
+
+}
+
+#define TEST 1
+
+void solve()
+{
+    ll x, y;
+    cin >> x >> y;
+
+    ll xlim = 0;
+    if (y > 0) {
+        xlim += y * 2;
+    }
+    
+    if (y < 0) {
+        xlim += -y * 4;
+    }
+
+    if (xlim > x || (x - xlim) % 3) {
+        cout << "NO\n";
+        return;
+    }
+
+    cout << "YES\n";
+}
+
+int main()
+{
+    ios::sync_with_stdio(false);
+    cin.tie(nullptr);
+
+    pre();
+
+    int t;
+    (TEST && cin >> t) || (t = 1);
+    while (t--) {
+        solve();
+    }
+}

Codeforces Round 1082 (Div. 2)/B. ABAB Construction.cpp

@@ -0,0 +1,143 @@
+/* Problem URL: https://codeforces.com/contest/2202/problem/B */
+
+#include <bits/stdc++.h>
+#include <ext/pb_ds/assoc_container.hpp>
+#include <ext/pb_ds/tree_policy.hpp>
+
+using namespace std;
+using namespace __gnu_pbds;
+
+template <class T, class comp = less<>>
+using ordered_set = tree<T, null_type , comp , rb_tree_tag , tree_order_statistics_node_update>;
+
+#define V vector
+
+#define rmin(a, b) a = min(a, b)
+#define rmax(a, b) a = max(a, b)
+
+#define rep(i, lim) for (int i = 0; i < (lim); i++)
+#define nrep(i, s, lim) for (int i = s; i < (lim); i++)
+
+#define repv(i, v) for (auto &i : (v))
+#define fillv(v) for (auto &itr_ : (v)) { cin >> itr_; }
+#define sortv(v) sort(v.begin(), v.end())
+#define all(v) (v).begin(), (v).end()
+
+using vi = vector<int>;
+using vvi = vector<vi>;
+using vvvi = vector<vvi>;
+using vvvvi = vector<vvvi>;
+
+using ll = long long;
+
+using vl = vector<ll>;
+using vvl = vector<vl>;
+using vvvl = vector<vvl>;
+using vvvvl = vector<vvvl>;
+
+template<class v>
+auto operator<<(ostream &os, const vector<v> &vec)->ostream& {
+    os << vec[0];
+    for (size_t i = 1; i < vec.size(); i++) {
+        os << ' ' << vec[i];
+    }
+    os << '\n';
+    return os;
+}
+
+template<class v>
+auto operator>>(istream &is, vector<v> &vec)->istream& {
+    for (auto &i : vec) {
+        is >> i;
+    }
+    return is;
+}
+
+template<class v>
+auto operator<<(ostream &os, const vector<vector<v>> &vec)->ostream& {
+    for (auto &i : vec) {
+        os << i[0];
+        for (size_t j = 1; j < i.size(); j++) {
+            os << ' ' << i[j];
+        }
+        os << '\n';
+    }
+    return os;
+}
+
+template<class v>
+auto operator>>(istream  &is, vector<vector<v>> &vec)->istream& {
+    for (auto &i : vec) {
+        for (auto &j : i) {
+            is >> j;
+        }
+    }
+    return is;
+}
+
+const int oo = INT32_MAX >> 1;
+const ll OO = INT64_MAX >> 1;
+
+
+void pre()
+{
+
+}
+
+#define TEST 1
+
+void solve()
+{
+    int n;
+    cin >> n;
+    string a;
+    cin >> a;
+
+    vvvi dp(n, vvi(2, vi(2)));
+
+    if (a.back() == 'a') {
+        dp.back()[0][0] = 1;
+    } else if (a.back() == 'b') {
+        dp.back()[1][1] = 1;
+    } else {
+        dp.back()[0][0] = 1;
+        dp.back()[1][1] = 1;
+    }
+
+    for (int i = n - 2; i >= 0; i--) {
+        rep(j, 4) {
+            int b1 = (j >> 1) & 1;
+            int b2 = j & 1;
+
+            if (a[i] == '?') {
+                dp[i][b1][b2] |= dp[i + 1][b1^1][b2];
+                dp[i][b1][b2] |= dp[i + 1][b1][b2^1];
+                continue;
+            }
+
+            int c = a[i] - 'a';
+            if (b1 == c) {
+                dp[i][b1][b2] |= dp[i + 1][b1^1][b2];
+            }
+            if (b2 == c) {
+                dp[i][b1][b2] |= dp[i + 1][b1][b2^1];
+            }
+        }
+    }
+
+    cout << (dp[0][0][~n & 1] ? "YES\n" : "NO\n");
+}
+
+int main()
+{
+    ios::sync_with_stdio(false);
+    cin.tie(nullptr);
+
+    pre();
+
+    int t;
+    (TEST && cin >> t) || (t = 1);
+    while (t--) {
+        solve();
+    }
+}

Codeforces Round 1082 (Div. 2)/C1. Lost Civilization (Easy Version).cpp

@@ -0,0 +1,126 @@
+/* Problem URL: https://codeforces.com/contest/2202/problem/C1 */
+
+#include <bits/stdc++.h>
+#include <ext/pb_ds/assoc_container.hpp>
+#include <ext/pb_ds/tree_policy.hpp>
+
+using namespace std;
+using namespace __gnu_pbds;
+
+template <class T, class comp = less<>>
+using ordered_set = tree<T, null_type , comp , rb_tree_tag , tree_order_statistics_node_update>;
+
+#define V vector
+
+#define rmin(a, b) a = min(a, b)
+#define rmax(a, b) a = max(a, b)
+
+#define rep(i, lim) for (int i = 0; i < (lim); i++)
+#define nrep(i, s, lim) for (int i = s; i < (lim); i++)
+
+#define repv(i, v) for (auto &i : (v))
+#define fillv(v) for (auto &itr_ : (v)) { cin >> itr_; }
+#define sortv(v) sort(v.begin(), v.end())
+#define all(v) (v).begin(), (v).end()
+
+using vi = vector<int>;
+using vvi = vector<vi>;
+using vvvi = vector<vvi>;
+using vvvvi = vector<vvvi>;
+
+using ll = long long;
+
+using vl = vector<ll>;
+using vvl = vector<vl>;
+using vvvl = vector<vvl>;
+using vvvvl = vector<vvvl>;
+
+template<class v>
+auto operator<<(ostream &os, const vector<v> &vec)->ostream& {
+    os << vec[0];
+    for (size_t i = 1; i < vec.size(); i++) {
+        os << ' ' << vec[i];
+    }
+    os << '\n';
+    return os;
+}
+
+template<class v>
+auto operator>>(istream &is, vector<v> &vec)->istream& {
+    for (auto &i : vec) {
+        is >> i;
+    }
+    return is;
+}
+
+template<class v>
+auto operator<<(ostream &os, const vector<vector<v>> &vec)->ostream& {
+    for (auto &i : vec) {
+        os << i[0];
+        for (size_t j = 1; j < i.size(); j++) {
+            os << ' ' << i[j];
+        }
+        os << '\n';
+    }
+    return os;
+}
+
+template<class v>
+auto operator>>(istream  &is, vector<vector<v>> &vec)->istream& {
+    for (auto &i : vec) {
+        for (auto &j : i) {
+            is >> j;
+        }
+    }
+    return is;
+}
+
+const int oo = INT32_MAX >> 1;
+const ll OO = INT64_MAX >> 1;
+
+
+void pre()
+{
+
+}
+
+#define TEST 1
+
+void solve()
+{
+    int n;
+    cin >> n;
+    vl a(n);
+    cin >> a;
+
+    set<ll> t;
+    int c = 0;
+
+    rep(i, n) {
+        if (t.count(a[i])) {
+            c++;
+            while (*prev(t.end()) > a[i] + 1) {
+                t.erase(prev(t.end()));
+            }
+        } else {
+            t.clear();
+        }
+        t.insert(a[i] + 1);
+    }
+
+    cout << n - c << '\n';
+}
+
+int main()
+{
+    ios::sync_with_stdio(false);
+    cin.tie(nullptr);
+
+    pre();
+
+    int t;
+    (TEST && cin >> t) || (t = 1);
+    while (t--) {
+        solve();
+    }
+}

Codeforces Round 1083 (Div. 2)/A. Simons and Making It Beautiful.cpp

@@ -0,0 +1,118 @@
+/* Problem URL: https://codeforces.com/contest/2205/problem/A */
+
+#include <bits/stdc++.h>
+#include <ext/pb_ds/assoc_container.hpp>
+#include <ext/pb_ds/tree_policy.hpp>
+
+using namespace std;
+using namespace __gnu_pbds;
+
+template <class T, class comp = less<>>
+using ordered_set = tree<T, null_type , comp , rb_tree_tag , tree_order_statistics_node_update>;
+
+#define V vector
+
+#define rmin(a, b) a = min(a, b)
+#define rmax(a, b) a = max(a, b)
+
+#define rep(i, lim) for (int i = 0; i < (lim); i++)
+#define nrep(i, s, lim) for (int i = s; i < (lim); i++)
+
+#define repv(i, v) for (auto &i : (v))
+#define fillv(v) for (auto &itr_ : (v)) { cin >> itr_; }
+#define sortv(v) sort(v.begin(), v.end())
+#define all(v) (v).begin(), (v).end()
+
+using vi = vector<int>;
+using vvi = vector<vi>;
+using vvvi = vector<vvi>;
+using vvvvi = vector<vvvi>;
+
+using ll = long long;
+
+using vl = vector<ll>;
+using vvl = vector<vl>;
+using vvvl = vector<vvl>;
+using vvvvl = vector<vvvl>;
+
+template<class v>
+auto operator<<(ostream &os, const vector<v> &vec)->ostream& {
+    os << vec[0];
+    for (size_t i = 1; i < vec.size(); i++) {
+        os << ' ' << vec[i];
+    }
+    os << '\n';
+    return os;
+}
+
+template<class v>
+auto operator>>(istream &is, vector<v> &vec)->istream& {
+    for (auto &i : vec) {
+        is >> i;
+    }
+    return is;
+}
+
+template<class v>
+auto operator<<(ostream &os, const vector<vector<v>> &vec)->ostream& {
+    for (auto &i : vec) {
+        os << i[0];
+        for (size_t j = 1; j < i.size(); j++) {
+            os << ' ' << i[j];
+        }
+        os << '\n';
+    }
+    return os;
+}
+
+template<class v>
+auto operator>>(istream  &is, vector<vector<v>> &vec)->istream& {
+    for (auto &i : vec) {
+        for (auto &j : i) {
+            is >> j;
+        }
+    }
+    return is;
+}
+
+const int oo = INT32_MAX >> 1;
+const ll OO = INT64_MAX >> 1;
+
+
+void pre()
+{
+
+}
+
+#define TEST 1
+
+void solve()
+{
+    int n;
+    cin >> n;
+    vi p(n);
+    cin >> p;
+
+    rep(i, n) {
+        if (p[i] == n) {
+            swap(p[i], p[0]);
+            break;
+        }
+    }
+
+    cout << p;
+}
+
+int main()
+{
+    ios::sync_with_stdio(false);
+    cin.tie(nullptr);
+
+    pre();
+
+    int t;
+    (TEST && cin >> t) || (t = 1);
+    while (t--) {
+        solve();
+    }
+}

Codeforces Round 1083 (Div. 2)/B. Simons and Cakes for Success.cpp

@@ -0,0 +1,140 @@
+/* Problem URL: https://codeforces.com/contest/2205/problem/B */
+
+#include <bits/stdc++.h>
+#include <ext/pb_ds/assoc_container.hpp>
+#include <ext/pb_ds/tree_policy.hpp>
+
+using namespace std;
+using namespace __gnu_pbds;
+
+template <class T, class comp = less<>>
+using ordered_set = tree<T, null_type , comp , rb_tree_tag , tree_order_statistics_node_update>;
+
+#define V vector
+
+#define rmin(a, b) a = min(a, b)
+#define rmax(a, b) a = max(a, b)
+
+#define rep(i, lim) for (int i = 0; i < (lim); i++)
+#define nrep(i, s, lim) for (int i = s; i < (lim); i++)
+
+#define repv(i, v) for (auto &i : (v))
+#define fillv(v) for (auto &itr_ : (v)) { cin >> itr_; }
+#define sortv(v) sort(v.begin(), v.end())
+#define all(v) (v).begin(), (v).end()
+
+using vi = vector<int>;
+using vvi = vector<vi>;
+using vvvi = vector<vvi>;
+using vvvvi = vector<vvvi>;
+
+using ll = long long;
+
+using vl = vector<ll>;
+using vvl = vector<vl>;
+using vvvl = vector<vvl>;
+using vvvvl = vector<vvvl>;
+
+template<class v>
+auto operator<<(ostream &os, const vector<v> &vec)->ostream& {
+    os << vec[0];
+    for (size_t i = 1; i < vec.size(); i++) {
+        os << ' ' << vec[i];
+    }
+    os << '\n';
+    return os;
+}
+
+template<class v>
+auto operator>>(istream &is, vector<v> &vec)->istream& {
+    for (auto &i : vec) {
+        is >> i;
+    }
+    return is;
+}
+
+template<class v>
+auto operator<<(ostream &os, const vector<vector<v>> &vec)->ostream& {
+    for (auto &i : vec) {
+        os << i[0];
+        for (size_t j = 1; j < i.size(); j++) {
+            os << ' ' << i[j];
+        }
+        os << '\n';
+    }
+    return os;
+}
+
+template<class v>
+auto operator>>(istream  &is, vector<vector<v>> &vec)->istream& {
+    for (auto &i : vec) {
+        for (auto &j : i) {
+            is >> j;
+        }
+    }
+    return is;
+}
+
+const int oo = INT32_MAX >> 1;
+const ll OO = INT64_MAX >> 1;
+
+constexpr int MAXN = 1e5;
+bool prime[MAXN];
+vl primes;
+
+
+void pre()
+{
+    fill(prime, prime + MAXN, true);
+    prime[1] = false;
+
+    nrep(i, 2, MAXN) {
+        if (!prime[i]) {
+            continue;
+        }
+
+        primes.push_back(i);
+        for (int j = i * 2; j < MAXN; j += i) {
+            prime[j] = false;
+        }
+    }
+}
+
+#define TEST 1
+
+void solve()
+{
+    ll n;
+    cin >> n;
+
+    vl ans;
+    for (int i = 0; primes[i] * primes[i] <= n; i++) {
+        while (n % primes[i] == 0) {
+            n /= primes[i];
+            ans.push_back(primes[i]);
+        }
+    }
+
+    ans.push_back(n);
+    ans.erase(unique(all(ans)), ans.end());
+
+    ll act = 1;
+    repv(i, ans) {
+        act *= i;
+    }
+    cout << act << '\n';
+}
+
+int main()
+{
+    ios::sync_with_stdio(false);
+    cin.tie(nullptr);
+
+    pre();
+
+    int t;
+    (TEST && cin >> t) || (t = 1);
+    while (t--) {
+        solve();
+    }
+}

Codeforces Round 1083 (Div. 2)/C. Simons and Posting Blogs.cpp

@@ -0,0 +1,197 @@
+/* Problem URL: https://codeforces.com/contest/2205/problem/C */
+
+#include <bits/stdc++.h>
+#include <ext/pb_ds/assoc_container.hpp>
+#include <ext/pb_ds/tree_policy.hpp>
+
+using namespace std;
+using namespace __gnu_pbds;
+
+template <class T, class comp = less<>>
+using ordered_set = tree<T, null_type , comp , rb_tree_tag , tree_order_statistics_node_update>;
+
+#define V vector
+
+#define rmin(a, b) a = min(a, b)
+#define rmax(a, b) a = max(a, b)
+
+#define rep(i, lim) for (int i = 0; i < (lim); i++)
+#define nrep(i, s, lim) for (int i = s; i < (lim); i++)
+
+#define repv(i, v) for (auto &i : (v))
+#define fillv(v) for (auto &itr_ : (v)) { cin >> itr_; }
+#define sortv(v) sort(v.begin(), v.end())
+#define all(v) (v).begin(), (v).end()
+
+using vi = vector<int>;
+using vvi = vector<vi>;
+using vvvi = vector<vvi>;
+using vvvvi = vector<vvvi>;
+
+using ll = long long;
+
+using vl = vector<ll>;
+using vvl = vector<vl>;
+using vvvl = vector<vvl>;
+using vvvvl = vector<vvvl>;
+
+template<class v>
+auto operator<<(ostream &os, const vector<v> &vec)->ostream& {
+    os << vec[0];
+    for (size_t i = 1; i < vec.size(); i++) {
+        os << ' ' << vec[i];
+    }
+    os << '\n';
+    return os;
+}
+
+template<class v>
+auto operator>>(istream &is, vector<v> &vec)->istream& {
+    for (auto &i : vec) {
+        is >> i;
+    }
+    return is;
+}
+
+template<class v>
+auto operator<<(ostream &os, const vector<vector<v>> &vec)->ostream& {
+    for (auto &i : vec) {
+        os << i[0];
+        for (size_t j = 1; j < i.size(); j++) {
+            os << ' ' << i[j];
+        }
+        os << '\n';
+    }
+    return os;
+}
+
+template<class v>
+auto operator>>(istream  &is, vector<vector<v>> &vec)->istream& {
+    for (auto &i : vec) {
+        for (auto &j : i) {
+            is >> j;
+        }
+    }
+    return is;
+}
+
+const int oo = INT32_MAX >> 1;
+const ll OO = INT64_MAX >> 1;
+
+
+void pre()
+{
+
+}
+
+#define TEST 1
+
+void solve()
+{
+    int n;
+    cin >> n;
+
+    vvi act(n);
+    rep(i, n) {
+        int m;
+        cin >> m;
+        act[i].resize(m);
+        cin >> act[i];
+    }
+
+    V<bool> used(1e6 + 1);
+
+    vi t(n);
+    iota(all(t), 0);
+    vi ans;
+    while (true) {
+        if (t.empty()) {
+            break;
+        }
+
+        vi ch = t;
+        vi tmp;
+        while (ch.size() > 1) {
+            int a = oo;
+            repv(j, ch) {
+                while (!act[j].empty() && used[act[j].back()]) {
+                    act[j].pop_back();
+                }
+
+                if (act[j].empty()) {
+                    a = oo;
+                    break;
+                }
+
+                if (act[j].back() < a) {
+                    tmp.clear();
+                    tmp.push_back(j);
+                    a = act[j].back();
+                    continue;
+                }
+
+                if (act[j].back() == a) {
+                    tmp.push_back(j);
+                }
+            }
+
+            if (a == oo) {
+                break;
+            }
+
+            used[a] = true;
+            ans.push_back(a);
+            swap(ch, tmp);
+            tmp.clear();
+        }
+
+        bool rem = false;
+        int cur = 0;
+        rep(i, t.size()) {
+            while (!act[t[i]].empty() && used[act[t[i]].back()]) {
+                act[t[i]].pop_back();
+            }
+
+            if (act[t[i]].empty()) {
+                rem = true;
+                continue;
+            }
+
+            t[cur] = t[i];
+            cur++;
+        }
+        while (t.size() > cur) {
+            t.pop_back();
+        }
+
+        if (rem) {
+            continue;
+        }
+
+        while (!act[ch[0]].empty()) {
+            int j = act[ch[0]].back();
+            act[ch[0]].pop_back();
+            if (used[j]) {
+                continue;
+            }
+            used[j] = true;
+            ans.push_back(j);
+        }
+    }
+
+    cout << ans;
+}
+
+int main()
+{
+    ios::sync_with_stdio(false);
+    cin.tie(nullptr);
+
+    pre();
+
+    int t;
+    (TEST && cin >> t) || (t = 1);
+    while (t--) {
+        solve();
+    }
+}

Codeforces Round 1083 (Div. 2)/D. Simons and Beating Peaks.cpp

@@ -0,0 +1,172 @@
+/* Problem URL: https://codeforces.com/contest/2205/problem/D */
+
+#include <bits/stdc++.h>
+#include <ext/pb_ds/assoc_container.hpp>
+#include <ext/pb_ds/tree_policy.hpp>
+
+using namespace std;
+using namespace __gnu_pbds;
+
+template <class T, class comp = less<>>
+using ordered_set = tree<T, null_type , comp , rb_tree_tag , tree_order_statistics_node_update>;
+
+#define V vector
+
+#define rmin(a, b) a = min(a, b)
+#define rmax(a, b) a = max(a, b)
+
+#define rep(i, lim) for (int i = 0; i < (lim); i++)
+#define nrep(i, s, lim) for (int i = s; i < (lim); i++)
+
+#define repv(i, v) for (auto &i : (v))
+#define fillv(v) for (auto &itr_ : (v)) { cin >> itr_; }
+#define sortv(v) sort(v.begin(), v.end())
+#define all(v) (v).begin(), (v).end()
+
+using vi = vector<int>;
+using vvi = vector<vi>;
+using vvvi = vector<vvi>;
+using vvvvi = vector<vvvi>;
+
+using ll = long long;
+
+using vl = vector<ll>;
+using vvl = vector<vl>;
+using vvvl = vector<vvl>;
+using vvvvl = vector<vvvl>;
+
+template<class v>
+auto operator<<(ostream &os, const vector<v> &vec)->ostream& {
+    os << vec[0];
+    for (size_t i = 1; i < vec.size(); i++) {
+        os << ' ' << vec[i];
+    }
+    os << '\n';
+    return os;
+}
+
+template<class v>
+auto operator>>(istream &is, vector<v> &vec)->istream& {
+    for (auto &i : vec) {
+        is >> i;
+    }
+    return is;
+}
+
+template<class v>
+auto operator<<(ostream &os, const vector<vector<v>> &vec)->ostream& {
+    for (auto &i : vec) {
+        os << i[0];
+        for (size_t j = 1; j < i.size(); j++) {
+            os << ' ' << i[j];
+        }
+        os << '\n';
+    }
+    return os;
+}
+
+template<class v>
+auto operator>>(istream  &is, vector<vector<v>> &vec)->istream& {
+    for (auto &i : vec) {
+        for (auto &j : i) {
+            is >> j;
+        }
+    }
+    return is;
+}
+
+const int oo = INT32_MAX >> 1;
+const ll OO = INT64_MAX >> 1;
+
+
+void pre()
+{
+
+}
+
+#define TEST 1
+
+void solve()
+{
+    int n;
+    cin >> n;
+    vi p(n);
+    cin >> p;
+
+    vi pos(n);
+    rep(i, n) {
+        pos[p[i] - 1] = i;
+    }
+
+    vi lf(n, -1);
+    vi rg(n, n);
+
+    stack<pair<int, int>> s;
+    rep(i, n) {
+        while (!s.empty() && s.top().first < p[i]) {
+            s.pop();
+        }
+
+        if (!s.empty()) {
+            lf[i] = s.top().second;
+        }
+
+        s.emplace(p[i], i);
+    }
+
+    while (!s.empty()) {
+        s.pop();
+    }
+
+    for (int i = n - 1; i >= 0; i--) {
+        while (!s.empty() && s.top().first < p[i]) {
+            s.pop();
+        }
+
+        if (!s.empty()) {
+            rg[i] = s.top().second;
+        }
+
+        s.emplace(p[i], i);
+    }
+
+    vvi dp(n, vi(2));
+
+    int ans = oo;
+    
+    for (int i = n - 1; i >= 0; i--) {
+        int ps = pos[i];
+
+        if (lf[ps] == -1) {
+            dp[i][0] = ps;
+        } else {
+            int dis = ps - lf[ps] - 1;
+            dp[i][0] = dis + dp[p[lf[ps]] - 1][0];
+        }
+
+        if (rg[ps] == n) {
+            dp[i][1] = n - ps - 1;
+        } else {
+            int dis = rg[ps] - ps - 1;
+            dp[i][1] = dis + dp[p[rg[ps]] - 1][1];
+        }
+
+        rmin(ans, dp[i][0] + dp[i][1]);
+    }
+
+    cout << ans << '\n';
+}
+
+int main()
+{
+    ios::sync_with_stdio(false);
+    cin.tie(nullptr);
+
+    pre();
+
+    int t;
+    (TEST && cin >> t) || (t = 1);
+    while (t--) {
+        solve();
+    }
+}

Codeforces Round 1084 (Div. 3)/A. Eating Game.cpp

@@ -0,0 +1,111 @@
+/* Problem URL: https://codeforces.com/contest/2200/problem/A */
+
+#include <bits/stdc++.h>
+#include <ext/pb_ds/assoc_container.hpp>
+#include <ext/pb_ds/tree_policy.hpp>
+
+using namespace std;
+using namespace __gnu_pbds;
+
+template <class T, class comp = less<>>
+using ordered_set = tree<T, null_type , comp , rb_tree_tag , tree_order_statistics_node_update>;
+
+#define V vector
+
+#define rmin(a, b) a = min(a, b)
+#define rmax(a, b) a = max(a, b)
+
+#define rep(i, lim) for (int i = 0; i < (lim); i++)
+#define nrep(i, s, lim) for (int i = s; i < (lim); i++)
+
+#define repv(i, v) for (auto &i : (v))
+#define fillv(v) for (auto &itr_ : (v)) { cin >> itr_; }
+#define sortv(v) sort(v.begin(), v.end())
+#define all(v) (v).begin(), (v).end()
+
+using vi = vector<int>;
+using vvi = vector<vi>;
+using vvvi = vector<vvi>;
+using vvvvi = vector<vvvi>;
+
+using ll = long long;
+
+using vl = vector<ll>;
+using vvl = vector<vl>;
+using vvvl = vector<vvl>;
+using vvvvl = vector<vvvl>;
+
+template<class v>
+auto operator<<(ostream &os, const vector<v> &vec)->ostream& {
+    os << vec[0];
+    for (size_t i = 1; i < vec.size(); i++) {
+        os << ' ' << vec[i];
+    }
+    os << '\n';
+    return os;
+}
+
+template<class v>
+auto operator>>(istream &is, vector<v> &vec)->istream& {
+    for (auto &i : vec) {
+        is >> i;
+    }
+    return is;
+}
+
+template<class v>
+auto operator<<(ostream &os, const vector<vector<v>> &vec)->ostream& {
+    for (auto &i : vec) {
+        os << i[0];
+        for (size_t j = 1; j < i.size(); j++) {
+            os << ' ' << i[j];
+        }
+        os << '\n';
+    }
+    return os;
+}
+
+template<class v>
+auto operator>>(istream  &is, vector<vector<v>> &vec)->istream& {
+    for (auto &i : vec) {
+        for (auto &j : i) {
+            is >> j;
+        }
+    }
+    return is;
+}
+
+const int oo = INT32_MAX >> 1;
+const ll OO = INT64_MAX >> 1;
+
+
+void pre()
+{
+
+}
+
+#define TEST 1
+
+void solve()
+{
+    int n;
+    cin >> n;
+    vi a(n);
+    cin >> a;
+    int b = *max_element(all(a));
+    cout << count(all(a), b) << '\n';
+}
+
+int main()
+{
+    ios::sync_with_stdio(false);
+    cin.tie(nullptr);
+
+    pre();
+
+    int t;
+    (TEST && cin >> t) || (t = 1);
+    while (t--) {
+        solve();
+    }
+}

Codeforces Round 1084 (Div. 3)/B. Deletion Sort.cpp

@@ -0,0 +1,118 @@
+/* Problem URL: https://codeforces.com/contest/2200/problem/B */
+
+#include <bits/stdc++.h>
+#include <ext/pb_ds/assoc_container.hpp>
+#include <ext/pb_ds/tree_policy.hpp>
+
+using namespace std;
+using namespace __gnu_pbds;
+
+template <class T, class comp = less<>>
+using ordered_set = tree<T, null_type , comp , rb_tree_tag , tree_order_statistics_node_update>;
+
+#define V vector
+
+#define rmin(a, b) a = min(a, b)
+#define rmax(a, b) a = max(a, b)
+
+#define rep(i, lim) for (int i = 0; i < (lim); i++)
+#define nrep(i, s, lim) for (int i = s; i < (lim); i++)
+
+#define repv(i, v) for (auto &i : (v))
+#define fillv(v) for (auto &itr_ : (v)) { cin >> itr_; }
+#define sortv(v) sort(v.begin(), v.end())
+#define all(v) (v).begin(), (v).end()
+
+using vi = vector<int>;
+using vvi = vector<vi>;
+using vvvi = vector<vvi>;
+using vvvvi = vector<vvvi>;
+
+using ll = long long;
+
+using vl = vector<ll>;
+using vvl = vector<vl>;
+using vvvl = vector<vvl>;
+using vvvvl = vector<vvvl>;
+
+template<class v>
+auto operator<<(ostream &os, const vector<v> &vec)->ostream& {
+    os << vec[0];
+    for (size_t i = 1; i < vec.size(); i++) {
+        os << ' ' << vec[i];
+    }
+    os << '\n';
+    return os;
+}
+
+template<class v>
+auto operator>>(istream &is, vector<v> &vec)->istream& {
+    for (auto &i : vec) {
+        is >> i;
+    }
+    return is;
+}
+
+template<class v>
+auto operator<<(ostream &os, const vector<vector<v>> &vec)->ostream& {
+    for (auto &i : vec) {
+        os << i[0];
+        for (size_t j = 1; j < i.size(); j++) {
+            os << ' ' << i[j];
+        }
+        os << '\n';
+    }
+    return os;
+}
+
+template<class v>
+auto operator>>(istream  &is, vector<vector<v>> &vec)->istream& {
+    for (auto &i : vec) {
+        for (auto &j : i) {
+            is >> j;
+        }
+    }
+    return is;
+}
+
+const int oo = INT32_MAX >> 1;
+const ll OO = INT64_MAX >> 1;
+
+
+void pre()
+{
+
+}
+
+#define TEST 1
+
+void solve()
+{
+    int n;
+    cin >> n;
+    vi a(n);
+    cin >> a;
+
+    nrep(i, 1, n) {
+        if (a[i] < a[i - 1]) {
+            cout << "1\n";
+            return;
+        }
+    }
+
+    cout << n << '\n';
+}
+
+int main()
+{
+    ios::sync_with_stdio(false);
+    cin.tie(nullptr);
+
+    pre();
+
+    int t;
+    (TEST && cin >> t) || (t = 1);
+    while (t--) {
+        solve();
+    }
+}

Codeforces Round 1084 (Div. 3)/C. Specialty String.cpp

@@ -0,0 +1,131 @@
+/* Problem URL: https://codeforces.com/contest/2200/problem/C */
+
+#include <bits/stdc++.h>
+#include <ext/pb_ds/assoc_container.hpp>
+#include <ext/pb_ds/tree_policy.hpp>
+
+using namespace std;
+using namespace __gnu_pbds;
+
+template <class T, class comp = less<>>
+using ordered_set = tree<T, null_type , comp , rb_tree_tag , tree_order_statistics_node_update>;
+
+#define V vector
+
+#define rmin(a, b) a = min(a, b)
+#define rmax(a, b) a = max(a, b)
+
+#define rep(i, lim) for (int i = 0; i < (lim); i++)
+#define nrep(i, s, lim) for (int i = s; i < (lim); i++)
+
+#define repv(i, v) for (auto &i : (v))
+#define fillv(v) for (auto &itr_ : (v)) { cin >> itr_; }
+#define sortv(v) sort(v.begin(), v.end())
+#define all(v) (v).begin(), (v).end()
+
+using vi = vector<int>;
+using vvi = vector<vi>;
+using vvvi = vector<vvi>;
+using vvvvi = vector<vvvi>;
+
+using ll = long long;
+
+using vl = vector<ll>;
+using vvl = vector<vl>;
+using vvvl = vector<vvl>;
+using vvvvl = vector<vvvl>;
+
+template<class v>
+auto operator<<(ostream &os, const vector<v> &vec)->ostream& {
+    os << vec[0];
+    for (size_t i = 1; i < vec.size(); i++) {
+        os << ' ' << vec[i];
+    }
+    os << '\n';
+    return os;
+}
+
+template<class v>
+auto operator>>(istream &is, vector<v> &vec)->istream& {
+    for (auto &i : vec) {
+        is >> i;
+    }
+    return is;
+}
+
+template<class v>
+auto operator<<(ostream &os, const vector<vector<v>> &vec)->ostream& {
+    for (auto &i : vec) {
+        os << i[0];
+        for (size_t j = 1; j < i.size(); j++) {
+            os << ' ' << i[j];
+        }
+        os << '\n';
+    }
+    return os;
+}
+
+template<class v>
+auto operator>>(istream  &is, vector<vector<v>> &vec)->istream& {
+    for (auto &i : vec) {
+        for (auto &j : i) {
+            is >> j;
+        }
+    }
+    return is;
+}
+
+const int oo = INT32_MAX >> 1;
+const ll OO = INT64_MAX >> 1;
+
+
+void pre()
+{
+
+}
+
+#define TEST 1
+
+void solve()
+{
+    int n;
+    string a;
+    cin >> n >> a;
+
+    if (n & 1) {
+        cout << "NO\n";
+        return;
+    }
+
+    vi c(n, 1);
+
+    for (int i = 1; i <= n; i += 2) {
+        vi pref = c;
+        nrep(j, 1, n) {
+            pref[j] += pref[j - 1];
+        }
+
+        for (int j = 0; j + i < n; j++) {
+            if (c[j] && c[j + i] && a[j] == a[j + i] && pref[j + i - 1] - pref[j] == 0) {
+                c[j] = 0;
+                c[j + i] = 0;
+            }
+        }
+    }
+
+    cout << (find(all(c), 1) == c.end() ? "YES\n" : "NO\n");
+}
+
+int main()
+{
+    ios::sync_with_stdio(false);
+    cin.tie(nullptr);
+
+    pre();
+
+    int t;
+    (TEST && cin >> t) || (t = 1);
+    while (t--) {
+        solve();
+    }
+}

Codeforces Round 1084 (Div. 3)/D. Portal.cpp

@@ -0,0 +1,150 @@
+/* Problem URL: https://codeforces.com/contest/2200/problem/D */
+
+#include <bits/stdc++.h>
+#include <ext/pb_ds/assoc_container.hpp>
+#include <ext/pb_ds/tree_policy.hpp>
+
+using namespace std;
+using namespace __gnu_pbds;
+
+template <class T, class comp = less<>>
+using ordered_set = tree<T, null_type , comp , rb_tree_tag , tree_order_statistics_node_update>;
+
+#define V vector
+
+#define rmin(a, b) a = min(a, b)
+#define rmax(a, b) a = max(a, b)
+
+#define rep(i, lim) for (int i = 0; i < (lim); i++)
+#define nrep(i, s, lim) for (int i = s; i < (lim); i++)
+
+#define repv(i, v) for (auto &i : (v))
+#define fillv(v) for (auto &itr_ : (v)) { cin >> itr_; }
+#define sortv(v) sort(v.begin(), v.end())
+#define all(v) (v).begin(), (v).end()
+
+using vi = vector<int>;
+using vvi = vector<vi>;
+using vvvi = vector<vvi>;
+using vvvvi = vector<vvvi>;
+
+using ll = long long;
+
+using vl = vector<ll>;
+using vvl = vector<vl>;
+using vvvl = vector<vvl>;
+using vvvvl = vector<vvvl>;
+
+template<class v>
+auto operator<<(ostream &os, const vector<v> &vec)->ostream& {
+    os << vec[0];
+    for (size_t i = 1; i < vec.size(); i++) {
+        os << ' ' << vec[i];
+    }
+    os << '\n';
+    return os;
+}
+
+template<class v>
+auto operator>>(istream &is, vector<v> &vec)->istream& {
+    for (auto &i : vec) {
+        is >> i;
+    }
+    return is;
+}
+
+template<class v>
+auto operator<<(ostream &os, const vector<vector<v>> &vec)->ostream& {
+    for (auto &i : vec) {
+        os << i[0];
+        for (size_t j = 1; j < i.size(); j++) {
+            os << ' ' << i[j];
+        }
+        os << '\n';
+    }
+    return os;
+}
+
+template<class v>
+auto operator>>(istream  &is, vector<vector<v>> &vec)->istream& {
+    for (auto &i : vec) {
+        for (auto &j : i) {
+            is >> j;
+        }
+    }
+    return is;
+}
+
+const int oo = INT32_MAX >> 1;
+const ll OO = INT64_MAX >> 1;
+
+
+void pre()
+{
+
+}
+
+#define TEST 1
+
+void solve()
+{
+    int n, x, y;
+    cin >> n >> x >> y;
+
+    vi p(n);
+    cin >> p;
+
+    vi act;
+    nrep(i, x, y) {
+        act.push_back(p[i]);
+    }
+
+    int pos = min_element(all(act)) - act.begin();
+    vi ans;
+
+    nrep(i, pos, act.size()) {
+        ans.push_back(act[i]);
+    }
+    rep(i, pos) {
+        ans.push_back(act[i]);
+    }
+
+    vi ot;
+    rep(i, x) {
+        ot.push_back(p[i]);
+    }
+    nrep(i, y, n) {
+        ot.push_back(p[i]);
+    }
+
+    if (ot.empty()) {
+        cout << ans;
+        return;
+    }
+
+    int i = 0;
+    for (; i < ot.size() && ot[i] < ans[0]; i++) {
+        cout << ot[i] << ' ';
+    }
+    repv(i, ans) {
+        cout << i << ' ';
+    }
+    for (; i < ot.size(); i++) {
+        cout << ot[i] << ' ';
+    }
+    cout << '\n';
+}
+
+int main()
+{
+    ios::sync_with_stdio(false);
+    cin.tie(nullptr);
+
+    pre();
+
+    int t;
+    (TEST && cin >> t) || (t = 1);
+    while (t--) {
+        solve();
+    }
+}

Codeforces Round 1084 (Div. 3)/E. Divisive Battle.cpp

@@ -0,0 +1,156 @@
+/* Problem URL: https://codeforces.com/contest/2200/problem/E */
+
+#include <bits/stdc++.h>
+#include <ext/pb_ds/assoc_container.hpp>
+#include <ext/pb_ds/tree_policy.hpp>
+
+using namespace std;
+using namespace __gnu_pbds;
+
+template <class T, class comp = less<>>
+using ordered_set = tree<T, null_type , comp , rb_tree_tag , tree_order_statistics_node_update>;
+
+#define V vector
+
+#define rmin(a, b) a = min(a, b)
+#define rmax(a, b) a = max(a, b)
+
+#define rep(i, lim) for (int i = 0; i < (lim); i++)
+#define nrep(i, s, lim) for (int i = s; i < (lim); i++)
+
+#define repv(i, v) for (auto &i : (v))
+#define fillv(v) for (auto &itr_ : (v)) { cin >> itr_; }
+#define sortv(v) sort(v.begin(), v.end())
+#define all(v) (v).begin(), (v).end()
+
+using vi = vector<int>;
+using vvi = vector<vi>;
+using vvvi = vector<vvi>;
+using vvvvi = vector<vvvi>;
+
+using ll = long long;
+
+using vl = vector<ll>;
+using vvl = vector<vl>;
+using vvvl = vector<vvl>;
+using vvvvl = vector<vvvl>;
+
+template<class v>
+auto operator<<(ostream &os, const vector<v> &vec)->ostream& {
+    os << vec[0];
+    for (size_t i = 1; i < vec.size(); i++) {
+        os << ' ' << vec[i];
+    }
+    os << '\n';
+    return os;
+}
+
+template<class v>
+auto operator>>(istream &is, vector<v> &vec)->istream& {
+    for (auto &i : vec) {
+        is >> i;
+    }
+    return is;
+}
+
+template<class v>
+auto operator<<(ostream &os, const vector<vector<v>> &vec)->ostream& {
+    for (auto &i : vec) {
+        os << i[0];
+        for (size_t j = 1; j < i.size(); j++) {
+            os << ' ' << i[j];
+        }
+        os << '\n';
+    }
+    return os;
+}
+
+template<class v>
+auto operator>>(istream  &is, vector<vector<v>> &vec)->istream& {
+    for (auto &i : vec) {
+        for (auto &j : i) {
+            is >> j;
+        }
+    }
+    return is;
+}
+
+const int oo = INT32_MAX >> 1;
+const ll OO = INT64_MAX >> 1;
+
+constexpr int MAXN = 1e6 + 1;
+int d[MAXN];
+
+void pre()
+{
+
+    fill(d, d + MAXN, 1);
+
+    nrep(i, 1, MAXN) {
+        if (d[i] != 1) {
+            continue;
+        }
+
+        for (int j = i; j < MAXN; j += i) {
+            d[j] = i;
+        }
+    }
+}
+
+#define TEST 1
+
+void solve()
+{
+    int n;
+    cin >> n;
+    vi a(n);
+    cin >> a;
+
+    bool pos = false;
+    nrep(i, 1, n) {
+        if (a[i] < a[i - 1]) {
+            pos = true;
+            break;
+        }
+    }
+
+    if (!pos) {
+        cout << "Bob\n";
+        return;
+    }
+
+    vi act;
+    repv(i, a) {
+        if (i == 1) {
+            act.push_back(i);
+            continue;
+        }
+        while (i > 1) {
+            act.push_back(d[i]);
+            i /= d[i];
+        }
+    }
+
+    nrep(i, 1, act.size()) {
+        if (act[i] < act[i - 1]) {
+            cout << "Alice\n";
+            return;
+        }
+    }
+
+    cout << "Bob\n";
+}
+
+int main()
+{
+    ios::sync_with_stdio(false);
+    cin.tie(nullptr);
+
+    pre();
+
+    int t;
+    (TEST && cin >> t) || (t = 1);
+    while (t--) {
+        solve();
+    }
+}

Codeforces Round 1084 (Div. 3)/F. Mooclear Reactor 2.cpp

@@ -0,0 +1,148 @@
+/* Problem URL: https://codeforces.com/contest/2200/problem/F */
+
+#include <bits/stdc++.h>
+#include <ext/pb_ds/assoc_container.hpp>
+#include <ext/pb_ds/tree_policy.hpp>
+
+using namespace std;
+using namespace __gnu_pbds;
+
+template <class T, class comp = less<>>
+using ordered_set = tree<T, null_type , comp , rb_tree_tag , tree_order_statistics_node_update>;
+
+#define V vector
+
+#define rmin(a, b) a = min(a, b)
+#define rmax(a, b) a = max(a, b)
+
+#define rep(i, lim) for (int i = 0; i < (lim); i++)
+#define nrep(i, s, lim) for (int i = s; i < (lim); i++)
+
+#define repv(i, v) for (auto &i : (v))
+#define fillv(v) for (auto &itr_ : (v)) { cin >> itr_; }
+#define sortv(v) sort(v.begin(), v.end())
+#define all(v) (v).begin(), (v).end()
+
+using vi = vector<int>;
+using vvi = vector<vi>;
+using vvvi = vector<vvi>;
+using vvvvi = vector<vvvi>;
+
+using ll = long long;
+
+using vl = vector<ll>;
+using vvl = vector<vl>;
+using vvvl = vector<vvl>;
+using vvvvl = vector<vvvl>;
+
+template<class v>
+auto operator<<(ostream &os, const vector<v> &vec)->ostream& {
+    os << vec[0];
+    for (size_t i = 1; i < vec.size(); i++) {
+        os << ' ' << vec[i];
+    }
+    os << '\n';
+    return os;
+}
+
+template<class v>
+auto operator>>(istream &is, vector<v> &vec)->istream& {
+    for (auto &i : vec) {
+        is >> i;
+    }
+    return is;
+}
+
+template<class v>
+auto operator<<(ostream &os, const vector<vector<v>> &vec)->ostream& {
+    for (auto &i : vec) {
+        os << i[0];
+        for (size_t j = 1; j < i.size(); j++) {
+            os << ' ' << i[j];
+        }
+        os << '\n';
+    }
+    return os;
+}
+
+template<class v>
+auto operator>>(istream  &is, vector<vector<v>> &vec)->istream& {
+    for (auto &i : vec) {
+        for (auto &j : i) {
+            is >> j;
+        }
+    }
+    return is;
+}
+
+const int oo = INT32_MAX >> 1;
+const ll OO = INT64_MAX >> 1;
+
+
+void pre()
+{
+
+}
+
+#define TEST 1
+
+void solve()
+{
+    int n, m;
+    cin >> n >> m;
+
+    vvi par(n + 1);
+    rep(i, n) {
+        int x, y;
+        cin >> x >> y;
+        par[y].push_back(x);
+    }
+
+    ll ans = 0;
+
+    vvl b(n + 1, vl(2));
+    multiset<ll> s;
+    ll tot = 0;
+    for (int i = n; i >= 0; i--) {
+        repv(j, par[i]) {
+            s.insert(j);
+            tot += j;
+        }
+
+        while (s.size() > i + 1) {
+            tot -= *s.begin();
+            s.erase(s.begin());
+        }
+
+        b[i][0] = tot;
+        b[i][1] = tot - *s.begin() * (s.size() == i + 1);
+        rmax(ans, b[i][0]);
+    }
+
+    vl ma(n + 1);
+    ma[0] = 0;
+    nrep(i, 1, n + 1) {
+        ma[i] = max(ma[i - 1], b[i][1]);
+    }
+
+    while (m--) {
+        ll x, y;
+        cin >> x >> y;
+        cout << max({b[y][0], ma[y] + x, ans}) << " \n"[m == 0];
+
+    }
+}
+
+int main()
+{
+    ios::sync_with_stdio(false);
+    cin.tie(nullptr);
+
+    pre();
+
+    int t;
+    (TEST && cin >> t) || (t = 1);
+    while (t--) {
+        solve();
+    }
+}

Codeforces Round 1085 (Div. 1 + Div. 2)/A. 1-1.cpp

@@ -0,0 +1,133 @@
+/* Problem URL: https://codeforces.com/contest/2207/problem/A */
+
+#include <bits/stdc++.h>
+#include <ext/pb_ds/assoc_container.hpp>
+#include <ext/pb_ds/tree_policy.hpp>
+
+using namespace std;
+using namespace __gnu_pbds;
+
+template <class T, class comp = less<>>
+using ordered_set = tree<T, null_type , comp , rb_tree_tag , tree_order_statistics_node_update>;
+
+#define V vector
+
+#define rmin(a, b) a = min(a, b)
+#define rmax(a, b) a = max(a, b)
+
+#define rep(i, lim) for (int i = 0; i < (lim); i++)
+#define nrep(i, s, lim) for (int i = s; i < (lim); i++)
+
+#define repv(i, v) for (auto &i : (v))
+#define fillv(v) for (auto &itr_ : (v)) { cin >> itr_; }
+#define sortv(v) sort(v.begin(), v.end())
+#define all(v) (v).begin(), (v).end()
+
+using vi = vector<int>;
+using vvi = vector<vi>;
+using vvvi = vector<vvi>;
+using vvvvi = vector<vvvi>;
+
+using ll = long long;
+
+using vl = vector<ll>;
+using vvl = vector<vl>;
+using vvvl = vector<vvl>;
+using vvvvl = vector<vvvl>;
+
+template<class v>
+auto operator<<(ostream &os, const vector<v> &vec)->ostream& {
+    os << vec[0];
+    for (size_t i = 1; i < vec.size(); i++) {
+        os << ' ' << vec[i];
+    }
+    os << '\n';
+    return os;
+}
+
+template<class v>
+auto operator>>(istream &is, vector<v> &vec)->istream& {
+    for (auto &i : vec) {
+        is >> i;
+    }
+    return is;
+}
+
+template<class v>
+auto operator<<(ostream &os, const vector<vector<v>> &vec)->ostream& {
+    for (auto &i : vec) {
+        os << i[0];
+        for (size_t j = 1; j < i.size(); j++) {
+            os << ' ' << i[j];
+        }
+        os << '\n';
+    }
+    return os;
+}
+
+template<class v>
+auto operator>>(istream  &is, vector<vector<v>> &vec)->istream& {
+    for (auto &i : vec) {
+        for (auto &j : i) {
+            is >> j;
+        }
+    }
+    return is;
+}
+
+const int oo = INT32_MAX >> 1;
+const ll OO = INT64_MAX >> 1;
+
+
+void pre()
+{
+
+}
+
+#define TEST 1
+
+void solve()
+{
+    int n;
+    cin >> n;
+    string s;
+    cin >> s;
+
+    nrep(i, 1, n - 1) {
+        if (s[i - 1] == '1' && s[i + 1] == '1') {
+            s[i] = '1';
+        }
+    }
+
+    int ans1 = 0;
+    int ans2 = 0;
+    int c = 0;
+    rep(i, n) {
+        if (s[i] == '1') {
+            c++;
+            continue;
+        }
+
+        ans1 += c - (c - 1) / 2;
+        ans2 += c;
+        c = 0;
+    }
+    ans1 += c - (c - 1) / 2;
+    ans2 += c;
+
+    cout << ans1 << ' ' << ans2 << '\n';
+}
+
+int main()
+{
+    ios::sync_with_stdio(false);
+    cin.tie(nullptr);
+
+    pre();
+
+    int t;
+    (TEST && cin >> t) || (t = 1);
+    while (t--) {
+        solve();
+    }
+}

Codeforces Round 1085 (Div. 1 + Div. 2)/B. One Night At Freddy's.cpp

@@ -0,0 +1,140 @@
+/* Problem URL: https://codeforces.com/contest/2207/problem/B */
+
+#include <bits/stdc++.h>
+#include <ext/pb_ds/assoc_container.hpp>
+#include <ext/pb_ds/tree_policy.hpp>
+
+using namespace std;
+using namespace __gnu_pbds;
+
+template <class T, class comp = less<>>
+using ordered_set = tree<T, null_type , comp , rb_tree_tag , tree_order_statistics_node_update>;
+
+#define V vector
+
+#define rmin(a, b) a = min(a, b)
+#define rmax(a, b) a = max(a, b)
+
+#define rep(i, lim) for (int i = 0; i < (lim); i++)
+#define nrep(i, s, lim) for (int i = s; i < (lim); i++)
+
+#define repv(i, v) for (auto &i : (v))
+#define fillv(v) for (auto &itr_ : (v)) { cin >> itr_; }
+#define sortv(v) sort(v.begin(), v.end())
+#define all(v) (v).begin(), (v).end()
+
+using vi = vector<int>;
+using vvi = vector<vi>;
+using vvvi = vector<vvi>;
+using vvvvi = vector<vvvi>;
+
+using ll = long long;
+
+using vl = vector<ll>;
+using vvl = vector<vl>;
+using vvvl = vector<vvl>;
+using vvvvl = vector<vvvl>;
+
+template<class v>
+auto operator<<(ostream &os, const vector<v> &vec)->ostream& {
+    os << vec[0];
+    for (size_t i = 1; i < vec.size(); i++) {
+        os << ' ' << vec[i];
+    }
+    os << '\n';
+    return os;
+}
+
+template<class v>
+auto operator>>(istream &is, vector<v> &vec)->istream& {
+    for (auto &i : vec) {
+        is >> i;
+    }
+    return is;
+}
+
+template<class v>
+auto operator<<(ostream &os, const vector<vector<v>> &vec)->ostream& {
+    for (auto &i : vec) {
+        os << i[0];
+        for (size_t j = 1; j < i.size(); j++) {
+            os << ' ' << i[j];
+        }
+        os << '\n';
+    }
+    return os;
+}
+
+template<class v>
+auto operator>>(istream  &is, vector<vector<v>> &vec)->istream& {
+    for (auto &i : vec) {
+        for (auto &j : i) {
+            is >> j;
+        }
+    }
+    return is;
+}
+
+const int oo = INT32_MAX >> 1;
+const ll OO = INT64_MAX >> 1;
+
+
+void pre()
+{
+
+}
+
+#define TEST 1
+
+void solve()
+{
+    int n, m, l;
+    cin >> n >> m >> l;
+
+    vi rem(l);
+    rep(i, n) {
+        int a;
+        cin >> a;
+        rem[a - 1] = 1;
+    }
+
+    multiset<int> pq;
+    rep(i, min(n + 1, m)) {
+        pq.insert(0);
+    }
+
+    int c = n;
+
+    rep(i, l) {
+        while (pq.size() > c + 1) {
+            pq.erase(pq.begin());
+        }
+
+        auto itr = pq.begin();
+        int val = *itr;
+        pq.erase(itr);
+        pq.insert(val + 1);
+
+        if (rem[i]) {
+            pq.erase(prev(pq.end()));
+            pq.insert(0);
+            c--;
+        }
+    }
+
+    cout << *prev(pq.end()) << '\n';
+}
+
+int main()
+{
+    ios::sync_with_stdio(false);
+    cin.tie(nullptr);
+
+    pre();
+
+    int t;
+    (TEST && cin >> t) || (t = 1);
+    while (t--) {
+        solve();
+    }
+}

Codeforces Round 1085 (Div. 1 + Div. 2)/C. Where's My Water?.cpp

@@ -0,0 +1,106 @@
+/* Problem URL: https://codeforces.com/contest/2207/problem/C */
+
+#include <bits/stdc++.h>
+#include <ext/pb_ds/assoc_container.hpp>
+#include <ext/pb_ds/tree_policy.hpp>
+
+using namespace std;
+using namespace __gnu_pbds;
+
+template <class T, class comp = less<>>
+using ordered_set = tree<T, null_type , comp , rb_tree_tag , tree_order_statistics_node_update>;
+
+#define V vector
+
+#define rmin(a, b) a = min(a, b)
+#define rmax(a, b) a = max(a, b)
+
+#define rep(i, lim) for (int i = 0; i < (lim); i++)
+#define nrep(i, s, lim) for (int i = s; i < (lim); i++)
+
+#define repv(i, v) for (auto &i : (v))
+#define fillv(v) for (auto &itr_ : (v)) { cin >> itr_; }
+#define sortv(v) sort(v.begin(), v.end())
+#define all(v) (v).begin(), (v).end()
+
+using vi = vector<int>;
+using vvi = vector<vi>;
+using vvvi = vector<vvi>;
+using vvvvi = vector<vvvi>;
+
+using ll = long long;
+
+using vl = vector<ll>;
+using vvl = vector<vl>;
+using vvvl = vector<vvl>;
+using vvvvl = vector<vvvl>;
+
+template<class v>
+auto operator<<(ostream &os, const vector<v> &vec)->ostream& {
+    os << vec[0];
+    for (size_t i = 1; i < vec.size(); i++) {
+        os << ' ' << vec[i];
+    }
+    os << '\n';
+    return os;
+}
+
+template<class v>
+auto operator>>(istream &is, vector<v> &vec)->istream& {
+    for (auto &i : vec) {
+        is >> i;
+    }
+    return is;
+}
+
+template<class v>
+auto operator<<(ostream &os, const vector<vector<v>> &vec)->ostream& {
+    for (auto &i : vec) {
+        os << i[0];
+        for (size_t j = 1; j < i.size(); j++) {
+            os << ' ' << i[j];
+        }
+        os << '\n';
+    }
+    return os;
+}
+
+template<class v>
+auto operator>>(istream  &is, vector<vector<v>> &vec)->istream& {
+    for (auto &i : vec) {
+        for (auto &j : i) {
+            is >> j;
+        }
+    }
+    return is;
+}
+
+const int oo = INT32_MAX >> 1;
+const ll OO = INT64_MAX >> 1;
+
+
+void pre()
+{
+
+}
+
+#define TEST 1
+
+void solve()
+{
+
+}
+
+int main()
+{
+    ios::sync_with_stdio(false);
+    cin.tie(nullptr);
+
+    pre();
+
+    int t;
+    (TEST && cin >> t) || (t = 1);
+    while (t--) {
+        solve();
+    }
+}

Codeforces Round 1086 (Div. 2)/A. Bingo Candies.cpp

@@ -0,0 +1,132 @@
+/* Problem URL: https://codeforces.com/contest/2208/problem/A */
+
+#include <bits/stdc++.h>
+#include <ext/pb_ds/assoc_container.hpp>
+#include <ext/pb_ds/tree_policy.hpp>
+
+using namespace std;
+using namespace __gnu_pbds;
+
+template <class T, class comp = less<>>
+using ordered_set = tree<T, null_type , comp , rb_tree_tag , tree_order_statistics_node_update>;
+
+#define V vector
+
+#define rmin(a, b) a = min(a, b)
+#define rmax(a, b) a = max(a, b)
+
+#define rep(i, lim) for (int i = 0; i < (lim); i++)
+#define nrep(i, s, lim) for (int i = s; i < (lim); i++)
+
+#define repv(i, v) for (auto &i : (v))
+#define fillv(v) for (auto &itr_ : (v)) { cin >> itr_; }
+#define sortv(v) sort(v.begin(), v.end())
+#define all(v) (v).begin(), (v).end()
+
+using vi = vector<int>;
+using vvi = vector<vi>;
+using vvvi = vector<vvi>;
+using vvvvi = vector<vvvi>;
+
+using ll = long long;
+
+using vl = vector<ll>;
+using vvl = vector<vl>;
+using vvvl = vector<vvl>;
+using vvvvl = vector<vvvl>;
+
+template<class v>
+auto operator<<(ostream &os, const vector<v> &vec)->ostream& {
+    os << vec[0];
+    for (size_t i = 1; i < vec.size(); i++) {
+        os << ' ' << vec[i];
+    }
+    os << '\n';
+    return os;
+}
+
+template<class v>
+auto operator>>(istream &is, vector<v> &vec)->istream& {
+    for (auto &i : vec) {
+        is >> i;
+    }
+    return is;
+}
+
+template<class v>
+auto operator<<(ostream &os, const vector<vector<v>> &vec)->ostream& {
+    for (auto &i : vec) {
+        os << i[0];
+        for (size_t j = 1; j < i.size(); j++) {
+            os << ' ' << i[j];
+        }
+        os << '\n';
+    }
+    return os;
+}
+
+template<class v>
+auto operator>>(istream  &is, vector<vector<v>> &vec)->istream& {
+    for (auto &i : vec) {
+        for (auto &j : i) {
+            is >> j;
+        }
+    }
+    return is;
+}
+
+const int oo = INT32_MAX >> 1;
+const ll OO = INT64_MAX >> 1;
+
+
+void pre()
+{
+
+}
+
+#define TEST 1
+
+void solve()
+{
+    int n;
+    cin >> n;
+
+    vi c(n * n);
+    rep(i, n) {
+        rep(j, n) {
+            int a;
+            cin >> a;
+            c[a - 1]++;
+        }
+    }
+
+    if (n == 1) {
+        cout << "NO\n";
+        return;
+    }
+
+    int sz = n * n - n;
+
+    rep(i, n * n) {
+        if (c[i] > sz) {
+            cout << "NO\n";
+            return;
+        }
+    }
+
+    cout << "YES\n";
+}
+
+int main()
+{
+    ios::sync_with_stdio(false);
+    cin.tie(nullptr);
+
+    pre();
+
+    int t;
+    (TEST && cin >> t) || (t = 1);
+    while (t--) {
+        solve();
+    }
+}

Codeforces Round 1086 (Div. 2)/B. Cyclists.cpp

@@ -0,0 +1,150 @@
+/* Problem URL: https://codeforces.com/contest/2208/problem/B */
+
+#include <bits/stdc++.h>
+#include <ext/pb_ds/assoc_container.hpp>
+#include <ext/pb_ds/tree_policy.hpp>
+
+using namespace std;
+using namespace __gnu_pbds;
+
+template <class T, class comp = less<>>
+using ordered_set = tree<T, null_type , comp , rb_tree_tag , tree_order_statistics_node_update>;
+
+#define V vector
+
+#define rmin(a, b) a = min(a, b)
+#define rmax(a, b) a = max(a, b)
+
+#define rep(i, lim) for (int i = 0; i < (lim); i++)
+#define nrep(i, s, lim) for (int i = s; i < (lim); i++)
+
+#define repv(i, v) for (auto &i : (v))
+#define fillv(v) for (auto &itr_ : (v)) { cin >> itr_; }
+#define sortv(v) sort(v.begin(), v.end())
+#define all(v) (v).begin(), (v).end()
+
+using vi = vector<int>;
+using vvi = vector<vi>;
+using vvvi = vector<vvi>;
+using vvvvi = vector<vvvi>;
+
+using ll = long long;
+
+using vl = vector<ll>;
+using vvl = vector<vl>;
+using vvvl = vector<vvl>;
+using vvvvl = vector<vvvl>;
+
+template<class v>
+auto operator<<(ostream &os, const vector<v> &vec)->ostream& {
+    os << vec[0];
+    for (size_t i = 1; i < vec.size(); i++) {
+        os << ' ' << vec[i];
+    }
+    os << '\n';
+    return os;
+}
+
+template<class v>
+auto operator>>(istream &is, vector<v> &vec)->istream& {
+    for (auto &i : vec) {
+        is >> i;
+    }
+    return is;
+}
+
+template<class v>
+auto operator<<(ostream &os, const vector<vector<v>> &vec)->ostream& {
+    for (auto &i : vec) {
+        os << i[0];
+        for (size_t j = 1; j < i.size(); j++) {
+            os << ' ' << i[j];
+        }
+        os << '\n';
+    }
+    return os;
+}
+
+template<class v>
+auto operator>>(istream  &is, vector<vector<v>> &vec)->istream& {
+    for (auto &i : vec) {
+        for (auto &j : i) {
+            is >> j;
+        }
+    }
+    return is;
+}
+
+const int oo = INT32_MAX >> 1;
+const ll OO = INT64_MAX >> 1;
+
+
+void pre()
+{
+
+}
+
+#define TEST 1
+
+void solve()
+{
+    int n, k, p, m;
+    cin >> n >> k >> p >> m;
+
+    list<pair<int, bool>> a;
+    rep(i, n) {
+        int c;
+        cin >> c;
+        a.emplace_back(c, i == p - 1);
+    }
+
+    int ans = 0;
+    while (1) {
+        auto choice = a.begin();
+        auto itr = next(choice);
+
+        nrep(i, 1, k) {
+            if (choice->second) {
+                break;
+            }
+
+            if (itr->second) {
+                choice = itr;
+                itr++;
+                continue;
+            }
+
+            if (itr->first < choice->first) {
+                choice = itr;
+            }
+
+            itr++;
+        }
+
+        if (choice->first > m) {
+            break;
+        }
+
+        auto now = *choice;
+        a.erase(choice);
+        ans += now.second;
+        m -= now.first;
+        a.emplace_back(now);
+    }
+
+    cout << ans << '\n';
+}
+
+int main()
+{
+    ios::sync_with_stdio(false);
+    cin.tie(nullptr);
+
+    pre();
+
+    int t;
+    (TEST && cin >> t) || (t = 1);
+    while (t--) {
+        solve();
+    }
+}

Codeforces Round 1086 (Div. 2)/C. Stamina and Tasks.cpp

@@ -0,0 +1,123 @@
+/* Problem URL: https://codeforces.com/contest/2208/problem/C */
+
+#include <bits/stdc++.h>
+#include <ext/pb_ds/assoc_container.hpp>
+#include <ext/pb_ds/tree_policy.hpp>
+
+using namespace std;
+using namespace __gnu_pbds;
+
+template <class T, class comp = less<>>
+using ordered_set = tree<T, null_type , comp , rb_tree_tag , tree_order_statistics_node_update>;
+
+#define V vector
+
+#define rmin(a, b) a = min(a, b)
+#define rmax(a, b) a = max(a, b)
+
+#define rep(i, lim) for (int i = 0; i < (lim); i++)
+#define nrep(i, s, lim) for (int i = s; i < (lim); i++)
+
+#define repv(i, v) for (auto &i : (v))
+#define fillv(v) for (auto &itr_ : (v)) { cin >> itr_; }
+#define sortv(v) sort(v.begin(), v.end())
+#define all(v) (v).begin(), (v).end()
+
+using vi = vector<int>;
+using vvi = vector<vi>;
+using vvvi = vector<vvi>;
+using vvvvi = vector<vvvi>;
+
+using ll = long long;
+
+using vl = vector<ll>;
+using vvl = vector<vl>;
+using vvvl = vector<vvl>;
+using vvvvl = vector<vvvl>;
+
+template<class v>
+auto operator<<(ostream &os, const vector<v> &vec)->ostream& {
+    os << vec[0];
+    for (size_t i = 1; i < vec.size(); i++) {
+        os << ' ' << vec[i];
+    }
+    os << '\n';
+    return os;
+}
+
+template<class v>
+auto operator>>(istream &is, vector<v> &vec)->istream& {
+    for (auto &i : vec) {
+        is >> i;
+    }
+    return is;
+}
+
+template<class v>
+auto operator<<(ostream &os, const vector<vector<v>> &vec)->ostream& {
+    for (auto &i : vec) {
+        os << i[0];
+        for (size_t j = 1; j < i.size(); j++) {
+            os << ' ' << i[j];
+        }
+        os << '\n';
+    }
+    return os;
+}
+
+template<class v>
+auto operator>>(istream  &is, vector<vector<v>> &vec)->istream& {
+    for (auto &i : vec) {
+        for (auto &j : i) {
+            is >> j;
+        }
+    }
+    return is;
+}
+
+const int oo = INT32_MAX >> 1;
+const ll OO = INT64_MAX >> 1;
+
+
+void pre()
+{
+
+}
+
+#define TEST 1
+
+void solve()
+{
+    int n;
+    cin >> n;
+
+    V<pair<int, int>> a(n);
+    repv(i, a) {
+        cin >> i.first >> i.second;
+    }
+
+    reverse(all(a));
+
+    long double ans = 0;
+    rep(i, n) {
+        auto [c, p] = a[i];
+
+        rmax(ans, ans * (1 - p / 100.0L) + c);
+    }
+
+    cout << fixed << setprecision(10) << ans << '\n';
+}
+
+int main()
+{
+    ios::sync_with_stdio(false);
+    cin.tie(nullptr);
+
+    pre();
+
+    int t;
+    (TEST && cin >> t) || (t = 1);
+    while (t--) {
+        solve();
+    }
+}

Codeforces Round 1086 (Div. 2)/D1. Tree Orientation (Easy Version).cpp

@@ -0,0 +1,258 @@
+/* Problem URL: https://codeforces.com/contest/2208/problem/D1 */
+
+#include <bits/stdc++.h>
+#include <ext/pb_ds/assoc_container.hpp>
+#include <ext/pb_ds/tree_policy.hpp>
+
+using namespace std;
+using namespace __gnu_pbds;
+
+template <class T, class comp = less<>>
+using ordered_set = tree<T, null_type , comp , rb_tree_tag , tree_order_statistics_node_update>;
+
+#define V vector
+
+#define rmin(a, b) a = min(a, b)
+#define rmax(a, b) a = max(a, b)
+
+#define rep(i, lim) for (int i = 0; i < (lim); i++)
+#define nrep(i, s, lim) for (int i = s; i < (lim); i++)
+
+#define repv(i, v) for (auto &i : (v))
+#define fillv(v) for (auto &itr_ : (v)) { cin >> itr_; }
+#define sortv(v) sort(v.begin(), v.end())
+#define all(v) (v).begin(), (v).end()
+
+using vi = vector<int>;
+using vvi = vector<vi>;
+using vvvi = vector<vvi>;
+using vvvvi = vector<vvvi>;
+
+using ll = long long;
+
+using vl = vector<ll>;
+using vvl = vector<vl>;
+using vvvl = vector<vvl>;
+using vvvvl = vector<vvvl>;
+
+template<class v>
+auto operator<<(ostream &os, const vector<v> &vec)->ostream& {
+    os << vec[0];
+    for (size_t i = 1; i < vec.size(); i++) {
+        os << ' ' << vec[i];
+    }
+    os << '\n';
+    return os;
+}
+
+template<class v>
+auto operator>>(istream &is, vector<v> &vec)->istream& {
+    for (auto &i : vec) {
+        is >> i;
+    }
+    return is;
+}
+
+template<class v>
+auto operator<<(ostream &os, const vector<vector<v>> &vec)->ostream& {
+    for (auto &i : vec) {
+        os << i[0];
+        for (size_t j = 1; j < i.size(); j++) {
+            os << ' ' << i[j];
+        }
+        os << '\n';
+    }
+    return os;
+}
+
+template<class v>
+auto operator>>(istream  &is, vector<vector<v>> &vec)->istream& {
+    for (auto &i : vec) {
+        for (auto &j : i) {
+            is >> j;
+        }
+    }
+    return is;
+}
+
+const int oo = INT32_MAX >> 1;
+const ll OO = INT64_MAX >> 1;
+
+
+void pre()
+{
+
+}
+
+#define TEST 1
+
+void solve()
+{
+    int n;
+    cin >> n;
+
+    V<string> a(n);
+    cin >> a;
+
+    vvi graph(n);
+    vvi mult(n);
+    vvi inv(n);
+
+    rep(i, n) {
+        if (a[i][i] != '1') {
+            cout << "No\n";
+            return;
+        }
+
+        rep(j, n) {
+            if (i == j) {
+                continue;
+            }
+
+            if (a[i][j] == '0') {
+                continue;
+            }
+
+            rep(k, n) {
+                if (a[i][k] == '0' && a[j][k] == '1') {
+                    cout << "No\n";
+                    return;
+                }
+            }
+
+            graph[i].push_back(j);
+            inv[j].push_back(i);
+            mult[i].push_back(j);
+            mult[j].push_back(i);
+        }
+    }
+
+    vi st;
+    V<bool> frame(n);
+    V<bool> vis(n);
+
+    function<bool(int)> dfs = [&](int i) {
+        vis[i] = true;
+        frame[i] = true;
+
+        repv(j, graph[i]) {
+            if (frame[j]) {
+                return false;
+            }
+
+            if (vis[j]) {
+                continue;
+            }
+
+            if (!dfs(j)) {
+                return false;
+            }
+        }
+
+        st.push_back(i);
+
+        frame[i] = false;
+        return true;
+    };
+
+    function<void(int)> dfs2 = [&](int i) {
+        vis[i] = true;
+        repv(j, mult[i]) {
+            if (vis[j]) {
+                continue;
+            }
+
+            dfs2(j);
+        }
+    };
+
+    rep(i, n) {
+        if (vis[i]) {
+            continue;
+        }
+
+        if (!dfs(i)) {
+            cout << "No\n";
+            return;
+        }
+    }
+
+    fill(all(vis), false);
+    dfs2(0);
+
+
+    rep(i, n) {
+        if (!vis[i]) {
+            cout << "No\n";
+            return;
+        }
+    }
+
+    V<V<bool>> rem(n, V<bool>(n));
+
+    vvi act(n);
+    V<pair<int, int>> ans;
+
+    repv(i, st) {
+        repv(j, graph[i]) {
+            if (rem[i][j]) {
+                continue;
+            }
+
+            act[i].push_back(j);
+            act[j].push_back(i);
+            ans.emplace_back(i + 1, j + 1);
+            rem[i][j] = true;
+        }
+
+        repv(j, inv[i]) {
+            rep(k, n) {
+                rem[j][k] = rem[j][k] || rem[i][k];
+            }
+        }
+    }
+    fill(all(vis), false);
+
+    function<bool(int, int)> test = [&](int i, int p) {
+        vis[i] = true;
+        repv(j, act[i]) {
+            if (j == p) {
+                continue;
+            }
+
+            if (vis[j]) {
+                return false;
+            }
+
+            if (!test(j, i)) {
+                return false;
+            }
+        }
+
+        return true;
+    };
+
+    if (!test(0, 0)) {
+        cout << "No\n";
+        return;
+    }
+
+    cout << "Yes\n";
+    repv(i, ans) {
+        cout << i.first << ' ' << i.second << '\n';
+    }
+}
+
+int main()
+{
+    ios::sync_with_stdio(false);
+    cin.tie(nullptr);
+
+    pre();
+
+    int t;
+    (TEST && cin >> t) || (t = 1);
+    while (t--) {
+        solve();
+    }
+}

Codeforces Round 1087 (Div. 2)/A. Flip Flops.cpp

@@ -0,0 +1,126 @@
+/* Problem URL: https://codeforces.com/contest/2209/problem/A */
+
+#include <bits/stdc++.h>
+#include <ext/pb_ds/assoc_container.hpp>
+#include <ext/pb_ds/tree_policy.hpp>
+
+using namespace std;
+using namespace __gnu_pbds;
+
+template <class T, class comp = less<>>
+using ordered_set = tree<T, null_type , comp , rb_tree_tag , tree_order_statistics_node_update>;
+
+#define V vector
+
+#define rmin(a, b) a = min(a, b)
+#define rmax(a, b) a = max(a, b)
+
+#define rep(i, lim) for (int i = 0; i < (lim); i++)
+#define nrep(i, s, lim) for (int i = s; i < (lim); i++)
+
+#define repv(i, v) for (auto &i : (v))
+#define fillv(v) for (auto &itr_ : (v)) { cin >> itr_; }
+#define sortv(v) sort(v.begin(), v.end())
+#define all(v) (v).begin(), (v).end()
+
+using vi = vector<int>;
+using vvi = vector<vi>;
+using vvvi = vector<vvi>;
+using vvvvi = vector<vvvi>;
+
+using ll = long long;
+
+using vl = vector<ll>;
+using vvl = vector<vl>;
+using vvvl = vector<vvl>;
+using vvvvl = vector<vvvl>;
+
+template<class v>
+auto operator<<(ostream &os, const vector<v> &vec)->ostream& {
+    os << vec[0];
+    for (size_t i = 1; i < vec.size(); i++) {
+        os << ' ' << vec[i];
+    }
+    os << '\n';
+    return os;
+}
+
+template<class v>
+auto operator>>(istream &is, vector<v> &vec)->istream& {
+    for (auto &i : vec) {
+        is >> i;
+    }
+    return is;
+}
+
+template<class v>
+auto operator<<(ostream &os, const vector<vector<v>> &vec)->ostream& {
+    for (auto &i : vec) {
+        os << i[0];
+        for (size_t j = 1; j < i.size(); j++) {
+            os << ' ' << i[j];
+        }
+        os << '\n';
+    }
+    return os;
+}
+
+template<class v>
+auto operator>>(istream  &is, vector<vector<v>> &vec)->istream& {
+    for (auto &i : vec) {
+        for (auto &j : i) {
+            is >> j;
+        }
+    }
+    return is;
+}
+
+const int oo = INT32_MAX >> 1;
+const ll OO = INT64_MAX >> 1;
+
+
+void pre()
+{
+
+}
+
+#define TEST 1
+
+void solve()
+{
+        int n;
+        ll c;
+        ll k;
+        cin >> n >> c >> k;
+
+        vl a(n);
+        cin >> a;
+
+        sortv(a);
+        repv(i, a) {
+            if (i > c) {
+                break;
+            }
+
+            ll diff = c - i;
+
+            c += i + min(k, diff);
+            k -= min(k, diff);
+        }
+
+        cout << c << '\n';
+}
+
+int main()
+{
+    ios::sync_with_stdio(false);
+    cin.tie(nullptr);
+
+    pre();
+
+    int t;
+    (TEST && cin >> t) || (t = 1);
+    while (t--) {
+        solve();
+    }
+}

Codeforces Round 1087 (Div. 2)/B. Array.cpp

@@ -0,0 +1,121 @@
+/* Problem URL: https://codeforces.com/contest/2209/problem/B */
+
+#include <bits/stdc++.h>
+#include <ext/pb_ds/assoc_container.hpp>
+#include <ext/pb_ds/tree_policy.hpp>
+
+using namespace std;
+using namespace __gnu_pbds;
+
+template <class T, class comp = less<>>
+using ordered_set = tree<T, null_type , comp , rb_tree_tag , tree_order_statistics_node_update>;
+
+#define V vector
+
+#define rmin(a, b) a = min(a, b)
+#define rmax(a, b) a = max(a, b)
+
+#define rep(i, lim) for (int i = 0; i < (lim); i++)
+#define nrep(i, s, lim) for (int i = s; i < (lim); i++)
+
+#define repv(i, v) for (auto &i : (v))
+#define fillv(v) for (auto &itr_ : (v)) { cin >> itr_; }
+#define sortv(v) sort(v.begin(), v.end())
+#define all(v) (v).begin(), (v).end()
+
+using vi = vector<int>;
+using vvi = vector<vi>;
+using vvvi = vector<vvi>;
+using vvvvi = vector<vvvi>;
+
+using ll = long long;
+
+using vl = vector<ll>;
+using vvl = vector<vl>;
+using vvvl = vector<vvl>;
+using vvvvl = vector<vvvl>;
+
+template<class v>
+auto operator<<(ostream &os, const vector<v> &vec)->ostream& {
+    os << vec[0];
+    for (size_t i = 1; i < vec.size(); i++) {
+        os << ' ' << vec[i];
+    }
+    os << '\n';
+    return os;
+}
+
+template<class v>
+auto operator>>(istream &is, vector<v> &vec)->istream& {
+    for (auto &i : vec) {
+        is >> i;
+    }
+    return is;
+}
+
+template<class v>
+auto operator<<(ostream &os, const vector<vector<v>> &vec)->ostream& {
+    for (auto &i : vec) {
+        os << i[0];
+        for (size_t j = 1; j < i.size(); j++) {
+            os << ' ' << i[j];
+        }
+        os << '\n';
+    }
+    return os;
+}
+
+template<class v>
+auto operator>>(istream  &is, vector<vector<v>> &vec)->istream& {
+    for (auto &i : vec) {
+        for (auto &j : i) {
+            is >> j;
+        }
+    }
+    return is;
+}
+
+const int oo = INT32_MAX >> 1;
+const ll OO = INT64_MAX >> 1;
+
+
+void pre()
+{
+
+}
+
+#define TEST 1
+
+void solve()
+{
+    int n;
+    cin >> n;
+    vl a(n);
+    cin >> a;
+
+    rep(i, n) {
+        int c1 = 0;
+        int c2 = 0;
+        nrep(j, i + 1, n) {
+            c1 += a[j] > a[i];
+            c2 += a[j] < a[i];
+        }
+        
+        cout << max(c1, c2) << ' ';
+    }
+    cout << '\n';
+}
+
+int main()
+{
+    ios::sync_with_stdio(false);
+    cin.tie(nullptr);
+
+    pre();
+
+    int t;
+    (TEST && cin >> t) || (t = 1);
+    while (t--) {
+        solve();
+    }
+}

Codeforces Round 1087 (Div. 2)/C. Find the Zero.cpp

@@ -0,0 +1,145 @@
+/* Problem URL: https://codeforces.com/contest/2209/problem/C */
+
+#include <bits/stdc++.h>
+#include <ext/pb_ds/assoc_container.hpp>
+#include <ext/pb_ds/tree_policy.hpp>
+
+using namespace std;
+using namespace __gnu_pbds;
+
+template <class T, class comp = less<>>
+using ordered_set = tree<T, null_type , comp , rb_tree_tag , tree_order_statistics_node_update>;
+
+#define V vector
+
+#define rmin(a, b) a = min(a, b)
+#define rmax(a, b) a = max(a, b)
+
+#define rep(i, lim) for (int i = 0; i < (lim); i++)
+#define nrep(i, s, lim) for (int i = s; i < (lim); i++)
+
+#define repv(i, v) for (auto &i : (v))
+#define fillv(v) for (auto &itr_ : (v)) { cin >> itr_; }
+#define sortv(v) sort(v.begin(), v.end())
+#define all(v) (v).begin(), (v).end()
+
+using vi = vector<int>;
+using vvi = vector<vi>;
+using vvvi = vector<vvi>;
+using vvvvi = vector<vvvi>;
+
+using ll = long long;
+
+using vl = vector<ll>;
+using vvl = vector<vl>;
+using vvvl = vector<vvl>;
+using vvvvl = vector<vvvl>;
+
+template<class v>
+auto operator<<(ostream &os, const vector<v> &vec)->ostream& {
+    os << vec[0];
+    for (size_t i = 1; i < vec.size(); i++) {
+        os << ' ' << vec[i];
+    }
+    os << '\n';
+    return os;
+}
+
+template<class v>
+auto operator>>(istream &is, vector<v> &vec)->istream& {
+    for (auto &i : vec) {
+        is >> i;
+    }
+    return is;
+}
+
+template<class v>
+auto operator<<(ostream &os, const vector<vector<v>> &vec)->ostream& {
+    for (auto &i : vec) {
+        os << i[0];
+        for (size_t j = 1; j < i.size(); j++) {
+            os << ' ' << i[j];
+        }
+        os << '\n';
+    }
+    return os;
+}
+
+template<class v>
+auto operator>>(istream  &is, vector<vector<v>> &vec)->istream& {
+    for (auto &i : vec) {
+        for (auto &j : i) {
+            is >> j;
+        }
+    }
+    return is;
+}
+
+const int oo = INT32_MAX >> 1;
+const ll OO = INT64_MAX >> 1;
+
+
+void pre()
+{
+
+}
+
+#define TEST 1
+
+void solve()
+{
+    int n;
+    cin >> n;
+
+    auto ask = [&](int i, int j) {
+        cout << "? " << i << ' ' << j << endl;
+        int ans;
+        cin >> ans;
+        return ans;
+    };
+
+    auto answer = [&](int i) {
+        cout << "! " << i << endl;
+    };
+
+    for (int i = 1; i <= n * 2 - 2; i += 2) {
+        int ans = ask(i, i + 1);
+        if (ans == 1) {
+            answer(i);
+            return;
+        }
+    }
+
+    int p1 = n * 2 - 3;
+    int p2 = n * 2 - 2;
+    int p3 = n * 2 - 1;
+    int p4 = n * 2;
+
+    int ans = ask(p1, p3);
+    if (ans == 1) {
+        answer(p1);
+        return;
+    }
+
+    ans = ask(p2, p3);
+    if (ans == 1) {
+        answer(p2);
+        return;
+    }
+
+    answer(p4);
+}
+
+int main()
+{
+    ios::sync_with_stdio(false);
+    cin.tie(nullptr);
+
+    pre();
+
+    int t;
+    (TEST && cin >> t) || (t = 1);
+    while (t--) {
+        solve();
+    }
+}

Codeforces Round 854 by cybercats (Div. 1 + Div. 2)/C. Double Lexicographically Minimum.cpp

@@ -0,0 +1,173 @@
+/* Problem URL: https://codeforces.com/problemset/problem/1799/C */
+
+#include <bits/stdc++.h>
+#include <ext/pb_ds/assoc_container.hpp>
+#include <ext/pb_ds/tree_policy.hpp>
+
+using namespace std;
+using namespace __gnu_pbds;
+
+template <class T, class comp = less<>>
+using ordered_set = tree<T, null_type , comp , rb_tree_tag , tree_order_statistics_node_update>;
+
+#define V vector
+
+#define rmin(a, b) a = min(a, b)
+#define rmax(a, b) a = max(a, b)
+
+#define rep(i, lim) for (int i = 0; i < (lim); i++)
+#define nrep(i, s, lim) for (int i = s; i < (lim); i++)
+
+#define repv(i, v) for (auto &i : (v))
+#define fillv(v) for (auto &itr_ : (v)) { cin >> itr_; }
+#define sortv(v) sort(v.begin(), v.end())
+#define all(v) (v).begin(), (v).end()
+
+using vi = vector<int>;
+using vvi = vector<vi>;
+using vvvi = vector<vvi>;
+using vvvvi = vector<vvvi>;
+
+using ll = long long;
+
+using vl = vector<ll>;
+using vvl = vector<vl>;
+using vvvl = vector<vvl>;
+using vvvvl = vector<vvvl>;
+
+template<class v>
+auto operator<<(ostream &os, const vector<v> &vec)->ostream& {
+    os << vec[0];
+    for (size_t i = 1; i < vec.size(); i++) {
+        os << ' ' << vec[i];
+    }
+    os << '\n';
+    return os;
+}
+
+template<class v>
+auto operator>>(istream &is, vector<v> &vec)->istream& {
+    for (auto &i : vec) {
+        is >> i;
+    }
+    return is;
+}
+
+template<class v>
+auto operator<<(ostream &os, const vector<vector<v>> &vec)->ostream& {
+    for (auto &i : vec) {
+        os << i[0];
+        for (size_t j = 1; j < i.size(); j++) {
+            os << ' ' << i[j];
+        }
+        os << '\n';
+    }
+    return os;
+}
+
+template<class v>
+auto operator>>(istream  &is, vector<vector<v>> &vec)->istream& {
+    for (auto &i : vec) {
+        for (auto &j : i) {
+            is >> j;
+        }
+    }
+    return is;
+}
+
+const int oo = INT32_MAX >> 1;
+const ll OO = INT64_MAX >> 1;
+
+
+void pre()
+{
+
+}
+
+#define TEST 1
+
+void solve()
+{
+    string a;
+    cin >> a;
+
+    map<char, int> c;
+    repv(i, a) {
+        c[i]++;
+    }
+
+    int l = 0;
+    int r = a.size() - 1;
+
+    auto itr = c.begin();
+    while (itr != c.end()) {
+        auto [ch, co] = *itr;
+        itr = c.erase(itr);
+
+        while (co > 1) {
+            a[l] = ch;
+            a[r] = ch;
+            l++;
+            r--;
+            co -= 2;
+        }
+
+        if (co == 0) {
+            continue;
+        }
+
+        if (c.size() >= 2) {
+            a[r] = ch;
+            r--;
+            break;
+        }
+
+        if (c.empty()) {
+            a[l] = ch;
+            break;
+        }
+
+        auto [ch2, co2] = *itr;
+        itr = c.erase(itr);
+
+        int now = 1;
+        while (co2--) {
+            if (now) {
+                a[l] = ch2;
+                l++;
+            } else {
+                a[r] = ch2;
+                r--;
+            }
+            now ^= 1;
+        }
+
+        a[r] = ch;
+    }
+
+    while (itr != c.end()) {
+        auto [ch, co] = *itr;
+        itr++;
+
+        while (co--) {
+            a[l] = ch;
+            l++;
+        }
+    }
+
+    cout << a << '\n';
+}
+
+int main()
+{
+    ios::sync_with_stdio(false);
+    cin.tie(nullptr);
+
+    pre();
+
+    int t;
+    (TEST && cin >> t) || (t = 1);
+    while (t--) {
+        solve();
+    }
+}

Codeforces Round 855 (Div. 3)/E1. Unforgivable Curse (easy version).cpp

@@ -0,0 +1,137 @@
+/* Problem URL: https://codeforces.com/problemset/problem/1800/E1 */
+
+#include <bits/stdc++.h>
+#include <ext/pb_ds/assoc_container.hpp> #include <ext/pb_ds/tree_policy.hpp>
+
+using namespace std;
+using namespace __gnu_pbds;
+
+template <class T, class comp = less<>>
+using ordered_set = tree<T, null_type , comp , rb_tree_tag , tree_order_statistics_node_update>;
+
+#define V vector
+
+#define rmin(a, b) a = min(a, b)
+#define rmax(a, b) a = max(a, b)
+
+#define rep(i, lim) for (int i = 0; i < (lim); i++)
+#define nrep(i, s, lim) for (int i = s; i < (lim); i++)
+
+#define repv(i, v) for (auto &i : (v))
+#define fillv(v) for (auto &itr_ : (v)) { cin >> itr_; }
+#define sortv(v) sort(v.begin(), v.end())
+#define all(v) (v).begin(), (v).end()
+
+using vi = vector<int>;
+using vvi = vector<vi>;
+using vvvi = vector<vvi>;
+using vvvvi = vector<vvvi>;
+
+using ll = long long;
+
+using vl = vector<ll>;
+using vvl = vector<vl>;
+using vvvl = vector<vvl>;
+using vvvvl = vector<vvvl>;
+
+template<class v>
+auto operator<<(ostream &os, const vector<v> &vec)->ostream& {
+    os << vec[0];
+    for (size_t i = 1; i < vec.size(); i++) {
+        os << ' ' << vec[i];
+    }
+    os << '\n';
+    return os;
+}
+
+template<class v>
+auto operator>>(istream &is, vector<v> &vec)->istream& {
+    for (auto &i : vec) {
+        is >> i;
+    }
+    return is;
+}
+
+template<class v>
+auto operator<<(ostream &os, const vector<vector<v>> &vec)->ostream& {
+    for (auto &i : vec) {
+        os << i[0];
+        for (size_t j = 1; j < i.size(); j++) {
+            os << ' ' << i[j];
+        }
+        os << '\n';
+    }
+    return os;
+}
+
+template<class v>
+auto operator>>(istream  &is, vector<vector<v>> &vec)->istream& {
+    for (auto &i : vec) {
+        for (auto &j : i) {
+            is >> j;
+        }
+    }
+    return is;
+}
+
+const int oo = INT32_MAX >> 1;
+const ll OO = INT64_MAX >> 1;
+
+
+void pre()
+{
+
+}
+
+#define TEST 1
+
+void solve()
+{
+    int n, k;
+    cin >> n >> k;
+    string a, b;
+    cin >> a >> b;
+
+    vi c1(26);
+    vi c2(26);
+    rep(i, n) {
+        c1[a[i] - 'a']++;
+        c2[b[i] - 'a']++;
+    }
+
+    if (c1 != c2) {
+        cout << "NO\n";
+        return;
+    }
+
+    if (n <= 3 && a != b) {
+        cout << "NO\n";
+        return;
+    }
+
+    if (n >= 3 && n <= 5 && a[2] != b[2]) {
+        cout << "NO\n";
+        return;
+    }
+
+    if (n >= 3 && n <= 4 && a[1] != b[1]) {
+        cout << "NO\n";
+        return;
+    }
+
+    cout << "YES\n";
+}
+
+int main()
+{
+    ios::sync_with_stdio(false);
+    cin.tie(nullptr);
+
+    pre();
+
+    int t;
+    (TEST && cin >> t) || (t = 1);
+    while (t--) {
+        solve();
+    }
+}

Codeforces Round 855 (Div. 3)/F. Dasha and Nightmares.cpp

@@ -0,0 +1,142 @@
+/* Problem URL: https://codeforces.com/problemset/problem/1800/F */
+
+#include <bits/stdc++.h>
+#include <ext/pb_ds/assoc_container.hpp>
+#include <ext/pb_ds/tree_policy.hpp>
+
+using namespace std;
+using namespace __gnu_pbds;
+
+template <class T, class comp = less<>>
+using ordered_set = tree<T, null_type , comp , rb_tree_tag , tree_order_statistics_node_update>;
+
+#define V vector
+
+#define rmin(a, b) a = min(a, b)
+#define rmax(a, b) a = max(a, b)
+
+#define rep(i, lim) for (int i = 0; i < (lim); i++)
+#define nrep(i, s, lim) for (int i = s; i < (lim); i++)
+
+#define repv(i, v) for (auto &i : (v))
+#define fillv(v) for (auto &itr_ : (v)) { cin >> itr_; }
+#define sortv(v) sort(v.begin(), v.end())
+#define all(v) (v).begin(), (v).end()
+
+using vi = vector<int>;
+using vvi = vector<vi>;
+using vvvi = vector<vvi>;
+using vvvvi = vector<vvvi>;
+
+using ll = long long;
+
+using vl = vector<ll>;
+using vvl = vector<vl>;
+using vvvl = vector<vvl>;
+using vvvvl = vector<vvvl>;
+
+template<class v>
+auto operator<<(ostream &os, const vector<v> &vec)->ostream& {
+    os << vec[0];
+    for (size_t i = 1; i < vec.size(); i++) {
+        os << ' ' << vec[i];
+    }
+    os << '\n';
+    return os;
+}
+
+template<class v>
+auto operator>>(istream &is, vector<v> &vec)->istream& {
+    for (auto &i : vec) {
+        is >> i;
+    }
+    return is;
+}
+
+template<class v>
+auto operator<<(ostream &os, const vector<vector<v>> &vec)->ostream& {
+    for (auto &i : vec) {
+        os << i[0];
+        for (size_t j = 1; j < i.size(); j++) {
+            os << ' ' << i[j];
+        }
+        os << '\n';
+    }
+    return os;
+}
+
+template<class v>
+auto operator>>(istream  &is, vector<vector<v>> &vec)->istream& {
+    for (auto &i : vec) {
+        for (auto &j : i) {
+            is >> j;
+        }
+    }
+    return is;
+}
+
+const int oo = INT32_MAX >> 1;
+const ll OO = INT64_MAX >> 1;
+
+
+void pre()
+{
+
+}
+
+#define TEST 0
+
+void solve()
+{
+    int n;
+    cin >> n;
+
+    V<pair<int, int>> a(n);
+    rep(i, n) {
+        string s;
+        cin >> s;
+        vi c(26);
+        repv(i, s) {
+            c[i - 'a']++;
+        }
+
+        rep(j, 26) {
+            a[i].first |= (c[j] != 0) << j;
+            a[i].second |= (c[j] & 1) << j;
+        }
+    }
+
+    ll ans = 0;
+    rep(i, 26) {
+        vi all;
+        repv(j, a) {
+            if ((j.first >> i) & 1) {
+                continue;
+            }
+            all.push_back(j.second ^ ((1 << 26) - 1) ^ (1 << i));
+        }
+        sortv(all);
+        repv(j, a) {
+            if ((j.first >> i) & 1) {
+                continue;
+            }
+            ans += upper_bound(all(all), j.second) - lower_bound(all(all), j.second);
+        }
+    }
+
+    cout << (ans >> 1) << '\n';
+}
+
+int main()
+{
+    ios::sync_with_stdio(false);
+    cin.tie(nullptr);
+
+    pre();
+
+    int t;
+    (TEST && cin >> t) || (t = 1);
+    while (t--) {
+        solve();
+    }
+}

Codeforces Round 856 (Div. 2)/D. Counting Factorizations.cpp

@@ -78,20 +78,17 @@ auto operator>>(istream  &is, vector<vector<v>> &vec)->istream& {
 const int oo = INT32_MAX >> 1;
 const ll OO = INT64_MAX >> 1;
 
-const ll mod = 998244353;
-
-constexpr MAXN = 1e6 + 10;
+constexpr int MAXN = 1e6 + 10;
 bool prime[MAXN];
-bool vis[MAXN];
-
-vl fact[MAXN];
-vl inv[MAXN];
+ll fact[MAXN];
+ll inv[MAXN];
+ll finv[MAXN];
 
+ll mod = 998244353;
 
 void pre()
 {
     fill(prime, prime + MAXN, true);
-    prime[0] = false;
     prime[1] = false;
 
     nrep(i, 2, MAXN) {
@@ -105,50 +102,38 @@ void pre()
     }
 
     fact[0] = 1;
-    fact[1] = 1;
-    nrep(i, 2, MAXN) {
+    nrep(i, 1, MAXN) {
         fact[i] = fact[i - 1] * i % mod;
     }
 
-    inv[0] = 1;
     inv[1] = 1;
     nrep(i, 2, MAXN) {
         inv[i] = (mod - mod / i) * inv[mod % i] % mod;
     }
 
-    nrep(i, 2, MAXN) {
-        inv[i] = inv[i - 1] * inv[i] % mod;
+    finv[0] = 1;
+    nrep(i, 1, MAXN) {
+        finv[i] = finv[i - 1] * inv[i] % mod;
     }
 }
 
-#define TEST 1
+#define TEST 0
 
 void solve()
 {
     int n;
     cin >> n;
+    vi a(2 * n);
+    cin >> a;
 
-    vi act(n << 1);
-    cin >> act;
-
-    set<int> up;
-
-    vi ot;
     vi primes;
-
-    rep(i, n << 1) {
-        if (prime[act[i]]) {
-            if (vis[act[i]]) {
-                ot.push_back(act[i]);
-            } else {
-                up.insert(act[i]);
-                vis[act[i]] = true;
-                primes.push_back(act[i]);
-            }
-            continue;
+    map<int, ll> c;
+    rep(i, 2 * n) {
+        if (prime[a[i]] && !c.count(a[i])) {
+            primes.push_back(a[i]);
         }
 
-        ot.push_back(act[i]);
+        c[a[i]]++;
     }
 
     if (primes.size() < n) {
@@ -156,38 +141,27 @@ void solve()
         return;
     }
 
-    auto comb = [&](int n, int k) {
-        return fact[n] * inv[k] % mod * inv[n - k] % mod;
-    };
-
-    ll ans = comb(primes.size(), n);
-
-    if (ot.empty()) {
-        cout << ans << '\n';
-        return;
+    ll non = 1;
+    repv(i, c) {
+        if (!prime[i.first]) {
+            non = (non * finv[i.second]) % mod;
+        }
     }
 
-    sortv(ot);
+    vvl dp(primes.size() + 1, vl(n + 1));
+    dp[0][0] = fact[n] * non % mod;
 
-    int c = 1;
-    vi tmp;
+    nrep(i, 1, primes.size() + 1) {
+        int cur = primes[i - 1];
+        ll co = c[cur];
+        dp[i][0] = dp[i - 1][0] * finv[co] % mod;
 
-    nrep(i, 1, ot.size()) {
-        if (ot[i] == ot[i - 1]) {
-            c++;
-            continue;
+        nrep(j, 1, n + 1) {
+            dp[i][j] = (dp[i - 1][j] * finv[co] % mod + dp[i - 1][j - 1] * finv[co - 1] % mod) % mod;
+        }
     }
 
-        tmp.push_back(c);
-        c = 1;
-    }
-    tmp.push_back(c);
-
-
-
-    repv(i, up) {
-        vis[i] = false;
-    }
+    cout << dp[primes.size()][n] << '\n';
 }
 
 int main()

Codeforces Round 861 (Div. 2)/C. Unlucky Numbers.cpp

@@ -0,0 +1,168 @@
+/* Problem URL: https://codeforces.com/problemset/problem/1808/C */
+
+#include <bits/stdc++.h>
+#include <ext/pb_ds/assoc_container.hpp>
+#include <ext/pb_ds/tree_policy.hpp>
+
+using namespace std;
+using namespace __gnu_pbds;
+
+template <class T, class comp = less<>>
+using ordered_set = tree<T, null_type , comp , rb_tree_tag , tree_order_statistics_node_update>;
+
+#define V vector
+
+#define rmin(a, b) a = min(a, b)
+#define rmax(a, b) a = max(a, b)
+
+#define rep(i, lim) for (int i = 0; i < (lim); i++)
+#define nrep(i, s, lim) for (int i = s; i < (lim); i++)
+
+#define repv(i, v) for (auto &i : (v))
+#define fillv(v) for (auto &itr_ : (v)) { cin >> itr_; }
+#define sortv(v) sort(v.begin(), v.end())
+#define all(v) (v).begin(), (v).end()
+
+using vi = vector<int>;
+using vvi = vector<vi>;
+using vvvi = vector<vvi>;
+using vvvvi = vector<vvvi>;
+using vvvvvi = vector<vvvvi>;
+using vvvvvvi = vector<vvvvvi>;
+
+using ll = long long;
+
+using vl = vector<ll>;
+using vvl = vector<vl>;
+using vvvl = vector<vvl>;
+using vvvvl = vector<vvvl>;
+
+template<class v>
+auto operator<<(ostream &os, const vector<v> &vec)->ostream& {
+    os << vec[0];
+    for (size_t i = 1; i < vec.size(); i++) {
+        os << ' ' << vec[i];
+    }
+    os << '\n';
+    return os;
+}
+
+template<class v>
+auto operator>>(istream &is, vector<v> &vec)->istream& {
+    for (auto &i : vec) {
+        is >> i;
+    }
+    return is;
+}
+
+template<class v>
+auto operator<<(ostream &os, const vector<vector<v>> &vec)->ostream& {
+    for (auto &i : vec) {
+        os << i[0];
+        for (size_t j = 1; j < i.size(); j++) {
+            os << ' ' << i[j];
+        }
+        os << '\n';
+    }
+    return os;
+}
+
+template<class v>
+auto operator>>(istream  &is, vector<vector<v>> &vec)->istream& {
+    for (auto &i : vec) {
+        for (auto &j : i) {
+            is >> j;
+        }
+    }
+    return is;
+}
+
+const int oo = INT32_MAX >> 1;
+const ll OO = INT64_MAX >> 1;
+
+
+void pre()
+{
+
+}
+
+#define TEST 1
+
+void solve()
+{
+    string a, b;
+    cin >> a >> b;
+
+    string zer(b.size() - a.size(), '0');
+    a = zer + a;
+    int n = a.size();
+    rep(i, n) {
+        a[i] -= '0';
+        b[i] -= '0';
+    }
+
+    vvvvvvi memo(n, vvvvvi(2, vvvvi(2, vvvi(2, vvi(10, vi(10, -1))))));
+
+    function<int(int, int, int, int, int, int)> dp = [&](int i, int u, int o, int s, int mi, int ma){
+        if (i >= n) {
+            return ma - mi;
+        }
+
+        int &ans = memo[i][u][o][s][mi][ma];
+        if (ans != -1) {
+            return ans;
+        }
+        ans = oo;
+
+        for (int j = o ? 0 : a[i]; j <= (u ? 9 : b[i]); j++) {
+            rmin(ans, dp(i + 1, u || j < b[i], o || j > a[i], s || j != 0, s || j != 0 ? min(mi, j) : 9, s || j != 0 ? max(ma, j) : 0));
+        }
+        return ans;
+    };
+
+    int target = dp(0, 0, 0, 0, 9, 0);
+
+    string ans;
+    function<void(int, int, int, int, int, int)> rec = [&](int i, int u, int o, int s, int mi, int ma) {
+        for (int j = o ? 0 : a[i]; j <= (u ? 9 : b[i]); j++) {
+            bool nu = u || j < b[i];
+            bool no = o || j > a[i];
+            bool ns = s || j != 0;
+
+            int nmi = ns ? min(mi, j) : 9;
+            int nma = ns ? max(ma, j) : 0;
+
+            if (i == n - 1) {
+                if (nma - nmi == target) {
+                    ans += j + '0';
+                    return;
+                }
+                continue;
+            }
+
+            if (memo[i + 1][nu][no][ns][nmi][nma] == target) {
+                ans += j + '0';
+                rec(i + 1, nu, no, ns, nmi, nma);
+                return;
+            }
+        }
+    };
+
+    rec(0, 0, 0, 0, 9, 0);
+
+    cout << stoll(ans) << '\n';
+}
+
+int main()
+{
+    ios::sync_with_stdio(false);
+    cin.tie(nullptr);
+
+    pre();
+
+    int t;
+    (TEST && cin >> t) || (t = 1);
+    while (t--) {
+        solve();
+    }
+}

Codeforces Round 864 (Div. 2)/C. Li Hua and Chess.cpp

@@ -0,0 +1,143 @@
+/* Problem URL: https://codeforces.com/problemset/problem/1797/C */
+
+#include <bits/stdc++.h>
+#include <ext/pb_ds/assoc_container.hpp>
+#include <ext/pb_ds/tree_policy.hpp>
+
+using namespace std;
+using namespace __gnu_pbds;
+
+template <class T, class comp = less<>>
+using ordered_set = tree<T, null_type , comp , rb_tree_tag , tree_order_statistics_node_update>;
+
+#define V vector
+
+#define rmin(a, b) a = min(a, b)
+#define rmax(a, b) a = max(a, b)
+
+#define rep(i, lim) for (int i = 0; i < (lim); i++)
+#define nrep(i, s, lim) for (int i = s; i < (lim); i++)
+
+#define repv(i, v) for (auto &i : (v))
+#define fillv(v) for (auto &itr_ : (v)) { cin >> itr_; }
+#define sortv(v) sort(v.begin(), v.end())
+#define all(v) (v).begin(), (v).end()
+
+using vi = vector<int>;
+using vvi = vector<vi>;
+using vvvi = vector<vvi>;
+using vvvvi = vector<vvvi>;
+
+using ll = long long;
+
+using vl = vector<ll>;
+using vvl = vector<vl>;
+using vvvl = vector<vvl>;
+using vvvvl = vector<vvvl>;
+
+template<class v>
+auto operator<<(ostream &os, const vector<v> &vec)->ostream& {
+    os << vec[0];
+    for (size_t i = 1; i < vec.size(); i++) {
+        os << ' ' << vec[i];
+    }
+    os << '\n';
+    return os;
+}
+
+template<class v>
+auto operator>>(istream &is, vector<v> &vec)->istream& {
+    for (auto &i : vec) {
+        is >> i;
+    }
+    return is;
+}
+
+template<class v>
+auto operator<<(ostream &os, const vector<vector<v>> &vec)->ostream& {
+    for (auto &i : vec) {
+        os << i[0];
+        for (size_t j = 1; j < i.size(); j++) {
+            os << ' ' << i[j];
+        }
+        os << '\n';
+    }
+    return os;
+}
+
+template<class v>
+auto operator>>(istream  &is, vector<vector<v>> &vec)->istream& {
+    for (auto &i : vec) {
+        for (auto &j : i) {
+            is >> j;
+        }
+    }
+    return is;
+}
+
+const int oo = INT32_MAX >> 1;
+const ll OO = INT64_MAX >> 1;
+
+
+void pre()
+{
+
+}
+
+#define TEST 1
+
+void solve()
+{
+    ll n, m;
+    cin >> n >> m;
+
+    auto ask = [&](int i, int j) {
+        cout << "? " << i << ' ' << j << endl;
+        ll ans;
+        cin >> ans;
+        return ans;
+    };
+
+    auto answer = [&](int i, int j) {
+        cout << "! " << i << ' ' << j << endl;
+        return;
+    };
+
+    ll c1 = ask(1, 1);
+
+    if (c1 >= n) {
+        ll c2 = ask(1, c1 + 1);
+        answer(c2 + 1, c1 + 1);
+        return;
+    }
+
+    ll c2 = ask(c1 + 1, 1);
+
+    if (c1 != c2) {
+        ll c3 = ask(c1 + 1, c2 + 1);
+        if (c3 == 0) {
+            answer(c1 + 1, c2 + 1);
+            return;
+        }
+
+        answer(n - c2, c1 + 1);
+        return;
+    }
+
+    ll c3 = ask(1, c1 + 1);
+    answer(c3 + 1, c1 + 1);
+}
+
+int main()
+{
+    ios::sync_with_stdio(false);
+    cin.tie(nullptr);
+
+    pre();
+
+    int t;
+    (TEST && cin >> t) || (t = 1);
+    while (t--) {
+        solve();
+    }
+}

Codeforces Round 867 (Div. 3)/F. Gardening Friends.cpp

@@ -0,0 +1,174 @@
+/* Problem URL: https://codeforces.com/problemset/problem/1822/F */
+
+#include <bits/stdc++.h>
+#include <ext/pb_ds/assoc_container.hpp>
+#include <ext/pb_ds/tree_policy.hpp>
+
+using namespace std;
+using namespace __gnu_pbds;
+
+template <class T, class comp = less<>>
+using ordered_set = tree<T, null_type , comp , rb_tree_tag , tree_order_statistics_node_update>;
+
+#define V vector
+
+#define rmin(a, b) a = min(a, b)
+#define rmax(a, b) a = max(a, b)
+
+#define rep(i, lim) for (int i = 0; i < (lim); i++)
+#define nrep(i, s, lim) for (int i = s; i < (lim); i++)
+
+#define repv(i, v) for (auto &i : (v))
+#define fillv(v) for (auto &itr_ : (v)) { cin >> itr_; }
+#define sortv(v) sort(v.begin(), v.end())
+#define all(v) (v).begin(), (v).end()
+
+using vi = vector<int>;
+using vvi = vector<vi>;
+using vvvi = vector<vvi>;
+using vvvvi = vector<vvvi>;
+
+using ll = long long;
+
+using vl = vector<ll>;
+using vvl = vector<vl>;
+using vvvl = vector<vvl>;
+using vvvvl = vector<vvvl>;
+
+template<class v>
+auto operator<<(ostream &os, const vector<v> &vec)->ostream& {
+    os << vec[0];
+    for (size_t i = 1; i < vec.size(); i++) {
+        os << ' ' << vec[i];
+    }
+    os << '\n';
+    return os;
+}
+
+template<class v>
+auto operator>>(istream &is, vector<v> &vec)->istream& {
+    for (auto &i : vec) {
+        is >> i;
+    }
+    return is;
+}
+
+template<class v>
+auto operator<<(ostream &os, const vector<vector<v>> &vec)->ostream& {
+    for (auto &i : vec) {
+        os << i[0];
+        for (size_t j = 1; j < i.size(); j++) {
+            os << ' ' << i[j];
+        }
+        os << '\n';
+    }
+    return os;
+}
+
+template<class v>
+auto operator>>(istream  &is, vector<vector<v>> &vec)->istream& {
+    for (auto &i : vec) {
+        for (auto &j : i) {
+            is >> j;
+        }
+    }
+    return is;
+}
+
+const int oo = INT32_MAX >> 1;
+const ll OO = INT64_MAX >> 1;
+
+
+void pre()
+{
+
+}
+
+#define TEST 1
+
+void solve()
+{
+    int n;
+    cin >> n;
+    ll k, c;
+    cin >> k >> c;
+
+    vvi graph(n);
+    rep(i, n - 1) {
+        int a, b;
+        cin >> a >> b;
+        a--, b--;
+        graph[a].push_back(b);
+        graph[b].push_back(a);
+    }
+
+    vi dis(n);
+    vi dp(n);
+    dis[0] = -1;
+
+    function<int(int, int)> dfs = [&](int i, int p) {
+        dis[i] = dis[p] + 1;
+        repv(j, graph[i]) {
+            if (j == p) {
+                continue;
+            }
+
+            rmax(dp[i], dfs(j, i) + 1);
+        }
+
+        return dp[i];
+    };
+
+    dfs(0, 0);
+
+    function<void(int, int)> reroot = [&](int i, int p) {
+        ll c1 = -1;
+        ll c2 = -1;
+        repv(j, graph[i]) {
+            if (dp[j] + 1 > c1) {
+                c2 = c1;
+                c1 = dp[j] + 1;
+                continue;
+            }
+
+            if (dp[j] + 1 > c2) {
+                c2 = dp[j] + 1;
+            }
+        }
+
+        ll ans = c1;
+
+        repv(j, graph[i]) {
+            if (j == p) {
+                continue;
+            }
+            dp[i] = dp[j] + 1 == ans ? c2 : c1;
+            reroot(j, i);
+        }
+
+        dp[i] = ans;
+    };
+
+    reroot(0, 0);
+
+    ll ans = 0;
+    rep(i, n) {
+        rmax(ans, dp[i] * k - dis[i] * c);
+    }
+
+    cout << ans << '\n';
+}
+
+int main()
+{
+    ios::sync_with_stdio(false);
+    cin.tie(nullptr);
+
+    pre();
+
+    int t;
+    (TEST && cin >> t) || (t = 1);
+    while (t--) {
+        solve();
+    }
+}

Codeforces Round 879 (Div. 2)/A. Unit Array.cpp

@@ -0,0 +1,127 @@
+/* Problem URL: https://codeforces.com/contest/1834/problem/A */
+
+#include <bits/stdc++.h>
+#include <ext/pb_ds/assoc_container.hpp>
+#include <ext/pb_ds/tree_policy.hpp>
+
+using namespace std;
+using namespace __gnu_pbds;
+
+template <class T, class comp = less<>>
+using ordered_set = tree<T, null_type , comp , rb_tree_tag , tree_order_statistics_node_update>;
+
+#define V vector
+
+#define rmin(a, b) a = min(a, b)
+#define rmax(a, b) a = max(a, b)
+
+#define rep(i, lim) for (int i = 0; i < (lim); i++)
+#define nrep(i, s, lim) for (int i = s; i < (lim); i++)
+
+#define repv(i, v) for (auto &i : (v))
+#define fillv(v) for (auto &itr_ : (v)) { cin >> itr_; }
+#define sortv(v) sort(v.begin(), v.end())
+#define all(v) (v).begin(), (v).end()
+
+using vi = vector<int>;
+using vvi = vector<vi>;
+using vvvi = vector<vvi>;
+using vvvvi = vector<vvvi>;
+
+using ll = long long;
+
+using vl = vector<ll>;
+using vvl = vector<vl>;
+using vvvl = vector<vvl>;
+using vvvvl = vector<vvvl>;
+
+template<class v>
+auto operator<<(ostream &os, const vector<v> &vec)->ostream& {
+    os << vec[0];
+    for (size_t i = 1; i < vec.size(); i++) {
+        os << ' ' << vec[i];
+    }
+    os << '\n';
+    return os;
+}
+
+template<class v>
+auto operator>>(istream &is, vector<v> &vec)->istream& {
+    for (auto &i : vec) {
+        is >> i;
+    }
+    return is;
+}
+
+template<class v>
+auto operator<<(ostream &os, const vector<vector<v>> &vec)->ostream& {
+    for (auto &i : vec) {
+        os << i[0];
+        for (size_t j = 1; j < i.size(); j++) {
+            os << ' ' << i[j];
+        }
+        os << '\n';
+    }
+    return os;
+}
+
+template<class v>
+auto operator>>(istream  &is, vector<vector<v>> &vec)->istream& {
+    for (auto &i : vec) {
+        for (auto &j : i) {
+            is >> j;
+        }
+    }
+    return is;
+}
+
+const int oo = INT32_MAX >> 1;
+const ll OO = INT64_MAX >> 1;
+
+
+void pre()
+{
+
+}
+
+#define TEST 1
+
+void solve()
+{
+    int n;
+    cin >> n;
+
+    array<int, 2> c = {0, 0};
+    rep(i, n) {
+        int r;
+        cin >> r;
+        c[r > 0]++;
+    }
+
+    int ans = 0;
+    if (c[1] < c[0]) {
+        int diff = (c[0] - c[1] + 1) >> 1;
+        ans += diff;
+        c[0] -= diff;
+    }
+
+    if (c[0] & 1) {
+        ans++;
+    }
+
+    cout << ans << '\n';
+}
+
+int main()
+{
+    ios::sync_with_stdio(false);
+    cin.tie(nullptr);
+
+    pre();
+
+    int t;
+    (TEST && cin >> t) || (t = 1);
+    while (t--) {
+        solve();
+    }
+}

Codeforces Round 879 (Div. 2)/B. Maximum Strength.cpp

@@ -0,0 +1,128 @@
+/* Problem URL: https://codeforces.com/contest/1834/problem/B */
+
+#include <bits/stdc++.h>
+#include <ext/pb_ds/assoc_container.hpp>
+#include <ext/pb_ds/tree_policy.hpp>
+
+using namespace std;
+using namespace __gnu_pbds;
+
+template <class T, class comp = less<>>
+using ordered_set = tree<T, null_type , comp , rb_tree_tag , tree_order_statistics_node_update>;
+
+#define V vector
+
+#define rmin(a, b) a = min(a, b)
+#define rmax(a, b) a = max(a, b)
+
+#define rep(i, lim) for (int i = 0; i < (lim); i++)
+#define nrep(i, s, lim) for (int i = s; i < (lim); i++)
+
+#define repv(i, v) for (auto &i : (v))
+#define fillv(v) for (auto &itr_ : (v)) { cin >> itr_; }
+#define sortv(v) sort(v.begin(), v.end())
+#define all(v) (v).begin(), (v).end()
+
+using vi = vector<int>;
+using vvi = vector<vi>;
+using vvvi = vector<vvi>;
+using vvvvi = vector<vvvi>;
+
+using ll = long long;
+
+using vl = vector<ll>;
+using vvl = vector<vl>;
+using vvvl = vector<vvl>;
+using vvvvl = vector<vvvl>;
+
+template<class v>
+auto operator<<(ostream &os, const vector<v> &vec)->ostream& {
+    os << vec[0];
+    for (size_t i = 1; i < vec.size(); i++) {
+        os << ' ' << vec[i];
+    }
+    os << '\n';
+    return os;
+}
+
+template<class v>
+auto operator>>(istream &is, vector<v> &vec)->istream& {
+    for (auto &i : vec) {
+        is >> i;
+    }
+    return is;
+}
+
+template<class v>
+auto operator<<(ostream &os, const vector<vector<v>> &vec)->ostream& {
+    for (auto &i : vec) {
+        os << i[0];
+        for (size_t j = 1; j < i.size(); j++) {
+            os << ' ' << i[j];
+        }
+        os << '\n';
+    }
+    return os;
+}
+
+template<class v>
+auto operator>>(istream  &is, vector<vector<v>> &vec)->istream& {
+    for (auto &i : vec) {
+        for (auto &j : i) {
+            is >> j;
+        }
+    }
+    return is;
+}
+
+const int oo = INT32_MAX >> 1;
+const ll OO = INT64_MAX >> 1;
+
+
+void pre()
+{
+
+}
+
+#define TEST 1
+
+void solve()
+{
+    string l, r;
+    cin >> l >> r;
+
+    int pad = r.size() - l.size();
+    string p(pad, '0');
+    p += l;
+    l = p;
+
+    int i = 0;
+    ll ans = 0;
+    while (i < r.size() && r[i] == l[i]) {
+        i++;
+    }
+
+    if (i == r.size()) {
+        cout << "0\n";
+        return;
+    }
+
+    ans += r[i] - l[i];
+    ans += (r.size() - i - 1) * 9;
+
+    cout << ans << '\n';
+}
+
+int main()
+{
+    ios::sync_with_stdio(false);
+    cin.tie(nullptr);
+
+    pre();
+
+    int t;
+    (TEST && cin >> t) || (t = 1);
+    while (t--) {
+        solve();
+    }
+}

Codeforces Round 879 (Div. 2)/C. Game with Reversing.cpp

@@ -0,0 +1,133 @@
+/* Problem URL: https://codeforces.com/contest/1834/problem/C */
+
+#include <bits/stdc++.h>
+#include <ext/pb_ds/assoc_container.hpp>
+#include <ext/pb_ds/tree_policy.hpp>
+
+using namespace std;
+using namespace __gnu_pbds;
+
+template <class T, class comp = less<>>
+using ordered_set = tree<T, null_type , comp , rb_tree_tag , tree_order_statistics_node_update>;
+
+#define V vector
+
+#define rmin(a, b) a = min(a, b)
+#define rmax(a, b) a = max(a, b)
+
+#define rep(i, lim) for (int i = 0; i < (lim); i++)
+#define nrep(i, s, lim) for (int i = s; i < (lim); i++)
+
+#define repv(i, v) for (auto &i : (v))
+#define fillv(v) for (auto &itr_ : (v)) { cin >> itr_; }
+#define sortv(v) sort(v.begin(), v.end())
+#define all(v) (v).begin(), (v).end()
+
+using vi = vector<int>;
+using vvi = vector<vi>;
+using vvvi = vector<vvi>;
+using vvvvi = vector<vvvi>;
+
+using ll = long long;
+
+using vl = vector<ll>;
+using vvl = vector<vl>;
+using vvvl = vector<vvl>;
+using vvvvl = vector<vvvl>;
+
+template<class v>
+auto operator<<(ostream &os, const vector<v> &vec)->ostream& {
+    os << vec[0];
+    for (size_t i = 1; i < vec.size(); i++) {
+        os << ' ' << vec[i];
+    }
+    os << '\n';
+    return os;
+}
+
+template<class v>
+auto operator>>(istream &is, vector<v> &vec)->istream& {
+    for (auto &i : vec) {
+        is >> i;
+    }
+    return is;
+}
+
+template<class v>
+auto operator<<(ostream &os, const vector<vector<v>> &vec)->ostream& {
+    for (auto &i : vec) {
+        os << i[0];
+        for (size_t j = 1; j < i.size(); j++) {
+            os << ' ' << i[j];
+        }
+        os << '\n';
+    }
+    return os;
+}
+
+template<class v>
+auto operator>>(istream  &is, vector<vector<v>> &vec)->istream& {
+    for (auto &i : vec) {
+        for (auto &j : i) {
+            is >> j;
+        }
+    }
+    return is;
+}
+
+const int oo = INT32_MAX >> 1;
+const ll OO = INT64_MAX >> 1;
+
+
+void pre()
+{
+
+}
+
+#define TEST 1
+
+void solve()
+{
+    int n;
+    cin >> n;
+    string a, b;
+    cin >> a >> b;
+
+    int c1 = 0;
+    int c2 = 0;
+    rep(i, n) {
+        c1 += a[i] != b[i];
+        c2 += a[i] != b[n - i - 1];
+    }
+
+    if (c1 == 0) {
+        cout << "0\n";
+        return;
+    }
+
+    if (c1 == 1) {
+        cout << "1\n";
+        return;
+    }
+
+    if (c2 == 0) {
+        cout << "2\n";
+        return;
+    }
+
+    cout << min(c1 * 2 - 1 + (~c1 & 1), c2 * 2 - 1 + (c2 & 1)) << '\n';
+}
+
+int main()
+{
+    ios::sync_with_stdio(false);
+    cin.tie(nullptr);
+
+    pre();
+
+    int t;
+    (TEST && cin >> t) || (t = 1);
+    while (t--) {
+        solve();
+    }
+}

Codeforces Round 879 (Div. 2)/D. Survey in Class.cpp

@@ -0,0 +1,164 @@
+/* Problem URL: https://codeforces.com/problemset/problem/1834/D */
+
+#include <bits/stdc++.h>
+#include <ext/pb_ds/assoc_container.hpp>
+#include <ext/pb_ds/tree_policy.hpp>
+
+using namespace std;
+using namespace __gnu_pbds;
+
+template <class T, class comp = less<>>
+using ordered_set = tree<T, null_type , comp , rb_tree_tag , tree_order_statistics_node_update>;
+
+#define V vector
+
+#define rmin(a, b) a = min(a, b)
+#define rmax(a, b) a = max(a, b)
+
+#define rep(i, lim) for (int i = 0; i < (lim); i++)
+#define nrep(i, s, lim) for (int i = s; i < (lim); i++)
+
+#define repv(i, v) for (auto &i : (v))
+#define fillv(v) for (auto &itr_ : (v)) { cin >> itr_; }
+#define sortv(v) sort(v.begin(), v.end())
+#define all(v) (v).begin(), (v).end()
+
+using vi = vector<int>;
+using vvi = vector<vi>;
+using vvvi = vector<vvi>;
+using vvvvi = vector<vvvi>;
+
+using ll = long long;
+
+using vl = vector<ll>;
+using vvl = vector<vl>;
+using vvvl = vector<vvl>;
+using vvvvl = vector<vvvl>;
+
+template<class v>
+auto operator<<(ostream &os, const vector<v> &vec)->ostream& {
+    os << vec[0];
+    for (size_t i = 1; i < vec.size(); i++) {
+        os << ' ' << vec[i];
+    }
+    os << '\n';
+    return os;
+}
+
+template<class v>
+auto operator>>(istream &is, vector<v> &vec)->istream& {
+    for (auto &i : vec) {
+        is >> i;
+    }
+    return is;
+}
+
+template<class v>
+auto operator<<(ostream &os, const vector<vector<v>> &vec)->ostream& {
+    for (auto &i : vec) {
+        os << i[0];
+        for (size_t j = 1; j < i.size(); j++) {
+            os << ' ' << i[j];
+        }
+        os << '\n';
+    }
+    return os;
+}
+
+template<class v>
+auto operator>>(istream  &is, vector<vector<v>> &vec)->istream& {
+    for (auto &i : vec) {
+        for (auto &j : i) {
+            is >> j;
+        }
+    }
+    return is;
+}
+
+const int oo = INT32_MAX >> 1;
+const ll OO = INT64_MAX >> 1;
+
+
+void pre()
+{
+
+}
+
+#define TEST 1
+
+void solve()
+{
+    int n, m;
+    cin >> n >> m;
+
+    V<pair<ll, ll>> a(n);
+
+    pair<ll, ll> a1 = {oo, oo};
+    pair<ll, ll> a2 = {0, 0};
+    pair<ll, ll> a3 = {0, oo};
+
+    auto sz = [&](pair<ll, ll> a) {
+        return a.second - a.first + 1;
+    };
+
+    repv(i, a) {
+        cin >> i.first >> i.second;
+        if (a1.second > i.second || (a1.second == i.second && a1.first > i.first)) {
+            a1 = i;
+        }
+
+        if (a2.first < i.first || (a2.first == i.first && a2.second < i.second)) {
+            a2 = i;
+        }
+
+        if (sz(i) <= sz(a3)) { 
+            a3 = i;
+        }
+    }
+
+    auto calc = [&](pair<ll, ll> a, pair<ll, ll> b) {
+        if (a.first > b.first) {
+            swap(a, b);
+        }
+
+        auto [al, ar] = a;
+        auto [bl, br] = b;
+
+        if (al <= bl && ar >= br) {
+            return sz(a) - sz(b);
+        }
+
+        if (al <= br && bl <= ar) {
+            return max(sz({al, bl}), sz({ar, br})) - 1;
+        }
+
+        return max(sz(a), sz(b));
+    };
+
+    ll ans = 0;
+    repv(i, a) {
+        rmax(ans, calc(a1, i) * 2);
+    }
+    repv(i, a) {
+        rmax(ans, calc(a2, i) * 2);
+    }
+    repv(i, a) {
+        rmax(ans, calc(a3, i) * 2);
+    }
+
+    cout << ans << '\n';
+}
+
+int main()
+{
+    ios::sync_with_stdio(false);
+    cin.tie(nullptr);
+
+    pre();
+
+    int t;
+    (TEST && cin >> t) || (t = 1);
+    while (t--) {
+        solve();
+    }
+}

Codeforces Round 889 (Div. 1)/A1. Dual (Easy Version).cpp

@@ -0,0 +1,177 @@
+/* Problem URL: https://codeforces.com/problemset/problem/1854/A1 */
+
+#include <bits/stdc++.h>
+#include <ext/pb_ds/assoc_container.hpp>
+#include <ext/pb_ds/tree_policy.hpp>
+
+using namespace std;
+using namespace __gnu_pbds;
+
+template <class T, class comp = less<>>
+using ordered_set = tree<T, null_type , comp , rb_tree_tag , tree_order_statistics_node_update>;
+
+#define V vector
+
+#define rmin(a, b) a = min(a, b)
+#define rmax(a, b) a = max(a, b)
+
+#define rep(i, lim) for (int i = 0; i < (lim); i++)
+#define nrep(i, s, lim) for (int i = s; i < (lim); i++)
+
+#define repv(i, v) for (auto &i : (v))
+#define fillv(v) for (auto &itr_ : (v)) { cin >> itr_; }
+#define sortv(v) sort(v.begin(), v.end())
+#define all(v) (v).begin(), (v).end()
+
+using vi = vector<int>;
+using vvi = vector<vi>;
+using vvvi = vector<vvi>;
+using vvvvi = vector<vvvi>;
+
+using ll = long long;
+
+using vl = vector<ll>;
+using vvl = vector<vl>;
+using vvvl = vector<vvl>;
+using vvvvl = vector<vvvl>;
+
+template<class v>
+auto operator<<(ostream &os, const vector<v> &vec)->ostream& {
+    os << vec[0];
+    for (size_t i = 1; i < vec.size(); i++) {
+        os << ' ' << vec[i];
+    }
+    os << '\n';
+    return os;
+}
+
+template<class v>
+auto operator>>(istream &is, vector<v> &vec)->istream& {
+    for (auto &i : vec) {
+        is >> i;
+    }
+    return is;
+}
+
+template<class v>
+auto operator<<(ostream &os, const vector<vector<v>> &vec)->ostream& {
+    for (auto &i : vec) {
+        os << i[0];
+        for (size_t j = 1; j < i.size(); j++) {
+            os << ' ' << i[j];
+        }
+        os << '\n';
+    }
+    return os;
+}
+
+template<class v>
+auto operator>>(istream  &is, vector<vector<v>> &vec)->istream& {
+    for (auto &i : vec) {
+        for (auto &j : i) {
+            is >> j;
+        }
+    }
+    return is;
+}
+
+const int oo = INT32_MAX >> 1;
+const ll OO = INT64_MAX >> 1;
+
+
+void pre()
+{
+
+}
+
+#define TEST 1
+
+void solve()
+{
+    int n;
+    cin >> n;
+    vl a(n);
+    cin >> a;
+
+    int mi = oo;
+    int mii = -1;
+    int ma = -oo;
+    int mai = -1;
+    rep(i, n) {
+        if (a[i] < mi) {
+            mi = a[i];
+            mii = i;
+        }
+
+        if (a[i] >= ma) {
+            ma = a[i];
+            mai = i;
+        }
+    }
+
+    if (ma == mi) {
+        cout << "0\n";
+        return;
+    }
+
+    V<pair<int, int>> ans;
+
+    auto printans = [&]() {
+        cout << ans.size() << '\n';
+        repv(i, ans) {
+            cout << i.first << ' ' << i.second << '\n';
+        }
+    };
+
+    if (ma > 0) {
+        ans.emplace_back(mai + 1, mai + 1);
+        ans.emplace_back(mai + 1, mai + 1);
+        ans.emplace_back(mai + 1, mai + 1);
+        ans.emplace_back(mai + 1, mai + 1);
+        ans.emplace_back(mai + 1, mai + 1);
+        ans.emplace_back(n, mai + 1);
+        ans.emplace_back(n, n);
+        ans.emplace_back(n, n);
+        ans.emplace_back(n, n);
+
+        rep(i, n) {
+            ans.emplace_back(i + 1, n);
+            ans.emplace_back(n, n);
+        }
+
+        printans();
+        return;
+    }
+
+    ans.emplace_back(mii + 1, mii + 1);
+    ans.emplace_back(mii + 1, mii + 1);
+    ans.emplace_back(mii + 1, mii + 1);
+    ans.emplace_back(mii + 1, mii + 1);
+    ans.emplace_back(mii + 1, mii + 1);
+    ans.emplace_back(mii + 1, mii + 1);
+    ans.emplace_back(1, mii + 1);
+    ans.emplace_back(1, 1);
+    ans.emplace_back(1, 1);
+    ans.emplace_back(1, 1);
+
+    for (int i = n - 1; i >= 0; i--) {
+        ans.emplace_back(i + 1, 1);
+        ans.emplace_back(1, 1);
+    }
+
+    printans();
+}
+
+int main()
+{
+    ios::sync_with_stdio(false);
+    cin.tie(nullptr);
+
+    pre();
+
+    int t;
+    (TEST && cin >> t) || (t = 1);
+    while (t--) {
+        solve();
+    }
+}

Codeforces Round 890 (Div. 2) supported by Constructor Institute/C. To Become Max.cpp

@@ -0,0 +1,159 @@
+/* Problem URL: https://codeforces.com/problemset/problem/1856/C */
+
+#include <bits/stdc++.h>
+#include <ext/pb_ds/assoc_container.hpp>
+#include <ext/pb_ds/tree_policy.hpp>
+
+using namespace std;
+using namespace __gnu_pbds;
+
+template <class T, class comp = less<>>
+using ordered_set = tree<T, null_type , comp , rb_tree_tag , tree_order_statistics_node_update>;
+
+#define V vector
+
+#define rmin(a, b) a = min(a, b)
+#define rmax(a, b) a = max(a, b)
+
+#define rep(i, lim) for (int i = 0; i < (lim); i++)
+#define nrep(i, s, lim) for (int i = s; i < (lim); i++)
+
+#define repv(i, v) for (auto &i : (v))
+#define fillv(v) for (auto &itr_ : (v)) { cin >> itr_; }
+#define sortv(v) sort(v.begin(), v.end())
+#define all(v) (v).begin(), (v).end()
+
+using vi = vector<int>;
+using vvi = vector<vi>;
+using vvvi = vector<vvi>;
+using vvvvi = vector<vvvi>;
+
+using ll = long long;
+
+using vl = vector<ll>;
+using vvl = vector<vl>;
+using vvvl = vector<vvl>;
+using vvvvl = vector<vvvl>;
+
+template<class v>
+auto operator<<(ostream &os, const vector<v> &vec)->ostream& {
+    os << vec[0];
+    for (size_t i = 1; i < vec.size(); i++) {
+        os << ' ' << vec[i];
+    }
+    os << '\n';
+    return os;
+}
+
+template<class v>
+auto operator>>(istream &is, vector<v> &vec)->istream& {
+    for (auto &i : vec) {
+        is >> i;
+    }
+    return is;
+}
+
+template<class v>
+auto operator<<(ostream &os, const vector<vector<v>> &vec)->ostream& {
+    for (auto &i : vec) {
+        os << i[0];
+        for (size_t j = 1; j < i.size(); j++) {
+            os << ' ' << i[j];
+        }
+        os << '\n';
+    }
+    return os;
+}
+
+template<class v>
+auto operator>>(istream  &is, vector<vector<v>> &vec)->istream& {
+    for (auto &i : vec) {
+        for (auto &j : i) {
+            is >> j;
+        }
+    }
+    return is;
+}
+
+const int oo = INT32_MAX >> 1;
+const ll OO = INT64_MAX >> 1;
+
+
+void pre()
+{
+
+}
+
+#define TEST 1
+
+void solve()
+{
+    int n;
+    ll k;
+    cin >> n >> k;
+
+    vl a(n);
+    cin >> a;
+
+    ll ans = *max_element(all(a));
+    rep(i, n - 1) {
+        ll co = 0;
+        nrep(j, i + 1, n) {
+            if (a[j] < a[i] - (j - i - 1)) {
+                co += a[i] - (j - i - 1) - a[j];
+                if (co >= k) {
+                    break;
+                }
+                continue;
+            }
+
+            if (co == k) {
+                break;
+            }
+
+            ll lk = k - co;
+            ll low = 0;
+            ll high = a[j] - a[i] + j - i - 1;
+            ll act = 0;
+            while (low <= high) {
+                ll mid = (low + high) >> 1;
+
+                ll cost = mid * (j - i);
+                if (cost < lk) {
+                    low = mid + 1;
+                    act = mid;
+                    continue;
+                }
+
+                high = mid - 1;
+            }
+
+            rmax(ans, a[i] + act + 1);
+            a[i] += act;
+            co += act * (j - i);
+
+            if (a[j] < a[i] - (j - i - 1)) {
+                co += a[i] - (j - i - 1) - a[j];
+                if (co >= k) {
+                    break;
+                }
+            }
+        }
+    }
+
+    cout << ans << '\n';
+}
+
+int main()
+{
+    ios::sync_with_stdio(false);
+    cin.tie(nullptr);
+
+    pre();
+
+    int t;
+    (TEST && cin >> t) || (t = 1);
+    while (t--) {
+        solve();
+    }
+}

Codeforces Round 893 (Div. 2)/B. The Walkway.cpp

@@ -0,0 +1,158 @@
+/* Problem URL: https://codeforces.com/problemset/problem/1858/B */
+
+#include <bits/stdc++.h>
+#include <ext/pb_ds/assoc_container.hpp>
+#include <ext/pb_ds/tree_policy.hpp>
+
+using namespace std;
+using namespace __gnu_pbds;
+
+template <class T, class comp = less<>>
+using ordered_set = tree<T, null_type , comp , rb_tree_tag , tree_order_statistics_node_update>;
+
+#define V vector
+
+#define rmin(a, b) a = min(a, b)
+#define rmax(a, b) a = max(a, b)
+
+#define rep(i, lim) for (int i = 0; i < (lim); i++)
+#define nrep(i, s, lim) for (int i = s; i < (lim); i++)
+
+#define repv(i, v) for (auto &i : (v))
+#define fillv(v) for (auto &itr_ : (v)) { cin >> itr_; }
+#define sortv(v) sort(v.begin(), v.end())
+#define all(v) (v).begin(), (v).end()
+
+using vi = vector<int>;
+using vvi = vector<vi>;
+using vvvi = vector<vvi>;
+using vvvvi = vector<vvvi>;
+
+using ll = long long;
+
+using vl = vector<ll>;
+using vvl = vector<vl>;
+using vvvl = vector<vvl>;
+using vvvvl = vector<vvvl>;
+
+template<class v>
+auto operator<<(ostream &os, const vector<v> &vec)->ostream& {
+    os << vec[0];
+    for (size_t i = 1; i < vec.size(); i++) {
+        os << ' ' << vec[i];
+    }
+    os << '\n';
+    return os;
+}
+
+template<class v>
+auto operator>>(istream &is, vector<v> &vec)->istream& {
+    for (auto &i : vec) {
+        is >> i;
+    }
+    return is;
+}
+
+template<class v>
+auto operator<<(ostream &os, const vector<vector<v>> &vec)->ostream& {
+    for (auto &i : vec) {
+        os << i[0];
+        for (size_t j = 1; j < i.size(); j++) {
+            os << ' ' << i[j];
+        }
+        os << '\n';
+    }
+    return os;
+}
+
+template<class v>
+auto operator>>(istream  &is, vector<vector<v>> &vec)->istream& {
+    for (auto &i : vec) {
+        for (auto &j : i) {
+            is >> j;
+        }
+    }
+    return is;
+}
+
+const int oo = INT32_MAX >> 1;
+const ll OO = INT64_MAX >> 1;
+
+
+void pre()
+{
+
+}
+
+#define TEST 1
+
+void solve()
+{
+    int n, m, d;
+    cin >> n >> m >> d;
+
+    vi t(m);
+    cin >> t;
+
+    vl suf(m);
+    suf[m - 1] = (n - t[m - 1]) / d + 1;
+
+    for (int i = m - 2; i >= 0; i--) {
+        suf[i] = suf[i + 1] + (t[i + 1] - t[i] - 1) / d + 1;
+    }
+
+    ll ans = OO;
+    int c = 1;
+    ll pref = 0;
+
+    rep(i, m) {
+        if (i == 0) {
+            ll tot = (t[i + 1] - 2) / d + suf[1] + 1;
+            ans = tot;
+            pref += max((t[i] - 2) / d, 0) + 1 + (t[0] != 1);
+            continue;
+        }
+
+        if (i == m - 1) {
+            ll tot = (n - t[i - 1]) / d + pref;
+
+            if (tot < ans) {
+                ans = tot;
+                c = 1;
+                continue;
+            }
+
+            if (tot == ans) {
+                c++;
+            }
+
+            continue;
+        }
+
+        ll tot = (t[i + 1] - t[i - 1] - 1) / d + suf[i + 1] + pref;
+        if (tot < ans) {
+            ans = tot;
+            c = 1;
+        } else if (tot == ans) {
+            c++;
+        }
+
+        pref += (t[i] - t[i - 1] - 1) / d + 1;
+    }
+
+    cout << ans << ' ' << c << '\n';
+}
+
+int main()
+{
+    ios::sync_with_stdio(false);
+    cin.tie(nullptr);
+
+    pre();
+
+    int t;
+    (TEST && cin >> t) || (t = 1);
+    while (t--) {
+        solve();
+    }
+}

Codeforces Round 898 (Div. 4)/G. ABBC or BACB.cpp

@@ -0,0 +1,135 @@
+/* Problem URL: https://codeforces.com/problemset/problem/1873/G */
+
+#include <bits/stdc++.h>
+#include <ext/pb_ds/assoc_container.hpp>
+#include <ext/pb_ds/tree_policy.hpp>
+
+using namespace std;
+using namespace __gnu_pbds;
+
+template <class T, class comp = less<>>
+using ordered_set = tree<T, null_type , comp , rb_tree_tag , tree_order_statistics_node_update>;
+
+#define V vector
+
+#define rmin(a, b) a = min(a, b)
+#define rmax(a, b) a = max(a, b)
+
+#define rep(i, lim) for (int i = 0; i < (lim); i++)
+#define nrep(i, s, lim) for (int i = s; i < (lim); i++)
+
+#define repv(i, v) for (auto &i : (v))
+#define fillv(v) for (auto &itr_ : (v)) { cin >> itr_; }
+#define sortv(v) sort(v.begin(), v.end())
+#define all(v) (v).begin(), (v).end()
+
+using vi = vector<int>;
+using vvi = vector<vi>;
+using vvvi = vector<vvi>;
+using vvvvi = vector<vvvi>;
+
+using ll = long long;
+
+using vl = vector<ll>;
+using vvl = vector<vl>;
+using vvvl = vector<vvl>;
+using vvvvl = vector<vvvl>;
+
+template<class v>
+auto operator<<(ostream &os, const vector<v> &vec)->ostream& {
+    os << vec[0];
+    for (size_t i = 1; i < vec.size(); i++) {
+        os << ' ' << vec[i];
+    }
+    os << '\n';
+    return os;
+}
+
+template<class v>
+auto operator>>(istream &is, vector<v> &vec)->istream& {
+    for (auto &i : vec) {
+        is >> i;
+    }
+    return is;
+}
+
+template<class v>
+auto operator<<(ostream &os, const vector<vector<v>> &vec)->ostream& {
+    for (auto &i : vec) {
+        os << i[0];
+        for (size_t j = 1; j < i.size(); j++) {
+            os << ' ' << i[j];
+        }
+        os << '\n';
+    }
+    return os;
+}
+
+template<class v>
+auto operator>>(istream  &is, vector<vector<v>> &vec)->istream& {
+    for (auto &i : vec) {
+        for (auto &j : i) {
+            is >> j;
+        }
+    }
+    return is;
+}
+
+const int oo = INT32_MAX >> 1;
+const ll OO = INT64_MAX >> 1;
+
+
+void pre()
+{
+
+}
+
+#define TEST 1
+
+void solve()
+{
+    string s;
+    cin >> s;
+    int n = s.size();
+
+    if (n == 1) {
+        cout << "0\n";
+        return;
+    }
+
+    vi pos = {0};
+    rep(i, n) {
+        if (s[i] == 'B') {
+            pos.push_back(i + 1);
+        }
+    }
+    pos.push_back(n + 1);
+
+    if (pos.size() == 2) {
+        cout << "0\n";
+        return;
+    }
+
+    vvi dp(pos.size(), vi(2));
+
+    nrep(i, 1, pos.size() - 1) {
+        dp[i][0] = pos[i] - pos[i - 1] - 1 + dp[i - 1][0];
+        dp[i][1] = pos[i + 1] - pos[i] - 1 + max(dp[i - 1][0], dp[i - 1][1]);
+    }
+
+    cout << max(dp.end()[-2][0], dp.end()[-2][1]) << '\n';
+}
+
+int main()
+{
+    ios::sync_with_stdio(false);
+    cin.tie(nullptr);
+
+    pre();
+
+    int t;
+    (TEST && cin >> t) || (t = 1);
+    while (t--) {
+        solve();
+    }
+}

Codeforces Round 902 (Div. 1, based on COMPFEST 15 - Final Round)/B. Effects of Anti Pimples.cpp

@@ -0,0 +1,144 @@
+/* Problem URL: https://codeforces.com/problemset/problem/1876/B */
+
+#include <bits/stdc++.h>
+#include <ext/pb_ds/assoc_container.hpp>
+#include <ext/pb_ds/tree_policy.hpp>
+
+using namespace std;
+using namespace __gnu_pbds;
+
+template <class T, class comp = less<>>
+using ordered_set = tree<T, null_type , comp , rb_tree_tag , tree_order_statistics_node_update>;
+
+#define V vector
+
+#define rmin(a, b) a = min(a, b)
+#define rmax(a, b) a = max(a, b)
+
+#define rep(i, lim) for (int i = 0; i < (lim); i++)
+#define nrep(i, s, lim) for (int i = s; i < (lim); i++)
+
+#define repv(i, v) for (auto &i : (v))
+#define fillv(v) for (auto &itr_ : (v)) { cin >> itr_; }
+#define sortv(v) sort(v.begin(), v.end())
+#define all(v) (v).begin(), (v).end()
+
+using vi = vector<int>;
+using vvi = vector<vi>;
+using vvvi = vector<vvi>;
+using vvvvi = vector<vvvi>;
+
+using ll = long long;
+
+using vl = vector<ll>;
+using vvl = vector<vl>;
+using vvvl = vector<vvl>;
+using vvvvl = vector<vvvl>;
+
+template<class v>
+auto operator<<(ostream &os, const vector<v> &vec)->ostream& {
+    os << vec[0];
+    for (size_t i = 1; i < vec.size(); i++) {
+        os << ' ' << vec[i];
+    }
+    os << '\n';
+    return os;
+}
+
+template<class v>
+auto operator>>(istream &is, vector<v> &vec)->istream& {
+    for (auto &i : vec) {
+        is >> i;
+    }
+    return is;
+}
+
+template<class v>
+auto operator<<(ostream &os, const vector<vector<v>> &vec)->ostream& {
+    for (auto &i : vec) {
+        os << i[0];
+        for (size_t j = 1; j < i.size(); j++) {
+            os << ' ' << i[j];
+        }
+        os << '\n';
+    }
+    return os;
+}
+
+template<class v>
+auto operator>>(istream  &is, vector<vector<v>> &vec)->istream& {
+    for (auto &i : vec) {
+        for (auto &j : i) {
+            is >> j;
+        }
+    }
+    return is;
+}
+
+const int oo = INT32_MAX >> 1;
+const ll OO = INT64_MAX >> 1;
+
+
+void pre()
+{
+
+}
+
+#define TEST 0
+
+void solve()
+{
+    int n;
+    cin >> n;
+
+    vi a(n);
+    cin >> a;
+
+    vl c(2e5);
+
+    rep(i, n) {
+        for (int j = i + 1; j <= n; j += i + 1) {
+            rmax(a[i], a[j - 1]);
+        }
+        c[a[i]]++;
+    }
+
+    const ll mod = 998244353;
+
+    auto fpow = [&](ll a, ll p) {
+        ll ans = 1;
+        rep(i, 61) {
+            if ((p >> i) & 1) {
+                (ans *= a) %= mod;
+            }
+            (a *= a) %= mod;
+        }
+        return ans;
+    };
+
+    ll ans = 0;
+    for (int i = 2e5 - 1; i >= 0; i--) {
+        if (c[i] == 0) {
+            continue;
+        }
+
+        n -= c[i];
+        (ans += ((fpow(2, c[i]) - 1) % mod + mod) % mod * fpow(2, n) % mod * i % mod) %= mod;
+    }
+
+    cout << ans << '\n';
+}
+
+int main()
+{
+    ios::sync_with_stdio(false);
+    cin.tie(nullptr);
+
+    pre();
+
+    int t;
+    (TEST && cin >> t) || (t = 1);
+    while (t--) {
+        solve();
+    }
+}

Codeforces Round 904 (Div. 2)/C. Medium Design.cpp

@@ -0,0 +1,160 @@
+/* Problem URL: https://codeforces.com/problemset/problem/1884/C */
+
+#include <bits/stdc++.h>
+#include <ext/pb_ds/assoc_container.hpp>
+#include <ext/pb_ds/tree_policy.hpp>
+
+using namespace std;
+using namespace __gnu_pbds;
+
+template <class T, class comp = less<>>
+using ordered_set = tree<T, null_type , comp , rb_tree_tag , tree_order_statistics_node_update>;
+
+#define V vector
+
+#define rmin(a, b) a = min(a, b)
+#define rmax(a, b) a = max(a, b)
+
+#define rep(i, lim) for (int i = 0; i < (lim); i++)
+#define nrep(i, s, lim) for (int i = s; i < (lim); i++)
+
+#define repv(i, v) for (auto &i : (v))
+#define fillv(v) for (auto &itr_ : (v)) { cin >> itr_; }
+#define sortv(v) sort(v.begin(), v.end())
+#define all(v) (v).begin(), (v).end()
+
+using vi = vector<int>;
+using vvi = vector<vi>;
+using vvvi = vector<vvi>;
+using vvvvi = vector<vvvi>;
+
+using ll = long long;
+
+using vl = vector<ll>;
+using vvl = vector<vl>;
+using vvvl = vector<vvl>;
+using vvvvl = vector<vvvl>;
+
+template<class v>
+auto operator<<(ostream &os, const vector<v> &vec)->ostream& {
+    os << vec[0];
+    for (size_t i = 1; i < vec.size(); i++) {
+        os << ' ' << vec[i];
+    }
+    os << '\n';
+    return os;
+}
+
+template<class v>
+auto operator>>(istream &is, vector<v> &vec)->istream& {
+    for (auto &i : vec) {
+        is >> i;
+    }
+    return is;
+}
+
+template<class v>
+auto operator<<(ostream &os, const vector<vector<v>> &vec)->ostream& {
+    for (auto &i : vec) {
+        os << i[0];
+        for (size_t j = 1; j < i.size(); j++) {
+            os << ' ' << i[j];
+        }
+        os << '\n';
+    }
+    return os;
+}
+
+template<class v>
+auto operator>>(istream  &is, vector<vector<v>> &vec)->istream& {
+    for (auto &i : vec) {
+        for (auto &j : i) {
+            is >> j;
+        }
+    }
+    return is;
+}
+
+const int oo = INT32_MAX >> 1;
+const ll OO = INT64_MAX >> 1;
+
+
+void pre()
+{
+
+}
+
+#define TEST 1
+
+void solve()
+{
+    int n, m;
+    cin >> n >> m;
+    
+    V<pair<int, int>> a(n);
+    vector<int> c;
+    repv(i, a) {
+        cin >> i.first >> i.second;
+        c.push_back(i.first);
+        c.push_back(i.second);
+    }
+    auto itr = find(all(a), make_pair(1, m));
+    if (itr != a.end()) {
+        a.erase(itr);
+    }
+
+    sortv(c);
+    c.erase(unique(all(c)), c.end());
+    repv(i, a) {
+        i.first = lower_bound(all(c), i.first) - c.begin();
+        i.second = lower_bound(all(c), i.second) - c.begin();
+    }
+
+    int sz = c.size() + 1;
+
+    vi t(sz);
+    vi pref(sz);
+    vi suf(sz);
+    repv(i, a) {
+        t[i.first]++;
+        t[i.second + 1]--;
+        if (c[i.first] == 1) {
+            pref[0]++;
+            pref[i.second + 1]--;
+        }
+
+        if (c[i.second] == m) {
+            suf[sz - 1]++;
+            if (i.first > 0) {
+                suf[i.first - 1]--;
+            }
+        }
+    }
+
+    nrep(i, 1, sz) {
+        pref[i] += pref[i - 1];
+        suf[sz - i - 1] += suf[sz - i];
+        t[i] += t[i - 1];
+    }
+
+    int ans = 0;
+    rep(i, sz) {
+        rmax(ans, t[i] - min(pref[i], suf[i]));
+    }
+
+    cout << ans << '\n';
+}
+
+int main()
+{
+    ios::sync_with_stdio(false);
+    cin.tie(nullptr);
+
+    pre();
+
+    int t;
+    (TEST && cin >> t) || (t = 1);
+    while (t--) {
+        solve();
+    }
+}

Codeforces Round 913 (Div. 3)/D. Jumping Through Segments.cpp

@@ -0,0 +1,154 @@
+/* Problem URL: https://codeforces.com/problemset/problem/1907/D */
+
+#include <bits/stdc++.h>
+#include <ext/pb_ds/assoc_container.hpp>
+#include <ext/pb_ds/tree_policy.hpp>
+
+using namespace std;
+using namespace __gnu_pbds;
+
+template <class T, class comp = less<>>
+using ordered_set = tree<T, null_type , comp , rb_tree_tag , tree_order_statistics_node_update>;
+
+#define V vector
+
+#define rmin(a, b) a = min(a, b)
+#define rmax(a, b) a = max(a, b)
+
+#define rep(i, lim) for (int i = 0; i < (lim); i++)
+#define nrep(i, s, lim) for (int i = s; i < (lim); i++)
+
+#define repv(i, v) for (auto &i : (v))
+#define fillv(v) for (auto &itr_ : (v)) { cin >> itr_; }
+#define sortv(v) sort(v.begin(), v.end())
+#define all(v) (v).begin(), (v).end()
+
+using vi = vector<int>;
+using vvi = vector<vi>;
+using vvvi = vector<vvi>;
+using vvvvi = vector<vvvi>;
+
+using ll = long long;
+
+using vl = vector<ll>;
+using vvl = vector<vl>;
+using vvvl = vector<vvl>;
+using vvvvl = vector<vvvl>;
+
+template<class v>
+auto operator<<(ostream &os, const vector<v> &vec)->ostream& {
+    os << vec[0];
+    for (size_t i = 1; i < vec.size(); i++) {
+        os << ' ' << vec[i];
+    }
+    os << '\n';
+    return os;
+}
+
+template<class v>
+auto operator>>(istream &is, vector<v> &vec)->istream& {
+    for (auto &i : vec) {
+        is >> i;
+    }
+    return is;
+}
+
+template<class v>
+auto operator<<(ostream &os, const vector<vector<v>> &vec)->ostream& {
+    for (auto &i : vec) {
+        os << i[0];
+        for (size_t j = 1; j < i.size(); j++) {
+            os << ' ' << i[j];
+        }
+        os << '\n';
+    }
+    return os;
+}
+
+template<class v>
+auto operator>>(istream  &is, vector<vector<v>> &vec)->istream& {
+    for (auto &i : vec) {
+        for (auto &j : i) {
+            is >> j;
+        }
+    }
+    return is;
+}
+
+const int oo = INT32_MAX >> 1;
+const ll OO = INT64_MAX >> 1;
+
+
+void pre()
+{
+
+}
+
+#define TEST 1
+
+void solve()
+{
+    int n;
+    cin >> n;
+
+    V<pair<ll, ll>> a(n);
+    repv(i, a) {
+        cin >> i.first >> i.second;
+    }
+
+    ll low = 0;
+    ll high = 1e9;
+    ll ans = 1e9;
+    while (low <= high) {
+        ll mid = (low + high) >> 1;
+
+        ll l = 0;
+        ll r = 0;
+
+        bool pos = true;
+
+        repv(i, a) {
+            ll l1 = l - mid;
+            ll l2 = l + mid;
+            ll r1 = r - mid;
+            ll r2 = r + mid;
+
+            rmax(l1, i.first);
+            rmin(l2, i.second);
+            rmax(r1, i.first);
+            rmin(r2, i.second);
+
+            l = min(l1, r1);
+            r = max(l2, r2);
+
+            if (l > r) {
+                pos = false;
+                break;
+            }
+        }
+
+        if (pos) {
+            ans = mid;
+            high = mid - 1;
+            continue;
+        }
+
+        low = mid + 1;
+    }
+
+    cout << ans << '\n';
+}
+
+int main()
+{
+    ios::sync_with_stdio(false);
+    cin.tie(nullptr);
+
+    pre();
+
+    int t;
+    (TEST && cin >> t) || (t = 1);
+    while (t--) {
+        solve();
+    }
+}

Codeforces Round 913 (Div. 3)/E. Good Triples.cpp

@@ -0,0 +1,116 @@
+/* Problem URL: https://codeforces.com/problemset/problem/1907/E */
+
+#include <bits/stdc++.h>
+#include <ext/pb_ds/assoc_container.hpp>
+#include <ext/pb_ds/tree_policy.hpp>
+
+using namespace std;
+using namespace __gnu_pbds;
+
+template <class T, class comp = less<>>
+using ordered_set = tree<T, null_type , comp , rb_tree_tag , tree_order_statistics_node_update>;
+
+#define V vector
+
+#define rmin(a, b) a = min(a, b)
+#define rmax(a, b) a = max(a, b)
+
+#define rep(i, lim) for (int i = 0; i < (lim); i++)
+#define nrep(i, s, lim) for (int i = s; i < (lim); i++)
+
+#define repv(i, v) for (auto &i : (v))
+#define fillv(v) for (auto &itr_ : (v)) { cin >> itr_; }
+#define sortv(v) sort(v.begin(), v.end())
+#define all(v) (v).begin(), (v).end()
+
+using vi = vector<int>;
+using vvi = vector<vi>;
+using vvvi = vector<vvi>;
+using vvvvi = vector<vvvi>;
+
+using ll = long long;
+
+using vl = vector<ll>;
+using vvl = vector<vl>;
+using vvvl = vector<vvl>;
+using vvvvl = vector<vvvl>;
+
+template<class v>
+auto operator<<(ostream &os, const vector<v> &vec)->ostream& {
+    os << vec[0];
+    for (size_t i = 1; i < vec.size(); i++) {
+        os << ' ' << vec[i];
+    }
+    os << '\n';
+    return os;
+}
+
+template<class v>
+auto operator>>(istream &is, vector<v> &vec)->istream& {
+    for (auto &i : vec) {
+        is >> i;
+    }
+    return is;
+}
+
+template<class v>
+auto operator<<(ostream &os, const vector<vector<v>> &vec)->ostream& {
+    for (auto &i : vec) {
+        os << i[0];
+        for (size_t j = 1; j < i.size(); j++) {
+            os << ' ' << i[j];
+        }
+        os << '\n';
+    }
+    return os;
+}
+
+template<class v>
+auto operator>>(istream  &is, vector<vector<v>> &vec)->istream& {
+    for (auto &i : vec) {
+        for (auto &j : i) {
+            is >> j;
+        }
+    }
+    return is;
+}
+
+const int oo = INT32_MAX >> 1;
+const ll OO = INT64_MAX >> 1;
+
+
+void pre()
+{
+
+}
+
+#define TEST 1
+
+void solve()
+{
+    ll n;
+    cin >> n;
+
+    ll ans = 1;
+    while (n > 0) {
+        ll now = n % 10;
+        n /= 10;
+        
+        ans *= (now + 1) * (now + 2) / 2;
+    }
+    cout << ans << '\n';
+}
+
+int main()
+{
+    ios::sync_with_stdio(false);
+    cin.tie(nullptr);
+
+    pre();
+
+    int t;
+    (TEST && cin >> t) || (t = 1);
+    while (t--) {
+        solve();
+    }
+}

Codeforces Round 921 (Div. 1)/A. Did We Get Everything Covered?.cpp

@@ -0,0 +1,171 @@
+/* Problem URL: https://codeforces.com/problemset/problem/1924/A */
+
+#include <bits/stdc++.h>
+#include <ext/pb_ds/assoc_container.hpp>
+#include <ext/pb_ds/tree_policy.hpp>
+
+using namespace std;
+using namespace __gnu_pbds;
+
+template <class T, class comp = less<>>
+using ordered_set = tree<T, null_type , comp , rb_tree_tag , tree_order_statistics_node_update>;
+
+#define V vector
+
+#define rmin(a, b) a = min(a, b)
+#define rmax(a, b) a = max(a, b)
+
+#define rep(i, lim) for (int i = 0; i < (lim); i++)
+#define nrep(i, s, lim) for (int i = s; i < (lim); i++)
+
+#define repv(i, v) for (auto &i : (v))
+#define fillv(v) for (auto &itr_ : (v)) { cin >> itr_; }
+#define sortv(v) sort(v.begin(), v.end())
+#define all(v) (v).begin(), (v).end()
+
+using vi = vector<int>;
+using vvi = vector<vi>;
+using vvvi = vector<vvi>;
+using vvvvi = vector<vvvi>;
+
+using ll = long long;
+
+using vl = vector<ll>;
+using vvl = vector<vl>;
+using vvvl = vector<vvl>;
+using vvvvl = vector<vvvl>;
+
+template<class v>
+auto operator<<(ostream &os, const vector<v> &vec)->ostream& {
+    os << vec[0];
+    for (size_t i = 1; i < vec.size(); i++) {
+        os << ' ' << vec[i];
+    }
+    os << '\n';
+    return os;
+}
+
+template<class v>
+auto operator>>(istream &is, vector<v> &vec)->istream& {
+    for (auto &i : vec) {
+        is >> i;
+    }
+    return is;
+}
+
+template<class v>
+auto operator<<(ostream &os, const vector<vector<v>> &vec)->ostream& {
+    for (auto &i : vec) {
+        os << i[0];
+        for (size_t j = 1; j < i.size(); j++) {
+            os << ' ' << i[j];
+        }
+        os << '\n';
+    }
+    return os;
+}
+
+template<class v>
+auto operator>>(istream  &is, vector<vector<v>> &vec)->istream& {
+    for (auto &i : vec) {
+        for (auto &j : i) {
+            is >> j;
+        }
+    }
+    return is;
+}
+
+const int oo = INT32_MAX >> 1;
+const ll OO = INT64_MAX >> 1;
+
+
+void pre()
+{
+
+}
+
+#define TEST 1
+
+void solve()
+{
+    int n, k, m;
+    cin >> n >> k >> m;
+    string a;
+    cin >> a;
+
+    vi pos(k, -1);
+    vvi ne(m + 1, vi(k, -1));
+
+    for (int i = m - 1; i >= 0; i--) {
+        ne[i + 1] = pos;
+        pos[a[i] - 'a'] = i + 1;
+    }
+    ne[0] = pos;
+
+    vi memo(m + 1, -1);
+
+    function<int(int)> dp = [&](int i) {
+        if (i == -1) {
+            return 0;
+        }
+
+        int &ans = memo[i];
+        if (ans != -1) {
+            return ans;
+        }
+
+        ans = oo;
+        rep(j, k) {
+            rmin(ans, dp(ne[i][j]) + 1);
+        }
+
+        return ans;
+    };
+
+    int c = dp(0) - 1;
+    if (c >= n) {
+        cout << "YES\n";
+        return;
+    }
+
+    cout << "NO\n";
+
+    int now = 0;
+    string ans;
+    while (ans.size() < n) {
+        int j = 0;
+        while (1) {
+            if (ne[now][j] == -1) {
+                while (ans.size() < n) {
+                    ans += j + 'a';
+                }
+                break;
+            }
+
+            if (memo[ne[now][j]] == c) {
+                c--;
+                ans += j + 'a';
+                now = ne[now][j];
+                break;
+            }
+
+            j++;
+        }
+    }
+
+    cout << ans << '\n';
+}
+
+int main()
+{
+    ios::sync_with_stdio(false);
+    cin.tie(nullptr);
+
+    pre();
+
+    int t;
+    (TEST && cin >> t) || (t = 1);
+    while (t--) {
+        solve();
+    }
+}

Codeforces Round 926 (Div. 2)/C. Sasha and the Casino.cpp

@@ -0,0 +1,122 @@
+/* Problem URL: https://codeforces.com/problemset/problem/1929/C */
+
+#include <bits/stdc++.h>
+#include <ext/pb_ds/assoc_container.hpp>
+#include <ext/pb_ds/tree_policy.hpp>
+
+using namespace std;
+using namespace __gnu_pbds;
+
+template <class T, class comp = less<>>
+using ordered_set = tree<T, null_type , comp , rb_tree_tag , tree_order_statistics_node_update>;
+
+#define V vector
+
+#define rmin(a, b) a = min(a, b)
+#define rmax(a, b) a = max(a, b)
+
+#define rep(i, lim) for (int i = 0; i < (lim); i++)
+#define nrep(i, s, lim) for (int i = s; i < (lim); i++)
+
+#define repv(i, v) for (auto &i : (v))
+#define fillv(v) for (auto &itr_ : (v)) { cin >> itr_; }
+#define sortv(v) sort(v.begin(), v.end())
+#define all(v) (v).begin(), (v).end()
+
+using vi = vector<int>;
+using vvi = vector<vi>;
+using vvvi = vector<vvi>;
+using vvvvi = vector<vvvi>;
+
+using ll = long long;
+
+using vl = vector<ll>;
+using vvl = vector<vl>;
+using vvvl = vector<vvl>;
+using vvvvl = vector<vvvl>;
+
+template<class v>
+auto operator<<(ostream &os, const vector<v> &vec)->ostream& {
+    os << vec[0];
+    for (size_t i = 1; i < vec.size(); i++) {
+        os << ' ' << vec[i];
+    }
+    os << '\n';
+    return os;
+}
+
+template<class v>
+auto operator>>(istream &is, vector<v> &vec)->istream& {
+    for (auto &i : vec) {
+        is >> i;
+    }
+    return is;
+}
+
+template<class v>
+auto operator<<(ostream &os, const vector<vector<v>> &vec)->ostream& {
+    for (auto &i : vec) {
+        os << i[0];
+        for (size_t j = 1; j < i.size(); j++) {
+            os << ' ' << i[j];
+        }
+        os << '\n';
+    }
+    return os;
+}
+
+template<class v>
+auto operator>>(istream  &is, vector<vector<v>> &vec)->istream& {
+    for (auto &i : vec) {
+        for (auto &j : i) {
+            is >> j;
+        }
+    }
+    return is;
+}
+
+const int oo = INT32_MAX >> 1;
+const ll OO = INT64_MAX >> 1;
+
+
+void pre()
+{
+
+}
+
+#define TEST 1
+
+void solve()
+{
+    ll k, x, a;
+    cin >> k >> x >> a;
+
+    ll cost = 1;
+    ll cur = 1;
+
+    rep(i, x - 1) {
+        cur = cost / (k - 1) + 1;
+        cost += cur;
+
+        if (cost > a) {
+            cout << "NO\n";
+            return;
+        }
+    }
+
+    cout << ((a - cost) * k > a ? "YES\n" : "NO\n");
+}
+
+int main()
+{
+    ios::sync_with_stdio(false);
+    cin.tie(nullptr);
+
+    pre();
+
+    int t;
+    (TEST && cin >> t) || (t = 1);
+    while (t--) {
+        solve();
+    }
+}

Codeforces Round 928 (Div. 4)/G. Vlad and Trouble at MIT.cpp

@@ -0,0 +1,143 @@
+/* Problem URL: https://codeforces.com/contest/1926/problem/G */
+
+#include <bits/stdc++.h>
+#include <ext/pb_ds/assoc_container.hpp>
+#include <ext/pb_ds/tree_policy.hpp>
+
+using namespace std;
+using namespace __gnu_pbds;
+
+template <class T, class comp = less<>>
+using ordered_set = tree<T, null_type , comp , rb_tree_tag , tree_order_statistics_node_update>;
+
+#define V vector
+
+#define rmin(a, b) a = min(a, b)
+#define rmax(a, b) a = max(a, b)
+
+#define rep(i, lim) for (int i = 0; i < (lim); i++)
+#define nrep(i, s, lim) for (int i = s; i < (lim); i++)
+
+#define repv(i, v) for (auto &i : (v))
+#define fillv(v) for (auto &itr_ : (v)) { cin >> itr_; }
+#define sortv(v) sort(v.begin(), v.end())
+#define all(v) (v).begin(), (v).end()
+
+using vi = vector<int>;
+using vvi = vector<vi>;
+using vvvi = vector<vvi>;
+using vvvvi = vector<vvvi>;
+
+using ll = long long;
+
+using vl = vector<ll>;
+using vvl = vector<vl>;
+using vvvl = vector<vvl>;
+using vvvvl = vector<vvvl>;
+
+template<class v>
+auto operator<<(ostream &os, const vector<v> &vec)->ostream& {
+    os << vec[0];
+    for (size_t i = 1; i < vec.size(); i++) {
+        os << ' ' << vec[i];
+    }
+    os << '\n';
+    return os;
+}
+
+template<class v>
+auto operator>>(istream &is, vector<v> &vec)->istream& {
+    for (auto &i : vec) {
+        is >> i;
+    }
+    return is;
+}
+
+template<class v>
+auto operator<<(ostream &os, const vector<vector<v>> &vec)->ostream& {
+    for (auto &i : vec) {
+        os << i[0];
+        for (size_t j = 1; j < i.size(); j++) {
+            os << ' ' << i[j];
+        }
+        os << '\n';
+    }
+    return os;
+}
+
+template<class v>
+auto operator>>(istream  &is, vector<vector<v>> &vec)->istream& {
+    for (auto &i : vec) {
+        for (auto &j : i) {
+            is >> j;
+        }
+    }
+    return is;
+}
+
+const int oo = INT32_MAX >> 1;
+const ll OO = INT64_MAX >> 1;
+
+
+void pre()
+{
+
+}
+
+#define TEST 1
+
+void solve()
+{
+    int n;
+    cin >> n;
+
+    vvi graph(n);
+    nrep(i, 1, n) {
+        int p;
+        cin >> p;
+        graph[p - 1].push_back(i);
+    }
+
+    string a;
+    cin >> a;
+
+    vvl dp(n, vl(3));
+
+    function<void(int)> dfs = [&](int i) {
+        if (a[i] == 'S') {
+            dp[i][0] = oo;
+            dp[i][2] = oo;
+        }
+
+        if (a[i] == 'P') {
+            dp[i][1] = oo;
+            dp[i][2] = oo;
+        }
+
+        repv(j, graph[i]) {
+            dfs(j);
+
+            dp[i][0] += min({dp[j][0], dp[j][1] + 1, dp[j][2]});
+            dp[i][1] += min({dp[j][0] + 1, dp[j][1], dp[j][2]});
+            dp[i][2] += min({dp[j][0] + 1, dp[j][1] + 1, dp[j][2]});
+        }
+    };
+
+    dfs(0);
+
+    cout << *min_element(all(dp[0])) << '\n';
+}
+
+int main()
+{
+    ios::sync_with_stdio(false);
+    cin.tie(nullptr);
+
+    pre();
+
+    int t;
+    (TEST && cin >> t) || (t = 1);
+    while (t--) {
+        solve();
+    }
+}

Codeforces Round 943 (Div. 3)/G1. Division + LCP (easy version).cpp

@@ -0,0 +1,163 @@
+/* Problem URL: https://codeforces.com/problemset/problem/1968/G1 */
+
+#include <bits/stdc++.h>
+#include <ext/pb_ds/assoc_container.hpp>
+#include <ext/pb_ds/tree_policy.hpp>
+
+using namespace std;
+using namespace __gnu_pbds;
+
+template <class T, class comp = less<>>
+using ordered_set = tree<T, null_type , comp , rb_tree_tag , tree_order_statistics_node_update>;
+
+#define V vector
+
+#define rmin(a, b) a = min(a, b)
+#define rmax(a, b) a = max(a, b)
+
+#define rep(i, lim) for (int i = 0; i < (lim); i++)
+#define nrep(i, s, lim) for (int i = s; i < (lim); i++)
+
+#define repv(i, v) for (auto &i : (v))
+#define fillv(v) for (auto &itr_ : (v)) { cin >> itr_; }
+#define sortv(v) sort(v.begin(), v.end())
+#define all(v) (v).begin(), (v).end()
+
+using vi = vector<int>;
+using vvi = vector<vi>;
+using vvvi = vector<vvi>;
+using vvvvi = vector<vvvi>;
+
+using ll = long long;
+
+using vl = vector<ll>;
+using vvl = vector<vl>;
+using vvvl = vector<vvl>;
+using vvvvl = vector<vvvl>;
+
+template<class v>
+auto operator<<(ostream &os, const vector<v> &vec)->ostream& {
+    os << vec[0];
+    for (size_t i = 1; i < vec.size(); i++) {
+        os << ' ' << vec[i];
+    }
+    os << '\n';
+    return os;
+}
+
+template<class v>
+auto operator>>(istream &is, vector<v> &vec)->istream& {
+    for (auto &i : vec) {
+        is >> i;
+    }
+    return is;
+}
+
+template<class v>
+auto operator<<(ostream &os, const vector<vector<v>> &vec)->ostream& {
+    for (auto &i : vec) {
+        os << i[0];
+        for (size_t j = 1; j < i.size(); j++) {
+            os << ' ' << i[j];
+        }
+        os << '\n';
+    }
+    return os;
+}
+
+template<class v>
+auto operator>>(istream  &is, vector<vector<v>> &vec)->istream& {
+    for (auto &i : vec) {
+        for (auto &j : i) {
+            is >> j;
+        }
+    }
+    return is;
+}
+
+const int oo = INT32_MAX >> 1;
+const ll OO = INT64_MAX >> 1;
+
+
+void pre()
+{
+
+}
+
+#define TEST 1
+
+struct hash_string {
+    static vl p;
+    static ll m;
+    static ll b;
+    vl hash;
+
+    hash_string(string &a) {
+        while (p.size() <= a.size()) {
+            p.push_back(((__int128)p.back() * b) % m);
+        }
+
+        hash.resize(a.size() + 1);
+        rep(i, a.size()) {
+            hash[i + 1] = ((__int128)hash[i] * b + a[i]) % m;
+        }
+    }
+
+    ll gethash(int l, int r) {
+        return ((hash[r + 1] - (__int128)hash[l] * p[r - l + 1]) % m + m) % m;
+    }
+};
+
+vl hash_string::p = {1};
+ll hash_string:: m = (1LL << 61) - 1;
+mt19937_64 rng(chrono::steady_clock::now().time_since_epoch().count());
+ll hash_string:: b = uniform_int_distribution<>()(rng);
+
+void solve()
+{
+    int n, l, r;
+    cin >> n >> l >> r;
+    string a;
+    cin >> a;
+
+    hash_string ah(a);
+
+    int low = 1;
+    int high = n;
+    int ans = 0;
+    while (low <= high) {
+        int mid = (low + high) >> 1;
+
+        int c = 1;
+        for (int i = mid; i + mid - 1 < n; i++) {
+            if (ah.gethash(0, mid - 1) == ah.gethash(i, i + mid - 1)) {
+                c++;
+                i += mid - 1;
+            }
+        }
+
+        if (c >= l) {
+            ans = mid;
+            low = mid + 1;
+            continue;
+        }
+
+        high = mid - 1;
+    }
+
+    cout << ans << '\n';
+}
+
+int main()
+{
+    ios::sync_with_stdio(false);
+    cin.tie(nullptr);
+
+    pre();
+
+    int t;
+    (TEST && cin >> t) || (t = 1);
+    while (t--) {
+        solve();
+    }
+}

Codeforces Round 945 (Div. 2)/C. Cat, Fox and Double Maximum.cpp

@@ -0,0 +1,171 @@
+/* Problem URL: https://codeforces.com/problemset/problem/1973/C */
+
+#include <bits/stdc++.h>
+#include <ext/pb_ds/assoc_container.hpp>
+#include <ext/pb_ds/tree_policy.hpp>
+
+using namespace std;
+using namespace __gnu_pbds;
+
+template <class T, class comp = less<>>
+using ordered_set = tree<T, null_type , comp , rb_tree_tag , tree_order_statistics_node_update>;
+
+#define V vector
+
+#define rmin(a, b) a = min(a, b)
+#define rmax(a, b) a = max(a, b)
+
+#define rep(i, lim) for (int i = 0; i < (lim); i++)
+#define nrep(i, s, lim) for (int i = s; i < (lim); i++)
+
+#define repv(i, v) for (auto &i : (v))
+#define fillv(v) for (auto &itr_ : (v)) { cin >> itr_; }
+#define sortv(v) sort(v.begin(), v.end())
+#define all(v) (v).begin(), (v).end()
+
+using vi = vector<int>;
+using vvi = vector<vi>;
+using vvvi = vector<vvi>;
+using vvvvi = vector<vvvi>;
+
+using ll = long long;
+
+using vl = vector<ll>;
+using vvl = vector<vl>;
+using vvvl = vector<vvl>;
+using vvvvl = vector<vvvl>;
+
+template<class v>
+auto operator<<(ostream &os, const vector<v> &vec)->ostream& {
+    os << vec[0];
+    for (size_t i = 1; i < vec.size(); i++) {
+        os << ' ' << vec[i];
+    }
+    os << '\n';
+    return os;
+}
+
+template<class v>
+auto operator>>(istream &is, vector<v> &vec)->istream& {
+    for (auto &i : vec) {
+        is >> i;
+    }
+    return is;
+}
+
+template<class v>
+auto operator<<(ostream &os, const vector<vector<v>> &vec)->ostream& {
+    for (auto &i : vec) {
+        os << i[0];
+        for (size_t j = 1; j < i.size(); j++) {
+            os << ' ' << i[j];
+        }
+        os << '\n';
+    }
+    return os;
+}
+
+template<class v>
+auto operator>>(istream  &is, vector<vector<v>> &vec)->istream& {
+    for (auto &i : vec) {
+        for (auto &j : i) {
+            is >> j;
+        }
+    }
+    return is;
+}
+
+const int oo = INT32_MAX >> 1;
+const ll OO = INT64_MAX >> 1;
+
+
+void pre()
+{
+
+}
+
+#define TEST 1
+
+void solve()
+{
+    int n;
+    cin >> n;
+
+    vi p(n);
+    cin >> p;
+
+    vi ans;
+    int best = 0;
+
+    priority_queue<pair<int, int>> mi;
+    priority_queue<pair<int, int>, V<pair<int, int>>, greater<>> ma;
+
+    auto getans = [&]() -> pair<vi, int> {
+        vi t(n);
+
+        int now = 1;
+        while (!mi.empty()) {
+            auto [c, i] = mi.top();
+            mi.pop();
+            t[i] = now;
+            now++;
+        }
+
+        now = n;
+        while (!ma.empty()) {
+            auto [c, i] = ma.top();
+            ma.pop();
+            t[i] = now;
+            now--;
+        }
+
+        int ans = 0;
+        nrep(i, 1, n - 1) {
+            ans += t[i] + p[i] > max(t[i + 1] + p[i + 1], t[i - 1] + p[i - 1]);
+        }
+
+        return {t, ans};
+    };
+
+    rep(i, n) {
+        if (i & 1) {
+            mi.emplace(p[i], i);
+        } else {
+            ma.emplace(p[i], i);
+        }
+    }
+
+    auto [t, v] = getans();
+    swap(ans, t);
+    best = v;
+
+    rep(i, n) {
+        if (i & 1) {
+            ma.emplace(p[i], i);
+        } else {
+            mi.emplace(p[i], i);
+        }
+    }
+
+    auto [t2, v2] = getans();
+    if (v2 > best) {
+        swap(ans, t2);
+        best = v2;
+    }
+
+    cout << ans;
+}
+
+int main()
+{
+    ios::sync_with_stdio(false);
+    cin.tie(nullptr);
+
+    pre();
+
+    int t;
+    (TEST && cin >> t) || (t = 1);
+    while (t--) {
+        solve();
+    }
+}

Codeforces Round 954 (Div. 3)/E. Beautiful Array.cpp

@@ -0,0 +1,168 @@
+/* Problem URL: https://codeforces.com/problemset/problem/1986/E */
+
+#include <bits/stdc++.h>
+#include <ext/pb_ds/assoc_container.hpp>
+#include <ext/pb_ds/tree_policy.hpp>
+
+using namespace std;
+using namespace __gnu_pbds;
+
+template <class T, class comp = less<>>
+using ordered_set = tree<T, null_type , comp , rb_tree_tag , tree_order_statistics_node_update>;
+
+#define V vector
+
+#define rmin(a, b) a = min(a, b)
+#define rmax(a, b) a = max(a, b)
+
+#define rep(i, lim) for (int i = 0; i < (lim); i++)
+#define nrep(i, s, lim) for (int i = s; i < (lim); i++)
+
+#define repv(i, v) for (auto &i : (v))
+#define fillv(v) for (auto &itr_ : (v)) { cin >> itr_; }
+#define sortv(v) sort(v.begin(), v.end())
+#define all(v) (v).begin(), (v).end()
+
+using vi = vector<int>;
+using vvi = vector<vi>;
+using vvvi = vector<vvi>;
+using vvvvi = vector<vvvi>;
+
+using ll = long long;
+
+using vl = vector<ll>;
+using vvl = vector<vl>;
+using vvvl = vector<vvl>;
+using vvvvl = vector<vvvl>;
+
+template<class v>
+auto operator<<(ostream &os, const vector<v> &vec)->ostream& {
+    os << vec[0];
+    for (size_t i = 1; i < vec.size(); i++) {
+        os << ' ' << vec[i];
+    }
+    os << '\n';
+    return os;
+}
+
+template<class v>
+auto operator>>(istream &is, vector<v> &vec)->istream& {
+    for (auto &i : vec) {
+        is >> i;
+    }
+    return is;
+}
+
+template<class v>
+auto operator<<(ostream &os, const vector<vector<v>> &vec)->ostream& {
+    for (auto &i : vec) {
+        os << i[0];
+        for (size_t j = 1; j < i.size(); j++) {
+            os << ' ' << i[j];
+        }
+        os << '\n';
+    }
+    return os;
+}
+
+template<class v>
+auto operator>>(istream  &is, vector<vector<v>> &vec)->istream& {
+    for (auto &i : vec) {
+        for (auto &j : i) {
+            is >> j;
+        }
+    }
+    return is;
+}
+
+const int oo = INT32_MAX >> 1;
+const ll OO = INT64_MAX >> 1;
+
+
+void pre()
+{
+
+}
+
+#define TEST 1
+
+void solve()
+{
+    int n;
+    ll k;
+    cin >> n >> k;
+    vl a(n);
+    cin >> a;
+
+    map<ll, vl> c;
+    rep(i, n) {
+        c[a[i] % k].push_back(a[i]);
+    }
+
+    int oc = 0;
+    repv(i, c) {
+        oc += i.second.size() & 1;
+    }
+
+    if (oc > 1) {
+        cout << "-1\n";
+        return;
+    }
+
+    auto func = [&](vl &v) -> int {
+        if (v.size() <= 1) {
+            return 0;
+        }
+        int n = v.size();
+        vl suf(n + 1);
+        suf[n - 2] = (v.end()[-1] - v.end()[-2]) / k;
+        for (int i = n - 4; i >= 0; i -= 2) {
+            suf[i] = suf[i + 2] + (v[i + 1] - v[i]) / k;
+        }
+
+        ll ans = OO;
+        ll sum = 0;
+        rep(i, n) {
+            if (i & 1) {
+                rmin(ans, (v[i + 1] - v[i - 1]) / k + suf[i + 2] + sum);
+                sum += (v[i] - v[i - 1]) / k;
+                continue;
+            }
+
+            rmin(ans, sum + suf[i + 1]);
+        }
+
+        return ans;
+    };
+
+    ll ans = 0;
+    repv(i, c) {
+        auto &v = i.second;
+        sortv(v);
+        if (v.size() & 1) {
+            ans += func(v);
+            continue;
+        }
+
+        nrep(j, 1, v.size()) {
+            ans += (v[j] - v[j - 1]) / k;
+            j++;
+        }
+    }
+
+    cout << ans << '\n';
+}
+
+int main()
+{
+    ios::sync_with_stdio(false);
+    cin.tie(nullptr);
+
+    pre();
+
+    int t;
+    (TEST && cin >> t) || (t = 1);
+    while (t--) {
+        solve();
+    }
+}

Codeforces Round 954 (Div. 3)/F. Non-academic Problem.cpp

@@ -0,0 +1,208 @@
+/* Problem URL: https://codeforces.com/problemset/problem/1986/F */
+
+#include <bits/stdc++.h>
+#include <ext/pb_ds/assoc_container.hpp>
+#include <ext/pb_ds/tree_policy.hpp>
+
+using namespace std;
+using namespace __gnu_pbds;
+
+template <class T, class comp = less<>>
+using ordered_set = tree<T, null_type , comp , rb_tree_tag , tree_order_statistics_node_update>;
+
+#define V vector
+
+#define rmin(a, b) a = min(a, b)
+#define rmax(a, b) a = max(a, b)
+
+#define rep(i, lim) for (int i = 0; i < (lim); i++)
+#define nrep(i, s, lim) for (int i = s; i < (lim); i++)
+
+#define repv(i, v) for (auto &i : (v))
+#define fillv(v) for (auto &itr_ : (v)) { cin >> itr_; }
+#define sortv(v) sort(v.begin(), v.end())
+#define all(v) (v).begin(), (v).end()
+
+using vi = vector<int>;
+using vvi = vector<vi>;
+using vvvi = vector<vvi>;
+using vvvvi = vector<vvvi>;
+
+using ll = long long;
+
+using vl = vector<ll>;
+using vvl = vector<vl>;
+using vvvl = vector<vvl>;
+using vvvvl = vector<vvvl>;
+
+template<class v>
+auto operator<<(ostream &os, const vector<v> &vec)->ostream& {
+    os << vec[0];
+    for (size_t i = 1; i < vec.size(); i++) {
+        os << ' ' << vec[i];
+    }
+    os << '\n';
+    return os;
+}
+
+template<class v>
+auto operator>>(istream &is, vector<v> &vec)->istream& {
+    for (auto &i : vec) {
+        is >> i;
+    }
+    return is;
+}
+
+template<class v>
+auto operator<<(ostream &os, const vector<vector<v>> &vec)->ostream& {
+    for (auto &i : vec) {
+        os << i[0];
+        for (size_t j = 1; j < i.size(); j++) {
+            os << ' ' << i[j];
+        }
+        os << '\n';
+    }
+    return os;
+}
+
+template<class v>
+auto operator>>(istream  &is, vector<vector<v>> &vec)->istream& {
+    for (auto &i : vec) {
+        for (auto &j : i) {
+            is >> j;
+        }
+    }
+    return is;
+}
+
+const int oo = INT32_MAX >> 1;
+const ll OO = INT64_MAX >> 1;
+
+
+void pre()
+{
+
+}
+
+#define TEST 1
+
+void solve()
+{
+    int n, m;
+    cin >> n >> m;
+
+    V<V<pair<int, int>>> graph(n);
+    V<bool> rem(m);
+    while (m--) {
+        int a, b;
+        cin >> a >> b;
+        a--, b--;
+        graph[a].emplace_back(b, m);
+        graph[b].emplace_back(a, m);
+    }
+
+    V<bool> vis(n);
+    vi t(n);
+    vi mi(n);
+    int tim = 0;
+    int tt = 1;
+    function<int(int, int)> dfs = [&](int i, int p) {
+        vis[i] = true;
+        t[i] = tim++;
+        mi[i] = t[i];
+
+        for (auto [j, ind] : graph[i]) {
+            if (j == p) {
+                continue;
+            }
+
+            if (vis[j]) {
+                rmin(mi[i], t[j]);
+                continue;
+            }
+
+            rmin(mi[i], dfs(j, i));
+            if (mi[j] > t[i]) {
+                rem[ind] = true;
+                tt++;
+            }
+        }
+
+        return mi[i];
+    };
+
+    dfs(0, 0);
+
+    vl c(tt);
+    vi g(n);
+    vvi act(tt);
+    int cur = 0;
+    fill(all(vis), false);
+
+    function<void(int)> func = [&](int i) {
+        vis[i] = true;
+        g[i] = cur;
+        c[cur]++;
+        for (auto [j, ind] : graph[i]) {
+            if (vis[j] || rem[ind]) {
+                continue;
+            }
+
+            func(j);
+        }
+    };
+
+    rep(i, n) {
+        if (vis[i]) {
+            continue;
+        }
+        func(i);
+        cur++;
+    }
+
+    rep(i, n) {
+        for (auto [j, ind] : graph[i]) {
+            if (rem[ind]) {
+                act[g[i]].push_back(g[j]);
+                act[g[j]].push_back(g[i]);
+            }
+        }
+    }
+
+    repv(i, act) {
+        sortv(i);
+        i.erase(unique(all(i)), i.end());
+    }
+
+    ll ans = (ll)n * (n - 1) / 2;
+    function<ll(int, int)> calc = [&](int i, int p) {
+        ll count = c[i];
+        repv(j, act[i]) {
+            if (j == p) {
+                continue;
+            }
+
+            ll tm = calc(j, i);
+            rmin(ans, tm * (tm - 1) / 2 + (n - tm) * (n - tm - 1) / 2);
+            count += tm;
+        }
+        return count;
+    };
+
+    calc(0, 0);
+    cout << ans << '\n';
+}
+
+int main()
+{
+    ios::sync_with_stdio(false);
+    cin.tie(nullptr);
+
+    pre();
+
+    int t;
+    (TEST && cin >> t) || (t = 1);
+    while (t--) {
+        solve();
+    }
+}

Codeforces Round 957 (Div. 3)/F. Valuable Cards.cpp

@@ -0,0 +1,137 @@
+/* Problem URL: https://codeforces.com/problemset/problem/1992/F */
+
+#include <bits/stdc++.h>
+#include <ext/pb_ds/assoc_container.hpp>
+#include <ext/pb_ds/tree_policy.hpp>
+
+using namespace std;
+using namespace __gnu_pbds;
+
+template <class T, class comp = less<>>
+using ordered_set = tree<T, null_type , comp , rb_tree_tag , tree_order_statistics_node_update>;
+
+#define V vector
+
+#define rmin(a, b) a = min(a, b)
+#define rmax(a, b) a = max(a, b)
+
+#define rep(i, lim) for (int i = 0; i < (lim); i++)
+#define nrep(i, s, lim) for (int i = s; i < (lim); i++)
+
+#define repv(i, v) for (auto &i : (v))
+#define fillv(v) for (auto &itr_ : (v)) { cin >> itr_; }
+#define sortv(v) sort(v.begin(), v.end())
+#define all(v) (v).begin(), (v).end()
+
+using vi = vector<int>;
+using vvi = vector<vi>;
+using vvvi = vector<vvi>;
+using vvvvi = vector<vvvi>;
+
+using ll = long long;
+
+using vl = vector<ll>;
+using vvl = vector<vl>;
+using vvvl = vector<vvl>;
+using vvvvl = vector<vvvl>;
+
+template<class v>
+auto operator<<(ostream &os, const vector<v> &vec)->ostream& {
+    os << vec[0];
+    for (size_t i = 1; i < vec.size(); i++) {
+        os << ' ' << vec[i];
+    }
+    os << '\n';
+    return os;
+}
+
+template<class v>
+auto operator>>(istream &is, vector<v> &vec)->istream& {
+    for (auto &i : vec) {
+        is >> i;
+    }
+    return is;
+}
+
+template<class v>
+auto operator<<(ostream &os, const vector<vector<v>> &vec)->ostream& {
+    for (auto &i : vec) {
+        os << i[0];
+        for (size_t j = 1; j < i.size(); j++) {
+            os << ' ' << i[j];
+        }
+        os << '\n';
+    }
+    return os;
+}
+
+template<class v>
+auto operator>>(istream  &is, vector<vector<v>> &vec)->istream& {
+    for (auto &i : vec) {
+        for (auto &j : i) {
+            is >> j;
+        }
+    }
+    return is;
+}
+
+const int oo = INT32_MAX >> 1;
+const ll OO = INT64_MAX >> 1;
+
+
+void pre()
+{
+
+}
+
+#define TEST 1
+
+void solve()
+{
+    int n, x;
+    cin >> n >> x;
+
+    vi a(n);
+    cin >> a;
+
+    set<int> ev;
+    ev.insert(x);
+
+    int ans = 1;
+    rep(i, n) {
+        set<int> tmp = ev;
+        repv(j, ev) {
+            if (j % a[i] == 0) {
+                tmp.insert(j / a[i]);
+            }
+        }
+
+        if (tmp.count(1)) {
+            ans++;
+            ev.clear();
+            ev.insert(x);
+            if (x % a[i] == 0) {
+                ev.insert(x / a[i]);
+            }
+            continue;
+        }
+
+        swap(ev, tmp);
+    }
+
+    cout << ans << '\n';
+}
+
+int main()
+{
+    ios::sync_with_stdio(false);
+    cin.tie(nullptr);
+
+    pre();
+
+    int t;
+    (TEST && cin >> t) || (t = 1);
+    while (t--) {
+        solve();
+    }
+}

Codeforces Round 962 (Div. 3)/D. Fun.cpp

@@ -0,0 +1,115 @@
+/* Problem URL: https://codeforces.com/problemset/problem/1996/D */
+
+#include <bits/stdc++.h>
+#include <ext/pb_ds/assoc_container.hpp>
+#include <ext/pb_ds/tree_policy.hpp>
+
+using namespace std;
+using namespace __gnu_pbds;
+
+template <class T, class comp = less<>>
+using ordered_set = tree<T, null_type , comp , rb_tree_tag , tree_order_statistics_node_update>;
+
+#define V vector
+
+#define rmin(a, b) a = min(a, b)
+#define rmax(a, b) a = max(a, b)
+
+#define rep(i, lim) for (int i = 0; i < (lim); i++)
+#define nrep(i, s, lim) for (int i = s; i < (lim); i++)
+
+#define repv(i, v) for (auto &i : (v))
+#define fillv(v) for (auto &itr_ : (v)) { cin >> itr_; }
+#define sortv(v) sort(v.begin(), v.end())
+#define all(v) (v).begin(), (v).end()
+
+using vi = vector<int>;
+using vvi = vector<vi>;
+using vvvi = vector<vvi>;
+using vvvvi = vector<vvvi>;
+
+using ll = long long;
+
+using vl = vector<ll>;
+using vvl = vector<vl>;
+using vvvl = vector<vvl>;
+using vvvvl = vector<vvvl>;
+
+template<class v>
+auto operator<<(ostream &os, const vector<v> &vec)->ostream& {
+    os << vec[0];
+    for (size_t i = 1; i < vec.size(); i++) {
+        os << ' ' << vec[i];
+    }
+    os << '\n';
+    return os;
+}
+
+template<class v>
+auto operator>>(istream &is, vector<v> &vec)->istream& {
+    for (auto &i : vec) {
+        is >> i;
+    }
+    return is;
+}
+
+template<class v>
+auto operator<<(ostream &os, const vector<vector<v>> &vec)->ostream& {
+    for (auto &i : vec) {
+        os << i[0];
+        for (size_t j = 1; j < i.size(); j++) {
+            os << ' ' << i[j];
+        }
+        os << '\n';
+    }
+    return os;
+}
+
+template<class v>
+auto operator>>(istream  &is, vector<vector<v>> &vec)->istream& {
+    for (auto &i : vec) {
+        for (auto &j : i) {
+            is >> j;
+        }
+    }
+    return is;
+}
+
+const int oo = INT32_MAX >> 1;
+const ll OO = INT64_MAX >> 1;
+
+void pre()
+{
+
+}
+
+#define TEST 1
+
+void solve()
+{
+    int n, x;
+    cin >> n >> x;
+
+    ll ans = 0;
+    nrep(a, 1, n + 1) {
+        nrep(b, 1, n / a + 1) {
+            ans += max(min(x - (ll)a - b, ((ll)n - a * b) / (a + b)), 0LL);
+        }
+    }
+
+    cout << ans << '\n';
+}
+
+int main()
+{
+    ios::sync_with_stdio(false);
+    cin.tie(nullptr);
+
+    pre();
+
+    int t;
+    (TEST && cin >> t) || (t = 1);
+    while (t--) {
+        solve();
+    }
+}

Codeforces Round 962 (Div. 3)/F. Bomb.cpp

@@ -0,0 +1,161 @@
+/* Problem URL: https://codeforces.com/problemset/problem/1996/F */
+
+#include <bits/stdc++.h>
+#include <ext/pb_ds/assoc_container.hpp>
+#include <ext/pb_ds/tree_policy.hpp>
+
+using namespace std;
+using namespace __gnu_pbds;
+
+template <class T, class comp = less<>>
+using ordered_set = tree<T, null_type , comp , rb_tree_tag , tree_order_statistics_node_update>;
+
+#define V vector
+
+#define rmin(a, b) a = min(a, b)
+#define rmax(a, b) a = max(a, b)
+
+#define rep(i, lim) for (int i = 0; i < (lim); i++)
+#define nrep(i, s, lim) for (int i = s; i < (lim); i++)
+
+#define repv(i, v) for (auto &i : (v))
+#define fillv(v) for (auto &itr_ : (v)) { cin >> itr_; }
+#define sortv(v) sort(v.begin(), v.end())
+#define all(v) (v).begin(), (v).end()
+
+using vi = vector<int>;
+using vvi = vector<vi>;
+using vvvi = vector<vvi>;
+using vvvvi = vector<vvvi>;
+
+using ll = long long;
+
+using vl = vector<ll>;
+using vvl = vector<vl>;
+using vvvl = vector<vvl>;
+using vvvvl = vector<vvvl>;
+
+template<class v>
+auto operator<<(ostream &os, const vector<v> &vec)->ostream& {
+    os << vec[0];
+    for (size_t i = 1; i < vec.size(); i++) {
+        os << ' ' << vec[i];
+    }
+    os << '\n';
+    return os;
+}
+
+template<class v>
+auto operator>>(istream &is, vector<v> &vec)->istream& {
+    for (auto &i : vec) {
+        is >> i;
+    }
+    return is;
+}
+
+template<class v>
+auto operator<<(ostream &os, const vector<vector<v>> &vec)->ostream& {
+    for (auto &i : vec) {
+        os << i[0];
+        for (size_t j = 1; j < i.size(); j++) {
+            os << ' ' << i[j];
+        }
+        os << '\n';
+    }
+    return os;
+}
+
+template<class v>
+auto operator>>(istream  &is, vector<vector<v>> &vec)->istream& {
+    for (auto &i : vec) {
+        for (auto &j : i) {
+            is >> j;
+        }
+    }
+    return is;
+}
+
+const int oo = INT32_MAX >> 1;
+const ll OO = INT64_MAX >> 1;
+
+
+void pre()
+{
+
+}
+
+#define TEST 1
+
+void solve()
+{
+    int n;
+    ll k;
+    cin >> n >> k;
+
+    vl a(n);
+    vl b(n);
+    cin >> a >> b;
+
+    ll low = 0;
+    ll high = 1e9;
+    ll act = 1e9;
+    while (low <= high) {
+        ll mid = (low + high) >> 1;
+
+        ll cos = 0;
+        rep(i, n) {
+            cos += max((a[i] - mid + b[i] - 1) / b[i], 0LL);
+        }
+
+        if (cos <= k) {
+            act = mid;
+            high = mid - 1;
+            continue;
+        }
+
+        low = mid + 1;
+    }
+    
+    ll ans = 0;
+    ll cos = 0;
+    priority_queue<pair<ll, ll>> pq;
+    rep(i, n) {
+        ll t = max((a[i] - act + b[i] - 1) / b[i], 0LL);
+        cos += t;
+
+        ll mod = a[i] % b[i];
+        ll add = t * (a[i] / b[i] * 2 - t + 1) / 2 * b[i] + mod * t;
+        a[i] -= b[i] * t;
+        ans += add;
+        pq.emplace(max(a[i], 0LL), b[i]);
+    }
+
+    k -= cos;
+
+    while (k > 0) {
+        auto [x, y] = pq.top();
+        if (x == 0) {
+            break;
+        }
+        pq.pop();
+        ans += x;
+        pq.emplace(max(x - y, 0LL), y);
+        k--;
+    }
+
+    cout << ans << '\n';
+}
+
+int main()
+{
+    ios::sync_with_stdio(false);
+    cin.tie(nullptr);
+
+    pre();
+
+    int t;
+    (TEST && cin >> t) || (t = 1);
+    while (t--) {
+        solve();
+    }
+}

Codeforces Round 963 (Div. 2)/C. Light Switches.cpp

@@ -0,0 +1,142 @@
+/* Problem URL: https://codeforces.com/problemset/problem/1993/C */
+
+#include <bits/stdc++.h>
+#include <ext/pb_ds/assoc_container.hpp>
+#include <ext/pb_ds/tree_policy.hpp>
+
+using namespace std;
+using namespace __gnu_pbds;
+
+template <class T, class comp = less<>>
+using ordered_set = tree<T, null_type , comp , rb_tree_tag , tree_order_statistics_node_update>;
+
+#define V vector
+
+#define rmin(a, b) a = min(a, b)
+#define rmax(a, b) a = max(a, b)
+
+#define rep(i, lim) for (int i = 0; i < (lim); i++)
+#define nrep(i, s, lim) for (int i = s; i < (lim); i++)
+
+#define repv(i, v) for (auto &i : (v))
+#define fillv(v) for (auto &itr_ : (v)) { cin >> itr_; }
+#define sortv(v) sort(v.begin(), v.end())
+#define all(v) (v).begin(), (v).end()
+
+using vi = vector<int>;
+using vvi = vector<vi>;
+using vvvi = vector<vvi>;
+using vvvvi = vector<vvvi>;
+
+using ll = long long;
+
+using vl = vector<ll>;
+using vvl = vector<vl>;
+using vvvl = vector<vvl>;
+using vvvvl = vector<vvvl>;
+
+template<class v>
+auto operator<<(ostream &os, const vector<v> &vec)->ostream& {
+    os << vec[0];
+    for (size_t i = 1; i < vec.size(); i++) {
+        os << ' ' << vec[i];
+    }
+    os << '\n';
+    return os;
+}
+
+template<class v>
+auto operator>>(istream &is, vector<v> &vec)->istream& {
+    for (auto &i : vec) {
+        is >> i;
+    }
+    return is;
+}
+
+template<class v>
+auto operator<<(ostream &os, const vector<vector<v>> &vec)->ostream& {
+    for (auto &i : vec) {
+        os << i[0];
+        for (size_t j = 1; j < i.size(); j++) {
+            os << ' ' << i[j];
+        }
+        os << '\n';
+    }
+    return os;
+}
+
+template<class v>
+auto operator>>(istream  &is, vector<vector<v>> &vec)->istream& {
+    for (auto &i : vec) {
+        for (auto &j : i) {
+            is >> j;
+        }
+    }
+    return is;
+}
+
+const int oo = INT32_MAX >> 1;
+const ll OO = INT64_MAX >> 1;
+
+
+void pre()
+{
+
+}
+
+#define TEST 1
+
+void solve()
+{
+    int n, k;
+    cin >> n >> k;
+
+    vl a(n);
+    cin >> a;
+
+    ll mod = k << 1;
+    vl pref((mod << 1) + 1);
+
+    ll ma = 0;
+
+    repv(i, a) {
+        pref[i % mod]++;
+        pref[i % mod + k]--;
+        rmax(ma, i);
+    }
+
+    nrep(i, 1, (mod << 1) + 1) {
+        pref[i] += pref[i - 1];
+    }
+
+    int act = 0;
+    nrep(i, ma % mod, (mod << 1)) {
+        ll sum = 0;
+        if (i >= mod) {
+            sum = pref[i] + pref[i - mod];
+        } else {
+            sum = pref[i] + pref[i + mod];
+        }
+
+        if (sum == n) {
+            cout << ma + i - ma % mod << '\n';
+            return;
+        }
+    }
+
+    cout << "-1\n";
+}
+
+int main()
+{
+    ios::sync_with_stdio(false);
+    cin.tie(nullptr);
+
+    pre();
+
+    int t;
+    (TEST && cin >> t) || (t = 1);
+    while (t--) {
+        solve();
+    }
+}

Codeforces Round 964 (Div. 4)/F. Expected Median.cpp

@@ -0,0 +1,149 @@
+/* Problem URL: https://codeforces.com/problemset/problem/1999/F */
+
+#include <bits/stdc++.h>
+#include <ext/pb_ds/assoc_container.hpp>
+#include <ext/pb_ds/tree_policy.hpp>
+
+using namespace std;
+using namespace __gnu_pbds;
+
+template <class T, class comp = less<>>
+using ordered_set = tree<T, null_type , comp , rb_tree_tag , tree_order_statistics_node_update>;
+
+#define V vector
+
+#define rmin(a, b) a = min(a, b)
+#define rmax(a, b) a = max(a, b)
+
+#define rep(i, lim) for (int i = 0; i < (lim); i++)
+#define nrep(i, s, lim) for (int i = s; i < (lim); i++)
+
+#define repv(i, v) for (auto &i : (v))
+#define fillv(v) for (auto &itr_ : (v)) { cin >> itr_; }
+#define sortv(v) sort(v.begin(), v.end())
+#define all(v) (v).begin(), (v).end()
+
+using vi = vector<int>;
+using vvi = vector<vi>;
+using vvvi = vector<vvi>;
+using vvvvi = vector<vvvi>;
+
+using ll = long long;
+
+using vl = vector<ll>;
+using vvl = vector<vl>;
+using vvvl = vector<vvl>;
+using vvvvl = vector<vvvl>;
+
+template<class v>
+auto operator<<(ostream &os, const vector<v> &vec)->ostream& {
+    os << vec[0];
+    for (size_t i = 1; i < vec.size(); i++) {
+        os << ' ' << vec[i];
+    }
+    os << '\n';
+    return os;
+}
+
+template<class v>
+auto operator>>(istream &is, vector<v> &vec)->istream& {
+    for (auto &i : vec) {
+        is >> i;
+    }
+    return is;
+}
+
+template<class v>
+auto operator<<(ostream &os, const vector<vector<v>> &vec)->ostream& {
+    for (auto &i : vec) {
+        os << i[0];
+        for (size_t j = 1; j < i.size(); j++) {
+            os << ' ' << i[j];
+        }
+        os << '\n';
+    }
+    return os;
+}
+
+template<class v>
+auto operator>>(istream  &is, vector<vector<v>> &vec)->istream& {
+    for (auto &i : vec) {
+        for (auto &j : i) {
+            is >> j;
+        }
+    }
+    return is;
+}
+
+const int oo = INT32_MAX >> 1;
+const ll OO = INT64_MAX >> 1;
+
+const ll mod = 1e9 + 7;
+
+constexpr int MAXN = 2e5 + 10;
+ll fact[MAXN];
+ll inv[MAXN];
+ll invf[MAXN];
+
+void pre()
+{
+    fact[0] = 1;
+    nrep(i, 1, MAXN) {
+        fact[i] = fact[i - 1] * i % mod;
+    }
+
+    inv[1] = 1;
+    nrep(i, 2, MAXN) {
+        inv[i] = (mod - mod / i) * inv[mod % i] % mod;
+    }
+
+    invf[0] = 1;
+    nrep(i, 1, MAXN) {
+        invf[i] = invf[i - 1] * inv[i] % mod;
+    }
+}
+
+ll comb(ll n, ll k) {
+    return fact[n] * invf[k] % mod * invf[n - k] % mod;
+}
+
+#define TEST 1
+
+void solve()
+{
+    int n, k;
+    cin >> n >> k;
+    vi a(n);
+    cin >> a;
+
+    ll c0 = count(all(a), 0);
+    ll c1 = count(all(a), 1);
+
+    ll ans = 0;
+    nrep(i, (k + 1) >> 1, k + 1) {
+        ll o = i;
+        ll z = k - i;
+
+        if (c0 < z || c1 < o) {
+            continue;
+        }
+
+        (ans += comb(c1, o) * comb(c0, z) % mod) %= mod;
+    }
+    
+    cout << ans << '\n';
+}
+
+int main()
+{
+    ios::sync_with_stdio(false);
+    cin.tie(nullptr);
+
+    pre();
+
+    int t;
+    (TEST && cin >> t) || (t = 1);
+    while (t--) {
+        solve();
+    }
+}

Codeforces Round 966 (Div. 3)/E. Photoshoot for Gorillas.cpp

@@ -0,0 +1,167 @@
+/* Problem URL: https://codeforces.com/problemset/problem/2000/E */
+
+#include <bits/stdc++.h>
+#include <ext/pb_ds/assoc_container.hpp>
+#include <ext/pb_ds/tree_policy.hpp>
+
+using namespace std;
+using namespace __gnu_pbds;
+
+template <class T, class comp = less<>>
+using ordered_set = tree<T, null_type , comp , rb_tree_tag , tree_order_statistics_node_update>;
+
+#define V vector
+
+#define rmin(a, b) a = min(a, b)
+#define rmax(a, b) a = max(a, b)
+
+#define rep(i, lim) for (int i = 0; i < (lim); i++)
+#define nrep(i, s, lim) for (int i = s; i < (lim); i++)
+
+#define repv(i, v) for (auto &i : (v))
+#define fillv(v) for (auto &itr_ : (v)) { cin >> itr_; }
+#define sortv(v) sort(v.begin(), v.end())
+#define all(v) (v).begin(), (v).end()
+
+using vi = vector<int>;
+using vvi = vector<vi>;
+using vvvi = vector<vvi>;
+using vvvvi = vector<vvvi>;
+
+using ll = long long;
+
+using vl = vector<ll>;
+using vvl = vector<vl>;
+using vvvl = vector<vvl>;
+using vvvvl = vector<vvvl>;
+
+template<class v>
+auto operator<<(ostream &os, const vector<v> &vec)->ostream& {
+    os << vec[0];
+    for (size_t i = 1; i < vec.size(); i++) {
+        os << ' ' << vec[i];
+    }
+    os << '\n';
+    return os;
+}
+
+template<class v>
+auto operator>>(istream &is, vector<v> &vec)->istream& {
+    for (auto &i : vec) {
+        is >> i;
+    }
+    return is;
+}
+
+template<class v>
+auto operator<<(ostream &os, const vector<vector<v>> &vec)->ostream& {
+    for (auto &i : vec) {
+        os << i[0];
+        for (size_t j = 1; j < i.size(); j++) {
+            os << ' ' << i[j];
+        }
+        os << '\n';
+    }
+    return os;
+}
+
+template<class v>
+auto operator>>(istream  &is, vector<vector<v>> &vec)->istream& {
+    for (auto &i : vec) {
+        for (auto &j : i) {
+            is >> j;
+        }
+    }
+    return is;
+}
+
+const int oo = INT32_MAX >> 1;
+const ll OO = INT64_MAX >> 1;
+
+
+void pre()
+{
+
+}
+
+#define TEST 1
+
+void solve()
+{
+    int n, m, k;
+    cin >> n >> m >> k;
+
+    int w;
+    cin >> w;
+    vl a(w);
+    cin >> a;
+
+    vvl c(n, vl(m));
+    rep(i, n - k + 1) {
+        rep(j, m - k + 1) {
+            c[i][j]++;
+            int id = i + k;
+            int jd = j + k;
+
+            if (id < n) {
+                c[id][j]--;
+            }
+
+            if (jd < m) {
+                c[i][jd]--;
+            }
+
+            if (id < n && jd < m) {
+                c[id][jd]++;
+            }
+        }
+    }
+
+    rep(i, n) {
+        rep(j, m) {
+            if (i > 0) {
+                c[i][j] += c[i - 1][j];
+            }
+
+            if (j > 0) {
+                c[i][j] += c[i][j - 1];
+            }
+
+            if (i > 0 && j > 0) {
+                c[i][j] -= c[i - 1][j - 1];
+            }
+        }
+    }
+
+    vi t;
+    rep(i, n) {
+        rep(j, m) {
+            t.push_back(c[i][j]);
+        }
+    }
+
+    sort(all(t), greater<>());
+    sort(all(a), greater<>());
+
+    ll ans = 0;
+
+    rep(i, w) {
+        ans += a[i] * t[i];
+    }
+
+    cout << ans << '\n';
+}
+
+int main()
+{
+    ios::sync_with_stdio(false);
+    cin.tie(nullptr);
+
+    pre();
+
+    int t;
+    (TEST && cin >> t) || (t = 1);
+    while (t--) {
+        solve();
+    }
+}

Codeforces Round 969 (Div. 1)/A. Iris and Game on the Tree.cpp

@@ -0,0 +1,154 @@
+/* Problem URL: https://codeforces.com/problemset/problem/2006/A */
+
+#include <bits/stdc++.h>
+#include <ext/pb_ds/assoc_container.hpp>
+#include <ext/pb_ds/tree_policy.hpp>
+
+using namespace std;
+using namespace __gnu_pbds;
+
+template <class T, class comp = less<>>
+using ordered_set = tree<T, null_type , comp , rb_tree_tag , tree_order_statistics_node_update>;
+
+#define V vector
+
+#define rmin(a, b) a = min(a, b)
+#define rmax(a, b) a = max(a, b)
+
+#define rep(i, lim) for (int i = 0; i < (lim); i++)
+#define nrep(i, s, lim) for (int i = s; i < (lim); i++)
+
+#define repv(i, v) for (auto &i : (v))
+#define fillv(v) for (auto &itr_ : (v)) { cin >> itr_; }
+#define sortv(v) sort(v.begin(), v.end())
+#define all(v) (v).begin(), (v).end()
+
+using vi = vector<int>;
+using vvi = vector<vi>;
+using vvvi = vector<vvi>;
+using vvvvi = vector<vvvi>;
+
+using ll = long long;
+
+using vl = vector<ll>;
+using vvl = vector<vl>;
+using vvvl = vector<vvl>;
+using vvvvl = vector<vvvl>;
+
+template<class v>
+auto operator<<(ostream &os, const vector<v> &vec)->ostream& {
+    os << vec[0];
+    for (size_t i = 1; i < vec.size(); i++) {
+        os << ' ' << vec[i];
+    }
+    os << '\n';
+    return os;
+}
+
+template<class v>
+auto operator>>(istream &is, vector<v> &vec)->istream& {
+    for (auto &i : vec) {
+        is >> i;
+    }
+    return is;
+}
+
+template<class v>
+auto operator<<(ostream &os, const vector<vector<v>> &vec)->ostream& {
+    for (auto &i : vec) {
+        os << i[0];
+        for (size_t j = 1; j < i.size(); j++) {
+            os << ' ' << i[j];
+        }
+        os << '\n';
+    }
+    return os;
+}
+
+template<class v>
+auto operator>>(istream  &is, vector<vector<v>> &vec)->istream& {
+    for (auto &i : vec) {
+        for (auto &j : i) {
+            is >> j;
+        }
+    }
+    return is;
+}
+
+const int oo = INT32_MAX >> 1;
+const ll OO = INT64_MAX >> 1;
+
+
+void pre()
+{
+
+}
+
+#define TEST 1
+
+void solve()
+{
+    int n;
+    cin >> n;
+    vvi graph(n);
+    rep(i, n - 1) {
+        int a, b;
+        cin >> a >> b;
+        a--, b--;
+        graph[a].push_back(b);
+        graph[b].push_back(a);
+    }
+
+    string a;
+    cin >> a;
+
+    array<int, 3> c = {0, 0, 0};
+    int ch = 0;
+
+    function<void(int, int)> dfs = [&](int i, int p) {
+        if (i != p && graph[i].size() == 1) {
+            if (a[i] == '?') {
+                c[2]++;
+                return;
+            }
+
+            c[a[i] - '0']++;
+            return;
+        }
+
+        if (a[i] == '?') {
+            ch++;
+        }
+
+        repv(j, graph[i]) {
+            if (j == p) {
+                continue;
+            }
+            dfs(j, i);
+        }
+    };
+
+    dfs(0, 0);
+
+    if (a[0] == '?') {
+        cout << max(max(c[0], c[1]) + c[2] / 2, min(c[0], c[1]) + (c[2] + (~ch & 1)) / 2) << '\n';
+        return;
+    }
+
+    int t = a[0] - '0';
+    cout << c[t^1] + (c[2] + 1) / 2 << '\n';
+}
+
+int main()
+{
+    ios::sync_with_stdio(false);
+    cin.tie(nullptr);
+
+    pre();
+
+    int t;
+    (TEST && cin >> t) || (t = 1);
+    while (t--) {
+        solve();
+    }
+}

Codeforces Round 969 (Div. 2)/C. Dora and C++.cpp

@@ -0,0 +1,130 @@
+/* Problem URL: https://codeforces.com/problemset/problem/2007/C */
+
+#include <bits/stdc++.h>
+#include <ext/pb_ds/assoc_container.hpp>
+#include <ext/pb_ds/tree_policy.hpp>
+
+using namespace std;
+using namespace __gnu_pbds;
+
+template <class T, class comp = less<>>
+using ordered_set = tree<T, null_type , comp , rb_tree_tag , tree_order_statistics_node_update>;
+
+#define V vector
+
+#define rmin(a, b) a = min(a, b)
+#define rmax(a, b) a = max(a, b)
+
+#define rep(i, lim) for (int i = 0; i < (lim); i++)
+#define nrep(i, s, lim) for (int i = s; i < (lim); i++)
+
+#define repv(i, v) for (auto &i : (v))
+#define fillv(v) for (auto &itr_ : (v)) { cin >> itr_; }
+#define sortv(v) sort(v.begin(), v.end())
+#define all(v) (v).begin(), (v).end()
+
+using vi = vector<int>;
+using vvi = vector<vi>;
+using vvvi = vector<vvi>;
+using vvvvi = vector<vvvi>;
+
+using ll = long long;
+
+using vl = vector<ll>;
+using vvl = vector<vl>;
+using vvvl = vector<vvl>;
+using vvvvl = vector<vvvl>;
+
+template<class v>
+auto operator<<(ostream &os, const vector<v> &vec)->ostream& {
+    os << vec[0];
+    for (size_t i = 1; i < vec.size(); i++) {
+        os << ' ' << vec[i];
+    }
+    os << '\n';
+    return os;
+}
+
+template<class v>
+auto operator>>(istream &is, vector<v> &vec)->istream& {
+    for (auto &i : vec) {
+        is >> i;
+    }
+    return is;
+}
+
+template<class v>
+auto operator<<(ostream &os, const vector<vector<v>> &vec)->ostream& {
+    for (auto &i : vec) {
+        os << i[0];
+        for (size_t j = 1; j < i.size(); j++) {
+            os << ' ' << i[j];
+        }
+        os << '\n';
+    }
+    return os;
+}
+
+template<class v>
+auto operator>>(istream  &is, vector<vector<v>> &vec)->istream& {
+    for (auto &i : vec) {
+        for (auto &j : i) {
+            is >> j;
+        }
+    }
+    return is;
+}
+
+const int oo = INT32_MAX >> 1;
+const ll OO = INT64_MAX >> 1;
+
+
+void pre()
+{
+
+}
+
+#define TEST 1
+
+void solve()
+{
+    int n;
+    ll a, b;
+    cin >> n >> a >> b;
+    ll g = gcd(a, b);
+
+    vl v(n);
+    repv(i, v) {
+        cin >> i;
+        i %= g;
+    }
+    sortv(v);
+    v.erase(unique(all(v)), v.end());
+
+    if (v.size() == 1) {
+        cout << "0\n";
+        return;
+    }
+
+    ll ans = v.back() - v[0];
+
+    nrep(i, 1, v.size()) {
+        rmin(ans, v[i - 1] + g - v[i]);
+    }
+
+    cout << ans << '\n';
+}
+
+int main()
+{
+    ios::sync_with_stdio(false);
+    cin.tie(nullptr);
+
+    pre();
+
+    int t;
+    (TEST && cin >> t) || (t = 1);
+    while (t--) {
+        solve();
+    }
+}

Codeforces Round 971 (Div. 4)/E. Klee's SUPER DUPER LARGE Array!!!.cpp

@@ -0,0 +1,132 @@
+/* Problem URL: https://codeforces.com/problemset/problem/2009/E */
+
+#include <bits/stdc++.h>
+#include <ext/pb_ds/assoc_container.hpp>
+#include <ext/pb_ds/tree_policy.hpp>
+
+using namespace std;
+using namespace __gnu_pbds;
+
+template <class T, class comp = less<>>
+using ordered_set = tree<T, null_type , comp , rb_tree_tag , tree_order_statistics_node_update>;
+
+#define V vector
+
+#define rmin(a, b) a = min(a, b)
+#define rmax(a, b) a = max(a, b)
+
+#define rep(i, lim) for (int i = 0; i < (lim); i++)
+#define nrep(i, s, lim) for (int i = s; i < (lim); i++)
+
+#define repv(i, v) for (auto &i : (v))
+#define fillv(v) for (auto &itr_ : (v)) { cin >> itr_; }
+#define sortv(v) sort(v.begin(), v.end())
+#define all(v) (v).begin(), (v).end()
+
+using vi = vector<int>;
+using vvi = vector<vi>;
+using vvvi = vector<vvi>;
+using vvvvi = vector<vvvi>;
+
+using ll = long long;
+
+using vl = vector<ll>;
+using vvl = vector<vl>;
+using vvvl = vector<vvl>;
+using vvvvl = vector<vvvl>;
+
+template<class v>
+auto operator<<(ostream &os, const vector<v> &vec)->ostream& {
+    os << vec[0];
+    for (size_t i = 1; i < vec.size(); i++) {
+        os << ' ' << vec[i];
+    }
+    os << '\n';
+    return os;
+}
+
+template<class v>
+auto operator>>(istream &is, vector<v> &vec)->istream& {
+    for (auto &i : vec) {
+        is >> i;
+    }
+    return is;
+}
+
+template<class v>
+auto operator<<(ostream &os, const vector<vector<v>> &vec)->ostream& {
+    for (auto &i : vec) {
+        os << i[0];
+        for (size_t j = 1; j < i.size(); j++) {
+            os << ' ' << i[j];
+        }
+        os << '\n';
+    }
+    return os;
+}
+
+template<class v>
+auto operator>>(istream  &is, vector<vector<v>> &vec)->istream& {
+    for (auto &i : vec) {
+        for (auto &j : i) {
+            is >> j;
+        }
+    }
+    return is;
+}
+
+const int oo = INT32_MAX >> 1;
+const ll OO = INT64_MAX >> 1;
+
+
+void pre()
+{
+
+}
+
+#define TEST 1
+
+void solve()
+{
+    ll n, k;
+    cin >> n >> k;
+
+    auto calc = [&](ll l, ll r) {
+        return (r - l + 1) * (l + r) / 2;
+    };
+
+    ll low = k;
+    ll high = k + n - 2;
+    ll ans = k;
+    while (low <= high) {
+        ll mid = (low + high) / 2;
+
+        ll f = calc(k, mid);
+        ll s = calc(mid + 1, k + n - 1);
+
+        ll a = f - s;
+        if (a <= 0) {
+            ans = mid;
+            low = mid + 1;
+            continue;
+        }
+
+        high = mid - 1;
+    }
+
+    cout << min(abs(calc(k, ans) - calc(ans + 1, k + n - 1)), abs(calc(k, ans + 1) - calc(ans + 2, k + n - 1))) << '\n';
+}
+
+int main()
+{
+    ios::sync_with_stdio(false);
+    cin.tie(nullptr);
+
+    pre();
+
+    int t;
+    (TEST && cin >> t) || (t = 1);
+    while (t--) {
+        solve();
+    }
+}

Codeforces Round 972 (Div. 2)/C. Lazy Narek.cpp

@@ -0,0 +1,156 @@
+/* Problem URL: https://codeforces.com/problemset/problem/2005/C */
+
+#include <bits/stdc++.h>
+#include <ext/pb_ds/assoc_container.hpp>
+#include <ext/pb_ds/tree_policy.hpp>
+
+using namespace std;
+using namespace __gnu_pbds;
+
+template <class T, class comp = less<>>
+using ordered_set = tree<T, null_type , comp , rb_tree_tag , tree_order_statistics_node_update>;
+
+#define V vector
+
+#define rmin(a, b) a = min(a, b)
+#define rmax(a, b) a = max(a, b)
+
+#define rep(i, lim) for (int i = 0; i < (lim); i++)
+#define nrep(i, s, lim) for (int i = s; i < (lim); i++)
+
+#define repv(i, v) for (auto &i : (v))
+#define fillv(v) for (auto &itr_ : (v)) { cin >> itr_; }
+#define sortv(v) sort(v.begin(), v.end())
+#define all(v) (v).begin(), (v).end()
+
+using vi = vector<int>;
+using vvi = vector<vi>;
+using vvvi = vector<vvi>;
+using vvvvi = vector<vvvi>;
+
+using ll = long long;
+
+using vl = vector<ll>;
+using vvl = vector<vl>;
+using vvvl = vector<vvl>;
+using vvvvl = vector<vvvl>;
+
+template<class v>
+auto operator<<(ostream &os, const vector<v> &vec)->ostream& {
+    os << vec[0];
+    for (size_t i = 1; i < vec.size(); i++) {
+        os << ' ' << vec[i];
+    }
+    os << '\n';
+    return os;
+}
+
+template<class v>
+auto operator>>(istream &is, vector<v> &vec)->istream& {
+    for (auto &i : vec) {
+        is >> i;
+    }
+    return is;
+}
+
+template<class v>
+auto operator<<(ostream &os, const vector<vector<v>> &vec)->ostream& {
+    for (auto &i : vec) {
+        os << i[0];
+        for (size_t j = 1; j < i.size(); j++) {
+            os << ' ' << i[j];
+        }
+        os << '\n';
+    }
+    return os;
+}
+
+template<class v>
+auto operator>>(istream  &is, vector<vector<v>> &vec)->istream& {
+    for (auto &i : vec) {
+        for (auto &j : i) {
+            is >> j;
+        }
+    }
+    return is;
+}
+
+const int oo = INT32_MAX >> 1;
+const ll OO = INT64_MAX >> 1;
+
+bool inv[256];
+
+void pre()
+{
+    inv['n'] = true;
+    inv['a'] = true;
+    inv['r'] = true;
+    inv['e'] = true;
+    inv['k'] = true;
+}
+
+#define TEST 1
+
+string fd = "narek";
+
+void solve()
+{
+    int n, m;
+    cin >> n >> m;
+
+    V<string> a(n);
+    cin >> a;
+
+
+    vvl memo(n, vl(5, -OO));
+
+    function<ll(int, int)> dp = [&](int i, int f) {
+        if (i >= n) {
+            return (ll)-f;
+        }
+
+        ll &ans = memo[i][f];
+        if (ans != -OO) {
+            return ans;
+        }
+
+        int pr = f;
+
+        ans = 0;
+        repv(j, a[i]) {
+            if (j == fd[f]) {
+                ans += 5 * (f == 4);
+                f = f + 1 - 5 * (f == 4);
+                continue;
+            }
+
+            ans -= inv[j];
+        }
+
+        ll tmp = -OO;
+        rmax(tmp, dp(i + 1, f));
+
+        return ans = max({ans + tmp, ans - f, dp(i + 1, pr)});
+    };
+
+    ll ans = 0;
+    rep(i, n) {
+        rmax(ans, dp(i, 0));
+    }
+
+    cout << ans << '\n';
+}
+
+int main()
+{
+    ios::sync_with_stdio(false);
+    cin.tie(nullptr);
+
+    pre();
+
+    int t;
+    (TEST && cin >> t) || (t = 1);
+    while (t--) {
+        solve();
+    }
+}

Codeforces Round 973 (Div. 2)/C. Password Cracking.cpp

@@ -0,0 +1,163 @@
+/* Problem URL: https://codeforces.com/problemset/problem/2013/C */
+
+#include <bits/stdc++.h>
+#include <ext/pb_ds/assoc_container.hpp>
+#include <ext/pb_ds/tree_policy.hpp>
+
+using namespace std;
+using namespace __gnu_pbds;
+
+template <class T, class comp = less<>>
+using ordered_set = tree<T, null_type , comp , rb_tree_tag , tree_order_statistics_node_update>;
+
+#define V vector
+
+#define rmin(a, b) a = min(a, b)
+#define rmax(a, b) a = max(a, b)
+
+#define rep(i, lim) for (int i = 0; i < (lim); i++)
+#define nrep(i, s, lim) for (int i = s; i < (lim); i++)
+
+#define repv(i, v) for (auto &i : (v))
+#define fillv(v) for (auto &itr_ : (v)) { cin >> itr_; }
+#define sortv(v) sort(v.begin(), v.end())
+#define all(v) (v).begin(), (v).end()
+
+using vi = vector<int>;
+using vvi = vector<vi>;
+using vvvi = vector<vvi>;
+using vvvvi = vector<vvvi>;
+
+using ll = long long;
+
+using vl = vector<ll>;
+using vvl = vector<vl>;
+using vvvl = vector<vvl>;
+using vvvvl = vector<vvvl>;
+
+template<class v>
+auto operator<<(ostream &os, const vector<v> &vec)->ostream& {
+    os << vec[0];
+    for (size_t i = 1; i < vec.size(); i++) {
+        os << ' ' << vec[i];
+    }
+    os << '\n';
+    return os;
+}
+
+template<class v>
+auto operator>>(istream &is, vector<v> &vec)->istream& {
+    for (auto &i : vec) {
+        is >> i;
+    }
+    return is;
+}
+
+template<class v>
+auto operator<<(ostream &os, const vector<vector<v>> &vec)->ostream& {
+    for (auto &i : vec) {
+        os << i[0];
+        for (size_t j = 1; j < i.size(); j++) {
+            os << ' ' << i[j];
+        }
+        os << '\n';
+    }
+    return os;
+}
+
+template<class v>
+auto operator>>(istream  &is, vector<vector<v>> &vec)->istream& {
+    for (auto &i : vec) {
+        for (auto &j : i) {
+            is >> j;
+        }
+    }
+    return is;
+}
+
+const int oo = INT32_MAX >> 1;
+const ll OO = INT64_MAX >> 1;
+
+
+void pre()
+{
+
+}
+
+#define TEST 1
+
+void solve()
+{
+    int n;
+    cin >> n;
+
+    auto ask = [&](string a) {
+        cout << "? " << a << endl;
+        int ans;
+        cin >> ans;
+        return ans;
+    };
+
+    auto answer = [&](string a) {
+        cout << "! " << a << endl;
+    };
+
+    if (n == 1) {
+        bool t = ask("0");
+        if (t) {
+            answer("0");
+        } else {
+            answer("1");
+        }
+        return;
+    }
+
+    string ans;
+    if (ask("0")) {
+        ans = "0";
+    } else {
+        ans = "1";
+    }
+
+    bool back = false;
+    rep(i, n - 1) {
+        if (back) {
+            if (ask("0" + ans)) {
+                ans = "0" + ans;
+                continue;
+            }
+
+            ans = "1" + ans;
+            continue;
+        }
+
+        if (ask(ans + "0")) {
+            ans += "0";
+            continue;
+        }
+
+        if (ask(ans + "1")) {
+            ans += "1";
+            continue;
+        }
+
+        back = true;
+        i--;
+    }
+
+    answer(ans);
+}
+
+int main()
+{
+    ios::sync_with_stdio(false);
+    cin.tie(nullptr);
+
+    pre();
+
+    int t;
+    (TEST && cin >> t) || (t = 1);
+    while (t--) {
+        solve();
+    }
+}

Codeforces Round 976 (Div. 2) and Divide By Zero 9.0/C. Bitwise Balancing.cpp

@@ -0,0 +1,139 @@
+/* Problem URL: https://codeforces.com/problemset/problem/2020/C */
+
+#include <bits/stdc++.h>
+#include <ext/pb_ds/assoc_container.hpp>
+#include <ext/pb_ds/tree_policy.hpp>
+
+using namespace std;
+using namespace __gnu_pbds;
+
+template <class T, class comp = less<>>
+using ordered_set = tree<T, null_type , comp , rb_tree_tag , tree_order_statistics_node_update>;
+
+#define V vector
+
+#define rmin(a, b) a = min(a, b)
+#define rmax(a, b) a = max(a, b)
+
+#define rep(i, lim) for (int i = 0; i < (lim); i++)
+#define nrep(i, s, lim) for (int i = s; i < (lim); i++)
+
+#define repv(i, v) for (auto &i : (v))
+#define fillv(v) for (auto &itr_ : (v)) { cin >> itr_; }
+#define sortv(v) sort(v.begin(), v.end())
+#define all(v) (v).begin(), (v).end()
+
+using vi = vector<int>;
+using vvi = vector<vi>;
+using vvvi = vector<vvi>;
+using vvvvi = vector<vvvi>;
+
+using ll = long long;
+
+using vl = vector<ll>;
+using vvl = vector<vl>;
+using vvvl = vector<vvl>;
+using vvvvl = vector<vvvl>;
+
+template<class v>
+auto operator<<(ostream &os, const vector<v> &vec)->ostream& {
+    os << vec[0];
+    for (size_t i = 1; i < vec.size(); i++) {
+        os << ' ' << vec[i];
+    }
+    os << '\n';
+    return os;
+}
+
+template<class v>
+auto operator>>(istream &is, vector<v> &vec)->istream& {
+    for (auto &i : vec) {
+        is >> i;
+    }
+    return is;
+}
+
+template<class v>
+auto operator<<(ostream &os, const vector<vector<v>> &vec)->ostream& {
+    for (auto &i : vec) {
+        os << i[0];
+        for (size_t j = 1; j < i.size(); j++) {
+            os << ' ' << i[j];
+        }
+        os << '\n';
+    }
+    return os;
+}
+
+template<class v>
+auto operator>>(istream  &is, vector<vector<v>> &vec)->istream& {
+    for (auto &i : vec) {
+        for (auto &j : i) {
+            is >> j;
+        }
+    }
+    return is;
+}
+
+const int oo = INT32_MAX >> 1;
+const ll OO = INT64_MAX >> 1;
+
+
+void pre()
+{
+
+}
+
+#define TEST 1
+
+void solve()
+{
+    ll b, c, d;
+    cin >> b >> c >> d;
+
+    ll ans = 0;
+    rep(i, 61) {
+        int bi = (b >> i) & 1;
+        int ci = (c >> i) & 1;
+        ll di = (d >> i) & 1;
+
+        if (bi && ci) {
+            ans |= (di^1) << i;
+            continue;
+        }
+
+        if (bi && !ci) {
+            if (!di) {
+                cout << "-1\n";
+                return;
+            }
+            continue;
+        }
+
+        if (!bi && ci) {
+            if (di) {
+                cout << "-1\n";
+                return;
+            }
+            continue;
+        }
+
+        ans |= di << i;
+    }
+    
+    cout << ans << '\n';
+}
+
+int main()
+{
+    ios::sync_with_stdio(false);
+    cin.tie(nullptr);
+
+    pre();
+
+    int t;
+    (TEST && cin >> t) || (t = 1);
+    while (t--) {
+        solve();
+    }
+}

Codeforces Round 981 (Div. 3)/F. Kosuke's Sloth.cpp

@@ -0,0 +1,127 @@
+/* Problem URL: https://codeforces.com/problemset/problem/2033/F */
+
+#include <bits/stdc++.h>
+#include <ext/pb_ds/assoc_container.hpp>
+#include <ext/pb_ds/tree_policy.hpp>
+
+using namespace std;
+using namespace __gnu_pbds;
+
+template <class T, class comp = less<>>
+using ordered_set = tree<T, null_type , comp , rb_tree_tag , tree_order_statistics_node_update>;
+
+#define V vector
+
+#define rmin(a, b) a = min(a, b)
+#define rmax(a, b) a = max(a, b)
+
+#define rep(i, lim) for (int i = 0; i < (lim); i++)
+#define nrep(i, s, lim) for (int i = s; i < (lim); i++)
+
+#define repv(i, v) for (auto &i : (v))
+#define fillv(v) for (auto &itr_ : (v)) { cin >> itr_; }
+#define sortv(v) sort(v.begin(), v.end())
+#define all(v) (v).begin(), (v).end()
+
+using vi = vector<int>;
+using vvi = vector<vi>;
+using vvvi = vector<vvi>;
+using vvvvi = vector<vvvi>;
+
+using ll = long long;
+
+using vl = vector<ll>;
+using vvl = vector<vl>;
+using vvvl = vector<vvl>;
+using vvvvl = vector<vvvl>;
+
+template<class v>
+auto operator<<(ostream &os, const vector<v> &vec)->ostream& {
+    os << vec[0];
+    for (size_t i = 1; i < vec.size(); i++) {
+        os << ' ' << vec[i];
+    }
+    os << '\n';
+    return os;
+}
+
+template<class v>
+auto operator>>(istream &is, vector<v> &vec)->istream& {
+    for (auto &i : vec) {
+        is >> i;
+    }
+    return is;
+}
+
+template<class v>
+auto operator<<(ostream &os, const vector<vector<v>> &vec)->ostream& {
+    for (auto &i : vec) {
+        os << i[0];
+        for (size_t j = 1; j < i.size(); j++) {
+            os << ' ' << i[j];
+        }
+        os << '\n';
+    }
+    return os;
+}
+
+template<class v>
+auto operator>>(istream  &is, vector<vector<v>> &vec)->istream& {
+    for (auto &i : vec) {
+        for (auto &j : i) {
+            is >> j;
+        }
+    }
+    return is;
+}
+
+const int oo = INT32_MAX >> 1;
+const ll OO = INT64_MAX >> 1;
+
+
+void pre()
+{
+
+}
+
+#define TEST 1
+
+void solve()
+{
+    ll n, k;
+    cin >> n >> k;
+    const ll mod = 1e9 + 7;
+    n %= mod;
+
+    if (k == 1) {
+        cout << n << '\n';
+        return;
+    }
+
+    ll cur = 2;
+    ll a = 1;
+    ll b = 1;
+
+    while (b % k != 0) {
+        ll c = b;
+        b = (a + b) % k;
+        a = c;
+        cur++;
+    }
+
+    cout << cur * n % mod << '\n';
+}
+
+int main()
+{
+    ios::sync_with_stdio(false);
+    cin.tie(nullptr);
+
+    pre();
+
+    int t;
+    (TEST && cin >> t) || (t = 1);
+    while (t--) {
+        solve();
+    }
+}

Codeforces Round 984 (Div. 3)/E. Reverse the Rivers.cpp

@@ -0,0 +1,180 @@
+/* Problem URL: https://codeforces.com/problemset/problem/2036/E */
+
+#include <bits/stdc++.h>
+#include <ext/pb_ds/assoc_container.hpp>
+#include <ext/pb_ds/tree_policy.hpp>
+
+using namespace std;
+using namespace __gnu_pbds;
+
+template <class T, class comp = less<>>
+using ordered_set = tree<T, null_type , comp , rb_tree_tag , tree_order_statistics_node_update>;
+
+#define V vector
+
+#define rmin(a, b) a = min(a, b)
+#define rmax(a, b) a = max(a, b)
+
+#define rep(i, lim) for (int i = 0; i < (lim); i++)
+#define nrep(i, s, lim) for (int i = s; i < (lim); i++)
+
+#define repv(i, v) for (auto &i : (v))
+#define fillv(v) for (auto &itr_ : (v)) { cin >> itr_; }
+#define sortv(v) sort(v.begin(), v.end())
+#define all(v) (v).begin(), (v).end()
+
+using vi = vector<int>;
+using vvi = vector<vi>;
+using vvvi = vector<vvi>;
+using vvvvi = vector<vvvi>;
+
+using ll = long long;
+
+using vl = vector<ll>;
+using vvl = vector<vl>;
+using vvvl = vector<vvl>;
+using vvvvl = vector<vvvl>;
+
+template<class v>
+auto operator<<(ostream &os, const vector<v> &vec)->ostream& {
+    os << vec[0];
+    for (size_t i = 1; i < vec.size(); i++) {
+        os << ' ' << vec[i];
+    }
+    os << '\n';
+    return os;
+}
+
+template<class v>
+auto operator>>(istream &is, vector<v> &vec)->istream& {
+    for (auto &i : vec) {
+        is >> i;
+    }
+    return is;
+}
+
+template<class v>
+auto operator<<(ostream &os, const vector<vector<v>> &vec)->ostream& {
+    for (auto &i : vec) {
+        os << i[0];
+        for (size_t j = 1; j < i.size(); j++) {
+            os << ' ' << i[j];
+        }
+        os << '\n';
+    }
+    return os;
+}
+
+template<class v>
+auto operator>>(istream  &is, vector<vector<v>> &vec)->istream& {
+    for (auto &i : vec) {
+        for (auto &j : i) {
+            is >> j;
+        }
+    }
+    return is;
+}
+
+const int oo = INT32_MAX >> 1;
+const ll OO = INT64_MAX >> 1;
+
+
+void pre()
+{
+
+}
+
+#define TEST 0
+
+void solve()
+{
+    int n, m, q;
+    cin >> n >> m >> q;
+
+    vvl a(n, vl(m));
+    cin >> a;
+
+    rep(j, m) {
+        nrep(i, 1, n) {
+            a[i][j] |= a[i - 1][j];
+        }
+    }
+
+    while (q--) {
+        int l = 0;
+        int r = n - 1;
+
+        int q;
+        cin >> q;
+        while (q--) {
+            int p;
+            char op;
+            ll c;
+            cin >> p >> op >> c;
+            p--;
+
+            auto findl = [&]() {
+                int low = l;
+                int high = n - 1;
+                int ans = n;
+                while (low <= high) {
+                    int mid = (low + high) >> 1;
+
+                    if (a[mid][p] > c) {
+                        ans = mid;
+                        high = mid - 1;
+                        continue;
+                    }
+
+                    low = mid + 1;
+                }
+                return ans;
+            };
+
+            auto findr = [&]() {
+                int low = 0;
+                int high = r;
+                int ans = -1;
+                while (low <= high) {
+                    int mid = (low + high) >> 1;
+
+                    if (a[mid][p] < c) {
+                        ans = mid;
+                        low = mid + 1;
+                        continue;
+                    }
+
+                    high = mid - 1;
+                }
+                return ans;
+            };
+
+            if (op == '>') {
+                l = findl();
+            } else {
+                r = findr();
+            }
+        }
+
+        if (l > r) {
+            cout << "-1\n";
+            continue;
+        }
+
+        cout << l + 1 << '\n';
+    }
+}
+
+int main()
+{
+    ios::sync_with_stdio(false);
+    cin.tie(nullptr);
+
+    pre();
+
+    int t;
+    (TEST && cin >> t) || (t = 1);
+    while (t--) {
+        solve();
+    }
+}

Codeforces Round 993 (Div. 4)/G1. Medium Demon Problem (easy version).cpp

@@ -0,0 +1,169 @@
+/* Problem URL: https://codeforces.com/problemset/problem/2044/G1 */
+
+#include <bits/stdc++.h>
+#include <ext/pb_ds/assoc_container.hpp>
+#include <ext/pb_ds/tree_policy.hpp>
+
+using namespace std;
+using namespace __gnu_pbds;
+
+template <class T, class comp = less<>>
+using ordered_set = tree<T, null_type , comp , rb_tree_tag , tree_order_statistics_node_update>;
+
+#define V vector
+
+#define rmin(a, b) a = min(a, b)
+#define rmax(a, b) a = max(a, b)
+
+#define rep(i, lim) for (int i = 0; i < (lim); i++)
+#define nrep(i, s, lim) for (int i = s; i < (lim); i++)
+
+#define repv(i, v) for (auto &i : (v))
+#define fillv(v) for (auto &itr_ : (v)) { cin >> itr_; }
+#define sortv(v) sort(v.begin(), v.end())
+#define all(v) (v).begin(), (v).end()
+
+using vi = vector<int>;
+using vvi = vector<vi>;
+using vvvi = vector<vvi>;
+using vvvvi = vector<vvvi>;
+
+using ll = long long;
+
+using vl = vector<ll>;
+using vvl = vector<vl>;
+using vvvl = vector<vvl>;
+using vvvvl = vector<vvvl>;
+
+template<class v>
+auto operator<<(ostream &os, const vector<v> &vec)->ostream& {
+    os << vec[0];
+    for (size_t i = 1; i < vec.size(); i++) {
+        os << ' ' << vec[i];
+    }
+    os << '\n';
+    return os;
+}
+
+template<class v>
+auto operator>>(istream &is, vector<v> &vec)->istream& {
+    for (auto &i : vec) {
+        is >> i;
+    }
+    return is;
+}
+
+template<class v>
+auto operator<<(ostream &os, const vector<vector<v>> &vec)->ostream& {
+    for (auto &i : vec) {
+        os << i[0];
+        for (size_t j = 1; j < i.size(); j++) {
+            os << ' ' << i[j];
+        }
+        os << '\n';
+    }
+    return os;
+}
+
+template<class v>
+auto operator>>(istream  &is, vector<vector<v>> &vec)->istream& {
+    for (auto &i : vec) {
+        for (auto &j : i) {
+            is >> j;
+        }
+    }
+    return is;
+}
+
+const int oo = INT32_MAX >> 1;
+const ll OO = INT64_MAX >> 1;
+
+
+void pre()
+{
+
+}
+
+#define TEST 1
+
+void solve()
+{
+    int n;
+    cin >> n;
+    vi p(n);
+    repv(i, p) {
+        cin >> i;
+        i--;
+    }
+
+    V<bool> vis(n);
+    V<bool> loop(n);
+
+    function<void(int)> getloop = [&](int i) {
+        vis[i] = true;
+        int t = p[i];
+        int h = p[t];
+
+        while (t != h) {
+            if (vis[t]) {
+                return;
+            }
+
+            vis[t] = true;
+
+            t = p[t];
+            h = p[p[h]];
+        }
+
+        vis[t] = true;
+        loop[t] = true;
+        h = p[h];
+        while (h != t) {
+            loop[h] = true;
+            vis[h] = true;
+            h = p[h];
+        }
+    };
+
+    rep(i, n) {
+        if (vis[i]) {
+            continue;
+        }
+
+        getloop(i);
+    }
+
+    vi ans(n, -1);
+
+    function<int(int)> dfs = [&](int i) {
+        if (loop[i]) {
+            return ans[i] = 0;
+        }
+
+        if (ans[i] != -1) {
+            return ans[i];
+        }
+
+        return ans[i] = dfs(p[i]) + 1;
+    };
+
+    rep(i, n) {
+        dfs(i);
+    }
+
+    cout << *max_element(all(ans)) + 2 << '\n';
+}
+
+int main()
+{
+    ios::sync_with_stdio(false);
+    cin.tie(nullptr);
+
+    pre();
+
+    int t;
+    (TEST && cin >> t) || (t = 1);
+    while (t--) {
+        solve();
+    }
+}

Codeforces Round 993 (Div. 4)/G2. Medium Demon Problem (hard version).cpp

@@ -0,0 +1,181 @@
+/* Problem URL: https://codeforces.com/problemset/problem/2044/G2 */
+
+#include <bits/stdc++.h>
+#include <ext/pb_ds/assoc_container.hpp>
+#include <ext/pb_ds/tree_policy.hpp>
+
+using namespace std;
+using namespace __gnu_pbds;
+
+template <class T, class comp = less<>>
+using ordered_set = tree<T, null_type , comp , rb_tree_tag , tree_order_statistics_node_update>;
+
+#define V vector
+
+#define rmin(a, b) a = min(a, b)
+#define rmax(a, b) a = max(a, b)
+
+#define rep(i, lim) for (int i = 0; i < (lim); i++)
+#define nrep(i, s, lim) for (int i = s; i < (lim); i++)
+
+#define repv(i, v) for (auto &i : (v))
+#define fillv(v) for (auto &itr_ : (v)) { cin >> itr_; }
+#define sortv(v) sort(v.begin(), v.end())
+#define all(v) (v).begin(), (v).end()
+
+using vi = vector<int>;
+using vvi = vector<vi>;
+using vvvi = vector<vvi>;
+using vvvvi = vector<vvvi>;
+
+using ll = long long;
+
+using vl = vector<ll>;
+using vvl = vector<vl>;
+using vvvl = vector<vvl>;
+using vvvvl = vector<vvvl>;
+
+template<class v>
+auto operator<<(ostream &os, const vector<v> &vec)->ostream& {
+    os << vec[0];
+    for (size_t i = 1; i < vec.size(); i++) {
+        os << ' ' << vec[i];
+    }
+    os << '\n';
+    return os;
+}
+
+template<class v>
+auto operator>>(istream &is, vector<v> &vec)->istream& {
+    for (auto &i : vec) {
+        is >> i;
+    }
+    return is;
+}
+
+template<class v>
+auto operator<<(ostream &os, const vector<vector<v>> &vec)->ostream& {
+    for (auto &i : vec) {
+        os << i[0];
+        for (size_t j = 1; j < i.size(); j++) {
+            os << ' ' << i[j];
+        }
+        os << '\n';
+    }
+    return os;
+}
+
+template<class v>
+auto operator>>(istream  &is, vector<vector<v>> &vec)->istream& {
+    for (auto &i : vec) {
+        for (auto &j : i) {
+            is >> j;
+        }
+    }
+    return is;
+}
+
+const int oo = INT32_MAX >> 1;
+const ll OO = INT64_MAX >> 1;
+
+
+void pre()
+{
+
+}
+
+#define TEST 1
+
+void solve()
+{
+    int n;
+    cin >> n;
+    vi p(n);
+    vvi rev(n);
+    rep(i, n) {
+        cin >> p[i];
+        p[i]--;
+        rev[p[i]].push_back(i);
+    }
+
+    V<bool> vis(n);
+    V<bool> loop(n);
+    vvi ne(20, vi(n, -1));
+
+    rep(i, n) {
+        ne[0][i] = p[i];
+    }
+
+    function<void(int)> getloop = [&](int i) {
+        vis[i] = true;
+        int t = p[i];
+        int h = p[t];
+
+        while (t != h) {
+            if (vis[t]) {
+                return;
+            }
+
+            vis[t] = true;
+
+            t = p[t];
+            h = p[p[h]];
+        }
+
+        vis[t] = true;
+        loop[t] = true;
+        h = p[h];
+        while (h != t) {
+            loop[h] = true;
+            vis[h] = true;
+            h = p[h];
+        }
+    };
+
+    rep(i, n) {
+        if (vis[i]) {
+            continue;
+        }
+
+        getloop(i);
+    }
+
+    ll ans = 0;
+    function<ll(int)> dfs = [&](int i) {
+        ll ans = 1;
+        repv(j, rev[i]) {
+            ans += dfs(j);
+        }
+        return ans;
+    };
+
+    rep(i, n) {
+        if (!loop[i]) {
+            continue;
+        }
+
+        repv(j, rev[i]) {
+            if (loop[j]) {
+                continue;
+            }
+
+            rmax(ans, dfs(j));
+        }
+    }
+
+    cout << ans + 2 << '\n';
+}
+
+int main()
+{
+    ios::sync_with_stdio(false);
+    cin.tie(nullptr);
+
+    pre();
+
+    int t;
+    (TEST && cin >> t) || (t = 1);
+    while (t--) {
+        solve();
+    }
+}

Codeforces Round 996 (Div. 2)/C. The Trail.cpp

@@ -0,0 +1,156 @@
+/* Problem URL: https://codeforces.com/problemset/problem/2055/C */
+
+#include <bits/stdc++.h>
+#include <ext/pb_ds/assoc_container.hpp>
+#include <ext/pb_ds/tree_policy.hpp>
+
+using namespace std;
+using namespace __gnu_pbds;
+
+template <class T, class comp = less<>>
+using ordered_set = tree<T, null_type , comp , rb_tree_tag , tree_order_statistics_node_update>;
+
+#define V vector
+
+#define rmin(a, b) a = min(a, b)
+#define rmax(a, b) a = max(a, b)
+
+#define rep(i, lim) for (int i = 0; i < (lim); i++)
+#define nrep(i, s, lim) for (int i = s; i < (lim); i++)
+
+#define repv(i, v) for (auto &i : (v))
+#define fillv(v) for (auto &itr_ : (v)) { cin >> itr_; }
+#define sortv(v) sort(v.begin(), v.end())
+#define all(v) (v).begin(), (v).end()
+
+using vi = vector<int>;
+using vvi = vector<vi>;
+using vvvi = vector<vvi>;
+using vvvvi = vector<vvvi>;
+
+using ll = long long;
+
+using vl = vector<ll>;
+using vvl = vector<vl>;
+using vvvl = vector<vvl>;
+using vvvvl = vector<vvvl>;
+
+template<class v>
+auto operator<<(ostream &os, const vector<v> &vec)->ostream& {
+    os << vec[0];
+    for (size_t i = 1; i < vec.size(); i++) {
+        os << ' ' << vec[i];
+    }
+    os << '\n';
+    return os;
+}
+
+template<class v>
+auto operator>>(istream &is, vector<v> &vec)->istream& {
+    for (auto &i : vec) {
+        is >> i;
+    }
+    return is;
+}
+
+template<class v>
+auto operator<<(ostream &os, const vector<vector<v>> &vec)->ostream& {
+    for (auto &i : vec) {
+        os << i[0];
+        for (size_t j = 1; j < i.size(); j++) {
+            os << ' ' << i[j];
+        }
+        os << '\n';
+    }
+    return os;
+}
+
+template<class v>
+auto operator>>(istream  &is, vector<vector<v>> &vec)->istream& {
+    for (auto &i : vec) {
+        for (auto &j : i) {
+            is >> j;
+        }
+    }
+    return is;
+}
+
+const int oo = INT32_MAX >> 1;
+const ll OO = INT64_MAX >> 1;
+
+
+void pre()
+{
+
+}
+
+#define TEST 1
+
+void solve()
+{
+    int n, m;
+    cin >> n >> m;
+
+    string s;
+    cin >> s;
+
+    vvl a(n, vl(m));
+    cin >> a;
+
+    vvl ss(2);
+    ss[0].resize(n);
+    ss[1].resize(m);
+
+    rep(i, n) {
+        rep(j, m) {
+            ss[0][i] += a[i][j];
+            ss[1][j] += a[i][j];
+        }
+    }
+
+    int i = s[0] == 'D';
+    int j = s[0] == 'R';
+    a[0][0] = s[0] == 'D' ? -ss[0][0] : -ss[1][0];
+    ss[0][0] += a[0][0];
+    ss[1][0] += a[0][0];
+    ll ch = 0;
+    while (i < n - 1 || j < m - 1) {
+        // int pi = i - (s[i + j - 1] == 'D');
+        // int pj = j - (s[i + j - 1] == 'R');
+
+        // int ch = s[pi + pj] == 'R';
+        if (s[i + j] == 'R') {
+            ll s = ss[1][j];
+            a[i][j] = -s;
+            ss[0][i] -= s;
+            ss[1][j] -= s;
+            j++;
+            continue;
+        }
+
+        ll s = ss[0][i];
+        a[i][j] = -s;
+        ss[0][i] -= s;
+        ss[1][j] -= s;
+        i++;
+    }
+
+    ll diff = ss[0][n - 1];
+    a[n - 1][m - 1] = -diff;
+
+    cout << a;
+}
+
+int main()
+{
+    ios::sync_with_stdio(false);
+    cin.tie(nullptr);
+
+    pre();
+
+    int t;
+    (TEST && cin >> t) || (t = 1);
+    while (t--) {
+        solve();
+    }
+}

Educational Codeforces Round 142 (Rated for Div. 2)/C. Min Max Sort.cpp

@@ -0,0 +1,127 @@
+/* Problem URL: https://codeforces.com/problemset/problem/1792/C */
+
+#include <bits/stdc++.h>
+#include <ext/pb_ds/assoc_container.hpp>
+#include <ext/pb_ds/tree_policy.hpp>
+
+using namespace std;
+using namespace __gnu_pbds;
+
+template <class T, class comp = less<>>
+using ordered_set = tree<T, null_type , comp , rb_tree_tag , tree_order_statistics_node_update>;
+
+#define V vector
+
+#define rmin(a, b) a = min(a, b)
+#define rmax(a, b) a = max(a, b)
+
+#define rep(i, lim) for (int i = 0; i < (lim); i++)
+#define nrep(i, s, lim) for (int i = s; i < (lim); i++)
+
+#define repv(i, v) for (auto &i : (v))
+#define fillv(v) for (auto &itr_ : (v)) { cin >> itr_; }
+#define sortv(v) sort(v.begin(), v.end())
+#define all(v) (v).begin(), (v).end()
+
+using vi = vector<int>;
+using vvi = vector<vi>;
+using vvvi = vector<vvi>;
+using vvvvi = vector<vvvi>;
+
+using ll = long long;
+
+using vl = vector<ll>;
+using vvl = vector<vl>;
+using vvvl = vector<vvl>;
+using vvvvl = vector<vvvl>;
+
+template<class v>
+auto operator<<(ostream &os, const vector<v> &vec)->ostream& {
+    os << vec[0];
+    for (size_t i = 1; i < vec.size(); i++) {
+        os << ' ' << vec[i];
+    }
+    os << '\n';
+    return os;
+}
+
+template<class v>
+auto operator>>(istream &is, vector<v> &vec)->istream& {
+    for (auto &i : vec) {
+        is >> i;
+    }
+    return is;
+}
+
+template<class v>
+auto operator<<(ostream &os, const vector<vector<v>> &vec)->ostream& {
+    for (auto &i : vec) {
+        os << i[0];
+        for (size_t j = 1; j < i.size(); j++) {
+            os << ' ' << i[j];
+        }
+        os << '\n';
+    }
+    return os;
+}
+
+template<class v>
+auto operator>>(istream  &is, vector<vector<v>> &vec)->istream& {
+    for (auto &i : vec) {
+        for (auto &j : i) {
+            is >> j;
+        }
+    }
+    return is;
+}
+
+const int oo = INT32_MAX >> 1;
+const ll OO = INT64_MAX >> 1;
+
+
+void pre()
+{
+
+}
+
+#define TEST 1
+
+void solve()
+{
+    int n;
+    cin >> n;
+    vi p(n);
+    cin >> p;
+    vi pos(n);
+    rep(i, n) {
+        pos[p[i] - 1] = i;
+    }
+
+    int ans = n - 1;
+
+    int l = 0;
+    int ma = pos[0];
+    nrep(i, 1, n) {
+        if (pos[i] < pos[i - 1]) {
+            l = i;
+        }
+
+        rmin(ans, max(l, n - i - 1));
+    }
+
+    cout << ans << '\n';
+}
+
+int main()
+{
+    ios::sync_with_stdio(false);
+    cin.tie(nullptr);
+
+    pre();
+
+    int t;
+    (TEST && cin >> t) || (t = 1);
+    while (t--) {
+        solve();
+    }
+}

Educational Codeforces Round 143 (Rated for Div. 2)/D. Triangle Coloring.cpp

@@ -0,0 +1,156 @@
+/* Problem URL: https://codeforces.com/problemset/problem/1795/D */
+
+#include <bits/stdc++.h>
+#include <ext/pb_ds/assoc_container.hpp>
+#include <ext/pb_ds/tree_policy.hpp>
+
+using namespace std;
+using namespace __gnu_pbds;
+
+template <class T, class comp = less<>>
+using ordered_set = tree<T, null_type , comp , rb_tree_tag , tree_order_statistics_node_update>;
+
+#define V vector
+
+#define rmin(a, b) a = min(a, b)
+#define rmax(a, b) a = max(a, b)
+
+#define rep(i, lim) for (int i = 0; i < (lim); i++)
+#define nrep(i, s, lim) for (int i = s; i < (lim); i++)
+
+#define repv(i, v) for (auto &i : (v))
+#define fillv(v) for (auto &itr_ : (v)) { cin >> itr_; }
+#define sortv(v) sort(v.begin(), v.end())
+#define all(v) (v).begin(), (v).end()
+
+using vi = vector<int>;
+using vvi = vector<vi>;
+using vvvi = vector<vvi>;
+using vvvvi = vector<vvvi>;
+
+using ll = long long;
+
+using vl = vector<ll>;
+using vvl = vector<vl>;
+using vvvl = vector<vvl>;
+using vvvvl = vector<vvvl>;
+
+template<class v>
+auto operator<<(ostream &os, const vector<v> &vec)->ostream& {
+    os << vec[0];
+    for (size_t i = 1; i < vec.size(); i++) {
+        os << ' ' << vec[i];
+    }
+    os << '\n';
+    return os;
+}
+
+template<class v>
+auto operator>>(istream &is, vector<v> &vec)->istream& {
+    for (auto &i : vec) {
+        is >> i;
+    }
+    return is;
+}
+
+template<class v>
+auto operator<<(ostream &os, const vector<vector<v>> &vec)->ostream& {
+    for (auto &i : vec) {
+        os << i[0];
+        for (size_t j = 1; j < i.size(); j++) {
+            os << ' ' << i[j];
+        }
+        os << '\n';
+    }
+    return os;
+}
+
+template<class v>
+auto operator>>(istream  &is, vector<vector<v>> &vec)->istream& {
+    for (auto &i : vec) {
+        for (auto &j : i) {
+            is >> j;
+        }
+    }
+    return is;
+}
+
+const int oo = INT32_MAX >> 1;
+const ll OO = INT64_MAX >> 1;
+
+
+void pre()
+{
+
+}
+
+#define TEST 0
+
+void solve()
+{
+    int n;
+    cin >> n;
+    vl a(n);
+    cin >> a;
+
+    const ll mod = 998244353;
+    ll mul = 1;
+    for (int i = 0; i < n; i += 3) {
+        ll ma = *max_element(a.begin() + i, a.begin() + i + 3);
+        ll mi = *min_element(a.begin() + i, a.begin() + i + 3);
+
+        int ca = count(a.begin() + i, a.begin() + i + 3, ma);
+        int ci = count(a.begin() + i, a.begin() + i + 3, mi);
+
+        if (ca == 3) {
+            (mul *= 3) %= mod;
+            continue;
+        }
+
+        if (ca == 2) {
+            continue;
+        }
+
+        if (ci == 2) {
+            (mul *= 2) %= mod;
+        }
+    }
+
+    auto fpow = [&](ll a, ll p) {
+        ll ans = 1;
+
+        rep(i, 61) {
+            if ((p >> i) & 1) {
+                (ans *= a) %= mod;
+            }
+            (a *= a) %= mod;
+        }
+
+        return ans;
+    };
+
+    vl fact(n + 1);
+
+    fact[0] = 1;
+    nrep(i, 1, n + 1) {
+        fact[i] = fact[i - 1] * i % mod;
+    }
+
+    n /= 3;
+    ll comb = fact[n] * fpow(fact[n / 2], mod - 2) % mod * fpow(fact[n / 2], mod - 2) % mod;
+    cout << mul * comb % mod << '\n';
+}
+
+int main()
+{
+    ios::sync_with_stdio(false);
+    cin.tie(nullptr);
+
+    pre();
+
+    int t;
+    (TEST && cin >> t) || (t = 1);
+    while (t--) {
+        solve();
+    }
+}

Educational Codeforces Round 144 (Rated for Div. 2)/D. Maximum Subarray.cpp

@@ -0,0 +1,147 @@
+/* Problem URL: https://codeforces.com/problemset/problem/1796/D */
+
+#include <bits/stdc++.h>
+#include <ext/pb_ds/assoc_container.hpp>
+#include <ext/pb_ds/tree_policy.hpp>
+
+using namespace std;
+using namespace __gnu_pbds;
+
+template <class T, class comp = less<>>
+using ordered_set = tree<T, null_type , comp , rb_tree_tag , tree_order_statistics_node_update>;
+
+#define V vector
+
+#define rmin(a, b) a = min(a, b)
+#define rmax(a, b) a = max(a, b)
+
+#define rep(i, lim) for (int i = 0; i < (lim); i++)
+#define nrep(i, s, lim) for (int i = s; i < (lim); i++)
+
+#define repv(i, v) for (auto &i : (v))
+#define fillv(v) for (auto &itr_ : (v)) { cin >> itr_; }
+#define sortv(v) sort(v.begin(), v.end())
+#define all(v) (v).begin(), (v).end()
+
+using vi = vector<int>;
+using vvi = vector<vi>;
+using vvvi = vector<vvi>;
+using vvvvi = vector<vvvi>;
+
+using ll = long long;
+
+using vl = vector<ll>;
+using vvl = vector<vl>;
+using vvvl = vector<vvl>;
+using vvvvl = vector<vvvl>;
+
+template<class v>
+auto operator<<(ostream &os, const vector<v> &vec)->ostream& {
+    os << vec[0];
+    for (size_t i = 1; i < vec.size(); i++) {
+        os << ' ' << vec[i];
+    }
+    os << '\n';
+    return os;
+}
+
+template<class v>
+auto operator>>(istream &is, vector<v> &vec)->istream& {
+    for (auto &i : vec) {
+        is >> i;
+    }
+    return is;
+}
+
+template<class v>
+auto operator<<(ostream &os, const vector<vector<v>> &vec)->ostream& {
+    for (auto &i : vec) {
+        os << i[0];
+        for (size_t j = 1; j < i.size(); j++) {
+            os << ' ' << i[j];
+        }
+        os << '\n';
+    }
+    return os;
+}
+
+template<class v>
+auto operator>>(istream  &is, vector<vector<v>> &vec)->istream& {
+    for (auto &i : vec) {
+        for (auto &j : i) {
+            is >> j;
+        }
+    }
+    return is;
+}
+
+const int oo = INT32_MAX >> 1;
+const ll OO = INT64_MAX >> 1;
+
+
+void pre()
+{
+
+}
+
+#define TEST 1
+
+constexpr int MAXN = 2e5 + 10;
+constexpr int MAXK = 30;
+ll memo[MAXN][MAXK][4];
+
+void solve()
+{
+    int n, k;
+    ll x;
+    cin >> n >> k >> x;
+
+    vl a(n);
+    cin >> a;
+
+    ll otinf = -OO / 4;
+    vvvl memo(n, vvl(k + 1, vl(3, -OO)));
+
+    function<ll(int, int, int)> dp = [&](int i, int j, int s) {
+        if (j > k) {
+            return otinf;
+        }
+
+        if (i >= n) {
+            return j == k ? 0LL : otinf;
+        }
+
+        ll &ans = memo[i][j][s];
+        if (ans != -OO) {
+            return ans;
+        }
+
+        if (s == 0) {
+            return ans = max({dp(i + 1, j, 0), dp(i + 1, j + 1, 0),
+                             dp(i + 1, j + 1, 1) + a[i] + x, dp(i + 1, j, 1) + a[i] - x});
+        }
+
+        if (s == 1) {
+            return ans = max({dp(i + 1, j, 1) + a[i] - x, dp(i + 1, j + 1, 1) + a[i] + x,
+                             dp(i + 1, j, 2), dp(i + 1, j + 1, 2)});
+        }
+
+        return ans = max(dp(i + 1, j + 1, 2), dp(i + 1, j, 2));
+    };
+
+    cout << dp(0, 0, 0) << '\n';
+}
+
+int main()
+{
+    ios::sync_with_stdio(false);
+    cin.tie(nullptr);
+
+    pre();
+
+    int t;
+    (TEST && cin >> t) || (t = 1);
+    while (t--) {
+        solve();
+    }
+}

Educational Codeforces Round 153 (Rated for Div. 2)/C. Game on Permutation.cpp

@@ -0,0 +1,127 @@
+/* Problem URL: https://codeforces.com/problemset/problem/1860/C */
+
+#include <bits/stdc++.h>
+#include <ext/pb_ds/assoc_container.hpp>
+#include <ext/pb_ds/tree_policy.hpp>
+
+using namespace std;
+using namespace __gnu_pbds;
+
+template <class T, class comp = less<>>
+using ordered_set = tree<T, null_type , comp , rb_tree_tag , tree_order_statistics_node_update>;
+
+#define V vector
+
+#define rmin(a, b) a = min(a, b)
+#define rmax(a, b) a = max(a, b)
+
+#define rep(i, lim) for (int i = 0; i < (lim); i++)
+#define nrep(i, s, lim) for (int i = s; i < (lim); i++)
+
+#define repv(i, v) for (auto &i : (v))
+#define fillv(v) for (auto &itr_ : (v)) { cin >> itr_; }
+#define sortv(v) sort(v.begin(), v.end())
+#define all(v) (v).begin(), (v).end()
+
+using vi = vector<int>;
+using vvi = vector<vi>;
+using vvvi = vector<vvi>;
+using vvvvi = vector<vvvi>;
+
+using ll = long long;
+
+using vl = vector<ll>;
+using vvl = vector<vl>;
+using vvvl = vector<vvl>;
+using vvvvl = vector<vvvl>;
+
+template<class v>
+auto operator<<(ostream &os, const vector<v> &vec)->ostream& {
+    os << vec[0];
+    for (size_t i = 1; i < vec.size(); i++) {
+        os << ' ' << vec[i];
+    }
+    os << '\n';
+    return os;
+}
+
+template<class v>
+auto operator>>(istream &is, vector<v> &vec)->istream& {
+    for (auto &i : vec) {
+        is >> i;
+    }
+    return is;
+}
+
+template<class v>
+auto operator<<(ostream &os, const vector<vector<v>> &vec)->ostream& {
+    for (auto &i : vec) {
+        os << i[0];
+        for (size_t j = 1; j < i.size(); j++) {
+            os << ' ' << i[j];
+        }
+        os << '\n';
+    }
+    return os;
+}
+
+template<class v>
+auto operator>>(istream  &is, vector<vector<v>> &vec)->istream& {
+    for (auto &i : vec) {
+        for (auto &j : i) {
+            is >> j;
+        }
+    }
+    return is;
+}
+
+const int oo = INT32_MAX >> 1;
+const ll OO = INT64_MAX >> 1;
+
+
+void pre()
+{
+
+}
+
+#define TEST 1
+
+void solve()
+{
+    int n;
+    cin >> n;
+    vi p(n);
+    cin >> p;
+
+    int ans = 0;
+    vi lis;
+    rep(i, n) {
+        auto itr = lower_bound(all(lis), p[i]);
+        int pos;
+        if (itr == lis.end()) {
+            lis.push_back(p[i]);
+            pos = lis.size() - 1;
+        } else {
+            *itr = p[i];
+            pos = itr - lis.begin();
+        }
+
+        ans += pos == 1;
+    }
+
+    cout << ans << '\n';
+}
+
+int main()
+{
+    ios::sync_with_stdio(false);
+    cin.tie(nullptr);
+
+    pre();
+
+    int t;
+    (TEST && cin >> t) || (t = 1);
+    while (t--) {
+        solve();
+    }
+}

Educational Codeforces Round 157 (Rated for Div. 2)/C. Torn Lucky Ticket.cpp

@@ -0,0 +1,163 @@
+/* Problem URL: https://codeforces.com/problemset/problem/1895/C */
+
+#include <bits/stdc++.h>
+#include <ext/pb_ds/assoc_container.hpp>
+#include <ext/pb_ds/tree_policy.hpp>
+
+using namespace std;
+using namespace __gnu_pbds;
+
+template <class T, class comp = less<>>
+using ordered_set = tree<T, null_type , comp , rb_tree_tag , tree_order_statistics_node_update>;
+
+#define V vector
+
+#define rmin(a, b) a = min(a, b)
+#define rmax(a, b) a = max(a, b)
+
+#define rep(i, lim) for (int i = 0; i < (lim); i++)
+#define nrep(i, s, lim) for (int i = s; i < (lim); i++)
+
+#define repv(i, v) for (auto &i : (v))
+#define fillv(v) for (auto &itr_ : (v)) { cin >> itr_; }
+#define sortv(v) sort(v.begin(), v.end())
+#define all(v) (v).begin(), (v).end()
+
+using vi = vector<int>;
+using vvi = vector<vi>;
+using vvvi = vector<vvi>;
+using vvvvi = vector<vvvi>;
+
+using ll = long long;
+
+using vl = vector<ll>;
+using vvl = vector<vl>;
+using vvvl = vector<vvl>;
+using vvvvl = vector<vvvl>;
+
+template<class v>
+auto operator<<(ostream &os, const vector<v> &vec)->ostream& {
+    os << vec[0];
+    for (size_t i = 1; i < vec.size(); i++) {
+        os << ' ' << vec[i];
+    }
+    os << '\n';
+    return os;
+}
+
+template<class v>
+auto operator>>(istream &is, vector<v> &vec)->istream& {
+    for (auto &i : vec) {
+        is >> i;
+    }
+    return is;
+}
+
+template<class v>
+auto operator<<(ostream &os, const vector<vector<v>> &vec)->ostream& {
+    for (auto &i : vec) {
+        os << i[0];
+        for (size_t j = 1; j < i.size(); j++) {
+            os << ' ' << i[j];
+        }
+        os << '\n';
+    }
+    return os;
+}
+
+template<class v>
+auto operator>>(istream  &is, vector<vector<v>> &vec)->istream& {
+    for (auto &i : vec) {
+        for (auto &j : i) {
+            is >> j;
+        }
+    }
+    return is;
+}
+
+const int oo = INT32_MAX >> 1;
+const ll OO = INT64_MAX >> 1;
+
+
+void pre()
+{
+
+}
+
+#define TEST 0
+
+void solve()
+{
+    int n;
+    cin >> n;
+
+    V<string> ev;
+    V<string> od;
+
+    rep(i, n) {
+        string a;
+        cin >> a;
+        if (a.size() & 1) {
+            od.emplace_back(a);
+        } else {
+            ev.emplace_back(a);
+        }
+    }
+
+    auto scmp = [&](string &a, string &b) {
+        return a.size() < b.size();
+    };
+
+    sort(all(ev), scmp);
+    sort(all(od), scmp);
+
+    auto calc = [&](V<string> &a) {
+        ll ans = 0;
+        V<map<int, int>> c(6);
+
+        repv(i, a) {
+            nrep(j, 1, min(6, (int)i.size() + 1)) {
+                int lim = (i.size() + j) >> 1;
+                ll cur = 0;
+                rep(k, lim - j) {
+                    cur -= i[k] - '0';
+                }
+                nrep(k, lim - j, i.size()) {
+                    cur += i[k] - '0';
+                }
+
+                ans += c[j][cur];
+
+                cur = 0;
+                rep(k, lim) {
+                    cur += i[k] - '0';
+                }
+                nrep(k, lim, i.size()) {
+                    cur -= i[k] - '0';
+                }
+
+                ans += c[j][cur];
+            }
+
+            c[i.size()][accumulate(all(i), 0) - '0' * i.size()]++;
+        }
+
+        return ans;
+    };
+
+    cout << calc(ev) + calc(od) << '\n';
+}
+
+int main()
+{
+    ios::sync_with_stdio(false);
+    cin.tie(nullptr);
+
+    pre();
+
+    int t;
+    (TEST && cin >> t) || (t = 1);
+    while (t--) {
+        solve();
+    }
+}