【JZOJ 省选模拟】亚特兰大

题目

Description
司令部截获了深海的电报，你的镇守府即将被深海轰炸。
虽然你作为历战提督，已经有了很多局地战、火箭机，但是刚刚击破 E6 甲，拥有亚特兰大以及最高倍率对空 ci 的你，决定只用亚特兰大抵挡对面的炸家。
你的镇守府可以看成一棵树，深海的轰炸是在某两个点之间进行的（起点终点交换视为一种），轰炸路径是树上的简单路径。也就是说，深海一共有 种可能的轰炸方案。
你的亚特兰大在不同的边上具有不同的击坠值，最终深海剩下的飞机数是经过路径上所有击坠值的gcd − 1。当这个值变成 0 时，你就成功抵挡住了深海的炸家。
现在你想知道，深海一共有多少种可能的轰炸方案，你可以成功抵挡。
但不幸的是，亚特兰大初来乍到，击坠值有点不稳定，所以会出现 Q 次击坠值变化，每次变化指某一条边的击坠值改变。
请你计算出这 Q + 1 种局面的所有答案。

Input
第一行一个整数 n。
接下来 n − 1 行每行三个整数 u,v,w，表示在结点 u,v 之间的边击坠值是 w。
接下来一行一个整数 Q。
接下来 Q 行每行两个整数 k,x，表示将读入的第 k 条边（下标从 1 开始）的击坠值改为 x。

Output
输出 Q + 1 行，每行一个整数，
依次表示初始局面、第 1 次变化后的局面、……、第 Q 次变化后的局面的答案。

Sample Input
样例输入：
6
2 1 3
2 3 2
4 1 7
2 5 3
6 3 9
4
1 6
1 9
4 3
2 9

Sample Output
样例输出：
9
8
9
9
4

Data Constraint
对于所有数据，满足 2 ≤ n ≤ 10^5 , Q ≤ 100 , 1 ≤ w,x ≤ 10^6 。
对于 10% 的数据，n ≤ 300。
对于 30% 的数据，n ≤ 1000。
对于 70% 的数据，n ≤ 7000。

思路

根据莫比乌斯反演可得

其中 f(i) 表示 gcd mod i=0 的路径条数。
莫比乌斯函数可以直接先用线性筛求出。
而对于 f(i)，我们可以每次把权值是 i 的倍数的边全部取出，计算得出的连通块的路径个数。
我们可以发现修改次数非常小，所以可以先把不会修改的边全部先处理掉，并且用并查集处理连通块。
对于某次修改，只继续加入会被修改的边计算。
可以用并查集的启发式合并实现并查集的还原。

代码

#include<bits/stdc++.h>
#define ll long long
using namespace std;
const int N=2e5+77,M=1e6+77;
struct point
{
	int id,t;
	point(){}
	point(int _id,int _t) :
		id(_id),t(_t) {}
};
struct line
{
	int x,y,z;
}b[N],c[N];
bool bo[M];
int fa[N],sze[N],n,q,miu[M],L = 1e6,tim[N],vis[N];
ll ans[N],sum;
vector<int>stk,a[M];
vector<point>g[M],h[N];

void init()
{
	for(int i=1; i<=L; i++) miu[i]=1;
	for(int i=2; i<=L; i++)
	if(!bo[i])
	{
		miu[i]=-1;
		a[i].push_back(i);
		for(int j=i<<1; j<=L; j+=i)
		{
			bo[j]=1;
			if(j/i%i==0) miu[j]=0;
			else miu[j]=-miu[j];
			a[j].push_back(i);
		}
	}
}

int gf(int x)
{
	while(fa[x]) x=fa[x];
	return x;
}

void merge(int x,int y)
{
	int fx=gf(x),fy=gf(y);
	if(sze[fx]<sze[fy]) swap(fx,fy);
	fa[fy]=fx;
	sum+=(ll)sze[fx]*sze[fy];
	sze[fx]+=sze[fy];
	stk.push_back(fy);
}

void cut()
{
	int fy=stk.back(),fx=fa[fy];
	sze[fx]-=sze[fy];
	sum-=(ll)sze[fx]*sze[fy];
	fa[fy]=0;
	stk.pop_back();
}

void ins(int x,int id,int t)
{
	point u=point(id,t);
	int len=a[x].size(),all=1<<len;
	for(int s=0; s<all; s++)
	{
		int y=1;
		for(int i=0; i<len; i++)
		if(s&(1<<i)) y*=a[x][i];
		g[y].push_back(u);
	}
}

void solve(int x)
{
	int len=g[x].size();
	sum=0;
	ll tot=0;
	for(int i=0,j=0; i<len; i=j+1)
	{
		j=i-1;
		int now_t=g[x][i].t;
		while(j<len-1&&g[x][j+1].t==now_t)
		{
			j++;
			int pos=g[x][j].id;
			merge(b[pos].x,b[pos].y);
		}
		ll tmp=miu[x]*sum;
		if(now_t!=-1)
		{
			ans[now_t]+=tmp;
			for(int k=i; k<=j; k++) cut();
		}
		else
		{
			for(int k=j+1; k<len; k++) vis[g[x][k].t]=x;
			for(int k=0; k<=q; k++)
			if(vis[k]!=x) ans[k]+=tmp;
		}
	}
	while(stk.size()) cut();
}

int main()
{
	freopen("atoranta.in","r",stdin); freopen("atoranta.out","w",stdout);
	init();
	scanf("%d",&n);
	for(int i=1; i<n; i++) scanf("%d%d%d",&b[i].x,&b[i].y,&b[i].z);
	scanf("%d",&q);
	for(int i=1; i<=q; i++) scanf("%d%d",&c[i].x,&c[i].y),tim[c[i].x]=i;
	for(int i=1; i<n; i++)
	if(!tim[i]) ins(b[i].z,i,-1);
	for(int i=1; i<=q; i++)
	{
		point u=point(c[i].x,c[i].y);
		for(int j=i; j<=q; j++)
		if(j==i||c[j].x!=c[i].x) h[j].push_back(u);
		else break;
		bool pd=0;
		for(int j=1; j<i; j++)
		if(c[j].x==c[i].x)
		{
			pd=1; break;
		}
		if(!pd)
		{
			point v=point(c[i].x,b[c[i].x].z);
			for(int j=0; j<i; j++) h[j].push_back(v);
		}
	}
	for(int i=0; i<=q; i++)
	{
		int len=h[i].size();
		for(int j=0; j<len; j++) ins(h[i][j].t,h[i][j].id,i);
	}
	for(int i=1; i<=n; i++) sze[i]=1;
	for(int i=1; i<=L; i++)
	if(g[i].size()) solve(i);
	for(int i=0; i<=q; i++) printf("%lld\n",ans[i]);
}