Migrate code to this repo

Author: sohnryang

src/data_structures/fenwick_tree.cc

@@ -0,0 +1,32 @@
+/*
+ * Fenwick Tree
+ */
+
+#include <vector>
+
+using namespace std;
+
+class FenwickTree {
+private:
+    vector<int> tree;
+public:
+    FenwickTree(int n) : tree(n + 1) {}
+
+    int range_sum(int pos) {
+        ++pos;
+        int ret = 0;
+        while (pos > 0) {
+            ret += tree[pos];
+            pos &= (pos - 1);
+        }
+        return ret;
+    }
+
+    void update(int pos, int val) {
+        ++pos;
+        while (pos < tree.size()) {
+            tree[pos] += val;
+            pos += (pos & -pos);
+        }
+    }
+};

src/data_structures/rankless_union_find.cc

@@ -0,0 +1,33 @@
+/*
+ * "Rankless" Union-find disjoint set
+ */
+
+#include <vector>
+
+using namespace std;
+
+class RanklessUnionFind {
+private:
+    vector<int> p, rank, setSize;
+    int numSets;
+public:
+    RanklessUnionFind(int N) {
+        setSize.assign(N, 1);
+        numSets = N;
+        rank.assign(N, 0);
+        p.assign(N, 0);
+        for (int i = 0; i < N; i++) p[i] = i;
+    }
+    int findSet(int i) { return (p[i] == i) ? i : (p[i] = findSet(p[i])); }
+    bool isSameSet(int i, int j) { return findSet(i) == findSet(j); }
+    void unionSet(int i, int j) {
+        if (!isSameSet(i, j)) {
+            numSets--;
+            int x = findSet(i), y = findSet(j);
+            p[y] = x;
+            setSize[x] += setSize[y];
+        }
+    }
+    int numDisjointSets() { return numSets; }
+    int sizeOfSet(int i) { return setSize[findSet(i)]; }
+};

src/data_structures/rmq.cc

@@ -0,0 +1,56 @@
+/*
+ * Range Minimum Query
+ */
+
+#include <algorithm>
+#include <numeric>
+#include <vector>
+
+using namespace std;
+
+class RMQ {
+private:
+    vector<long long> tree;
+    int len;
+
+    long long init_tree(vector<long long>& arr, int lo, int hi, int node) {
+        if (lo == hi) return tree[node] = arr[lo];
+        int mid = (lo + hi) / 2;
+        long long left = init_tree(arr, lo, mid, node * 2);
+        long long right = init_tree(arr, mid + 1, hi, node * 2 + 1);
+        return tree[node] = min(left, right);
+    }
+
+    long long query(int lo, int hi, int node, int node_lo, int node_hi) {
+        if (hi < node_lo || node_hi < lo)
+            return numeric_limits<long long>::max();
+        if (lo <= node_lo && node_hi <= hi) return tree[node];
+        int mid = (node_lo + node_hi) / 2;
+        return min(query(lo, hi, node * 2, node_lo, mid),
+                   query(lo, hi, node * 2 + 1, mid + 1, node_hi));
+    }
+
+    long long update(int idx, int newval, int node, int node_lo, int node_hi) {
+        if (idx < node_lo || node_hi < idx) return tree[node];
+        if (node_lo == node_hi) return tree[node] = newval;
+        int mid = (node_lo + node_hi) / 2;
+        return tree[node] = min(
+            update(idx, newval, node * 2, node_lo, mid),
+            update(idx, newval, node * 2 + 1, mid + 1, node_hi)
+        );
+    }
+public:
+    long long query(int lo, int hi) {
+        return query(lo, hi, 1, 0, len - 1);
+    }
+
+    long long update(int idx, int newval) {
+        return update(idx, newval, 1, 0, len - 1);
+    }
+
+    RMQ(vector<long long>& arr) {
+        len = arr.size();
+        tree.resize(len * 4);
+        init_tree(arr, 0, len - 1, 1);
+    }
+};

src/data_structures/union_find.cc

@@ -0,0 +1,37 @@
+/*
+ * Union-find disjoint set
+ */
+
+typedef vector<int> vi;
+
+class UnionFind {
+private:
+    vi p, rank, setSize;
+    int numSets;
+public:
+    UnionFind(int N) {
+        setSize.assign(N, 1);
+        numSets = N;
+        rank.assign(N, 0);
+        p.assign(N, 0);
+        for (int i = 0; i < N; i++) p[i] = i;
+    }
+    int findSet(int i) { return (p[i] == i) ? i : (p[i] = findSet(p[i])); }
+    bool isSameSet(int i, int j) { return findSet(i) == findSet(j); }
+    void unionSet(int i, int j) {
+        if (!isSameSet(i, j)) {
+            numSets--;
+            int x = findSet(i), y = findSet(j);
+            if (rank[x] > rank[y]) {
+                p[y] = x;
+                setSize[x] += setSize[y];
+            } else {
+                p[x] = y;
+                setSize[y] += setSize[x];
+                if (rank[x] == rank[y]) rank[y]++;
+            }
+        }
+    }
+    int numDisjointSets() { return numSets; }
+    int sizeOfSet(int i) { return setSize[findSet(i)]; }
+};