ihhh题解

10分做法：

由于空间卡得紧，所以给了10分暴力分0.0
所以大家很容易就知道暴力就是线段树套ac自动机辣
时间：$O((sum |qSi| + sum |nSi|)*log Q)$
空间：$O((sum |nSi|)*log n)$

40-50分做法：

发现我们可以用莫队做，可是有删除操作不好搞。
发现其实删除操作就是在trie上把一个串的trie节点的size统统删去1，然后用跑的时候这个不更新size=0的终止节点就行辣，由于fail的性质，可以证明这样做是正确的。于是维护size我们用lct。
虽然理论复杂度和满分做法一样，可是区间修改的splay十分蛋疼，你懂的。
我比较良心因此数据给了一些分给此做法～因此期望分就是40~50分辣。
时间：$O(N^{1.5}log(max{|nSi|})+Qlog(max{|qSi|}))$ 
空间：$O(sum |nSi| + sum |qSi|)$

满分做法：

其实发现我们可以在终止节点打个标记= =所以lct从维护trie变成维护fail树，然后就能通过全部数据辣...
时间：$O(N^{1.5}log(max{|nSi|})+Qlog(max{|qSi|}))$
空间：$O(sum |nSi| + sum |qSi|)$
维护树还能用树链剖分+线段树，这种做法虽然在修改上多了一个log，但是由于常熟十分小，期望分数还是100分的，只要你没写残...
时间：$O(N^{1.5}log(max{|nSi|})+Qlog^2(max{|qSi|}))$
空间：$O(sum |nSi| log(sum |nSi|) + sum |qSi|)$
妈呀你们做题才发现这题能被分块水掉............
完了完了我的人生啊.............

完了完了saffah大爷说了一种秒标程的做法：

同样是建线段树，然后我们查询一个区间的时候先标记，总共会标记$O(QlogN)$个节点，然后我们对每个标记的节点再建ac自动机，查询完一个就rebuild自动机....这样空间就不会爆了......orz
这样每个串最多被build到$O(log(N))$个自动机内，因此查询复杂度为$O(log(N) sum |nSi|)$

乱搞？

1、暴力修改终止节点：然而fail树高度最坏$O(max{S})$。（咦好像数据并没有出全a的数据，没水过的估计被卡常了？） 、、
2、分块大发：似乎这是正解...然而还是被卡常了.....

PS：

复杂度和最长串长度有关？然而好像我造的随机数据并没有太长QAQ

满分第一种做法（ac自动机+莫队+lct）：

#include <bits/stdc++.h>
using namespace std;
const int N=1e5+10, nQ=1e5+10, nSz=26, S=5*1e5+10;
struct node *null, *root;
struct node {
	node *c[2], *f, *ch[nSz], *fail;
	int n, mx, tag;
	void init() { c[0]=c[1]=f=null; fail=root; for(int i=0; i<nSz; ++i) ch[i]=root; mx=n=tag=0; }
	bool d() { return f->c[1]==this; }
	bool isson() { return f->c[0]==this || f->c[1]==this; }
	void setc(node *x, bool d) { c[d]=x; x->f=this; }
	void up() { mx=max(c[0]->mx, c[1]->mx); if(tag) mx=max(mx, n); }
}Po[S], *iT=Po, *pos[N], *s[S];
node *newnode() { iT->init(); return iT++; }
void rot(node *x) {
	node *f=x->f; bool d=x->d();
	if(f->isson()) f->f->setc(x, f->d());
	else x->f=f->f;
	f->setc(x->c[!d], d);
	x->setc(f, !d);
	f->up();
}
void splay(node *x) {
	while(x->isson())
		if(!x->f->isson()) rot(x);
		else x->d()==x->f->d()?(rot(x->f), rot(x)):(rot(x), rot(x));
	x->up();
}
node *access(node *x) { node *y=null; for(; x!=null; y=x, x=x->f) splay(x), x->c[1]=y; return y; }
void add(char *s, int id) {
	int n=strlen(s); node *now=root;
	for(int i=0; i<n; ++i) {
		int x=s[i]-'a';
		if(now->ch[x]==root) now->ch[x]=newnode();
		now=now->ch[x];
	}
	now->n=n; pos[id]=now;
}
void bfs() {
	int fr=0, ta=0;
	s[ta++]=root; node *x;
	while(fr!=ta) {
		x=s[fr++];
		for(int i=0; i<nSz; ++i)
			if(x->ch[i]!=root) {
				s[ta++]=x->ch[i];
				if(x==root) continue;
				x->ch[i]->fail=x->fail->ch[i];
				x->ch[i]->f=x->ch[i]->fail;
			}
			else x->ch[i]=x->fail->ch[i];
	}
}
int getans(char *s, int n) {
	int ans=0; node *now=root;
	for(int i=0; i<n; ++i) {
		int x=s[i]-'a';
		now=now->ch[x];
		access(now); splay(now); ans=max(ans, now->mx);
	}
	return ans;
}
void update(int x, int f) { splay(pos[x]); pos[x]->tag+=f; pos[x]->up(); }
int blc[nQ], n, Q, nowid=0;
char a[S];
struct qq { int l, r, id, n, pos; }q[nQ];
bool cmp1(const qq &a, const qq &b) { return blc[a.l]==blc[b.l]?a.r<b.r:a.l<b.l; }
bool cmp2(const qq &a, const qq &b) { return a.id<b.id; }
void init() {
	null=iT++; root=iT++; null->init(); root->init();
	for(int i=0, sq=sqrt(n+0.5); i<n; ++i) blc[i]=i/sq;
}
int main() {
	scanf("%d%d", &n, &Q);
	init();
	for(int i=0; i<n; ++i) { scanf("%s", a); add(a, i); }
	for(int i=0; i<Q; ++i) { int l, r; scanf("%d%d%s", &l, &r, a+nowid); --l; --r; q[i]=(qq){l, r, i, (int)strlen(a+nowid), nowid}; nowid+=q[i].n; }
	bfs();
	sort(q, q+Q, cmp1);
	int l=0, r=-1;
	for(int i=0; i<Q; ++i) {
		int nl=q[i].l, nr=q[i].r;
		while(nl<l) update(--l, 1);
		while(nl>l) update(l++, -1);
		while(nr<r) update(r--, -1);
		while(nr>r) update(++r, 1);
		blc[q[i].id]=getans(a+q[i].pos, q[i].n);
	}
	for(int i=0; i<Q; ++i) printf("%d
", blc[i]);
	return 0;
}

　　

满分第二种做法（ac自动机+莫队+树剖+线段树）：

#include <cstdio>
#include <cmath>
#include <cstring>
#include <algorithm>

using namespace std;

struct edge {
    int t;
    edge *next;
};
struct qry {
    char* str;
    int len, l, r, bl, i;
};
struct seg {
    int l, r, s, c, v;
    seg *ls, *rs;
};
inline bool cmpQry(const qry& a, const qry& b) {
    if (a. bl == b. bl)
        return a. r > b. r;
    else
        return a. bl < b. bl;
}

const int maxn = 100009;
const int maxlen = 500009;

int n, m, bsz, ans[maxn];
int tr[maxlen][27], fl[maxlen], ep[maxn], tn, dep[maxlen];
int d[maxlen], sz[maxlen], tc, fc[maxlen], ch[maxlen], cl[maxlen];
char g[maxlen], cbuf_arr[maxlen], *cbuf(cbuf_arr);
qry q[maxn];
edge ebuf_arr[maxlen << 1], *ebuf(ebuf_arr), *head[maxlen];
seg sbuf_arr[maxn << 2], *sbuf(sbuf_arr), *rt[maxlen];

int trieIns(char* a) {
    int p(1);
    for (; *a; ++ a) {
        int d(*a - 97);
        if (!tr[p][d])
            dep[tr[p][d] = ++ tn] = dep[p] + 1;
        p = tr[p][d];
    }
    return p;
}
inline void addEdge(int u, int v) {
    ebuf-> t = v;
    ebuf-> next = head[u];
    head[u] = ebuf ++;
}

#define cpos(_p_) (d[_p_]-d[ch[fc[_p_]]])
#define midp(_p_) ((_p_->l+_p_->r)>>1)
inline seg* sgtBuild(int l, int r) {
    seg* p(sbuf ++);
    p-> l = l, p-> r = r;
    p-> s = 0, p-> c = 0;
    if (l + 1 < r) {
        p-> ls = sgtBuild(l, midp(p));
        p-> rs = sgtBuild(midp(p), r);
    }
    return p;
}
inline void sgtChg(seg* p, int po, int v) {
    if (p-> l + 1 == p-> r) {
        p-> c += v;
        if (p-> c)
            p-> s = p-> v;
        else
            p-> s = 0;
    }
    else {
        if (po < midp(p))
            sgtChg(p-> ls, po, v);
        else
            sgtChg(p-> rs, po, v);
        p-> s = max(p-> ls-> s, p-> rs-> s);
    }
}
inline void sgtSet(seg* p, int po, int vo) {
    if (p-> l + 1 == p-> r)
        p-> v = vo;
    else if (po < midp(p))
        sgtSet(p-> ls, po, vo);
    else
        sgtSet(p-> rs, po, vo);
}
inline int sgtQry(seg* p, int po) {
    if (p-> r == po)
        return p-> s;
    else if (po <= midp(p))
        return sgtQry(p-> ls, po);
    else
        return max(p-> ls-> s, sgtQry(p-> rs, po));
}

void acaBuild() {
    static int q[maxlen];
    int hd(0), tl(1);
    fl[q[0] = 1] = 0;
    d[1] = 1;
    while (hd < tl) {
        int u(q[hd ++]), v;
        for (int i = 0; i < 26; ++ i)
            if ((v = tr[u][i])) {
                int w;
                for (w = fl[u]; w && !tr[w][i]; w = fl[w]);
                if (!w)
                    fl[v] = 1;
                else
                    fl[v] = tr[w][i];
                d[v] = d[fl[v]] + 1;
                addEdge(fl[v], v);
                q[tl ++] = v;
            }
    }
    tc = 0;
    for (int i = tl - 1; i >= 0; -- i) {
        int p(q[i]), z(-1);
        sz[p] = 1;
        for (edge* e = head[p]; e; e = e-> next) {
            sz[p] += sz[e-> t];
            if (z == -1 || sz[e-> t] > sz[z])
                z = e-> t;
        }
        if (z == -1)
            cl[fc[p] = ++ tc] = 1;
        else
            ++ cl[fc[p] = fc[z]];
        ch[fc[p]] = p;
    }
    for (int i = 1; i <= tc; ++ i)
        rt[i] = sgtBuild(0, cl[i]);
    for (int i = 1; i <= tn; ++ i)
        sgtSet(rt[fc[i]], cpos(i), dep[i]);
}

int getTrans(int p, int w) {
    for (; p && !tr[p][w]; p = fl[p]);
    if (p)
        return tr[p][w];
    else
        return 1;
}
void cptMo() {
    sort(q, q + m, cmpQry);
    int l(1), r(1);
    sgtChg(rt[fc[ep[1]]], cpos(ep[1]), 1);
    for (int i = 0; i < m; ++ i) {
        while (r < q[i]. r) {
            ++ r;
            sgtChg(rt[fc[ep[r]]], cpos(ep[r]), 1);
        }
        while (l > q[i]. l) {
            -- l;
            sgtChg(rt[fc[ep[l]]], cpos(ep[l]), 1);
        }
        while (r > q[i]. r) {
            sgtChg(rt[fc[ep[r]]], cpos(ep[r]), -1);
            -- r;
        }
        while (l < q[i]. l) {
            sgtChg(rt[fc[ep[l]]], cpos(ep[l]), -1);
            ++ l;
        }
        int g(0);
        for (int p = 1, j = 0; j < q[i]. len; ++ j) {
            p = getTrans(p, q[i]. str[j] - 97);
            for (int u = p; u; u = fl[ch[fc[u]]])
                g = max(g, sgtQry(rt[fc[u]], cpos(u) + 1));
        }
        ans[q[i]. i] = g;
    }
}

int main() {
    scanf("%d%d", &n, &m);
    bsz = (int)pow(n, 0.5) + 1;
    dep[tn = 1] = 0;
    for (int i = 1; i <= n; ++ i) {
        scanf("%s", g);
        ep[i] = trieIns(g);
    }
    acaBuild();
    for (int i = 0; i < m; ++ i) {
        scanf("%d%d%s", &q[i]. l, &q[i]. r, cbuf);
        q[i]. len = strlen(q[i]. str = cbuf);
        cbuf += q[i]. len;
        q[i]. bl = q[i]. l / bsz;
        q[i]. i = i;
    }
    cptMo();
    for (int i = 0; i < m; ++ i)
        printf("%d
", ans[i]);
}

　　

满分第三种做法（还没写...）：