https://www.hackerrank.com/challenges/how-many-substrings/problem
题解
似乎是被毒瘤澜澜放弃做T3的一道题（因为ASDFZ有很多人做过，当然，他换了一道更毒瘤的……）
仓鼠在最后一天的时候提了一嘴然后我发现依旧菜菜的不会……（因为太菜模拟天天被吊打）
仓鼠好神仙啊%%%（烤熟了味道怎么样啊）
这道题三个数据结构结合在一起使用，但是感觉却没有那么码农，就是直接把板子套一套（当然板子不熟另当别论），用namespace的话可以降低编码复杂度（给起名废留了一条活路）
我们考虑离线
也就是对于一个右端点r，维护左端点在\([1,r]\)的答案
我们直接建一个后缀树出来（是反串的后缀树……就是直接正着建后缀自动机，把父亲节点连起来就好了）
那么当右端点往后扩展一格的时候，我们只需要考虑一下增量就好了
如果对于一个起点v，\([v,r]\)这个串能被统计的仅当不存在一个\(p<=r\)，\([p - r + v,p]\)和\([v,r]\)相等
然后看了一眼我们画的后缀树……
如果我们能在另外一处找到某个位置p代表的节点，这个节点和r所代表的节点的lca到根的字符串长度，就是p能影响到r的范围
那么我们就考虑对r祖先的每个节点，维护一个在子树里除了r以外最大值
具体操作就是每次Access一下，这一条链的值就改变了
那么最后想一下，我们r要特殊处理的那些p，在r到根的路径上被分成一段一段的，那就是r到根上路过的所有偏爱链，我们Access的时候都会考虑到，把它们记录下来然后更新线段树就好
我们具体操作的时候可以让线段树里每个节点x代表从x开始的本质不同的字符串有多少
每次在前面减掉在后面出现过的串就好
查询的时候就查询一段区间和
你说我写的你看不懂，那你看看代码吧，如果还看不懂就画画后缀树就知道了
代码
//#define ivorysi
using namespace std;
typedef long long int64;
typedef double db;
template<class T>
void read(T &res) {
res = 0;T f = 1;char c = getchar();
while(c < '0' || c > '9') {
if(c == '-') f = -1;
c = getchar();
}
while(c >= '0' && c <= '9' ) {
res = res * 10 + c - '0';
c = getchar();
}
res *= f;
}
template<class T>
void out(T x) {
if(x < 0) {x = -x;putchar('-');}
if(x >= 10) {
out(x / 10);
}
putchar('0' + x % 10);
}
int N,Q,cnt,ver[MAXN];
pii MK[MAXN];
char s[MAXN];
int64 ans[MAXN];
struct qry_node {
int l,r,id;
friend bool operator < (qry_node &a,qry_node &b) {
return a.r < b.r;
};
}qry[MAXN];
namespace sam {
struct sam_node {
sam_node *nxt[26],*par;
int len,cnt,id;
}pool[MAXN * 2],*tail = pool,*root,*last,*que[MAXN * 2];
int c[MAXN];
void build_sam(int c,int l) {
sam_node *nowp = tail++,*p;
nowp->len = l;nowp->cnt = 1;
for(p = last ; p && !p->nxt[c] ; p = p->par) {
p->nxt[c] = nowp;
}
if(!p) nowp->par = root;
else {
sam_node *q = p->nxt[c];
if(q->len == p->len + 1) nowp->par = q;
else {
sam_node *copyq = tail++;
*copyq = *q;
copyq->cnt = 0;copyq->len = p->len + 1;
q->par = nowp->par = copyq;
for( ; p && p->nxt[c] == q; p = p->par) {
p->nxt[c] = copyq;
}
}
}
last = nowp;
}
}
namespace seg_tr {
struct seg_tr_node {
int l,r;
int64 lz,sum;
}tr[MAXN * 4];
void build(int u,int l,int r) {
tr[u].l = l;tr[u].r = r;
tr[u].lz = tr[u].sum = 0;
if(l == r) return;
int mid = (l + r) >> 1;
build(u << 1,l,mid);
build(u << 1 | 1,mid + 1,r);
}
void add_lazy(int u,int64 v) {
tr[u].lz += v;tr[u].sum += v * (tr[u].r - tr[u].l + 1);
}
void push_down(int u) {
if(tr[u].lz) {
add_lazy(u << 1,tr[u].lz);
add_lazy(u << 1 | 1,tr[u].lz);
tr[u].lz = 0;
}
}
void update(int u) {
tr[u].sum = tr[u << 1].sum + tr[u << 1 | 1].sum;
}
void add(int u,int l,int r,int64 v) {
if(tr[u].l == l && tr[u].r == r) {
add_lazy(u,v);return;
}
int mid = (tr[u].l + tr[u].r) >> 1;
push_down(u);
if(r <= mid) add(u << 1,l,r,v);
else if(l > mid) add(u << 1 | 1,l,r,v);
else {add(u << 1,l,mid,v);add(u << 1 | 1,mid + 1,r,v);}
update(u);
}
int64 query(int u,int l,int r) {
if(tr[u].l == l && tr[u].r == r) return tr[u].sum;
push_down(u);
int mid = (tr[u].l + tr[u].r) >> 1;
if(r <= mid) return query(u << 1,l,r);
else if(l > mid) return query(u << 1 | 1,l,r);
else return query(u << 1,l,mid) + query(u << 1 | 1,mid + 1,r);
}
}
namespace lct {
struct node {
node *lc,*rc,*fa;
int pos,cov,len;
void cover(int v) {
cov = v;
pos = v;
}
void push_down() {
if(cov) {
if(lc) lc->cover(cov);
if(rc) rc->cover(cov);
cov = 0;
}
}
void update() {
if(lc) pos = max(lc->pos,pos);
if(rc) pos = max(rc->pos,pos);
}
}*tr[MAXN * 2],*que[MAXN * 2];
void init() {
for(int i = 0 ; i <= 2 * N ; ++i) {
tr[i] = new node;
tr[i]->lc = tr[i]->rc = tr[i]->fa = NULL;
tr[i]->pos = tr[i]->cov = 0;
}
}
bool isRoot(node *u) {
if(!u->fa) return true;
else return u->fa->lc != u && u->fa->rc != u;
}
bool which(node *u) {
return u->fa->rc == u;
}
void rotate(node *u) {
node *v = u->fa,*w = v->fa;
if(!isRoot(v) && w) {(v == w->lc ? w->lc : w->rc) = u;}
node *b = u == v->lc ? u->rc : u->lc;
u->fa = w;v->fa = u;
if(b) b->fa = v;
if(u == v->lc) {u->rc = v;v->lc = b;}
else {u->lc = v;v->rc = b;}
v->update();
}
void Splay(node *u) {
int tot = 0;
node *x;
for(x = u ; !isRoot(x) ; x = x->fa) {
que[++tot] = u;
}
que[++tot] = x;
for(int i = tot ; i >= 1 ; --i) {
que[i]->push_down();
}
while(!isRoot(u)) {
if(!isRoot(u->fa)) {
if(which(u->fa) == which(u)) rotate(u->fa);
else rotate(u);
}
rotate(u);
}
u->update();
}
void Access(node *u,int v) {
cnt = 0;
u->cover(v);
for(node *x = NULL ; u ; x = u ,u = u->fa) {
Splay(u);
MK[++cnt] = mp(u->len,u->pos);
u->rc = x;
u->update();
}
}
};
void Init() {
read(N);read(Q);
scanf("%s",s + 1);
lct::init();
seg_tr::build(1,1,N);
sam::root = sam::last = sam::tail++;
for(int i = 1 ; i <= N ; ++i) {
sam::build_sam(s[i] - 'a',i);
}
int m = sam::tail - sam::pool;
for(int i = 0 ; i < m ; ++i) {
sam::c[sam::pool[i].len]++;
}
for(int i = 1 ; i <= N ; ++i) {
sam::c[i] += sam::c[i - 1];
}
for(int i = 0 ; i < m ; ++i) {
sam::que[sam::c[sam::pool[i].len]--] = &sam::pool[i];
}
for(int i = 1 ; i <= m ; ++i) {
sam::que[i]->id = i;
if(sam::que[i]->cnt) ver[sam::que[i]->len] = i;
}
for(int i = 1 ; i <= m ; ++i) {
lct::tr[i]->len = sam::que[i]->len;
if(sam::que[i]->par) {
lct::tr[i]->fa = lct::tr[sam::que[i]->par->id];
}
}
int l,r;
for(int i = 1 ; i <= Q ; ++i) {
read(l);read(r);++l;++r;
qry[i] = (qry_node){l,r,i};
}
sort(qry + 1,qry + Q + 1);
}
void Solve() {
int p = 1;
for(int i = 1 ; i <= N ; ++i) {
seg_tr::add(1,1,i,1);
lct::Access(lct::tr[ver[i]],i);
int last = 0;
for(int j = cnt ; j > 1 ; --j) {
if(MK[j].fi == 0) continue;
if(MK[j].se != 0) {
seg_tr::add(1,MK[j].se - MK[j].fi + 1,MK[j].se - last,-1);
}
last = MK[j].fi;
}
while(p <= Q && qry[p].r == i) {
ans[qry[p].id] = seg_tr::query(1,qry[p].l,qry[p].r);
++p;
}
}
for(int i = 1 ; i <= Q ; ++i) {
out(ans[i]);enter;
}
}
int main() {
freopen("f1.in","r",stdin);
Init();
Solve();
return 0;
}
本文章为转载内容，我们尊重原作者对文章享有的著作权。如有内容错误或侵权问题，欢迎原作者联系我们进行内容更正或删除文章。
