HDU 4270 Dynamic Lover 后缀自动机

题目大意：

就是现在初始有一个字符串, 然后接下来有m (m <= 10W) 次操作, 每次操作可能是在现有字符串后面加上一段字符, 或者是删掉一段字符, 或者是询问当前字符串中长度为len的所有字串中字典序最小的, 还要讲长度不够的后缀也考虑在内, 并且在有多个相同的时候输出下标最小的

大致思路：

首先用后缀自动机的话对于添加操作和询问操作都很容易解决, 但是对于删除操作就不太好办了

对于删除操作需要对于SAM中的每个节点都添加一个del指针, 表示是否已经被删除, 然后由于每次添加新字符的时候最多只会添加2个节点, 将有同一次插入字符新生成的结点的del指针指向同一个bool的域, 那么删除操作的时候只需要修改这个域中对应的bool值同时删除了这些结点

注意这里的删除并不是真的将这个点从SAM中去掉了, 其实并没有, 只是将他们标记为删除了而已, SAM中点的个数没有减少, 并且删除操作之后要将last指针指向最后一个字符新建的np结点, , 也就是最后的right集合为{L}(L为当前长度)的那个结点

这样在每次询问的时候只要不沿着已经删除的点走就可以了, 细节见代码和代码注释吧

代码如下：

Result  :  Accepted     Memory  :  36124 KB     Time  :  608 ms

/*
* Author: Gatevin
* Created Time:  2015/4/27 11:24:39
* File Name: Rin_Tohsaka.cpp
*/
#include<iostream>
#include<sstream>
#include<fstream>
#include<vector>
#include<list>
#include<deque>
#include<queue>
#include<stack>
#include<map>
#include<set>
#include<bitset>
#include<algorithm>
#include<cstdio>
#include<cstdlib>
#include<cstring>
#include<cctype>
#include<cmath>
#include<ctime>
#include<iomanip>
using namespace std;
const double eps(1e-8);
typedef long long lint;
#define foreach(e, x) for(__typeof(x.begin()) e = x.begin(); e != x.end(); ++e)
#define SHOW_MEMORY(x) cout<<sizeof(x)/(1024*1024.)<<"MB"<<endl

#define maxn 400010
#define maxm 200010

bool Delete[maxm];
int D;//Delete域的个数
char s[maxm];//字符串
int L;//当前的有效字符串的长度
int pos[maxm];
//表示当前的串的第i个字符在sam中对应的结点np是nodePool[pos[i]], 由于np与nq共享一个Delete域记住这个就够了

int col;//给suf染色的颜色

struct Suffix_Automation
{
struct State
{
State *par;
State *go[26];
bool* del;//指示是否被删除
int right, mi, cnt, val, leftmost;
int suf;
void init(int _val = 0)
{
par = 0, val = _val, right = mi = cnt = 0, leftmost = 1e9, suf = 0;
memset(go, 0, sizeof(go));
}
int calc()
{
if(par == 0) return 0;
else return val - par->val;
}
};
State *last, *cur, *root;
State nodePool[maxn];
State* newState(int val = 0)
{
cur->init(val);
return cur++;
}
void init()
{
cur = nodePool;
root = newState();
root->del = &Delete[D++];
last = root;
}
void extend(int w, int l)
{
State *p = last;
State *np = newState(p->val + 1);
np->leftmost = l;
//事实上考虑到right集合的性质以及np状态中包含的最长串可知这一点, 求leftmost并不需要topo排序
pos[l] = cur - nodePool - 1;
np->del = &Delete[D++];
*(np->del) = false;
np->right = 1;
while(p && (p->go[w] == 0 || *(p->go[w]->del)))
{
p->go[w] = np;
p = p->par;
}
if(p == 0)
{
np->par = root;
}
else
{
State *q = p->go[w];
if(p->val + 1 == q->val)
{
np->par = q;
}
else
{
State *nq = newState(p->val + 1);
memcpy(nq->go, q->go, sizeof(q->go));
nq->del = q->del;
nq->par = q->par;
q->par = nq;
np->par = nq;
nq->leftmost = q->leftmost;//nq作为新建的结点介于q和q-par之间, 儿子只有q和np, right集合中的最小肯定是q中的最小
while(p && p->go[w] == q)//q肯定是没有被del的
{
p->go[w] = nq;
p = p->par;
}
}
}
last = np;
}
void Del(int len)
{
for(int i = L - len; i < L; i++) *(nodePool[pos[i]].del) = true;//这些点标记为删除
L -= len;//字符总长度减少
last = &nodePool[pos[L - 1]];//标记添加的最末尾字符对应的np位置
return;
}
void Die()//给right集合中包含最后的L的染色, 方便solve的递归求解
{
State *e = last;
while(e->par && e != root) e->suf = col, e = e->par;
return;
}
bool solve(State *now, int nowlen, int len)
{
if(nowlen == len)
{
printf("%d\n", now->leftmost - (len - 1) + 1);
return true;
}
if(now->suf == col)//是后缀点
{
printf("%d\n", L - nowlen + 1);
return true;
}
for(int i = 0; i < 26; i++)
if(now->go[i] && !*(now->go[i]->del))
if(solve(now->go[i], nowlen + 1, len)) return true;
return true;
}
};

Suffix_Automation sam;

int main()
{
while(scanf("%s", s) != EOF)
{
int n = strlen(s);
sam.init();
D = 0, L = 0, col = 0;
memset(Delete, 0, sizeof(Delete));
for(int i = 0; i < n; i++)
sam.extend(s[i] - 'a', L++);
int m, k;
scanf("%d", &m);
while(m--)
{
scanf("%d", &k);
switch(k)
{
case 1: scanf("%s", s);
n = strlen(s);
for(int i = 0; i < n; i++)
sam.extend(s[i] - 'a', L++);
break;
case 2: scanf("%d", &n), col++, sam.Die(), sam.solve(sam.root, 0, n);
break;
case 3: scanf("%d", &n), sam.Del(n);
break;
}
}
}
return 0;
}