X000010

P1829 [国家集训队]Crash的数字表格 / JZPTAB

题意：求 \({\rm S}(n,m)=\sum\limits_{i=1}^n\sum\limits_{j=1}^m{\rm lcm}(i,j)\) ，对 \(20101009\) 取模。

\(x/y\) 等价于 \(\left\lfloor \dfrac xy \right\rfloor\) ，并且设 \(n\le m\)

\[\begin{aligned}
\sum_{i=1}^n\sum_{j=1}^m{\rm lcm}(i,j)
&= \sum_{i=1}^n\sum_{j=1}^m\dfrac{ij}{\gcd(i,j)} \\
&= \sum_{d=1}^n\sum_{i=1}^{n/d}\sum_{j=1}^{m/d}[(i,j)=1]\times\dfrac{(id)\times(jd)}d \\
&= \sum_{d=1}^nd\sum_{i=1}^{n/d}\sum_{j=1}^{m/d}[(i,j)=1]\times ij \\
\end{aligned}\]

我们需要设法快速求出 \({\rm sum}(n,m)=\sum\limits_{i=1}^n\sum\limits_{j=1}^m[(i,j)=1]\times ij\) 这样一个式子的值

\[\begin{aligned}
\sum_{i=1}^n\sum_{j=1}^m[(i,j)=1]\times ij
&= \sum_{i=1}^n\sum_{j=1}^m\sum_{d'\mid (i,j)}\mu(d')ij \\
&= \sum_{d'=1}^n\mu(d')\sum_{d'\mid i}\sum_{d'\mid j}ij \\
&= \sum_{d'=1}^n\mu(d')\sum_{i=1}^{n/d'}\sum_{j=1}^{m/d'}(id')(jd') \\
&= \sum_{d'=1}^n\mu(d')d'^2\sum_{i=1}^{n/d'}\sum_{j=1}^{m/d'}ij \\
\end{aligned}\]

我们需要设法快速求出 \({\rm f}(n,m)=\sum\limits_{i=1}^n\sum\limits_{j=1}^m ij\) 这样一个式子的值

\[\sum_{i=1}^n\sum_{j=1}^mij=\left(\sum_{i=1}^ni\right)\left(\sum_{j=1}^mj\right)=\dfrac{n(n+1)}2\times\dfrac{m(m+1)}2
\]

于是 \({\rm f}(n,m)\) 可以 \(O(1)\) 求出

则 \({\rm sum}(n,m)=\sum\limits_{d'=1}^n\mu(d')d'^2{\rm f}(n/d',m/d')\)

考虑数论分块，可以 \(O(\sqrt n+\sqrt m)\) 求出

则 \({\rm S}(n,m)=\sum\limits_{d=1}^nd~{\rm sum}(n/d,m/d)\)

考虑数论分块，可以 \(O((\sqrt n+\sqrt m)\times ?)\) 求出

这个时间复杂度最高是 \(O(n^{0.75})\) ，我不会证（

时间复杂度是线性的（跑欧拉筛肯定线性）

也有别的方法 不写了 反正都是线性

#include<stdio.h>
const int N=10000000,P=20101009; int n,m,ans,t1,t2,t3,t4;
int cnt,t,p[5800000],v[N+2],mu[N+2],s[N+2]; //1e7以内的素数不超过5800000个
void prework() { //欧拉筛
	for (int i=2; i<=N; ++i) {
		v[i]||(p[++cnt]=i,mu[i]=-1);
		for (int j=1; j<=cnt&&1ll*p[j]*i<=N; ++j) {
			v[t=p[j]*i]=1;
			if (i%p[j]==0) break; mu[t]=-mu[i];
		}
		((s[i]=s[i-1]+1ll*i*i*mu[i]%P)%=P)<0&&(s[i]+=P);
	}
}
inline int min(int x,int y) { return x<y?x:y; }
inline int sss(int n) { return (1ll*n*(n+1)>>1)%P; }
inline int f(int n,int m) { return 1ll*sss(n)*sss(m)%P; } //f
inline int sum(int n,int m) { //sum
	int ans=0;
	for (int l=1,r,mx=min(n,m); l<=mx; l=r+1) {
		r=min(n/(t1=n/l),m/(t2=m/l));
		ans=(1ll*f(t1,t2)*(s[r]-s[l-1])+ans)%P;
	}
	ans<0&&(ans+=P); return ans;
}
int main() {
	mu[1]=s[1]=1,prework(); scanf("%d%d",&n,&m);
	for (int l=1,r,mx=min(n,m); l<=mx; l=r+1) { //S
		r=min(n/(t3=n/l),m/(t4=m/l));
		ans=((1ll*(r-l+1)*(l+r)*sum(t3,t4)>>1)+ans)%P;
	}
	ans<0&&(ans+=P); printf("%d\n",ans);
	return 0;
}

P5435 基于值域预处理的快速 GCD

是一道模板题，考察一种 \(O(\text{值域})-O(1)\) 的求gcd方法（虽然这个 \(O(1)\) 常数略大）

主要思想：对于 \((x,y)\) ，将 \(x\) 分解为 \(a\times b\times c\) ，使 \(a,b,c\) 均 \(\big(\le \sqrt x\) 或 \(\in \sf prime\big)\)

证明这样的分解存在（废话，可以不看）：

使用数学归纳法

设分解 \(\{a,b,c\}\) 中 \(a\le b\le c\) ，\(c\) 非质数且 \(c>\sqrt n\)

将 \(c\) 分解为 \(d\times e\) ，其中 \(d\le e\) ，易知 \(d\le \sqrt x\)

考虑这样一种分解： \(x=abc=abde=(ab)(d)(e)\)

发现 \(ab=\dfrac xc\le \sqrt x,d \le \sqrt x\)

如果 \(e\le \sqrt x\) 或者 \(e\) 为质数，那么得到了合法分解；否则我们继续处理 \(\{ab,d,e\}\) ，合法分解必然存在

考虑递归实现：我们可以找出 \(x\) 的最小质因子 \(p\) ，然后先分解 \(\dfrac xp\) ，最后将 \(p\) 乘到分解后最小的那个因数里

实际上根据这个思路 我们也有递推的方法 跑一遍线性筛就可以把这个分解处理好

证明这种分解方式得到的分解合法（所以说上面那段证明是废话）：

设 \(x\) 的最小质因子为 \(p\) ，使用这种方法对 \(\dfrac xp\) 得到的分解是 \(\{a,b,c\}\) ，其中 \(a\le b\le c\)

• \(x\) 是质数时，直接得到分解 \(\{1,1,x\}\)
• \(x\) 不是质数时，首先根据条件得到 \(p<a,b,c\) ，又因为 \(pabc=x\) ，所以 \(p\le \sqrt[4]x\)
  
  另外我们有 \(a\le \sqrt[3]{\frac xp}\) ，易得 \(pa<\sqrt[3]{\frac xp}\times p=\sqrt[3]{xp^2}\le \sqrt x\)
  
  那么证毕

得到这样的分解后，我们就可以快速计算 \(\gcd(x,y)\) 了：

将 \(x\) 分解为 \(\{a,b,c\}\) ，我们只需计算 \((a,y)\times(b,y)\times(c,y)\) 即可

我们可以事先打一个 \(\sqrt{10^6}\times\sqrt{10^6}\) 的表，存储 \(1\le x,y\le 10^3\) 时 \((x,y)\) 的值

以 \((a,y)\) 为例，如果 \(a\le 10^3\) ，我们直接在表里查 gcd[a][y%a] ，否则 \(a\) 必为质数，那么判断 \(a\mid y\) 是否成立即可

\((b,y)\) 和 \((c,y)\) 同理，因此理论上是 \(O(1)\) 的，虽然常数大

下面是代码

#include<cstdio>
const int N=1000000,nn=1000,P=998244353;
int n,cnt,t,tt,s,a[5010],b[5010],p[100000],v[N+2];
int g[nn+2][nn+2]; struct node { int a,b,c; }f[N+2];
inline void swap(int &x,int &y) { int t=x; x=y,y=t; }
inline int gcd(int x,int y) { //求gcd
	int a=f[x].a,b=f[x].b,c=f[x].c,ans=1;
	tt=(a>nn?(y%a?1:a):g[a][y%a]); y/=tt,ans*=tt; //ans*=(a,y)
	tt=(b>nn?(y%b?1:b):g[b][y%b]); y/=tt,ans*=tt; //ans*=(b,y)
	tt=(c>nn?(y%c?1:c):g[c][y%c]); y/=tt,ans*=tt; //ans*=(c,y)
	return ans;
}
int main() {
	scanf("%d",&n); f[1]={1,1,1};
	for (int i=2; i<=N; ++i) { //线性筛&预处理分解
		v[i]||(f[i]={1,1,i},p[++cnt]=i); //i为质数
		for (int j=1; j<=cnt&&1ll*p[j]*i<=N; ++j) {
			v[t=p[j]*i]=1,f[t]={f[i].a*p[j],f[i].b,f[i].c};
			f[t].a>f[t].b&&(swap(f[t].a,f[t].b),0); //保证a≤b≤c
			f[t].b>f[t].c&&(swap(f[t].b,f[t].c),0); //保证a≤b≤c
			if (i%p[j]==0) break;
		}
	}
	for (int i=1; i<=nn; ++i) g[i][0]=g[0][i]=i; //预处理表
	for (int i=1; i<=nn; ++i) //预处理表
		for (int j=1; j<i; ++j) g[i][j]=g[j][i%j];
	for (int i=1; i<=n; ++i) scanf("%d",a+i);
	for (int i=1; i<=n; ++i) scanf("%d",b+i);
	for (int i=1,j; i<=n; ++i,printf("%d\n",s))
		for (s=0,t=j=1; j<=n; ++j)
			t=1ll*t*i%P,s=(1ll*t*gcd(a[i],b[j])+s)%P;
	return 0;
}

P2579 [ZJOI2005]沼泽鳄鱼

矩阵乘法+图论。

考虑一个简化版的问题：\(NFish=0\) ，即不考虑食人鱼。

我们设 \(a_{x,i,j}\) 表示刚好走 \(x\) 步的前提下，从 \(i\) 走到 \(j\) 的方案数。

考虑第 \(x-1\) 步时到达的中转点 \(k\) ，我们有 \(a_{x,i,j}=\sum_{x=1}^na_{x-1,i,k}\times a_{1,j,k}\)

突然发现这个式子是矩阵乘法的形式！

把 \(a_x,a_{x-1},a_1\) 看做矩阵，我们有 \(a_x=a_{x-1}\times a_1\)

从而可以得到 \(a_x=a_1^k\)

根据 \(a_1\) 定义，把原图存为邻接矩阵即为 \(a_1\) 。那么我们做矩阵快速幂，答案即为 \(a_{x,Start,End}\) 。

现在我们考虑食人鱼：

第 \(x\) 步时，若食人鱼在 \(j\) 位置，那么对于所有的 \(i\) ，都有 \(a_{x,i,j}=0\)

注意到一个关键的信息：\(T=2\text 或3\text 或4\)

有 \((2,3,4)=12\) ，那么我们发现所有食人鱼的运动必定以12个单位时间为1周期

所以此时的 \(a\{1,2,\dots,x\}\) 虽然不全部相等了，但依然存在周期性！

则答案矩阵为 \(a_1\times a_2\times \dots\times a_{12}\times a_1 \times \dots\)

我们知道答案矩阵是由 \(k\) 个矩阵连乘得到。那么这个式子应当等于 \(\left(\prod\limits_{i=1}^{12}a_i\right)^{k/12}\times \prod\limits_{i=1}^{k\%12}a_i\)

这个式子又可以用矩阵快速幂优化，于是我们有了 \(O(n^3\log k)\) 的正确算法。

为了方便，代码实现时用 \(a_0\) 存储 \(a_{12}\) 。

#include<cstdio>
#include<cstring>
#define rep(i,x) for (int i=0; i<x; ++i)
const int P=10000; int n,m,M,p1,p2,k,x,y,t,a[52][52];
struct node { int c[52][52]; }Q,Q1,f[12];
node operator * (node x,node y) { //矩阵乘法
	static node t; memset(t.c,0,sizeof t.c);
	rep(i,n) rep(k,n) rep(j,n)
		(t.c[i][j]+=x.c[i][k]*y.c[k][j])%=P;
	return t;
}

int main() {
	scanf("%d%d%d%d%d",&n,&m,&p1,&p2,&k);
	while (m--) scanf("%d%d",&x,&y),a[x][y]=a[y][x]=1; //a为原图
	rep(i,12) memcpy(f[i].c,a,sizeof a);
	for (scanf("%d",&M); M; --M) {
		scanf("%d",&t);
		rep(i,t) {
			scanf("%d",&x);
			for (int j=i; j<12; j+=t)
				rep(k,n) f[j].c[k][x]=0; //这一段可以自行思考一下
		}
	}
	Q=f[1]; for (int i=2; i<12; ++i) Q=Q*f[i]; Q=Q*f[0]; //Q=a1*a2*...*a12
	rep(i,n) Q1.c[i][i]=1; //初始化为单位矩阵
	for (y=k/12; y; y>>=1) (y&1)&&(Q1=Q1*Q,0),Q=Q*Q; //快速幂
	for (int i=1,mx=k%12; i<=mx; ++i) Q1=Q1*f[i];
	printf("%d\n",Q1.c[p1][p2]);
	return 0;
}

P3821 Isaac

和上面那题非常相似。

矩阵乘法为 \(c_{i,j}=\min\{\max(a_{i,k},b_{k,j})\}\)

我也不知道这个为啥满足结合律，反正照着用就对了

我也不知道这个乘法定义下的单位矩阵是什么，所以代码里通过一些改动避免了单位矩阵的使用（ \(Q^k=Q\times Q^{k-1}\) ）

另外矩阵乘法中是一堆最大值求min，所以 \(c\) 中所有元素要初始化成无穷大

#include<cstdio>
#include<cstring>
#define rep(i,x) for (int i=1; i<=x; ++i)
int inf,n,m,p1,p2,k,M,T,x,y,w,a[52][52];
inline int min(int x,int y) { return x<y?x:y; }
inline int max(int x,int y) { return x>y?x:y; }
struct node { int c[52][52]; }Q,Q1,f[12];
node operator * (node x,node y) { //矩阵乘法
	static node t; memset(t.c,0x7f,sizeof t.c); //初始化
	rep(i,n) rep(k,n) rep(j,n)
		t.c[i][j]=min(t.c[i][j],max(x.c[i][k],y.c[k][j]));
	return t;
}

int main() {
	scanf("%d%d%d%d%d",&n,&m,&p1,&p2,&k);
	memset(a,0x7f,sizeof a); inf=a[0][0]; //其实直接写inf=0x7f7f7f7f就行了
	while (m--) scanf("%d%d%d",&x,&y,&w),a[x][y]=a[y][x]=w; //存图
	for (int i=0; i<12; ++i) memcpy(f[i].c,a,sizeof a);
	for (scanf("%d",&M); M; --M) {
		scanf("%d",&T);
		for (int i=0; i<T; ++i) {
			scanf("%d",&x);
			for (int j=i; j<12; j+=T) rep(k,n) f[j].c[k][x]=inf;
		}
	}
	Q=f[1]; for (int i=2; i<12; ++i) Q=Q*f[i]; Q=Q*f[0]; //计算Q
	if (k/12) {
		for (y=k/12-1,Q1=Q; y; y>>=1) (y&1)&&(Q1=Q1*Q,0),Q=Q*Q; //快速幂
		for (int i=1,mx=k%12; i<=mx; ++i) Q1=Q1*f[i];
	}
	else { Q1=f[1]; for (int i=2; i<=k; ++i) Q1=Q1*f[i]; }
	(x=Q1.c[p1][p2])==inf?puts("'IMP0SSBLE!!'"):printf("%d",x);
	return 0;
}

SP26017 GCDMAT - GCD OF MATRIX

考虑计算 \(\sum\limits_{i=1}^n\sum\limits_{j=1}^m\gcd(i,j)\) ，然后容斥算出答案。

欧拉反演

\[\begin{aligned}
\sum_{i=1}^n\sum_{j=1}^m\gcd(i,j)
&= \sum_{i=1}^n\sum_{j=1}^m\sum_{d\mid \gcd(i,j)}\varphi(d) \\
&= \sum_{d=1}^{\min(n,m)}\sum_{d\mid i}\sum_{d\mid j}\varphi(d) \\
&= \sum_{d=1}^{\min(n,m)}\varphi(d)\times\left\lfloor\dfrac nd\right\rfloor\left\lfloor\dfrac md\right\rfloor
\end{aligned}\]

至此可用数论分块计算。时间复杂度 \(O(\sqrt n+\sqrt m)\) 。

再加上容斥和多组数据，时间复杂度为 \(O(T(\sqrt n+\sqrt m))\)

#include<cstdio>
const int N=50002,P=1e9+7; int n1,m1,n2,m2,t,cnt,ans;
int t1,t2,T,p[10000],v[N],phi[N],s[N];
void prework() { //筛
	for (int i=2; i<N; ++i) {
		v[i]||(p[++cnt]=i,phi[i]=i-1);
		for (int j=1; j<=cnt&&1ll*p[j]*i<N; ++j) {
			v[t=p[j]*i]=1;
			if (i%p[j]) phi[t]=phi[i]*(p[j]-1);
			else { phi[t]=phi[i]*p[j]; break; }
		}
		s[i]=s[i-1]+phi[i];
	}
}
inline int min(int x,int y) { return x<y?x:y; }
int S(int n,int m) { //数论分块
	int ans=0;
	for (int l=1,r,mx=min(n,m); l<=mx; l=r+1) {
		r=min(n/(t1=n/l),m/(t2=m/l));
		ans=(1ll*t1*t2*(s[r]-s[l-1])+ans)%P;
	}
	return ans;
}

int main() {
	phi[1]=1,s[1]=1,prework();
	for (scanf("%d%d%d",&T,&t1,&t2); T; --T) {
		scanf("%d%d%d%d",&n1,&m1,&n2,&m2),--n1,--m1;
		ans=(S(n2,m2)-S(n2,m1)-S(n1,m2)+S(n1,m1))%P; //容斥
		ans<0&&(ans+=P); printf("%d\n",ans);
	}
	return 0;
}

SP26045 GCDMAT2 - GCD OF MATRIX (hard)

你可能觉得上一题比较菜不配做紫题 但它的加强版确实有作为黑题的资格

是一道卡常神题 技巧比较精妙

这题的数据范围比上题大一些，又因为我们的算法常数略大，不可通过，加了O2 Ofast什么的也一样

于是我们考虑优化常数

我们发现容斥造成了四倍常数，设法对其进行优化：

\[\sum_{d=1}^n\varphi(d)(i2/d-i1/d)(j2/d-j1/d)
\]

\(x/y\) 等价于 \(\left\lfloor \dfrac xy \right\rfloor\)

但是这个常数还是垃圾，跑不过，怎么办？

这里是一个很实用的技巧：预处理 \(\dfrac 11\sim\dfrac 1n\) 。

原理是除法很慢，即使乘double都比做除法快

又因为数论分块里总是带了一大堆除法，这个优化就能大大提升它的效率

这个优化确实非常强 但你可能还是过不掉

主要原因是数论分块本身的常数太大了（毕竟4个数取min然后各种计算），数据小的时候甚至跑不过暴力。

发现 \(i2,j2\le 1000\) 的时候完全可以预处理gcd前缀和，然后直接容斥。

那么我们把这个小优化也加进来，就可以卡进时限了。

#pragma GCC optimize(3)
#pragma GCC target("avx")
#pragma GCC optimize("Ofast")
#pragma GCC optimize("inline") //火车头里面几个我比较喜欢用的
#include<stdio.h>
#include<ctype.h>
const int N=1000001,P=1e9+7; int n1,m1,n2,m2,t,T,mx,cnt;
int t1,t2,t3,t4,p[100000],s[1001][1001],v[N];
long long ans,phi[N]; double tt,a[N];
void prework() {
	for (int i=2; i<N; ++i) {
		v[i]||(p[++cnt]=i,phi[i]=i-1);
		for (int j=1; j<=cnt&&1ll*p[j]*i<N; ++j) {
			v[t=p[j]*i]=1;
			if (i%p[j]) phi[t]=phi[i]*(p[j]-1);
			else { phi[t]=phi[i]*p[j]; break; }
		}
		phi[i]+=phi[i-1];
	}
}
inline int min(int x,int y) { return x<y?x:y; }

inline int read() {
	int x=0; char ch=getchar();
	while (!isdigit(ch)) ch=getchar();
	while (isdigit(ch)) x=x*10+(ch^48),ch=getchar();
	return x;
}
int gcd(int x,int y) { return y?gcd(y,x%y):x; }
int main() {
	phi[1]=1,prework(),T=read(),read(),read();
	for (int i=1; i<N; ++i) a[i]=1./i*(1+1e-10); //为了防止精度问题再加个eps
	for (int i=1; i<=1000; ++i) for (int j=1; j<=1000; ++j)
		s[i][j]=s[i-1][j]+s[i][j-1]+gcd(i,j)-s[i-1][j-1];
	while (T--) {
		n1=read()-1,m1=read()-1,n2=read(),m2=read(),ans=0;
		if (n2<=1000&&m2<=1000) { //不做数论分块
			printf("%d\n",s[n2][m2]-s[n1][m2]-s[n2][m1]+s[n1][m1]);
			continue;
		}
		for (int l=1,r,mx=min(n2,m2); l<=mx; l=r+1) {
			tt=a[l],r=mx;
			(t1=n1*tt)&&(r=min(r,n1*a[t1])); //注意t1=0时无需操作
			(t2=m1*tt)&&(r=min(r,m1*a[t2])); //同上
			(t3=n2*tt)&&(r=min(r,n2*a[t3])); //同上
			(t4=m2*tt)&&(r=min(r,m2*a[t4])); //同上
			ans+=(phi[r]-phi[l-1])*(t3-t1)*(t4-t2);
		}
		printf("%d\n",ans%P);
	}
	return 0;
}

【当前卡常方法仍不十分精妙，仍在研究中，会在X000011中专门记一下卡常方法】

SP14168 AFS2 - Amazing Factor Sequence (medium)

几乎算裸题了

\(\begin{aligned}
\sum\limits_{i=1}^n(\sigma(i)-i)
&=\left(\sum\limits_{i=1}^n\sigma(i)\right)-\dfrac{n(n+1)}2 \\
&=\left(\sum\limits_{i=1}^n\sum\limits_{d\mid i}d\right)-\dfrac{n(n+1)}2 \\
&=\left(\sum\limits_{d=1}^nd\left\lfloor\dfrac nd\right\rfloor\right)-\dfrac{n(n+1)}2
\end{aligned}\)

然后就是数论分块直接算

时间复杂度 \(O(\sqrt n)\) ，另外要开 __int128

#include<stdio.h>
typedef __int128 lll;
int T; long long n,t; lll ans;
void O(lll x) { x>9&&(O(x/10),0); putchar(x%10^48); } //__int128要手写输出
int main() {
	scanf("%d",&T); register long long l,r;
	while (T--) {
		scanf("%lld",&n),ans=0;
		for (l=1,r; l<=n; l=r+1)
			r=n/(t=n/l),ans+=(lll)t*(r-l+1)*(l+r)>>1;
		O(ans-((lll)n*(n+1)>>1)),putchar('\n');
	}
	return 0;
}