联合省选 2020 作业题

题面
根据欧拉函数的性质，有 $n={\sum }_{i|n}\phi (i)$，因此，将最终要求的答案化为：
${\sum }_T{\sum }_{i\in T}{w}_i{\sum }_{d=1}\phi (d)[d|gc{d}_{j\in T}{w}_j]$
其中 $gc{d}_{i\in S}{w}_i$ 为边集 $S$ 中边权值的最大公约数。
对式子进行进一步整理，得到：
${\sum }_{d=1}\phi (d){\sum }_T{\sum }_{i\in T}{w}_i{\prod }_{j\in T}[d|w_j]$
那么很明显，先枚举 $d$，然后将边权为 $d$ 倍数的边提出来，跑矩阵树。设已经枚举了 $d$，得到的边集为 $S$，则要求：
${\sum }_{T\subseteq S}{\sum }_{i\in T}{w}_i$
普通的矩阵树只能处理生成树边权积之和问题，即：
${\sum }_T{\prod }_{i\in T}{w}_i$
这里将矩阵中的元素换为一次多项式，边权为 $w$ 的边在填入矩阵时改为 $1+wx$，若行列式算出来的多项式为 ${\sum }_{i=0}{a}_i{x}^i$，则所以生成树边权之和为 $a_1$。
由于改变了边权的形式，要求的结果也变为了：
${\sum }_{T\subseteq S}{\prod }_{i\in T}(1+w_{i}x)$
将多项式乘法展开，只对一次项求和，得到：
${\sum }_{T\subseteq S}{\sum }_{i\in T}{w}_i$
由于只对一次项求和，因此在做多项式乘法和多项式逆元时对 $x^2$ 取模。
设现有多项式 $(a+bx)$，要求其逆元。若 $a=0$，则无逆元，同时生成树的答案为$0$。否则，则一定有逆元 $(c+dx)$ 满足 $(a+bx)(c+dx)\mathrm{m}\mathrm{o}\mathrm{d}{x}^2=1$。将其展开，得到：
$ac+(ad+bc)x=1$
因此：
$\{\begin{array}{l}ac=1\\ ad+bc=0\end{array}$
解得：
$\{\begin{array}{l}c=a^{-1}\\ d=-a^{-2}b\end{array}$
按照这样的多项式运算法则跑普通矩阵树即可。
当边集 $S$ 中没有生成树时可以剪枝。
时间复杂度 $O(n^{3}w)$，空间复杂度 $O(n^2+w)$

#include<stdio.h>
#include<vector>
using namespace std;
#define R register int
#define L long long
#define I inline
#define F friend operator
#define N 152502
#define P 998244353
vector<int>G[N];
int phi[N],prime[14066],f[31],st[435],ed[435],l[435];
bool vis[N];
I int GetF(int x){
	if(f[x]==x){
		return x;
	}
	f[x]=GetF(f[x]);
	return f[x];
}
I void InitPhi(){
	phi[1]=1;
	int ct=0;
	for(R i=2;i!=N;i++){
		if(vis[i]==false){
			phi[i]=i-1;
			prime[ct]=i;
			ct++;
		}
		for(R j=0;j!=ct&&prime[j]*i<N;j++){
			int t=i*prime[j];
			vis[t]=true;
			if(i%prime[j]==0){
				phi[t]=phi[i]*prime[j];
				break;
			}
			phi[t]=phi[i]*(prime[j]-1);
		}
	}
}
I int Add(int x,int y){
	x+=y;
	if(x>=P){
		return x-P;
	}
	return x<0?x+P:x;
}
I int PowMod(int x,int y){
	int res=1;
	while(y!=0){
		if((y&1)==1){
			res=(L)res*x%P;
		}
		x=(L)x*x%P;
		y>>=1;
	}
	return res;
}
struct Poly{
	int A,B;
	I void Init(int x,int y){
		A=x;
		B=y;
	}
	I bool F==(Poly x,Poly y){
		return x.A==y.A&&x.B==y.B;
	}
	I Poly F+(Poly x,Poly y){
		Poly res;
		res.Init(Add(x.A,y.A),Add(x.B,y.B));
		return res;
	}
	I Poly F-(Poly x,Poly y){
		Poly res;
		res.Init(Add(x.A,-y.A),Add(x.B,-y.B));
		return res;
	}
	I Poly F*(Poly x,Poly y){
		Poly res;
		res.Init((L)x.A*y.A%P,((L)x.A*y.B+(L)x.B*y.A)%P);
		return res;
	}
}b[31][31];
I Poly Pair(int x,int y){
	Poly res;
	res.A=x;
	res.B=y;
	return res;
}
I Poly GetInv(Poly x){
	int tem=PowMod(x.A,P-2);
	return Pair(tem,P-(L)x.B*tem%P*tem%P);
}
I int GetAns(int&n){
	Poly res=Pair(1,0);
	for(R i=1;i!=n;i++){
		int p=i;
		while(p!=n&&b[p][i].A==0){
			p++;
		}
		if(p==n){
			return 0;
		}
		if(p!=i){
			for(R j=i;j!=n;j++){
				Poly tem=b[i][j];
				b[i][j]=b[p][j];
				b[p][j]=tem;
			}
			res=Pair(0,0)-res;
		}
		Poly inv=GetInv(b[i][i]);
		res=res*b[i][i];
		for(R j=i+1;j!=n;j++){
			Poly tem=inv*b[j][i];
			for(R k=i;k!=n;k++){
				b[j][k]=b[j][k]-tem*b[i][k];
			}
		}
	}
	return res.B;
}
int main(){
	InitPhi();
	int n,m,ans=0;
	scanf("%d%d",&n,&m);
	for(int i=0;i!=m;i++){
		scanf("%d%d%d",st+i,ed+i,l+i);
		for(R j=1;j*j<=l[i];j++){
			if(l[i]%j==0){
				G[j].push_back(i);
				if(j*j!=l[i]){
					G[l[i]/j].push_back(i);
				}
			}
		}
	}
	for(R i=1;i!=N;i++){
		if(G[i].size()>n-2){
			for(R i=1;i<=n;i++){
				f[i]=i;
				for(R j=1;j!=n;j++){
					b[i][j]=Pair(0,0);
				}
			}
			for(vector<int>::iterator T=G[i].begin();T!=G[i].end();T++){
				int x=st[*T],y=ed[*T];
				if(GetF(x)!=GetF(y)){
					f[f[x]]=y;
				}
				Poly tem=Pair(1,l[*T]);
				b[x][x]=b[x][x]+tem;
				b[y][y]=b[y][y]+tem;
				b[x][y]=b[x][y]-tem;
				b[y][x]=b[y][x]-tem;
			}
			bool tag=true;
			for(R i=2;i<=n;i++){
				if(GetF(i)!=GetF(1)){
					tag=false;
					break;
				}
			}
			if(tag==true){
				ans=Add(ans,(L)GetAns(n)*phi[i]%P);
			}
		}
	}
	printf("%d",ans);
	return 0;
}

另外，此题利用莫比乌斯反演也是可以做的。将题目要求的答案化为：
${\sum }_{d=1}d{\sum }_T[gc{d}_{i\in T}{w}_i=d]{\sum }_{j\in T}{w}_j$
$={\sum }_{d=1}d{\sum }_T{\prod }_{i\in T}[d|w_i]{\sum }_{t=1}{\prod }_{j\in T}[td|w_j]\mu (t){\sum }_{k\in T}{w}_k$
$={\sum }_{d=1}d{\sum }_T{\sum }_{t=1}\mu (t){\prod }_{i\in T}[td|w_i]{\sum }_{j\in T}{w}_j$
$={\sum }_{p=1}{\sum }_{d|p}d\mu (\frac{p}{d}){\sum }_T{\prod }_{i\in T}[p|w_i]{\sum }_{j\in T}{w}_j$
利用这个式子，再结合矩阵树即可。时空复杂度与上一个算法相同。
根据狄利克雷卷积可知 $\phi (n)={\sum }_{d|n}\frac{n}{d}\mu (d)$，所以最终的式子与之前的算法也是完全相同的。