Add a bunch of other problems.

XIII UnB Contest Mirror/A. Analyzing the Race.cpp

@@ -0,0 +1,209 @@
+/* Problem URL: https://codeforces.com/gym/106159/problem/A */
+
+#include <bits/stdc++.h>
+#include <ext/pb_ds/assoc_container.hpp>
+#include <ext/pb_ds/tree_policy.hpp>
+
+using namespace std;
+using namespace __gnu_pbds;
+
+template <class T, class comp = less<>>
+using ordered_set = tree<T, null_type , comp , rb_tree_tag , tree_order_statistics_node_update>;
+
+#define V vector
+
+#define rmin(a, b) a = min(a, b)
+#define rmax(a, b) a = max(a, b)
+
+#define rep(i, lim) for (int i = 0; i < (lim); i++)
+#define nrep(i, s, lim) for (int i = s; i < (lim); i++)
+
+#define repv(i, v) for (auto &i : (v))
+#define fillv(v) for (auto &itr_ : (v)) { cin >> itr_; }
+#define sortv(v) sort(v.begin(), v.end())
+#define all(v) (v).begin(), (v).end()
+
+using vi = vector<int>;
+using vvi = vector<vi>;
+using vvvi = vector<vvi>;
+using vvvvi = vector<vvvi>;
+
+using ll = long long;
+
+using vl = vector<ll>;
+using vvl = vector<vl>;
+using vvvl = vector<vvl>;
+using vvvvl = vector<vvvl>;
+
+template<class v>
+auto operator<<(ostream &os, const vector<v> &vec)->ostream& {
+    os << vec[0];
+    for (size_t i = 1; i < vec.size(); i++) {
+        os << ' ' << vec[i];
+    }
+    os << '\n';
+    return os;
+}
+
+template<class v>
+auto operator>>(istream &is, vector<v> &vec)->istream& {
+    for (auto &i : vec) {
+        is >> i;
+    }
+    return is;
+}
+
+template<class v>
+auto operator<<(ostream &os, const vector<vector<v>> &vec)->ostream& {
+    for (auto &i : vec) {
+        os << i[0];
+        for (size_t j = 1; j < i.size(); j++) {
+            os << ' ' << i[j];
+        }
+        os << '\n';
+    }
+    return os;
+}
+
+template<class v>
+auto operator>>(istream  &is, vector<vector<v>> &vec)->istream& {
+    for (auto &i : vec) {
+        for (auto &j : i) {
+            is >> j;
+        }
+    }
+    return is;
+}
+
+const int oo = INT32_MAX >> 1;
+const ll OO = INT64_MAX >> 1;
+
+
+void pre()
+{
+
+}
+
+ll mod = 998244353;
+
+#define TEST 0
+
+void solve()
+{
+    ll n, m;
+    cin >> n >> m;
+    string s;
+    cin >> s;
+
+    auto fpow = [&](ll a, ll p) {
+        ll ans = 1;
+        rep(i, 61) {
+            if ((p >> i) & 1) {
+                ans *= a;
+                ans %= mod;
+            }
+
+            a *= a;
+            a %= mod;
+        }
+
+        return ans;
+    };
+
+    // ll total = fpow(26, n - m) * (n - m + 1) % mod;
+    // // cout << fpow(26, n - m) * (n - m + 1) % mod << '\n';
+    // // cout << fpow(26, n - m) << '\n';
+    //
+    // nrep(i, 1, m - 1) {
+    //     if (s.substr(i, m - 1) != s.substr(0, m - i)) {
+    //         continue;
+    //     }
+    //
+    //     string tmp1 = s.substr(0, i);
+    //     string tmp2 = s.substr(m - i);
+    //     reverse(all(tmp2));
+    //     if (tmp1 != tmp2) {
+    //         continue;
+    //     }
+    //
+    //     int size = m + i;
+    //     if (size > n) {
+    //         break;
+    //     }
+    //
+    //     total -= fpow(26, n - size) * (n - size + 1) % mod;
+    //     total += mod * (total < 0);
+    // }
+    //
+    // if (2 * m > n) {
+    //     cout << total << '\n';
+    //     return;
+    // }
+    //
+    // ll rem = fpow(26, n - m * 2);
+    //
+    //
+    // cout << total << '\n';
+
+    // ll total = fpow(26, n);
+    // rep(i, m) {
+    //     ll now = fpow(26, i);
+    //     ll cur = n - i;
+    //
+    //     ll inv = (cur + m - 1) / m % mod;
+    //     ll val = (cur / m * (m - 1) + max(cur % m - 1, 0LL)) % mod;
+    //
+    //     total -= now * fpow(25, inv) % mod * fpow(26, val) % mod;
+    //     total += mod * (total < 0);
+    // }
+    //
+    // cout << total << '\n';
+
+    vl fact(101);
+    fact[0] = 1;
+    nrep(i, 1, 101) {
+        fact[i] = (fact[i - 1] * i) % mod;
+    }
+
+    vl inv(101);
+    inv[0] = 1;
+    inv[1] = 1;
+    nrep(i, 2, 101) {
+        inv[i] = (mod - mod / i) * inv[mod % i] % mod;
+    }
+    nrep(i, 2, 101) {
+        inv[i] = (inv[i] * inv[i - 1]) % mod;
+    }
+
+    auto comb = [&](ll n, ll k) {
+        return fact[n] * inv[k] % mod * inv[n - k] % mod;
+    };
+
+    auto comb2 = [&](ll n, ll k) {
+        ll ans = n;
+        ll div = 1;
+        nrep(i, 2, k + 1) {
+            ans = (ans * (n - i + 1)) % mod;
+            div = (div * i) % mod;
+        }
+
+        return ans * fpow(div, mod - 2) % mod;
+    };
+
+    ll rem = 0;
+    ll cur = (n + m - 1) / m;
+}
+
+int main()
+{
+    ios::sync_with_stdio(false);
+    cin.tie(nullptr);
+
+    pre();
+
+    int t;
+    (TEST && cin >> t) || (t = 1);
+    while (t--) {
+        solve();
+    }
+}

XIII UnB Contest Mirror/B. Bauru.cpp

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

XIII UnB Contest Mirror/C. Creating a Playlist.cpp

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

XIII UnB Contest Mirror/D. Shift Cipher.cpp

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

XIII UnB Contest Mirror/E. Elementary Data Structure Problem.cpp

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

XIII UnB Contest Mirror/F. Falatro.cpp

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

XIII UnB Contest Mirror/G. Gelatos from Goiás.cpp

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

XIII UnB Contest Mirror/I. Ivo saw the UVa.cpp

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

XIII UnB Contest Mirror/J. Jolly Game Night.cpp

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

XIII UnB Contest Mirror/K. Kronos.cpp

@@ -0,0 +1,118 @@
+/* Problem URL: https://codeforces.com/gym/106159/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;
+}
+
+const int oo = INT32_MAX >> 1;
+const ll OO = INT64_MAX >> 1;
+
+
+void pre()
+{
+
+}
+
+#define TEST 0
+
+void solve()
+{
+    int n, q;
+    cin >> n >> q;
+
+    vi a(n);
+    cin >> a;
+    sortv(a);
+
+    while (q--) {
+        int l, r;
+        cin >> l >> r;
+
+        cout << upper_bound(all(a), r) - lower_bound(all(a), l) << '\n';
+    }
+}
+
+int main()
+{
+    ios::sync_with_stdio(false);
+    cin.tie(nullptr);
+
+    pre();
+
+    int t;
+    (TEST && cin >> t) || (t = 1);
+    while (t--) {
+        solve();
+    }
+}

XIII UnB Contest Mirror/L. Leveling Diamonds.cpp

@@ -0,0 +1,129 @@
+/* Problem URL: https://codeforces.com/gym/106159/problem/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()
+{
+    ll n;
+    cin >> n;
+
+    ll mod = 1e9 + 7;
+
+    auto fpow = [&](ll a, ll p) {
+        ll ans = 1;
+        rep(i, 61) {
+            if ((p >> i) & 1) {
+                ans *= a;
+                ans %= mod;
+            }
+
+            a *= a;
+            a %= mod;
+        }
+
+        return ans;
+    };
+
+    ll part1 = 4 * ((__int128)n * (n + 1) % mod * (2 * n + 1) % mod * fpow(6, mod - 2)) % mod;
+    ll part2 = 4 * ((__int128)n * (n + 1) % mod * fpow(2, mod - 2)) % mod;
+
+    cout << ((part1 + part2) % mod + n) % mod << '\n';
+}
+
+int main()
+{
+    ios::sync_with_stdio(false);
+    cin.tie(nullptr);
+
+    pre();
+
+    int t;
+    (TEST && cin >> t) || (t = 1);
+    while (t--) {
+        solve();
+    }
+}

XIII UnB Contest Mirror/N. Nautic Issue.cpp

@@ -0,0 +1,173 @@
+/* Problem URL: https://codeforces.com/gym/106159/problem/N */
+
+#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()
+{
+    ll d, tmpy;
+    cin >> d >> tmpy;
+    __int128 y = tmpy;
+
+    int size = 62;
+    V<__int128> mov(size);
+    mov[0] = 0;
+    mov[1] = 1;
+    mov[2] = 3;
+    nrep(i, 3, size) {
+        mov[i] = mov[i - 1] * 2;
+    }
+
+    V<__int128> pref(size + 1);
+    rep(i, size) {
+        pref[i + 1] = pref[i] + mov[i];
+    }
+
+    int low = 0;
+    int high = size;
+    int an = -1;
+    while (low <= high) {
+        int mid = (low + high) >> 1;
+
+        if (pref[mid] >= d) {
+            an = mid;
+            high = mid - 1;
+            continue;
+        }
+
+        low = mid + 1;
+    }
+
+    int now = ~an & 1;
+    __int128 cost = d - pref[an - 1];
+    __int128 x = y + cost * (now ? -1 : 1);
+    now ^= 1;
+    an--;
+    while (an-- > 0) {
+        __int128 next = x + mov[an] * (now ? -1 : 1);
+        if ((y >= x && y <= next) || (y >= next && y <= x)) {
+            cout << "Nao\n";
+            return;
+        }
+        x = next;
+        now ^= 1;
+    }
+
+    string ans;
+    if (x == 0) {
+        ans = "0";
+    } else {
+        bool neg = false;
+        if (x < 0) {
+            x = -x;
+            neg = true;
+        }
+        while (x > 0) {
+            ans.push_back(x % 10 + '0');
+            x /= 10;
+        }
+        if (neg) {
+            ans.push_back('-');
+        }
+    }
+    reverse(all(ans));
+
+    cout << "Sim\n" << ans << '\n';
+}
+
+int main()
+{
+    ios::sync_with_stdio(false);
+    cin.tie(nullptr);
+
+    pre();
+
+    int t;
+    (TEST && cin >> t) || (t = 1);
+    while (t--) {
+        solve();
+    }
+}