树的直径

直径

vector很喜欢研究树，他觉得求的直径方法很妙。
最近他给带点权的树定义了一种特殊的直径，如果一条链上的点两不互质那么这直径，链就是合法的，特殊直径最长。
他很快的秒了这道题，但是调皮的gg把他的代码删掉了，现在他把这题交给你。

题面描述：
在树上求最长直径，满足直径上的点的权值两两互质。

这道题早上想了另种方法，
第一种：
找到一个根，然后左子树只能往上走，右子树只能往下走，每个节点记录一个vector，记录每个可以最长可以达到的公因数，以及可以达到该公因数的值，这样的时间复杂度是O(n2)，但是时间复杂度也要O（n2），而且代码好像很复杂，于是没有打。

第二种：
先欧拉筛求出2到100000的质数（），因为每个数最多有logn的质数，所以枚举这些质数，并找出来这棵树上 哪些节点可以整除，然后除完了之后找最长的整数链，（这个就是树的最长直径）。

树的最长直径

但是这次题意有错。。第二种方案虽然是正解（原题意的正解（即这条链上所有数的公共gcd不为1）吗，但是本题是所有数两两不互质，比如说……（6,10,15）这组数据是过不了的。）

代码

#include<bits/stdc++.h>
using namespace std;
const int maxn=100005;
int n,l,c[maxn],len,value[maxn],visit[maxn],V[maxn];
bool b[maxn];
map< int, vector<int> > factor;
struct node
{
    node *nxt;
    int where;
} a[maxn<<1],*first[maxn];
inline void makelist(int x,int y)
{
    a[++l].where=y;
    a[l].nxt=first[x];
    first[x]=&a[l];
}
pair<int, int> bfs(int init,int v,int round)
{
    c[1]=init;
    visit[init]=1;
    int pos=0,will=0;
    int k=1,l=1;
    for (;l<=k; l++)
      {
        int m=c[l];
        if (visit[m]>will)
          {
            will=visit[m];
            pos=m;
          }
        for (node *x=first[m]; x; x=x->nxt)
          if (!(value[x->where]%v)&&!visit[x->where])
            {
              visit[x->where]=visit[m]+1;
              c[++k]=x->where;
            }
      }
    if (round==0)
      {
        for (int i=1; i<=k; i++)
          visit[c[i]]=0;
        return make_pair(pos,will);
      }
}
int calc(int v)
{
    vector<int> idx=factor[v];
    int will=0;
    for (int i=0; i<idx.size(); i++)
      if (!visit[idx[i]])
        will=max(will,bfs(bfs(idx[i],v,0).first,v,1).second);
    for (int i=0; i<idx.size(); i++)
      visit[idx[i]]=0;
    return will;
}

int main()
{
    freopen("diameter.in","r",stdin);
    freopen("diameter.out","w",stdout);
    len=0;
    memset(b,false,sizeof(b));
    for (int i=2; i<=100000; i++)
      {
        if (!b[i]) c[++len]=i;
        for (int j=1; j<=len; j++)
          if (c[j]*i>100000) break;
        else 
          {
            b[c[j]*i]=true;
            if (!(i%c[j])) break;
          }
      }
        scanf("%d",&n);
        memset(first,0,sizeof(first));
        l=0;
        for (int i=1; i<n; i++)
          {
            int x,y;
            scanf("%d%d",&x,&y);
            makelist(x, y);
            makelist(y, x);
          }
        factor.clear();
        for (int i=1; i<=n; i++)
          {
            int x;
            scanf("%d",&x);
            value[i]=x;
            for (int j=1; c[j]*c[j]<=x; ++j)
              if (!(x%c[j]))
              {
                if (factor.find(c[j])==factor.end())
                    factor[c[j]].clear();
                factor[c[j]].push_back(i);
                for (;!(x%c[j]);)
                  x/=c[j];
              }
        if (x!=1)
          {
            if (factor.find(x)==factor.end())
            factor[x].clear();
            factor[x].push_back(i);
          }
      }
      memset(visit,0,sizeof(visit));
      memset(V,0,sizeof(V));
      int ans=0;
      for (map< int, vector<int> >::iterator itr=factor.begin(); itr!=factor.end(); itr++)
        ans=max(ans,calc(itr->first));
      printf("%d",ans);

}