HDU - 4670 Cube number on a tree 点分治+哈希

题目：给你一棵n个节点的树，再给你K个质数，每个节点都有一个权值，权值都是由这些质数组成，路径的长度定义成路径上的节点的权值的 乘积，问有多少路径满足路径的长度是个立方数。

思路：点分治，用map哈希一下就好了。题目虽然说节点的权值范围内有0，但是数据应该没有0，不然这样做就错了

代码：

#pragma comment(linker, "/STACK:1024000000,1024000000")
#include<iostream>
#include<algorithm>
#include<cstdio>
#include<cmath>
#include<cstring>
#include<string>
#include<vector>
#include<map>
#include<set>
#include<queue>
#include<stack>
#include<list>
#include<numeric>
using namespace std;
#define LL long long
#define ULL unsigned long long
#define INF 0x3f3f3f3f
#define mm(a,b) memset(a,b,sizeof(a))
#define PP puts("*********************");
template<class T> T f_abs(T a){ return a > 0 ? a : -a; }
template<class T> T gcd(T a, T b){ return b ? gcd(b, a%b) : a; }
template<class T> T lcm(T a,T b){return a/gcd(a,b)*b;}
// 0x3f3f3f3f3f3f3f3f
// 0x3f3f3f3f


const int maxn=5e4+50;
struct Node{
    int v,next;
}edge[2*maxn];
int head[maxn],tol;//节点从1开始计数
int son[maxn],f[maxn],vis[maxn];
int dep[maxn][31],siz,d[maxn][31];
int cntv,root,K,ans;
LL prime[31];
int fac[maxn][31],num[31];
map<LL,int> mp;
void init(){
    mm(head,-1);tol=0;
    mm(vis,0);
    f[0]=INF;//一定要初始化成一个很大的值
}
void addedge(int u,int v){
    edge[tol].v=v;
    edge[tol].next=head[u];
    head[u]=tol++;
}
void getroot(int u,int fa){//寻找重心
    son[u]=1,f[u]=0;
    for(int i=head[u];i!=-1;i=edge[i].next){
        int v=edge[i].v;
        if(v==fa||vis[v]) continue;
        getroot(v,u);
        son[u]+=son[v];
        f[u]=max(f[u],son[v]);
    }
    f[u]=max(f[u],cntv-son[u]);//sum表示当前树的大小
    if(f[u]<f[root]) root=u;//更新当前重心
}
void getdepth(int u,int fa){
    for(int j=0;j<K;j++)
        dep[siz][j]=d[u][j];
    siz++;
    for(int i=head[u];i!=-1;i=edge[i].next){
        int v=edge[i].v;
        if(v==fa||vis[v]) continue;
        for(int j=0;j<K;j++)
            d[v][j]=(d[u][j]+fac[v][j])%3;
        getdepth(v,u);
    }
}
LL change(int *arr){
    LL res=0;;
    for(int i=0;i<K;i++)
        res=res*3+arr[i];
    return res;
}
bool judge(int *arr){
    for(int i=0;i<K;i++)
        if(arr[i]!=0)
            return false;
    return true;
}
void solve(int u){//计算以u为重心的树
    vis[u]=1;
    mp.clear();
    for(int i=head[u];i!=-1;i=edge[i].next){
        int v=edge[i].v;
        if(vis[v]) continue;
        for(int j=0;j<K;j++) d[v][j]=fac[v][j];
        siz=0;
        getdepth(v,0);
        for(int j=0;j<siz;j++){
            for(int k=0;k<K;k++)
                num[k]=(dep[j][k]+fac[u][k])%3;
            if(judge(num)) ans++;
            for(int k=0;k<K;k++)
                num[k]=(3-num[k])%3;
            LL x=change(num);
            ans+=mp[x];
        }
        for(int j=0;j<siz;j++){
            LL x=change(dep[j]);
            mp[x]++;
        }
    }
    for(int i=head[u];i!=-1;i=edge[i].next){
        int v=edge[i].v;
        if(vis[v]) continue;
        cntv=son[v];
        root=0;
        getroot(v,0);
        solve(root);
    }
}
int main(){

    int n,u,v;
    LL w;
    while(~scanf("%d",&n)){
        init();
        scanf("%d",&K);
        for(int i=0;i<K;i++)
            scanf("%lld",&prime[i]);
        for(int i=1;i<=n;i++){
            scanf("%lld",&w);
            for(int j=0;j<K;j++){
                fac[i][j]=0;
                while(w%prime[j]==0){
                    fac[i][j]=(fac[i][j]+1)%3;
                    w/=prime[j];
                }
            }
        }
        for(int i=1;i<n;i++){
            scanf("%d%d",&u,&v);
            addedge(u,v);
            addedge(v,u);
        }
        cntv=n;
        root=0;
        getroot(1,0);
        ans=0;
        for(int i=1;i<=n;i++)
            if(judge(fac[i]))
                ans++;
        solve(root);
        printf("%d\n",ans);
    }
    return 0;
}