COGS——T2084. Asm.Def的基本算法

http://cogs.pro/cogs/problem/problem.php?pid=2084

★☆   输入文件：asm_algo.in   输出文件：asm_algo.out   简单对比
时间限制：1 s   内存限制：256 MB

【题目描述】

“有句美国俗语说，如果走起来像鸭子，叫起来像鸭子，那就是一只鸭子。”斯科特·华莱士看着Asm.Def面前屏幕上滚动的绿色字符，若有所思地说。

“什么意思？”

“你的数据。看上去是一棵树。”

“按照保密条令，我什么也不说这是最好的——但见你这么热情，一句话不说也不好。”Asm.Def停下手中的快速数论变换，“确实是树。”

“然后你怎么算出来目标的位置？”

“都需要按照基本算法，按照图论的那一套理论，去产生。听说过LCA吗？不是那个印度飞机，我是说最近公共祖先……”

Asm.Def通过分析无线电信号得到了一棵有n个节点，以1为根的树。除1之外，节点i的父亲是p_i。节点带有权值，节点i的权值是w_i。

我们定义某点的祖先为从根到它路径上的所有点（包括它本身），而两个节点a、b的最近公共祖先是某个点p，使得p同时是a、b的祖先，而且p离根最远。

Asm.Def想要求出

（文字：∑∑w_i*w_j*w_LCA(i,j)），

其中LCA(i,j)是i、j的最近公共祖先，他认为这个值至关重要。由于这个值可能很大，Asm.Def只需要知道它模1,000,000,007（即10^9+7）的结果。

【输入格式】

第1行两个整数：n和w_1.

第2行到第n行，第i行有两个整数p_i和w_i。

【输出格式】

一行一个整数，即答案模1,000,000,007的值。

【样例输入】

2 2
1 1

【样例输出】

17

【提示】

1×1×1+1×2×2+2×1×2+2×2×2=17。

对于30%的数据，n<=100，w_i<=10。

对于60%的数据，n<=1000，w_i<=1000.

对于100%的数据，1<=n<=10^5，0<=w_i<=10^9，1<=p_i<i.

裸LCA只能拿60分后面就超时了

 #include <algorithm>
 #include <cstdio>

 #define mod 1000000007

 using namespace std;

 const int N(1e6+);
 int n,x,ans,w[N],a[N];

 int sumedge,head[N];
 struct Edge
 {
     int from,to,next;
     Edge(int from=,int to=,int next=):from(from),to(to),next(next){}
 }edge[N];
 void ins(int from,int to)
 {
     edge[++sumedge]=Edge(from,to,head[from]);
     head[from]=sumedge;
 }

 int deep[N],size[N],dad[N],top[N];
 void DFS(int x)
 {
     deep[x]=deep[dad[x]]+;size[x]=;
     for(int i=head[x];i;i=edge[i].next)
     {
         int to=edge[i].to;
         if(dad[x]!=to)
             dad[to]=x,DFS(to),size[x]+=size[to];
     }
 }
 void DFS_(int x)
 {
     int t=;if(!top[x]) top[x]=x;
     for(int i=head[x];i;i=edge[i].next)
     {
         int to=edge[i].to;
         if(dad[x]!=to&&size[t]<size[to]) t=to;
     }
     if(t) top[t]=top[x],DFS_(t);
     for(int i=head[x];i;i=edge[i].next)
     {
         int to=edge[i].to;
         if(dad[x]!=to&&t!=to) DFS_(to);
     }
 }

 int LCA(int x,int y)
 {
     for(;top[x]!=top[y];x=dad[top[x]])
         if(deep[top[x]]<deep[top[y]]) swap(x,y);
     return deep[x]>deep[y]?y:x;
 }

 int main()
 {
     freopen("asm_algo.in","r",stdin);
     freopen("asm_algo.out","w",stdout);
     scanf("%d%d",&n,&w[]);
     for(int i=;i<=n;i++)
         scanf("%d%d",&x,w+i),ins(i,x),ins(x,i);
     DFS(); DFS_();
     for(int i=;i<=n;i++)
       for(int j=;j<=n;j++)
         ans=(ans%mod+(w[i]*w[j]*w[LCA(i,j)])%mod)%mod;
     printf("%d",ans);
     return ;
 }

AAAAAATTTT

 #include <algorithm>
 #include <cstdio>

 #define mod 1000000007
 #define LL long long

 using namespace std;

 const LL N(1e5+);
 LL n,x,w[N];

 LL sumedge,head[N];
 struct Edge
 {
     LL from,to,next;
     Edge(LL from=,LL to=,LL next=):from(from),to(to),next(next){}
 }edge[N];
 void ins(LL from,LL to)
 {
     edge[++sumedge]=Edge(from,to,head[from]);
     head[from]=sumedge;
 }

 LL sum[N],dad[N],ans;
 void DFS(LL x)
 {
     sum[x]=w[x];
     for(LL i=head[x];i;i=edge[i].next)
     {
         LL to=edge[i].to;
         if(!dad[to])
         {
             dad[to]=x; DFS(to);
             ans=(ans%mod+sum[x]%mod*sum[to]%mod*w[x]%mod)%mod;
             sum[x]=(sum[x]%mod+sum[to]%mod)%mod;
         }
     }
 }

 int main()
 {
     freopen("asm_algo.in","r",stdin);
     freopen("asm_algo.out","w",stdout);
     scanf("%lld%lld",&n,&w[]);
     for(LL i=;i<=n;i++)
         scanf("%lld%lld",&x,w+i), ins(x,i);
     DFS(); ans=ans%mod*%mod;
     for(LL i=;i<=n;i++)
         ans=(ans%mod+w[i]%mod*w[i]%mod*w[i]%mod)%mod;
     printf("%lld",ans%mod);
     return ;
 }

AAAAAAAAAA