[日常训练] Surprise me

【问题描述】

• 众所周知，clyz 的红太阳 cyx 非常喜欢数学，而 zpyz 的 syx 非常喜欢树。有一天，cyx 和 syx 一起画了一棵带有数字的树。具体的，这棵树一共有 $n$ 个节点，第 $i$ 个节点上写着数字 $a_i$。但是如果只是画了一棵树的话，显然是非常的 boring，于是cyx从这棵树上随机选择了一个节点 $u$，然后 syx 也学着 cyx 的样子，在这棵树上随机选了一个节点 $v(u̸=v)$。cyx 于是说：“我们对选出来的节点定义一个权值吧！”因为 syx 非常地喜欢树，于是她认为权值一定要是 $d(u,v)$，即树上两个点之间最短路的距离。因为 cyx 非常地喜欢数学，所以他认为 syx 的定义过于 naive 了，于是 cyx 认为权值一定要是 $\phi (a_u\times a_v)$。两人争执不下，最终双方各让一步，共同决定权值应为这两个函数的乘积，即 $d(u,v)\phi (a_u\times a_v)$。
• 那么现在，问题来了，假如 cyx 和 syx 分别从树上随机选择一个点（两点互不相同），那么得到的权值的期望是多少？由于这个值可能很大，所以你只需要告诉他们这个值$\mathrm{m}\mathrm{o}\mathrm{d}(10^9+7)$ 的结果就行了。具体的，记所有方案的总权值为 $P$，总方案数为 $Q$，显然 $Q=n(n-1)$，那么你只需要输出$P\times Q^{-1}\mathrm{m}\mathrm{o}\mathrm{d}(10^9+7)$的值就行了。

【输入格式】

• 第一行一个正整数 $n$，表示总的点数。
• 第二行 $n$ 个正整数，第 $i$ 个正整数表示第 $i$ 个点的权值 $a_i$。
• 接下来 $n-1$ 行每行两个正整数，表示树上的一条边。

【输出格式】

• 一个正整数，表示答案。

【数据规模】

• 有 20% 的数据，满足 $2\le n\le 1000$。
• 有 20% 的数据，满足 $2\le n\le 50000$ 且第 $i$ 条边连接点 $i$ 和 $i+1$。
• 有 20% 的数据，树随机生成。
• 对于全部数据，满足 $2\le n\le 200000$，$1$~$n$ 的点权刚好组成一个 $1$~$n$ 的排列。

【分析】

【代码】

#include <algorithm>
#include <iostream>
#include <cstdlib>
#include <cstring>
#include <cstdio>
#include <cctype>
#include <cmath>
#include <ctime>

const int S = 1 << 20;
char frd[S], *ihead = frd + S;
const char *itail = ihead;

inline char nxtChar()
{
	if (ihead == itail)	
		fread(frd, 1, S, stdin), ihead = frd;
	return *ihead++;
}

template <class T>
inline void read(T &res)
{
	char ch;
	while (ch = nxtChar(), !isdigit(ch));
	res = ch ^ 48;
	while (ch = nxtChar(), isdigit(ch))
		res = res * 10 + ch - 48;
}

const int mod = 1e9 + 7;
const int N = 2e5 + 5;
const int M = 4e5 + 5;
int sum[N], f[20][M], pos[N], Log[M], val[N], stk[N];
int dep[N], vir[M], apr[N], dfn[N], low[N];
int pri[N], a[N], phi[N], miu[N], g[N];
int n, pr, vm, ans, tis, top, E; bool vis[N];

inline int ksm(int x, int k)
{
	int res = 1;
	while (k)
	{
		if (k & 1) res = 1ll * res * x % mod;
		x = 1ll * x * x % mod; k >>= 1;
	}
	return res;
}

inline void add(int &x, int y)
{
	x += y;
	x >= mod ? x -= mod : 0;
}

struct Edge 
{
	int to; Edge *nxt;
};

Edge p[M], *lst[N], *P = p;
Edge q[M], *rst[N], *Q = q;

inline void Link(int x, int y)
{
	(++P)->nxt = lst[x]; lst[x] = P; P->to = y;
	(++P)->nxt = lst[y]; lst[y] = P; P->to = x;
}

inline void Rink(int x, int y)
{
	(++Q)->nxt = rst[x]; rst[x] = Q; Q->to = y;
}

inline void Dfs(int x, int fa)
{
	f[0][++E] = x;
	pos[x] = E;
	dfn[x] = ++tis;
	dep[x] = dep[fa] + 1;
	for (Edge *e = lst[x]; e; e = e->nxt)
	{
		int y = e->to;
		if (y == fa) continue;
		Dfs(y, x);
		f[0][++E] = x;
	}
	low[x] = tis;
}

inline void Dfs2(int x)
{
	sum[x] = val[x];
	for (Edge *e = rst[x]; e; e = e->nxt)
	{
		int y = e->to;
		Dfs2(y);
		ans = (1ll * (mod - 4) * dep[x] % mod * sum[x] % mod * sum[y] + ans) % mod;
		add(sum[x], sum[y]);
	}
}

inline bool cmp(const int &x, const int &y)
{
	return dfn[x] < dfn[y];
}

inline bool check_Sub(int x, int y)
{
	return dfn[y] >= dfn[x] && dfn[y] <= low[x]; 
}

inline int idMin(int x, int y)
{
	return dep[x] < dep[y] ? x : y;
}

inline int query_LCA(int x, int y)
{
	if (x > y) std::swap(x, y);
	int k = Log[y - x + 1];
	return idMin(f[k][x], f[k][y - (1 << k) + 1]);
}

int main()
{
	freopen("sm.in", "r", stdin);
	freopen("sm.out", "w", stdout);
	
	read(n);
	for (int i = 1; i <= n; ++i)
		read(a[i]), apr[a[i]] = i;
	for (int i = 1, x, y; i < n; ++i)
	{
		read(x); read(y);
		Link(x, y);
	}
	Dfs(1, 0);
	Log[0] = -1;
	for (int i = 1; i <= E; ++i)
		Log[i] = Log[i >> 1] + 1;
	for (int j = 1, jm = Log[E]; j <= jm; ++j)	
		for (int i = 1; i + (1 << j) - 1 <= E; ++i)
			f[j][i] = idMin(f[j - 1][i], f[j - 1][i + (1 << j - 1)]);
	
	phi[1] = miu[1] = 1;
	for (int i = 2; i <= n; ++i)
	{
		if (!vis[i])
		{
			pri[++pr] = i;
			phi[i] = i - 1;
			miu[i] = -1;
		}
		for (int j = 1; j <= pr && 1ll * pri[j] * i <= n; ++j)
		{
			int tmp = pri[j] * i;
			vis[tmp] = true;
			if (i % pri[j] == 0)
			{
				miu[tmp] = 0;
				phi[tmp] = phi[i] * pri[j];
				break;
			}
			miu[tmp] = -miu[i];
			phi[tmp] = phi[i] * (pri[j] - 1);
		}
	}
	for (int i = 2; i <= n; ++i)
		if (miu[i] < 0) miu[i] += mod;
	for (int i = 1; i <= n; ++i)
	{	
		int res = 0; vm = 0;
		for (int j = i; j <= n; j += i)
			vir[++vm] = apr[j];
		std::sort(vir + 1, vir + vm + 1, cmp);
		for (int j = 1, jm = vm; j < jm; ++j)
			vir[++vm] = query_LCA(pos[vir[j]], pos[vir[j + 1]]);
		vir[++vm] = 1;
		std::sort(vir + 1, vir + vm + 1, cmp);
		vm = std::unique(vir + 1, vir + vm + 1) - vir - 1;
		for (int j = 1, x; x = vir[j], j <= vm; ++j)
			val[x] = a[x] % i == 0 ? phi[a[x]] : 0;
		
		stk[top = 1] = vir[1];
		for (int j = 2; j <= vm; ++j)
		{
			while (top && !check_Sub(stk[top], vir[j])) --top;
			Rink(stk[top], vir[j]);
			stk[++top] = vir[j];
		} 
		
		ans = 0;
		Dfs2(1);
		for (int j = 1, x; x = vir[j], j <= vm; ++j)
			if (val[x])
			{
				int tmp = sum[1];
				add(tmp, mod - val[x]);
				ans = (2ll * tmp * val[x] % mod * dep[x] + ans) % mod;
			}
		g[i] = ans;	 
		for (int i = 1; i <= vm; ++i)
			sum[vir[i]] = 0, rst[vir[i]] = NULL; Q = q;
	}
	for (int i = 1; i <= n; ++i)
	{
		int tmp = 1ll * i * ksm(phi[i], mod - 2) % mod, res = 0;
		for (int j = i; j <= n; j += i)
			res = (1ll * miu[j / i] * g[j] + res) % mod;
		ans = (1ll * res * tmp + ans) % mod;
	}
	printf("%d\n", 1ll * ans * ksm(1ll * n * (n - 1) % mod, mod - 2) % mod);
}