More problems

.gitignore

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

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-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, 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)/B. Battle of Arrays.cpp

@@ -0,0 +1,138 @@
+/* Problem URL: https://codeforces.com/contest/2181/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;
+    cin >> n >> m;
+
+    multiset<ll, greater<>> a[2];
+
+    rep(i, n) {
+        ll b;
+        cin >> b;
+        a[0].insert(b);
+    }
+
+    rep(i, m) {
+        ll b;
+        cin >> b;
+        a[1].insert(b);
+    }
+
+    int now = 0;
+
+    while (!a[now].empty()) {
+        ll ca = *a[now].begin();
+        ll cb = *a[now^1].begin();
+        a[now^1].erase(a[now^1].begin());
+        now ^= 1;
+
+        cb -= ca;
+        if (cb > 0) {
+            a[now].insert(cb);
+        }
+    }
+
+    string win[] = {"Bob", "Alice"};
+    cout << win[now] << '\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)/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();
+    }
+}

CodeTON Round 8 (Div. 1 + Div. 2, Rated, Prizes!)/C2. Bessie's Birthday Cake (Hard Version).cpp

@@ -0,0 +1,164 @@
+/* Problem URL: https://codeforces.com/problemset/problem/1942/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, x, y;
+    cin >> n >> x >> y;
+
+    ll ini = y;
+
+    vi a(x);
+    cin >> a;
+    sortv(a);
+
+    ll ans = x - 2;
+
+    ll even = 0;
+    vl odds;
+    nrep(i, 1, x) {
+        if (a[i] - a[i - 1] - 1 <= 1) {
+            ans += a[i] - a[i - 1] - 1;
+            continue;
+        }
+
+        ll g = a[i] - a[i - 1] - 1;
+        if (g & 1) {
+            odds.push_back(g >> 1);
+            continue;
+        }
+
+        even += g >> 1;
+    }
+
+    ll g = n - (a.back() - a[0] + 1);
+
+    if (g <= 1) {
+        ans += g;
+    } else if (g & 1) {
+        odds.push_back(g >> 1);
+    } else {
+        even += g >> 1;
+    }
+
+
+    sortv(odds);
+
+    repv(i, odds) {
+        if (y >= i) {
+            y -= i;
+            ans += i + 1;
+            continue;
+        }
+
+        ans += y;
+        y = 0;
+        break;
+    }
+
+    ll ev = min(even, (ll)y);
+    y -= ev;
+    ans += ev;
+    ll us = ini - y;
+    ans += us;
+    cout << ans << '\n';
+}
+
+int main()
+{
+    ios::sync_with_stdio(false);
+    cin.tie(nullptr);
+
+    pre();
+
+    int t;
+    (TEST && cin >> t) || (t = 1);
+    while (t--) {
+        solve();
+    }
+}

CodeTON Round 9 (Div. 1 + Div. 2, Rated, Prizes!)/D. Shohag Loves GCD.cpp

@@ -0,0 +1,155 @@
+/* Problem URL: https://codeforces.com/problemset/problem/2039/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;
+
+    vi a(m);
+    cin >> a;
+    sort(all(a), greater<>());
+
+    if (n == 1) {
+        cout << a[0] << '\n';
+        return;
+    }
+
+    if (m == 1) {
+        cout << "-1\n";
+        return;
+    }
+
+    set<int> all;
+    nrep(i, 1, n + 1) {
+        all.insert(i);
+    }
+
+    vi ans(n);
+    rep(i, m) {
+        if (all.empty()) {
+            break;
+        }
+
+        auto itr = all.begin();
+        int cur = *itr;
+        ans[*itr - 1] = a[i];
+        itr = all.erase(itr);
+
+        while (itr != all.end()) {
+            if (*itr % cur == 0) {
+                itr++;
+                continue;
+            }
+
+            ans[*itr - 1] = a[i];
+            itr = all.erase(itr);
+        }
+    }
+
+    if (!all.empty()) {
+        cout << "-1\n";
+        return;
+    }
+
+    cout << ans;
+}
+
+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 1004 (Div. 2)/C. Devyatkino.cpp

@@ -0,0 +1,123 @@
+/* Problem URL: https://codeforces.com/problemset/problem/2067/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;
+    cin >> n;
+
+    rep(k, 8) {
+        string now = to_string(n - k);
+
+        int cur = 0;
+        repv(i, now) {
+            if (i <= '7') {
+                rmax(cur, i - '0');
+            }
+        }
+
+        if (k >= 7 - cur) {
+            cout << k << '\n';
+            return;
+        }
+    }
+}
+
+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 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 1030 (Div. 2)/D1. Red Light, Green Light (Easy version).cpp

@@ -0,0 +1,189 @@
+/* Problem URL: https://codeforces.com/problemset/problem/2118/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, k;
+    cin >> n >> k;
+
+    vl p(n);
+    vl d(n);
+    cin >> p >> d;
+
+    V<V<bool>> loop(n, V<bool>(2));
+    V<V<bool>> vis(n, V<bool>(2));
+    V<V<bool>> frame(n, V<bool>(2));
+
+    function<bool(int, int, ll)> func = [&](int i, int dir, ll cur) -> bool {
+        if (cur % k != d[i]) {
+            int ne = i + 1 - 2 * dir;
+            if (ne < 0 || ne == n) {
+                return false;
+            }
+
+            return func(ne, dir, (cur + abs(p[i] - p[ne])) % k);
+        }
+
+        dir ^= 1;
+
+        if (frame[i][dir]) {
+            frame[i][dir] = false;
+            loop[i][dir] = true;
+            return true;
+        }
+
+        if (vis[i][dir]) {
+            return false;
+        }
+
+        vis[i][dir] = true;
+        frame[i][dir] = true;
+
+        int ne = i + 1 - 2 * dir;
+        if (ne < 0 || ne == n) {
+            frame[i][dir] = false;
+            return false;
+        }
+        bool res = func(ne, dir, (cur + abs(p[i] - p[ne])) % k);
+
+        if (res == true) {
+            loop[i][dir] = true;
+        }
+
+        frame[i][dir] = false;
+        return loop[i][dir];
+    };
+
+    rep(i, n) {
+        if (!vis[i][0]) {
+            func(i, 1, d[i]);
+        }
+
+        if (!vis[i][1]) {
+            func(i, 0, d[i]);
+        }
+    }
+
+    int q;
+    cin >> q;
+    while (q--) {
+        ll c;
+        cin >> c;
+
+        int ind = lower_bound(all(p), c) - p.begin();
+        bool pos = true;
+        ll cur = 0;
+        while (ind < n) {
+            cur = (cur + abs(p[ind] - c)) % k;
+            if (cur == d[ind]) {
+                if (loop[ind][1]) {
+                    pos = false;
+                }
+                break;
+            }
+            c = p[ind];
+            ind++;
+        }
+
+        cout << (pos ? "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 1033 (Div. 2) and CodeNite 2025/C. Divine Tree.cpp

@@ -0,0 +1,160 @@
+/* Problem URL: https://codeforces.com/contest/2120/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 n, m;
+    cin >> n >> m;
+
+    ll high = n * (n + 1) / 2;
+
+    if (m < n || m > high) {
+        cout << "-1\n";
+        return;
+    }
+
+    set<ll, greater<>> all;
+    nrep(i, 1, n + 1) {
+        all.insert(i);
+    }
+
+    V<pair<int, int>> edges;
+    int root = -1;
+    int prev = -1;
+
+    auto itr = all.begin();
+    while (n < m) {
+        while (n - 1 > m - *itr) {
+            itr++;
+        }
+        n--;
+        m -= *itr;
+        if (root == -1) {
+            root = *itr;
+            prev = root;
+            itr = all.erase(itr);
+            continue;
+        }
+
+        edges.emplace_back(prev, *itr);
+        prev = *itr;
+        itr = all.erase(itr);
+    }
+
+    if (prev == -1) {
+        root = 1;
+    } else {
+        edges.emplace_back(prev, 1);
+    }
+
+    all.erase(1);
+    itr = all.begin();
+    while (itr != all.end()) {
+        edges.emplace_back(1, *itr);
+        itr++;
+    }
+
+    cout << root << '\n';
+    repv(i, edges) {
+        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 1040 (Div. 1)/C1. Interactive RBS (Easy Version).cpp

@@ -0,0 +1,190 @@
+/* Problem URL: https://codeforces.com/problemset/problem/2129/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;
+
+    string ans(n, ' ');
+
+    vi pos(n);
+    rep(i, n) {
+        pos[i] = i + 1;
+    }
+    bool rev = false;
+
+    int total;
+    cout << "? " << n;
+    nrep(i, 1, n + 1) {
+        cout << ' ' << i;
+    }
+    cout << endl;
+    cin >> total;
+
+    if (total == 0) {
+        rev = true;
+        reverse(all(pos));
+        cout << "? " << n;
+        rep(i, n) {
+            cout << ' ' << pos[i];
+        }
+        cout << endl;
+        cin >> total;
+    }
+
+    auto sfirstclose = [&]() {
+        int low = 2;
+        int high = n;
+        int ans = 2;
+        while (low <= high) {
+            int mid = (low + high) >> 1;
+
+            cout << "? " << mid;
+            rep(i, mid) {
+                cout << ' ' << pos[i];
+            }
+            cout << endl;
+            int cur;
+            cin >> cur;
+
+            if (cur == total) {
+                ans = mid;
+                high = mid - 1;
+                continue;
+            }
+
+            low = mid + 1;
+        }
+
+        return ans;
+    };
+
+    int c = sfirstclose();
+
+    int v = pos[c -  1];
+    for (int i = 0; i + 1 < n; i += 2)  {
+        cout << "? 9 " << i + 1 << ' ' << v << ' '  << v << ' ' << i + 2 << ' ' <<  v << ' ' <<  i + 1 << ' ' << i + 1 << ' ' << i + 2 << ' ' << i + 2 << endl;
+        int cur;
+        cin >> cur;
+
+        char a1[] = {')', ')', '(', '('};
+        char a2[] = {')', '(', '(', ')'};
+
+        ans[i] = a1[cur];
+        ans[i + 1] = a2[cur];
+    }
+
+    if (n & 1) {
+        cout << "? 2 " << n << ' ' << pos[c - 1] << endl;
+        int cur;
+        cin >> cur;
+
+        if (cur == 1) {
+            ans.back() = '(';
+        } else {
+            ans.back() = ')';
+        }
+    }
+
+    cout << "! " << ans << endl;
+}
+
+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};
+    int now = 1;
-
+    int lim = n;
-    V<pair<int, int>> edges;
+    int ma = 1;
-
+    while (now < n) {
-    for (int i = n - 1; i >= 0; i--) {
+        int ps = pos[now - 1];
-        while (!s.empty() && s.top().first > pos[i]) {
+        if (now > ma) {
-            edges.emplace_back(s.top().second + 1, i + 1);
+            cout << "No\n";
-            s.pop();
+            return;
         }
 
-        if (big.first > pos[i]) {
+        if (ps >= lim) {
-            edges.emplace_back(big.second + 1, i + 1);
+            now++;
             continue;
         }
 
-        big = {pos[i], i};
+        nrep(i, ps + 1, n) {
-        s.emplace(pos[i], i);
+            if (p[i] < now) {
+                break;
+            }
+
+            ans.emplace_back(p[i], now);
+        }
+        if (now != ma) {
+            ans.emplace_back(ma, now);
+        }
+
+        lim = ps;
+        rmax(ma, suf[ps]);
     }
 
-    sortv(edges);
+    if (ans.size() < n - 1) {
-    edges.erase(unique(all(edges)), edges.end());
-
-    if (edges.size() != n - 1) {
         cout << "No\n";
         return;
     }
 
     cout << "Yes\n";
-    repv(i, edges) {
+    repv(i, ans) {
         cout << i.first << ' ' << i.second << '\n';
     }
 }

Codeforces Round 1069 (Div. 1)/B. Wishing Cards.cpp

@@ -0,0 +1,147 @@
+/* Problem URL: https://codeforces.com/contest/2174/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;
+    cin >> n >> k;
+
+    vi a(n);
+    cin >> a;
+
+    V<pair<int, int>> act = {{0, 0}, {1, a[0]}};
+    int cur = a[0];
+    nrep(i, 1, n) {
+        if (cur >= a[i]) {
+            continue;
+        }
+
+        act.emplace_back(i + 1, a[i]);
+        cur = a[i];
+    }
+
+    act.emplace_back(n + 1, 0);
+
+    vvvl dp(act.size(), vvl(k + 1, vl(k + 1)));
+    ll ans = 0;
+
+    vvl maximal(act.size(), vl(k + 1));
+
+    int c = 1;
+
+    nrep(i, 1, act.size() - 1) {
+        int lim = act[i].second;
+        int dis = act[i].first - act[i - 1].first;
+
+        rep(j, k + 1) {
+            rep(l, min(act[i].second, j) + 1) {
+                dp[i][j][l] = max(maximal[i - 1][j - l] + l, dp[i - 1][j][l] + l * (dp[i - 1][j][l] != 0) * dis);
+                ll next = 0;
+                next = act[i + 1].first - act[i].first - 1;
+                rmax(maximal[i][j], dp[i][j][l] + l *  next);
+                rmax(ans, maximal[i][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 1069 (Div. 2)/C. Needle in a Haystack.cpp

@@ -0,0 +1,148 @@
+/* Problem URL: https://codeforces.com/contest/2175/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()
+{
+    string a, b;
+    cin >> a >> b;
+
+    vi count(26);
+    vi count2(26);
+
+    repv(i, a) {
+        count2[i - 'a']++;
+    }
+
+    repv(i, b) {
+        count[i - 'a']++;
+    }
+
+    rep(i, 26) {
+        if (count[i] < count2[i]) {
+            cout << "Impossible\n";
+            return;
+        }
+        count[i] -= count2[i];
+    }
+
+    int cur = 0;
+    string ans;
+
+    rep(i, 26) {
+        while (cur < a.size() && a[cur] <= i + 'a') {
+            ans.push_back(a[cur]);
+            cur++;
+        }
+
+        while (count[i]) {
+            count[i]--;
+            ans.push_back(i + 'a');
+        }
+    }
+
+    while (cur < a.size()) {
+        ans.push_back(a[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();
+    }
+}

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)/A. Perfect Root.cpp

@@ -0,0 +1,110 @@
+/* Problem URL: https://codeforces.com/contest/2185/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;
+    nrep(i, 1, n + 1) {
+        cout << i * i << " \n"[i == 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 1076 (Div. 3)/A. DBMB and the Array.cpp

@@ -0,0 +1,121 @@
+/* Problem URL: https://codeforces.com/contest/2193/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, s, x;
+    cin >> n >> s >> x;
+
+    int cur = 0;
+    while (n--) {
+        int x;
+        cin >> x;
+        cur += x;
+    }
+
+    if (cur > s || (cur - s) % x) {
+        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 1076 (Div. 3)/B. Reverse a Permutation.cpp

@@ -0,0 +1,130 @@
+/* Problem URL: https://codeforces.com/contest/2193/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 p(n);
+    cin >> p;
+    int cur = n;
+    int inv = n;
+    rep(i, n) {
+        if (p[i] == cur) {
+            cur--;
+            continue;
+        }
+
+        inv = i;
+        break;
+    }
+
+    int l = inv;
+    while (l < n && p[l] != cur) {
+        l++;
+    }
+
+    reverse(p.begin() + inv, p.begin() + l + 1);
+
+    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 1076 (Div. 3)/C. Replace and Sum.cpp

@@ -0,0 +1,127 @@
+/* Problem URL: https://codeforces.com/contest/2193/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, q;
+    cin >> n >> q;
+    vl a(n);
+    vl b(n);
+    cin >> a >> b;
+    rmax(a[n - 1], b[n - 1]);
+
+    for (int i = n - 2; i >= 0; i--) {
+        a[i] = max({a[i], a[i + 1], b[i]});
+    }
+
+    vl pref(n + 1);
+    nrep(i, 1, n + 1) {
+        pref[i] = pref[i - 1] + a[i - 1];
+    }
+
+    while (q--) {
+        int l, r;
+        cin >> l >> r;
+        cout << pref[r] - pref[l - 1] << ' ';
+    }
+    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 1076 (Div. 3)/D. Monster Game.cpp

@@ -0,0 +1,138 @@
+/* Problem URL: https://codeforces.com/contest/2193/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;
+    vl a(n);
+    vi b(n);
+    cin >> a >> b;
+
+    priority_queue<ll> s;
+    repv(i, a) {
+        s.push(i);
+    }
+
+    ll best = OO;
+
+    ll ans = 0;
+    rep(i, n) {
+        while (b[i]) {
+            if (s.empty()) {
+                break;
+            }
+
+            rmin(best, s.top());
+            s.pop();
+            b[i]--;
+        }
+
+        if (b[i]) {
+            break;
+        }
+
+        rmax(ans, (i + 1) * best);
+    }
+
+    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 1080 (Div. 3)/A. Sieve of Erato67henes.cpp

@@ -0,0 +1,112 @@
+/* Problem URL: https://codeforces.com/contest/2195/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;
+
+    vl a(n);
+    cin >> a;
+
+    cout << (count(all(a), 67) ? "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 1080 (Div. 3)/B. Heapify 1.cpp

@@ -0,0 +1,152 @@
+/* Problem URL: https://codeforces.com/contest/2195/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;
+
+    vvi s;
+    vi st;
+    V<bool> vis(n);
+
+    rep(i, n) {
+        if (vis[i]) {
+            continue;
+        }
+
+        s.emplace_back();
+        st.push_back(i);
+        for (int j = i; j < n; j = (j + 1) * 2 - 1) {
+            vis[j] = true;
+            s.back().push_back(j + 1);
+        }
+    }
+
+    repv(i, s) {
+        sort(all(i), [&](int i, int j){
+             return a[i - 1] < a[j - 1];
+             });
+    }
+
+    vi ans(n);
+
+    rep(i, s.size()) {
+        int start = st[i];
+        auto &v = s[i];
+
+        for (int j = 0; j < v.size(); j++, start = (start + 1) * 2 - 1) {
+            ans[start] = a[v[j] - 1];
+        }
+    }
+
+    nrep(i, 1, n) {
+        if (ans[i] < ans[i - 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 1080 (Div. 3)/C. Dice Roll Sequence.cpp

@@ -0,0 +1,128 @@
+/* Problem URL: https://codeforces.com/contest/2195/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;
+    vi a(n);
+    cin >> a;
+
+    vvl dp(n + 1, vl(6, OO));
+    fill(all(dp[0]), 0);
+
+    nrep(i, 1, n + 1) {
+        int cur = a[i - 1] - 1;
+
+        rep(j, 6) {
+            int add = cur != j;
+            rep(k, 6) {
+                if (k == j || k == 6 - j - 1) {
+                    continue;
+                }
+                rmin(dp[i][j], add + dp[i - 1][k]);
+            }
+        }
+    }
+
+    cout << *min_element(all(dp.back())) << '\n';
+}
+
+int main()
+{
+    ios::sync_with_stdio(false);
+    cin.tie(nullptr);
+
+    pre();
+
+    int t;
+    (TEST && cin >> t) || (t = 1);
+    while (t--) {
+        solve();
+    }
+}

Codeforces Round 1080 (Div. 3)/D. Absolute Cinema.cpp

@@ -0,0 +1,123 @@
+/* Problem URL: https://codeforces.com/contest/2195/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;
+    vl a(n);
+    cin >> a;
+
+    ll sum = a[0] + a.back();
+    for (int i = n - 1; i > 0; i--) {
+        a[i] = a[i - 1] - a[i];
+    }
+    a[0] = sum / (n - 1);
+
+    vl ans(n);
+    ans.back() = (a[0] + a.back()) / 2;
+    rep(i, n - 1) {
+        ans[i] = (a[i] - a[i + 1]) / 2;
+    }
+    
+    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 1080 (Div. 3)/E. Idiot First Search.cpp

@@ -0,0 +1,147 @@
+/* Problem URL: https://codeforces.com/contest/2195/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;
+
+
+void pre()
+{
+
+}
+
+#define TEST 1
+
+void solve()
+{
+    int n;
+    cin >> n;
+
+    V<array<int, 2>> graph(n);
+    rep(i, n) {
+        int a, b;
+        cin >> a >> b;
+        graph[i][0] = a - 1;
+        graph[i][1] = b - 1;
+    }
+
+    const ll mod = 1e9 + 7;
+    vl ans(n);
+
+    function<ll(int)> dfs = [&](int i) {
+        if (graph[i][0] == -1) {
+            return ans[i] = 1;
+        }
+
+        return ans[i] = (dfs(graph[i][0]) + dfs(graph[i][1]) + 3) % mod;
+    };
+
+    dfs(0);
+
+    function<void(int, int)> dfs2 = [&](int i, int p) {
+        ans[i] += ans[p];
+        ans[i] %= mod;
+
+        if (graph[i][0] == -1) {
+            return;
+        }
+
+        dfs2(graph[i][0], i);
+        dfs2(graph[i][1], i);
+    };
+
+    if (graph[0][0] != -1) {
+        dfs2(graph[0][0], 0);
+        dfs2(graph[0][1], 0);
+    }
+
+    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 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 265 (Div. 1)/B. Restore Cube.cpp

@@ -0,0 +1,223 @@
+/* Problem URL: https://codeforces.com/contest/464/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;
+
+struct pt {
+    ll x, y, z;
+
+    pt(ll x, ll y, ll z): x(x), y(y), z(z) {}
+    pt() = default;
+    
+    friend istream &operator >> (istream &is, pt &a) {
+        is >> a.x >> a.y >> a.z;
+        return is;
+    }
+
+    friend ostream &operator << (ostream &os, pt a) {
+        os << a.x << ' ' << a.y << ' ' << a.z;
+        return os;
+    }
+
+    pt operator ^ (pt b) {
+        return pt(y * b.z- z * b.y, z * b.x - x * b.z, x * b.y - y * b.x);
+    }
+
+    ll operator * (pt b) {
+        return x * b.x + y * b.y + z * b.z;
+    }
+
+    pt operator - (pt b) {
+        return pt(x - b.x, y - b.y, z - b.z);
+    }
+
+    bool operator == (pt b) {
+        return x == b.x && y == b.y && z == b.z;
+    }
+
+    bool operator < (pt b) {
+        if (x == b.x) {
+            if (y == b.y) {
+                return z < b.z;
+            }
+            return y < b.y;
+        }
+        return x < b.x;
+    }
+};
+
+ll dis2(pt a, pt b)
+{
+    ll x = a.x - b.x;
+    ll y = a.y - b.y;
+    ll z = a.z - b.z;
+
+    return x * x + y * y + z * z;
+}
+
+void pre()
+{
+
+}
+
+#define TEST 0
+
+void solve()
+{
+    vvi pts(8, vi(3));
+    cin >> pts;
+
+    rep(i, 8) {
+        sortv(pts[i]);
+    }
+    
+    auto check = [&](){
+        V<pt> p(8);
+        rep(i, 8) {
+            p[i] = {pts[i][0], pts[i][1], pts[i][2]};
+        }
+
+        sortv(p);
+        p.erase(unique(all(p)), p.end());
+
+        if (p.size() != 8) {
+            return false;
+        }
+
+        vi dis(7);
+        nrep(i, 1, 8) {
+            dis[i - 1] = dis2(p[i], p[0]);
+        }
+
+        sortv(dis);
+
+        nrep(i, 1, 8) {
+            vi d2;
+            rep(j, 8) {
+                if (i == j) {
+                    continue;
+                }
+
+                d2.push_back(dis2(p[i], p[j]));
+            }
+
+            sortv(d2);
+            if (d2 != dis) {
+                return false;
+            }
+        }
+
+        return true;
+    };
+
+    function<bool(int)> func = [&](int i){
+        if (i >= 8) {
+            return check();
+        }
+
+        do {
+            if (func(i + 1)) {
+                return true;
+            }
+        } while (next_permutation(all(pts[i])));
+
+        return false;
+    };
+
+    if (!func(0)) {
+        cout << "NO\n";
+        return;
+    }
+
+    cout << "YES\n";
+    cout << pts;
+}
+
+int main()
+{
+    ios::sync_with_stdio(false);
+    cin.tie(nullptr);
+
+    pre();
+
+    int t;
+    (TEST && cin >> t) || (t = 1);
+    while (t--) {
+        solve();
+    }
+}

Codeforces Round 839 (Div. 3)/E. Permutation Game.cpp

@@ -0,0 +1,153 @@
+/* Problem URL: https://codeforces.com/problemset/problem/1772/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;
+    cin >> n;
+    vi a(n);
+    cin >> a;
+
+    vi p1(n);
+    vi p2(n);
+
+    rep(i, n) {
+        p1[i] = (a[i] != (i + 1));
+        p2[i] = (a[i] != (n - i));
+    }
+
+    int c[2] = {0, 0};
+    int d = 0;
+    rep(i, n) {
+        if (p1[i] && p1[i] == p2[i]) {
+            d++;
+            continue;
+        }
+
+        c[0] += p1[i];
+        c[1] += p2[i];
+    }
+
+    int cur = 0;
+    while (1) {
+        if (c[cur]) {
+            c[cur]--;
+            cur ^= 1;
+            continue;
+        }
+
+        if (d) {
+            if (d == 1 && c[cur^1] == 0) {
+                cout << "Tie\n";
+                return;
+            }
+            d--;
+            cur ^= 1;
+            continue;
+        }
+
+        break;
+    }
+
+    string win[] = {"First", "Second"};
+    cout << win[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 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

@@ -0,0 +1,179 @@
+/* Problem URL: https://codeforces.com/problemset/problem/1794/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;
+
+constexpr int MAXN = 1e6 + 10;
+bool prime[MAXN];
+ll fact[MAXN];
+ll inv[MAXN];
+ll finv[MAXN];
+
+ll mod = 998244353;
+
+void pre()
+{
+    fill(prime, prime + MAXN, true);
+    prime[1] = false;
+
+    nrep(i, 2, MAXN) {
+        if (!prime[i]) {
+            continue;
+        }
+
+        for (int j = i * 2; j < MAXN; j += i) {
+            prime[j] = false;
+        }
+    }
+
+    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;
+    }
+
+    finv[0] = 1;
+    nrep(i, 1, MAXN) {
+        finv[i] = finv[i - 1] * inv[i] % mod;
+    }
+}
+
+#define TEST 0
+
+void solve()
+{
+    int n;
+    cin >> n;
+    vi a(2 * n);
+    cin >> a;
+
+    vi primes;
+    map<int, ll> c;
+    rep(i, 2 * n) {
+        if (prime[a[i]] && !c.count(a[i])) {
+            primes.push_back(a[i]);
+        }
+
+        c[a[i]]++;
+    }
+
+    if (primes.size() < n) {
+        cout << "0\n";
+        return;
+    }
+
+    ll non = 1;
+    repv(i, c) {
+        if (!prime[i.first]) {
+            non = (non * finv[i.second]) % mod;
+        }
+    }
+
+    vvl dp(primes.size() + 1, vl(n + 1));
+    dp[0][0] = fact[n] * non % mod;
+
+    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(j, 1, n + 1) {
+            dp[i][j] = (dp[i - 1][j] * finv[co] % mod + dp[i - 1][j - 1] * finv[co - 1] % mod) % mod;
+        }
+    }
+
+    cout << dp[primes.size()][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 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 874 (Div. 3)/G. Ksyusha and Chinchilla.cpp

@@ -0,0 +1,182 @@
+/* Problem URL: https://codeforces.com/problemset/problem/1833/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;
+
+    V<set<pair<int, int>>> graph(n);
+
+    nrep(i, 1, n) {
+        int a, b;
+        cin >> a >> b;
+        a--, b--;
+        graph[a].emplace(b, i);
+        graph[b].emplace(a, i);
+    }
+
+    set<int> er;
+
+    bool pos = true;
+    function<int(int, int)> dfs = [&](int i, int p) {
+        int c = 0;
+        auto cur = graph[i].begin();
+        while (cur != graph[i].end()) {
+            auto [j, ind] = *cur;
+            graph[i].erase({j, ind});
+            cur = graph[i].begin();
+
+            if (graph[j].size() != 1) {
+                graph[j].erase({i, ind});
+                int res = dfs(j, ind);
+                if (res == 0) {
+                    c++;
+                    continue;
+                }
+
+                if (res == 1) {
+                    if (c != 0) {
+                        pos = false;
+                        return 2;
+                    }
+
+                    for (auto [k, _] : graph[i]) {
+                        er.insert(_);
+                        graph[k].erase({i, _});
+                        if (dfs(k, _) != 2) {
+                            pos = false;
+                            return 0;
+                        }
+                    }
+
+                    return 2;
+                }
+
+                er.insert(ind);
+                continue;
+            }
+
+            c++;
+        }
+
+        if (c > 2) {
+            pos = false;
+            return 0;
+        }
+
+        return c;
+    };
+
+    if (dfs(0, -1) != 2 || !pos) {
+        cout << "-1\n";
+        return;
+    }
+
+    er.erase(0);
+
+    cout << er.size() << '\n';
+    repv(i, er) {
+        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 877 (Div. 2)/C. No Prime Differences.cpp

@@ -0,0 +1,159 @@
+/* Problem URL: https://codeforces.com/problemset/problem/1838/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;
+
+constexpr int MAXN = 1e6 + 10;
+bool prime[MAXN];
+
+void pre()
+{
+    fill(prime, prime + MAXN, true);
+    prime[1] = false;
+
+    nrep(i, 2, MAXN) {
+        if (!prime[i]) {
+            continue;
+        }
+
+        for (int j = i * 2; j < MAXN; j += i) {
+            prime[j] = false;
+        }
+    }
+}
+
+#define TEST 1
+
+void solve()
+{
+    int n, m;
+    cin >> n >> m;
+
+    vvi ans(n, vi(m));
+
+    if (!prime[m]) {
+        rep(i, n) {
+            rep(j, m) {
+                ans[i][j] = i * m + j + 1;
+            }
+        }
+        cout << ans << '\n';
+        return;
+    }
+
+    if (!prime[n]) {
+        rep(j, m) {
+            rep(i, n) {
+                ans[i][j] = j * n + i + 1;
+            }
+        }
+        cout << ans << '\n';
+        return;
+    }
+
+    int cur = 1;
+    for (int i = 0; i < n; i += 2) {
+        rep(j, m) {
+            ans[i][j] = cur;
+            cur++;
+        }
+    }
+
+    for (int i = 1; i < n; i += 2) {
+        rep(j, m) {
+            ans[i][j] = 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();
+    }
+}

Codeforces Round 886 (Div. 4)/G. The Morning Star.cpp

@@ -0,0 +1,134 @@
+/* Problem URL: https://codeforces.com/problemset/problem/1850/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;
+
+    V<pair<ll, ll>> v(n);
+    repv(i, v) {
+        cin >> i.first >> i.second;
+    }
+    sortv(v);
+
+    map<ll, ll> cx;
+    map<ll, ll> cy;
+
+    ll lim = 1e10;
+
+    ll ans = 0;
+    repv(p, v) {
+        auto [x, y] = p;
+        ans += cx[x];
+        ans += cy[y];
+        ans += cy[y - lim + x];
+        ans += cy[y + lim - x];
+
+        cx[x]++;
+        cy[y]++;
+        cy[y - lim + x]++;
+        cy[y + lim - x]++;
+    }
+
+    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 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 895 (Div. 3)/E. Data Structures Fan.cpp

@@ -0,0 +1,217 @@
+/* Problem URL: https://codeforces.com/problemset/problem/1872/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;
+    cin >> n;
+
+    vl a(n);
+    cin >> a;
+
+    string b;
+    cin >> b;
+
+    while (__builtin_popcount(n) != 1) {
+        n++;
+        a.push_back(0);
+        b.push_back('0');
+    }
+
+    vl seg0(n << 1);
+    vl seg1(n << 1);
+    vi lazy(n << 1);
+
+    nrep(i, n, n << 1) {
+        if (b[i - n] == '0') {
+            seg0[i] = a[i - n];
+        } else {
+            seg1[i] = a[i - n];
+        }
+    }
+
+    for (int i = n - 1; i > 0; i--) {
+        seg0[i] = seg0[i * 2] ^ seg0[i * 2 + 1];
+        seg1[i] = seg1[i * 2] ^ seg1[i * 2 + 1];
+    }
+
+    auto propagate = [&](int i) {
+        if (!lazy[i]) {
+            return;
+        }
+
+        lazy[i] = 0;
+
+        swap(seg0[i], seg1[i]);
+
+        if (i < n) {
+            lazy[i * 2] ^= 1;
+            lazy[i * 2 + 1] ^= 1;
+        }
+    };
+
+    function<pair<ll, ll>(int, int, int, int, int)> update = [&](int i, int l, int r, int tl, int tr) -> pair<ll, ll> {
+        propagate(i);
+
+        if (l > tr || r < tl) {
+            return {seg0[i], seg1[i]};
+        }
+
+        if (l >= tl && r <= tr) {
+            lazy[i] ^= 1;
+            propagate(i);
+            return {seg0[i], seg1[i]};
+        }
+
+        int mid = (l + r) >> 1;
+
+        auto a1 = update(i * 2, l, mid, tl, tr);
+        auto a2 = update(i * 2 + 1, mid + 1, r, tl, tr);
+
+        seg0[i] = a1.first ^ a2.first;
+        seg1[i] = a1.second ^ a2.second;
+
+        return {seg0[i], seg1[i]};
+    };
+
+    function<pair<ll, ll>(int, int, int, int, int)> query = [&](int i, int l, int r, int tl, int tr) -> pair<ll, ll> {
+        if (l > tr || r < tl) {
+            return {0, 0};
+        }
+
+        propagate(i);
+
+        if (l >= tl && r <= tr) {
+            return {seg0[i], seg1[i]};
+        }
+
+        int mid = (l + r) >> 1;
+
+        auto a1 = query(i * 2, l, mid, tl, tr);
+        auto a2 = query(i * 2 + 1, mid + 1, r, tl, tr);
+
+        return {a1.first ^ a2.first, a1.second ^ a2.second};
+    };
+
+    int q;
+    cin >> q;
+    while (q--) {
+        int op;
+        cin >> op;
+        if (op == 1) {
+            int l, r;
+            cin >> l >> r;
+            update(1, 0, n - 1, l - 1, r - 1);
+            continue;
+        }
+
+        int g;
+        cin >> g;
+
+        if (g == 0) {
+            cout << query(1, 0, n - 1, 0, n - 1).first << ' ';
+        } else {
+            cout << query(1, 0, n - 1, 0, n - 1).second << ' ';
+        }
+    }
+    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 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 901 (Div. 2)/D. Jellyfish and Mex.cpp

@@ -0,0 +1,141 @@
+/* Problem URL: https://codeforces.com/problemset/problem/1875/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;
+
+    vl a(n);
+    cin >> a;
+
+    vi c(n + 3);
+    repv(i, a) {
+        if (i > n + 1) {
+            continue;
+        }
+
+        c[i]++;
+    }
+
+    int mex = 0;
+
+    rep(i, n) {
+        if (c[i] == 0) {
+            mex = i;
+            break;
+        }
+    }
+
+    ll ans = OO;
+
+    vl dp(mex + 1, OO);
+    dp[mex] = 0;
+
+    for (int i = n; i >= 0; i--) {
+        nrep(j, i + 1, mex + 1) {
+            rmin(dp[i], dp[j] + (c[i] - 1) * j + i);
+        }
+    }
+
+    cout << 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 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)/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 914 (Div. 2)/C. Array Game.cpp

@@ -0,0 +1,156 @@
+/* Problem URL: https://codeforces.com/problemset/problem/1904/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;
+    if (k >= 3) {
+        cout << "0\n";
+        return;
+    }
+
+    sort(all(a), greater<>());
+
+    ll ans = *min_element(all(a));
+
+    vl ot;
+
+    rep(i, n - 1) {
+        nrep(j, i + 1, n) {
+            rmin(ans, max(a[i] - a[j] * k, a[i] % a[j]));
+
+            if (k > 1) {
+                ll cur = a[i] - a[j];
+                int ind = lower_bound(all(a), cur, greater<>()) - a.begin();
+                if (ind < n) {
+                    rmin(ans, abs(a[ind] - cur));
+                }
+
+                if (ind < n - 1) {
+                    rmin(ans, abs(a[ind + 1] - cur));
+                }
+
+                if (ind < n - 2) {
+                    rmin(ans, abs(a[ind + 2] - cur));
+                }
+
+                if (ind > 0) {
+                    rmin(ans, abs(a[ind - 1] - cur));
+                }
+
+                if (ind > 1) {
+                    rmin(ans, abs(a[ind - 2] - cur));
+                }
+
+                rmin(ans, abs(cur - a[j]));
+                rmin(ans, abs(cur - a[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 916 (Div. 3)/E1. Game with Marbles (Easy Version).cpp

@@ -0,0 +1,131 @@
+/* Problem URL: https://codeforces.com/problemset/problem/1914/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;
+    cin >> n;
+
+    vl a(n);
+    vl b(n);
+    cin >> a >> b;
+
+    vvl dp(1 << n, vl(2));
+    nrep(i, 1, 1 << n) {
+        ll maxi = -OO;
+        ll mini = OO;
+
+        rep(j, n) {
+            if (~(i >> j) & 1) {
+                continue;
+            }
+
+            rmax(maxi, dp[i ^ (1 << j)][0] + a[j] - 1);
+            rmin(mini, dp[i ^ (1 << j)][1] - b[j] + 1);
+        }
+
+        dp[i][0] = mini;
+        dp[i][1] = maxi;
+    }
+
+    cout << dp[(1 << n) - 1][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 920 (Div. 3)/F. Sum of Progression.cpp

@@ -0,0 +1,116 @@
+/* Problem URL: https://codeforces.com/problemset/problem/1921/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;
+    vl a(n);
+    cin >> a;
+    
+    
+
+    while (q--) {
+        int s, d, k;
+        cin >> s >> d >> k;
+    }
+}
+
+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 924 (Div. 2)/D. Lonely Mountain Dungeons.cpp

@@ -0,0 +1,136 @@
+/* Problem URL: https://codeforces.com/problemset/problem/1928/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;
+    ll b;
+    ll x;
+    cin >> n >> b >> x;
+
+    vl a(n);
+    int m = *max_element(all(a));
+
+    vi s(n);
+    vl ac(n);
+
+    vvi t(m);
+    ll total = -x * (m - 1);
+    rep(i, n) {
+        rep(j, a[i]) {
+            t[j].push_back(i);
+        }
+        total += a[i] * (a[i - 1]) / 2 * b;
+        ac[i] = a[i] * (a[i - 1]) / 2 * b;
+    }
+
+    ll ans = total;
+    for (int i = m - 1; i > 0; i--) {
+        repv(j, t[i]) {
+            total -= ac[j];
+            ll sz = i;
+            ll cmp = a[i] % sz;
+            sz -= cmp;
+        }
+    }
+}
+
+int main()
+{
+    ios::sync_with_stdio(false);
+    cin.tie(nullptr);
+
+    pre();
+
+    int t;
+    (TEST && cin >> t) || (t = 1);
+    while (t--) {
+        solve();
+    }
+}

Codeforces Round 925 (Div. 3)/E. Anna and the Valentine's Day Gift.cpp

@@ -0,0 +1,131 @@
+/* Problem URL: https://codeforces.com/problemset/problem/1931/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;
+    cin >> n >> m;
+
+    priority_queue<int> a;
+    int total = 0;
+    rep(i, n) {
+        string s;
+        cin >> s;
+        total += s.size();
+        int rem = 0;
+        while (s.back() == '0') {
+            s.pop_back();
+            rem++;
+        }
+        a.push(rem);
+    }
+
+    while (!a.empty()) {
+        int cur = a.top();
+        a.pop();
+        a.push(0);
+        a.pop();
+        total -= cur;
+    }
+
+    cout << (total > m ? "Sasha\n" : "Anna\n");
+}
+
+int main()
+{
+    ios::sync_with_stdio(false);
+    cin.tie(nullptr);
+
+    pre();
+
+    int t;
+    (TEST && cin >> t) || (t = 1);
+    while (t--) {
+        solve();
+    }
+}

Codeforces Round 925 (Div. 3)/F. Chat Screenshots.cpp

@@ -0,0 +1,210 @@
+/* Problem URL: https://codeforces.com/problemset/problem/1931/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, k;
+    cin >> n >> k;
+
+    vvi p(k, vi(n));
+    cin >> p;
+
+    if (n == 1 || k == 1) {
+        cout << "YES\n";
+        return;
+    }
+
+    if (k == 2) {
+        int i1 = 1;
+        int i2 = 1;
+
+        rep(i, n) {
+            if (i1 >= n) {
+                if (p[1][i2] != p[0][0]) {
+                    cout << "NO\n";
+                    return;
+                }
+
+                continue;
+            }
+
+            if (i2 >= n) {
+                if (p[0][i1] != p[1][0]) {
+                    cout << "NO\n";
+                    return;
+                }
+
+                continue;
+            }
+
+            if (p[0][i1] == p[1][i2]) {
+                i1++;
+                i2++;
+                continue;
+            }
+
+            if (p[0][i1] == p[1][0]) {
+                i1++;
+                continue;
+            }
+
+            if (p[1][i2] == p[0][0]) {
+                i2++;
+                continue;
+            }
+
+            cout << "NO\n";
+            return;
+        }
+        
+        cout << "YES\n";
+        return;
+    }
+
+    V<bool> vis(n + 1);
+    int cur = -1;
+
+    int next = -1;
+
+    int eq = n;
+
+    nrep(i, 1, n) {
+        if (next == -1) {
+            if (p[0][i] == p[1][i] || p[0][i] == p[2][i]) {
+                cur = p[0][i];
+            } else if (p[1][i] == p[2][i]) {
+                cur = p[1][i];
+            } else {
+                cout << "NO\n";
+                return;
+            }
+        } else {
+            cur = next;
+        }
+
+        next = -1;
+        vis[cur] = true;
+        rep(j, k) {
+            if (p[j][i] != cur) {
+                if (!vis[p[j][0]]) {
+                    cout << "NO\n";
+                    return;
+                }
+
+                if (next != -1 && p[j][i] != next) {
+                    cout << "NO\n";
+                    return;
+                }
+
+                next = p[j][i];
+                continue;
+            }
+
+            if (vis[p[j][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 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 927 (Div. 3)/D. Card Game.cpp

@@ -0,0 +1,170 @@
+/* Problem URL: https://codeforces.com/problemset/problem/1932/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;
+
+    char t;
+    cin >> t;
+
+    V<string> tmp;
+    V<string> ev;
+    rep(i, n << 1) {
+        string a;
+        cin >> a;
+
+        if (a[1] == t) {
+            ev.emplace_back(a);
+            continue;
+        }
+        tmp.emplace_back(a);
+    }
+
+    sort(all(ev), greater<>());
+    sort(all(tmp), greater<>());
+
+    repv(i, tmp) {
+        ev.emplace_back(i);
+    }
+
+    V<bool> vis(n);
+    V<pair<int, int>> ans;
+
+    function<bool(int)> func = [&](int i) {
+        if (i >= (n << 1)) {
+            return true;
+        }
+
+        if (vis[i]) {
+            return func(i + 1);
+        }
+
+        nrep(j, i + 1, (n << 1)) {
+            if (vis[j]) {
+                continue;
+            }
+
+            if ((ev[i][1] == t && ev[j][1] != t) || (ev[i][1] == ev[j][1] && ev[i][0] > ev[j][0])) {
+                vis[j] = true;
+                ans.emplace_back(j, i);
+                if (func(i + 1)) {
+                    return true;
+                }
+                vis[j] = false;
+                ans.pop_back();
+            }
+        }
+        
+        return false;
+    };
+
+    if (!func(0)) {
+        cout << "IMPOSSIBLE\n";
+        return;
+    }
+
+    repv(i, ans) {
+        cout << ev[i.first] << ' ' << ev[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 927 (Div. 3)/E. Final Countdown.cpp

@@ -0,0 +1,132 @@
+/* Problem URL: https://codeforces.com/problemset/problem/1932/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;
+    cin >> n;
+    string a;
+    cin >> a;
+
+    reverse(all(a));
+
+    vi tmp(n + 1);
+    for (int i = n - 1; i >= 0; i--) {
+        tmp[i] = tmp[i + 1] + (a[i] - '0');
+    }
+
+    string res;
+
+    int c = 0;
+    rep(i, n) {
+        c += tmp[i];
+        res.push_back(c % 10 + '0');
+        c /= 10;
+    }
+
+    res.push_back(c + '0');
+    while (res.back() == '0') {
+        res.pop_back();
+    }
+    reverse(all(res));
+    cout << res << '\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 931 (Div. 2)/C. Find a Mine.cpp

@@ -0,0 +1,140 @@
+/* Problem URL: https://codeforces.com/problemset/problem/1934/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 x, int y) {
+        if (y <= 0) {
+            return 100LL;
+        }
+        cout << "? " << x << ' ' << y << endl;
+        ll ans;
+        cin >> ans;
+        return ans;
+    };
+
+    auto answer = [&](int x, int y) {
+        cout << "! " << x << ' ' << y << endl;
+    };
+
+    ll dis1 = ask(1, 1);
+    ll dis2 = ask(n, 1);
+
+    ll y = (dis1 + dis2 - n + 3) >> 1;
+    ll x = dis1 + 2 - y;
+
+    ll tmp = ask(x, y);
+    if (tmp == 0) {
+        answer(x, y);
+        return;
+    }
+
+    dis2 = ask(1, m);
+
+    x = (dis1 + dis2 - m + 3) >> 1;
+    y = dis1 + 2 - x;
+
+    answer(x, y);
+}
+
+int main()
+{
+    ios::sync_with_stdio(false);
+    cin.tie(nullptr);
+
+    pre();
+
+    int t;
+    (TEST && cin >> t) || (t = 1);
+    while (t--) {
+        solve();
+    }
+}

Codeforces Round 944 (Div. 4)/F. Circle Perimeter.cpp

@@ -0,0 +1,139 @@
+/* Problem URL: https://codeforces.com/problemset/problem/1971/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 r;
+    cin >> r;
+
+    ll low = r * r;
+    ll high = (r + 1) * (r + 1);
+
+    ll x = 0;
+    ll y = 0;
+
+    auto dis = [&](ll x, ll y) {
+        return x * x + y * y;
+    };
+
+    ll ans = 0;
+
+    while (y <= r) {
+        while (dis(x + 1, y) <= low) {
+            x++;
+        }
+
+        while (dis(x, y) >= high) {
+            x--;
+        }
+
+        while (dis(x - 1, y) >= low && x > 0) {
+            ans++;
+            x--;
+        }
+
+        ans++;
+        y++;
+    }
+
+    cout << ans + (ans - 2) * 3 + 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 946 (Div. 3)/D. Ingenuity-2.cpp

@@ -0,0 +1,185 @@
+/* Problem URL: https://codeforces.com/problemset/problem/1974/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;
+    string a;
+    cin >> a;
+
+    int x = 0;
+    int y = 0;
+
+    pair<int, int> var[256];
+    var['N'] = {0, 1};
+    var['S'] = {0, -1};
+    var['E'] = {1, 0};
+    var['W'] = {-1, 0};
+
+    repv(i, a) {
+        x += var[i].first;
+        y += var[i].second;
+    }
+
+    if ((x & 1) || (y & 1)) {
+        cout << "NO\n";
+        return;
+    }
+
+    x >>= 1;
+    y >>= 1;
+
+    if (x == 0 && y == 0) {
+        if (a.size() == 2) {
+            cout << "NO\n";
+            return;
+        }
+
+        int ind1 = find(all(a), 'N') - a.begin();
+        int ind2 = find(all(a), 'S') - a.begin();
+        if (ind1 == n || ind2 == n) {
+            ind1 = find(all(a), 'E') - a.begin();
+            ind2 = find(all(a), 'W') - a.begin();
+        }
+
+        rep(i, n) {
+            if (i == ind1 || i == ind2) {
+                cout << 'H';
+                continue;
+            }
+
+            cout << "R";
+        }
+        cout << '\n';
+        return;
+    }
+
+    repv(i, a) {
+        if (i == 'N' && y > 0) {
+            y--;
+            cout << "R";
+            continue;
+        }
+
+        if (i == 'S' && y < 0) {
+            y++;
+            cout << "R";
+            continue;
+        }
+
+        if (i == 'E' && x > 0) {
+            x--;
+            cout << "R";
+            continue;
+        }
+
+        if (i == 'W' && x < 0) {
+            x++;
+            cout << "R";
+            continue;
+        }
+
+        cout << "H";
+    }
+    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 952 (Div. 4)/H1. Maximize the Largest Component (Easy Version).cpp

@@ -0,0 +1,212 @@
+/* Problem URL: https://codeforces.com/problemset/problem/1985/H1 */
+
+#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<string> a(n);
+    cin >> a;
+
+    vi dsu(n * m);
+    vi size(n * m);
+    rep(i, n * m) {
+        dsu[i] = i;
+        size[i] = 1;
+    }
+
+    stack<pair<int, int>> s;
+    auto save = [&]() {
+        s.emplace(-1, -1);
+    };
+
+    auto roll = [&]() {
+        while (s.top().first != -1) {
+            auto [i, j] = s.top();
+            size[i] -= size[j];
+            dsu[j] = j;
+            s.pop();
+        }
+    };
+
+    function<int(int)> find_p = [&](int i) {
+        if (dsu[i] == i) {
+            return i;
+        }
+        return find_p(dsu[i]);
+    };
+
+    int ans = 1;
+
+    auto join = [&](int i, int j) {
+        i = find_p(i);
+        j = find_p(j);
+
+        if (i == j) {
+            return;
+        }
+
+        if (size[i] < size[j]) {
+            swap(i, j);
+        }
+
+        s.emplace(i, j);
+        size[i] += size[j];
+        rmax(ans, size[i]);
+        dsu[j] = i;
+    };
+
+    rep(i, n) {
+        rep(j, m) {
+            if (a[i][j] == '.') {
+                continue;
+            }
+
+            if (i > 0 && a[i - 1][j] == '#') {
+                join(i * m + j, (i - 1) * m + j);
+            }
+
+            if (j > 0 && a[i][j - 1] == '#') {
+                join(i * m + j, i * m + j - 1);
+            }
+        }
+    }
+
+    rep(i, n) {
+        save();
+        rep(j, m) {
+            if (i > 0 && a[i - 1][j] == '#') {
+                join(i * m + j, (i - 1) * m + j);
+            }
+
+            if (i < n - 1 && a[i + 1][j] == '#') {
+                join(i * m + j, (i + 1) * m + j);
+            }
+
+            if (j > 0) {
+                join(i * m + j, i * m + j - 1);
+            }
+        }
+        roll();
+    }
+
+    rep(j, m) {
+        save();
+        rep(i, n) {
+            if (i > 0) {
+                join(i * m + j, (i - 1) * m + j);
+            }
+
+            if (j > 0 && a[i][j - 1] == '#') {
+                join(i * m + j, i * m + j - 1);
+            }
+            
+            if (j < m - 1 && a[i][j + 1] == '#') {
+                join(i * m + j, i * m + j + 1);
+            }
+        }
+        roll();
+    }
+
+    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)/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 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. 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 970 (Div. 3)/E. Alternating String.cpp

@@ -0,0 +1,157 @@
+/* Problem URL: https://codeforces.com/problemset/problem/2008/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;
+    string a;
+    cin >> n >> a;
+
+    if (a.size() & 1) {
+        vvvi suf(n + 1, vvi(26, vi(2)));
+        for (int i = n - 1; i >= 0; i--) {
+            suf[i][a[i] - 'a'][i & 1]++;
+
+            rep(j, 26) {
+                suf[i][j][0] += suf[i + 1][j][0];
+                suf[i][j][1] += suf[i + 1][j][1];
+            }
+        }
+
+        int c = n >> 1;
+
+        int ans = oo;
+
+        vvi pref(26, vi(2));
+        rep(i, n) {
+            int mi0 = oo;
+            int mi1 = oo;
+            rep(j, 26) {
+                rmin(mi0, c - pref[j][0] - suf[i + 1][j][1]);
+                rmin(mi1, c - pref[j][1] - suf[i + 1][j][0]);
+            }
+
+            rmin(ans, mi0 + mi1);
+
+            pref[a[i] - 'a'][i & 1]++;
+        }
+
+        cout << ans + 1 << '\n';
+        return;
+    }
+
+    vvi c(26, vi(2));
+    rep(i, n) {
+        c[a[i] - 'a'][i & 1]++;
+    }
+
+    int cc = n >> 1;
+
+    int mi0 = oo;
+    int mi1 = oo;
+    rep(j, 26) {
+        rmin(mi0, cc - c[j][0]);
+        rmin(mi1, cc - c[j][1]);
+    }
+
+    cout << mi0 + mi1 << '\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)/D. Satyam and Counting.cpp

@@ -0,0 +1,135 @@
+/* Problem URL: https://codeforces.com/problemset/problem/2009/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<V<bool>> p(2, V<bool>(n + 1));
+
+    rep(i, n) {
+        int x, y;
+        cin >> x >> y;
+        p[y][x] = true;
+    }
+
+    ll ans = 0;
+    n++;
+
+    rep(i, n) {
+        if (p[0][i] && p[1][i]) {
+            ans += n - 3;
+        }
+
+        if (i > 0 && i < n - 1) {
+            if (p[0][i] && p[1][i - 1] && p[1][i + 1]) {
+                ans++;
+            }
+
+            if (p[1][i] && p[0][i - 1] && p[0][i + 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 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();
+    }
+}