[loj3396]novel

建立AC自动机，记$|x$和$fail_{x}$分别表示$x$的深度（从$0$开始）和失配指针

记$W_{x}$表示以$x$为结束节点的字符串权值和$,S_{x}=\sum_{z在(fail树中)x到根路径上}W_{z}$

对于字符串$s_{i}$，定义$pos_{r}$表示$s_{i}[1,r]$在AC自动机上的位置，则
$$
g(s_{i}[l,r])=g(s_{i}[l,r))+\sum_{x在(fail树中)pos_{r}到根路径上,|x|\le r-l+1}W_{x}
$$
在此基础上，问题即对所有$r$求$\max_{1\le l\le r}\frac{g(s_{i}[l,r])}{r-l+1}$，并将$l$分为三类讨论：

1. $l=1$，单独维护，转移即$g(s_{i}[1,r])=g(s_{i}[1,r))+S_{pos_{r}}$

2. $2\le l\le r-|fail_{pos_{r}}|$，注意到后者随着$r$增加单调不降，即依次执行：

• 全局加上$S_{fail_{pos_{r}}}$（由于$i\ge 2,x=pos_{r}$的情况无意义）
• 对于$r-|fail_{pos_{r-1}}|\le l\le r-|fail_{pos_{r}}|$，在当前序列末尾加入$g(s_{i}[l,r])$
• 查询$\max_{l\in [2,r-|fail_{pos_{r}}|]}\frac{g(s_{i}[l,r])}{r-l+1}$

关于查询，二分枚举答案$k$，即判定是否存在$(l-1)k+g(s_{i}[l,r])\ge rk$

维护前者的凸包（自变量为$k$），注意到$k$减小无意义，进而可以用指针代替二分

关于加入的$g(s_{i}[l,r])$，记$t=s_{i}(r-|fail_{pos_{r}}|,r]$，则所求的$s_{i}[l,r]$即以$t$为后缀

注意到$t$是某个串的前缀（即$fail_{pos_{r}}$对应位置），可以预处理出$g(t)$（参考$1.$）

对反串建立AC自动机，在其中找到$t$所在位置，并依次加入$t$前的字符即可

前者可以对每个串均预处理出（倒序枚举长度跳$fail$树），后者即加上对应位置的$S'_{x}$

3. $r-|fail_{pos_{r}}|<l\le r$，可以利用$t$所对应前缀所求出的结果

为了保证结果间的顺序，处理完前两种情况后在AC自动机上bfs一遍即可

时间复杂度为$o(m)$，可以通过

#include<bits/stdc++.h>
using namespace std;
#define N 200005
#define M 5000005
#define mod 998244353
#define ll long long
#define LL __int128
int T,n,x,l,ql,qr,lst,Ans,inv[M],pos[M],q[M];
char s[M];ll tag,val[M];vector<int>ch[N];
struct Frac{
    ll x;int y;
    int get(){
        return x%mod*inv[y]%mod;
    }
    bool operator < (const Frac &n)const{
        return (LL)x*n.y<(LL)y*n.x;
    }
}ans[M];
struct AC{
    int V=1,dep[M],nex[M],ch[M][4];
    ll W[M],S[M],g[M];
    queue<int>q;vector<int>dfn,v[N];
    void add(char *s,int l,int id,int x){
        int k=1;v[id].push_back(1);
        for(int i=0;i<l;i++){
            int c=s[i]-'a';
            if (!ch[k][c])ch[k][c]=++V,dep[V]=dep[k]+1;
            k=ch[k][c],v[id].push_back(k);
        }
        W[k]+=x;
    }
    void build(){
        for(int i=0;i<4;i++){
            if (!ch[1][i])ch[1][i]=1;
            else nex[ch[1][i]]=1,q.push(ch[1][i]);
        }
        while (!q.empty()){
            int k=q.front();q.pop();
            S[k]=W[k]+S[nex[k]],g[k]+=S[k],dfn.push_back(k);
            for(int i=0;i<4;i++)
                if (!ch[k][i])ch[k][i]=ch[nex[k]][i];
                else{
                    nex[ch[k][i]]=ch[nex[k]][i];
                    g[ch[k][i]]+=g[k],q.push(ch[k][i]);
                }
        }
    }
}T1,T2;
Frac get(int x,int y){
    return Frac{val[x]-val[y],y-x};
}
void add(int k){
    if (k==1)return;
    while ((ql<qr)&&(get(q[qr],k)<get(q[qr-1],q[qr])))qr--;
    q[++qr]=k;
}
Frac query(int k){
    if (ql>qr)return Frac{0,1};
    val[k+1]=-tag;
    while ((ql<qr)&&(get(q[ql],k+1)<get(q[ql+1],k+1)))ql++;
    return get(q[ql],k+1);
}
int main(){
    inv[0]=inv[1]=1;
    for(int i=2;i<M;i++)inv[i]=(ll)(mod-mod/i)*inv[mod%i]%mod;
    scanf("%d%d",&n,&T);
    for(int i=1;i<=n;i++){
        scanf("%s%d",s,&x),l=strlen(s);
        for(int j=0;j<l;j++)ch[i].push_back(s[j]-'a');
        T1.add(s,l,i,x),reverse(s,s+l),T2.add(s,l,i,x);
    }
    T1.build(),T2.build();
    for(int i=1;i<=n;i++){
        l=ch[i].size();
        for(int j=l,k=T2.v[i][l];j>=0;j--){
            while (j<T2.dep[k])k=T2.nex[k];
            pos[T1.v[i][j]]=k;
        }
    }
    for(int i=1;i<=n;i++){
        l=ch[i].size(),ql=1,qr=lst=0;
        for(int r=1;r<=l;r++){
            int k=T1.v[i][r];tag+=T1.S[T1.nex[k]];
            int k0=pos[T1.nex[k]];ll s=T1.g[T1.nex[k]];
            for(int j=r-T1.dep[T1.nex[k]];j>=r-T1.dep[T1.nex[lst]];j--){
                k0=T2.ch[k0][ch[i][j-1]],s+=T2.S[k0],val[j]=s-tag;
            }
            for(int j=r-T1.dep[T1.nex[lst]];j<=r-T1.dep[T1.nex[k]];j++)add(j);
            lst=k,ans[k]=max(query(r),Frac{T1.g[k],r});
        }
    }
    for(int i:T1.dfn)ans[i]=max(ans[i],ans[T1.nex[i]]);
    for(int i=1;i<=n;i++){
        l=ch[i].size();Frac s=Frac{0,1};
        for(int j=1;j<=l;j++)s=max(s,ans[T1.v[i][j]]),Ans^=s.get();
        if ((!T)&&(i==1))printf("%.6f\n",1.0*s.x/s.y);
    }
    if (T)printf("%d\n",Ans);
    return 0;
}