Merge branch 'master' of https://git.puffypony.party/Segcolt/cses-solutions

.gdb_history

@@ -1,137 +1,3 @@
-p b
-next
-run
-next
-p pref[i - a]
-next
-next
-p vaar
-p var
-p pref[i]
-p pref[i] - *var.begin()
-next
-break 94
-run
-next
-p i - b + 1
-p i - b + 1
-p i
-break 94
-run
-run
-next
-p i - b + 1
-p a
-p b
-p i - b + 1
-p i
-p i - b - 1
-break 94
-run
-next
-next
-p ans
-p var
-p pref[i - a]
-break 94
-run
-next
-p anms
-p ans
-next
-p i - a
-p pref[i - a]
-p i
-next
-p ansd
-p ans
-next
-p var
-break 127
-ru
-p log
-next
-p log
-p l
-p r
-p r - (1 << log)
-sparse
-p sparse
-break 128
-run
-p sparse
-continue
-run
-p sparse[l][log]
-p l
-p r
-break 128
-run
-break 154
-run
-p seg[0 + fds.size()]
-p segl[0 + fds.size()]
-p segl[1 + fds.size()]
-p segl[1 + fds.size()]
-p segl[2 + fds.size()]
-p segl[3 + fds.size()]
-p segl[4 + fds.size()]
-p segl[5 + fds.size()]
-next
-p i
-p fds[i]
-p sparsequery(i, i)
-p ans
-p i
-next
-p segr[8 + fds.size()]
-p segr[7 + fds.size()]
-p segr[8 + fds.size()]
-p segr[9 + fds.size()]
-break 178
-ru
-p segr
-p segr[5 + fds.size()]
-break 138
-run
-nextr
-next
-pi 
-p i
-p i
-p i
-continue
-necxt
-nexty
-next
-continue
-next
-continue
-next
-next
-p seg[6 + fds.size()]
-break 139
-run
-continue
-next
-p ans
-break 126
-run
-p count
-p n
-break 109
-run
-next
-p ans
-p count
-break 90
-run
-next
-p sum
-next
-p i
-next
-break 110
 run
 p sum
 p count
@@ -254,3 +120,137 @@ p e.cap - e.flow
 continue
 p v
 p f
+ru
+run
+break 168
+run
+next
+p now
+next
+p lower->first
+p upper->second
+p lower->second
+p now.a
+p now.b
+p i.i
+p now.i
+next
+p p var
+p var
+p ans
+p l
+p r
+p bit
+run
+next
+p var
+p bit
+next
+p bit
+next
+p bit
+next
+p bit
+next
+break 156
+run
+break 97
+run
+p a
+next
+p 
+p n
+next
+p cur
+break 97
+run
+next
+p i
+p cur
+next
+p cur
+next
+p cur
+p ans
+break  98
+ru
+next
+p cur
+p ans
+p a[j]
+p a
+p n / 17
+next
+p cur
+p n / (a[0] * a[1])
+next
+p cur
+next
+next
+p ans
+next
+break 100
+run
+continue
+next
+p cur
+p i
+p n / a[2]
+next
+p cur
+p n / (a[0] * a[2])
+next
+p cur
+p i
+n / (a[1] * a[2])
+p n / (a[1] * a[2])
+next
+p ans
+next
+p cur
+p i
+p n / (a[0] * a[1] * a[2])
+next
+p cur
+next
+p n / a[3]
+next
+p cur
+p i
+p n / (a[0] * a[3])
+p ans
+next
+p ans
+next
+p cur
+p n / (a[1] * a[3])
+next
+p cur
+next
+p cur
+p i
+p n / (a[2] * a[3])
+next
+p cur
+next
+p cur
+next
+pc ur
+next
+p ans
+break 101
+run
+next
+continue
+next
+p cur
+p cur2
+p n / cur2
+p cur
+next
+p cur
+p cur2
+p ans + cur
+p ans2 + n / cur2
+p n / cur2
+p cur

.gitignore

@@ -34,3 +34,8 @@
 
 # Ignore testcases files from competitest
 *.testcases
+
+# Ignore gdb
+.gdb_history
+
+*sync*

CSES Problem Set/Convex Hull.cpp

@@ -0,0 +1,192 @@
+/* Problem URL: https://cses.fi/problemset/task/2195 */
+
+#include <bits/stdc++.h>
+#include <ext/pb_ds/assoc_container.hpp>
+#include <ext/pb_ds/tree_policy.hpp>
+
+using namespace std;
+using namespace __gnu_pbds;
+
+template <class T, class comp = less<>>
+using ordered_set = tree<T, null_type , comp , rb_tree_tag , tree_order_statistics_node_update>;
+
+#define V vector
+
+#define rmin(a, b) a = min(a, b)
+#define rmax(a, b) a = max(a, b)
+
+#define rep(i, lim) for (int i = 0; i < (lim); i++)
+#define nrep(i, s, lim) for (int i = s; i < (lim); i++)
+
+#define repv(i, v) for (auto &i : (v))
+#define fillv(v) for (auto &itr_ : (v)) { cin >> itr_; }
+#define sortv(v) sort(v.begin(), v.end())
+#define all(v) (v).begin(), (v).end()
+
+using vi = vector<int>;
+using vvi = vector<vi>;
+using vvvi = vector<vvi>;
+using vvvvi = vector<vvvi>;
+
+using ll = long long;
+
+using vl = vector<ll>;
+using vvl = vector<vl>;
+using vvvl = vector<vvl>;
+using vvvvl = vector<vvvl>;
+
+template<class v>
+auto operator<<(ostream &os, const vector<v> &vec)->ostream& {
+    os << vec[0];
+    for (size_t i = 1; i < vec.size(); i++) {
+        os << ' ' << vec[i];
+    }
+    os << '\n';
+    return os;
+}
+
+template<class v>
+auto operator>>(istream &is, vector<v> &vec)->istream& {
+    for (auto &i : vec) {
+        is >> i;
+    }
+    return is;
+}
+
+template<class v>
+auto operator<<(ostream &os, const vector<vector<v>> &vec)->ostream& {
+    for (auto &i : vec) {
+        os << i[0];
+        for (size_t j = 1; j < i.size(); j++) {
+            os << ' ' << i[j];
+        }
+        os << '\n';
+    }
+    return os;
+}
+
+template<class v>
+auto operator>>(istream  &is, vector<vector<v>> &vec)->istream& {
+    for (auto &i : vec) {
+        for (auto &j : i) {
+            is >> j;
+        }
+    }
+    return is;
+}
+
+const int oo = INT32_MAX >> 1;
+const ll OO = INT64_MAX >> 1;
+
+struct pt {
+    ll x, y;
+    
+    pt() = default;
+    pt(ll x, ll y): x(x), y(y) {}
+    pt(const pt &a): x(a.x), y(a.y) {}
+
+    friend istream &operator >> (istream &is, pt &a) {
+        is >> a.x >> a.y;
+        return is;
+    }
+
+    friend ostream &operator << (ostream &os, pt a) {
+        os << a.x << ' ' << a.y << '\n';
+        return os;
+    }
+
+    ll operator ^ (pt b) {
+        return x * b.y - y * b.x;
+    }
+
+    pt operator - (pt b) {
+        return pt(x - b.x, y - b.y);
+    }
+
+    bool operator < (pt b) {
+        if (x == b.x) {
+            return y < b.y;
+        }
+        return x < b.x;
+    }
+};
+
+ll sarea2(pt a, pt b, pt c) {
+    return (b - a) ^ (c - b);
+}
+
+int ccw(pt a, pt b, pt c)
+{
+    ll ar = sarea2(a, b, c);
+    return (ar > 0) - (ar < 0);
+}
+
+V<pt> convex_hull(V<pt> v)
+{
+    sortv(v);
+    if (v.size() <= 2) {
+        return v;
+    }
+
+    int n = v.size();
+
+    V<pt> ac;
+    V<pt> tmp;
+
+    rep(i, n) {
+        while (ac.size() >= 2 && ccw(ac.end()[-2], ac.end()[-1], v[i]) > 0) {
+            ac.pop_back();
+        }
+        ac.emplace_back(v[i]);
+    }
+
+    for (int i = n - 1; i >= 0; i--) {
+        while (tmp.size() >= 2 && ccw(tmp.end()[-2], tmp.end()[-1], v[i]) > 0) {
+            tmp.pop_back();
+        }
+        tmp.emplace_back(v[i]);
+    }
+
+    ac.pop_back();
+    tmp.pop_back();
+
+    repv(i, tmp) {
+        ac.emplace_back(i);
+    }
+
+    return ac;
+}
+
+void pre()
+{
+
+}
+
+#define TEST 0
+
+void solve()
+{
+    int n;
+    cin >> n;
+    V<pt> a(n);
+    cin >> a;
+    auto conv = convex_hull(a);
+    cout << conv.size() << '\n';
+    repv(i, conv) {
+        cout << i.x << ' ' << i.y << '\n';
+    }
+}
+
+int main()
+{
+    ios::sync_with_stdio(false);
+    cin.tie(nullptr);
+
+    pre();
+
+    int t;
+    (TEST && cin >> t) || (t = 1);
+    while (t--) {
+        solve();
+    }
+}

CSES Problem Set/Fibonacci Numbers.cpp

@@ -0,0 +1,151 @@
+/* Problem URL: https://cses.fi/problemset/task/1722 */
+
+#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;
+
+    if (n == 0) {
+        cout << "0\n";
+        return;
+    }
+
+    const ll mod = 1e9 + 7;
+
+    auto mul = [&](vvl &a, vvl &b) {
+        vvl c(a.size(), vl(b[0].size()));
+
+        rep(i, c.size()) {
+            rep(j, c[i].size()) {
+                rep(k, b.size()) {
+                    c[i][j] = (c[i][j] + a[i][k] * b[k][j] % mod) % mod;
+                }
+            }
+        }
+
+        return c;
+    };
+
+    auto fpow = [&](ll p) {
+        vvl ans = {
+            {0},
+            {1}
+        };
+
+        vvl po = {
+            {0, 1},
+            {1, 1}
+        };
+
+        rep(i, 61) {
+            if ((p >> i) & 1) {
+                ans = mul(po, ans);
+            }
+            po = mul(po, po);
+        }
+
+        return ans;
+    };
+
+    cout << fpow(n - 1)[1] << '\n';
+}
+
+int main()
+{
+    ios::sync_with_stdio(false);
+    cin.tie(nullptr);
+
+    pre();
+
+    int t;
+    (TEST && cin >> t) || (t = 1);
+    while (t--) {
+        solve();
+    }
+}

CSES Problem Set/Graph Paths I.cpp

@@ -0,0 +1,152 @@
+/* Problem URL: https://cses.fi/problemset/task/1723 */
+ 
+#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, k;
+    cin >> n >> m >> k;
+ 
+    vvl adj(n, vl(n));
+ 
+    while (m--) {
+        int a, b;
+        cin >> a >> b;
+        adj[a - 1][b - 1]++;
+    }
+ 
+    ll mod = 1e9 + 7;
+ 
+    auto mul = [&](vvl &a, vvl &b) {
+        vvl c(a.size(), vl(b[0].size()));
+ 
+        rep(i, c.size()) {
+            rep(j, c[0].size()) {
+                rep(k, b.size()) {
+                    c[i][j] += a[i][k] * b[k][j];
+                    c[i][j] %= mod;
+                }
+            }
+        }
+ 
+        return c;
+    };
+ 
+    auto fpow = [&]() {
+        vvl ans(n, vl(n));
+        rep(i, n) {
+            ans[i][i] = 1;
+        }
+ 
+        rep(i, 30) {
+            if ((k >> i) & 1) {
+                ans = mul(ans, adj);
+            }
+            adj = mul(adj, adj);
+        }
+ 
+        return ans;
+    };
+ 
+    auto ans = fpow();
+ 
+    cout << ans[0][n - 1] << '\n';
+}
+ 
+int main()
+{
+    ios::sync_with_stdio(false);
+    cin.tie(nullptr);
+ 
+    pre();
+ 
+    int t;
+    (TEST && cin >> t) || (t = 1);
+    while (t--) {
+        solve();
+    }
+}

CSES Problem Set/Graph Paths II.cpp

@@ -0,0 +1,149 @@
+/* Problem URL: https://cses.fi/problemset/task/1724 */
+ 
+#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, k;
+    cin >> n >> m >> k;
+ 
+    vvl adj(n, vl(n, OO));
+ 
+    while (m--) {
+        int a, b, c;
+        cin >> a >> b >> c;
+        a--, b--;
+        rmin(adj[a][b], (ll)c);
+    }
+ 
+    auto mul = [&](vvl &a, vvl &b) {
+        vvl c(a.size(), vl(b[0].size(), OO));
+ 
+        rep(i, c.size()) {
+            rep(j, c[0].size()) {
+                rep(k, b.size()) {
+                    rmin(c[i][j], a[i][k] + b[k][j]);
+                }
+            }
+        }
+ 
+        return c;
+    };
+ 
+    auto fpow = [&]() {
+        vvl ans(n, vl(n, OO));
+        rep(i, n) {
+            ans[i][i] = 0;
+        }
+ 
+        rep(i, 30) {
+            if ((k >> i) & 1) {
+                ans = mul(ans, adj);
+            }
+            adj = mul(adj, adj);
+        }
+ 
+        return ans;
+    };
+ 
+    ll ans = fpow()[0][n - 1];
+    cout << (ans == OO ? -1 : ans) << '\n';
+}
+ 
+int main()
+{
+    ios::sync_with_stdio(false);
+    cin.tie(nullptr);
+ 
+    pre();
+ 
+    int t;
+    (TEST && cin >> t) || (t = 1);
+    while (t--) {
+        solve();
+    }
+}

CSES Problem Set/Next Prime.cpp

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

CSES Problem Set/Pizzeria Queries.cpp

@@ -0,0 +1,166 @@
+/* Problem URL: https://cses.fi/problemset/task/2206 */
+
+#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, q;
+    cin >> n >> q;
+
+    vl fds(n);
+    cin >> fds;
+
+    ll oo = INT64_MAX >> 1;
+
+    while (__builtin_popcount(n) != 1) {
+        n++;
+        fds.push_back(oo);
+    }
+
+    vl segpref(n * 2);
+    vl segsuf(n * 2);
+    
+    rep(i, n) {
+        segpref[i + n] = fds[i] + i;
+        segsuf[i + n] = fds[i] + (n - i - 1);
+    }
+
+    for (int i = n - 1; i > 0; i--) {
+        segpref[i] = min(segpref[i * 2], segpref[i * 2 + 1]);
+        segsuf[i] = min(segsuf[i * 2], segsuf[i * 2 + 1]);
+    }
+
+    auto update = [&](int i, ll v) {
+        i += n;
+        segpref[i] = v + (i - n);
+        segsuf[i] = v + (2 * n - i - 1);
+
+        for (i >>= 1; i > 0; i >>= 1) {
+            segpref[i] = min(segpref[i * 2], segpref[i * 2 + 1]);
+            segsuf[i] = min(segsuf[i * 2], segsuf[i * 2 + 1]);
+        }
+    };
+
+    function<ll(int, int, int, int, int)> querypref = [&](int i, int l, int r, int tl, int tr) {
+        if (l > tr || r < tl) {
+            return oo;
+        }
+
+        if (l >= tl && r <= tr) {
+            return segpref[i];
+        }
+
+        int mid = (l + r) >> 1;
+
+        return min(querypref(i * 2, l, mid, tl, tr), querypref(i * 2 + 1, mid + 1, r, tl, tr));
+    };
+
+    function<ll(int, int, int, int, int)> querysuf = [&](int i, int l, int r, int tl, int tr) {
+        if (l > tr || r < tl) {
+            return oo;
+        }
+
+        if (l >= tl && r <= tr) {
+            return segsuf[i];
+        }
+
+        int mid = (l + r) >> 1;
+
+        return min(querysuf(i * 2, l, mid, tl, tr), querysuf(i * 2 + 1, mid + 1, r, tl, tr));
+    };
+
+    while (q--) {
+        int op;
+        cin >> op;
+
+        if (op == 1) {
+            int k, x;
+            cin >> k >> x;
+
+            update(k - 1, x);
+            continue;
+        }
+
+        int k;
+        cin >> k;
+        k--;
+
+        cout << min({querypref(1, 0, n - 1, k, n - 1) - k, querysuf(1, 0, n - 1, 0, k) - (n - k - 1)}) << '\n';
+    }
+}

CSES Problem Set/Point Location Test.cpp

@@ -0,0 +1,126 @@
+/* Problem URL: https://cses.fi/problemset/task/2189 */
+
+#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 x1, y1, x2, y2, x3, y3;
+    cin >> x1 >> y1 >> x2 >> y2 >> x3 >> y3;
+
+    x3 -= x2;
+    y3 -= y2;
+    x2 -= x1;
+    y2 -= y1;
+
+    ll ar = x2 * y3 - y2 * x3;
+
+    if (ar > 0) {
+        cout << "LEFT\n";
+        return;
+    }
+
+    if (ar < 0) {
+        cout << "RIGHT\n";
+        return;
+    }
+
+    cout << "TOUCH\n";
+}
+
+int main()
+{
+    ios::sync_with_stdio(false);
+    cin.tie(nullptr);
+
+    pre();
+
+    int t;
+    (TEST && cin >> t) || (t = 1);
+    while (t--) {
+        solve();
+    }
+}

CSES Problem Set/Polygon Area.cpp

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

CSES Problem Set/Polynomial Queries.cpp

@@ -0,0 +1,181 @@
+/* Problem URL: https://cses.fi/problemset/task/1736 */
+
+#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, q;
+    cin >> n >> q;
+
+    vl fds(n);
+    cin >> fds;
+
+    while (__builtin_popcount(n) != 1) {
+        n++;
+        fds.push_back(0);
+    }
+
+    vl seg(n * 2);
+    vl lazy(n * 2);
+    vl c(n * 2);
+    V<bool> upd(n * 2);
+
+    nrep(i, n, n * 2) {
+        seg[i] = fds[i - n];
+    }
+
+    for (int i = n - 1; i > 0; i--) {
+        seg[i] = seg[i * 2] + seg[i * 2 + 1];
+    }
+
+    auto propagate = [&](int i, int l, int r) {
+        if (!upd[i]) {
+            return;
+        }
+
+        upd[i] = false;
+
+        ll size = (r - l + 1);
+
+        seg[i] += (size * (r + l) / 2) * c[i] + c[i] * size - lazy[i] * size;
+
+        if (i < n) {
+            lazy[i * 2] += lazy[i];
+            lazy[i * 2 + 1] += lazy[i];
+            c[i * 2] += c[i];
+            c[i * 2 + 1] += c[i];
+            upd[i * 2] = true;
+            upd[i * 2 + 1] = true;
+        }
+
+        c[i] = 0;
+        lazy[i] = 0;
+    };
+
+    function<void(int, int, int, int, int, ll)>  update = [&](int i, int l, int r, int tl, int tr, ll v) {
+        propagate(i, l, r);
+
+        if (l > tr || r < tl) {
+            return;
+        }
+
+        if (l >= tl && r <= tr) {
+            lazy[i] += v;
+            upd[i] = true;
+            c[i]++;
+            propagate(i, l, r);
+            return;
+        }
+
+        int mid = (l + r) >> 1;
+
+        update(i * 2, l, mid, tl, tr, v);
+        update(i * 2 + 1, mid + 1, r, tl, tr, v);
+
+        seg[i] = seg[i * 2] + seg[i * 2 + 1];
+    };
+
+    function<ll(int, int, int, int, int)> query = [&](int i, int l, int r, int tl, int tr) {
+        propagate(i, l, r);
+
+        if (l > tr || r < tl) {
+            return 0LL;
+        }
+
+        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);
+    };
+
+    while (q--) {
+        int op, l, r;
+        cin >> op >> l >> r;
+
+        if (op == 1) {
+            update(1, 1, n, l, r, l);
+            continue;
+        }
+
+        cout << query(1, 1, n, l, r) << '\n';
+    }
+}

CSES Problem Set/Prefix Sum Queries.cpp

@@ -0,0 +1,211 @@
+/* Problem URL: https://cses.fi/problemset/task/2166 */
+
+#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, q;
+    cin >> n >> q;
+
+    vl fds(n);
+
+    cin >> fds;
+
+    ll oo = INT64_MAX >> 1;
+
+    while (__builtin_popcount(n) != 1) {
+        n++;
+        fds.push_back(0);
+    }
+
+    vl seg(n * 2);
+    vl pref(n * 2);
+    vl lazy(n * 2);
+
+    auto propagate = [&](int i, int l, int r) {
+        if (lazy[i] == 0) {
+            return;
+        }
+
+        if (i >= n) {
+            seg[i] += lazy[i];
+            lazy[i] = 0;
+            return; 
+        }
+
+        seg[i] += lazy[i];
+        lazy[i * 2] += lazy[i];
+        lazy[i * 2 + 1] += lazy[i];
+        lazy[i] = 0;
+    };
+
+    function<void(int, int, int, int, int, ll)> update = [&](int i, int l, int r, int tl, int tr, ll v) {
+        propagate(i, l, r);
+
+        if (l > tr || r < tl) {
+            return;
+        }
+
+        if (l >= tl && r <= tr) {
+            lazy[i] += v;
+            propagate(i, l, r);
+            return;
+        }
+
+        int mid = (l + r) >> 1;
+
+        update(i * 2, l, mid, tl, tr, v);
+        update(i * 2 + 1, mid + 1, r, tl, tr, v);
+
+        seg[i] = max(seg[i * 2], seg[i * 2 + 1]);
+    };
+
+    function<void(int, ll)> updatepref = [&](int i, ll v) {
+        i += n;
+        pref[i] = v;
+
+        for (i >>= 1; i > 0; i >>= 1) {
+            pref[i] = pref[i * 2] + pref[i * 2 + 1];
+        }
+    };
+
+    function<ll(int, int, int, int, int)> query = [&](int i, int l, int r, int tl, int tr) {
+        if (l > tr || r < tl) {
+            return -oo;
+        }
+
+        propagate(i, l, r);
+
+        if (l >= tl && r <= tr) {
+            return seg[i];
+        }
+
+        int mid = (l + r) >> 1;
+
+        return max(query(i * 2, l, mid, tl, tr), query(i * 2 + 1, mid + 1, r, tl, tr));
+    };
+
+    function<ll(int, int, int, int, int)> prefquery = [&](int i, int l, int r, int tl, int tr) {
+        if (l > tr || r < tl) {
+            return 0LL;
+        }
+
+        propagate(i, l, r);
+
+        if (l >= tl && r <= tr) {
+            return pref[i];
+        }
+
+        int mid = (l + r) >> 1;
+
+        return prefquery(i * 2, l, mid, tl, tr) + prefquery(i * 2 + 1, mid + 1, r, tl, tr);
+    };
+
+    rep(i, n) {
+        update(1, 0, n - 1, i, n - 1, fds[i]);
+        pref[i + n] = fds[i];
+    }
+
+    for (int i = n - 1; i > 0; i--) {
+        pref[i] = pref[i * 2] + pref[i * 2 + 1];
+    }
+
+    while (q--) {
+        int op;
+        cin >> op;
+        
+        if (op == 1) {
+            int k, u;
+            cin >> k >> u;
+            k--;
+
+            update(1, 0, n - 1, k, n - 1, u);
+            update(1, 0, n - 1, k, n - 1, -fds[k]);
+            updatepref(k, u);
+            fds[k] = u;
+            continue;
+        }
+
+        int a, b;
+        cin >> a >> b;
+        a--, b--;
+
+        cout << max(query(1, 0, n - 1, a, b) - prefquery(1, 0, n - 1, 0, a - 1), 0LL) << '\n';
+    }
+}

CSES Problem Set/Prime Multiples.cpp

@@ -0,0 +1,132 @@
+/* Problem URL: https://cses.fi/problemset/task/2185 */
+
+#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;
+    int k;
+    cin >> n >> k;
+
+    vl a(k);
+    cin >> a;
+
+    __int128 ans = 0;
+    nrep(i, 1, 1 << k) {
+        long double cur = n;
+        ll cur2 = 1;
+        rep(j, k) {
+            if ((i >> j) & 1) {
+                cur /= a[j];
+                cur2 *= a[j];
+            }
+        }
+
+        if (~__builtin_popcount(i) & 1) {
+            cur = -cur;
+            cur2 = -cur2;
+        }
+
+        ans += (ll)cur;
+    }
+
+    cout << (ll)ans << '\n';
+}
+
+int main()
+{
+    ios::sync_with_stdio(false);
+    cin.tie(nullptr);
+
+    pre();
+
+    int t;
+    (TEST && cin >> t) || (t = 1);
+    while (t--) {
+        solve();
+    }
+}

CSES Problem Set/Range Interval Queries.cpp

@@ -0,0 +1,121 @@
+/* Problem URL: https://cses.fi/problemset/task/3163 */
+ 
+#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;
+ 
+    vi fds(n);
+    map<int, int> var;
+    repv(i, fds) {
+        cin >> i;
+        var[i] = 0;
+    }
+
+    int v = 0;
+    repv(i, var) {
+        i.second = v;
+        v++;
+    }
+
+    vi bit1(var.size() + 1);
+    vi bit2(var.size() + 1);
+
+    auto add = [&](vi &bit, int i, int v) {
+        for (; i <= var.size(); i += i&(-i)) {
+            bit[i] += v;
+        }
+    };
+
+    auto get = [&](vi &bit, int i) {
+        int ans = 0;
+        for (; i > 0; i -= i&(-i)) {
+            ans += bit[i];
+        }
+
+        return ans;
+    };
+
+    rep(i, n) {
+        
+    }
+
+    while (q--) {
+        int l, r, a, b;
+        cin >> l >> r >> a >> b;
+
+
+    }
+}

CSES Problem Set/Range Updates and Sums.cpp

@@ -0,0 +1,244 @@
+/* Problem URL: https://cses.fi/problemset/task/1735 */
+
+#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;
+
+    vl fds(n);
+    cin >> fds;
+
+    while (__builtin_popcount(n) != 1) {
+        n++;
+        fds.push_back(0);
+    }
+
+    vl seg(n * 2);
+    vl lazyadd(n * 2);
+    vl lazyset(n * 2);
+    V<bool> updadd(n * 2);
+    V<bool> updset(n * 2);
+
+    nrep(i, n, n * 2) {
+        seg[i] = fds[i - n];
+    }
+
+    for (int i = n - 1; i > 0; i--) {
+        seg[i] = seg[i * 2] + seg[i * 2 + 1];
+    }
+
+    auto propagateset = [&](int i, int l, int r) {
+        if (!updset[i]) {
+            return;
+        }
+
+        updset[i] = false;
+
+        if (i >= n) {
+            seg[i] = lazyset[i];
+            return;
+        }
+
+        seg[i] = lazyset[i] * (r - l + 1);
+        lazyset[i * 2] = lazyset[i];
+        lazyset[i * 2 + 1] = lazyset[i];
+        updset[i * 2] = true;
+        updset[i * 2 + 1] = true;
+
+        lazyadd[i * 2] = 0;
+        lazyadd[i * 2 + 1] = 0;
+        updadd[i * 2] = false;
+        updadd[i * 2 + 1] = false;
+    };
+
+    auto propagateadd = [&](int i, int l, int r) {
+        if (!updadd[i]) {
+            return;
+        }
+
+        updadd[i] = false;
+
+        if (i >= n) {
+            seg[i] += lazyadd[i];
+            lazyadd[i] = 0;
+            return;
+        }
+
+        seg[i] += lazyadd[i] * (r - l + 1);
+        lazyadd[i * 2] += lazyadd[i];
+        lazyadd[i * 2 + 1] += lazyadd[i];
+        updadd[i * 2] = true;
+        updadd[i * 2 + 1] = true;
+        lazyadd[i] = 0;
+    };
+
+    auto propagate = [&](int i, int l, int r) {
+        propagateset(i, l, r);
+        propagateadd(i, l, r);
+    };
+
+    function<void(int, int, int, int, int, ll v)> updateset = [&](int i, int l, int r, int tl, int tr, ll v) {
+        propagate(i, l, r);
+
+        if (l > tr || r < tl) {
+            return;
+        }
+
+        if (l >= tl && r <= tr) {
+            lazyset[i] = v;
+            updset[i] = true;
+            updadd[i] = false;
+            lazyadd[i] = 0;
+            propagate(i, l, r);
+            return;
+        }
+
+        int mid = (l + r) >> 1;
+
+        updateset(i * 2, l, mid, tl, tr, v);
+        updateset(i * 2 + 1, mid + 1, r, tl, tr, v);
+
+        seg[i] = seg[i * 2] + seg[i * 2 + 1];
+    };
+
+    function<void(int, int, int, int, int, ll v)> updateadd = [&](int i, int l, int r, int tl, int tr, ll v) {
+        propagate(i, l, r);
+
+        if (l > tr || r < tl) {
+            return;
+        }
+
+        if (l >= tl && r <= tr) {
+            lazyadd[i] += v;
+            updadd[i] = true;
+            propagate(i, l, r);
+            return;
+        }
+
+        int mid = (l + r) >> 1;
+
+        updateadd(i * 2, l, mid, tl, tr, v);
+        updateadd(i * 2 + 1, mid + 1, r, tl, tr, v);
+
+        seg[i] = seg[i * 2] + seg[i * 2 + 1];
+    };
+
+    function<ll(int, int, int, int, int)> query = [&](int i, int l, int r, int tl, int tr) {
+        if (l > tr || r < tl) {
+            return 0LL;
+        }
+
+        propagate(i, l, r);
+
+        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);
+    };
+
+    while (m--) {
+        int op;
+        cin >> op;
+
+        if (op == 1) {
+            int l, r;
+            ll v;
+            cin >> l >> r >> v;
+            updateadd(1, 0, n - 1, l - 1, r - 1, v);
+            continue;
+        }
+
+        if (op == 2) {
+            int l, r;
+            ll v;
+            cin >> l >> r >> v;
+            updateset(1, 0, n - 1, l - 1, r - 1, v);
+            continue;
+        }
+
+        int l, r;
+        cin >> l >> r;
+        cout << query(1, 0, n - 1, l - 1, r - 1) << '\n';
+    }
+}

CSES Problem Set/SOS Bit Problem.cpp

@@ -0,0 +1,112 @@
+/* Problem URL: https://cses.fi/problemset/task/1654 */
+
+#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;
+
+    const int log = 20;
+    vl sos(1 << log);
+    vl inv(1 << log);
+
+    const int all = (1 << log) - 1;
+
+    repv(i, fds) {
+        sos[i]++;
+        inv[~i & all]++;
+    }
+
+    rep(i, log) {
+        rep(j, 1 << log) {
+            if ((j >> i) & 1) {
+                sos[j] += sos[j ^ (1 << i)];
+                inv[j] += inv[j ^ (1 << i)];
+            }
+        }
+    }
+
+    repv(i, fds) {
+        cout << sos[i] << ' ' << inv[~i & all] << ' ' << sos[all] - sos[~i & all] << '\n';
+    }
+}

CSES Problem Set/Subarray Sum Queries.cpp

@@ -0,0 +1,124 @@
+/* Problem URL: https://cses.fi/problemset/task/1190 */
+
+#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;
+}
+
+struct node {
+    ll ans;
+    ll sum;
+    ll pref;
+    ll suf;
+
+    node(ll ans, ll sum, ll pref, ll suf): ans(ans), sum(sum), pref(pref), suf(suf) {}
+    node() = default;
+};
+
+V<node> segtree;
+
+int main()
+{
+    ios::sync_with_stdio(false);
+    cin.tie(nullptr);
+
+    int n, m;
+    cin >> n >> m;
+    vl ar(n);
+    cin >> ar;
+
+    while (__builtin_popcount(n) != 1) {
+        ar.push_back(-1);
+        n++;
+    }
+
+    segtree.resize(n * 2);
+
+    for (size_t i = n; i < n * 2; i++) {
+        segtree[i] = node(max(ar[i - n], 0LL), ar[i - n], max(ar[i - n], 0LL), max(ar[i - n], 0LL));
+    }
+
+    for (size_t i = n - 1; i > 0; i--) {
+        segtree[i].ans = max(segtree[i * 2].suf + segtree[i * 2 + 1].pref, max(segtree[i * 2].ans, segtree[i * 2 + 1].ans));
+        segtree[i].sum = segtree[i * 2].sum + segtree[i * 2 + 1].sum;
+        segtree[i].pref = max(segtree[i * 2].pref, segtree[i * 2].sum + segtree[i * 2 + 1].pref);
+        segtree[i].suf = max(segtree[i * 2 + 1].suf, segtree[i * 2 + 1].sum + segtree[i * 2].suf);
+    }
+
+    while (m--) {
+        ll i, v;
+        cin >> i >> v;
+        segtree[n + i - 1] = node(max(v, 0LL), v, max(v, 0LL), max(v, 0LL));
+        for (size_t j = (n + i - 1) / 2; j > 0; j /= 2) {
+            segtree[j].ans = max(segtree[j * 2].suf + segtree[j * 2 + 1].pref, max(segtree[j * 2].ans, segtree[j * 2 + 1].ans));
+            segtree[j].sum = segtree[j * 2].sum + segtree[j * 2 + 1].sum;
+            segtree[j].pref = max(segtree[j * 2].pref, segtree[j * 2].sum + segtree[j * 2 + 1].pref);
+            segtree[j].suf = max(segtree[j * 2 + 1].suf, segtree[j * 2 + 1].sum + segtree[j * 2].suf);
+        }
+        cout << segtree[1].ans << '\n';
+    }
+}

CSES Problem Set/Visible Buildings Queries.cpp

@@ -0,0 +1,178 @@
+/* Problem URL: https://cses.fi/problemset/task/3304 */
+
+#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, q;
+    cin >> n >> q;
+
+    vl fds(n);
+    cin >> fds;
+
+    vvi sparse(20, vi(n));
+
+    rep(i, n) {
+        sparse[0][i] = fds[i];
+    }
+
+    nrep(j, 1, 20) {
+        for (int i = 0; i + (1 << (j - 1)) < n; i++) {
+            sparse[j][i] = max(sparse[j - 1][i], sparse[j - 1][i + (1 << (j - 1))]);
+        }
+    }
+
+    auto squery = [&](int i, int j) {
+        int log = 31 - __builtin_clz(j - i + 1);
+
+        return max(sparse[log][i], sparse[log][j - (1 << log) + 1]);
+    };
+
+    vi ans(n);
+
+    rep(i, n) {
+        int low = 0;
+        int high = i - 1;
+        int act = i;
+
+        while (low <= high) {
+            int mid = (low + high) >> 1;
+
+            if (squery(mid, i - 1) < fds[i]) {
+                act = mid;
+                high = mid - 1;
+                continue;
+            }
+
+            low = mid + 1;
+        }
+
+        ans[i] = act;
+    }
+
+
+    int oo = INT32_MAX >> 1;
+
+    while (__builtin_popcount(n) != 1) {
+        n++;
+        ans.push_back(oo);
+    }
+
+    vvi mergeseg(n * 2);
+
+    function<void(int, int, int)> build = [&](int i, int l, int r) {
+        if (l == r) {
+            mergeseg[i] = {ans[i - n]};
+            return;
+        }
+
+        int mid = (l + r) >> 1;
+
+        build(i * 2, l, mid);
+        build(i * 2 + 1, mid + 1, r);
+
+        merge(all(mergeseg[i * 2]), all(mergeseg[i * 2 + 1]), back_inserter(mergeseg[i]));
+    };
+
+    build(1, 0, n - 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 upper = upper_bound(all(mergeseg[i]), v);
+
+            return upper - mergeseg[i].begin();
+        }
+
+        int mid = (l + r) >> 1;
+
+        return query(i * 2, l, mid, tl, tr, v) + query(i * 2 + 1, mid + 1, r, tl, tr, v);
+    };
+
+    while (q--) {
+        int a, b;
+        cin >> a >> b;
+        a--, b--;
+
+        cout << query(1, 0, n - 1, a, b, a) << '\n';
+    }
+}