Some problems for the list

2024-2025 ICPC, NERC, Southern and Volga Russian Regional Contest (Unrated, Online Mirror, ICPC Rules, Preferably Teams)/L. Bridge Renovation.cpp

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

Codeforces Round 1002 (Div. 2)/C. Customer Service.cpp

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

Codeforces Round 1009 (Div. 3)/D. Counting Points.cpp

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

Codeforces Round 887 (Div. 1)/A. Ntarsis' Set.cpp

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

Codeforces Round 887 (Div. 1)/B. Imbalanced Arrays.cpp

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

Codeforces Round 917 (Div. 2)/C. Watering an Array.cpp

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

Codeforces Round 919 (Div. 2)/D. Array Repetition.cpp

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

Codeforces Round 927 (Div. 3)/C. LR-remainders.cpp

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

Codeforces Round 977 (Div. 2, based on COMPFEST 16 - Final Round)/C2. Adjust The Presentation (Hard Version).cpp

@@ -0,0 +1,207 @@
+/* Problem URL: https://codeforces.com/problemset/problem/2021/C2 */
+
+#include <bits/stdc++.h>
+#include <ext/pb_ds/assoc_container.hpp>
+#include <ext/pb_ds/tree_policy.hpp>
+
+using namespace std;
+using namespace __gnu_pbds;
+
+template <class T, class comp = less<>>
+using ordered_set = tree<T, null_type , comp , rb_tree_tag , tree_order_statistics_node_update>;
+
+#define V vector
+
+#define rmin(a, b) a = min(a, b)
+#define rmax(a, b) a = max(a, b)
+
+#define rep(i, lim) for (int i = 0; i < (lim); i++)
+#define nrep(i, s, lim) for (int i = s; i < (lim); i++)
+
+#define repv(i, v) for (auto &i : (v))
+#define fillv(v) for (auto &itr_ : (v)) { cin >> itr_; }
+#define sortv(v) sort(v.begin(), v.end())
+#define all(v) (v).begin(), (v).end()
+
+using vi = vector<int>;
+using vvi = vector<vi>;
+using vvvi = vector<vvi>;
+using vvvvi = vector<vvvi>;
+
+using ll = long long;
+
+using vl = vector<ll>;
+using vvl = vector<vl>;
+using vvvl = vector<vvl>;
+using vvvvl = vector<vvvl>;
+
+template<class v>
+auto operator<<(ostream &os, const vector<v> &vec)->ostream& {
+    os << vec[0];
+    for (size_t i = 1; i < vec.size(); i++) {
+        os << ' ' << vec[i];
+    }
+    os << '\n';
+    return os;
+}
+
+template<class v>
+auto operator>>(istream &is, vector<v> &vec)->istream& {
+    for (auto &i : vec) {
+        is >> i;
+    }
+    return is;
+}
+
+template<class v>
+auto operator<<(ostream &os, const vector<vector<v>> &vec)->ostream& {
+    for (auto &i : vec) {
+        os << i[0];
+        for (size_t j = 1; j < i.size(); j++) {
+            os << ' ' << i[j];
+        }
+        os << '\n';
+    }
+    return os;
+}
+
+template<class v>
+auto operator>>(istream  &is, vector<vector<v>> &vec)->istream& {
+    for (auto &i : vec) {
+        for (auto &j : i) {
+            is >> j;
+        }
+    }
+    return is;
+}
+
+const int oo = INT32_MAX >> 1;
+const ll OO = INT64_MAX >> 1;
+
+
+void pre()
+{
+
+}
+
+#define TEST 1
+
+void solve()
+{
+    int n, m, q;
+    cin >> n >> m >> q;
+
+    vi a(n);
+    cin >> a;
+
+    vi var(n);
+    V<set<int>> ap(n);
+    rep(i, n) {
+        var[a[i] - 1] = i;
+        ap[i].insert(oo);
+    }
+
+    vi b(m);
+    rep(i, m) {
+        cin >> b[i];
+        ap[var[b[i] - 1]].insert(i);
+    }
+
+    int sz = n;
+    while (__builtin_popcount(sz) != 1) {
+        sz++;
+    }
+
+    V<ordered_set<pair<int, int>>> seg(sz * 2);
+    vl sum(sz * 2);
+    nrep(i, sz, sz * 2) {
+        seg[i].insert({oo, i - sz});
+    }
+
+    for (int i = sz - 1; i > 0; i--) {
+        repv(j, seg[i * 2]) {
+            seg[i].insert(j);
+        }
+        repv(j, seg[i * 2 + 1]) {
+            seg[i].insert(j);
+        }
+    }
+
+    auto update = [&](int i, int v) {
+        int ind = i;
+        i += sz;
+        auto bf = *seg[i].begin();
+        seg[i].clear();
+        seg[i].insert({v, i - sz});
+        int now = i & 1;
+        int dd = 0;
+
+        for (i >>= 1; i > 0; i >>= 1) {
+            seg[i].erase(bf);
+            seg[i].insert({v, ind});
+            sum[i] += dd;
+
+            if (now) {
+                int s = seg[i * 2].size() - seg[i * 2].order_of_key({v, oo});
+                int s2 = seg[i * 2].size() - seg[i * 2].order_of_key({bf.first, oo});
+                sum[i] -= s2;
+                sum[i] += s;
+                dd -= s2;
+                dd += s;
+            } else {
+                int s = seg[i * 2 + 1].order_of_key({v, -1});
+                int s2 = seg[i * 2 + 1].order_of_key({bf.first, -1});
+                sum[i] -= s2;
+                sum[i] += s;
+                dd -= s2;
+                dd += s;
+            }
+
+            now = i & 1;
+        }
+    };
+
+    rep(i, n) {
+        update(i, *ap[i].begin());
+    }
+
+    auto check = [&]() {
+        string ans[] = {
+            "TIDAK",
+            "YA"
+        };
+        cout << ans[sum[1] == 0] << '\n';
+    };
+
+    check();
+    while (q--) {
+        int i, j;
+        cin >> i >> j;
+        i--;
+
+        int bf = b[i];
+        b[i] = j;
+        int actbf = var[bf - 1];
+        int actb = var[b[i] - 1];
+
+        ap[actbf].erase(i);
+        ap[actb].insert(i);
+        update(actbf, *ap[actbf].begin());
+        update(actb, *ap[actb].begin());
+        check();
+    }
+}
+
+int main()
+{
+    ios::sync_with_stdio(false);
+    cin.tie(nullptr);
+
+    pre();
+
+    int t;
+    (TEST && cin >> t) || (t = 1);
+    while (t--) {
+        solve();
+    }
+}

Educational Codeforces Round 152 (Rated for Div. 2)/C. Binary String Copying.cpp

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

Educational Codeforces Round 162 (Rated for Div. 2)/D. Slimes.cpp

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

TODO.md

@@ -146,6 +146,11 @@ Official divs from codeforces
 
 		I honestly have no idea how to solve this, the editorial didn't help much, I'll get
 		back at it after learning NTT or something.
+	
+	- [ ] [C2. Adjust The Presentation (Hard Version)](https://codeforces.com/problemset/problem/2021/C2)
+
+		I already have the idea figured out, but my solution ended up getting TLE, I'll have to come
+		with something better.
 
 - Div 3
 

problemlist.md

@@ -17,6 +17,11 @@ A little collection of interesting problems that I randomly decided to do.
 
 	Another incredibly annoying problem, beware...
 
+- [D. Counting Points]](https://codeforces.com/problemset/problem/2074/D)
+
+	I remember that I couldn't solve it before... Now it's painfully easy to do, but the
+	idea might be interesting to show in a class or something.
+
 ## Data structures
 
 - [D. Recommendations](https://codeforces.com/contest/2042/problem/D)
@@ -41,6 +46,11 @@ A little collection of interesting problems that I randomly decided to do.
 	Can be solved in two ways, but the sparse table one is interesting, although
 	the other way seems more versatile.
 
+- [A. Ntarsis' Set](https://codeforces.com/problemset/problem/1852/A)
+
+	REALLY good binary search problem, amazing to do and think about, the binary search isn't
+	obvious at all.
+
 ## Reroot
 
 - [D. Tree XOR](https://codeforces.com/problemset/problem/1882/D)