More problems

.gdb_history

@@ -1,37 +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
@@ -254,3 +220,37 @@ 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

.gitignore

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

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/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/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';
+    }
+}