format: change indentation

.clang-format

@@ -10,7 +10,7 @@ BraceWrapping:
   BeforeCatch: false
   BeforeElse: false
   IndentBraces: false
-IndentWidth: 2
+IndentWidth: 4
 ColumnLimit: 0
 AllowShortIfStatementsOnASingleLine: AllIfsAndElse
 AllowShortLoopsOnASingleLine: true

src/1-ds/erasable_pq.cpp

@@ -1,14 +1,14 @@
 #include "../common/common.hpp"
 template <class T, class O = less<T>>
 struct pq_set {
-  priority_queue<T, vector<T>, O> q, del;
-  const T &top() const { return q.top(); }
-  int size() const { return int(q.size() - del.size()); }
-  bool empty() const { return !size(); }
-  void insert(const T x) { q.push(x), flush(); }
-  void pop() { q.pop(), flush(); }
-  void erase(const T x) { del.push(x), flush(); }
-  void flush() {
-    while (del.size() && q.top() == del.top()) q.pop(), del.pop();
-  }
+    priority_queue<T, vector<T>, O> q, del;
+    const T &top() const { return q.top(); }
+    int size() const { return int(q.size() - del.size()); }
+    bool empty() const { return !size(); }
+    void insert(const T x) { q.push(x), flush(); }
+    void pop() { q.pop(), flush(); }
+    void erase(const T x) { del.push(x), flush(); }
+    void flush() {
+        while (del.size() && q.top() == del.top()) q.pop(), del.pop();
+    }
 };

src/1-ds/fenwick_tree.cpp

@@ -1,65 +1,65 @@
 #include "../common/common.hpp"
 // 1. Fenwick Tree
-struct Fenwick { // 0-indexed
-  int flag, cnt; // array size
-  vector<ll> arr, t;
-  void build(int n) {
-    for (flag = 1; flag < n; flag <<= 1, cnt++);
-    arr.resize(flag);
-    t.resize(flag);
-    for (int i = 0; i < n; i++) cin >> arr[i];
-    for (int i = 0; i < n; i++) {
-      t[i] += arr[i];
-      if (i | (i + 1) < flag) t[i | (i + 1)] += t[i];
+struct Fenwick {   // 0-indexed
+    int flag, cnt; // array size
+    vector<ll> arr, t;
+    void build(int n) {
+        for (flag = 1; flag < n; flag <<= 1, cnt++);
+        arr.resize(flag);
+        t.resize(flag);
+        for (int i = 0; i < n; i++) cin >> arr[i];
+        for (int i = 0; i < n; i++) {
+            t[i] += arr[i];
+            if (i | (i + 1) < flag) t[i | (i + 1)] += t[i];
+        }
     }
-  }
-  void add(int p, ll value) { // add value at position p
-    arr[p] += value;
-    while (p < flag) {
-      t[p] += value;
-      p |= p + 1;
+    void add(int p, ll value) { // add value at position p
+        arr[p] += value;
+        while (p < flag) {
+            t[p] += value;
+            p |= p + 1;
+        }
     }
-  }
-  void modify(int p, ll value) { // set value at position p
-    add(p, value - arr[p]);
-  }
-  ll query(int x) {
-    ll ret = 0;
-    while (x >= 0) ret += t[x], x = (x & (x + 1)) - 1;
-    return ret;
-  }
-  ll query(int l, int r) {
-    return query(r) - (l ? query(l - 1) : 0);
-  }
-  int kth(int k) { // find the kth smallest number (1-indexed)
-    assert(t.back() >= k);
-    int l = 0, r = arr.size();
-    for (int i = 0; i <= cnt; i++) {
-      int mid = (l + r) >> 1;
-      ll val = mid ? t[mid - 1] : t.back();
-      if (val >= k) r = mid;
-      else l = mid, k -= val;
+    void modify(int p, ll value) { // set value at position p
+        add(p, value - arr[p]);
+    }
+    ll query(int x) {
+        ll ret = 0;
+        while (x >= 0) ret += t[x], x = (x & (x + 1)) - 1;
+        return ret;
+    }
+    ll query(int l, int r) {
+        return query(r) - (l ? query(l - 1) : 0);
+    }
+    int kth(int k) { // find the kth smallest number (1-indexed)
+        assert(t.back() >= k);
+        int l = 0, r = arr.size();
+        for (int i = 0; i <= cnt; i++) {
+            int mid = (l + r) >> 1;
+            ll val = mid ? t[mid - 1] : t.back();
+            if (val >= k) r = mid;
+            else l = mid, k -= val;
+        }
+        return l;
     }
-    return l;
-  }
 };
 // 2. Fenwick Tree Range Update Point Query
 struct FenwickRUPQ { // 1-indexed
-  int flag;
-  vector<ll> t;
-  void build(int N) {
-    flag = N;
-    t.resize(flag + 1);
-  }
-  void modify(int l, int r, int val) { // add a val to all elements in interval [l, r]
-    for (; l <= flag; l += l & -l) t[l] += val;
-    for (r++; r <= flag; r += r & -r) t[r] -= val;
-  }
-  ll query(int x) {
-    ll ret = 0;
-    for (; x; x ^= x & -x) ret += t[x];
-    return ret;
-  }
+    int flag;
+    vector<ll> t;
+    void build(int N) {
+        flag = N;
+        t.resize(flag + 1);
+    }
+    void modify(int l, int r, int val) { // add a val to all elements in interval [l, r]
+        for (; l <= flag; l += l & -l) t[l] += val;
+        for (r++; r <= flag; r += r & -r) t[r] -= val;
+    }
+    ll query(int x) {
+        ll ret = 0;
+        for (; x; x ^= x & -x) ret += t[x];
+        return ret;
+    }
 };
 // 3. 2D Fenwick Tree
 // INPUT: Given an 2D array of integers of size N * M.
@@ -68,63 +68,63 @@ struct FenwickRUPQ { // 1-indexed
 // OUTPUT: Given the query (1 sx sy ex ey), output the sum of elements from the interval (sx, sy) to (ex, ey)
 // TIME COMPLEXITY: O(N * M) for initialize fenwick tree, O(logN * logM) for each query.
 struct Fenwick2D { // 0-indexed
-  int n, m, real_n, real_m;
-  vector<vector<ll>> arr, t;
-  void build(int N, int M) {
-    real_n = N, real_m = M;
+    int n, m, real_n, real_m;
+    vector<vector<ll>> arr, t;
+    void build(int N, int M) {
+        real_n = N, real_m = M;
 
-    n = m = 1;
-    while (n < N) n <<= 1;
-    while (m < M) m <<= 1;
-    arr.resize(n, vector<ll>(m));
-    t.resize(n, vector<ll>(m));
+        n = m = 1;
+        while (n < N) n <<= 1;
+        while (m < M) m <<= 1;
+        arr.resize(n, vector<ll>(m));
+        t.resize(n, vector<ll>(m));
 
-    for (int i = 0; i < real_n; i++) {
-      for (int j = 0; j < real_m; j++) {
-        cin >> arr[i][j];
-      }
-    }
-    for (int i = 0; i < n; i++) {
-      for (int j = 0; j < m; j++) {
-        t[i][j] += arr[i][j];
+        for (int i = 0; i < real_n; i++) {
+            for (int j = 0; j < real_m; j++) {
+                cin >> arr[i][j];
+            }
+        }
+        for (int i = 0; i < n; i++) {
+            for (int j = 0; j < m; j++) {
+                t[i][j] += arr[i][j];
 
-        int ni = i | (i + 1), nj = j | (j + 1);
-        if (ni < n) t[ni][j] += t[i][j];
-        if (nj < m) t[i][nj] += t[i][j];
-        if (ni < n && nj < m) t[ni][nj] -= t[i][j];
-      }
+                int ni = i | (i + 1), nj = j | (j + 1);
+                if (ni < n) t[ni][j] += t[i][j];
+                if (nj < m) t[i][nj] += t[i][j];
+                if (ni < n && nj < m) t[ni][nj] -= t[i][j];
+            }
+        }
+    }
+    void add(int x, int y, ll value) { // add value at position (x, y)
+        assert(0 <= x && x < real_n && 0 <= y && y < real_m);
+        arr[x][y] += value;
+        for (int i = x; i < n; i |= i + 1) {
+            for (int j = y; j < m; j |= j + 1) {
+                t[i][j] += value;
+            }
+        }
+    }
+    void modify(int x, int y, ll value) { // set value at position (x, y)
+        assert(0 <= x && x < real_n && 0 <= y && y < real_m);
+        add(x, y, value - arr[x][y]);
     }
-  }
-  void add(int x, int y, ll value) { // add value at position (x, y)
-    assert(0 <= x && x < real_n && 0 <= y && y < real_m);
-    arr[x][y] += value;
-    for (int i = x; i < n; i |= i + 1) {
-      for (int j = y; j < m; j |= j + 1) {
-        t[i][j] += value;
-      }
+    ll query(ll x, ll y) {
+        assert(0 <= x && x < real_n && 0 <= y && y < real_m);
+        ll ret = 0;
+        for (int i = x; i >= 0; i = (i & (i + 1)) - 1) {
+            for (int j = y; j >= 0; j = (j & (j + 1)) - 1) {
+                ret += t[i][j];
+            }
+        }
+        return ret;
     }
-  }
-  void modify(int x, int y, ll value) { // set value at position (x, y)
-    assert(0 <= x && x < real_n && 0 <= y && y < real_m);
-    add(x, y, value - arr[x][y]);
-  }
-  ll query(ll x, ll y) {
-    assert(0 <= x && x < real_n && 0 <= y && y < real_m);
-    ll ret = 0;
-    for (int i = x; i >= 0; i = (i & (i + 1)) - 1) {
-      for (int j = y; j >= 0; j = (j & (j + 1)) - 1) {
-        ret += t[i][j];
-      }
+    ll query(ll sx, ll sy, ll ex, ll ey) {
+        assert(0 <= sx && sx <= ex && ex < real_n);
+        assert(0 <= sy && sy <= ey && ey < real_m);
+        ll ret = query(ex, ey);
+        if (sx) ret -= query(sx - 1, ey);
+        if (sy) ret -= query(ex, sy - 1);
+        if (sx && sy) ret += query(sx - 1, sy - 1);
+        return ret;
     }
-    return ret;
-  }
-  ll query(ll sx, ll sy, ll ex, ll ey) {
-    assert(0 <= sx && sx <= ex && ex < real_n);
-    assert(0 <= sy && sy <= ey && ey < real_m);
-    ll ret = query(ex, ey);
-    if (sx) ret -= query(sx - 1, ey);
-    if (sy) ret -= query(ex, sy - 1);
-    if (sx && sy) ret += query(sx - 1, sy - 1);
-    return ret;
-  }
 };

src/1-ds/li_chao_tree.cpp

@@ -8,50 +8,50 @@
 using Line = pair<ll, ll>;
 constexpr Line e = {0, -1e18};
 struct LiChaoTree {
-  ll f(Line l, ll x) { return l.first * x + l.second; }
-  struct Node {
-    ll xl, xr;
-    int l, r;
-    Line line;
-  };
-  vector<Node> t;
-  void build(ll xlb, ll xub) {
-    t.push_back({xlb, xub, -1, -1, e});
-  }
-  void insert(Line newLine, int n = 0) {
-    ll xl = t[n].xl, xr = t[n].xr;
-    ll xmid = (xl + xr) >> 1;
+    ll f(Line l, ll x) { return l.first * x + l.second; }
+    struct Node {
+        ll xl, xr;
+        int l, r;
+        Line line;
+    };
+    vector<Node> t;
+    void build(ll xlb, ll xub) {
+        t.push_back({xlb, xub, -1, -1, e});
+    }
+    void insert(Line newLine, int n = 0) {
+        ll xl = t[n].xl, xr = t[n].xr;
+        ll xmid = (xl + xr) >> 1;
 
-    Line llow = t[n].line, lhigh = newLine;
-    if (f(llow, xl) >= f(lhigh, xl)) swap(llow, lhigh);
+        Line llow = t[n].line, lhigh = newLine;
+        if (f(llow, xl) >= f(lhigh, xl)) swap(llow, lhigh);
 
-    if (f(llow, xr) <= f(lhigh, xr)) {
-      t[n].line = lhigh;
-      return;
-    } else if (f(llow, xmid) < f(lhigh, xmid)) {
-      t[n].line = lhigh;
-      if (t[n].r == -1) {
-        t[n].r = sz(t);
-        t.push_back({xmid + 1, xr, -1, -1, e});
-      }
-      insert(llow, t[n].r);
-    } else if (f(llow, xmid) >= f(lhigh, xmid)) {
-      t[n].line = llow;
-      if (t[n].l == -1) {
-        t[n].l = sz(t);
-        t.push_back({xl, xmid, -1, -1, e});
-      }
-      insert(lhigh, t[n].l);
+        if (f(llow, xr) <= f(lhigh, xr)) {
+            t[n].line = lhigh;
+            return;
+        } else if (f(llow, xmid) < f(lhigh, xmid)) {
+            t[n].line = lhigh;
+            if (t[n].r == -1) {
+                t[n].r = sz(t);
+                t.push_back({xmid + 1, xr, -1, -1, e});
+            }
+            insert(llow, t[n].r);
+        } else if (f(llow, xmid) >= f(lhigh, xmid)) {
+            t[n].line = llow;
+            if (t[n].l == -1) {
+                t[n].l = sz(t);
+                t.push_back({xl, xmid, -1, -1, e});
+            }
+            insert(lhigh, t[n].l);
+        }
     }
-  }
-  ll query(ll x, int n = 0) {
-    if (n == -1) return e.second;
-    ll xl = t[n].xl, xr = t[n].xr;
-    ll xmid = (xl + xr) >> 1;
+    ll query(ll x, int n = 0) {
+        if (n == -1) return e.second;
+        ll xl = t[n].xl, xr = t[n].xr;
+        ll xmid = (xl + xr) >> 1;
 
-    ll ret = f(t[n].line, x);
-    if (x <= xmid) ret = max(ret, query(x, t[n].l));
-    else ret = max(ret, query(x, t[n].r));
-    return ret;
-  }
+        ll ret = f(t[n].line, x);
+        if (x <= xmid) ret = max(ret, query(x, t[n].l));
+        else ret = max(ret, query(x, t[n].r));
+        return ret;
+    }
 };