HDU 6430 Problem E. TeaTree(虚树)

Problem E. TeaTree

Problem Description

Recently, TeaTree acquire new knoledge gcd (Greatest Common Divisor), now she want to test you.
As we know, TeaTree is a tree and her root is node 1, she have n nodes and n-1 edge, for each node i, it has it’s value v[i].
For every two nodes i and j (i is not equal to j), they will tell their Lowest Common Ancestors (LCA) a number : gcd(v[i],v[j]).
For each node, you have to calculate the max number that it heard. some definition:
In graph theory and computer science, the lowest common ancestor (LCA) of two nodes u and v in a tree is the lowest (deepest) node that has both u and v as descendants, where we define each node to be a descendant of itself.

Input

On the first line, there is a positive integer n, which describe the number of nodes.
Next line there are n-1 positive integers f[2] ,f[3], …, f[n], f[i] describe the father of node i on tree.
Next line there are n positive integers v[2] ,v[3], …, v[n], v[i] describe the value of node i.
n<=100000, f[i]<i, v[i]<=100000

Output

Your output should include n lines, for i-th line, output the max number that node i heard.
For the nodes who heard nothing, output -1.

题目链接：http://acm.hdu.edu.cn/showproblem.php?pid=6430

题意：

一棵树上每个节点权值为v[i]，每个节点的heard值是：以它为LCA的两个节点的GCD的最大值，要求输出每个节点的heard值。

树节点个数1e5，权值为最大1e5。

思路：由于权值最大才1e5，开一个1e5的vector，考虑将树节点存入它权值因子的vector（比如权值为9的结点，将他存入v[1],v[3],v[9]里），然后按照每一个vector建立一棵虚树。将这颗虚树上除了叶子的点的答案都更新。但是由于只要更新非叶子节点的值，我就直接在建立虚树边的时候更新了，省去建边和搜索的过程。

 #include<cstdio>
 #include<algorithm>
 #include<cstring>
 #include<vector>
 #include<cmath>
 using namespace std;
 const int maxn = ;

 struct Edge       ///存原树
 {
     int to,next;
 } E[maxn << ];
 int frist[maxn], sign = ;
 inline void AddEdge(int u, int v)
 {
     E[sign].to = v;
     E[sign].next = frist[u];
     frist[u] = sign++;
 }

 /*
 struct void_tree  ///存虚树
 {
     int to,next;
 }vtree[maxn];
 int sign2=0,first2[maxn];
 inline void add_edge(int u, int v)
 {
     vtree[sign2].to = v;
     vtree[sign2].next = first2[u];
     first2[u] = sign2++;
 }
 */
 int dfn[maxn];   ///dfs序
 int deep[maxn];  ///节点深度
 int s[maxn];     ///栈
 int a[maxn];     ///存需要建立虚树的点
 int index=;
 int top;         ///栈顶

 int fa[][maxn];

 void dfs(int u)  ///预处理dep和fa[0][j]
 {
     dfn[u] = ++index;
     for(int i=frist[u];i;i=E[i].next)
     {
         if(E[i].to!=fa[][u])
         {
             deep[E[i].to]=deep[u]+;
             fa[][E[i].to]=u;
             dfs(E[i].to);
         }
     }
 }
 inline int LCA(int u,int v)  ///求LCA
 {
     if(deep[u]>deep[v])swap(u,v);
     for(int i=;~i;i--)
         if(deep[fa[i][v]]>=deep[u])
             v=fa[i][v];
     if(u==v)return u;
     for(int i=;~i;i--)
         if(fa[i][u]!=fa[i][v])
         {
             u=fa[i][u];
             v=fa[i][v];
         }
     return fa[][u];
 }
 int answer[maxn];

 inline void insert_point(int x,int num)  ///建立虚树
 {
     if(top == )
     {
         s[++top] = x;
         return ;
     }
     int lca = LCA(x, s[top]);
     if(lca == s[top])
     {
         s[++top]=x;
         return ;
     }
     while(top >=  && dfn[s[top - ]] >= dfn[lca])
     {
         answer[s[top - ]]=num;  ///不建边了，直接更新答案
         //add_edge(s[top - 1], s[top]);
         top--;
     }
     if(lca != s[top])
     {
         answer[lca]=num;
         //add_edge(lca, s[top]);
         s[top] = lca;
     }
     s[++top] = x;
 }

 inline int comp(const int &a, const int &b)
 {
     return dfn[a] < dfn[b];
 }

 vector<int>mmp[maxn];

 int main()
 {
     int n,x,m;
     memset(answer,-, sizeof(answer));
     memset(frist, -, sizeof(frist));
     scanf("%d",&n);
     for(int i=; i<=n; i++)
     {
         scanf("%d",&x);
         AddEdge(x,i);
     }

     deep[]=fa[][]=;
     dfs();
     for(int i=;i<=;i++)
         for(int j=;j<=n;j++)
             fa[i][j]=fa[i-][fa[i-][j]];

     ///将节点存入它权值因子的vector
     int Max = ;
     for(int i=; i<=n; i++)
     {
         scanf("%d",&x);
         Max = max(Max,x);
         int temp = sqrt(x+);
         for(int j=; j<=temp; j++)
         {
             if(x%j==)
             {
                 mmp[j].push_back(i);
                 if(j!=x/j)
                     mmp[x/j].push_back(i);
             }
         }
     }

     for(int k=; k<=Max; k++)
     {
         m = mmp[k].size();
         if(m<=)continue;
         for(int i = ; i <= m; i++)a[i] = mmp[k][i-];
         sort(a + , a + m + , comp);
         //memset(first2,-1,sizeof(first2));
         top=;
         for(int i = ; i <= m; i++)
             insert_point(a[i],k);
         while(top > )
         {
             answer[s[top - ]]=k;           ///不建边了，直接更新答案
             //add_edge(s[top - 1], s[top]);
             top--;
         }
         //dfs(s[top]);                      ///省去dfs
     }
     for(int i=;i<=n;i++)
         printf("%d\n",answer[i]);
     return ;
 }