Codeforces Round #349 (Div. 1) C E （计数. SAM+线段树）

 C Codeword

题意：有多个询问，问长度为n包含当前串s为子序列的字符串有多少种

ans = ΣC(i-1, len-1) * 25^(i-len) * 26 ^ (n-i)

离线随便搞搞

#include <iostream>
#include <string>
#include <cstring>
#include <cstdio>
#include <algorithm>
#include <cmath>
#include <vector>
#include <map>
#include <bitset>
#include <queue>
#pragma comment(linker, "/STACK:102400000,102400000")
using namespace std;

#define LL long long
#define ULL unsigned long long
#define eps 1e-9
#define N (200000 + 10)
#define M (400000 + 10)
#define pii pair<int,int>
#define MP make_pair
#define inf 0x3f3f3f3f
#define lson ll, md, ls
#define rson md + 1, rr, rs
#define mod 1000000007


int f[N], nf[N];
int p1[N], p2[N];
int qpow(int x, int y) {
	int ret = 1;
	while(y) {
		if(y & 1) ret = (LL) ret * x % mod;
		x = (LL)x * x % mod;
		y >>= 1;
	}
	return ret;
}

void init() {
	f[0] = 1, nf[0] = 1;
	for(int i = 1; i < N; ++i)
		f[i] = (LL) f[i-1] * i % mod;
	nf[N-1] = qpow(f[N-1], mod-2);
	for(int i = N-2; i > 0; --i) 
		nf[i] = (LL) nf[i+1] * (i+1) % mod;

	p1[0] = p2[0] = 1;
	for(int i = 1; i < N; ++i)
		p1[i] = (LL) p1[i-1] * 25 %mod,
		p2[i] = (LL) p2[i-1] * 26 % mod;

}

int C(int n, int m) {
	if(n < m) return 0;
	return (LL) f[n] * nf[n-m] % mod * nf[m]% mod;
}
int len;
int get(int i) {
	return (LL) C(i-1, len-1) * p1[i-len] % mod;
}
char s[N];
struct node {
	int op, val, l, id;
	int ret;
	bool operator < (const node &ot) const{
		return l < ot.l || (l == ot.l && val < ot.val);
	}
}a[N];

int last;
LL ans;

void cal(int &n) {
	ans = (26 * ans % mod + (LL)get(n+1) % mod) % mod;
	++n;
}
bool cmp(node a, node b) {
	return a.id < b.id;
}

void RE() {
	vector<int> vt;
	vt[0] = -1;
}

int main() {
	//freopen("in.txt", "r", stdin);
	int m;
	init();
	scanf("%d", &m);
	scanf("%s", s);
	len = strlen(s);
	for(int i = 0; i < m; ++i) {
		scanf("%d", &a[i].op);
		a[i].id = i;
		if(a[i].op == 1) {
			scanf("%s", s);
			len = strlen(s);
		}
		else {
			scanf("%d", &a[i].val);
		}
		a[i].l = len;
	}
	sort(a, a + m);
	ans = 0; 
	for(int i = 0; i < m; ++i) {
		if(a[i].op == 0) continue;
		if(i == 0 || a[i].l != a[i-1].l) ans = 0, last = 0, len = a[i].l;
		
		while(last < a[i].val) cal(last);
		a[i].ret = ans;
	}
	sort(a, a + m, cmp);
	for(int i = 0; i < m; ++i)
		if(a[i].op == 2) printf("%d\n", a[i].ret);
}

E Forensic Examination

题意：给一个大串s和m个小串，每次询问大串的子串s[sl,sr]在[l,r]之间这些小串中出现次数最多的是哪个小串

对所有小串做一次sam，对s的每个后缀先记录对应节点及往前能匹配多长，然后倍增找到s[sl,sr]对应的结点u。

考虑计算s在t中出现了多少次只需要在s所在结点的parent tree子树中计算包含了几个t的前缀

于是需要在u的子树中统计包含了多少个每个小串的前缀，每个结点建一颗线段树保存，由于sam每个结点最多包含一个小串的一个前缀，可以从parent tree叶子节点往上，先把当前结点表示的前缀加入，然后向上做线段树合并。

对于询问就在线段树中查询l到r最大值即可。

#include <iostream>
#include <string>
#include <cstring>
#include <cstdio>
#include <algorithm>
#include <cmath>
#include <vector>
#include <map>
#include <bitset>
#include <queue>
#pragma comment(linker, "/STACK:102400000,102400000")
using namespace std;

#define LL long long
#define ULL unsigned long long
#define eps 1e-9
#define N (2000000 + 10)
#define M (8000000 + 10)
#define pii pair<int,int>
#define MP make_pair
#define inf 0x3f3f3f3f
#define lson ll, md, ls
#define rson md + 1, rr, rs
#define mod 1000000007

int n,m;
struct Query{
	int l, r, id;
	Query() {}
	Query(int l, int r, int id) :l(l), r(r), id(id) {}
};

struct state {
	int val, id;
	state *son[27], *par[30];
	vector<Query> Que;
	int rt;
}que[N], *root, *last;
int tot;

void extend(int w, int id) {
	state *p = last;
	state *np = &que[tot++];
	np->val = p->val + 1;
	while(p && p->son[w] == 0) {
		p->son[w] = np, p = p->par[0];
	}
	if(p == 0) {
		np->par[0] = root;
	}
	else {
		state *q = p->son[w];
		if(q->val == p->val + 1) 
			np->par[0] = q;
		else {
			state *nq = &que[tot++];
			memcpy(nq->son, q->son, sizeof q->son);
			nq->par[0] = q->par[0];
			nq->val = p->val + 1;
			np->par[0] = q->par[0] = nq;
			while(p && p->son[w] == q) {
				p->son[w] = nq, p = p->par[0];
			}
		}
	}
	np->id = id;
	last = np;
}
char s[N], t[N];
state * match[N]; int mlen[N];
pii ans[N];
int rk[N], cnt[N];


void par_init() {
	for(int j = 1; j <= 20; ++j) 
		for(int i = 0; i < tot; ++i)
			if(que[i].par[j-1])
				que[i].par[j] = que[i].par[j-1]->par[j-1];
}

void s_init() {
	state *cur = root;
	int tl = 0;
	for(int i = 0; i < n; ++i) {
		int c = s[i]-'a'+1;
		while(cur && cur->son[c] == NULL) {
			cur = cur->par[0];
			if(cur)
				tl = cur->val;
			else tl = 0;
		}
		if(cur && cur->son[c]) {
			
			mlen[i] = ++tl;
			cur = cur->son[c];
			match[i] = cur;
		}
		else match[i] = NULL, cur = root;
	}
}

state * find(state *st, int len) {
	state *cur = st;
	for(int i = 20; i >= 0; --i) {
		if(cur->par[i] && cur->par[i]->val >= len) 
			cur = cur->par[i];
	}
	return cur;
}
int tcnt;
int mx[M], ls[M], rs[M], who[N];

void up(int i) {
	if(mx[ls[i]] > mx[rs[i]]) {
		mx[i] = mx[ls[i]];
		who[i] = who[ls[i]];
	}
	else if(mx[ls[i]] == mx[rs[i]]) {
		mx[i] = mx[ls[i]];
		who[i] = min(who[ls[i]], who[rs[i]]);
	}
	else {
		mx[i] = mx[rs[i]];
		who[i] = who[rs[i]];
	}

}

int update(int u, int l, int r, int id) {
	if(u == 0) u = ++tcnt;
	if(l == r) {
		mx[u] += 1;
		who[u] = id;
		return u;
	}
	int mid = l + r >> 1;
	if(id <= mid) ls[u] = update(ls[u], l, mid, id);
	else rs[u] = update(rs[u], mid+1, r, id);
	up(u);
	return u;
}

pii query(int u, int l, int r, int ll, int rr) {
	if(u == 0) return MP(ll, 0);
	if(l == ll && r == rr) {
		return MP(who[u], mx[u]);
	}
	int md = l+r >> 1;
	pii ret;
	if(rr <= md) ret = query(ls[u], l, md, ll, rr);
	else if(ll > md) ret = query(rs[u], md+1,r, ll, rr);
	else {
		pii ts = query(ls[u], l, md, ll, md);
		pii rt = query(rs[u], md+1, r, md+1, rr);
		if(ts.second >= rt.second) ret = ts;
		else ret = rt;
	}
	return ret;
}

int merge(int u, int v, int l, int r) {
	if(u == 0 || v == 0) return u ^ v;
	if(l == r) {
		mx[u] += mx[v];
		who[u] = l;
		return u;
	}
	int md = l + r >> 1;
	ls[u] = merge(ls[u], ls[v], l, md);
	rs[u] = merge(rs[u], rs[v], md+1, r);
	up(u);
	return u;
}

state * check(int l, int r) {
	state *cur = root;
	for(int i = l; i <= r; ++i)
		cur = cur->son[s[i]-'a'+1];
	return cur;
}

int main() {
	//freopen("in.txt", "r", stdin);
	scanf("%s", s);
	n = strlen(s);
	scanf("%d", &m);
	root = last = &que[tot++];
	for(int i = 1; i <= m; ++i)
	{
		scanf("%s", t);
		int len = strlen(t);
		for(int j = 0; j < len; ++j)
			extend(t[j]-'a'+1, i);
		extend(0, 0);
	}

	par_init();
	s_init();
	int q;
	scanf("%d", &q);

	for(int i = 1; i <= q; ++i) {
		int l, r, sl,sr;
		scanf("%d%d%d%d", &l, &r, &sl, &sr);
		--sl, --sr;
		state *cur = NULL;
		if(mlen[sr] >= sr-sl+1) cur = find(match[sr], sr-sl+1);
		
		if(cur == NULL) ans[i] = MP(l, 0);
		else cur->Que.push_back(Query(l, r, i));
	}

	//topo
	for(int i = 0; i < tot; ++i) ++cnt[que[i].val];
	for(int i = 1; i <= tot; ++i) cnt[i] += cnt[i-1];
	for(int i = 0; i < tot; ++i) rk[--cnt[que[i].val]] = i;

	//cal
	for(int u = tot-1; u > 0; -- u) {
		int i = rk[u];
		if(que[i].id != 0) 
			que[i].rt = update(que[i].rt, 1, m, que[i].id);
		for(int j = 0; j < que[i].Que.size(); ++j) {
			Query tmp = que[i].Que[j];
			ans[tmp.id] = query(que[i].rt, 1, m, tmp.l, tmp.r);
		}
		if(que[i].par[0]) 
			que[i].par[0]->rt = merge(que[i].par[0]->rt, que[i].rt, 1, m);
	}

	for(int i = 1; i <= q; ++i)
		printf("%d %d\n", ans[i].first, ans[i].second);
}