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 = 100500;

struct Edge       ///存原树
{
    int to,next;
} E[maxn << 1];
int frist[maxn], sign = 1;
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=0;
int top;         ///栈顶

int fa[18][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[0][u])
        {
            deep[E[i].to]=deep[u]+1;
            fa[0][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=16;~i;i--)
        if(deep[fa[i][v]]>=deep[u])
            v=fa[i][v];
    if(u==v)return u;
    for(int i=16;~i;i--)
        if(fa[i][u]!=fa[i][v])
        {
            u=fa[i][u];
            v=fa[i][v];
        }
    return fa[0][u];
}
int answer[maxn];

inline void insert_point(int x,int num)  ///建立虚树
{
    if(top == 0)
    {
        s[++top] = x;
        return ;
    }
    int lca = LCA(x, s[top]);
    if(lca == s[top])
    {
        s[++top]=x;
        return ;
    }
    while(top >= 1 && dfn[s[top - 1]] >= dfn[lca])
    {
        answer[s[top - 1]]=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,-1, sizeof(answer));
    memset(frist, -1, sizeof(frist));
    scanf("%d",&n);
    for(int i=2; i<=n; i++)
    {
        scanf("%d",&x);
        AddEdge(x,i);
    }

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

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

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