牛客挑战赛42 B 树上启发式合并

题目

(https://ac.nowcoder.com/acm/contest/6944/B)

题目描述

小睿睿和小熙熙是很好的朋友，他们的学校有n个教室，教室间有n-1条路径且任意教室互相联通，每个教室给他们带来的愉悦值为val[i]，
每天他们会选择在两个不同的教室(i,j)间的简单路径上秀恩爱，并给在lca(i,j)教室的人带来gcd(val[i],val[j])的伤害。
每个教室里的单身狗们想知道：能给他们带来最大伤害和对应的无序点对数有多少个（对于叶子结点，最大伤害及对应的无序点对个数为0）
无序点对：(i,j)与(j,i)视作同一对，gcd(a,b)：a与b的最大公因数

输入描述:

第1行1个整数n，表示教室个数

第2至n行，每行两个整数a,b，表示a,b间有一条边

第n+1行，共n个整数，表示第i个教室的权值为val[i]

输出描述:

共n行，每行2个整数，分别表示第i个点受到的最大伤害和对应的无序点对数

输入

8
1 2
1 3
1 8
2 4
2 5
3 6
3 7
9 9 9 12 12 12 3 9

输出

12 2
12 1
3 3
0 0
0 0
0 0
0 0
0 0

备注:

树以1号教室为根
对于50%的数据，n≤1000且树的形态随机生成

另有20%的数据，树的形态为一条链

对于100%的数据，n,val[i]≤100000

思路一 启发式合并

我们考虑树上启发式合并，那么对于一个树，我们并不知道，他和存在的数谁的gcd最大。
那么我们把数拆成他所有的因子。这样我们就可以考虑所有的贡献了，因为可能的gcd一个是他的因子。

现在就可以启发式合并了，我刚开始考虑轻重链启发式合并，发现一个问题，子树间每个因子的对数和，必须记录。

而这个是没有办法记录的，后了考虑SET的合并，用一个mp记录了可以。复杂度多个log，可以过了，

后面发现看题解发现

其实只记录当前gcd的最大值和个数就可以了。如果现在的最大gcd为x，对数为y。合并这棵子数得到<a, b>
$a<x$ 因为要先满足gcd最大，所以这个b虽然没有考虑之前的子树贡献，但是这个一定用不到。
$a==x$ 那么y记录了之前的贡献，b记录这看子树新产生的贡献，那么y+=b。就可以了。对数是正确的。
$a>x$ 那么y在之前一定没有在两棵子数出现过，不然最大的gcd不是x。所以y是正确的，用<x, y>替换<a, b>就可以了。

所以记录最大的gcd和对数就可以了。

思路二 线段树合并。

和上面的思路差不多，只是用线段树来替换map。那么在合并的同时，计算贡献。

#pragma GCC optimize(3, "Ofast", "inline")
//#pragma GCC target("avx,avx2,fma")
//#pragma GCC optimization ("unroll-loops")

#include <bits/stdc++.h>
#define rint register int
#define LL long long
#define getchar() (p1==p2&&(p2=(p1=buf)+fread(buf,1,1<<20,stdin),p1==p2)?EOF:*p1++)

using namespace std;

char buf[1<<20],*p1=buf,*p2=buf;
inline LL read() {
    char c=getchar();
    LL x=0,f=1;
    while(c<'0'||c>'9') {
        if(c=='-')
            f=-1;
        c=getchar();
    }
    while(c>='0'&&c<='9') {
        x=x*10+c-'0';
        c=getchar();
    }
    return x*f;
}

inline void print(LL x) {
    if (x < 0) {
        putchar('-');
        x = -x;
    }
    if (x >= 10)
        print(x / 10);
    putchar(x % 10 + '0');
}

struct edge {
    int to, nex;
} e[100010 << 1];
int head[100010], tot;

void add(int x, int y) {
    e[++tot].to = y;
    e[tot].nex = head[x];
    head[x] = tot;
}

int b[100010];
vector<int> v[100010];
pair<int, int> ans[100010];
map<int, LL, greater<int> > mp[100010];
pair<int, LL> sum[100010];

void DFS(int u, int fa) {

    for(auto x: v[b[u]]) {
        mp[u][x]++;
    }

    for(int i = head[u]; i; i = e[i].nex) {
        int to=e[i].to;
        if(to==fa) continue;
        DFS(to, u);
        if(mp[u].size()<mp[to].size()) { //启发式贪心
            swap(mp[u], mp[to]);
        }
        for(auto x: mp[to]) {
            int s1=x.first;
            LL s2=x.second;
            if(mp[u].count(s1)){//计算新贡献
                if(s1==sum[u].first){
                    sum[u].second+=s2*mp[u][s1];
                }
                if(s1>sum[u].first){
                    sum[u]={s1, s2*mp[u][s1]};
                }
                break;
            }
        }

        for(auto x: mp[to]) {//合并子链
            int s1=x.first;
            LL s2=x.second;
            mp[u][s1]+=s2;
        }
    }
}

int main() {
    int n, x, y;
    n=read();

    for(int i=1; i<n; i++) {
        x=read(), y=read();
        add(x, y);
        add(y, x);
    }
    for(int i=1; i<=n; i++) {
        b[i]=read();
    }
    for(int i=1; i<=n; i++) {
        if(v[b[i]].size()==0) {
            int sz=sqrt(b[i]);
            for(int k=1; k<=sz; k++) {
                if(b[i]%k==0) {
                    v[b[i]].push_back(k);
                    if(k*k!=b[i]) {
                        v[b[i]].push_back(b[i]/k);
                    }
                }
            }
        }
    }

    DFS(1, 0);

    for(int i=1; i<=n; i++) {
        print(sum[i].first), printf(" "), print(sum[i].second), printf("\n");
    }

    return 0;
}