杂题记 2

杂题记 1，杂题记 2

写在前面：分解大致为 $15\sim 20$ 题，题目难度高，大部分题个人认为的实际难度不低于洛谷的紫题。

$\color{lightblue}{\texttt{CF1848F. Vika and Wiki}}$#

$\text{link}$ 。提示：考虑第 $i$ 次会变成啥。

$\texttt{solution}$

下边设 $a_k$ 为实际中的 $a_{k\bmod n}$。首先根据样例猜测一定有解。

按照提示，注意到第 $1$ 次 $a_i\gets a_i\ \text{xor}\ a_{i+1}$，第二次 $a_i\gets a_i\ \text{xor}\ a_{i+1}\ \text{xor}\ a_{i+1}\ \text{xor}\ a_{i+2}=a_i\ \text{xor}\ a_{i+2}$。

但是第三次似乎没啥规律？这时注意到可以倍增，第 $2^k$ 次 $a_i\gets a_i\ \text{xor}\ a_{i+2^k}$。于是 $k=\log_2n$ 一定是一个解。但是要求最小解。

由于我们可以快速求每 $2^k$ 次操作数组会变成啥，直接倍增即可，类似倍增 $\text{lca}$ 求出最大的不变为全 $0$ 的操作数，最后 $+1$ 即可。

$\texttt{code}$

#include<bits/stdc++.h>
#define LL long long
#define fr(x) freopen(#x".in","r",stdin);freopen(#x".out","w",stdout);
using namespace std;
const int N=1<<20|5;
int n,a[N],b[N],ans;
int main()
{
	ios::sync_with_stdio(0);cin.tie(0);cout.tie(0);cin>>n;
	for(int i=0;i<n;i++) cin>>a[i];
	if(!*max_element(a,a+n)) return cout<<0,0;
	for(int i=n/2;i;i>>=1)
	{
		for(int j=0;j<n;j++) b[j]=a[j];
		for(int j=0;j<n;j++) b[j]^=a[(j+i)&(n-1)];
		if(*max_element(b,b+n)){ans+=i;for(int j=0;j<n;j++) a[j]=b[j];}
	}
	return cout<<ans+1,0;
}

$\color{lightblue}{\texttt{CF512D. Fox And Travelling}}$#

$\text{link}$ 。提示：缩点，dp。

$\texttt{solution}$

考虑把题目中的“加点”理解为删点，发现每个点可以被删当且仅当这个点只有一条连边，删点后删去这个点连的所有边。

发现这个性质很严，手模一下，发现对于一个边双，若边双内有 $\ge 2$ 个点，那么整个边双都不可被删，这样性质就很好了。

---

考虑缩点后的森林（图不联通），称边双内点为 $1$ 的为白点，否则为黑点。

考虑森林里一颗全为白点的树，dp 计算。发现钦定一个点为根会漏算，于是把这个树中所有点都当做根算一遍答案。记 $size$ 为这棵树的大小，发现 $t<size$ 个点的方案在以不是这 $t$ 个点为根时都会算一遍，于是要除上 $size-t$。当 $t=size$ 时方案就不重不漏，不用动。

简单说一下 dp 式，大概是 $f_u=1,\forall v\in son_u,f_{u,i}\times f_{v,j}\times \binom{i+j}{j}\to f_{u,i+j}$，枚举完所有子节点后算上加上这个点的贡献：$f_{v,sz_u}\gets f_{v,sz_u-1}$，复杂度同树形背包 $O(n^2)$。

剩下的树可以拆分成若干以黑点连出的白点为根的树，同上 dp，当发现子节点转移到黑点的时候直接 return，精细实现一下发现是对的。这时候以那个点为根不重不漏。

把每颗树的答案合并起来和上面的 dp 类似，记得 $0$ 处答案的转移要特别注意，实现精细，还用不懂看代码。

$\texttt{code}$

#include<bits/stdc++.h>
#define P pair<int,int>
#define LL long long
#define fr(x) freopen(#x".in","r",stdin);freopen(#x".out","w",stdout);
using namespace std;
const int N=105,M=1e4+5,mod=1e9+9;
int n,m,id[N],low[N],tot=1,head[N],ok[M<<1],cnt,bl[N],c[N],jc[N],inv[N],siz[N],f[N][N],ff[N],F[N],A[N],ans[N];
struct edge{int to,nex;}e[M<<1];P E[M];basic_string<int>g[N],h;bool v[N];
inline int md(int x){return x>=mod?x-mod:x;}
inline int ksm(int x,int p){int s=1;for(;p;(p&1)&&(s=1ll*s*x%mod),x=1ll*x*x%mod,p>>=1);return s;}
inline int C(int n,int m){return n<m?0:1ll*jc[n]*inv[m]%mod*inv[n-m]%mod;}
inline void add(int u,int v)
{
	e[++tot]={v,head[u]};head[u]=tot;
	e[++tot]={u,head[v]};head[v]=tot;
}
void dfs(int x,int fa)
{
	id[x]=low[x]=++tot;
	for(int i=head[x];i;i=e[i].nex)
	{
		int to=e[i].to;
		if(!id[to]) dfs(to,x),low[x]=min(low[x],low[to]),(low[to]>id[x])&&(ok[i]=ok[i^1]=1);
		else if(to^fa) low[x]=min(low[x],id[to]);
	}
}
void dfs1(int x)
{
	v[x]=1;bl[x]=cnt;c[cnt]++;
	for(int i=head[x];i;i=e[i].nex){int to=e[i].to;if(!ok[i]&&!v[to]) dfs1(to);}
}//缩成边双 
void dfs2(int x){v[x]=1;h+=x;for(int i:g[x]) if(!v[i]) dfs2(i);}//找到全白树的所有点 
void dfs3(int x,int fa)
{
	if(c[x]>1) return;siz[x]=f[x][0]=1;v[x]=1;//注意这里也要v=1，dfs2的v=1只处理了全白树
	for(int i:g[x]) if(i^fa)
	{
		dfs3(i,x);
		for(int j=0;j<=siz[x];j++) ff[j]=f[x][j],f[x][j]=0;
		for(int j=0;j<=siz[x];j++) for(int k=0;k<=siz[i];k++)
			f[x][j+k]=(f[x][j+k]+1ll*ff[j]*f[i][k]%mod*C(j+k,k))%mod;siz[x]+=siz[i];
	}f[x][siz[x]]=f[x][siz[x]-1];
}//对于所有树的dp，注意这里的树形背包实现，要有上界 
inline void sol(int x)
{
	h.clear();dfs2(x);memset(F,0,sizeof(F));
	for(int i:h)
	{
		memset(f,0,sizeof(f));dfs3(i,0);
		for(int j=0;j<=h.size();j++) F[j]=md(F[j]+f[i][j]);
	}
	for(int i=0;i<=n;i++) A[i]=ans[i];
	for(int i=1;i<=h.size();i++)
	{
		int t=1ll*F[i]*ksm(h.size()-i,mod-2)%mod;if(i==h.size()) t=F[i];
		for(int j=i;j<=n;j++) ans[j]=(ans[j]+1ll*t*A[j-i]%mod*C(j,i))%mod;
	}
}//对于全白树每个点dp并贡献到答案 
int main()
{
	ios::sync_with_stdio(0);cin.tie(0);cout.tie(0);cin>>n>>m;
	jc[0]=1;for(int i=1;i<=n;i++) jc[i]=1ll*jc[i-1]*i%mod;
	inv[n]=ksm(jc[n],mod-2);for(int i=n-1;i>=0;i--) inv[i]=1ll*inv[i+1]*(i+1)%mod;
	for(int i=1,u,v;i<=m;i++) cin>>u>>v,add(u,v),E[i]={u,v};tot=0;
	for(int i=1;i<=n;i++) if(!id[i]) dfs(i,0);
	for(int i=1;i<=n;i++) if(!v[i]) cnt++,dfs1(i);
	for(int i=1;i<=m;i++)
	{
		auto [u,v]=E[i];u=bl[u],v=bl[v];
		if((u^v)) g[u]+=v,g[v]+=u;
	}memset(v,0,sizeof(v));ans[0]=1;
	for(int i=1;i<=cnt;i++) if(!v[i]&&c[i]>1)
		for(int j:g[i]) if(!v[j]&&c[j]==1)
		{
			dfs3(j,i);
			for(int I=0;I<=n;I++) A[I]=ans[I];
			for(int I=1;I<=n;I++) for(int J=I;J<=n;J++) ans[J]=(ans[J]+1ll*f[j][I]*A[J-I]%mod*C(J,I))%mod;
		}//黑点连出的白点为根的树特殊处理，贡献答案的方式略有不同 
	for(int i=1;i<=cnt;i++) if(!v[i]&&c[i]==1) sol(i);
	for(int i=0;i<=n;i++) cout<<ans[i]<<"\n";
	return 0;
}

$\color{lightblue}{\texttt{CF1762E. Tree Sum}}$#

$\text{link}$ 。提示：奇偶，算贡献。

$\texttt{solution}$

首先看到样例就猜测 $n$ 为奇数答案为 $0$，否则为啥剩下三样例个全是偶数？

考虑反证，记 $F(u)$ 表示 $\prod\limits_{(u,v,w)\in E} w$。则由题意 $\forall u,F(u)=-1$。则 $\prod\limits_{u}F(u)=(-1)^n=-1$。

考虑每条边的贡献，由于每条边会在两个端点贡献一次，于是 $\prod\limits_{u}F(u)=\prod\limits_{(u,v,w)\in E} w^2=1$，矛盾。

接下来考虑每种形态的树有怎样的填法，注意到类似 Prüfer 序列从叶节点剥，填法唯一。

考虑直接求 $dis$ 很困难，于是算每条边的贡献。首先边在 $dis$ 上等价于割掉这条边 $1,n$ 在不同连通块上。设两个连通块的大小为 $i,n-i$。若边权为 $1$，则两边子树内的 $F$ 值都不变，于是两边都是合法的子树，$2\mid i,2\mid n-i$。否则两边一定都不合法，$i,n-i$ 都是奇数。

考虑 $i,n-i$ 的两个连通块有多少种构成树的方案，首先两个子树分别是 $i^{i-2}$ 和 $(n-i)^{n-i-2}$，然后两边各选一个点连边是 $i(n-i)$，然后除掉 $1,n$ 的剩下 $n-2$ 个点给 $1$ 的连通块 $i-1$ 个是 $\binom{n-2}{i-1}$.

记 $f_i=i^{i-1}$，则答案为 $\sum\limits_{i=1}^{n-1} \dbinom{n-2}{i-1}f_if_{n-i}$，经验证：在 $f_1$ 处这样答案仍是对的，复杂度 $O(n\log n)$。

注意到拆开组合数这是一个卷积形式，于是能 $\texttt{NTT}$ 做到 $O(N\log N)$ 算出 $n=1\sim N$ 时的答案，但是在这题是没必要的。

$\texttt{code}$

#include<bits/stdc++.h>
#define LL long long
#define fr(x) freopen(#x".in","r",stdin);freopen(#x".out","w",stdout);
using namespace std;
const int N=1e6+5,mod=998244353;
int n,f[N],jc[N],inv[N],ans;
inline int md(int x){return x>=mod?x-mod:x;}
inline int ksm(int x,int p){int s=1;for(;p;(p&1)&&(s=1ll*s*x%mod),x=1ll*x*x%mod,p>>=1);return s;}
inline int C(int n,int m){return n<m?0:1ll*jc[n]*inv[m]%mod*inv[n-m]%mod;}
int main()
{
	scanf("%d",&n);if(n&1) return puts("0"),0;
	jc[0]=1;for(int i=1;i<=n;i++) jc[i]=1ll*jc[i-1]*i%mod;
	inv[n]=ksm(jc[n],mod-2);for(int i=n-1;i>=0;i--) inv[i]=1ll*inv[i+1]*(i+1)%mod;
	for(int i=1;i<=n;i++) f[i]=ksm(i,i-1);
	for(int i=1,t;i<n;i++) t=1ll*C(n-2,i-1)*f[i]%mod*f[n-i]%mod,ans=md(ans+((i&1)?mod-t:t));
	return printf("%d",ans),0;
}

$\color{lightblue}{\texttt{CF1305F. Kuroni and the Punishment}}$#

$\text{link}$ 。提示：上界，一半，随机化。

$\texttt{solution}$

丢一道类似 trick 的题：CF364D。

首先，容易注意到答案上界为 $n$，因为一定能在不超过 $n$ 次操作内变成全偶数。

而后有结论：在最终的答案中，一定存在至少一半的元素，它们最多被操作过一次。

反证：如果有至少一半两次，那么总个操作数就 $>n$ 了。

考虑这个一半怎么用，发现每次随机一个数组中的数，它们被操作次数 $\le 1$ 的概率是 $\ge \frac{1}{2}$ 的，于是直接随机若干个，枚举它被 $\pm 1$ 或不动，枚举它质因子 check 即可。不会 check 就别做这题了。

设随机 $C$ 个，$V=\max(a)$，则复杂度为 $O(C(n\omega(V)+\sqrt V))$，错误率为 $\le\dfrac{1}{2^C}$，于是取 $C\in[20,50]$ 即可通过，具体取值看喜好。

$\texttt{code}$

#include<bits/stdc++.h>
#define LL long long
#define fr(x) freopen(#x".in","r",stdin);freopen(#x".out","w",stdout);
using namespace std;
const int N=2e5+5;
mt19937 rnd(time(0));
int n;LL a[N],b[N],ans=1e18,t,p[15];
inline void sol(LL w)
{
	t=0;for(int i=2;1ll*i*i<=w;i++) if(w%i==0){p[++t]=i;while(w%i==0) w/=i;}
	if(w>1) p[++t]=w;
	for(int i=1;i<=t;i++)
	{
		LL s=0,c;
		for(int j=1;j<=n;j++) c=a[j]%p[i],s+=a[j]<p[i]?p[i]-c:min(c,p[i]-c);
		ans=min(ans,s);
	}
}
int main()
{
	ios::sync_with_stdio(0);cin.tie(0);cout.tie(0);cin>>n;
	for(int i=1;i<=n;i++) cin>>a[i],b[i]=a[i];shuffle(b+1,b+1+n,rnd);
	for(int i=1;i<=min(20,n);i++) sol(b[i]),sol(b[i]-1),sol(b[i]+1);
	return cout<<ans,0;
}

$\color{lightblue}{\texttt{gym 104639E. Magical Pair}}$#

$\text{link}$ 。提示：算贡献，离散对数，狄利克雷前缀和。

$\texttt{solution}$

为了简洁下面用 $/$ 代替分数。

首先特判 $A,B$ 有 $n$ 的倍数的情况，发现当且仅当两者均为 $n$ 倍数时才有贡献，于是这部分答案为 $(n-1)^2$。

考虑令 $A=(a,b)$ 表示 $a=A\bmod n,b=A\bmod n-1$，类似定义 $B=(c,d)$，则有：$0\le a,c<n,0\le b,d<n-1$，且 $n^2-n$ 个数与自然数对 $(a,b)$ 一一对应。

这时 $A^B\equiv B^A\pmod n\Leftrightarrow a^d\equiv b^c\pmod n$。

考虑算贡献，记 $f_c$ 表示 $a^d\equiv c\pmod n$ 的个数，则答案为 $\sum\limits_{c=1}^{n-1} f_c^2$。

设 $g$ 为原根，$m=n-1$，则 $a^d\equiv c\pmod n\Leftrightarrow g^{a'd}\equiv g^{c'}\pmod n\Leftrightarrow a'd\equiv c'\pmod m$。

此时有 $0\le a',d,c'<m$，其中 $a',c'$ 满足 $g^{a'}\equiv a\pmod m,g^{c'}\equiv c\pmod m$。

记 $F_{c'}$ 表示 $a'd\equiv c'\pmod m,0\le a',d<m$ 的个数，则答案为 $\sum\limits_{i=0}^{m-1} F_i^2$。

---

考虑固定 $k$，求 $xy\equiv k\pmod m,0\le x,y<m$ 的数量。

枚举 $(x,m)=d$，那么 $x$ 的取值只有 $\varphi(m/d)$ 种，我们需要保证 $d\mid k$。

那么有 $(x/d)\times y\equiv (k/d)\pmod {(m/d)},(x/d,m/d)=1$，也就是 $y\equiv (k/d)\times ((x/d)^{-1})\pmod {(m/d)}$。

于是 $y$ 在 $\bmod {(m/d)}$ 下唯一确定，此时 $y$ 在 $\bmod m$ 在有 $d$ 种取值。于是此时合法的 $(x,y)$ 的方案数为 $\sum\limits_{d\mid (m,k)} \varphi(m/d)d$。

于是 $\sum\limits_{i=0}^{m-1} F_i^2=\sum\limits_{i=0}^{m-1} \left(\sum\limits_{d\mid (m,i)} \varphi(m/d)d\right)^2=\sum\limits_{D\mid m} \varphi(m/D)\left(\sum \limits_{d\mid D} \varphi(m/d)d\right)^2$.

其中第二个等号是枚举 $(m,i)=D$ 时统计 $i$。记 $g_D=\sum \limits_{d\mid D} \varphi(m/d)d,G_D=\varphi(m/D)D$，则 $g_D=\sum\limits_{d\mid D}G_d$，做狄利克雷前缀和即可。

其中分解质因数要用 $\texttt{pollard-rho}$。

---

考虑计算这时狄利克雷前缀和的复杂度，记 $m$ 的质因数分解为：$\prod\limits_{i=1}^k p_i^{\alpha_i}$，则复杂度为 $\sum\limits_{i=1}^k \sum\limits_{d\mid m,p_i^{\alpha_i}\nmid d}1=\sum\limits_{i=1}^k \alpha_i\prod\limits_{j\neq i}(\alpha_i+1)<\sum\limits_{i=1}^k \prod\limits_{j=1}^k(\alpha_i+1)=d(m)w(n)$，由于我实现不精细要对所有质因数进行一次排序，此时复杂度为 $d(n)\log (d(n))$。

质因数分解的复杂度为 $\sqrt[4]{n}$，于是总复杂度 $O(T(\sqrt[4]{n}+d(n)(w(n)+\log d(n))))$，查表发现足以通过本题。具体不懂的可以看代码。

注意，写代码时我的式子是：$\sum\limits_{D\mid m} \varphi(D)\left(\sum \limits_{d\mid (m/D)} \varphi(m/d)d\right)^2$，显然这是等价的。

$\texttt{code}$

#include<bits/stdc++.h>
#include<bits/extc++.h>
#define P pair<LL,LL>
#define fi first
#define se second
#define LL long long
#define int LL
#define bll __int128
#define fr(x) freopen(#x".in","r",stdin);freopen(#x".out","w",stdout);
using namespace std;
using namespace __gnu_pbds;
mt19937 rnd(time(0));
const int N=2e5+5,M=25,mod=998244353;
LL T,n,m,t,p[M],c[M],pp[M],cnt,b[N];P a[N];
basic_string<int>g[M];
gp_hash_table<LL,int>mp;
inline int md(int x){return x>=mod?x-mod:x;}
inline void ad(int &x,int y){x=md(x+y);}
inline int ksm(int x,int p){LL s=1;for(;p;(p&1)&&(s=1ll*s*x%mod),x=1ll*x*x%mod,p>>=1);return s;}
namespace PRHO
{
	inline LL ksm(LL x,LL p,LL mod){LL s=1;for(;p;(p&1)&&(s=(bll)s*x%mod),x=(bll)x*x%mod,p>>=1);return s;}
	#define mytz __builtin_ctzll
	#define Abs(x) ((x)>0?(x):-(x))
	inline LL gcd(LL a,LL b)
	{
		LL az=mytz(a),bz=mytz(b),z=min(az,bz),diff;b>>=bz;
		while(a) a>>=az,diff=a-b,az=mytz(diff),b=min(a,b),a=Abs(diff);return b<<z;
	}
	const LL pr[]={2,3,5,7,11,13,17,19,23,29,31,37};
	inline bool check(LL a,LL p)
	{
		LL d=a-1,t=0;while(~d&1) d>>=1,t++;LL now=ksm(p,d,a);
		if(now==1||now==0||now==a-1) return 1;
		for(int i=0;i<t;i++)
		{
			now=(bll)now*now%a;
			if(now==1) return 0;
			if(now==a-1&&i!=t-1) return 1;
		}
		return 0;
	}
	inline bool pd(LL x)
	{
		if(x==1) return 0;
		for(LL i:pr)
		{
			if(x==i) return 1;
			if(x%i==0||!check(x,i)) return 0;
		}return 1;
	}
	#define f(x,c,n) (((bll)(x)*(x)+(c))%(n))
	inline LL Find(LL x)
	{
		LL t1=1ll*rnd()*rnd()%(x-1)+1,c=1ll*rnd()*rnd()%(x-1)+1,t2=f(t1,c,x),d,mul=1;
		for(int i=1;;i<<=1,t1=t2,mul=1)
		{
			for(int j=1;j<=i;j++)
			{
				t2=f(t2,c,x);
				mul=(bll)mul*Abs(t1-t2)%x;
				if(j%127==0){d=gcd(mul,x);if(d>1) return d;}
			}d=gcd(mul,x);
			if(d>1) return d;
		}
	}
	void po(LL x)
	{
		if(x<=1e9){for(int i=2;i*i<=x;i++) if(x%i==0){p[++t]=i;while(x%i==0) x/=i;}if(x^1) p[++t]=x;return;}
		if(x==1) return;
		if(pd(x)) return p[++t]=x,void();LL num=Find(x);
		while(x%num==0) x/=num;po(x),po(num);
	}
	inline void bk(LL x){t=c[1]=0;po(x);for(int i=1;i<=t;c[++i]=0) while(x%p[i]==0) c[i]++,x/=p[i];}
}using PRHO::bk;//封装的pollard-rho 
void dfs(int x,LL s,LL ph)
{
	if(x==t+1){a[++cnt]={s,ph};return;}LL S=1,PH=1;
	for(int i=0;i<=c[x];i++) dfs(x+1,s*S,ph*PH),s*=p[x],PH*=(p[x]-(!i));
}//由质因子得到所有因子以及所有因子的phi 
signed main()
{
	ios::sync_with_stdio(0);cin.tie(0);cout.tie(0);cin>>T;
	while(T--)
	{
		cin>>n;m=n-1;bk(m);cnt=0;dfs(1,1,1);sort(a+1,a+1+cnt);mp.clear();
		for(int i=1;i<=cnt;i++) mp[a[i].fi]=i;int x,ans=0,sum=1;//分解质因子部分 
		for(int i=1;i<=t;i++){pp[i]=1;for(int j=1;j<=c[i];j++) pp[i]*=p[i];}
		for(int i=1;i<=t;i++) for(int j=1;j<=cnt;j++) if(a[j].fi%pp[i]) g[i]+=j;//这里就是处理可被转移的位置，自己仔细思考为啥这样做 
		for(int i=1;i<=cnt;i++) x=a[i].fi,b[i]=a[mp[m/x]].se%mod*(x%mod)%mod;//这行是求 G 
		for(int i=1;i<=t;i++) for(int j:g[i]) x=a[j].fi,ad(b[mp[x*p[i]]],b[j]);//这行是做狄利克雷前缀和求 g 
		for(int i=1;i<=cnt;i++) x=b[mp[m/a[i].fi]],ans=(ans+a[i].se%mod*x%mod*x)%mod;//统计答案部分 
		m%=mod;ans=(ans+m*m)%mod;cout<<ans<<"\n";//加上 (n-1)*(n-1) 
		for(int i=1;i<=t;i++) g[i].clear();
	}
	return 0;
}

$\color{lightblue}{\texttt{ABC331G. Collect Them All}}$#

$\text{link}$ 。提示：多项式，$\min-\max$ 反演。

$\texttt{solution}$

锐评：出题人只会 $\log^2$ 太不牛了！既然出了就得会但 $\log$ 啊。而且官方题解写的一坨屎，太复杂了（

这题的有个小套路是参考P5860，推荐同时练习。

前置知识：多项式理论（要会多项式 $\exp$），概率期望，$\min-\max$ 反演。

分析复杂度时默认 $n,m$ 同阶。

---

考虑设第 $i$ 个颜色出现的最早时间为 $t_i$，则要求 $E(\max(t_i))$

发现 $\min$ 比 $\max$ 好求，进行 $\min-\max$ 反演，令 $S=\{a_1,a_2,\dots,a_m\}$：

$E(\max(t_i))=\sum\limits_{T\subset S,T\neq \varnothing} (-1)^{|T|+1} E(\min(T))$

考察 $E(\min(T))$，发现一个位置的颜色属于 $T$ 的概率为 $P(x)=\dfrac{\sum\limits_{x\in T} x}{n}$，由于概率期望互为倒数，于是 $E(\min(T))=\dfrac{n}{\sum\limits_{x\in T} x}$

于是 $E(\max(t_i))=n\times \sum\limits_{T\subset S,T\neq \varnothing} \dfrac{(-1)^{|T|+1}}{\sum\limits_{x\in T} x}$

---

这时发现分母部分是和的倒数，难刻画，考虑剥离。

考虑 $\forall s$，求 $f_s=\sum\limits_{\substack{\sum\limits_{x\in T} x=s \\ T\subset S,T\neq \varnothing }}(-1)^{|T|+1}$，$E(\max(t_i))=n\sum\limits_{s=1}^n\dfrac{f_s}{s}$

这东西先考虑朴素 dp：设 $F_{i,j}$ 表示 $\sum\limits_{\substack{\sum\limits_{x\in T} x=j \\ T\subset \{1,2,\dots ,i\}}}(-1)^{|T|+1}$，则有转移：

$F_{i,j}=F_{i-1,j}-F_{i-1,j-a_i}$，初值为 $F_{0,0}=-1$，欲 $\forall s$ 求 $F_{n,s}$

考虑套路性的设 $F_i(x)=\sum\limits_{j\ge 0}F_{i,j}x^j$，则 $F_{i}=(1-x^{a_i})F_{i-1}$

于是 $F_{n}=-\prod\limits_{i=1}^m(1-x^{a_i})$，此时大部分人都会分治 $\text{NTT}$ 做到 $O(n\log^2n)$。

考虑求 $\prod\limits_{i=1}^m(1-x^{a_i})$，限制条件为 $a_i\ge 1,\sum a_i=n$，记 $a_i=v$ 的有 $c_v$ 个，进行 $\ln-\exp$：

$\prod\limits_{i=1}^m(1-x^{a_i})=\exp(\sum\limits_{i=1}^m\ln (1-x^{a_i}))=\exp(-\sum\limits_{v=1}^nc_v\sum\limits_{j=1}^{n/v}\dfrac{x^{vj}}{j})$

里面直接暴力算即可，套多项式 $\exp$，复杂度为 $O(n\log n)$，注意不要漏 $F$ 前的负号和前面 $n$ 的系数。

$\texttt{code}$

#include<bits/stdc++.h>
#define fr(x) freopen(#x".in","r",stdin);freopen(#x".out","w",stdout);
using namespace std;
const int mod=998244353,N=8e5+5;
int n,m,a[N],b[N],c[N],I[N],w[N],mmax,ans;
inline int rd()
{
    int x=0,zf=1;
    char ch=getchar();
    while(ch<'0'||ch>'9') (ch=='-')and(zf=-1),ch=getchar();
    while(ch>='0'&&ch<='9') x=x*10+ch-'0',ch=getchar();
    return x*zf;
}
inline void wr(int x)
{
    if(x==0) return putchar('0'),putchar(' '),void();
    int num[35],len=0;
    while(x) num[++len]=x%10,x/=10;
    for(int i=len;i>=1;i--) putchar(num[i]+'0');
    putchar(' ');
}
inline int bger(int x){return x|=x>>1,x|=x>>2,x|=x>>4,x|=x>>8,x|=x>>16,x+1;}
inline int md(int x){return x>=mod?x-mod:x;}
inline int ksm(int x,int p){int s=1;for(;p;(p&1)&&(s=1ll*s*x%mod),x=1ll*x*x%mod,p>>=1);return s;}
inline void dao(int *a,int n){for(int i=1;i<n;i++) a[i-1]=1ll*i*a[i]%mod;a[n-1]=0;}
inline void ji(int *a,int n){for(int i=n-1;i>=1;i--) a[i]=1ll*ksm(i,mod-2)*a[i-1]%mod;a[0]=0;}
inline void init(int mmax)
{
	for(int i=1,j,k;i<mmax;i<<=1)
		for(w[j=i]=1,k=ksm(3,(mod-1)/(i<<1)),j++;j<(i<<1);j++)
			w[j]=1ll*w[j-1]*k%mod;
}
inline void DNT(int *a,int mmax)
{
	for(int i,j,k=mmax>>1,L,*W,*x,*y,z;k;k>>=1)
		for(L=k<<1,i=0;i<mmax;i+=L)
			for(j=0,W=w+k,x=a+i,y=x+k;j<k;j++,W++,x++,y++)
				*y=1ll*(*x+mod-(z=*y))* *W%mod,*x=md(*x+z);
}
inline void IDNT(int *a,int mmax)
{
	for(int i,j,k=1,L,*W,*x,*y,z;k<mmax;k<<=1)
		for(L=k<<1,i=0;i<mmax;i+=L)
			for(j=0,W=w+k,x=a+i,y=x+k;j<k;j++,W++,x++,y++)
				z=1ll* *W* *y%mod,*y=md(*x+mod-z),*x=md(*x+z);
	reverse(a+1,a+mmax);
	for(int inv=ksm(mmax,mod-2),i=0;i<mmax;i++) a[i]=1ll*a[i]*inv%mod;
}
inline void NTT(int *a,int *b,int n,int m)
{
	mmax=bger(n+m);init(mmax);
	DNT(a,mmax);DNT(b,mmax);
	for(int i=0;i<mmax;i++) a[i]=1ll*a[i]*b[i]%mod;
	IDNT(a,mmax);
}
void INV(int num,int *a,int *b)
{
	if(num==1) return b[0]=ksm(a[0],mod-2),void();
	INV((num+1)>>1,a,b);
	int mmax=bger(num<<1);init(mmax);
	static int c[N];
	for(int i=0;i<num;i++) c[i]=a[i];for(int i=num;i<mmax;i++) c[i]=0;
	DNT(c,mmax);DNT(b,mmax);
	for(int i=0;i<mmax;i++) b[i]=1ll*(2-1ll*c[i]*b[i]%mod+mod)%mod*b[i]%mod;
	IDNT(b,mmax);
	for(int i=num;i<mmax;i++) b[i]=0;
}
inline void Ln(int *a,int n){static int b[N];for(int i=0;i<bger(n<<1);i++) b[i]=0;INV(n,a,b);dao(a,n);NTT(a,b,n,n);ji(a,n);for(int i=n;i<bger(n<<1);i++) a[i]=0;}
inline void Exp(int *a,int *b,int n)
{
	if(n==1) return b[0]=1,void();
	Exp(a,b,(n+1)>>1);static int c[N];for(int i=0;i<bger(n<<1);i++) c[i]=0;
	for(int i=0;i<n;i++) c[i]=b[i];Ln(c,n);
	for(int i=0;i<n;i++) c[i]=md(mod-c[i]+a[i]);c[0]=md(c[0]+1);
	NTT(b,c,n,n);for(int i=n;i<bger(n<<1);i++) b[i]=0;
}
int main()
{
	n=rd(),m=rd();for(int i=1;i<=m;i++) c[rd()]++;
	I[1]=1;for(int i=2;i<=n;i++) I[i]=mod-1ll*I[mod%i]*(mod/i)%mod;
	for(int i=1;i<=n;i++) for(int j=1;j<=n/i;j++) a[i*j]=(a[i*j]+1ll*c[i]*I[j])%mod;
	for(int i=1;i<=n;i++) a[i]=md(mod-a[i]);Exp(a,b,n+1);
	for(int i=1;i<=n;i++) ans=(ans+1ll*b[i]*I[i])%mod;
    return wr(1ll*(mod-n)*ans%mod),0;
}

$\color{lightblue}{\texttt{Snuke21 E. Tournament}}$#

$\text{link}$ 。提示：竞赛图缩点后的性质。

$\texttt{solution}$

前置知识：竞赛图强联通分量性质，只要用到本文的结论 $1$。

竞赛图强连通缩点后的 $\texttt{DAG}$ 呈链状, 前面的所有点向后面的所有点连边。

通常性的，我们考虑应考虑前 $i$ 个强连通分量，于是我们对所有图缩点后对这样的划线计数：

假设某条线前面有 $1\le i\le n$ 个点（注意不是强联通分量），后面有 $n-i$ 个点，则这个竞赛图可以拆成：

• 前 $i$ 个点组成的竞赛子图

• 后 $n-i$ 个点组成的竞赛子图

• 所有前 $i$ 个点向所有后 $n-i$ 个点连的一条有向边

于是我们要把 $n$ 个点划分成大小为 $i,n-i$ 两个集合，两个集合内的点要以某种方式连成竞赛图，而后按照第三个条件再连边。

记 $s_i=\binom{i}{2}$，则方案数为 $\dbinom{n}{i}2^{s_i}2^{s_{n-i}}$，于是答案为 $\sum\limits_{i=1}^n \dbinom{n}{i}2^{s_i}2^{s_{n-i}}$

复杂度 $O(n\log n)\sim O(n)$ 不等，取决于实现的精细（我代码是带 $\log$ 的）

---

此题很难低于 $O(n)$ 的原因：

由于 $s_is_j+ij=s_{i+j}$，于是 $2^{s_i}2^{s_{n-i}}=2^{n-i(n-i)}=2^{n^2-ni-i^2}$。此时幂次出现了平方而且要求和，是经典不太可做问题。

$\texttt{code}$

#include<bits/stdc++.h>
#define LL long long
#define fr(x) freopen(#x".in","r",stdin);freopen(#x".out","w",stdout);
using namespace std;
const int N=1e5+5,mod=1e9+7;
int n,ans,I[N];
inline int md(int x){return x>=mod?x-mod:x;}
inline int ksm(int x,int p){int s=1;for(;p;(p&1)&&(s=1ll*s*x%mod),x=1ll*x*x%mod,p>>=1);return s;}
int main()
{
	ios::sync_with_stdio(0);cin.tie(0);cout.tie(0);cin>>n;
	I[1]=1;for(int i=2;i<=n;i++) I[i]=mod-1ll*I[mod%i]*(mod/i)%mod;
	for(int i=1,s=n;i<=n;s=1ll*s*(n-i)%mod*I[i+1]%mod,i++) ans=(ans+1ll*s*ksm(2,(1ll*i*(i-1)+1ll*(n-i)*(n-i-1))/2%(mod-1)))%mod;
	return cout<<ans,0;
}

$\color{lightblue}{\texttt{Snuke Density}}$#

$\text{link}$ 。提示：分析 $v_2$。

$\texttt{solution}$

硬生生把一个困难的蓝想了黑的做法。（下面讲的是蓝的思维难度的做法）

前置知识：Kummer 定理，勒让德定理。

显然特判 $c<\max(a,b)$ 和 $c\ge a+b$ 的情况，现在情况是 $a,b\le c<a+b$

考虑变形：$\dfrac{c!}{a!b!}=\dbinom{a+b}{a}\times \left(\dfrac{(a+b)!}{c!}\right)^{-1}$

若它是整数，根据 Kummer 定理，$v_2\left(\dbinom{a+b}{a}\right)$ 等于 $a + b$ 在 $2$ 进制下进位的次数。

于是根据数据范围有 $v_2\left(\dbinom{a+b}{a}\right)\le 37$。

于是 $v_2\left(\dfrac{(a+b)!}{c!}\right)\le 37\Rightarrow \sum\limits_{i\ge 1} \left\lfloor\dfrac{a+b}{2^i}\right\rfloor-\left\lfloor\dfrac{c}{2^i}\right\rfloor\le 37$

于是 $\left\lfloor\dfrac{a+b}{2}\right\rfloor-\left\lfloor\dfrac{c}{2}\right\rfloor\le 37\Rightarrow 37\ge \left\lfloor\dfrac{a+b}{2}\right\rfloor-\left\lfloor\dfrac{c}{2}\right\rfloor\ge \dfrac{a+b}{2}-1-\dfrac{c}{2}\Rightarrow a+b-c\le 2\times 38=76$

于是 $0<a+b-c\le 76$，否则不是整数。

考虑若它不是整数，则存在素数 $p$ 使得 $v_p\left(\dfrac{c!}{a!b!}\right)<0$，即 $v_p\left(\dbinom{a+b}{a}\times \left(\dfrac{(a+b)!}{c!}\right)^{-1}\right)<0$。

于是 $p\mid \dfrac{(a+b)!}{c!}$，于是 $p$ 必为 $(c,a+b]$ 中一个数的素因子。由于 $0<a+b-c\le 76$，直接枚举而后分解素因子即可判断。

瓶颈在于分解素因子，设其复杂度为 $T(V)$，则总复杂度为 $O(\log V(T(V)+\omega(V)\log V))=O(T(V)\log V+\log^3V)$

其中 $V$ 为 $\max\{a,b,c\}$，而最外层的 $\log$ 为 $76$，显然由分析这时数始终是 $\log V$ 级别的。

如果用 pollard-rho 则这题能做 $V=10^{18}$。那个黑的想法就不讲了，太蠢了。

$\texttt{code}$

#include<bits/stdc++.h>
#define LL long long
#define fr(x) freopen(#x".in","r",stdin);freopen(#x".out","w",stdout);
using namespace std;
const int N=1e6+5;
LL a,b,c;
inline bool chk(LL p){LL cnt=0;for(LL i=p;i<=c;i*=p) cnt+=c/i-a/i-b/i;return cnt>=0;}
int main()
{
	ios::sync_with_stdio(0);cin.tie(0);cout.tie(0);cin>>a>>b>>c;
	if(c>=a+b) return cout<<"YES",0;if(max(a,b)>c||a+b>c+80) return cout<<"NO",0;
	for(LL i=c+1;i<=a+b;i++)
	{
		LL x=i;
		for(LL j=2;j*j<=x;j++) if(x%j==0)
		{
			while(x%j==0) x/=j;
			if(!chk(j)) return cout<<"NO",0;
		}if((x^1)&&!chk(x)) return cout<<"NO",0;
	}
	return cout<<"YES",0;
}

$\color{lightblue}{\texttt{Tenka1 F. ModularPowerEquation!!}}$#

$\text{link}$ 。提示：幂塔。

$\texttt{solution}$

前置知识：扩展欧拉定理，幂塔。前置题目：P4139，一定要先做这个！

沿用记号：记 $a\uparrow\uparrow b=\begin{matrix} \underbrace{a^{a^{a^{a\dots}}}}\\b \end{matrix}$

想到幂塔这题就容易多了。感觉第一篇题解是没想清楚欧拉定理的细节写的，那个对较小数的处理太粗糙了！感觉这样直接求比他的递归更容易想到啊。

由前置题目推广：记 $a_0=1,a_n=A^{a_{n-1}},b_n=a_n\bmod m$，则 $\exists N$，使得 $\forall n\ge N$，$b_n$ 为常数。

于是取充分大的 $n$，则 $A\uparrow\uparrow n$ 为一组解。（你可以想象成 $n\to +\infty$ 理解）

但是 $R=a\uparrow\uparrow n$ 太大了，考虑 $r$ 为一组解，想要：$A^{R}\equiv A^{r}\pmod m,R\equiv r\pmod m$。

不妨设 $R>\varphi(m)$，于是由扩展欧拉可以变成构造：$r>\varphi(m),R\equiv r\pmod {\varphi(m)},R\equiv r\pmod {m}$。

记 $L=\text{lcm}(m,\varphi(m))$，则我们容易构造出 $r=R\bmod L+L$ 为满足条件且 $\le 2\times 10^{18}$ 的解。

于是要求 $R\bmod m,R\bmod \varphi(m)$，然后 exgcd 合并。

而求这个显然就转换为了前置题目，直接套上即可，复杂度 $O(Q\sqrt{m}\log m)$。注意 exgcd 时要用 __int128。

$\texttt{code}$

#include<bits/stdc++.h>
#define LL long long
#define bll __int128
#define fr(x) freopen(#x".in","r",stdin);freopen(#x".out","w",stdout);
using namespace std;
LL T,a,mod,ph;
inline LL phi(LL x)
{
	LL s=x;
	for(LL i=2;i*i<=x;i++)
	{
		if(x%i==0) s=s/i*(i-1);
		for(;x%i==0;x/=i);
	}
	if(x>1) s=s/x*(x-1);return s;
}
inline LL ksm(LL x,LL p,const LL mod){LL s=1;for(;p;(p&1)&&(s=1ll*s*x%mod),x=1ll*x*x%mod,p>>=1);return s;}
LL dfs(LL mod)
{
	if(mod==1) return 0;LL t=phi(mod);
	return ksm(a,dfs(t)+t,mod);
}//前置题目的过程 
void exgcd(LL a,LL b,bll &x,bll &y)
{
	if(!b) return x=1,y=0,void();
	exgcd(b,a%b,x,y);bll t=x-(a/b)*y;x=y;y=t;
}
signed main()
{
	ios::sync_with_stdio(0);cin.tie(0);cout.tie(0);cin>>T;
	while(T--)
	{
		cin>>a>>mod;ph=phi(mod);LL x=dfs(mod),y=dfs(ph);bll x0,y0;//分别求解 mod m,mod phi(m) 
		LL X,L=mod/__gcd(mod,ph)*ph,C=(y-x)/__gcd(mod,ph);exgcd(mod,ph,x0,y0);//exgcd合并,记得__int128! 
		X=((x0%L+L)%L*C%L*mod%L+x)%L;cout<<X+L<<"\n";//记得+L！
	}
	return 0;
}

$\color{lightblue}{\texttt{LG P9970. 套娃}}$#

$\text{link}$ 。提示：极小区间。

$\texttt{solution}$

前置知识：P4137 的在线单次 $O(\log n)$ 求区间 $\text{mex}$ 做法，CF1870E 的结论。

赛事做繁了，没冲出来。发现第二篇题解难理解，第一篇题解有个细节繁了，于是我结合了一下。除去主席树板子，代码非常短。

这篇题解是目前第一篇题解和第二篇的结合，由重合请见谅。

如果不想看结论证明直接忽略即可，没啥影响。

---

称 $[l,r]$ 是极小区间，当且仅当不存在 $[L,R]\varsubsetneq[l,r]$，$\text{mex}(l,r)=\text{mex}(L,R)$。则有结论：极小区间只有 $O(n)$ 个。

• 证明：设 $[l,r]$ 是极小区间，则显然 $a_l\neq a_r$，不妨设 $a_l>a_r$，则由于删掉端点 $\text{mex}$ 要变化，于是 $\text{mex}(l,r)>a_l>a_r$。若存在 $r_1>r$，$[l,r_1]$ 是极小区间，则 $\text{mex}(l,r)\ge a_l>a_{r_1}$，于是 $a_{r_1}$ 在 $[l,r]$ 中出现过。于是删去 $a_{r_1}$，$\text{mex}$ 不变。于是固定 $l$，$a_l>a_r$ 的情况只对应一个 $r$，所以只有 $O(n)$ 个了。

---

考虑如何求所有极小区间。如果直接按证明方法求是非常难写的。于是考虑巧妙方法。

设 $\text{mex}(l,r)=x$，则称 $[l,r]$ 为 $\text{mex}_x$ 区间。

考虑一个 $\text{mex}_x$ 的极小区间，同样不妨设 $a_l>a_r$，则由于极小性，于是 $a_r$ 在 $(l,r)$ 中没有出现。

考虑删去 $a_l$ 之后，$\text{mex}$ 变为 $a_l$，不妨设 $\text{mex}_{a_l}$ 区间 $[l+1,r]$ 对应的极小子区间为 $[L,R]$，则 $a_r$ 一定在 $[L,R]$ 中出现，于是 $R=r$。

• 这说明：$\text{mex}_x$ 区间必定为一个 $\text{mex}_{t}$ 区间向一端扩展到第一个数 $t$ 得到。其中 $x>t$。

---

考虑从 $x=0\to n+1$ 依次求出所有 $\text{mex}_x$ 极小区间。对于每个 $x$ 维护 $\text{mex}_x$ 极小区间的 vector。

每次先把所有 $\text{mex}_{x-1}$ 区间进行如上扩展，设一个扩展完后 $\text{mex}=y$，则把新区间丢到 $y$ 的 vector 里。这里求扩展完的 $\text{mex}$ 用上面说的单次 $O(\log n)$ 的方法。

这时候所有 $\text{mex}_x$ 极小区间都在 $x$ 的 vector 里了，但注意扩展完的不一定都是极小的，于是排除掉即可。就不多不少的求出了 $\text{mex}_x$ 极小区间，一直做下去即可。记得初始化极小 $\text{mex}_{0/1}$ 区间。

由于极小区间总共只有 $O(n)$ 个，乘上求区间 $\text{mex}$ 的 $\log$，于是复杂度为 $O(n\log n)$。

---

求出所有极小区间后，考虑所有对应 $\text{mex}_x$ 的极小子区间 $[l,r]$ 的大区间的形态。

设 $l$ 左侧第一个 $x$ 的位置为 $L-1$，$r$ 右侧第一个 $x$ 的位置为 $R+1$。

则所有对应的大区间为：左端点在 $[L,l]$，右端点在 $[r,R]$ 的所有区间。于是 $\forall len\in [r-l+1,R-L+1]$，存在长为 $len$ 的区间 $\text{mex}=x$。

于是问题就转化成了：维护 $n$ 个集合，区间插入一个数，最终对所有集合求 $\text{mex}$。把插入操作差分，用一个 set 动态维护 $\text{mex}$ 即可。具体看代码。

$\texttt{code}$

#include<bits/stdc++.h>
#define LL long long
#define P pair<int,int>
#define fi first
#define se second
#define fr(x) freopen(#x".in","r",stdin);freopen(#x".out","w",stdout);
using namespace std;
const int N=1e5+5;
int n,V,a[N],cnt[N],tot,rt[N];
vector<int>g[N],ad[N],dl[N];vector<P>h[N];
namespace MEX
{
	struct node{int ls,rs,x;}b[N*25];
	void build(int l,int r,int &wz)
	{
		b[wz=++tot]={0,0,0};if(l==r) return;
		int mid=(l+r)>>1;build(l,mid,b[wz].ls);build(mid+1,r,b[wz].rs);
	}
	void updata(int l,int r,int &wz,int wz1,int x,int y)
	{
		b[wz=++tot]=b[wz1];if(l==r) return b[wz].x=y,void();
		int mid=(l+r)>>1;
		if(x<=mid) updata(l,mid,b[wz].ls,b[wz1].ls,x,y);
		else updata(mid+1,r,b[wz].rs,b[wz1].rs,x,y);
		b[wz].x=min(b[b[wz].ls].x,b[b[wz].rs].x);
	}
	int query(int l,int r,int wz,int x)
	{
		if(l==r) return l;int mid=(l+r)>>1;
		if(b[b[wz].ls].x<x) return query(l,mid,b[wz].ls,x);
		return query(mid+1,r,b[wz].rs,x);
	}
	inline int que(int l,int r){return query(0,V,rt[r],l);}
}using MEX::que;
int vis[1005][1005];
inline void add(int l,int r,int L,int R,int x){ad[L-r+1].push_back(x);dl[R-l+2].push_back(x);}
inline void getans()
{
	set<int>S;for(int i=0;i<=n;i++) cnt[i]=0,S.insert(i);
	for(int i=1;i<=n;i++)
	{
		for(int j:ad[i]) if(!cnt[j]++) S.erase(j);
		for(int j:dl[i]) if(!--cnt[j]) S.insert(j);cout<<*S.begin()<<" ";
	}
}
int main()
{
	ios::sync_with_stdio(0);cin.tie(0);cout.tie(0);cin>>n;
	V=n+3;for(int i=0;i<=V;i++) g[i].push_back(0);
	for(int i=1;i<=n;i++) cin>>a[i],g[a[i]].push_back(i);
	MEX::build(1,V,rt[0]);for(int i=1;i<=n;i++) MEX::updata(0,V,rt[i],rt[i-1],a[i],i);
	for(int i=0;i<=V;i++) g[i].push_back(n+1);
	for(int i=1;i<=n;i++) a[i]?h[0].push_back({i,i}):h[1].push_back({i,i});
	for(int i=1;i<=V;i++)
	{
		for(auto [l,r]:h[i-1])
		{
			#define all g[i-1].begin(),g[i-1].end()
			int L=*(--lower_bound(all,l)),R=*upper_bound(all,r);
			if(L) h[que(L,r)].push_back({L,r});
			if(R<=n) h[que(l,R)].push_back({l,R});
		}sort(h[i].begin(),h[i].end(),[](P x,P y){return x.fi==y.fi?x.se<y.se:x.fi>y.fi;});
		vector<P>G;int las=2e9;
		for(auto [l,r]:h[i]) if(las>r) G.push_back({l,r}),las=r;swap(G,h[i]);
	}
	for(int i=0;i<=V;i++)
		for(auto [l,r]:h[i])
			#define all g[i].begin(),g[i].end()
			add(*(--lower_bound(all,l))+1,l,r,*upper_bound(all,r)-1,i);
	return getans(),0;
}

$\color{lightblue}{\texttt{LG P9291. Quick sort}}$#

$\text{link}$ 。提示：逆操作。

$\texttt{solution}$

人类智慧题。需要一些矩阵乘法的知识辅助理解。

首先 $O(n\log n)$ 次操作时容易的，按顺序把 $n\to 1$ 依次归位即可。每个数归位由于每次距离减半于是是 $\log n$ 的。

这时候随机一下会不会很优秀？但是有佬证明了这个算法期望下依然是 $O(n\log n)$ 次的。不足以通过。

---

到了人类智慧部分了，看这个结构本来不是很好逆，但是依然要逆。

不妨设初始排列为 $p$，$1\sim n$ 的排列为 $I$。操作为 $f_1,f_2,\dots,f_k$，则 $p\circ f_1\circ f_2\circ\dots\circ f_k=I$。

考虑左右求逆。操作本质为矩阵乘法，于是类似的做。同时 $1\sim n$ 的排列可以看做单位矩阵。

于是 $f_k^{-1}\circ \dots \circ f_2^{-1}\circ f_1^{-1}\circ p^{-1}=I$。由于矩乘中 $AB=I\Leftrightarrow BA=I$，于是 $p^{-1}\circ f_k^{-1}\circ \dots \circ f_2^{-1}\circ f_1^{-1}=I$。

• 令逆操作 $f^{-1}=g$，相当于对逆排列 $p'=p^{-1}$ 进行编号 $k\to 1$ 的逆操作，最终要变成 $1\sim n$ 的排列。

---

同样的，我们依然按顺序把 $n\to 1$ 依次归位。然后把操作逆序输出。

观察对 $[1,2i]$ 逆操作，则位置 $i$ 上的数变到位置 $2i$ 了。同时 $\forall \frac{i}{2}<w<i$ 的位置 $w$，对 $[2w-i+1,i]$ 逆操作即可把位置 $w$ 上的数移动到位置 $i$ 上。

设 $i$ 在位置 $w\le i$。如果 $w\neq i$，我们先把 $w$ 倍增到 $(\frac{i}{2},i]$ 范围，而后进行一次逆操作即可。次数为 $\log_2(i/w)\le \log_2 i-\log_2 w+1$。

看似没有优化？但是不妨先进行随机打乱，此时假设 $p$ 在 $[1,i]$ 中随机选取，则 $E(\log _2(w))=\dfrac{\log_2(i!)}{i}\sim \log_2\left(\sqrt[2i]{2\pi i}\times \dfrac{i}{e}\right)=\log_2i-\log_2(e)+C$。

其中 $C>0$ 是极小的余项，可以用函数图像感受一下。近似部分用了 Stirling 公式估计阶乘。

于是 $\log_2 i-\log_2 w+1\sim \log_2e+1$，于是总次数估计为 $2n\sim 3n$ 次。足以通过。事实上次数上界设为 $6000$ 也能飞快就出结果。

---

关于随机打乱：方法是随机选常数个区间进行逆操作。直接对 $p'$ 这样做即可，还原为 $1\sim n$ 后，最后逆序输出时这样显然不影响正确性。

注意最开始是对逆排列进行上述操作！具体细节看代码，代码很短。

$\texttt{code}$

#include<bits/stdc++.h>
#define P pair<int,int>
#define fi first
#define se second
#define LL long long
#define fr(x) freopen(#x".in","r",stdin);freopen(#x".out","w",stdout);
using namespace std;
mt19937 rnd(time(0));
const int N=3e3+5,M=1.5e4+5;
int n,a[N],b[N],c[N],tot;P ans[M];
inline void rep(int l,int r)
{
	ans[++tot]={l,r};int t=l;
	for(int i=l;i<=r;i++) c[i]=b[i];
	for(int i=l+1;i<=r;i+=2) b[i]=c[t++];
	for(int i=l;i<=r;i+=2) b[i]=c[t++];
}
int main()
{
	ios::sync_with_stdio(0);cin.tie(0);cout.tie(0);cin>>n;
	for(int i=1,x;i<=n;i++) cin>>x,a[x]=i;
	do
	{
		memcpy(b,a,sizeof(b));tot=0;
		for(int i=1;i<=52;i++)
		{
			int l=rnd()%n+1,r=rnd()%n+1;
			if(l>r) swap(l,r);rep(l,r);
		}
		for(int i=n;i;i--) if(b[i]^i)
		{
			int w=i;while(b[w]^i) w--;
			while((w<<1)<=i) rep(1,w<<=1);
			if(w^i) rep(2*w-i+1,i);
		}
	}while(tot>7500);cout<<tot<<"\n";
	for(int i=tot;i;i--) cout<<ans[i].fi<<" "<<ans[i].se<<"\n";
	return 0;
}

$\color{lightblue}{\texttt{loj 6575. LJJ 学二项式定理 二}}$#

$\text{link}$ 。提示：$\texttt{GF}$。

$\texttt{solution}$

前置知识：齐次线性递推。

注意到瓶颈在于组合数上标有 $+\ i$。

考虑 $[x^n]\dfrac{1}{(1-x)^{k+1}}=\dbinom{n+k}{k}$，于是容易构造出答案为：$[x^n]\sum\limits_{i\ge 0}\dfrac{x^{i(m-1)}}{(1-x)^{im+1}}$.

$[x^n]\sum\limits_{i\ge 0}\dfrac{x^{i(m-1)}}{(1-x)^{im+1}}=[x^n]\frac{1}{1-x}\sum\limits_{i\ge 0}\left(\dfrac{x^{m-1}}{(1-x)^{m}}\right)^i=[x^n]\frac{1}{(1-x)(1-f(x))}\left(f(x)=\dfrac{x^{m-1}}{(1-x)^{m}}\right)=[x^n]\dfrac{(1-x)^{m}}{(1-x)((1-x)^{m}-x^{m-1})}$

直接上齐次递推中的 Bostan-mori 算法即可，复杂度 $O(m^2\log n)$ 或 $O(m\log m\log n)$，取决于多项式乘法的实现。

在 $m=5000,p=998244353$ 时需要 $\texttt{NTT}$ 来加速。否则超时。

一个细节就是最后的分母始终是 $1$，不需要求逆得出结果。还有不懂可以看代码。

$\texttt{code}$

#include<bits/stdc++.h>
#define LL long long
#define fr(x) freopen(#x".in","r",stdin);freopen(#x".out","w",stdout);
using namespace std;
const int N=4e4+5,mod=998244353;
LL n;int m,Mod,a[N],b[N],c[N],w[N],C[N/4][N/4];
inline int bger(int x){return x|=x>>1,x|=x>>2,x|=x>>4,x|=x>>8,x|=x>>16,x+1;}
inline int md(int x){return x>=Mod?x-Mod:x;}
inline int ksm(int x,int p){int s=1;for(;p;(p&1)&&(s=1ll*s*x%mod),x=1ll*x*x%mod,p>>=1);return s;}
inline void init(int mmax)
{
	for(int i=1,j,k;i<mmax;i<<=1)
		for(w[j=i]=1,k=ksm(3,(mod-1)/(i<<1)),j++;j<(i<<1);j++)
			w[j]=1ll*w[j-1]*k%mod;
}
inline void DNT(int *a,int mmax)
{
	for(int i,j,k=mmax>>1,L,*W,*x,*y,z;k;k>>=1)
		for(L=k<<1,i=0;i<mmax;i+=L)
			for(j=0,W=w+k,x=a+i,y=x+k;j<k;j++,W++,x++,y++)
				*y=1ll*(*x+mod-(z=*y))* *W%mod,*x=md(*x+z);
}
inline void IDNT(int *a,int mmax)
{
	for(int i,j,k=1,L,*W,*x,*y,z;k<mmax;k<<=1)
		for(L=k<<1,i=0;i<mmax;i+=L)
			for(j=0,W=w+k,x=a+i,y=x+k;j<k;j++,W++,x++,y++)
				z=1ll* *W* *y%mod,*y=md(*x+mod-z),*x=md(*x+z);
	reverse(a+1,a+mmax);
	for(int inv=ksm(mmax,mod-2),i=0;i<mmax;i++) a[i]=1ll*a[i]*inv%mod;
}
inline void mul(int *a,int *b,int n,int m)
{
	static int c[N];
	for(int i=0;i<=n;i++) for(int j=0;j<=m;j++) c[i+j]=(c[i+j]+1ll*a[i]*b[j])%Mod;
	for(int i=0;i<=n+m;i++) a[i]=c[i],c[i]=0;
}
inline void NTT(int *a,int *b,int n,int m)
{
	if(Mod^998244353) return mul(a,b,n,m);
	int mmax=bger(n+m);init(mmax);DNT(a,mmax);DNT(b,mmax);
	for(int i=0;i<mmax;i++) a[i]=1ll*a[i]*b[i]%mod;IDNT(a,mmax);
}
inline int genf(int *a,int *b,int n,int m,LL k)
{
	static int c[N],d[N];
	for(;k;k>>=1)
	{
		memset(c,0,sizeof(c));for(int i=0;i<=m;i++) c[i]=b[i];
		for(int i=1;i<=m;i+=2) c[i]=(Mod-c[i])%Mod;
		memset(d,0,sizeof(d));for(int i=0;i<=m;i++) d[i]=c[i];
		NTT(a,c,n,m);NTT(b,d,m,m);int j=0;
		for(int i=(k&1);i<=n+m;i+=2,j++) a[i/2]=a[i];n=j-1;j=0;
		for(int i=0;i<=2*m;i+=2,j++) b[i/2]=b[i];m=j-1;
		for(int i=n+1;i<=N-5;i++) a[i]=0;
		for(int i=m+1;i<=N-5;i++) b[i]=0;
	}return a[0];
}
int main()
{
	ios::sync_with_stdio(0);cin.tie(0);cout.tie(0);cin>>n>>m>>Mod;
	for(int i=0;i<=m;i++) for(int j=0;j<=i;j++) C[i][j]=!j?1:md(C[i-1][j]+C[i-1][j-1]);
	for(int i=0;i<=m;i++) a[i]=b[i]=i&1?(Mod-C[m][i]):C[m][i];b[m-1]=md(b[m-1]-1+Mod);
	for(int i=0;i<=m;i++) c[i+1]=md(Mod-b[i]);
	for(int i=0;i<=m+1;i++) b[i]=md(b[i]+c[i]);
	return cout<<genf(a,b,m,m+1,n),0;
}

$\color{lightblue}{\texttt{ATC tenka1 2019f. Banned X}}$#

$\text{link}$ 。提示：消 $0$，考虑前缀和，组合计数。

$\texttt{solution}$

第一个线性做法题解。下文规定若 $m<0$ 或 $n<m$，则 $\dbinom{n}{m}=0$。

先不考虑 $0$，设长度为 $m$ 的 $1,2$ 序列满足条件的方案数为 $f_m$，则答案为 $\sum\limits_{i=0}^n\dbinom{n}{i}f_m$。考虑线性求 $f_m$。

设总和为 $s$，分讨：

若 $s<X-1$，则数量为 $\sum\limits_{s=m}^{X-2} \dbinom{m}{s-m}$。

否则，若序列合法一定存在前缀和为 $X-1$。

首先总和要 $\ge X-1$，而又不存在为 $X$ 的前缀和，且序列中元素在 $\{1,2\}$ 中，于是存在。

特判 $m=0$，此时考虑 $0\le k\le m$ 位置的前缀和为 $X-1$，发现 $a_{k+1}=2$，又发现 $a_1=1$ 不满足条件，于是 $a_1=2$。

递推下去，于是 $a_{1,2,\cdots,m-k},a_{k+1,k+2,\cdots ,m}$ 均为 $2$，其他位置任意。

再分讨，若 $m-k\le k$，则对 $(m-k,k]$ 中填数方案计数，否则判断全填 $2$ 可不可行即可。

后者是容易的，前者是要 $2k-m$ 个数，和为 $x-1-2(m-k)$，简单计算后发现为 $\dbinom{2k-m}{X-1-m}$。

于是这时方案数为 $\sum\limits_{k=0}^m \dbinom{2k-m}{X-1-m}+[2\nmid X]\times [(m-1)/2\ge (X-1)/2]$。

设 $n,X$ 同阶，复杂度 $O(n^2)$。代码。

---

接下来考虑线性求 $\sum\limits_{s=m}^{X-2} \dbinom{m}{s-m}=\sum\limits_{i=0}^{X-2-m} \dbinom{m}{i}$，这是容易的。先预处理阶乘逆元。

$\sum\limits_{i=0}^{X-2-m} \dbinom{m}{i}=\sum\limits_{i=0}^{X-2-(m-1)} \left(\dbinom{m-1}{i}+\dbinom{m-1}{i-1}\right)-\dbinom{m}{X-m+1}=2\sum\limits_{i=0}^{X-2-(m-1)} \dbinom{m-1}{i}-\dbinom{m-1}{X-m+1}-\dbinom{m}{X-m+1}$。就能每次 $O(1)$ 递推啦。

---

最后线性求 $\sum\limits_{k=0}^m \dbinom{2k-m}{X-1-m}$。第一步思路来源于官方题解，但最后式子比官方题解简单。

$\begin{aligned} \sum\limits_{k=0}^m \dbinom{2k-m}{X-1-m}&=\dfrac{1}{2}\left(\sum\limits_{k=0}^m \dbinom{2k-m}{X-1-m}+\dbinom{2k-m}{X-1-m}\right)\\ &=\dfrac{1}{2}\left(\sum\limits_{k=0}^m \dbinom{2k-m}{X-1-m}+\dbinom{2k-(m+1)}{X-1-m}+\dbinom{2k-(m+1)}{X-1-(m+1)}\right)\\ &=\dfrac{1}{2}\left(\sum\limits_{k=0}^{2m} \dbinom{k-m}{X-1-m}+\sum\limits_{k=0}^m\dbinom{2k-(m+1)}{X-1-(m+1)}\right)\\ &=\dfrac{1}{2}\left(\dbinom{m+1}{X-m}+\sum\limits_{k=0}^{m+1}\dbinom{2k-(m+1)}{X-1-(m+1)}-\dbinom{m+1}{X-1-(m+1)}\right) \end{aligned}$

于是 $2\sum\limits_{k=0}^m \dbinom{2k-m}{X-1-m}+\dbinom{m+1}{X-1-(m+1)}-\dbinom{m+1}{X-m}=\sum\limits_{k=0}^{m+1}\dbinom{2k-(m+1)}{X-1-(m+1)}$。一样预处理阶乘线性递推即可。

最终复杂度 $O(n)$。

$\texttt{code}$

#include<bits/stdc++.h>
#define LL long long
#define fr(x) freopen(#x".in","r",stdin);freopen(#x".out","w",stdout);
using namespace std;
const int N=1e5+5,M=N-5,mod=998244353;
int n,X,s,S,jc[N],inv[N],f[N];
inline int md(int x){return x>=mod?x-mod:x;}
inline int ksm(int x,int p){int s=1;for(;p;(p&1)&&(s=1ll*s*x%mod),x=1ll*x*x%mod,p>>=1);return s;}
inline int C(int n,int m){return n<m?0:1ll*jc[n]*inv[m]%mod*inv[n-m]%mod;}
inline int sol(int m)
{
	if(!m) return 1;int ans=0;
	if(m==1) for(int i=0;i<X-1-m;i++) s=md(s+C(m,i));
	else s=md((2ll*s-C(m,X-m-1)-C(m-1,X-m-1))%mod+mod);ans=md(ans+s);
	if(X-1>=m)
	{
		if(m==1) for(int i=0;i<=m;i++) S=md(S+C(2*i-m,X-1-m));
		ans=md(ans+S);if(m+1<=X-1) S=md((2ll*S-C(m+1,X-m)+C(m+1,X-m-2))%mod+mod);
	}
	if(X&1) ans=md(ans+((m-1)/2>=(X-1)/2));return ans;
}
int main()
{
	ios::sync_with_stdio(0);cin.tie(0);cout.tie(0);cin>>n>>X;
    jc[0]=1;for(int i=1;i<=M;i++) jc[i]=1ll*jc[i-1]*i%mod;
    inv[M]=ksm(jc[M],mod-2);for(int i=M-1;i>=0;i--) inv[i]=1ll*inv[i+1]*(i+1)%mod;
	for(int i=0;i<=n;i++) f[i]=sol(i);int ans=0;
	for(int i=0;i<=n;i++) ans=(ans+1ll*C(n,i)*f[i])%mod;
	return cout<<ans,0;
}

$\color{lightblue}{\texttt{ATC tenka1 2019e. Polynomial Divisors}}$#

$\text{link}$ 。提示：拉格朗日定理。

$\texttt{solution}$

前置知识：拉格朗日定理。

设 $g=\gcd\limits_{i=0}^n a_i$，则 $|g|$ 的所有素因子都满足条件。

考虑剩下的，若 $p$ 为满足条件的素数，则多项式 $A$ 必有因式 $\prod\limits_{i=0}^{p-1}(x-i)\equiv x^p-x\pmod p$。同余这步可以参考前置知识中文章。

于是得出 $\forall k\sum\limits_{i=0}^n [i\equiv k\pmod {p-1}]a_i=0$。

对于每个素数判一下即可，由拉格朗日定理得 $p\le n$。

复杂度 $O(\dfrac{n^2}{\ln n})$，跑不满。

$\texttt{code}$

//洛谷 AT_tenka1_2019_e
//https://www.luogu.com.cn/problem/AT_tenka1_2019_e
#include<bits/stdc++.h>
#define LL long long
#define fr(x) freopen(#x".in","r",stdin);freopen(#x".out","w",stdout);
using namespace std;
const int N=1e4+5;
int n,g,a[N],b[N],pr[N];bool v[N];
basic_string<int>ans;
inline void init(int M)
{
	for(int i=2;i<=M;i++)
	{
		if(!v[i]) pr[++pr[0]]=i;
		for(int j=1;j<=pr[0]&&i*pr[j]<=M;j++)
		{
			v[i*pr[j]]=1;
			if(i%pr[j]==0) break;
		}
	}
}
int main()
{
	ios::sync_with_stdio(0);cin.tie(0);cout.tie(0);cin>>n;
	for(int i=n;~i;i--) cin>>a[i],g=__gcd(g,a[i]);g=abs(g);
	for(int i=2;i*i<=g;i++) if(!(g%i)){ans+=i;while(!(g%i)) g/=i;}
	if(g^1) ans+=g;init(n);
	for(int i=1;i<=pr[0];i++)
	{
		int p=pr[i];bool ok=1;if(a[0]%p) continue;
		for(int j=0;j<p-1;j++) b[j]=0;
		for(int j=0;j<=n;j++) b[j%(p-1)]=(b[j%(p-1)]+a[j]%p+p)%p;
		for(int j=0;j<p-1;j++) if(b[j]){ok=0;break;}if(ok) ans+=p;
	}sort(ans.begin(),ans.end());ans.erase(unique(ans.begin(),ans.end()),ans.end());
	for(int i:ans) cout<<i<<"\n";
	return 0;
}

$\color{lightblue}{\texttt{P9443. Hand of the Free Marked}}$#

$\text{link}$ 。提示：枚举计数。

$\texttt{solution}$

下文计算复杂度时设 $k,m$ 同阶。

枚举每种样式选了多少个，设当前考虑的情况为样式 $1\sim m$ 分别选了 $c_{1,2,\cdots, m}$ 个，考虑此时猜中的概率。

先计算选出这种情况的方案数。为 $s=\prod\limits_{i=1}^m \dbinom{a_i}{c_i}$。

考虑根据桌面上牌表示的信息情况总数。

前 $k$ 张有 $(k-1)!$ 种排列方式，枚举倒置的牌，计算得：

$(k-1)!\times \sum\limits_{i=1}^ms\times \dfrac{\dbinom{a_i}{c_i-1}}{\dbinom{a_i}{c_i}}=(k-1)!\times \sum\limits_{i=1}^ms\times \dfrac{c_i}{a_i-c_i+1}$。

于是猜中的概率为 $(k-1)!\times \sum\limits_{i=1}^m\dfrac{c_i}{a_i-c_i+1}$，然后要与 $1$ 取 $\min$，直接 $O(m^2)$ 计算即可。

考虑这种情况出现的概率，发现是 $\dfrac{s}{\dbinom{n}{k}}$，用你喜欢的写法 $O(m^2)$ 算即可。

---

枚举合法的 $c_{1,2,\cdots, m}$ 的情况直接 dfs 做即可，情况数上界为选若干非负整数和为 $k$ 的方案数。即 $\dbinom{k+m-1}{k}$。

当 $k,m$ 同阶时，情况数 $\dbinom{k+m-1}{k}\le \dbinom{2m}{m}$。

总复杂度就是 $O\left(m^2\dbinom{2m}{m}\right)$，随便过。

$\texttt{code}$

#include<bits/stdc++.h>
#define LL long long
#define LD long double
#define fr(x) freopen(#x".in","r",stdin);freopen(#x".out","w",stdout);
using namespace std;
const int N=15;
int k,m,a[N],b[N];LL n;LD ans=1;
inline void calc()
{
	LD s=0;
	for(int i=1;i<=m;i++) s+=(LD)b[i]/(a[i]-b[i]+1);
	for(int i=1;i<k;i++) s*=i;
	if(s>=1) return;s=1-s;
	for(int i=1,K=0;i<=m;i++)
		for(int j=0;j<b[i];j++,K++) s*=(LD)(a[i]-j)/(b[i]-j)*(k-K)/(n-K);ans-=s;
}
void dfs(int v,int x)
{
	if(v==m+1){if(!x) calc();return;}
	for(int i=0;i<=min(a[v],x);i++) b[v]=i,dfs(v+1,x-i);
}
int main()
{
	ios::sync_with_stdio(0);cin.tie(0);cout.tie(0);cin>>k>>m;
	for(int i=1;i<=m;i++) cin>>a[i],n+=a[i];
	dfs(1,k);printf("%.12Lf",ans);
	return 0;
}

$\color{lightblue}{\texttt{P10254. 口吃}}$#

$\text{link}$ 。提示：考虑把式子和 $[a_i>a_j]$ 挂上关系。

$\texttt{solution}$

只有写了题解才能明白每一步的原委。

考虑拆 $i$：

$\begin{aligned} \sum\limits_{i=1}^n ia_i&=\sum\limits_{i=1}^n a_i\left(\sum\limits_{j<i}[a_i>a_j]+[a_i<a_j]+1\right)\\ &=\sum\limits_{i=1}^n a_i\left(a_i-\sum\limits_{j>i}[a_i>a_j]+\sum\limits_{j<i}[a_i<a_j]\right)\\ &=\sum\limits_{i=1}^n i^2+\sum\limits_{i=1}^n a_i\left(\sum\limits_{j<i}[a_i<a_j]-\sum\limits_{j>i}[a_i>a_j]\right)\\ &=\sum\limits_{i=1}^n i^2+\sum\limits_{i=1}^n a_i\sum\limits_{j<i}[a_i<a_j]-\sum\limits_{i=1}^n a_i\sum\limits_{j>i}[a_i>a_j] \end{aligned}$

对最后两部分 dp 即可。

---

首先套路性地记 $f_{i,j}$ 表示填到 $i$，逆序对数为 $j$ 的方案数。

则 $f_{i,j}=\sum\limits_{0\le k<i} f_{i-1,j-k}$，记下 $f$ 的前缀和进行前缀和优化即可。

则前半部分的总贡献为 $f_{n,k}\times \sum\limits_{i=1}^n i^2$。

记 $g_{i,j}$ 表示填到 $i$，逆序对数为 $j$ 的方案中当前所有 $\sum\limits_{i=1}^n a_i\sum\limits_{j>i}[a_i>a_j]$ 的和。

则 $g_{i,j}=\sum\limits_{0\le k<i}g_{i-1,j-k}+i\times k\times f_{i-1,j-k}$。

类似记 $h_{i,j}$ 表示填到 $i$，逆序对数为 $j$ 的方案中当前所有 $\sum\limits_{i=1}^n a_i\sum\limits_{j<i}[a_i<a_j]$ 的和。

考虑倒着做，令 $t=n-i+1$，$h_{i,j}=\sum\limits_{0\le k<t}h_{i+1,j-k}+i\times k\times f_{i+1,j-k}$。

此时若正着做，则有：$h_{i,j}=\sum\limits_{0\le k<i}h_{i-1,j-k}+(n-i+1)\times k\times f_{i-1,j-k}$。

考虑 $U=h-g$，则 $U_{i,j}=\sum\limits_{0\le k<i}U_{i-1,j-k}+(n-2i+1)\times k\times f_{i-1,j-k}$。

答案为 $f_{n,k}\times \sum\limits_{i=1}^n i^2+U_{n,k}$。

记下 $U$ 的前缀和和 $jf_{i,j}$ 的前缀和，优化 dp 即可。具体细节看代码。

复杂度 $O(nk)$，空间复杂度经过优化后为 $O(k)$。

$\texttt{code}$

#include<bits/stdc++.h>
#define LL long long
#define fr(x) freopen(#x".in","r",stdin);freopen(#x".out","w",stdout);
using namespace std;
const int N=305,M=N*(N-1)/2+5,mod=998244353;
int n,k,f[M],F[M],s[M],g[M],G[M];
inline int md(int x){return x>=mod?x-mod:x;}
int main()
{
	ios::sync_with_stdio(0);cin.tie(0);cout.tie(0);cin>>n>>k;
	f[0]=1;for(int i=0;i<=k;i++) F[i]=1;
	for(int i=1;i<=n;i++)
	{
		for(int j=0;j<=k;j++) f[j]=md(F[j]-((j>=i)?F[j-i]:0)+mod),
			g[j]=md((1ll*(G[j]-((j>=i)?G[j-i]:0))+1ll*(n-2*i+1)*j*f[j]-1ll*(n-2*i+1)*(s[j]-((j>=i)?s[j-i]:0)))%mod+mod);
		F[0]=f[0],G[0]=g[0];
		for(int j=1;j<=k;j++) F[j]=md(F[j-1]+f[j]),G[j]=md(G[j-1]+g[j]),s[j]=(s[j-1]+1ll*j*f[j])%mod;
	}
	return cout<<(1ll*n*(n+1)*(n*2+1)/6%mod*f[k]+g[k])%mod,0;
}

$\color{lightblue}{\texttt{P8140. Trailing Digits}}$#

$\text{link}$ 。提示：同余方程。

$\texttt{solution}$

目前最优复杂度题解。

显然答案具有可二分性。现在考虑判断 $k$ 是否满足条件。

令 $A=10^k,c=d\times\dfrac{10^k-1}{9}$，则我们需要找到最小的非负整数 $x$ 使得 $Ax+c\equiv 0\pmod b$。

这显然是可以通过 exgcd $O(\log b)$ 求解的，具体细节看代码。

注意：当 $d=0$ 且解出 $x=0$ 时，需要把 $x$ 加到最小正整数。

然后考虑最终数 $\le a$ 的条件，只需 $Ax+c\le a$，把 $Ax+c$ 表示为字符串，进行 $O(len)$ 比较即可。

瓶颈在于二分加比较，复杂度 $O(len\log len)$。

---

注意到二分不同值时比较的不同位只有 $\lg b$ 级别，即前几位是解出来的 $x$，后面大多数为都是 $d$，于是存在 $O(len)$ 预处理 $O(\lg b)$ 比较的做法。留作思考（我懒得写了）。

于是最优复杂度可以看作 $O(len)$，于是可以加强到 $a=10^{10^7},b=10^9$ 这样。

$\texttt{code}$

#include<bits/stdc++.h>
#define LL long long
#define fr(x) freopen(#x".in","r",stdin);freopen(#x".out","w",stdout);
using namespace std;
const int N=1e4+5;
int b,d;LL x,y;string a;
inline int ksm(int x,int p,const int mod){int s=1;for(;p;(p&1)&&(s=1ll*s*x%mod),x=1ll*x*x%mod,p>>=1);return s;}
void exgcd(int a,int b,LL &x,LL &y)
{
	if(!b) return x=1,y=0,void();
	exgcd(b,a%b,x,y);LL t=x-(a/b)*y;x=y;y=t;
}
inline int eq(int a,int b,int c)
{
	int t=__gcd(a,b);if(c%t) return -1;
	exgcd(a,b,x,y);b/=t;x=(x%b+b)*(c/t)%b;return (!x&&!d)?b:x;
}//exgcd 求解最小解，注意最小解要对 b/gcd 取模，而不是对 b 取模，注意 d=0 的 Corner Case
inline int pw(int k,const int mod){return ((ksm(10,k,9*mod)-1+9*mod)/9)%mod;}//求 c 的小手段
inline bool cmp(string b,string a){if(b.size()^a.size()) return b.size()<a.size();return b<=a;}//O(len) 比较
inline bool chk(int k)
{
	int a=ksm(10,k,b),c=1ll*(b-d)*pw(k,b)%b,t=eq(a,b,c);
	if(t==-1) return 0;string s=t?to_string(t):"";
	while(k--) s+=(d+'0');return cmp(s,::a);
}//二分判断答案，要注意同余方程无解的情况
int main()
{
	ios::sync_with_stdio(0);cin.tie(0);cout.tie(0);cin>>b>>d>>a;
	int l=1,r=a.size(),mid,ans=0;
	while(l<=r) mid=(l+r)>>1,(chk(mid))?(ans=mid,l=mid+1):r=mid-1;
	return cout<<ans,0;
}

$\color{lightblue}{\texttt{ABC352G. Socks 3}}$#

$\text{link}$ 。提示：期望转概率。

$\texttt{solution}$

我起了，一枪秒了。

ABC g 就这素质了，感觉好熟悉的题，但一下子又找不到原题。

套路性的，设抽袜子次数为 $X$。则 $\mathbb{E}(X)=\sum\limits_{k=0}^n \mathbb{P}(X>k)$。

考虑 $\mathbb{P}(X>k)$ 的意义，即抽 $k$ 次后袜子仍两两不同的概率。

首先算方案数，设 $s=\sum\limits_{i=1}^n a_i$，显然是 $\prod\limits_{i=0}^{k-1}(s-i)=k!\dbinom{s}{k}$。

考虑两两不同的方案数，颜色 $i$ 的生成函数为：$1+a_ix$，即不选有一种方案，选一个有 $a_i$ 种方案。

而最后 $k$ 个袜子可以任意排列，于是方案数为：$k![x^k]\prod\limits_{i=1}^n(1+a_ix)$。

于是 $\mathbb{E}(X)=\sum\limits_{k=0}^n \dfrac{k!\binom{s}{k}}{k![x^k]\prod\limits_{i=1}^n(1+a_ix)}=\sum\limits_{k=0}^n \dfrac{\binom{s}{k}}{[x^k]\prod\limits_{i=1}^n(1+a_ix)}$.

于是只需求出 $f(x)=\prod\limits_{i=1}^n(1+a_ix)$ 的 $0\sim n$ 次项系数即可。

这是一个经典分治 $\texttt{NTT}$ 问题，复杂度 $O(n\log^2 n)$，$\texttt{NTT}$ 不要太慢就足以通过。

求 $\dbinom{s}{k}$ 利用 $\dfrac{s-k}{k+1}\dbinom{s}{k}=\dbinom{s}{k+1}$ 递推即可。

---

记 $a_i=k$ 的个数为 $c_k$，$m=\max a$，则 $f(x)=\prod\limits_{i=2}^m(1+ix)^{c_i}=\prod\limits_{i=2}^m g_i(x)$。

单个 $g$ 直接二项式定理展开即可，而后对 $g_2\sim g_m$ 做分治 $\texttt{NTT}$，此时复杂度应为 $O(n\log n\log m)$，更优秀一点，但我懒得写啦，自己上面那个做法已经跑飞快了。

$\texttt{code}$

#include<bits/stdc++.h>
#define LL long long
using namespace std;
const int mod=998244353,N=12e5+5;
int n,s,f[N],a[N],w[N],*b[N],mmax,ans;
inline int rd()
{
    int x=0,zf=1;
    char ch=getchar();
    while(ch<'0'||ch>'9') (ch=='-')and(zf=-1),ch=getchar();
    while(ch>='0'&&ch<='9') x=x*10+ch-'0',ch=getchar();
    return x*zf;
}
inline void wr(int x)
{
    if(x==0) return putchar('0'),putchar('\n'),void();
    int num[35],len=0;
    while(x) num[++len]=x%10,x/=10;
    for(int i=len;i>=1;i--) putchar(num[i]+'0');
    putchar('\n');
}
inline int bger(int x){return x|=x>>1,x|=x>>2,x|=x>>4,x|=x>>8,x|=x>>16,x+1;}
inline int md(int x){return x>=mod?x-mod:x;}
inline int ksm(int x,int p){int s=1;for(;p;(p&1)&&(s=1ll*s*x%mod),x=1ll*x*x%mod,p>>=1);return s;}
inline void init(int mmax)
{
	for(int i=1,j,k;i<mmax;i<<=1)
		for(w[j=i]=1,k=ksm(3,(mod-1)/(i<<1)),j++;j<(i<<1);j++)
			w[j]=1ll*w[j-1]*k%mod;
}
inline void DNT(int *a,int mmax)
{
	for(int i,j,k=mmax>>1,L,*W,*x,*y,z;k;k>>=1)
		for(L=k<<1,i=0;i<mmax;i+=L)
			for(j=0,W=w+k,x=a+i,y=x+k;j<k;j++,W++,x++,y++)
				*y=1ll*(*x+mod-(z=*y))* *W%mod,*x=md(*x+z);
}
inline void IDNT(int *a,int mmax)
{
	for(int i,j,k=1,L,*W,*x,*y,z;k<mmax;k<<=1)
		for(L=k<<1,i=0;i<mmax;i+=L)
			for(j=0,W=w+k,x=a+i,y=x+k;j<k;j++,W++,x++,y++)
				z=1ll* *W* *y%mod,*y=md(*x+mod-z),*x=md(*x+z);
	reverse(a+1,a+mmax);
	for(int inv=ksm(mmax,mod-2),i=0;i<mmax;i++) a[i]=1ll*a[i]*inv%mod;
}
inline void NTT(int *a,int *b,int n,int m)
{
	mmax=bger(n+m);DNT(a,mmax);DNT(b,mmax);
	for(int i=0;i<mmax;i++) a[i]=1ll*a[i]*b[i]%mod;IDNT(a,mmax);
}
void sol(int l,int r,int wz)
{
	b[wz]=new int[r-l+2];
	if(l==r) return b[wz][0]=1,b[wz][1]=a[l],void();
	int mid=(l+r)>>1;sol(l,mid,wz<<1);sol(mid+1,r,wz<<1|1);
	static int A[N],B[N];for(int i=0;i<bger(r-l+3);i++) A[i]=B[i]=0;
	for(int i=0;i<=mid-l+1;i++) A[i]=b[wz<<1][i];
	for(int i=0;i<=r-mid;i++) B[i]=b[wz<<1|1][i];
	NTT(A,B,mid-l+2,r-mid+1);for(int i=0;i<=r-l+1;i++) b[wz][i]=A[i];
}
int main()
{
	n=rd();init(bger(n<<1));for(int i=1;i<=n;i++) s=md(s+(a[i]=rd()));
	f[0]=1;for(int i=0;i<n;i++) f[i+1]=1ll*f[i]*(i+1)%mod*ksm(s-i,mod-2)%mod;
	sol(1,n,1);for(int i=0;i<=n;i++) ans=(ans+1ll*b[1][i]*f[i])%mod;
	return wr(ans),0;
}

$\color{lightblue}{\texttt{qoj 5376. xor}}$#

$\text{link}$ 。提示：分段，自然数幂和。

$\texttt{solution}$

前置知识，线性/线性对数求自然数幂和：CF622F，这里为了实现简洁带了 $\log$。

考虑设 $c_x$ 表示 $0\le i,j,k<n$ 且 $i \oplus j \oplus k=x$ 的个数，则 $ans=\sum\limits_{x} c_x x^d$。

猜测/观察到 $c_x$ 形成的值相同的连续段个数不多，一个朴素的上界是 $\log^3 n$ 段。

• PS： 实际执行下来感觉是 $O(\log n)$ 级别的，不是很会证。

考虑怎么快速求出这些连续段以及其对应的 $c$ 的值。

套路性的，考虑把 $[0,n)$ 拆成若干 $[x,x+2^k)$ 的合并。

此时维护 $(x,k,c)$ 这样一个类，表示数在 $[x,x+2^k)$ 中，且有 $c$ 种方案。

考虑 merge $(x_0,k_0,c_0),(x_1,k_1,c_1)$，不妨设 $k_0\le k_1$，发现形成的新类为：$(2^{k_1}\lfloor (x_0\oplus x_1)/2^{k_1}\rfloor,k_1,2^{k_0}c_0c_1)$。

枚举 $i,j,k$ 分别在哪个类里，并自然数幂和计算一个类的答案即可。

复杂度 $O(\log^3 n+d\times \text{polylog}(n))$。一个朴素的上界是四只 $\log$，实际感觉是两只或三只 $\log$。

$\texttt{code}$

//qoj 5376
//https://qoj.ac/problem/5376
#include<bits/stdc++.h>
#define LL long long
#define fr(x) freopen(#x".in","r",stdin);freopen(#x".out","w",stdout);
using namespace std;
const int N=1e5+15,mod=998244353;
int n,k,m,p2[95],jc[N],inv[N],a[N],ans;
unordered_map<int,int>mp;
struct node{int x,k,c;}b[35];
inline node hb(node A,node B)
{
	if(A.k>B.k) swap(A,B);auto [x,k,c]=A;auto [X,K,C]=B;
	return {X^(x>>K<<K),K,1ll*c*C%mod*p2[k]%mod};
}//合并类
inline int md(int x){return x>=mod?x-mod:x;}
inline int ksm(int x,int p){int s=1;for(;p;(p&1)&&(s=1ll*s*x%mod),x=1ll*x*x%mod,p>>=1);return s;}
inline int sol(int n)
{
	int s=1,t,ans=0;
	if(n<=k+2) return a[n];n%=mod;n+=mod;
	if(mp.count(n)) return mp[n];
	for(int i=1;i<=k+2;i++) s=1ll*s*(n-i)%mod;
	for(int i=1;i<=k+2;i++) t=1ll*a[i]*inv[i-1]%mod*inv[k+2-i]%mod*s%mod*ksm(n-i,mod-2)%mod,ans=md(ans+(((k+2-i)&1)?mod-t:t));
	return mp[n]=ans;
}
inline void init()
{
	int M=k+1;for(int i=jc[0]=1;i<=M;i++) jc[i]=1ll*jc[i-1]*i%mod;
	inv[M]=ksm(jc[M],mod-2);for(int i=M-1;i>=0;i--) inv[i]=1ll*inv[i+1]*(i+1)%mod;
	for(int i=1;i<=k+2;i++) a[i]=md(a[i-1]+ksm(i,k));
	for(int i=p2[0]=1;i<=50;i++) p2[i]=md(p2[i-1]<<1);
}//自然数幂和
int main()
{
	ios::sync_with_stdio(0);cin.tie(0);cout.tie(0);cin>>n>>k;init();
	for(int i=0;i<=__lg(n);i++) if(n>>i&1) b[++m]={n>>(i+1)<<(i+1),i,1};
	for(int i=1;i<=m;i++) for(int j=1;j<=m;j++) for(int I=1;I<=m;I++)
	{
		auto [x,k,c]=::hb(hb(b[i],b[j]),b[I]);int s=md(sol(x+(1<<k)-1)+mod-sol(x-1));
		ans=(ans+1ll*c*s)%mod;//计算答案
	}//枚举三次类
	return cout<<ans,0;
}

$\color{lightblue}{\texttt{P10855. Gcd with Xor}}$#

$\text{link}$ 。提示：$\text{xor}$ 拆 $\log$ 段区间。

$\texttt{solution}$

记 $ans$ 表示最终答案。

$$\begin{aligned} ans&=\sum\limits_{i=1}^n\sum\limits_{j=i}^n (i,i\ \text{xor}\ j)^k \\ &=\sum\limits_{i=1}^n\sum\limits_{d\mid i}d^k\sum\limits_{j=i}^n[(i,i\ \text{xor}\ j)=d] \\ &=\sum\limits_{i=1}^n\sum\limits_{d\mid i}d^k\sum\limits_{j=i}^n\sum\limits_{dD\mid i,dD\mid i\ \text{xor}\ j,i\le j\le n}\mu(D) \\ &=\sum\limits_{T=1}^n \left(\sum\limits_{d\mid T}d^k\mu(T/d)\right)\sum\limits_{T\mid i}\sum\limits_{j=i}^n[T\mid (i\ \text{xor}\ j)] \end{aligned}$$

此时注意到 $j\in[i,n],i\ \text{xor}\ j$ 显然能被分成 $\log$ 段区间，再加上调和级数的 $\ln$，后半部分的复杂度是 $O(n\ln n\log n)$。

至于 $f(T)=\sum\limits_{d\mid T}d^k\mu(T/d)$ 部分，为了避免 $\log k$ 的出现，可以线性筛 $O(n)$ 预处理 $1^k,2^k,\cdots ,n^k$。

此时前半部分计算的复杂度就是调和级数的 $O(n\ln n)$。

于是复杂度 $O(n\log^2 n)$，常数别写太劣就能过。

$\texttt{code}$

#include<bits/stdc++.h>
#define LL long long
#define fr(x) freopen(#x".in","r",stdin);freopen(#x".out","w",stdout);
using namespace std;
const int N=2e5+5,mod=1e9+7;
int T,n,k,pr[N],mu[N],pw[N],s;bool v[N];
basic_string<int>d[N];
inline int md(int x){return x>=mod?x-mod:x;}
inline int ksm(int x,int p){int s=1;for(;p;(p&1)&&(s=1ll*s*x%mod),x=1ll*x*x%mod,p>>=1);return s;}
inline void init(int M)
{
    for(int i=2;i<=M;i++)
    {
        if(!v[i]) pr[++pr[0]]=i,mu[i]=-1;
        for(int j=1;j<=pr[0]&&i*pr[j]<=M;j++)
        {
            v[i*pr[j]]=1;if(i%pr[j]==0) break;
            mu[i*pr[j]]=-mu[i];
        }
    }mu[1]=1;
    for(int i=1;i<=M;i++) for(int j=i;j<=M;j+=i) d[j]+=i; 
}//预处理 mu 以及因子
inline void ipw(int M)
{
    pr[0]=0;
    for(int i=2;i<=M;i++)
    {
        if(!v[i]) pr[++pr[0]]=i,pw[i]=ksm(i,k);
        for(int j=1;j<=pr[0]&&i*pr[j]<=M;j++)
        {
            v[i*pr[j]]=1;pw[i*pr[j]]=1ll*pw[i]*pw[pr[j]]%mod;
            if(i%pr[j]==0) break;
        }
    }pw[1]=1;
}//O(nln k/ln n) 预处理 1^k,2^k,...,n^k
inline int get(int l,int r,int d){return r/d+1-((l>0)?(l-1)/d+1:0);}
void dfs(int l,int r,int L,int R,int x)
{
    if(L<=l&&r<=R)
    {
        int t=__lg((l^r)+1),y=(L^l)>>t<<t;
        s=md(s+get(y,y+(1<<t)-1,x)); return;
    }int mid=(l+r)>>1;
    if(L<=mid) dfs(l,mid,L,R,x);
    if(mid<R) dfs(mid+1,r,L,R,x);
}//拆成 log 段区间算后半部分贡献
int main()
{
    ios::sync_with_stdio(0);cin.tie(0);cout.tie(0);cin>>T;init(N-5);
    while(T--)
    {
        cin>>n>>k;ipw(n);int ans=0,U=1<<(__lg(n)+1);
        for(int i=1;i<=n;i++)
        {
            int A=0;s=0;
            for(int j:d[i]) A=(A+1ll*pw[j]*(mod+mu[i/j]))%mod;//前半部分直接枚举
            for(int j=i;j<=n;j+=i) dfs(0,U-1,j,n,i);ans=(ans+1ll*A*s)%mod;//后半部分
        }cout<<ans<<"\n";
    }
    return 0;
}