Add a bunch of other problems.

Some are not finished...

2015-2016 Petrozavodsk Winter Training Camp, Saratov SU Contest/G. Maximum Product.cpp

@@ -0,0 +1,144 @@
+/* Problem URL: https://codeforces.com/gym/100886/problem/G */
+
+#include <bits/stdc++.h>
+
+using namespace std;
+#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;
+}
+
+int main()
+{
+    ios::sync_with_stdio(false);
+    cin.tie(nullptr);
+
+    string tmp, b;
+    cin >> tmp >> b;
+
+    size_t diff = b.size() - tmp.size();
+
+    string a;
+    rep(i, diff) {
+        a.push_back('0');
+    }
+
+    a += tmp;
+
+    rep(i, a.size()) {
+        if (a[i] != b[i]) {
+            break;
+        }
+
+        if (a[i] == '0') {
+            cout << b << '\n';
+            return 0;
+        }
+    }
+
+    vvvvl memo(a.size(), vvvl(2, vvl(2, vl(2, -1))));
+
+    function<ll(int, int, int, int)> dp = [&](int i, int over, int under, int started) -> ll {
+        if (i >= a.size()) {
+            return 1;
+        }
+
+        ll &ans = memo[i][over][under][started];
+        if (ans != -1) {
+            return ans;
+        }
+
+        ans = 0;
+
+        char limit = over ? '0' : a[i];
+        for (int j = under ? '9' : b[i]; j >= limit; j--) {
+            rmax(ans, dp(i + 1, over || j > a[i], under || j < b[i], started || j != '0') * (!started && j == '0' ? 1 : j - '0'));
+        }
+
+        return ans;
+    };
+
+    ll res = dp(0, 0, 0, 0);
+
+    string ans;
+    function<void(int, int, int, int, ll)> recover = [&](int i, int over, int under, int started, ll prod) {
+        if (i >= a.size() - 1) {
+            ans.push_back(prod + '0');
+            return;
+        }
+
+        char limit = over ? '0' : a[i];
+        for (int j = under ? '9' : b[i]; j >= limit; j--) {
+            ll div = !started && j == '0' ? 1 : j - '0';
+
+            if (prod % div == 0 && memo[i + 1][over || j > a[i]][under || j < b[i]][started || j != '0'] == prod / div) {
+                ans.push_back(j);
+                recover(i + 1, over || j > a[i], under || j < b[i], started || j != '0', prod / div);
+                return;
+            }
+        }
+    };
+
+    recover(0, 0, 0, 0, res);
+
+    cout << stoll(ans) << '\n';
+}

2018 German Collegiate Programming Contest (GCPC 18)/A. Attack on Alpha-Zet.cpp

@@ -0,0 +1,78 @@
+/* Problem URL: https://codeforces.com/gym/102021/problem/A */
+
+#include <bits/stdc++.h>
+
+using namespace std;
+
+#define V vector
+
+#define rmin(a, b) a = min(a, b)
+#define rmax(a, b) a = max(a, b)
+
+#define rep(i, lim) for (size_t i = 0; i < (lim); i++)
+#define nrep(i, s, lim) for (size_t 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;
+}
+
+int main()
+{
+    ios::sync_with_stdio(false);
+    cin.tie(nullptr);
+
+
+}

2018-2019 ACM-ICPC Brazil Subregional Programming Contest/B. Marbles.cpp

@@ -0,0 +1,134 @@
+/* Problem URL: https://codeforces.com/gym/101908/problem/B */
+
+#include <bits/stdc++.h>
+
+using namespace std;
+
+#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;
+}
+
+int main()
+{
+    ios::sync_with_stdio(false);
+    cin.tie(nullptr);
+
+    int mr;
+    cin >> mr;
+
+    const int n = 101;
+    const int inf = INT32_MAX >> 1;
+
+    vvi grundy(n, vi(n));
+
+    rep(i, n) {
+        grundy[i][i] = 1000;
+        grundy[0][i] = 1000;
+        grundy[i][0] = 1000;
+    }
+
+    auto search = [&](int i, int j) {
+        V<bool> exists(1001, false);
+        nrep(k, 1, n) {
+            if (i - k >= 0) {
+                exists[grundy[i - k][j]] = true;
+            }
+
+            if (j - k >= 0) {
+                exists[grundy[i][j - k]] = true;
+            }
+
+            if (i - k >= 0 && j - k >= 0) {
+                exists[grundy[i - k][j - k]] = true;
+            }
+        }
+
+        int mex = 0;
+        while (exists[mex]) {
+            mex++;
+        }
+
+        return mex;
+    };
+
+    nrep(i, 1, n) {
+        nrep(j, 1, n) {
+            if (i == j) {
+                continue;
+            }
+            grundy[i][j] = search(i, j);
+        }
+    }
+
+    int state = 0;
+
+    while (mr--) {
+        int i, j;
+        cin >> i >> j;
+
+        state ^= grundy[i][j];
+    }
+
+    cout << (state == 0 ? "N\n" : "Y\n");
+}

2018-2019 ACM-ICPC Brazil Subregional Programming Contest/C. Pizza Cutter.cpp

@@ -0,0 +1,156 @@
+/* Problem URL: https://codeforces.com/gym/101908/problem/C */
+
+#include <bits/stdc++.h>
+
+using namespace std;
+
+#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;
+}
+
+int main()
+{
+    ios::sync_with_stdio(false);
+    cin.tie(nullptr);
+
+    ll x, y;
+    cin >> x >> y;
+
+    ll h, v;
+    cin >> h >> v;
+
+    ll ans = (h + 1) * (v + 1);
+
+    V<pair<ll, ll>> ys(h);
+    repv(i, ys) {
+        cin >> i.first >> i.second;
+    }
+
+    V<pair<ll, ll>> xs(v);
+
+    repv(i, xs) {
+        cin >> i.first >> i.second;
+    }
+
+    sortv(ys);
+    sortv(xs);
+
+    function<ll(V<pair<ll, ll>>&)> count = [&](V<pair<ll, ll>> &vec) -> ll {
+        if (vec.size() <= 1) {
+            return 0;
+        }
+
+        int mid = vec.size() / 2;
+
+        V<pair<ll, ll>> first(mid);
+        rep(i, mid) {
+            first[i] = vec[i];
+        }
+
+        V<pair<ll, ll>> second(vec.size() - mid);
+        rep(i, vec.size() - mid) {
+            second[i] = vec[vec.size() - i - 1];
+        }
+        reverse(all(second));
+
+        ll ans = count(first);
+        ans += count(second);
+
+        int now = 0;
+        int l = 0;
+        int r = 0;
+        while (l < first.size() && r < second.size()) {
+            if (first[l].second <= second[r].second) {
+                vec[now] = first[l];
+                now++;
+                l++;
+                continue;
+            }
+
+            ans += first.size() - l;
+            vec[now] = second[r];
+            now++;
+            r++;
+        }
+
+        while (l < first.size()) {
+            vec[now] = first[l];
+            l++;
+            now++;
+        }
+
+        while (r < second.size()) {
+            vec[now] = second[r];
+            r++;
+            now++;
+        }
+
+        return ans;
+    };
+
+    ans += count(xs);
+    ans += count(ys);
+
+    cout << ans << '\n';
+}

2018-2019 ACM-ICPC Brazil Subregional Programming Contest/D. Unraveling Monty Hall.cpp

@@ -0,0 +1,89 @@
+/* Problem URL: https://codeforces.com/gym/101908/problem/D */
+
+#include <bits/stdc++.h>
+
+using namespace std;
+
+#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;
+}
+
+int main()
+{
+    ios::sync_with_stdio(false);
+    cin.tie(nullptr);
+
+    int t;
+    cin >> t;
+    int count = 0;
+    while (t--) {
+        int n;
+        cin >> n;
+        
+        if (n == 2 || n == 3) {
+            count++;
+        }
+    }
+    cout << count << '\n';
+}

2018-2019 ACM-ICPC Brazil Subregional Programming Contest/E. Enigma.cpp

@@ -0,0 +1,97 @@
+/* Problem URL: https://codeforces.com/gym/101908/problem/E */
+
+#include <bits/stdc++.h>
+
+using namespace std;
+
+#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;
+}
+
+int main()
+{
+    ios::sync_with_stdio(false);
+    cin.tie(nullptr);
+
+    string a, b;
+    cin >> a >> b;
+
+    int count = 0;
+    rep(i, a.size() - b.size() + 1) {
+        bool pos = true;
+
+        rep(j, b.size()) {
+            if (a[i + j] == b[j]) {
+                pos = false;
+                break;
+            }
+        }
+
+        if (pos) {
+            count++;
+        }
+    }
+
+    cout << count << '\n';
+}

2018-2019 ACM-ICPC Brazil Subregional Programming Contest/F. Music Festival.cpp

@@ -0,0 +1,81 @@
+/* Problem URL: https://codeforces.com/gym/101908/problem/F */
+
+#include <bits/stdc++.h>
+
+using namespace std;
+
+#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;
+}
+
+int main()
+{
+    ios::sync_with_stdio(false);
+    cin.tie(nullptr);
+
+    int n;
+    cin >> n;
+
+    V<tuple<int, int, int, int>> stuff;
+}

2018-2019 ACM-ICPC Brazil Subregional Programming Contest/I. Switches.cpp

@@ -0,0 +1,120 @@
+/* Problem URL: https://codeforces.com/gym/101908/problem/I */
+
+#include <bits/stdc++.h>
+
+using namespace std;
+
+#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;
+}
+
+int main()
+{
+    ios::sync_with_stdio(false);
+    cin.tie(nullptr);
+
+    int n, m;
+    cin >> n >> m;
+
+    int l;
+    cin >> l;
+
+    int on = l;
+
+    vi status(m);
+    while (l--) {
+        int a;
+        cin >> a;
+        status[a - 1] = 1;
+    }
+
+    vvi graph(n);
+    rep(i, n) {
+        int k;
+        cin >> k;
+
+        while (k--) {
+            int b;
+            cin >> b;
+            graph[i].push_back(b - 1);
+        }
+    }
+
+    int i = 0;
+    while (i < 2 * n && on != 0) {
+        repv(j, graph[i % n]) {
+            on += 1 - 2 * status[j];
+            status[j] ^= 1;
+        }
+
+        i++;
+    }
+
+    if (on != 0) {
+        cout << "-1\n";
+        return 0;
+    }
+
+    cout << i << '\n';
+}

2018-2019 ACM-ICPC Brazil Subregional Programming Contest/L. Subway Lines.cpp

@@ -0,0 +1,159 @@
+/* Problem URL: https://codeforces.com/gym/101908/problem/L */
+
+#include <bits/stdc++.h>
+
+using namespace std;
+
+#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;
+}
+
+int main()
+{
+    ios::sync_with_stdio(false);
+    cin.tie(nullptr);
+
+    int n, q;
+    cin >> n >> q;
+
+    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);
+    }
+
+    vvi parent(n, vi(20, 0));
+    vi depth(n, 0);
+
+    function<void(int, int)> dfs = [&](int i, int p) {
+        depth[i] = depth[p] + 1;
+        parent[i][0] = p;
+
+        nrep(j, 1, 20) {
+            parent[i][j] = parent[parent[i][j - 1]][j - 1];
+        }
+
+        for (auto j : graph[i]) {
+            if (j == p) {
+                continue;
+            }
+
+            dfs(j, i);
+        }
+    };
+
+    dfs(0, 0);
+
+    auto lca = [&](int a, int b) {
+        if (depth[a] > depth[b]) {
+            swap(a, b);
+        }
+
+        int diff = depth[b] - depth[a];
+
+        rep(i, 20) {
+            if ((diff >> i) & 1) {
+                b = parent[b][i];
+            }
+        }
+
+        if (a == b) {
+            return a;
+        }
+
+        for (int i = 19; i >= 0; i--) {
+            if (parent[a][i] != parent[b][i]) {
+                a = parent[a][i];
+                b = parent[b][i];
+            }
+        }
+
+        return parent[a][0];
+    };
+
+    auto dis = [&](int a, int b) {
+        return depth[a] + depth[b] - 2 * depth[lca(a, b)];
+    };
+
+    while (q--) {
+        int a, b, c, d;
+        cin >> a >> b >> c >> d;
+        a--, b--, c--, d--;
+
+        int x = dis(a, b) + dis(c, d);
+        int y = min(dis(a, c) + dis(b, d), dis(a, d) + dis(b, c));
+
+        if (y > x) {
+            cout << "0\n";
+            continue;
+        }
+
+        cout << (x - y) / 2 + 1 << '\n';
+    }
+}

2019-2020 ACM-ICPC Brazil Subregional Programming Contest/B. Buffoon.cpp

@@ -0,0 +1,95 @@
+/* Problem URL: https://codeforces.com/gym/102346/problem/B */
+
+#include <bits/stdc++.h>
+
+using namespace std;
+
+#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;
+}
+
+int main()
+{
+    ios::sync_with_stdio(false);
+    cin.tie(nullptr);
+
+    int n;
+    cin >> n;
+
+    n--;
+    int carlos;
+    cin >> carlos;
+
+    while (n--) {
+        int nm;
+        cin >> nm;
+
+        if (nm > carlos) {
+            cout << "N\n";
+            return 0;
+        }
+    }
+
+    cout << "S\n";
+}

2019-2020 ACM-ICPC Brazil Subregional Programming Contest/D. Denouncing Mafia.cpp

@@ -0,0 +1,129 @@
+/* Problem URL: https://codeforces.com/gym/102346/problem/D */
+
+#include <bits/stdc++.h>
+
+using namespace std;
+
+#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;
+}
+
+int main()
+{
+    ios::sync_with_stdio(false);
+    cin.tie(nullptr);
+
+    int n, k;
+    cin >> n >> k;
+
+    vvi graph(n);
+
+    nrep(i, 1, n) {
+        int p;
+        cin >> p;
+
+        graph[p - 1].push_back(i);
+    }
+
+    V<multiset<int, greater<>>> sets(n);
+
+    function<void(int)> dfs = [&](int i) {
+        for (auto j : graph[i]) {
+            dfs(j);
+
+            if (sets[j].size() > sets[i].size()) {
+                swap(sets[j], sets[i]);
+            }
+
+            for (auto k : sets[j]) {
+                sets[i].insert(k);
+            }
+        }
+
+        if (sets[i].empty()) {
+            sets[i].insert(1);
+            return;
+        }
+
+        auto itr = sets[i].begin();
+        int v = *itr + 1;
+        sets[i].erase(itr);
+        sets[i].insert(v);
+    };
+
+    dfs(0);
+
+    int ans = 0;
+    auto itr = sets[0].begin();
+    rep(i, k) {
+        if (itr == sets[0].end()) {
+            break;
+        }
+
+        ans += *itr;
+        itr++;
+    }
+
+    cout << ans << '\n';
+}

2019-2020 ACM-ICPC Brazil Subregional Programming Contest/H. Hour for a Run.cpp

@@ -0,0 +1,91 @@
+/* Problem URL: https://codeforces.com/gym/102346/problem/H */
+
+#include <bits/stdc++.h>
+
+using namespace std;
+
+#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;
+}
+
+int main()
+{
+    ios::sync_with_stdio(false);
+    cin.tie(nullptr);
+
+    int n, v;
+    cin >> n >> v;
+
+    v *= n;
+
+    cout << (ll)ceil(v * 0.1) << ' ';
+    cout << (ll)ceil(v * 0.2) << ' ';
+    cout << (ll)ceil(v * 0.3) << ' ';
+    cout << (ll)ceil(v * 0.4) << ' ';
+    cout << (ll)ceil(v * 0.5) << ' ';
+    cout << (ll)ceil(v * 0.6) << ' ';
+    cout << (ll)ceil(v * 0.7) << ' ';
+    cout << (ll)ceil(v * 0.8) << ' ';
+    cout << (ll)ceil(v * 0.9) << '\n';
+}

2019-2020 ACM-ICPC Brazil Subregional Programming Contest/J. Jar of Water Game.cpp

@@ -0,0 +1,204 @@
+/* Problem URL: https://codeforces.com/gym/102346/problem/J */
+
+#include <bits/stdc++.h>
+
+using namespace std;
+
+#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;
+}
+
+int main()
+{
+    ios::sync_with_stdio(false);
+    cin.tie(nullptr);
+
+    int n, k;
+    cin >> n >> k;
+
+    vvi cards(n, vi(14, 0));
+
+    map<char, int> act;
+
+    act['A'] = 1;
+    act['2'] = 2;
+    act['3'] = 3;
+    act['4'] = 4;
+    act['5'] = 5;
+    act['6'] = 6;
+    act['7'] = 7;
+    act['8'] = 8;
+    act['9'] = 9;
+    act['D'] = 10;
+    act['Q'] = 11;
+    act['J'] = 12;
+    act['K'] = 13;
+
+    rep(i, n) {
+        string a;
+        cin >> a;
+
+        repv(j, a) {
+            cards[i][act[j]]++;
+        }
+    }
+
+    k--;
+
+    rep(i, n) {
+        if (i == k) {
+            continue;
+        }
+
+        nrep(j, 1, 14) {
+            if (cards[i][j] == 4) {
+                cout << i + 1 << '\n';
+                return 0;
+            }
+        }
+    }
+
+    rep(i, n) {
+        int minimal = 2;
+        int choice = 13;
+
+        int now = (i + k) % n;
+
+        for (int j = 13; j > 0; j--) {
+            if (cards[now][j] <= minimal && cards[now][j] > 0) {
+                minimal = cards[now][j];
+                choice = j;
+            }
+        }
+
+        cards[now][choice]--;
+        cards[(now + 1) % n][choice]++;
+
+        if (now != k) {
+            nrep(j, 1, 14) {
+                if (cards[now][j] == 4) {
+                    rep(l, n) {
+                        nrep(c, 1, 14) {
+                            if (cards[l][c] == 4 && l != k) {
+                                cout << l + 1 << '\n';
+                                return 0;
+                            }
+                        }
+                    }
+                }
+            }
+        }
+    }
+     
+    nrep(i, 1, 14) {
+        if (cards[k][i] == 4) {
+            cout << k + 1 << '\n';
+            return 0;
+        }
+    }
+
+    k = (k + 1) % n;
+
+    while (true) {
+        rep(i, n - 1) {
+            int minimal = 2;
+            int choice = 13;
+
+            int now = (k + i) % n;
+
+            for (int j = 13; j > 0; j--) {
+                if (cards[now][j] <= minimal && cards[now][j] > 0) {
+                    minimal = cards[now][j];
+                    choice = j;
+                }
+            }
+
+            cards[now][choice]--;
+            cards[(now + 1) % n][choice]++;
+            if (now != ((k - 1) % n + n) % n) {
+                nrep(j, 1, 14) {
+                    if (cards[now][j] == 4) {
+                        rep(l, n) {
+                            nrep(c, 1, 14) {
+                                if (cards[l][c] == 4 && l != ((k - 1) % n + n) % n) {
+                                    cout << l + 1 << '\n';
+                                    return 0;
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+        }
+
+        nrep(i, 1, 14) {
+            if (cards[k][i] == 4) {
+                cout << k + 1 << '\n';
+                return 0;
+            }
+        }
+
+        k = (k + 1) % n;
+    }
+}

2019-2020 ACM-ICPC Brazil Subregional Programming Contest/L. Less Coin Tosses.cpp

@@ -0,0 +1,80 @@
+/* Problem URL: https://codeforces.com/gym/102346/problem/L */
+
+#include <bits/stdc++.h>
+
+using namespace std;
+
+#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;
+}
+
+int main()
+{
+    ios::sync_with_stdio(false);
+    cin.tie(nullptr);
+
+    ll n;
+    cin >> n;
+    cout << (1LL << (__builtin_popcountll(n))) << '\n';
+}

2019-2020 ACM-ICPC Brazil Subregional Programming Contest/M. Maratona Brasileira de Popcorn.cpp

@@ -0,0 +1,125 @@
+/* Problem URL: https://codeforces.com/gym/102346/problem/M */
+
+#include <bits/stdc++.h>
+
+using namespace std;
+
+#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;
+}
+
+int main()
+{
+    ios::sync_with_stdio(false);
+    cin.tie(nullptr);
+
+    int n, c, t;
+    cin >> n >> c >> t;
+
+    vi pop(n);
+
+    repv(i, pop) {
+        cin >> i;
+        // i = (i + (t - 1)) / t;
+    }
+
+    ll ans = 1;
+    ll low = 1;
+    ll high = 1e9;
+
+    while (low <= high) {
+        ll mid = (low + high) / 2;
+
+        int count = 1;
+        ll now = 0;
+
+        rep(i, n) {
+            if ((pop[i] + (t - 1)) / t > mid) {
+                now = 1e9 + 1;
+                break;
+            }
+
+            now += pop[i];
+
+            if ((now + (t - 1)) / t > mid) {
+                if (count == c) {
+                    break;
+                }
+
+                count++;
+                now = pop[i];
+            }
+        }
+
+        if ((now + (t - 1)) / t <= mid) {
+            ans = mid;
+            high = mid - 1;
+            continue;
+        }
+
+        low = mid + 1;
+    }
+
+    cout << ans << '\n';
+}

2020-2021 ACM-ICPC Brazil Subregional Programming Contest/B. Battleship.cpp

@@ -0,0 +1,117 @@
+/* Problem URL: https://codeforces.com/gym/102861/problem/B */
+
+#include <bits/stdc++.h>
+
+using namespace std;
+
+#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;
+}
+
+int main()
+{
+    ios::sync_with_stdio(false);
+    cin.tie(nullptr);
+
+    int n;
+    cin >> n;
+
+    V<V<bool>> pos(10, V<bool>(10));
+
+    while (n--) {
+        int d, l, r, c;
+        cin >> d >> l >> r >> c;
+        r--, c--;
+
+        if (d == 0) {
+            if (c + l - 1 > 9) {
+                cout << "N\n";
+                return 0;
+            }
+            nrep(i, c, c + l) {
+                if (pos[r][i]) {
+                    cout << "N\n";
+                    return 0;
+                }
+
+                pos[r][i] = true;
+            }
+        } else {
+            if (r + l - 1 > 9) {
+                cout << "N\n";
+                return 0;
+            }
+            nrep(i, r, r + l) {
+                if (pos[i][c]) {
+                    cout << "N\n";
+                    return 0;
+                }
+                
+                pos[i][c] = true;
+            }
+        }
+    }
+
+    cout << "Y\n";
+}

2020-2021 ACM-ICPC Brazil Subregional Programming Contest/E. Party Company.cpp

@@ -0,0 +1,189 @@
+/* Problem URL: https://codeforces.com/gym/102861/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;
+}
+
+int main()
+{
+    ios::sync_with_stdio(false);
+    cin.tie(nullptr);
+
+    int n, m;
+    cin >> n >> m;
+
+    vvi graph(n);
+    vi age(n);
+
+    rep(i, n) {
+        cin >> age[i];
+        int j;
+        cin >> j;
+
+        if (i == 0) {
+            continue;
+        }
+
+        graph[j - 1].push_back(i);
+    }
+
+    const int log = 17;
+
+    vvi parent(n, vi(log));
+    vvi maximal(n, vi(log));
+
+    function<void(int, int)> dfs = [&](int i, int p) {
+        parent[i][0] = p;
+        maximal[i][0] = age[p];
+
+        nrep(j, 1, log) {
+            parent[i][j] = parent[parent[i][j - 1]][j - 1];
+            maximal[i][j] = max(age[parent[i][j]], maximal[i][j - 1]);
+        }
+
+        for (auto j : graph[i]) {
+            dfs(j, i);
+        }
+    };
+
+    dfs(0, 0);
+
+    vvi count(n);
+
+    while (m--) {
+        int i, l, r;
+        cin >> i >> l >> r;
+        i--;
+
+        auto add = [&]() {
+            for (int j = log - 1; j >= 0; j--) {
+                if (maximal[i][j] <= r) {
+                    i = parent[i][j];
+                }
+            }
+
+            count[i].push_back(l);
+        };
+
+        add();
+    }
+
+    int size = 1 << (32 - __builtin_clz(1e5));
+    vi seg(size * 2);
+
+    auto update = [&](int i, int v) {
+        i += size;
+        seg[i] += v;
+
+        for (i >>= 1; i > 0; i >>= 1) {
+            seg[i] = seg[i * 2] + seg[i * 2 + 1];
+        }
+    };
+
+    function<int(int, int, int, int, int)> query = [&](int i, int l, int r, int tl, int tr) {
+        if (l > tr || r < tl) {
+            return 0;
+        }
+
+        if (l >= tl && r <= tr) {
+            return seg[i];
+        }
+
+        int mid = (l + r) >> 1;
+
+        return query(i * 2, l, mid, tl, tr) + query(i * 2 + 1, mid + 1, r, tl, tr);
+    };
+
+    vi ans(n);
+
+    function<void(int)> getans = [&](int i) {
+        repv(j, count[i]) {
+            update(j, 1);
+        }
+
+        ans[i] = query(1, 0, size - 1, 0, age[i]);
+
+        for (auto j : graph[i]) {
+            getans(j);
+        }
+
+        repv(j, count[i]) {
+            update(j, -1);
+        }
+    };
+
+    getans(0);
+
+    cout << ans << '\n';
+}

2020-2021 ACM-ICPC Brazil Subregional Programming Contest/F. Fastminton.cpp

@@ -0,0 +1,122 @@
+/* Problem URL: https://codeforces.com/gym/102861/problem/F */
+
+#include <bits/stdc++.h>
+
+using namespace std;
+
+#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;
+}
+
+int main()
+{
+    ios::sync_with_stdio(false);
+    cin.tie(nullptr);
+
+    string a;
+    cin >> a;
+
+    vi points(2);
+    vi games(2);
+    
+    int now = 0;
+
+    const char *msg[] = {
+        "",
+        "",
+        "(winner)"
+    };
+
+    const char *left[] = {
+        "*",
+        ""
+    };
+
+    const char *right[] = {
+        "",
+        "*"
+    };
+
+    repv(i, a) {
+        if (i == 'S') {
+            points[now]++;
+        } else if (i == 'R') {
+            now ^= 1; 
+            points[now]++;
+        } else if (i == 'Q') {
+            if (games[0] == 2 || games[1] == 2) {
+                printf("%d %s - %d %s\n", games[0], msg[games[0]], games[1], msg[games[1]]);
+                continue;
+            }
+
+            printf("%d (%d%s) - %d (%d%s)\n", games[0], points[0], left[now], games[1], points[1], right[now]);
+        }
+
+        if (points[now] == 10 || (points[now] >= 5 && points[now] - points[now^1] >= 2)) {
+            games[now]++;
+            points[0] = 0;
+            points[1] = 0;
+        }
+    }
+}

2020-2021 ACM-ICPC Brazil Subregional Programming Contest/G. Game Show!.cpp

@@ -0,0 +1,96 @@
+/* Problem URL: https://codeforces.com/gym/102861/problem/G */
+
+#include <bits/stdc++.h>
+
+using namespace std;
+
+#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;
+}
+
+int main()
+{
+    ios::sync_with_stdio(false);
+    cin.tie(nullptr);
+
+    int n;
+    cin >> n;
+
+    vi fds(n);
+    cin >> fds;
+
+    vi pref(n + 1);
+    pref[0] = 100;
+
+    rep(i, n) {
+        pref[i + 1] = pref[i] + fds[i];
+    }
+
+    int maximal = 0;
+    repv(i, pref) {
+        rmax(maximal, i);
+    }
+    
+    cout << maximal << '\n';
+}

2021-2022 ACM-ICPC Brazil Subregional Programming Contest/C. Creating Multiples.cpp

@@ -0,0 +1,125 @@
+/* Problem URL: https://codeforces.com/gym/103388/problem/C */
+
+#include <bits/stdc++.h>
+
+using namespace std;
+
+#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;
+}
+
+int main()
+{
+    ios::sync_with_stdio(false);
+    cin.tie(nullptr);
+
+    ll b;
+    int l;
+    cin >> b >> l;
+
+    ll mod = b + 1;
+
+    auto fastpow = [&](ll a, ll p) {
+        ll ans = 1;
+        ll now = a;
+
+        rep(i, 20) {
+            if ((p >> i) & 1) {
+                ans *= now;
+                ans %= mod;
+            }
+
+            now *= now;
+            now %= mod;
+        }
+
+        return ans;
+    };
+
+    vl fds(l);
+    cin >> fds;
+
+    ll now = 0;
+    rep(i, l) {
+        now += fds[i] * fastpow(b, l - i - 1);
+        now %= mod;
+    }
+
+    if (now == 0) {
+        cout << "0 0\n";
+        return 0;
+    }
+
+    rep(i, l) {
+        ll p = fastpow(b, l - i - 1);
+        ll tmp = (p * now) % mod;
+
+        if (fds[i] >= tmp) {
+            cout << i + 1 << ' ' << fds[i] - tmp << '\n';
+            return 0;
+        }
+    }
+
+    cout << "-1 -1\n";
+}

2021-2022 ACM-ICPC Brazil Subregional Programming Contest/E. Escalator.cpp

@@ -0,0 +1,128 @@
+/* Problem URL: https://codeforces.com/gym/103388/problem/E */
+
+#include <bits/stdc++.h>
+
+using namespace std;
+
+#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;
+}
+
+int main()
+{
+    ios::sync_with_stdio(false);
+    cin.tie(nullptr);
+
+    int n;
+    cin >> n;
+
+    int now = 0;
+    int dir = 0;
+
+    now = 0;
+    dir = 0;
+
+    V<queue<int>> fds(2);
+
+    while (n--) {
+        int t, d;
+        cin >> t >> d;
+
+        fds[d].push(t);
+    }
+
+    while (!fds[0].empty() || !fds[1].empty()) {
+        if (fds[0].empty()) {
+            dir = 1;
+        } else if (fds[1].empty()) {
+            dir = 0;
+        } else {
+            dir = fds[0].front() > fds[1].front();
+        }
+
+        if (fds[dir].front() <= now) {
+            while (!fds[dir].empty() && fds[dir].front() <= now) {
+                fds[dir].pop();
+            }
+            now += 10;
+
+            while (!fds[dir].empty() && fds[dir].front() <= now) {
+                now = fds[dir].front() + 10;
+                fds[dir].pop();
+            }
+
+            continue;
+        }
+
+        now = fds[dir].front() + 10;
+        fds[dir].pop();
+
+        while (!fds[dir].empty() && fds[dir].front() <= now) {
+            now = fds[dir].front() + 10;
+            fds[dir].pop();
+        }
+    }
+
+    cout << now << '\n';
+}

2021-2022 ACM-ICPC Brazil Subregional Programming Contest/G. Getting in Shape.cpp

@@ -0,0 +1,133 @@
+/* Problem URL: https://codeforces.com/gym/103388/problem/G */
+
+#include <bits/stdc++.h>
+
+using namespace std;
+
+#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;
+}
+
+int main()
+{
+    ios::sync_with_stdio(false);
+    cin.tie(nullptr);
+
+    ll n;
+    cin >> n;
+
+    vl dp(77);
+    dp[0] = 1;
+    dp[1] = 1;
+    
+    rep(i, 75) {
+        dp[i + 1] += dp[i];
+        dp[i + 2] += dp[i];
+    }
+
+    unordered_map<ll, bool> vis;
+
+    vi ans;
+
+    function<bool(ll)> dfs = [&](ll now) {
+        if (now == 1) {
+            return true;
+        }
+
+        if (vis[now]) {
+            return false;
+        }
+
+        vis[now] = true;
+
+        for (int i = 74; i > 0; i--) {
+            if (now % dp[i] == 0) {
+                bool res = dfs(now / dp[i]);
+
+                if (res) {
+                    ans.push_back(i);
+                    return true;
+                }
+            }
+        }
+
+        return false;
+    };
+
+    if (!dfs(n)) {
+        cout << "IMPOSSIBLE\n";
+        return 0;
+    }
+
+    reverse(all(ans));
+
+    string tmp;
+
+    repv(i, ans) {
+        tmp += string(i, 'A');
+        tmp += 'B';
+    }
+
+    cout << tmp << '\n';
+}

2021-2022 ACM-ICPC Brazil Subregional Programming Contest/H. Handling the Blocks.cpp

@@ -0,0 +1,111 @@
+/* Problem URL: https://codeforces.com/gym/103388/problem/H */
+
+#include <bits/stdc++.h>
+
+using namespace std;
+
+#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;
+}
+
+int main()
+{
+    ios::sync_with_stdio(false);
+    cin.tie(nullptr);
+
+    int n, k;
+    cin >> n >> k;
+
+    vvi blocks(k);
+
+    vi act;
+
+    while (n--) {
+        int num, c;
+        cin >> num >> c;
+
+        blocks[c - 1].push_back(num);
+        act.push_back(c - 1);
+    }
+
+    rep(i, k) {
+        sort(all(blocks[i]), greater<>());
+    }
+
+    vi ans;
+
+    rep(i, act.size()) {
+        ans.push_back(blocks[act[i]].back());
+        blocks[act[i]].pop_back();
+    }
+
+    nrep(i, 1, ans.size()) {
+        if (ans[i - 1] > ans[i]) {
+            cout << "N\n";
+            return 0;
+        }
+    }
+    
+    cout << "Y\n";
+}

2021-2022 ACM-ICPC Brazil Subregional Programming Contest/K. Kathmandu.cpp

@@ -0,0 +1,100 @@
+/* Problem URL: https://codeforces.com/gym/103388/problem/K */
+
+#include <bits/stdc++.h>
+
+using namespace std;
+
+#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;
+}
+
+int main()
+{
+    ios::sync_with_stdio(false);
+    cin.tie(nullptr);
+
+    int t, d, m;
+    cin >> t >> d >> m;
+
+    int prev = 0;
+
+    while (m--) {
+        int n;
+        cin >> n;
+
+        if (n - prev >= t) {
+            cout << "Y\n";
+            return 0;
+        }
+
+        prev = n;
+    }
+
+    if (d - prev >= t) {
+        cout << "Y\n";
+        return 0;
+    }
+
+    cout << "N\n";
+}

2021-2022 ACM-ICPC Brazil Subregional Programming Contest/M. Monarchy in Vertigo.cpp

@@ -0,0 +1,130 @@
+/* Problem URL: https://codeforces.com/gym/103388/problem/M */
+
+#include <bits/stdc++.h>
+
+using namespace std;
+
+#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;
+}
+
+int main()
+{
+    ios::sync_with_stdio(false);
+    cin.tie(nullptr);
+
+    int q;
+    cin >> q;
+
+    vvi graph(1);
+    int cur = 1;
+
+    vi status(1);
+    vi chosen(1);
+    vi parent(1);
+
+    function<int(int)> dfs = [&](int i) {
+        if (status[i] != -1) {
+            return i;
+        }
+
+        while (chosen[i] < graph[i].size()) {
+            int res = dfs(graph[i][chosen[i]]);
+
+            if (res == -1) {
+                chosen[i]++;
+                continue;
+            }
+
+            return res;
+        }
+
+        return -1;
+    };
+
+    while (q--) {
+        int p, c;
+        cin >> p >> c;
+
+        if (p == 1) {
+            graph[c - 1].push_back(graph.size());
+            graph.emplace_back();
+            parent.push_back(c - 1);
+            status.push_back(0);
+            chosen.push_back(0);
+            continue;
+        }
+
+        status[c - 1] = -1;
+
+        int ans = cur - 1;
+        int tmp;
+        while ((tmp = dfs(ans)) == -1) {
+           ans = parent[ans];
+        }
+
+        cur = tmp + 1;
+        cout << cur << '\n';
+    }
+}

2021-2022 ACM-ICPC Brazil Subregional Programming Contest/N. No Luck.cpp

@@ -0,0 +1,132 @@
+/* Problem URL: https://codeforces.com/gym/103388/problem/N */
+
+#include <bits/stdc++.h>
+
+using namespace std;
+
+#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;
+}
+
+int main()
+{
+    ios::sync_with_stdio(false);
+    cin.tie(nullptr);
+
+    int y, n;
+    cin >> y >> n;
+
+    vi fds(y);
+    cin >> fds;
+
+    while (__builtin_popcount(y) != 1) {
+        y++;
+        fds.push_back(0);
+    }
+    
+    vvi seg(y * 2);
+
+    function<void(int, int, int)> build = [&](int i, int l, int r) {
+        if (l == r) {
+            seg[i].push_back(fds[i - y]);
+            return;
+        }
+
+        int mid = (l + r) / 2;
+
+        build(i * 2, l, mid);
+        build(i * 2 + 1, mid + 1, r);
+
+        merge(all(seg[i * 2]), all(seg[i * 2 + 1]), back_inserter(seg[i]));
+    };
+
+    build(1, 0, y - 1);
+
+    function<int(int, int, int, int, int, int)> query = [&](int i, int l, int r, int tl, int tr, int v) -> int {
+        if (l > tr || r < tl) {
+            return 0;
+        }
+
+        if (l >= tl && r <= tr) {
+            auto lower = lower_bound(all(seg[i]), v);
+            return seg[i].end() - lower;
+        }
+
+        int mid = (l + r) / 2;
+
+        return query(i * 2, l, mid, tl, tr, v) + query(i * 2 + 1, mid + 1, r, tl, tr, v);
+    };
+
+    while (n--) {
+        int a, p ,f;
+        cin >> a >> p >> f;
+
+        if (fds[a - 1] >= p) {
+            cout << "0\n";
+            continue;
+        }
+
+        cout << query(1, 0, y - 1, a - 1, a + f - 1, p) << '\n';
+    }
+}

2022 Benelux Algorithm Programming Contest (BAPC 22)/F. Failing Flagship.cpp

@@ -0,0 +1,170 @@
+/* Problem URL: https://codeforces.com/gym/104020/problem/F */
+
+#include <bits/stdc++.h>
+
+using namespace std;
+
+#define V vector
+
+#define rmin(a, b) a = min(a, b)
+#define rmax(a, b) a = max(a, b)
+
+#define rep(i, lim) for (size_t i = 0; i < (lim); i++)
+#define nrep(i, s, lim) for (size_t 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;
+}
+
+#define double long double
+
+int main()
+{
+    ios::sync_with_stdio(false);
+    cin.tie(nullptr);
+
+    string a, b;
+    cin >> a >> b;
+
+    double ang1;
+    double ang2;
+
+    map<string, double> var;
+    var["N"] = 0;
+    var["E"] = 90;
+    var["S"] = 180;
+    var["W"] = 270;
+    var["NE"] = 45;
+    var["SE"] = 135;
+    var["SW"] = 225;
+    var["NW"] = 315;
+
+    if (a.size() == 1) {
+        ang1 = var[a];
+    } else {
+        ang1 = var[a.substr(a.size() - 2)];
+
+        map<char, double> mul;
+        mul['W'] = 1;
+        mul['E'] = 1;
+        mul['S'] = 1;
+        mul['N'] = 1;
+
+        string tmp = a.substr(a.size() - 2);
+
+        if (tmp == "NE") {
+            mul['N'] = -1;
+        } else if (tmp == "SE") {
+            mul['E'] = -1;
+        } else if (tmp == "SW") {
+            mul['S'] = -1;
+        } else {
+            mul['W'] = -1;
+        }
+
+        a.pop_back();
+        a.pop_back();
+
+        double now = 45 / (double)2;
+
+        while (!a.empty()) {
+            ang1 += now * mul[a.back()];
+            a.pop_back();
+            now /= 2;
+        }
+    }
+
+    if (b.size() == 1) {
+        ang2 = var[b];
+    } else {
+        ang2 = var[b.substr(b.size() - 2)];
+
+        map<char, double> mul;
+        mul['W'] = 1;
+        mul['E'] = 1;
+        mul['S'] = 1;
+        mul['N'] = 1;
+
+        string tmp = b.substr(b.size() - 2);
+
+        if (tmp == "NE") {
+            mul['N'] = -1;
+        } else if (tmp == "SE") {
+            mul['E'] = -1;
+        } else if (tmp == "SW") {
+            mul['S'] = -1;
+        } else {
+            mul['W'] = -1;
+        }
+
+        b.pop_back();
+        b.pop_back();
+
+        double now = 45 / (double)2;
+
+        while (!b.empty()) {
+            ang2 += now * mul[b.back()];
+            b.pop_back();
+            now /= 2;
+        }
+    }
+
+    if (ang1 < ang2) {
+        swap(ang1, ang2);
+    }
+
+    cout << fixed << setprecision(20) << min(ang1 - ang2, (ang2 - ang1) + 360) << '\n';
+}

2022 Benelux Algorithm Programming Contest (BAPC 22)/J. Jagged Skyline.cpp

@@ -0,0 +1,124 @@
+/* Problem URL: https://codeforces.com/gym/104020/problem/J */
+
+#include <bits/stdc++.h>
+
+using namespace std;
+
+#define V vector
+
+#define rmin(a, b) a = min(a, b)
+#define rmax(a, b) a = max(a, b)
+
+#define rep(i, lim) for (size_t i = 0; i < (lim); i++)
+#define nrep(i, s, lim) for (size_t 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;
+}
+
+int main()
+{
+    ios::sync_with_stdio(false);
+    cin.tie(nullptr);
+
+    ll w, h;
+    cin >> w >> h;
+
+    vi columns(w);
+    rep(i, w) {
+        columns[i] = i;
+    }
+
+    mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
+    shuffle(all(columns), rng);
+
+    ll ansx = 1;
+    ll ansy = 0;
+    repv(i, columns) {
+        if (ansy == h) {
+            break;
+        }
+        cout << "? " << i + 1 << ' ' << ansy + 1 << endl;
+
+        string a;
+        cin >> a;
+
+        if (a == "sky") {
+            continue;
+        }
+
+        ll low = ansy + 1;
+        ll high = h;
+        while (low <= high) {
+            ll mid = (high - low) / 2 + low;
+
+            cout << "? " << i + 1 << ' ' << mid << endl;
+
+            cin >> a;
+
+            if (a == "building") {
+                ansy = mid;
+                ansx = i + 1;
+                low = mid + 1;
+                continue;
+            }
+
+            high = mid - 1;
+        }
+    }
+
+    cout << "! " << ansx << ' ' << ansy << endl;
+}

2022 Benelux Algorithm Programming Contest (BAPC 22)/K. Kiosk Construction.cpp

@@ -0,0 +1,182 @@
+/* Problem URL: https://codeforces.com/gym/104020/problem/K */
+
+#include <bits/stdc++.h>
+
+using namespace std;
+
+#define V vector
+
+#define rmin(a, b) a = min(a, b)
+#define rmax(a, b) a = max(a, b)
+
+#define rep(i, lim) for (size_t i = 0; i < (lim); i++)
+#define nrep(i, s, lim) for (size_t 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;
+}
+
+int main()
+{
+    ios::sync_with_stdio(false);
+    cin.tie(nullptr);
+
+    int n, m;
+    cin >> n >> m;
+
+    set<int> attempts;
+    for (int i = 1; i <= n * m; i++) {
+        attempts.insert(i);
+    }
+
+    vvi fds(n, vi(m));
+    cin >> fds;
+    
+    auto choice = [&](int i, int j, int t) {
+        int add[4][2] = {{0, 1}, {0, -1}, {1, 0}, {-1, 0}};
+
+        int ans = INT32_MAX >> 1;
+
+        for (auto &k : add) {
+            int id = i + k[0];
+            int jd = j + k[1];
+
+            if (id >= 0 && id < n && jd >= 0 && jd < m) {
+                int now = fds[id][jd];
+                if (abs(t - now) < abs(t - ans) || (abs(t - now) == abs(t - ans) && abs(fds[i][j] - now) < abs(fds[i][j] - ans))) {
+                    ans = now;
+                }
+            }
+        }
+
+        return ans;
+    };
+
+    vvvi graph(n * m, vvi(n * m));
+    vvvi look(n * m, vvi(n * m));
+
+    for (int i = 1; i <= n * m; i++) {
+        rep(j, n) {
+            rep(k, m) {
+                if (fds[j][k] == i) {
+                    continue;
+                }
+
+                int tmp = choice(j, k, i);
+                graph[i - 1][tmp - 1].push_back(fds[j][k] - 1);
+                look[i - 1][fds[j][k] - 1].push_back(tmp - 1);
+            }
+        }
+    }
+
+    vvi depth(n * m, vi(n * m, 0));
+
+    V<bool> vis(n * m);
+    function<void(int, int, int)> dfs = [&](int i, int t, int d) {
+        vis[i] = true;
+        depth[i][t] = d;
+
+        for (auto j : graph[t][i]) {
+            if (vis[j]) {
+                continue;
+            }
+
+            dfs(j, t, d + 1);
+        }
+    };
+
+    rep(i, n * m) {
+        fill(all(vis), false);
+
+        dfs(i, i, 0);
+
+        auto itr = attempts.begin();
+        while (itr != attempts.end()) {
+            if (!vis[*itr]) {
+                itr = attempts.erase(itr);
+            } else {
+                itr++;
+            }
+        }
+
+        if (attempts.empty()) {
+            break;
+        }
+    }
+
+    if (attempts.empty()) {
+        cout << "impossible\n";
+        return 0;
+    }
+
+    int ans = 0;
+    int minimal = INT32_MAX >> 1;
+
+    for (auto i : attempts) {
+        int get = 0;
+
+        for (auto j : depth[i]) {
+            rmax(get, j);
+        }
+
+        if (get < minimal) {
+            ans = i;
+            minimal = get;
+        }
+    }
+
+    cout << ans + 1 << ' ' << minimal << '\n';
+}

2022 USP Try-outs/B. Tuk-Tuk Express.cpp

@@ -0,0 +1,196 @@
+/* Problem URL: https://codeforces.com/gym/103934/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;
+}
+
+int main()
+{
+    ios::sync_with_stdio(false);
+    cin.tie(nullptr);
+
+    ll c, x, t, n;
+    cin >> c >> x >> t >> n;
+
+    ll t1, t2, t3;
+    cin >> t1 >> t2 >> t3;
+
+    if (c == 1) {
+        cout << max({t - t1, t - t2, t - t3}) << '\n';
+        return 0;
+    }
+
+    vl count(3);
+    vl prev(3);
+    vl prevadd(3);
+
+    vl ti = {t1, t2, t3};
+
+    ll ans = 0;
+
+    V<pair<ll, ll>> fds(n);
+    repv(i, fds) {
+        cin >> i.first >> i.second;
+    }
+
+    sortv(fds);
+
+    auto binsearch = [&](ll low, ll high, ll lim) {
+        ll ans = 0;
+
+        while (low <= high) {
+            ll mid = (high + low) >> 1;
+
+            if (x * mid <= lim) {
+                ans = mid;
+                low = mid + 1;
+                continue;
+            }
+
+            high = mid - 1;
+        }
+
+        return ans;
+    };
+
+    auto updateprev = [&](int i, ll time) {
+        if (time - prev[i] <= x) {
+            return;
+        }
+
+        if (prev[i] + x + ti[i] > t) {
+            count[i] = 0;
+            ll diff = time - prev[i];
+            ll binans = binsearch(0, diff / x, t - ti[i] - prev[i]);
+            if (prev[i] + x * binans + ti[i] < t) {
+                rmax(ans, prev[i] + x * binans);
+            }
+            prev[i] += diff / x * x;
+            return;
+        }
+
+        ll diff = time - prev[i];
+        ll binans = binsearch(0, diff / x, t - ti[i] - prev[i]);
+        if (prev[i] + x * binans + ti[i] < t) {
+            rmax(ans, prev[i] + x * binans);
+        }
+        prev[i] += diff / x * x;
+        count[i] = 0;
+
+        return;
+    };
+
+    auto updatetime = [&](int i, ll time) {
+        if (count[i] < c - 1) {
+            return;
+        }
+
+        if (count[i] == c) {
+            if (prevadd[i] + ti[i] <= min(t, time)) {
+                rmax(ans, min(t, time) - ti[i]);
+            }
+
+            if (time + ti[i] <= t) {
+                rmax(ans, time);
+            }
+
+            count[i] = 0;
+            prev[i] = time;
+            prevadd[i] = time;
+            return;
+        }
+
+        if (time + ti[i] <= t) {
+            rmax(ans, time);
+        }
+
+        prevadd[i] = time;
+    };
+
+    repv(i, fds) {
+        ll time = i.first;
+
+        updateprev(0, time);
+        updateprev(1, time);
+        updateprev(2, time);
+
+        count[i.second - 1]++;
+
+        updatetime(0, time);
+        updatetime(1, time);
+        updatetime(2, time);
+    }
+
+    cout << ans << '\n';
+}

2022-2023 ICPC Brazil Subregional Programming Contest/A. Finding Maximal Non-Trivial Monotones.cpp

@@ -0,0 +1,96 @@
+/* Problem URL: https://codeforces.com/gym/103960/problem/A */
+
+#include <bits/stdc++.h>
+
+using namespace std;
+
+#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;
+}
+
+int main()
+{
+    ios::sync_with_stdio(false);
+    cin.tie(nullptr);
+
+    int n;
+    string a;
+    cin >> n >> a;
+
+    int ans = 0;
+    int count = 0;
+    repv(i, a) {
+        if (i == 'b') {
+            ans += count >= 2 ? count : 0;
+            count = 0;
+            continue;
+        }
+
+        count++;
+    }
+
+    ans += count >= 2 ? count : 0;
+
+    cout << ans << '\n';
+}

2022-2023 ICPC Brazil Subregional Programming Contest/D. Displacing Particles.cpp

@@ -0,0 +1,108 @@
+/* Problem URL: https://codeforces.com/gym/103960/problem/D */
+
+#include <bits/stdc++.h>
+
+using namespace std;
+
+#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;
+}
+
+int main()
+{
+    ios::sync_with_stdio(false);
+    cin.tie(nullptr);
+
+    int n, is, js;
+    cin >> n >> is >> js;
+
+    int inf = INT32_MAX >> 1;
+    vi dp(1 << n, inf);
+
+    auto bfs = [&]() {
+        queue<int> q;
+        
+        dp[1 << (n - 1)] = 0;
+        q.push(1 << (n - 1));
+
+        while (!q.empty()) {
+            int i = q.front();
+            q.pop();
+
+            if (dp[i >> 1] > dp[i] + 1) {
+                dp[i >> 1] = dp[i] + 1;
+                q.push(i >> 1);
+            }
+
+            if (dp[(i + (1 << n)) >> 1] > dp[i] + 1) {
+                dp[(i + (1 << n)) >> 1] = dp[i] + 1;
+                q.push((i + (1 << n)) >> 1);
+            }
+        }
+    };
+
+    bfs();
+
+    cout << dp[is] << '\n';
+}

2022-2023 ICPC Brazil Subregional Programming Contest/E. Eliminating Ballons.cpp

@@ -0,0 +1,99 @@
+/* Problem URL: https://codeforces.com/gym/103960/problem/E */
+
+#include <bits/stdc++.h>
+
+using namespace std;
+
+#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;
+}
+
+int main()
+{
+    ios::sync_with_stdio(false);
+    cin.tie(nullptr);
+
+    int n;
+    cin >> n;
+
+    vi c(1e6 + 1, 0);
+
+    int ans = 0;
+
+    while (n--) {
+        int now;
+        cin >> now;
+
+        if (c[now] == 0) {
+            ans++;
+            c[now - 1]++;
+            continue;
+        }
+
+        c[now]--;
+        c[now - 1]++;
+    }
+
+    cout << ans << '\n';
+}

2022-2023 ICPC Brazil Subregional Programming Contest/F. Multidimensional Hangman.cpp

@@ -0,0 +1,150 @@
+/* Problem URL: https://codeforces.com/gym/103960/problem/F */
+
+#include <bits/stdc++.h>
+
+using namespace std;
+
+#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;
+}
+
+int main()
+{
+    ios::sync_with_stdio(false);
+    cin.tie(nullptr);
+
+    int n, c;
+    cin >> n >> c;
+
+    vvi trie(1, vi(26));
+    vvi count(1, vi(26));
+    
+    function<int(string&, int, int)> add = [&](string &a, int i, int p) {
+        if (a[i] == '*') {
+            int maximal = 0;
+            rep(j, 26) {
+                if (trie[p][j] == 0) {
+                    trie[p][j] = trie.size();
+                    trie.emplace_back(26);
+                    count.emplace_back(26);
+                }
+
+                if (i == c - 1) {
+                    count[p][j]++;
+                    rmax(maximal, count[p][j]);
+                    continue;
+                }
+
+                rmax(count[p][j], add(a, i + 1, trie[p][j]));
+                rmax(maximal, count[p][j]);
+            }
+
+            return maximal;
+        }
+
+        if (trie[p][a[i] - 'a'] == 0) {
+            trie[p][a[i] - 'a'] = trie.size();
+            trie.emplace_back(26);
+            count.emplace_back(26);
+        }
+
+        if (i == c - 1) {
+            count[p][a[i] - 'a']++;
+            return count[p][a[i] - 'a'];
+        }
+
+        rmax(count[p][a[i] - 'a'], add(a, i + 1, trie[p][a[i] - 'a']));
+
+        return count[p][a[i] - 'a'];
+    };
+
+    while (n--) {
+        string f;
+        cin >> f;
+
+        add(f, 0, 0);
+    }
+
+    string ans;
+    int now = 0;
+    int ansc = 0;
+
+    rep(i, c) {
+        int tmp = 0;
+        int maximal = 0;
+
+        rep(j, 26) {
+            if (count[now][j] > maximal) {
+                maximal = count[now][j];
+                tmp = j;
+            }
+        }
+
+        ans.push_back(tmp + 'a');
+        ansc = maximal;
+        now = trie[now][tmp];
+    }
+
+    cout << ans << ' ' << ansc << '\n';
+}

2022-2023 ICPC Brazil Subregional Programming Contest/H. Helping the Transit.cpp

@@ -0,0 +1,185 @@
+/* Problem URL: https://codeforces.com/gym/103960/problem/H */
+
+#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;
+}
+
+int main()
+{
+    ios::sync_with_stdio(false);
+    cin.tie(nullptr);
+
+    int n, m;
+    cin >> n >> m;
+
+    vvi graph(n);
+    vvi inv(n);
+    vvi comp(n);
+
+    while (m--) {
+        int a, b;
+        cin >> a >> b;
+        a--, b--;
+
+        graph[a].push_back(b);
+        inv[b].push_back(a);
+        comp[a].push_back(b);
+        comp[b].push_back(a);
+    }
+
+    stack<int> preorder;
+
+    V<bool> vis(n);
+
+    function<void(int)> getpre = [&](int i) {
+        vis[i] = true;
+
+        for (auto j : graph[i]) {
+            if (vis[j]) {
+                continue;
+            }
+
+            getpre(j);
+        }
+
+        preorder.push(i);
+    };
+
+    rep(i, n) {
+        if (vis[i]) {
+            continue;
+        }
+
+        getpre(i);
+    }
+
+    int g = 0;
+    fill(all(vis), false);
+    V<set<int>> condin;
+    V<set<int>> condout;
+    vi group(n, -1);
+
+    function<void(int)> dfs = [&](int i) {
+        vis[i] = true;
+        group[i] = g;
+
+        for (auto j : inv[i]) {
+            if (group[j] != -1 && group[j] != g) {
+                condin[g].insert(group[j]);
+                condout[group[j]].insert(g);
+                continue;
+            }
+
+            if (vis[j]) {
+                continue;
+            }
+
+            dfs(j);
+        }
+    };
+
+    while (!preorder.empty()) {
+        int i = preorder.top();
+        preorder.pop();
+
+        if (vis[i]) {
+            continue;
+        }
+
+        condin.emplace_back();
+        condout.emplace_back();
+        dfs(i);
+        g++;
+    }
+
+    if (g == 1) {
+        cout << "0\n";
+        return 0;
+    }
+
+    int nonein = 0;
+    int noneout = 0;
+
+    rep(i, g) {
+        if (condin[i].empty()) {
+            nonein++;
+        }
+
+        if (condout[i].empty()) {
+            noneout++;
+        }
+    }
+
+    cout << max(nonein, noneout) << '\n';
+}

2022-2023 ICPC Brazil Subregional Programming Contest/I. Intercepting Information.cpp

@@ -0,0 +1,88 @@
+/* Problem URL: https://codeforces.com/gym/103960/problem/I */
+
+#include <bits/stdc++.h>
+
+using namespace std;
+
+#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;
+}
+
+int main()
+{
+    ios::sync_with_stdio(false);
+    cin.tie(nullptr);
+
+    rep(i, 9) {
+        int n;
+        cin >> n;
+
+        if (n == 9) {
+            cout << "F\n";
+            return 0;
+        }
+    }
+
+    cout << "S\n";
+}

2022-2023 ICPC Brazil Subregional Programming Contest/J. Playing 23.cpp

@@ -0,0 +1,142 @@
+/* Problem URL: https://codeforces.com/gym/103960/problem/J */
+
+#include <bits/stdc++.h>
+
+using namespace std;
+
+#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;
+}
+
+int main()
+{
+    ios::sync_with_stdio(false);
+    cin.tie(nullptr);
+
+    int n;
+    cin >> n;
+
+    map<string, int> card;
+
+    vi cards(11, 4);
+    cards[10] = 16;
+
+    int john = 0;
+    int mary = 0;
+
+    vi value(14, 0);
+    nrep(i, 1, 11) {
+        value[i] = i;
+    }
+
+    value[11] = 10;
+    value[12] = 10;
+    value[13] = 10;
+
+    int c1, c2;
+    cin >> c1 >> c2;
+    cards[value[c1]]--;
+    cards[value[c2]]--;
+
+    john = value[c1] + value[c2];
+
+    cin >> c1 >> c2;
+    cards[value[c1]]--;
+    cards[value[c2]]--;
+
+    mary = value[c1] + value[c2];
+
+    while (n--) {
+        int c;
+        cin >> c;
+
+        cards[value[c]]--;
+        john += value[c];
+        mary += value[c];
+    }
+
+    if (mary >= john) {
+        if (23 - mary > 10 || cards[23 - mary] == 0) {
+            cout << "-1\n";
+            return 0;
+        }
+
+        cout << 23 - mary << '\n';
+        return 0;
+    }
+
+    nrep(i, 1, 11) {
+        if (mary + i > 23) {
+            cout << "-1\n";
+            return 0;
+        }
+
+        if (john + i > 23 && cards[i] > 0) {
+            cout << i << '\n';
+            return 0;
+        }
+    }
+
+    cout << "-1\n";
+}

2023 ICPC HIAST Collegiate Programming Contest/K. Sam-Oh, the funny coach.cpp

@@ -0,0 +1,139 @@
+/* Problem URL: https://codeforces.com/gym/104493/problem/K */
+
+#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;
+}
+
+int main()
+{
+    ios::sync_with_stdio(false);
+    cin.tie(nullptr);
+
+    int n, m;
+    cin >> n >> m;
+
+    vvi count(n, vi(26));
+
+    rep(i, n) {
+        string a;
+        cin >> a;
+
+        repv(j, a) {
+            count[i][j - 'a']++;
+        }
+    }
+
+    int q;
+    cin >> q;
+    while (q--) {
+        int a, b;
+        cin >> a >> b;
+        a--, b--;
+
+        int ans = 0;
+        vi pos(2);
+
+        rep(i, 26) {
+            int act0 = count[a][i];
+            int act1 = count[b][i];
+            if (pos[0] <= pos[1]) {
+                int diff = pos[1] - pos[0];
+                if (act0 < diff) {
+                    pos[0] += count[a][i];
+                    pos[1] += count[b][i];
+                    continue;
+                }
+
+                act0 -= diff;
+                pos[0] += diff;
+            } else {
+                int diff = pos[0] - pos[1];
+                if (act1 < diff) {
+                    pos[0] += count[a][i];
+                    pos[1] += count[b][i];
+                    continue;
+                }
+
+                act1 -= diff;
+                pos[1] += diff;
+            }
+
+            ans += min(act0, act1);
+            pos[0] += act0;
+            pos[1] += act1;
+        }
+
+        cout << ans << '\n';
+    }
+}

2023 United Kingdom and Ireland Programming Contest (UKIEPC 2023)/A. Assessment Disruption.cpp

@@ -0,0 +1,83 @@
+/* Problem URL: https://codeforces.com/gym/104785/problem/A */
+
+#include <bits/stdc++.h>
+
+using namespace std;
+
+#define V vector
+
+#define rmin(a, b) a = min(a, b)
+#define rmax(a, b) a = max(a, b)
+
+#define rep(i, lim) for (size_t i = 0; i < (lim); i++)
+#define nrep(i, s, lim) for (size_t 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;
+}
+
+int main()
+{
+    ios::sync_with_stdio(false);
+    cin.tie(nullptr);
+
+    int n, w;
+    cin >> n >> w;
+
+    rep(i, n) {
+        cout << w - i << ' ' << 500 << '\n';
+    }
+}

2023 United Kingdom and Ireland Programming Contest (UKIEPC 2023)/F. Fast Forward.cpp

@@ -0,0 +1,157 @@
+/* Problem URL: https://codeforces.com/gym/104785/problem/F */
+
+#include <bits/stdc++.h>
+
+using namespace std;
+
+#define V vector
+
+#define rmin(a, b) a = min(a, b)
+#define rmax(a, b) a = max(a, b)
+
+#define rep(i, lim) for (size_t i = 0; i < (lim); i++)
+#define nrep(i, s, lim) for (size_t 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;
+}
+
+int parent[(ll)2e6 + 1][21];
+
+int main()
+{
+    ios::sync_with_stdio(false);
+    cin.tie(nullptr);
+
+    ll n, c;
+    cin >> n >> c;
+
+    vl fds(n);
+    cin >> fds;
+    rep(i, n) {
+        fds.push_back(fds[i]);
+    }
+
+    vl pref(n * 2 + 1);
+    rep(i, n * 2) {
+        pref[i + 1] = pref[i] + fds[i];
+    }
+
+    vvi graph(n * 2 + 1);
+    rep(i, n * 2) {
+        int ans = -1;
+        int low = i;
+        int high = min((int)i + n - 1, n * 2 - 1);
+
+        while (low <= high) {
+            int mid = (low + high) / 2;
+
+            if (pref[mid + 1] - pref[i] >= c) {
+                ans = mid + 1;
+                high = mid - 1;
+                continue;
+            }
+
+            low = mid + 1;
+        }
+
+        if (ans != -1) {
+            graph[ans].push_back(i);
+        }
+    }
+
+    int inf = INT32_MAX >> 1;
+    rep(i, n * 2 + 1) {
+        rep(j, 21) {
+            parent[i][j] = inf;
+        }
+    }
+    // vvi parent(n * 2 + 1, vi(21, inf));
+    V<bool> vis(n * 2 + 1, false);
+
+    function<void(int, int)> dfs = [&](int i, int p){
+        parent[i][0] = p;
+        vis[i] = true;
+
+        for (int j = 1; j <= 20 && parent[i][j - 1] != inf; j++) {
+            parent[i][j] = parent[parent[i][j - 1]][j - 1];
+        }
+
+        for (auto j : graph[i]) {
+            dfs(j, i);
+        }
+    };
+
+    for (int i = n * 2; i >= 0; i--) {
+        if (!vis[i]) {
+            dfs(i, inf);
+        }
+    }
+
+    rep(i, n) {
+        int now = i;
+        int ans = 0;
+        for (int j = 20; j >= 0; j--) {
+            if (parent[now][j] < i + n) {
+                ans += (1 << j);
+                now = parent[now][j];
+            }
+        }
+
+        cout << ans << ' ';
+    }
+    cout << '\n';
+}

2023 United Kingdom and Ireland Programming Contest (UKIEPC 2023)/K. Kernel Scheduler.cpp

@@ -0,0 +1,108 @@
+/* Problem URL: https://codeforces.com/gym/104785/problem/K */
+
+#include <bits/stdc++.h>
+
+using namespace std;
+
+#define V vector
+
+#define rmin(a, b) a = min(a, b) 
+#define rmax(a, b) a = max(a, b)
+
+#define rep(i, lim) for (size_t i = 0; i < (lim); i++)
+#define nrep(i, s, lim) for (size_t 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;
+}
+
+int main()
+{
+    ios::sync_with_stdio(false);
+    cin.tie(nullptr);
+
+    int n, m;
+    cin >> n >> m;
+
+    vi dec;
+    vi cres;
+    rep(i, m) {
+        int a, b;
+        cin >> a >> b;
+
+        if (a > b) {
+            dec.push_back(i + 1);
+        } else {
+            cres.push_back(i + 1);
+        }
+    }
+
+    cout << "YES\n";
+    if (dec.size() > cres.size()) {
+        cout << dec.size() << '\n';
+        for (auto i : dec) {
+            cout << i << ' ';
+        }
+        cout << '\n';
+        return 0;
+    }
+
+    cout << cres.size() << '\n';
+    for (auto i : cres) {
+        cout << i << ' ';
+    }
+    cout << '\n';
+}

2023 United Kingdom and Ireland Programming Contest (UKIEPC 2023)/L. Last One Standing.cpp

@@ -0,0 +1,116 @@
+/* Problem URL: https://codeforces.com/gym/104785/problem/L */
+
+#include <bits/stdc++.h>
+
+using namespace std;
+
+#define V vector
+
+#define rmin(a, b) a = min(a, b)
+#define rmax(a, b) a = max(a, b)
+
+#define rep(i, lim) for (size_t i = 0; i < (lim); i++)
+#define nrep(i, s, lim) for (size_t 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;
+}
+
+int main()
+{
+    ios::sync_with_stdio(false);
+    cin.tie(nullptr);
+
+    ll h1, d1, t1;
+    cin >> h1 >> d1 >> t1;
+    ll h2, d2, t2;
+    cin >> h2 >> d2 >> t2;
+
+    h1 -= d2;
+    h2 -= d1;
+
+    if (h1 < 0 && h2 < 0) {
+        cout << "draw\n";
+        return 0;
+    }
+
+    if (h1 < 0) {
+        cout << "player two\n";
+        return 0;
+    }
+
+    if (h2 < 0) {
+        cout << "player one\n";
+        return 0;
+    }
+
+    ll killt1 = (h1 / d2 + min(1LL, h1 % d2)) * t2;
+    ll killt2 = (h2 / d1 + min(1LL, h2 % d1)) * t1;
+
+    if (killt1 == killt2) {
+        cout << "draw\n";
+        return 0;
+    }
+
+    if (killt1 > killt2) {
+        cout << "player one\n";
+        return 0;
+    }
+    
+    if (killt2 > killt1) {
+        cout << "player two\n";
+    }
+}

2023 United Kingdom and Ireland Programming Contest (UKIEPC 2023)/M. Mini-Tetris 3023.cpp

@@ -0,0 +1,91 @@
+/* Problem URL: https://codeforces.com/gym/104785/problem/M */
+
+#include <bits/stdc++.h>
+
+using namespace std;
+
+#define V vector
+
+#define rmin(a, b) a = min(a, b)
+#define rmax(a, b) a = max(a, b)
+
+#define rep(i, lim) for (size_t i = 0; i < (lim); i++)
+#define nrep(i, s, lim) for (size_t 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;
+}
+
+int main()
+{
+    ios::sync_with_stdio(false);
+    cin.tie(nullptr);
+
+    int a, b, c;
+    cin >> a >> b >> c;
+
+    int squares = 2 * a;
+
+    int ret = 0;
+    if (c > 1 && b >= 1) {
+        c -= 2;
+        ret += 2 + b * 2;
+        ret++;
+    }
+
+    ret += 3 * (c / 2);
+    cout << squares + ret << '\n';
+}

2023 United Kingdom and Ireland Programming Contest (UKIEPC 2023)/N. Naming Wine Bottles.cpp

@@ -0,0 +1,131 @@
+/* Problem URL: https://codeforces.com/gym/104785/problem/N */
+
+#include <bits/stdc++.h>
+
+using namespace std;
+
+#define V vector
+
+#define rmin(a, b) a = min(a, b)
+#define rmax(a, b) a = max(a, b)
+
+#define rep(i, lim) for (size_t i = 0; i < (lim); i++)
+#define nrep(i, s, lim) for (size_t 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;
+}
+
+int main()
+{
+    ios::sync_with_stdio(false);
+    cin.tie(nullptr);
+
+    int n;
+    cin >> n;
+
+    map<string, string> var;
+    var["0.75"] = "standard";
+    var["15"] = "nebuchadnezzar";
+    var["12"] = "balthazar";
+
+    string now = "a";
+
+    while (n--) {
+        string a;
+        cin >> a;
+
+        size_t i = 0;
+        string b;
+        while (a[i] != 'L' && a[i] == '0') {
+            i++;
+        }
+
+        if (a[i] == 'L') {
+            b = "0";
+        } else {
+            while (a[i] != '.' && a[i] != 'L') {
+                b.push_back(a[i]);
+                i++;
+            }
+
+            if (a[i] != 'L') {
+                i++;
+                string tmp;
+                while (a[i] != 'L') {
+                    while (a[i] == '0') {
+                        tmp.push_back(a[i]);
+                        i++;
+                    }
+
+                    if (a[i] != 'L') {
+                        b += tmp;
+                        b += a[i];
+                        i++;
+                    }
+                }
+            }
+        }
+
+        auto itr = var.find(b);
+        if (itr == var.end()) {
+            var[b] = now;
+            now += 'a';
+        }
+
+        cout << var[b] << '\n';
+    }
+}

2023-2024 ACM-ICPC Latin American Regional Programming Contest/J. Journey of the Robber.cpp

@@ -0,0 +1,153 @@
+/* Problem URL: https://codeforces.com/gym/104736/problem/J */
+
+#include <bits/stdc++.h>
+
+using namespace std;
+
+#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;
+}
+
+int main()
+{
+    ios::sync_with_stdio(false);
+    cin.tie(nullptr);
+
+    int n;
+    cin >> n;
+
+    vvi graph(n);
+
+    rep(i, n - 1) {
+        int a, b;
+        cin >> a >> b;
+        a--, b--;
+
+        graph[a].push_back(b);
+        graph[b].push_back(a);
+    }
+    vi ans(n);
+    int prev = n - 1;
+
+    if (n > 1) {
+        n = 1 << (32 - __builtin_clz(n - 1));
+    }
+
+    int inf = INT32_MAX >> 1;
+    vi seg(n * 2, inf);
+
+    auto update = [&](int i, int v) {
+        seg[i + n] = v;
+        for (int j = (i + n) / 2; j > 0; j /= 2) {
+            seg[j] = min(seg[j * 2], seg[j * 2 + 1]);
+        }
+    };
+
+    function<int(int, int, int, int, int)> search = [&](int i, int l, int r, int tl, int tr) {
+        if (l > tr || r < tl || seg[i] == inf) {
+            return -1;
+        }
+
+        if (l == r) {
+            return i - n;
+        }
+
+        if (l >= tl && r <= tr) {
+            int mid = (l + r) / 2;
+            if (seg[i * 2] <= seg[i * 2 + 1]) {
+                return search(i * 2, l, mid, tl, tr);
+            }
+            return search(i * 2 + 1, mid + 1, r, tl, tr);
+        }
+
+        int mid = (l + r) / 2;
+        int ans1 = search(i * 2, l, mid, tl, tr);
+        int ans2 = search(i * 2 + 1, mid + 1, r, tl, tr);
+
+        if (ans2 == -1 || seg[ans1 + n] < seg[ans2 + n] || (seg[ans1 + n] == seg[ans2 + n] && ans1 < ans2)) {
+            return ans1;
+        }
+        return ans2;
+    };
+
+    function<void(int, int, int)> dfs = [&](int i, int p, int d) {
+        update(i, d);
+
+        ans[i] = search(1, 0, n - 1, i, n - 1) + 1;
+
+        for (auto j : graph[i]) {
+            if (j == p) {
+                continue;
+            }
+
+            dfs(j, i, d - 1);
+        }
+
+        update(i, inf);
+    };
+
+    dfs(prev, -1, inf - 1);
+
+    cout << ans;
+}

2023-2024 ICPC Brazil Subregional Programming Contest/A. Amusement Park Adventure.cpp

@@ -0,0 +1,91 @@
+/* Problem URL: https://codeforces.com/gym/104555/problem/A */
+
+#include <bits/stdc++.h>
+
+using namespace std;
+
+#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;
+}
+
+int main()
+{
+    ios::sync_with_stdio(false);
+    cin.tie(nullptr);
+
+    int n, h;
+    cin >> n >> h;
+
+    int ans = 0;
+    while (n--) {
+        int num;
+        cin >> num;
+
+        if (h >= num) {
+            ans++;
+        }
+    }
+
+    cout << ans << '\n';
+}

2023-2024 ICPC Brazil Subregional Programming Contest/E. Extracting Pollen.cpp

@@ -0,0 +1,109 @@
+/* Problem URL: https://codeforces.com/gym/104555/problem/E */
+
+#include <bits/stdc++.h>
+
+using namespace std;
+
+#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;
+}
+
+int main()
+{
+    ios::sync_with_stdio(false);
+    cin.tie(nullptr);
+
+    ll n, k;
+    cin >> n >> k;
+
+    vi count(1e6 + 1);
+    count[0] = 1e9;
+
+    while (n--) {
+        int num;
+        cin >> num;
+
+        count[num]++;
+    }
+
+    auto calc = [&](int i) {
+        int tmp = i;
+        int sum = 0;
+        while (tmp > 0) {
+            sum += tmp % 10;
+            tmp /= 10;
+        }
+
+        return sum;
+    };
+
+    int ans = 1e6;
+    while (count[ans] < k)  {
+        k -= count[ans];
+        count[ans - calc(ans)] += count[ans];
+        ans--;
+    }
+
+    cout << calc(ans) << '\n';
+}

2023-2024 ICPC Brazil Subregional Programming Contest/F. Fatigue-Fighting Vacation.cpp

@@ -0,0 +1,101 @@
+/* Problem URL: https://codeforces.com/gym/104555/problem/F */
+
+#include <bits/stdc++.h>
+
+using namespace std;
+
+#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;
+}
+
+int main()
+{
+    ios::sync_with_stdio(false);
+    cin.tie(nullptr);
+
+    int d, c, r;
+    cin >> d >> c >> r;
+
+    int ans = r;
+
+    vi fds(c);
+    cin >> fds;
+
+    while (r--) {
+        int num;
+        cin >> num;
+        d += num;
+    }
+
+    rep(i, fds.size()) {
+        if (d >= fds[i]) {
+            d -= fds[i];
+            ans++;
+        } else {
+            break;
+        }
+    }
+
+    cout << ans << '\n';
+}

2023-2024 ICPC Brazil Subregional Programming Contest/G. Great Treaty of Byteland.cpp

@@ -0,0 +1,314 @@
+/* Problem URL: https://codeforces.com/gym/104555/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>;
+
+#define sq(x) ((x)*(ll)(x))
+
+struct pt { // ponto
+	int x, y;
+	pt(int x_ = 0, int y_ = 0) : x(x_), y(y_) {}
+	bool operator < (const pt p) const {
+		if (x != p.x) return x < p.x;
+		return y < p.y;
+	}
+	bool operator == (const pt p) const {
+		return x == p.x and y == p.y;
+	}
+	pt operator + (const pt p) const { return pt(x+p.x, y+p.y); }
+	pt operator - (const pt p) const { return pt(x-p.x, y-p.y); }
+	pt operator * (const int c) const { return pt(x*c, y*c); }
+	ll operator * (const pt p) const { return x*(ll)p.x + y*(ll)p.y; }
+	ll operator ^ (const pt p) const { return x*(ll)p.y - y*(ll)p.x; }
+	friend istream& operator >> (istream& in, pt& p) {
+		return in >> p.x >> p.y;
+	}
+};
+
+struct line { // reta
+	pt p, q;
+	line() {}
+	line(pt p_, pt q_) : p(p_), q(q_) {}
+	friend istream& operator >> (istream& in, line& r) {
+		return in >> r.p >> r.q;
+	}
+};
+
+// PONTO & VETOR
+
+ll dist2(pt p, pt q) { // quadrado da distancia
+	return sq(p.x - q.x) + sq(p.y - q.y);
+}
+
+ll sarea2(pt p, pt q, pt r) { // 2 * area com sinal
+	return (q-p)^(r-q);
+}
+
+bool col(pt p, pt q, pt r) { // se p, q e r sao colin.
+	return sarea2(p, q, r) == 0;
+}
+
+bool ccw(pt p, pt q, pt r) { // se p, q, r sao ccw
+	return sarea2(p, q, r) > 0;
+}
+
+int quad(pt p) { // quadrante de um ponto
+	return (p.x<0)^3*(p.y<0);
+}
+
+bool compare_angle(pt p, pt q) { // retorna se ang(p) < ang(q)
+	if (quad(p) != quad(q)) return quad(p) < quad(q);
+	return ccw(q, pt(0, 0), p);
+}
+
+pt rotate90(pt p) { // rotaciona 90 graus
+	return pt(-p.y, p.x);
+}
+
+// RETA
+
+bool isinseg(pt p, line r) { // se p pertence ao seg de r
+	pt a = r.p - p, b = r.q - p;
+	return (a ^ b) == 0 and (a * b) <= 0;
+}
+
+bool interseg(line r, line s) { // se o seg de r intersecta o seg de s
+	if (isinseg(r.p, s) or isinseg(r.q, s)
+		or isinseg(s.p, r) or isinseg(s.q, r)) return 1;
+
+	return ccw(r.p, r.q, s.p) != ccw(r.p, r.q, s.q) and
+			ccw(s.p, s.q, r.p) != ccw(s.p, s.q, r.q);
+}
+
+int segpoints(line r) { // numero de pontos inteiros no segmento
+	return 1 + __gcd(abs(r.p.x - r.q.x), abs(r.p.y - r.q.y));
+}
+
+double get_t(pt v, line r) { // retorna t tal que t*v pertence a reta r
+	return (r.p^r.q) / (double) ((r.p-r.q)^v);
+}
+
+// POLIGONO
+
+// quadrado da distancia entre os retangulos a e b (lados paralelos aos eixos)
+// assume que ta representado (inferior esquerdo, superior direito)
+ll dist2_rect(pair<pt, pt> a, pair<pt, pt> b) {
+	int hor = 0, vert = 0;
+	if (a.second.x < b.first.x) hor = b.first.x - a.second.x;
+	else if (b.second.x < a.first.x) hor = a.first.x - b.second.x;
+	if (a.second.y < b.first.y) vert = b.first.y - a.second.y;
+	else if (b.second.y < a.first.y) vert = a.first.y - b.second.y;
+	return sq(hor) + sq(vert);
+}
+
+ll polarea2(vector<pt> v) { // 2 * area do poligono
+	ll ret = 0;
+	for (int i = 0; i < v.size(); i++)
+		ret += sarea2(pt(0, 0), v[i], v[(i + 1) % v.size()]);
+	return abs(ret);
+}
+
+// se o ponto ta dentro do poligono: retorna 0 se ta fora,
+// 1 se ta no interior e 2 se ta na borda
+int inpol(vector<pt>& v, pt p) { // O(n)
+	int qt = 0;
+	for (int i = 0; i < v.size(); i++) {
+		if (p == v[i]) return 2;
+		int j = (i+1)%v.size();
+		if (p.y == v[i].y and p.y == v[j].y) {
+			if ((v[i]-p)*(v[j]-p) <= 0) return 2;
+			continue;
+		}
+		bool baixo = v[i].y < p.y;
+		if (baixo == (v[j].y < p.y)) continue;
+		auto t = (p-v[i])^(v[j]-v[i]);
+		if (!t) return 2;
+		if (baixo == (t > 0)) qt += baixo ? 1 : -1;
+	}
+	return qt != 0;
+}
+
+vector<pt> convex_hull(vector<pt> v) { // convex hull - O(n log(n))
+	sort(v.begin(), v.end());
+	v.erase(unique(v.begin(), v.end()), v.end());
+	if (v.size() <= 1) return v;
+	vector<pt> l, u;
+	for (int i = 0; i < v.size(); i++) {
+		while (l.size() > 1 and !ccw(l.end()[-2], l.end()[-1], v[i]))
+			l.pop_back();
+		l.push_back(v[i]);
+	}
+	for (int i = v.size() - 1; i >= 0; i--) {
+		while (u.size() > 1 and !ccw(u.end()[-2], u.end()[-1], v[i]))
+			u.pop_back();
+		u.push_back(v[i]);
+	}
+	l.pop_back(); u.pop_back();
+	for (pt i : u) l.push_back(i);
+	return l;
+}
+
+ll interior_points(vector<pt> v) { // pontos inteiros dentro de um poligono simples
+	ll b = 0;
+	for (int i = 0; i < v.size(); i++)
+		b += segpoints(line(v[i], v[(i+1)%v.size()])) - 1;
+	return (polarea2(v) - b) / 2 + 1;
+}
+
+struct convex_pol {
+	vector<pt> pol;
+
+	// nao pode ter ponto colinear no convex hull
+	convex_pol() {}
+	convex_pol(vector<pt> v) : pol(convex_hull(v)) {}
+
+	// se o ponto ta dentro do hull - O(log(n))
+	bool is_inside(pt p) {
+		if (pol.size() == 0) return false;
+		if (pol.size() == 1) return p == pol[0];
+		int l = 1, r = pol.size();
+		while (l < r) {
+			int m = (l+r)/2;
+			if (ccw(p, pol[0], pol[m])) l = m+1;
+			else r = m;
+		}
+		if (l == 1) return isinseg(p, line(pol[0], pol[1]));
+		if (l == pol.size()) return false;
+		return !ccw(p, pol[l], pol[l-1]);
+	}
+	// ponto extremo em relacao a cmp(p, q) = p mais extremo q
+	// (copiado de https://github.com/gustavoM32/caderno-zika)
+	int extreme(const function<bool(pt, pt)>& cmp) {
+		int n = pol.size();
+		auto extr = [&](int i, bool& cur_dir) {
+			cur_dir = cmp(pol[(i+1)%n], pol[i]);
+			return !cur_dir and !cmp(pol[(i+n-1)%n], pol[i]);
+		};
+		bool last_dir, cur_dir;
+		if (extr(0, last_dir)) return 0;
+		int l = 0, r = n;
+		while (l+1 < r) {
+			int m = (l+r)/2;
+			if (extr(m, cur_dir)) return m;
+			bool rel_dir = cmp(pol[m], pol[l]);
+			if ((!last_dir and cur_dir) or
+					(last_dir == cur_dir and rel_dir == cur_dir)) {
+				l = m;
+				last_dir = cur_dir;
+			} else r = m;
+		}
+		return l;
+	}
+	int max_dot(pt v) {
+		return extreme([&](pt p, pt q) { return p*v > q*v; });
+	}
+	pair<int, int> tangents(pt p) {
+		auto L = [&](pt q, pt r) { return ccw(p, r, q); };
+		auto R = [&](pt q, pt r) { return ccw(p, q, r); };
+		return {extreme(L), extreme(R)};
+	}
+};
+
+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;
+}
+
+int main()
+{
+    ios::sync_with_stdio(false);
+    cin.tie(nullptr);
+
+    int n;
+    cin >> n;
+
+    map<pt, int> var;
+
+    V<pt> points(n);
+    rep(i, n) {
+        cin >> points[i].x >> points[i].y;
+        var[{points[i].x, points[i].y}] = i + 1;
+    }
+
+    convex_pol conv(points);
+
+    set<int> ans;
+
+    repv(i, points) {
+        if (inpol(conv.pol, i) == 2) {
+            ans.insert(var[i]);
+        }
+    }
+
+    repv(i, ans) {
+        cout << i << ' ';
+    }
+    cout << '\n';
+}

2023-2024 ICPC Brazil Subregional Programming Contest/H. Honest Worker.cpp

@@ -0,0 +1,114 @@
+/* Problem URL: https://codeforces.com/gym/104555/problem/H */
+
+#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;
+}
+
+int main()
+{
+    ios::sync_with_stdio(false);
+    cin.tie(nullptr);
+
+    int n;
+    ll s;
+    cin >> n >> s;
+
+    V<tuple<ll, ll, ll>> fds(n);
+    for (auto &[l, r, c] : fds) {
+        cin >> l >> r >> c;
+    }
+
+    sortv(fds);
+
+    ll ans = 0;
+    
+    ll cost = 0;
+    ll ln = 0;
+    ll rn = 0;
+    for (auto [l, r, c] : fds) {
+        ll tmp = (r - l + 1) * s - c;
+
+        if (rn < l) {
+            if (tmp > 0) {
+                cost = c;
+                ln = l;
+                rn = r;
+                ans += tmp;
+            }
+            continue;
+        }
+
+
+    }
+}

2023-2024 ICPC Brazil Subregional Programming Contest/I. Investigating Zeroes and Ones.cpp

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

2023-2024 ICPC Brazil Subregional Programming Contest/L. Lexicographical Challenge.cpp

@@ -0,0 +1,97 @@
+/* Problem URL: https://codeforces.com/gym/104555/problem/L */
+
+#include <bits/stdc++.h>
+
+using namespace std;
+
+#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;
+}
+
+int main()
+{
+    ios::sync_with_stdio(false);
+    cin.tie(nullptr);
+
+    string a;
+    int k;
+    cin >> a >> k;
+
+    V<string> fds(k);
+
+    rep(i, a.size()) {
+        fds[i % k].push_back(a[i]);
+    }
+
+    rep(i, k) {
+        sort(all(fds[i]), greater<>());
+    }
+
+    rep(i, a.size()) {
+        cout << fds[i % k].back();
+        fds[i % k].pop_back();
+    }
+
+    cout << '\n';
+}

2023-2024 ICPC Brazil Subregional Programming Contest/M. Maximizing Flight Efficiency.cpp

@@ -0,0 +1,121 @@
+/* Problem URL: https://codeforces.com/gym/104555/problem/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;
+}
+
+int main()
+{
+    ios::sync_with_stdio(false);
+    cin.tie(nullptr);
+
+    int n;
+    cin >> n;
+
+    vvl dis(n, vl(n));
+    cin >> dis;
+
+    vvl tmp = dis;
+
+    ll ans = 0;
+
+    rep(k, n) {
+        rep(i, n) {
+            rep(j, n) {
+                rmin(tmp[i][j], tmp[i][k] + tmp[k][j]);
+            }
+        }
+    }
+
+    if (tmp != dis) {
+        cout << "-1\n";
+        return 0;
+    }
+
+    ll oo = INT64_MAX >> 1;
+
+    rep(k, n) {
+        rep(i, n) {
+            rep(j, n) {
+                if (i != j && j != k && k != i && dis[i][j] == dis[i][k] + dis[k][j]) {
+                    dis[i][j] = oo;
+                    dis[j][i] = oo;
+                    ans++;
+                }
+            }
+        }
+    }
+
+    cout << ans << '\n';
+}

2024 (ICPC) Jiangxi Provincial Contest -- Official Contest/I. Neuvillette Circling.cpp

@@ -0,0 +1,193 @@
+/* Problem URL: https://codeforces.com/gym/105231/problem/I */
+
+#include <bits/stdc++.h>
+
+#pragma GCC optimize("Ofast")
+#pragma GCC optimize("unroll-loops")
+#pragma GCC target("avx2")
+#pragma GCC target("bmi,bmi2,popcnt,lzcnt")
+
+using namespace std;
+
+#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;
+}
+using pd = pair<double, double>;
+
+pd operator+(pd a, pd b) {
+    pd fds = {a.first + b.first, a.second + b.second};
+    return fds;
+}
+
+pd operator-(pd a, pd b) {
+    pd fds = {a.first - b.first, a.second - b.second};
+    return fds;
+}
+
+pd operator/(pd a, double f) {
+    return make_pair(a.first / f, a.second / f);
+}
+
+pd operator*(pd a, double f) {
+    return make_pair(a.first * f, a.second * f);
+}
+
+pd rotate90(pd a) {
+    return pd(-a.second, a.first);
+}
+
+double operator^(pd a, pd b) {
+    return a.first * b.second - a.second * b.first;
+}
+
+struct line {
+    pd p, q;
+};
+
+double get_t(pd v, line r) {
+    return (r.p^r.q) / ((r.p - r.q)^v);
+}
+
+double EPS = 1e-6;
+double inf = 1e18;
+pd inter(line r, line s)
+{
+    if (abs((r.p - r.q) ^ (s.p - s.q)) < EPS) {
+        return pd(inf, inf);
+    }
+
+    r.q = r.q - r.p, s.p = s.p - r.p, s.q = s.q - r.p;
+    return (r.q * get_t(r.q, s)) + r.p;
+}
+
+pd getcenter(pd a, pd b, pd c) {
+    b = (a + b)  / 2;
+    c = (a + c) / 2;
+    return inter(line(b, b + rotate90(a - b)), line(c, c + rotate90(a - c)));
+}
+
+int main()
+{
+    ios::sync_with_stdio(false);
+    cin.tie(nullptr);
+
+    int n;
+    cin >> n;
+
+    V<pair<double, double>> points(n);
+
+    repv(i, points) {
+        cin >> i.first >> i.second;
+    }
+
+    V<double> disses(n, 1e16);
+
+    auto dis = [&](pair<double, double> &a, pair<double, double> &b) {
+        double x = a.first - b.first;
+        double y = a.second - b.second;
+        return sqrt(x * x + y * y);
+    };
+
+    V<double> lol(n);
+
+    auto calc = [&](pair<double, double> center) {
+        rep(i, n) {
+            lol[i] = dis(center, points[i]);
+        }
+    };
+
+    auto search = [&](pair<double, double> point) {
+        sortv(lol);
+
+        nrep(i, 1, n) {
+            rmin(disses[i], lol[i]);
+        }
+    };
+
+    rep(i, n - 1) {
+        nrep(j, i + 1, n) {
+            pair<double, double> center = {(points[i].first + points[j].first) / 2, (points[i].second + points[j].second) / 2};
+            calc(center);
+            search(center);
+        }
+    }
+
+    rep(i, n - 2) {
+        nrep(j, i + 1, n - 1) {
+            nrep(k, j + 1, n) {
+                auto center = getcenter(points[i], points[j], points[k]);
+                calc(center);
+                search(center);
+            }
+        }
+    }
+
+    int act = 1;
+    nrep(i, 1, n) {
+        rep(j, act) {
+            cout << fixed << setprecision(8) << disses[i] << '\n';
+        }
+        act++;
+    }
+}

2024 (ICPC) Jiangxi Provincial Contest -- Official Contest/L. Campus.cpp

@@ -0,0 +1,231 @@
+/* Problem URL: https://codeforces.com/gym/105231/problem/L */
+
+#include <bits/stdc++.h>
+
+using namespace std;
+
+#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;
+}
+
+int main()
+{
+    ios::sync_with_stdio(false);
+    cin.tie(nullptr);
+
+    int n, m, k, t;
+    cin >> n >> m >> k >> t;
+
+    vl fds(n);
+    cin >> fds;
+
+    V<tuple<int, int, int>> gates;
+
+    rep(i, k) {
+        int n, l, r;
+        cin >> n >> l >> r;
+        n--;
+
+        gates.emplace_back(n, l, r);
+    }
+
+    ll inf = INT64_MAX >> 1;
+    vvl dis(n, vl(k, inf));
+
+    V<V<pair<int, ll>>> graph(n);
+
+    auto dijkstra = [&](int i, int k) {
+        priority_queue<pair<ll, int>, V<pair<ll, int>>, greater<>> pq;
+
+        dis[i][k] = 0;
+        pq.emplace(0, i);
+
+        while (!pq.empty()) {
+            auto [c, now] = pq.top();
+            pq.pop();
+
+            if (c > dis[now][k]) {
+                continue;
+            }
+
+            for (auto [j, cost] : graph[now]) {
+                if (dis[j][k] > cost + c) {
+                    dis[j][k] = cost + c;
+                    pq.emplace(cost + c, j);
+                }
+            }
+        }
+    };
+
+    while (m--) {
+        int a, b, c;
+        cin >> a >> b >> c;
+        a--, b--;
+
+        graph[a].emplace_back(b, c);
+        graph[b].emplace_back(a, c);
+    }
+
+    rep(i, k) {
+        dijkstra(get<0>(gates[i]), i);
+    }
+
+    vi pos(t + 2, 0);
+    for (auto [i, l, r] : gates) {
+        pos[l]++;
+        pos[r + 1]--;
+    }
+
+    nrep(i, 1, t) {
+        pos[i] += pos[i - 1];
+    }
+
+    vl ans(t + 2, 0);
+
+    rep(i, n) {
+        priority_queue<pair<ll, int>> pq;
+        rep(j, k) {
+            pq.emplace(dis[i][j], j);
+        }
+
+        set<tuple<ll, int ,int>> inter; 
+        while (!pq.empty()) {
+            auto [c, j] = pq.top();
+            pq.pop();
+
+            auto [n, l, r] = gates[j];
+
+            auto itr = inter.begin();
+            while (itr != inter.end()) {
+                auto [cost, tl, tr] = *itr;
+                if (l <= tl && r >= tr) {
+                    inter.erase(make_tuple(cost, tl, tr));
+                    ans[tl] -= cost * fds[i];
+                    ans[tr + 1] += cost * fds[i];
+                    itr = inter.begin();
+                    continue;
+                }
+
+                if (l >= tl &&  r <= tr) {
+                    inter.erase(make_tuple(cost, tl, tr));
+                    ans[tl] -= cost * fds[i];
+                    ans[tr + 1] += cost * fds[i];
+                    if (l - 1 >= tl) {
+                        inter.emplace(cost, tl, l - 1);
+                        ans[tl] += cost * fds[i];
+                        ans[l] -= cost * fds[i];
+                    }
+                    if (r + 1 <= tr) {
+                        inter.emplace(cost, r + 1, tr);
+                        ans[r + 1] += cost * fds[i];
+                        ans[tr + 1] -= cost * fds[i];
+                    }
+                    itr = inter.begin();
+                    continue;
+                }
+
+                if (l >= tl && l <= tr) {
+                    inter.erase(make_tuple(cost, tl, tr));
+                    ans[tl] -= cost * fds[i];
+                    ans[tr + 1] += cost * fds[i];
+                    if (l - 1 >= tl) {
+                        inter.emplace(cost, tl, l - 1);
+                        ans[tl] += cost * fds[i];
+                        ans[l] -= cost * fds[i];
+                    }
+                    itr = inter.begin();
+                    continue;
+                }
+
+                if (r >= tl && r <= tr) {
+                    inter.erase(make_tuple(cost, tl, tr));
+                    ans[tl] -= cost * fds[i];
+                    ans[tr + 1] += cost * fds[i];
+                    if (r + 1 <= tr) {
+                        inter.emplace(cost, r + 1, tr);
+                        ans[r + 1] += cost * fds[i];
+                        ans[tr + 1] -= cost * fds[i];
+                    }
+                    itr = inter.begin();
+                    continue;
+                }
+
+                itr++;
+            }
+
+            inter.emplace(c, l, r);
+            ans[l] += c * fds[i];
+            ans[r + 1] -= c * fds[i];
+        }
+    }
+
+    for (int i = 1; i <= t; i++) {
+        ans[i] += ans[i - 1];
+        if (!pos[i]) {
+            cout << "-1\n";
+            continue;
+        }
+        cout << ans[i] << '\n';
+    }
+}

2024 Aleppo Collegiate Programming Contest/I. Nested Circles.cpp

@@ -0,0 +1,152 @@
+/* Problem URL: https://codeforces.com/gym/105316/problem/I */
+
+#include <bits/stdc++.h>
+
+using namespace std;
+
+#define V vector
+
+#define rmin(a, b) a = min(a, b)
+#define rmax(a, b) a = max(a, b)
+
+#define rep(i, lim) for (size_t i = 0; i < (lim); i++)
+#define nrep(i, s, lim) for (size_t 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;
+}
+
+double dis(ll x1, ll y1, ll x2, ll y2)
+{
+    ll x = x1 - x2;
+    ll y = y1 - y2;
+    return sqrt(x * x + y * y);
+}
+
+int main()
+{
+    ios::sync_with_stdio(false);
+    cin.tie(nullptr);
+
+    int t;
+    cin >> t;
+    while (t--) {
+        int n, q;
+        cin >> n >> q;
+
+        V<pair<int, int>> points;
+
+        while (n--) {
+            int x, y, z;
+            cin >> x >> y >> z;
+
+            for (size_t i = 0; i <= z; i++) {
+                int yn = y + i;
+                int xn = x;
+                while (dis(xn, yn, x, y) <= z) {
+                    points.emplace_back(xn, yn);
+                    int dx = xn - x;
+                    int dy = yn - y;
+                    if (dy != 0) {
+                        points.emplace_back(xn, y - dy);
+                    }
+                    if (dx != 0) {
+                        points.emplace_back(x - dx, yn);
+                    }
+                    if (dx != 0 && dy != 0) {
+                        points.emplace_back(x - dx, y - dy);
+                    }
+                    xn++;
+                }
+            }
+        }
+
+        sortv(points);
+        pair<int, int> prev = {-1e6, -1e6};
+        int now = 1;
+
+        V<pair<int, int>> act;
+        vi count;
+
+        for (auto i : points) {
+            if (i == prev) {
+                now++;
+                continue;
+            }
+
+            act.emplace_back(prev);
+            count.push_back(now);
+            now = 1;
+            prev = i;
+        }
+
+        act.emplace_back(prev);
+        count.push_back(now);
+
+        while (q--) {
+            int x, y;
+            cin >> x >> y;
+
+            auto itr = lower_bound(act.begin(), act.end(), make_pair(x, y));
+            if (itr == act.end() || *itr != make_pair(x, y)) {
+                cout << "0\n";
+                continue;
+            }
+
+            cout << count[itr - act.begin()] << '\n';
+        }
+    }
+}

2024 ICPC Belarus Regional Contest/E. Enter the Museum.cpp

@@ -0,0 +1,140 @@
+/* Problem URL: https://codeforces.com/gym/105535/problem/E */
+
+#include <bits/stdc++.h>
+
+using namespace std;
+
+#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;
+}
+
+int main()
+{
+    ios::sync_with_stdio(false);
+    cin.tie(nullptr);
+
+    int n;
+    cin >> n;
+
+    vi fds(n);
+    cin >> fds;
+
+    vvi graph(n);
+    nrep(i, 1, n) {
+        int a, b;
+        cin >> a >> b;
+        a--, b--;
+
+        graph[a].push_back(b);
+        graph[b].push_back(a);
+    }
+
+    vi ans;
+    int total = 0;
+
+    function<bool(int, int)> dfs = [&](int i, int p) {
+        fds[i]--;
+        total++;
+
+        ans.push_back(i + 1);
+
+        repv(j, graph[i]) {
+            if (j == p) {
+                continue;
+            }
+
+            if (!dfs(j, i) || fds[i] == 0) {
+                return false;
+            }
+            
+            total++;
+            fds[i]--;
+            ans.push_back(i + 1);
+
+            while (fds[j] > 0) {
+                if (fds[i] == 0) {
+                    return false;
+                }
+
+                ans.push_back(j + 1);
+                ans.push_back(i + 1);
+
+                fds[i]--;
+                fds[j]--;
+                total += 2;
+            }
+        }
+
+        return true;
+    };
+
+    fds[0]++;
+    int check = accumulate(all(fds), 0);
+    if (!dfs(0, 0) || total != check) {
+        cout << "0\n";
+        return 0;
+    }
+
+    cout << ans;
+}

2024 ICPC Gran Premio de Mexico 1ra Fecha/B. Bacterial Sampling.cpp

@@ -0,0 +1,182 @@
+/* Problem URL: https://codeforces.com/gym/105164/problem/B */
+
+#include <bits/stdc++.h>
+
+using namespace std;
+
+#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;
+}
+
+ll mod = 1e9 + 7;
+
+vvl operator*(vvl &a, vvl &b)
+{
+    vvl ans(a.size(), vl(b[0].size()));
+
+    rep(i, a.size()) {
+        rep(j, b[0].size()) {
+            rep(k, a[0].size()) {
+                ans[i][j] = (ans[i][j] + a[i][k] * b[k][j]) % mod;
+            }
+        }
+    }
+
+    return ans;
+}
+
+ll exp(int n)
+{
+    vvl ans = {
+        {1},
+        {0},
+        {0},
+        {0},
+        {0},
+        {3},
+        {0},
+        {0},
+        {0},
+        {3},
+        {0},
+        {9},
+        {0},
+        {3},
+        {0},
+        {18},
+        {0},
+        {30},
+        {0},
+        {27}
+    };
+
+    if (n < 20) {
+        ll total = 0;
+        for (int i = 0; i <= n; i++) {
+            total += ans[i][0];
+            total %= mod;
+        }
+
+        return total;
+    }
+
+    n -= 20;
+    
+    vvl tmp(20, vl(20));
+
+    rep(i, 19) {
+        tmp[i][i + 1] = 1;
+    }
+
+    for (int j = 20 - 6; j >= 0; j -= 4) {
+        tmp[19][j] = 3;
+    }
+
+    rep(i, 31) {
+        if ((n >> i) & 1) {
+            ans = tmp * ans;
+        }
+        tmp = tmp * tmp;
+    }
+
+    ll total = 0;
+    rep(i, 20) {
+        total += ans[i][0];
+        total %= mod;
+    }
+
+    return total;
+}
+
+int main()
+{
+    ios::sync_with_stdio(false);
+    cin.tie(nullptr);
+
+    int t;
+    cin >> t;
+    while (t--) {
+        int n;
+        cin >> n;
+
+        // vl dp(n + 1);
+        // dp[0] = 1;
+        //
+        // for (int i = 1; i <= n; i++) {
+        //     for (int j = i - 6; j >= 0 && abs(i - j) <= 20; j -= 4) {
+        //         dp[i] += dp[j] * 3;
+        //         dp[i] %= mod;
+        //     }
+        // }
+        //
+        // ll total = 0;
+        // for (int i = max(n - 19, 0); i <= n; i++) {
+        //     total += dp[i];
+        //     total %= mod;
+        // }
+
+        cout << exp(n) << '\n';
+        // cout << total << '\n';
+    }
+}

2024 ICPC Gran Premio de Mexico 2da Fecha/D. Dueling Digits.cpp

@@ -0,0 +1,117 @@
+/* Problem URL: https://codeforces.com/gym/105216/problem/D */
+
+#include <bits/stdc++.h>
+
+using namespace std;
+
+#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;
+}
+
+ll mod = 1e9 + 7;
+int dest = 7200;
+
+int main()
+{
+    ios::sync_with_stdio(false);
+    cin.tie(nullptr);
+
+    vvl dp(801, vl(7201 * 2));
+    dp[0][dest] = 1;
+
+    for (int i = 0; i <= 14400; i++) {
+        for (int j = 1; j <= 8; j++) {
+            if (i - j >= 0) {
+                dp[1][i] += dp[0][i - j] * (9 - j);
+            }
+            if (i + j <= 14400) {
+                dp[1][i] += dp[0][i + j] * (9 - j);
+            }
+            dp[1][i] %= mod;
+        }
+    }
+
+    for (int i = 2; i <= 800; i++) {
+        for (int j = 0; j <= 14400; j++) {
+            for (int k = 1; k <= 9; k++) {
+                if (j - k >= 0) {
+                    dp[i][j] += dp[i - 1][j - k] * (10 - k);
+                }
+                if (j + k <= 14400) {
+                    dp[i][j] += dp[i - 1][j + k] * (10 - k);
+                }
+                dp[i][j] %= mod;
+            }
+        }
+    }
+
+    int q;
+    cin >> q;
+    while (q--) {
+        int n;
+        cin >> n;
+
+        cout << dp[n][dest] << '\n';
+    }
+}

2024 ICPC Gran Premio de Mexico 2da Fecha/E. Egotistical Command Chain.cpp

@@ -0,0 +1,111 @@
+/* Problem URL: https://codeforces.com/gym/105216/problem/E */
+
+#include <bits/stdc++.h>
+
+using namespace std;
+
+#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;
+}
+
+int main()
+{
+    ios::sync_with_stdio(false);
+    cin.tie(nullptr);
+
+    int n;
+    cin >> n;
+
+    V<pair<int, int>> fds(n);
+    rep(i, n) {
+        fds[i].second = i;
+        cin >> fds[i].first;
+    }
+
+    V<pair<int, int>> ans;
+    vvi graph(n);
+    vi roots;
+
+    int total = 0;
+
+    sort(all(fds));
+    rep(i, n) {
+        int now = fds[i].first - 1;
+
+        if (total < now) {
+            cout << "-1\n";
+            return 0;
+        }
+
+        total++;
+        rep(j, now) {
+            ans.emplace_back(fds[i].second + 1, fds[j].second + 1);
+        }
+    }
+
+    cout << ans.size() << '\n';
+    for (auto [i, j] : ans) {
+        cout << i << ' ' << j << '\n';
+    }
+}

2024 ICPC Gran Premio de Mexico 2da Fecha/J. Japanese Samurai Fight.cpp

@@ -0,0 +1,124 @@
+/* Problem URL: https://codeforces.com/gym/105216/problem/J */
+
+#include <bits/stdc++.h>
+
+using namespace std;
+
+#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;
+}
+
+int main()
+{
+    ios::sync_with_stdio(false);
+    cin.tie(nullptr);
+
+    int n, m;
+    cin >> n >> m;
+
+    if (n == 1) {
+        cout << "NO\n";
+        return 0;
+    }
+
+    V<pair<int, int>> ans;
+    V<V<bool>> connect(n, V<bool>(n));
+    while (m--) {
+        int a, b;
+        cin >> a >> b;
+        a--, b--;
+
+        connect[a][b] = true;
+        connect[b][a] = true;
+    }
+
+    cout << "YES\n";
+
+    rep(i, n / 2) {
+        nrep(j, i + 1, n / 2) {
+            if (!connect[i][j]) {
+                connect[i][j] = true;
+                connect[j][i] = true;
+
+                ans.emplace_back(i + 1, j + 1);
+            }
+        }
+    }
+
+    nrep(i, n / 2, n) {
+        nrep(j, i + 1, n) {
+            if (!connect[i][j]) {
+                connect[i][j] = true;
+                connect[j][i] = true;
+
+                ans.emplace_back(i + 1, j + 1);
+            }
+        }
+    }
+
+    cout << ans.size() << '\n';
+    for (auto [i, j] : ans) {
+        cout << i << ' ' << j << '\n';
+    }
+}

2024 United Kingdom and Ireland Programming Contest (UKIEPC 2024)/A. Amalgram.cpp

@@ -0,0 +1,99 @@
+/* Problem URL: https://codeforces.com/gym/105446/problem/A */
+
+#include <bits/stdc++.h>
+
+using namespace std;
+
+#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;
+}
+
+int main()
+{
+    ios::sync_with_stdio(false);
+    cin.tie(nullptr);
+
+    string a, b;
+    cin >> a >> b;
+
+    vi counta(26);
+    vi countb(26);
+
+    repv(i, a) {
+        counta[i - 'a']++;
+    }
+
+    repv(i, b) {
+        countb[i - 'a']++;
+    }
+
+    rep(i, 26) {
+        int now = max(counta[i], countb[i]);
+
+        while (now--) {
+            cout << (char)(i + 'a');
+        }
+    }
+    cout << '\n';
+}

2024 United Kingdom and Ireland Programming Contest (UKIEPC 2024)/D. Drone Control.cpp

@@ -0,0 +1,123 @@
+/* Problem URL: https://codeforces.com/gym/105446/problem/D */
+
+#include <bits/stdc++.h>
+
+#include <algorithm>
+
+using namespace std;
+
+#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;
+}
+
+int main()
+{
+    ios::sync_with_stdio(false);
+    cin.tie(nullptr);
+
+    int q;
+    cin >> q;
+    while (q--) {
+        double p, r, y;
+        cin >> p >> r >> y;
+
+        double low = -1.5;
+        double high = 1.5;
+
+        while (high - low >= 1e-10) {
+            double third = (high - low) / 3;
+            double mid1 = low + third;
+            double mid2 = high - third;
+
+            auto check = [&](double mid) {
+                double w = mid;
+                double s = (y - p - r) / 2 + w;
+                double n = r + s;
+                double e = p + w;
+
+                return max({abs(w), abs(s), abs(n), abs(e)});
+            };
+
+            if (check(mid1) < check(mid2)) {
+                high = mid1;
+                continue;
+            }
+
+            if (check(mid1) > check(mid2)) {
+                low = mid2;
+                continue;
+            }
+
+            low = mid1;
+            high = mid2;
+        }
+
+        double w = low;
+        double s = (y - p - r) / 2 + w;
+        double n = r + s;
+        double e = p + w;
+
+        cout << fixed << setprecision(6) << n << ' ' << e << ' ' << s << ' ' << w << '\n';
+    }
+}

2024 United Kingdom and Ireland Programming Contest (UKIEPC 2024)/F. Finding Suspicious Proteins.cpp

@@ -0,0 +1,140 @@
+/* Problem URL: https://codeforces.com/gym/105446/problem/F */
+
+#include <bits/stdc++.h>
+
+using namespace std;
+
+#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;
+}
+
+int main()
+{
+    ios::sync_with_stdio(false);
+    cin.tie(nullptr);
+
+    int n, l, k;
+    cin >> n >> l >> k;
+
+    V<bool> vis(n);
+
+    V<string> rev(n);
+
+    vvi s(n, vi(l));
+
+    rep(i, n) {
+        string fds;
+        cin >> fds;
+        rev[i] = fds;
+
+        rep(j, l) {
+            cin >> s[i][j];
+        }
+    }
+
+    auto diff = [&](int i, int j) {
+        int ans = 0;
+        rep(f, l) {
+            ans += abs(s[i][f] - s[j][f]);
+        }
+
+        return ans;
+    };
+
+    vi dis(n, INT32_MAX);
+
+    vi choices;
+    int now = 0;
+    int maximal = 0;
+
+    nrep(i, 1, n) {
+        int d = diff(0, i);
+
+        if (d > maximal) {
+            maximal = d;
+            now = i;
+        }
+    }
+
+    choices.push_back(now);
+
+    nrep(i, 1, k) {
+        now = 0;
+        maximal = 0;
+        rep(j, n) {
+            rmin(dis[j], diff(choices.back(), j));
+
+            if (dis[j] > maximal) {
+                maximal = dis[j];
+                now = j;
+            }
+        }
+
+        choices.push_back(now);
+    }
+
+    repv(i, choices) {
+        cout << rev[i] << '\n';
+    }
+}

2024-2025 ICPC Brazil Subregional Programming Contest/A. Attention to the Meeting.cpp

@@ -0,0 +1,81 @@
+/* Problem URL: https://codeforces.com/gym/105327/problem/A */
+
+#include <bits/stdc++.h>
+
+using namespace std;
+
+#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;
+}
+
+int main()
+{
+    ios::sync_with_stdio(false);
+    cin.tie(nullptr);
+
+    int n, k;
+    cin >> n >> k;
+
+    cout << (k - (k / n) * n >= (n - 1) ? k / n : k / n - 1)  << '\n';
+}

2024-2025 ICPC Brazil Subregional Programming Contest/B. Bacon Number.cpp

@@ -0,0 +1,239 @@
+/* Problem URL: https://codeforces.com/gym/105327/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;
+}
+
+int main()
+{
+    ios::sync_with_stdio(false);
+    cin.tie(nullptr);
+
+    int n, m;
+    cin >> n >> m;
+
+    vvi tree(n + m);
+
+    vi dsu(n + m);
+    rep(i, dsu.size()) {
+        dsu[i] = i;
+    }
+
+    function<int(int)> find_p = [&](int i) {
+        if (dsu[i] == i) {
+            return i;
+        }
+        return dsu[i] = find_p(dsu[i]);
+    };
+
+    auto join = [&](int a, int b) {
+        a = find_p(a);
+        b = find_p(b);
+
+        if (a == b) {
+            return false;
+        }
+
+        dsu[a] = b;
+        return true;
+    };
+
+    rep(i, n) {
+        int k;
+        cin >> k;
+
+        while (k--) {
+            int j;
+            cin >> j;
+            j--;
+
+            if (!join(i, j + n)) {
+                continue;
+            }
+
+            tree[i].push_back(j + n);
+            tree[j + n].push_back(i);
+        }
+    }
+
+    vvi parent(n + m, vi(25));
+    vi depth(n + m, -1);
+    vi group(n + m, -1);
+    int g = 0;
+    V<bool> vis(n + m);
+
+    function<void(int, int)> buildlca = [&](int i, int p) {
+        parent[i][0] = p;
+        depth[i] = depth[p] + 1;
+        group[i] = g;
+
+        vis[i] = true;
+
+        nrep(j, 1, 25) {
+            parent[i][j] = parent[parent[i][j - 1]][j - 1];
+        }
+
+        for (auto j : tree[i]) {
+            if (j == p) {
+                continue;
+            }
+
+            buildlca(j, i);
+        }
+    };
+
+    rep(i, n + m) {
+        if (vis[i]) {
+            continue;
+        }
+
+        buildlca(i, i);
+        g++;
+    }
+
+    auto lca = [&](int a, int b) {
+        if (depth[a] > depth[b]) {
+            swap(a, b);
+        }
+
+        int diff = depth[b] - depth[a];
+
+        rep(i, 25) {
+            if ((diff >> i) & 1) {
+                b = parent[b][i];
+            }
+        }
+
+        if (a == b) {
+            return a;
+        }
+
+        for (int i = 24; i >= 0; i--) {
+            if (parent[a][i] == parent[b][i]) {
+                continue;
+            }
+
+            a = parent[a][i];
+            b = parent[b][i];
+        }
+
+        return parent[a][0];
+    };
+
+    int q;
+    cin >> q;
+    while (q--) {
+        int a, b;
+        cin >> a >> b;
+        a--, b--;
+
+        a += n;
+        b += n;
+
+        if (group[a] != group[b]) {
+            cout << "-1\n";
+            continue;
+        }
+
+        int p = lca(a, b);
+
+        vi ans1;
+        vi ans2;
+
+        while (a != p) {
+            ans1.push_back(a + 1);
+            a = parent[a][0];
+        }
+
+        ans1.push_back(a + 1);
+
+        while (b != p) {
+            ans2.push_back(b + 1);
+            b = parent[b][0];
+        }
+
+        reverse(all(ans2));
+
+        cout << (ans1.size() + ans2.size() + 1) / 2 << '\n';
+
+        repv(i, ans1) {
+            cout << i - (i > n ? n : 0) << ' ';
+        }
+
+        repv(i, ans2) {
+            cout << i - (i > n ? n : 0) << ' ';
+        }
+        cout << '\n';
+    }
+}

2024-2025 ICPC Brazil Subregional Programming Contest/E. Enigma of the Jewelry Case.cpp

@@ -0,0 +1,117 @@
+/* Problem URL: https://codeforces.com/gym/105327/problem/E */
+
+#include <bits/stdc++.h>
+
+using namespace std;
+
+#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;
+}
+
+int main()
+{
+    ios::sync_with_stdio(false);
+    cin.tie(nullptr);
+
+    int n;
+    cin >> n;
+
+    vvi fds(n, vi(n));
+    cin >> fds;
+
+    int ans = 0;
+
+    auto valid = [&]() {
+        rep(i, n) {
+            nrep(j, 1, n) {
+                if (fds[i][j] <= fds[i][j - 1]) {
+                    return false;
+                }
+
+                if (fds[j][i] <= fds[j - 1][i]) {
+                    return false;
+                }
+            }
+        }
+
+        return true;
+    };
+
+    auto rotate = [&]() {
+        vvi tmp = fds;
+
+        rep(i, n) {
+            rep(j, n) {
+                fds[i][j] = tmp[j][n - i - 1];
+            }
+        }
+    };
+
+    while (!valid()) {
+        ans++;
+        rotate();
+    }
+
+    cout << ans << '\n';
+}

2024-2025 ICPC Brazil Subregional Programming Contest/F. Fractions are better when continued.cpp

@@ -0,0 +1,89 @@
+/* Problem URL: https://codeforces.com/gym/105327/problem/F */
+
+#include <bits/stdc++.h>
+
+using namespace std;
+
+#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;
+}
+
+int main()
+{
+    ios::sync_with_stdio(false);
+    cin.tie(nullptr);
+
+    int n;
+    cin >> n;
+
+    ll a = 0;
+    ll b = 1;
+
+    while (n--) {
+        swap(a, b);
+        b += a;
+    }
+
+    cout << b << '\n';
+}

2025 Argentinian Programming Tournament (TAP)/B. Block sum array.cpp

@@ -0,0 +1,141 @@
+/* Problem URL: https://codeforces.com/gym/106054/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;
+}
+
+int main()
+{
+    ios::sync_with_stdio(false);
+    cin.tie(nullptr);
+
+    int n, k;
+    cin >> n >> k;
+
+    const ll mod = 998244353;
+
+    auto fpow = [&](ll a, ll p) {
+        ll ans = 1;
+
+        rep(i, 31) {
+            if ((p >> i) & 1) {
+                ans *= a;
+                ans %= mod;
+            }
+            
+            a *= a;
+            a %= mod;
+        }
+
+        return ans;
+    };
+
+    auto comb = [&](ll n, ll k) {
+        ll ans = 1;
+        ll div = 1;
+
+        rep(i, k) {
+            ans *= (n - i);
+            ans %= mod;
+
+            div *= (i + 1);
+            div %= mod;
+        }
+
+        return (ans * fpow(div, mod - 2)) % mod;
+    };
+
+    vl b(n - k + 1);
+    cin >> b;
+
+    ll ans = b[0];
+    
+    rep(i, k) {
+        ll m = 0;
+        ll tmp = 0;
+        for (int j = i; j + 1 < b.size(); j += k) {
+            m += b[j] - b[j + 1];
+            rmax(tmp, m);
+        }
+
+        ans -= tmp;
+    }
+
+    if (ans < 0) {
+        cout << "0\n";
+        return 0;
+    }
+
+    cout << comb(ans + k - 1, k - 1) << '\n';
+}

8VC Venture Cup 2016 - Elimination Round/E. Simple Skewness.cpp

@@ -0,0 +1,201 @@
+/* Problem URL: https://codeforces.com/contest/626/problem/E */
+
+#include <bits/stdc++.h>
+
+using namespace std;
+
+#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;
+}
+
+#define double long double
+
+int main()
+{
+    ios::sync_with_stdio(false);
+    cin.tie(nullptr);
+
+    int n;
+    cin >> n;
+
+    vl fds(n);
+    cin >> fds;
+    sortv(fds);
+
+    pair<int, int> median = {0, 0};
+    double ans = 0;
+    int dev = 0;
+
+    vl pref(n + 1);
+    rep(i, n) {
+        pref[i + 1] = pref[i] + fds[i];
+    }
+
+    auto search = [&](int med, int devi, int i) {
+        int low = 1;
+        int high = devi;
+
+        ll ans = 0;
+        while (low <= high) {
+            int third = (high - low) / 3;
+            int mid1 = low + third;
+            int mid2 = high - third;
+
+            double ans1 = (double)(pref[i + 1] - pref[i - mid1] + pref[n] - pref[n - mid1]) / (mid1 * 2 + med) - fds[i];
+            double ans2 = (double)(pref[i + 1] - pref[i - mid2] + pref[n] - pref[n - mid2]) / (mid2 * 2 + med) - fds[i];
+
+            if (ans1 > ans2) {
+                ans = mid1;
+                high = mid2 - 1;
+                continue;
+            }
+
+            if (ans2 > ans1) {
+                ans = mid2;
+                low = mid1 + 1;
+                continue;
+            }
+
+            ans = mid1;
+            low = mid1 + 1;
+            high = mid2 - 1;
+        }
+
+        return ans;
+    };
+    auto search2 = [&](int med, int devi, int i) {
+        int low = 1;
+        int high = devi;
+
+        ll ans = 0;
+        while (low <= high) {
+            int third = (high - low) / 3;
+            int mid1 = low + third;
+            int mid2 = high - third;
+
+            double ans1 = (double)(pref[i + 2] - pref[i - mid1] + pref[n] - pref[n - mid1]) / (mid1 * 2 + med) - (fds[i] + fds[i + 1]) / 2.0L;
+            double ans2 = (double)(pref[i + 2] - pref[i - mid2] + pref[n] - pref[n - mid2]) / (mid2 * 2 + med) - (fds[i] + fds[i + 1]) / 2.0L;
+
+            if (ans1 > ans2) {
+                ans = mid1;
+                high = mid2 - 1;
+                continue;
+            }
+
+            if (ans2 > ans1) {
+                ans = mid2;
+                low = mid1 + 1;
+                continue;
+            }
+
+            ans = mid1;
+            low = mid1 + 1;
+            high = mid2 - 1;
+        }
+
+        return ans;
+    };
+
+    rep(i, n) {
+        int devi = min(i, n - i - 1);
+
+        int best = search(1, devi, i);
+        double tmp = (double)(pref[i + 1] - pref[i - best] + pref[n] - pref[n - best]) / (best * 2 + 1) - fds[i];
+
+        if (tmp >= ans) {
+            ans = tmp;
+            median = {i, i};
+            dev = best;
+        }
+    }
+
+    rep(i, n - 1) {
+        int devi = min(i, n - i - 2);
+
+        int best = search2(2, devi, i);
+        double tmp = (double)(pref[i + 2] - pref[i - best] + pref[n] - pref[n - best]) / (best * 2 + 2) - (fds[i] + fds[i + 1]) / 2.0L;
+
+        if (tmp >= ans) {
+            ans = tmp;
+            median = {i, i + 1};
+            dev = best;
+        }
+    }
+
+    int size = dev * 2 + (median.first != median.second) + 1;
+    cout << size << '\n';
+
+    nrep(i, median.first - dev, median.first) {
+        cout << fds[i] << ' ';
+    }
+    cout << fds[median.first] << ' ';
+    if (median.first != median.second) {
+        cout << fds[median.second] << ' ';
+    }
+
+    nrep(i, n - dev, n) {
+        cout << fds[i] << ' ';
+    }
+    cout << '\n';
+}

Atto Round 1 (Codeforces Round 1041, Div. 1 + Div. 2)/B. Hamiiid, Haaamid... Hamid?.cpp

@@ -0,0 +1,108 @@
+/* Problem URL: https://codeforces.com/problemset/problem/2127/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;
+}
+
+int main()
+{
+    ios::sync_with_stdio(false);
+    cin.tie(nullptr);
+
+    int t;
+    cin >> t;
+    while (t--) {
+        int n, x;
+        cin >> n >> x;
+        string a;
+        cin >> a;
+        x--;
+
+        int l = -1;
+        rep(i, x) {
+            if (a[i] == '#') {
+                l = i;
+            }
+        }
+
+        int r = n;
+        for (int i = n - 1; i > x; i--) {
+            if (a[i] == '#') {
+                r = i;
+            }
+        }
+
+        cout << max(min(x + 1, n - r + 1), min(l + 2, n - x)) << '\n';
+    }
+}

Codeforces Beta Round 19/E. Fairy.cpp

@@ -0,0 +1,89 @@
+/* Problem URL: https://codeforces.com/contest/19/problem/E */
+
+#include <bits/stdc++.h>
+
+using namespace std;
+
+#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;
+}
+
+int main()
+{
+    ios::sync_with_stdio(false);
+    cin.tie(nullptr);
+
+    int n, m;
+    cin >> n >> m;
+
+    V<V<pair<int, int>>> graph(n);
+
+    rep(i, m) {
+        int a, b;
+        cin >> a >> b;
+        a--, b--;
+
+
+    }
+}

Codeforces Beta Round 89 (Div. 2)/E. Bertown roads.cpp

@@ -0,0 +1,141 @@
+/* Problem URL: https://codeforces.com/contest/118/problem/E */
+
+#include <bits/stdc++.h>
+
+using namespace std;
+
+#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;
+}
+
+int main()
+{
+    ios::sync_with_stdio(false);
+    cin.tie(nullptr);
+
+    int n, m;
+    cin >> n >> m;
+
+    vvi graph(n);
+    rep(i, m) {
+        int a, b;
+        cin >> a >> b;
+        a--, b--;
+        graph[a].push_back(b);
+        graph[b].push_back(a);
+    }
+
+    vvi dfstree(n);
+    V<pair<int, int>> ans;
+    vi up(n);
+    vi down(n);
+    vi lvl(n);
+
+    function<void(int, int)> make_tree = [&](int i, int d) {
+        lvl[i] = d;
+
+        for (auto j : graph[i]) {
+            if (lvl[j] != 0) {
+                if (lvl[j] >= lvl[i]) {
+                    ans.emplace_back(j, i);
+                    down[i]++;
+                    up[j]++;
+                }
+                continue;
+            }
+
+            ans.emplace_back(i, j);
+            dfstree[i].push_back(j);
+            make_tree(j, d + 1);
+        }
+    };
+
+    make_tree(0, 1);
+    vi dp(n);
+    dp[0] = 1;
+
+    function<bool(int)> check = [&](int i) {
+        dp[i] += up[i];
+        dp[i] -= down[i];
+
+        for (auto j : dfstree[i]) {
+            if (!check(j)) {
+                return false;
+            }
+
+            dp[i] += dp[j];
+        }
+
+        return dp[i] != 0;
+    };
+
+    if (!check(0)) {
+        cout << "0\n";
+        return 0;
+    }
+
+    for (auto [u, v] : ans) {
+        cout << u + 1 << ' ' << v + 1 << '\n';
+    }
+}

Codeforces Round 1027 (Div. 3)/D. Come a Little Closer.cpp

@@ -0,0 +1,201 @@
+/* Problem URL: https://codeforces.com/contest/2114/problem/D */
+
+#include <bits/stdc++.h>
+
+using namespace std;
+
+#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;
+}
+
+int main()
+{
+    ios::sync_with_stdio(false);
+    cin.tie(nullptr);
+
+    int t;
+    cin >> t;
+    while (t--) {
+        int n;
+        cin >> n;
+
+        V<pair<ll, ll>> fds(n);
+        repv(i, fds) {
+            cin >> i.first >> i.second;
+        }
+
+        if (n == 1) {
+            cout << 1 << '\n';
+            continue;
+        }
+
+        ll inf = INT64_MAX >> 1;
+        priority_queue<pair<ll, ll>> minx;
+        minx.emplace(inf, inf);
+        minx.emplace(inf, inf);
+        priority_queue<pair<ll, ll>, V<pair<ll, ll>>, greater<>> maxx;
+        maxx.emplace(0, 0);
+        maxx.emplace(0, 0);
+        priority_queue<pair<ll, ll>> miny;
+        miny.emplace(inf, inf);
+        miny.emplace(inf, inf);
+        priority_queue<pair<ll, ll>, V<pair<ll, ll>>, greater<>> maxy;
+        maxy.emplace(0, 0);
+        maxy.emplace(0, 0);
+
+        repv(i, fds) {
+            minx.emplace(i.first, i.second);
+            minx.pop();
+            maxx.emplace(i.first, i.second);
+            maxx.pop();
+            miny.emplace(i.second, i.first);
+            miny.pop();
+            maxy.emplace(i.second, i.first);
+            maxy.pop();
+        }
+
+        pair<ll, ll> minx2 = minx.top();
+        minx.pop();
+        pair<ll, ll> minx1 = minx.top();
+
+
+        pair<ll, ll> maxx2 = maxx.top();
+        maxx.pop();
+        pair<ll, ll> maxx1 = maxx.top();
+
+
+        pair<ll, ll> miny2 = miny.top();
+        miny.pop();
+        pair<ll, ll> miny1 = miny.top();
+
+        pair<ll, ll> maxy2 = maxy.top();
+        maxy.pop();
+        pair<ll, ll> maxy1 = maxy.top();
+
+        ll ans = inf;
+
+        rmin(ans, (maxx1.first - minx1.first + 1) * (maxy1.first - miny1.first + 1));
+
+        if ((maxx2.first - minx1.first + 1) * (maxy1.first - miny1.first + 1) <= n - 1) {
+            rmin(ans, (maxx2.first - minx1.first + 1) * (maxy1.first - miny1.first + 2));
+            rmin(ans, (maxx2.first - minx1.first + 2) * (maxy1.first - miny1.first + 1));
+        } else {
+            rmin(ans, (maxx2.first - minx1.first + 1) * (maxy1.first - miny1.first + 1));
+        }
+        if ((maxx1.first - minx2.first + 1) * (maxy1.first - miny1.first + 1) <= n - 1) {
+            rmin(ans, (maxx1.first - minx2.first + 1) * (maxy1.first - miny1.first + 2));
+            rmin(ans, (maxx1.first - minx2.first + 2) * (maxy1.first - miny1.first + 1));
+        } else {
+            rmin(ans, (maxx1.first - minx2.first + 1) * (maxy1.first - miny1.first + 1));
+        }
+        if ((maxx1.first - minx1.first + 1) * (maxy2.first - miny1.first + 1) <= n - 1) {
+            rmin(ans, (maxx1.first - minx1.first + 2) * (maxy2.first - miny1.first + 1));
+            rmin(ans, (maxx1.first - minx1.first + 1) * (maxy2.first - miny1.first + 2));
+        } else {
+            rmin(ans, (maxx1.first - minx1.first + 1) * (maxy2.first - miny1.first + 1));
+        }
+        if ((maxx1.first - minx1.first + 1) * (maxy1.first - miny2.first + 1) <= n - 1) {
+            rmin(ans, (maxx1.first - minx1.first + 2) * (maxy1.first - miny2.first + 1));
+            rmin(ans, (maxx1.first - minx1.first + 1) * (maxy1.first - miny2.first + 2));
+        } else {
+            rmin(ans, (maxx1.first - minx1.first + 1) * (maxy1.first - miny2.first + 1));
+        }
+
+        if (maxx1.first == maxy1.second && maxx1.second == maxy1.first) {
+            if ((maxx2.first - minx1.first + 1) * (maxy2.first - miny1.first + 1) > n - 1) {
+                rmin(ans, (maxx2.first - minx1.first + 1) * (maxy2.first - miny1.first + 1));
+            } else {
+                rmin(ans, (maxx2.first - minx1.first + 1) * (maxy2.first - miny1.first + 2));
+                rmin(ans, (maxx2.first - minx1.first + 2) * (maxy2.first - miny1.first + 1));
+            }
+        }
+        if (minx1.first == miny1.second && minx1.second == miny1.first) {
+            if ((maxx1.first - minx2.first + 1) * (maxy1.first - miny2.first + 1) > n - 1) {
+                rmin(ans, (maxx1.first - minx2.first + 1) * (maxy1.first - miny2.first + 1));
+            } else {
+                rmin(ans, (maxx1.first - minx2.first + 1) * (maxy1.first - miny2.first + 2));
+                rmin(ans, (maxx1.first - minx2.first + 2) * (maxy1.first - miny2.first + 1));
+            }
+        }
+
+        if (minx1.first == maxy1.second && minx1.second == maxy1.first) {
+            if ((maxx1.first - minx2.first + 1) * (maxy2.first - miny1.first + 1) > n - 1) {
+                rmin(ans, (maxx1.first - minx2.first + 1) * (maxy2.first - miny1.first + 1));
+            } else {
+                rmin(ans, (maxx1.first - minx2.first + 2) * (maxy2.first - miny1.first + 1));
+                rmin(ans, (maxx1.first - minx2.first + 1) * (maxy2.first - miny1.first + 2));
+            }
+        }
+        if (maxx1.first == miny1.second && maxx1.second == miny1.first) {
+            if ((maxx2.first - minx1.first + 1) * (maxy1.first - miny2.first + 1) > n - 1) {
+                rmin(ans, (maxx2.first - minx1.first + 1) * (maxy1.first - miny2.first + 1));
+            } else {
+                rmin(ans, (maxx2.first - minx1.first + 2) * (maxy1.first - miny2.first + 1));
+                rmin(ans, (maxx2.first - minx1.first + 1) * (maxy1.first - miny2.first + 2));
+            }
+        }
+
+        cout << ans << '\n';
+    }
+}

Codeforces Round 1027 (Div. 3)/E. Kirei Attacks the Estate.cpp

@@ -0,0 +1,149 @@
+/* Problem URL: https://codeforces.com/contest/2114/problem/E */
+
+#include <bits/stdc++.h>
+
+using namespace std;
+
+#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;
+}
+
+int main()
+{
+    ios::sync_with_stdio(false);
+    cin.tie(nullptr);
+
+    int t;
+    cin >> t;
+
+    while (t--) {
+        int n;
+        cin >> n;
+
+        vl fds(n);
+        cin >> fds;
+
+        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);
+        }
+
+        vvl dp(n, vl(2, 0));
+
+        vi parent(n);
+        parent[0] = -1;
+
+        function<void(int, int)> make_p = [&](int i, int p) {
+            parent[i] = p;
+
+            for (auto j : graph[i]) {
+                if (j == p) {
+                    continue;
+                }
+
+                make_p(j, i);
+            }
+        };
+
+        make_p(0, -1);
+        vl ans(n);
+
+        V<bool> vis(n, false);
+
+        function<void(int)> calc = [&](int i) {
+            if (i == 0) {
+                ans[i] = fds[i];
+                dp[i][0] = fds[i];
+                dp[i][1] = -fds[i];
+                return;
+            }
+
+            if (vis[i]) {
+                return;
+            }
+
+            vis[i] = true;
+            dp[i][0] = fds[i];
+            dp[i][1] = -fds[i];
+
+            calc(parent[i]);
+
+            rmax(dp[i][0], dp[i][0] + dp[parent[i]][1]);
+            rmax(dp[i][1], dp[i][1] + dp[parent[i]][0]);
+
+            ans[i] = dp[i][0];
+        };
+
+        rep(i, n) {
+            calc(i);
+        }
+
+        cout << ans;
+    }
+}

Codeforces Round 834 (Div. 3)/A. Yes-Yes?.cpp

@@ -0,0 +1,119 @@
+/* Problem URL: https://codeforces.com/contest/1759/problem/A */
+
+#include <bits/stdc++.h>
+
+using namespace std;
+
+#define V vector
+
+#define rmin(a, b) a = min(a, b)
+#define rmax(a, b) a = max(a, b)
+
+#define rep(i, lim) for (size_t i = 0; i < (lim); i++)
+#define nrep(i, s, lim) for (size_t 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;
+}
+
+int main()
+{
+    ios::sync_with_stdio(false);
+    cin.tie(nullptr);
+
+    int t;
+    cin >> t;
+    while (t--) {
+        string a;
+        cin >> a;
+
+        bool yes = true;
+        for (size_t i = 0; i < a.size() && yes; i++) { 
+            if (a[i] == 'Y') {
+                if (i + 1 < a.size() && a[i + 1] != 'e') {
+                    yes = false;
+                    continue;
+                }
+                if (i + 2 < a.size() && a[i + 2] != 's') {
+                    yes = false;
+                    continue;
+                }
+            } else if (a[i] == 'e') {
+                if (i + 1 < a.size() && a[i + 1] != 's') {
+                    yes = false;
+                    continue;
+                }
+                if (i + 2 < a.size() && a[i + 2] != 'Y') {
+                    yes = false;
+                    continue;
+                }
+            } else if (a[i] == 's') {
+                if (i + 1 < a.size() && a[i + 1] != 'Y') {
+                    yes = false;
+                    continue;
+                }
+                if (i + 2 < a.size() && a[i + 2] != 'e') {
+                    yes = false;
+                    continue;
+                }
+            } else {
+                yes = false;
+            }
+        }
+
+        cout << (yes ? "YES\n" : "NO\n");
+    }
+}

Codeforces Round 834 (Div. 3)/B. Lost Permutation.cpp

@@ -0,0 +1,101 @@
+/* Problem URL: https://codeforces.com/contest/1759/problem/B */
+
+#include <bits/stdc++.h>
+
+using namespace std;
+
+#define V vector
+
+#define rmin(a, b) a = min(a, b)
+#define rmax(a, b) a = max(a, b)
+
+#define rep(i, lim) for (size_t i = 0; i < (lim); i++)
+#define nrep(i, s, lim) for (size_t 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;
+}
+
+int main()
+{
+    ios::sync_with_stdio(false);
+    cin.tie(nullptr);
+
+    int t;
+    cin >> t;
+    while (t--) {
+        int m, s;
+        cin >> m >> s;
+
+        ll total = 0;
+        int maximus = 0;
+        while (m--) {
+            int c;
+            cin >> c;
+            total += c;
+            rmax(maximus, c);
+        }
+
+        ll perm = maximus * (maximus + 1) / 2;
+        s -= perm - total;
+
+        for (size_t i = maximus + 1; i <= s; i++) {
+            s -= i;
+        }
+
+        cout << (s == 0 ? "YES\n" : "NO\n");
+    }
+}

Codeforces Round 834 (Div. 3)/C. Thermostat.cpp

@@ -0,0 +1,116 @@
+/* Problem URL: https://codeforces.com/contest/1759/problem/C */
+
+#include <bits/stdc++.h>
+
+using namespace std;
+
+#define V vector
+
+#define rmin(a, b) a = min(a, b)
+#define rmax(a, b) a = max(a, b)
+
+#define rep(i, lim) for (size_t i = 0; i < (lim); i++)
+#define nrep(i, s, lim) for (size_t 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;
+}
+
+int main()
+{
+    ios::sync_with_stdio(false);
+    cin.tie(nullptr);
+
+    int t;
+    cin >> t;
+    while (t--) {
+        ll l, r, x;
+        cin >> l >> r >> x;
+        ll a, b;
+        cin >> a >> b;
+
+        if (a == b) {
+            cout << "0\n";
+            continue;
+        }
+
+        if (abs(a - b) >= x) {
+            cout << "1\n";
+            continue;
+        }
+
+        if (a > b) {
+            swap(a, b);
+        }
+
+        if (b - l >= x && a - l >= x) {
+            cout << "2\n";
+            continue;
+        }
+
+        if (r - b >= x && r - a >= x) {
+            cout << "2\n";
+            continue;
+        }
+
+        if (r - l >= x && ((b - l >= x && r - a >= x) || (r - b >= x && a - l >= x))) {
+            cout << "3\n";
+            continue;
+        }
+
+        cout << "-1\n";
+    }
+}

Codeforces Round 834 (Div. 3)/D. Make It Round.cpp

@@ -0,0 +1,122 @@
+/* Problem URL: https://codeforces.com/contest/1759/problem/D */
+
+#include <bits/stdc++.h>
+
+using namespace std;
+
+#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;
+}
+
+int main()
+{
+    ios::sync_with_stdio(false);
+    cin.tie(nullptr);
+
+    int t;
+    cin >> t;
+    while (t--) {
+        ll n, m;
+        cin >> n >> m;
+
+        ll fives = 0;
+        ll twos = 0;
+
+        ll tmp = n;
+        while (tmp % 5 == 0) {
+            tmp /= 5;
+            fives++;
+        }
+
+        while (tmp % 2 == 0) {
+            tmp /= 2;
+            twos++;
+        }
+
+        tmp = n;
+        while (tmp % 10 == 0) {
+            tmp /= 10;
+            twos--;
+            fives--;
+        }
+
+        ll now = 1;
+        while (twos > 0 && now * 5 <= m) {
+            now *= 5;
+            twos--;
+        }
+
+        while (fives > 0 && now * 2 <= m) {
+            now *= 2;
+            fives--;
+        }
+
+        while (now * 10 <= m) {
+            now *= 10;
+        }
+
+
+        cout << n * now * (m / now) << '\n';
+    }
+}

Codeforces Round 1003 (Div. 4)/A. Skibidus and Amog'u.cpp

@@ -0,0 +1,93 @@
+/* Problem URL: https://codeforces.com/contest/2065/problem/0 */
+
+#include <bits/stdc++.h>
+
+using namespace std;
+
+#define V vector
+
+#define rmin(a, b) a = min(a, b)
+#define rmax(a, b) a = max(a, b)
+
+#define rep(i, lim) for (size_t i = 0; i < (lim); i++)
+#define nrep(i, s, lim) for (size_t 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;
+}
+
+int main()
+{
+    ios::sync_with_stdio(false);
+    cin.tie(nullptr);
+
+    int t;
+    scanf("%d", &t);
+    while (t--) {
+        char fds[11];
+        scanf("%s", fds);
+
+        char *ptr = fds;
+        while (*ptr != 0) {
+            ptr++;
+        }
+
+        ptr[-1] = 0;
+        ptr[-2] = 'i';
+
+        puts(fds);
+    }
+}

Codeforces Round 1003 (Div. 4)/B. Skibidus and Ohio.cpp

@@ -0,0 +1,93 @@
+/* Problem URL: https://codeforces.com/contest/2065/problem/B */
+
+#include <bits/stdc++.h>
+
+using namespace std;
+
+#define V vector
+
+#define rmin(a, b) a = min(a, b)
+#define rmax(a, b) a = max(a, b)
+
+#define rep(i, lim) for (size_t i = 0; i < (lim); i++)
+#define nrep(i, s, lim) for (size_t 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;
+}
+
+int main()
+{
+    ios::sync_with_stdio(false);
+    cin.tie(nullptr);
+
+    int t;
+    cin >> t;
+    while (t--) {
+        string a;
+        cin >> a;
+
+        size_t size = a.size();
+        nrep(i, 1, a.size()) {
+            if (a[i] == a[i - 1]) {
+                size = 1;
+                break;
+            }
+        }
+
+        cout << size << '\n';
+    }
+}

Codeforces Round 1003 (Div. 4)/C1. Skibidus and Fanum Tax (easy version).cpp

@@ -0,0 +1,118 @@
+/* Problem URL: https://codeforces.com/contest/2065/problem/C1 */
+
+#include <bits/stdc++.h>
+
+using namespace std;
+
+#define V vector
+
+#define rmin(a, b) a = min(a, b)
+#define rmax(a, b) a = max(a, b)
+
+#define rep(i, lim) for (size_t i = 0; i < (lim); i++)
+#define nrep(i, s, lim) for (size_t 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;
+}
+
+int main()
+{
+    ios::sync_with_stdio(false);
+    cin.tie(nullptr);
+
+    int t;
+    cin >> t;
+    while (t--) {
+        int n, m;
+        cin >> n >> m;
+
+        vi a(n);
+        cin >> a;
+        int num;
+        cin >> num;
+        
+        if (num - a[0] < a[0]) {
+            a[0] = num - a[0];
+        }
+
+        bool pos = true;
+        nrep(i, 1, n) {
+            if (num - a[i] < a[i] && num - a[i] >= a[i - 1]) {
+                a[i] = num - a[i];
+                continue;
+            }
+
+            if (a[i] < a[i - 1] && num - a[i] >= a[i - 1]) {
+                a[i] = num - a[i];
+                continue;
+            }
+
+            if (a[i] >= a[i - 1]) {
+                continue;
+            }
+
+            pos = false;
+            break;
+        }
+
+        if (pos) {
+            cout << "YES\n";
+        } else {
+            cout << "NO\n";
+        }
+    }
+}

Codeforces Round 1003 (Div. 4)/C2. Skibidus and Fanum Tax (hard version).cpp

@@ -0,0 +1,130 @@
+/* Problem URL: https://codeforces.com/contest/2065/problem/C2 */
+
+#include <bits/stdc++.h>
+
+using namespace std;
+
+#define V vector
+
+#define rmin(a, b) a = min(a, b)
+#define rmax(a, b) a = max(a, b)
+
+#define rep(i, lim) for (size_t i = 0; i < (lim); i++)
+#define nrep(i, s, lim) for (size_t 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;
+}
+
+int main()
+{
+    ios::sync_with_stdio(false);
+    // cin.tie(nullptr);
+
+    int t;
+    cin >> t;
+    while (t--) {
+        int n, m;
+        cin >> n >> m;
+
+        vl a(n);
+        cin >> a;
+        vl b(m);
+        cin >> b;
+
+        sortv(b);
+
+        if (b[0] - a[0] < a[0]) {
+            a[0] = b[0] - a[0];
+        }
+
+        bool pos = true;
+        nrep(i, 1, a.size()) {
+            int low = 0;
+            int high = b.size() - 1;
+            int ans = b.size();
+            while (low <= high) {
+                int mid = (low + high) / 2;
+
+                if (b[mid] - a[i] >= a[i - 1]) {
+                    ans = mid;
+                    high = mid - 1;
+                    continue;
+                }
+
+                low = mid + 1;
+            }
+
+            if (ans != b.size() && b[ans] - a[i] > a[i] && a[i] >= a[i - 1]) {
+                continue;
+            }
+
+            if (ans != b.size() && b[ans] - a[i] >= a[i - 1]) {
+                a[i] = b[ans] - a[i];
+                continue;
+            }
+
+            if (a[i] >= a[i - 1]) {
+                continue;
+            }
+            
+            pos = false;
+            break;
+        }
+
+        cout << (pos ? "YES\n" : "NO\n");
+    }
+}

Codeforces Round 1003 (Div. 4)/D. Skibidus and Sigma.cpp

@@ -0,0 +1,105 @@
+/* Problem URL: https://codeforces.com/contest/2065/problem/D */
+
+#include <bits/stdc++.h>
+
+using namespace std;
+
+#define V vector
+
+#define rmin(a, b) a = min(a, b)
+#define rmax(a, b) a = max(a, b)
+
+#define rep(i, lim) for (size_t i = 0; i < (lim); i++)
+#define nrep(i, s, lim) for (size_t 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;
+}
+
+int main()
+{
+    ios::sync_with_stdio(false);
+    cin.tie(nullptr);
+
+    int t;
+    cin >> t;
+    while (t--) {
+        int n, m;
+        cin >> n >> m;
+
+        V<pair<ll, V<ll>>> arrays(n, pair<ll, V<ll>>(0, V<ll>(m)));
+
+        for (auto &[num, arr] : arrays) {
+            for (auto &i : arr) {
+                cin >> i;
+                num += i;
+            }
+        }
+
+        sort(arrays.begin(), arrays.end(), greater<>());
+
+        ll total = 0;
+        ll pref = 0;
+        for (auto &[num, arr] : arrays) {
+            for (auto i : arr) {
+                pref += i;
+                total += pref;
+            }
+        }
+
+        cout << total << '\n';
+    }
+}

Codeforces Round 1003 (Div. 4)/E. Skibidus and Rizz.cpp

@@ -0,0 +1,127 @@
+/* Problem URL: https://codeforces.com/contest/2065/problem/E */
+
+#include <bits/stdc++.h>
+
+using namespace std;
+#define V vector
+
+#define rmin(a, b) a = min(a, b)
+#define rmax(a, b) a = max(a, b)
+
+#define rep(i, lim) for (size_t i = 0; i < (lim); i++)
+#define nrep(i, s, lim) for (size_t 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;
+}
+
+int main()
+{
+    ios::sync_with_stdio(false);
+    cin.tie(nullptr);
+
+    int t;
+    cin >> t;
+    while (t--) {
+        int x, y, z;
+        cin >> x >> y >> z;
+
+        if (z < abs(x - y) || z > max(x, y)) {
+            cout << "-1\n";
+            continue;
+        }
+
+        string ans;
+        int zeroes = x > y ? 1 : 0;
+
+        if (zeroes) {
+            rep(i, z) {
+                ans.push_back('0');
+                x--;
+            }
+        } else {
+            rep(i, z) {
+                ans.push_back('1');
+                y--;
+            }
+        }
+
+        int lim = x + y - z;
+        zeroes ^= 1;
+
+        while (x > 0 && y > 0) {
+            if (zeroes) {
+                ans.push_back('0');
+                x--;
+            } else {
+                ans.push_back('1');
+                y--;
+            }
+            zeroes ^= 1;
+        }
+
+        while (x > 0) {
+            ans.push_back('0');
+            x--;
+        }
+        while (y > 0) {
+            ans.push_back('1');
+            y--;
+        }
+
+        cout << ans << '\n';
+    }
+}

Codeforces Round 1003 (Div. 4)/F. Skibidus and Slay.cpp

@@ -0,0 +1,132 @@
+/* Problem URL: https://codeforces.com/contest/2065/problem/F */
+
+#include <bits/stdc++.h>
+
+using namespace std;
+
+#define V vector
+
+#define rmin(a, b) a = min(a, b)
+#define rmax(a, b) a = max(a, b)
+
+#define rep(i, lim) for (size_t i = 0; i < (lim); i++)
+#define nrep(i, s, lim) for (size_t 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;
+}
+
+int main()
+{
+    ios::sync_with_stdio(false);
+    cin.tie(nullptr);
+
+    int t;
+    cin >> t;
+    while (t--) {
+        int n;
+        cin >> n;
+
+        vi color(n + 1);
+        rep(i, n) {
+            cin >> color[i + 1];
+        }
+
+        vvi graph(n + 1);
+        rep(i, n - 1) {
+            int a, b;
+            cin >> a >> b;
+
+            graph[a].push_back(b);
+            graph[b].push_back(a);
+        }
+
+        vi parent(n + 1);
+
+        string ans(n, '0');
+        function<void(int, int)> dfs = [&](int i, int p){
+            if (color[i] == color[p]) {
+                ans[color[i] - 1] = '1';
+            }
+
+            if (color[i] == color[parent[p]]) {
+                ans[color[i] - 1] = '1';
+            }
+
+            parent[i] = p;
+
+            map<int, int> count;
+            for (auto j : graph[i]) {
+                if (j == p) {
+                    continue;
+                }
+
+                count[color[j]]++;
+                dfs(j, i);
+            }
+
+            for (auto &i : count) {
+                if (i.second >= 2) {
+                    ans[i.first - 1] = '1';
+                }
+            }
+        };
+
+        dfs(1, 0);
+
+        cout << ans << '\n';
+    }
+}

Codeforces Round 1003 (Div. 4)/G. Skibidus and Capping.cpp

@@ -0,0 +1,139 @@
+/* Problem URL: https://codeforces.com/contest/2065/problem/G */
+
+#include <bits/stdc++.h>
+
+using namespace std;
+
+#define V vector
+
+#define rmin(a, b) a = min(a, b)
+#define rmax(a, b) a = max(a, b)
+
+#define rep(i, lim) for (size_t i = 0; i < (lim); i++)
+#define nrep(i, s, lim) for (size_t 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;
+}
+
+int main()
+{
+    ios::sync_with_stdio(false);
+    cin.tie(nullptr);
+
+    V<bool> isprime(2e5 + 1, true);
+    isprime[1] = false;
+    vi divs(2e5 + 1);
+    divs[1] = 1;
+
+    for (int i = 2; i <= (int)2e5; i++) {
+        if (!isprime[i]) {
+            continue;
+        }
+
+        divs[i] = i;
+
+        for (int j = i * 2; j <= (int)2e5; j += i) {
+            isprime[j] = false;
+            divs[j] = i;
+        }
+    }
+
+    int t;
+    cin >> t;
+    while (t--) {
+        int n;
+        cin >> n;
+
+        vi nums;
+        ll primes = 0;
+        ll ans = 0;
+        vl count(n + 1);
+        rep(i, n) {
+            int num;
+            cin >> num;
+            if (isprime[num]) {
+                ans += primes;
+                primes++;
+                ans -= count[num];
+                count[num]++;
+                continue;
+            }
+
+            int a = divs[num];
+            int b = num / a;
+
+            if (!isprime[b]) {
+                continue;
+            }
+
+            nums.push_back(num);
+        }
+
+        for (auto i : nums) {
+            int a = divs[i];
+            int b = i / a;
+
+            count[i]++;
+            ans += count[a] + count[b] + count[i];
+            if (a == b) {
+                ans -= count[a];
+            }
+        }
+
+        cout << ans << '\n';
+    }
+}

Codeforces Round 1006 (Div. 3)/A. New World, New Me, New Array.cpp

@@ -0,0 +1,90 @@
+/* Problem URL: https://codeforces.com/contest/2072/problem/A */
+
+#include <bits/stdc++.h>
+
+using namespace std;
+
+#define V vector
+
+#define rmin(a, b) a = min(a, b)
+#define rmax(a, b) a = max(a, b)
+
+#define rep(i, lim) for (size_t i = 0; i < (lim); i++)
+#define nrep(i, s, lim) for (size_t 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;
+}
+
+int main()
+{
+    ios::sync_with_stdio(false);
+    cin.tie(nullptr);
+
+    int t;
+    cin >> t;
+    while (t--) {
+        int n, k, p;
+        cin >> n >> k >> p;
+
+        int ans = (n * p);
+        if ((ans >= k && k >= 0) || (-ans <= k && k < 0)) {
+            cout << (k == 0 ? 0 : abs(k / p) + min(1, abs(k % p))) << '\n';
+        } else {
+            cout << -1 << '\n';
+        }
+    }
+}

Codeforces Round 1006 (Div. 3)/B. Having Been a Treasurer in the Past, I Help Goblins Deceive.cpp

@@ -0,0 +1,92 @@
+/* Problem URL: https://codeforces.com/contest/2072/problem/B */
+
+#include <bits/stdc++.h>
+
+using namespace std;
+
+#define V vector
+
+#define rmin(a, b) a = min(a, b)
+#define rmax(a, b) a = max(a, b)
+
+#define rep(i, lim) for (size_t i = 0; i < (lim); i++)
+#define nrep(i, s, lim) for (size_t 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;
+}
+
+int main()
+{
+    ios::sync_with_stdio(false);
+    cin.tie(nullptr);
+
+    int t;
+    cin >> t;
+    while (t--) {
+        int n;
+        cin >> n;
+        string s;
+        cin >> s;
+
+        map<char, ll> count;
+        repv(i, s) {
+            count[i]++;
+        }
+
+        cout << count['-'] / 2 * (count['-'] / 2 + (count['-'] & 1)) * count['_'] << '\n';
+    }
+}

Codeforces Round 1006 (Div. 3)/C. Creating Keys for StORages Has Become My Main Skill.cpp

@@ -0,0 +1,109 @@
+/* Problem URL: https://codeforces.com/contest/2072/problem/C */
+
+#include <bits/stdc++.h>
+
+using namespace std;
+
+#define V vector
+
+#define rmin(a, b) a = min(a, b)
+#define rmax(a, b) a = max(a, b)
+
+#define rep(i, lim) for (size_t i = 0; i < (lim); i++)
+#define nrep(i, s, lim) for (size_t 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;
+}
+
+int main()
+{
+    ios::sync_with_stdio(false);
+    cin.tie(nullptr);
+
+    int t;
+    cin >> t;
+    while (t--) {
+        ll n, x;
+        cin >> n >> x;
+
+        if (n == 1) {
+            cout << x << '\n';
+            continue;
+        }
+
+        int pop = x == 0 ? 0 : __builtin_popcount(x);
+
+        int i = 0;
+        ll num = 0;
+        for (i = 0; i < n - 1 && (x | i) == x; i++) {
+            cout << i << ' ';
+            num |= i;
+        }
+
+        if (i == n - 1 && (x | i) == x && (num | i) == x) {
+            cout << i << ' ';
+        } else {
+            cout << x - num << ' ';
+        }
+        i++;
+        for (; i < n; i++) {
+            cout << 0 << ' ';
+        }
+
+        cout << '\n';
+    }
+}

Codeforces Round 1006 (Div. 3)/D. For Wizards, the Exam Is Easy, but I Couldn't Handle It.cpp

@@ -0,0 +1,123 @@
+/* Problem URL: https://codeforces.com/contest/2072/problem/D */
+
+#include <bits/stdc++.h>
+
+using namespace std;
+
+#define V vector
+
+#define rmin(a, b) a = min(a, b)
+#define rmax(a, b) a = max(a, b)
+
+#define rep(i, lim) for (size_t i = 0; i < (lim); i++)
+#define nrep(i, s, lim) for (size_t 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;
+}
+
+int main()
+{
+    ios::sync_with_stdio(false);
+    cin.tie(nullptr);
+
+    int t;
+    cin >> t;
+    while (t--) {
+        int n;
+        cin >> n;
+        vi nums(n);
+        cin >> nums;
+
+        int total = 0;
+        rep(i, n - 1) {
+            nrep(j, i + 1, n) {
+                if (nums[i] > nums[j]) {
+                    total++;
+                }
+            }
+        }
+
+        int best = total;
+        int l = 0;
+        int r = 0;
+
+        rep(i, n - 1) {
+            int right = 0;
+            int inv = 0;
+            nrep(j, i + 1, n) {
+                if (nums[j] > nums[i]) {
+                    right++;
+                } else if (nums[j] < nums[i]) {
+                    inv++;
+                }
+
+                if (total - inv + right < best) {
+                    best = total - inv + right;
+                    l = i;
+                    r = j;
+                }
+            }
+        }
+
+        if (best == total) {
+            cout << "1 1\n";
+            continue;
+        }
+
+        cout << l + 1 << ' ' << r + 1 << '\n';
+    }
+}

Codeforces Round 1006 (Div. 3)/E. Do You Love Your Hero and His Two-Hit Multi-Target Attacks?.cpp

@@ -0,0 +1,117 @@
+/* Problem URL: https://codeforces.com/contest/2072/problem/E */
+
+#include <bits/stdc++.h>
+
+using namespace std;
+
+#define V vector
+
+#define rmin(a, b) a = min(a, b)
+#define rmax(a, b) a = max(a, b)
+
+#define rep(i, lim) for (size_t i = 0; i < (lim); i++)
+#define nrep(i, s, lim) for (size_t 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;
+}
+
+int main()
+{
+    ios::sync_with_stdio(false);
+    cin.tie(nullptr);
+
+    int t;
+    cin >> t;
+    while (t--) {
+        ll k;
+        cin >> k;
+
+        int x = 1;
+        int y = 0;
+
+        V<pair<int, int>> staffs = {{0, 0}};
+
+        int eq = 1;
+        int total = 0;
+
+        while (total + eq <= k) {
+            total += eq;
+            eq++;
+            staffs.emplace_back(x, y);
+            x++;
+        }
+
+        x = -1;
+        y = 1;
+        while (total < k) {
+            x++;
+            eq = 1;
+
+            while (total + eq <= k) {
+                total += eq;
+                eq++;
+                staffs.emplace_back(x, y);
+                y++;
+            }
+        }
+
+        cout << staffs.size() << '\n';
+        for (auto [x, y] : staffs) {
+            cout << x << ' ' << y << '\n';
+        }
+    }
+}

Codeforces Round 1006 (Div. 3)/F. Goodbye, Banker Life.cpp

@@ -0,0 +1,92 @@
+/* Problem URL: https://codeforces.com/contest/2072/problem/F */
+
+#include <bits/stdc++.h>
+
+using namespace std;
+
+#define V vector
+
+#define rmin(a, b) a = min(a, b)
+#define rmax(a, b) a = max(a, b)
+
+#define rep(i, lim) for (size_t i = 0; i < (lim); i++)
+#define nrep(i, s, lim) for (size_t 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;
+}
+
+int main()
+{
+    ios::sync_with_stdio(false);
+    cin.tie(nullptr);
+
+    int t;
+    cin >> t;
+    while (t--) {
+        int n, k;
+        cin >> n >> k;
+
+        for (int i = 0; i < n; i++) {
+            if ((i & ((n - 1) - i)) > 0) {
+                cout << "0 ";
+            } else {
+                cout << k << ' ';
+            }
+        }
+        cout << '\n';
+    }
+}

Codeforces Round 1009 (Div. 3)/C. XOR and Triangle.cpp

@@ -0,0 +1,91 @@
+/* Problem URL: https://codeforces.com/contest/2074/problem/C */
+
+#include <bits/stdc++.h>
+
+using namespace std;
+
+#define V vector
+
+#define rmin(a, b) a = min(a, b)
+#define rmax(a, b) a = max(a, b)
+
+#define rep(i, lim) for (size_t i = 0; i < (lim); i++)
+#define nrep(i, s, lim) for (size_t 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;
+}
+
+int main()
+{
+    ios::sync_with_stdio(false);
+    cin.tie(nullptr);
+
+    int t;
+    cin >> t;
+    while (t--) {
+        ll n;
+        cin >> n;
+
+        if (__builtin_popcount(n) == 1 || 32 - __builtin_clz(n) - __builtin_ctz(~n) == 0) {
+            cout << "-1\n";
+            continue;
+        }
+
+        int ans = (1 << (31 - __builtin_clz(n))) - 1;
+        cout << ans << '\n';
+    }
+}

Codeforces Round 1013 (Div. 3)/A. Olympiad Date.cpp

@@ -0,0 +1,108 @@
+/* Problem URL: https://codeforces.com/contest/2091/problem/A */
+
+#include <bits/stdc++.h>
+
+using namespace std;
+
+#define V vector
+
+#define rmin(a, b) a = min(a, b)
+#define rmax(a, b) a = max(a, b)
+
+#define rep(i, lim) for (size_t i = 0; i < (lim); i++)
+#define nrep(i, s, lim) for (size_t 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;
+}
+
+int main()
+{
+    ios::sync_with_stdio(false);
+    cin.tie(nullptr);
+
+    int t;
+    cin >> t;
+    while (t--) {
+        vi count(10, 0);
+        count[0] = 3;
+        count[1] = 1;
+        count[2] = 2;
+        count[3] = 1;
+        count[5] = 1;
+        
+        size_t ans = 0;
+        ll counting = 8;
+        int n;
+        cin >> n;
+        vi nums(n);
+        cin >> nums;
+
+        rep(i, n) {
+            if (count[nums[i]] > 0) {
+                counting--;
+                count[nums[i]]--;
+            }
+
+            if (counting == 0) {
+                ans = i + 1;
+                break;
+            }
+        }
+
+        cout << ans << '\n';
+    }
+}

Codeforces Round 1013 (Div. 3)/B. Team Training.cpp

@@ -0,0 +1,113 @@
+/* Problem URL: https://codeforces.com/contest/2091/problem/B */
+
+#include <bits/stdc++.h>
+
+using namespace std;
+
+#define V vector
+
+#define rmin(a, b) a = min(a, b)
+#define rmax(a, b) a = max(a, b)
+
+#define rep(i, lim) for (size_t i = 0; i < (lim); i++)
+#define nrep(i, s, lim) for (size_t 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;
+}
+
+int main()
+{
+    ios::sync_with_stdio(false);
+    cin.tie(nullptr);
+
+    int t;
+    cin >> t;
+    while (t--) {
+        ll n, x;
+        cin >> n >> x;
+
+        int count = 0;
+        priority_queue<ll> pq;
+        while (n--) {
+            ll num;
+            cin >> num;
+            if (num >= x) {
+                count++;
+                continue;
+            }
+            pq.push(num);
+        }
+
+        ll now = 0;
+        ll memb = 0;
+        while (!pq.empty()) {
+            ll cur = pq.top();
+            pq.pop();
+
+            now = cur;
+            memb++;
+
+            if (now * memb >= x) {
+                count++;
+                now = 0;
+                memb = 0;
+            }
+        }
+
+        cout << count << '\n';
+    }
+}

Codeforces Round 1013 (Div. 3)/C. Combination Lock.cpp

@@ -0,0 +1,97 @@
+/* Problem URL: https://codeforces.com/contest/2091/problem/C */
+
+#include <bits/stdc++.h>
+
+using namespace std;
+
+#define V vector
+
+#define rmin(a, b) a = min(a, b)
+#define rmax(a, b) a = max(a, b)
+
+#define rep(i, lim) for (size_t i = 0; i < (lim); i++)
+#define nrep(i, s, lim) for (size_t 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;
+}
+
+int main()
+{
+    ios::sync_with_stdio(false);
+    cin.tie(nullptr);
+
+    int t;
+    cin >> t;
+
+    while (t--) {
+        int n;
+        cin >> n;
+
+        if ((n & 1) == 0) {
+            cout << "-1\n";
+            continue;
+        }
+
+        for (size_t i = 2; i <= n; i += 2) {
+            cout << i << ' ';
+        }
+        for (size_t i = 1; i <= n; i += 2) {
+            cout << i << ' ';
+        }
+        cout << '\n';
+    }
+}

Codeforces Round 1013 (Div. 3)/D. Place of the Olympiad.cpp

@@ -0,0 +1,96 @@
+/* Problem URL: https://codeforces.com/contest/2091/problem/D */
+
+#include <bits/stdc++.h>
+
+using namespace std;
+
+#define V vector
+
+#define rmin(a, b) a = min(a, b)
+#define rmax(a, b) a = max(a, b)
+
+#define rep(i, lim) for (size_t i = 0; i < (lim); i++)
+#define nrep(i, s, lim) for (size_t 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;
+}
+
+int main()
+{
+    ios::sync_with_stdio(false);
+    cin.tie(nullptr);
+
+    int t;
+    cin >> t;
+    while (t--) {
+        ll n, m, k;
+        cin >> n >> m >> k;
+
+        if (n >= k) {
+            cout << "1\n";
+            continue;
+        }
+
+        ll bigger = k / n;
+        if (k % n > 0) {
+            bigger++;
+        }
+
+        ll empty = m - bigger + 1;
+        cout << bigger / empty + min(1LL, bigger % empty) << '\n';
+    }
+}

Codeforces Round 1013 (Div. 3)/E. Interesting Ratio.cpp

@@ -0,0 +1,104 @@
+/* Problem URL: https://codeforces.com/contest/2091/problem/E */
+
+#include <bits/stdc++.h>
+
+using namespace std;
+
+#define V vector
+
+#define rmin(a, b) a = min(a, b)
+#define rmax(a, b) a = max(a, b)
+
+#define rep(i, lim) for (size_t i = 0; i < (lim); i++)
+#define nrep(i, s, lim) for (size_t 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;
+}
+
+int main()
+{
+    ios::sync_with_stdio(false);
+    cin.tie(nullptr);
+
+    vi primes(1e7 + 1, 0);
+
+    for (size_t i = 2; i <= (size_t)1e7; i++) {
+        if (primes[i] != 0) {
+            continue;
+        }
+
+        primes[i]++;
+        for (size_t j = i * 2; j <= (size_t)1e7; j += i) {
+            primes[j]++;
+        }
+    }
+
+    vl count(1e7 + 1, 0);
+    for (size_t i = 2; i <= (size_t)1e7; i++) {
+        count[i] = count[i - 1];
+        count[i] += primes[i];
+    }
+
+    int t;
+    cin >> t;
+    while (t--) {
+        ll n;
+        cin >> n;
+
+        cout << count[n] << '\n';
+    }
+}

Codeforces Round 1013 (Div. 3)/F. Igor and Mountain.cpp

@@ -0,0 +1,82 @@
+/* Problem URL: https://codeforces.com/contest/2091/problem/F */
+
+#include <bits/stdc++.h>
+
+using namespace std;
+
+#define V vector
+
+#define rmin(a, b) a = min(a, b)
+#define rmax(a, b) a = max(a, b)
+
+#define rep(i, lim) for (size_t i = 0; i < (lim); i++)
+#define nrep(i, s, lim) for (size_t 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;
+}
+
+int main()
+{
+    ios::sync_with_stdio(false);
+    cin.tie(nullptr);
+
+    int n, m, d;
+    cin >> n >> m >> d;
+
+    V<string> a;
+    cin >> a;
+}