【做题纪要】4月“祝祷转过千年诗篇”- 『雪山之眼』
(做题纪要前放点闲话应该没啥问题...吧?)
禾念你虽然pv里的藏文格式全都错了但是应该不至于直接把藏文全删了吧(
还有天依游学记怎么这么快就还剩十几天就要完结了，哭哭
P2408 不同子串个数
板子题，最后结果为 \(\dfrac{n(n+1)}{2}-\sum\limits_{i=2}^{n}\text h_i\)
这个我应该在学习笔记里写了，这里挂一下
代码
点击查看代码
namespace solve{
int height[N],sa[N],oldsa[N],rk[N],oldrk[N],cnt[N],key[N];
namespace SA{
inline bool cmp(int x,int y,int w){
return (oldrk[x]==oldrk[y])&&(oldrk[x+w]==oldrk[y+w]);
}
inline void Init(char *s){
int n=strlen(s+1),m=127,tot;
for_(i,1,n)
rk[i]=s[i],
++cnt[rk[i]];
for_(i,1,m)
cnt[i]+=cnt[i-1];
_for(i,n,1) sa[cnt[rk[i]]--]=i;
for(int w=1;;w<<=1,m=tot) {
tot=0;
_for(i,n,n-w+1)
oldsa[++tot]=i;
for_(i,1,n)
if(sa[i]>w)
oldsa[++tot]=sa[i]-w;
memset(cnt,0,sizeof(cnt));
for_(i,1,n)
++cnt[key[i]=rk[oldsa[i]]];
for_(i,1,m)
cnt[i]+=cnt[i-1];
_for(i,n,1)
sa[cnt[key[i]]--]=oldsa[i];
memcpy(oldrk+1,rk+1,n*sizeof(int));
tot=0;
for_(i,1,n)
rk[sa[i]]=((cmp(sa[i],sa[i-1],w))?(tot):(++tot));
if(tot==n)
break;
}
}
inline void Init_H(char *s){
int n=strlen(s+1),tot=0;
for_(i,1,n){
if(!rk[i]) continue;
if(tot) --tot;
while(s[i+tot]==s[sa[rk[i]-1]+tot]) ++tot;
height[rk[i]]=tot;
}
}
}
using namespace SA;
inline void In(){
int n,ans=0;
char s[N];
FastI>>n>>(s+1);
Init(s);Init_H(s);
for_(i,2,n) ans+=height[i];
FastO<<((n*(n+1)/2)-ans)<<endl;
}
}
using namespace solve;
P3181 「HAOI2016」找相同字符
大到小扫描 \(\text {height}\) 数组，合并相邻后缀
当前块中的贡献就是第一个串的后缀数 $\times $ 第二个串的后缀数 \(\times\) 当前枚举的 \(\text {height}\)。
因此我们直接用并查集维护即可
代码
点击查看代码
namespace solve{
int height[N],sa[N],oldsa[N],rk[N],oldrk[N],cnt[N],key[N];
namespace SA{
inline bool cmp(int x,int y,int w){
return (oldrk[x]==oldrk[y])&&(oldrk[x+w]==oldrk[y+w]);
}
inline void Init(char *s){
int n=strlen(s+1),m=127,tot;
for_(i,1,n)
rk[i]=s[i],
++cnt[rk[i]];
for_(i,1,m)
cnt[i]+=cnt[i-1];
_for(i,n,1) sa[cnt[rk[i]]--]=i;
for(int w=1;;w<<=1,m=tot) {
tot=0;
_for(i,n,n-w+1)
oldsa[++tot]=i;
for_(i,1,n)
if(sa[i]>w)
oldsa[++tot]=sa[i]-w;
memset(cnt,0,sizeof(cnt));
for_(i,1,n)
++cnt[key[i]=rk[oldsa[i]]];
for_(i,1,m)
cnt[i]+=cnt[i-1];
_for(i,n,1)
sa[cnt[key[i]]--]=oldsa[i];
memcpy(oldrk+1,rk+1,n*sizeof(int));
tot=0;
for_(i,1,n)
rk[sa[i]]=((cmp(sa[i],sa[i-1],w))?(tot):(++tot));
if(tot==n)
break;
}
}
inline void Init_H(char *s){
int n=strlen(s+1),tot=0;
for_(i,1,n){
if(!rk[i]) continue;
if(tot) --tot;
while(s[i+tot]==s[sa[rk[i]-1]+tot]) ++tot;
height[rk[i]]=tot;
}
}
}
using namespace SA;
int f[N],g[N],A[N],B[N];
inline bool cmp1(int a,int b){
return height[a]>height[b];
}
inline int find(int x){
return f[x]=((f[x]!=x)?find(f[x]):x);
}
char s1[N],s2[N],s[N];
inline void In(){
FastI>>(s1+1)>>(s2+1);
int len1=strlen(s1+1);
int len2=strlen(s2+1);
int n=len1+len2+1;
for_(i,1,n){
if(i==len1+1) s[i]='#';
else if(i<=len1) s[i]=s1[i];
else s[i]=s2[i-len1-1];
}
Init(s);Init_H(s);
for_(i,1,n){
g[i]=i+1;f[i]=i;
if(sa[i]>len1+1) B[i]=1;
if(sa[i]<=len1) A[i]=1;
}
sort(g+1,g+1+n,cmp1);
int ans=0;
for_(i,1,n-1){
int x=find(g[i]),y=find(g[i]-1);
ans+=(A[x]*B[y]+A[y]*B[x])*height[g[i]];
A[y]+=A[x];B[y]+=B[x];
f[x]=y;
}
write(ans);
}
}
P4070「SDOI2016」生成魔咒
题意
在一个字符串后加上字符，问加上这个字符后有多少本质不同的字符串
思路
首先看到不同的字符串可以很容易的想到本题需要使用 \(\text{SA}\)
正着做不好写，所以离线，把插入字符串换成删除字符串，直接求出最后全部加入完情况下的 \(\text {height}\) 数组
静态求本质不同的字符串很好求，上面第一道题就是，结果为 \(\large \frac{n(n+1)}{2}\)
这样我们贡献就好维护了，对于删除一个位置为 \(i\) 的字符，我们定义其前一个存在的和后一个存在的后缀字符串为 last 和 nxt
结果很明显是 \(ans+ \text{LCP}(last,rk[i]) + \text{LCP}(rk[i],nxt) - \text {LCP}(last,nxt)\)
随便挂个类似 set 的东西来维护就行
代码
警钟长鸣，char数组直接存巨大数字会溢出
点击查看代码
namespace solve{
int height[N],sa[N],oldsa[N],rk[N],oldrk[N];
ll cnt[N],key[N];
namespace SA{
inline bool cmp(ll x,ll y,ll w){
return (oldrk[x]==oldrk[y])&&(oldrk[x+w]==oldrk[y+w]);
}
inline void Init(int *s,int n){
int m=127000,tot;
for_(i,1,n)
rk[i]=s[i],
++cnt[rk[i]];
for_(i,1,m)
cnt[i]+=cnt[i-1];
_for(i,n,1) sa[cnt[rk[i]]--]=i;
for(ll w=1;;w<<=1,m=tot) {
tot=0;
_for(i,n,n-w+1)
oldsa[++tot]=i;
for_(i,1,n)
if(sa[i]>w)
oldsa[++tot]=sa[i]-w;
memset(cnt,0,sizeof(cnt));
for_(i,1,n)
++cnt[key[i]=rk[oldsa[i]]];
for_(i,1,m)
cnt[i]+=cnt[i-1];
_for(i,n,1)
sa[cnt[key[i]]--]=oldsa[i];
memcpy(oldrk+1,rk+1,n*sizeof(int));
tot=0;
for_(i,1,n)
rk[sa[i]]=((cmp(sa[i],sa[i-1],w))?(tot):(++tot));
if(tot==n)
break;
}
}
inline void Init_H(int *s,int n){
int tot=0;
for_(i,1,n){
if(!rk[i]) continue;
if(tot) --tot;
while(s[i+tot]==s[sa[rk[i]-1]+tot]) ++tot;
height[rk[i]]=tot;
}
}
}
using namespace SA;
ll val[N],a[N],san[N];char s[N];
namespace STree{
class Tree{
public:
int maxm,minm,lazy,l,r;
}T[N];
inline void build(int q,int l,int r){
T[q].l=l;T[q].r=r;
if(l==r) {
T[q].maxm=T[q].minm=val[l];
}
build(lc(q),l,mid(l,r));
build(rc(q),mid(l,r)+1,r);
T[q].maxm=max(T[lc(q)].maxm,T[rc(q)].maxm);
T[q].minm=min(T[lc(q)].minm,T[rc(q)].minm);
}
inline void lazy(int q){
if(T[q].lazy){
T[lc(q)].lazy+=T[q].lazy;
T[rc(q)].lazy+=T[q].lazy;
T[lc(q)].minm+=T[q].lazy;
T[rc(q)].minm+=T[q].lazy;
T[lc(q)].maxm+=T[q].lazy;
T[rc(q)].maxm+=T[q].lazy;
T[q].lazy=0;
}
}
inline void change(int q,int l,int r,int val){
if(T[q].l>r || T[q].r<l) return;
if(T[q].lazy) lazy(q);
if(T[q].l>=l && r<=T[q].r){
T[q].maxm+=val;
T[q].minm+=val;
}
change(lc(q),l,r,val);
change(rc(q),l,r,val);
T[q].maxm=max(T[lc(q)].maxm,T[rc(q)].maxm);
T[q].minm=min(T[lc(q)].minm,T[rc(q)].minm);
}
inline int Askmin(int q,int l,int r){
if(T[q].l>r || T[q].r<l) return inf;
if(T[q].lazy) lazy(q);
if(T[q].l>=l&&r<=T[q].r) return T[q].minm;
return min(Askmin(lc(q),l,r),Askmin(rc(q),l,r));
}
inline int Askmax(int q,int l,int r){
if(T[q].l>r || T[q].r<l) return inf;
if(T[q].lazy) lazy(q);
if(T[q].l>=l&&r<=T[q].r) return T[q].maxm;
return max(Askmax(lc(q),l,r),Askmax(rc(q),l,r));
}
}
//these are useless,TianYi do not know why she wrote it QAQ
int Log[N];
namespace ST{
ll minn[N][25];
inline void build(int n){
for_(i,1,n) {minn[i][0]=height[i];}
for_(j,1,20) {
for_(i,1,n-(1<<j)+1){
minn[i][j]=min(minn[i][j-1],minn[i+(1<<(j-1))][j-1]);
}
}
}
inline ll askLCP(ll i,ll j){
ll qwq=Log[j-i];
return min(minn[i+1][qwq],minn[j-(1<<qwq)+1][qwq]);
}
}
using namespace ST;
// the ST table is useful but not SegTree QAQ
stack<int> S;
set<ll> vis;
map<ll,ll> mp;
inline void In(){
int n;read(n);
_for(i,n,1){
read(a[i]);
}
for_(i,1,n)
san[i]=a[i];
sort(san+1,san+n+1);
int SAs=unique(san+1,san+n+1)-san-1;
for_(i,1,n)
a[i]=lower_bound(san+1,san+SAs+1,a[i])-san;
Init(a,n);Init_H(a,n);
Log[1]=0;
for_(i,2,n){
Log[i]=Log[i>>1]+1;
}
build(n);
vis.insert(inf) ;
vis.insert(-inf);
ll ans=0;
_for(i,n,1){
ans+=n-i+1;
ll p=*--vis.upper_bound(rk[i]);
ll q=*vis.lower_bound(rk[i]);
if (p!=-inf && q==inf) {ans-=askLCP(p,rk[i]);}
if (p==-inf && q!=inf) {ans-=askLCP(rk[i],q);}
if (p!=-inf && q!=inf) {ans-=max(askLCP(p,rk[i]),askLCP(rk[i],q));}
write(ans,'\n');
vis.insert(rk[i]);
}
}
}
using namespace solve;
P6793「SNOI2020」字符串
题意
给定两个长度为 \(n\) 的小写字符串 \(a, b\)，求出他们所有长为 \(k\) 的子串，分别组成集合 \(\text {A, B}\) ，每次可以修改 \(\text A\) 中一个元素的后缀，费用为后缀的长度，求将 \(\text A\) 修改成 \(\text B\) 的最小费用之和。
思路
首先依然是看到后缀，所以考虑使用后缀数组来解决这个问题
还是老样子，先把字符串连起来，然后用特殊字符隔开，然后我们可以很明显的发现对于 \(x\) 和 \(y\) 两个串，如果想要让其对应我们需要的费用为 \(k-\text {LCP}(x,y)+1\)
然后我们贪心的先把 \(\text{LCP}\) 较大的串都对应起来，用并查集维护即可
代码
代码
namespace solve{
int height[N],sa[N],oldsa[N],rk[N],oldrk[N];
ll cnt[N],key[N];
namespace SA{
inline bool cmp(ll x,ll y,ll w){
return (oldrk[x]==oldrk[y])&&(oldrk[x+w]==oldrk[y+w]);
}
inline void Init(char *s){
int n=strlen(s+1),m=128,tot;
for_(i,1,n)
rk[i]=s[i],
++cnt[rk[i]];
for_(i,1,m)
cnt[i]+=cnt[i-1];
_for(i,n,1) sa[cnt[rk[i]]--]=i;
for(ll w=1;;w<<=1,m=tot) {
tot=0;
_for(i,n,n-w+1)
oldsa[++tot]=i;
for_(i,1,n)
if(sa[i]>w)
oldsa[++tot]=sa[i]-w;
memset(cnt,0,sizeof(cnt));
for_(i,1,n)
++cnt[key[i]=rk[oldsa[i]]];
for_(i,1,m)
cnt[i]+=cnt[i-1];
_for(i,n,1)
sa[cnt[key[i]]--]=oldsa[i];
memcpy(oldrk+1,rk+1,n*sizeof(int));
tot=0;
for_(i,1,n)
rk[sa[i]]=((cmp(sa[i],sa[i-1],w))?(tot):(++tot));
if(tot==n)
break;
}
}
inline void Init_H(char *s){
int n=strlen(s+1),tot=0;
for_(i,1,n){
if(!rk[i]) continue;
if(tot) --tot;
while(s[i+tot]==s[sa[rk[i]-1]+tot]) ++tot;
height[rk[i]]=tot;
}
}
}
using namespace SA;
int Log[N];
namespace ST_table{
ll minn[N][20];
inline void build(int n){
for_(i,1,n) {minn[i][0]=height[i];}
for_(j,1,20) {
for_(i,1,n-(1<<j)+1){
minn[i][j]=min(minn[i][j-1],minn[i+(1<<(j-1))][j-1]);
}
}
}
inline ll askLCP(ll i,ll j){
ll qwq=Log[j-i];
return min(minn[i+1][qwq],minn[j-(1<<qwq)+1][qwq]);
}
}
//using namespace ST_Table;
int fa[N];
inline int find(int x){
return ((fa[x]==x)?x:fa[x]=find(fa[x]));
}
inline void merge(int x,int y){
fa[x]=y;
}
char s1[N],s2[N],s[N];
vector<int> vec[300005];
int cnt1[N];
inline void In(){
Log[1]=0;
for_(i,1,N-1) Log[i]=Log[i>>1]+1;
for_(i,1,N-1) fa[i]=i;
int n,k;read(n,k);
FastI>>(s1+1)>>(s2+1);
for_(i,1,2*n+1){
if(i==n+1) s[i]='#';
else if(i<=n) s[i]=s1[i];
else s[i]=s2[i-n-1];
}
int len=n*2+1;
Init(s),Init_H(s);
int ans=(n-k+1)*k;
for_(i,1,len){
cnt1[i]=0;
if(sa[i]<=n-k+1) cnt1[i]=1;
else if(sa[i]>n+1 && sa[i]<=len-k+1) cnt1[i]=-1;
if(i>1) vec[height[i]].push_back(i);
}
_for(i,n,0){
int sz=vec[i].size();
for_(j,0,sz-1){
int qwq=vec[i][j];
int x=find(qwq-1),y=find(qwq);
ans-=((cnt1[x]*cnt1[y]>0)?(0):(min(abs(cnt1[x]),abs(cnt1[y]))))*min(i,k);
cnt1[y]=cnt1[x]+cnt1[y];
merge(x,y);
}
}
write(ans,'\n');
}
}
using namespace solve;
CF955D Scissors
思路
首先考虑对于传进来的两个串 \(s_1\) 和 \(s_2\) ，预处理出 \(s_2\) 的每个前缀在 \(s_1\) 中出现的最早位置和 \(s_2\) 每个后缀在 \(s_1\) 中出现的最晚位置
然后直接扫一遍就行了，复杂度 \(\text O(n)\)
代码
点击查看代码
namespace solve{
const int N=5e5+5;
int mod=1e9,base=131;
int n,m,k,ans1,ans2,lm[N],rm[N];
char s[N],t[N];
class Hash{
public:
int Hash[N], poww[N];
inline void Init(char *s) {
int len=strlen(s+1);
poww[0]=1;
for_(i,1,len) {
Hash[i]=(Hash[i-1]*base+s[i]-'a'+1) % mod;
poww[i]=poww[i-1]*base%mod;
}
}
inline int get(int l, int r){
return ((Hash[r]-Hash[l-1]*poww[r-l+1])%mod+mod)%mod;
}
}S,T;
inline bool Judge(){
if (n<(k<<1)||m>(k<<1)) return 0;
S.Init(s),T.Init(t);
int pos=k;
for_(i,1,m) lm[i]=n+1;
for_(i,1,min(m,k)){
while(pos<=n&&S.get(pos-i+1,pos)!=T.get(1,i))
pos++;
if(S.get(k-i+1,k)==T.get(1,i))
pos=k;
lm[i]=pos;
}
pos=n-k+1;
for_(i,1,min(m,k)){
while(pos && S.get(pos, pos + i - 1) != T.get(m - i + 1, m)) pos--;
if(S.get(n-k+1,n-k+i)==T.get(m-i+1,m)) pos=n-k+1;
rm[m-i+1]=pos;
}
for_(i,1,n-m+1){
if(S.get(i,i+m-1)==T.get(1,m)){
if(k>=i&&n-k+1<=i+m-1) continue;
ans1=min(max(1ll,i-k+1),n-k+1-k);
ans2=max(k+1,min(n-k+1,i));
return 1;
}
}
for_(i,1,m-1){
if(lm[i]<rm[i+1]&&lm[i]<=n&&rm[i+1]){
ans1=lm[i]-k+1;
ans2=rm[i+1];
return 1;
}
}
return 0;
}
inline void In() {
srand(time(0));
mod+=rand();
base+=rand()%10;
read(n,m,k);
FastI>>(s+1)>>(t+1);
if(Judge())
write("Yes\n",ans1," ",ans2);
else
write("No");
}
}
CF1037H Security
题意
给定一个字符串 \(s\) 和 \(q\) 次询问，每次询问给出一个 \(l_i,r_i\) 和 \(x_i\)，你需要选出一个满足以下条件的字符串 \(str\)。
-
\(str\) 是 \(s[l_i\sim r_i]\) 的子串。
-
\(str > x_i\)。
-
\(str\) 是所有满足以下条件内字符串字典序最小的。
输出 \(str\) 的长度，如果不存在 \(str\) 则输出 \(-1\)。
思路
先把 \(s\) 和所有的询问 \(x_i\) 串都连起来，用小于 \(a\) 的字符连接，连成字符串 \(S\)
枚举 \(T\) 的前缀，判断区间中是否存在一个子串满足以下条件
-
这个子串等于这个前缀加上一个字母
-
加上的字母大于 \(T\) 的前缀的后面一个字符
如果前缀为 \(T\) 本身，那么后面一个字符是极小的。
在 \(\text {SA}\) 上二分出一个区间，满足区间中的后缀与 \(T\) 的 \(\text{LCP}\) 长度等于正在枚举的 \(T\) 的前缀长度 \(len\)，记录上次的二分结果
求这个区间中满足 \(sa_i\in [l,r-len]\) 的最小的 \(i\) ，用主席树或者扫描线维护，复杂度 \(\text O(|S| \log |S|)\)
代码
点击查看代码
namespace solve{
const int N=4e5+5;
char stp[N];
int s[N*2],n,len;
class SA{
public:
int sa[N*2],height[N*2],cnt[N*2],rk[N*2];
void S_sort(int *s,int l,int m){
int cnt1;
for_(i,1,l) cnt[height[i]=s[i]]++;
for_(i,2,m) cnt[i]+=cnt[i-1];
_for(i,l,1) sa[cnt[height[i]]--]=i;
For_(k,1,l,k){
cnt1=0;
for_(i,l-k+1,l) rk[++cnt1]=i;
for_(i,1,l)
if(sa[i]>k)
rk[++cnt1]=sa[i]-k;
for_(i,1,m) cnt[i]=0;
for_(i,1,l) cnt[height[i]]++;
for_(i,2,m) cnt[i]+=cnt[i-1];
_for(i,l,1) sa[cnt[height[rk[i]]]--]=rk[i],rk[i]=0;
swap(height,rk);
height[sa[1]]=m=1;
for_(i,2,l)
height[sa[i]]=m=m+!(rk[sa[i]]==rk[sa[i-1]]&&rk[sa[i]+k]==rk[sa[i-1]+k]);
if(m==l) return;
}
}
inline void build(int *s,int l,int m){
int k=0;
S_sort(s,l,m);
for_(i,1,l)
rk[sa[i]]=i;
for_(i,1,l){
if(rk[i]==1) k=0;
else{
if(k>0) k--;
int j=sa[rk[i]-1];
while(i+k<=l&&j+k<=l&&s[i+k]==s[j+k])
k++;
}
height[rk[i]]=k;
}
}
}a;
class SegTree{
public:
int t[N*4],d;
inline void build(int n){
for(d=1;d<n;d<<=1);
memset(t,0x7f,sizeof(t));
}
inline int ask(int l,int r){
int mn=2e9;
for(l=l+d-1,r=r+d+1;l^r^1;l>>=1,r>>=1){
if(l&1^1) mn=min(mn,t[l^1]);
if(r&1) mn=min(mn,t[r^1]);
}
return mn;
}
inline void add(int x,int v){
for(int i=x+d;i;i>>=1)
t[i]=v;
}
}T;
pair<int,int> q[N];
namespace ST_Table{
int val[N],l[N],ans[N],ansl[N],Log[N*2],ST[20][N*2];
inline int askmin(int l,int r){
int k=Log[r-l+1];
return min(ST[k][l],ST[k][r-(1<<k)+1]);
}
}
using namespace ST_Table;
namespace Solve{
class node{
public:
int w,l,r,id,len;
};
vector<node> que[N*2];
inline void ask(int l,int r,int val,int slen,int id){
int w,cnt2=a.rk[val];
for(int j=1<<20;j;j>>=1)
((cnt2+j<=len)&&(askmin(a.rk[val]+1,cnt2+j)>=(min(slen,r-l)+1)))&&(
cnt2+=j
);
_for(i,min(slen,r-l),0){
w=cnt2;
for(int j=1<<20;j;j>>=1)
((w+j<=len)&&(askmin(cnt2+1,w+j)>=i))&&(
w+=j
);
que[cnt2+1].push_back(node{w,l,r-i,id,i});
cnt2=w;
}
}
inline void solve(){
T.build(l[0]);
int tp,id;
_for(i,len,1){
(a.sa[i]<=l[0])&&(T.add(a.sa[i],i),0);
int len1=que[i].size();
for_(j,0,len1-1)
(que[i][j].len>ansl[id=que[i][j].id]&&(tp=T.ask(que[i][j].l,que[i][j].r))<=que[i][j].w)&&(
ans[id]=a.sa[tp],ansl[id]=que[i][j].len,
0
);
}
}
}
using namespace Solve;
inline void In(){
memset(ansl,-1,sizeof(ansl));
int m;
FastI>>stp>>m;
l[0]=strlen(stp);
for_(i,0,l[0]-1)
s[++len]=stp[i];
s[++len]='z'+1;
for_(i,1,m){
read(q[i].first,q[i].second);
FastI>>stp;
l[i]=strlen(stp),val[i]=len+1;
for_(j,0,l[i]-1)
s[++len]=stp[j];
s[++len]='a'-1;
}
a.build(s,len,'z'+1);
for_(i,2,len)
ST[0][i]=a.height[i];
for(int j=1;(1<<j)<=len;j++)
for_(i,1,len-(1<<j)+1)
ST[j][i]=min(ST[j-1][i],ST[j-1][i+(1<<j-1)]);
for_(i,2,len)
Log[i]=Log[i>>1]+1;
for_(i,1,m)
ask(q[i].first,q[i].second,val[i],l[i],i);
solve();
for_(i,1,m){
if(ans[i]){
for_(j,ans[i],ans[i]+ansl[i])
write(char(s[j]));
write("\n");
}
else
write("-1\n");
}
}
}
using namespace solve;
P1117「NOI2016」优秀的拆分
题意
求一个字符串所有的子串可以拆成 \(\text{AABB}\) 的本质不同的形式个数，其中 \(\text{A,B}\) 均为任意非空字符串
多组测试
思路
多测不清空，亲人两行泪
之前听说过好几次这道 \(\text{NOI2016}\) 的后缀数组好题，所以直接考虑如何使用后缀数组来解决这道题
题目要求 \(\mathbf{AABB}\) 的数量，我们拆分问题可以转化为求每个点相邻的 \(\mathbf{AA}\) 串的数量（以这个点为头或以这个点为尾）
定义 \(pre_i\) 以 \(s[i]\) 为结尾的 \(\mathbf{AA}\) 串的数量，\(nxt_i\) 为以 \(s[i]\) 开头的 \(\mathbf{AA}\) 串的数量
这样我们就可以把两个相连的 \(\mathbf{AA}\) 的合并成一个 \(\mathbf{AABB}\) 的拆分，答案为 \(ans=\sum\limits_{i=1}^{n-1} pre_{i+1} \times nxt_i\)
可暴力求明显是 \(O(n^2 log n)\) 的，会超时
我们枚举 \(len\) 代表 \(\mathbf{AA}\) 形子串的 \(\dfrac{1}{2}\) 长度，然后判断 \(\text{LCP}\) 和 \(\text{LCS}\)，然后
代码
P5048【 YnOI2019 模拟赛】Yuno loves sqrt technology II
查询区间逆序对，要求时间小于 \(\mathcal O(n^{\frac{3}{2}})\)，空间 \(\mathcal O(n)\)
假设我们现在的区间是 \([l,r]\)，也就是图中红色的部分
现在我们需要向右移动一格
这一次的移动为我们带来的贡献是 \([1\sim r]\) 内大于 \(\mathbf{val}(r+1)\) 的数量减去\([1\sim l-1]\) 内大于 \(\mathbf{val}(r+1)\)
用图中的数字来表示就是 \([1\sim 7]\) 内值大于 \(\mathbf{val(8)}\) 的数量 减去 \([1\sim 4]\) 内大于 \(\mathbf{val}(8)\) 的数量
考虑第一个(也就是 \([1\sim r]\) 内大于 \(\mathbf{val}(r+1)\) 的数量)是定值，可以直接预处理，但是在后面那个里 \(l\) 是不确定的，我们无法直接预处理，所以这个也就是主要要维护的地方
我们可以首先先对于每个位置都开一个 \(\mathbf{vector}\) 来维护，把当前询问的编号和 \(r+1\) 扔到 \(l\) 所在的 \(\mathbf{vector}\) 里，进行第二次离线
莫队一共会移动端点 \(\mathcal O(n\sqrt n)\) 次，内存较大
我们发现，从 \(r\) 移动到我们想要移动的 \(r_1\) 时 \(l\) 不会发生变化，所以我们可以直接把 \(\{r+1 \sim r_1\}\) 扔到 \(\mathbf{vector}\) 内，这样空间就是 \(\mathcal O(n)\) 的了
然后可以值域分块，单次 \(\mathcal O(1)\) 修改 \(\mathcal O(\sqrt n )\) 查询，但是我们发现我们有 \(n\sqrt n\) 次询问和 \(n\) 次修改
所以我们适当增加修改的复杂度至 \(\mathcal O(\sqrt n)\) ，借此将查询的复杂度降为 \(\mathcal O(1)\)
总复杂度 \(\mathcal O(n \log n+n \sqrt n)\)，空间 \(\mathcal O(n)\)
按照上面的区间逆序对问题来实现即可
特殊的，本题因为是 \(\mathbf{YnOI}\) 所以比较卡常，不能#define int long long不然会 TLE
FastIO都救不回来那种
点击查看代码
#include<bits/stdc++.h>
#include <sys/mman.h>
#define N 100010
#define firein(a) freopen(a".in","r",stdin)
#define fireout(a) freopen(a".out","w",stdout);
#define fire(a) firein(a),fireout(a)
#define for_(a,b,c) for(int a=b;a<=c;a++)
#define _for(a,b,c) for(int a=b;a>=c;a--)
#define For_(a,b,c,d) for(int a=b;a<=c;a+=d)
#define _For(a,b,c,d) for(int a=b;a>=c;a-=d)
using namespace std;
namespace Solve{
const char *I=(char*)mmap(0,1<<22,1,2,0,0);
inline int read() {
int x=0,f=0;
while(*I<48)f|=*I++==45;
while(*I>47)x=x*10+(*I++&15);
return f?-x:x;
}
char O[1<<22],*o=O;
void print(long long x) {
if(x<0)*o++=45,x=-x;
if(x>9)print(x/10);
*o++=48+x%10;
}
struct Query{
int l,r,v,id;
}q[N];
vector<Query> L[N],R[N];
int n,m,blo,a[N],b[N],c[N],d[N],mp[N],tot,pos[N],bL[N],bR[N];
long long sum1[N],sum2[N],ans[N],Ans[N];
inline bool cmp(const Query &a,const Query &b){
if((a.l-1)/blo!=(b.l-1)/blo) return (a.l-1)/blo<(b.l-1)/blo;
return a.r<b.r;
}
namespace BIT{
#define lowbit(x) ((x)&(-x))
inline void Add(int x,int v){
For_(i,x,n,lowbit(i))
b[i]+=v;
}
inline int Ask(int x){
int ans=0;
_For(i,x,1,lowbit(i)){
ans+=b[i];
}
return ans;
}
}
using namespace BIT;
inline void Solve(){
sort(q+1,q+m+1,cmp);
q[0].l=1;
for_(i,1,m){
ans[i]=sum1[q[i].r]-sum1[q[i-1].r]+sum2[q[i].l]-sum2[q[i-1].l];
if(q[i-1].r<q[i].r) {
L[q[i-1].l-1].push_back({q[i-1].r+1,q[i].r,-1,i});
}
if(q[i].r<q[i-1].r) {
L[q[i-1].l-1].push_back({q[i].r+1,q[i-1].r,1,i});
}
if(q[i].l<q[i-1].l) {
R[q[i].r+1].push_back({q[i].l,q[i-1].l-1,-1,i});
}
if(q[i-1].l<q[i].l) {
R[q[i].r+1].push_back({q[i-1].l,q[i].l-1,1,i});
}
}
}
void In(){
n=read(),m=read();
blo=sqrt(n)+1;
for_(i,1,n) {
a[i]=read();
mp[i]=a[i];
}
sort(mp+1,mp+n+1);
tot=unique(mp+1,mp+n+1)-mp-1;
for_(i,1,n)
a[i]=lower_bound(mp+1,mp+tot+1,a[i])-mp;
for_(i,1,n){
sum1[i]=sum1[i-1]+i-1-Ask(a[i]);
Add(a[i],1);
}
memset(b,0,sizeof(b));
_for(i,n,1){
sum2[i]=sum2[i+1]+Ask(a[i]-1);
Add(a[i],1);
}
for_(i,1,m){
q[i].l=read();
q[i].r=read();
q[i].id=i;
}
Solve();
for_(i,1,1e5){
pos[i]=(i-1)/blo+1;
if(pos[i]!=pos[i-1]) {
bL[pos[i]]=i;
bR[pos[i-1]]=i-1;
}
}
bR[pos[(int)1e5]]=1e5;
int sum,l,r,v,id;
for_(i,1,n){
for_(j,1,pos[a[i]]-1)
c[j]++;
for_(j,bL[pos[a[i]]],a[i])
d[j]++;
int Size=L[i].size();
for_(j,0,Size-1){
l=L[i][j].l;
r=L[i][j].r;
v=L[i][j].v;
id=L[i][j].id;
sum=0;
for_(k,l,r)
sum+=c[pos[a[k]+1]]+d[a[k]+1];
ans[id]+=v*sum;
}
}
memset(c,0,sizeof(c));
memset(d,0,sizeof(d));
_for(i,n,1){
for_(j,pos[a[i]]+1,blo)
c[j]++;
for_(j,a[i],bR[pos[a[i]]])
d[j]++;
int Size=R[i].size();
for_(j,0,Size-1){
l=R[i][j].l;
r=R[i][j].r;
v=R[i][j].v;
id=R[i][j].id;
sum=0;
for_(k,l,r)
sum+=c[pos[a[k]-1]]+d[a[k]-1];
ans[id]+=v*sum;
}
}
for_(i,1,m){
ans[i]+=ans[i-1];
Ans[q[i].id]=ans[i];
}
for_(i,1,m)
print(Ans[i]),*o++='\n';
fwrite(O,1,o-O,stdout);
}
}
using namespace Solve;
signed main(){
#ifndef ONLINE_JUDGE
fire("data");
#endif
In();
}
P4887 第十四分块(前体)
点缀光辉的第十四分块(前体)，分块不可做，二次离线莫队
首先分析题面，考虑对于每次进行移动，贡献是 \(\{1\sim r\}\) 内和 \(\mathbf{val}(r+1)\) 异或和中 \(1\) 的个数 减去 \(\{1\sim l-1\}\) 内和 \(\mathbf{val}(r+1)\) 异或和中 \(1\) 的个数
前面依然是预处理，后面的直接 vector 存进去，和上一道题一样
然后我们发现，后面的值域分块维护，解决
数组开 \(100010\)，交上去，诶 \(\mathbf{wa}\) 了，调了半天发现只要改到 \(200020\) 就能过
不过这道题似乎不是很卡常，没用 Fread 和 Fwrite 也过了，直接关同步流 cin/cout
点击查看代码
#define ONLINE_JUDGE
#include<bits/stdc++.h>
#include<sys/mman.h>
#include<fcntl.h>
#define N 200010
#define firein(a) freopen(a".in","r",stdin)
#define fireout(a) freopen(a".out","w",stdout);
#define fire(a) firein(a),fireout(a)
#define for_(a,b,c) for(int a=b;a<=c;a++)
#define _for(a,b,c) for(int a=b;a>=c;a--)
#define For_(a,b,c,d) for(int a=b;a<=c;a+=d)
#define _For(a,b,c,d) for(int a=b;a>=c;a-=d)
#define lowbit(x) ((x)&(-x))
#define int long long
typedef long long ll;
using namespace std;
namespace Solve{
// #ifndef ONLINE_JUDGE
// int _if=open("data.in",O_RDONLY);
// FILE* _of=fopen("data.out","w");
// #else
// int _if=fileno(stdin);
// FILE* _of=stdout;
// #endif
// const char *_I=(char*)mmap(0,1<<24,1,2,_if,0);
// inline ll read(){
// int x=0;
// while(*_I<48)++_I;
// while(*_I>47)x=x*10+(*_I++&15);
// return x;
// }
// char O[1<<24],*o=O;
// void print(ll x){
// if (x>9)print(x/10);
// *o++=x%10+48;
// }
int a[N],bl[N],st[N],blo,top,n,m,k;
ll s1[N],s2[N],s[N],ret[N],ans[N],res;
struct node{
int l,r,id;
inline node(){}
inline node(int L,int R,int Id):l(L),r(R),id(Id){}
inline bool operator <(const node &b)const{
return bl[l]==bl[b.l]?r<b.r:l<b.l;
}
}q[N];
inline void Init(){
int Cnt,X;
for(int i=0;i<16384;++i){
Cnt=0,X=i;
for(;X;X^=lowbit(X))
++Cnt;
if(Cnt==k)
st[++top]=i;
}
}
vector<node>Q[N];
inline void Solve1(){
int l=q[1].r+1,r=q[1].r;
for_(i,1,m){
if(l<q[i].l){
Q[r].push_back(node(l,q[i].l-1,q[i].id<<1));
}
if(l>q[i].l){
Q[r].push_back(node(q[i].l,l-1,q[i].id<<1));
}
l=q[i].l;
if(r<q[i].r){
Q[l-1].push_back(node(r+1,q[i].r,q[i].id<<1|1));
}
if(r>q[i].r){
Q[l-1].push_back(node(q[i].r+1,r,q[i].id<<1|1));
}
r=q[i].r;
}
}
inline void Solve2(){
int l=q[1].r+1,r=q[1].r;
for_(i,1,m){
if(l<q[i].l)
res-=ret[q[i].id<<1]-s2[q[i].l-1]+s2[l-1];
if(l>q[i].l)
res+=ret[q[i].id<<1]-s2[l-1]+s2[q[i].l-1];
l=q[i].l;
if(r<q[i].r)
res+=s1[q[i].r]-s1[r]-ret[q[i].id<<1|1];
if(r>q[i].r)
res-=s1[r]-s1[q[i].r]-ret[q[i].id<<1|1];
r=q[i].r;
ans[q[i].id]=res;
}
}
inline void In(){
std::ios::sync_with_stdio(false);
cin.tie(nullptr);cout.tie(nullptr);
cin>>n>>m>>k;
blo=800;
Init();
for_(i,1,n){
cin>>a[i];
bl[i]=(i-1)/blo+1;
}
for_(i,1,m){
cin>>q[i].l>>q[i].r;
q[i].id=i;
}
sort(q+1,q+1+m);
Solve1();
for_(i,1,n){
s1[i]=s1[i-1]+s[a[i]];
for_(k,1,top)
++s[a[i]^st[k]];
s2[i]=s2[i-1]+s[a[i]];
for(vector<node>::iterator it=Q[i].begin();it!=Q[i].end();++it)
for_(k,it->l,it->r)
ret[it->id]+=s[a[k]];
}
Solve2();
for_(i,1,m)
cout<<ans[i]<<endl;
}
}
using namespace Solve;
signed main(){
// fire("data");
In();
}
