Sqrt tree

Trees/SQRT TREE

@@ -0,0 +1,153 @@
+SqrtTreeItem op(const SqrtTreeItem &a, const SqrtTreeItem &b);
+
+inline int log2Up(int n) {
+    int res = 0;
+    while ((1 << res) < n) {
+        res++;
+    }
+    return res;
+}
+
+class SqrtTree {
+private:
+    int n, lg, indexSz;
+    vector<SqrtTreeItem> v;
+    vector<int> clz, layers, onLayer;
+    vector< vector<SqrtTreeItem> > pref, suf, between;
+
+    inline void buildBlock(int layer, int l, int r) {
+        pref[layer][l] = v[l];
+        for (int i = l+1; i < r; i++) {
+            pref[layer][i] = op(pref[layer][i-1], v[i]);
+        }
+        suf[layer][r-1] = v[r-1];
+        for (int i = r-2; i >= l; i--) {
+            suf[layer][i] = op(v[i], suf[layer][i+1]);
+        }
+    }
+
+    inline void buildBetween(int layer, int lBound, int rBound, int betweenOffs) {
+        int bSzLog = (layers[layer]+1) >> 1;
+        int bCntLog = layers[layer] >> 1;
+        int bSz = 1 << bSzLog;
+        int bCnt = (rBound - lBound + bSz - 1) >> bSzLog;
+        for (int i = 0; i < bCnt; i++) {
+            SqrtTreeItem ans;
+            for (int j = i; j < bCnt; j++) {
+                SqrtTreeItem add = suf[layer][lBound + (j << bSzLog)];
+                ans = (i == j) ? add : op(ans, add);
+                between[layer-1][betweenOffs + lBound + (i << bCntLog) + j] = ans;
+            }
+        }
+    }
+
+    inline void buildBetweenZero() {
+        int bSzLog = (lg+1) >> 1;
+        for (int i = 0; i < indexSz; i++) {
+            v[n+i] = suf[0][i << bSzLog];
+        }
+        build(1, n, n + indexSz, (1 << lg) - n);
+    }
+
+    inline void updateBetweenZero(int bid) {
+        int bSzLog = (lg+1) >> 1;
+        v[n+bid] = suf[0][bid << bSzLog];
+        update(1, n, n + indexSz, (1 << lg) - n, n+bid);
+    }
+
+    void build(int layer, int lBound, int rBound, int betweenOffs) {
+        if (layer >= (int)layers.size()) {
+            return;
+        }
+        int bSz = 1 << ((layers[layer]+1) >> 1);
+        for (int l = lBound; l < rBound; l += bSz) {
+            int r = min(l + bSz, rBound);
+            buildBlock(layer, l, r);
+            build(layer+1, l, r, betweenOffs);
+        }
+        if (layer == 0) {
+            buildBetweenZero();
+        } else {
+            buildBetween(layer, lBound, rBound, betweenOffs);
+        }
+    }
+
+    void update(int layer, int lBound, int rBound, int betweenOffs, int x) {
+        if (layer >= (int)layers.size()) {
+            return;
+        }
+        int bSzLog = (layers[layer]+1) >> 1;
+        int bSz = 1 << bSzLog;
+        int blockIdx = (x - lBound) >> bSzLog;
+        int l = lBound + (blockIdx << bSzLog);
+        int r = min(l + bSz, rBound);
+        buildBlock(layer, l, r);
+        if (layer == 0) {
+            updateBetweenZero(blockIdx);
+        } else {
+            buildBetween(layer, lBound, rBound, betweenOffs);
+        }
+        update(layer+1, l, r, betweenOffs, x);
+    }
+
+    inline SqrtTreeItem query(int l, int r, int betweenOffs, int base) {
+        if (l == r) {
+            return v[l];
+        }
+        if (l + 1 == r) {
+            return op(v[l], v[r]);
+        }
+        int layer = onLayer[clz[(l - base) ^ (r - base)]];
+        int bSzLog = (layers[layer]+1) >> 1;
+        int bCntLog = layers[layer] >> 1;
+        int lBound = (((l - base) >> layers[layer]) << layers[layer]) + base;
+        int lBlock = ((l - lBound) >> bSzLog) + 1;
+        int rBlock = ((r - lBound) >> bSzLog) - 1;
+        SqrtTreeItem ans = suf[layer][l];
+        if (lBlock <= rBlock) {
+            SqrtTreeItem add = (layer == 0) ? (
+                query(n + lBlock, n + rBlock, (1 << lg) - n, n)
+            ) : (
+                between[layer-1][betweenOffs + lBound + (lBlock << bCntLog) + rBlock]
+            );
+            ans = op(ans, add);
+        }
+        ans = op(ans, pref[layer][r]);
+        return ans;
+    }
+public:
+    inline SqrtTreeItem query(int l, int r) {
+        return query(l, r, 0, 0);
+    }
+
+    inline void update(int x, const SqrtTreeItem &item) {
+        v[x] = item;
+        update(0, 0, n, 0, x);
+    }
+
+    SqrtTree(const vector<SqrtTreeItem>& a)
+        : n((int)a.size()), lg(log2Up(n)), v(a), clz(1 << lg), onLayer(lg+1) {
+        clz[0] = 0;
+        for (int i = 1; i < (int)clz.size(); i++) {
+            clz[i] = clz[i >> 1] + 1;
+        }
+        int tlg = lg;
+        while (tlg > 1) {
+            onLayer[tlg] = (int)layers.size();
+            layers.push_back(tlg);
+            tlg = (tlg+1) >> 1;
+        }
+        for (int i = lg-1; i >= 0; i--) {
+            onLayer[i] = max(onLayer[i], onLayer[i+1]);
+        }
+        int betweenLayers = max(0, (int)layers.size() - 1);
+        int bSzLog = (lg+1) >> 1;
+        int bSz = 1 << bSzLog;
+        indexSz = (n + bSz - 1) >> bSzLog;
+        v.resize(n + indexSz);
+        pref.assign(layers.size(), vector<SqrtTreeItem>(n + indexSz));
+        suf.assign(layers.size(), vector<SqrtTreeItem>(n + indexSz));
+        between.assign(betweenLayers, vector<SqrtTreeItem>((1 << lg) + bSz));
+        build(0, 0, n, 0);
+    }
+};

Trees/Suffix Tree

@@ -0,0 +1,87 @@
+string s;
+int n;
+
+struct node {
+    int l, r, par, link;
+    map<char,int> next;
+
+    node (int l=0, int r=0, int par=-1)
+        : l(l), r(r), par(par), link(-1) {}
+    int len()  {  return r - l;  }
+    int &get (char c) {
+        if (!next.count(c))  next[c] = -1;
+        return next[c];
+    }
+};
+node t[MAXN];
+int sz;
+
+struct state {
+    int v, pos;
+    state (int v, int pos) : v(v), pos(pos)  {}
+};
+state ptr (0, 0);
+
+state go (state st, int l, int r) {
+    while (l < r)
+        if (st.pos == t[st.v].len()) {
+            st = state (t[st.v].get( s[l] ), 0);
+            if (st.v == -1)  return st;
+        }
+        else {
+            if (s[ t[st.v].l + st.pos ] != s[l])
+                return state (-1, -1);
+            if (r-l < t[st.v].len() - st.pos)
+                return state (st.v, st.pos + r-l);
+            l += t[st.v].len() - st.pos;
+            st.pos = t[st.v].len();
+        }
+    return st;
+}
+
+int split (state st) {
+    if (st.pos == t[st.v].len())
+        return st.v;
+    if (st.pos == 0)
+        return t[st.v].par;
+    node v = t[st.v];
+    int id = sz++;
+    t[id] = node (v.l, v.l+st.pos, v.par);
+    t[v.par].get( s[v.l] ) = id;
+    t[id].get( s[v.l+st.pos] ) = st.v;
+    t[st.v].par = id;
+    t[st.v].l += st.pos;
+    return id;
+}
+
+int get_link (int v) {
+    if (t[v].link != -1)  return t[v].link;
+    if (t[v].par == -1)  return 0;
+    int to = get_link (t[v].par);
+    return t[v].link = split (go (state(to,t[to].len()), t[v].l + (t[v].par==0), t[v].r));
+}
+
+void tree_extend (int pos) {
+    for(;;) {
+        state nptr = go (ptr, pos, pos+1);
+        if (nptr.v != -1) {
+            ptr = nptr;
+            return;
+        }
+
+        int mid = split (ptr);
+        int leaf = sz++;
+        t[leaf] = node (pos, n, mid);
+        t[mid].get( s[pos] ) = leaf;
+
+        ptr.v = get_link (mid);
+        ptr.pos = t[ptr.v].len();
+        if (!mid)  break;
+    }
+}
+
+void build_tree() {
+    sz = 1;
+    for (int i=0; i<n; ++i)
+        tree_extend (i);
+}